WebSVN – HelenOS – Diff – /trunk/uspace/console/gcons.c


/*
 * Copyright (C) 2006 Ondrej Palkovsky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup console
 * @{
 */
/** @file
 */
 
#include <ipc/fb.h>
#include <ipc/ipc.h>
#include <async.h>
#include <stdio.h>
#include <sys/mman.h>
#include <string.h>
#include <align.h>
 
#include "console.h"
#include "gcons.h"
 
#define CONSOLE_TOP      66
#define CONSOLE_MARGIN   6
 
#define STATUS_START    110
#define STATUS_TOP      8
#define STATUS_SPACE    4
#define STATUS_WIDTH    48
#define STATUS_HEIGHT   48
 
#define MAIN_COLOR      0xffffff
 
static int use_gcons = 0;
static ipcarg_t xres,yres;
 
enum butstate {
    CONS_DISCONNECTED = 0,
    CONS_SELECTED,
    CONS_IDLE,
    CONS_HAS_DATA,
    CONS_KERNEL,
    CONS_DISCONNECTED_SEL,
    CONS_LAST
};
 
static int console_vp;
static int cstatus_vp[CONSOLE_COUNT];
static enum butstate console_state[CONSOLE_COUNT];
 
static int fbphone;
 
/** List of pixmaps identifying these icons */
static int ic_pixmaps[CONS_LAST] = {-1, -1, -1, -1, -1, -1};
static int animation = -1;
 
static int active_console = 0;
 
static void vp_switch(int vp)
{
    async_msg(fbphone,FB_VIEWPORT_SWITCH, vp);
}
 
/** Create view port */
static int vp_create(unsigned int x, unsigned int y,
             unsigned int width, unsigned int height)
{
    return async_req_2(fbphone, FB_VIEWPORT_CREATE,
               (x << 16) | y, (width << 16) | height,
               NULL, NULL);
}
 
static void clear(void)
{
    async_msg(fbphone, FB_CLEAR, 0);
   
}
 
static void set_style(int fgcolor, int bgcolor)
{
    async_msg_2(fbphone, FB_SET_STYLE, fgcolor, bgcolor);
}
 
/** Transparent putchar */
static void tran_putch(char c, int row, int col)
{
    async_msg_3(fbphone, FB_TRANS_PUTCHAR, c, row, col);
}
 
/** Redraw the button showing state of a given console */
static void redraw_state(int consnum)
{
    char data[5];
    int i;
    enum butstate state = console_state[consnum];
 
    vp_switch(cstatus_vp[consnum]);
    if (ic_pixmaps[state] != -1)
        async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum],
            ic_pixmaps[state]);
 
    if (state != CONS_DISCONNECTED && state != CONS_KERNEL && state !=
        CONS_DISCONNECTED_SEL) {
        snprintf(data, 5, "%d", consnum + 1);
        for (i=0; data[i]; i++)
            tran_putch(data[i], 1, 2 + i);
    }
}
 
/** Notification run on changing console (except kernel console) */
void gcons_change_console(int consnum)
{
    int i;
 
    if (!use_gcons)
        return;
 
    if (active_console == KERNEL_CONSOLE) {
        for (i = 0; i < CONSOLE_COUNT; i++)
            redraw_state(i);
        if (animation != -1)
            async_msg(fbphone, FB_ANIM_START, animation);
    } else {
        if (console_state[active_console] == CONS_DISCONNECTED_SEL)
            console_state[active_console] = CONS_DISCONNECTED;
        else
            console_state[active_console] = CONS_IDLE;
        redraw_state(active_console);
    }
    active_console = consnum;
 
    if (console_state[consnum] == CONS_DISCONNECTED) {
        console_state[consnum] = CONS_DISCONNECTED_SEL;
        redraw_state(consnum);
    } else
        console_state[consnum] = CONS_SELECTED;
    redraw_state(consnum);
 
    vp_switch(console_vp);
}
 
/** Notification function that gets called on new output to virtual console */
void gcons_notify_char(int consnum)
{
    if (!use_gcons)
        return;
 
    if (consnum == active_console || console_state[consnum] ==
        CONS_HAS_DATA)
        return;
 
    console_state[consnum] = CONS_HAS_DATA;
 
    if (active_console == KERNEL_CONSOLE)
        return;
 
    redraw_state(consnum);
   
    vp_switch(console_vp);
}
 
/** Notification function called on service disconnect from console */
void gcons_notify_disconnect(int consnum)
{
    if (!use_gcons)
        return;
    if (active_console == consnum)
        console_state[consnum] = CONS_DISCONNECTED_SEL;
    else
        console_state[consnum] = CONS_DISCONNECTED;
 
    if (active_console == KERNEL_CONSOLE)
        return;
 
    redraw_state(consnum);
    vp_switch(console_vp);
}
 
/** Notification function called on console connect */
void gcons_notify_connect(int consnum)
{
    if (!use_gcons)
        return;
    if (active_console == consnum)
        console_state[consnum] = CONS_SELECTED;
    else
        console_state[consnum] = CONS_IDLE;
 
    if (active_console == KERNEL_CONSOLE)
        return;
 
    redraw_state(consnum);
    vp_switch(console_vp);
}
 
/** Change to kernel console */
void gcons_in_kernel(void)
{
    if (console_state[active_console] == CONS_DISCONNECTED_SEL)
        console_state[active_console] = CONS_DISCONNECTED;
    else
        console_state[active_console] = CONS_IDLE;
    redraw_state(active_console);
 
    if (animation != -1)
        async_msg(fbphone, FB_ANIM_STOP, animation);
 
    active_console = KERNEL_CONSOLE; /* Set to kernel console */
    vp_switch(0);
}
 
