Subversion Repositories HelenOS

Rev

Rev 3675 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3675 Rev 4377
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_1(fbphone,FB_VIEWPORT_SWITCH, vp);
84
    async_msg_1(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, unsigned int width,
88
static int vp_create(unsigned int x, unsigned int y, unsigned int width,
89
    unsigned int height)
89
    unsigned int height)
90
{
90
{
91
    return async_req_2_0(fbphone, FB_VIEWPORT_CREATE, (x << 16) | y,
91
    return async_req_2_0(fbphone, FB_VIEWPORT_CREATE, (x << 16) | y,
92
        (width << 16) | height);
92
        (width << 16) | height);
93
}
93
}
94
 
94
 
95
static void clear(void)
95
static void clear(void)
96
{
96
{
97
    async_msg_0(fbphone, FB_CLEAR);
97
    async_msg_0(fbphone, FB_CLEAR);
98
}
98
}
99
 
99
 
100
static void set_style(int fgcolor, int bgcolor)
100
static void set_rgb_color(int fgcolor, int bgcolor)
101
{
101
{
102
    async_msg_2(fbphone, FB_SET_STYLE, fgcolor, bgcolor);
102
    async_msg_2(fbphone, FB_SET_RGB_COLOR, fgcolor, bgcolor);
103
}
103
}
104
 
104
 
105
/** Transparent putchar */
105
/** Transparent putchar */
106
static void tran_putch(char c, int row, int col)
106
static void tran_putch(char c, int row, int col)
107
{
107
{
108
    async_msg_3(fbphone, FB_TRANS_PUTCHAR, c, row, col);
108
    async_msg_3(fbphone, FB_PUTCHAR, c, row, col);
109
}
109
}
110
 
110
 
111
/** Redraw the button showing state of a given console */
111
/** Redraw the button showing state of a given console */
112
static void redraw_state(int consnum)
112
static void redraw_state(int consnum)
113
{
113
{
114
    char data[5];
114
    char data[5];
115
    int i;
115
    int i;
116
    enum butstate state = console_state[consnum];
116
    enum butstate state = console_state[consnum];
117
 
117
 
118
    vp_switch(cstatus_vp[consnum]);
118
    vp_switch(cstatus_vp[consnum]);
119
    if (ic_pixmaps[state] != -1)
119
    if (ic_pixmaps[state] != -1)
120
        async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum],
120
        async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum],
121
            ic_pixmaps[state]);
121
            ic_pixmaps[state]);
122
 
122
 
123
    if (state != CONS_DISCONNECTED && state != CONS_KERNEL &&
123
    if (state != CONS_DISCONNECTED && state != CONS_KERNEL &&
124
        state != CONS_DISCONNECTED_SEL) {
124
        state != CONS_DISCONNECTED_SEL) {
125
        snprintf(data, 5, "%d", consnum + 1);
125
        snprintf(data, 5, "%d", consnum + 1);
126
        for (i = 0; data[i]; i++)
126
        for (i = 0; data[i]; i++)
127
            tran_putch(data[i], 1, 2 + i);
127
            tran_putch(data[i], 1, 2 + i);
128
    }
128
    }
129
}
129
}
130
 
130
 
