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

Archive Download this file

Revision: 2457