/** Return x, where left <= x <= right && |a-x|==min(|a-x|) is smallest */
static inline int limit(int a,int left, int right)
{
    if (a < left)
        a = left;
    if (a >= right)
        a = right - 1;
    return a;
}
 
int mouse_x, mouse_y;
int btn_pressed, btn_x, btn_y;
 
/** Handle mouse move
 *
 * @param dx Delta X of mouse move
 * @param dy Delta Y of mouse move
 */
void gcons_mouse_move(int dx, int dy)
{
    mouse_x = limit(mouse_x+dx, 0, xres);
    mouse_y = limit(mouse_y+dy, 0, yres);
 
    async_msg_2(fbphone, FB_POINTER_MOVE, mouse_x, mouse_y);
}
 
static int gcons_find_conbut(int x, int y)
{
    int status_start = STATUS_START + (xres - 800) / 2;;
 
    if (y < STATUS_TOP || y >= STATUS_TOP + STATUS_HEIGHT)
        return -1;
   
    if (x < status_start)
        return -1;
   
    if (x >= status_start + (STATUS_WIDTH + STATUS_SPACE) * CONSOLE_COUNT)
        return -1;
    if (((x - status_start) % (STATUS_WIDTH+STATUS_SPACE)) < STATUS_SPACE)
        return -1;
   
    return (x - status_start) / (STATUS_WIDTH+STATUS_SPACE);
}
 
/** Handle mouse click
 *
 * @param state New state (1-pressed, 0-depressed)
 */
int gcons_mouse_btn(int state)
{
    int conbut;
 
    if (state) {
        conbut = gcons_find_conbut(mouse_x, mouse_y);
        if (conbut != -1) {
            btn_pressed = 1;
            btn_x = mouse_x;
            btn_y = mouse_y;
        }
        return -1;
    }
    if (!state && !btn_pressed)
        return -1;
    btn_pressed = 0;
 
    conbut = gcons_find_conbut(mouse_x, mouse_y);
    if (conbut == gcons_find_conbut(btn_x, btn_y))
        return conbut;
    return -1;
}
 
 
/** Draw a PPM pixmap to framebuffer
 *
 * @param logo Pointer to PPM data
 * @param size Size of PPM data
 * @param x Coordinate of upper left corner
 * @param y Coordinate of upper left corner
 */
static void draw_pixmap(char *logo, size_t size, int x, int y)
{
    char *shm;
    int rc;
 
    /* Create area */
    shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
        MAP_ANONYMOUS, 0, 0);
    if (shm == MAP_FAILED)
        return;
 
    memcpy(shm, logo, size);
    /* Send area */
    rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm, 0, NULL,
        NULL);
    if (rc)
        goto exit;
    rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t) shm, 0,
        PROTO_READ, NULL, NULL, NULL);
    if (rc)
        goto drop;
    /* Draw logo */
    async_msg_2(fbphone, FB_DRAW_PPM, x, y);
drop:
    /* Drop area */
    async_msg(fbphone, FB_DROP_SHM, 0);
exit:      
    /* Remove area */
    munmap(shm, size);
}
 
extern char _binary_helenos_ppm_start[0];
extern int _binary_helenos_ppm_size;
extern char _binary_nameic_ppm_start[0];
extern int _binary_nameic_ppm_size;
/** Redraws console graphics  */
static void gcons_redraw_console(void)
{
    int i;
 
    if (!use_gcons)
        return;
   
    vp_switch(0);
    set_style(MAIN_COLOR, MAIN_COLOR);
    clear();
    draw_pixmap(_binary_helenos_ppm_start, (size_t)
        &_binary_helenos_ppm_size, xres - 66, 2);
    draw_pixmap(_binary_nameic_ppm_start, (size_t)
        &_binary_nameic_ppm_size, 5, 17);
 
    for (i=0;i < CONSOLE_COUNT; i++)
        redraw_state(i);
    vp_switch(console_vp);
}
 
/** Creates a pixmap on framebuffer
 *
 * @param data PPM data
 * @param size PPM data size
 * @return Pixmap identification
 */
static int make_pixmap(char *data, int size)
{
    char *shm;
    int rc;
    int pxid = -1;
 
    /* Create area */
    shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
        MAP_ANONYMOUS, 0, 0);
    if (shm == MAP_FAILED)
        return -1;
 
    memcpy(shm, data, size);
    /* Send area */
    rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm, 0, NULL,
        NULL);
    if (rc)
        goto exit;
    rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t) shm, 0,
        PROTO_READ, NULL, NULL, NULL);
    if (rc)
        goto drop;
 
    /* Obtain pixmap */
    rc = async_req(fbphone, FB_SHM2PIXMAP, 0, NULL);
    if (rc < 0)
        goto drop;
    pxid = rc;
drop:
    /* Drop area */
    async_msg(fbphone, FB_DROP_SHM, 0);
exit:      
    /* Remove area */
    munmap(shm, size);
 
    return pxid;
}
 
extern char _binary_anim_1_ppm_start[0];
extern int _binary_anim_1_ppm_size;
extern char _binary_anim_2_ppm_start[0];
extern int _binary_anim_2_ppm_size;
extern char _binary_anim_3_ppm_start[0];
extern int _binary_anim_3_ppm_size;
extern char _binary_anim_4_ppm_start[0];
extern int _binary_anim_4_ppm_size;
 