131
/** Notification run on changing console (except kernel console) */
131
/** Notification run on changing console (except kernel console) */
132
void gcons_change_console(int consnum)
132
void gcons_change_console(int consnum)
133
{
133
{
134
    int i;
134
    int i;
135
 
135
 
136
    if (!use_gcons)
136
    if (!use_gcons)
137
        return;
137
        return;
138
 
138
 
139
    if (active_console == KERNEL_CONSOLE) {
139
    if (active_console == KERNEL_CONSOLE) {
140
        for (i = 0; i < CONSOLE_COUNT; i++)
140
        for (i = 0; i < CONSOLE_COUNT; i++)
141
            redraw_state(i);
141
            redraw_state(i);
142
        if (animation != -1)
142
        if (animation != -1)
143
            async_msg_1(fbphone, FB_ANIM_START, animation);
143
            async_msg_1(fbphone, FB_ANIM_START, animation);
144
    } else {
144
    } else {
145
        if (console_state[active_console] == CONS_DISCONNECTED_SEL)
145
        if (console_state[active_console] == CONS_DISCONNECTED_SEL)
146
            console_state[active_console] = CONS_DISCONNECTED;
146
            console_state[active_console] = CONS_DISCONNECTED;
147
        else
147
        else
148
            console_state[active_console] = CONS_IDLE;
148
            console_state[active_console] = CONS_IDLE;
149
        redraw_state(active_console);
149
        redraw_state(active_console);
150
    }
150
    }
151
    active_console = consnum;
151
    active_console = consnum;
152
 
152
 
153
    if (console_state[consnum] == CONS_DISCONNECTED) {
153
    if (console_state[consnum] == CONS_DISCONNECTED) {
154
        console_state[consnum] = CONS_DISCONNECTED_SEL;
154
        console_state[consnum] = CONS_DISCONNECTED_SEL;
155
        redraw_state(consnum);
155
        redraw_state(consnum);
156
    } else
156
    } else
157
        console_state[consnum] = CONS_SELECTED;
157
        console_state[consnum] = CONS_SELECTED;
158
    redraw_state(consnum);
158
    redraw_state(consnum);
159
 
159
 
160
    vp_switch(console_vp);
160
    vp_switch(console_vp);
161
}
161
}
162
 
162
 
163
/** Notification function that gets called on new output to virtual console */
163
/** Notification function that gets called on new output to virtual console */
164
void gcons_notify_char(int consnum)
164
void gcons_notify_char(int consnum)
165
{
165
{
166
    if (!use_gcons)
166
    if (!use_gcons)
167
        return;
167
        return;
168
 
168
 
169
    if (consnum == active_console ||
169
    if (consnum == active_console ||
170
        console_state[consnum] == CONS_HAS_DATA)
170
        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)
-
 
221
        console_state[active_console] = CONS_DISCONNECTED;
-
 
222
    else
-
 
223
        console_state[active_console] = CONS_IDLE;
-
 
224
    redraw_state(active_console);
-
 
225
 
-
 
226
    if (animation != -1)
220
    if (animation != -1)
227
        async_msg_1(fbphone, FB_ANIM_STOP, animation);
221
        async_msg_1(fbphone, FB_ANIM_STOP, animation);
228
 
222
   
229
    active_console = KERNEL_CONSOLE; /* Set to kernel console */
223
    active_console = KERNEL_CONSOLE;
230
    vp_switch(0);
224
    vp_switch(0);
231
}
225
}
232
 
226
 
233
/** Return x, where left <= x <= right && |a-x|==min(|a-x|) is smallest */
227
/** Return x, where left <= x <= right && |a-x|==min(|a-x|) is smallest */
234
static inline int limit(int a,int left, int right)
228
static inline int limit(int a,int left, int right)
235
{
229
{
236
    if (a < left)
230
    if (a < left)
237
        a = left;
231
        a = left;
238
    if (a >= right)
232
    if (a >= right)
239
        a = right - 1;
233
        a = right - 1;
240
    return a;
234
    return a;
241
}
235
}
242
 
236
 
243
int mouse_x, mouse_y;
237
int mouse_x, mouse_y;
244
int btn_pressed, btn_x, btn_y;
238
int btn_pressed, btn_x, btn_y;
245
 
239
 
246
/** Handle mouse move
240
/** Handle mouse move
247
 *
241
 *
248
 * @param dx Delta X of mouse move
242
 * @param dx Delta X of mouse move
249
 * @param dy Delta Y of mouse move
243
 * @param dy Delta Y of mouse move
250
 */
244
 */
