Chameleon

Chameleon Svn Source Tree

Root/trunk/i386/boot2/gui.c

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

Archive Download this file

Revision: 2766