static void make_anim(void)
{
    int an;
    int pm;
 
    an = async_req(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE],
        NULL);
    if (an < 0)
        return;
 
    pm = make_pixmap(_binary_anim_1_ppm_start, (int)
        &_binary_anim_1_ppm_size);
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
 
    pm = make_pixmap(_binary_anim_2_ppm_start, (int)
        &_binary_anim_2_ppm_size);
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
 
    pm = make_pixmap(_binary_anim_3_ppm_start, (int)
        &_binary_anim_3_ppm_size);
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
 
    pm = make_pixmap(_binary_anim_4_ppm_start, (int)
        &_binary_anim_4_ppm_size);
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
 
    async_msg(fbphone, FB_ANIM_START, an);
 
    animation = an;
}
 
extern char _binary_cons_selected_ppm_start[0];
extern int _binary_cons_selected_ppm_size;
extern char _binary_cons_idle_ppm_start[0];
extern int _binary_cons_idle_ppm_size;
extern char _binary_cons_has_data_ppm_start[0];
extern int _binary_cons_has_data_ppm_size;
extern char _binary_cons_kernel_ppm_start[0];
extern int _binary_cons_kernel_ppm_size;
 
/** Initialize nice graphical console environment */
void gcons_init(int phone)
{
    int rc;
    int i;
    int status_start = STATUS_START;
 
    fbphone = phone;
 
    rc = async_req_2(phone, FB_GET_RESOLUTION, 0, 0, &xres, &yres);
    if (rc)
        return;
   
    if (xres < 800 || yres < 600)
        return;
 
    /* create console viewport */
    /* Align width & height to character size */
    console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP, ALIGN_DOWN(xres -
        2 * CONSOLE_MARGIN, 8), ALIGN_DOWN(yres - (CONSOLE_TOP +
        CONSOLE_MARGIN), 16));
    if (console_vp < 0)
        return;
   
    /* Create status buttons */
    status_start += (xres - 800) / 2;
    for (i = 0; i < CONSOLE_COUNT; i++) {
        cstatus_vp[i] = vp_create(status_start + CONSOLE_MARGIN + i *
            (STATUS_WIDTH + STATUS_SPACE), STATUS_TOP,
            STATUS_WIDTH, STATUS_HEIGHT);
        if (cstatus_vp[i] < 0)
            return;
        vp_switch(cstatus_vp[i]);
        set_style(0x202020, 0xffffff);
    }
   
    /* Initialize icons */
    ic_pixmaps[CONS_SELECTED] =
        make_pixmap(_binary_cons_selected_ppm_start, (int)
        &_binary_cons_selected_ppm_size);
    ic_pixmaps[CONS_IDLE] = make_pixmap(_binary_cons_idle_ppm_start, (int)
        &_binary_cons_idle_ppm_size);
    ic_pixmaps[CONS_HAS_DATA] =
        make_pixmap(_binary_cons_has_data_ppm_start, (int)
        &_binary_cons_has_data_ppm_size);
    ic_pixmaps[CONS_DISCONNECTED] =
        make_pixmap(_binary_cons_idle_ppm_start, (int)
        &_binary_cons_idle_ppm_size);
    ic_pixmaps[CONS_KERNEL] = make_pixmap(_binary_cons_kernel_ppm_start,
        (int) &_binary_cons_kernel_ppm_size);
    ic_pixmaps[CONS_DISCONNECTED_SEL] = ic_pixmaps[CONS_SELECTED];
   
    make_anim();
 
    use_gcons = 1;
    console_state[0] = CONS_DISCONNECTED_SEL;
    console_state[KERNEL_CONSOLE] = CONS_KERNEL;
    gcons_redraw_console();
}
 
/** @}
 */
 
 

