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␊
1340void vramwrite (void *data, int width, int height)␊
1341{␊
1342␉if (VIDEO (depth) == 32 && VIDEO (rowBytes) == gui.backbuffer->width * 4)␊
1343␉{␊
1344␉␉memcpy((uint8_t *)vram, gui.backbuffer->pixels, VIDEO (rowBytes)*VIDEO (height));␊
1345␉}␊
1346␉else␊
1347␉{␊
1348␉␉uint32_t r;␊
1349␉␉uint32_t g;␊
1350␉␉uint32_t b;␊
1351␉␉int i, j;␊
1352␉␉for (i = 0; i < VIDEO (height); i++)␊
1353␉␉{␊
1354␉␉␉for (j = 0; j < VIDEO (width); j++)␊
1355␉␉␉{␊
1356␉␉␉␉b = ((uint8_t *) data)[4*i*width + 4*j];␊
1357␉␉␉␉g = ((uint8_t *) data)[4*i*width + 4*j + 1];␊
1358␉␉␉␉r = ((uint8_t *) data)[4*i*width + 4*j + 2];␊
1359␉␉␉␉switch (VIDEO (depth))␊
1360␉␉␉␉{␊
1361␉␉␉␉␉case 32:␊
1362␉␉␉␉␉␉*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*4) = (b&0xff) | ((g&0xff)<<8) | ((r&0xff)<<16);␊
1363␉␉␉␉␉␉break;␊
1364␉␉␉␉␉case 24:␊
1365␉␉␉␉␉␉*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*3) = ((*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*3))&0xff000000)␊
1366␉␉␉␉␉␉| (b&0xff) | ((g&0xff)<<8) | ((r&0xff)<<16);␊
1367␉␉␉␉␉␉break;␊
1368␉␉␉␉␉case 16:␊
1369␉␉␉␉␉␉// Somehow 16-bit is always 15-bits really␊
1370␉␉␉␉␉␉//␉␉␉␉␉␉*(uint16_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*2) = ((b&0xf8)>>3) | ((g&0xfc)<<3) | ((r&0xf8)<<8);␊
1371␉␉␉␉␉␉//␉␉␉␉␉␉break;␉␉␉␉␉␉␉␊
1372␉␉␉␉␉case 15:␊
1373␉␉␉␉␉␉*(uint16_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*2) = ((b&0xf8)>>3) | ((g&0xf8)<<2) | ((r&0xf8)<<7);␊
1374␉␉␉␉␉␉break;␉␊
1375␉␉␉␉␉default:␊
1376␉␉␉␉␉␉break;␊
1377␉␉␉␉}␊
1378␉␉␉}␊
1379␉␉}␊
1380␉}␊
1381}␊
1382␊
1383// ====================================================================␊
1384␊
1385void updateVRAM()␊
1386{␊
1387␉if (gui.redraw)␊
1388␉{␊
1389␉␉if (gui.devicelist.draw)␊
1390␉␉{␊
1391␉␉␉blend( gui.devicelist.pixmap, gui.backbuffer, gui.devicelist.pos );␊
1392␉␉}␊
1393␉␉if (gui.bootprompt.draw)␊
1394␉␉{␊
1395␉␉␉blend( gui.bootprompt.pixmap, gui.backbuffer, gui.bootprompt.pos );␊
1396␉␉}␊
1397␉␉if (gui.menu.draw)␊
1398␉␉{␊
1399␉␉blend( gui.menu.pixmap, gui.backbuffer, gui.menu.pos );␊
1400␉␉}␊
1401␉␉if (gui.infobox.draw)␊
1402␉␉{␊
1403␉␉␉blend( gui.infobox.pixmap, gui.backbuffer, gui.infobox.pos );␊
1404␉␉}␊
1405␉}␊
1406␊
1407␉vramwrite ( gui.backbuffer->pixels, gui.backbuffer->width, gui.backbuffer->height );␊
1408␊
1409␉if (gui.redraw)␊
1410␉{␊
1411␉␉memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );␊
1412␉␉gui.redraw = false;␊
1413␉}␊
1414}␊
1415␊
1416// ====================================================================␊
1417␊
1418struct putc_info //Azi: exists on console.c & printf.c␊
1419{␊
1420␉char * str;␊
1421␉char * last_str;␊
1422};␊
1423␊
1424// ====================================================================␊
1425␊
1426static int␊
1427sputc(int c, struct putc_info * pi) //Azi: same as above␊
1428{␊
1429␉if (pi->last_str)␊
1430␉{␊
1431␉␉if (pi->str == pi->last_str)␊
1432␉␉{␊
1433␉␉␉*(pi->str) = '\0';␊
1434␉␉␉return 0;␊
1435␉␉}␊
1436␉}␊
1437␉*(pi->str)++ = c;␊
1438␉return c;␊
1439}␊
1440␊
1441// ====================================================================␊
1442␊
1443int gprintf( window_t * window, const char * fmt, ...)␊
1444{␊
1445␉char *formattedtext;␊
1446␊
1447␉va_list ap;␊
1448␊
1449␉struct putc_info pi;␊
1450␊
1451␉if ((formattedtext = malloc(1024)) != NULL)␊
1452␉{␊
1453␉␉// format the text␊
1454␉␉va_start(ap, fmt);␊
1455␉␉pi.str = formattedtext;␊
1456␉␉pi.last_str = 0;␊
1457␉␉prf(fmt, ap, sputc, &pi);␊
1458␉␉*pi.str = '\0';␊
1459␉␉va_end(ap);␊
1460␉␉␊
1461␉␉position_t␉origin, cursor, bounds;␊
1462␊
1463␉␉int i;␊
1464␉␉int character;␊
1465␊
1466␉␉origin.x = MAX( window->cursor.x, window->hborder );␊
1467␉␉origin.y = MAX( window->cursor.y, window->vborder );␊
1468␉␉␊
1469␉␉bounds.x = ( window->width - window->hborder );␊
1470␉␉bounds.y = ( window->height - window->vborder );␊
1471␉␉␊
1472␉␉cursor = origin;␊
1473␊
1474␉␉font_t *font = &font_console;␊
1475␊
1476␉␉for( i=0; i< strlen(formattedtext); i++ )␊
1477␉␉{␊
1478␉␉␉character = formattedtext[i];␊
1479␉␉␉␊
1480␉␉␉character -= 32;␊
1481␊
1482␉␉␉// newline ?␊
1483␉␉␉if( formattedtext[i] == '\n' )␊
1484␉␉␉{␊
1485␉␉␉␉cursor.x = window->hborder;␊
1486␉␉␉␉cursor.y += font->height;␊
1487␊
1488␉␉␉␉if ( cursor.y > bounds.y )␊
1489␉␉␉␉{␊
1490␉␉␉␉␉cursor.y = origin.y;␊
1491␉␉␉␉}␊
1492␉␉␉␉continue;␊
1493␉␉␉}␊
1494␊
1495␉␉␉// tab ?␊
1496␉␉␉if( formattedtext[i] == '\t' )␊
1497␉␉␉{␊
1498␉␉␉␉cursor.x += ( font->chars[0]->width * 5 );␊
1499␉␉␉}␊
1500␊
1501␉␉␉// draw the character␊
1502␉␉␉if( font->chars[character])␊
1503␉␉␉{␊
1504␉␉␉␉blend(font->chars[character], window->pixmap, cursor);␊
1505␉␉␉}␊
1506␊
1507␉␉␉cursor.x += font->chars[character]->width;␊
1508␊
1509␉␉␉// check x pos and do newline␊
1510␉␉␉if ( cursor.x > bounds.x )␊
1511␉␉␉{␊
1512␉␉␉␉cursor.x = origin.x;␊
1513␉␉␉␉cursor.y += font->height;␊
1514␉␉␉}␊
1515␉␉␉␊
1516␉␉␉// check y pos and reset to origin.y␊
1517␉␉␉if ( cursor.y > bounds.y )␊
1518␉␉␉{␊
1519␉␉␉␉cursor.y = origin.y;␊
1520␉␉␉}␊
1521␉␉}␊
1522␊
1523␉␉// update cursor postition␊
1524␉␉window->cursor = cursor;␊
1525␉␉␊
1526␉␉free(formattedtext);␊
1527␉␉␊
1528␉␉return 0;␊
1529␉}␊
1530␉return 1;␊
1531}␊
1532␊
1533// ====================================================================␊
1534␊
1535int dprintf( window_t * window, const char * fmt, ...)␊
1536{␊
1537␉char *formattedtext;␊
1538␉␊
1539␉va_list ap;␊
1540␊
1541␉//window = &gui.debug;␊
1542␉␊
1543␉struct putc_info pi;␊
1544␊
1545␉if ((formattedtext = malloc(1024)) != NULL)␊
1546␉{␊
1547␉␉// format the text␊
1548␉␉va_start(ap, fmt);␊
1549␉␉pi.str = formattedtext;␊
1550␉␉pi.last_str = 0;␊
1551␉␉prf(fmt, ap, sputc, &pi);␊
1552␉␉*pi.str = '\0';␊
1553␉␉va_end(ap);␊
1554␉␉␊
1555␉␉position_t␉origin, cursor, bounds;␊
1556␊
1557␉␉int i;␊
1558␉␉int character;␊
1559␊
1560␉␉origin.x = MAX( gui.debug.cursor.x, window->hborder );␊
1561␉␉origin.y = MAX( gui.debug.cursor.y, window->vborder );␊
1562␉␉␊
1563␉␉bounds.x = ( window->width - window->hborder );␊
1564␉␉bounds.y = ( window->height - window->vborder );␊
1565␉␉␊
1566␉␉cursor = origin;␊
1567␉␉␊
1568␉␉font_t *font = &font_console;␊
1569␉␉␊
1570␉␉for( i=0; i< strlen(formattedtext); i++ )␊
1571␉␉{␊
1572␉␉␉character = formattedtext[i];␊
1573␉␉␉␊
1574␉␉␉character -= 32;␊
1575␉␉␉␊
1576␉␉␉// newline ?␊
1577␉␉␉if( formattedtext[i] == '\n' )␊
1578␉␉␉{␊
1579␉␉␉␉cursor.x = window->hborder;␊
1580␉␉␉␉cursor.y += font->height;␊
1581␉␉␉␉␊
1582␉␉␉␉if ( cursor.y > bounds.y )␊
1583␉␉␉␉{␊
1584␉␉␉␉␉cursor.y = origin.y;␊
1585␉␉␉␉}␊
1586␉␉␉␉continue;␊
1587␉␉␉}␊
1588␉␉␉␊
1589␉␉␉// tab ?␊
1590␉␉␉if( formattedtext[i] == '\t' )␊
1591␉␉␉{␊
1592␉␉␉␉cursor.x += ( font->chars[0]->width * 5 );␊
1593␉␉␉}␊
1594␉␉␉// draw the character␊
1595␉␉␉if( font->chars[character])␊
1596␉␉␉{␊
1597␉␉␉␉blend(font->chars[character], gui.backbuffer, cursor);␊
1598␉␉␉}␊
1599␉␉␉cursor.x += font->chars[character]->width;␊
1600␉␉␉␊
1601␉␉␉// check x pos and do newline␊
1602␉␉␉if ( cursor.x > bounds.x )␊
1603␉␉␉{␊
1604␉␉␉␉cursor.x = origin.x;␊
1605␉␉␉␉cursor.y += font->height;␊
1606␉␉␉}␊
1607␉␉␉␊
1608␉␉␉// check y pos and reset to origin.y␊
1609␉␉␉if ( cursor.y > bounds.y )␊
1610␉␉␉{␊
1611␉␉␉␉cursor.y = origin.y;␊
1612␉␉␉}␊
1613␉␉}␊
1614␉␉␊
1615␉␉// update cursor postition␊
1616␉␉gui.debug.cursor = cursor;␊
1617␉␉␊
1618␉␉free(formattedtext);␊
1619␉␉␊
1620␉␉return 0;␊
1621␉␉␊
1622␉}␊
1623␉return 1;␊
1624}␊
1625␊
1626// ====================================================================␊
1627␊
1628int vprf(const char * fmt, va_list ap)␊
1629{␊
1630␉int i;␊
1631␉int character;␊
1632␊
1633␉char *formattedtext;␊
1634␉window_t *window = &gui.screen;␊
1635␉struct putc_info pi;␊
1636␉␊
1637␉position_t␉origin, cursor, bounds;␊
1638␉font_t *font = &font_console;␊
1639␉␊
1640␉if ((formattedtext = malloc(1024)) != NULL)␊
1641␉{␊
1642␉␉// format the text␊
1643␉␉pi.str = formattedtext;␊
1644␉␉pi.last_str = 0;␊
1645␉␉prf(fmt, ap, sputc, &pi);␊
1646␉␉*pi.str = '\0';␊
1647␉␉␊
1648␉␉origin.x = MAX( window->cursor.x, window->hborder );␊
1649␉␉origin.y = MAX( window->cursor.y, window->vborder );␊
1650␉␉bounds.x = ( window->width - ( window->hborder * 2 ) );␊
1651␉␉bounds.y = ( window->height - ( window->vborder * 2 ) );␊
1652␉␉cursor = origin;␊
1653␊
1654␉␉for( i=0; i< strlen(formattedtext) ; i++ )␊
1655␉␉{␊
1656␉␉␉character = formattedtext[i];␊
1657␉␉␉character -= 32;␊
1658␉␉␉␊
1659␉␉␉// newline ?␊
1660␉␉␉if( formattedtext[i] == '\n' )␊
1661␉␉␉{␊
1662␉␉␉␉cursor.x = window->hborder;␊
1663␉␉␉␉cursor.y += font->height;␊
1664␉␉␉␉if ( cursor.y > bounds.y )␊
1665␉␉␉␉{␊
1666␉␉␉␉␉gui.redraw = true;␊
1667␉␉␉␉␉updateVRAM();␊
1668␉␉␉␉␉cursor.y = window->vborder;␊
1669␉␉␉␉}␊
1670␉␉␉␉window->cursor.y = cursor.y;␊
1671␉␉␉␉continue;␊
1672␉␉␉}␊
1673␊
1674␉␉␉// tab ?␊
1675␉␉␉if( formattedtext[i] == '\t' )␊
1676␉␉␉{␊
1677␉␉␉␉cursor.x = ( cursor.x / ( font->chars[0]->width * 8 ) + 1 ) * ( font->chars[0]->width * 8 );␊
1678␉␉␉␉continue;␊
1679␉␉␉}␊
1680␉␉␉cursor.x += font->chars[character]->width;␊
1681␉␉␉␊
1682␉␉␉// check x pos and do newline␊
1683␉␉␉if ( cursor.x > bounds.x )␊
1684␉␉␉{␊
1685␉␉␉␉cursor.x = origin.x;␊
1686␉␉␉␉cursor.y += font->height;␊
1687␉␉␉}␊
1688␊
1689␉␉␉// check y pos and reset to origin.y␊
1690␉␉␉if ( cursor.y > ( bounds.y + font->chars[0]->height) )␊
1691␉␉␉{␊
1692␉␉␉␉gui.redraw = true;␊
1693␉␉␉␉updateVRAM();␊
1694␉␉␉␉cursor.y = window->vborder;␊
1695␉␉␉}␊
1696␉␉␉// draw the character␊
1697␉␉␉if( font->chars[character])␊
1698␉␉␉{␊
1699␉␉␉␉blend(font->chars[character], gui.backbuffer, cursor);␊
1700␉␉␉}␊
1701␉␉}␊
1702␉␉// save cursor postition␊
1703␉␉window->cursor.x = cursor.x;␊
1704␉␉updateVRAM();␊
1705␉␉free(formattedtext);␊
1706␉␉return 0;␊
1707␉}␊
1708␉return 1;␊
1709}␊
1710␊
1711// ====================================================================␊
1712␊
1713pixmap_t *charToPixmap(unsigned char ch, font_t *font)␊
1714{␊
1715␉unsigned int cha = (unsigned int)ch - 32;␊
1716␉if (cha >= font->count)␊
1717␉{␊
1718␉␉// return ? if the font for the char doesn't exists␊
1719␉␉cha = '?' - 32;␊
1720␉}␊
1721␉return font->chars[cha] ? font->chars[cha] : NULL;␊
1722}␊
1723␊
1724// ====================================================================␊
1725␊
1726position_t drawChar(unsigned char ch, font_t *font, pixmap_t *blendInto, position_t p)␊
1727{␊
1728␉pixmap_t* pm = charToPixmap(ch, font);␊
1729␉if (pm && ((p.x + pm->width) < blendInto->width))␊
1730␉{␊
1731␉␉blend(pm, blendInto, p);␊
1732␉␉return pos(p.x + pm->width, p.y);␊
1733␉}␊
1734␉else␊
1735␉{␊
1736␉␉return p;␊
1737␉}␊
1738}␊
1739␊
1740// ====================================================================␊
1741␊
1742void drawStr(char *ch, font_t *font, pixmap_t *blendInto, position_t p)␊
1743{␊
1744␉int i=0;␊
1745␉position_t current_pos = pos(p.x, p.y);␊
1746␉␊
1747␉for (i=0; i < strlen(ch); i++)␊
1748␉{␊
1749␉␉// newline ?␊
1750␉␉if ( ch[i] == '\n' )␊
1751␉␉{␊
1752␉␉␉current_pos.x = p.x;␊
1753␉␉␉current_pos.y += font->height;␊
1754␉␉␉continue;␊
1755␉␉}␊
1756␉␉␊
1757␉␉// tab ?␊
1758␉␉if ( ch[i] == '\t' )␊
1759␉␉{␊
1760␉␉␉current_pos.x += TAB_PIXELS_WIDTH;␊
1761␉␉␉continue;␊
1762␉␉}␊
1763␉␉␊
1764␉␉current_pos = drawChar(ch[i], font, blendInto, current_pos);␊
1765␉}␊
1766}␊
1767␊
1768// ====================================================================␊
1769␊
1770void drawStrCenteredAt(char *text, font_t *font, pixmap_t *blendInto, position_t p)␊
1771{␊
1772␉int i = 0;␊
1773␉int width = 0;␊
1774␉int max_width = 0;␊
1775␉int height = font->height;␊
1776␊
1777␉// calculate the width in pixels␊
1778␉for (i=0; i < strlen(text); i++)␊
1779␉{␊
1780␉␉if (text[i] == '\n')␊
1781␉␉{␊
1782␉␉␉width = 0;␊
1783␉␉␉height += font->height;␊
1784␉␉}␊
1785␉␉else if (text[i] == '\t')␊
1786␉␉{␊
1787␉␉␉width += TAB_PIXELS_WIDTH;␊
1788␉␉}␊
1789␉␉else␊
1790␉␉{␊
1791␉␉␉pixmap_t* pm = charToPixmap(text[i], font);␊
1792␉␉␉if (pm)␊
1793␉␉␉{␊
1794␉␉␉␉width += pm->width;␊
1795␉␉␉}␊
1796␉␉}␊
1797␉␉if (width > max_width)␊
1798␉␉{␊
1799␉␉␉max_width = width;␊
1800␉␉}␊
1801␉}␊
1802␊
1803␉p.x = ( p.x - ( max_width / 2 ) );␊
1804␉p.y = ( p.y - ( height / 2 ) );␊
1805␉␊
1806␉drawStr(text, font, blendInto, p);␊
1807}␊
1808␊
1809// ====================================================================␊
1810␊
1811int destroyFont(font_t *font)␊
1812{␊
1813␉int i;␊
1814␉for (i = 0; i < CHARACTERS_COUNT; i++)␊
1815␉{␊
1816␉␉if (font->chars[i])␊
1817␉␉{␊
1818␉␉␉if (font->chars[i]->pixels)␊
1819␉␉␉{␊
1820␉␉␉␉free (font->chars[i]->pixels);␊
1821␉␉␉}␊
1822␉␉␉free (font->chars[i]);␊
1823␉␉␉font->chars[i] = 0;␊
1824␉␉}␊
1825␉}␊
1826␉return 0;␊
1827}␊
1828␊
1829// ====================================================================␊
1830␊
1831int initFont(font_t *font, image_t *data)␊
1832{␊
1833␉unsigned int x = 0, y = 0, x2 = 0, x3 = 0;␊
1834␉␊
1835␉int start = 0, end = 0, count = 0, space = 0;␊
1836␉␊
1837␉bool monospaced = false;␊
1838␉␊
1839␉font->height = data->image->height;␊
1840␊
1841␉for( x = 0; x < data->image->width && count < CHARACTERS_COUNT; x++)␊
1842␉{␊
1843␉␉start = end;␊
1844␊
1845␉␉// if the pixel is red we've reached the end of the char␊
1846␉␉if( pixel( data->image, x, 0 ).value == 0xFFFF0000)␊
1847␉␉{␊
1848␉␉␉end = x + 1;␊
1849␊
1850␉␉␉if( (font->chars[count] = malloc(sizeof(pixmap_t)) ) )␊
1851␉␉␉{␊
1852␉␉␉␉font->chars[count]->width = ( end - start) - 1;␊
1853␉␉␉␉font->chars[count]->height = font->height;␊
1854␊
1855␉␉␉␉if ( ( font->chars[count]->pixels = malloc( font->chars[count]->width * data->image->height * 4) ) )␊
1856␉␉␉␉{␊
1857␉␉␉␉␉space += ( font->chars[count]->width * data->image->height * 4 );␊
1858␉␉␉␉␉// we skip the first line because there are just the red pixels for the char width␊
1859␉␉␉␉␉for( y = 1; y< (font->height); y++)␊
1860␉␉␉␉␉{␊
1861␉␉␉␉␉␉for( x2 = start, x3 = 0; x2 < end; x2++, x3++)␊
1862␉␉␉␉␉␉{␊
1863␉␉␉␉␉␉␉pixel( font->chars[count], x3, y ) = pixel( data->image, x2, y );␊
1864␉␉␉␉␉␉}␉␊
1865␉␉␉␉␉}␊
1866␊
1867␉␉␉␉␉// check if font is monospaced␊
1868␉␉␉␉␉if( ( count > 0 ) && ( font->width != font->chars[count]->width ) )␊
1869␉␉␉␉␉{␊
1870␉␉␉␉␉␉monospaced = true;␊
1871␉␉␉␉␉}␊
1872␊
1873␉␉␉␉␉font->width = font->chars[count]->width;␊
1874␊
1875␉␉␉␉␉count++;␊
1876␉␉␉␉}␊
1877␉␉␉}␊
1878␉␉}␊
1879␉}␊
1880␊
1881␉for (x = count; x < CHARACTERS_COUNT; x++)␊
1882␉{␊
1883␉␉font->chars[x] = NULL;␊
1884␉}␊
1885␊
1886␉if(monospaced)␊
1887␉{␊
1888␉␉font->width = 0;␊
1889␉}␊
1890␊
1891␉font->count = count;␊
1892␊
1893␉return 0;␊
1894}␊
1895␊
1896// ====================================================================␊
1897␊
1898void colorFont(font_t *font, uint32_t color)␊
1899{␊
1900␉if( !color )␊
1901␉{␊
1902␉␉return;␊
1903␉}␊
1904␊
1905␉int x, y, width, height;␊
1906␉int count = 0;␊
1907␉pixel_t *buff;␊
1908␉␊
1909␉while( font->chars[count++] )␊
1910␉{␊
1911␉␉width = font->chars[count-1]->width;␊
1912␉␉height = font->chars[count-1]->height;␊
1913␉␉for( y = 0; y < height; y++ )␊
1914␉␉{␊
1915␉␉␉for( x = 0; x < width; x++ )␊
1916␉␉␉{␊
1917␉␉␉␉buff = &(pixel( font->chars[count-1], x, y ));␊
1918␉␉␉␉if( buff->ch.a )␊
1919␉␉␉␉{␊
1920␉␉␉␉␉buff->ch.r = (color & 0xFFFF0000) >> 16;␊
1921␉␉␉␉␉buff->ch.g = (color & 0xFF00FF00) >> 8;␊
1922␉␉␉␉␉buff->ch.b = (color & 0xFF0000FF);␊
1923␉␉␉␉}␊
1924␉␉␉}␊
1925␉␉}␊
1926␉}␊
1927}␊
1928␊
1929// ====================================================================␊
1930␊
1931void makeRoundedCorners(pixmap_t *p)␊
1932{␊
1933␉int x,y;␊
1934␉int width=p->width-1;␊
1935␉int height=p->height-1;␊
1936␉␊
1937␉// 10px rounded corner alpha values␊
1938␉uint8_t roundedCorner[10][10] =␊
1939␉{␊
1940␉␉{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x80, 0xC0, 0xFF},␊
1941␉␉{ 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF},␊
1942␉␉{ 0x00, 0x00, 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1943␉␉{ 0x00, 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1944␉␉{ 0x00, 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1945␉␉{ 0x00, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1946␉␉{ 0x40, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1947␉␉{ 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1948␉␉{ 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},␊
1949␉␉{ 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}␊
1950␉};␊
1951␉␊
1952␉uint8_t alpha=0;␊
1953␉␊
1954␉for( y=0; y<10; y++)␊
1955␉{␊
1956␉␉for( x=0; x<10; x++)␊
1957␉␉{␊
1958␉␉␉// skip if the pixel should be visible␊
1959␉␉␉if(roundedCorner[y][x] != 0xFF)␊
1960␉␉␉{ ␊
1961␉␉␉␉alpha = ( roundedCorner[y][x] ? (uint8_t) (roundedCorner[y][x] * pixel(p, x, y).ch.a) / 255 : 0 );␊
1962␉␉␉␉// Upper left corner␊
1963␉␉␉␉pixel(p, x, y).ch.a = alpha;␊
1964␊
1965␉␉␉␉// upper right corner␊
1966␉␉␉␉pixel(p, width-x,y).ch.a = alpha;␊
1967␊
1968␉␉␉␉// lower left corner␊
1969␉␉␉␉pixel(p, x, height-y).ch.a = alpha;␊
1970␊
1971␉␉␉␉// lower right corner␊
1972␉␉␉␉pixel(p, width-x, height-y).ch.a = alpha;␊
1973␉␉␉}␊
1974␉␉}␊
1975␉}␊
1976}␊
1977␊
1978// ====================================================================␊
1979␊
1980void showInfoBox(char *title, char *text_orig)␊
1981{␊
1982␉char* text;␊
1983␉int i, key, lines, visiblelines;␊
1984␊
1985␉int currentline=0;␊
1986␉int cnt=0;␊
1987␉int offset=0;␊
1988␉␊
1989␉if( !title || !text_orig ) {␊
1990␉␉return;␊
1991␉}␊
1992␊
1993␉// Create a copy so that we don't mangle the original␊
1994␉text = malloc(strlen(text_orig) + 1);␊
1995␉strcpy(text, text_orig);␊
1996␊
1997␉position_t pos_title = pos ( gui.infobox.vborder, gui.infobox.vborder );␊
1998␊
1999␉// calculate number of lines in the title␊
2000␉for ( i = 0, lines = 1; i<strlen(title); i++ ) {␊
2001␉␉if( title[i] == '\n') {␊
2002␉␉␉lines++;␊
2003␉␉}␊
2004␉}␊
2005␉// y position of text is lines in title * height of font␊
2006␉position_t pos_text = pos( pos_title.x , pos_title.y + ( font_console.height * lines ));␊
2007␉␊
2008␉// calculate number of lines in the text␊
2009␉for ( i=0, lines = 1; i<strlen(text); i++ ) {␊
2010␉␉if( text[i] == '\n') {␊
2011␉␉␉lines++;␊
2012␉␉}␊
2013␉}␊
2014␉// if text ends with \n strip off␊
2015␉if( text[i] == '\n' || text[i] == '\0') {␊
2016␉␉lines--;␊
2017␉}␊
2018␉visiblelines = ( ( gui.infobox.height - ( gui.infobox.vborder * 2 ) ) / font_console.height ) - 1;␊
2019␉␊
2020␉// lets display the text and allow scroll thru using up down / arrows␊
2021␉while(1)␊
2022␉{␊
2023␉␉// move to current line in text␊
2024␉␉for( offset = 0, i = 0; offset < strlen(text); offset++ )␊
2025␉␉{␊
2026␉␉␉if( currentline == i)␊
2027␉␉␉{␊
2028␉␉␉␉break;␊
2029␉␉␉}␊
2030␊
2031␉␉␉if( text[offset] =='\n')␊
2032␉␉␉{␊
2033␉␉␉␉i++;␊
2034␉␉␉}␊
2035␉␉}␊
2036␊
2037␉␉// find last visible line in text and place \0␊
2038␉␉for( i = offset, cnt = 0; i < strlen(text); i++)␊
2039␉␉{␊
2040␉␉␉if(text[i]=='\n')␊
2041␉␉␉{␊
2042␉␉␉␉cnt++;␊
2043␉␉␉}␊
2044␊
2045␉␉␉if ( cnt == visiblelines )␊
2046␉␉␉{␊
2047␉␉␉␉text[i]='\0';␊
2048␉␉␉␉break;␊
2049␉␉␉}␊
2050␉␉}␊
2051␊
2052␉␉fillPixmapWithColor( gui.infobox.pixmap, gui.infobox.bgcolor);␊
2053␊
2054␉␉makeRoundedCorners( gui.infobox.pixmap);␊
2055␊
2056␉␉// print the title if present␊
2057␉␉if( title ) {␊
2058␉␉␉drawStr(title, &font_console, gui.infobox.pixmap, pos_title);␊
2059␉␉}␊
2060␉␉// print the text␊
2061␉␉drawStr( text + offset, &font_console, gui.infobox.pixmap, pos_text);␊
2062␊
2063␉␉// restore \n in text␊
2064␉␉if ( cnt == visiblelines ) {␊
2065␉␉␉text[i] = '\n';␊
2066␉␉}␊
2067␉␉position_t pos_indicator = pos( gui.infobox.width - ( images[iTextScrollPrev].image->width - ( gui.infobox.vborder / 2) ), pos_text.y );␊
2068␉␉␊
2069␉␉// draw prev indicator␊
2070␉␉if(offset)␊
2071␉␉{␊
2072␉␉␉blend( images[iTextScrollPrev].image, gui.infobox.pixmap, centeredAt( images[iTextScrollPrev].image, pos_indicator ));␊
2073␉␉}␊
2074␉␉␊
2075␉␉// draw next indicator␊
2076␉␉if( lines > ( currentline + visiblelines ) )␊
2077␉␉{␊
2078␉␉␉pos_indicator.y = ( gui.infobox.height - ( ( images[iTextScrollNext].image->width + gui.infobox.vborder ) / 2 ) );␊
2079␉␉␉blend( images[iTextScrollNext].image, gui.infobox.pixmap, centeredAt( images[iTextScrollNext].image, pos_indicator ) );␊
2080␉␉}␊
2081␊
2082␉␉gui.bootprompt.draw = false;␊
2083␉␉gui.infobox.draw = true;␊
2084␉␉gui.redraw = true;␊
2085␉␉␊
2086␉␉updateVRAM();␊
2087␉␉␊
2088␉␉key = getchar();␊
2089␊
2090␉␉if( key == KEY_UP ) {␊
2091␉␉␉if( currentline > 0 ) {␊
2092␉␉␉␉currentline--;␊
2093␉␉␉}␊
2094␉␉}␊
2095␊
2096␉␉if( key == KEY_DOWN ) {␊
2097␉␉␉if( lines > ( currentline + visiblelines ) ) {␊
2098␉␉␉␉currentline++;␊
2099␉␉␉}␊
2100␉␉}␊
2101␊
2102␉␉if( key == KEY_ESC || key == 'q' || key == 'Q') {␊
2103␉␉␉gui.infobox.draw = false;␊
2104␉␉␉gui.redraw = true;␊
2105␉␉␉updateVRAM();␊
2106␉␉␉break;␊
2107␉␉}␊
2108␊
2109␉␉if(key == ' ') { // spacebar = next page␊
2110␉␉␉if( lines > ( currentline + visiblelines ) ) {␊
2111␉␉␉␉currentline += visiblelines;␊
2112␉␉␉}␊
2113␉␉␉if(lines < (currentline + visiblelines)) {␊
2114␉␉␉␉currentline = lines - visiblelines;␊
2115␉␉␉}␊
2116␉␉}␊
2117␉}␊
2118␉free(text);␊
2119}␊
2120␊
2121// ====================================================================␊
2122␊
2123#if UNUSED␊
2124void animateProgressBar()␊
2125{␊
2126␉int y;␊
2127␉␊
2128␉if( time18() > lasttime)␊
2129␉{␊
2130␉␉lasttime = time18();␊
2131␊
2132␉␉pixmap_t *buffBar = images[iProgressBar].image;␊
2133␊
2134␉␉uint32_t buff = buffBar->pixels[0].value;␊
2135␉␊
2136␉␉memcpy( buffBar->pixels, buffBar->pixels + 1, ( (buffBar->width*buffBar->height) - 1 ) * 4 );␊
2137␊
2138␉␉for( y = buffBar->height - 1; y > 0; y--) {␊
2139␉␉␉pixel(buffBar, buffBar->width - 1, y) = pixel(buffBar, buffBar->width - 1, y - 1);␊
2140␉␉}␊
2141␉␉pixel(buffBar, buffBar->width-1, 0).value = buff;␊
2142␉}␊
2143}␊
2144#endif␊
2145␊
2146// ====================================================================␊
2147␊
2148void drawProgressBar(pixmap_t *blendInto, uint16_t width, position_t p, uint8_t progress)␊
2149{␊
2150␉if(progress>100) {␊
2151␉␉return;␊
2152␉}␊
2153␊
2154␉p.x = ( p.x - ( width / 2 ) );␊
2155␊
2156␉int todraw = (width * progress) / 100;␊
2157␊
2158␉pixmap_t *buff = images[iProgressBar].image;␊
2159␉pixmap_t *buffBG = images[iProgressBarBackground].image;␊
2160␉if(!buff || !buffBG) {␊
2161␉␉return;␊
2162␉}␊
2163␊
2164␉pixmap_t progressbar;␊
2165␉progressbar.pixels=malloc(width * 4 * buff->height);␊
2166␉if(!progressbar.pixels) {␊
2167␉␉return; ␊
2168␉}␊
2169␊
2170␉progressbar.width = width;␊
2171␉progressbar.height = buff->height;␊
2172␊
2173␉int x=0,x2=0,y=0;␊
2174␉␊
2175␉for(y=0; y<buff->height; y++) {␊
2176␉␉for(x=0; x<todraw; x++, x2++) {␊
2177␉␉␉if(x2 == (buff->width-1)) {␊
2178␉␉␉␉x2=0;␊
2179␉␉␉}␊
2180␉␉␉pixel(&progressbar, x,y).value = pixel(buff, x2,y).value;␊
2181␉␉}␊
2182␉␉x2=0;␊
2183␉}␊
2184␊
2185␉for(y=0; y<buff->height; y++) {␊
2186␉␉for(x=todraw, x2 = 0; x < width - 1; x++, x2++) {␊
2187␉␉␉if(x2 == (buffBG->width -2 )) {␊
2188␉␉␉␉x2 = 0;␊
2189␉␉␉}␊
2190␉␉␉pixel(&progressbar, x,y).value = pixel(buffBG, x2,y).value;␊
2191␉␉}␊
2192␉␉if(progress < 100) {␊
2193␉␉␉pixel(&progressbar, width - 1, y).value = pixel(buffBG, buffBG->width - 1, y).value;␊
2194␉␉}␊
2195␊
2196␉␉if(progress == 0) {␊
2197␉␉␉pixel(&progressbar, 0, y).value = pixel(buffBG, buffBG->width - 1, y).value;␊
2198␉␉}␊
2199␊
2200␉␉x2=0;␊
2201␉}␊
2202␊
2203␉blend(&progressbar, blendInto, p);␊
2204#if 0␊
2205␉animateProgressBar();␊
2206#endif␊
2207␉free(progressbar.pixels);␊
2208}␊
2209␊
2210// ====================================================================␊
2211␊
2212void drawInfoMenuItems()␊
2213{␊
2214␉int i,n;␊
2215␉␊
2216␉position_t position;␊
2217␉␊
2218␉pixmap_t *selection = images[iMenuSelection].image;␊
2219␉␊
2220␉pixmap_t *pbuff;␊
2221␊
2222␉fillPixmapWithColor(gui.menu.pixmap, gui.menu.bgcolor);␊
2223␊
2224␉makeRoundedCorners(gui.menu.pixmap);␊
2225␉␊
2226␉uint8_t offset = infoMenuNativeBoot ? 0 : infoMenuItemsCount - 1;␊
2227␊
2228␉position = pos(0,0);␊
2229␉␊
2230␉for ( i = 0, n = iMenuBoot; i < infoMenuItemsCount; i++, n++) {␊
2231␉␉if (i == infoMenuSelection) {␊
2232␉␉␉blend(selection, gui.menu.pixmap, position);␊
2233␉␉}␊
2234␊
2235␉␉pbuff = images[n].image;␊
2236␉␉if (offset && i >= INFOMENU_NATIVEBOOT_START && i <= INFOMENU_NATIVEBOOT_END) {␊
2237␉␉␉blend( images[n + (iMenuHelp - iMenuBoot)].image , gui.menu.pixmap, ␊
2238␉␉␉␉pos((position.x + (gui.menu.hborder / 2)), position.y + ((selection->height - pbuff->height) / 2)));␊
2239␉␉} else {␊
2240␉␉␉blend( pbuff, gui.menu.pixmap, ␊
2241␉␉␉␉pos((position.x + (gui.menu.hborder / 2)), position.y + ((selection->height - pbuff->height) / 2)));␊
2242␉␉}␊
2243␊
2244␉␉drawStr(infoMenuItems[i].text, &font_console, gui.menu.pixmap, ␊
2245␉␉␉pos(position.x + (pbuff->width + gui.menu.hborder), ␊
2246␉␉␉␉position.y + ((selection->height - font_console.height) / 2)));␊
2247␉␉position.y += images[iMenuSelection].image->height;␊
2248␉␊
2249␉}␊
2250␉␊
2251␉gui.redraw = true;␊
2252}␊
2253␊
2254// ====================================================================␊
2255␊
2256int drawInfoMenu()␊
2257{␊
2258␉drawInfoMenuItems();␊
2259␊
2260␉gui.menu.draw = true;␊
2261␊
2262␉updateVRAM();␊
2263␉␊
2264␉return 1;␊
2265}␊
2266␊
2267// ====================================================================␊
2268␊
2269int updateInfoMenu(int key)␊
2270{␊
2271␉switch (key)␊
2272␉{␊
2273␊
2274␉␉case KEY_UP:␉// up arrow␊
2275␉␉␉if (infoMenuSelection > 0) {␊
2276␉␉␉␉if(!infoMenuNativeBoot && infoMenuSelection == INFOMENU_NATIVEBOOT_END + 1) {␊
2277␉␉␉␉␉infoMenuSelection -= 4;␊
2278␉␉␉␉} else {␊
2279␉␉␉␉␉infoMenuSelection--;␊
2280␉␉␉␉}␊
2281␉␉␉␉drawInfoMenuItems();␊
2282␉␉␉␉updateVRAM();␊
2283␊
2284␉␉␉} else {␊
2285␊
2286␉␉␉␉gui.menu.draw = false;␊
2287␉␉␉␉gui.redraw = true;␊
2288␊
2289␉␉␉␉updateVRAM();␊
2290␉␉␉␉␊
2291␉␉␉␉return CLOSE_INFO_MENU;␊
2292␉␉␉}␊
2293␉␉␉break;␊
2294␊
2295␉␉case KEY_DOWN:␉// down arrow␊
2296␉␉␉if (infoMenuSelection < infoMenuItemsCount - 1) {␊
2297␉␉␉␉if(!infoMenuNativeBoot && infoMenuSelection == INFOMENU_NATIVEBOOT_START - 1)␊
2298␉␉␉␉{␊
2299␉␉␉␉␉infoMenuSelection += 4;␊
2300␉␉␉␉} else {␊
2301␉␉␉␉␉infoMenuSelection++;␊
2302␉␉␉␉}␊
2303␉␉␉␉drawInfoMenuItems();␊
2304␉␉␉␉updateVRAM();␊
2305␉␉␉}␊
2306␉␉␉break;␊
2307␊
2308␉␉case KEY_ENTER:␊
2309␉␉␉key = 0;␊
2310␉␉␉if( infoMenuSelection == MENU_SHOW_MEMORY_INFO ) {␊
2311␉␉␉␉showInfoBox( "Memory Info. Press q to quit.\n", getMemoryInfoString());␊
2312␉␉␉} else if( infoMenuSelection == MENU_SHOW_VIDEO_INFO ) {␊
2313␉␉␉␉showInfoBox( getVBEInfoString(), getVBEModeInfoString() );␊
2314␉␉␉} else if( infoMenuSelection == MENU_SHOW_HELP ) {␊
2315␉␉␉␉showHelp();␊
2316␉␉␉} else {␊
2317␉␉␉␉int buff = infoMenuSelection;␊
2318␉␉␉␉infoMenuSelection = 0;␊
2319␉␉␉␉return buff;␊
2320␉␉␉}␊
2321␉␉␉break;␊
2322␉␉default:␊
2323␉␉␉break;␊
2324␉}␊
2325␉return DO_NOT_BOOT;␊
2326}␊
2327␊
2328// ====================================================================␊
2329␊
2330uint16_t bootImageWidth = 0; ␊
2331uint16_t bootImageHeight = 0; ␊
2332uint8_t *bootImageData = NULL; ␊
2333static bool usePngImage = true;␊
2334␊
2335//==========================================================================␊
2336// loadBootGraphics␊
2337static void loadBootGraphics(void)␊
2338{␊
2339␉if (bootImageData != NULL) {␊
2340␉␉return;␊
2341␉}␊
2342␊
2343␉char dirspec[256];␊
2344␊
2345␉if ((strlen(theme_name) + 24) > sizeof(dirspec))␊
2346␉{␊
2347␉␉usePngImage = false; ␊
2348␉␉return;␊
2349␉}␊
2350␉sprintf(dirspec, "/Extra/Themes/%s/boot.png", theme_name);␊
2351␉if (loadPngImage(dirspec, &bootImageWidth, &bootImageHeight, &bootImageData) != 0) {␊
2352#ifdef CONFIG_EMBED_THEME␊
2353␉␉if ((loadEmbeddedPngImage(__boot_png, __boot_png_len, &bootImageWidth, &bootImageHeight, &bootImageData)) != 0)␊
2354#endif␊
2355␉␉usePngImage = false; ␊
2356␉}␊
2357}␊
2358␊
2359//==========================================================================␊
2360// drawBootGraphics␊
2361void drawBootGraphics(void)␊
2362{␊
2363␉int pos;␊
2364␉int length;␊
2365␉const char *dummyVal;␊
2366␉int oldScreenWidth, oldScreenHeight;␊
2367␉bool legacy_logo;␊
2368␉uint16_t x, y; ␊
2369␉␊
2370␉if (getBoolForKey("Legacy Logo", &legacy_logo, &bootInfo->chameleonConfig) && legacy_logo) {␊
2371␉␉usePngImage = false; ␊
2372␉} else if (bootImageData == NULL) {␊
2373␉␉loadBootGraphics();␊
2374␉}␊
2375␊
2376␉// parse screen size parameters␊
2377␉if (getIntForKey("boot_width", &pos, &bootInfo->themeConfig) && pos > 0) {␊
2378␉␉screen_params[0] = pos;␊
2379␉} else {␊
2380␉␉screen_params[0] = DEFAULT_SCREEN_WIDTH;␊
2381␉}␊
2382␉if (getIntForKey("boot_height", &pos, &bootInfo->themeConfig) && pos > 0) {␊
2383␉␉screen_params[1] = pos;␊
2384␉} else {␊
2385␉␉screen_params[1] = DEFAULT_SCREEN_HEIGHT;␊
2386␉}␊
2387␊
2388␉// Save current screen resolution.␊
2389␉oldScreenWidth = gui.screen.width;␊
2390␉oldScreenHeight = gui.screen.height;␊
2391␊
2392␉gui.screen.width = screen_params[0];␊
2393␉gui.screen.height = screen_params[1];␊
2394␊
2395␉// find best matching vesa mode for our requested width & height␊
2396␉getGraphicModeParams(screen_params);␊
2397␊
2398␉// Set graphics mode if the booter was in text mode or the screen resolution has changed.␊
2399␉if (bootArgs->Video.v_display == VGA_TEXT_MODE || (screen_params[0] != oldScreenWidth && screen_params[1] != oldScreenHeight) ) {␊
2400␉␉setVideoMode(GRAPHICS_MODE, 0);␊
2401␉}␊
2402␊
2403␉if (getValueForKey("-checkers", &dummyVal, &length, &bootInfo->chameleonConfig)) {␊
2404␉␉drawCheckerBoard();␊
2405␉} else {␊
2406␉␉// Fill the background to 75% grey (same as BootX). ␊
2407␉␉drawColorRectangle(0, 0, screen_params[0], screen_params[1], 0x01); ␊
2408␉}␊
2409␉if ((bootImageData) && (usePngImage)) { ␊
2410␉␉x = (screen_params[0] - MIN(bootImageWidth, screen_params[0])) / 2; ␊
2411␉␉y = (screen_params[1] - MIN(bootImageHeight, screen_params[1])) / 2; ␊
2412␊
2413␉␉// Draw the image in the center of the display. ␊
2414␉␉blendImage(x, y, bootImageWidth, bootImageHeight, bootImageData); ␊
2415␉} else { ␊
2416␉␉uint8_t *appleBootPict; ␊
2417␉␉bootImageData = NULL; ␊
2418␉␉bootImageWidth = kAppleBootWidth; ␊
2419␉␉bootImageHeight = kAppleBootHeight; ␊
2420␊
2421␉␉// Prepare the data for the default Apple boot image. ␊
2422␉␉appleBootPict = (uint8_t *) decodeRLE(gAppleBootPictRLE, kAppleBootRLEBlocks, bootImageWidth * bootImageHeight); ␊
2423␉␉if (appleBootPict) { ␊
2424␉␉␉convertImage(bootImageWidth, bootImageHeight, appleBootPict, &bootImageData); ␊
2425␉␉␉if (bootImageData) {␉␊
2426␉␉␉␉x = (screen_params[0] - MIN(kAppleBootWidth, screen_params[0])) / 2; ␊
2427␉␉␉␉y = (screen_params[1] - MIN(kAppleBootHeight, screen_params[1])) / 2; ␊
2428␉␉␉␉drawDataRectangle(x, y, kAppleBootWidth, kAppleBootHeight, bootImageData);␊
2429␉␉␉␉free(bootImageData);␊
2430␉␉␉}␊
2431␉␉␉free(appleBootPict); ␊
2432␉␉} ␊
2433␉}␊
2434}␊
2435// ====================================================================␊
2436

Archive Download this file

Revision: 2711