Chameleon

Chameleon Svn Source Tree

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

Archive Download this file

Revision: 2883