Rev 1867	Rev 2025
1	/*	1	/*
2	* Copyright (C) 2006 Ondrej Palkovsky	2	* Copyright (C) 2006 Ondrej Palkovsky
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup console	29	/** @addtogroup console
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <ipc/fb.h>	35	#include <ipc/fb.h>
36	#include <ipc/ipc.h>	36	#include <ipc/ipc.h>
37	#include <async.h>	37	#include <async.h>
38	#include <stdio.h>	38	#include <stdio.h>
39	#include <sys/mman.h>	39	#include <sys/mman.h>
40	#include <string.h>	40	#include <string.h>
41	#include <align.h>	41	#include <align.h>
42		42
43	#include "console.h"	43	#include "console.h"
44	#include "gcons.h"	44	#include "gcons.h"
45		45
46	#define CONSOLE_TOP 66	46	#define CONSOLE_TOP 66
47	#define CONSOLE_MARGIN 6	47	#define CONSOLE_MARGIN 6
48		48
49	#define STATUS_START 110	49	#define STATUS_START 110
50	#define STATUS_TOP 8	50	#define STATUS_TOP 8
51	#define STATUS_SPACE 4	51	#define STATUS_SPACE 4
52	#define STATUS_WIDTH 48	52	#define STATUS_WIDTH 48
53	#define STATUS_HEIGHT 48	53	#define STATUS_HEIGHT 48
54		54
55	#define MAIN_COLOR 0xffffff	55	#define MAIN_COLOR 0xffffff
56		56
57	static int use_gcons = 0;	57	static int use_gcons = 0;
58	static ipcarg_t xres,yres;	58	static ipcarg_t xres,yres;
59		59
60	enum butstate {	60	enum butstate {
61	CONS_DISCONNECTED = 0,	61	CONS_DISCONNECTED = 0,
62	CONS_SELECTED,	62	CONS_SELECTED,
63	CONS_IDLE,	63	CONS_IDLE,
64	CONS_HAS_DATA,	64	CONS_HAS_DATA,
65	CONS_KERNEL,	65	CONS_KERNEL,
66	CONS_DISCONNECTED_SEL,	66	CONS_DISCONNECTED_SEL,
67	CONS_LAST	67	CONS_LAST
68	};	68	};
69		69
70	static int console_vp;	70	static int console_vp;
71	static int cstatus_vp[CONSOLE_COUNT];	71	static int cstatus_vp[CONSOLE_COUNT];
72	static enum butstate console_state[CONSOLE_COUNT];	72	static enum butstate console_state[CONSOLE_COUNT];
73		73
74	static int fbphone;	74	static int fbphone;
75		75
76	/** List of pixmaps identifying these icons */	76	/** List of pixmaps identifying these icons */
77	static int ic_pixmaps[CONS_LAST] = {-1,-1,-1,-1,-1,-1};	77	static int ic_pixmaps[CONS_LAST] = {-1, -1, -1, -1, -1, -1};
78	static int animation = -1;	78	static int animation = -1;
79		79
80	static int active_console = 0;	80	static int active_console = 0;
81		81
82	static void vp_switch(int vp)	82	static void vp_switch(int vp)
83	{	83	{
84	async_msg(fbphone,FB_VIEWPORT_SWITCH, vp);	84	async_msg(fbphone,FB_VIEWPORT_SWITCH, vp);
85	}	85	}
86		86
87	/** Create view port */	87	/** Create view port */
88	static int vp_create(unsigned int x, unsigned int y,	88	static int vp_create(unsigned int x, unsigned int y,
89	unsigned int width, unsigned int height)	89	unsigned int width, unsigned int height)
90	{	90	{
91	return async_req_2(fbphone, FB_VIEWPORT_CREATE,	91	return async_req_2(fbphone, FB_VIEWPORT_CREATE,
92	(x << 16) \| y, (width << 16) \| height,	92	(x << 16) \| y, (width << 16) \| height,
93	NULL, NULL);	93	NULL, NULL);
94	}	94	}
95		95
96	static void clear(void)	96	static void clear(void)
97	{	97	{
98	async_msg(fbphone, FB_CLEAR, 0);	98	async_msg(fbphone, FB_CLEAR, 0);
99		99
100	}	100	}
101		101
102	static void set_style(int fgcolor, int bgcolor)	102	static void set_style(int fgcolor, int bgcolor)
103	{	103	{
104	async_msg_2(fbphone, FB_SET_STYLE, fgcolor, bgcolor);	104	async_msg_2(fbphone, FB_SET_STYLE, fgcolor, bgcolor);
105	}	105	}
106		106
107	/** Transparent putchar */	107	/** Transparent putchar */
108	static void tran_putch(char c, int row, int col)	108	static void tran_putch(char c, int row, int col)
109	{	109	{
110	async_msg_3(fbphone, FB_TRANS_PUTCHAR, c, row, col);	110	async_msg_3(fbphone, FB_TRANS_PUTCHAR, c, row, col);
111	}	111	}
112		112
113	/** Redraw the button showing state of a given console */	113	/** Redraw the button showing state of a given console */
114	static void redraw_state(int consnum)	114	static void redraw_state(int consnum)
115	{	115	{
116	char data[5];	116	char data[5];
117	int i;	117	int i;
118	enum butstate state = console_state[consnum];	118	enum butstate state = console_state[consnum];
119		119
120	vp_switch(cstatus_vp[consnum]);	120	vp_switch(cstatus_vp[consnum]);
121	if (ic_pixmaps[state] != -1)	121	if (ic_pixmaps[state] != -1)
122	async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum], ic_pixmaps[state]);	122	async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum],
-		123	ic_pixmaps[state]);
123		124
124	if (state != CONS_DISCONNECTED && state != CONS_KERNEL && state != CONS_DISCONNECTED_SEL) {	125	if (state != CONS_DISCONNECTED && state != CONS_KERNEL && state !=
-		126	CONS_DISCONNECTED_SEL) {
125	snprintf(data, 5, "%d", consnum+1);	127	snprintf(data, 5, "%d", consnum + 1);
126	for (i=0;data[i];i++)	128	for (i=0; data[i]; i++)
127	tran_putch(data[i], 1, 2+i);	129	tran_putch(data[i], 1, 2 + i);
128	}	130	}
129	}	131	}
130		132
131	/** Notification run on changing console (except kernel console) */	133	/** Notification run on changing console (except kernel console) */
132	void gcons_change_console(int consnum)	134	void gcons_change_console(int consnum)
133	{	135	{
134	int i;	136	int i;
135		137
136	if (!use_gcons)	138	if (!use_gcons)
137	return;	139	return;
138		140
139	if (active_console == KERNEL_CONSOLE) {	141	if (active_console == KERNEL_CONSOLE) {
140	for (i=0; i < CONSOLE_COUNT; i++)	142	for (i = 0; i < CONSOLE_COUNT; i++)
141	redraw_state(i);	143	redraw_state(i);
142	if (animation != -1)	144	if (animation != -1)
143	async_msg(fbphone, FB_ANIM_START, animation);	145	async_msg(fbphone, FB_ANIM_START, animation);
144	} else {	146	} else {
145	if (console_state[active_console] == CONS_DISCONNECTED_SEL)	147	if (console_state[active_console] == CONS_DISCONNECTED_SEL)
146	console_state[active_console] = CONS_DISCONNECTED;	148	console_state[active_console] = CONS_DISCONNECTED;
147	else	149	else
148	console_state[active_console] = CONS_IDLE;	150	console_state[active_console] = CONS_IDLE;
149	redraw_state(active_console);	151	redraw_state(active_console);
150	}	152	}
151	active_console = consnum;	153	active_console = consnum;
152		154
153	if (console_state[consnum] == CONS_DISCONNECTED) {	155	if (console_state[consnum] == CONS_DISCONNECTED) {
154	console_state[consnum] = CONS_DISCONNECTED_SEL;	156	console_state[consnum] = CONS_DISCONNECTED_SEL;
155	redraw_state(consnum);	157	redraw_state(consnum);
156	} else	158	} else
157	console_state[consnum] = CONS_SELECTED;	159	console_state[consnum] = CONS_SELECTED;
158	redraw_state(consnum);	160	redraw_state(consnum);
159		161
160	vp_switch(console_vp);	162	vp_switch(console_vp);
161	}	163	}
162		164
163	/** Notification function that gets called on new output to virtual console */	165	/** Notification function that gets called on new output to virtual console */
164	void gcons_notify_char(int consnum)	166	void gcons_notify_char(int consnum)
165	{	167	{
166	if (!use_gcons)	168	if (!use_gcons)
167	return;	169	return;
168		170
169	if (consnum == active_console \|\| console_state[consnum] == CONS_HAS_DATA)	171	if (consnum == active_console \|\| console_state[consnum] ==
-		172	CONS_HAS_DATA)
170	return;	173	return;
171		174
172	console_state[consnum] = CONS_HAS_DATA;	175	console_state[consnum] = CONS_HAS_DATA;
173		176
174	if (active_console == KERNEL_CONSOLE)	177	if (active_console == KERNEL_CONSOLE)
175	return;	178	return;
176		179
177	redraw_state(consnum);	180	redraw_state(consnum);
178		181
179	vp_switch(console_vp);	182	vp_switch(console_vp);
180	}	183	}
181		184
182	/** Notification function called on service disconnect from console */	185	/** Notification function called on service disconnect from console */
183	void gcons_notify_disconnect(int consnum)	186	void gcons_notify_disconnect(int consnum)
184	{	187	{
185	if (!use_gcons)	188	if (!use_gcons)
186	return;	189	return;
187	if (active_console == consnum)	190	if (active_console == consnum)
188	console_state[consnum] = CONS_DISCONNECTED_SEL;	191	console_state[consnum] = CONS_DISCONNECTED_SEL;
189	else	192	else
190	console_state[consnum] = CONS_DISCONNECTED;	193	console_state[consnum] = CONS_DISCONNECTED;
191		194
192	if (active_console == KERNEL_CONSOLE)	195	if (active_console == KERNEL_CONSOLE)
193	return;	196	return;
194		197
195	redraw_state(consnum);	198	redraw_state(consnum);
196	vp_switch(console_vp);	199	vp_switch(console_vp);
197	}	200	}
198		201
199	/** Notification function called on console connect */	202	/** Notification function called on console connect */
200	void gcons_notify_connect(int consnum)	203	void gcons_notify_connect(int consnum)
201	{	204	{
202	if (!use_gcons)	205	if (!use_gcons)
203	return;	206	return;
204	if (active_console == consnum)	207	if (active_console == consnum)
205	console_state[consnum] = CONS_SELECTED;	208	console_state[consnum] = CONS_SELECTED;
206	else	209	else
207	console_state[consnum] = CONS_IDLE;	210	console_state[consnum] = CONS_IDLE;
208		211
209	if (active_console == KERNEL_CONSOLE)	212	if (active_console == KERNEL_CONSOLE)
210	return;	213	return;
211		214
212	redraw_state(consnum);	215	redraw_state(consnum);
213	vp_switch(console_vp);	216	vp_switch(console_vp);
214	}	217	}
215		218
216	/** Change to kernel console */	219	/** Change to kernel console */
217	void gcons_in_kernel(void)	220	void gcons_in_kernel(void)
218	{	221	{
219	if (console_state[active_console] == CONS_DISCONNECTED_SEL)	222	if (console_state[active_console] == CONS_DISCONNECTED_SEL)
220	console_state[active_console] = CONS_DISCONNECTED;	223	console_state[active_console] = CONS_DISCONNECTED;
221	else	224	else
222	console_state[active_console] = CONS_IDLE;	225	console_state[active_console] = CONS_IDLE;
223	redraw_state(active_console);	226	redraw_state(active_console);
224		227
225	if (animation != -1)	228	if (animation != -1)
226	async_msg(fbphone, FB_ANIM_STOP, animation);	229	async_msg(fbphone, FB_ANIM_STOP, animation);
227		230
228	active_console = KERNEL_CONSOLE; /* Set to kernel console */	231	active_console = KERNEL_CONSOLE; /* Set to kernel console */
229	vp_switch(0);	232	vp_switch(0);
230	}	233	}
231		234
232	/** Return x, where left <= x <= right && \|a-x\|==min(\|a-x\|) is smallest */	235	/** Return x, where left <= x <= right && \|a-x\|==min(\|a-x\|) is smallest */
233	static inline int limit(int a,int left, int right)	236	static inline int limit(int a,int left, int right)
234	{	237	{
235	if (a < left)	238	if (a < left)
236	a = left;	239	a = left;
237	if (a >= right)	240	if (a >= right)
238	a = right - 1;	241	a = right - 1;
239	return a;	242	return a;
240	}	243	}
241		244
242	int mouse_x, mouse_y;	245	int mouse_x, mouse_y;
243	int btn_pressed, btn_x, btn_y;	246	int btn_pressed, btn_x, btn_y;
244		247
245	/** Handle mouse move	248	/** Handle mouse move
246	*	249	*
247	* @param dx Delta X of mouse move	250	* @param dx Delta X of mouse move
248	* @param dy Delta Y of mouse move	251	* @param dy Delta Y of mouse move
249	*/	252	*/
250	void gcons_mouse_move(int dx, int dy)	253	void gcons_mouse_move(int dx, int dy)
251	{	254	{
252	mouse_x = limit(mouse_x+dx, 0, xres);	255	mouse_x = limit(mouse_x+dx, 0, xres);
253	mouse_y = limit(mouse_y+dy, 0, yres);	256	mouse_y = limit(mouse_y+dy, 0, yres);
254		257
255	async_msg_2(fbphone, FB_POINTER_MOVE, mouse_x, mouse_y);	258	async_msg_2(fbphone, FB_POINTER_MOVE, mouse_x, mouse_y);
256	}	259	}
257		260
258	static int gcons_find_conbut(int x, int y)	261	static int gcons_find_conbut(int x, int y)
259	{	262	{
260	int status_start = STATUS_START + (xres-800) / 2;;	263	int status_start = STATUS_START + (xres - 800) / 2;;
261		264
262	if (y < STATUS_TOP \|\| y >= STATUS_TOP+STATUS_HEIGHT)	265	if (y < STATUS_TOP \|\| y >= STATUS_TOP + STATUS_HEIGHT)
263	return -1;	266	return -1;
264		267
265	if (x < status_start)	268	if (x < status_start)
266	return -1;	269	return -1;
267		270
268	if (x >= status_start + (STATUS_WIDTH+STATUS_SPACE)*CONSOLE_COUNT)	271	if (x >= status_start + (STATUS_WIDTH + STATUS_SPACE) * CONSOLE_COUNT)
269	return -1;	272	return -1;
270	if (((x - status_start) % (STATUS_WIDTH+STATUS_SPACE)) < STATUS_SPACE)	273	if (((x - status_start) % (STATUS_WIDTH+STATUS_SPACE)) < STATUS_SPACE)
271	return -1;	274	return -1;
272		275
273	return (x-status_start) / (STATUS_WIDTH+STATUS_SPACE);	276	return (x - status_start) / (STATUS_WIDTH+STATUS_SPACE);
274	}	277	}
275		278
276	/** Handle mouse click	279	/** Handle mouse click
277	*	280	*
278	* @param state New state (1-pressed, 0-depressed)	281	* @param state New state (1-pressed, 0-depressed)
279	*/	282	*/
280	int gcons_mouse_btn(int state)	283	int gcons_mouse_btn(int state)
281	{	284	{
282	int conbut;	285	int conbut;
283		286
284	if (state) {	287	if (state) {
285	conbut = gcons_find_conbut(mouse_x, mouse_y);	288	conbut = gcons_find_conbut(mouse_x, mouse_y);
286	if (conbut != -1) {	289	if (conbut != -1) {
287	btn_pressed = 1;	290	btn_pressed = 1;
288	btn_x = mouse_x;	291	btn_x = mouse_x;
289	btn_y = mouse_y;	292	btn_y = mouse_y;
290	}	293	}
291	return -1;	294	return -1;
292	}	295	}
293	if (!state && !btn_pressed)	296	if (!state && !btn_pressed)
294	return -1;	297	return -1;
295	btn_pressed = 0;	298	btn_pressed = 0;
296		299
297	conbut = gcons_find_conbut(mouse_x, mouse_y);	300	conbut = gcons_find_conbut(mouse_x, mouse_y);
298	if (conbut == gcons_find_conbut(btn_x, btn_y))	301	if (conbut == gcons_find_conbut(btn_x, btn_y))
299	return conbut;	302	return conbut;
300	return -1;	303	return -1;
301	}	304	}
302		305
303		306
304	/** Draw a PPM pixmap to framebuffer	307	/** Draw a PPM pixmap to framebuffer
305	*	308	*
306	* @param logo Pointer to PPM data	309	* @param logo Pointer to PPM data
307	* @param size Size of PPM data	310	* @param size Size of PPM data
308	* @param x Coordinate of upper left corner	311	* @param x Coordinate of upper left corner
309	* @param y Coordinate of upper left corner	312	* @param y Coordinate of upper left corner
310	*/	313	*/
311	static void draw_pixmap(char *logo, size_t size, int x, int y)	314	static void draw_pixmap(char *logo, size_t size, int x, int y)
312	{	315	{
313	char *shm;	316	char *shm;
314	int rc;	317	int rc;
315		318
316	/* Create area */	319	/* Create area */
317	shm = mmap(NULL, size, PROTO_READ \| PROTO_WRITE, MAP_SHARED \| MAP_ANONYMOUS, 0, 0);	320	shm = mmap(NULL, size, PROTO_READ \| PROTO_WRITE, MAP_SHARED \|
-		321	MAP_ANONYMOUS, 0, 0);
318	if (shm == MAP_FAILED)	322	if (shm == MAP_FAILED)
319	return;	323	return;
320		324
321	memcpy(shm, logo, size);	325	memcpy(shm, logo, size);
322	/* Send area */	326	/* Send area */
323	rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);	327	rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm, 0, NULL,
-		328	NULL);
324	if (rc)	329	if (rc)
325	goto exit;	330	goto exit;
326	rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);	331	rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t) shm, 0,
-		332	PROTO_READ, NULL, NULL, NULL);
327	if (rc)	333	if (rc)
328	goto drop;	334	goto drop;
329	/* Draw logo */	335	/* Draw logo */
330	async_msg_2(fbphone, FB_DRAW_PPM, x, y);	336	async_msg_2(fbphone, FB_DRAW_PPM, x, y);
331	drop:	337	drop:
332	/* Drop area */	338	/* Drop area */
333	async_msg(fbphone, FB_DROP_SHM, 0);	339	async_msg(fbphone, FB_DROP_SHM, 0);
334	exit:	340	exit:
335	/* Remove area */	341	/* Remove area */
336	munmap(shm, size);	342	munmap(shm, size);
337	}	343	}
338		344
339	extern char _binary_helenos_ppm_start[0];	345	extern char _binary_helenos_ppm_start[0];
340	extern int _binary_helenos_ppm_size;	346	extern int _binary_helenos_ppm_size;
341	extern char _binary_nameic_ppm_start[0];	347	extern char _binary_nameic_ppm_start[0];
342	extern int _binary_nameic_ppm_size;	348	extern int _binary_nameic_ppm_size;
343	/** Redraws console graphics */	349	/** Redraws console graphics */
344	static void gcons_redraw_console(void)	350	static void gcons_redraw_console(void)
345	{	351	{
346	int i;	352	int i;
347		353
348	if (!use_gcons)	354	if (!use_gcons)
349	return;	355	return;
350		356
351	vp_switch(0);	357	vp_switch(0);
352	set_style(MAIN_COLOR, MAIN_COLOR);	358	set_style(MAIN_COLOR, MAIN_COLOR);
353	clear();	359	clear();
354	draw_pixmap(_binary_helenos_ppm_start, (size_t)&_binary_helenos_ppm_size, xres-66, 2);	360	draw_pixmap(_binary_helenos_ppm_start, (size_t)
-		361	&_binary_helenos_ppm_size, xres - 66, 2);
355	draw_pixmap(_binary_nameic_ppm_start, (size_t)&_binary_nameic_ppm_size, 5, 17);	362	draw_pixmap(_binary_nameic_ppm_start, (size_t)
-		363	&_binary_nameic_ppm_size, 5, 17);
356		364
357	for (i=0;i < CONSOLE_COUNT; i++)	365	for (i=0;i < CONSOLE_COUNT; i++)
358	redraw_state(i);	366	redraw_state(i);
359	vp_switch(console_vp);	367	vp_switch(console_vp);
360	}	368	}
361		369
362	/** Creates a pixmap on framebuffer	370	/** Creates a pixmap on framebuffer
363	*	371	*
364	* @param data PPM data	372	* @param data PPM data
365	* @param size PPM data size	373	* @param size PPM data size
366	* @return Pixmap identification	374	* @return Pixmap identification
367	*/	375	*/
368	static int make_pixmap(char *data, int size)	376	static int make_pixmap(char *data, int size)
369	{	377	{
370	char *shm;	378	char *shm;
371	int rc;	379	int rc;
372	int pxid = -1;	380	int pxid = -1;
373		381
374	/* Create area */	382	/* Create area */
375	shm = mmap(NULL, size, PROTO_READ \| PROTO_WRITE, MAP_SHARED \| MAP_ANONYMOUS, 0, 0);	383	shm = mmap(NULL, size, PROTO_READ \| PROTO_WRITE, MAP_SHARED \|
-		384	MAP_ANONYMOUS, 0, 0);
376	if (shm == MAP_FAILED)	385	if (shm == MAP_FAILED)
377	return -1;	386	return -1;
378		387
379	memcpy(shm, data, size);	388	memcpy(shm, data, size);
380	/* Send area */	389	/* Send area */
381	rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);	390	rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm, 0, NULL,
-		391	NULL);
382	if (rc)	392	if (rc)
383	goto exit;	393	goto exit;
384	rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);	394	rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t) shm, 0,
-		395	PROTO_READ, NULL, NULL, NULL);
385	if (rc)	396	if (rc)
386	goto drop;	397	goto drop;
387		398
388	/* Obtain pixmap */	399	/* Obtain pixmap */
389	rc = async_req(fbphone, FB_SHM2PIXMAP, 0, NULL);	400	rc = async_req(fbphone, FB_SHM2PIXMAP, 0, NULL);
390	if (rc < 0)	401	if (rc < 0)
391	goto drop;	402	goto drop;
392	pxid = rc;	403	pxid = rc;
393	drop:	404	drop:
394	/* Drop area */	405	/* Drop area */
395	async_msg(fbphone, FB_DROP_SHM, 0);	406	async_msg(fbphone, FB_DROP_SHM, 0);
396	exit:	407	exit:
397	/* Remove area */	408	/* Remove area */
398	munmap(shm, size);	409	munmap(shm, size);
399		410
400	return pxid;	411	return pxid;
401	}	412	}
402		413
403	extern char _binary_anim_1_ppm_start[0];	414	extern char _binary_anim_1_ppm_start[0];
404	extern int _binary_anim_1_ppm_size;	415	extern int _binary_anim_1_ppm_size;
405	extern char _binary_anim_2_ppm_start[0];	416	extern char _binary_anim_2_ppm_start[0];
406	extern int _binary_anim_2_ppm_size;	417	extern int _binary_anim_2_ppm_size;
407	extern char _binary_anim_3_ppm_start[0];	418	extern char _binary_anim_3_ppm_start[0];
408	extern int _binary_anim_3_ppm_size;	419	extern int _binary_anim_3_ppm_size;
409	extern char _binary_anim_4_ppm_start[0];	420	extern char _binary_anim_4_ppm_start[0];
410	extern int _binary_anim_4_ppm_size;	421	extern int _binary_anim_4_ppm_size;
-		422
411	static void make_anim(void)	423	static void make_anim(void)
412	{	424	{
413	int an;	425	int an;
414	int pm;	426	int pm;
415		427
416	an = async_req(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE], NULL);	428	an = async_req(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE],
-		429	NULL);
417	if (an < 0)	430	if (an < 0)
418	return;	431	return;
419		432
420	pm = make_pixmap(_binary_anim_1_ppm_start, (int)&_binary_anim_1_ppm_size);	433	pm = make_pixmap(_binary_anim_1_ppm_start, (int)
-		434	&_binary_anim_1_ppm_size);
421	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);	435	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
422		436
423	pm = make_pixmap(_binary_anim_2_ppm_start, (int)&_binary_anim_2_ppm_size);	437	pm = make_pixmap(_binary_anim_2_ppm_start, (int)
-		438	&_binary_anim_2_ppm_size);
424	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);	439	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
425		440
426	pm = make_pixmap(_binary_anim_3_ppm_start, (int)&_binary_anim_3_ppm_size);	441	pm = make_pixmap(_binary_anim_3_ppm_start, (int)
-		442	&_binary_anim_3_ppm_size);
427	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);	443	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
428		444
429	pm = make_pixmap(_binary_anim_4_ppm_start, (int)&_binary_anim_4_ppm_size);	445	pm = make_pixmap(_binary_anim_4_ppm_start, (int)
-		446	&_binary_anim_4_ppm_size);
430	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);	447	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
431		448
432	async_msg(fbphone, FB_ANIM_START, an);	449	async_msg(fbphone, FB_ANIM_START, an);
433		450
434	animation = an;	451	animation = an;
435	}	452	}
436		453
437	extern char _binary_cons_selected_ppm_start[0];	454	extern char _binary_cons_selected_ppm_start[0];
438	extern int _binary_cons_selected_ppm_size;	455	extern int _binary_cons_selected_ppm_size;
439	extern char _binary_cons_idle_ppm_start[0];	456	extern char _binary_cons_idle_ppm_start[0];
440	extern int _binary_cons_idle_ppm_size;	457	extern int _binary_cons_idle_ppm_size;
441	extern char _binary_cons_has_data_ppm_start[0];	458	extern char _binary_cons_has_data_ppm_start[0];
442	extern int _binary_cons_has_data_ppm_size;	459	extern int _binary_cons_has_data_ppm_size;
443	extern char _binary_cons_kernel_ppm_start[0];	460	extern char _binary_cons_kernel_ppm_start[0];
444	extern int _binary_cons_kernel_ppm_size;	461	extern int _binary_cons_kernel_ppm_size;
-		462
445	/** Initialize nice graphical console environment */	463	/** Initialize nice graphical console environment */
446	void gcons_init(int phone)	464	void gcons_init(int phone)
447	{	465	{
448	int rc;	466	int rc;
449	int i;	467	int i;
450	int status_start = STATUS_START;	468	int status_start = STATUS_START;
451		469
452	fbphone = phone;	470	fbphone = phone;
453		471
454	rc = async_req_2(phone, FB_GET_RESOLUTION, 0, 0, &xres, &yres);	472	rc = async_req_2(phone, FB_GET_RESOLUTION, 0, 0, &xres, &yres);
455	if (rc)	473	if (rc)
456	return;	474	return;
457		475
458	if (xres < 800 \|\| yres < 600)	476	if (xres < 800 \|\| yres < 600)
459	return;	477	return;
460		478
461	/* create console viewport */	479	/* create console viewport */
462	/* Align width & height to character size */	480	/* Align width & height to character size */
463	console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP,	481	console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP, ALIGN_DOWN(xres -
464	ALIGN_DOWN(xres-2*CONSOLE_MARGIN, 8),	482	2 * CONSOLE_MARGIN, 8), ALIGN_DOWN(yres - (CONSOLE_TOP +
465	ALIGN_DOWN(yres-(CONSOLE_TOP+CONSOLE_MARGIN),16));	483	CONSOLE_MARGIN), 16));
466	if (console_vp < 0)	484	if (console_vp < 0)
467	return;	485	return;
468		486
469	/* Create status buttons */	487	/* Create status buttons */
470	status_start += (xres-800) / 2;	488	status_start += (xres - 800) / 2;
471	for (i=0; i < CONSOLE_COUNT; i++) {	489	for (i = 0; i < CONSOLE_COUNT; i++) {
472	cstatus_vp[i] = vp_create(status_start+CONSOLE_MARGIN+i*(STATUS_WIDTH+STATUS_SPACE),	490	cstatus_vp[i] = vp_create(status_start + CONSOLE_MARGIN + i *
-		491	(STATUS_WIDTH + STATUS_SPACE), STATUS_TOP,
473	STATUS_TOP, STATUS_WIDTH, STATUS_HEIGHT);	492	STATUS_WIDTH, STATUS_HEIGHT);
474	if (cstatus_vp[i] < 0)	493	if (cstatus_vp[i] < 0)
475	return;	494	return;
476	vp_switch(cstatus_vp[i]);	495	vp_switch(cstatus_vp[i]);
477	set_style(0x202020, 0xffffff);	496	set_style(0x202020, 0xffffff);
478	}	497	}
479		498
480	/* Initialize icons */	499	/* Initialize icons */
-		500	ic_pixmaps[CONS_SELECTED] =

Subversion Repositories HelenOS

(root)/trunk/uspace/console/gcons.c – Rev 1867 → 2025