Chameleon

Chameleon Svn Source Tree

Root/tags/2.0/i386/boot2/gui.c

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

Archive Download this file

Revision: 1808