251
void gcons_mouse_move(int dx, int dy)
245
void gcons_mouse_move(int dx, int dy)
252
{
246
{
253
    mouse_x = limit(mouse_x + dx, 0, xres);
247
    mouse_x = limit(mouse_x + dx, 0, xres);
254
    mouse_y = limit(mouse_y + dy, 0, yres);
248
    mouse_y = limit(mouse_y + dy, 0, yres);
255
 
249
 
256
    async_msg_2(fbphone, FB_POINTER_MOVE, mouse_x, mouse_y);
250
    async_msg_2(fbphone, FB_POINTER_MOVE, mouse_x, mouse_y);
257
}
251
}
258
 
252
 
259
static int gcons_find_conbut(int x, int y)
253
static int gcons_find_conbut(int x, int y)
260
{
254
{
261
    int status_start = STATUS_START + (xres - 800) / 2;
255
    int status_start = STATUS_START + (xres - 800) / 2;
262
 
256
 
263
    if (y < STATUS_TOP || y >= STATUS_TOP + STATUS_HEIGHT)
257
    if (y < STATUS_TOP || y >= STATUS_TOP + STATUS_HEIGHT)
264
        return -1;
258
        return -1;
265
   
259
   
266
    if (x < status_start)
260
    if (x < status_start)
267
        return -1;
261
        return -1;
268
   
262
   
269
    if (x >= status_start + (STATUS_WIDTH + STATUS_SPACE) * CONSOLE_COUNT)
263
    if (x >= status_start + (STATUS_WIDTH + STATUS_SPACE) * CONSOLE_COUNT)
270
        return -1;
264
        return -1;
271
    if (((x - status_start) % (STATUS_WIDTH + STATUS_SPACE)) < STATUS_SPACE)
265
    if (((x - status_start) % (STATUS_WIDTH + STATUS_SPACE)) < STATUS_SPACE)
272
        return -1;
266
        return -1;
273
   
267
   
274
    return (x - status_start) / (STATUS_WIDTH + STATUS_SPACE);
268
    return (x - status_start) / (STATUS_WIDTH + STATUS_SPACE);
275
}
269
}
276
 
270
 
277
/** Handle mouse click
271
/** Handle mouse click
278
 *
272
 *
279
 * @param state New state (1-pressed, 0-depressed)
273
 * @param state New state (1-pressed, 0-depressed)
280
 */
274
 */
281
int gcons_mouse_btn(int state)
275
int gcons_mouse_btn(int state)
282
{
276
{
283
    int conbut;
277
    int conbut;
284
 
278
 
285
    if (state) {
279
    if (state) {
286
        conbut = gcons_find_conbut(mouse_x, mouse_y);
280
        conbut = gcons_find_conbut(mouse_x, mouse_y);
287
        if (conbut != -1) {
281
        if (conbut != -1) {
288
            btn_pressed = 1;
282
            btn_pressed = 1;
289
            btn_x = mouse_x;
283
            btn_x = mouse_x;
290
            btn_y = mouse_y;
284
            btn_y = mouse_y;
291
        }
285
        }
292
        return -1;
286
        return -1;
293
    }
287
    }
294
    if (!state && !btn_pressed)
288
    if (!state && !btn_pressed)
295
        return -1;
289
        return -1;
296
    btn_pressed = 0;
290
    btn_pressed = 0;
297
 
291
 
298
    conbut = gcons_find_conbut(mouse_x, mouse_y);
292
    conbut = gcons_find_conbut(mouse_x, mouse_y);
299
    if (conbut == gcons_find_conbut(btn_x, btn_y))
293
    if (conbut == gcons_find_conbut(btn_x, btn_y))
300
        return conbut;
294
        return conbut;
301
    return -1;
295
    return -1;
302
}
296
}
303
 
297
 
304
 
298
 
