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 "gui.h"␊
12#include "term.h"␊
13#include "appleboot.h"␊
14#include "vers.h"␊
15␊
16#ifndef DEBUG_GUI␊
17␉#define DEBUG_GUI 0␊
18#endif␊
19␊
20#if DEBUG_GUI␊
21␉#define DBG(x...)␉printf(x)␊
22#else␊
23␉#define DBG(x...)␊
24#endif␊
25␊
26#define IMG_REQUIRED -1␊
27#define THEME_NAME_DEFAULT␉"Default"␊
28static const char *theme_name = THEME_NAME_DEFAULT;␊
29␊
30#ifdef CONFIG_EMBED_THEME␊
31#include "art.h"␊
32#endif␊
33␊
34#define LOADPNG(img, alt_img) if (loadThemeImage(#img, alt_img) != 0) { return 1; }␊
35␊
36#define VIDEO(x) (bootArgs->Video.v_ ## x)␊
37␊
38#define vram VIDEO(baseAddr)␊
39␊
40#define TAB_PIXELS_WIDTH (font->chars[0]->width * 4) // tab = 4 spaces␊
41␊
42int lasttime = 0; // we need this for animating maybe␊
43␊
44// ====================================================================␊
45␊
46/*␊
47 * ATTENTION: the enum and the following array images[] MUST match !!!␊
48 */␊
49enum {␊
50␉iBackground = 0,␊
51␉iLogo,␊
52␊
53␉iDeviceGeneric,␊
54␉iDeviceGeneric_o,␊
55␉iDeviceHFS,␊
56␉iDeviceHFS_o,␊
57␊
58␉iDeviceHFS_cap,␊
59␉iDeviceHFS_cap_o,␊
60␉iDeviceHFS_yos,␊
61␉iDeviceHFS_yos_o,␊
62␉iDeviceHFS_mav,␊
63␉iDeviceHFS_mav_o,␊
64␉iDeviceHFS_ML,␊
65␉iDeviceHFS_ML_o,␊
66␉iDeviceHFS_Lion,␊
67␉iDeviceHFS_Lion_o,␊
68␉iDeviceHFS_SL,␊
69␉iDeviceHFS_SL_o,␊
70␉iDeviceHFS_Leo,␊
71␉iDeviceHFS_Leo_o,␊
72␉iDeviceHFS_Tiger,␊
73␉iDeviceHFS_Tiger_o,␊
74␊
75␉iDeviceHFSRAID,␊
76␉iDeviceHFSRAID_o,␊
77␉iDeviceHFSRAID_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_cap,␊
100␉iDeviceHFSFUSION_cap_o,␊
101␉iDeviceHFSFUSION_yos,␊
102␉iDeviceHFSFUSION_yos_o,␊
103␉iDeviceHFSFUSION_mav,␊
104␉iDeviceHFSFUSION_mav_o,␊
105␉iDeviceHFSFUSION_ML,␊
106␉iDeviceHFSFUSION_ML_o,␊
107␊
108␉iDeviceEXT3,␊
109␉iDeviceEXT3_o,␊
110␉iDeviceFreeBSD, /* FreeBSD/OpenBSD detection,nawcom's code by valv, Icon credits to blackosx */␊
111␉iDeviceFreeBSD_o, /* FreeBSD/OpenBSD detection,nawcom's code by valv, Icon credits to blackosx */␊
112␉iDeviceOpenBSD, /* FreeBSD/OpenBSD detection,nawcom's code by valv, Icon credits to blackosx */␊
113␉iDeviceOpenBSD_o, /* FreeBSD/OpenBSD detection,nawcom's code by valv, Icon credits to blackosx */␊
114␉iDeviceBEFS, /* Haiku detection and Icon credits to scorpius */␊
115␉iDeviceBEFS_o, /* Haiku detection and Icon credits to scorpius */␊
116␉iDeviceFAT,␊
117␉iDeviceFAT_o,␊
118␉iDeviceFAT16,␊
119␉iDeviceFAT16_o,␊
120␉iDeviceFAT32,␊
121␉iDeviceFAT32_o,␊
122␉iDeviceNTFS,␊
123␉iDeviceNTFS_o,␊
124␉iDeviceCDROM,␊
125␉iDeviceCDROM_o,␊
126␊
127␉iSelection,␊
128␉iDeviceScrollPrev,␊
129␉iDeviceScrollNext,␊
130␊
131␉iMenuBoot,␊
132␉iMenuVerbose,␊
133␉iMenuIgnoreCaches,␊
134␉iMenuSingleUser,␊
135␉iMenuMemoryInfo,␊
136␉iMenuVideoInfo,␊
137␉iMenuHelp,␊
138␉iMenuVerboseDisabled,␊
139␉iMenuIgnoreCachesDisabled,␊
140␉iMenuSingleUserDisabled,␊
141␉iMenuSelection,␊
142␊
143␉iProgressBar,␊
144␉iProgressBarBackground,␊
145␊
146␉iTextScrollPrev,␊
147␉iTextScrollNext,␊
148␊
149␉iFontConsole,␊
150␉iFontSmall,␊
151};␊
152␊
153// ====================================================================␊
154␊
155image_t images[] = {␊
156␉{.name = "background", .image = NULL},␊
157␉{.name = "logo", .image = NULL},␊
158␊
159␉{.name = "device_generic", .image = NULL},␊
160␉{.name = "device_generic_o", .image = NULL},␊
161␉{.name = "device_hfsplus", .image = NULL},␊
162␉{.name = "device_hfsplus_o", .image = NULL},␊
163␊
164␉{.name = "device_hfsplus_cap", .image = NULL},␊
165␉{.name = "device_hfsplus_cap_o", .image = NULL},␊
166␉{.name = "device_hfsplus_yos", .image = NULL},␊
167␉{.name = "device_hfsplus_yos_o", .image = NULL},␊
168␉{.name = "device_hfsplus_mav", .image = NULL},␊
169␉{.name = "device_hfsplus_mav_o", .image = NULL},␊
170␉{.name = "device_hfsplus_ml", .image = NULL},␊
171␉{.name = "device_hfsplus_ml_o", .image = NULL},␊
172␉{.name = "device_hfsplus_lion", .image = NULL},␊
173␉{.name = "device_hfsplus_lion_o", .image = NULL},␊
174␉{.name = "device_hfsplus_sl", .image = NULL},␊
175␉{.name = "device_hfsplus_sl_o", .image = NULL},␊
176␉{.name = "device_hfsplus_leo", .image = NULL},␊
177␉{.name = "device_hfsplus_leo_o", .image = NULL},␊
178␉{.name = "device_hfsplus_tiger", .image = NULL},␊
179␉{.name = "device_hfsplus_tiger_o", .image = NULL},␊
180␊
181␉{.name = "device_hfsraid", .image = NULL},␊
182␉{.name = "device_hfsraid_o", .image = NULL},␊
183␉{.name = "device_hfsraid_cap", .image = NULL},␊
184␉{.name = "device_hfsraid_cap_o", .image = NULL},␊
185␉{.name = "device_hfsraid_yos", .image = NULL},␊
186␉{.name = "device_hfsraid_yos_o", .image = NULL},␊
187␉{.name = "device_hfsraid_mav", .image = NULL},␊
188␉{.name = "device_hfsraid_mav_o", .image = NULL},␊
189␉{.name = "device_hfsraid_ml", .image = NULL},␊
190␉{.name = "device_hfsraid_ml_o", .image = NULL},␊
191␉{.name = "device_hfsraid_lion", .image = NULL},␊
192␉{.name = "device_hfsraid_lion_o", .image = NULL},␊
193␉{.name = "device_hfsraid_sl", .image = NULL},␊
194␉{.name = "device_hfsraid_sl_o", .image = NULL},␊
195␉{.name = "device_hfsraid_leo", .image = NULL},␊
196␉{.name = "device_hfsraid_leo_o", .image = NULL},␊
197␉{.name = "device_hfsraid_tiger", .image = NULL},␊
198␉{.name = "device_hfsraid_tiger_o", .image = NULL},␊
199␊
200␉{.name = "device_hfsplus_recovery", .image = NULL},␊
201␉{.name = "device_hfsplus_recovery_o", .image = NULL},␊
202␊
203␉{.name = "device_hfsfusion", .image = NULL},␊
204␉{.name = "device_hfsfusion_o", .image = NULL},␊
205␉{.name = "device_hfsfusion_cap", .image = NULL},␊
206␉{.name = "device_hfsfusion_cap_o", .image = NULL},␊
207␉{.name = "device_hfsfusion_yos", .image = NULL},␊
208␉{.name = "device_hfsfusion_yos_o", .image = NULL},␊
209␉{.name = "device_hfsfusion_mav", .image = NULL},␊
210␉{.name = "device_hfsfusion_mav_o", .image = NULL},␊
211␉{.name = "device_hfsfusion_ml", .image = NULL},␊
212␉{.name = "device_hfsfusion_ml_o", .image = NULL},␊
213␊
214␉{.name = "device_ext3", .image = NULL},␊
215␉{.name = "device_ext3_o", .image = NULL},␊
216␉{.name = "device_freebsd", .image = NULL}, /* FreeBSD/OpenBSD detection,nawcom's code by valv, Icon credits to blackosx */␊
217␉{.name = "device_freebsd_o", .image = NULL}, /* FreeBSD/OpenBSD detection,nawcom's code by valv, Icon credits to blackosx */␊
218␉{.name = "device_openbsd", .image = NULL}, /* FreeBSD/OpenBSD detection,nawcom's code by valv, Icon credits to blackosx */␊
219␉{.name = "device_openbsd_o", .image = NULL}, /* FreeBSD/OpenBSD detection,nawcom's code by valv, Icon credits to blackosx */␊
220␉{.name = "device_befs", .image = NULL}, /* Haiku detection and Icon credits to scorpius */␊
221␉{.name = "device_befs_o", .image = NULL}, /* Haiku detection and Icon credits to scorpius */␊
222␉{.name = "device_fat", .image = NULL},␊
223␉{.name = "device_fat_o", .image = NULL},␊
224␉{.name = "device_fat16", .image = NULL},␊
225␉{.name = "device_fat16_o", .image = NULL},␊
226␉{.name = "device_fat32", .image = NULL},␊
227␉{.name = "device_fat32_o", .image = NULL},␊
228␉{.name = "device_ntfs", .image = NULL},␊
229␉{.name = "device_ntfs_o", .image = NULL},␊
230␉{.name = "device_cdrom", .image = NULL},␊
231␉{.name = "device_cdrom_o", .image = NULL},␊
232␊
233␉{.name = "device_selection", .image = NULL},␊
234␉{.name = "device_scroll_prev", .image = NULL},␊
235␉{.name = "device_scroll_next", .image = NULL},␊
236␊
237␉{.name = "menu_boot", .image = NULL},␊
238␉{.name = "menu_verbose", .image = NULL},␊
239␉{.name = "menu_ignore_caches", .image = NULL},␊
240␉{.name = "menu_single_user", .image = NULL},␊
241␉{.name = "menu_memory_info", .image = NULL},␊
242␉{.name = "menu_video_info", .image = NULL},␊
243␉{.name = "menu_help", .image = NULL},␊
244␉{.name = "menu_verbose_disabled", .image = NULL},␊
245␉{.name = "menu_ignore_caches_disabled", .image = NULL},␊
246␉{.name = "menu_single_user_disabled", .image = NULL},␊
247␉{.name = "menu_selection", .image = NULL},␊
248␊
249␉{.name = "progress_bar", .image = NULL},␊
250␉{.name = "progress_bar_background", .image = NULL},␊
251␊
252␉{.name = "text_scroll_prev", .image = NULL},␊
253␉{.name = "text_scroll_next", .image = NULL},␊
254␊
255␉{.name = "font_console", .image = NULL},␊
256␉{.name = "font_small", .image = NULL},␊
257};␊
258␊
259// ====================================================================␊
260␊
261int imageCnt = 0;␊
262␊
263extern int␉gDeviceCount;␊
264extern int␉selectIndex;␊
265␊
266extern MenuItem *menuItems;␊
267␊
268//char prompt[BOOT_STRING_LEN];␊
269extern char gBootArgs[BOOT_STRING_LEN];␊
270␊
271char prompt_text[] = "boot: ";␊
272␊
273menuitem_t infoMenuItems[] =␊
274{␊
275␉{ .text = "Boot" },␊
276␉{ .text = "Boot Verbose" },␊
277␉{ .text = "Boot Ignore Caches" },␊
278␉{ .text = "Boot Single User" },␊
279␉{ .text = "Memory Info" },␊
280␉{ .text = "Video Info" },␊
281␉{ .text = "Help" }␊
282};␊
283␊
284int initFont(font_t *font, image_t *image);␊
285int destroyFont(font_t *font);␊
286void colorFont(font_t *font, uint32_t color);␊
287void makeRoundedCorners(pixmap_t *p);␊
288␊
289static int infoMenuSelection = 0;␊
290static int infoMenuItemsCount = sizeof(infoMenuItems)/sizeof(infoMenuItems[0]);␊
291␊
292static bool infoMenuNativeBoot = false;␊
293␊
294// here we store the used screen resolution␊
295static unsigned long screen_params[4] = {DEFAULT_SCREEN_WIDTH, DEFAULT_SCREEN_HEIGHT, 32, 0};␊
296␊
297static int getImageIndexByName(const char *name)␊
298{␊
299␉int i;␊
300␉for (i = 0; i < sizeof(images) / sizeof(images[0]); i++)␊
301␉{␊
302␉␉if (strncmp(name, images[i].name, sizeof(images[i].name)) == 0)␊
303␉␉{␊
304␉␉␉return i; // found the name␊
305␉␉}␊
306␉}␊
307␉return -1;␊
308}␊
309␊
310#ifdef CONFIG_EMBED_THEME␊
311static int getEmbeddedImageIndexByName(const char *name)␊
312{␊
313␉int upperLimit = sizeof(embeddedImages) / sizeof(embeddedImages[0]) - 1;␊
314␉int lowerLimit = 0;␊
315␉int compareIndex = (upperLimit - lowerLimit) >> 1; // Midpoint␊
316␉int result;␊
317␉␊
318␉// NOTE: This algorithm assumes that the embedded images are sorted.␊
319␉// This is currently done using the make file. If the array is␊
320␉// generated manualy, this *will* fail to work properly.␊
321␉while((result = strncmp(name, embeddedImages[compareIndex].name, sizeof(embeddedImages[compareIndex].name))) != 0)␊
322␉{␊
323␉␉if (result > 0)␉{ // We need to search a HIGHER index␊
324␉␉␉if (compareIndex != lowerLimit) {␊
325␉␉␉␉lowerLimit = compareIndex;␊
326␉␉␉} else {␊
327␉␉␉␉return -1;␊
328␉␉␉}␊
329␉␉␉compareIndex = (upperLimit + lowerLimit + 1) >> 1;␉// Midpoint, round up␊
330␉␉}␊
331␉␉else { // We Need to search a LOWER index␊
332␉␉␉if (compareIndex != upperLimit) {␊
333␉␉␉␉upperLimit = compareIndex;␊
334␉␉␉} else {␊
335␉␉␉␉return -1;␊
336␉␉␉}␊
337␉␉␉compareIndex = (upperLimit + lowerLimit) >> 1;␉// Midpoint, round down␊
338␉␉}␊
339␉}␊
340␉return compareIndex;␊
341}␊
342#endif␊
343␊
344static int loadThemeImage(const char *image, int alt_image)␊
345{␊
346␉char␉␉dirspec[256];␊
347␉int ␉␉i;␊
348#ifdef CONFIG_EMBED_THEME␊
349␉int ␉␉e;␊
350#endif␊
351␉uint16_t␉width;␊
352␉uint16_t␉height;␊
353␉uint8_t␉␉*imagedata;␊
354␊
355␉if ((strlen(image) + strlen(theme_name) + 20) > sizeof(dirspec)) {␊
356␉␉return 1;␊
357␉}␊
358␉if ((i = getImageIndexByName(image)) < 0) {␊
359␉␉return 1;␊
360␉}␊
361␉if (!images[i].image && !(images[i].image = malloc(sizeof(pixmap_t)))) {␊
362␉␉return 1;␊
363␉}␊
364␉sprintf(dirspec, "/Extra/Themes/%s/%s.png", theme_name, image);␊
365␉width = 0;␊
366␉height = 0;␊
367␉imagedata = NULL;␊
368␉if ((loadPngImage(dirspec, &width, &height, &imagedata)) == 0) {␊
369␉␉images[i].image->width = width;␊
370␉␉images[i].image->height = height;␊
371␉␉images[i].image->pixels = (pixel_t *)imagedata;␊
372␉␉flipRB(images[i].image);␊
373␉␉return 0;␊
374␉}␊
375#ifdef CONFIG_EMBED_THEME␊
376␉else if ((e = getEmbeddedImageIndexByName(image)) >= 0) {␊
377␉␉unsigned char *embed_data;␊
378␉␉unsigned int embed_size;␊
379␉␉embed_data = embeddedImages[e].pngdata;␊
380␉␉embed_size = *embeddedImages[e].length;␊
381␊
382␉␉if (loadEmbeddedPngImage(embed_data, embed_size, &width, &height, &imagedata) == 0) {␊
383␉␉␉images[i].image->width = width;␊
384␉␉␉images[i].image->height = height;␊
385␉␉␉images[i].image->pixels = (pixel_t *)imagedata;␊
386␉␉␉flipRB(images[i].image);␊
387␉␉␉return 0;␊
388 }␊
389 }␊
390#endif␊
391 else if (alt_image != IMG_REQUIRED && is_image_loaded(alt_image)) {␊
392 // Using the passed alternate image for non-mandatory images.␊
393 // We don't clone the already existing pixmap, but using its properties instead!␊
394 images[i].image->width = images[alt_image].image->width;␊
395 images[i].image->height = images[alt_image].image->height;␊
396 images[i].image->pixels = images[alt_image].image->pixels;␊
397 return 0;␊
398 }␊
399␊
400␉// If we got here it's an error␊
401#ifndef CONFIG_EMBED_THEME␊
402␉printf("ERROR: GUI: could not open '%s/%s.png'!\n", theme_name, image);␊
403␉sleep(2);␊
404#endif␊
405␉free(images[i].image);␊
406␉images[i].image = NULL;␊
407␉return 1;␊
408}␊
409␊
410// ====================================================================␊
411␊
412static int loadGraphics(void)␊
413{␊
414␉LOADPNG(background, IMG_REQUIRED);␊
415␉LOADPNG(logo, IMG_REQUIRED);␊
416␊
417␉LOADPNG(device_generic, IMG_REQUIRED);␊
418␉LOADPNG(device_generic_o, iDeviceGeneric);␊
419␉LOADPNG(device_hfsplus, iDeviceGeneric);␊
420␉LOADPNG(device_hfsplus_o, iDeviceHFS);␊
421␊
422␉LOADPNG(device_hfsplus_cap, iDeviceHFS);␊
423␉LOADPNG(device_hfsplus_cap_o, iDeviceHFS_cap);␊
424␉LOADPNG(device_hfsplus_yos, iDeviceHFS);␊
425␉LOADPNG(device_hfsplus_yos_o, iDeviceHFS_yos);␊
426␉LOADPNG(device_hfsplus_mav, iDeviceHFS);␊
427␉LOADPNG(device_hfsplus_mav_o, iDeviceHFS_mav);␊
428␉LOADPNG(device_hfsplus_ml, iDeviceHFS);␊
429␉LOADPNG(device_hfsplus_ml_o, iDeviceHFS_ML);␊
430␉LOADPNG(device_hfsplus_lion, iDeviceHFS);␊
431␉LOADPNG(device_hfsplus_lion_o, iDeviceHFS_Lion);␊
432␉LOADPNG(device_hfsplus_sl, iDeviceHFS);␊
433␉LOADPNG(device_hfsplus_sl_o, iDeviceHFS_SL);␊
434␉LOADPNG(device_hfsplus_leo, iDeviceHFS);␊
435␉LOADPNG(device_hfsplus_leo_o, iDeviceHFS_Leo);␊
436␉LOADPNG(device_hfsplus_tiger, iDeviceHFS);␊
437␉LOADPNG(device_hfsplus_tiger_o, iDeviceHFS_Tiger);␊
438␊
439␉LOADPNG(device_hfsraid, iDeviceHFS);␊
440␉LOADPNG(device_hfsraid_o, iDeviceHFSRAID);␊
441␉LOADPNG(device_hfsraid_cap, iDeviceHFSRAID);␊
442␉LOADPNG(device_hfsraid_cap_o, iDeviceHFSRAID_cap);␊
443␉LOADPNG(device_hfsraid_yos, iDeviceHFSRAID);␊
444␉LOADPNG(device_hfsraid_yos_o, iDeviceHFSRAID_yos);␊
445␉LOADPNG(device_hfsraid_mav, iDeviceHFSRAID);␊
446␉LOADPNG(device_hfsraid_mav_o, iDeviceHFSRAID_mav);␊
447␉LOADPNG(device_hfsraid_ml, iDeviceHFSRAID);␊
448␉LOADPNG(device_hfsraid_ml_o, iDeviceHFSRAID_ML);␊
449␉LOADPNG(device_hfsraid_lion, iDeviceHFSRAID);␊
450␉LOADPNG(device_hfsraid_lion_o, iDeviceHFSRAID_Lion);␊
451␉LOADPNG(device_hfsraid_sl, iDeviceHFSRAID);␊
452␉LOADPNG(device_hfsraid_sl_o, iDeviceHFSRAID_SL);␊
453␉LOADPNG(device_hfsraid_leo, iDeviceHFSRAID);␊
454␉LOADPNG(device_hfsraid_leo_o, iDeviceHFSRAID_Leo);␊
455␉LOADPNG(device_hfsraid_tiger, iDeviceHFSRAID);␊
456␉LOADPNG(device_hfsraid_tiger_o, iDeviceHFSRAID_Tiger);␊
457␊
458␉LOADPNG(device_hfsplus_recovery, iDeviceHFS);␊
459␉LOADPNG(device_hfsplus_recovery_o, iDeviceHFSRECOVERY);␊
460␊
461␉LOADPNG(device_hfsfusion, iDeviceHFS);␊
462␉LOADPNG(device_hfsfusion_o, iDeviceHFSFUSION);␊
463␉LOADPNG(device_hfsfusion_cap, iDeviceHFSFUSION);␊
464␉LOADPNG(device_hfsfusion_cap_o, iDeviceHFSFUSION_cap);␊
465␉LOADPNG(device_hfsfusion_yos, iDeviceHFSFUSION);␊
466␉LOADPNG(device_hfsfusion_yos_o, iDeviceHFSFUSION_yos);␊
467␉LOADPNG(device_hfsfusion_mav, iDeviceHFSFUSION);␊
468␉LOADPNG(device_hfsfusion_mav_o, iDeviceHFSFUSION_mav);␊
469␉LOADPNG(device_hfsfusion_ml, iDeviceHFSFUSION);␊
470␉LOADPNG(device_hfsfusion_ml_o, iDeviceHFSFUSION_ML);␊
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␉␉␉␉␉␉default:␊
1125␉␉␉␉␉␉␉devicetype = (device->flags & kBVFlagBooter ? iDeviceHFSRAID : iDeviceHFS);␊
1126␉␉␉␉␉␉␉break;␊
1127␉␉␉␉␉}␊
1128␉␉␉␉}␊
1129␊
1130␉␉␉␉break;␊
1131␊
1132␉␉␉}␊
1133␉␉␉case kPartitionTypeHPFS:␊
1134␉␉␉␉devicetype = iDeviceNTFS;␉␉// Use HPFS / NTFS icon␊
1135␉␉␉␉break;␊
1136␊
1137␉␉␉case kPartitionTypeFAT16:␊
1138␉␉␉␉devicetype = iDeviceFAT16;␉␉// Use FAT16 icon␊
1139␉␉␉␉break;␊
1140␊
1141␉␉␉case kPartitionTypeFAT32:␊
1142␉␉␉␉devicetype = iDeviceFAT32;␉␉// Use FAT32 icon␊
1143␉␉␉␉break;␊
1144␊
1145␉␉␉case kPartitionTypeEXT3:␊
1146␉␉␉␉devicetype = iDeviceEXT3;␉␉// Use EXT2/3 icon␊
1147␉␉␉␉break;␊
1148␊
1149␉␉␉case kPartitionTypeFreeBSD: /* FreeBSD/OpenBSD detection,nawcom's code by valv, Icon credits to blackosx */␊
1150␉␉␉␉devicetype = iDeviceFreeBSD;␉␉// Use FreeBSD icon␊
1151␉␉␉␉break;␊
1152␊
1153␉␉␉case kPartitionTypeOpenBSD: /* FreeBSD/OpenBSD detection,nawcom's code by valv, Icon credits to blackosx */␊
1154␉␉␉␉devicetype = iDeviceOpenBSD;␉␉// Use OpenBSD icon␊
1155␉␉␉␉break;␊
1156␊
1157␉␉␉case kPartitionTypeBEFS: /* Haiku detection and Icon credits to scorpius */␊
1158␉␉␉␉devicetype = iDeviceBEFS;␉␉// Use BEFS / Haiku icon␊
1159␉␉␉␉break;␊
1160␊
1161␉␉␉default:␊
1162␉␉␉␉devicetype = iDeviceGeneric;␉␉// Use Generic icon␊
1163␉␉␉␉break;␊
1164␉␉}␊
1165␉}␊
1166␉␊
1167␉// Draw the selection image and use the next (device_*_o) image for the selected item.␊
1168␉if (isSelected)␊
1169␉{␊
1170␉␉blend(images[iSelection].image, buffer, centeredAt(images[iSelection].image, p));␊
1171␉␉devicetype++; // select override image ␊
1172␉}␊
1173␊
1174␉// draw icon␊
1175␉blend(images[devicetype].image, buffer, centeredAt(images[devicetype].image, p));␊
1176␉␊
1177␉p.y += (images[iSelection].image->height / 2) + font_console.chars[0]->height;␊
1178␉␊
1179␉// draw volume label ␊
1180␉drawStrCenteredAt( device->label, &font_small, buffer, p);␉␊
1181␊
1182}␊
1183␊
1184// ====================================================================␊
1185␊
1186void drawDeviceList (int start, int end, int selection)␊
1187{␊
1188␉int␉␉␉i;␊
1189␉bool␉␉shoWinfo = false;␊
1190␉extern bool showBootBanner;␊
1191␉position_t␉p, p_prev, p_next;␊
1192␊
1193␉//uint8_t␉maxDevices = MIN( gui.maxdevices, menucount );␊
1194␊
1195␉fillPixmapWithColor( gui.devicelist.pixmap, gui.devicelist.bgcolor);␊
1196␊
1197␉makeRoundedCorners( gui.devicelist.pixmap);␊
1198␊
1199␉switch (gui.layout) {␊
1200␊
1201␉␉case VerticalLayout:␊
1202␉␉␉p.x = (gui.devicelist.width /2);␊
1203␉␉␉p.y = ( ( images[iSelection].image->height / 2 ) + images[iDeviceScrollPrev].image->height + gui.devicelist.iconspacing );␊
1204␊
1205␉␉␉// place scroll indicators at top & bottom edges␊
1206␉␉␉p_prev = pos ( gui.devicelist.width / 2 , gui.devicelist.iconspacing );␊
1207␉␉␉p_next = pos ( p_prev.x, gui.devicelist.height - gui.devicelist.iconspacing );␊
1208␉␉␉␊
1209␉␉␉break;␊
1210␉␉␉␊
1211␉␉default:␉// use Horizontal layout as the default␊
1212␊
1213␉␉case HorizontalLayout:␊
1214␉␉␉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;␊
1215␉␉␉p.y = ((gui.devicelist.height - font_console.chars[0]->height ) - images[iSelection].image->height) / 2 + ( images[iSelection].image->height / 2 );␊
1216␊
1217␉␉␉// place scroll indicators at left & right edges␊
1218␉␉␉p_prev = pos ( images[iDeviceScrollPrev].image->width / 2 + gui.devicelist.iconspacing / 2, gui.devicelist.height / 2 );␊
1219␉␉␉p_next = pos ( gui.devicelist.width - ( images[iDeviceScrollNext].image->width / 2 + gui.devicelist.iconspacing / 2), gui.devicelist.height / 2 );␊
1220␉␉␉␊
1221␉␉␉break;␊
1222␉␉␉␊
1223␉}␊
1224␉␊
1225␉// draw visible device icons␊
1226␉for (i = 0; i < gui.maxdevices; i++)␊
1227␉{␊
1228␉␉BVRef param = menuItems[start + i].param;␊
1229␊
1230␉␉bool isSelected = ((start + i) == selection) ? true : false;␊
1231␉␉if (isSelected) {␊
1232␉␉␉if (param->flags & kBVFlagNativeBoot) {␊
1233␉␉␉␉infoMenuNativeBoot = true;␊
1234␉␉␉} else {␊
1235␉␉␉␉infoMenuNativeBoot = false;␊
1236␉␉␉␉if(infoMenuSelection >= INFOMENU_NATIVEBOOT_START && infoMenuSelection <= INFOMENU_NATIVEBOOT_END) {␊
1237␉␉␉␉␉infoMenuSelection = 0;␊
1238␉␉␉␉}␊
1239␉␉␉}␊
1240␊
1241␉␉␉if (gui.menu.draw) {␊
1242␉␉␉␉drawInfoMenuItems();␊
1243␉␉␉}␊
1244␉␉␉getBoolForKey(kShowInfoKey, &shoWinfo, &bootInfo->chameleonConfig);␊
1245␉␉␉␊
1246␉␉␉if (shoWinfo && showBootBanner) {␊
1247␉␉␉␉gui.debug.cursor = pos( 10, 100);␊
1248␉␉␉␉dprintf( &gui.screen, "label: %s\n", param->label );␊
1249␉␉␉␉dprintf( &gui.screen, "biosdev: 0x%x\n", param->biosdev );␊
1250␉␉␉␉dprintf( &gui.screen, "type: 0x%x\n", param->type );␊
1251␉␉␉␉dprintf( &gui.screen, "flags: 0x%x\n", param->flags );␊
1252␉␉␉␉dprintf( &gui.screen, "part_no: %d\n", param->part_no );␊
1253␉␉␉␉dprintf( &gui.screen, "part_boff: 0x%x\n", param->part_boff );␊
1254␉␉␉␉dprintf( &gui.screen, "part_type: 0x%x\n", param->part_type );␊
1255␉␉␉␉dprintf( &gui.screen, "bps: 0x%x\n", param->bps );␊
1256␉␉␉␉dprintf( &gui.screen, "name: %s\n", param->name );␊
1257␉␉␉␉dprintf( &gui.screen, "type_name: %s\n", param->type_name );␊
1258␉␉␉␉dprintf( &gui.screen, "modtime: %d\n", param->modTime );␊
1259//␉␉␉␉// res␊
1260␉␉␉␉dprintf( &gui.screen, "width: %d\n", gui.screen.width );␊
1261␉␉␉␉dprintf( &gui.screen, "height: %d\n", gui.screen.height );␊
1262//␉␉␉␉dprintf( &gui.screen, "attr: 0x%x\n", gui.screen.attr ); //Azi: reminder␊
1263//␉␉␉␉dprintf( &gui.screen, "mm: %d\n", gui.screen.mm );␊
1264␉␉␉}␊
1265␉␉}␊
1266␉␉␊
1267␉␉drawDeviceIcon( param, gui.devicelist.pixmap, p, isSelected);␊
1268␉␉␊
1269␉␉if (gui.layout == HorizontalLayout)␊
1270␉␉{␊
1271␉␉␉p.x += images[iSelection].image->width + gui.devicelist.iconspacing; ␊
1272␉␉}␊
1273␉␉if (gui.layout == VerticalLayout)␊
1274␉␉{␊
1275␉␉␉p.y += ( images[iSelection].image->height + font_console.chars[0]->height + gui.devicelist.iconspacing ); ␊
1276␉␉}␊
1277␉}␊
1278␊
1279␉// draw prev indicator␊
1280␉if (start) {␊
1281␉␉blend( images[iDeviceScrollPrev].image, gui.devicelist.pixmap, centeredAt( images[iDeviceScrollPrev].image, p_prev ) );␊
1282␉}␊
1283␉// draw next indicator␊
1284␉if ( end < gDeviceCount - 1 ) {␊
1285␉␉blend( images[iDeviceScrollNext].image, gui.devicelist.pixmap, centeredAt( images[iDeviceScrollNext].image, p_next ) );␊
1286␉}␊
1287␉gui.redraw = true;␊
1288␉␊
1289␉updateVRAM();␊
1290␉␊
1291}␊
1292␊
1293// ====================================================================␊
1294␊
1295void clearGraphicBootPrompt()␊
1296{␊
1297␉// clear text buffer␊
1298␉//prompt[0] = '\0';␊
1299␉//prompt_pos=0;␊
1300␊
1301␉␊
1302␉if(gui.bootprompt.draw == true )␊
1303␉{␊
1304␉␉gui.bootprompt.draw = false;␊
1305␉␉gui.redraw = true;␊
1306␉␉// this causes extra frames to be drawn␊
1307␉␉//updateVRAM();␊
1308␉}␊
1309␊
1310␉return;␊
1311}␊
1312␊
1313// ====================================================================␊
1314␊
1315void updateGraphicBootPrompt()␊
1316{␊
1317␉fillPixmapWithColor( gui.bootprompt.pixmap, gui.bootprompt.bgcolor);␊
1318␊
1319␉makeRoundedCorners( gui.bootprompt.pixmap);␊
1320␊
1321␉position_t p_text = pos( gui.bootprompt.hborder , ( ( gui.bootprompt.height - font_console.chars[0]->height) ) / 2 );␊
1322␊
1323␉// print the boot prompt text␊
1324␉drawStr(prompt_text, &font_console, gui.bootprompt.pixmap, p_text);␊
1325␉␊
1326␉// get the position of the end of the boot prompt text to display user input␊
1327␉position_t p_prompt = pos( p_text.x + ( ( strlen(prompt_text) ) * font_console.chars[0]->width ), p_text.y );␊
1328␉␊
1329␉drawStr( gBootArgs, &font_console, gui.bootprompt.pixmap, p_prompt);␊
1330␊
1331␉gui.menu.draw = false;␊
1332␉gui.bootprompt.draw = true;␊
1333␉gui.redraw = true;␊
1334␉␊
1335␉updateVRAM();␊
1336␉␊
1337␉return;␊
1338}␊
1339␊
1340// ====================================================================␊
1341␊
1342static inline void vramwrite (void *data, int width, int height)␊
1343{␊
1344␉extern void* memcpy_interruptible(void*, const void*, size_t);␊
1345␉if (VIDEO (depth) == 32 && VIDEO (rowBytes) == gui.backbuffer->width * 4)␊
1346␉{␊
1347␉␉memcpy_interruptible((uint8_t *)vram, gui.backbuffer->pixels, VIDEO (rowBytes)*VIDEO (height));␊
1348␉}␊
1349␉else␊
1350␉{␊
1351␉␉uint32_t r;␊
1352␉␉uint32_t g;␊
1353␉␉uint32_t b;␊
1354␉␉int i, j;␊
1355␉␉for (i = 0; i < VIDEO (height); i++)␊
1356␉␉{␊
1357␉␉␉for (j = 0; j < VIDEO (width); j++)␊
1358␉␉␉{␊
1359␉␉␉␉b = ((uint8_t *) data)[4*i*width + 4*j];␊
1360␉␉␉␉g = ((uint8_t *) data)[4*i*width + 4*j + 1];␊
1361␉␉␉␉r = ((uint8_t *) data)[4*i*width + 4*j + 2];␊
1362␉␉␉␉switch (VIDEO (depth))␊
1363␉␉␉␉{␊
1364␉␉␉␉␉case 32:␊
1365␉␉␉␉␉␉*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*4) = (b&0xff) | ((g&0xff)<<8) | ((r&0xff)<<16);␊
1366␉␉␉␉␉␉break;␊
1367␉␉␉␉␉case 24:␊
1368␉␉␉␉␉␉*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*3) = ((*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*3))&0xff000000)␊
1369␉␉␉␉␉␉| (b&0xff) | ((g&0xff)<<8) | ((r&0xff)<<16);␊
1370␉␉␉␉␉␉break;␊
1371␉␉␉␉␉case 16:␊
1372␉␉␉␉␉␉// Somehow 16-bit is always 15-bits really␊
1373␉␉␉␉␉␉//␉␉␉␉␉␉*(uint16_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*2) = ((b&0xf8)>>3) | ((g&0xfc)<<3) | ((r&0xf8)<<8);␊
1374␉␉␉␉␉␉//␉␉␉␉␉␉break;␉␉␉␉␉␉␉␊
1375␉␉␉␉␉case 15:␊
1376␉␉␉␉␉␉*(uint16_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*2) = ((b&0xf8)>>3) | ((g&0xf8)<<2) | ((r&0xf8)<<7);␊
1377␉␉␉␉␉␉break;␉␊
1378␉␉␉␉␉default:␊
1379␉␉␉␉␉␉break;␊
1380␉␉␉␉}␊
1381␉␉␉}␊
1382␉␉}␊
1383␉}␊
1384}␊
1385␊
1386// ====================================================================␊
1387␊
1388void updateVRAM()␊
1389{␊
1390␉if (gui.redraw)␊
1391␉{␊
1392␉␉if (gui.devicelist.draw)␊
1393␉␉{␊
1394␉␉␉blend( gui.devicelist.pixmap, gui.backbuffer, gui.devicelist.pos );␊
1395␉␉}␊
1396␉␉if (gui.bootprompt.draw)␊
1397␉␉{␊
1398␉␉␉blend( gui.bootprompt.pixmap, gui.backbuffer, gui.bootprompt.pos );␊
1399␉␉}␊
1400␉␉if (gui.menu.draw)␊
1401␉␉{␊
1402␉␉blend( gui.menu.pixmap, gui.backbuffer, gui.menu.pos );␊
1403␉␉}␊
1404␉␉if (gui.infobox.draw)␊
1405␉␉{␊
1406␉␉␉blend( gui.infobox.pixmap, gui.backbuffer, gui.infobox.pos );␊
1407␉␉}␊
1408␉}␊
1409␊
1410␉vramwrite ( gui.backbuffer->pixels, gui.backbuffer->width, gui.backbuffer->height );␊
1411␊
1412␉if (gui.redraw)␊
1413␉{␊
1414␉␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
1415␉␉gui.redraw = false;␊
1416␉}␊
1417}␊
1418␊
1419// ====================================================================␊
1420␊
1421struct putc_info //Azi: exists on console.c & printf.c␊
1422{␊
1423␉char *str;␊
1424␉char *last_str;␊
1425};␊
1426␊
1427// ====================================================================␊
1428␊
1429static int sputc(int c, struct putc_info * pi) //Azi: same as above␊
1430{␊
1431␉if (pi->last_str)␊
1432␉{␊
1433␉␉if (pi->str == pi->last_str)␊
1434␉␉{␊
1435␉␉␉*(pi->str) = '\0';␊
1436␉␉␉return 0;␊
1437␉␉}␊
1438␉}␊
1439␉*(pi->str)++ = c;␊
1440␉return c;␊
1441}␊
1442␊
1443// ====================================================================␊
1444␊
1445int gprintf( window_t * window, const char * fmt, ...)␊
1446{␊
1447␉char *formattedtext;␊
1448␊
1449␉va_list ap;␊
1450␊
1451␉struct putc_info pi;␊
1452␊
1453␉if ((formattedtext = malloc(1024)) != NULL)␊
1454␉{␊
1455␉␉// format the text␊
1456␉␉va_start(ap, fmt);␊
1457␉␉pi.str = formattedtext;␊
1458␉␉pi.last_str = 0;␊
1459␉␉prf(fmt, ap, sputc, &pi);␊
1460␉␉*pi.str = '\0';␊
1461␉␉va_end(ap);␊
1462␉␉␊
1463␉␉position_t␉origin, cursor, bounds;␊
1464␊
1465␉␉int i;␊
1466␉␉int character;␊
1467␊
1468␉␉origin.x = MAX( window->cursor.x, window->hborder );␊
1469␉␉origin.y = MAX( window->cursor.y, window->vborder );␊
1470␉␉␊
1471␉␉bounds.x = ( window->width - window->hborder );␊
1472␉␉bounds.y = ( window->height - window->vborder );␊
1473␉␉␊
1474␉␉cursor = origin;␊
1475␊
1476␉␉font_t *font = &font_console;␊
1477␊
1478␉␉for( i=0; i< strlen(formattedtext); i++ )␊
1479␉␉{␊
1480␉␉␉character = formattedtext[i];␊
1481␉␉␉␊
1482␉␉␉character -= 32;␊
1483␊
1484␉␉␉// newline ?␊
1485␉␉␉if( formattedtext[i] == '\n' )␊
1486␉␉␉{␊
1487␉␉␉␉cursor.x = window->hborder;␊
1488␉␉␉␉cursor.y += font->height;␊
1489␊
1490␉␉␉␉if ( cursor.y > bounds.y )␊
1491␉␉␉␉{␊
1492␉␉␉␉␉cursor.y = origin.y;␊
1493␉␉␉␉}␊
1494␉␉␉␉continue;␊
1495␉␉␉}␊
1496␊
1497␉␉␉// tab ?␊
1498␉␉␉if( formattedtext[i] == '\t' )␊
1499␉␉␉{␊
1500␉␉␉␉cursor.x += ( font->chars[0]->width * 5 );␊
1501␉␉␉}␊
1502␊
1503␉␉␉// draw the character␊
1504␉␉␉if( font->chars[character])␊
1505␉␉␉{␊
1506␉␉␉␉blend(font->chars[character], window->pixmap, cursor);␊
1507␉␉␉}␊
1508␊
1509␉␉␉cursor.x += font->chars[character]->width;␊
1510␊
1511␉␉␉// check x pos and do newline␊
1512␉␉␉if ( cursor.x > bounds.x )␊
1513␉␉␉{␊
1514␉␉␉␉cursor.x = origin.x;␊
1515␉␉␉␉cursor.y += font->height;␊
1516␉␉␉}␊
1517␉␉␉␊
1518␉␉␉// check y pos and reset to origin.y␊
1519␉␉␉if ( cursor.y > bounds.y )␊
1520␉␉␉{␊
1521␉␉␉␉cursor.y = origin.y;␊
1522␉␉␉}␊
1523␉␉}␊
1524␊
1525␉␉// update cursor postition␊
1526␉␉window->cursor = cursor;␊
1527␉␉␊
1528␉␉free(formattedtext);␊
1529␉␉␊
1530␉␉return 0;␊
1531␉}␊
1532␉return 1;␊
1533}␊
1534␊
1535// ====================================================================␊
1536␊
1537int dprintf( window_t * window, const char * fmt, ...)␊
1538{␊
1539␉char *formattedtext;␊
1540␉␊
1541␉va_list ap;␊
1542␊
1543␉//window = &gui.debug;␊
1544␉␊
1545␉struct putc_info pi;␊
1546␊
1547␉if ((formattedtext = malloc(1024)) != NULL)␊
1548␉{␊
1549␉␉// format the text␊
1550␉␉va_start(ap, fmt);␊
1551␉␉pi.str = formattedtext;␊
1552␉␉pi.last_str = 0;␊
1553␉␉prf(fmt, ap, sputc, &pi);␊
1554␉␉*pi.str = '\0';␊
1555␉␉va_end(ap);␊
1556␉␉␊
1557␉␉position_t␉origin, cursor, bounds;␊
1558␊
1559␉␉int i;␊
1560␉␉int character;␊
1561␊
1562␉␉origin.x = MAX( gui.debug.cursor.x, window->hborder );␊
1563␉␉origin.y = MAX( gui.debug.cursor.y, window->vborder );␊
1564␉␉␊
1565␉␉bounds.x = ( window->width - window->hborder );␊
1566␉␉bounds.y = ( window->height - window->vborder );␊
1567␉␉␊
1568␉␉cursor = origin;␊
1569␉␉␊
1570␉␉font_t *font = &font_console;␊
1571␉␉␊
1572␉␉for( i=0; i< strlen(formattedtext); i++ )␊
1573␉␉{␊
1574␉␉␉character = formattedtext[i];␊
1575␉␉␉␊
1576␉␉␉character -= 32;␊
1577␉␉␉␊
1578␉␉␉// newline ?␊
1579␉␉␉if( formattedtext[i] == '\n' )␊
1580␉␉␉{␊
1581␉␉␉␉cursor.x = window->hborder;␊
1582␉␉␉␉cursor.y += font->height;␊
1583␉␉␉␉␊
1584␉␉␉␉if ( cursor.y > bounds.y )␊
1585␉␉␉␉{␊
1586␉␉␉␉␉cursor.y = origin.y;␊
1587␉␉␉␉}␊
1588␉␉␉␉continue;␊
1589␉␉␉}␊
1590␉␉␉␊
1591␉␉␉// tab ?␊
1592␉␉␉if( formattedtext[i] == '\t' )␊
1593␉␉␉{␊
1594␉␉␉␉cursor.x += ( font->chars[0]->width * 5 );␊
1595␉␉␉}␊
1596␉␉␉// draw the character␊
1597␉␉␉if( font->chars[character])␊
1598␉␉␉{␊
1599␉␉␉␉blend(font->chars[character], gui.backbuffer, cursor);␊
1600␉␉␉}␊
1601␉␉␉cursor.x += font->chars[character]->width;␊
1602␉␉␉␊
1603␉␉␉// check x pos and do newline␊
1604␉␉␉if ( cursor.x > bounds.x )␊
1605␉␉␉{␊
1606␉␉␉␉cursor.x = origin.x;␊
1607␉␉␉␉cursor.y += font->height;␊
1608␉␉␉}␊
1609␉␉␉␊
1610␉␉␉// check y pos and reset to origin.y␊
1611␉␉␉if ( cursor.y > bounds.y )␊
1612␉␉␉{␊
1613␉␉␉␉cursor.y = origin.y;␊
1614␉␉␉}␊
1615␉␉}␊
1616␉␉␊
1617␉␉// update cursor postition␊
1618␉␉gui.debug.cursor = cursor;␊
1619␉␉␊
1620␉␉free(formattedtext);␊
1621␉␉␊
1622␉␉return 0;␊
1623␉␉␊
1624␉}␊
1625␉return 1;␊
1626}␊
1627␊
1628// ====================================================================␊
1629␊
1630int vprf(const char * fmt, va_list ap)␊
1631{␊
1632␉int i;␊
1633␉int character;␊
1634␊
1635␉char *formattedtext;␊
1636␉window_t *window = &gui.screen;␊
1637␉struct putc_info pi;␊
1638␉␊
1639␉position_t␉origin, cursor, bounds;␊
1640␉font_t *font = &font_console;␊
1641␉␊
1642␉if ((formattedtext = malloc(1024)) != NULL)␊
1643␉{␊
1644␉␉// format the text␊
1645␉␉pi.str = formattedtext;␊
1646␉␉pi.last_str = 0;␊
1647␉␉prf(fmt, ap, sputc, &pi);␊
1648␉␉*pi.str = '\0';␊
1649␉␉␊
1650␉␉origin.x = MAX( window->cursor.x, window->hborder );␊
1651␉␉origin.y = MAX( window->cursor.y, window->vborder );␊
1652␉␉bounds.x = ( window->width - ( window->hborder * 2 ) );␊
1653␉␉bounds.y = ( window->height - ( window->vborder * 2 ) );␊
1654␉␉cursor = origin;␊
1655␊
1656␉␉for( i=0; i< strlen(formattedtext) ; i++ )␊
1657␉␉{␊
1658␉␉␉character = formattedtext[i];␊
1659␉␉␉character -= 32;␊
1660␉␉␉␊
1661␉␉␉// newline ?␊
1662␉␉␉if( formattedtext[i] == '\n' )␊
1663␉␉␉{␊
1664␉␉␉␉cursor.x = window->hborder;␊
1665␉␉␉␉cursor.y += font->height;␊
1666␉␉␉␉if ( cursor.y > bounds.y )␊
1667␉␉␉␉{␊
1668␉␉␉␉␉gui.redraw = true;␊
1669␉␉␉␉␉updateVRAM();␊
1670␉␉␉␉␉cursor.y = window->vborder;␊
1671␉␉␉␉}␊
1672␉␉␉␉window->cursor.y = cursor.y;␊
1673␉␉␉␉continue;␊
1674␉␉␉}␊
1675␊
1676␉␉␉// tab ?␊
1677␉␉␉if( formattedtext[i] == '\t' )␊
1678␉␉␉{␊
1679␉␉␉␉cursor.x = ( cursor.x / ( font->chars[0]->width * 8 ) + 1 ) * ( font->chars[0]->width * 8 );␊
1680␉␉␉␉continue;␊
1681␉␉␉}␊
1682␉␉␉cursor.x += font->chars[character]->width;␊
1683␉␉␉␊
1684␉␉␉// check x pos and do newline␊
1685␉␉␉if ( cursor.x > bounds.x )␊
1686␉␉␉{␊
1687␉␉␉␉cursor.x = origin.x;␊
1688␉␉␉␉cursor.y += font->height;␊
1689␉␉␉}␊
1690␊
1691␉␉␉// check y pos and reset to origin.y␊
1692␉␉␉if ( cursor.y > ( bounds.y + font->chars[0]->height) )␊
1693␉␉␉{␊
1694␉␉␉␉gui.redraw = true;␊
1695␉␉␉␉updateVRAM();␊
1696␉␉␉␉cursor.y = window->vborder;␊
1697␉␉␉}␊
1698␉␉␉// draw the character␊
1699␉␉␉if( font->chars[character])␊
1700␉␉␉{␊
1701␉␉␉␉blend(font->chars[character], gui.backbuffer, cursor);␊
1702␉␉␉}␊
1703␉␉}␊
1704␉␉// save cursor postition␊
1705␉␉window->cursor.x = cursor.x;␊
1706␉␉updateVRAM();␊
1707␉␉free(formattedtext);␊
1708␉␉return 0;␊
1709␉}␊
1710␉return 1;␊
1711}␊
1712␊
1713// ====================================================================␊
1714␊
1715pixmap_t *charToPixmap(unsigned char ch, font_t *font)␊
1716{␊
1717␉unsigned int cha = (unsigned int)ch - 32;␊
1718␉if (cha >= font->count)␊
1719␉{␊
1720␉␉// return ? if the font for the char doesn't exists␊
1721␉␉cha = '?' - 32;␊
1722␉}␊
1723␉return font->chars[cha] ? font->chars[cha] : NULL;␊
1724}␊
1725␊
1726// ====================================================================␊
1727␊
1728position_t drawChar(unsigned char ch, font_t *font, pixmap_t *blendInto, position_t p)␊
1729{␊
1730␉pixmap_t* pm = charToPixmap(ch, font);␊
1731␉if (pm && ((p.x + pm->width) < blendInto->width))␊
1732␉{␊
1733␉␉blend(pm, blendInto, p);␊
1734␉␉return pos(p.x + pm->width, p.y);␊
1735␉}␊
1736␉else␊
1737␉{␊
1738␉␉return p;␊
1739␉}␊
1740}␊
1741␊
1742// ====================================================================␊
1743␊
1744void drawStr(char *ch, font_t *font, pixmap_t *blendInto, position_t p)␊
1745{␊
1746␉int i=0;␊
1747␉position_t current_pos = pos(p.x, p.y);␊
1748␉␊
1749␉for (i=0; i < strlen(ch); i++)␊
1750␉{␊
1751␉␉// newline ?␊
1752␉␉if ( ch[i] == '\n' )␊
1753␉␉{␊
1754␉␉␉current_pos.x = p.x;␊
1755␉␉␉current_pos.y += font->height;␊
1756␉␉␉continue;␊
1757␉␉}␊
1758␉␉␊
1759␉␉// tab ?␊
1760␉␉if ( ch[i] == '\t' )␊
1761␉␉{␊
1762␉␉␉current_pos.x += TAB_PIXELS_WIDTH;␊
1763␉␉␉continue;␊
1764␉␉}␊
1765␉␉␊
1766␉␉current_pos = drawChar(ch[i], font, blendInto, current_pos);␊
1767␉}␊
1768}␊
1769␊
1770// ====================================================================␊
1771␊
1772void drawStrCenteredAt(char *text, font_t *font, pixmap_t *blendInto, position_t p)␊
1773{␊
1774␉int i = 0;␊
1775␉int width = 0;␊
1776␉int max_width = 0;␊
1777␉int height = font->height;␊
1778␊
1779␉// calculate the width in pixels␊
1780␉for (i=0; i < strlen(text); i++)␊
1781␉{␊
1782␉␉if (text[i] == '\n')␊
1783␉␉{␊
1784␉␉␉width = 0;␊
1785␉␉␉height += font->height;␊
1786␉␉}␊
1787␉␉else if (text[i] == '\t')␊
1788␉␉{␊
1789␉␉␉width += TAB_PIXELS_WIDTH;␊
1790␉␉}␊
1791␉␉else␊
1792␉␉{␊
1793␉␉␉pixmap_t* pm = charToPixmap(text[i], font);␊
1794␉␉␉if (pm)␊
1795␉␉␉{␊
1796␉␉␉␉width += pm->width;␊
1797␉␉␉}␊
1798␉␉}␊
1799␉␉if (width > max_width)␊
1800␉␉{␊
1801␉␉␉max_width = width;␊
1802␉␉}␊
1803␉}␊
1804␊
1805␉p.x = ( p.x - ( max_width / 2 ) );␊
1806␉p.y = ( p.y - ( height / 2 ) );␊
1807␉␊
1808␉drawStr(text, font, blendInto, p);␊
1809}␊
1810␊
1811// ====================================================================␊
1812␊
1813int destroyFont(font_t *font)␊
1814{␊
1815␉int i;␊
1816␉for (i = 0; i < CHARACTERS_COUNT; i++)␊
1817␉{␊
1818␉␉if (font->chars[i])␊
1819␉␉{␊
1820␉␉␉if (font->chars[i]->pixels)␊
1821␉␉␉{␊
1822␉␉␉␉free (font->chars[i]->pixels);␊
1823␉␉␉}␊
1824␉␉␉free (font->chars[i]);␊
1825␉␉␉font->chars[i] = 0;␊
1826␉␉}␊
1827␉}␊
1828␉return 0;␊
1829}␊
1830␊
1831// ====================================================================␊
1832␊
1833int initFont(font_t *font, image_t *data)␊
1834{␊
1835␉unsigned int x = 0, y = 0, x2 = 0, x3 = 0;␊
1836␉␊
1837␉int start = 0, end = 0, count = 0, space = 0;␊
1838␉␊
1839␉bool monospaced = false;␊
1840␉␊
1841␉font->height = data->image->height;␊
1842␊
1843␉for( x = 0; x < data->image->width && count < CHARACTERS_COUNT; x++)␊
1844␉{␊
1845␉␉start = end;␊
1846␊
1847␉␉// if the pixel is red we've reached the end of the char␊
1848␉␉if( pixel( data->image, x, 0 ).value == 0xFFFF0000)␊
1849␉␉{␊
1850␉␉␉end = x + 1;␊
1851␊
1852␉␉␉if( (font->chars[count] = malloc(sizeof(pixmap_t)) ) )␊
1853␉␉␉{␊
1854␉␉␉␉font->chars[count]->width = ( end - start) - 1;␊
1855␉␉␉␉font->chars[count]->height = font->height;␊
1856␊
1857␉␉␉␉if ( ( font->chars[count]->pixels = malloc( font->chars[count]->width * data->image->height * 4) ) )␊
1858␉␉␉␉{␊
1859␉␉␉␉␉space += ( font->chars[count]->width * data->image->height * 4 );␊
1860␉␉␉␉␉// we skip the first line because there are just the red pixels for the char width␊
1861␉␉␉␉␉for( y = 1; y< (font->height); y++)␊
1862␉␉␉␉␉{␊
1863␉␉␉␉␉␉for( x2 = start, x3 = 0; x2 < end; x2++, x3++)␊
1864␉␉␉␉␉␉{␊
1865␉␉␉␉␉␉␉pixel( font->chars[count], x3, y ) = pixel( data->image, x2, y );␊
1866␉␉␉␉␉␉}␉␊
1867␉␉␉␉␉}␊
1868␊
1869␉␉␉␉␉// check if font is monospaced␊
1870␉␉␉␉␉if( ( count > 0 ) && ( font->width != font->chars[count]->width ) )␊
1871␉␉␉␉␉{␊
1872␉␉␉␉␉␉monospaced = true;␊
1873␉␉␉␉␉}␊
1874␊
1875␉␉␉␉␉font->width = font->chars[count]->width;␊
1876␊
1877␉␉␉␉␉count++;␊
1878␉␉␉␉}␊
1879␉␉␉}␊
1880␉␉}␊
1881␉}␊
1882␊
1883␉for (x = count; x < CHARACTERS_COUNT; x++)␊
1884␉{␊
1885␉␉font->chars[x] = NULL;␊
1886␉}␊
1887␊
1888␉if(monospaced)␊
1889␉{␊
1890␉␉font->width = 0;␊
1891␉}␊
1892␊
1893␉font->count = count;␊
1894␊
1895␉return 0;␊
1896}␊
1897␊
1898// ====================================================================␊
1899␊
1900void colorFont(font_t *font, uint32_t color)␊
1901{␊
1902␉if( !color )␊
1903␉{␊
1904␉␉return;␊
1905␉}␊
1906␊
1907␉int x, y, width, height;␊
1908␉int count = 0;␊
1909␉pixel_t *buff;␊
1910␉␊
1911␉while( font->chars[count++] )␊
1912␉{␊
1913␉␉width = font->chars[count-1]->width;␊
1914␉␉height = font->chars[count-1]->height;␊
1915␉␉for( y = 0; y < height; y++ )␊
1916␉␉{␊
1917␉␉␉for( x = 0; x < width; x++ )␊
1918␉␉␉{␊
1919␉␉␉␉buff = &(pixel( font->chars[count-1], x, y ));␊
1920␉␉␉␉if( buff->ch.a )␊
1921␉␉␉␉{␊
1922␉␉␉␉␉buff->ch.r = (color & 0xFFFF0000) >> 16;␊
1923␉␉␉␉␉buff->ch.g = (color & 0xFF00FF00) >> 8;␊
1924␉␉␉␉␉buff->ch.b = (color & 0xFF0000FF);␊
1925␉␉␉␉}␊
1926␉␉␉}␊
1927␉␉}␊
1928␉}␊
1929}␊
1930␊
1931// ====================================================================␊
1932␊
1933void makeRoundedCorners(pixmap_t *p)␊
1934{␊
1935␉int x,y;␊
1936␉int width=p->width-1;␊
1937␉int height=p->height-1;␊
1938␉␊
1939␉// 10px rounded corner alpha values␊
1940␉uint8_t roundedCorner[10][10] =␊
1941␉{␊
1942␉␉{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x80, 0xC0, 0xFF},␊
1943␉␉{ 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF},␊
1944␉␉{ 0x00, 0x00, 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1945␉␉{ 0x00, 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1946␉␉{ 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1947␉␉{ 0x00, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1948␉␉{ 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1949␉␉{ 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1950␉␉{ 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1951␉␉{ 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}␊
1952␉};␊
1953␉␊
1954␉uint8_t alpha=0;␊
1955␉␊
1956␉for( y=0; y<10; y++)␊
1957␉{␊
1958␉␉for( x=0; x<10; x++)␊
1959␉␉{␊
1960␉␉␉// skip if the pixel should be visible␊
1961␉␉␉if(roundedCorner[y][x] != 0xFF)␊
1962␉␉␉{ ␊
1963␉␉␉␉alpha = ( roundedCorner[y][x] ? (uint8_t) (roundedCorner[y][x] * pixel(p, x, y).ch.a) / 255 : 0 );␊
1964␉␉␉␉// Upper left corner␊
1965␉␉␉␉pixel(p, x, y).ch.a = alpha;␊
1966␊
1967␉␉␉␉// upper right corner␊
1968␉␉␉␉pixel(p, width-x,y).ch.a = alpha;␊
1969␊
1970␉␉␉␉// lower left corner␊
1971␉␉␉␉pixel(p, x, height-y).ch.a = alpha;␊
1972␊
1973␉␉␉␉// lower right corner␊
1974␉␉␉␉pixel(p, width-x, height-y).ch.a = alpha;␊
1975␉␉␉}␊
1976␉␉}␊
1977␉}␊
1978}␊
1979␊
1980// ====================================================================␊
1981␊
1982void showInfoBox(char *title, char *text_orig)␊
1983{␊
1984␉char* text;␊
1985␉int i, key, lines, visiblelines;␊
1986␊
1987␉int currentline=0;␊
1988␉int cnt=0;␊
1989␉int offset=0;␊
1990␉␊
1991␉if( !title || !text_orig ) {␊
1992␉␉return;␊
1993␉}␊
1994␊
1995␉// Create a copy so that we don't mangle the original␊
1996␉text = malloc(strlen(text_orig) + 1);␊
1997␉strcpy(text, text_orig);␊
1998␊
1999␉position_t pos_title = pos ( gui.infobox.vborder, gui.infobox.vborder );␊
2000␊
2001␉// calculate number of lines in the title␊
2002␉for ( i = 0, lines = 1; i<strlen(title); i++ ) {␊
2003␉␉if( title[i] == '\n') {␊
2004␉␉␉lines++;␊
2005␉␉}␊
2006␉}␊
2007␉// y position of text is lines in title * height of font␊
2008␉position_t pos_text = pos( pos_title.x , pos_title.y + ( font_console.height * lines ));␊
2009␉␊
2010␉// calculate number of lines in the text␊
2011␉for ( i=0, lines = 1; i<strlen(text); i++ ) {␊
2012␉␉if( text[i] == '\n') {␊
2013␉␉␉lines++;␊
2014␉␉}␊
2015␉}␊
2016␉// if text ends with \n strip off␊
2017␉if( text[i] == '\n' || text[i] == '\0') {␊
2018␉␉lines--;␊
2019␉}␊
2020␉visiblelines = ( ( gui.infobox.height - ( gui.infobox.vborder * 2 ) ) / font_console.height ) - 1;␊
2021␉␊
2022␉// lets display the text and allow scroll thru using up down / arrows␊
2023␉while(1)␊
2024␉{␊
2025␉␉// move to current line in text␊
2026␉␉for( offset = 0, i = 0; offset < strlen(text); offset++ )␊
2027␉␉{␊
2028␉␉␉if( currentline == i)␊
2029␉␉␉{␊
2030␉␉␉␉break;␊
2031␉␉␉}␊
2032␊
2033␉␉␉if( text[offset] =='\n')␊
2034␉␉␉{␊
2035␉␉␉␉i++;␊
2036␉␉␉}␊
2037␉␉}␊
2038␊
2039␉␉// find last visible line in text and place \0␊
2040␉␉for( i = offset, cnt = 0; i < strlen(text); i++)␊
2041␉␉{␊
2042␉␉␉if(text[i]=='\n')␊
2043␉␉␉{␊
2044␉␉␉␉cnt++;␊
2045␉␉␉}␊
2046␊
2047␉␉␉if ( cnt == visiblelines )␊
2048␉␉␉{␊
2049␉␉␉␉text[i]='\0';␊
2050␉␉␉␉break;␊
2051␉␉␉}␊
2052␉␉}␊
2053␊
2054␉␉fillPixmapWithColor( gui.infobox.pixmap, gui.infobox.bgcolor);␊
2055␊
2056␉␉makeRoundedCorners( gui.infobox.pixmap);␊
2057␊
2058␉␉// print the title if present␊
2059␉␉if( title ) {␊
2060␉␉␉drawStr(title, &font_console, gui.infobox.pixmap, pos_title);␊
2061␉␉}␊
2062␉␉// print the text␊
2063␉␉drawStr( text + offset, &font_console, gui.infobox.pixmap, pos_text);␊
2064␊
2065␉␉// restore \n in text␊
2066␉␉if ( cnt == visiblelines ) {␊
2067␉␉␉text[i] = '\n';␊
2068␉␉}␊
2069␉␉position_t pos_indicator = pos( gui.infobox.width - ( images[iTextScrollPrev].image->width - ( gui.infobox.vborder / 2) ), pos_text.y );␊
2070␉␉␊
2071␉␉// draw prev indicator␊
2072␉␉if(offset)␊
2073␉␉{␊
2074␉␉␉blend( images[iTextScrollPrev].image, gui.infobox.pixmap, centeredAt( images[iTextScrollPrev].image, pos_indicator ));␊
2075␉␉}␊
2076␉␉␊
2077␉␉// draw next indicator␊
2078␉␉if( lines > ( currentline + visiblelines ) )␊
2079␉␉{␊
2080␉␉␉pos_indicator.y = ( gui.infobox.height - ( ( images[iTextScrollNext].image->width + gui.infobox.vborder ) / 2 ) );␊
2081␉␉␉blend( images[iTextScrollNext].image, gui.infobox.pixmap, centeredAt( images[iTextScrollNext].image, pos_indicator ) );␊
2082␉␉}␊
2083␊
2084␉␉gui.bootprompt.draw = false;␊
2085␉␉gui.infobox.draw = true;␊
2086␉␉gui.redraw = true;␊
2087␉␉␊
2088␉␉updateVRAM();␊
2089␉␉␊
2090␉␉key = getchar();␊
2091␊
2092␉␉if( key == KEY_UP ) {␊
2093␉␉␉if( currentline > 0 ) {␊
2094␉␉␉␉currentline--;␊
2095␉␉␉}␊
2096␉␉}␊
2097␊
2098␉␉if( key == KEY_DOWN ) {␊
2099␉␉␉if( lines > ( currentline + visiblelines ) ) {␊
2100␉␉␉␉currentline++;␊
2101␉␉␉}␊
2102␉␉}␊
2103␊
2104␉␉if( key == KEY_ESC || key == 'q' || key == 'Q') {␊
2105␉␉␉gui.infobox.draw = false;␊
2106␉␉␉gui.redraw = true;␊
2107␉␉␉updateVRAM();␊
2108␉␉␉break;␊
2109␉␉}␊
2110␊
2111␉␉if(key == ' ') { // spacebar = next page␊
2112␉␉␉if( lines > ( currentline + visiblelines ) ) {␊
2113␉␉␉␉currentline += visiblelines;␊
2114␉␉␉}␊
2115␉␉␉if(lines < (currentline + visiblelines)) {␊
2116␉␉␉␉currentline = lines - visiblelines;␊
2117␉␉␉}␊
2118␉␉}␊
2119␉}␊
2120␉free(text);␊
2121}␊
2122␊
2123// ====================================================================␊
2124␊
2125#if UNUSED␊
2126void animateProgressBar()␊
2127{␊
2128␉int y;␊
2129␉␊
2130␉if( time18() > lasttime)␊
2131␉{␊
2132␉␉lasttime = time18();␊
2133␊
2134␉␉pixmap_t *buffBar = images[iProgressBar].image;␊
2135␊
2136␉␉uint32_t buff = buffBar->pixels[0].value;␊
2137␉␊
2138␉␉memcpy( buffBar->pixels, buffBar->pixels + 1, ( (buffBar->width*buffBar->height) - 1 ) * 4 );␊
2139␊
2140␉␉for( y = buffBar->height - 1; y > 0; y--) {␊
2141␉␉␉pixel(buffBar, buffBar->width - 1, y) = pixel(buffBar, buffBar->width - 1, y - 1);␊
2142␉␉}␊
2143␉␉pixel(buffBar, buffBar->width-1, 0).value = buff;␊
2144␉}␊
2145}␊
2146#endif␊
2147␊
2148// ====================================================================␊
2149␊
2150void drawProgressBar(pixmap_t *blendInto, uint16_t width, position_t p, uint8_t progress)␊
2151{␊
2152␉if(progress>100) {␊
2153␉␉return;␊
2154␉}␊
2155␊
2156␉p.x = ( p.x - ( width / 2 ) );␊
2157␊
2158␉int todraw = (width * progress) / 100;␊
2159␊
2160␉pixmap_t *buff = images[iProgressBar].image;␊
2161␉pixmap_t *buffBG = images[iProgressBarBackground].image;␊
2162␉if(!buff || !buffBG) {␊
2163␉␉return;␊
2164␉}␊
2165␊
2166␉pixmap_t progressbar;␊
2167␉progressbar.pixels=malloc(width * 4 * buff->height);␊
2168␉if(!progressbar.pixels) {␊
2169␉␉return; ␊
2170␉}␊
2171␊
2172␉progressbar.width = width;␊
2173␉progressbar.height = buff->height;␊
2174␊
2175␉int x=0,x2=0,y=0;␊
2176␉␊
2177␉for(y=0; y<buff->height; y++) {␊
2178␉␉for(x=0; x<todraw; x++, x2++) {␊
2179␉␉␉if(x2 == (buff->width-1)) {␊
2180␉␉␉␉x2=0;␊
2181␉␉␉}␊
2182␉␉␉pixel(&progressbar, x,y).value = pixel(buff, x2,y).value;␊
2183␉␉}␊
2184␉␉x2=0;␊
2185␉}␊
2186␊
2187␉for(y=0; y<buff->height; y++) {␊
2188␉␉for(x=todraw, x2 = 0; x < width - 1; x++, x2++) {␊
2189␉␉␉if(x2 == (buffBG->width -2 )) {␊
2190␉␉␉␉x2 = 0;␊
2191␉␉␉}␊
2192␉␉␉pixel(&progressbar, x,y).value = pixel(buffBG, x2,y).value;␊
2193␉␉}␊
2194␉␉if(progress < 100) {␊
2195␉␉␉pixel(&progressbar, width - 1, y).value = pixel(buffBG, buffBG->width - 1, y).value;␊
2196␉␉}␊
2197␊
2198␉␉if(progress == 0) {␊
2199␉␉␉pixel(&progressbar, 0, y).value = pixel(buffBG, buffBG->width - 1, y).value;␊
2200␉␉}␊
2201␊
2202␉␉x2=0;␊
2203␉}␊
2204␊
2205␉blend(&progressbar, blendInto, p);␊
2206#if 0␊
2207␉animateProgressBar();␊
2208#endif␊
2209␉free(progressbar.pixels);␊
2210}␊
2211␊
2212// ====================================================================␊
2213␊
2214void drawInfoMenuItems()␊
2215{␊
2216␉int i,n;␊
2217␉␊
2218␉position_t position;␊
2219␉␊
2220␉pixmap_t *selection = images[iMenuSelection].image;␊
2221␉␊
2222␉pixmap_t *pbuff;␊
2223␊
2224␉fillPixmapWithColor(gui.menu.pixmap, gui.menu.bgcolor);␊
2225␊
2226␉makeRoundedCorners(gui.menu.pixmap);␊
2227␉␊
2228␉uint8_t offset = infoMenuNativeBoot ? 0 : infoMenuItemsCount - 1;␊
2229␊
2230␉position = pos(0,0);␊
2231␉␊
2232␉for ( i = 0, n = iMenuBoot; i < infoMenuItemsCount; i++, n++) {␊
2233␉␉if (i == infoMenuSelection) {␊
2234␉␉␉blend(selection, gui.menu.pixmap, position);␊
2235␉␉}␊
2236␊
2237␉␉pbuff = images[n].image;␊
2238␉␉if (offset && i >= INFOMENU_NATIVEBOOT_START && i <= INFOMENU_NATIVEBOOT_END) {␊
2239␉␉␉blend( images[n + (iMenuHelp - iMenuBoot)].image , gui.menu.pixmap, ␊
2240␉␉␉␉pos((position.x + (gui.menu.hborder / 2)), position.y + ((selection->height - pbuff->height) / 2)));␊
2241␉␉} else {␊
2242␉␉␉blend( pbuff, gui.menu.pixmap, ␊
2243␉␉␉␉pos((position.x + (gui.menu.hborder / 2)), position.y + ((selection->height - pbuff->height) / 2)));␊
2244␉␉}␊
2245␊
2246␉␉drawStr(infoMenuItems[i].text, &font_console, gui.menu.pixmap, ␊
2247␉␉␉pos(position.x + (pbuff->width + gui.menu.hborder), ␊
2248␉␉␉␉position.y + ((selection->height - font_console.height) / 2)));␊
2249␉␉position.y += images[iMenuSelection].image->height;␊
2250␉␊
2251␉}␊
2252␉␊
2253␉gui.redraw = true;␊
2254}␊
2255␊
2256// ====================================================================␊
2257␊
2258int drawInfoMenu()␊
2259{␊
2260␉drawInfoMenuItems();␊
2261␊
2262␉gui.menu.draw = true;␊
2263␊
2264␉updateVRAM();␊
2265␉␊
2266␉return 1;␊
2267}␊
2268␊
2269// ====================================================================␊
2270␊
2271int updateInfoMenu(int key)␊
2272{␊
2273␉switch (key)␊
2274␉{␊
2275␊
2276␉␉case KEY_UP:␉// up arrow␊
2277␉␉␉if (infoMenuSelection > 0) {␊
2278␉␉␉␉if(!infoMenuNativeBoot && infoMenuSelection == INFOMENU_NATIVEBOOT_END + 1) {␊
2279␉␉␉␉␉infoMenuSelection -= 4;␊
2280␉␉␉␉} else {␊
2281␉␉␉␉␉infoMenuSelection--;␊
2282␉␉␉␉}␊
2283␉␉␉␉drawInfoMenuItems();␊
2284␉␉␉␉updateVRAM();␊
2285␊
2286␉␉␉} else {␊
2287␊
2288␉␉␉␉gui.menu.draw = false;␊
2289␉␉␉␉gui.redraw = true;␊
2290␊
2291␉␉␉␉updateVRAM();␊
2292␉␉␉␉␊
2293␉␉␉␉return CLOSE_INFO_MENU;␊
2294␉␉␉}␊
2295␉␉␉break;␊
2296␊
2297␉␉case KEY_DOWN:␉// down arrow␊
2298␉␉␉if (infoMenuSelection < infoMenuItemsCount - 1) {␊
2299␉␉␉␉if(!infoMenuNativeBoot && infoMenuSelection == INFOMENU_NATIVEBOOT_START - 1)␊
2300␉␉␉␉{␊
2301␉␉␉␉␉infoMenuSelection += 4;␊
2302␉␉␉␉} else {␊
2303␉␉␉␉␉infoMenuSelection++;␊
2304␉␉␉␉}␊
2305␉␉␉␉drawInfoMenuItems();␊
2306␉␉␉␉updateVRAM();␊
2307␉␉␉}␊
2308␉␉␉break;␊
2309␊
2310␉␉case KEY_ENTER:␊
2311␉␉␉key = 0;␊
2312␉␉␉if( infoMenuSelection == MENU_SHOW_MEMORY_INFO ) {␊
2313␉␉␉␉showInfoBox( "Memory Info. Press q to quit.\n", getMemoryInfoString());␊
2314␉␉␉} else if( infoMenuSelection == MENU_SHOW_VIDEO_INFO ) {␊
2315␉␉␉␉showInfoBox( getVBEInfoString(), getVBEModeInfoString() );␊
2316␉␉␉} else if( infoMenuSelection == MENU_SHOW_HELP ) {␊
2317␉␉␉␉showHelp();␊
2318␉␉␉} else {␊
2319␉␉␉␉int buff = infoMenuSelection;␊
2320␉␉␉␉infoMenuSelection = 0;␊
2321␉␉␉␉return buff;␊
2322␉␉␉}␊
2323␉␉␉break;␊
2324␉␉default:␊
2325␉␉␉break;␊
2326␉}␊
2327␉return DO_NOT_BOOT;␊
2328}␊
2329␊
2330// ====================================================================␊
2331␊
2332uint16_t bootImageWidth = 0;␊
2333uint16_t bootImageHeight = 0;␊
2334uint8_t *bootImageData = NULL;␊
2335static bool usePngImage = true;␊
2336␊
2337//==========================================================================␊
2338// loadBootGraphics␊
2339static void loadBootGraphics(void)␊
2340{␊
2341␉if (bootImageData != NULL) {␊
2342␉␉return;␊
2343␉}␊
2344␊
2345␉char dirspec[256];␊
2346␊
2347␉if ((strlen(theme_name) + 24) > sizeof(dirspec))␊
2348␉{␊
2349␉␉usePngImage = false; ␊
2350␉␉return;␊
2351␉}␊
2352␉sprintf(dirspec, "/Extra/Themes/%s/boot.png", theme_name);␊
2353␉if (loadPngImage(dirspec, &bootImageWidth, &bootImageHeight, &bootImageData) != 0) {␊
2354#ifdef CONFIG_EMBED_THEME␊
2355␉␉if ((loadEmbeddedPngImage(__boot_png, __boot_png_len, &bootImageWidth, &bootImageHeight, &bootImageData)) != 0)␊
2356#endif␊
2357␉␉usePngImage = false; ␊
2358␉}␊
2359}␊
2360␊
2361//==========================================================================␊
2362// drawBootGraphics␊
2363void drawBootGraphics(void)␊
2364{␊
2365␉int pos;␊
2366␉int length;␊
2367␉const char *dummyVal;␊
2368␉int oldScreenWidth, oldScreenHeight;␊
2369␉bool legacy_logo = true; // ErmaC: Legacy Logo is enabled by default␊
2370␊
2371␉uint16_t x, y;␊
2372␊
2373␉getBoolForKey("Legacy Logo", &legacy_logo, &bootInfo->chameleonConfig);␊
2374␊
2375␉if ( legacy_logo )␊
2376␉{␊
2377␉␉usePngImage = false; ␊
2378␉}␊
2379␉else if (bootImageData == NULL)␊
2380␉{␊
2381␉␉loadBootGraphics();␊
2382␉}␊
2383␊
2384␉// parse screen size parameters␊
2385␉if (getIntForKey("boot_width", &pos, &bootInfo->themeConfig) && pos > 0)␊
2386␉{␊
2387␉␉screen_params[0] = pos;␊
2388␉}␊
2389␉else␊
2390␉{␊
2391␉␉screen_params[0] = DEFAULT_SCREEN_WIDTH;␊
2392␉}␊
2393␊
2394␉if (getIntForKey("boot_height", &pos, &bootInfo->themeConfig) && pos > 0)␊
2395␉{␊
2396␉␉screen_params[1] = pos;␊
2397␉}␊
2398␉else␊
2399␉{␊
2400␉␉screen_params[1] = DEFAULT_SCREEN_HEIGHT;␊
2401␉}␊
2402␊
2403␉// Save current screen resolution.␊
2404␉oldScreenWidth = gui.screen.width;␊
2405␉oldScreenHeight = gui.screen.height;␊
2406␊
2407␉gui.screen.width = screen_params[0];␊
2408␉gui.screen.height = screen_params[1];␊
2409␊
2410␉// find best matching vesa mode for our requested width & height␊
2411␉getGraphicModeParams(screen_params);␊
2412␊
2413␉// Set graphics mode if the booter was in text mode or the screen resolution has changed.␊
2414␉if (bootArgs->Video.v_display == VGA_TEXT_MODE || (screen_params[0] != oldScreenWidth && screen_params[1] != oldScreenHeight) )␊
2415␉{␊
2416␉␉setVideoMode(GRAPHICS_MODE );␊
2417␉}␊
2418␊
2419␉if (getValueForKey("-checkers", &dummyVal, &length, &bootInfo->chameleonConfig))␊
2420␉{␊
2421␉␉drawCheckerBoard();␊
2422␉}␊
2423␉else␊
2424␉{␊
2425␉␉if ( ( MacOSVerCurrent >= MacOSVer2Int("10.10") ) && ( FlagBlackOption ) ) // Yosemite and Up!␊
2426␉␉{␊
2427␉␉␉// BlackMode␊
2428␉␉␉setBackgroundColor(0xff030000);␊
2429␉␉}␊
2430␉␉else␊
2431␉␉{␊
2432␉␉␉// Fill the background to 75% grey (same as BootX).␊
2433␉␉␉setBackgroundColor(0xffbfbfbf);␊
2434␉␉}␊
2435␉}␊
2436␊
2437␉if ((bootImageData) && (usePngImage))␊
2438␉{␊
2439␉␉x = (screen_params[0] - MIN(bootImageWidth, screen_params[0])) / 2; ␊
2440␉␉y = (screen_params[1] - MIN(bootImageHeight, screen_params[1])) / 2; ␊
2441␊
2442␉␉// Draw the image in the center of the display. ␊
2443␉␉blendImage(x, y, bootImageWidth, bootImageHeight, bootImageData); ␊
2444␉}␊
2445␉else␊
2446␉{␊
2447␉␉// Standard size (Width 84 Height 103)␊
2448␉␉// TODO HiDPI size (Width 168 Height 206)␊
2449␉␉// So still need to probe and assign HiDPIOption properly␊
2450␉␉chooseLogoMode();␊
2451␉}␊
2452}␊
2453// ====================================================================␊
2454void chooseLogoMode()␊
2455{␊
2456␉int logoWith␉= HiDPIOption ? (APPLE_LOGO_WIDTH * 2) : APPLE_LOGO_WIDTH;␊
2457␉int logoHeight␉= HiDPIOption ? (APPLE_LOGO_HEIGHT * 2) : APPLE_LOGO_HEIGHT;␊
2458␉int logoX␉= HiDPIOption ? APPLE_LOGO_2X_X : APPLE_LOGO_X;␊
2459␉int logoY␉= HiDPIOption ? APPLE_LOGO_2X_Y : APPLE_LOGO_Y;␊
2460␉int logoSize␉= ( logoWith * logoHeight );␊
2461␊
2462␉void *dst = malloc(logoSize);␊
2463␊
2464␉void *logoData = ( FlagBlackOption ? (void *)AppleLogoBlackPacked : (void *)AppleLogoPacked );␊
2465␉uint32_t src_size = ( FlagBlackOption ? sizeof(AppleLogoBlackPacked) : sizeof(AppleLogoPacked) );␊
2466␊
2467␉if (dst)␊
2468␉{␊
2469␉␉if (lzvn_decode(dst, logoSize, logoData, src_size) == logoSize)␊
2470␉␉{␊
2471␉␉␉uint8_t *bootImageData = NULL;␊
2472␉␉␉convertImage(logoWith, logoHeight, dst, &bootImageData);␊
2473␉␉␉drawDataRectangle(logoX, logoY, logoWith, logoHeight, bootImageData);␊
2474␉␉}␊
2475␉␉free(dst);␊
2476␉}␊
2477}␊
2478

Archive Download this file

Revision: 2825