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#include "gui.h"␊
16#include "appleboot.h"␊
17#include "vers.h"␊
18#include "modules.h"␊
19#include "rand.h"␊
20#include "sl.h"␊
21␊
22␊
23gui_t gui;␉␉␉␉␉// gui structure␊
24font_t font_small;␊
25font_t font_console;␊
26␊
27␊
28#define IMG_REQUIRED -1␊
29#define THEME_NAME_DEFAULT␉"Default"␊
30const char* theme_name = THEME_NAME_DEFAULT;␊
31␊
32char dirsrc[22];␊
33␊
34#ifdef EMBED_THEME␊
35#include "art.h"␊
36#endif␊
37␊
38static int loadThemeImage(char *src, const char *image, int alt_image);␊
39␊
40#define LOADPNG(src, img, alt_img) if (loadThemeImage(src, #img, alt_img) != 0) { return 1; }␊
41␊
42#ifndef MIN␊
43#define MIN(x, y) ((x) < (y) ? (x) : (y))␊
44#endif␊
45␊
46#ifndef MAX␊
47#define MAX(x, y) ((x) > (y) ? (x) : (y))␊
48#endif␊
49␊
50#define VIDEO(x) (bootArgs->Video.v_ ## x)␊
51␊
52#define vram VIDEO(baseAddr)␊
53␊
54int lasttime = 0; // we need this for animating maybe␊
55␊
56extern int gDeviceCount;␊
57␊
58/*␊
59 * ATTENTION: the enum and the following array images[] MUST match !!!␊
60 */␊
61enum {␊
62 iBackground = 0,␊
63 iLogo,␊
64␉␊
65 iDeviceGeneric,␊
66 iDeviceGeneric_o,␊
67 iDeviceHFS,␊
68 iDeviceHFS_o,␊
69 iDeviceHFSRAID,␊
70 iDeviceHFSRAID_o,␊
71 iDeviceEXT3,␊
72 iDeviceEXT3_o,␊
73␉iDeviceFreeBSD,␊
74 iDeviceFreeBSD_o,␊
75 iDeviceOpenBSD,␊
76 iDeviceOpenBSD_o,␊
77 iDeviceFAT,␊
78 iDeviceFAT_o,␊
79 iDeviceFAT16,␊
80 iDeviceFAT16_o,␊
81 iDeviceFAT32,␊
82 iDeviceFAT32_o,␊
83 iDeviceNTFS,␊
84 iDeviceNTFS_o,␊
85 iDeviceCDROM,␊
86 iDeviceCDROM_o,␊
87␉␊
88 iSelection,␊
89 iDeviceScrollPrev,␊
90 iDeviceScrollNext,␊
91␉␊
92 iMenuBoot,␊
93 iMenuVerbose,␊
94 iMenuIgnoreCaches,␊
95 iMenuSingleUser,␊
96 iMenuMemoryInfo,␊
97 iMenuVideoInfo,␊
98 iMenuHelp,␊
99 iMenuVerboseDisabled,␊
100 iMenuIgnoreCachesDisabled,␊
101 iMenuSingleUserDisabled,␊
102 iMenuSelection,␊
103␉␊
104 iProgressBar,␊
105 iProgressBarBackground,␊
106␉␊
107 iTextScrollPrev,␊
108 iTextScrollNext,␊
109␉␊
110 iFontConsole,␊
111 iFontSmall,␊
112};␊
113␊
114image_t images[] = {␊
115 {.name = "background", .image = NULL},␊
116 {.name = "logo", .image = NULL},␊
117 ␊
118 {.name = "device_generic", .image = NULL},␊
119 {.name = "device_generic_o", .image = NULL},␊
120 {.name = "device_hfsplus", .image = NULL},␊
121 {.name = "device_hfsplus_o", .image = NULL},␊
122 {.name = "device_hfsraid", .image = NULL},␊
123 {.name = "device_hfsraid_o", .image = NULL},␊
124 {.name = "device_ext3", .image = NULL},␊
125 {.name = "device_ext3_o", .image = NULL},␊
126␉{.name = "device_freebsd", .image = NULL},␊
127 {.name = "device_freebsd_o", .image = NULL},␊
128 {.name = "device_openbsd", .image = NULL},␊
129 {.name = "device_openbsd_o", .image = NULL},␊
130 {.name = "device_fat", .image = NULL},␊
131 {.name = "device_fat_o", .image = NULL},␊
132 {.name = "device_fat16", .image = NULL},␊
133 {.name = "device_fat16_o", .image = NULL},␊
134 {.name = "device_fat32", .image = NULL},␊
135 {.name = "device_fat32_o", .image = NULL},␊
136 {.name = "device_ntfs", .image = NULL},␊
137 {.name = "device_ntfs_o", .image = NULL},␊
138 {.name = "device_cdrom", .image = NULL},␊
139 {.name = "device_cdrom_o", .image = NULL},␊
140␉␊
141 {.name = "device_selection", .image = NULL},␊
142 {.name = "device_scroll_prev", .image = NULL},␊
143 {.name = "device_scroll_next", .image = NULL},␊
144 ␊
145 {.name = "menu_boot", .image = NULL},␊
146 {.name = "menu_verbose", .image = NULL},␊
147 {.name = "menu_ignore_caches", .image = NULL},␊
148 {.name = "menu_single_user", .image = NULL},␊
149 {.name = "menu_memory_info", .image = NULL},␊
150 {.name = "menu_video_info", .image = NULL},␊
151 {.name = "menu_help", .image = NULL},␊
152 {.name = "menu_verbose_disabled", .image = NULL},␊
153 {.name = "menu_ignore_caches_disabled", .image = NULL},␊
154 {.name = "menu_single_user_disabled", .image = NULL},␊
155 {.name = "menu_selection", .image = NULL},␊
156 ␊
157 {.name = "progress_bar", .image = NULL},␊
158 {.name = "progress_bar_background", .image = NULL},␊
159 ␊
160 {.name = "text_scroll_prev", .image = NULL},␊
161 {.name = "text_scroll_next", .image = NULL},␊
162 ␊
163 {.name = "font_console", .image = NULL},␊
164 {.name = "font_small", .image = NULL},␊
165};␊
166␊
167int imageCnt = 0;␊
168␊
169extern int␉gDeviceCount;␊
170extern int␉selectIndex;␊
171␊
172char prompt[BOOT_STRING_LEN];␊
173␊
174int prompt_pos=0;␊
175␊
176char prompt_text[] = "boot: ";␊
177␊
178menuitem_t infoMenuItems[] =␊
179{␊
180␉{ .text = "Boot" },␊
181␉{ .text = "Boot Verbose" },␊
182␉{ .text = "Boot Ignore Caches" },␊
183␉{ .text = "Boot Single User" },␊
184␉{ .text = "Memory Info" },␊
185␉{ .text = "Video Info" },␊
186␉{ .text = "Help" }␊
187};␊
188␊
189int initFont(font_t *font, image_t *image);␊
190void colorFont(font_t *font, uint32_t color);␊
191void makeRoundedCorners(pixmap_t *p);␊
192␊
193int infoMenuSelection = 0;␊
194int infoMenuItemsCount = sizeof(infoMenuItems)/sizeof(infoMenuItems[0]);␊
195␊
196bool infoMenuNativeBoot = false;␊
197␊
198unsigned long screen_params[4] = {DEFAULT_SCREEN_WIDTH, DEFAULT_SCREEN_HEIGHT, 32, 0};␉// here we store the used screen resolution␊
199␊
200int getImageIndexByName(const char *name)␊
201{␊
202 int i;␊
203␉for (i = 0; (unsigned)i < sizeof(images) / sizeof(images[0]); i++)␊
204␉{␊
205␉ if (strcmp(name, images[i].name) == 0)␊
206␉ return i; // found the name␊
207␉}␊
208␉return -1;␊
209}␊
210␊
211#ifdef EMBED_THEME␊
212static int getEmbeddedImageIndexByName(const char *name)␊
213{␊
214␉int upperLimit = sizeof(embeddedImages) / sizeof(embeddedImages[0]) - 1;␊
215␉int lowerLimit = 0;␊
216␉int compareIndex = (upperLimit - lowerLimit) >> 1; // Midpoint␊
217␉int result;␊
218␉␊
219␉// NOTE: This algorithm assumes that the embeddedImages is sorted.␊
220␉// This is currently done using the make file. If the array is every ␊
221␉// manualy generated, this *will* fail to work properly.␊
222␉while((result = strcmp(name, embeddedImages[compareIndex].name)) != 0)␊
223␉{␊
224␉␉if(result > 0)␉// We need to search a HIGHER index␊
225␉␉{␊
226␉␉␉if(compareIndex != lowerLimit)␊
227␉␉␉{␊
228␉␉␉␉lowerLimit = compareIndex;␊
229␉␉␉}␊
230␉␉␉else␊
231␉␉␉{␊
232␉␉␉␉return -1;␊
233␉␉␉}␊
234␉␉␉compareIndex = (upperLimit + lowerLimit + 1) >> 1;␉// Midpoint, round up␊
235␉␉}␊
236␉␉else // We Need to search a LOWER index␊
237␉␉{␊
238␉␉␉if(compareIndex != upperLimit)␊
239␉␉␉{␊
240␉␉␉␉upperLimit = compareIndex;␊
241␉␉␉}␊
242␉␉␉else␊
243␉␉␉{␊
244␉␉␉␉return -1;␊
245␉␉␉}␊
246␉␉␉compareIndex = (upperLimit + lowerLimit) >> 1;␉// Midpoint, round down␊
247␉␉}␊
248␉}␊
249␉return compareIndex;␊
250}␊
251#endif␊
252␊
253static int loadThemeImage(char* src, const char *image, int alt_image)␊
254{␊
255␉char␉␉dirspec[256];␊
256␉int ␉␉i;␊
257#ifdef EMBED_THEME␊
258␉int ␉␉e;␊
259#endif␊
260␉uint16_t␉width;␊
261␉uint16_t␉height;␊
262␉uint8_t␉␉*imagedata;␊
263␉if ((unsigned)(strlen(image) + strlen(theme_name) + 30 ) > sizeof(dirspec)) {␊
264␉␉return 1;␊
265␉}␊
266␉␊
267 if ((i = getImageIndexByName(image)) >= 0)␊
268 {␊
269 if (images[i].image == NULL) {␊
270 images[i].image = malloc(sizeof(pixmap_t));␊
271 }␊
272 sprintf(dirspec, "%s/%s/%s.png", src, theme_name, image);␊
273␊
274 width = 0;␊
275 height = 0;␊
276 imagedata = NULL;␊
277 if ( strlen(theme_name) > 0 && (loadPngImage(dirspec, &width, &height, &imagedata)) == 0)␊
278 {␊
279 images[i].image->width = width;␊
280 images[i].image->height = height;␊
281 images[i].image->pixels = (pixel_t *)imagedata;␊
282 flipRB(images[i].image);␊
283 return 0;␊
284 }␊
285#ifdef EMBED_THEME␊
286 else if ((e = getEmbeddedImageIndexByName(image)) >= 0)␊
287 {␊
288 unsigned char *embed_data;␊
289 unsigned int embed_size;␊
290 embed_data = embeddedImages[e].pngdata;␊
291 embed_size = *embeddedImages[e].length;␊
292␉␉␉␊
293 if (loadEmbeddedPngImage(embed_data, embed_size, &width, &height, &imagedata) == 0)␊
294 {␊
295 images[i].image->width = width;␊
296 images[i].image->height = height;␊
297 images[i].image->pixels = (pixel_t *)imagedata;␊
298 flipRB(images[i].image);␊
299 return 0;␊
300 }␊
301␉␉␉␊
302 return 0;␊
303 }␊
304#endif␊
305 else if (alt_image != IMG_REQUIRED && images[alt_image].image->pixels != NULL)␊
306 {␊
307 // Using the passed alternate image for non-mandatory images.␊
308 // We don't clone the already existing pixmap, but using its properties instead!␊
309 images[i].image->width = images[alt_image].image->width;␊
310 images[i].image->height = images[alt_image].image->height;␊
311 images[i].image->pixels = images[alt_image].image->pixels;␊
312 return 0;␊
313 }␊
314 else␊
315 {␊
316#ifndef EMBED_THEME␊
317 printf("ERROR: GUI: could not open '%s/%s.png'!\n", theme_name, image);␊
318␉␉␉sleep(2);␊
319#endif␊
320 return 1;␊
321 }␊
322 }␊
323␊
324␉return 1;␊
325}␊
326␊
327static int loadGraphics(char *src)␊
328{␊
329␉LOADPNG(src, background, IMG_REQUIRED);␊
330␊
331␉LOADPNG(src, logo, IMG_REQUIRED);␊
332␉␊
333␉LOADPNG(src, device_generic, IMG_REQUIRED);␊
334␉LOADPNG(src, device_generic_o, iDeviceGeneric);␊
335␉LOADPNG(src, device_hfsplus, iDeviceGeneric);␊
336␉LOADPNG(src, device_hfsplus_o, iDeviceHFS);␊
337␉LOADPNG(src, device_hfsraid, iDeviceGeneric);␊
338␉LOADPNG(src, device_hfsraid_o, iDeviceHFSRAID);␊
339␉LOADPNG(src, device_ext3, iDeviceGeneric);␊
340␉LOADPNG(src, device_ext3_o, iDeviceEXT3);␊
341␉LOADPNG(src, device_freebsd, iDeviceGeneric);␊
342␉LOADPNG(src, device_freebsd_o, iDeviceFreeBSD);␊
343␉LOADPNG(src, device_openbsd, iDeviceGeneric);␊
344␉LOADPNG(src, device_openbsd_o, iDeviceOpenBSD);␊
345␉LOADPNG(src, device_fat, iDeviceGeneric);␊
346␉LOADPNG(src, device_fat_o, iDeviceFAT);␊
347␉LOADPNG(src, device_fat16, iDeviceFAT);␊
348␉LOADPNG(src, device_fat16_o, iDeviceFAT_o);␊
349␉LOADPNG(src, device_fat32, iDeviceFAT);␊
350␉LOADPNG(src, device_fat32_o, iDeviceFAT_o);␊
351␉LOADPNG(src, device_ntfs, iDeviceGeneric);␊
352␉LOADPNG(src, device_ntfs_o, iDeviceNTFS);␊
353␉LOADPNG(src, device_cdrom, iDeviceGeneric);␊
354␉LOADPNG(src, device_cdrom_o, iDeviceCDROM);␊
355␉␊
356␉LOADPNG(src, device_selection, IMG_REQUIRED);␊
357␉LOADPNG(src, device_scroll_prev, IMG_REQUIRED);␊
358␉LOADPNG(src, device_scroll_next, IMG_REQUIRED);␊
359␉␊
360␉LOADPNG(src, menu_boot, IMG_REQUIRED);␊
361␉LOADPNG(src, menu_verbose, IMG_REQUIRED);␊
362␉LOADPNG(src, menu_ignore_caches, IMG_REQUIRED);␊
363␉LOADPNG(src, menu_single_user, IMG_REQUIRED);␊
364␉LOADPNG(src, menu_memory_info, IMG_REQUIRED);␊
365␉LOADPNG(src, menu_video_info, IMG_REQUIRED);␊
366␉LOADPNG(src, menu_help, IMG_REQUIRED);␊
367␉LOADPNG(src, menu_verbose_disabled, IMG_REQUIRED);␊
368␉LOADPNG(src, menu_ignore_caches_disabled, IMG_REQUIRED);␊
369␉LOADPNG(src, menu_single_user_disabled, IMG_REQUIRED);␊
370␉LOADPNG(src, menu_selection, IMG_REQUIRED);␊
371␉␊
372␉LOADPNG(src, progress_bar, IMG_REQUIRED);␊
373␉LOADPNG(src, progress_bar_background, IMG_REQUIRED);␊
374␉␊
375␉LOADPNG(src, text_scroll_prev, IMG_REQUIRED);␊
376␉LOADPNG(src, text_scroll_next, IMG_REQUIRED);␊
377␉␊
378␉LOADPNG(src, font_console, IMG_REQUIRED);␊
379␉LOADPNG(src, font_small, IMG_REQUIRED);␊
380␉␊
381␉initFont( &font_console, &images[iFontConsole]);␊
382␉initFont( &font_small, &images[iFontSmall]);␊
383␉␊
384␉return 0;␊
385}␊
386␊
387pixmap_t *getCroppedPixmapAtPosition( pixmap_t *from, position_t pos, uint16_t width, uint16_t height )␊
388{␊
389␉␊
390␉pixmap_t *cropped = malloc( sizeof( pixmap_t ) );␊
391␉if( !cropped )␊
392␉␉return 0;␊
393␉cropped->pixels = malloc( width * height * 4 );␊
394␉if ( !cropped->pixels )␊
395␉␉return 0;␊
396␉␊
397␉cropped->width = width;␊
398␉cropped->height = height;␊
399␉␊
400␉int destx = 0, desty = 0;␊
401␉int srcx = pos.x, srcy = pos.y;␊
402␉␊
403␉for( ; desty < height; desty++, srcy++)␊
404␉{␊
405␉␉for( destx = 0, srcx = pos.x; destx < width; destx++, srcx++ )␊
406␉␉{␊
407␉␉␉pixel( cropped, destx, desty ).value = pixel( from, srcx, srcy ).value;␊
408␉␉}␊
409␉}␊
410␉return cropped;␊
411}␊
412␊
413int createBackBuffer( window_t *window )␊
414{␊
415␉gui.backbuffer = malloc(sizeof(pixmap_t));␊
416␉if(!gui.backbuffer)␊
417␉␉return 1;␊
418␉␊
419␉gui.backbuffer->pixels = malloc( window->width * window->height * 4 );␊
420␉if(!gui.backbuffer->pixels)␊
421␉{␊
422␉␉free(gui.backbuffer);␊
423␉␉gui.backbuffer = 0;␊
424␉␉return 1;␊
425␉}␊
426␉␊
427␉gui.backbuffer->width = gui.screen.width;␊
428␉gui.backbuffer->height = gui.screen.height;␊
429␉␊
430␉return 0;␊
431}␊
432␊
433int createWindowBuffer( window_t *window )␊
434{␊
435␉window->pixmap = malloc(sizeof(pixmap_t));␊
436␉if(!window->pixmap)␊
437␉␉return 1;␊
438␉␊
439␉window->pixmap->pixels = malloc( window->width * window->height * 4 );␊
440␉if(!window->pixmap->pixels)␊
441␉{␊
442␉␉free(window->pixmap);␊
443␉␉window->pixmap = 0;␊
444␉␉return 1;␊
445␉}␊
446␉␊
447␉window->pixmap->width = window->width;␊
448␉window->pixmap->height = window->height;␊
449␉␊
450␉return 0;␊
451}␊
452␊
453int freeWindowBuffer( window_t *window )␊
454{␊
455␉if (window->pixmap && window->pixmap->pixels)␊
456 {␊
457␉␉free(window->pixmap->pixels);␊
458␉␉free(window->pixmap);␊
459␉␉return 0;␊
460␉}␊
461␉␊
462␉return 1;␊
463}␊
464␊
465void fillPixmapWithColor(pixmap_t *pm, uint32_t color)␊
466{␊
467␉int x,y;␊
468␉␊
469␉// fill with given color AARRGGBB␊
470␉for( x=0; x < pm->width; x++ )␊
471␉␉for( y=0; y< pm->height; y++)␊
472␉␉␉pixel(pm,x,y).value = color;␊
473}␊
474␊
475void drawBackground()␊
476{␊
477␉// reset text cursor␊
478␉gui.screen.cursor.x = gui.screen.hborder;␊
479␉gui.screen.cursor.y = gui.screen.vborder;␊
480␉␊
481␉fillPixmapWithColor( gui.screen.pixmap, gui.screen.bgcolor);␊
482␉␊
483␉// draw background.png into background buffer␊
484␉blend( images[iBackground].image, gui.screen.pixmap, gui.background.pos );␊
485␉␊
486␉// draw logo.png into background buffer␊
487␉if (gui.logo.draw)␊
488␉{␊
489 ␉blend( images[iLogo].image, gui.screen.pixmap, gui.logo.pos);␊
490␉}␊
491␉␊
492␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
493}␊
494␊
495void setupDeviceList(config_file_t *theme)␊
496{␊
497␉unsigned int pixel;␊
498␉int␉alpha;␉␉␉␉// transparency level 0 (obligue) - 255 (transparent)␊
499␉uint32_t color;␉␉␉// color value formatted RRGGBB␊
500␉int val, len;␊
501␉const char *string;␉␊
502␉␊
503␉if(getIntForKey("devices_max_visible", &val, theme ))␊
504␉␉gui.maxdevices = MIN( val, gDeviceCount );␊
505␉␊
506␉if(getIntForKey("devices_iconspacing", &val, theme ))␊
507␉␉gui.devicelist.iconspacing = val;␊
508␉␊
509␉// check layout for horizontal or vertical␊
510␉gui.layout = HorizontalLayout;␊
511␉if(getValueForKey( "devices_layout", &string, &len, theme)) {␊
512␉␉if (!strcmp (string, "vertical")) {␊
513␉␉␉gui.layout = VerticalLayout;␊
514␉␉}␊
515␉}␊
516␉␊
517␉switch (gui.layout) {␊
518␉␉case VerticalLayout:␊
519␉␉␉gui.devicelist.height = ((images[iSelection].image->height + font_console.chars[0]->height + gui.devicelist.iconspacing) * MIN(gui.maxdevices, gDeviceCount) + (images[iDeviceScrollPrev].image->height + images[iDeviceScrollNext].image->height) + gui.devicelist.iconspacing);␊
520␉␉␉gui.devicelist.width = (images[iSelection].image->width + gui.devicelist.iconspacing);␊
521␉␉␉␊
522␉␉␉if(getDimensionForKey("devices_pos_x", &pixel, theme, gui.screen.width , images[iSelection].image->width ) )␊
523␉␉␉␉gui.devicelist.pos.x = pixel;␊
524␉␉␉␊
525␉␉␉if(getDimensionForKey("devices_pos_y", &pixel, theme, gui.screen.height , gui.devicelist.height ) )␊
526␉␉␉␉gui.devicelist.pos.y = pixel;␊
527␉␉␉break;␊
528␉␉␉␊
529␉␉case HorizontalLayout:␊
530␉␉default:␊
531␉␉␉gui.devicelist.width = ((images[iSelection].image->width + gui.devicelist.iconspacing) * MIN(gui.maxdevices, gDeviceCount) + (images[iDeviceScrollPrev].image->width + images[iDeviceScrollNext].image->width) + gui.devicelist.iconspacing);␊
532␉␉␉gui.devicelist.height = (images[iSelection].image->height + font_console.chars[0]->height + gui.devicelist.iconspacing);␊
533␉␉␉␊
534␉␉␉if(getDimensionForKey("devices_pos_x", &pixel, theme, gui.screen.width , gui.devicelist.width ) )␊
535␉␉␉␉gui.devicelist.pos.x = pixel;␊
536␉␉␉else␊
537␉␉␉␉gui.devicelist.pos.x = ( gui.screen.width - gui.devicelist.width ) / 2;␊
538␉␉␉␊
539␉␉␉if(getDimensionForKey("devices_pos_y", &pixel, theme, gui.screen.height , images[iSelection].image->height ) )␊
540␉␉␉␉gui.devicelist.pos.y = pixel;␊
541␉␉␉else␊
542␉␉␉␉gui.devicelist.pos.y = ( gui.screen.height - gui.devicelist.height ) / 2;␊
543␉␉␉break;␊
544␉}␊
545␉␊
546␉if(getColorForKey("devices_bgcolor", &color, theme))␊
547␉␉gui.devicelist.bgcolor = (color & 0x00FFFFFF);␊
548␉␊
549␉if(getIntForKey("devices_transparency", &alpha, theme))␊
550␉␉gui.devicelist.bgcolor = gui.devicelist.bgcolor | (( 255 - ( alpha & 0xFF) ) << 24);␊
551␉␊
552␉if (gui.devicelist.pixmap)␊
553␉{␊
554␉ freeWindowBuffer(&gui.devicelist);␊
555 createWindowBuffer(&gui.devicelist);␊
556 }␊
557}␊
558␊
559void loadThemeValues(config_file_t *theme)␊
560{␊
561␉unsigned int screen_width = gui.screen.width;␊
562␉unsigned int screen_height = gui.screen.height;␊
563␉unsigned int pixel;␊
564␉int␉alpha;␉␉␉␉// transparency level 0 (obligue) - 255 (transparent)␊
565␉uint32_t color;␉␉␉// color value formatted RRGGBB␊
566␉int val;␊
567␉␊
568␉/*␊
569␉ * Parse screen parameters␊
570␉ */␊
571␉if(getColorForKey("screen_bgcolor", &color, theme ))␊
572␉␉gui.screen.bgcolor = (color & 0x00FFFFFF);␊
573␉␊
574␉if(getIntForKey("screen_textmargin_h", &val, theme))␊
575␉␉gui.screen.hborder = MIN( gui.screen.width , val );␊
576␉␊
577␉if(getIntForKey("screen_textmargin_v", &val, theme))␊
578␉␉gui.screen.vborder = MIN( gui.screen.height , val );␊
579␉␊
580␉/*␊
581␉ * Parse background parameters␊
582␉ */␊
583␉if(getDimensionForKey("background_pos_x", &pixel, theme, screen_width , images[iBackground].image->width ) )␊
584␉␉gui.background.pos.x = pixel;␊
585␉␊
586␉if(getDimensionForKey("background_pos_y", &pixel, theme, screen_height , images[iBackground].image->height ) )␊
587␉␉gui.background.pos.y = pixel;␊
588␉␊
589␉/*␊
590␉ * Parse logo parameters␊
591␉ */␊
592␉if(getDimensionForKey("logo_pos_x", &pixel, theme, screen_width , images[iLogo].image->width ) )␊
593␉␉gui.logo.pos.x = pixel;␊
594␉␊
595␉if(getDimensionForKey("logo_pos_y", &pixel, theme, screen_height , images[iLogo].image->height ) )␊
596␉␉gui.logo.pos.y = pixel;␊
597␉␊
598␉/*␊
599␉ * Parse progress bar parameters␊
600␉ */␊
601␉if(getDimensionForKey("progressbar_pos_x", &pixel, theme, screen_width , 0 ) )␊
602␉␉gui.progressbar.pos.x = pixel;␊
603␉␊
604␉if(getDimensionForKey("progressbar_pos_y", &pixel, theme, screen_height , 0 ) )␊
605␉␉gui.progressbar.pos.y = pixel;␊
606␉␊
607␉/*␊
608␉ * Parse countdown text parameters␊
609␉ */␊
610␉if(getDimensionForKey("countdown_pos_x", &pixel, theme, screen_width , 0 ) )␊
611␉␉gui.countdown.pos.x = pixel;␊
612␉␊
613␉if(getDimensionForKey("countdown_pos_y", &pixel, theme, screen_height , 0 ) )␊
614␉␉gui.countdown.pos.y = pixel;␊
615␉␊
616 /*␊
617␉ * Parse devicelist parameters␊
618␉ */␊
619␉setupDeviceList(theme);␊
620␉␊
621␉/*␊
622␉ * Parse infobox parameters␊
623␉ */␊
624␉if(getIntForKey("infobox_width", &val, theme) && val >= 0)␊
625␉␉gui.infobox.width = MIN( screen_width ,(unsigned) val );␊
626␉␊
627␉if(getIntForKey("infobox_height", &val, theme) && val >= 0)␊
628␉␉gui.infobox.height = MIN( screen_height , (unsigned)val );␊
629␉␊
630␉if(getDimensionForKey("infobox_pos_x", &pixel, theme, screen_width , gui.infobox.width ) )␊
631␉␉gui.infobox.pos.x = pixel;␊
632␉␊
633␉if(getDimensionForKey("infobox_pos_y", &pixel, theme, screen_height , gui.infobox.height ) )␊
634␉␉gui.infobox.pos.y = pixel;␊
635␉␊
636␉if(getIntForKey("infobox_textmargin_h", &val, theme))␊
637␉␉gui.infobox.hborder = MIN( gui.infobox.width , val );␊
638␉␊
639␉if(getIntForKey("infobox_textmargin_v", &val, theme))␊
640␉␉gui.infobox.vborder = MIN( gui.infobox.height , val );␊
641␉␊
642␉if(getColorForKey("infobox_bgcolor", &color, theme))␊
643␉␉gui.infobox.bgcolor = (color & 0x00FFFFFF);␊
644␉␊
645␉if(getIntForKey("infobox_transparency", &alpha, theme))␊
646␉␉gui.infobox.bgcolor = gui.infobox.bgcolor | (( 255 - ( alpha & 0xFF) ) << 24);␊
647␉␊
648␉/*␊
649␉ * Parse menu parameters␊
650␉ */␊
651␉if(getDimensionForKey("menu_width", &pixel, theme, gui.screen.width , 0 ) )␊
652␉␉gui.menu.width = pixel;␊
653␉else␊
654␉␉gui.menu.width = images[iMenuSelection].image->width;␊
655␉␊
656␉if(getDimensionForKey("menu_height", &pixel, theme, gui.screen.height , 0 ) )␊
657␉␉gui.menu.height = pixel;␊
658␉else␊
659␉␉gui.menu.height = (infoMenuItemsCount) * images[iMenuSelection].image->height;␊
660␉␊
661␉if(getDimensionForKey("menu_pos_x", &pixel, theme, screen_width , gui.menu.width ) )␊
662␉␉gui.menu.pos.x = pixel;␊
663␉␊
664␉if(getDimensionForKey("menu_pos_y", &pixel, theme, screen_height , gui.menu.height ) )␊
665␉␉gui.menu.pos.y = pixel;␊
666␉␊
667␉if(getIntForKey("menu_textmargin_h", &val, theme))␊
668␉␉gui.menu.hborder = MIN( gui.menu.width , val );␊
669␉␊
670␉if(getIntForKey("menu_textmargin_v", &val, theme))␊
671␉␉gui.menu.vborder = MIN( gui.menu.height , val );␊
672␉␊
673␉if(getColorForKey("menu_bgcolor", &color, theme))␊
674␉␉gui.menu.bgcolor = (color & 0x00FFFFFF);␊
675␉␊
676␉if(getIntForKey("menu_transparency", &alpha, theme))␊
677␉␉gui.menu.bgcolor = gui.menu.bgcolor | (( 255 - ( alpha & 0xFF) ) << 24);␉␉␊
678␉␊
679␉/*␊
680␉ * Parse bootprompt parameters␊
681␉ */␊
682␉if(getDimensionForKey("bootprompt_width", &pixel, theme, screen_width , 0 ) )␊
683␉␉gui.bootprompt.width = pixel;␊
684␉␊
685␉if(getIntForKey("bootprompt_height", &val, theme) && val >= 0)␊
686␉␉gui.bootprompt.height = MIN( screen_height , (unsigned)val );␊
687␉␊
688␉if(getDimensionForKey("bootprompt_pos_x", &pixel, theme, screen_width , gui.bootprompt.width ) )␊
689␉␉gui.bootprompt.pos.x = pixel;␊
690␉␊
691␉if(getDimensionForKey("bootprompt_pos_y", &pixel, theme, screen_height , gui.bootprompt.height ) )␊
692␉␉gui.bootprompt.pos.y = pixel;␊
693␉␊
694␉if(getIntForKey("bootprompt_textmargin_h", &val, theme) && val >= 0)␊
695␉␉gui.bootprompt.hborder = MIN( gui.bootprompt.width , (unsigned)val );␊
696␉␊
697␉if(getIntForKey("bootprompt_textmargin_v", &val, theme) && val >= 0)␊
698␉␉gui.bootprompt.vborder = MIN( gui.bootprompt.height , (unsigned)val );␊
699␉␊
700␉if(getColorForKey("bootprompt_bgcolor", &color, theme))␊
701␉␉gui.bootprompt.bgcolor = (color & 0x00FFFFFF);␊
702␉␊
703␉if(getIntForKey("bootprompt_transparency", &alpha, theme))␊
704␉␉gui.bootprompt.bgcolor = gui.bootprompt.bgcolor | (( 255 - ( alpha & 0xFF) ) << 24);␊
705␉␊
706␉if(getColorForKey("font_small_color", &color, theme))␊
707␉␉gui.screen.font_small_color = (color & 0x00FFFFFF);␊
708␉␊
709␉if(getColorForKey("font_console_color", &color, theme))␊
710␉␉gui.screen.font_console_color = (color & 0x00FFFFFF);␊
711}␊
712␊
713#define MAX_tHEME 255␊
714␊
715int randomTheme(char *dirspec, const char **theme) {␊
716␉␉␊
717␉long ret, flags, time;␊
718␉long long␉ index;␊
719␉␊
720␉const char * name;␉␉ ␊
721␉index = 0;␉␉ ␊
722␉uint8_t i=0;␊
723␉␉␉␊
724␉char *list[MAX_tHEME];␊
725#ifdef EMBED_THEME␊
726␉␉␉list[i] = "";␊
727␉␉␉i++;␊
728#endif␊
729␉␊
730␉while (i < MAX_tHEME) {␊
731␉␉ret = GetDirEntry(dirspec, &index, &name, &flags, &time);␊
732␉␉if (ret == -1) break;␊
733␉␉␊
734␉␉// Make sure this is a directory.␊
735␉␉if ((flags & kFileTypeMask) != kFileTypeDirectory) continue;␊
736␉␉␊
737␉␉if ((unsigned)(strlen(name) + 34) > 256) continue;␊
738␉␉␊
739␉␉if ((list[i] = (char *)malloc(strlen(name))) == NULL) continue;␉␉␉␉␉␉␊
740␉␉␊
741␉␉strcpy(list[i], name);␊
742␉␉␊
743␉␉i++;␊
744␉␉␊
745␉}␊
746␉␊
747␉if (i) {␉␉␉␊
748␉␉␉␉␊
749␉␉srand (time18());␉␉␊
750␉␉␊
751␉␉*theme = list[(rand() % i)];␉␉␉␊
752␉␉␊
753␉␉␉␉␊
754␉␉int ret = startGUI();␊
755␊
756␉␉uint8_t l=0;␊
757#ifdef EMBED_THEME␊
758␉␉l++;␊
759#endif␉␉␊
760␉␉while (l<i) {␊
761␉␉␉free(list[l]);␊
762␉␉␉l++;␊
763␉␉}␊
764␉␉␊
765␉␉return ret;␊
766␉} ␊
767␉␊
768␉return 1;␉␉␉␉␊
769␉␊
770␉␊
771}␊
772␊
773int initGUI(void)␊
774{␉␊
775␉bool dummybool = true;␊
776␉getBoolForKey(kGUIKey, &dummybool, &bootInfo->bootConfig);␊
777␉if (!dummybool) {␊
778␉␉return 1;␊
779␉}␊
780␉␊
781␉{␊
782␉␉long flags;␊
783␉␉long time;␊
784␉␉long ret = -1;␊
785␉␉␊
786␉␉ret = GetFileInfo("/Extra/", "Themes", &flags, &time);␊
787␉␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory)) {␊
788␉␉␉sprintf(dirsrc, "/Extra/Themes");␊
789␉␉␉␊
790␉␉} else {␊
791␉␉␉ret = GetFileInfo("bt(0,0)/Extra/", "Themes", &flags, &time);␊
792␉␉␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory)) {␊
793␉␉␉␉sprintf(dirsrc, "bt(0,0)/Extra/Themes");␊
794␉␉␉␉␊
795␉␉␉} else {␊
796␉␉␉␉return 1;␊
797␉␉␉}␊
798 ␊
799␉␉}␉␉␊
800␉}␊
801␉␊
802␉int len;␉␉␊
803␉bool theme_ran= false;␊
804␉getBoolForKey("RandomTheme", &theme_ran, &bootInfo->bootConfig);␊
805␉int ret = 1;␊
806␉␊
807␉if (theme_ran) {␊
808␉␉␉␉␉␉␊
809␉␉ret = randomTheme(dirsrc, &theme_name); ␉␉␊
810␉␉␊
811␉} ␊
812␊
813␉␊
814␉if (ret)␊
815␉{␉␉␉␊
816␉␉if (getValueForKey( "Theme", &theme_name, &len, &bootInfo->bootConfig ) == true)␊
817␉␉{␊
818␉␉␉ret = startGUI();␊
819␊
820␉␉} ␊
821#ifdef EMBED_THEME␉␊
822␉␉if (ret) {␊
823␉␉␉theme_name = "";␉␉␉␉␊
824␉␉␉ret = startGUI();␉␉␉␊
825␉␉}␉␉␊
826#endif␉␉␊
827␉␉if (ret) {␊
828␉␉␉theme_name = THEME_NAME_DEFAULT;␊
829␉␉␉ret = startGUI();␊
830␉␉}␊
831␉}␊
832␉return ret;␊
833}␊
834␊
835int startGUI(void)␊
836{␊
837␉int val;␉␊
838␉char dirspec[256];␊
839␉␊
840␉␉␊
841␉if ((unsigned)(strlen(theme_name) + 34) > sizeof(dirspec)) {␊
842␉␉return 1;␊
843␉}␊
844␉␉␊
845␉sprintf(dirspec, "%s/%s/theme.plist", dirsrc ,theme_name);␊
846␉␊
847␉if (loadConfigFile(dirspec, &bootInfo->themeConfig) != 0) {␊
848␉␉␉␉␊
849#ifdef EMBED_THEME␊
850␉␉␉if (strlen(theme_name) == 0) {␊
851␉␉␉␉config_file_t *config;␊
852␉␉␉␉␊
853␉␉␉␉config = &bootInfo->themeConfig;␊
854␉␉␉␉if (ParseXMLFile((char *)__theme_plist, &config->dictionary) != 0) {␊
855␉␉␉␉␉return 1;␊
856␉␉␉␉}␊
857␉␉␉}␉␉␉␊
858#else␊
859␉␉␉return 1;␊
860#endif␉␉␊
861 }␊
862␉␊
863␉if (execute_hook("getResolution_hook", &screen_params[0], &screen_params[1], &screen_params[2], NULL, NULL, NULL) != EFI_SUCCESS)␉␉␊
864␉{␉␉␊
865␉␉// parse display size parameters␊
866␉␉if (getIntForKey("screen_width", &val, &bootInfo->themeConfig) && val > 0) {␊
867␉␉␉screen_params[0] = val;␊
868␉␉}␊
869␉␉if (getIntForKey("screen_height", &val, &bootInfo->themeConfig) && val > 0) {␊
870␉␉␉screen_params[1] = val;␊
871␉␉}␉␉␊
872␉}␊
873␉␊
874␉␊
875␉// Initalizing GUI strucutre.␊
876␉bzero(&gui, sizeof(gui_t));␊
877␉␊
878␉// find best matching vesa mode for our requested width & height␊
879␉getGraphicModeParams(screen_params);␊
880␉␊
881␉// set our screen structure with the mode width & height␊
882␉gui.screen.width = screen_params[0];␉␊
883␉gui.screen.height = screen_params[1];␊
884␉␊
885␉// load graphics otherwise fail and return␊
886␉if (loadGraphics(dirsrc) == 0) {␊
887␉␉loadThemeValues(&bootInfo->themeConfig);␊
888␉␉colorFont(&font_small, gui.screen.font_small_color);␊
889␉␉colorFont(&font_console, gui.screen.font_console_color);␊
890␉␉␊
891␉␉// create the screen & window buffers␊
892␉␉if (createBackBuffer(&gui.screen) == 0)␊
893␉␉{␊
894␉␉␉if (createWindowBuffer(&gui.screen) == 0)␊
895␉␉␉{␊
896␉␉␉␉if (createWindowBuffer(&gui.devicelist) == 0)␊
897␉␉␉␉{␊
898␉␉␉␉␉if (createWindowBuffer(&gui.bootprompt) == 0)␊
899␉␉␉␉␉{␊
900␉␉␉␉␉␉if (createWindowBuffer(&gui.infobox) == 0)␊
901␉␉␉␉␉␉{␊
902␉␉␉␉␉␉␉if (createWindowBuffer(&gui.menu) == 0)␊
903␉␉␉␉␉␉␉{␊
904␉␉␉␉␉␉␉ gui.logo.draw = true;␊
905␉␉␉␉␉␉␉␉drawBackground();␊
906␉␉␉␉␉␉␉␉// lets copy the screen into the back buffer␊
907#if UNUSED␊
908␉␉␉␉␉␉␉␉setVideoMode( GRAPHICS_MODE, 0 );␊
909#else␊
910␉␉␉␉␉␉␉␉setVideoMode( GRAPHICS_MODE );␊
911#endif␊
912␉␉␉␉␉␉␉␉gui.initialised = true;␉␉␉␉␉␉␉␉␊
913␉␉␉␉␉␉␉␉return 0;␊
914␉␉␉␉␉␉␉}␊
915␉␉␉␉␉␉}␊
916␉␉␉␉␉}␊
917␉␉␉␉}␊
918␉␉␉}␊
919␉␉}␊
920␉}␊
921␉return 1;␊
922}␊
923␊
924void drawDeviceIcon(BVRef device, pixmap_t *buffer, position_t p, bool isSelected)␊
925{␊
926␉int devicetype;␊
927␉␊
928␉if( diskIsCDROM(device) )␊
929␉␉devicetype = iDeviceCDROM;␉␉␉␉// Use CDROM icon␊
930␉else␊
931␉{␉␊
932␉␉switch (device->part_type)␊
933␉␉{␊
934␉␉␉case kPartitionTypeHFS:␊
935#ifdef BOOT_HELPER_SUPPORT␉␊
936␉␉␉␉// Use HFS or HFSRAID icon depending on bvr flags.␊
937␉␉␉␉devicetype = (device->flags & kBVFlagBooter) ? iDeviceHFSRAID : iDeviceHFS;␊
938#else␊
939␉␉␉␉devicetype = iDeviceHFS;␊
940#endif␊
941␉␉␉␉break;␊
942␉␉␉␉␊
943␉␉␉case kPartitionTypeHPFS:␊
944␉␉␉␉devicetype = iDeviceNTFS;␉␉// Use HPFS / NTFS icon␊
945␉␉␉␉break;␊
946␉␉␉␉␊
947␉␉␉case kPartitionTypeFAT16:␊
948␉␉␉␉devicetype = iDeviceFAT16;␉␉// Use FAT16 icon␊
949␉␉␉␉break;␊
950␉␉␉␉␊
951␉␉␉case kPartitionTypeFAT32:␊
952␉␉␉␉devicetype = iDeviceFAT32;␉␉// Use FAT32 icon␊
953␉␉␉␉break;␊
954␉␉␉␉␊
955␉␉␉case kPartitionTypeEXT3:␊
956␉␉␉␉devicetype = iDeviceEXT3;␉␉// Use EXT2/3 icon␊
957␉␉␉␉break;␊
958␉␉␉␊
959␉␉␉case kPartitionTypeFreeBSD:␊
960␉␉␉␉devicetype = iDeviceFreeBSD;␉␉// Use FreeBSD icon␊
961␉␉␉␉break;␊
962␉␉␉␉␊
963␉␉␉case kPartitionTypeOpenBSD:␊
964␉␉␉␉devicetype = iDeviceOpenBSD;␉␉// Use OpenBSD icon␊
965␉␉␉␉break;␊
966␉␉␉␉␊
967␉␉␉default:␊
968␉␉␉␉devicetype = iDeviceGeneric;␉// Use Generic icon␊
969␉␉␉␉break;␊
970␉␉}␊
971␉}␊
972␉␊
973␉// Draw the selection image and use the next (device_*_o) image for the selected item.␊
974 if (isSelected)␊
975␉{␊
976␉␉blend(images[iSelection].image, buffer, centeredAt(images[iSelection].image, p));␊
977␉␉devicetype++; // selec override image ␊
978␉}␊
979␉␊
980␉// draw icon␊
981␉blend( images[devicetype].image, buffer, centeredAt( images[devicetype].image, p ));␊
982␉␊
983␉p.y += (images[iSelection].image->height / 2) + font_console.chars[0]->height;␊
984␉␊
985␉// draw volume label ␊
986␉drawStrCenteredAt( device->label, &font_small, buffer, p);␉␊
987␉␊
988}␊
989␊
990void drawDeviceList (int start, int end, int selection)␊
991{␊
992␉int i;␊
993␉position_t p, p_prev, p_next;␊
994␉␊
995␉//uint8_t␉maxDevices = MIN( gui.maxdevices, menucount );␊
996␉␊
997␉fillPixmapWithColor( gui.devicelist.pixmap, gui.devicelist.bgcolor);␊
998␉␊
999␉makeRoundedCorners( gui.devicelist.pixmap);␊
1000␉␊
1001␉switch (gui.layout)␊
1002␉{␊
1003␉␉␉␊
1004␉␉case VerticalLayout:␊
1005␉␉␉p.x = (gui.devicelist.width /2);␊
1006␉␉␉p.y = ( ( images[iSelection].image->height / 2 ) + images[iDeviceScrollPrev].image->height + gui.devicelist.iconspacing );␊
1007␉␉␉␊
1008␉␉␉// place scroll indicators at top & bottom edges␊
1009␉␉␉p_prev = pos ( gui.devicelist.width / 2 , gui.devicelist.iconspacing );␊
1010␉␉␉p_next = pos ( p_prev.x, gui.devicelist.height - gui.devicelist.iconspacing );␊
1011␉␉␉␊
1012␉␉␉break;␊
1013␉␉␉␊
1014␉␉default:␉// use Horizontal layout as the default␊
1015␉␉␉␊
1016␉␉case HorizontalLayout:␊
1017␉␉␉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;␊
1018␉␉␉p.y = ((gui.devicelist.height - font_console.chars[0]->height ) - images[iSelection].image->height) / 2 + ( images[iSelection].image->height / 2 );␊
1019␉␉␉␊
1020␉␉␉// place scroll indicators at left & right edges␊
1021␉␉␉p_prev = pos ( images[iDeviceScrollPrev].image->width / 2 + gui.devicelist.iconspacing / 2, gui.devicelist.height / 2 );␊
1022␉␉␉p_next = pos ( gui.devicelist.width - ( images[iDeviceScrollNext].image->width / 2 + gui.devicelist.iconspacing / 2), gui.devicelist.height / 2 );␊
1023␉␉␉␊
1024␉␉␉break;␊
1025␉␉␉␊
1026␉}␊
1027␉␊
1028␉// draw visible device icons␊
1029␉for (i = 0; i < gui.maxdevices; i++)␊
1030␉{␊
1031␉␉BVRef param = menuItems[start + i].param;␊
1032␉␉␊
1033 bool isSelected = ((start + i) == selection) ? true : false;␊
1034␉␉if (isSelected)␊
1035␉␉{␊
1036 if (param->flags & kBVFlagNativeBoot)␊
1037 {␊
1038 infoMenuNativeBoot = true;␊
1039 }␊
1040 else␊
1041 {␊
1042 infoMenuNativeBoot = false;␊
1043 if(infoMenuSelection >= INFOMENU_NATIVEBOOT_START && infoMenuSelection <= INFOMENU_NATIVEBOOT_END)␊
1044␉␉␉␉␉infoMenuSelection = 0;␊
1045 }␊
1046␉␉␉␊
1047␉␉␉if(gui.menu.draw)␊
1048␉␉␉␉drawInfoMenuItems();␊
1049␉␉␉␊
1050#if DEBUG␊
1051 gui.debug.cursor = pos( 10, 100);␊
1052 dprintf( &gui.screen, "label %s\n", param->label );␊
1053 dprintf( &gui.screen, "biosdev 0x%x\n", param->biosdev );␊
1054 dprintf( &gui.screen, "width %d\n", gui.screen.width);␊
1055 dprintf( &gui.screen, "height %d\n", gui.screen.height);␊
1056 dprintf( &gui.screen, "type 0x%x\n", param->type );␊
1057 dprintf( &gui.screen, "flags 0x%x\n", param->flags );␊
1058 dprintf( &gui.screen, "part_no %d\n", param->part_no );␊
1059 dprintf( &gui.screen, "part_boff 0x%x\n", param->part_boff );␊
1060 dprintf( &gui.screen, "part_type 0x%x\n", param->part_type );␊
1061 dprintf( &gui.screen, "bps 0x%x\n", param->bps );␊
1062 dprintf( &gui.screen, "name %s\n", param->name );␊
1063 dprintf( &gui.screen, "type_name %s\n", param->type_name );␊
1064 dprintf( &gui.screen, "modtime %d\n", param->modTime );␊
1065#endif␊
1066␉␉}␊
1067␉␉␊
1068␉␉drawDeviceIcon( param, gui.devicelist.pixmap, p, isSelected);␊
1069␉␉␊
1070␉␉if (gui.layout == HorizontalLayout)␊
1071␉␉{␊
1072␉␉␉p.x += images[iSelection].image->width + gui.devicelist.iconspacing; ␊
1073␉␉}␊
1074␉␉if (gui.layout == VerticalLayout)␊
1075␉␉{␊
1076␉␉␉p.y += ( images[iSelection].image->height + font_console.chars[0]->height + gui.devicelist.iconspacing ); ␊
1077␉␉}␊
1078␉}␊
1079␉␊
1080␉// draw prev indicator␊
1081␉if(start)␊
1082␉␉blend( images[iDeviceScrollPrev].image, gui.devicelist.pixmap, centeredAt( images[iDeviceScrollPrev].image, p_prev ) );␊
1083␉␊
1084␉// draw next indicator␊
1085␉if( end < gDeviceCount - 1 )␊
1086␉␉blend( images[iDeviceScrollNext].image, gui.devicelist.pixmap, centeredAt( images[iDeviceScrollNext].image, p_next ) );␊
1087␉␊
1088␉gui.redraw = true;␊
1089␉␊
1090␉updateVRAM();␊
1091␉␊
1092}␊
1093␊
1094void clearGraphicBootPrompt()␊
1095{␊
1096␉// clear text buffer␊
1097␉prompt[0] = '\0';␊
1098␉prompt_pos=0;␊
1099␉␊
1100␉␊
1101␉if(␉gui.bootprompt.draw == true )␊
1102␉{␊
1103␉␉gui.bootprompt.draw = false;␊
1104␉␉gui.redraw = true;␊
1105␉␉// this causes extra frames to be drawn␊
1106␉␉//updateVRAM();␊
1107␉}␊
1108␉␊
1109␉return;␊
1110}␊
1111␊
1112void updateGraphicBootPrompt(int key)␊
1113{␊
1114␉if ( key == kBackspaceKey )␊
1115␉␉prompt[--prompt_pos] = '\0';␊
1116␉else ␊
1117␉{␊
1118␉␉prompt[prompt_pos] = key;␊
1119␉␉prompt_pos++;␊
1120␉␉prompt[prompt_pos] = '\0';␊
1121␉}␊
1122␉␊
1123␉fillPixmapWithColor( gui.bootprompt.pixmap, gui.bootprompt.bgcolor);␊
1124␉␊
1125␉makeRoundedCorners( gui.bootprompt.pixmap);␊
1126␉␊
1127␉position_t p_text = pos( gui.bootprompt.hborder , ( ( gui.bootprompt.height - font_console.chars[0]->height) ) / 2 );␊
1128␉␊
1129␉// print the boot prompt text␊
1130␉drawStr(prompt_text, &font_console, gui.bootprompt.pixmap, p_text);␊
1131␉␊
1132␉// get the position of the end of the boot prompt text to display user input␊
1133␉position_t p_prompt = pos( p_text.x + ( ( strlen(prompt_text) ) * font_console.chars[0]->width ), p_text.y );␊
1134␉␊
1135␉// calculate the position of the cursor␊
1136␉int␉offset = ( prompt_pos - ( ( gui.bootprompt.width / font_console.chars[0]->width ) - strlen(prompt_text) - 2 ) );␉␊
1137␉␊
1138␉if ( offset < 0)␊
1139␉␉offset = 0;␊
1140␉␊
1141␉drawStr( prompt+offset, &font_console, gui.bootprompt.pixmap, p_prompt);␊
1142␉␊
1143␉gui.menu.draw = false;␊
1144␉gui.bootprompt.draw = true;␊
1145␉gui.redraw = true;␊
1146␉␊
1147␉updateVRAM();␊
1148␉␊
1149␉return;␊
1150}␊
1151␊
1152#if UNUSED␊
1153inline␊
1154void vramwrite (void *data, int width, int height)␊
1155#else␊
1156inline␊
1157void vramwrite (void *data, int width)␊
1158#endif␊
1159{␊
1160␉if (VIDEO (depth) == 0x20 /*32*/ && VIDEO (rowBytes) == (unsigned long)gui.backbuffer->width * 4)␊
1161␉␉memcpy((uint8_t *)vram, gui.backbuffer->pixels, VIDEO (rowBytes)*VIDEO (height));␊
1162␉else␊
1163␉{␊
1164␉␉uint32_t r, g, b;␊
1165␉␉uint32_t i, j;␊
1166␉␉for (i = 0; i < VIDEO (height); i++)␊
1167␉␉␉for (j = 0; j < VIDEO (width); j++)␊
1168␉␉␉{␊
1169␉␉␉␉b = ((uint8_t *) data)[4*i*width + 4*j];␊
1170␉␉␉␉g = ((uint8_t *) data)[4*i*width + 4*j + 1];␊
1171␉␉␉␉r = ((uint8_t *) data)[4*i*width + 4*j + 2];␊
1172␉␉␉␉switch (VIDEO (depth))␊
1173␉␉␉␉{␊
1174␉␉␉␉␉case 32:␊
1175␉␉␉␉␉␉*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*4) = (b&0xff) | ((g&0xff)<<8) | ((r&0xff)<<16);␊
1176␉␉␉␉␉␉break;␊
1177␉␉␉␉␉case 24:␊
1178␉␉␉␉␉␉*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*3) = ((*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*3))&0xff000000)␊
1179␉␉␉␉␉␉| (b&0xff) | ((g&0xff)<<8) | ((r&0xff)<<16);␊
1180␉␉␉␉␉␉break;␊
1181␉␉␉␉␉case 16:␊
1182␉␉␉␉␉␉// Somehow 16-bit is always 15-bits really␊
1183␉␉␉␉␉␉//␉␉␉␉␉␉*(uint16_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*2) = ((b&0xf8)>>3) | ((g&0xfc)<<3) | ((r&0xf8)<<8);␊
1184␉␉␉␉␉␉//␉␉␉␉␉␉break;␉␉␉␉␉␉␉␊
1185␉␉␉␉␉case 15:␊
1186␉␉␉␉␉␉*(uint16_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*2) = ((b&0xf8)>>3) | ((g&0xf8)<<2) | ((r&0xf8)<<7);␊
1187␉␉␉␉␉␉break;␉␊
1188␉␉␉␉␉default:␊
1189␉␉␉␉␉␉break;␊
1190␉␉␉␉}␊
1191␉␉␉}␊
1192␉}␊
1193}␊
1194␊
1195void updateVRAM()␊
1196{␊
1197␉if (gui.redraw)␊
1198␉{␊
1199␉␉if (gui.devicelist.draw)␊
1200␉␉␉blend( gui.devicelist.pixmap, gui.backbuffer, gui.devicelist.pos );␊
1201␉␉␊
1202␉␉if (gui.bootprompt.draw)␊
1203␉␉␉blend( gui.bootprompt.pixmap, gui.backbuffer, gui.bootprompt.pos );␊
1204␉␉␊
1205␉␉if (gui.menu.draw)␊
1206␉␉␉blend( gui.menu.pixmap, gui.backbuffer, gui.menu.pos );␊
1207␉␉␊
1208␉␉if (gui.infobox.draw)␊
1209␉␉␉blend( gui.infobox.pixmap, gui.backbuffer, gui.infobox.pos );␊
1210␉}␊
1211#if UNUSED␊
1212␉vramwrite ( gui.backbuffer->pixels, gui.backbuffer->width, gui.backbuffer->height );␊
1213#else␊
1214␉vramwrite ( gui.backbuffer->pixels, gui.backbuffer->width );␊
1215#endif␊
1216␉if (gui.redraw)␊
1217␉{␊
1218␉␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
1219␉␉gui.redraw = false;␊
1220␉}␊
1221}␊
1222␊
1223struct putc_info {␊
1224 char * str;␊
1225 char * last_str;␊
1226};␊
1227␊
1228static void␊
1229sputc(int c, struct putc_info * pi)␊
1230{␊
1231 if (pi->last_str)␊
1232 if (pi->str == pi->last_str) {␊
1233 *(pi->str) = '\0';␊
1234 return;␊
1235 }␊
1236 *(pi->str)++ = c;␊
1237}␊
1238␊
1239int gprintf( window_t * window, const char * fmt, ...)␊
1240{␊
1241␉char *formattedtext;␊
1242␉␊
1243␉va_list ap;␊
1244␉␊
1245␉struct putc_info pi;␊
1246␉␊
1247␉if ((formattedtext = malloc(1024)) != NULL) {␊
1248␉␉// format the text␊
1249␉␉va_start(ap, fmt);␊
1250␉␉pi.str = formattedtext;␊
1251␉␉pi.last_str = 0;␊
1252␉␉prf(fmt, ap, sputc, &pi);␊
1253␉␉*pi.str = '\0';␊
1254␉␉va_end(ap);␊
1255␉␉␊
1256␉␉position_t␉origin, cursor, bounds;␊
1257␉␉␊
1258␉␉int i;␊
1259␉␉int character;␊
1260␉␉␊
1261␉␉origin.x = MAX( window->cursor.x, window->hborder );␊
1262␉␉origin.y = MAX( window->cursor.y, window->vborder );␊
1263␉␉␊
1264␉␉bounds.x = ( window->width - window->hborder );␊
1265␉␉bounds.y = ( window->height - window->vborder );␊
1266␉␉␊
1267␉␉cursor = origin;␊
1268␉␉␊
1269␉␉font_t *font = &font_console;␊
1270␉␉␊
1271␉␉for( i=0; i< strlen(formattedtext); i++ )␊
1272␉␉{␊
1273␉␉␉character = formattedtext[i];␊
1274␉␉␉␊
1275␉␉␉character -= 32;␊
1276␉␉␉␊
1277␉␉␉// newline ?␊
1278␉␉␉if( formattedtext[i] == '\n' )␊
1279␉␉␉{␊
1280␉␉␉␉cursor.x = window->hborder;␊
1281␉␉␉␉cursor.y += font->height;␊
1282␉␉␉␉␊
1283␉␉␉␉if ( cursor.y > bounds.y )␊
1284␉␉␉␉␉cursor.y = origin.y;␊
1285␉␉␉␉␊
1286␉␉␉␉continue;␊
1287␉␉␉}␊
1288␉␉␉␊
1289␉␉␉// tab ?␊
1290␉␉␉if( formattedtext[i] == '\t' )␊
1291␉␉␉␉cursor.x += ( font->chars[0]->width * 5 );␊
1292␉␉␉␊
1293␉␉␉// draw the character␊
1294␉␉␉if( font->chars[character])␊
1295␉␉␉␉blend(font->chars[character], window->pixmap, cursor);␊
1296␉␉␉␊
1297␉␉␉cursor.x += font->chars[character]->width;␊
1298␉␉␉␊
1299␉␉␉// check x pos and do newline␊
1300␉␉␉if ( cursor.x > bounds.x )␊
1301␉␉␉{␊
1302␉␉␉␉cursor.x = origin.x;␊
1303␉␉␉␉cursor.y += font->height;␊
1304␉␉␉}␊
1305␉␉␉␊
1306␉␉␉// check y pos and reset to origin.y␊
1307␉␉␉if ( cursor.y > bounds.y )␊
1308␉␉␉␉cursor.y = origin.y;␊
1309␉␉}␊
1310␉␉␊
1311␉␉// update cursor postition␊
1312␉␉window->cursor = cursor;␊
1313␉␉␊
1314␉␉free(formattedtext);␊
1315␉␉␊
1316␉␉return 0;␊
1317␉␉␊
1318␉}␊
1319␉return 1;␊
1320}␊
1321␊
1322int dprintf( window_t * window, const char * fmt, ...)␊
1323{␊
1324␉char *formattedtext;␊
1325␉␊
1326␉va_list ap;␊
1327␉␊
1328␉//window = &gui.debug;␊
1329␉␊
1330␉struct putc_info pi;␊
1331␉␊
1332␉if ((formattedtext = malloc(1024)) != NULL) {␊
1333␉␉// format the text␊
1334␉␉va_start(ap, fmt);␊
1335␉␉pi.str = formattedtext;␊
1336␉␉pi.last_str = 0;␊
1337␉␉prf(fmt, ap, sputc, &pi);␊
1338␉␉*pi.str = '\0';␊
1339␉␉va_end(ap);␊
1340␉␉␊
1341␉␉position_t␉origin, cursor, bounds;␊
1342␉␉␊
1343␉␉int i;␊
1344␉␉int character;␊
1345␉␉␊
1346␉␉origin.x = MAX( gui.debug.cursor.x, window->hborder );␊
1347␉␉origin.y = MAX( gui.debug.cursor.y, window->vborder );␊
1348␉␉␊
1349␉␉bounds.x = ( window->width - window->hborder );␊
1350␉␉bounds.y = ( window->height - window->vborder );␊
1351␉␉␊
1352␉␉cursor = origin;␊
1353␉␉␊
1354␉␉font_t *font = &font_console;␊
1355␉␉␊
1356␉␉for( i=0; i< strlen(formattedtext); i++ )␊
1357␉␉{␊
1358␉␉␉character = formattedtext[i];␊
1359␉␉␉␊
1360␉␉␉character -= 32;␊
1361␉␉␉␊
1362␉␉␉// newline ?␊
1363␉␉␉if( formattedtext[i] == '\n' )␊
1364␉␉␉{␊
1365␉␉␉␉cursor.x = window->hborder;␊
1366␉␉␉␉cursor.y += font->height;␊
1367␉␉␉␉␊
1368␉␉␉␉if ( cursor.y > bounds.y )␊
1369␉␉␉␉␉cursor.y = origin.y;␊
1370␉␉␉␉␊
1371␉␉␉␉continue;␊
1372␉␉␉}␊
1373␉␉␉␊
1374␉␉␉// tab ?␊
1375␉␉␉if( formattedtext[i] == '\t' )␊
1376␉␉␉␉cursor.x += ( font->chars[0]->width * 5 );␊
1377␉␉␉␊
1378␉␉␉// draw the character␊
1379␉␉␉if( font->chars[character])␊
1380␉␉␉␉blend(font->chars[character], gui.backbuffer, cursor);␊
1381␉␉␉␊
1382␉␉␉cursor.x += font->chars[character]->width;␊
1383␉␉␉␊
1384␉␉␉// check x pos and do newline␊
1385␉␉␉if ( cursor.x > bounds.x )␊
1386␉␉␉{␊
1387␉␉␉␉cursor.x = origin.x;␊
1388␉␉␉␉cursor.y += font->height;␊
1389␉␉␉}␊
1390␉␉␉␊
1391␉␉␉// check y pos and reset to origin.y␊
1392␉␉␉if ( cursor.y > bounds.y )␊
1393␉␉␉␉cursor.y = origin.y;␊
1394␉␉}␊
1395␉␉␊
1396␉␉// update cursor postition␊
1397␉␉gui.debug.cursor = cursor;␊
1398␉␉␊
1399␉␉free(formattedtext);␊
1400␉␉␊
1401␉␉return 0;␊
1402␉␉␊
1403␉}␊
1404␉return 1;␊
1405}␊
1406␊
1407int vprf(const char * fmt, va_list ap)␊
1408{␊
1409␉int i;␊
1410␉int character;␊
1411␉␊
1412␉char *formattedtext;␊
1413␉window_t *window = &gui.screen;␊
1414␉struct putc_info pi;␊
1415␉␊
1416␉position_t␉origin, cursor, bounds;␊
1417␉font_t *font = &font_console;␊
1418␉␊
1419␉if ((formattedtext = malloc(1024)) != NULL) {␊
1420␉␉// format the text␊
1421␉␉pi.str = formattedtext;␊
1422␉␉pi.last_str = 0;␊
1423␉␉prf(fmt, ap, sputc, &pi);␊
1424␉␉*pi.str = '\0';␊
1425␉␉␊
1426␉␉origin.x = MAX( window->cursor.x, window->hborder );␊
1427␉␉origin.y = MAX( window->cursor.y, window->vborder );␊
1428␉␉bounds.x = ( window->width - ( window->hborder * 2 ) );␊
1429␉␉bounds.y = ( window->height - ( window->vborder * 2 ) );␊
1430␉␉cursor = origin;␊
1431␉␉␊
1432␉␉for( i=0; i< strlen(formattedtext); i++ )␊
1433␉␉{␊
1434␉␉␉character = formattedtext[i];␊
1435␉␉␉character -= 32;␊
1436␉␉␉␊
1437␉␉␉// newline ?␊
1438␉␉␉if( formattedtext[i] == '\n' )␊
1439␉␉␉{␊
1440␉␉␉␉cursor.x = window->hborder;␊
1441␉␉␉␉cursor.y += font->height;␊
1442␉␉␉␉if ( cursor.y > bounds.y )␊
1443␉␉␉␉{␊
1444␉␉␉␉␉gui.redraw = true;␊
1445␉␉␉␉␉updateVRAM();␊
1446␉␉␉␉␉cursor.y = window->vborder;␊
1447␉␉␉␉}␊
1448␉␉␉␉window->cursor.y = cursor.y;␊
1449␉␉␉␉continue;␊
1450␉␉␉}␊
1451␉␉␉␊
1452␉␉␉// tab ?␊
1453␉␉␉if( formattedtext[i] == '\t' )␊
1454␉␉␉{␊
1455␉␉␉␉cursor.x = ( cursor.x / ( font->chars[0]->width * 8 ) + 1 ) * ( font->chars[0]->width * 8 );␊
1456␉␉␉␉continue;␊
1457␉␉␉}␊
1458␉␉␉cursor.x += font->chars[character]->width;␊
1459␉␉␉␊
1460␉␉␉// check x pos and do newline␊
1461␉␉␉if ( cursor.x > bounds.x )␊
1462␉␉␉{␊
1463␉␉␉␉cursor.x = origin.x;␊
1464␉␉␉␉cursor.y += font->height;␊
1465␉␉␉}␊
1466␉␉␉␊
1467␉␉␉// check y pos and reset to origin.y␊
1468␉␉␉if ( cursor.y > ( bounds.y + font->chars[0]->height) )␊
1469␉␉␉{␊
1470␉␉␉␉gui.redraw = true;␊
1471␉␉␉␉updateVRAM();␊
1472␉␉␉␉cursor.y = window->vborder;␊
1473␉␉␉}␊
1474␉␉␉// draw the character␊
1475␉␉␉if( font->chars[character])␊
1476␉␉␉␉blend(font->chars[character], gui.backbuffer, cursor);␊
1477␉␉}␊
1478␉␉// save cursor postition␊
1479␉␉window->cursor.x = cursor.x;␊
1480␉␉updateVRAM();␊
1481␉␉free(formattedtext);␊
1482␉␉return 0;␊
1483␉}␊
1484␉return 1;␊
1485}␊
1486␊
1487void drawStr(char *ch, font_t *font, pixmap_t *blendInto, position_t p)␊
1488{␊
1489␉int i=0;␊
1490␉int y=0; // we need this to support multilines '\n'␊
1491␉int x=0;␊
1492␉␊
1493␉for(i=0;i<strlen(ch);i++)␊
1494␉{␊
1495␉␉int cha=(int)ch[i];␊
1496␉␉␊
1497␉␉cha-=32;␊
1498␉␉␊
1499␉␉// newline ?␊
1500␉␉if( ch[i] == '\n' )␊
1501␉␉{␊
1502␉␉␉x = 0;␊
1503␉␉␉y += font->height;␊
1504␉␉␉continue;␊
1505␉␉}␊
1506␉␉␊
1507␉␉// tab ?␊
1508␉␉if( ch[i] == '\t' )␊
1509␉␉␉x+=(font->chars[0]->width*5);␊
1510␉␉␊
1511␉␉if(font->chars[cha])␊
1512␉␉␉blend(font->chars[cha], blendInto, pos(p.x+x, p.y+y));␊
1513␉␉␊
1514␉␉x += font->chars[cha]->width;␊
1515␉}␊
1516}␊
1517␊
1518void drawStrCenteredAt(char *text, font_t *font, pixmap_t *blendInto, position_t p)␊
1519{␊
1520␉int i = 0;␊
1521␉int width = 0;␊
1522␉␊
1523␉// calculate the width in pixels␊
1524␉for(i=0;i<strlen(text);i++)␊
1525␉␉width += font->chars[text[i]-32]->width;␊
1526␉␊
1527␉p.x = ( p.x - ( width / 2 ) );␊
1528␉p.y = ( p.y - ( font->height / 2 ) ); ␊
1529␉␊
1530␉if ( p.x == -6 )␊
1531␉{␊
1532␉␉p.x = 0;␊
1533␉}␊
1534␉␊
1535␉for(i=0;i<strlen(text);i++)␊
1536␉{␊
1537␉␉int cha=(int)text[i];␊
1538␉␉␊
1539␉␉cha-=32;␊
1540␉␉␊
1541␉␉if(font->chars[cha])␊
1542␉␉{␊
1543␉␉␉blend(font->chars[cha], blendInto, p);␊
1544␉␉␉p.x += font->chars[cha]->width;␊
1545␉␉}␊
1546␉}␊
1547␉␊
1548}␊
1549␊
1550int initFont(font_t *font, image_t *data)␊
1551{␊
1552␉unsigned int x = 0, y = 0, x2 = 0, x3 = 0;␊
1553␉␊
1554␉int start = 0, end = 0, count = 0, space = 0;␊
1555␉␊
1556␉bool monospaced = false;␊
1557␉␊
1558␉font->height = data->image->height;␉␊
1559␉␊
1560␉for( x = 0; x < data->image->width; x++)␊
1561␉{␊
1562␉␉start = end;␊
1563␉␉␊
1564␉␉// if the pixel is red we've reached the end of the char␊
1565␉␉if( pixel( data->image, x, 0 ).value == 0xFFFF0000)␊
1566␉␉{␊
1567␉␉␉end = x + 1;␊
1568␉␉␉␊
1569␉␉␉if( (font->chars[count] = malloc(sizeof(pixmap_t)) ) )␊
1570␉␉␉{␊
1571␉␉␉␉font->chars[count]->width = ( end - start) - 1;␊
1572␉␉␉␉font->chars[count]->height = font->height;␊
1573␉␉␉␉␊
1574␉␉␉␉if ( ( font->chars[count]->pixels = malloc( font->chars[count]->width * data->image->height * 4) ) )␊
1575␉␉␉␉{␊
1576␉␉␉␉␉space += ( font->chars[count]->width * data->image->height * 4 );␊
1577␉␉␉␉␉// we skip the first line because there are just the red pixels for the char width␊
1578␉␉␉␉␉for( y = 1; y< (font->height); y++)␊
1579␉␉␉␉␉{␊
1580␉␉␉␉␉␉for( x2 = (unsigned)start, x3 = 0; x2 < (unsigned)end; x2++, x3++)␊
1581␉␉␉␉␉␉{␊
1582␉␉␉␉␉␉␉pixel( font->chars[count], x3, y ) = pixel( data->image, x2, y );␊
1583␉␉␉␉␉␉}␉␊
1584␉␉␉␉␉}␊
1585␉␉␉␉␉␊
1586␉␉␉␉␉// check if font is monospaced␊
1587␉␉␉␉␉if( ( count > 0 ) && ( font->width != font->chars[count]->width ) )␊
1588␉␉␉␉␉␉monospaced = true;␊
1589␉␉␉␉␉␊
1590␉␉␉␉␉font->width = font->chars[count]->width;␊
1591␉␉␉␉␉␊
1592␉␉␉␉␉count++;␊
1593␉␉␉␉}␊
1594␉␉␉}␊
1595␉␉}␊
1596␉}␊
1597␉␊
1598␉if(monospaced)␊
1599␉␉font->width = 0;␊
1600␉␊
1601␉return 0;␊
1602}␊
1603␊
1604void colorFont(font_t *font, uint32_t color)␊
1605{␊
1606␉if( !color )␊
1607␉␉return;␊
1608␉␊
1609␉int x, y, width, height;␊
1610␉int count = 0;␊
1611␉pixel_t *buff;␊
1612␉␊
1613␉while( font->chars[count++] )␊
1614␉{␊
1615␉␉width = font->chars[count-1]->width;␊
1616␉␉height = font->chars[count-1]->height;␊
1617␉␉for( y = 0; y < height; y++ )␊
1618␉␉{␊
1619␉␉␉for( x = 0; x < width; x++ )␊
1620␉␉␉{␊
1621␉␉␉␉buff = &(pixel( font->chars[count-1], x, y ));␊
1622␉␉␉␉if( buff->ch.a )␊
1623␉␉␉␉{␊
1624␉␉␉␉␉buff->ch.r = (color & 0xFFFF0000) >> 16;␊
1625␉␉␉␉␉buff->ch.g = (color & 0xFF00FF00) >> 8;␊
1626␉␉␉␉␉buff->ch.b = (color & 0xFF0000FF);␊
1627␉␉␉␉}␊
1628␉␉␉}␊
1629␉␉}␊
1630␉}␊
1631}␊
1632␊
1633void makeRoundedCorners(pixmap_t *p)␊
1634{␊
1635␉int x,y;␊
1636␉int width=p->width-1;␊
1637␉int height=p->height-1;␊
1638␉␊
1639␉// 10px rounded corner alpha values␊
1640␉uint8_t roundedCorner[10][10] =␊
1641␉{␊
1642␉␉{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x80, 0xC0, 0xFF},␊
1643␉␉{ 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF},␊
1644␉␉{ 0x00, 0x00, 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1645␉␉{ 0x00, 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1646␉␉{ 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1647␉␉{ 0x00, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1648␉␉{ 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1649␉␉{ 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1650␉␉{ 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1651␉␉{ 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}␊
1652␉};␊
1653␉␊
1654␉uint8_t alpha=0;␊
1655␉␊
1656␉for( y=0; y<10; y++)␊
1657␉{␊
1658␉␉for( x=0; x<10; x++)␊
1659␉␉{␊
1660␉␉␉// skip if the pixel should be visible␊
1661␉␉␉if(roundedCorner[y][x] != 0xFF) ␊
1662␉␉␉{ ␊
1663␉␉␉␉alpha = ( roundedCorner[y][x] ? (uint8_t) (roundedCorner[y][x] * pixel(p, x, y).ch.a) / 255 : 0 );␊
1664␉␉␉␉// Upper left corner␊
1665␉␉␉␉pixel(p, x, y).ch.a = alpha;␊
1666␉␉␉␉␊
1667␉␉␉␉// upper right corner␊
1668␉␉␉␉pixel(p, width-x,y).ch.a = alpha;␊
1669␉␉␉␉␊
1670␉␉␉␉// lower left corner␊
1671␉␉␉␉pixel(p, x, height-y).ch.a = alpha;␊
1672␉␉␉␉␊
1673␉␉␉␉// lower right corner␊
1674␉␉␉␉pixel(p, width-x, height-y).ch.a = alpha;␊
1675␉␉␉}␊
1676␉␉}␊
1677␉}␊
1678}␊
1679␊
1680void showInfoBox(char *title, char *text)␊
1681{␊
1682␉int i, key, lines, visiblelines;␊
1683␉␊
1684␉int currentline=0;␊
1685␉int cnt=0;␊
1686␉int offset=0;␊
1687␉␊
1688␉if( !title || !text )␊
1689␉␉return;␊
1690␉␊
1691␉position_t pos_title = pos ( gui.infobox.vborder, gui.infobox.vborder );␊
1692␉␊
1693␉// calculate number of lines in the title␊
1694␉for ( i = 0, lines = 1; i<strlen(title); i++ )␊
1695␉␉if( title[i] == '\n')␊
1696␉␉␉lines++;␊
1697␉␊
1698␉// y position of text is lines in title * height of font␊
1699␉position_t pos_text = pos( pos_title.x , pos_title.y + ( font_console.height * lines ));␊
1700␉␊
1701␉// calculate number of lines in the text␊
1702␉for ( i=0, lines = 1; i<strlen(text); i++ )␊
1703␉␉if( text[i] == '\n')␊
1704␉␉␉lines++;␊
1705␉␊
1706␉// if text ends with \n strip off␊
1707␉if( text[i] == '\n' || text[i] == '\0')␊
1708␉␉lines--;␊
1709␉␊
1710␉visiblelines = ( ( gui.infobox.height - ( gui.infobox.vborder * 2 ) ) / font_console.height ) - 1;␊
1711␉␊
1712␉// lets display the text and allow scroll thru using up down / arrows␊
1713␉while(1)␊
1714␉{␊
1715␉␉// move to current line in text␊
1716␉␉for( offset = 0, i = 0; offset < strlen(text); offset++ )␊
1717␉␉{␊
1718␉␉␉if( currentline == i)␊
1719␉␉␉␉break;␊
1720␉␉␉if( text[offset] =='\n')␊
1721␉␉␉␉i++;␊
1722␉␉}␊
1723␉␉␊
1724␉␉// find last visible line in text and place \0␊
1725␉␉for( i = offset, cnt = 0; i < strlen(text); i++)␊
1726␉␉{␊
1727␉␉␉if(text[i]=='\n')␊
1728␉␉␉␉cnt++;␊
1729␉␉␉if ( cnt == visiblelines )␊
1730␉␉␉{␊
1731␉␉␉␉text[i]='\0';␊
1732␉␉␉␉break;␊
1733␉␉␉}␊
1734␉␉}␊
1735␉␉␊
1736␉␉fillPixmapWithColor( gui.infobox.pixmap, gui.infobox.bgcolor);␊
1737␉␉␊
1738␉␉makeRoundedCorners( gui.infobox.pixmap);␊
1739␉␉␊
1740␉␉// print the title if present␊
1741␉␉if( title )␊
1742␉␉␉drawStr(title, &font_console, gui.infobox.pixmap, pos_title);␊
1743␉␉␊
1744␉␉// print the text␊
1745␉␉drawStr( text + offset, &font_console, gui.infobox.pixmap, pos_text);␊
1746␉␉␊
1747␉␉// restore \n in text␊
1748␉␉if ( cnt == visiblelines )␊
1749␉␉␉text[i] = '\n';␊
1750␉␉␊
1751␉␉position_t pos_indicator = pos( gui.infobox.width - ( images[iTextScrollPrev].image->width - ( gui.infobox.vborder / 2) ), pos_text.y );␊
1752␉␉␊
1753␉␉// draw prev indicator␊
1754␉␉if(offset)␊
1755␉␉{␊
1756␉␉␉blend( images[iTextScrollPrev].image, gui.infobox.pixmap, centeredAt( images[iTextScrollPrev].image, pos_indicator ));␊
1757␉␉}␊
1758␉␉␊
1759␉␉// draw next indicator␊
1760␉␉if( lines > ( currentline + visiblelines ) )␊
1761␉␉{␊
1762␉␉␉pos_indicator.y = ( gui.infobox.height - ( ( images[iTextScrollNext].image->width + gui.infobox.vborder ) / 2 ) );␊
1763␉␉␉blend( images[iTextScrollNext].image, gui.infobox.pixmap, centeredAt( images[iTextScrollNext].image, pos_indicator ) );␊
1764␉␉}␊
1765␉␉␊
1766␉␉gui.bootprompt.draw = false;␊
1767␉␉gui.infobox.draw = true;␊
1768␉␉gui.redraw = true;␊
1769␉␉␊
1770␉␉updateVRAM();␊
1771␉␉␊
1772␉␉key = getc();␊
1773␉␉␊
1774␉␉if( key == kUpArrowkey )␊
1775␉␉␉if( currentline > 0 )␊
1776␉␉␉␉currentline--;␊
1777␉␉␊
1778␉␉if( key == kDownArrowkey )␊
1779␉␉␉if( lines > ( currentline + visiblelines ) )␊
1780␉␉␉␉currentline++;␊
1781␉␉␊
1782␉␉if( key == kEscapeKey || key == 'q' || key == 'Q')␊
1783␉␉{␊
1784␉␉␉gui.infobox.draw = false;␊
1785␉␉␉gui.redraw = true;␊
1786␉␉␉updateVRAM();␊
1787␉␉␉break;␊
1788␉␉}␊
1789␉}␊
1790}␊
1791␊
1792void animateProgressBar()␊
1793{␊
1794␉int y;␊
1795␉␊
1796␉if( time18() > (unsigned) lasttime)␊
1797␉{␊
1798␉␉lasttime = time18();␊
1799␉␉␊
1800␉␉pixmap_t *buffBar = images[iProgressBar].image;␊
1801␉␉␊
1802␉␉uint32_t buff = buffBar->pixels[0].value;␊
1803␉␉␊
1804␉␉memcpy( buffBar->pixels, buffBar->pixels + 1, ( (buffBar->width*buffBar->height) - 1 ) * 4 );␊
1805␉␉␊
1806␉␉for( y = buffBar->height - 1; y > 0; y--)␊
1807␉␉␉pixel(buffBar, buffBar->width - 1, y) = pixel(buffBar, buffBar->width - 1, y - 1);␊
1808␉␉␊
1809␉␉pixel(buffBar, buffBar->width-1, 0).value = buff;␊
1810␉}␊
1811}␊
1812␊
1813void drawProgressBar(pixmap_t *blendInto, uint16_t width, position_t p, uint8_t progress)␊
1814{␊
1815␉if(progress>100)␊
1816␉␉return;␊
1817␉␊
1818␉p.x = ( p.x - ( width / 2 ) );␊
1819␉␊
1820␉int todraw = (width * progress) / 100;␊
1821␉␊
1822␉pixmap_t *buff = images[iProgressBar].image;␊
1823␉pixmap_t *buffBG = images[iProgressBarBackground].image;␊
1824␉if(!buff || !buffBG)␊
1825␉␉return;␊
1826␉␊
1827␉pixmap_t progressbar;␊
1828␉progressbar.pixels=malloc(width * 4 * buff->height);␊
1829␉if(!progressbar.pixels)␊
1830␉␉return; ␊
1831␉␊
1832␉progressbar.width = width;␊
1833␉progressbar.height = buff->height;␊
1834␉␊
1835␉int x=0,x2=0,y=0;␊
1836␉␊
1837␉for(y=0; y<buff->height; y++)␊
1838␉{␊
1839␉␉for(x=0; x<todraw; x++, x2++)␊
1840␉␉{␊
1841␉␉␉if(x2 == (buff->width-1)) x2=0;␊
1842␉␉␉pixel(&progressbar, x,y).value = pixel(buff, x2,y).value;␊
1843␉␉}␊
1844␉␉x2=0;␊
1845␉}␊
1846␉␊
1847␉for(y=0; y<buff->height; y++)␊
1848␉{␊
1849␉␉for(x=todraw, x2 = 0; x < width - 1; x++, x2++)␊
1850␉␉{␊
1851␉␉␉if(x2 == (buffBG->width -2 )) x2 = 0;␊
1852␉␉␉pixel(&progressbar, x,y).value = pixel(buffBG, x2,y).value;␊
1853␉␉}␊
1854␉␉if(progress < 100)␊
1855␉␉␉pixel(&progressbar, width - 1, y).value = pixel(buffBG, buffBG->width - 1, y).value;␊
1856␉␉if(progress == 0)␊
1857␉␉␉pixel(&progressbar, 0, y).value = pixel(buffBG, buffBG->width - 1, y).value;␊
1858␉␉x2=0;␊
1859␉}␊
1860␉␊
1861␉blend(&progressbar, blendInto, p);␊
1862␉animateProgressBar();␊
1863␉free(progressbar.pixels);␊
1864}␊
1865␊
1866void drawInfoMenuItems()␊
1867{␊
1868␉int i,n;␊
1869␉␊
1870␉position_t position;␊
1871␉␊
1872␉pixmap_t *selection = images[iMenuSelection].image;␊
1873␉␊
1874␉pixmap_t *pbuff;␊
1875␉␊
1876␉fillPixmapWithColor(gui.menu.pixmap, gui.menu.bgcolor);␊
1877␉␊
1878␉makeRoundedCorners(gui.menu.pixmap);␊
1879␉␊
1880␉uint8_t offset = infoMenuNativeBoot ? 0 : infoMenuItemsCount - 1;␊
1881␉␊
1882␉position = pos(0,0);␊
1883␉␊
1884␉for ( i = 0, n = iMenuBoot; i < infoMenuItemsCount; i++, n++)␊
1885␉{␊
1886␉␉if (i == infoMenuSelection)␊
1887␉␉{␊
1888␉␉␉blend(selection, gui.menu.pixmap, position);␊
1889␉␉}␊
1890␉␉␊
1891␉␉pbuff = images[n].image;␊
1892␉␉if (offset && i >= INFOMENU_NATIVEBOOT_START && i <= INFOMENU_NATIVEBOOT_END)␊
1893␉␉{␊
1894␉␉␉blend( images[n + (iMenuHelp - iMenuBoot)].image , gui.menu.pixmap, ␊
1895␉␉␉␉ pos((position.x + (gui.menu.hborder / 2)), position.y + ((selection->height - pbuff->height) / 2)));␊
1896␉␉}␊
1897␉␉else␊
1898␉␉{␊
1899␉␉␉blend( pbuff, gui.menu.pixmap, ␊
1900␉␉␉␉ pos((position.x + (gui.menu.hborder / 2)), position.y + ((selection->height - pbuff->height) / 2)));␊
1901␉␉}␊
1902␉␉␊
1903␉␉drawStr(infoMenuItems[i].text, &font_console, gui.menu.pixmap, ␊
1904␉␉␉␉pos(position.x + (pbuff->width + gui.menu.hborder), ␊
1905␉␉␉␉␉position.y + ((selection->height - font_console.height) / 2)));␊
1906␉␉position.y += images[iMenuSelection].image->height;␊
1907␉␉␊
1908␉}␊
1909␉␊
1910␉gui.redraw = true;␊
1911}␊
1912␊
1913int drawInfoMenu()␊
1914{␊
1915␉drawInfoMenuItems();␊
1916␉␊
1917␉gui.menu.draw = true;␊
1918␉␊
1919␉updateVRAM();␊
1920␉␊
1921␉return 1;␊
1922}␊
1923␊
1924int updateInfoMenu(int key)␊
1925{␊
1926␉switch (key)␊
1927␉{␊
1928␉␉␉␊
1929␉␉case kUpArrowkey:␉// up arrow␊
1930␉␉␉if (infoMenuSelection > 0)␊
1931␉␉␉{␊
1932␉␉␉␉if(!infoMenuNativeBoot && infoMenuSelection == INFOMENU_NATIVEBOOT_END + 1)␊
1933␉␉␉␉{␊
1934␉␉␉␉␉infoMenuSelection -= 4;␊
1935␉␉␉␉}␊
1936␉␉␉␉else␊
1937␉␉␉␉{␊
1938␉␉␉␉␉infoMenuSelection--;␊
1939␉␉␉␉}␊
1940␉␉␉␉drawInfoMenuItems();␊
1941␉␉␉␉updateVRAM();␊
1942␉␉␉␉␊
1943␉␉␉} ␊
1944␉␉␉else ␊
1945␉␉␉{␊
1946␉␉␉␉␊
1947␉␉␉␉gui.menu.draw = false;␊
1948␉␉␉␉gui.redraw = true;␊
1949␉␉␉␉␊
1950␉␉␉␉updateVRAM();␊
1951␉␉␉␉␊
1952␉␉␉␉return CLOSE_INFO_MENU;␊
1953␉␉␉}␊
1954␉␉␉break;␊
1955␉␉␉␊
1956␉␉case kDownArrowkey:␉// down arrow␊
1957␉␉␉if (infoMenuSelection < infoMenuItemsCount - 1)␊
1958␉␉␉{␊
1959␉␉␉␉if(!infoMenuNativeBoot && infoMenuSelection == INFOMENU_NATIVEBOOT_START - 1)␊
1960␉␉␉␉␉infoMenuSelection += 4;␊
1961␉␉␉␉else␊
1962␉␉␉␉␉infoMenuSelection++;␊
1963␉␉␉␉drawInfoMenuItems();␊
1964␉␉␉␉updateVRAM();␊
1965␉␉␉}␊
1966␉␉␉break;␊
1967␉␉␉␊
1968␉␉case kReturnKey:␊
1969␉␉␉key = 0;␊
1970␉␉␉if( infoMenuSelection == MENU_SHOW_MEMORY_INFO )␊
1971␉␉␉␉showInfoBox( "Memory Info. Press q to quit.\n", getMemoryInfoString());␊
1972␉␉␉␊
1973␉␉␉else if( infoMenuSelection == MENU_SHOW_VIDEO_INFO )␊
1974␉␉␉␉showInfoBox( getVBEInfoString(), getVBEModeInfoString() );␊
1975␉␉␉␊
1976␉␉␉else if( infoMenuSelection == MENU_SHOW_HELP )␊
1977␉␉␉␉showHelp();␊
1978␉␉␉␊
1979␉␉␉else␊
1980␉␉␉{␊
1981␉␉␉␉int buff = infoMenuSelection;␊
1982␉␉␉␉infoMenuSelection = 0;␊
1983␉␉␉␉return buff;␊
1984␉␉␉}␊
1985␉␉␉break;␊
1986␉␉default:␊
1987␉␉␉break;␊
1988␉}␊
1989␉return DO_NOT_BOOT;␊
1990}␊
1991␊
1992uint16_t bootImageWidth = 0; ␊
1993uint16_t bootImageHeight = 0; ␊
1994uint8_t *bootImageData = NULL; ␊
1995static bool usePngImage = false;␊
1996␊
1997//==========================================================================␊
1998// loadBootGraphics␊
1999void loadBootGraphics(char *src)␊
2000{␊
2001␉if (bootImageData != NULL) {␊
2002␉␉return;␊
2003␉}␊
2004␉␊
2005␉char dirspec[256];␊
2006␉␊
2007␉if ((unsigned)(strlen(theme_name) + 34) > sizeof(dirspec)) {␊
2008␉␉usePngImage = false; ␊
2009␉␉return;␊
2010␉}␊
2011␉sprintf(dirspec, "%s/%s/boot.png", src, theme_name);␊
2012␉if (strlen(theme_name) == 0 || loadPngImage(dirspec, &bootImageWidth, &bootImageHeight, &bootImageData) != 0) {␊
2013#ifdef EMBED_THEME␊
2014␉␉if ((loadEmbeddedPngImage(__boot_png, __boot_png_len, &bootImageWidth, &bootImageHeight, &bootImageData)) != 0)␊
2015#endif␊
2016␉␉␉usePngImage = false; ␊
2017␉}␊
2018}␊
2019␊
2020//==========================================================================␊
2021// drawBootGraphics␊
2022void drawBootGraphics(void)␊
2023{␊
2024␉int pos;␊
2025␉int length;␊
2026␉const char *dummyVal;␊
2027␉int oldScreenWidth, oldScreenHeight;␊
2028␉uint16_t x, y; ␊
2029␉bool legacy_logo = false;␊
2030␉getBoolForKey("Legacy Logo", &legacy_logo, &bootInfo->bootConfig);␉␊
2031␉if (legacy_logo == false) {␊
2032␉␉usePngImage = true;␊
2033␉␉␊
2034␉␉if (bootImageData == NULL)␊
2035␉␉␉loadBootGraphics(dirsrc);␊
2036␉␉␊
2037␉}␉␉␊
2038␉␊
2039␉␊
2040␉if (execute_hook("getResolution_hook", &screen_params[0], &screen_params[1], &screen_params[2], NULL, NULL, NULL) != EFI_SUCCESS)␉␉␊
2041␉{␉␉␊
2042␉␉// parse screen size parameters␊
2043␉␉if (getIntForKey("boot_width", &pos, &bootInfo->themeConfig) && pos > 0) {␊
2044␉␉␉screen_params[0] = pos;␊
2045␉␉} else {␊
2046␉␉␉screen_params[0] = DEFAULT_SCREEN_WIDTH;␊
2047␉␉}␊
2048␉␉if (getIntForKey("boot_height", &pos, &bootInfo->themeConfig) && pos > 0) {␊
2049␉␉␉screen_params[1] = pos;␊
2050␉␉} else {␊
2051␉␉␉screen_params[1] = DEFAULT_SCREEN_HEIGHT;␊
2052␉␉}␊
2053␉}␉␊
2054␉␊
2055 // Save current screen resolution.␊
2056␉oldScreenWidth = gui.screen.width;␊
2057␉oldScreenHeight = gui.screen.height;␊
2058␉␊
2059␉gui.screen.width = screen_params[0];␊
2060␉gui.screen.height = screen_params[1];␊
2061␉␊
2062␉// find best matching vesa mode for our requested width & height␊
2063␉getGraphicModeParams(screen_params);␊
2064␉␊
2065 // Set graphics mode if the booter was in text mode or the screen resolution has changed.␊
2066␉if (bootArgs->Video.v_display == VGA_TEXT_MODE␊
2067␉␉|| (screen_params[0] != (uint32_t)oldScreenWidth && screen_params[1] != (uint32_t)oldScreenHeight) )␊
2068␉{␊
2069#if UNUSED␊
2070␉␉setVideoMode(GRAPHICS_MODE, 0);␊
2071#else␊
2072␉␉setVideoMode(GRAPHICS_MODE);␊
2073#endif␊
2074␉}␊
2075␉␊
2076␉if (getValueForKey("-checkers", &dummyVal, &length, &bootInfo->bootConfig)) {␊
2077␉␉drawCheckerBoard();␊
2078␉} else {␊
2079␉␉// Fill the background to 75% grey (same as BootX). ␊
2080␉␉drawColorRectangle(0, 0, screen_params[0], screen_params[1], 0x01); ␊
2081␉}␊
2082␉if ((bootImageData) && (usePngImage)) { ␊
2083␉␉x = (screen_params[0] - MIN(bootImageWidth, screen_params[0])) / 2; ␊
2084␉␉y = (screen_params[1] - MIN(bootImageHeight, screen_params[1])) / 2; ␊
2085␉␉␊
2086␉␉// Draw the image in the center of the display. ␊
2087␉␉blendImage(x, y, bootImageWidth, bootImageHeight, bootImageData); ␊
2088␉} else { ␊
2089␉␉uint8_t *appleBootPict; ␊
2090␉␉bootImageData = NULL; ␊
2091␉␉bootImageWidth = kAppleBootWidth; ␊
2092␉␉bootImageHeight = kAppleBootHeight; ␊
2093␉␉␊
2094␉␉// Prepare the data for the default Apple boot image. ␊
2095␉␉appleBootPict = (uint8_t *) decodeRLE(gAppleBootPictRLE, kAppleBootRLEBlocks, bootImageWidth * bootImageHeight); ␊
2096␉␉if (appleBootPict) { ␊
2097␉␉␉convertImage(bootImageWidth, bootImageHeight, appleBootPict, &bootImageData); ␊
2098␉␉␉if (bootImageData) {␉␊
2099␉␉␉␉x = (screen_params[0] - MIN(kAppleBootWidth, screen_params[0])) / 2; ␊
2100␉␉␉␉y = (screen_params[1] - MIN(kAppleBootHeight, screen_params[1])) / 2; ␊
2101␉␉␉␉drawDataRectangle(x, y, kAppleBootWidth, kAppleBootHeight, bootImageData);␊
2102␉␉␉␉free(bootImageData);␊
2103␉␉␉}␊
2104␉␉␉free(appleBootPict); ␊
2105␉␉} ␊
2106␉} ␊
2107}␊
2108␊
2109int GUI_initGraphicsMode ()␊
2110{␊
2111␉unsigned long params[4];␊
2112␉int count;␊
2113␉␊
2114␉params[3] = 0;␊
2115␉count = getNumberArrayFromProperty( kGraphicsModeKey, params, 4 );␊
2116␉␊
2117␉// Try to find a resolution if "Graphics Mode" setting is not available.␊
2118␉if ( count < 3 )␊
2119␉{␊
2120␉␉// Use the default resolution if we don't have an initialized GUI.␊
2121␉␉if (gui.screen.width == 0 || gui.screen.height == 0)␊
2122␉␉{␊
2123␉␉␉gui.screen.width = DEFAULT_SCREEN_WIDTH;␉␊
2124␉␉␉gui.screen.height = DEFAULT_SCREEN_HEIGHT;␊
2125␉␉}␊
2126␉␉␊
2127␉␉params[0] = gui.screen.width;␊
2128␉␉params[1] = gui.screen.height;␊
2129␉␉params[2] = 32;␊
2130␉}␊
2131␉␊
2132␉// Map from pixel format to bits per pixel.␊
2133␉␊
2134␉if ( params[2] == 256 ) params[2] = 8;␊
2135␉if ( params[2] == 555 ) params[2] = 16;␊
2136␉if ( params[2] == 888 ) params[2] = 32;␊
2137␉␊
2138#if UNUSED␊
2139␉return setVESAGraphicsMode( params[0], params[1], params[2], params[3] );␊
2140#else␊
2141␉return setVESAGraphicsMode( params[0], params[1], params[2] );␊
2142#endif␊
2143}␊
2144␊
2145␊
2146int GUI_countdown( const char * msg, int row, int timeout )␊
2147{␊
2148 unsigned long time;␊
2149 register int ch = 0;␊
2150 int col = strlen(msg) + 1;␊
2151␉␊
2152 flushKeyboardBuffer();␊
2153␉␊
2154␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
2155␉{␊
2156␉␉moveCursor( 0, row );␊
2157␉␉printf(msg);␊
2158␉␉␊
2159␉} else {␊
2160␉␉␊
2161␉␉position_t p = pos( gui.screen.width / 2 + 1 , ( gui.devicelist.pos.y + 3 ) + ( ( gui.devicelist.height - gui.devicelist.iconspacing ) / 2 ) );␊
2162␉␉␊
2163␉␉char dummy[80];␊
2164␉␉getBootVolumeDescription( gBootVolume, dummy, sizeof(dummy) - 1, true );␊
2165␉␉drawDeviceIcon( gBootVolume, gui.screen.pixmap, p, true );␊
2166␉␉drawStrCenteredAt( (char *) msg, &font_small, gui.screen.pixmap, gui.countdown.pos );␊
2167␉␉␊
2168␉␉// make this screen the new background␊
2169␉␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
2170␉␉␊
2171␉}␊
2172␉␊
2173␉int multi_buff = 18 * (timeout);␊
2174 int multi = ++multi_buff;␊
2175␉␊
2176 int lasttime=0;␊
2177␉␊
2178 for ( time = time18(), timeout++; timeout > 0; )␊
2179 {␊
2180␉␉if( time18() > (unsigned)lasttime)␊
2181␉␉{␊
2182␉␉␉multi--; ␊
2183␉␉␉lasttime=time18();␊
2184␉␉}␉␉␊
2185␉␉␊
2186 if ((ch = readKeyboardStatus()))␊
2187 break;␊
2188␉␉␊
2189 // Count can be interrupted by holding down shift,␊
2190 // control or alt key␊
2191 if ( ( readKeyboardShiftFlags() & 0x0F ) != 0 )␊
2192␉␉{␊
2193 ch = 1;␊
2194 break;␊
2195 }␊
2196␉␉␊
2197 if ( time18() >= time )␊
2198 {␊
2199 time += 18;␊
2200 timeout--;␊
2201␉␉␉␊
2202␉␉␉if( bootArgs->Video.v_display == VGA_TEXT_MODE )␊
2203␉␉␉{␊
2204␉␉␉␉moveCursor( col, row );␊
2205␉␉␉␉printf("(%d) ", timeout);␊
2206␉␉␉}␊
2207 }␊
2208␉␉␊
2209␉␉if( bootArgs->Video.v_display == GRAPHICS_MODE )␊
2210␉␉{␊
2211␉␉␉drawProgressBar( gui.screen.pixmap, 100, gui.progressbar.pos , ( multi * 100 / multi_buff ) );␊
2212␉␉␉gui.redraw = true;␊
2213␉␉␉updateVRAM();␊
2214␉␉}␊
2215␉␉␊
2216 }␊
2217␉␊
2218 flushKeyboardBuffer();␊
2219␉␊
2220 return ch;␊
2221}␊
2222␊
2223

Archive Download this file

Revision: 1119