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

Archive Download this file

Revision: 2743