nortti
/
links
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
links/haiku.cpp

1007 lines
24 KiB
C++
Raw Permalink Blame History

/* haiku.cpp
* (c) 2007 François Revol
* This file is a part of the Links program, released under GPL
*/
/*
* GUI code
*/
/*
* TODO:
* - more paste handling ?
* - more DnD (maybe check if in menu or not and prepend "g" ?)
* - handle DnD of Net+ bookmarks
*/
#include "cfg.h"
#ifdef GRDRV_HAIKU
extern "C" {
#include "links.h"
}
#undef B_ENTER
#include <app/Application.h>
#include <app/Clipboard.h>
#include <interface/Bitmap.h>
#include <interface/Region.h>
#include <interface/Screen.h>
#include <interface/View.h>
#include <interface/Window.h>
#include <storage/Entry.h>
#include <storage/File.h>
#include <storage/Path.h>
#include <support/Locker.h>
#include <support/String.h>
//#define DBG(l...) fprintf(stderr, l);
#define DBG(l...) {}
/*
#ifdef debug
#undef debug
#endif
#define debug(x)
#define fprintf(x, y)
*/
extern "C" struct graphics_driver haiku_driver;
class LinksApplication : public BApplication {
public:
LinksApplication():BApplication("application/x-vnd.links"){}
virtual bool QuitRequested();
};
class LinksView;
class LinksWindow : public BWindow {
public:
LinksWindow(BRect r);
~LinksWindow();
virtual void FrameResized(float width, float height);
virtual bool QuitRequested();
struct rect update_rect;
int resized;
LinksView *view;
};
class LinksView : public BView {
public:
LinksView(LinksWindow *w);
~LinksView();
virtual void Draw(BRect r);
virtual void MouseDown(BPoint p);
virtual void MouseUp(BPoint p);
virtual void MouseMoved(BPoint p, uint32 transit, const BMessage *dragmsg);
virtual void KeyDown(const char *s, int32 numBytes);
virtual void MessageReceived(BMessage *msg);
LinksWindow *win;
struct graphics_device *dev;
void d_flush();
int flushing;
int last_x, last_y;
unsigned last_buttons;
};
#define lv(dev) ((LinksView *)(dev)->driver_data)
#define lock_dev(dev) do { if (!lv(dev)->win->Lock()) return; } while (0)
#define lock_dev0(dev) do { if (!lv(dev)->win->Lock()) return 0; } while (0)
#define unlock_dev(dev) do { lv(dev)->win->Unlock(); } while (0)
static void be_get_size(struct graphics_device *dev);
struct be_event {
list_entry_1st
BMessage *msg;
struct graphics_device *dev;
list_entry_last
};
static struct list_head be_message_queue;
static BLocker message_queue_lock;
#define detach_and_pipe_message(d) do { \
BMessage *current = Looper()->DetachCurrentMessage(); \
if (current) { \
struct be_event *ev = (struct be_event *)malloc(sizeof(struct be_event));\
message_queue_lock.Lock(); \
if (ev && d) { \
int r; \
ev->msg = current; \
ev->dev = d; \
add_to_list_end(be_message_queue, ev); \
EINTRLOOP(r, write(wpipe, " ", 1)); \
} else { \
if (ev) free(ev); \
delete current; \
} \
message_queue_lock.Unlock(); \
} \
} while (0)
static LinksApplication *be_links_app;
static int msg_pipe[2];
static thread_id be_app_thread_id;
#define rpipe (msg_pipe[0])
#define wpipe (msg_pipe[1])
#define small_color (sizeof(rgb_color) <= sizeof(long))
#define get_color32(c, rgb) rgb_color \
c((rgb_color){ \
static_cast<uint8>((rgb >> 16) & 255), \
static_cast<uint8>((rgb >> 8) & 255), \
static_cast<uint8>(rgb & 255), \
255})
static color_space be_cs_desktop, be_cs_bmp;
static int be_x_size, be_y_size;
static int be_win_x_size, be_win_y_size;
static int be_win_x_pos, be_win_y_pos;
bool LinksApplication::QuitRequested()
{
int i, n;
n = CountWindows();
for (i = 0; i < n; i++) {
BWindow *win = WindowAt(i);
if (win) {
win->PostMessage(B_QUIT_REQUESTED);
}
}
return false;
}
LinksWindow::LinksWindow(BRect r):BWindow(r, "Links", B_DOCUMENT_WINDOW, 0)
{
DBG("LINKSWINDOW\n");
update_rect.x1 = 0;
update_rect.x2 = 0;
update_rect.y1 = 0;
update_rect.y2 = 0;
resized = 0;
view = NULL;
}
LinksWindow::~LinksWindow()
{
view = NULL;
DBG("~LINKSWINDOW\n");
}
void LinksWindow::FrameResized(float width, float height)
{
message_queue_lock.Lock();
resized = 1;
message_queue_lock.Unlock();
}
bool LinksWindow::QuitRequested()
{
detach_and_pipe_message(view->dev);
return false;
}
static void do_flush(void *p_dev)
{
struct graphics_device *dev = (struct graphics_device *)p_dev;
LinksView *v = lv(dev);
v->win->Lock();
v->win->Flush();
v->win->Unlock();
v->flushing = 0;
}
LinksView::LinksView(LinksWindow *w):BView(w->Bounds(), "Links", B_FOLLOW_ALL, B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE | B_NAVIGABLE)
{
DBG("LINKSVIEW\n");
(win = w)->AddChild(this);
SetViewColor(B_TRANSPARENT_32_BIT);
MakeFocus();
w->view = this;
flushing = 0;
last_x = last_y = 0;
last_buttons = 0;
}
LinksView::~LinksView()
{
win->view = NULL;
DBG("~LINKSVIEW\n");
}
void LinksView::d_flush()
{
if (flushing) return;
register_bottom_half(do_flush, this->dev);
flushing = 1;
}
static void be_get_event(void *dummy)
{
struct be_event *ev;
static char to_read[64];
int r;
BMessage *msg;
LinksView *view;
LinksWindow *win;
struct graphics_device *dev;
EINTRLOOP(r, read(rpipe, to_read, sizeof to_read));
test_another_message:
message_queue_lock.Lock();
ev = NULL;
if (!list_empty(be_message_queue)) {
ev = list_struct(be_message_queue.next, struct be_event);
del_from_list(ev);
}
message_queue_lock.Unlock();
if (!ev)
return;
msg = ev->msg;
dev = ev->dev;
view = lv(dev);
win = dynamic_cast<LinksWindow *>(view->Window());
switch (msg->what) {
case B_QUIT_REQUESTED: {
dev->keyboard_handler(dev, KBD_CTRL_C, 0);
break;
}
case _UPDATE_: {
/*DBG("paint: %d %d %d %d\n", rr.x1, rr.x2, rr.y1, rr.y2);*/
struct rect rr;
int resized;
message_queue_lock.Lock();
rr = win->update_rect;
win->update_rect.x1 =
win->update_rect.x2 =
win->update_rect.y1 =
win->update_rect.y2 = 0;
resized = win->resized;
win->resized = 0;
message_queue_lock.Unlock();
if (!resized) {
if (is_rect_valid(&rr))
dev->redraw_handler(dev, &rr);
} else {
be_get_size(dev);
dev->resize_handler(dev);
}
break;
}
case B_MOUSE_DOWN: {
BPoint where;
int32 buttons;
int btn = B_LEFT;
if (msg->FindInt32("buttons", &buttons) != B_OK)
return;
if (msg->FindPoint("where", &where) != B_OK)
return;
if (view) view->last_buttons = buttons;
if (buttons & B_PRIMARY_MOUSE_BUTTON)
btn = B_LEFT;
else if (buttons & B_SECONDARY_MOUSE_BUTTON)
btn = B_RIGHT;
else if (buttons & B_TERTIARY_MOUSE_BUTTON)
btn = B_MIDDLE;
else if (buttons & (B_TERTIARY_MOUSE_BUTTON << 1))
btn = B_FOURTH;
else if (buttons & (B_TERTIARY_MOUSE_BUTTON << 2))
btn = B_FIFTH;
else if (buttons & (B_TERTIARY_MOUSE_BUTTON << 3))
btn = B_SIXTH;
dev->mouse_handler(dev, view->last_x = (int)where.x, view->last_y = (int)where.y, B_DOWN | btn);
break;
}
case B_MOUSE_UP: {
BPoint where;
int32 buttons;
int btn;
if (msg->FindInt32("buttons", &buttons) != B_OK)
return;
if (msg->FindPoint("where", &where) != B_OK)
return;
btn = B_LEFT;
if (view->last_buttons & ~buttons & B_PRIMARY_MOUSE_BUTTON)
btn = B_LEFT;
else if (view->last_buttons & ~buttons & B_SECONDARY_MOUSE_BUTTON)
btn = B_RIGHT;
else if (view->last_buttons & ~buttons & B_TERTIARY_MOUSE_BUTTON)
btn = B_MIDDLE;
else if (view->last_buttons & ~buttons & (B_TERTIARY_MOUSE_BUTTON << 1))
btn = B_FOURTH;
else if (view->last_buttons & ~buttons & (B_TERTIARY_MOUSE_BUTTON << 2))
btn = B_FIFTH;
else if (view->last_buttons & ~buttons & (B_TERTIARY_MOUSE_BUTTON << 3))
btn = B_SIXTH;
view->last_buttons = buttons;
dev->mouse_handler(dev, view->last_x = (int)where.x, view->last_y = (int)where.y, B_UP | btn);
break;
}
case B_MOUSE_MOVED: {
BPoint where;
int32 buttons;
int btn = B_LEFT;
if (msg->FindInt32("buttons", &buttons) != B_OK)
return;
if (msg->FindPoint("where", &where) != B_OK)
return;
if (buttons & B_PRIMARY_MOUSE_BUTTON)
btn = B_LEFT;
else if (buttons & B_SECONDARY_MOUSE_BUTTON)
btn = B_RIGHT;
else if (buttons & B_TERTIARY_MOUSE_BUTTON)
btn = B_MIDDLE;
else if (buttons & (B_TERTIARY_MOUSE_BUTTON << 1))
btn = B_FOURTH;
else if (buttons & (B_TERTIARY_MOUSE_BUTTON << 2))
btn = B_FIFTH;
else if (buttons & (B_TERTIARY_MOUSE_BUTTON << 3))
btn = B_SIXTH;
dev->mouse_handler(dev, view->last_x = (int)where.x, view->last_y = (int)where.y, !buttons ? B_MOVE : B_DRAG | btn);
break;
}
case B_KEY_DOWN: {
int32 modifiers;
const char *bytes;
int c;
int mods = 0;
if (msg->FindInt32("modifiers", &modifiers) != B_OK)
return;
if (msg->FindString("bytes", &bytes) != B_OK)
return;
unsigned char buf[4] = { 0, 0, 0, 0 };
unsigned char *ss;
/*fprintf(stderr, "bytes '%s' %x %x, modifiers '%x'\n", bytes, bytes[0], bytes[1], modifiers);*/
if (modifiers & (B_LEFT_CONTROL_KEY | B_RIGHT_CONTROL_KEY | B_LEFT_COMMAND_KEY | B_RIGHT_COMMAND_KEY)) {
int32 raw;
if (msg->FindInt32("raw_char", &raw) != B_OK)
return;
buf[0] = (unsigned char)raw;
ss = buf;
} else {
ss = (unsigned char *)bytes;
}
GET_UTF_8(ss, c);
switch (c) {
case B_BACKSPACE: c = KBD_BS; break;
case B_ENTER: c = KBD_ENTER; break;
case B_SPACE: c = ' '; break;
case B_TAB: c = KBD_TAB; break;
case B_ESCAPE: c = KBD_ESC; break;
case B_LEFT_ARROW: c = KBD_LEFT; break;
case B_RIGHT_ARROW: c = KBD_RIGHT; break;
case B_UP_ARROW: c = KBD_UP; break;
case B_DOWN_ARROW: c = KBD_DOWN; break;
case B_INSERT: c = KBD_INS; break;
case B_DELETE: c = KBD_DEL; break;
case B_HOME: c = KBD_HOME; break;
case B_END: c = KBD_END; break;
case B_PAGE_UP: c = KBD_PAGE_UP; break;
case B_PAGE_DOWN: c = KBD_PAGE_DOWN; break;
case B_FUNCTION_KEY: {
int32 fn;
if (msg->FindInt32("key", &fn) != B_OK)
goto def;
if (fn >= B_F1_KEY && fn <= B_F12_KEY) {
c = KBD_F1 - (fn - B_F1_KEY);
break;
}
goto def;
}
default:
def:
if (c < 32)
c = 0;
else modifiers &= ~(B_LEFT_SHIFT_KEY|B_RIGHT_SHIFT_KEY);
break;
}
if (modifiers & (B_LEFT_SHIFT_KEY|B_RIGHT_SHIFT_KEY))
mods |= KBD_SHIFT;
if (modifiers & (B_LEFT_CONTROL_KEY|B_RIGHT_CONTROL_KEY))
mods |= KBD_CTRL;
if (modifiers & (B_LEFT_COMMAND_KEY|B_RIGHT_COMMAND_KEY))
mods |= KBD_ALT;
if (c) dev->keyboard_handler(dev, c, mods);
break;
}
case B_COPY: {
dev->keyboard_handler(dev, KBD_COPY, 0);
break;
}
case B_CUT: {
dev->keyboard_handler(dev, KBD_CUT, 0);
break;
}
case B_PASTE: {
dev->keyboard_handler(dev, KBD_PASTE, 0);
break;
}
case B_MOUSE_WHEEL_CHANGED: {
float delta_x, delta_y;
if (msg->FindFloat("be:wheel_delta_x", &delta_x) != B_OK)
delta_x = 0;
if (msg->FindFloat("be:wheel_delta_y", &delta_y) != B_OK)
delta_y = 0;
if (delta_y) dev->mouse_handler(dev, view->last_x, view->last_y, B_MOVE | (delta_y > 0 ? B_WHEELDOWN : B_WHEELUP));
if (delta_x) dev->mouse_handler(dev, view->last_x, view->last_y, B_MOVE | (delta_x < 0 ? B_WHEELLEFT : B_WHEELRIGHT));
break;
}
case B_SIMPLE_DATA: {
entry_ref ref;
unsigned char *string = NULL;
const unsigned char *text_plain;
ssize_t len;
if (msg->FindRef("refs", &ref) == B_OK) {
BPath path(&ref);
if (path.InitCheck() == B_OK) {
BFile f(path.Path(), B_READ_ONLY);
BString url;
if (f.InitCheck() == B_OK && f.ReadAttrString("META:url", &url) >= B_OK) {
string = stracpy((const unsigned char *)url.String());
} else {
unsigned char str[3072];
int r;
string = stracpy((const unsigned char *)"file://");
EINTRLOOP(r, readlink(path.Path(), (char *)str, sizeof(str)));
if (r < 0 || r >= (int)sizeof(str)) {
add_to_strn(&string, (unsigned char *)path.Path());
} else if (str[0] == '/') {
add_to_strn(&string, str);
} else {
unsigned char *rch;
add_to_strn(&string, (unsigned char *)path.Path());
rch = (unsigned char *)strrchr((const char *)string, '/');
if (rch)
rch[1] = 0;
add_to_strn(&string, str);
}
}
}
} else if (msg->FindData("text/plain", B_MIME_TYPE, (const void **)&text_plain, &len) == B_OK) {
string = memacpy(text_plain, len);
}
if (string) {
dev->extra_handler(dev, EV_EXTRA_OPEN_URL, string);
mem_free(string);
}
break;
}
case B_MIME_DATA: {
const unsigned char *text_plain;
ssize_t len;
if (msg->FindData("text/plain", B_MIME_TYPE, (const void **)&text_plain, &len) == B_OK) {
unsigned char *string = memacpy(text_plain, len);
dev->extra_handler(dev, EV_EXTRA_OPEN_URL, string);
mem_free(string);
}
break;
}
default: {
msg->PrintToStream();
break;
}
}
free(ev);
delete msg;
goto test_another_message;
}
static void be_get_size(struct graphics_device *dev)
{
BRect r;
lock_dev(dev);
r = lv(dev)->Bounds();
unlock_dev(dev);
dev->size.x1 = dev->size.y1 = 0;
dev->size.x2 = (int)r.Width() + 1;
dev->size.y2 = (int)r.Height() + 1;
}
void LinksView::Draw(BRect r)
{
struct rect rr;
rr.x1 = (int)r.left;
rr.x2 = (int)r.right + 1;
rr.y1 = (int)r.top;
rr.y2 = (int)r.bottom + 1;
message_queue_lock.Lock();
if (dev)
unite_rect(&lv(dev)->win->update_rect, &lv(dev)->win->update_rect, &rr);
message_queue_lock.Unlock();
detach_and_pipe_message(dev);
}
void LinksView::MouseDown(BPoint p)
{
SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
detach_and_pipe_message(dev);
}
void LinksView::MouseUp(BPoint p)
{
detach_and_pipe_message(dev);
}
void LinksView::MouseMoved(BPoint p, uint32 transit, const BMessage *dragmsg)
{
message_queue_lock.Lock();
if (!list_empty(be_message_queue)) {
struct be_event *ev = list_struct(be_message_queue.prev, struct be_event);
if (ev->msg->what == B_MOUSE_MOVED) {
del_from_list(ev);
delete ev->msg;
free(ev);
}
}
message_queue_lock.Unlock();
detach_and_pipe_message(dev);
}
void LinksView::MessageReceived(BMessage *msg)
{
switch (msg->what) {
case B_MOUSE_WHEEL_CHANGED:
case B_COPY:
case B_CUT:
case B_PASTE:
case B_SIMPLE_DATA:
case B_MIME_DATA:
detach_and_pipe_message(dev);
break;
default:
//BView::MessageReceived(msg);
break;
}
}
void LinksView::KeyDown(const char *s, int32 numBytes)
{
detach_and_pipe_message(dev);
}
static int32 be_app_thread(void *p)
{
be_links_app->Lock();
be_links_app->Run();
delete be_links_app;
return 0;
}
static unsigned char *be_init_driver(unsigned char *param, unsigned char *display)
{
init_list(be_message_queue);
be_links_app = new LinksApplication();
if (!be_links_app) {
return stracpy((unsigned char *)"Unable to allocate Application object.\n");
}
if (c_pipe(msg_pipe)) {
delete be_links_app;
return stracpy((unsigned char *)"Could not create pipe.\n");
}
set_nonblock(rpipe);
set_nonblock(wpipe);
set_handlers(rpipe, be_get_event, NULL, NULL);
be_app_thread_id = spawn_thread(be_app_thread, "links_app", B_NORMAL_PRIORITY, NULL);
resume_thread(be_app_thread_id);
be_links_app->Unlock();
be_cs_desktop = B_NO_COLOR_SPACE;
be_x_size = 640;
be_y_size = 480;
BScreen d;
if (d.IsValid()) {
be_cs_desktop = d.ColorSpace();
be_x_size = (int)d.Frame().Width() + 1;
be_y_size = (int)d.Frame().Height() + 1;
}
be_win_y_size = be_y_size * 9 / 10;
be_win_x_size = be_win_y_size;
/*
DBG("%d %d\n", be_x_size, be_y_size);
DBG("%d %d\n", be_win_x_size, be_win_y_size);
*/
be_win_y_pos = (be_y_size - be_win_y_size) / 2;
be_win_x_pos = be_x_size - be_win_x_size - be_win_y_pos;
/*debug("depth: %d %d %d %d %d", be_cs_desktop, B_RGB15, B_RGB16, B_RGB24, B_RGB32);*/
be_cs_bmp = be_cs_desktop;
/* - BeOS doesn't handle BView::DrawBitmap() with RGB24 */
switch (be_cs_bmp) {
case B_RGB32:
haiku_driver.depth = 0xc4;
break;
case B_RGB16:
haiku_driver.depth = 0x82;
break;
case B_RGB15:
haiku_driver.depth = 0x7a;
break;
default:
be_cs_bmp = B_RGB32;
haiku_driver.depth = 0xc4;
break;
}
return NULL;
}
static void be_shutdown_driver()
{
status_t ret;
int r;
//debug((unsigned char *)"D");
//debug((unsigned char *)"DD");
be_links_app->PostMessage(_QUIT_);
//debug((unsigned char *)"E");
wait_for_thread(be_app_thread_id, &ret);
//debug((unsigned char *)"F");
set_handlers(rpipe, NULL, NULL, NULL);
EINTRLOOP(r, close(rpipe));
EINTRLOOP(r, close(wpipe));
}
static struct graphics_device *be_init_device()
{
LinksView *view;
LinksWindow *win;
struct graphics_device *dev = (struct graphics_device *)mem_calloc(sizeof(struct graphics_device));
//debug((unsigned char *)"1");
win = new LinksWindow(BRect(be_win_x_pos, be_win_y_pos, be_win_x_pos + be_win_x_size, be_win_y_pos + be_win_y_size));
be_win_x_pos += 28;
if (be_win_x_pos + be_win_x_size > be_x_size)
be_win_x_pos = 5;
be_win_y_pos += 28;
if (be_win_y_pos + be_win_y_size > be_y_size)
be_win_y_pos = 29;
//debug((unsigned char *)"2");
if (!win) {
mem_free(dev);
return NULL;
}
//debug((unsigned char *)"3");
view = new LinksView(win);
if (!view) {
delete win;
mem_free(dev);
return NULL;
}
view->dev = dev;
dev->driver_data = view;
be_get_size(dev);
memcpy(&dev->clip, &dev->size, sizeof(struct rect));
//debug((unsigned char *)"4");
win->Show();
win->Lock();
view->MakeFocus();
win->Unlock();
//debug((unsigned char *)"5");
return dev;
}
static void be_shutdown_device(struct graphics_device *dev)
{
struct be_event *ev;
struct list_head *lev;
LinksWindow *win = lv(dev)->win;
unregister_bottom_half(do_flush, dev);
message_queue_lock.Lock();
lv(dev)->dev = NULL;
foreachback(struct be_event, ev, lev, be_message_queue) {
if (ev->dev == dev) {
lev = lev->next;
del_from_list(ev);
delete ev->msg;
free(ev);
}
}
message_queue_lock.Unlock();
win->PostMessage(_QUIT_);
mem_free(dev);
}
static unsigned char *be_get_af_unix_name(void)
{
return cast_uchar "";
}
static void be_set_title(struct graphics_device *dev, unsigned char *title)
{
LinksWindow *win = lv(dev)->win;
lock_dev(dev);
win->SetTitle((const char *)title);
lv(dev)->d_flush();
unlock_dev(dev);
}
static int be_get_empty_bitmap(struct bitmap *bmp)
{
bmp->data = NULL;
bmp->flags = NULL;
DBG("bmp\n");
//DBG("bmp (%d, %d) cs %08x\n", bmp->x, bmp->y, be_cs_bmp);
BRect r(0, 0, bmp->x - 1, bmp->y - 1);
retry:
BBitmap *b = new BBitmap(r, /*B_RGB32*/be_cs_bmp);
if (!b) {
if (out_of_memory(0, NULL, 0))
goto retry;
DBG("%s: error 1\n", __FUNCTION__);
return -1;
}
if (!b->IsValid()) {
delete b;
DBG("%s: error 2\n", __FUNCTION__);
return -1;
}
if (b->LockBits() < B_OK) {
delete b;
DBG("%s: error 3\n", __FUNCTION__);
return -1;
}
bmp->data = b->Bits();
bmp->skip = b->BytesPerRow();
bmp->flags = b;
//DBG("bmp: data %p, skip %d, flags %p\n", bmp->data, bmp->skip, bmp->flags);
return 0;
}
static void be_register_bitmap(struct bitmap *bmp)
{
BBitmap *b = (BBitmap *)bmp->flags;
if (b)
b->UnlockBits();
}
static void *be_prepare_strip(struct bitmap *bmp, int top, int lines)
{
DBG("preps\n");
BBitmap *b = (BBitmap *)bmp->flags;
if (!b)
return NULL;
if (b->LockBits() < B_OK)
return NULL;
bmp->data = b->Bits();
bmp->skip = b->BytesPerRow();
return ((char *)bmp->data) + bmp->skip * top;
}
static void be_commit_strip(struct bitmap *bmp, int top, int lines)
{
BBitmap *b = (BBitmap *)bmp->flags;
if (!b)
return;
b->UnlockBits();
}
static void be_unregister_bitmap(struct bitmap *bmp)
{
DBG("unb\n");
BBitmap *b = (BBitmap *)bmp->flags;
if (!b)
return;
delete b;
}
static void be_draw_bitmap(struct graphics_device *dev, struct bitmap *bmp, int x, int y)
{
DBG("drawb\n");
BBitmap *b = (BBitmap *)bmp->flags;
if (!b)
return;
CLIP_DRAW_BITMAP
lock_dev(dev);
lv(dev)->DrawBitmap(b, b->Bounds(), BRect(x, y, x + bmp->x - 1, y + bmp->y - 1));
lv(dev)->d_flush();
unlock_dev(dev);
}
static long be_get_color(int rgb)
{
if (small_color) {
get_color32(c, rgb);
return *(long *)(void *)&c;
} else return rgb & 0xffffff;
}
static void *color2void(long *color)
{
return (void *)color;
}
static void be_fill_area(struct graphics_device *dev, int x1, int y1, int x2, int y2, long color)
{
DBG("fill\n");
CLIP_FILL_AREA
lock_dev(dev);
if (small_color)
lv(dev)->SetHighColor(*(rgb_color *)color2void(&color));
else
lv(dev)->SetHighColor(get_color32(, color));
lv(dev)->FillRect(BRect(x1, y1, x2 - 1, y2 - 1));
lv(dev)->d_flush();
unlock_dev(dev);
}
static void be_draw_hline(struct graphics_device *dev, int x1, int y, int x2, long color)
{
DBG("hline\n");
CLIP_DRAW_HLINE
lock_dev(dev);
if (small_color)
lv(dev)->SetHighColor(*(rgb_color *)color2void(&color));
else
lv(dev)->SetHighColor(get_color32(, color));
lv(dev)->StrokeLine(BPoint(x1, y), BPoint(x2 - 1, y));
lv(dev)->d_flush();
unlock_dev(dev);
}
static void be_draw_vline(struct graphics_device *dev, int x, int y1, int y2, long color)
{
DBG("vline\n");
CLIP_DRAW_VLINE
lock_dev(dev);
if (small_color)
lv(dev)->SetHighColor(*(rgb_color *)color2void(&color));
else
lv(dev)->SetHighColor(get_color32(, color));
lv(dev)->StrokeLine(BPoint(x, y1), BPoint(x, y2 - 1));
lv(dev)->d_flush();
unlock_dev(dev);
}
static void be_scroll_redraws(struct graphics_device *dev, struct rect *r, int scx, int scy)
{
struct rect *e = &lv(dev)->win->update_rect;
if (!is_rect_valid(e))
return;
if (scx >= 0) {
if (e->x2 > r->x1 && e->x2 < r->x2) {
e->x2 += scx;
if (e->x2 > r->x2) e->x2 = r->x2;
}
} else {
if (e->x1 > r->x1 && e->x1 < r->x2) {
e->x1 += scx;
if (e->x1 < r->x1) e->x1 = r->x1;
}
}
if (scy >= 0) {
if (e->y2 > r->y1 && e->y2 < r->y2) {
e->y2 += scy;
if (e->y2 > r->y2) e->y2 = r->y2;
}
} else {
if (e->y1 > r->y1 && e->y1 < r->y2) {
e->y1 += scy;
if (e->y1 < r->y1) e->y1 = r->y1;
}
}
}
static int be_scroll(struct graphics_device *dev, struct rect_set **ignore, int scx, int scy)
{
DBG("scroll\n");
lock_dev0(dev);
lv(dev)->CopyBits(
BRect( dev->clip.x1 - (scx < 0 ? scx : 0),
dev->clip.y1 - (scy < 0 ? scy : 0),
dev->clip.x2 - (scx >= 0 ? scx : 0) - 1,
dev->clip.y2 - (scy >= 0 ? scy : 0) - 1),
BRect( dev->clip.x1 + (scx >= 0 ? scx : 0),
dev->clip.y1 + (scy >= 0 ? scy : 0),
dev->clip.x2 + (scx < 0 ? scx : 0) - 1,
dev->clip.y2 + (scy < 0 ? scy : 0) - 1)
);
lv(dev)->d_flush();
be_scroll_redraws(dev, &dev->clip, scx, scy);
unlock_dev(dev);
return 1;
}
static void be_set_clip_area(struct graphics_device *dev)
{
DBG("setc\n");
lock_dev(dev);
BRegion clip(BRect(dev->clip.x1, dev->clip.y1, dev->clip.x2 - 1, dev->clip.y2 - 1));
lv(dev)->ConstrainClippingRegion(&clip);
unlock_dev(dev);
}
static void be_flush(struct graphics_device *dev)
{
unregister_bottom_half(do_flush, dev);
do_flush(dev);
}
static unsigned char *be_get_clipboard_text(void)
{
unsigned char *ret = NULL;
if (be_clipboard->Lock()) {
BMessage *data = be_clipboard->Data();
if (data) {
const char *text_plain;
ssize_t len;
if (data->FindData("text/plain", B_MIME_TYPE, (const void **)&text_plain, &len) == B_OK) {
ret = memacpy((unsigned char *)text_plain, len);
}
}
be_clipboard->Unlock();
}
return ret;
}
static void be_set_clipboard_text(struct graphics_device *dev, unsigned char *text)
{
if (be_clipboard->Lock()) {
be_clipboard->Clear();
BMessage* data = be_clipboard->Data();
if (data) {
data->AddData("text/plain", B_MIME_TYPE, (const char *)text, strlen((const char *)text));
be_clipboard->Commit();
}
be_clipboard->Unlock();
}
}
struct graphics_driver haiku_driver = {
(unsigned char *)"haiku",
be_init_driver,
be_init_device,
be_shutdown_device,
be_shutdown_driver,
NULL,
NULL,
NULL,
be_get_af_unix_name,
NULL,
NULL,
be_get_empty_bitmap,
be_register_bitmap,
be_prepare_strip,
be_commit_strip,
be_unregister_bitmap,
be_draw_bitmap,
be_get_color,
be_fill_area,
be_draw_hline,
be_draw_vline,
be_scroll,
be_set_clip_area,
be_flush,
NULL, /* block */
NULL, /* unblock */
NULL, /* set_palette */
NULL, /* get_real_colors */
be_set_title,
x_exec, /* exec */
be_set_clipboard_text, /* set_clipboard_text */
be_get_clipboard_text, /* get_clipboard_text */
0, /* depth */
0, 0, /* size */
GD_UNICODE_KEYS, /* flags */
NULL, /* param */
};
#endif /* GRDRV_HAIKU */
Reference in New Issue View Git Blame Copy Permalink