305
/** Draw a PPM pixmap to framebuffer
299
/** Draw a PPM pixmap to framebuffer
306
 *
300
 *
307
 * @param logo Pointer to PPM data
301
 * @param logo Pointer to PPM data
308
 * @param size Size of PPM data
302
 * @param size Size of PPM data
309
 * @param x Coordinate of upper left corner
303
 * @param x Coordinate of upper left corner
310
 * @param y Coordinate of upper left corner
304
 * @param y Coordinate of upper left corner
311
 */
305
 */
312
static void draw_pixmap(char *logo, size_t size, int x, int y)
306
static void draw_pixmap(char *logo, size_t size, int x, int y)
313
{
307
{
314
    char *shm;
308
    char *shm;
315
    int rc;
309
    int rc;
316
 
310
 
317
    /* Create area */
311
    /* Create area */
318
    shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
312
    shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
319
        MAP_ANONYMOUS, 0, 0);
313
        MAP_ANONYMOUS, 0, 0);
320
    if (shm == MAP_FAILED)
314
    if (shm == MAP_FAILED)
321
        return;
315
        return;
322
 
316
 
323
    memcpy(shm, logo, size);
317
    memcpy(shm, logo, size);
324
    /* Send area */
318
    /* Send area */
325
    rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
319
    rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
326
    if (rc)
320
    if (rc)
327
        goto exit;
321
        goto exit;
328
    rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
322
    rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
329
    if (rc)
323
    if (rc)
330
        goto drop;
324
        goto drop;
331
    /* Draw logo */
325
    /* Draw logo */
332
    async_msg_2(fbphone, FB_DRAW_PPM, x, y);
326
    async_msg_2(fbphone, FB_DRAW_PPM, x, y);
333
drop:
327
drop:
334
    /* Drop area */
328
    /* Drop area */
335
    async_msg_0(fbphone, FB_DROP_SHM);
329
    async_msg_0(fbphone, FB_DROP_SHM);
336
exit:      
330
exit:      
337
    /* Remove area */
331
    /* Remove area */
338
    munmap(shm, size);
332
    munmap(shm, size);
339
}
333
}
340
 
334
 
341
extern char _binary_helenos_ppm_start[0];
335
extern char _binary_helenos_ppm_start[0];
342
extern int _binary_helenos_ppm_size;
336
extern int _binary_helenos_ppm_size;
343
extern char _binary_nameic_ppm_start[0];
337
extern char _binary_nameic_ppm_start[0];
344
extern int _binary_nameic_ppm_size;
338
extern int _binary_nameic_ppm_size;
-
 
339
 
345
/** Redraws console graphics  */
340
/** Redraws console graphics */
346
static void gcons_redraw_console(void)
341
void gcons_redraw_console(void)
347
{
342
{
348
    int i;
343
    int i;
349
 
344
   
350
    if (!use_gcons)
345
    if (!use_gcons)
351
        return;
346
        return;
352
   
347
   
353
    vp_switch(0);
348
    vp_switch(0);
354
    set_style(MAIN_COLOR, MAIN_COLOR);
349
    set_rgb_color(MAIN_COLOR, MAIN_COLOR);
355
    clear();
350
    clear();
356
    draw_pixmap(_binary_helenos_ppm_start,
351
    draw_pixmap(_binary_helenos_ppm_start,
357
        (size_t) &_binary_helenos_ppm_size, xres - 66, 2);
352
        (size_t) &_binary_helenos_ppm_size, xres - 66, 2);
358
    draw_pixmap(_binary_nameic_ppm_start,
353
    draw_pixmap(_binary_nameic_ppm_start,
359
        (size_t) &_binary_nameic_ppm_size, 5, 17);
354
        (size_t) &_binary_nameic_ppm_size, 5, 17);
360
 
355
   
361
    for (i = 0; i < CONSOLE_COUNT; i++)
356
    for (i = 0; i < CONSOLE_COUNT; i++)
362
        redraw_state(i);
357
        redraw_state(i);
363
    vp_switch(console_vp);
358
    vp_switch(console_vp);
364
}
359
}
365
 
