Chameleon

Chameleon Svn Source Tree

Root/branches/diebuche/i386/boot2/gui.c

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

Archive Download this file

Revision: 131