branches/meklortOld/i386/modules/GUI/gui.c - Chameleon Svn Source Tree - Chameleon open source boot loader project.

Root/branches/meklortOld/i386/modules/GUI/gui.c

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

Download this file