360
 
366
/** Creates a pixmap on framebuffer
361
/** Creates a pixmap on framebuffer
367
 *
362
 *
368
 * @param data PPM data
363
 * @param data PPM data
369
 * @param size PPM data size
364
 * @param size PPM data size
370
 * @return Pixmap identification
365
 * @return Pixmap identification
371
 */
366
 */
372
static int make_pixmap(char *data, int size)
367
static int make_pixmap(char *data, int size)
373
{
368
{
374
    char *shm;
369
    char *shm;
375
    int rc;
370
    int rc;
376
    int pxid = -1;
371
    int pxid = -1;
377
 
372
 
378
    /* Create area */
373
    /* Create area */
379
    shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
374
    shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
380
        MAP_ANONYMOUS, 0, 0);
375
        MAP_ANONYMOUS, 0, 0);
381
    if (shm == MAP_FAILED)
376
    if (shm == MAP_FAILED)
382
        return -1;
377
        return -1;
383
 
378
 
384
    memcpy(shm, data, size);
379
    memcpy(shm, data, size);
385
    /* Send area */
380
    /* Send area */
386
    rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
381
    rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
387
    if (rc)
382
    if (rc)
388
        goto exit;
383
        goto exit;
389
    rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
384
    rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
390
    if (rc)
385
    if (rc)
391
        goto drop;
386
        goto drop;
392
 
387
 
393
    /* Obtain pixmap */
388
    /* Obtain pixmap */
394
    rc = async_req_0_0(fbphone, FB_SHM2PIXMAP);
389
    rc = async_req_0_0(fbphone, FB_SHM2PIXMAP);
395
    if (rc < 0)
390
    if (rc < 0)
396
        goto drop;
391
        goto drop;
397
    pxid = rc;
392
    pxid = rc;
398
drop:
393
drop:
399
    /* Drop area */
394
    /* Drop area */
400
    async_msg_0(fbphone, FB_DROP_SHM);
395
    async_msg_0(fbphone, FB_DROP_SHM);
401
exit:      
396
exit:      
402
    /* Remove area */
397
    /* Remove area */
403
    munmap(shm, size);
398
    munmap(shm, size);
404
 
399
 
405
    return pxid;
400
    return pxid;
406
}
401
}
407
 
402
 
408
extern char _binary_anim_1_ppm_start[0];
403
extern char _binary_anim_1_ppm_start[0];
409
extern int _binary_anim_1_ppm_size;
404
extern int _binary_anim_1_ppm_size;
410
extern char _binary_anim_2_ppm_start[0];
405
extern char _binary_anim_2_ppm_start[0];
411
extern int _binary_anim_2_ppm_size;
406
extern int _binary_anim_2_ppm_size;
412
extern char _binary_anim_3_ppm_start[0];
407
extern char _binary_anim_3_ppm_start[0];
413
extern int _binary_anim_3_ppm_size;
408
extern int _binary_anim_3_ppm_size;
414
extern char _binary_anim_4_ppm_start[0];
409
extern char _binary_anim_4_ppm_start[0];
415
extern int _binary_anim_4_ppm_size;
410
extern int _binary_anim_4_ppm_size;
416
 
411
 
417
static void make_anim(void)
412
static void make_anim(void)
418
{
413
{
419
    int an;
414
    int an;
420
    int pm;
415
    int pm;
421
 
416
 
422
    an = async_req_1_0(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE]);
417
    an = async_req_1_0(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE]);
423
    if (an < 0)
418
    if (an < 0)
424
        return;
419
        return;
425
 
420
 
426
    pm = make_pixmap(_binary_anim_1_ppm_start,
421
    pm = make_pixmap(_binary_anim_1_ppm_start,
427
        (int) &_binary_anim_1_ppm_size);
422
        (int) &_binary_anim_1_ppm_size);
428
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
423
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
429
 
424
 
