WebSVN – HelenOS-historic – Diff – /uspace/trunk/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 int cstat_row, cstat_col; /* Size of cstatus buttons */
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)
{
    /* Init function, use ipc_call_sync */
    return ipc_call_sync_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);
}
 
/** 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;
    size_t hsize = (size_t)&_binary_helenos_ppm_size;
 
    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 = ipc_call_sync_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 1649	Rev 1668
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 65	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 3	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 int cstat_row, cstat_col; /* Size of cstatus buttons */	72	static int cstat_row, cstat_col; /* Size of cstatus buttons */
73	static enum butstate console_state[CONSOLE_COUNT];	73	static enum butstate console_state[CONSOLE_COUNT];
74		74
75	static int fbphone;	75	static int fbphone;
76		76
77	/** List of pixmaps identifying these icons */	77	/** List of pixmaps identifying these icons */
78	static int ic_pixmaps[CONS_LAST] = {-1,-1,-1,-1,-1,-1};	78	static int ic_pixmaps[CONS_LAST] = {-1,-1,-1,-1,-1,-1};
79	static int animation = -1;	79	static int animation = -1;
80		80
81	static int active_console = 0;	81	static int active_console = 0;
82		82
83	static void vp_switch(int vp)	83	static void vp_switch(int vp)
84	{	84	{
85	async_msg(fbphone,FB_VIEWPORT_SWITCH, vp);	85	async_msg(fbphone,FB_VIEWPORT_SWITCH, vp);
86	}	86	}
87		87
88	/** Create view port */	88	/** Create view port */
89	static int vp_create(unsigned int x, unsigned int y,	89	static int vp_create(unsigned int x, unsigned int y,
90	unsigned int width, unsigned int height)	90	unsigned int width, unsigned int height)
91	{	91	{
92	/* Init function, use ipc_call_sync */	92	/* Init function, use ipc_call_sync */
93	return ipc_call_sync_2(fbphone, FB_VIEWPORT_CREATE,	93	return ipc_call_sync_2(fbphone, FB_VIEWPORT_CREATE,
94	(x << 16) \| y, (width << 16) \| height,	94	(x << 16) \| y, (width << 16) \| height,
95	NULL, NULL);	95	NULL, NULL);
96	}	96	}
97		97
98	static void clear(void)	98	static void clear(void)
99	{	99	{
100	async_msg(fbphone, FB_CLEAR, 0);	100	async_msg(fbphone, FB_CLEAR, 0);
101		101
102	}	102	}
103		103
104	static void set_style(int fgcolor, int bgcolor)	104	static void set_style(int fgcolor, int bgcolor)
105	{	105	{
106	async_msg_2(fbphone, FB_SET_STYLE, fgcolor, bgcolor);	106	async_msg_2(fbphone, FB_SET_STYLE, fgcolor, bgcolor);
107	}	107	}
108		108
109	/** Transparent putchar */	109	/** Transparent putchar */
110	static void tran_putch(char c, int row, int col)	110	static void tran_putch(char c, int row, int col)
111	{	111	{
112	async_msg_3(fbphone, FB_TRANS_PUTCHAR, c, row, col);	112	async_msg_3(fbphone, FB_TRANS_PUTCHAR, c, row, col);
113	}	113	}
114		114
115	/** Redraw the button showing state of a given console */	115	/** Redraw the button showing state of a given console */
116	static void redraw_state(int consnum)	116	static void redraw_state(int consnum)
117	{	117	{
118	char data[5];	118	char data[5];
119	int i;	119	int i;
120	enum butstate state = console_state[consnum];	120	enum butstate state = console_state[consnum];
121		121
122	vp_switch(cstatus_vp[consnum]);	122	vp_switch(cstatus_vp[consnum]);
123	if (ic_pixmaps[state] != -1)	123	if (ic_pixmaps[state] != -1)
124	async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum], ic_pixmaps[state]);	124	async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum], ic_pixmaps[state]);
125		125
126	if (state != CONS_DISCONNECTED && state != CONS_KERNEL && state != CONS_DISCONNECTED_SEL) {	126	if (state != CONS_DISCONNECTED && state != CONS_KERNEL && state != CONS_DISCONNECTED_SEL) {
127	snprintf(data, 5, "%d", consnum+1);	127	snprintf(data, 5, "%d", consnum+1);
128	for (i=0;data[i];i++)	128	for (i=0;data[i];i++)
129	tran_putch(data[i], 1, 2+i);	129	tran_putch(data[i], 1, 2+i);
130	}	130	}
131	}	131	}
132		132
133	/** Notification run on changing console (except kernel console) */	133	/** Notification run on changing console (except kernel console) */
134	void gcons_change_console(int consnum)	134	void gcons_change_console(int consnum)
135	{	135	{
136	int i;	136	int i;
137		137
138	if (!use_gcons)	138	if (!use_gcons)
139	return;	139	return;
140		140
141	if (active_console == KERNEL_CONSOLE) {	141	if (active_console == KERNEL_CONSOLE) {
142	for (i=0; i < CONSOLE_COUNT; i++)	142	for (i=0; i < CONSOLE_COUNT; i++)
143	redraw_state(i);	143	redraw_state(i);
144	if (animation != -1)	144	if (animation != -1)
145	async_msg(fbphone, FB_ANIM_START, animation);	145	async_msg(fbphone, FB_ANIM_START, animation);
146	} else {	146	} else {
147	if (console_state[active_console] == CONS_DISCONNECTED_SEL)	147	if (console_state[active_console] == CONS_DISCONNECTED_SEL)
148	console_state[active_console] = CONS_DISCONNECTED;	148	console_state[active_console] = CONS_DISCONNECTED;
149	else	149	else
150	console_state[active_console] = CONS_IDLE;	150	console_state[active_console] = CONS_IDLE;
151	redraw_state(active_console);	151	redraw_state(active_console);
152	}	152	}
153	active_console = consnum;	153	active_console = consnum;
154		154
155	if (console_state[consnum] == CONS_DISCONNECTED) {	155	if (console_state[consnum] == CONS_DISCONNECTED) {
156	console_state[consnum] = CONS_DISCONNECTED_SEL;	156	console_state[consnum] = CONS_DISCONNECTED_SEL;
157	redraw_state(consnum);	157	redraw_state(consnum);
158	} else	158	} else
159	console_state[consnum] = CONS_SELECTED;	159	console_state[consnum] = CONS_SELECTED;
160	redraw_state(consnum);	160	redraw_state(consnum);
161		161
162	vp_switch(console_vp);	162	vp_switch(console_vp);
163	}	163	}
164		164
165	/** Notification function that gets called on new output to virtual console */	165	/** Notification function that gets called on new output to virtual console */
166	void gcons_notify_char(int consnum)	166	void gcons_notify_char(int consnum)
167	{	167	{
168	if (!use_gcons)	168	if (!use_gcons)
169	return;	169	return;
170		170
171	if (consnum == active_console \|\| console_state[consnum] == CONS_HAS_DATA)	171	if (consnum == active_console \|\| console_state[consnum] == CONS_HAS_DATA)
172	return;	172	return;
173		173
174	console_state[consnum] = CONS_HAS_DATA;	174	console_state[consnum] = CONS_HAS_DATA;
175		175
176	if (active_console == KERNEL_CONSOLE)	176	if (active_console == KERNEL_CONSOLE)
177	return;	177	return;
178		178
179	redraw_state(consnum);	179	redraw_state(consnum);
180		180
181	vp_switch(console_vp);	181	vp_switch(console_vp);
182	}	182	}
183		183
184	/** Notification function called on service disconnect from console */	184	/** Notification function called on service disconnect from console */
185	void gcons_notify_disconnect(int consnum)	185	void gcons_notify_disconnect(int consnum)
186	{	186	{
187	if (!use_gcons)	187	if (!use_gcons)
188	return;	188	return;
189	if (active_console == consnum)	189	if (active_console == consnum)
190	console_state[consnum] = CONS_DISCONNECTED_SEL;	190	console_state[consnum] = CONS_DISCONNECTED_SEL;
191	else	191	else
192	console_state[consnum] = CONS_DISCONNECTED;	192	console_state[consnum] = CONS_DISCONNECTED;
193		193
194	if (active_console == KERNEL_CONSOLE)	194	if (active_console == KERNEL_CONSOLE)
195	return;	195	return;
196		196
197	redraw_state(consnum);	197	redraw_state(consnum);
198	vp_switch(console_vp);	198	vp_switch(console_vp);
199	}	199	}
200		200
201	/** Notification function called on console connect */	201	/** Notification function called on console connect */
202	void gcons_notify_connect(int consnum)	202	void gcons_notify_connect(int consnum)
203	{	203	{
204	if (!use_gcons)	204	if (!use_gcons)
205	return;	205	return;
206	if (active_console == consnum)	206	if (active_console == consnum)
207	console_state[consnum] = CONS_SELECTED;	207	console_state[consnum] = CONS_SELECTED;
208	else	208	else
209	console_state[consnum] = CONS_IDLE;	209	console_state[consnum] = CONS_IDLE;
210		210
211	if (active_console == KERNEL_CONSOLE)	211	if (active_console == KERNEL_CONSOLE)
212	return;	212	return;
213		213
214	redraw_state(consnum);	214	redraw_state(consnum);
215	vp_switch(console_vp);	215	vp_switch(console_vp);
216	}	216	}
217		217
218	/** Change to kernel console */	218	/** Change to kernel console */
219	void gcons_in_kernel(void)	219	void gcons_in_kernel(void)
220	{	220	{
221	if (console_state[active_console] == CONS_DISCONNECTED_SEL)	221	if (console_state[active_console] == CONS_DISCONNECTED_SEL)
222	console_state[active_console] = CONS_DISCONNECTED;	222	console_state[active_console] = CONS_DISCONNECTED;
223	else	223	else
224	console_state[active_console] = CONS_IDLE;	224	console_state[active_console] = CONS_IDLE;
225	redraw_state(active_console);	225	redraw_state(active_console);
226		226
227	if (animation != -1)	227	if (animation != -1)
228	async_msg(fbphone, FB_ANIM_STOP, animation);	228	async_msg(fbphone, FB_ANIM_STOP, animation);
229		229
230	active_console = KERNEL_CONSOLE; /* Set to kernel console */	230	active_console = KERNEL_CONSOLE; /* Set to kernel console */
231	vp_switch(0);	231	vp_switch(0);
232	}	232	}
233		233
234	/** Draw a PPM pixmap to framebuffer	234	/** Draw a PPM pixmap to framebuffer
235	*	235	*
236	* @param logo Pointer to PPM data	236	* @param logo Pointer to PPM data
237	* @param size Size of PPM data	237	* @param size Size of PPM data
238	* @param x Coordinate of upper left corner	238	* @param x Coordinate of upper left corner
239	* @param y Coordinate of upper left corner	239	* @param y Coordinate of upper left corner
240	*/	240	*/
241	static void draw_pixmap(char *logo, size_t size, int x, int y)	241	static void draw_pixmap(char *logo, size_t size, int x, int y)
242	{	242	{
243	char *shm;	243	char *shm;
244	int rc;	244	int rc;
245		245
246	/* Create area */	246	/* Create area */
247	shm = mmap(NULL, size, PROTO_READ \| PROTO_WRITE, MAP_SHARED \| MAP_ANONYMOUS, 0, 0);	247	shm = mmap(NULL, size, PROTO_READ \| PROTO_WRITE, MAP_SHARED \| MAP_ANONYMOUS, 0, 0);
248	if (shm == MAP_FAILED)	248	if (shm == MAP_FAILED)
249	return;	249	return;
250		250
251	memcpy(shm, logo, size);	251	memcpy(shm, logo, size);
252	/* Send area */	252	/* Send area */
253	rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);	253	rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);
254	if (rc)	254	if (rc)
255	goto exit;	255	goto exit;
256	rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);	256	rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);
257	if (rc)	257	if (rc)
258	goto drop;	258	goto drop;
259	/* Draw logo */	259	/* Draw logo */
260	async_msg_2(fbphone, FB_DRAW_PPM, x, y);	260	async_msg_2(fbphone, FB_DRAW_PPM, x, y);
261	drop:	261	drop:
262	/* Drop area */	262	/* Drop area */
263	async_msg(fbphone, FB_DROP_SHM, 0);	263	async_msg(fbphone, FB_DROP_SHM, 0);
264	exit:	264	exit:
265	/* Remove area */	265	/* Remove area */
266	munmap(shm, size);	266	munmap(shm, size);
267	}	267	}
268		268
269	extern char _binary_helenos_ppm_start[0];	269	extern char _binary_helenos_ppm_start[0];
270	extern int _binary_helenos_ppm_size;	270	extern int _binary_helenos_ppm_size;
271	extern char _binary_nameic_ppm_start[0];	271	extern char _binary_nameic_ppm_start[0];
272	extern int _binary_nameic_ppm_size;	272	extern int _binary_nameic_ppm_size;
273	/** Redraws console graphics */	273	/** Redraws console graphics */
274	static void gcons_redraw_console(void)	274	static void gcons_redraw_console(void)
275	{	275	{
276	int i;	276	int i;
277	size_t hsize = (size_t)&_binary_helenos_ppm_size;	277	size_t hsize = (size_t)&_binary_helenos_ppm_size;
278		278
279	if (!use_gcons)	279	if (!use_gcons)
280	return;	280	return;
281		281
282	vp_switch(0);	282	vp_switch(0);
283	set_style(MAIN_COLOR, MAIN_COLOR);	283	set_style(MAIN_COLOR, MAIN_COLOR);
284	clear();	284	clear();
285	draw_pixmap(_binary_helenos_ppm_start, (size_t)&_binary_helenos_ppm_size, xres-66, 2);	285	draw_pixmap(_binary_helenos_ppm_start, (size_t)&_binary_helenos_ppm_size, xres-66, 2);
286	draw_pixmap(_binary_nameic_ppm_start, (size_t)&_binary_nameic_ppm_size, 5, 17);	286	draw_pixmap(_binary_nameic_ppm_start, (size_t)&_binary_nameic_ppm_size, 5, 17);
287		287
288	for (i=0;i < CONSOLE_COUNT; i++)	288	for (i=0;i < CONSOLE_COUNT; i++)
289	redraw_state(i);	289	redraw_state(i);
290	vp_switch(console_vp);	290	vp_switch(console_vp);
291	}	291	}
292		292
293	/** Creates a pixmap on framebuffer	293	/** Creates a pixmap on framebuffer
294	*	294	*
295	* @param data PPM data	295	* @param data PPM data
296	* @param size PPM data size	296	* @param size PPM data size
297	* @return Pixmap identification	297	* @return Pixmap identification
298	*/	298	*/
299	static int make_pixmap(char *data, int size)	299	static int make_pixmap(char *data, int size)
300	{	300	{
301	char *shm;	301	char *shm;
302	int rc;	302	int rc;
303	int pxid = -1;	303	int pxid = -1;
304		304
305	/* Create area */	305	/* Create area */
306	shm = mmap(NULL, size, PROTO_READ \| PROTO_WRITE, MAP_SHARED \| MAP_ANONYMOUS, 0, 0);	306	shm = mmap(NULL, size, PROTO_READ \| PROTO_WRITE, MAP_SHARED \| MAP_ANONYMOUS, 0, 0);
307	if (shm == MAP_FAILED)	307	if (shm == MAP_FAILED)
308	return -1;	308	return -1;
309		309
310	memcpy(shm, data, size);	310	memcpy(shm, data, size);
311	/* Send area */	311	/* Send area */
312	rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);	312	rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);
313	if (rc)	313	if (rc)
314	goto exit;	314	goto exit;
315	rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);	315	rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);
316	if (rc)	316	if (rc)
317	goto drop;	317	goto drop;
318		318
319	/* Obtain pixmap */	319	/* Obtain pixmap */
320	rc = async_req(fbphone, FB_SHM2PIXMAP, 0, NULL);	320	rc = async_req(fbphone, FB_SHM2PIXMAP, 0, NULL);
321	if (rc < 0)	321	if (rc < 0)
322	goto drop;	322	goto drop;
323	pxid = rc;	323	pxid = rc;
324	drop:	324	drop:
325	/* Drop area */	325	/* Drop area */
326	async_msg(fbphone, FB_DROP_SHM, 0);	326	async_msg(fbphone, FB_DROP_SHM, 0);
327	exit:	327	exit:
328	/* Remove area */	328	/* Remove area */
329	munmap(shm, size);	329	munmap(shm, size);
330		330
331	return pxid;	331	return pxid;
332	}	332	}
333		333
334	extern char _binary_anim_1_ppm_start[0];	334	extern char _binary_anim_1_ppm_start[0];
335	extern int _binary_anim_1_ppm_size;	335	extern int _binary_anim_1_ppm_size;
336	extern char _binary_anim_2_ppm_start[0];	336	extern char _binary_anim_2_ppm_start[0];
337	extern int _binary_anim_2_ppm_size;	337	extern int _binary_anim_2_ppm_size;
338	extern char _binary_anim_3_ppm_start[0];	338	extern char _binary_anim_3_ppm_start[0];
339	extern int _binary_anim_3_ppm_size;	339	extern int _binary_anim_3_ppm_size;
340	extern char _binary_anim_4_ppm_start[0];	340	extern char _binary_anim_4_ppm_start[0];
341	extern int _binary_anim_4_ppm_size;	341	extern int _binary_anim_4_ppm_size;
342	static void make_anim(void)	342	static void make_anim(void)
343	{	343	{
344	int an;	344	int an;
345	int pm;	345	int pm;
346		346
347	an = async_req(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE], NULL);	347	an = async_req(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE], NULL);
348	if (an < 0)	348	if (an < 0)
349	return;	349	return;
350		350
351	pm = make_pixmap(_binary_anim_1_ppm_start, (int)&_binary_anim_1_ppm_size);	351	pm = make_pixmap(_binary_anim_1_ppm_start, (int)&_binary_anim_1_ppm_size);
352	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);	352	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
353		353
354	pm = make_pixmap(_binary_anim_2_ppm_start, (int)&_binary_anim_2_ppm_size);	354	pm = make_pixmap(_binary_anim_2_ppm_start, (int)&_binary_anim_2_ppm_size);
355	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);	355	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
356		356
357	pm = make_pixmap(_binary_anim_3_ppm_start, (int)&_binary_anim_3_ppm_size);	357	pm = make_pixmap(_binary_anim_3_ppm_start, (int)&_binary_anim_3_ppm_size);
358	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);	358	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
359		359
360	pm = make_pixmap(_binary_anim_4_ppm_start, (int)&_binary_anim_4_ppm_size);	360	pm = make_pixmap(_binary_anim_4_ppm_start, (int)&_binary_anim_4_ppm_size);
361	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);	361	async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
362		362
363	async_msg(fbphone, FB_ANIM_START, an);	363	async_msg(fbphone, FB_ANIM_START, an);
364		364
365	animation = an;	365	animation = an;
366	}	366	}
367		367
368	extern char _binary_cons_selected_ppm_start[0];	368	extern char _binary_cons_selected_ppm_start[0];
369	extern int _binary_cons_selected_ppm_size;	369	extern int _binary_cons_selected_ppm_size;
370	extern char _binary_cons_idle_ppm_start[0];	370	extern char _binary_cons_idle_ppm_start[0];
371	extern int _binary_cons_idle_ppm_size;	371	extern int _binary_cons_idle_ppm_size;
372	extern char _binary_cons_has_data_ppm_start[0];	372	extern char _binary_cons_has_data_ppm_start[0];
373	extern int _binary_cons_has_data_ppm_size;	373	extern int _binary_cons_has_data_ppm_size;
374	extern char _binary_cons_kernel_ppm_start[0];	374	extern char _binary_cons_kernel_ppm_start[0];
375	extern int _binary_cons_kernel_ppm_size;	375	extern int _binary_cons_kernel_ppm_size;
376	/** Initialize nice graphical console environment */	376	/** Initialize nice graphical console environment */
377	void gcons_init(int phone)	377	void gcons_init(int phone)
378	{	378	{
379	int rc;	379	int rc;
380	int i;	380	int i;
381	int status_start = STATUS_START;	381	int status_start = STATUS_START;
382		382
383	fbphone = phone;	383	fbphone = phone;
384		384
385	rc = ipc_call_sync_2(phone, FB_GET_RESOLUTION, 0, 0, &xres, &yres);	385	rc = ipc_call_sync_2(phone, FB_GET_RESOLUTION, 0, 0, &xres, &yres);
386	if (rc)	386	if (rc)
387	return;	387	return;
388		388
389	if (xres < 800 \|\| yres < 600)	389	if (xres < 800 \|\| yres < 600)
390	return;	390	return;
391		391
392	/* create console viewport */	392	/* create console viewport */
393	/* Align width & height to character size */	393	/* Align width & height to character size */
394	console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP,	394	console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP,
395	ALIGN_DOWN(xres-2*CONSOLE_MARGIN, 8),	395	ALIGN_DOWN(xres-2*CONSOLE_MARGIN, 8),
396	ALIGN_DOWN(yres-(CONSOLE_TOP+CONSOLE_MARGIN),16));	396	ALIGN_DOWN(yres-(CONSOLE_TOP+CONSOLE_MARGIN),16));
397	if (console_vp < 0)	397	if (console_vp < 0)
398	return;	398	return;
399		399
400	/* Create status buttons */	400	/* Create status buttons */
401	status_start += (xres-800) / 2;	401	status_start += (xres-800) / 2;
402	for (i=0; i < CONSOLE_COUNT; i++) {	402	for (i=0; i < CONSOLE_COUNT; i++) {
403	cstatus_vp[i] = vp_create(status_start+CONSOLE_MARGIN+i*(STATUS_WIDTH+STATUS_SPACE),	403	cstatus_vp[i] = vp_create(status_start+CONSOLE_MARGIN+i*(STATUS_WIDTH+STATUS_SPACE),
404	STATUS_TOP, STATUS_WIDTH, STATUS_HEIGHT);	404	STATUS_TOP, STATUS_WIDTH, STATUS_HEIGHT);
405	if (cstatus_vp[i] < 0)	405	if (cstatus_vp[i] < 0)
406	return;	406	return;
407	vp_switch(cstatus_vp[i]);	407	vp_switch(cstatus_vp[i]);
408	set_style(0x202020, 0xffffff);	408	set_style(0x202020, 0xffffff);
409	}	409	}
410		410
411	/* Initialize icons */	411	/* Initialize icons */
412	ic_pixmaps[CONS_SELECTED] = make_pixmap(_binary_cons_selected_ppm_start,	412	ic_pixmaps[CONS_SELECTED] = make_pixmap(_binary_cons_selected_ppm_start,
413	(int)&_binary_cons_selected_ppm_size);	413	(int)&_binary_cons_selected_ppm_size);
414	ic_pixmaps[CONS_IDLE] = make_pixmap(_binary_cons_idle_ppm_start,	414	ic_pixmaps[CONS_IDLE] = make_pixmap(_binary_cons_idle_ppm_start,
415	(int)&_binary_cons_idle_ppm_size);	415	(int)&_binary_cons_idle_ppm_size);
416	ic_pixmaps[CONS_HAS_DATA] = make_pixmap(_binary_cons_has_data_ppm_start,	416	ic_pixmaps[CONS_HAS_DATA] = make_pixmap(_binary_cons_has_data_ppm_start,
417	(int)&_binary_cons_has_data_ppm_size);	417	(int)&_binary_cons_has_data_ppm_size);
418	ic_pixmaps[CONS_DISCONNECTED] = make_pixmap(_binary_cons_idle_ppm_start,	418	ic_pixmaps[CONS_DISCONNECTED] = make_pixmap(_binary_cons_idle_ppm_start,
419	(int)&_binary_cons_idle_ppm_size);	419	(int)&_binary_cons_idle_ppm_size);
420	ic_pixmaps[CONS_KERNEL] = make_pixmap(_binary_cons_kernel_ppm_start,	420	ic_pixmaps[CONS_KERNEL] = make_pixmap(_binary_cons_kernel_ppm_start,
421	(int)&_binary_cons_kernel_ppm_size);	421	(int)&_binary_cons_kernel_ppm_size);
422	ic_pixmaps[CONS_DISCONNECTED_SEL] = ic_pixmaps[CONS_SELECTED];	422	ic_pixmaps[CONS_DISCONNECTED_SEL] = ic_pixmaps[CONS_SELECTED];
423		423
424	make_anim();	424	make_anim();
425		425
426	use_gcons = 1;	426	use_gcons = 1;
427	console_state[0] = CONS_DISCONNECTED_SEL;	427	console_state[0] = CONS_DISCONNECTED_SEL;
428	console_state[KERNEL_CONSOLE] = CONS_KERNEL;	428	console_state[KERNEL_CONSOLE] = CONS_KERNEL;
429	gcons_redraw_console();	429	gcons_redraw_console();
430	}	430	}
431		431
432	/** @}	432	/** @}
433	*/	433	*/
434		434
435		435

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/console/gcons.c – Rev 1649 → 1668