Chameleon

Chameleon Svn Source Tree

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

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

Archive Download this file

Revision: 2862