Chameleon

Chameleon Svn Source Tree

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

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

Archive Download this file

Revision: 642