2012-02-04 07:15:26 +04:00
|
|
|
/*
|
2012-07-07 08:08:28 +04:00
|
|
|
* 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>
|
2012-02-04 07:15:26 +04:00
|
|
|
#include <syscall.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <time.h>
|
2012-02-12 03:57:22 +04:00
|
|
|
#include <assert.h>
|
2012-02-11 09:26:30 +04:00
|
|
|
#include <sys/stat.h>
|
2012-02-04 07:15:26 +04:00
|
|
|
|
|
|
|
#include <ft2build.h>
|
|
|
|
#include FT_FREETYPE_H
|
|
|
|
#include FT_CACHE_H
|
|
|
|
|
2012-01-30 03:05:42 +04:00
|
|
|
#include "lib/list.h"
|
2012-02-04 07:15:26 +04:00
|
|
|
#include "lib/graphics.h"
|
2012-02-12 04:54:34 +04:00
|
|
|
#include "lib/window.h"
|
2012-04-13 07:42:24 +04:00
|
|
|
#include "lib/pthread.h"
|
2012-10-15 06:53:16 +04:00
|
|
|
#include "lib/kbd.h"
|
2012-02-11 09:26:30 +04:00
|
|
|
|
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
|
|
|
|
2012-10-17 06:05:58 +04:00
|
|
|
#define SINGLE_USER_MODE 0
|
2012-10-14 00:02:58 +04:00
|
|
|
|
2012-03-28 04:09:11 +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
|
|
|
|
2012-03-28 04:09:11 +04:00
|
|
|
void spin_unlock(int volatile * lock) {
|
|
|
|
__sync_lock_release(lock);
|
|
|
|
}
|
2012-02-26 09:52:09 +04:00
|
|
|
|
2012-09-14 09:12:47 +04:00
|
|
|
window_t * windows[0x10000];
|
|
|
|
|
2012-09-29 11:38:11 +04:00
|
|
|
volatile uint8_t screenshot_next_frame = 0;
|
2012-02-12 04:01:21 +04:00
|
|
|
|
2012-02-04 07:15:26 +04:00
|
|
|
sprite_t * sprites[128];
|
2012-01-30 03:05:42 +04:00
|
|
|
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
gfx_context_t * ctx;
|
|
|
|
|
2012-02-11 09:26:30 +04:00
|
|
|
#define WIN_D 32
|
2012-02-12 04:01:21 +04:00
|
|
|
#define WIN_B (WIN_D / 8)
|
2012-04-13 08:30:04 +04:00
|
|
|
#define MOUSE_DISCARD_LEVEL 6
|
2012-02-11 09:26:30 +04:00
|
|
|
|
|
|
|
|
|
|
|
list_t * process_list;
|
|
|
|
|
2012-02-23 11:30:56 +04:00
|
|
|
int32_t mouse_x, mouse_y;
|
2012-04-13 07:42:24 +04:00
|
|
|
int32_t click_x, click_y;
|
2012-04-13 08:21:38 +04:00
|
|
|
uint32_t mouse_discard = 0;
|
2012-09-14 09:12:47 +04:00
|
|
|
#define MOUSE_SCALE 3
|
2012-02-23 11:30:56 +04:00
|
|
|
#define MOUSE_OFFSET_X 26
|
|
|
|
#define MOUSE_OFFSET_Y 26
|
|
|
|
|
2012-03-15 07:03:55 +04:00
|
|
|
void redraw_region_slow(int32_t x, int32_t y, int32_t width, int32_t height);
|
|
|
|
void redraw_cursor() {
|
2012-03-28 01:52:46 +04:00
|
|
|
//redraw_region_slow(mouse_x / MOUSE_SCALE - 32, mouse_y / MOUSE_SCALE - 32, 64, 64);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
draw_sprite(ctx, sprites[3], mouse_x / MOUSE_SCALE - MOUSE_OFFSET_X, mouse_y / MOUSE_SCALE - MOUSE_OFFSET_Y);
|
2012-03-15 07:03:55 +04:00
|
|
|
}
|
|
|
|
|
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);
|
2012-02-14 05:46:00 +04:00
|
|
|
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;
|
2012-03-27 22:58:21 +04:00
|
|
|
uintptr_t * top_map = NULL;
|
2012-02-26 10:45:46 +04:00
|
|
|
|
2012-02-11 09:26:30 +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) {
|
2012-02-11 09:26:30 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-02-11 09:26:30 +04:00
|
|
|
void init_process_list () {
|
|
|
|
process_list = list_create();
|
2012-09-14 09:12:47 +04:00
|
|
|
memset(windows, 0x00000000, sizeof(window_t *) * 0x10000);
|
2012-02-11 09:26:30 +04:00
|
|
|
}
|
|
|
|
|
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;
|
2012-02-11 09:26:30 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-03-27 22:58:21 +04:00
|
|
|
uint8_t inline is_top_fast(window_t * window, uint16_t x, uint16_t y) {
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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
|
|
|
}
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +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;
|
|
|
|
}
|
|
|
|
|
2012-02-23 11:30:56 +04:00
|
|
|
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;
|
2012-02-23 11:30:56 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return window_top;
|
|
|
|
}
|
|
|
|
|
2012-09-14 09:12:47 +04:00
|
|
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-14 09:12:47 +04:00
|
|
|
void reorder_window (window_t * window, uint16_t new_zed) {
|
|
|
|
if (!window) {
|
|
|
|
return;
|
|
|
|
}
|
2012-03-02 07:13:52 +04:00
|
|
|
|
2012-09-14 09:12:47 +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
|
|
|
}
|
2012-09-14 09:12:47 +04:00
|
|
|
return;
|
2012-02-17 11:28:12 +04:00
|
|
|
}
|
2012-09-14 09:12:47 +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-11 09:26:30 +04:00
|
|
|
|
2012-09-14 09:12:47 +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;
|
2012-09-14 09:12:47 +04:00
|
|
|
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;
|
2012-09-14 09:12:47 +04:00
|
|
|
if (win->z > window->z) continue;
|
2012-02-26 09:52:09 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-14 09:12:47 +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
|
|
|
}
|
2012-02-11 09:26:30 +04:00
|
|
|
|
2012-02-23 11:30:56 +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);
|
2012-02-23 11:30:56 +04:00
|
|
|
}
|
|
|
|
|
2012-03-28 04:09:11 +04:00
|
|
|
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-02-11 09:26:30 +04:00
|
|
|
|
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 */
|
2012-02-11 09:26:30 +04:00
|
|
|
|
|
|
|
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);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
uint16_t _hi_x = min(window->x + width, ctx->width);
|
2012-02-11 09:26:30 +04:00
|
|
|
uint16_t _lo_y = max(window->y + y, 0);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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;
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
GFX(ctx,x,y) = ((uint32_t *)window->buffer)[TO_WINDOW_OFFSET(x,y)];
|
2012-01-30 03:05:42 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-03-15 07:03:55 +04:00
|
|
|
|
|
|
|
//redraw_region_slow(mouse_x / MOUSE_SCALE - 32, mouse_y / MOUSE_SCALE - 32, 64, 64);
|
2012-03-28 01:52:46 +04:00
|
|
|
//redraw_cursor();
|
2012-01-30 03:05:42 +04:00
|
|
|
}
|
|
|
|
|
2012-09-14 09:12:47 +04:00
|
|
|
void window_add (window_t * window) {
|
|
|
|
int z = window->z;
|
|
|
|
while (windows[z]) {
|
|
|
|
z++;
|
2012-03-08 08:31:24 +04:00
|
|
|
}
|
2012-09-14 09:12:47 +04:00
|
|
|
printf("Assigning depth of %d to window 0x%x\n", z, window);
|
|
|
|
window->z = z;
|
|
|
|
windows[z] = window;
|
|
|
|
}
|
2012-03-08 08:31:24 +04:00
|
|
|
|
2012-09-14 09:12:47 +04:00
|
|
|
void unorder_window (window_t * window) {
|
|
|
|
int z = window->z;
|
|
|
|
if (z < 0x10000 && windows[z]) {
|
|
|
|
windows[z] = 0;
|
2012-09-13 07:10:48 +04:00
|
|
|
}
|
2012-09-14 09:12:47 +04:00
|
|
|
window->z = 0;
|
|
|
|
return;
|
2012-03-08 08:31:24 +04:00
|
|
|
}
|
|
|
|
|
2012-02-11 09:26:30 +04:00
|
|
|
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);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
uint16_t _hi_x = min(x + width, ctx->width);
|
2012-02-26 08:47:20 +04:00
|
|
|
uint16_t _lo_y = max(y, 0);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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) {
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
//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 {
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
//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;
|
2012-03-27 22:58:21 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-14 09:12:47 +04:00
|
|
|
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);
|
2012-09-14 09:12:47 +04:00
|
|
|
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);
|
2012-09-14 09:12:47 +04:00
|
|
|
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
|
|
|
|
2012-09-14 09:12:47 +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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-09-14 09:12:47 +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) {
|
2012-03-28 01:52:46 +04:00
|
|
|
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);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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) {
|
2012-03-28 01:52:46 +04:00
|
|
|
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);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-02-11 09:26:30 +04:00
|
|
|
|
2012-09-17 05:14:07 +04:00
|
|
|
wid_t volatile _next_wid = 1;
|
2012-02-11 09:26:30 +04:00
|
|
|
|
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;
|
2012-02-21 09:31:00 +04:00
|
|
|
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-11 09:26:30 +04:00
|
|
|
|
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
|
2012-03-14 02:44:19 +04:00
|
|
|
syscall_yield();
|
2012-02-11 09:26:30 +04:00
|
|
|
}
|
|
|
|
|
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;
|
2012-02-21 09:31:00 +04:00
|
|
|
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
|
2012-04-13 07:42:24 +04:00
|
|
|
syscall_yield();
|
|
|
|
}
|
|
|
|
|
2012-04-13 08:21:38 +04:00
|
|
|
FILE *fdopen(int fd, const char *mode);
|
|
|
|
|
2012-04-13 07:42:24 +04:00
|
|
|
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 */
|
2012-04-13 08:21:38 +04:00
|
|
|
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);
|
2012-04-13 07:42:24 +04:00
|
|
|
//syscall_send_signal(pw->pid, SIGWINEVENT); // SIGWINEVENT
|
2012-04-13 08:21:38 +04:00
|
|
|
//syscall_yield();
|
2012-02-17 11:28:12 +04:00
|
|
|
}
|
|
|
|
|
2012-02-12 04:54:34 +04:00
|
|
|
void process_window_command (int sig) {
|
2012-02-11 09:26:30 +04:00
|
|
|
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
|
2012-02-11 09:26:30 +04:00
|
|
|
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));
|
2012-02-11 09:26:30 +04:00
|
|
|
|
2012-02-23 11:30:56 +04:00
|
|
|
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;
|
2012-02-23 11:30:56 +04:00
|
|
|
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--;
|
|
|
|
|
2012-02-11 09:26:30 +04:00
|
|
|
switch (header.command_type) {
|
|
|
|
case WC_NEWWINDOW:
|
2012-09-14 09:12:47 +04:00
|
|
|
{
|
|
|
|
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);
|
2012-10-12 10:55:53 +04:00
|
|
|
window->use_alpha = wwt.left;
|
2012-09-14 09:12:47 +04:00
|
|
|
}
|
2012-02-11 09:26:30 +04:00
|
|
|
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);
|
|
|
|
}
|
2012-02-11 09:26:30 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case WC_DESTROY:
|
|
|
|
read(pw->command_pipe, &wwt, sizeof(w_window_t));
|
2012-03-21 01:23:24 +04:00
|
|
|
window_t * win = get_window_with_process(pw, wwt.wid);
|
2012-03-28 04:09:11 +04:00
|
|
|
win->x = 0xFFFF;
|
2012-09-14 09:12:47 +04:00
|
|
|
unorder_window(win);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
redraw_region_slow(0,0,ctx->width,ctx->height);
|
2012-03-28 04:09:11 +04:00
|
|
|
/* Wait until we're done drawing */
|
|
|
|
spin_lock(&am_drawing);
|
|
|
|
spin_unlock(&am_drawing);
|
2012-03-21 01:23:24 +04:00
|
|
|
free_window(win);
|
2012-03-24 02:44:37 +04:00
|
|
|
send_window_event(pw, WE_DESTROYED, &wwt);
|
2012-02-11 09:26:30 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case WC_DAMAGE:
|
|
|
|
read(pw->command_pipe, &wwt, sizeof(w_window_t));
|
2012-03-27 22:58:21 +04:00
|
|
|
//redraw_window(get_window_with_process(pw, wwt.wid), wwt.left, wwt.top, wwt.width, wwt.height);
|
2012-02-11 09:26:30 +04:00
|
|
|
break;
|
|
|
|
|
2012-03-02 07:13:52 +04:00
|
|
|
case WC_REDRAW:
|
|
|
|
read(pw->command_pipe, &wwt, sizeof(w_window_t));
|
2012-03-27 22:58:21 +04:00
|
|
|
//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;
|
|
|
|
|
2012-03-08 08:31:24 +04:00
|
|
|
case WC_REORDER:
|
|
|
|
read(pw->command_pipe, &wwt, sizeof(w_window_t));
|
|
|
|
reorder_window(get_window_with_process(pw, wwt.wid), wwt.left);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
redraw_region_slow(0,0,ctx->width,ctx->height);
|
2012-03-08 08:31:24 +04:00
|
|
|
break;
|
|
|
|
|
2012-02-11 09:26:30 +04:00
|
|
|
default:
|
2012-02-12 04:54:34 +04:00
|
|
|
printf("[compositor] WARN: Unknown command type %d...\n", header.command_type);
|
2012-02-11 09:26:30 +04:00
|
|
|
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:
|
2012-02-11 09:26:30 +04:00
|
|
|
fstat(pw->command_pipe, &buf);
|
|
|
|
}
|
|
|
|
}
|
2012-03-02 07:13:52 +04:00
|
|
|
syscall_yield();
|
2012-01-30 03:05:42 +04:00
|
|
|
}
|
|
|
|
|
2012-02-11 09:26:30 +04:00
|
|
|
|
2012-02-04 07:15:26 +04:00
|
|
|
|
2012-01-30 03:05:42 +04:00
|
|
|
|
2012-02-04 07:15:26 +04:00
|
|
|
void waitabit() {
|
|
|
|
int x = time(NULL);
|
|
|
|
while (time(NULL) < x + 1) {
|
2012-03-02 07:13:52 +04:00
|
|
|
syscall_yield();
|
2012-02-04 07:15:26 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-11 09:26:30 +04:00
|
|
|
|
|
|
|
/* Request page system */
|
|
|
|
|
|
|
|
|
2012-02-12 04:54:34 +04:00
|
|
|
wins_server_global_t volatile * _request_page;
|
2012-02-11 09:26:30 +04:00
|
|
|
|
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();
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
_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-02-11 09:26:30 +04:00
|
|
|
}
|
|
|
|
|
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();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-02-11 09:26:30 +04:00
|
|
|
void process_request () {
|
2012-02-14 02:21:52 +04:00
|
|
|
fflush(stdout);
|
2012-02-11 09:26:30 +04:00
|
|
|
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();
|
2012-04-13 08:21:38 +04:00
|
|
|
pw->event_pipe_file = fdopen(pw->event_pipe, "a");
|
2012-02-11 09:26:30 +04:00
|
|
|
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;
|
2012-02-11 09:26:30 +04:00
|
|
|
_request_page->server_done = 1;
|
2012-02-12 04:54:34 +04:00
|
|
|
|
|
|
|
list_insert(process_list, pw);
|
2012-02-11 09:26:30 +04:00
|
|
|
}
|
2012-03-02 07:13:52 +04:00
|
|
|
|
|
|
|
if (!_request_page->lock) {
|
|
|
|
reset_request_system();
|
|
|
|
}
|
2012-02-11 09:26:30 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2012-02-11 09:26:30 +04:00
|
|
|
|
|
|
|
void init_signal_handlers () {
|
2012-03-02 07:13:52 +04:00
|
|
|
#if 0
|
2012-09-05 07:27:49 +04:00
|
|
|
syscall_signal(SIGWINEVENT, process_window_command); // SIGWINEVENT
|
2012-03-02 07:13:52 +04:00
|
|
|
#else
|
2012-09-05 07:27:49 +04:00
|
|
|
syscall_signal(SIGWINEVENT, ignore); // SIGWINEVENT
|
2012-03-02 07:13:52 +04:00
|
|
|
#endif
|
2012-02-11 09:26:30 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Sprite stuff */
|
|
|
|
|
|
|
|
|
2012-02-04 07:15:26 +04:00
|
|
|
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) {
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
return (ctx->width - x) / 2;
|
2012-02-04 07:15:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
int center_y(int y) {
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
return (ctx->height - y) / 2;
|
2012-02-04 07:15:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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);
|
2012-02-04 07:15:26 +04:00
|
|
|
|
|
|
|
if (progress_width > 0) {
|
|
|
|
int width = ((PROGRESS_WIDTH - 2) * progress) / progress_width;
|
|
|
|
for (int8_t i = 0; i < PROGRESS_HEIGHT - 1; ++i) {
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
draw_line(ctx, x + 1, x + 1 + width, y + PROGRESS_OFFSET + i + 1, y + PROGRESS_OFFSET + i + 1, fill);
|
2012-02-04 07:15:26 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-02-04 11:20:33 +04:00
|
|
|
uint32_t gradient_at(uint16_t j) {
|
|
|
|
float x = j * 80;
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
x = x / ctx->height;
|
2012-02-04 11:20:33 +04:00
|
|
|
return rgb(0, 1 * x, 2 * x);
|
|
|
|
}
|
|
|
|
|
2012-02-04 07:15:26 +04:00
|
|
|
void display() {
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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
|
|
|
}
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
draw_sprite(ctx, sprites[0], center_x(sprites[0]->width), center_y(sprites[0]->height));
|
2012-02-04 07:15:26 +04:00
|
|
|
draw_progress();
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
flip(ctx);
|
2012-02-04 07:15:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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) {
|
2012-02-04 07:15:26 +04:00
|
|
|
FILE * f = fopen(name, "r");
|
|
|
|
size_t s = 0;
|
|
|
|
fseek(f, 0, SEEK_END);
|
|
|
|
s = ftell(f);
|
|
|
|
fseek(f, 0, SEEK_SET);
|
2012-02-16 13:34:42 +04:00
|
|
|
|
|
|
|
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!");
|
|
|
|
|
2012-02-04 07:15:26 +04:00
|
|
|
fread(font, s, 1, f);
|
2012-02-21 04:33:09 +04:00
|
|
|
|
2012-02-04 07:15:26 +04:00
|
|
|
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
|
2012-02-04 07:15:26 +04:00
|
|
|
|
|
|
|
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
|
2012-02-04 07:15:26 +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-04 07:15:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
2012-02-04 07:15:26 +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-04 07:15:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
2012-02-04 07:15:26 +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-04 07:15:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
2012-02-04 07:15:26 +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-04 07:15:26 +04:00
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2012-02-11 09:26:30 +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();
|
2012-02-12 03:57:22 +04:00
|
|
|
list_insert(process_list, pw);
|
2012-02-11 09:26:30 +04:00
|
|
|
|
2012-02-16 06:50:31 +04:00
|
|
|
init_sprite(3, "/usr/share/arrow.bmp","/usr/share/arrow_alpha.bmp");
|
2012-02-11 09:26:30 +04:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
mouse_x = MOUSE_SCALE * ctx->width / 2;
|
|
|
|
mouse_y = MOUSE_SCALE * ctx->height / 2;
|
2012-04-13 07:42:24 +04:00
|
|
|
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;
|
2012-04-13 10:21:01 +04:00
|
|
|
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;
|
|
|
|
}
|
2012-03-28 01:52:46 +04:00
|
|
|
//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 */
|
2012-10-12 11:17:23 +04:00
|
|
|
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;
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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;
|
2012-03-28 01:52:46 +04:00
|
|
|
//draw_sprite(sprites[3], mouse_x / MOUSE_SCALE - MOUSE_OFFSET_X, mouse_y / MOUSE_SCALE - MOUSE_OFFSET_Y);
|
2012-10-15 06:53:16 +04:00
|
|
|
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) {
|
2012-10-15 06:53:16 +04:00
|
|
|
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);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
redraw_region_slow(0,0,ctx->width,ctx->height);
|
2012-02-26 09:52:09 +04:00
|
|
|
}
|
|
|
|
}
|
2012-10-15 06:53:16 +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);
|
|
|
|
}
|
|
|
|
}
|
2012-10-15 06:53:16 +04:00
|
|
|
} else if (_mouse_state == 0 && (packet->buttons & MOUSE_BUTTON_LEFT) && !k_alt) {
|
2012-04-11 07:34:36 +04:00
|
|
|
_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;
|
|
|
|
|
2012-04-13 07:42:24 +04:00
|
|
|
click_x = mouse_x / MOUSE_SCALE - _mouse_win_x;
|
|
|
|
click_y = mouse_y / MOUSE_SCALE - _mouse_win_y;
|
2012-04-11 07:34:36 +04:00
|
|
|
|
2012-04-13 08:30:04 +04:00
|
|
|
mouse_discard = 1;
|
2012-04-13 10:21:01 +04:00
|
|
|
_mouse_moved = 0;
|
2012-04-13 08:30:04 +04:00
|
|
|
|
2012-04-11 07:34:36 +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);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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) {
|
2012-10-15 06:53:16 +04:00
|
|
|
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;
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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) {
|
2012-04-11 07:34:36 +04:00
|
|
|
if (!(packet->buttons & MOUSE_BUTTON_LEFT)) {
|
|
|
|
/* Released */
|
|
|
|
_mouse_state = 0;
|
|
|
|
_mouse_win_x = _mouse_window->x;
|
|
|
|
_mouse_win_y = _mouse_window->y;
|
|
|
|
|
2012-04-13 07:42:24 +04:00
|
|
|
click_x = mouse_x / MOUSE_SCALE - _mouse_win_x;
|
|
|
|
click_y = mouse_y / MOUSE_SCALE - _mouse_win_y;
|
2012-04-13 10:21:01 +04:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2012-04-11 07:34:36 +04:00
|
|
|
|
|
|
|
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 {
|
2012-04-11 07:34:36 +04:00
|
|
|
/* Still down */
|
2012-04-13 07:42:24 +04:00
|
|
|
|
2012-04-13 10:21:01 +04:00
|
|
|
_mouse_moved = 1;
|
2012-04-13 08:30:04 +04:00
|
|
|
mouse_discard--;
|
|
|
|
if (mouse_discard < 1) {
|
|
|
|
mouse_discard = MOUSE_DISCARD_LEVEL;
|
2012-04-13 07:42:24 +04:00
|
|
|
|
2012-04-13 08:21:38 +04:00
|
|
|
w_mouse_t _packet;
|
|
|
|
_packet.wid = _mouse_window->wid;
|
2012-04-11 07:34:36 +04:00
|
|
|
|
2012-04-13 08:21:38 +04:00
|
|
|
_mouse_win_x = _mouse_window->x;
|
|
|
|
_mouse_win_y = _mouse_window->y;
|
2012-04-13 07:42:24 +04:00
|
|
|
|
2012-04-13 08:21:38 +04:00
|
|
|
_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;
|
2012-04-13 07:42:24 +04:00
|
|
|
|
2012-04-13 08:21:38 +04:00
|
|
|
_packet.new_x = click_x;
|
|
|
|
_packet.new_y = click_y;
|
2012-04-13 07:42:24 +04:00
|
|
|
|
2012-04-13 08:21:38 +04:00
|
|
|
_packet.buttons = packet->buttons;
|
2012-04-13 10:21:01 +04:00
|
|
|
_packet.command = WE_MOUSEMOVE;
|
2012-04-11 07:34:36 +04:00
|
|
|
|
2012-04-13 08:21:38 +04:00
|
|
|
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;
|
2012-10-15 06:53:16 +04:00
|
|
|
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;
|
2012-10-15 06:53:16 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-03-27 22:58:21 +04:00
|
|
|
void * redraw_thread(void * derp) {
|
|
|
|
while (1) {
|
2012-03-28 04:09:11 +04:00
|
|
|
spin_lock(&am_drawing);
|
2012-03-27 22:58:21 +04:00
|
|
|
redraw_everything_fast();
|
2012-03-28 03:19:35 +04:00
|
|
|
/* Other stuff */
|
2012-03-27 22:58:21 +04:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2012-03-28 04:09:11 +04:00
|
|
|
spin_unlock(&am_drawing);
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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);
|
|
|
|
}
|
2012-03-27 22:58:21 +04:00
|
|
|
syscall_yield();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-04 07:15:26 +04:00
|
|
|
int main(int argc, char ** argv) {
|
|
|
|
|
|
|
|
/* Initialize graphics setup */
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
ctx = init_graphics_fullscreen_double_buffer();
|
2012-02-04 07:15:26 +04:00
|
|
|
|
Context-based graphics library.
All graphics library commands now take a gfx_context_t pointer, which
points to a simple datastructure describing a rendering context (width,
height, depth, total size, front buffer, backbuffer; where backbuffer =
front buffer when not in double-buffering mode, thus we always render to
backbuffer except on a flip). This may have caused a minor speed
reduction, but I don't really care as it's far more important that we
support multiple graphics contexts.
TODO:
- Shared Memory Fonts library (there are a couple of apps that use these
so-called "shmem fonts" on their own; we need a dedicated library for
them)
- Break off "TTK" GUI toolkit into its own library. Since it's just a
callback-based button framework, this shouldn't be too hard right now.
Also, with the previous tick, I'll be able to put labels on controls
and start using text in more places.
2012-04-17 22:21:34 +04:00
|
|
|
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
|
|
|
|
2012-02-11 09:26:30 +04:00
|
|
|
/* Initialize the client request system */
|
|
|
|
init_request_system();
|
|
|
|
|
|
|
|
/* Initialize process list */
|
|
|
|
init_process_list();
|
|
|
|
|
|
|
|
/* Initialize signal handlers */
|
|
|
|
init_signal_handlers();
|
|
|
|
|
2012-02-04 07:15:26 +04:00
|
|
|
/* Load sprites */
|
2012-02-04 11:20:33 +04:00
|
|
|
init_sprite(0, "/usr/share/bs.bmp", "/usr/share/bs-alpha.bmp");
|
2012-02-04 07:15:26 +04:00
|
|
|
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);
|
2012-02-04 07:15:26 +04:00
|
|
|
|
|
|
|
foreach(node, startup_items) {
|
|
|
|
run_startup_item((startup_item *)node->value);
|
|
|
|
display();
|
|
|
|
}
|
|
|
|
|
2012-10-12 10:55:53 +04:00
|
|
|
/* load the mouse cursor */
|
|
|
|
init_sprite(3, "/usr/share/arrow.bmp","/usr/share/arrow_alpha.bmp");
|
2012-02-12 04:01:21 +04:00
|
|
|
|
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);
|
|
|
|
|
2012-03-27 22:58:21 +04:00
|
|
|
pthread_t redraw_everything_thread;
|
|
|
|
pthread_create(&redraw_everything_thread, NULL, redraw_thread, NULL);
|
|
|
|
|
2012-10-12 10:55:53 +04:00
|
|
|
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
|
2012-09-13 09:10:10 +04:00
|
|
|
char * args[] = {"/bin/glogin", NULL};
|
2012-10-14 00:02:58 +04:00
|
|
|
#endif
|
2012-10-08 11:17:50 +04:00
|
|
|
execvp(args[0], args);
|
2012-03-08 09:44:02 +04:00
|
|
|
}
|
2012-03-08 08:31:24 +04:00
|
|
|
|
2012-02-12 04:54:34 +04:00
|
|
|
/* Sit in a run loop */
|
2012-02-08 12:45:47 +04:00
|
|
|
while (1) {
|
2012-02-12 04:54:34 +04:00
|
|
|
process_request();
|
2012-02-17 00:31:40 +04:00
|
|
|
process_window_command(0);
|
2012-03-11 04:20:34 +04:00
|
|
|
syscall_yield();
|
2012-01-30 03:05:42 +04:00
|
|
|
}
|
2012-02-04 07:15:26 +04:00
|
|
|
|
2012-02-12 04:54:34 +04:00
|
|
|
// XXX: Better have SIGINT/SIGSTOP handlers
|
2012-02-04 07:15:26 +04:00
|
|
|
return 0;
|
2012-01-30 03:05:42 +04:00
|
|
|
}
|