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

Archive Download this file

Revision: 2542