Chameleon

Chameleon Svn Source Tree

Root/branches/cparm/i386/modules/GUI/gui.c

1/*␊
2 * gui.c␊
3 * ␊
4 *␊
5 * Created by Jasmin Fazlic on 18.12.08.␊
6 * Copyright 2008/09 Jasmin Fazlic All rights reserved.␊
7 * Copyright 2008/09 iNDi All rights reserved.␊
8 *␊
9 */␊
10␊
11/*␊
12 * cparm : cleaned␊
13 */␊
14␊
15/*␊
16 * cparm : add volume version detection␊
17 */␊
18#include "platform.h"␊
19#include "gui.h"␊
20#include "GUI_appleboot.h"␊
21#include "vers.h"␊
22#include "modules.h"␊
23#include "sl.h"␊
24␊
25#ifndef DEBUG_GUI␊
26#define DEBUG_GUI 0␊
27#endif␊
28␊
29#if DEBUG_GUI==2␊
30#define DBG(x...)␉printf(x);sleep(2)␊
31#elif DEBUG_GUI==1␊
32#define DBG(x...)␉printf(x)␊
33#else␊
34#define DBG(x...)␊
35#endif␊
36␊
37enum {␊
38␉kBackspaceKey␉= 0x08,␊
39␉kTabKey␉␉␉= 0x09,␊
40␉kReturnKey␉␉= 0x0d,␊
41␉kEscapeKey␉␉= 0x1b,␊
42␉kUpArrowkey␉␉= 0x4800, ␊
43␉kDownArrowkey␉= 0x5000,␊
44␉kASCIIKeyMask␉= 0x7f,␊
45␉kF5Key␉␉␉= 0x3f00,␊
46␉kF10Key␉␉␉= 0x4400␊
47};␊
48␊
49static config_file_t themeConfig;␉␉␉␉ // theme.plist␊
50␊
51themeList_t* themeList = NULL;␊
52␊
53static void (*showHelp)(void) = NULL;␊
54static char *(*getMemoryInfoString)(void) = NULL;␊
55␊
56␊
57gui_t gui;␉␉␉␉␉// gui structure␊
58font_t font_small;␊
59font_t font_console;␊
60␊
61␊
62#define IMG_REQUIRED -1␊
63#define THEME_NAME_DEFAULT␉"Default"␊
64const char* theme_name = THEME_NAME_DEFAULT;␊
65␊
66char dirsrc[22];␊
67␊
68#ifdef EMBED_THEME␊
69#include "art.h"␊
70#endif␊
71␊
72struct putc_info {␊
73 char * str;␊
74 char * last_str;␊
75};␊
76␊
77static int loadThemeImage(char *src, const char *image, int alt_image);␊
78static void loadBootGraphics(char *src);␊
79static void drawInfoMenuItems();␊
80static void drawProgressBar(pixmap_t *blendInto, uint16_t width, position_t p, uint8_t progress);␊
81static void animateProgressBar();␊
82static void makeRoundedCorners(pixmap_t *p);␊
83static void colorFont(font_t *font, uint32_t color);␊
84static int initFont(font_t *font, image_t *data);␊
85static void drawStrCenteredAt(char *text, font_t *font, pixmap_t *blendInto, position_t p);␊
86static position_t drawChar(unsigned char ch, font_t *font, pixmap_t *blendInto, position_t p);␊
87static void drawStr(char *ch, font_t *font, pixmap_t *blendInto, position_t p);␊
88#if DEBUG_GUI␊
89static int dprintf( window_t * window, const char * fmt, ...);␊
90#endif␊
91static void sputc(int c, struct putc_info * pi);␊
92␊
93static inline␊
94void vramwrite (void *data, int width);␊
95␊
96static void drawDeviceIcon(BVRef device, pixmap_t *buffer, position_t p, bool isSelected);␊
97static int startGUI(void);␊
98static void free_theme_list();␊
99static void add_theme(const char* theme, uint8_t nb);␊
100static int randomTheme(char *dirspec, const char **theme);␊
101static void loadThemeValues(config_file_t *theme);␊
102static void setupDeviceList(config_file_t *theme);␊
103static void fillPixmapWithColor(pixmap_t *pm, uint32_t color);␊
104static int freeWindowBuffer( window_t *window );␊
105static int createWindowBuffer( window_t *window );␊
106static int createBackBuffer( window_t *window );␊
107static int loadGraphics(char *src);␊
108#ifdef EMBED_THEME␊
109static int getEmbeddedImageIndexByName(const char *name);␊
110#endif␊
111static int getImageIndexByName(const char *name);␊
112␊
113static int destroyFont(font_t *font);␊
114static int unloadGraphics(void);␊
115static int freeBackBuffer( window_t *window );␊
116static bool is_image_loaded(int i);␊
117␊
118#define LOADPNG(src, img, alt_img) if (loadThemeImage(src, #img, alt_img) != 0) { return 1; }␊
119␊
120#ifndef MIN␊
121#define MIN(x, y) ((x) < (y) ? (x) : (y))␊
122#endif␊
123␊
124#ifndef MAX␊
125#define MAX(x, y) ((x) > (y) ? (x) : (y))␊
126#endif␊
127␊
128#define VIDEO(x) (((boot_args_common*)getBootArgs())->Video.v_ ## x)␊
129␊
130#define vram VIDEO(baseAddr)␊
131␊
132#define TAB_PIXELS_WIDTH (font->chars[0]->width * 4) // tab = 4 spaces␊
133␊
134int lasttime = 0; // we need this for animating maybe␊
135␊
136/*␊
137 * ATTENTION: the enum and the following array images[] MUST match !!!␊
138 */␊
139enum {␊
140 iBackground = 0,␊
141 iLogo,␊
142␉␊
143 iDeviceGeneric,␊
144 iDeviceGeneric_o,␊
145 iDeviceHFS,␊
146 iDeviceHFS_o,␊
147 iDeviceHFS_ML,␊
148 iDeviceHFS_ML_o,␊
149␉iDeviceHFS_Lion,␊
150 iDeviceHFS_Lion_o,␊
151␉iDeviceHFS_SL,␊
152 iDeviceHFS_SL_o,␊
153␉iDeviceHFS_Leo,␊
154 iDeviceHFS_Leo_o,␊
155␉iDeviceHFS_Tiger,␊
156 iDeviceHFS_Tiger_o,␊
157 iDeviceHFSRAID,␊
158 iDeviceHFSRAID_o,␊
159 iDeviceHFSRAID_ML,␊
160 iDeviceHFSRAID_ML_o,␊
161␉iDeviceHFSRAID_Lion,␊
162 iDeviceHFSRAID_Lion_o,␊
163␉iDeviceHFSRAID_SL,␊
164 iDeviceHFSRAID_SL_o,␊
165␉iDeviceHFSRAID_Leo,␊
166 iDeviceHFSRAID_Leo_o,␊
167␉iDeviceHFSRAID_Tiger,␊
168 iDeviceHFSRAID_Tiger_o,␊
169 iDeviceEXT3,␊
170 iDeviceEXT3_o,␉␊
171␉iDeviceFreeBSD,␊
172 iDeviceFreeBSD_o,␊
173 iDeviceOpenBSD,␊
174 iDeviceOpenBSD_o,␊
175␉iDeviceBEFS, /* Haiku detection and Icon credits to scorpius */␊
176␉iDeviceBEFS_o, /* Haiku detection and Icon credits to scorpius */␊
177 iDeviceFAT,␊
178 iDeviceFAT_o,␊
179 iDeviceFAT16,␊
180 iDeviceFAT16_o,␊
181 iDeviceFAT32,␊
182 iDeviceFAT32_o,␊
183 iDeviceNTFS,␊
184 iDeviceNTFS_o,␊
185 iDeviceCDROM,␊
186 iDeviceCDROM_o,␊
187␉␊
188 iSelection,␊
189 iDeviceScrollPrev,␊
190 iDeviceScrollNext,␊
191␉␊
192 iMenuBoot,␊
193 iMenuVerbose,␊
194 iMenuIgnoreCaches,␊
195 iMenuSingleUser,␊
196 iMenuMemoryInfo,␊
197 iMenuVideoInfo,␊
198 iMenuHelp,␊
199 iMenuVerboseDisabled,␊
200 iMenuIgnoreCachesDisabled,␊
201 iMenuSingleUserDisabled,␊
202 iMenuSelection,␊
203␉␊
204 iProgressBar,␊
205 iProgressBarBackground,␊
206␉␊
207 iTextScrollPrev,␊
208 iTextScrollNext,␊
209␉␊
210 iFontConsole,␊
211 iFontSmall,␊
212};␊
213␊
214image_t images[] = {␊
215 {.name = "background", .image = NULL},␊
216 {.name = "logo", .image = NULL},␊
217 ␊
218 {.name = "device_generic", .image = NULL},␊
219 {.name = "device_generic_o", .image = NULL},␊
220 ␊
221␉{.name = "device_hfsplus", .image = NULL},␊
222 {.name = "device_hfsplus_o", .image = NULL},␊
223␉{.name = "device_hfsplus_ml", .image = NULL},␊
224 {.name = "device_hfsplus_ml_o", .image = NULL},␊
225␉{.name = "device_hfsplus_lion", .image = NULL},␊
226 {.name = "device_hfsplus_lion_o", .image = NULL},␊
227␉{.name = "device_hfsplus_sl", .image = NULL},␊
228 {.name = "device_hfsplus_sl_o", .image = NULL},␊
229␉{.name = "device_hfsplus_leo", .image = NULL},␊
230 {.name = "device_hfsplus_leo_o", .image = NULL},␊
231␉{.name = "device_hfsplus_tiger", .image = NULL},␊
232 {.name = "device_hfsplus_tiger_o", .image = NULL},␊
233␉␊
234 {.name = "device_hfsraid", .image = NULL},␊
235 {.name = "device_hfsraid_o", .image = NULL},␊
236 {.name = "device_hfsraid_ml", .image = NULL},␊
237 {.name = "device_hfsraid_ml_o", .image = NULL},␊
238␉{.name = "device_hfsraid_lion", .image = NULL},␊
239 {.name = "device_hfsraid_lion_o", .image = NULL},␊
240␉{.name = "device_hfsraid_sl", .image = NULL},␊
241 {.name = "device_hfsraid_sl_o", .image = NULL},␊
242␉{.name = "device_hfsraid_leo", .image = NULL},␊
243 {.name = "device_hfsraid_leo_o", .image = NULL},␊
244␉{.name = "device_hfsraid_tiger", .image = NULL},␊
245 {.name = "device_hfsraid_tiger_o", .image = NULL},␊
246␉␊
247 {.name = "device_ext3", .image = NULL},␊
248 {.name = "device_ext3_o", .image = NULL},␊
249␉{.name = "device_freebsd", .image = NULL},␊
250 {.name = "device_freebsd_o", .image = NULL},␊
251 {.name = "device_openbsd", .image = NULL},␊
252 {.name = "device_openbsd_o", .image = NULL},␊
253␉{.name = "device_befs", .image = NULL}, /* Haiku detection and Icon credits to scorpius */␊
254␉{.name = "device_befs_o", .image = NULL}, /* Haiku detection and Icon credits to scorpius */␊
255 {.name = "device_fat", .image = NULL},␊
256 {.name = "device_fat_o", .image = NULL},␊
257 {.name = "device_fat16", .image = NULL},␊
258 {.name = "device_fat16_o", .image = NULL},␊
259 {.name = "device_fat32", .image = NULL},␊
260 {.name = "device_fat32_o", .image = NULL},␊
261 {.name = "device_ntfs", .image = NULL},␊
262 {.name = "device_ntfs_o", .image = NULL},␊
263 {.name = "device_cdrom", .image = NULL},␊
264 {.name = "device_cdrom_o", .image = NULL},␊
265␉␊
266 {.name = "device_selection", .image = NULL},␊
267 {.name = "device_scroll_prev", .image = NULL},␊
268 {.name = "device_scroll_next", .image = NULL},␊
269 ␊
270 {.name = "menu_boot", .image = NULL},␊
271 {.name = "menu_verbose", .image = NULL},␊
272 {.name = "menu_ignore_caches", .image = NULL},␊
273 {.name = "menu_single_user", .image = NULL},␊
274 {.name = "menu_memory_info", .image = NULL},␊
275 {.name = "menu_video_info", .image = NULL},␊
276 {.name = "menu_help", .image = NULL},␊
277 {.name = "menu_verbose_disabled", .image = NULL},␊
278 {.name = "menu_ignore_caches_disabled", .image = NULL},␊
279 {.name = "menu_single_user_disabled", .image = NULL},␊
280 {.name = "menu_selection", .image = NULL},␊
281 ␊
282 {.name = "progress_bar", .image = NULL},␊
283 {.name = "progress_bar_background", .image = NULL},␊
284 ␊
285 {.name = "text_scroll_prev", .image = NULL},␊
286 {.name = "text_scroll_next", .image = NULL},␊
287 ␊
288 {.name = "font_console", .image = NULL},␊
289 {.name = "font_small", .image = NULL},␊
290};␊
291␊
292//int imageCnt = 0;␊
293␊
294char prompt[BOOT_STRING_LEN];␊
295␊
296int prompt_pos=0;␊
297␊
298char prompt_text[] = "boot: ";␊
299␊
300menuitem_t infoMenuItems[] =␊
301{␊
302␉{ .text = "Boot" },␊
303␉{ .text = "Boot Verbose" },␊
304␉{ .text = "Boot Ignore Caches" },␊
305␉{ .text = "Boot Single User" },␊
306␉{ .text = "Memory Info" },␊
307␉{ .text = "Video Info" },␊
308␉{ .text = "Help" }␊
309};␊
310␊
311int infoMenuSelection = 0;␊
312int infoMenuItemsCount = sizeof(infoMenuItems)/sizeof(infoMenuItems[0]);␊
313␊
314bool infoMenuNativeBoot = false;␊
315␊
316unsigned long screen_params[4] = {DEFAULT_SCREEN_WIDTH, DEFAULT_SCREEN_HEIGHT, 32, 0};␉// here we store the used screen resolution␊
317␊
318static void moveCursor( int col, int row )␊
319{␊
320 setCursorPosition( col, row, 0 );␊
321}␊
322␊
323/*␊
324 *␊
325 */␊
326␊
327bool getDimensionForKey( const char *key, unsigned int *value, config_file_t *config, unsigned int dimension_max, unsigned int object_size )␊
328{␊
329␉const char *val;␊
330␉␊
331 int size = 0;␊
332␉int sum = 0;␊
333 ␊
334␉bool negative = false;␊
335␉bool percentage = false;␊
336 ␊
337 config = resolveConfig(config);␊
338␉␊
339 if (getValueForKey(key, &val, &size, config))␊
340␉{␊
341␉␉if ( size )␊
342␉␉{␊
343␉␉␉if (*val == '-')␊
344␉␉␉{␊
345␉␉␉␉negative = true;␊
346␉␉␉␉val++;␊
347␉␉␉␉size--;␊
348␉␉␉}␊
349␉␉␉␊
350␉␉␉if (val[size-1] == '%')␊
351␉␉␉{␊
352␉␉␉␉percentage = true;␊
353␉␉␉␉size--;␊
354␉␉␉}␊
355␉␉␉␊
356␉␉␉// convert string to integer␊
357␉␉␉for (sum = 0; size > 0; size--)␊
358␉␉␉{␊
359␉␉␉␉if (*val < '0' || *val > '9')␊
360␉␉␉␉␉return false;␊
361␉␉␉␉␊
362␉␉␉␉sum = (sum * 10) + (*val++ - '0');␊
363␉␉␉}␊
364␉␉␉␊
365␉␉␉if (percentage)␊
366␉␉␉␉sum = ( dimension_max * sum ) / 100;␊
367␉␉␉␊
368␉␉␉// calculate offset from opposite origin␊
369␉␉␉if (negative)␊
370␉␉␉␉sum = ( ( dimension_max - object_size ) - sum );␊
371␉␉␉␊
372␉␉} else {␊
373␉␉␉␊
374␉␉␉// null value calculate center␊
375␉␉␉sum = ( dimension_max - object_size ) / 2;␊
376␉␉␉␊
377␉␉}␊
378␉␉␊
379␉␉*value = (uint16_t) sum;␊
380␉␉return true;␊
381␉}␊
382␉␊
383␉// key not found␊
384 return false;␊
385}␊
386␊
387static bool getColorForKey( const char *key, unsigned int *value, config_file_t *config )␊
388{␊
389 const char *val;␊
390 int size;␊
391 ␊
392 config = resolveConfig(config);␊
393 ␊
394 if (getValueForKey(key, &val, &size, config))␊
395␉{␊
396␉␉if (*val == '#')␊
397␉␉{␊
398 val++;␊
399␉␉␉*value = strtol(val, NULL, 16);␊
400␉␉␉return true;␊
401 }␊
402 }␊
403 return false;␊
404}␊
405//==========================================================================␊
406␊
407/* Flush keyboard buffer; returns TRUE if any of the flushed␊
408 * characters was F8.␊
409 */␊
410␊
411static bool flushKeyboardBuffer(void)␊
412{␊
413 bool status = false;␊
414␉␊
415 while ( readKeyboardStatus() ) {␊
416 if (bgetc() == 0x4200) status = true;␊
417 }␊
418 return status;␊
419}␊
420␊
421static int getImageIndexByName(const char *name)␊
422{␊
423 int i;␊
424␉for (i = 0; (unsigned)i < sizeof(images) / sizeof(images[0]); i++)␊
425␉{␊
426␉ if (strcmp(name, images[i].name) == 0)␊
427␉ return i; // found the name␊
428␉}␊
429␉return -1;␊
430}␊
431␊
432#ifdef EMBED_THEME␊
433static int getEmbeddedImageIndexByName(const char *name)␊
434{␊
435␉int upperLimit = sizeof(embeddedImages) / sizeof(embeddedImages[0]) - 1;␊
436␉int lowerLimit = 0;␊
437␉int compareIndex = (upperLimit - lowerLimit) >> 1; // Midpoint␊
438␉int result;␊
439␉␊
440␉// NOTE: This algorithm assumes that the embeddedImages is sorted.␊
441␉// This is currently done using the make file. If the array is every ␊
442␉// manualy generated, this *will* fail to work properly.␊
443␉while((result = strcmp(name, embeddedImages[compareIndex].name)) != 0)␊
444␉{␊
445␉␉if(result > 0)␉// We need to search a HIGHER index␊
446␉␉{␊
447␉␉␉if(compareIndex != lowerLimit)␊
448␉␉␉{␊
449␉␉␉␉lowerLimit = compareIndex;␊
450␉␉␉}␊
451␉␉␉else␊
452␉␉␉{␊
453␉␉␉␉return -1;␊
454␉␉␉}␊
455␉␉␉compareIndex = (upperLimit + lowerLimit + 1) >> 1;␉// Midpoint, round up␊
456␉␉}␊
457␉␉else // We Need to search a LOWER index␊
458␉␉{␊
459␉␉␉if(compareIndex != upperLimit)␊
460␉␉␉{␊
461␉␉␉␉upperLimit = compareIndex;␊
462␉␉␉}␊
463␉␉␉else␊
464␉␉␉{␊
465␉␉␉␉return -1;␊
466␉␉␉}␊
467␉␉␉compareIndex = (upperLimit + lowerLimit) >> 1;␉// Midpoint, round down␊
468␉␉}␊
469␉}␊
470␉return compareIndex;␊
471}␊
472#endif␊
473␊
474static int loadThemeImage(char* src, const char *image, int alt_image)␊
475{␊
476␉char␉␉dirspec[256];␊
477␉int ␉␉i;␊
478#ifdef EMBED_THEME␊
479␉int ␉␉e;␊
480#endif␊
481␉uint16_t␉width;␊
482␉uint16_t␉height;␊
483␉uint8_t␉␉*imagedata;␊
484␉if ((unsigned)(strlen(image) + strlen(theme_name) + strlen(src) + (6+1) ) > sizeof(dirspec)) {␊
485␉␉␊
486␉␉DBG("Path of %s/%s/%s.png to long\n", src, theme_name, image);␊
487␉␉␊
488␉␉return 1;␊
489␉}␊
490␉␊
491 if ((i = getImageIndexByName(image)) >= 0)␊
492 { ␊
493␉␉if (images[i].image == NULL) {␊
494␉␉␉images[i].image = malloc(sizeof(pixmap_t));␊
495␉␉␉if (images[i].image == NULL) {␊
496␉␉␉␉␊
497␉␉␉␉DBG("Unable to allocate memory for %s.png\n", image);␊
498␉␉␉␉␊
499␉␉␉␉return 1;␊
500␉␉␉}␊
501␉␉}␊
502 sprintf(dirspec, "%s/%s/%s.png", src, theme_name, image);␊
503␉␉␊
504 width = 0;␊
505 height = 0;␊
506 imagedata = NULL;␊
507 if ( strlen(theme_name) > 0 && (loadPngImage(dirspec, &width, &height, &imagedata)) == 0)␊
508 {␊
509 images[i].image->width = width;␊
510 images[i].image->height = height;␊
511 images[i].image->pixels = (pixel_t *)imagedata;␊
512 flipRB(images[i].image);␊
513␉␉␉␊
514␉␉␉DBG("[ %s ] succesfully loaded and registred !!\n", dirspec);␊
515␉␉␉␊
516 return 0;␊
517 }␊
518#ifdef EMBED_THEME␊
519 else if ((e = getEmbeddedImageIndexByName(image)) >= 0)␊
520 {␊
521 unsigned char *embed_data;␊
522 unsigned int embed_size;␊
523 embed_data = embeddedImages[e].pngdata;␊
524 embed_size = *embeddedImages[e].length;␊
525␉␉␉␊
526 if (loadEmbeddedPngImage(embed_data, embed_size, &width, &height, &imagedata) == 0)␊
527 {␊
528 images[i].image->width = width;␊
529 images[i].image->height = height;␊
530 images[i].image->pixels = (pixel_t *)imagedata;␊
531 flipRB(images[i].image);␊
532 return 0;␊
533 }␊
534␉␉␉␊
535 return 0;␊
536 }␊
537#endif␊
538 else if (alt_image != IMG_REQUIRED)␊
539 {␊
540␉␉␉if (images[alt_image].image->pixels != NULL) {␊
541␉␉␉␉␊
542␉␉␉␉// Using the passed alternate image for non-mandatory images.␊
543␉␉␉␉// We don't clone the already existing pixmap, but using its properties instead!␊
544␉␉␉␉images[i].image->width = images[alt_image].image->width;␊
545␉␉␉␉images[i].image->height = images[alt_image].image->height;␊
546␉␉␉␉images[i].image->pixels = images[alt_image].image->pixels;␊
547␉␉␉␉␊
548␉␉␉} else {␊
549␉␉␉␉␊
550␉␉␉␉DBG("Unable to load %s, this image not vital anyway, reseting and returning success !!\n", dirspec);␊
551␉␉␉␉␊
552␉␉␉␉free(images[i].image);␊
553␉␉␉␉images[i].image = NULL;␊
554␉␉␉} ␊
555␉␉␉␊
556 return 0;␊
557 }␊
558 else␊
559 {␊
560#if DEBUG_GUI␊
561 printf("ERROR: GUI: could not open '%s/%s.png'!\n", theme_name, image);␊
562␉␉␉sleep(2);␊
563#else␊
564#ifndef CONFIG_EMBED_THEME␊
565 printf("ERROR: GUI: could not open '%s/%s.png'!\n", theme_name, image);␊
566␉␉␉sleep(2);␊
567#endif␊
568#endif␊
569␉␉␉free(images[i].image);␊
570␉␉␉images[i].image = NULL;␊
571␉␉␉return 1;␊
572␉␉␉␊
573 }␊
574␉␉␊
575 }␊
576␉␊
577#if DEBUG_GUI␊
578␉printf("[ %s/%s/%s.png ] not used in this version, skipped !!\n",src, theme_name, image);␊
579␉sleep(2);␊
580#endif␊
581␉return 1;␊
582}␊
583␊
584static int loadGraphics(char *src)␊
585{␊
586␉DBG("Loading image into memory....\n",theme_name);␊
587␉␊
588␉LOADPNG(src, background, IMG_REQUIRED);␊
589␉␊
590␉LOADPNG(src, logo, IMG_REQUIRED);␊
591␉␊
592␉LOADPNG(src, device_generic, IMG_REQUIRED);␊
593␉LOADPNG(src, device_generic_o, iDeviceGeneric);␊
594␉␊
595␉LOADPNG(src, device_hfsplus, iDeviceGeneric);␊
596␉LOADPNG(src, device_hfsplus_o, iDeviceHFS);␊
597 LOADPNG(src, device_hfsplus_ml, iDeviceHFS_ML);␊
598 LOADPNG(src, device_hfsplus_ml_o, iDeviceHFS_ML_o);␊
599␉LOADPNG(src, device_hfsplus_lion, iDeviceHFS_Lion);␊
600␉LOADPNG(src, device_hfsplus_lion_o, iDeviceHFS_Lion_o);␊
601␉LOADPNG(src, device_hfsplus_sl, iDeviceHFS_SL);␊
602␉LOADPNG(src, device_hfsplus_sl_o, iDeviceHFS_SL_o);␊
603␉LOADPNG(src, device_hfsplus_leo, iDeviceHFS_Leo);␊
604␉LOADPNG(src, device_hfsplus_leo_o, iDeviceHFS_Leo_o);␊
605␉LOADPNG(src, device_hfsplus_tiger, iDeviceHFS_Tiger);␊
606␉LOADPNG(src, device_hfsplus_tiger_o, iDeviceHFS_Tiger_o);␊
607␉␊
608␉LOADPNG(src, device_hfsraid, iDeviceGeneric);␊
609␉LOADPNG(src, device_hfsraid_o, iDeviceHFSRAID);␊
610 LOADPNG(src, device_hfsraid_ml, iDeviceHFSRAID_ML);␊
611 LOADPNG(src, device_hfsraid_ml_o, iDeviceHFSRAID_ML_o);␊
612␉LOADPNG(src, device_hfsraid_lion, iDeviceHFSRAID_Lion);␊
613␉LOADPNG(src, device_hfsraid_lion_o, iDeviceHFSRAID_Lion_o);␊
614␉LOADPNG(src, device_hfsraid_sl, iDeviceHFSRAID_SL);␊
615␉LOADPNG(src, device_hfsraid_sl_o, iDeviceHFSRAID_SL_o);␊
616␉LOADPNG(src, device_hfsraid_leo, iDeviceHFSRAID_Leo);␊
617␉LOADPNG(src, device_hfsraid_leo_o, iDeviceHFSRAID_Leo_o);␊
618␉LOADPNG(src, device_hfsraid_tiger, iDeviceHFSRAID_Tiger);␊
619␉LOADPNG(src, device_hfsraid_tiger_o, iDeviceHFSRAID_Tiger_o);␊
620␉␊
621␉LOADPNG(src, device_ext3, iDeviceGeneric);␊
622␉LOADPNG(src, device_ext3_o, iDeviceEXT3);␊
623␉LOADPNG(src, device_freebsd, iDeviceGeneric);␊
624␉LOADPNG(src, device_freebsd_o, iDeviceFreeBSD);␊
625␉LOADPNG(src, device_openbsd, iDeviceGeneric);␊
626␉LOADPNG(src, device_openbsd_o, iDeviceOpenBSD);␊
627␉LOADPNG(src, device_befs,␉␉␉␉␉ iDeviceGeneric); /* Haiku detection and Icon credits to scorpius */␊
628␉LOADPNG(src, device_befs_o,␉␉␉␉␉ iDeviceBEFS); /* Haiku detection and Icon credits to scorpius */␊
629␉LOADPNG(src, device_fat, iDeviceGeneric);␊
630␉LOADPNG(src, device_fat_o, iDeviceFAT);␊
631␉LOADPNG(src, device_fat16, iDeviceFAT);␊
632␉LOADPNG(src, device_fat16_o, iDeviceFAT_o);␊
633␉LOADPNG(src, device_fat32, iDeviceFAT);␊
634␉LOADPNG(src, device_fat32_o, iDeviceFAT_o);␊
635␉LOADPNG(src, device_ntfs, iDeviceGeneric);␊
636␉LOADPNG(src, device_ntfs_o, iDeviceNTFS);␊
637␉LOADPNG(src, device_cdrom, iDeviceGeneric);␊
638␉LOADPNG(src, device_cdrom_o, iDeviceCDROM);␊
639␉␊
640␉LOADPNG(src, device_selection, IMG_REQUIRED);␊
641␉LOADPNG(src, device_scroll_prev, IMG_REQUIRED);␊
642␉LOADPNG(src, device_scroll_next, IMG_REQUIRED);␊
643␉␊
644␉LOADPNG(src, menu_boot, IMG_REQUIRED);␊
645␉LOADPNG(src, menu_verbose, IMG_REQUIRED);␊
646␉LOADPNG(src, menu_ignore_caches, IMG_REQUIRED);␊
647␉LOADPNG(src, menu_single_user, IMG_REQUIRED);␊
648␉LOADPNG(src, menu_memory_info, IMG_REQUIRED);␊
649␉LOADPNG(src, menu_video_info, IMG_REQUIRED);␊
650␉LOADPNG(src, menu_help, IMG_REQUIRED);␊
651␉LOADPNG(src, menu_verbose_disabled, IMG_REQUIRED);␊
652␉LOADPNG(src, menu_ignore_caches_disabled, IMG_REQUIRED);␊
653␉LOADPNG(src, menu_single_user_disabled, IMG_REQUIRED);␊
654␉LOADPNG(src, menu_selection, IMG_REQUIRED);␊
655␉␊
656␉LOADPNG(src, progress_bar, IMG_REQUIRED);␊
657␉LOADPNG(src, progress_bar_background, IMG_REQUIRED);␊
658␉␊
659␉LOADPNG(src, text_scroll_prev, IMG_REQUIRED);␊
660␉LOADPNG(src, text_scroll_next, IMG_REQUIRED);␊
661␉␊
662␉LOADPNG(src, font_console, IMG_REQUIRED);␊
663␉LOADPNG(src, font_small, IMG_REQUIRED);␊
664␉␊
665␉DBG("Initializing font....\n",theme_name);␊
666␉␊
667␉initFont( &font_console, &images[iFontConsole]);␊
668␉initFont( &font_small, &images[iFontSmall]);␊
669␉␊
670␉DBG("Graphic objects successfully loaded !!\n",theme_name);␊
671␉␊
672␉return 0;␊
673}␊
674␊
675static int unloadGraphics(void)␊
676{␊
677 int i;␊
678␉␊
679 destroyFont(&font_console);␊
680 destroyFont(&font_small);␊
681␉for (i = 0; i < sizeof(images) / sizeof(images[0]); i++)␊
682␉{␊
683␉ if (images[i].image)␊
684␉ {␊
685␉ ␉if (images[i].image->pixels) free(images[i].image->pixels);␊
686␉ ␉free (images[i].image);␊
687␉ ␉images[i].image = 0;␊
688␉ }␊
689␉}␊
690␉return 0;␊
691}␊
692␊
693static int freeBackBuffer( window_t *window )␊
694{␊
695␉if (gui.backbuffer && gui.backbuffer->pixels)␊
696 {␊
697␉␉free(gui.backbuffer->pixels);␊
698␉␉free(gui.backbuffer);␊
699␉␉gui.backbuffer = 0;␊
700␉␉return 0;␊
701␉}␊
702 ␊
703␉return 1;␊
704}␊
705␊
706#if UNUSED␊
707pixmap_t *getCroppedPixmapAtPosition( pixmap_t *from, position_t pos, uint16_t width, uint16_t height )␊
708{␊
709␉␊
710␉pixmap_t *cropped = malloc( sizeof( pixmap_t ) );␊
711␉if( !cropped )␊
712␉␉return 0;␊
713␉cropped->pixels = malloc( width * height * 4 );␊
714␉if ( !cropped->pixels )␊
715␉␉return 0;␊
716␉␊
717␉cropped->width = width;␊
718␉cropped->height = height;␊
719␉␊
720␉int destx = 0, desty = 0;␊
721␉int srcx = pos.x, srcy = pos.y;␊
722␉␊
723␉for( ; desty < height; desty++, srcy++)␊
724␉{␊
725␉␉for( destx = 0, srcx = pos.x; destx < width; destx++, srcx++ )␊
726␉␉{␊
727␉␉␉pixel( cropped, destx, desty ).value = pixel( from, srcx, srcy ).value;␊
728␉␉}␊
729␉}␊
730␉return cropped;␊
731}␊
732#endif␊
733␊
734static int createBackBuffer( window_t *window )␊
735{␊
736␉gui.backbuffer = malloc(sizeof(pixmap_t));␊
737␉if(!gui.backbuffer)␊
738␉{␊
739␉␉DBG("Unable to allocate memory for gui.backbuffer");␊
740␉␉return 1;␊
741␉}␊
742␉␊
743␉gui.backbuffer->pixels = malloc( window->width * window->height * 4 );␊
744␉if(!gui.backbuffer->pixels)␊
745␉{␊
746␉␉free(gui.backbuffer);␊
747␉␉gui.backbuffer = 0;␊
748␉␉DBG("Unable to allocate memory for gui.backbuffer->pixels");␊
749␉␉return 1;␊
750␉}␊
751␉␊
752␉gui.backbuffer->width = gui.screen.width;␊
753␉gui.backbuffer->height = gui.screen.height;␊
754␉␊
755␉return 0;␊
756}␊
757␊
758static int createWindowBuffer( window_t *window )␊
759{␊
760␉window->pixmap = malloc(sizeof(pixmap_t));␊
761␉if(!window->pixmap)␊
762␉{␊
763␉␉DBG("Unable to allocate memory for window->pixmap");␊
764␉␉return 1;␊
765␉}␊
766␉␊
767␉window->pixmap->pixels = malloc( window->width * window->height * 4 );␊
768␉if(!window->pixmap->pixels)␊
769␉{␊
770␉␉free(window->pixmap);␊
771␉␉window->pixmap = 0;␊
772␉␉DBG("Unable to allocate memory for window->pixmap->pixels");␊
773␉␉return 1;␊
774␉}␊
775␉␊
776␉window->pixmap->width = window->width;␊
777␉window->pixmap->height = window->height;␊
778␉␊
779␉return 0;␊
780}␊
781␊
782static int freeWindowBuffer( window_t *window )␊
783{␊
784␉if (window->pixmap && window->pixmap->pixels)␊
785 {␊
786␉␉free(window->pixmap->pixels);␊
787␉␉free(window->pixmap);␊
788␉␉return 0;␊
789␉}␊
790␉␊
791␉return 1;␊
792}␊
793␊
794static void fillPixmapWithColor(pixmap_t *pm, uint32_t color)␊
795{␊
796␉int x,y;␊
797␉␊
798␉// fill with given color AARRGGBB␊
799␉for( x=0; x < pm->width; x++ )␊
800␉␉for( y=0; y< pm->height; y++)␊
801␉␉␉pixel(pm,x,y).value = color;␊
802}␊
803␊
804void drawBackground()␊
805{␊
806␉// reset text cursor␊
807␉gui.screen.cursor.x = gui.screen.hborder;␊
808␉gui.screen.cursor.y = gui.screen.vborder;␊
809␉␊
810␉fillPixmapWithColor( gui.screen.pixmap, gui.screen.bgcolor);␊
811␉␊
812␉// draw background.png into background buffer␊
813␉blend( images[iBackground].image, gui.screen.pixmap, gui.background.pos );␊
814␉␊
815␉// draw logo.png into background buffer␊
816␉if (gui.logo.draw)␊
817␉{␊
818 ␉blend( images[iLogo].image, gui.screen.pixmap, gui.logo.pos);␊
819␉}␊
820␉␊
821␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
822}␊
823␊
824static void setupDeviceList(config_file_t *theme)␊
825{␊
826␉unsigned int pixel;␊
827␉int␉alpha;␉␉␉␉// transparency level 0 (obligue) - 255 (transparent)␊
828␉uint32_t color;␉␉␉// color value formatted RRGGBB␊
829␉int val, len;␊
830␉const char *string;␉␊
831 int devcnt = (int)get_env(envgDeviceCount);␊
832␊
833␉if(getIntForKey("devices_max_visible", &val, theme ))␊
834␉␉gui.maxdevices = MIN( val, devcnt );␊
835␉␊
836␉if(getIntForKey("devices_iconspacing", &val, theme ))␊
837␉␉gui.devicelist.iconspacing = val;␊
838␉␊
839␉// check layout for horizontal or vertical␊
840␉gui.layout = HorizontalLayout;␊
841␉if(getValueForKey( "devices_layout", &string, &len, theme)) {␊
842␉␉if (!strcmp (string, "vertical")) {␊
843␉␉␉gui.layout = VerticalLayout;␊
844␉␉}␊
845␉}␊
846␉␊
847␉switch (gui.layout) {␊
848␉␉case VerticalLayout:␊
849␉␉␉gui.devicelist.height = ((images[iSelection].image->height + font_console.chars[0]->height + gui.devicelist.iconspacing) * MIN(gui.maxdevices, devcnt) + (images[iDeviceScrollPrev].image->height + images[iDeviceScrollNext].image->height) + gui.devicelist.iconspacing);␊
850␉␉␉gui.devicelist.width = (images[iSelection].image->width + gui.devicelist.iconspacing);␊
851␉␉␉␊
852␉␉␉if(getDimensionForKey("devices_pos_x", &pixel, theme, gui.screen.width , images[iSelection].image->width ) )␊
853␉␉␉␉gui.devicelist.pos.x = pixel;␊
854␉␉␉␊
855␉␉␉if(getDimensionForKey("devices_pos_y", &pixel, theme, gui.screen.height , gui.devicelist.height ) )␊
856␉␉␉␉gui.devicelist.pos.y = pixel;␊
857␉␉␉break;␊
858␉␉␉␊
859␉␉case HorizontalLayout:␊
860␉␉default:␊
861␉␉␉gui.devicelist.width = ((images[iSelection].image->width + gui.devicelist.iconspacing) * MIN(gui.maxdevices, devcnt) + (images[iDeviceScrollPrev].image->width + images[iDeviceScrollNext].image->width) + gui.devicelist.iconspacing);␊
862␉␉␉gui.devicelist.height = (images[iSelection].image->height + font_console.chars[0]->height + gui.devicelist.iconspacing);␊
863␉␉␉␊
864␉␉␉if(getDimensionForKey("devices_pos_x", &pixel, theme, gui.screen.width , gui.devicelist.width ) )␊
865␉␉␉␉gui.devicelist.pos.x = pixel;␊
866␉␉␉else␊
867␉␉␉␉gui.devicelist.pos.x = ( gui.screen.width - gui.devicelist.width ) / 2;␊
868␉␉␉␊
869␉␉␉if(getDimensionForKey("devices_pos_y", &pixel, theme, gui.screen.height , images[iSelection].image->height ) )␊
870␉␉␉␉gui.devicelist.pos.y = pixel;␊
871␉␉␉else␊
872␉␉␉␉gui.devicelist.pos.y = ( gui.screen.height - gui.devicelist.height ) / 2;␊
873␉␉␉break;␊
874␉}␊
875␉␊
876␉if(getColorForKey("devices_bgcolor", &color, theme))␊
877␉␉gui.devicelist.bgcolor = (color & 0x00FFFFFF);␊
878␉␊
879␉if(getIntForKey("devices_transparency", &alpha, theme))␊
880␉␉gui.devicelist.bgcolor = gui.devicelist.bgcolor | (( 255 - ( alpha & 0xFF) ) << 24);␊
881␉␊
882␉if (gui.devicelist.pixmap)␊
883␉{␊
884␉ freeWindowBuffer(&gui.devicelist);␊
885 createWindowBuffer(&gui.devicelist);␊
886 }␊
887}␊
888␊
889static void loadThemeValues(config_file_t *theme)␊
890{␊
891␉unsigned int screen_width = gui.screen.width;␊
892␉unsigned int screen_height = gui.screen.height;␊
893␉unsigned int pixel;␊
894␉int␉alpha;␉␉␉␉// transparency level 0 (obligue) - 255 (transparent)␊
895␉uint32_t color;␉␉␉// color value formatted RRGGBB␊
896␉int val;␊
897␉␊
898␉/*␊
899␉ * Parse screen parameters␊
900␉ */␊
901␉if(getColorForKey("screen_bgcolor", &color, theme ))␊
902␉␉gui.screen.bgcolor = (color & 0x00FFFFFF);␊
903␉␊
904␉if(getIntForKey("screen_textmargin_h", &val, theme))␊
905␉␉gui.screen.hborder = MIN( gui.screen.width , val );␊
906␉␊
907␉if(getIntForKey("screen_textmargin_v", &val, theme))␊
908␉␉gui.screen.vborder = MIN( gui.screen.height , val );␊
909␉␊
910␉/*␊
911␉ * Parse background parameters␊
912␉ */␊
913␉if(getDimensionForKey("background_pos_x", &pixel, theme, screen_width , images[iBackground].image->width ) )␊
914␉␉gui.background.pos.x = pixel;␊
915␉␊
916␉if(getDimensionForKey("background_pos_y", &pixel, theme, screen_height , images[iBackground].image->height ) )␊
917␉␉gui.background.pos.y = pixel;␊
918␉␊
919␉/*␊
920␉ * Parse logo parameters␊
921␉ */␊
922␉if(getDimensionForKey("logo_pos_x", &pixel, theme, screen_width , images[iLogo].image->width ) )␊
923␉␉gui.logo.pos.x = pixel;␊
924␉␊
925␉if(getDimensionForKey("logo_pos_y", &pixel, theme, screen_height , images[iLogo].image->height ) )␊
926␉␉gui.logo.pos.y = pixel;␊
927␉␊
928␉/*␊
929␉ * Parse progress bar parameters␊
930␉ */␊
931␉if(getDimensionForKey("progressbar_pos_x", &pixel, theme, screen_width , 0 ) )␊
932␉␉gui.progressbar.pos.x = pixel;␊
933␉␊
934␉if(getDimensionForKey("progressbar_pos_y", &pixel, theme, screen_height , 0 ) )␊
935␉␉gui.progressbar.pos.y = pixel;␊
936␉␊
937␉/*␊
938␉ * Parse countdown text parameters␊
939␉ */␊
940␉if(getDimensionForKey("countdown_pos_x", &pixel, theme, screen_width , 0 ) )␊
941␉␉gui.countdown.pos.x = pixel;␊
942␉␊
943␉if(getDimensionForKey("countdown_pos_y", &pixel, theme, screen_height , 0 ) )␊
944␉␉gui.countdown.pos.y = pixel;␊
945␉␊
946 /*␊
947␉ * Parse devicelist parameters␊
948␉ */␊
949␉setupDeviceList(theme);␊
950␉␊
951␉/*␊
952␉ * Parse infobox parameters␊
953␉ */␊
954␉if(getIntForKey("infobox_width", &val, theme) && val >= 0)␊
955␉␉gui.infobox.width = MIN( screen_width ,(unsigned) val );␊
956␉␊
957␉if(getIntForKey("infobox_height", &val, theme) && val >= 0)␊
958␉␉gui.infobox.height = MIN( screen_height , (unsigned)val );␊
959␉␊
960␉if(getDimensionForKey("infobox_pos_x", &pixel, theme, screen_width , gui.infobox.width ) )␊
961␉␉gui.infobox.pos.x = pixel;␊
962␉␊
963␉if(getDimensionForKey("infobox_pos_y", &pixel, theme, screen_height , gui.infobox.height ) )␊
964␉␉gui.infobox.pos.y = pixel;␊
965␉␊
966␉if(getIntForKey("infobox_textmargin_h", &val, theme))␊
967␉␉gui.infobox.hborder = MIN( gui.infobox.width , val );␊
968␉␊
969␉if(getIntForKey("infobox_textmargin_v", &val, theme))␊
970␉␉gui.infobox.vborder = MIN( gui.infobox.height , val );␊
971␉␊
972␉if(getColorForKey("infobox_bgcolor", &color, theme))␊
973␉␉gui.infobox.bgcolor = (color & 0x00FFFFFF);␊
974␉␊
975␉if(getIntForKey("infobox_transparency", &alpha, theme))␊
976␉␉gui.infobox.bgcolor = gui.infobox.bgcolor | (( 255 - ( alpha & 0xFF) ) << 24);␊
977␉␊
978␉/*␊
979␉ * Parse menu parameters␊
980␉ */␊
981␉if(getDimensionForKey("menu_width", &pixel, theme, gui.screen.width , 0 ) )␊
982␉␉gui.menu.width = pixel;␊
983␉else␊
984␉␉gui.menu.width = images[iMenuSelection].image->width;␊
985␉␊
986␉if(getDimensionForKey("menu_height", &pixel, theme, gui.screen.height , 0 ) )␊
987␉␉gui.menu.height = pixel;␊
988␉else␊
989␉␉gui.menu.height = (infoMenuItemsCount) * images[iMenuSelection].image->height;␊
990␉␊
991␉if(getDimensionForKey("menu_pos_x", &pixel, theme, screen_width , gui.menu.width ) )␊
992␉␉gui.menu.pos.x = pixel;␊
993␉␊
994␉if(getDimensionForKey("menu_pos_y", &pixel, theme, screen_height , gui.menu.height ) )␊
995␉␉gui.menu.pos.y = pixel;␊
996␉␊
997␉if(getIntForKey("menu_textmargin_h", &val, theme))␊
998␉␉gui.menu.hborder = MIN( gui.menu.width , val );␊
999␉␊
1000␉if(getIntForKey("menu_textmargin_v", &val, theme))␊
1001␉␉gui.menu.vborder = MIN( gui.menu.height , val );␊
1002␉␊
1003␉if(getColorForKey("menu_bgcolor", &color, theme))␊
1004␉␉gui.menu.bgcolor = (color & 0x00FFFFFF);␊
1005␉␊
1006␉if(getIntForKey("menu_transparency", &alpha, theme))␊
1007␉␉gui.menu.bgcolor = gui.menu.bgcolor | (( 255 - ( alpha & 0xFF) ) << 24);␉␉␊
1008␉␊
1009␉/*␊
1010␉ * Parse bootprompt parameters␊
1011␉ */␊
1012␉if(getDimensionForKey("bootprompt_width", &pixel, theme, screen_width , 0 ) )␊
1013␉␉gui.bootprompt.width = pixel;␊
1014␉␊
1015␉if(getIntForKey("bootprompt_height", &val, theme) && val >= 0)␊
1016␉␉gui.bootprompt.height = MIN( screen_height , (unsigned)val );␊
1017␉␊
1018␉if(getDimensionForKey("bootprompt_pos_x", &pixel, theme, screen_width , gui.bootprompt.width ) )␊
1019␉␉gui.bootprompt.pos.x = pixel;␊
1020␉␊
1021␉if(getDimensionForKey("bootprompt_pos_y", &pixel, theme, screen_height , gui.bootprompt.height ) )␊
1022␉␉gui.bootprompt.pos.y = pixel;␊
1023␉␊
1024␉if(getIntForKey("bootprompt_textmargin_h", &val, theme) && val >= 0)␊
1025␉␉gui.bootprompt.hborder = MIN( gui.bootprompt.width , (unsigned)val );␊
1026␉␊
1027␉if(getIntForKey("bootprompt_textmargin_v", &val, theme) && val >= 0)␊
1028␉␉gui.bootprompt.vborder = MIN( gui.bootprompt.height , (unsigned)val );␊
1029␉␊
1030␉if(getColorForKey("bootprompt_bgcolor", &color, theme))␊
1031␉␉gui.bootprompt.bgcolor = (color & 0x00FFFFFF);␊
1032␉␊
1033␉if(getIntForKey("bootprompt_transparency", &alpha, theme))␊
1034␉␉gui.bootprompt.bgcolor = gui.bootprompt.bgcolor | (( 255 - ( alpha & 0xFF) ) << 24);␊
1035␉␊
1036␉if(getColorForKey("font_small_color", &color, theme))␊
1037␉␉gui.screen.font_small_color = (color & 0x00FFFFFF);␊
1038␉␊
1039␉if(getColorForKey("font_console_color", &color, theme))␊
1040␉␉gui.screen.font_console_color = (color & 0x00FFFFFF);␊
1041}␊
1042␊
1043#define MAX_THEMES 255␊
1044␊
1045static void add_theme(const char* theme, uint8_t nb)␊
1046{␊
1047␉␊
1048␉themeList_t* new_theme = malloc(sizeof(themeList_t));␊
1049␉if (new_theme)␊
1050␉{␉␊
1051␉␉new_theme->next = themeList;␊
1052␉␉␊
1053␉␉themeList = new_theme;␊
1054␉␉␊
1055␉␉new_theme->nb = nb;␊
1056␉␉new_theme->theme = newString(theme);␊
1057␉}␉␊
1058}␊
1059␊
1060static void free_theme_list()␊
1061{␊
1062␉themeList_t* entry = themeList;␊
1063␉while(entry)␊
1064␉{␊
1065#if DEBUG_GUI␊
1066␉␉printf("freeing %s (nb = %d)\n", entry->theme, entry->nb);␉␉␊
1067#endif␊
1068␉␉␊
1069␉␉char *theme = entry->theme;␊
1070␉␉themeList_t* tmp = NULL;␊
1071␉␉␊
1072␉␉tmp = entry;␊
1073␉␉entry = entry->next;␉␉␊
1074␉␉␊
1075␉␉free(theme);␉␉␊
1076␉␉free(tmp);␊
1077␉␉␊
1078␉}␊
1079}␊
1080␊
1081␊
1082static int randomTheme(char *dirspec, const char **theme) {␊
1083␉␊
1084␉long ret, flags, time;␊
1085␉long long␉ index;␊
1086␉int sta = 1;␊
1087␉const char * name;␉␉ ␊
1088␉index = 0;␉␉ ␊
1089␉uint8_t i=0;␊
1090␉␊
1091#ifdef EMBED_THEME␊
1092␉add_theme("", i);␊
1093␉i++;␊
1094#endif␊
1095␉␊
1096␉while (i < MAX_THEMES) {␊
1097␉␉ret = GetDirEntry(dirspec, &index, &name, &flags, &time);␊
1098␉␉if (ret == -1) break;␊
1099␉␉␊
1100␉␉// Make sure this is a directory.␊
1101␉␉if ((flags & kFileTypeMask) != kFileTypeDirectory) continue;␊
1102␉␉␊
1103␉␉add_theme(name, i);␉␉␉␊
1104␉␉␊
1105␉␉i++;␊
1106␉␉␊
1107␉}␉␊
1108#if DEBUG_GUI␊
1109␉themeList_t* debugentry = themeList;␊
1110␉printf("theme list: \n");␊
1111␉while(debugentry)␊
1112␉{␊
1113␉␉printf("* %s (nb = %d)\n", debugentry->theme, debugentry->nb);␉␉␊
1114␉␉debugentry = debugentry->next;␊
1115␉}␉␊
1116␉printf("\n");␊
1117#endif␊
1118␊
1119␉if (i) {␉␉␉␊
1120␉␉␊
1121␉␉uint8_t choosen = arc4random_uniform(i+1);␊
1122␉␉␉␉␉␉␊
1123␉␉themeList_t* entry = themeList;␊
1124␊
1125␉␉while(entry)␊
1126␉␉{␊
1127␊
1128␉␉␉if (entry->nb == choosen) break;␊
1129␉␉␉␊
1130␉␉␉entry = entry->next;␊
1131␉␉}␊
1132␉␉␊
1133␉␉if (entry) {␊
1134#if DEBUG_GUI␊
1135␊
1136␉␉␉printf("choosen theme %s (nb = %d)\n", entry->theme, entry->nb);␊
1137␉␉␉sleep(1);␊
1138#endif␊
1139␉␉␉*theme = entry->theme;␉␉␉␊
1140␉␉␉␊
1141␉␉␉sta = startGUI();␊
1142␉␉␉␊
1143␊
1144␉␉}␉ ␊
1145#if DEBUG_GUI␊
1146␉␉else {␊
1147␉␉␉goto out;␊
1148␉␉}␊
1149#endif␊
1150␉␊
1151␉␉␊
1152␉␉free_theme_list();␊
1153␉␉␊
1154␉} ␊
1155#if DEBUG_GUI␊
1156␉else {␊
1157␉␉printf("No theme found !!\n");␊
1158␉␉␊
1159␉␉sleep(1);␊
1160␉}␉␊
1161#endif␊
1162␉return sta;␉␊
1163␉␊
1164#if DEBUG_GUI␊
1165out:␊
1166␉␉printf("random theme failed !!\n");␊
1167␉␉␊
1168␉␉sleep(1);␉␉␊
1169#endif␊
1170␉return sta;␉␊
1171␉␊
1172␉␊
1173}␊
1174␊
1175int initGUI(void)␊
1176{␉␊
1177␉bool dummybool = true;␊
1178␉int ret = 1;␉␊
1179␉bool theme_ran= false;␊
1180␉bool theme_name_set= false;␊
1181␉␊
1182␉getBoolForKey(kGUIKey, &dummybool, DEFAULT_BOOT_CONFIG);␊
1183␉if (!dummybool) {␊
1184␉␉return 1;␊
1185␉}␊
1186 getMemoryInfoString = (void*)lookup_all_symbols(SYMBOLS_BUNDLE,"_getMemoryInfoString");␊
1187 showHelp = (void*)lookup_all_symbols(SYMBOLS_BUNDLE,"_showHelp");␊
1188␊
1189␉␊
1190␉getBoolForKey("RandomTheme", &theme_ran, DEFAULT_BOOT_CONFIG);␊
1191␉␊
1192␉{␊
1193␉␉long flags;␊
1194␉␉long time;␊
1195␉␉long ret = -1;␊
1196␉␉int len;␊
1197␉␉␊
1198␉␉theme_name_set = getValueForKey( "Theme", &theme_name, &len, DEFAULT_BOOT_CONFIG );␊
1199␉␉␊
1200␉␉if (theme_ran) ␊
1201␉␉{␉␉␊
1202␉␉retry:␊
1203␉␉␉ret = GetFileInfo("rd(0,0)/Extra/", "Themes", &flags, &time);␊
1204␉␉␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory)) {␊
1205␉␉␉␉sprintf(dirsrc, "rd(0,0)/Extra/Themes");␊
1206␉␉␉␉␊
1207␉␉␉} else {␊
1208␉␉␉␉ret = GetFileInfo("/Extra/", "Themes", &flags, &time);␊
1209␉␉␉␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory)) {␊
1210␉␉␉␉␉sprintf(dirsrc, "/Extra/Themes");␊
1211␉␉␉␉␉␊
1212␉␉␉␉} else {␊
1213␉␉␉␉␉ret = GetFileInfo("bt(0,0)/Extra/", "Themes", &flags, &time);␊
1214␉␉␉␉␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory)) {␊
1215␉␉␉␉␉␉sprintf(dirsrc, "bt(0,0)/Extra/Themes");␊
1216␉␉␉␉␉␉␊
1217␉␉␉␉␉} else {␊
1218␉␉␉␉␉␉printf("Failed to find the /extra/Themes folder\n");␊
1219␉␉␉␉␉␉return 1;␊
1220␉␉␉␉␉}␊
1221␉␉␉␉}␊
1222␉␉␉␉␊
1223␉␉␉}␉␉␊
1224␉␉} ␊
1225␉␉else if (theme_name_set)␊
1226␉␉{␉␉␊
1227␉␉␉ret = GetFileInfo("rd(0,0)/Extra/Themes/", theme_name, &flags, &time);␊
1228␉␉␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory)) {␊
1229␉␉␉␉sprintf(dirsrc, "rd(0,0)/Extra/Themes");␊
1230␉␉␉␉␊
1231␉␉␉} else {␊
1232␉␉␉␉ret = GetFileInfo("/Extra/Themes/", theme_name, &flags, &time);␊
1233␉␉␉␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory)) {␊
1234␉␉␉␉␉sprintf(dirsrc, "/Extra/Themes");␊
1235␉␉␉␉␉␊
1236␉␉␉␉} else {␊
1237␉␉␉␉␉ret = GetFileInfo("bt(0,0)/Extra/Themes/", theme_name, &flags, &time);␊
1238␉␉␉␉␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory)) {␊
1239␉␉␉␉␉␉sprintf(dirsrc, "bt(0,0)/Extra/Themes");␊
1240␉␉␉␉␉␉␊
1241␉␉␉␉␉} else {␊
1242␉␉␉␉␉␉printf("Failed to find the /extra/Themes/%s folder\n",theme_name);␊
1243␉␉␉␉␉␉theme_name_set = false;␊
1244␉␉␉␉␉␉goto retry;␊
1245␉␉␉␉␉}␊
1246␉␉␉␉}␊
1247␉␉␉␉␊
1248␉␉␉}␊
1249␉␉}␉␊
1250␉}␉␊
1251␉␊
1252␉if (theme_ran)␊
1253␉{␊
1254␉␉␊
1255␉␉ret = randomTheme(dirsrc, &theme_name);␊
1256 ␉␉␊
1257␉␉if (ret) printf("randomTheme Failed !! \n");␊
1258#if DEBUG_GUI␊
1259␉␉else␊
1260 {␊
1261 DBG("Theme successfuly Choosen randomly !! \n"); ␊
1262 }␊
1263#endif␊
1264␉} ␊
1265␉␊
1266␉if (ret)␊
1267␉{␉␉␉␊
1268␉␉if (theme_name_set == true)␊
1269␉␉{␊
1270␉␉␉ret = startGUI();␊
1271␉␉␉␊
1272␉␉␉if (ret) printf("Failed to load Theme : %s !! \n", theme_name);␊
1273␉␉␉␊
1274␉␉} ␊
1275#ifdef EMBED_THEME␉␊
1276␉␉if (ret) {␊
1277␉␉␉theme_name = "";␉␉␉␉␊
1278␉␉␉ret = startGUI();␊
1279␉␉␉␊
1280␉␉␉if (ret) printf("Failed to load Embed Theme !! \n");␊
1281␉␉␉␊
1282␉␉}␉␉␊
1283#endif␉␉␊
1284␉␉if (ret && (strcmp(theme_name, THEME_NAME_DEFAULT) != 0)) {␊
1285␉␉␉theme_name = THEME_NAME_DEFAULT;␊
1286␉␉␉ret = startGUI();␊
1287␉␉␉␊
1288␉␉␉if (ret) printf("Failed to load Default Theme : %s !! \n", THEME_NAME_DEFAULT);␊
1289␉␉}␊
1290␉} ␊
1291␉return ret;␊
1292}␊
1293␊
1294static int startGUI(void)␊
1295{␊
1296␉int val;␉␊
1297␉char dirspec[256];␊
1298␉␊
1299␉␊
1300␉if ((unsigned)(strlen(theme_name) + strlen(dirsrc) + strlen("theme.plist") + 2 ) > sizeof(dirspec)) {␊
1301␉␉␊
1302␉␉DBG("Path of %s/%s/theme.plist to long\n", dirsrc, theme_name);␉␉␊
1303␉␉return 1;␊
1304␉}␊
1305␉␊
1306␉sprintf(dirspec, "%s/%s/theme.plist", dirsrc ,theme_name);␊
1307␉␊
1308␉if (loadConfigFile(dirspec, &themeConfig) != 0) {␊
1309␉␉␊
1310#ifdef EMBED_THEME␊
1311␉␉if (strlen(theme_name) == 0) {␊
1312␉␉␉config_file_t *config;␊
1313␉␉␉␊
1314␉␉␉config = &themeConfig;␊
1315␉␉␉if (ParseXMLFile((char *)__theme_plist, &config->dictionary) != 0) {␊
1316␉␉␉␉␊
1317␉␉␉␉DBG("Unable to load embed theme plist datas.\n");␊
1318␉␉␉␉␊
1319␉␉␉␉return 1;␊
1320␉␉␉}␊
1321␉␉}␉␉␉␊
1322#else␊
1323␉␉␊
1324␉␉DBG("Unable to load %s theme plist.\n",theme_name);␊
1325␉␉␊
1326␉␉return 1;␊
1327␉␉␊
1328#endif␉␉␊
1329 }␊
1330␉␊
1331␉if (execute_hook("getResolution_hook", &screen_params[0], &screen_params[1], &screen_params[2], NULL, NULL, NULL) != EFI_SUCCESS)␉␉␊
1332␉{␉␉␊
1333␉␉// parse display size parameters␊
1334␉␉if (getIntForKey("screen_width", &val, &themeConfig) && val > 0) {␊
1335␉␉␉screen_params[0] = val;␊
1336␉␉}␊
1337␉␉if (getIntForKey("screen_height", &val, &themeConfig) && val > 0) {␊
1338␉␉␉screen_params[1] = val;␊
1339␉␉}␉␉␊
1340␉}␊
1341#if DEBUG_GUI␊
1342␉else␊
1343␉{␊
1344␉␉printf("No getResolution function hook installed, using default resolution.\n",theme_name);␊
1345␉␉␊
1346␉}␊
1347#endif␊
1348␉␊
1349␉␊
1350␉// Initalizing GUI strucutre.␊
1351␉bzero(&gui, sizeof(gui_t));␊
1352␉␊
1353␉// find best matching vesa mode for our requested width & height␊
1354␉getGraphicModeParams(screen_params);␊
1355␉␊
1356␉// set our screen structure with the mode width & height␊
1357␉gui.screen.width = screen_params[0];␉␊
1358␉gui.screen.height = screen_params[1];␊
1359␉␊
1360␉// load graphics otherwise fail and return␊
1361␉if (loadGraphics(dirsrc) == 0) {␊
1362␉␉loadThemeValues(&themeConfig);␊
1363␉␉colorFont(&font_small, gui.screen.font_small_color);␊
1364␉␉colorFont(&font_console, gui.screen.font_console_color);␊
1365␉␉␊
1366␉␉// create the screen & window buffers␊
1367␉␉if (createBackBuffer(&gui.screen) == 0)␊
1368␉␉{␊
1369␉␉␉if (createWindowBuffer(&gui.screen) == 0)␊
1370␉␉␉{␊
1371␉␉␉␉if (createWindowBuffer(&gui.devicelist) == 0)␊
1372␉␉␉␉{␊
1373␉␉␉␉␉if (createWindowBuffer(&gui.bootprompt) == 0)␊
1374␉␉␉␉␉{␊
1375␉␉␉␉␉␉if (createWindowBuffer(&gui.infobox) == 0)␊
1376␉␉␉␉␉␉{␊
1377␉␉␉␉␉␉␉if (createWindowBuffer(&gui.menu) == 0)␊
1378␉␉␉␉␉␉␉{␊
1379␉␉␉␉␉␉␉ gui.logo.draw = true;␊
1380␉␉␉␉␉␉␉␉drawBackground();␊
1381␉␉␉␉␉␉␉␉// lets copy the screen into the back buffer␊
1382 memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
1383␊
1384␉␉␉␉␉␉␉␉setVideoMode( GRAPHICS_MODE );␊
1385␊
1386␉␉␉␉␉␉␉␉gui.initialised = true;␉␉␉␉␉␉␉␉␊
1387␉␉␉␉␉␉␉␉return 0;␊
1388␉␉␉␉␉␉␉}␊
1389␉␉␉␉␉␉}␊
1390␉␉␉␉␉}␊
1391␉␉␉␉}␊
1392␉␉␉}␊
1393␉␉}␊
1394␉}␊
1395␉␊
1396␉DBG("Loading error occurred, reseting...\n",theme_name);␉␉␊
1397␉␊
1398␉// Loading error occurred, freeing resources␊
1399 freeWindowBuffer(&gui.menu);␊
1400 freeWindowBuffer(&gui.infobox);␊
1401 freeWindowBuffer(&gui.bootprompt);␊
1402 freeWindowBuffer(&gui.devicelist);␊
1403 freeWindowBuffer(&gui.screen);␊
1404 freeBackBuffer(&gui.screen);␊
1405 unloadGraphics();␉␊
1406␉␊
1407␉return 1;␊
1408}␊
1409␊
1410static bool is_image_loaded(int i)␊
1411{␉␊
1412␉return (images[i].image != NULL) ? true : false;␊
1413}␊
1414␊
1415static void drawDeviceIcon(BVRef device, pixmap_t *buffer, position_t p, bool isSelected)␊
1416{␊
1417␉int devicetype;␊
1418␉␊
1419␉if( diskIsCDROM(device) )␊
1420␉␉devicetype = iDeviceCDROM;␉␉␉␉// Use CDROM icon␊
1421␉else␊
1422␉{␉␊
1423␉␉switch (device->part_type)␊
1424␉␉{␊
1425␉␉␉case kPartitionTypeHFS:␊
1426␉␉␉{␉␉␉␉␊
1427#ifdef BOOT_HELPER_SUPPORT␉␊
1428␉␉␉␉// Use HFS or HFSRAID icon depending on bvr flags.␊
1429␉␉␉␉if (device->flags & kBVFlagBooter) {␊
1430 ␊
1431␉␉␉␉␉switch (device->OSVersion[3]) {␊
1432 case '8':␊
1433 devicetype = is_image_loaded(iDeviceHFSRAID_ML) ? iDeviceHFSRAID_ML : is_image_loaded(iDeviceHFSRAID) ? iDeviceHFSRAID : iDeviceGeneric;␊
1434 break;␊
1435␉␉␉␉␉␉case '7':␊
1436␉␉␉␉␉␉␉devicetype = is_image_loaded(iDeviceHFSRAID_Lion) ? iDeviceHFSRAID_Lion : is_image_loaded(iDeviceHFSRAID) ? iDeviceHFSRAID : iDeviceGeneric;␊
1437␉␉␉␉␉␉␉break;␊
1438␉␉␉␉␉␉case '6':␊
1439␉␉␉␉␉␉␉devicetype = is_image_loaded(iDeviceHFSRAID_SL) ? iDeviceHFSRAID_SL : is_image_loaded(iDeviceHFSRAID) ? iDeviceHFSRAID : iDeviceGeneric;␊
1440␉␉␉␉␉␉␉break;␊
1441␉␉␉␉␉␉case '5':␊
1442␉␉␉␉␉␉␉devicetype = is_image_loaded(iDeviceHFSRAID_Leo) ? iDeviceHFSRAID_Leo : is_image_loaded(iDeviceHFSRAID) ? iDeviceHFSRAID : iDeviceGeneric;␊
1443␉␉␉␉␉␉␉break;␊
1444␉␉␉␉␉␉case '4':␊
1445␉␉␉␉␉␉␉devicetype = is_image_loaded(iDeviceHFSRAID_Tiger) ? iDeviceHFSRAID_Tiger : is_image_loaded(iDeviceHFSRAID) ? iDeviceHFSRAID : iDeviceGeneric;␊
1446␉␉␉␉␉␉␉break;␊
1447␉␉␉␉␉␉default:␊
1448␉␉␉␉␉␉␉devicetype = is_image_loaded(iDeviceHFSRAID) ? iDeviceHFSRAID : iDeviceGeneric;␊
1449␉␉␉␉␉␉␉break;␊
1450␉␉␉␉␉}␊
1451␉␉␉␉␉␊
1452␉␉␉␉} else␉␉␉␉␊
1453#endif␊
1454␉␉␉␉{␉␉␉␉␉␊
1455␉␉␉␉␉␊
1456␉␉␉␉␉switch (device->OSVersion[3]) {␊
1457 case '8':␊
1458 devicetype = is_image_loaded(iDeviceHFS_ML) ? iDeviceHFS_ML : is_image_loaded(iDeviceHFS) ? iDeviceHFS : iDeviceGeneric;␊
1459 break;␊
1460␉␉␉␉␉␉case '7':␊
1461␉␉␉␉␉␉␉devicetype = is_image_loaded(iDeviceHFS_Lion) ? iDeviceHFS_Lion : is_image_loaded(iDeviceHFS) ? iDeviceHFS : iDeviceGeneric;␊
1462␉␉␉␉␉␉␉break;␊
1463␉␉␉␉␉␉case '6':␊
1464␉␉␉␉␉␉␉devicetype = is_image_loaded(iDeviceHFS_SL) ? iDeviceHFS_SL : is_image_loaded(iDeviceHFS) ? iDeviceHFS : iDeviceGeneric;␊
1465␉␉␉␉␉␉␉break;␊
1466␉␉␉␉␉␉case '5':␊
1467␉␉␉␉␉␉␉devicetype = is_image_loaded(iDeviceHFS_Leo) ? iDeviceHFS_Leo : is_image_loaded(iDeviceHFS) ? iDeviceHFS : iDeviceGeneric;␊
1468␉␉␉␉␉␉␉break;␊
1469␉␉␉␉␉␉case '4':␊
1470␉␉␉␉␉␉␉devicetype = is_image_loaded(iDeviceHFS_Tiger) ? iDeviceHFS_Tiger : is_image_loaded(iDeviceHFS) ? iDeviceHFS : iDeviceGeneric;␊
1471␉␉␉␉␉␉␉break;␊
1472␉␉␉␉␉␉default:␊
1473␉␉␉␉␉␉␉devicetype = is_image_loaded(iDeviceHFS) ? iDeviceHFS : iDeviceGeneric;␊
1474␉␉␉␉␉␉␉break;␊
1475␉␉␉␉␉}␉␉␉␉␉␉␊
1476␉␉␉␉␉␊
1477␉␉␉␉}␊
1478␉␉␉␉␊
1479␉␉␉␉break;␊
1480␉␉␉␉␊
1481␉␉␉}␉␉␉␉␊
1482␉␉␉case kPartitionTypeHPFS:␊
1483␉␉␉␉devicetype = is_image_loaded(iDeviceNTFS) ? iDeviceNTFS : iDeviceGeneric;␉␉// Use HPFS / NTFS icon␊
1484␉␉␉␉break;␊
1485␉␉␉␉␊
1486␉␉␉case kPartitionTypeFAT16:␊
1487␉␉␉␉devicetype = is_image_loaded(iDeviceFAT16) ? iDeviceFAT16 : iDeviceGeneric;␉␉// Use FAT16 icon␊
1488␉␉␉␉break;␊
1489␉␉␉␉␊
1490␉␉␉case kPartitionTypeFAT32:␊
1491␉␉␉␉devicetype = is_image_loaded(iDeviceFAT32) ? iDeviceFAT32 : iDeviceGeneric;␉␉// Use FAT32 icon␊
1492␉␉␉␉break;␊
1493␉␉␉␉␊
1494␉␉␉case kPartitionTypeEXT3:␊
1495␉␉␉␉devicetype = is_image_loaded(iDeviceEXT3) ? iDeviceEXT3 : iDeviceGeneric;␉␉// Use EXT2/3 icon␊
1496␉␉␉␉break;␊
1497␉␉␉␉␊
1498␉␉␉case kPartitionTypeFreeBSD:␊
1499␉␉␉␉devicetype = is_image_loaded(iDeviceFreeBSD) ? iDeviceFreeBSD : iDeviceGeneric;␉␉// Use FreeBSD icon␊
1500␉␉␉␉break;␊
1501␉␉␉␉␊
1502␉␉␉case kPartitionTypeOpenBSD:␊
1503␉␉␉␉devicetype = is_image_loaded(iDeviceOpenBSD) ? iDeviceOpenBSD : iDeviceGeneric;␉␉// Use OpenBSD icon␊
1504␉␉␉␉break;␊
1505␉␉␉␉␊
1506␉␉␉case kPartitionTypeBEFS: /* Haiku detection and Icon credits to scorpius */␊
1507␉␉␉␉devicetype = is_image_loaded(iDeviceBEFS) ? iDeviceBEFS : iDeviceGeneric;// Use BEFS / Haiku icon␊
1508␉␉␉␉break;␊
1509␉␉␉␉␊
1510␉␉␉default:␊
1511␉␉␉␉devicetype = iDeviceGeneric;␉// Use Generic icon␊
1512␉␉␉␉break;␊
1513␉␉}␊
1514␉}␊
1515␉␊
1516␉// Draw the selection image and use the next (device_*_o) image for the selected item.␊
1517 if (isSelected)␊
1518␉{␊
1519␉␉blend(images[iSelection].image, buffer, centeredAt(images[iSelection].image, p));␊
1520␉␉devicetype++; // selec override image ␊
1521␉}␊
1522␉␊
1523␉// draw icon␊
1524␉blend( images[devicetype].image, buffer, centeredAt( images[devicetype].image, p ));␊
1525␉␊
1526␉p.y += (images[iSelection].image->height / 2) + font_console.chars[0]->height;␊
1527␉␊
1528␉// draw volume label ␊
1529␉drawStrCenteredAt( device->label, &font_small, buffer, p);␉␊
1530␉␊
1531}␊
1532␊
1533void drawDeviceList (int start, int end, int selection, MenuItem * menuItems)␊
1534{␊
1535␉int i;␊
1536␉position_t p, p_prev, p_next;␊
1537␉␊
1538␉//uint8_t␉maxDevices = MIN( gui.maxdevices, menucount );␊
1539␉␊
1540␉fillPixmapWithColor( gui.devicelist.pixmap, gui.devicelist.bgcolor);␊
1541␉␊
1542␉makeRoundedCorners( gui.devicelist.pixmap);␊
1543 ␊
1544 int devcnt = (int)get_env(envgDeviceCount);␊
1545␊
1546␉switch (gui.layout)␊
1547␉{␊
1548␉␉␉␊
1549␉␉case VerticalLayout:␊
1550␉␉␉p.x = (gui.devicelist.width /2);␊
1551␉␉␉p.y = ( ( images[iSelection].image->height / 2 ) + images[iDeviceScrollPrev].image->height + gui.devicelist.iconspacing );␊
1552␉␉␉␊
1553␉␉␉// place scroll indicators at top & bottom edges␊
1554␉␉␉p_prev = pos ( gui.devicelist.width / 2 , gui.devicelist.iconspacing );␊
1555␉␉␉p_next = pos ( p_prev.x, gui.devicelist.height - gui.devicelist.iconspacing );␊
1556␉␉␉␊
1557␉␉␉break;␊
1558␉␉␉␊
1559␉␉default:␉// use Horizontal layout as the default␊
1560␉␉␉␊
1561␉␉case HorizontalLayout:␊
1562␉␉␉p.x = (gui.devicelist.width - ( gui.devicelist.width / gui.maxdevices ) * gui.maxdevices ) / 2 + ( images[iSelection].image->width / 2) + images[iDeviceScrollPrev].image->width + gui.devicelist.iconspacing;␊
1563␉␉␉p.y = ((gui.devicelist.height - font_console.chars[0]->height ) - images[iSelection].image->height) / 2 + ( images[iSelection].image->height / 2 );␊
1564␉␉␉␊
1565␉␉␉// place scroll indicators at left & right edges␊
1566␉␉␉p_prev = pos ( images[iDeviceScrollPrev].image->width / 2 + gui.devicelist.iconspacing / 2, gui.devicelist.height / 2 );␊
1567␉␉␉p_next = pos ( gui.devicelist.width - ( images[iDeviceScrollNext].image->width / 2 + gui.devicelist.iconspacing / 2), gui.devicelist.height / 2 );␊
1568␉␉␉␊
1569␉␉␉break;␊
1570␉␉␉␊
1571␉}␊
1572␉␊
1573␉// draw visible device icons␊
1574␉for (i = 0; i < gui.maxdevices; i++)␊
1575␉{␊
1576␉␉BVRef param = menuItems[start + i].param;␊
1577␉␉␊
1578 bool isSelected = ((start + i) == selection) ? true : false;␊
1579␉␉if (isSelected)␊
1580␉␉{␊
1581 if (param->flags & kBVFlagNativeBoot)␊
1582 {␊
1583 infoMenuNativeBoot = true;␊
1584 }␊
1585 else␊
1586 {␊
1587 infoMenuNativeBoot = false;␊
1588 if(infoMenuSelection >= INFOMENU_NATIVEBOOT_START && infoMenuSelection <= INFOMENU_NATIVEBOOT_END)␊
1589␉␉␉␉␉infoMenuSelection = 0;␊
1590 }␊
1591␉␉␉␊
1592␉␉␉if(gui.menu.draw)␊
1593␉␉␉␉drawInfoMenuItems();␊
1594␉␉␉␊
1595#if DEBUG_GUI␊
1596 gui.debug.cursor = pos( 10, 100);␊
1597 dprintf( &gui.screen, "label %s\n", param->label );␊
1598 dprintf( &gui.screen, "biosdev 0x%x\n", param->biosdev );␊
1599 dprintf( &gui.screen, "width %d\n", gui.screen.width);␊
1600 dprintf( &gui.screen, "height %d\n", gui.screen.height);␊
1601 dprintf( &gui.screen, "type 0x%x\n", param->type );␊
1602 dprintf( &gui.screen, "flags 0x%x\n", param->flags );␊
1603 dprintf( &gui.screen, "part_no %d\n", param->part_no );␊
1604 dprintf( &gui.screen, "part_boff 0x%x\n", param->part_boff );␊
1605 dprintf( &gui.screen, "part_type 0x%x\n", param->part_type );␊
1606 dprintf( &gui.screen, "bps 0x%x\n", param->bps );␊
1607 dprintf( &gui.screen, "name %s\n", param->name );␊
1608 dprintf( &gui.screen, "type_name %s\n", param->type_name );␊
1609 dprintf( &gui.screen, "modtime %d\n", param->modTime );␊
1610#endif␊
1611␉␉}␊
1612␉␉␊
1613␉␉drawDeviceIcon( param, gui.devicelist.pixmap, p, isSelected);␊
1614␉␉␊
1615␉␉if (gui.layout == HorizontalLayout)␊
1616␉␉{␊
1617␉␉␉p.x += images[iSelection].image->width + gui.devicelist.iconspacing; ␊
1618␉␉}␊
1619␉␉if (gui.layout == VerticalLayout)␊
1620␉␉{␊
1621␉␉␉p.y += ( images[iSelection].image->height + font_console.chars[0]->height + gui.devicelist.iconspacing ); ␊
1622␉␉}␊
1623␉}␊
1624␉␊
1625␉// draw prev indicator␊
1626␉if(start)␊
1627␉␉blend( images[iDeviceScrollPrev].image, gui.devicelist.pixmap, centeredAt( images[iDeviceScrollPrev].image, p_prev ) );␊
1628␉␊
1629␉// draw next indicator␊
1630␉if( end < devcnt - 1 )␊
1631␉␉blend( images[iDeviceScrollNext].image, gui.devicelist.pixmap, centeredAt( images[iDeviceScrollNext].image, p_next ) );␊
1632␉␊
1633␉gui.redraw = true;␊
1634␉␊
1635␉updateVRAM();␊
1636␉␊
1637}␊
1638␊
1639void clearGraphicBootPrompt()␊
1640{␊
1641␉// clear text buffer␊
1642␉prompt[0] = '\0';␊
1643␉prompt_pos=0;␊
1644␉␊
1645␉␊
1646␉if(␉gui.bootprompt.draw == true )␊
1647␉{␊
1648␉␉gui.bootprompt.draw = false;␊
1649␉␉gui.redraw = true;␊
1650␉␉// this causes extra frames to be drawn␊
1651␉␉//updateVRAM();␊
1652␉}␊
1653␉␊
1654␉return;␊
1655}␊
1656␊
1657void updateGraphicBootPrompt(int key)␊
1658{␊
1659␉if ( key == kBackspaceKey )␊
1660␉␉prompt[--prompt_pos] = '\0';␊
1661␉else ␊
1662␉{␊
1663␉␉prompt[prompt_pos] = key;␊
1664␉␉prompt_pos++;␊
1665␉␉prompt[prompt_pos] = '\0';␊
1666␉}␊
1667␉␊
1668␉fillPixmapWithColor( gui.bootprompt.pixmap, gui.bootprompt.bgcolor);␊
1669␉␊
1670␉makeRoundedCorners( gui.bootprompt.pixmap);␊
1671␉␊
1672␉position_t p_text = pos( gui.bootprompt.hborder , ( ( gui.bootprompt.height - font_console.chars[0]->height) ) / 2 );␊
1673␉␊
1674␉// print the boot prompt text␊
1675␉drawStr(prompt_text, &font_console, gui.bootprompt.pixmap, p_text);␊
1676␉␊
1677␉// get the position of the end of the boot prompt text to display user input␊
1678␉position_t p_prompt = pos( p_text.x + ( ( strlen(prompt_text) ) * font_console.chars[0]->width ), p_text.y );␊
1679␉␊
1680␉// calculate the position of the cursor␊
1681␉int␉offset = ( prompt_pos - ( ( gui.bootprompt.width / font_console.chars[0]->width ) - strlen(prompt_text) - 2 ) );␉␊
1682␉␊
1683␉if ( offset < 0)␊
1684␉␉offset = 0;␊
1685␉␊
1686␉drawStr( prompt+offset, &font_console, gui.bootprompt.pixmap, p_prompt);␊
1687␉␊
1688␉gui.menu.draw = false;␊
1689␉gui.bootprompt.draw = true;␊
1690␉gui.redraw = true;␊
1691␉␊
1692␉updateVRAM();␊
1693␉␊
1694␉return;␊
1695}␊
1696␊
1697␊
1698static inline␊
1699void vramwrite (void *data, int width)␊
1700{␊
1701␉if (VIDEO (depth) == 0x20 /*32*/ && VIDEO (rowBytes) == (unsigned long)gui.backbuffer->width * 4)␊
1702␉␉memcpy((uint8_t *)vram, gui.backbuffer->pixels, VIDEO (rowBytes)*VIDEO (height));␊
1703␉else␊
1704␉{␊
1705␉␉uint32_t r, g, b;␊
1706␉␉uint32_t i, j;␊
1707␉␉for (i = 0; i < VIDEO (height); i++)␊
1708␉␉␉for (j = 0; j < VIDEO (width); j++)␊
1709␉␉␉{␊
1710␉␉␉␉b = ((uint8_t *) data)[4*i*width + 4*j];␊
1711␉␉␉␉g = ((uint8_t *) data)[4*i*width + 4*j + 1];␊
1712␉␉␉␉r = ((uint8_t *) data)[4*i*width + 4*j + 2];␊
1713␉␉␉␉switch (VIDEO (depth))␊
1714␉␉␉␉{␊
1715␉␉␉␉␉case 32:␊
1716␉␉␉␉␉␉*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*4) = (b&0xff) | ((g&0xff)<<8) | ((r&0xff)<<16);␊
1717␉␉␉␉␉␉break;␊
1718␉␉␉␉␉case 24:␊
1719␉␉␉␉␉␉*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*3) = ((*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*3))&0xff000000)␊
1720␉␉␉␉␉␉| (b&0xff) | ((g&0xff)<<8) | ((r&0xff)<<16);␊
1721␉␉␉␉␉␉break;␊
1722␉␉␉␉␉case 16:␊
1723␉␉␉␉␉␉// Somehow 16-bit is always 15-bits really␊
1724␉␉␉␉␉␉//␉␉␉␉␉␉*(uint16_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*2) = ((b&0xf8)>>3) | ((g&0xfc)<<3) | ((r&0xf8)<<8);␊
1725␉␉␉␉␉␉//␉␉␉␉␉␉break;␉␉␉␉␉␉␉␊
1726␉␉␉␉␉case 15:␊
1727␉␉␉␉␉␉*(uint16_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*2) = ((b&0xf8)>>3) | ((g&0xf8)<<2) | ((r&0xf8)<<7);␊
1728␉␉␉␉␉␉break;␉␊
1729␉␉␉␉␉default:␊
1730␉␉␉␉␉␉break;␊
1731␉␉␉␉}␊
1732␉␉␉}␊
1733␉}␊
1734}␊
1735␊
1736void updateVRAM()␊
1737{␊
1738␉if (gui.redraw)␊
1739␉{␊
1740␉␉if (gui.devicelist.draw)␊
1741␉␉␉blend( gui.devicelist.pixmap, gui.backbuffer, gui.devicelist.pos );␊
1742␉␉␊
1743␉␉if (gui.bootprompt.draw)␊
1744␉␉␉blend( gui.bootprompt.pixmap, gui.backbuffer, gui.bootprompt.pos );␊
1745␉␉␊
1746␉␉if (gui.menu.draw)␊
1747␉␉␉blend( gui.menu.pixmap, gui.backbuffer, gui.menu.pos );␊
1748␉␉␊
1749␉␉if (gui.infobox.draw)␊
1750␉␉␉blend( gui.infobox.pixmap, gui.backbuffer, gui.infobox.pos );␊
1751␉}␊
1752␊
1753␉vramwrite ( gui.backbuffer->pixels, gui.backbuffer->width );␊
1754␊
1755␉if (gui.redraw)␊
1756␉{␊
1757␉␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
1758␉␉gui.redraw = false;␊
1759␉}␊
1760}␊
1761␊
1762static void␊
1763sputc(int c, struct putc_info * pi)␊
1764{␊
1765 if (pi->last_str)␊
1766 if (pi->str == pi->last_str) {␊
1767 *(pi->str) = '\0';␊
1768 return;␊
1769 }␊
1770 *(pi->str)++ = c;␊
1771}␊
1772␊
1773int gprintf( window_t * window, const char * fmt, ...)␊
1774{␊
1775␉char *formattedtext;␊
1776␉␊
1777␉va_list ap;␊
1778␉␊
1779␉struct putc_info pi;␊
1780␉␊
1781␉if ((formattedtext = malloc(1024)) != NULL) {␊
1782␉␉// format the text␊
1783␉␉va_start(ap, fmt);␊
1784␉␉pi.str = formattedtext;␊
1785␉␉pi.last_str = 0;␊
1786␉␉prf(fmt, ap, sputc, &pi);␊
1787␉␉*pi.str = '\0';␊
1788␉␉va_end(ap);␊
1789␉␉␊
1790␉␉position_t␉origin, cursor, bounds;␊
1791␉␉␊
1792␉␉int i;␊
1793␉␉int character;␊
1794␉␉␊
1795␉␉origin.x = MAX( window->cursor.x, window->hborder );␊
1796␉␉origin.y = MAX( window->cursor.y, window->vborder );␊
1797␉␉␊
1798␉␉bounds.x = ( window->width - window->hborder );␊
1799␉␉bounds.y = ( window->height - window->vborder );␊
1800␉␉␊
1801␉␉cursor = origin;␊
1802␉␉␊
1803␉␉font_t *font = &font_console;␊
1804␉␉␊
1805␉␉for( i=0; i< strlen(formattedtext); i++ )␊
1806␉␉{␊
1807␉␉␉character = formattedtext[i];␊
1808␉␉␉␊
1809␉␉␉character -= 32;␊
1810␉␉␉␊
1811␉␉␉// newline ?␊
1812␉␉␉if( formattedtext[i] == '\n' )␊
1813␉␉␉{␊
1814␉␉␉␉cursor.x = window->hborder;␊
1815␉␉␉␉cursor.y += font->height;␊
1816␉␉␉␉␊
1817␉␉␉␉if ( cursor.y > bounds.y )␊
1818␉␉␉␉␉cursor.y = origin.y;␊
1819␉␉␉␉␊
1820␉␉␉␉continue;␊
1821␉␉␉}␊
1822␉␉␉␊
1823␉␉␉// tab ?␊
1824␉␉␉if( formattedtext[i] == '\t' )␊
1825␉␉␉␉cursor.x += ( font->chars[0]->width * 5 );␊
1826␉␉␉␊
1827␉␉␉// draw the character␊
1828␉␉␉if( font->chars[character])␊
1829␉␉␉␉blend(font->chars[character], window->pixmap, cursor);␊
1830␉␉␉␊
1831␉␉␉cursor.x += font->chars[character]->width;␊
1832␉␉␉␊
1833␉␉␉// check x pos and do newline␊
1834␉␉␉if ( cursor.x > bounds.x )␊
1835␉␉␉{␊
1836␉␉␉␉cursor.x = origin.x;␊
1837␉␉␉␉cursor.y += font->height;␊
1838␉␉␉}␊
1839␉␉␉␊
1840␉␉␉// check y pos and reset to origin.y␊
1841␉␉␉if ( cursor.y > bounds.y )␊
1842␉␉␉␉cursor.y = origin.y;␊
1843␉␉}␊
1844␉␉␊
1845␉␉// update cursor postition␊
1846␉␉window->cursor = cursor;␊
1847␉␉␊
1848␉␉free(formattedtext);␊
1849␉␉␊
1850␉␉return 0;␊
1851␉␉␊
1852␉}␊
1853␉return 1;␊
1854}␊
1855#if DEBUG_GUI␊
1856static int dprintf( window_t * window, const char * fmt, ...)␊
1857{␊
1858␉char *formattedtext;␊
1859␉␊
1860␉va_list ap;␊
1861␉␊
1862␉//window = &gui.debug;␊
1863␉␊
1864␉struct putc_info pi;␊
1865␉␊
1866␉if ((formattedtext = malloc(1024)) != NULL) {␊
1867␉␉// format the text␊
1868␉␉va_start(ap, fmt);␊
1869␉␉pi.str = formattedtext;␊
1870␉␉pi.last_str = 0;␊
1871␉␉prf(fmt, ap, sputc, &pi);␊
1872␉␉*pi.str = '\0';␊
1873␉␉va_end(ap);␊
1874␉␉␊
1875␉␉position_t␉origin, cursor, bounds;␊
1876␉␉␊
1877␉␉int i;␊
1878␉␉int character;␊
1879␉␉␊
1880␉␉origin.x = MAX( gui.debug.cursor.x, window->hborder );␊
1881␉␉origin.y = MAX( gui.debug.cursor.y, window->vborder );␊
1882␉␉␊
1883␉␉bounds.x = ( window->width - window->hborder );␊
1884␉␉bounds.y = ( window->height - window->vborder );␊
1885␉␉␊
1886␉␉cursor = origin;␊
1887␉␉␊
1888␉␉font_t *font = &font_console;␊
1889␉␉␊
1890␉␉for( i=0; i< strlen(formattedtext); i++ )␊
1891␉␉{␊
1892␉␉␉character = formattedtext[i];␊
1893␉␉␉␊
1894␉␉␉character -= 32;␊
1895␉␉␉␊
1896␉␉␉// newline ?␊
1897␉␉␉if( formattedtext[i] == '\n' )␊
1898␉␉␉{␊
1899␉␉␉␉cursor.x = window->hborder;␊
1900␉␉␉␉cursor.y += font->height;␊
1901␉␉␉␉␊
1902␉␉␉␉if ( cursor.y > bounds.y )␊
1903␉␉␉␉␉cursor.y = origin.y;␊
1904␉␉␉␉␊
1905␉␉␉␉continue;␊
1906␉␉␉}␊
1907␉␉␉␊
1908␉␉␉// tab ?␊
1909␉␉␉if( formattedtext[i] == '\t' )␊
1910␉␉␉␉cursor.x += ( font->chars[0]->width * 5 );␊
1911␉␉␉␊
1912␉␉␉// draw the character␊
1913␉␉␉if( font->chars[character])␊
1914␉␉␉␉blend(font->chars[character], gui.backbuffer, cursor);␊
1915␉␉␉␊
1916␉␉␉cursor.x += font->chars[character]->width;␊
1917␉␉␉␊
1918␉␉␉// check x pos and do newline␊
1919␉␉␉if ( cursor.x > bounds.x )␊
1920␉␉␉{␊
1921␉␉␉␉cursor.x = origin.x;␊
1922␉␉␉␉cursor.y += font->height;␊
1923␉␉␉}␊
1924␉␉␉␊
1925␉␉␉// check y pos and reset to origin.y␊
1926␉␉␉if ( cursor.y > bounds.y )␊
1927␉␉␉␉cursor.y = origin.y;␊
1928␉␉}␊
1929␉␉␊
1930␉␉// update cursor postition␊
1931␉␉gui.debug.cursor = cursor;␊
1932␉␉␊
1933␉␉free(formattedtext);␊
1934␉␉␊
1935␉␉return 0;␊
1936␉␉␊
1937␉}␊
1938␉return 1;␊
1939}␊
1940#endif␊
1941int vprf(const char * fmt, va_list ap)␊
1942{␊
1943␉int i;␊
1944␉int character;␊
1945␉␊
1946␉char *formattedtext;␊
1947␉window_t *window = &gui.screen;␊
1948␉struct putc_info pi;␊
1949␉␊
1950␉position_t␉origin, cursor, bounds;␊
1951␉font_t *font = &font_console;␊
1952␉␊
1953␉if ((formattedtext = malloc(1024)) != NULL) {␊
1954␉␉// format the text␊
1955␉␉pi.str = formattedtext;␊
1956␉␉pi.last_str = 0;␊
1957␉␉prf(fmt, ap, sputc, &pi);␊
1958␉␉*pi.str = '\0';␊
1959␉␉␊
1960␉␉origin.x = MAX( window->cursor.x, window->hborder );␊
1961␉␉origin.y = MAX( window->cursor.y, window->vborder );␊
1962␉␉bounds.x = ( window->width - ( window->hborder * 2 ) );␊
1963␉␉bounds.y = ( window->height - ( window->vborder * 2 ) );␊
1964␉␉cursor = origin;␊
1965␉␉␊
1966␉␉for( i=0; i< strlen(formattedtext); i++ )␊
1967␉␉{␊
1968␉␉␉character = formattedtext[i];␊
1969␉␉␉character -= 32;␊
1970␉␉␉␊
1971␉␉␉// newline ?␊
1972␉␉␉if( formattedtext[i] == '\n' )␊
1973␉␉␉{␊
1974␉␉␉␉cursor.x = window->hborder;␊
1975␉␉␉␉cursor.y += font->height;␊
1976␉␉␉␉if ( cursor.y > bounds.y )␊
1977␉␉␉␉{␊
1978␉␉␉␉␉gui.redraw = true;␊
1979␉␉␉␉␉updateVRAM();␊
1980␉␉␉␉␉cursor.y = window->vborder;␊
1981␉␉␉␉}␊
1982␉␉␉␉window->cursor.y = cursor.y;␊
1983␉␉␉␉continue;␊
1984␉␉␉}␊
1985␉␉␉␊
1986␉␉␉// tab ?␊
1987␉␉␉if( formattedtext[i] == '\t' )␊
1988␉␉␉{␊
1989␉␉␉␉cursor.x = ( cursor.x / ( font->chars[0]->width * 8 ) + 1 ) * ( font->chars[0]->width * 8 );␊
1990␉␉␉␉continue;␊
1991␉␉␉}␊
1992␉␉␉cursor.x += font->chars[character]->width;␊
1993␉␉␉␊
1994␉␉␉// check x pos and do newline␊
1995␉␉␉if ( cursor.x > bounds.x )␊
1996␉␉␉{␊
1997␉␉␉␉cursor.x = origin.x;␊
1998␉␉␉␉cursor.y += font->height;␊
1999␉␉␉}␊
2000␉␉␉␊
2001␉␉␉// check y pos and reset to origin.y␊
2002␉␉␉if ( cursor.y > ( bounds.y + font->chars[0]->height) )␊
2003␉␉␉{␊
2004␉␉␉␉gui.redraw = true;␊
2005␉␉␉␉updateVRAM();␊
2006␉␉␉␉cursor.y = window->vborder;␊
2007␉␉␉}␊
2008␉␉␉// draw the character␊
2009␉␉␉if( font->chars[character])␊
2010␉␉␉␉blend(font->chars[character], gui.backbuffer, cursor);␊
2011␉␉}␊
2012␉␉// save cursor postition␊
2013␉␉window->cursor.x = cursor.x;␊
2014␉␉updateVRAM();␊
2015␉␉free(formattedtext);␊
2016␉␉return 0;␊
2017␉}␊
2018␉return 1;␊
2019}␊
2020␊
2021pixmap_t* charToPixmap(unsigned char ch, font_t *font) {␊
2022␉unsigned int cha = (unsigned int)ch - 32;␊
2023␉if (cha >= font->count)␊
2024␉␉// return ? if the font for the char doesn't exists␊
2025␉␉cha = '?' - 32;␊
2026␉return font->chars[cha] ? font->chars[cha] : NULL;␊
2027}␊
2028␊
2029static position_t drawChar(unsigned char ch, font_t *font, pixmap_t *blendInto, position_t p) {␊
2030␉pixmap_t* pm = charToPixmap(ch, font);␊
2031␉if (pm && ((p.x + pm->width) < blendInto->width))␊
2032␉{␊
2033␉␉blend(pm, blendInto, p);␊
2034␉␉return pos(p.x + pm->width, p.y);␊
2035␉}␊
2036␉else␊
2037␉␉return p;␊
2038}␊
2039␊
2040static void drawStr(char *ch, font_t *font, pixmap_t *blendInto, position_t p)␊
2041{␊
2042␉int i=0;␊
2043␉position_t current_pos = pos(p.x, p.y);␊
2044␉␊
2045␉for (i=0; i < strlen(ch); i++)␊
2046␉{␉␉␊
2047␉␉// newline ?␊
2048␉␉if ( ch[i] == '\n' )␊
2049␉␉{␊
2050␉␉␉current_pos.x = p.x;␊
2051␉␉␉current_pos.y += font->height;␊
2052␉␉␉continue;␊
2053␉␉}␊
2054␉␉␊
2055␉␉// tab ?␊
2056␉␉if ( ch[i] == '\t' )␊
2057␉␉{␊
2058␉␉␉current_pos.x += TAB_PIXELS_WIDTH;␊
2059␉␉␉continue;␊
2060␉␉}␉␉␉␊
2061␉␉␊
2062␉␉current_pos = drawChar(ch[i], font, blendInto, current_pos);␊
2063␉}␊
2064}␊
2065␊
2066static void drawStrCenteredAt(char *text, font_t *font, pixmap_t *blendInto, position_t p)␊
2067{␊
2068␉int i = 0;␊
2069␉int width = 0;␊
2070␉int max_width = 0;␊
2071␉int height = font->height;␊
2072␉␊
2073␉// calculate the width in pixels␊
2074␉for (i=0; i < strlen(text); i++) {␊
2075␉␉if (text[i] == '\n')␊
2076␉␉{␊
2077␉␉␉width = 0;␊
2078␉␉␉height += font->height;␊
2079␉␉}␊
2080␉␉else if (text[i] == '\t')␊
2081␉␉␉width += TAB_PIXELS_WIDTH;␊
2082␉␉else␊
2083␉␉{␊
2084␉␉␉pixmap_t* pm = charToPixmap(text[i], font);␊
2085␉␉␉if (pm)␊
2086␉␉␉␉width += pm->width;␊
2087␉␉}␊
2088␉␉if (width > max_width)␊
2089␉␉␉max_width = width;␊
2090␉}␊
2091␉␊
2092␉p.x = ( p.x - ( max_width / 2 ) );␊
2093␉p.y = ( p.y - ( height / 2 ) );␊
2094␉␊
2095␉drawStr(text, font, blendInto, p);␉␊
2096}␊
2097␊
2098static int destroyFont(font_t *font)␊
2099{␊
2100␉int i;␊
2101 for (i = 0; i < CHARACTERS_COUNT; i++)␊
2102 {␊
2103␉␉if (font->chars[i])␊
2104␉␉{␊
2105␉␉␉if (font->chars[i]->pixels) free (font->chars[i]->pixels);␊
2106␉␉␉free (font->chars[i]);␊
2107␉␉␉font->chars[i] = 0;␊
2108␉␉}␊
2109 }␊
2110 return 0;␊
2111}␊
2112␊
2113static int initFont(font_t *font, image_t *data)␊
2114{␊
2115␉unsigned int x = 0, y = 0, x2 = 0, x3 = 0;␊
2116␉␊
2117␉int start = 0, end = 0, count = 0, space = 0;␊
2118␉␊
2119␉bool monospaced = false;␊
2120␉␊
2121␉font->height = data->image->height;␉␊
2122␉␊
2123␉for( x = 0; x < data->image->width && count < CHARACTERS_COUNT; x++)␊
2124␉{␊
2125␉␉start = end;␊
2126␉␉␊
2127␉␉// if the pixel is red we've reached the end of the char␊
2128␉␉if( pixel( data->image, x, 0 ).value == 0xFFFF0000)␊
2129␉␉{␊
2130␉␉␉end = x + 1;␊
2131␉␉␉␊
2132␉␉␉if( (font->chars[count] = malloc(sizeof(pixmap_t)) ) )␊
2133␉␉␉{␊
2134␉␉␉␉font->chars[count]->width = ( end - start) - 1;␊
2135␉␉␉␉font->chars[count]->height = font->height;␊
2136␉␉␉␉{␊
2137 int pixels_size = (font->chars[count]->width * data->image->height * 4);␊
2138 ␊
2139 if (!(pixels_size > 0))␊
2140 {␊
2141 continue;␊
2142 }␊
2143 ␊
2144 if ( !( font->chars[count]->pixels = malloc( pixels_size ) ) )␊
2145 {␊
2146 continue;␊
2147 } ␊
2148␊
2149␉␉␉␉␉space += pixels_size;␊
2150 }␊
2151␉␉␉␉// we skip the first line because there are just the red pixels for the char width␊
2152 for( y = 1; y< (font->height); y++)␊
2153 {␊
2154 for( x2 = (unsigned)start, x3 = 0; x2 < (unsigned)end; x2++, x3++)␊
2155 {␊
2156 pixel( font->chars[count], x3, y ) = pixel( data->image, x2, y );␊
2157 }␉␊
2158 }␊
2159 ␊
2160 // check if font is monospaced␊
2161 if( ( count > 0 ) && ( font->width != font->chars[count]->width ) )␊
2162 monospaced = true;␊
2163 ␊
2164 font->width = font->chars[count]->width;␊
2165 ␊
2166 count++;␉␊
2167␉␉␉␉␊
2168␉␉␉}␊
2169␉␉}␊
2170␉}␊
2171␉␊
2172␉for (x = count; x < CHARACTERS_COUNT; x++)␊
2173␉␉font->chars[x] = NULL;␊
2174␉␊
2175␉if(monospaced)␊
2176␉␉font->width = 0;␊
2177␉␊
2178␉font->count = count;␊
2179␉␊
2180␉return 0;␊
2181}␊
2182␊
2183static void colorFont(font_t *font, uint32_t color)␊
2184{␊
2185␉if( !color )␊
2186␉␉return;␊
2187␉␊
2188␉int x, y, width, height;␊
2189␉int count = 0;␊
2190␉pixel_t *buff;␊
2191␉␊
2192␉while( font->chars[count++] )␊
2193␉{␊
2194␉␉width = font->chars[count-1]->width;␊
2195␉␉height = font->chars[count-1]->height;␊
2196␉␉for( y = 0; y < height; y++ )␊
2197␉␉{␊
2198␉␉␉for( x = 0; x < width; x++ )␊
2199␉␉␉{␊
2200␉␉␉␉buff = &(pixel( font->chars[count-1], x, y ));␊
2201␉␉␉␉if( buff->ch.a )␊
2202␉␉␉␉{␊
2203␉␉␉␉␉buff->ch.r = (color & 0xFFFF0000) >> 16;␊
2204␉␉␉␉␉buff->ch.g = (color & 0xFF00FF00) >> 8;␊
2205␉␉␉␉␉buff->ch.b = (color & 0xFF0000FF);␊
2206␉␉␉␉}␊
2207␉␉␉}␊
2208␉␉}␊
2209␉}␊
2210}␊
2211␊
2212static void makeRoundedCorners(pixmap_t *p)␊
2213{␊
2214␉int x,y;␊
2215␉int width=p->width-1;␊
2216␉int height=p->height-1;␊
2217␉␊
2218␉// 10px rounded corner alpha values␊
2219␉uint8_t roundedCorner[10][10] =␊
2220␉{␊
2221␉␉{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x80, 0xC0, 0xFF},␊
2222␉␉{ 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF},␊
2223␉␉{ 0x00, 0x00, 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
2224␉␉{ 0x00, 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
2225␉␉{ 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
2226␉␉{ 0x00, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
2227␉␉{ 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
2228␉␉{ 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
2229␉␉{ 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
2230␉␉{ 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}␊
2231␉};␊
2232␉␊
2233␉uint8_t alpha=0;␊
2234␉␊
2235␉for( y=0; y<10; y++)␊
2236␉{␊
2237␉␉for( x=0; x<10; x++)␊
2238␉␉{␊
2239␉␉␉// skip if the pixel should be visible␊
2240␉␉␉if(roundedCorner[y][x] != 0xFF) ␊
2241␉␉␉{ ␊
2242␉␉␉␉alpha = ( roundedCorner[y][x] ? (uint8_t) (roundedCorner[y][x] * pixel(p, x, y).ch.a) / 255 : 0 );␊
2243␉␉␉␉// Upper left corner␊
2244␉␉␉␉pixel(p, x, y).ch.a = alpha;␊
2245␉␉␉␉␊
2246␉␉␉␉// upper right corner␊
2247␉␉␉␉pixel(p, width-x,y).ch.a = alpha;␊
2248␉␉␉␉␊
2249␉␉␉␉// lower left corner␊
2250␉␉␉␉pixel(p, x, height-y).ch.a = alpha;␊
2251␉␉␉␉␊
2252␉␉␉␉// lower right corner␊
2253␉␉␉␉pixel(p, width-x, height-y).ch.a = alpha;␊
2254␉␉␉}␊
2255␉␉}␊
2256␉}␊
2257}␊
2258␊
2259void showInfoBox(char *title, char *text)␊
2260{␊
2261␉int i, key, lines, visiblelines;␊
2262␉␊
2263␉int currentline=0;␊
2264␉int cnt=0;␊
2265␉int offset=0;␊
2266␉␊
2267␉if( !title || !text )␊
2268␉␉return;␊
2269␉␊
2270␉position_t pos_title = pos ( gui.infobox.vborder, gui.infobox.vborder );␊
2271␉␊
2272␉// calculate number of lines in the title␊
2273␉for ( i = 0, lines = 1; i<strlen(title); i++ )␊
2274␉␉if( title[i] == '\n')␊
2275␉␉␉lines++;␊
2276␉␊
2277␉// y position of text is lines in title * height of font␊
2278␉position_t pos_text = pos( pos_title.x , pos_title.y + ( font_console.height * lines ));␊
2279␉␊
2280␉// calculate number of lines in the text␊
2281␉for ( i=0, lines = 1; i<strlen(text); i++ )␊
2282␉␉if( text[i] == '\n')␊
2283␉␉␉lines++;␊
2284␉␊
2285␉// if text ends with \n strip off␊
2286␉if( text[i] == '\n' || text[i] == '\0')␊
2287␉␉lines--;␊
2288␉␊
2289␉visiblelines = ( ( gui.infobox.height - ( gui.infobox.vborder * 2 ) ) / font_console.height ) - 1;␊
2290␉␊
2291␉// lets display the text and allow scroll thru using up down / arrows␊
2292␉while(1)␊
2293␉{␊
2294␉␉// move to current line in text␊
2295␉␉for( offset = 0, i = 0; offset < strlen(text); offset++ )␊
2296␉␉{␊
2297␉␉␉if( currentline == i)␊
2298␉␉␉␉break;␊
2299␉␉␉if( text[offset] =='\n')␊
2300␉␉␉␉i++;␊
2301␉␉}␊
2302␉␉␊
2303␉␉// find last visible line in text and place \0␊
2304␉␉for( i = offset, cnt = 0; i < strlen(text); i++)␊
2305␉␉{␊
2306␉␉␉if(text[i]=='\n')␊
2307␉␉␉␉cnt++;␊
2308␉␉␉if ( cnt == visiblelines )␊
2309␉␉␉{␊
2310␉␉␉␉text[i]='\0';␊
2311␉␉␉␉break;␊
2312␉␉␉}␊
2313␉␉}␊
2314␉␉␊
2315␉␉fillPixmapWithColor( gui.infobox.pixmap, gui.infobox.bgcolor);␊
2316␉␉␊
2317␉␉makeRoundedCorners( gui.infobox.pixmap);␊
2318␉␉␊
2319␉␉// print the title if present␊
2320␉␉if( title )␊
2321␉␉␉drawStr(title, &font_console, gui.infobox.pixmap, pos_title);␊
2322␉␉␊
2323␉␉// print the text␊
2324␉␉drawStr( text + offset, &font_console, gui.infobox.pixmap, pos_text);␊
2325␉␉␊
2326␉␉// restore \n in text␊
2327␉␉if ( cnt == visiblelines )␊
2328␉␉␉text[i] = '\n';␊
2329␉␉␊
2330␉␉position_t pos_indicator = pos( gui.infobox.width - ( images[iTextScrollPrev].image->width - ( gui.infobox.vborder / 2) ), pos_text.y );␊
2331␉␉␊
2332␉␉// draw prev indicator␊
2333␉␉if(offset)␊
2334␉␉{␊
2335␉␉␉blend( images[iTextScrollPrev].image, gui.infobox.pixmap, centeredAt( images[iTextScrollPrev].image, pos_indicator ));␊
2336␉␉}␊
2337␉␉␊
2338␉␉// draw next indicator␊
2339␉␉if( lines > ( currentline + visiblelines ) )␊
2340␉␉{␊
2341␉␉␉pos_indicator.y = ( gui.infobox.height - ( ( images[iTextScrollNext].image->width + gui.infobox.vborder ) / 2 ) );␊
2342␉␉␉blend( images[iTextScrollNext].image, gui.infobox.pixmap, centeredAt( images[iTextScrollNext].image, pos_indicator ) );␊
2343␉␉}␊
2344␉␉␊
2345␉␉gui.bootprompt.draw = false;␊
2346␉␉gui.infobox.draw = true;␊
2347␉␉gui.redraw = true;␊
2348␉␉␊
2349␉␉updateVRAM();␊
2350␉␉␊
2351␉␉key = getc();␊
2352␉␉␊
2353␉␉if( key == kUpArrowkey )␊
2354␉␉␉if( currentline > 0 )␊
2355␉␉␉␉currentline--;␊
2356␉␉␊
2357␉␉if( key == kDownArrowkey )␊
2358␉␉␉if( lines > ( currentline + visiblelines ) )␊
2359␉␉␉␉currentline++;␊
2360␉␉␊
2361␉␉if( key == kEscapeKey || key == 'q' || key == 'Q')␊
2362␉␉{␊
2363␉␉␉gui.infobox.draw = false;␊
2364␉␉␉gui.redraw = true;␊
2365␉␉␉updateVRAM();␊
2366␉␉␉break;␊
2367␉␉}␊
2368␉}␊
2369}␊
2370␊
2371static void animateProgressBar()␊
2372{␊
2373␉int y;␊
2374␉␊
2375␉if( time18() > (unsigned) lasttime)␊
2376␉{␊
2377␉␉lasttime = time18();␊
2378␉␉␊
2379␉␉pixmap_t *buffBar = images[iProgressBar].image;␊
2380␉␉␊
2381␉␉uint32_t buff = buffBar->pixels[0].value;␊
2382␉␉␊
2383␉␉memcpy( buffBar->pixels, buffBar->pixels + 1, ( (buffBar->width*buffBar->height) - 1 ) * 4 );␊
2384␉␉␊
2385␉␉for( y = buffBar->height - 1; y > 0; y--)␊
2386␉␉␉pixel(buffBar, buffBar->width - 1, y) = pixel(buffBar, buffBar->width - 1, y - 1);␊
2387␉␉␊
2388␉␉pixel(buffBar, buffBar->width-1, 0).value = buff;␊
2389␉}␊
2390}␊
2391␊
2392static void drawProgressBar(pixmap_t *blendInto, uint16_t width, position_t p, uint8_t progress)␊
2393{␊
2394␉if(progress>100)␊
2395␉␉return;␊
2396␉␊
2397␉p.x = ( p.x - ( width / 2 ) );␊
2398␉␊
2399␉int todraw = (width * progress) / 100;␊
2400␉␊
2401␉pixmap_t *buff = images[iProgressBar].image;␊
2402␉pixmap_t *buffBG = images[iProgressBarBackground].image;␊
2403␉if(!buff || !buffBG)␊
2404␉␉return;␊
2405␉␊
2406␉pixmap_t progressbar;␊
2407␉progressbar.pixels=malloc(width * 4 * buff->height);␊
2408␉if(!progressbar.pixels)␊
2409␉␉return; ␊
2410␉␊
2411␉progressbar.width = width;␊
2412␉progressbar.height = buff->height;␊
2413␉␊
2414␉int x,x2,y;␊
2415␉␊
2416␉for(y=0; y<buff->height; y++)␊
2417␉{␊
2418␉␉for(x=0,x2=0; x<todraw; x++, x2++)␊
2419␉␉{␊
2420␉␉␉if(x2 == (buff->width-1)) x2=0;␊
2421␉␉␉pixel(&progressbar, x,y).value = pixel(buff, x2,y).value;␊
2422␉␉}␊
2423␉}␊
2424␉␊
2425␉for(y=0; y<buff->height; y++)␊
2426␉{␊
2427␉␉for(x=todraw, x2 = 0; x < width - 1; x++, x2++)␊
2428␉␉{␊
2429␉␉␉if(x2 == (buffBG->width -2 )) x2 = 0;␊
2430␉␉␉pixel(&progressbar, x,y).value = pixel(buffBG, x2,y).value;␊
2431␉␉}␊
2432␉␉if(progress < 100)␊
2433␉␉␉pixel(&progressbar, width - 1, y).value = pixel(buffBG, buffBG->width - 1, y).value;␊
2434␉␉if(progress == 0)␊
2435␉␉␉pixel(&progressbar, 0, y).value = pixel(buffBG, buffBG->width - 1, y).value;␊
2436␉}␊
2437␉␊
2438␉blend(&progressbar, blendInto, p);␊
2439␉animateProgressBar();␊
2440␉free(progressbar.pixels);␊
2441}␊
2442␊
2443static void drawInfoMenuItems()␊
2444{␊
2445␉int i,n;␊
2446␉␊
2447␉position_t position;␊
2448␉␊
2449␉pixmap_t *selection = images[iMenuSelection].image;␊
2450␉␊
2451␉pixmap_t *pbuff;␊
2452␉␊
2453␉fillPixmapWithColor(gui.menu.pixmap, gui.menu.bgcolor);␊
2454␉␊
2455␉makeRoundedCorners(gui.menu.pixmap);␊
2456␉␊
2457␉uint8_t offset = infoMenuNativeBoot ? 0 : infoMenuItemsCount - 1;␊
2458␉␊
2459␉position = pos(0,0);␊
2460␉␊
2461␉for ( i = 0, n = iMenuBoot; i < infoMenuItemsCount; i++, n++)␊
2462␉{␊
2463␉␉if (i == infoMenuSelection)␊
2464␉␉{␊
2465␉␉␉blend(selection, gui.menu.pixmap, position);␊
2466␉␉}␊
2467␉␉␊
2468␉␉pbuff = images[n].image;␊
2469␉␉if (offset && i >= INFOMENU_NATIVEBOOT_START && i <= INFOMENU_NATIVEBOOT_END)␊
2470␉␉{␊
2471␉␉␉blend( images[n + (iMenuHelp - iMenuBoot)].image , gui.menu.pixmap, ␊
2472␉␉␉␉ pos((position.x + (gui.menu.hborder / 2)), position.y + ((selection->height - pbuff->height) / 2)));␊
2473␉␉}␊
2474␉␉else␊
2475␉␉{␊
2476␉␉␉blend( pbuff, gui.menu.pixmap, ␊
2477␉␉␉␉ pos((position.x + (gui.menu.hborder / 2)), position.y + ((selection->height - pbuff->height) / 2)));␊
2478␉␉}␊
2479␉␉␊
2480␉␉drawStr(infoMenuItems[i].text, &font_console, gui.menu.pixmap, ␊
2481␉␉␉␉pos(position.x + (pbuff->width + gui.menu.hborder), ␊
2482␉␉␉␉␉position.y + ((selection->height - font_console.height) / 2)));␊
2483␉␉position.y += images[iMenuSelection].image->height;␊
2484␉␉␊
2485␉}␊
2486␉␊
2487␉gui.redraw = true;␊
2488}␊
2489␊
2490int drawInfoMenu()␊
2491{␊
2492␉drawInfoMenuItems();␊
2493␉␊
2494␉gui.menu.draw = true;␊
2495␉␊
2496␉updateVRAM();␊
2497␉␊
2498␉return 1;␊
2499}␊
2500␊
2501int updateInfoMenu(int key)␊
2502{␊
2503␉switch (key)␊
2504␉{␊
2505␉␉␉␊
2506␉␉case kUpArrowkey:␉// up arrow␊
2507␉␉␉if (infoMenuSelection > 0)␊
2508␉␉␉{␊
2509␉␉␉␉if(!infoMenuNativeBoot && infoMenuSelection == INFOMENU_NATIVEBOOT_END + 1)␊
2510␉␉␉␉{␊
2511␉␉␉␉␉infoMenuSelection -= 4;␊
2512␉␉␉␉}␊
2513␉␉␉␉else␊
2514␉␉␉␉{␊
2515␉␉␉␉␉infoMenuSelection--;␊
2516␉␉␉␉}␊
2517␉␉␉␉drawInfoMenuItems();␊
2518␉␉␉␉updateVRAM();␊
2519␉␉␉␉␊
2520␉␉␉} ␊
2521␉␉␉else ␊
2522␉␉␉{␊
2523␉␉␉␉␊
2524␉␉␉␉gui.menu.draw = false;␊
2525␉␉␉␉gui.redraw = true;␊
2526␉␉␉␉␊
2527␉␉␉␉updateVRAM();␊
2528␉␉␉␉␊
2529␉␉␉␉return CLOSE_INFO_MENU;␊
2530␉␉␉}␊
2531␉␉␉break;␊
2532␉␉␉␊
2533␉␉case kDownArrowkey:␉// down arrow␊
2534␉␉␉if (infoMenuSelection < infoMenuItemsCount - 1)␊
2535␉␉␉{␊
2536␉␉␉␉if(!infoMenuNativeBoot && infoMenuSelection == INFOMENU_NATIVEBOOT_START - 1)␊
2537␉␉␉␉␉infoMenuSelection += 4;␊
2538␉␉␉␉else␊
2539␉␉␉␉␉infoMenuSelection++;␊
2540␉␉␉␉drawInfoMenuItems();␊
2541␉␉␉␉updateVRAM();␊
2542␉␉␉}␊
2543␉␉␉break;␊
2544␉␉␉␊
2545␉␉case kReturnKey:␊
2546␉␉␉if( infoMenuSelection == MENU_SHOW_MEMORY_INFO )␊
2547␉␉␉␉showInfoBox( "Memory Info. Press q to quit.\n", getMemoryInfoString());␊
2548␉␉␉␊
2549␉␉␉else if( infoMenuSelection == MENU_SHOW_VIDEO_INFO )␊
2550␉␉␉␉showInfoBox( getVBEInfoString(), getVBEModeInfoString() );␊
2551␉␉␉␊
2552␉␉␉else if( infoMenuSelection == MENU_SHOW_HELP )␊
2553␉␉␉␉showHelp();␊
2554␉␉␉␊
2555␉␉␉else␊
2556␉␉␉{␊
2557␉␉␉␉int buff = infoMenuSelection;␊
2558␉␉␉␉infoMenuSelection = 0;␊
2559␉␉␉␉return buff;␊
2560␉␉␉}␊
2561␉␉␉break;␊
2562␉␉default:␊
2563␉␉␉break;␊
2564␉}␊
2565␉return DO_NOT_BOOT;␊
2566}␊
2567␊
2568uint16_t bootImageWidth = 0; ␊
2569uint16_t bootImageHeight = 0; ␊
2570uint8_t *bootImageData = NULL; ␊
2571static bool usePngImage = false;␊
2572␊
2573//==========================================================================␊
2574// loadBootGraphics␊
2575static void loadBootGraphics(char *src)␊
2576{␊
2577␉if (bootImageData != NULL) {␊
2578␉␉return;␊
2579␉}␊
2580␉␊
2581␉char dirspec[256];␊
2582␉␊
2583␉if ((unsigned)(strlen(theme_name) + 34) > sizeof(dirspec)) {␊
2584␉␉usePngImage = false; ␊
2585␉␉return;␊
2586␉}␊
2587␉sprintf(dirspec, "%s/%s/boot.png", src, theme_name);␊
2588␉if (strlen(theme_name) == 0 || loadPngImage(dirspec, &bootImageWidth, &bootImageHeight, &bootImageData) != 0) {␊
2589#ifdef EMBED_THEME␊
2590␉␉if ((loadEmbeddedPngImage(__boot_png, __boot_png_len, &bootImageWidth, &bootImageHeight, &bootImageData)) != 0)␊
2591#endif␊
2592␉␉␉usePngImage = false; ␊
2593␉}␊
2594}␊
2595␊
2596//==========================================================================␊
2597// drawBootGraphics␊
2598void drawBootGraphics(void)␊
2599{␊
2600␉int pos;␊
2601␉int length;␊
2602␉const char *dummyVal;␊
2603␉int oldScreenWidth, oldScreenHeight;␊
2604␉uint16_t x, y; ␊
2605␉bool legacy_logo = false;␊
2606␉getBoolForKey("Legacy Logo", &legacy_logo, DEFAULT_BOOT_CONFIG);␉␊
2607␉if (legacy_logo == false) {␊
2608␉␉usePngImage = true;␊
2609␉␉␊
2610␉␉if (bootImageData == NULL)␊
2611␉␉␉loadBootGraphics(dirsrc);␊
2612␉␉␊
2613␉}␉␉␊
2614␉␊
2615␉␊
2616␉if (execute_hook("getResolution_hook", &screen_params[0], &screen_params[1], &screen_params[2], NULL, NULL, NULL) != EFI_SUCCESS)␉␉␊
2617␉{␉␉␊
2618␉␉// parse screen size parameters␊
2619␉␉if (getIntForKey("boot_width", &pos, &themeConfig) && pos > 0) {␊
2620␉␉␉screen_params[0] = pos;␊
2621␉␉} else {␊
2622␉␉␉screen_params[0] = DEFAULT_SCREEN_WIDTH;␊
2623␉␉}␊
2624␉␉if (getIntForKey("boot_height", &pos, &themeConfig) && pos > 0) {␊
2625␉␉␉screen_params[1] = pos;␊
2626␉␉} else {␊
2627␉␉␉screen_params[1] = DEFAULT_SCREEN_HEIGHT;␊
2628␉␉}␊
2629␉}␉␊
2630␉␊
2631 // Save current screen resolution.␊
2632␉oldScreenWidth = gui.screen.width;␊
2633␉oldScreenHeight = gui.screen.height;␊
2634␉␊
2635␉gui.screen.width = screen_params[0];␊
2636␉gui.screen.height = screen_params[1];␊
2637␉␊
2638␉// find best matching vesa mode for our requested width & height␊
2639␉getGraphicModeParams(screen_params);␊
2640␉␊
2641 // Set graphics mode if the booter was in text mode or the screen resolution has changed.␊
2642␉if (getVideoMode() == VGA_TEXT_MODE␊
2643␉␉|| (screen_params[0] != (uint32_t)oldScreenWidth && screen_params[1] != (uint32_t)oldScreenHeight) )␊
2644␉{␊
2645␊
2646␉␉setVideoMode(GRAPHICS_MODE);␊
2647␊
2648␉}␊
2649␉␊
2650␉if (getValueForKey("-checkers", &dummyVal, &length, DEFAULT_BOOT_CONFIG)) {␊
2651␉␉drawCheckerBoard();␊
2652␉} else {␊
2653␉␉// Fill the background to 75% grey (same as BootX). ␊
2654␉␉drawColorRectangle(0, 0, screen_params[0], screen_params[1], 0x01); ␊
2655␉}␊
2656␉if ((bootImageData) && (usePngImage)) { ␊
2657␉␉x = (screen_params[0] - MIN(bootImageWidth, screen_params[0])) / 2; ␊
2658␉␉y = (screen_params[1] - MIN(bootImageHeight, screen_params[1])) / 2; ␊
2659␉␉␊
2660␉␉// Draw the image in the center of the display. ␊
2661␉␉blendImage(x, y, bootImageWidth, bootImageHeight, bootImageData); ␊
2662␉} else { ␊
2663␉␉uint8_t *appleBootPict; ␊
2664␉␉bootImageData = NULL; ␊
2665␉␉bootImageWidth = kAppleBootWidth; ␊
2666␉␉bootImageHeight = kAppleBootHeight; ␊
2667␉␉␊
2668␉␉// Prepare the data for the default Apple boot image. ␊
2669␉␉appleBootPict = (uint8_t *) decodeRLE(gAppleBootPictRLE, kAppleBootRLEBlocks, bootImageWidth * bootImageHeight); ␊
2670␉␉if (appleBootPict) { ␊
2671␉␉␉if (convertImage(bootImageWidth, bootImageHeight, appleBootPict, &bootImageData) == 0)␊
2672 {␊
2673 if (bootImageData) {␉␊
2674 x = (screen_params[0] - MIN(kAppleBootWidth, screen_params[0])) / 2; ␊
2675 y = (screen_params[1] - MIN(kAppleBootHeight, screen_params[1])) / 2; ␊
2676 drawDataRectangle(x, y, kAppleBootWidth, kAppleBootHeight, bootImageData);␊
2677 free(bootImageData);␊
2678 }␊
2679 }␉␉␉␊
2680␉␉␉free(appleBootPict); ␊
2681␉␉} ␊
2682␉} ␊
2683}␊
2684␊
2685int GUI_initGraphicsMode (void)␊
2686{␊
2687␉unsigned long params[4];␊
2688␉int count;␊
2689␉␊
2690␉params[3] = 0;␊
2691␉count = getNumberArrayFromProperty( kGraphicsModeKey, params, 4 );␊
2692␉␊
2693␉// Try to find a resolution if "Graphics Mode" setting is not available.␊
2694␉if ( count < 3 )␊
2695␉{␊
2696␉␉// Use the default resolution if we don't have an initialized GUI.␊
2697␉␉if (gui.screen.width == 0 || gui.screen.height == 0)␊
2698␉␉{␊
2699␉␉␉gui.screen.width = DEFAULT_SCREEN_WIDTH;␉␊
2700␉␉␉gui.screen.height = DEFAULT_SCREEN_HEIGHT;␊
2701␉␉}␊
2702␉␉␊
2703␉␉params[0] = gui.screen.width;␊
2704␉␉params[1] = gui.screen.height;␊
2705␉␉params[2] = 32;␊
2706␉}␊
2707␉␊
2708␉// Map from pixel format to bits per pixel.␊
2709␉␊
2710␉if ( params[2] == 256 ) params[2] = 8;␊
2711␉if ( params[2] == 555 ) params[2] = 16;␊
2712␉if ( params[2] == 888 ) params[2] = 32;␊
2713␉␊
2714␉return setVESAGraphicsMode( params[0], params[1], params[2] );␊
2715␊
2716}␊
2717␊
2718␊
2719int GUI_countdown( const char * msg, register int row, register int timeout , int *optionKey)␊
2720{␊
2721 register unsigned long time;␊
2722 int ch = 0;␊
2723 register int col = strlen(msg) + 1;␊
2724␉␊
2725 flushKeyboardBuffer();␊
2726␉␊
2727␉if( getVideoMode() == VGA_TEXT_MODE )␊
2728␉{␊
2729␉␉moveCursor( 0, row );␊
2730␉␉printf(msg);␊
2731␉␉␊
2732␉} else {␊
2733␉␉␊
2734␉␉position_t p = pos( gui.screen.width / 2 + 1 , ( gui.devicelist.pos.y + 3 ) + ( ( gui.devicelist.height - gui.devicelist.iconspacing ) / 2 ) );␊
2735␉␉␊
2736␉␉char dummy[80];␊
2737␉␉getBootVolumeDescription( ((BVRef)(uint32_t)get_env(envgBootVolume)), dummy, sizeof(dummy) - 1, true );␊
2738␉␉drawDeviceIcon( ((BVRef)(uint32_t)get_env(envgBootVolume)), gui.screen.pixmap, p, true );␊
2739␉␉drawStrCenteredAt( (char *) msg, &font_small, gui.screen.pixmap, gui.countdown.pos );␊
2740␉␉␊
2741␉␉// make this screen the new background␊
2742␉␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
2743␉␉␊
2744␉}␊
2745␉␊
2746␉int multi_buff = 18 * (timeout);␊
2747 int multi = ++multi_buff;␊
2748␉␊
2749 int lasttime=0;␊
2750␉␊
2751 for ( time = time18(), timeout++; timeout > 0; )␊
2752 {␊
2753␉␉␊
2754␉␉if( time18() > (unsigned)lasttime)␊
2755␉␉{␊
2756␉␉␉multi--; ␊
2757␉␉␉lasttime=time18();␊
2758␉␉}␉␉␊
2759␉␉␊
2760 if ((ch = readKeyboardStatus())){␊
2761 *optionKey = ch; ␊
2762 break;␊
2763␉␉}␊
2764␉␉␊
2765 // Count can be interrupted by holding down shift,␊
2766 // control or alt key␊
2767 if ( ( readKeyboardShiftFlags() & 0x0F ) != 0 )␊
2768␉␉{␊
2769 ch = 1;␊
2770 break;␊
2771 }␊
2772␉␉␊
2773 if ( time18() >= time )␊
2774 {␊
2775 time += 18;␊
2776 timeout--;␊
2777␉␉␉␊
2778␉␉␉if( getVideoMode() == VGA_TEXT_MODE )␊
2779␉␉␉{␊
2780␉␉␉␉moveCursor( col, row );␊
2781␉␉␉␉printf("(%d) ", timeout);␊
2782␉␉␉}␊
2783 }␊
2784␉␉␊
2785␉␉if( getVideoMode() == GRAPHICS_MODE )␊
2786␉␉{␊
2787␉␉␉drawProgressBar( gui.screen.pixmap, 100, gui.progressbar.pos , ( multi * 100 / multi_buff ) );␊
2788␉␉␉gui.redraw = true;␊
2789␉␉␉updateVRAM();␊
2790␉␉}␊
2791␉␉␊
2792 }␊
2793␉␊
2794 flushKeyboardBuffer();␊
2795␉␊
2796 return ch;␊
2797}␊
2798

Archive Download this file

Revision: 1972