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

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/console/gcons.c – Rev 1689 → 1707