Chameleon

Chameleon Svn Source Tree

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

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

Archive Download this file

Revision: 2594