430
    pm = make_pixmap(_binary_anim_2_ppm_start,
425
    pm = make_pixmap(_binary_anim_2_ppm_start,
431
        (int) &_binary_anim_2_ppm_size);
426
        (int) &_binary_anim_2_ppm_size);
432
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
427
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
433
 
428
 
434
    pm = make_pixmap(_binary_anim_3_ppm_start,
429
    pm = make_pixmap(_binary_anim_3_ppm_start,
435
        (int) &_binary_anim_3_ppm_size);
430
        (int) &_binary_anim_3_ppm_size);
436
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
431
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
437
 
432
 
438
    pm = make_pixmap(_binary_anim_4_ppm_start,
433
    pm = make_pixmap(_binary_anim_4_ppm_start,
439
        (int) &_binary_anim_4_ppm_size);
434
        (int) &_binary_anim_4_ppm_size);
440
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
435
    async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
441
 
436
 
442
    async_msg_1(fbphone, FB_ANIM_START, an);
437
    async_msg_1(fbphone, FB_ANIM_START, an);
443
 
438
 
444
    animation = an;
439
    animation = an;
445
}
440
}
446
 
441
 
447
extern char _binary_cons_selected_ppm_start[0];
442
extern char _binary_cons_selected_ppm_start[0];
448
extern int _binary_cons_selected_ppm_size;
443
extern int _binary_cons_selected_ppm_size;
449
extern char _binary_cons_idle_ppm_start[0];
444
extern char _binary_cons_idle_ppm_start[0];
450
extern int _binary_cons_idle_ppm_size;
445
extern int _binary_cons_idle_ppm_size;
451
extern char _binary_cons_has_data_ppm_start[0];
446
extern char _binary_cons_has_data_ppm_start[0];
452
extern int _binary_cons_has_data_ppm_size;
447
extern int _binary_cons_has_data_ppm_size;
453
extern char _binary_cons_kernel_ppm_start[0];
448
extern char _binary_cons_kernel_ppm_start[0];
454
extern int _binary_cons_kernel_ppm_size;
449
extern int _binary_cons_kernel_ppm_size;
455
 
450
 
456
/** Initialize nice graphical console environment */
451
/** Initialize nice graphical console environment */
457
void gcons_init(int phone)
452
void gcons_init(int phone)
458
{
453
{
459
    int rc;
454
    int rc;
460
    int i;
455
    int i;
461
    int status_start = STATUS_START;
456
    int status_start = STATUS_START;
462
 
457
   
463
    fbphone = phone;
458
    fbphone = phone;
464
 
459
   
465
    rc = async_req_0_2(phone, FB_GET_RESOLUTION, &xres, &yres);
460
    rc = async_req_0_2(phone, FB_GET_RESOLUTION, &xres, &yres);
466
    if (rc)
461
    if (rc)
467
        return;
462
        return;
468
   
463
   
469
    if (xres < 800 || yres < 600)
464
    if ((xres < 800) || (yres < 600))
470
        return;
465
        return;
471
 
466
   
472
    /* create console viewport */
467
    /* create console viewport */
473
    /* Align width & height to character size */
468
    /* Align width & height to character size */
474
    console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP,
469
    console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP,
475
        ALIGN_DOWN(xres - 2 * CONSOLE_MARGIN, 8),
470
        ALIGN_DOWN(xres - 2 * CONSOLE_MARGIN, 8),
476
        ALIGN_DOWN(yres - (CONSOLE_TOP + CONSOLE_MARGIN), 16));
471
        ALIGN_DOWN(yres - (CONSOLE_TOP + CONSOLE_MARGIN), 16));
477
    if (console_vp < 0)
472
    if (console_vp < 0)
478
        return;
473
        return;
479
   
474
   
480
    /* Create status buttons */
475
    /* Create status buttons */
481
    status_start += (xres - 800) / 2;
476
    status_start += (xres - 800) / 2;
