toaruos/userspace/compositor.c

1246 lines
34 KiB
C
Raw Normal View History

/*
* Compositor
*
* This is the window compositor application.
* It serves shared memory regions to clients
* and renders them to the screen.
2012-01-30 03:05:42 +04:00
*/
#include <stdio.h>
#include <stdint.h>
#include <syscall.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <assert.h>
#include <sys/stat.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_CACHE_H
2012-01-30 03:05:42 +04:00
#include "lib/list.h"
#include "lib/graphics.h"
2012-02-12 04:54:34 +04:00
#include "lib/window.h"
#include "lib/pthread.h"
#include "lib/kbd.h"
2012-02-13 04:47:01 +04:00
#include "../kernel/include/signal.h"
2012-02-16 06:50:31 +04:00
#include "../kernel/include/mouse.h"
2012-02-13 04:47:01 +04:00
#define SINGLE_USER_MODE 0
2012-10-14 00:02:58 +04:00
void spin_lock(int volatile * lock) {
while(__sync_lock_test_and_set(lock, 0x01)) {
syscall_yield();
}
}
2012-02-26 09:52:09 +04:00
void spin_unlock(int volatile * lock) {
__sync_lock_release(lock);
}
2012-02-26 09:52:09 +04:00
window_t * windows[0x10000];
2012-09-29 11:38:11 +04:00
volatile uint8_t screenshot_next_frame = 0;
sprite_t * sprites[128];
2012-01-30 03:05:42 +04:00
gfx_context_t * ctx;
#define WIN_D 32
#define WIN_B (WIN_D / 8)
2012-04-13 08:30:04 +04:00
#define MOUSE_DISCARD_LEVEL 6
list_t * process_list;
int32_t mouse_x, mouse_y;
int32_t click_x, click_y;
uint32_t mouse_discard = 0;
#define MOUSE_SCALE 3
#define MOUSE_OFFSET_X 26
#define MOUSE_OFFSET_Y 26
void redraw_region_slow(int32_t x, int32_t y, int32_t width, int32_t height);
void redraw_cursor() {
//redraw_region_slow(mouse_x / MOUSE_SCALE - 32, mouse_y / MOUSE_SCALE - 32, 64, 64);
draw_sprite(ctx, sprites[3], mouse_x / MOUSE_SCALE - MOUSE_OFFSET_X, mouse_y / MOUSE_SCALE - MOUSE_OFFSET_Y);
}
2012-02-12 04:54:34 +04:00
extern window_t * init_window (process_windows_t * pw, wid_t wid, int32_t x, int32_t y, uint16_t width, uint16_t height, uint16_t index);
extern void free_window (window_t * window);
extern void resize_window_buffer (window_t * window, int16_t left, int16_t top, uint16_t width, uint16_t height);
2012-02-12 04:54:34 +04:00
2012-02-26 10:45:46 +04:00
uint16_t * depth_map = NULL;
uintptr_t * top_map = NULL;
2012-02-26 10:45:46 +04:00
process_windows_t * get_process_windows (uint32_t pid) {
foreach(n, process_list) {
process_windows_t * pw = (process_windows_t *)n->value;
if (pw->pid == pid) {
return pw;
}
}
return NULL;
}
2012-02-12 04:54:34 +04:00
static window_t * get_window (wid_t wid) {
foreach (n, process_list) {
process_windows_t * pw = (process_windows_t *)n->value;
foreach (m, pw->windows) {
window_t * w = (window_t *)m->value;
if (w->wid == wid) {
return w;
}
}
}
return NULL;
}
2012-02-13 05:30:36 +04:00
static window_t * get_window_with_process (process_windows_t * pw, wid_t wid) {
foreach (m, pw->windows) {
window_t * w = (window_t *)m->value;
if (w->wid == wid) {
return w;
}
}
return NULL;
}
void init_process_list () {
process_list = list_create();
memset(windows, 0x00000000, sizeof(window_t *) * 0x10000);
}
2012-01-30 03:05:42 +04:00
int32_t min(int32_t a, int32_t b) {
return (a < b) ? a : b;
}
int32_t max(int32_t a, int32_t b) {
return (a > b) ? a : b;
}
uint8_t is_between(int32_t lo, int32_t hi, int32_t val) {
if (val >= lo && val < hi) return 1;
return 0;
}
uint8_t is_top(window_t *window, uint16_t x, uint16_t y) {
uint16_t index = window->z;
foreach(n, process_list) {
process_windows_t * pw = (process_windows_t *)n->value;
foreach(node, pw->windows) {
window_t * win = (window_t *)node->value;
if (win == window) continue;
if (win->z < index) continue;
if (is_between(win->x, win->x + win->width, x) && is_between(win->y, win->y + win->height, y)) {
return 0;
}
2012-01-30 03:05:42 +04:00
}
}
return 1;
}
uint8_t inline is_top_fast(window_t * window, uint16_t x, uint16_t y) {
if (x >= ctx->width || y >= ctx->height) {
2012-02-26 10:45:46 +04:00
return 0;
2012-03-29 00:54:31 +04:00
}
if (window->z == depth_map[x + y * ctx->width]) {
2012-02-26 10:45:46 +04:00
return 1;
2012-03-29 00:54:31 +04:00
}
2012-02-26 10:45:46 +04:00
return 0;
}
window_t * top_at(uint16_t x, uint16_t y) {
uint32_t index_top = 0;
window_t * window_top = NULL;
foreach(n, process_list) {
process_windows_t * pw = (process_windows_t *)n->value;
foreach(node, pw->windows) {
window_t * win = (window_t *)node->value;
if (is_between(win->x, win->x + win->width, x) && is_between(win->y, win->y + win->height, y)) {
if (window_top == NULL) {
window_top = win;
index_top = win->z;
2012-02-23 11:40:37 +04:00
} else {
if (win->z < index_top) continue;
window_top = win;
index_top = win->z;
}
}
}
}
return window_top;
}
void rebalance_windows() {
uint32_t i = 1;
for (; i < 0xFFF8; ++i) {
if (!windows[i]) break;
}
uint32_t j = i + 1;
for (; j < 0xFFF8; ++j) {
if (!windows[j]) break;
}
if (j == i + 1) {
printf("Nothing to reorder.\n");
return;
} else {
printf("Need to reshuffle. One moment.\n");
for (j = i; j < 0xFFF8; ++j) {
windows[j] = windows[j+1];
if (windows[j+1] == NULL) return;
windows[j]->z = j;
2012-03-02 07:13:52 +04:00
}
}
}
void reorder_window (window_t * window, uint16_t new_zed) {
if (!window) {
return;
}
2012-03-02 07:13:52 +04:00
int z = window->z;
window->z = new_zed;
if (windows[z] == window) {
windows[z] = NULL;
}
if (new_zed == 0 || new_zed == 0xFFFF) {
windows[new_zed] = window;
if (z != new_zed) {
rebalance_windows();
2012-02-17 11:28:12 +04:00
}
return;
2012-02-17 11:28:12 +04:00
}
if (windows[new_zed] != window) {
reorder_window(windows[new_zed], new_zed + 1);
windows[new_zed ] = window;
}
if (z != new_zed) {
rebalance_windows();
}
printf("Window 0x%x is now at z=%d\n", window, new_zed);
2012-02-17 11:28:12 +04:00
}
2012-02-26 09:52:09 +04:00
void make_top(window_t * window) {
uint16_t index = window->z;
if (index == 0) return;
if (index == 0xFFFF) return;
uint16_t highest = 0;
foreach(n, process_list) {
process_windows_t * pw = (process_windows_t *)n->value;
foreach(node, pw->windows) {
window_t * win = (window_t *)node->value;
if (win == window) continue;
2012-02-26 09:52:09 +04:00
if (win->z == 0) continue;
if (win->z == 0xFFFF) continue;
if (highest < win->z) highest = win->z;
if (win == window) continue;
if (win->z > window->z) continue;
2012-02-26 09:52:09 +04:00
}
}
printf("Making top will make this window stack at %d.\n", highest+1);
reorder_window(window, highest+1);
2012-02-26 09:52:09 +04:00
}
window_t * focused_window() {
2012-03-29 00:54:31 +04:00
return top_at(mouse_x / MOUSE_SCALE, mouse_y / MOUSE_SCALE);
}
volatile int am_drawing = 0;
2012-03-28 03:19:35 +04:00
window_t * moving_window = NULL;
int32_t moving_window_l = 0;
int32_t moving_window_t = 0;
2012-10-14 07:19:43 +04:00
window_t * resizing_window = NULL;
int32_t resizing_window_w = 0;
int32_t resizing_window_h = 0;
2012-02-12 04:54:34 +04:00
/* Internal drawing functions */
void redraw_window(window_t *window, uint16_t x, uint16_t y, uint16_t width, uint16_t height) {
if (!window) {
return;
}
uint16_t _lo_x = max(window->x + x, 0);
uint16_t _hi_x = min(window->x + width, ctx->width);
uint16_t _lo_y = max(window->y + y, 0);
uint16_t _hi_y = min(window->y + height, ctx->height);
2012-01-30 03:05:42 +04:00
for (uint16_t y = _lo_y; y < _hi_y; ++y) {
for (uint16_t x = _lo_x; x < _hi_x; ++x) {
2012-02-26 10:45:46 +04:00
/* XXX MAKE THIS FASTER */
if (is_top_fast(window, x, y)) {
2012-02-26 09:52:09 +04:00
if (TO_WINDOW_OFFSET(x,y) >= window->width * window->height) continue;
GFX(ctx,x,y) = ((uint32_t *)window->buffer)[TO_WINDOW_OFFSET(x,y)];
2012-01-30 03:05:42 +04:00
}
}
}
//redraw_region_slow(mouse_x / MOUSE_SCALE - 32, mouse_y / MOUSE_SCALE - 32, 64, 64);
//redraw_cursor();
2012-01-30 03:05:42 +04:00
}
void window_add (window_t * window) {
int z = window->z;
while (windows[z]) {
z++;
}
printf("Assigning depth of %d to window 0x%x\n", z, window);
window->z = z;
windows[z] = window;
}
void unorder_window (window_t * window) {
int z = window->z;
if (z < 0x10000 && windows[z]) {
windows[z] = 0;
}
window->z = 0;
return;
}
void redraw_full_window (window_t * window) {
if (!window) {
return;
}
redraw_window(window, (uint16_t)0, (uint16_t)0, window->width, window->height);
}
2012-02-26 08:47:20 +04:00
void redraw_region_slow(int32_t x, int32_t y, int32_t width, int32_t height) {
uint16_t _lo_x = max(x, 0);
uint16_t _hi_x = min(x + width, ctx->width);
2012-02-26 08:47:20 +04:00
uint16_t _lo_y = max(y, 0);
uint16_t _hi_y = min(y + height, ctx->height);
2012-02-26 08:47:20 +04:00
for (uint32_t y = _lo_y; y < _hi_y; ++y) {
for (uint32_t x = _lo_x; x < _hi_x; ++x) {
window_t * window = top_at(x,y);
2012-03-02 07:13:52 +04:00
if (window) {
//GFX(ctx,x,y) = ((uint32_t *)window->buffer)[TO_WINDOW_OFFSET(x,y)];
depth_map[x + y * ctx->width] = window->z;
top_map[x + y * ctx->width] = (uintptr_t)window;
2012-03-02 07:13:52 +04:00
} else {
//GFX(ctx,x,y) = (y % 2 ^ x % 2) ? rgb(0,0,0) : rgb(255,255,255);
depth_map[x + y * ctx->width] = 0;
top_map[x + y * ctx->width] = 0;
}
}
}
}
void blit_window(window_t * window, int32_t left, int32_t top) {
#define TO_DERPED_OFFSET(x,y) (((x) - left) + ((y) - top) * window->width)
2012-03-28 03:19:35 +04:00
uint16_t _lo_x = max(left, 0);
uint16_t _hi_x = min(left + window->width, ctx->width);
2012-03-28 03:19:35 +04:00
uint16_t _lo_y = max(top, 0);
uint16_t _hi_y = min(top + window->height, ctx->height);
if (window->use_alpha) {
for (uint16_t y = _lo_y; y < _hi_y; ++y) {
for (uint16_t x = _lo_x; x < _hi_x; ++x) {
GFX(ctx,x,y) = alpha_blend_rgba(GFX(ctx,x,y), ((uint32_t *)window->buffer)[TO_DERPED_OFFSET(x,y)]);
}
}
} else {
uint16_t win_x = _lo_x - left;
uint16_t width = (_hi_x - _lo_x) * 4;
uint16_t win_y = _lo_y - top;
2012-03-28 03:19:35 +04:00
for (uint16_t y = _lo_y; y < _hi_y; ++y) {
win_y = y - top;
memcpy(&ctx->backbuffer[4 * (y * ctx->width + _lo_x)], &window->buffer[(win_y * window->width + win_x) * 4], width);
2012-03-28 03:19:35 +04:00
}
}
}
void redraw_everything_fast() {
for (uint32_t i = 0; i < 0x10000; ++i) {
window_t * window = NULL;
if (windows[i]) {
window = windows[i];
if (window == moving_window) {
blit_window(moving_window, moving_window_l, moving_window_t);
} else {
blit_window(window, window->x, window->y);
}
}
}
}
2012-03-28 03:19:35 +04:00
2012-02-26 09:52:09 +04:00
void redraw_bounding_box(window_t *window, int32_t left, int32_t top, uint32_t derped) {
return;
2012-02-26 09:52:09 +04:00
if (!window) {
return;
}
int32_t _min_x = max(left, 0);
int32_t _min_y = max(top, 0);
int32_t _max_x = min(left + window->width - 1, ctx->width - 1);
int32_t _max_y = min(top + window->height - 1, ctx->height - 1);
2012-02-26 09:52:09 +04:00
if (!derped) {
redraw_region_slow(_min_x, _min_y, (_max_x - _min_x + 1), 1);
redraw_region_slow(_min_x, _max_y, (_max_x - _min_x + 1), 1);
redraw_region_slow(_min_x, _min_y, 1, (_max_y - _min_y + 1));
redraw_region_slow(_max_x, _min_y, 1, (_max_y - _min_y + 1));
} else {
uint32_t color = rgb(255,0,0);
draw_line(ctx, _min_x, _max_x, _min_y, _min_y, color);
draw_line(ctx, _min_x, _max_x, _max_y, _max_y, color);
draw_line(ctx, _min_x, _min_x, _min_y, _max_y, color);
draw_line(ctx, _max_x, _max_x, _min_y, _max_y, color);
2012-02-26 09:52:09 +04:00
}
}
2012-03-02 07:13:52 +04:00
void redraw_bounding_box_r(window_t *window, int32_t width, int32_t height, uint32_t derped) {
return;
2012-03-02 07:13:52 +04:00
if (!window) {
return;
}
int32_t _min_x = max(window->x, 0);
int32_t _min_y = max(window->y, 0);
int32_t _max_x = min(window->x + width - 1, ctx->width - 1);
int32_t _max_y = min(window->y + height - 1, ctx->height - 1);
2012-03-02 07:13:52 +04:00
if (!derped) {
redraw_region_slow(_min_x, _min_y, (_max_x - _min_x + 1), 1);
redraw_region_slow(_min_x, _max_y, (_max_x - _min_x + 1), 1);
redraw_region_slow(_min_x, _min_y, 1, (_max_y - _min_y + 1));
redraw_region_slow(_max_x, _min_y, 1, (_max_y - _min_y + 1));
} else {
uint32_t color = rgb(0,255,0);
draw_line(ctx, _min_x, _max_x, _min_y, _min_y, color);
draw_line(ctx, _min_x, _max_x, _max_y, _max_y, color);
draw_line(ctx, _min_x, _min_x, _min_y, _max_y, color);
draw_line(ctx, _max_x, _max_x, _min_y, _max_y, color);
2012-03-02 07:13:52 +04:00
}
}
2012-10-14 08:24:12 +04:00
void draw_box(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color) {
2012-10-14 07:19:43 +04:00
int32_t _min_x = max(x, 0);
int32_t _min_y = max(y, 0);
int32_t _max_x = min(x + w - 1, ctx->width - 1);
int32_t _max_y = min(y + h - 1, ctx->height - 1);
draw_line(ctx, _min_x, _max_x, _min_y, _min_y, color);
draw_line(ctx, _min_x, _max_x, _max_y, _max_y, color);
draw_line(ctx, _min_x, _min_x, _min_y, _max_y, color);
draw_line(ctx, _max_x, _max_x, _min_y, _max_y, color);
}
wid_t volatile _next_wid = 1;
2012-03-24 02:44:37 +04:00
void send_window_event (process_windows_t * pw, uint8_t event, w_window_t * packet) {
2012-02-12 04:54:34 +04:00
/* Construct the header */
wins_packet_t header;
header.magic = WINS_MAGIC;
2012-02-12 04:54:34 +04:00
header.command_type = event;
header.packet_size = sizeof(w_window_t);
2012-02-12 04:54:34 +04:00
/* Send them */
// XXX: we have a race condition here
write(pw->event_pipe, &header, sizeof(wins_packet_t));
2012-03-24 02:44:37 +04:00
write(pw->event_pipe, packet, sizeof(w_window_t));
2012-02-14 02:21:52 +04:00
syscall_send_signal(pw->pid, SIGWINEVENT); // SIGWINEVENT
syscall_yield();
}
2012-02-17 11:28:12 +04:00
void send_keyboard_event (process_windows_t * pw, uint8_t event, w_keyboard_t packet) {
/* Construct the header */
wins_packet_t header;
header.magic = WINS_MAGIC;
2012-02-17 11:28:12 +04:00
header.command_type = event;
header.packet_size = sizeof(w_keyboard_t);
/* Send them */
// XXX: we have a race condition here
write(pw->event_pipe, &header, sizeof(wins_packet_t));
write(pw->event_pipe, &packet, sizeof(w_keyboard_t));
syscall_send_signal(pw->pid, SIGWINEVENT); // SIGWINEVENT
syscall_yield();
}
FILE *fdopen(int fd, const char *mode);
void send_mouse_event (process_windows_t * pw, uint8_t event, w_mouse_t * packet) {
/* Construct the header */
wins_packet_t header;
header.magic = WINS_MAGIC;
header.command_type = event;
header.packet_size = sizeof(w_mouse_t);
/* Send them */
fwrite(&header, 1, sizeof(wins_packet_t), pw->event_pipe_file);
fwrite(packet, 1, sizeof(w_mouse_t), pw->event_pipe_file);
fflush(pw->event_pipe_file);
//syscall_send_signal(pw->pid, SIGWINEVENT); // SIGWINEVENT
//syscall_yield();
2012-02-17 11:28:12 +04:00
}
2012-02-12 04:54:34 +04:00
void process_window_command (int sig) {
foreach(n, process_list) {
process_windows_t * pw = (process_windows_t *)n->value;
/* Are there any messages in this process's command pipe? */
struct stat buf;
fstat(pw->command_pipe, &buf);
2012-02-14 02:21:52 +04:00
2012-03-02 07:13:52 +04:00
int max_requests_per_cycle = 1;
2012-02-14 02:21:52 +04:00
while ((buf.st_size > 0) && (max_requests_per_cycle > 0)) {
2012-03-02 07:13:52 +04:00
#if 0
2012-02-26 10:45:46 +04:00
if (!(buf.st_size > sizeof(wins_packet_t))) {
fstat(pw->command_pipe, &buf);
continue;
}
2012-03-02 07:13:52 +04:00
#endif
w_window_t wwt;
wins_packet_t header;
2012-02-26 08:47:20 +04:00
int bytes_read = read(pw->command_pipe, &header, sizeof(wins_packet_t));
while (header.magic != WINS_MAGIC) {
2012-02-26 10:45:46 +04:00
printf("Magic is wrong from pid %d, expected 0x%x but got 0x%x [read %d bytes of %d]\n", pw->pid, WINS_MAGIC, header.magic, bytes_read, sizeof(header));
2012-03-02 07:13:52 +04:00
max_requests_per_cycle--;
2012-02-26 07:28:33 +04:00
goto bad_magic;
memcpy(&header, (void *)((uintptr_t)&header + 1), (sizeof(header) - 1));
read(pw->event_pipe, (char *)((uintptr_t)&header + sizeof(header) - 1), 1);
}
2012-02-14 02:21:52 +04:00
max_requests_per_cycle--;
switch (header.command_type) {
case WC_NEWWINDOW:
{
printf("[compositor] New window request\n");
read(pw->command_pipe, &wwt, sizeof(w_window_t));
wwt.wid = _next_wid;
window_t * new_window = init_window(pw, _next_wid, wwt.left, wwt.top, wwt.width, wwt.height, _next_wid); //XXX: an actual index
window_add(new_window);
_next_wid++;
send_window_event(pw, WE_NEWWINDOW, &wwt);
redraw_region_slow(0,0,ctx->width,ctx->height);
}
break;
case WC_SET_ALPHA:
{
read(pw->command_pipe, &wwt, sizeof(w_window_t));
window_t * window = get_window_with_process(pw, wwt.wid);
window->use_alpha = wwt.left;
}
break;
case WC_RESIZE:
2012-10-14 00:02:58 +04:00
{
read(pw->command_pipe, &wwt, sizeof(w_window_t));
window_t * window = get_window(wwt.wid);
resize_window_buffer(window, window->x, window->y, wwt.width, wwt.height);
printf("Sending event.\n");
send_window_event(pw, WE_RESIZED, &wwt);
}
break;
case WC_DESTROY:
read(pw->command_pipe, &wwt, sizeof(w_window_t));
window_t * win = get_window_with_process(pw, wwt.wid);
win->x = 0xFFFF;
unorder_window(win);
redraw_region_slow(0,0,ctx->width,ctx->height);
/* Wait until we're done drawing */
spin_lock(&am_drawing);
spin_unlock(&am_drawing);
free_window(win);
2012-03-24 02:44:37 +04:00
send_window_event(pw, WE_DESTROYED, &wwt);
break;
case WC_DAMAGE:
read(pw->command_pipe, &wwt, sizeof(w_window_t));
//redraw_window(get_window_with_process(pw, wwt.wid), wwt.left, wwt.top, wwt.width, wwt.height);
break;
2012-03-02 07:13:52 +04:00
case WC_REDRAW:
read(pw->command_pipe, &wwt, sizeof(w_window_t));
//redraw_window(get_window_with_process(pw, wwt.wid), wwt.left, wwt.top, wwt.width, wwt.height);
2012-03-24 02:44:37 +04:00
send_window_event(pw, WE_REDRAWN, &wwt);
2012-03-02 07:13:52 +04:00
break;
case WC_REORDER:
read(pw->command_pipe, &wwt, sizeof(w_window_t));
reorder_window(get_window_with_process(pw, wwt.wid), wwt.left);
redraw_region_slow(0,0,ctx->width,ctx->height);
break;
default:
2012-02-12 04:54:34 +04:00
printf("[compositor] WARN: Unknown command type %d...\n", header.command_type);
void * nullbuf = malloc(header.packet_size);
read(pw->command_pipe, nullbuf, header.packet_size);
free(nullbuf);
break;
}
2012-02-26 07:28:33 +04:00
bad_magic:
fstat(pw->command_pipe, &buf);
}
}
2012-03-02 07:13:52 +04:00
syscall_yield();
2012-01-30 03:05:42 +04:00
}
2012-01-30 03:05:42 +04:00
void waitabit() {
int x = time(NULL);
while (time(NULL) < x + 1) {
2012-03-02 07:13:52 +04:00
syscall_yield();
}
}
/* Request page system */
2012-02-12 04:54:34 +04:00
wins_server_global_t volatile * _request_page;
2012-03-02 07:13:52 +04:00
void reset_request_system () {
2012-02-12 04:54:34 +04:00
_request_page->lock = 0;
_request_page->server_done = 0;
_request_page->client_done = 0;
_request_page->client_pid = 0;
_request_page->event_pipe = 0;
_request_page->command_pipe = 0;
_request_page->server_pid = getpid();
_request_page->server_width = ctx->width;
_request_page->server_height = ctx->height;
_request_page->server_depth = ctx->depth;
2012-02-12 04:54:34 +04:00
_request_page->magic = WINS_MAGIC;
}
2012-03-02 07:13:52 +04:00
void init_request_system () {
size_t size = sizeof(wins_server_global_t);
_request_page = (wins_server_global_t *)syscall_shm_obtain(WINS_SERVER_IDENTIFIER, &size);
if (!_request_page) {
fprintf(stderr, "[wins] Could not get a shm block for its request page! Bailing...");
exit(-1);
}
reset_request_system();
}
void process_request () {
2012-02-14 02:21:52 +04:00
fflush(stdout);
if (_request_page->client_done) {
process_windows_t * pw = malloc(sizeof(process_windows_t));
pw->pid = _request_page->client_pid;
pw->event_pipe = syscall_mkpipe();
pw->event_pipe_file = fdopen(pw->event_pipe, "a");
pw->command_pipe = syscall_mkpipe();
pw->windows = list_create();
_request_page->event_pipe = syscall_share_fd(pw->event_pipe, pw->pid);
_request_page->command_pipe = syscall_share_fd(pw->command_pipe, pw->pid);
2012-02-14 02:21:52 +04:00
_request_page->client_done = 0;
_request_page->server_done = 1;
2012-02-12 04:54:34 +04:00
list_insert(process_list, pw);
}
2012-03-02 07:13:52 +04:00
if (!_request_page->lock) {
reset_request_system();
}
}
void delete_process (process_windows_t * pw) {
list_destroy(pw->windows);
list_free(pw->windows);
free(pw->windows);
close(pw->command_pipe);
close(pw->event_pipe);
node_t * n = list_find(process_list, pw);
list_delete(process_list, n);
free(n);
free(pw);
}
/* Signals */
2012-03-02 07:13:52 +04:00
void * ignore(void * value) {
return NULL;
}
void init_signal_handlers () {
2012-03-02 07:13:52 +04:00
#if 0
syscall_signal(SIGWINEVENT, process_window_command); // SIGWINEVENT
2012-03-02 07:13:52 +04:00
#else
syscall_signal(SIGWINEVENT, ignore); // SIGWINEVENT
2012-03-02 07:13:52 +04:00
#endif
}
/* Sprite stuff */
sprite_t alpha_tmp;
void init_sprite(int i, char * filename, char * alpha) {
sprites[i] = malloc(sizeof(sprite_t));
load_sprite(sprites[i], filename);
if (alpha) {
sprites[i]->alpha = 1;
load_sprite(&alpha_tmp, alpha);
sprites[i]->masks = alpha_tmp.bitmap;
} else {
sprites[i]->alpha = 0;
}
sprites[i]->blank = 0x0;
}
int center_x(int x) {
return (ctx->width - x) / 2;
}
int center_y(int y) {
return (ctx->height - y) / 2;
}
static int progress = 0;
static int progress_width = 0;
#define PROGRESS_WIDTH 120
#define PROGRESS_HEIGHT 6
#define PROGRESS_OFFSET 50
void draw_progress() {
int x = center_x(PROGRESS_WIDTH);
int y = center_y(0);
uint32_t color = rgb(0,120,230);
uint32_t fill = rgb(0,70,160);
draw_line(ctx, x, x + PROGRESS_WIDTH, y + PROGRESS_OFFSET, y + PROGRESS_OFFSET, color);
draw_line(ctx, x, x + PROGRESS_WIDTH, y + PROGRESS_OFFSET + PROGRESS_HEIGHT, y + PROGRESS_OFFSET + PROGRESS_HEIGHT, color);
draw_line(ctx, x, x, y + PROGRESS_OFFSET, y + PROGRESS_OFFSET + PROGRESS_HEIGHT, color);
draw_line(ctx, x + PROGRESS_WIDTH, x + PROGRESS_WIDTH, y + PROGRESS_OFFSET, y + PROGRESS_OFFSET + PROGRESS_HEIGHT, color);
if (progress_width > 0) {
int width = ((PROGRESS_WIDTH - 2) * progress) / progress_width;
for (int8_t i = 0; i < PROGRESS_HEIGHT - 1; ++i) {
draw_line(ctx, x + 1, x + 1 + width, y + PROGRESS_OFFSET + i + 1, y + PROGRESS_OFFSET + i + 1, fill);
}
}
}
2012-02-04 11:20:33 +04:00
uint32_t gradient_at(uint16_t j) {
float x = j * 80;
x = x / ctx->height;
2012-02-04 11:20:33 +04:00
return rgb(0, 1 * x, 2 * x);
}
void display() {
for (uint16_t j = 0; j < ctx->height; ++j) {
draw_line(ctx, 0, ctx->width, j, j, gradient_at(j));
2012-02-04 11:20:33 +04:00
}
draw_sprite(ctx, sprites[0], center_x(sprites[0]->width), center_y(sprites[0]->height));
draw_progress();
flip(ctx);
}
typedef struct {
void (*func)();
char * name;
int time;
} startup_item;
list_t * startup_items;
void add_startup_item(char * name, void (*func)(), int time) {
progress_width += time;
startup_item * item = malloc(sizeof(startup_item));
item->name = name;
item->func = func;
item->time = time;
list_insert(startup_items, item);
}
static void test() {
/* Do Nothing */
}
void run_startup_item(startup_item * item) {
item->func();
progress += item->time;
}
FT_Library library;
FT_Face face;
FT_Face face_bold;
FT_Face face_italic;
FT_Face face_bold_italic;
FT_Face face_extra;
FT_GlyphSlot slot;
FT_UInt glyph_index;
2012-02-20 22:18:13 +04:00
char * loadMemFont(char * ident, char * name, size_t * size) {
FILE * f = fopen(name, "r");
size_t s = 0;
fseek(f, 0, SEEK_END);
s = ftell(f);
fseek(f, 0, SEEK_SET);
size_t shm_size = s;
char * font = (char *)syscall_shm_obtain(ident, &shm_size); //malloc(s);
assert((shm_size >= s) && "shm_obtain returned too little memory to load a font into!");
fread(font, s, 1, f);
fclose(f);
*size = s;
return font;
}
void _init_freetype() {
int error;
error = FT_Init_FreeType(&library);
}
#define FONT_SIZE 13
2012-02-26 08:47:20 +04:00
#define ACTUALLY_LOAD_FONTS 0
int error;
void _load_dejavu() {
char * font;
size_t s;
2012-02-20 22:18:13 +04:00
font = loadMemFont(WINS_SERVER_IDENTIFIER ".fonts.sans-serif", "/usr/share/fonts/DejaVuSans.ttf", &s);
2012-02-26 08:47:20 +04:00
#if ACTUALLY_LOAD_FONTS
error = FT_New_Memory_Face(library, font, s, 0, &face);
error = FT_Set_Pixel_Sizes(face, FONT_SIZE, FONT_SIZE);
2012-02-26 08:47:20 +04:00
#endif
}
void _load_dejavubold() {
char * font;
size_t s;
2012-02-20 22:18:13 +04:00
font = loadMemFont(WINS_SERVER_IDENTIFIER ".fonts.sans-serif.bold", "/usr/share/fonts/DejaVuSans-Bold.ttf", &s);
2012-02-26 08:47:20 +04:00
#if ACTUALLY_LOAD_FONTS
error = FT_New_Memory_Face(library, font, s, 0, &face_bold);
error = FT_Set_Pixel_Sizes(face_bold, FONT_SIZE, FONT_SIZE);
2012-02-26 08:47:20 +04:00
#endif
}
void _load_dejavuitalic() {
char * font;
size_t s;
2012-02-20 22:18:13 +04:00
font = loadMemFont(WINS_SERVER_IDENTIFIER ".fonts.sans-serif.italic", "/usr/share/fonts/DejaVuSans-Oblique.ttf", &s);
2012-02-26 08:47:20 +04:00
#if ACTUALLY_LOAD_FONTS
error = FT_New_Memory_Face(library, font, s, 0, &face_italic);
error = FT_Set_Pixel_Sizes(face_italic, FONT_SIZE, FONT_SIZE);
2012-02-26 08:47:20 +04:00
#endif
}
void _load_dejavubolditalic() {
char * font;
size_t s;
2012-02-20 22:18:13 +04:00
font = loadMemFont(WINS_SERVER_IDENTIFIER ".fonts.sans-serif.bolditalic", "/usr/share/fonts/DejaVuSans-BoldOblique.ttf", &s);
2012-02-26 08:47:20 +04:00
#if ACTUALLY_LOAD_FONTS
error = FT_New_Memory_Face(library, font, s, 0, &face_bold_italic);
error = FT_Set_Pixel_Sizes(face_bold_italic, FONT_SIZE, FONT_SIZE);
2012-02-26 08:47:20 +04:00
#endif
}
2012-02-26 07:28:33 +04:00
void _load_dejamonovu() {
char * font;
size_t s;
font = loadMemFont(WINS_SERVER_IDENTIFIER ".fonts.monospace", "/usr/share/fonts/DejaVuSansMono.ttf", &s);
2012-02-26 08:47:20 +04:00
#if ACTUALLY_LOAD_FONTS
2012-02-26 07:28:33 +04:00
error = FT_New_Memory_Face(library, font, s, 0, &face);
error = FT_Set_Pixel_Sizes(face, FONT_SIZE, FONT_SIZE);
2012-02-26 08:47:20 +04:00
#endif
2012-02-26 07:28:33 +04:00
}
void _load_dejamonovubold() {
char * font;
size_t s;
font = loadMemFont(WINS_SERVER_IDENTIFIER ".fonts.monospace.bold", "/usr/share/fonts/DejaVuSansMono-Bold.ttf", &s);
2012-02-26 08:47:20 +04:00
#if ACTUALLY_LOAD_FONTS
2012-02-26 07:28:33 +04:00
error = FT_New_Memory_Face(library, font, s, 0, &face_bold);
error = FT_Set_Pixel_Sizes(face_bold, FONT_SIZE, FONT_SIZE);
2012-02-26 08:47:20 +04:00
#endif
2012-02-26 07:28:33 +04:00
}
void _load_dejamonovuitalic() {
char * font;
size_t s;
font = loadMemFont(WINS_SERVER_IDENTIFIER ".fonts.monospace.italic", "/usr/share/fonts/DejaVuSansMono-Oblique.ttf", &s);
2012-02-26 08:47:20 +04:00
#if ACTUALLY_LOAD_FONTS
2012-02-26 07:28:33 +04:00
error = FT_New_Memory_Face(library, font, s, 0, &face_italic);
error = FT_Set_Pixel_Sizes(face_italic, FONT_SIZE, FONT_SIZE);
2012-02-26 08:47:20 +04:00
#endif
2012-02-26 07:28:33 +04:00
}
void _load_dejamonovubolditalic() {
char * font;
size_t s;
font = loadMemFont(WINS_SERVER_IDENTIFIER ".fonts.monospace.bolditalic", "/usr/share/fonts/DejaVuSansMono-BoldOblique.ttf", &s);
2012-02-26 08:47:20 +04:00
#if ACTUALLY_LOAD_FONTS
2012-02-26 07:28:33 +04:00
error = FT_New_Memory_Face(library, font, s, 0, &face_bold_italic);
error = FT_Set_Pixel_Sizes(face_bold_italic, FONT_SIZE, FONT_SIZE);
2012-02-26 08:47:20 +04:00
#endif
2012-02-26 07:28:33 +04:00
}
void init_base_windows () {
process_windows_t * pw = malloc(sizeof(process_windows_t));
pw->pid = getpid();
pw->command_pipe = syscall_mkpipe(); /* nothing in here */
pw->event_pipe = syscall_mkpipe(); /* nothing in here */
pw->windows = list_create();
list_insert(process_list, pw);
2012-02-16 06:50:31 +04:00
init_sprite(3, "/usr/share/arrow.bmp","/usr/share/arrow_alpha.bmp");
}
2012-02-17 00:31:40 +04:00
void * process_requests(void * garbage) {
int mfd = *((int *)garbage);
2012-02-17 00:38:50 +04:00
mouse_x = MOUSE_SCALE * ctx->width / 2;
mouse_y = MOUSE_SCALE * ctx->height / 2;
click_x = 0;
click_y = 0;
2012-02-17 00:38:50 +04:00
2012-02-26 09:52:09 +04:00
uint16_t _mouse_state = 0;
window_t * _mouse_window = NULL;
int32_t _mouse_init_x;
int32_t _mouse_init_y;
int32_t _mouse_win_x;
int32_t _mouse_win_y;
int8_t _mouse_moved = 0;
2012-02-26 09:52:09 +04:00
int32_t _mouse_win_x_p;
int32_t _mouse_win_y_p;
2012-02-17 00:31:40 +04:00
struct stat _stat;
2012-02-17 11:28:12 +04:00
char buf[1024];
2012-02-17 00:31:40 +04:00
while (1) {
2012-02-17 11:28:12 +04:00
fstat(mfd, &_stat);
while (_stat.st_size >= sizeof(mouse_device_packet_t)) {
mouse_device_packet_t * packet = (mouse_device_packet_t *)&buf;
int r = read(mfd, &buf, sizeof(mouse_device_packet_t));
if (packet->magic != MOUSE_MAGIC) {
int r = read(mfd, buf, 1);
break;
}
//redraw_region_slow(mouse_x / MOUSE_SCALE - 32, mouse_y / MOUSE_SCALE - 32, 64, 64);
2012-02-17 11:28:12 +04:00
/* Apply mouse movement */
int l;
l = 3;
2012-02-17 11:28:12 +04:00
mouse_x += packet->x_difference * l;
mouse_y -= packet->y_difference * l;
if (mouse_x < 0) mouse_x = 0;
if (mouse_y < 0) mouse_y = 0;
if (mouse_x >= ctx->width * MOUSE_SCALE) mouse_x = (ctx->width) * MOUSE_SCALE;
if (mouse_y >= ctx->height * MOUSE_SCALE) mouse_y = (ctx->height) * MOUSE_SCALE;
//draw_sprite(sprites[3], mouse_x / MOUSE_SCALE - MOUSE_OFFSET_X, mouse_y / MOUSE_SCALE - MOUSE_OFFSET_Y);
if (_mouse_state == 0 && (packet->buttons & MOUSE_BUTTON_LEFT) && k_alt) {
2012-02-26 09:52:09 +04:00
_mouse_window = focused_window();
if (_mouse_window) {
2012-10-14 07:19:43 +04:00
if (_mouse_window->z != 0 && _mouse_window->z != 0xFFFF) {
fprintf(stderr, "Dragging a window now.\n");
2012-02-26 09:52:09 +04:00
_mouse_state = 1;
_mouse_init_x = mouse_x;
_mouse_init_y = mouse_y;
_mouse_win_x = _mouse_window->x;
_mouse_win_y = _mouse_window->y;
_mouse_win_x_p = _mouse_win_x;
_mouse_win_y_p = _mouse_win_y;
2012-03-28 03:19:35 +04:00
moving_window = _mouse_window;
moving_window_l = _mouse_win_x_p;
moving_window_t = _mouse_win_y_p;
2012-02-26 09:52:09 +04:00
make_top(_mouse_window);
redraw_region_slow(0,0,ctx->width,ctx->height);
2012-02-26 09:52:09 +04:00
}
}
} else if (_mouse_state == 0 && (packet->buttons & MOUSE_BUTTON_MIDDLE) && k_alt) {
2012-10-14 07:19:43 +04:00
_mouse_window = focused_window();
if (_mouse_window) {
if (_mouse_window->z != 0 && _mouse_window->z != 0xFFFF) {
_mouse_state = 3;
_mouse_init_x = mouse_x;
_mouse_init_y = mouse_y;
_mouse_win_x = _mouse_window->x;
_mouse_win_y = _mouse_window->y;
resizing_window = _mouse_window;
resizing_window_w = _mouse_window->width;
resizing_window_h = _mouse_window->height;
make_top(_mouse_window);
redraw_region_slow(0,0,ctx->width, ctx->height);
}
}
} else if (_mouse_state == 0 && (packet->buttons & MOUSE_BUTTON_LEFT) && !k_alt) {
_mouse_window = focused_window();
if (_mouse_window) {
_mouse_state = 2; /* Dragging */
/* In window coordinates, that's... */
_mouse_win_x = _mouse_window->x;
_mouse_win_y = _mouse_window->y;
click_x = mouse_x / MOUSE_SCALE - _mouse_win_x;
click_y = mouse_y / MOUSE_SCALE - _mouse_win_y;
2012-04-13 08:30:04 +04:00
mouse_discard = 1;
_mouse_moved = 0;
2012-04-13 08:30:04 +04:00
printf("Mouse down at @ %d,%d = %d,%d\n", mouse_x, mouse_y, click_x, click_y);
}
2012-03-10 22:39:13 +04:00
#if 0
2012-03-02 07:13:52 +04:00
_mouse_window = focused_window();
if (_mouse_window) {
if (_mouse_window->z == 0 || _mouse_window->z == 0xFFFF) {
} else {
_mouse_state = 2;
_mouse_init_x = mouse_x;
_mouse_init_y = mouse_y;
_mouse_win_x = _mouse_window->width;
_mouse_win_y = _mouse_window->height;
_mouse_win_x_p= _mouse_win_x;
_mouse_win_y_p= _mouse_win_y;
make_top(_mouse_window);
redraw_region_slow(0,0,ctx->width,ctx->height);
2012-03-02 07:13:52 +04:00
}
}
2012-03-10 22:39:13 +04:00
#endif
2012-02-26 09:52:09 +04:00
} else if (_mouse_state == 1) {
if (!(packet->buttons & MOUSE_BUTTON_LEFT)) {
2012-02-26 09:52:09 +04:00
_mouse_window->x = _mouse_win_x + (mouse_x - _mouse_init_x) / MOUSE_SCALE;
_mouse_window->y = _mouse_win_y + (mouse_y - _mouse_init_y) / MOUSE_SCALE;
2012-03-28 03:19:35 +04:00
moving_window = NULL;
redraw_region_slow(0,0,ctx->width,ctx->height);
2012-02-26 09:52:09 +04:00
_mouse_state = 0;
} else {
redraw_bounding_box(_mouse_window, _mouse_win_x_p, _mouse_win_y_p, 0);
_mouse_win_x_p = _mouse_win_x + (mouse_x - _mouse_init_x) / MOUSE_SCALE;
_mouse_win_y_p = _mouse_win_y + (mouse_y - _mouse_init_y) / MOUSE_SCALE;
2012-03-28 03:19:35 +04:00
moving_window_l = _mouse_win_x_p;
moving_window_t = _mouse_win_y_p;
2012-02-26 09:52:09 +04:00
}
2012-03-02 07:13:52 +04:00
} else if (_mouse_state == 2) {
if (!(packet->buttons & MOUSE_BUTTON_LEFT)) {
/* Released */
_mouse_state = 0;
_mouse_win_x = _mouse_window->x;
_mouse_win_y = _mouse_window->y;
click_x = mouse_x / MOUSE_SCALE - _mouse_win_x;
click_y = mouse_y / MOUSE_SCALE - _mouse_win_y;
if (!_mouse_moved) {
printf("Finished a click!\n");
w_mouse_t _packet;
_packet.wid = _mouse_window->wid;
_mouse_win_x = _mouse_window->x;
_mouse_win_y = _mouse_window->y;
click_x = mouse_x / MOUSE_SCALE - _mouse_win_x;
click_y = mouse_y / MOUSE_SCALE - _mouse_win_y;
_packet.new_x = click_x;
_packet.new_y = click_y;
_packet.old_x = -1;
_packet.old_y = -1;
_packet.buttons = packet->buttons;
_packet.command = WE_MOUSECLICK;
send_mouse_event(_mouse_window->owner, WE_MOUSEMOVE, &_packet);
}
printf("Mouse up at @ %d,%d = %d,%d\n", mouse_x, mouse_y, click_x, click_y);
2012-03-02 07:13:52 +04:00
} else {
/* Still down */
_mouse_moved = 1;
2012-04-13 08:30:04 +04:00
mouse_discard--;
if (mouse_discard < 1) {
mouse_discard = MOUSE_DISCARD_LEVEL;
w_mouse_t _packet;
_packet.wid = _mouse_window->wid;
_mouse_win_x = _mouse_window->x;
_mouse_win_y = _mouse_window->y;
_packet.old_x = click_x;
_packet.old_y = click_y;
click_x = mouse_x / MOUSE_SCALE - _mouse_win_x;
click_y = mouse_y / MOUSE_SCALE - _mouse_win_y;
_packet.new_x = click_x;
_packet.new_y = click_y;
_packet.buttons = packet->buttons;
_packet.command = WE_MOUSEMOVE;
send_mouse_event(_mouse_window->owner, WE_MOUSEMOVE, &_packet);
}
2012-03-02 07:13:52 +04:00
}
2012-10-14 07:19:43 +04:00
} else if (_mouse_state == 3) {
int width_diff = (mouse_x - _mouse_init_x) / MOUSE_SCALE;
int height_diff = (mouse_y - _mouse_init_y) / MOUSE_SCALE;
resizing_window_w = resizing_window->width + width_diff;
resizing_window_h = resizing_window->height + height_diff;
if (!(packet->buttons & MOUSE_BUTTON_MIDDLE)) {
/* Resize */
w_window_t wwt;
wwt.wid = resizing_window->wid;
wwt.width = resizing_window_w;
wwt.height = resizing_window_h;
resize_window_buffer(resizing_window, resizing_window->x, resizing_window->y, wwt.width, wwt.height);
send_window_event(resizing_window->owner, WE_RESIZED, &wwt);
resizing_window = NULL;
_mouse_state = 0;
2012-02-26 08:47:20 +04:00
}
2012-02-17 11:28:12 +04:00
}
fstat(mfd, &_stat);
}
fstat(0, &_stat);
if (_stat.st_size) {
int r = read(0, buf, 1);
if (r > 0) {
w_keyboard_t packet;
packet.ret = kbd_scancode(buf[0], &packet.event);
2012-02-17 11:28:12 +04:00
window_t * focused = focused_window();
if (focused) {
packet.wid = focused->wid;
packet.command = 0;
packet.key = packet.ret ? packet.event.key : 0;
2012-02-17 11:28:12 +04:00
send_keyboard_event(focused->owner, WE_KEYDOWN, packet);
2012-02-17 00:31:40 +04:00
}
}
}
}
return NULL;
}
void * redraw_thread(void * derp) {
while (1) {
spin_lock(&am_drawing);
redraw_everything_fast();
2012-03-28 03:19:35 +04:00
/* Other stuff */
redraw_cursor();
2012-10-14 07:19:43 +04:00
/* Resizing window outline */
if (resizing_window) {
2012-10-14 08:24:12 +04:00
draw_box(resizing_window->x, resizing_window->y, resizing_window_w, resizing_window_h, rgb(0,128,128));
2012-10-14 07:19:43 +04:00
}
spin_unlock(&am_drawing);
flip(ctx);
2012-09-29 11:38:11 +04:00
if (screenshot_next_frame) {
screenshot_next_frame = 0;
printf("Going for screenshot...\n");
FILE * screenshot = fopen("/usr/share/screenshot.png", "w");
context_to_png(screenshot, ctx);
fclose(screenshot);
}
syscall_yield();
}
}
int main(int argc, char ** argv) {
/* Initialize graphics setup */
ctx = init_graphics_fullscreen_double_buffer();
depth_map = malloc(sizeof(uint16_t) * ctx->width * ctx->height);
top_map = malloc(sizeof(uintptr_t) * ctx->width * ctx->height);
2012-02-26 10:45:46 +04:00
/* Initialize the client request system */
init_request_system();
/* Initialize process list */
init_process_list();
/* Initialize signal handlers */
init_signal_handlers();
/* Load sprites */
2012-02-04 11:20:33 +04:00
init_sprite(0, "/usr/share/bs.bmp", "/usr/share/bs-alpha.bmp");
display();
/* Count startup items */
startup_items = list_create();
add_startup_item("Initializing FreeType", _init_freetype, 1);
add_startup_item("Loading font: Deja Vu Sans", _load_dejavu, 2);
add_startup_item("Loading font: Deja Vu Sans Bold", _load_dejavubold, 2);
add_startup_item("Loading font: Deja Vu Sans Oblique", _load_dejavuitalic, 2);
add_startup_item("Loading font: Deja Vu Sans Bold+Oblique", _load_dejavubolditalic, 2);
2012-02-26 07:28:33 +04:00
add_startup_item("Loading font: Deja Vu Sans Mono", _load_dejamonovu, 2);
add_startup_item("Loading font: Deja Vu Sans Mono Bold", _load_dejamonovubold, 2);
add_startup_item("Loading font: Deja Vu Sans Mono Oblique", _load_dejamonovuitalic, 2);
add_startup_item("Loading font: Deja Vu Sans Mono Bold+Oblique", _load_dejamonovubolditalic, 2);
foreach(node, startup_items) {
run_startup_item((startup_item *)node->value);
display();
}
/* load the mouse cursor */
init_sprite(3, "/usr/share/arrow.bmp","/usr/share/arrow_alpha.bmp");
2012-02-17 00:31:40 +04:00
/* Grab the mouse */
int mfd = syscall_mousedevice();
pthread_t input_thread;
pthread_create(&input_thread, NULL, process_requests, (void *)&mfd);
pthread_t redraw_everything_thread;
pthread_create(&redraw_everything_thread, NULL, redraw_thread, NULL);
setenv("DISPLAY", WINS_SERVER_IDENTIFIER, 1);
2012-03-08 09:44:02 +04:00
if (!fork()) {
2012-10-14 00:02:58 +04:00
#if SINGLE_USER_MODE
char * args[] = {"/bin/gsession", NULL};
#else
char * args[] = {"/bin/glogin", NULL};
2012-10-14 00:02:58 +04:00
#endif
execvp(args[0], args);
2012-03-08 09:44:02 +04:00
}
2012-02-12 04:54:34 +04:00
/* Sit in a run loop */
while (1) {
2012-02-12 04:54:34 +04:00
process_request();
2012-02-17 00:31:40 +04:00
process_window_command(0);
syscall_yield();
2012-01-30 03:05:42 +04:00
}
2012-02-12 04:54:34 +04:00
// XXX: Better have SIGINT/SIGSTOP handlers
return 0;
2012-01-30 03:05:42 +04:00
}