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

Archive Download this file

Revision: 2853