482
    for (i = 0; i < CONSOLE_COUNT; i++) {
477
    for (i = 0; i < CONSOLE_COUNT; i++) {
483
        cstatus_vp[i] = vp_create(status_start + CONSOLE_MARGIN +
478
        cstatus_vp[i] = vp_create(status_start + CONSOLE_MARGIN +
484
            i * (STATUS_WIDTH + STATUS_SPACE), STATUS_TOP,
479
            i * (STATUS_WIDTH + STATUS_SPACE), STATUS_TOP,
485
            STATUS_WIDTH, STATUS_HEIGHT);
480
            STATUS_WIDTH, STATUS_HEIGHT);
486
        if (cstatus_vp[i] < 0)
481
        if (cstatus_vp[i] < 0)
487
            return;
482
            return;
488
        vp_switch(cstatus_vp[i]);
483
        vp_switch(cstatus_vp[i]);
489
        set_style(0x202020, 0xffffff);
484
        set_rgb_color(0x202020, 0xffffff);
490
    }
485
    }
491
   
486
   
492
    /* Initialize icons */
487
    /* Initialize icons */
493
    ic_pixmaps[CONS_SELECTED] =
488
    ic_pixmaps[CONS_SELECTED] =
494
        make_pixmap(_binary_cons_selected_ppm_start,
489
        make_pixmap(_binary_cons_selected_ppm_start,
495
        (int) &_binary_cons_selected_ppm_size);
490
        (int) &_binary_cons_selected_ppm_size);
496
    ic_pixmaps[CONS_IDLE] = make_pixmap(_binary_cons_idle_ppm_start,
491
    ic_pixmaps[CONS_IDLE] = make_pixmap(_binary_cons_idle_ppm_start,
497
        (int) &_binary_cons_idle_ppm_size);
492
        (int) &_binary_cons_idle_ppm_size);
498
    ic_pixmaps[CONS_HAS_DATA] =
493
    ic_pixmaps[CONS_HAS_DATA] =
499
        make_pixmap(_binary_cons_has_data_ppm_start,
494
        make_pixmap(_binary_cons_has_data_ppm_start,
500
        (int) &_binary_cons_has_data_ppm_size);
495
        (int) &_binary_cons_has_data_ppm_size);
501
    ic_pixmaps[CONS_DISCONNECTED] =
496
    ic_pixmaps[CONS_DISCONNECTED] =
502
        make_pixmap(_binary_cons_idle_ppm_start,
497
        make_pixmap(_binary_cons_idle_ppm_start,
503
        (int) &_binary_cons_idle_ppm_size);
498
        (int) &_binary_cons_idle_ppm_size);
504
    ic_pixmaps[CONS_KERNEL] = make_pixmap(_binary_cons_kernel_ppm_start,
499
    ic_pixmaps[CONS_KERNEL] = make_pixmap(_binary_cons_kernel_ppm_start,
505
        (int) &_binary_cons_kernel_ppm_size);
500
        (int) &_binary_cons_kernel_ppm_size);
506
    ic_pixmaps[CONS_DISCONNECTED_SEL] = ic_pixmaps[CONS_SELECTED];
501
    ic_pixmaps[CONS_DISCONNECTED_SEL] = ic_pixmaps[CONS_SELECTED];
507
   
502
   
508
    make_anim();
503
    make_anim();
509
 
504
   
510
    use_gcons = 1;
505
    use_gcons = 1;
511
    console_state[0] = CONS_DISCONNECTED_SEL;
506
    console_state[0] = CONS_DISCONNECTED_SEL;
512
    console_state[KERNEL_CONSOLE] = CONS_KERNEL;
507
    console_state[KERNEL_CONSOLE] = CONS_KERNEL;
513
    gcons_redraw_console();
508
    gcons_redraw_console();
514
}
509
}
515
 
510
 
516
/** @}
511
/** @}
517
 */
512
 */
518
 
-
 
519
 
513