src/gui_beos.cc

/* vi:set ts=8 sts=4 sw=4:
 *
 * VIM - Vi IMproved			by Bram Moolenaar
 *			    BeBox GUI support Copyright 1998 by Olaf Seibert.
 *			    All Rights Reserved.
 *
 * Do ":help uganda"  in Vim to read copying and usage conditions.
 * Do ":help credits" in Vim to see a list of people who contributed.
 *
 * BeOS GUI.
 *
 * GUI support for the Buzzword Enhanced Operating System.
 *
 * Ported to R4 by Richard Offer <richard@whitequeen.com> Jul 99
 *
 */

/*
 * Structure of the BeOS GUI code:
 *
 * There are 3 threads.
 * 1. The initial thread. In gui_mch_prepare() this gets to run the
 *    BApplication message loop. But before it starts doing that,
 *    it creates thread 2:
 * 2. The main() thread. This thread is created in gui_mch_prepare()
 *    and its purpose in life is to call main(argc, argv) again.
 *    This thread is doing the bulk of the work.
 * 3. Sooner or later, a window is opened by the main() thread. This
 *    causes a second message loop to be created: the window thread.
 *
 * == alternatively ===
 *
 * #if RUN_BAPPLICATION_IN_NEW_THREAD...
 *
 * 1. The initial thread. In gui_mch_prepare() this gets to spawn
 *    thread 2. After doing that, it returns to main() to do the
 *    bulk of the work, being the main() thread.
 * 2. Runs the BApplication.
 * 3. The window thread, just like in the first case.
 *
 * This second alternative is cleaner from Vim's viewpoint. However,
 * the BeBook seems to assume everywhere that the BApplication *must*
 * run in the initial thread. So perhaps doing otherwise is very wrong.
 *
 * However, from a B_SINGLE_LAUNCH viewpoint, the first is better.
 * If Vim is marked "Single Launch" in its application resources,
 * and a file is dropped on the Vim icon, and another Vim is already
 * running, the file is passed on to the earlier Vim. This happens
 * in BApplication::Run(). So we want Vim to terminate if
 * BApplication::Run() terminates. (See the BeBook, on BApplication.
 * However, it seems that the second copy of Vim isn't even started
 * in this case... which is for the better since I wouldn't know how
 * to detect this case.)
 *
 * Communication between these threads occurs mostly by translating
 * BMessages that come in and posting an appropriate translation on
 * the VDCMP (Vim Direct Communication Message Port). Therefore the
 * actions required for keypresses and window resizes, etc, are mostly
 * performed in the main() thread.
 *
 * A notable exception to this is the Draw() event. The redrawing of
 * the window contents is performed asynchronously from the window
 * thread. To make this work correctly, a locking protocol is used when
 * any thread is accessing the essential variables that are used by
 * the window thread.
 *
 * This locking protocol consists of locking Vim's window. This is both
 * convenient and necessary.
 */
extern "C" {

#define new		xxx_new_xxx

#include <float.h>
#include <assert.h>
#include "vim.h"
#include "globals.h"
#include "proto.h"
#include "option.h"

#undef new

}	/* extern "C" */

/* ---------------- start of header part ---------------- */

#include <be/app/MessageQueue.h>
#include <be/app/Clipboard.h>
#include <be/kernel/OS.h>
#include <be/support/Beep.h>
#include <be/interface/View.h>
#include <be/interface/Window.h>
#include <be/interface/MenuBar.h>
#include <be/interface/MenuItem.h>
#include <be/interface/ScrollBar.h>
#include <be/interface/Region.h>
#include <be/interface/Screen.h>
#include <be/storage/Path.h>
#include <be/storage/Directory.h>
#include <be/storage/Entry.h>
#include <be/app/Application.h>
#include <be/support/Debug.h>

/*
 * The macro B_PIXEL_ALIGNMENT shows us which version
 * of the header files we're using.
 */
#if defined(B_PIXEL_ALIGNMENT)
#define HAVE_R3_OR_LATER    1
#else
#define HAVE_R3_OR_LATER    0
#endif

class VimApp;
class VimFormView;
class VimTextAreaView;
class VimWindow;

extern key_map *keyMap;
extern char *keyMapChars;

extern int main(int argc, char **argv);

#ifndef B_MAX_PORT_COUNT
#define B_MAX_PORT_COUNT    100
#endif

/*
 * VimApp seems comparable to the X "vimShell"
 */
class VimApp: public BApplication
{
    typedef BApplication Inherited;
public:
    VimApp(const char *appsig);
    ~VimApp();

    // callbacks:
#if 0
    virtual void DispatchMessage(BMessage *m, BHandler *h)
    {
	m->PrintToStream();
	Inherited::DispatchMessage(m, h);
    }
#endif
    virtual void ReadyToRun();
    virtual void ArgvReceived(int32 argc, char **argv);
    virtual void RefsReceived(BMessage *m);
    virtual bool QuitRequested();

    static void SendRefs(BMessage *m, bool changedir);
private:
};

class VimWindow: public BWindow
{
    typedef BWindow Inherited;
public:
    VimWindow();
    ~VimWindow();

    virtual void DispatchMessage(BMessage *m, BHandler *h);
    virtual void WindowActivated(bool active);
    virtual bool QuitRequested();

    VimFormView		*formView;

private:
    void init();

};

class VimFormView: public BView
{
    typedef BView Inherited;
public:
    VimFormView(BRect frame);
    ~VimFormView();

    // callbacks:
    virtual void AllAttached();
    virtual void FrameResized(float new_width, float new_height);

#define MENUBAR_MARGIN	1
    float MenuHeight() const
	{ return menuBar ? menuBar->Frame().Height() + MENUBAR_MARGIN: 0; }
    BMenuBar *MenuBar() const
	{ return menuBar; }

private:
    void init(BRect);

    BMenuBar		*menuBar;
    VimTextAreaView	*textArea;
};

class VimTextAreaView: public BView
{
    typedef BView Inherited;
public:
    VimTextAreaView(BRect frame);
    ~VimTextAreaView();

    // callbacks:
    virtual void Draw(BRect updateRect);
    virtual void KeyDown(const char *bytes, int32 numBytes);
    virtual void MouseDown(BPoint point);
    virtual void MouseUp(BPoint point);
    virtual void MouseMoved(BPoint point, uint32 transit, const BMessage *message);
    virtual void MessageReceived(BMessage *m);

    // own functions:
    int mchInitFont(char_u *name);
    void mchDrawString(int row, int col, char_u *s, int len, int flags);
    void mchClearBlock(int row1, int col1, int row2, int col2);
    void mchClearAll();
    void mchDeleteLines(int row, int num_lines);
    void mchInsertLines(int row, int num_lines);

    static void guiSendMouseEvent(int button, int x, int y, int repeated_click, int_u modifiers);
    static void guiBlankMouse(bool should_hide);
    static int_u mouseModifiersToVim(int32 beModifiers);

    int32 mouseDragEventCount;

private:
    void init(BRect);

    int_u	    vimMouseButton;
    int_u	    vimMouseModifiers;
};

class VimScrollBar: public BScrollBar
{
    typedef BScrollBar Inherited;
public:
    VimScrollBar(scrollbar_T *gsb, orientation posture);
    ~VimScrollBar();

    virtual void ValueChanged(float newValue);
    virtual void MouseUp(BPoint where);
    void SetValue(float newval);
    scrollbar_T *getGsb()
	{ return gsb; }

    int32	    scrollEventCount;

private:
    scrollbar_T *gsb;
    float	ignoreValue;
};


/*
 * For caching the fonts that are used;
 * Vim seems rather sloppy in this regard.
 */
class VimFont: public BFont
{
    typedef BFont Inherited;
public:
    VimFont();
    VimFont(const VimFont *rhs);
    VimFont(const BFont *rhs);
    VimFont(const VimFont &rhs);
    ~VimFont();

    VimFont *next;
    int refcount;
    char_u *name;

private:
    void init();
};

/* ---------------- end of GUI classes ---------------- */

struct MainArgs {
    int		 argc;
    char	**argv;
};

/*
 * These messages are copied through the VDCMP.
 * Therefore they ought not to have anything fancy.
 * They must be of POD type (Plain Old Data)
 * as the C++ standard calls them.
 */

#define	KEY_MSG_BUFSIZ	7
#if KEY_MSG_BUFSIZ < MAX_KEY_CODE_LEN
#error Increase KEY_MSG_BUFSIZ!
#endif

struct VimKeyMsg {
    char_u	length;
    char_u	chars[KEY_MSG_BUFSIZ];	/* contains Vim encoding */
};

struct VimResizeMsg {
    int		width;
    int		height;
};

struct VimScrollBarMsg {
    VimScrollBar *sb;
    long	value;
    int		stillDragging;
};

struct VimMenuMsg {
    vimmenu_T	*guiMenu;
};

struct VimMouseMsg {
    int		button;
    int		x;
    int		y;
    int		repeated_click;
    int_u	modifiers;
};

struct VimFocusMsg {
    bool	active;
};

struct VimRefsMsg {
    BMessage   *message;
    bool	changedir;
};

struct VimMsg {
    enum VimMsgType {
	Key, Resize, ScrollBar, Menu, Mouse, Focus, Refs
    };

    union {
	struct VimKeyMsg	Key;
	struct VimResizeMsg	NewSize;
	struct VimScrollBarMsg	Scroll;
	struct VimMenuMsg	Menu;
	struct VimMouseMsg	Mouse;
	struct VimFocusMsg	Focus;
	struct VimRefsMsg	Refs;
    } u;
};

#define RGB(r, g, b)	((char_u)(r) << 16 | (char_u)(g) << 8 | (char_u)(b) << 0)
#define GUI_TO_RGB(g)	{ (g) >> 16, (g) >> 8, (g) >> 0, 255 }

/* ---------------- end of header part ---------------- */

static struct specialkey
{
    uint16  BeKeys;
#define KEY(a,b)	((a)<<8|(b))
#define K(a)		KEY(0,a)		    // for ASCII codes
#define F(b)		KEY(1,b)		    // for scancodes
    char_u  vim_code0;
    char_u  vim_code1;
} special_keys[] =
{
    {K(B_UP_ARROW),	    'k', 'u'},
    {K(B_DOWN_ARROW),	    'k', 'd'},
    {K(B_LEFT_ARROW),	    'k', 'l'},
    {K(B_RIGHT_ARROW),	    'k', 'r'},
    {K(B_BACKSPACE),	    'k', 'b'},
    {K(B_INSERT),	    'k', 'I'},
    {K(B_DELETE),	    'k', 'D'},
    {K(B_HOME),		    'k', 'h'},
    {K(B_END),		    '@', '7'},
    {K(B_PAGE_UP),	    'k', 'P'},	    /* XK_Prior */
    {K(B_PAGE_DOWN),	    'k', 'N'},	    /* XK_Next, */

#define FIRST_FUNCTION_KEY  11
    {F(B_F1_KEY),	    'k', '1'},
    {F(B_F2_KEY),	    'k', '2'},
    {F(B_F3_KEY),	    'k', '3'},
    {F(B_F4_KEY),	    'k', '4'},
    {F(B_F5_KEY),	    'k', '5'},
    {F(B_F6_KEY),	    'k', '6'},
    {F(B_F7_KEY),	    'k', '7'},
    {F(B_F8_KEY),	    'k', '8'},
    {F(B_F9_KEY),	    'k', '9'},
    {F(B_F10_KEY),	    'k', ';'},

    {F(B_F11_KEY),	    'F', '1'},
    {F(B_F12_KEY),	    'F', '2'},
//  {XK_F13,		    'F', '3'},		/* would be print screen/ */
						/* sysreq */
    {F(0x0F),		    'F', '4'},		/* scroll lock */
    {F(0x10),		    'F', '5'},		/* pause/break */
//  {XK_F16,	    'F', '6'},
//  {XK_F17,	    'F', '7'},
//  {XK_F18,	    'F', '8'},
//  {XK_F19,	    'F', '9'},
//  {XK_F20,	    'F', 'A'},
//
//  {XK_F21,	    'F', 'B'},
//  {XK_F22,	    'F', 'C'},
//  {XK_F23,	    'F', 'D'},
//  {XK_F24,	    'F', 'E'},
//  {XK_F25,	    'F', 'F'},
//  {XK_F26,	    'F', 'G'},
//  {XK_F27,	    'F', 'H'},
//  {XK_F28,	    'F', 'I'},
//  {XK_F29,	    'F', 'J'},
//  {XK_F30,	    'F', 'K'},
//
//  {XK_F31,	    'F', 'L'},
//  {XK_F32,	    'F', 'M'},
//  {XK_F33,	    'F', 'N'},
//  {XK_F34,	    'F', 'O'},
//  {XK_F35,	    'F', 'P'},	    /* keysymdef.h defines up to F35 */

//  {XK_Help,	    '%', '1'},	    /* XK_Help */
    {F(B_PRINT_KEY),	    '%', '9'},

#if 0
    /* Keypad keys: */
    {F(0x48),	    'k', 'l'},	    /* XK_KP_Left */
    {F(0x4A),	    'k', 'r'},	    /* XK_KP_Right */
    {F(0x38),	    'k', 'u'},	    /* XK_KP_Up */
    {F(0x59),	    'k', 'd'},	    /* XK_KP_Down */
    {F(0x64),	    'k', 'I'},	    /* XK_KP_Insert */
    {F(0x65),	    'k', 'D'},	    /* XK_KP_Delete */
    {F(0x37),	    'k', 'h'},	    /* XK_KP_Home */
    {F(0x58),	    '@', '7'},	    /* XK_KP_End */
    {F(0x39),	    'k', 'P'},	    /* XK_KP_Prior */
    {F(0x60),	    'k', 'N'},	    /* XK_KP_Next */
    {F(0x49),	    '&', '8'},	    /* XK_Undo, keypad 5 */
#endif

    /* End of list marker: */
    {0,			    0, 0}
};

#define NUM_SPECIAL_KEYS    (sizeof(special_keys)/sizeof(special_keys[0]))

/* ---------------- VimApp ---------------- */

    static void
docd(BPath &path)
{
    mch_chdir(path.Path());
    /* Do this to get the side effects of a :cd command */
    do_cmdline_cmd((char_u *)"cd .");
}

/*
 * Really handle dropped files and folders.
 */
    static void
RefsReceived(BMessage *m, bool changedir)
{
    uint32 type;
    int32 count;

    //m->PrintToStream();
    switch (m->what) {
    case B_REFS_RECEIVED:
    case B_SIMPLE_DATA:
	m->GetInfo("refs", &type, &count);
	if (type != B_REF_TYPE)
	    goto bad;
	break;
    case B_ARGV_RECEIVED:
	m->GetInfo("argv", &type, &count);
	if (type != B_STRING_TYPE)
	    goto bad;
	if (changedir) {
	    char *dirname;
	    if (m->FindString("cwd", (const char **) &dirname) == B_OK) {
		chdir(dirname);
		do_cmdline_cmd((char_u *)"cd .");
	    }
	}
	break;
    default:
    bad:
	//fprintf(stderr, "bad!\n");
	delete m;
	return;
    }

#ifdef FEAT_VISUAL
    reset_VIsual();
#endif

    char_u  **fnames;
    fnames = (char_u **) alloc(count * sizeof(char_u *));
    int fname_index = 0;

    switch (m->what) {
    case B_REFS_RECEIVED:
    case B_SIMPLE_DATA:
	//fprintf(stderr, "case B_REFS_RECEIVED\n");
	for (int i = 0; i < count; ++i)
	{
	    entry_ref ref;
	    if (m->FindRef("refs", i, &ref) == B_OK) {
		BEntry entry(&ref, false);
		BPath path;
		entry.GetPath(&path);

		/* Change to parent directory? */
		if (changedir) {
		    BPath parentpath;
		    path.GetParent(&parentpath);
		    docd(parentpath);
		}

		/* Is it a directory? If so, cd into it. */
		BDirectory bdir(&ref);
		if (bdir.InitCheck() == B_OK) {
		    /* don't cd if we already did it */
		    if (!changedir)
			docd(path);
		} else {
		    mch_dirname(IObuff, IOSIZE);
		    char_u *fname = shorten_fname((char_u *)path.Path(), IObuff);
		    if (fname == NULL)
			fname = (char_u *)path.Path();
		    fnames[fname_index++] = vim_strsave(fname);
		    //fprintf(stderr, "%s\n", fname);
		}

		/* Only do it for the first file/dir */
		changedir = false;
	    }
	}
	break;
    case B_ARGV_RECEIVED:
	//fprintf(stderr, "case B_ARGV_RECEIVED\n");
	for (int i = 1; i < count; ++i)
	{
	    char *fname;

	    if (m->FindString("argv", i, (const char **) &fname) == B_OK) {
		fnames[fname_index++] = vim_strsave((char_u *)fname);
	    }
	}
	break;
    default:
	//fprintf(stderr, "case default\n");
	break;
    }

    delete m;

    /* Handle the drop, :edit to get to the file */
    if (fname_index > 0) {
	handle_drop(fname_index, fnames, FALSE);

	/* Update the screen display */
	update_screen(NOT_VALID);
	setcursor();
	out_flush();
    } else {
	vim_free(fnames);
    }
}

VimApp::VimApp(const char *appsig):
    BApplication(appsig)
{
}

VimApp::~VimApp()
{
}

    void
VimApp::ReadyToRun()
{
    /*
     * Apparently signals are inherited by the created thread -
     * disable the most annoying ones.
     */
    signal(SIGINT, SIG_IGN);
    signal(SIGQUIT, SIG_IGN);
}

    void
VimApp::ArgvReceived(int32 arg_argc, char **arg_argv)
{
    if (!IsLaunching()) {
	/*
	 * This can happen if we are set to Single or Exclusive
	 * Launch. Be nice and open the file(s).
	 */
	if (gui.vimWindow)
	    gui.vimWindow->Minimize(false);
	BMessage *m = CurrentMessage();
	DetachCurrentMessage();
	SendRefs(m, true);
    }
}

    void
VimApp::RefsReceived(BMessage *m)
{
    /* Horrible hack!!! XXX XXX XXX
     * The real problem is that b_start_ffc is set too late for
     * the initial empty buffer. As a result the window will be
     * split instead of abandoned.
     */
    int limit = 15;
    while (--limit >= 0 && (curbuf == NULL || curbuf->b_start_ffc == 0))
	snooze(100000);    // 0.1 s
    if (gui.vimWindow)
	gui.vimWindow->Minimize(false);
    DetachCurrentMessage();
    SendRefs(m, true);
}

/*
 * Pass a BMessage on to the main() thread.
 * Caller must have detached the message.
 */
    void
VimApp::SendRefs(BMessage *m, bool changedir)
{
    VimRefsMsg rm;
    rm.message = m;
    rm.changedir = changedir;

    write_port(gui.vdcmp, VimMsg::Refs, &rm, sizeof(rm));
    // calls ::RefsReceived
}

    bool
VimApp::QuitRequested()
{
    (void)Inherited::QuitRequested();
    return false;
}

/* ---------------- VimWindow ---------------- */

VimWindow::VimWindow():
    BWindow(BRect(40, 40, 150, 150),
	    "Vim",
	    B_TITLED_WINDOW,
	    0,
	    B_CURRENT_WORKSPACE)

{
    init();
}

VimWindow::~VimWindow()
{
    if (formView) {
	RemoveChild(formView);
	delete formView;
    }
    gui.vimWindow = NULL;
}

    void
VimWindow::init()
{
    /* Attach the VimFormView */
    formView = new VimFormView(Bounds());
    if (formView != NULL) {
	AddChild(formView);
    }
}

    void
VimWindow::DispatchMessage(BMessage *m, BHandler *h)
{
    /*
     * Route B_MOUSE_UP messages to MouseUp(), in
     * a manner that should be compatible with the
     * intended future system behaviour.
     */
    switch (m->what) {
    case B_MOUSE_UP:
	// if (!h) h = PreferredHandler();
// gcc isn't happy without this extra set of braces, complains about
// jump to case label crosses init of 'class BView * v'
// richard@whitequeen.com jul 99
	{
	BView *v = dynamic_cast<BView *>(h);
	if (v) {
	    //m->PrintToStream();
	    BPoint where;
	    m->FindPoint("where", &where);
	    v->MouseUp(where);
	} else {
	    Inherited::DispatchMessage(m, h);
	}
	}
	break;
    default:
	Inherited::DispatchMessage(m, h);
    }
}

    void
VimWindow::WindowActivated(bool active)
{
    Inherited::WindowActivated(active);
    /* the textArea gets the keyboard action */
    if (active && gui.vimTextArea)
	gui.vimTextArea->MakeFocus(true);

    struct VimFocusMsg fm;
    fm.active = active;

    write_port(gui.vdcmp, VimMsg::Focus, &fm, sizeof(fm));
}

    bool
VimWindow::QuitRequested()
{
    struct VimKeyMsg km;
    km.length = 5;
    memcpy((char *)km.chars, "\033:qa\r", km.length);

    write_port(gui.vdcmp, VimMsg::Key, &km, sizeof(km));

    return false;
}

/* ---------------- VimFormView ---------------- */

VimFormView::VimFormView(BRect frame):
    BView(frame, "VimFormView", B_FOLLOW_ALL_SIDES,
	    B_WILL_DRAW | B_FRAME_EVENTS),
    menuBar(NULL),
    textArea(NULL)
{
    init(frame);
}

VimFormView::~VimFormView()
{
    if (menuBar) {
	RemoveChild(menuBar);
#ifdef never
	// deleting the menuBar leads to SEGV on exit
	// richard@whitequeen.com Jul 99
	delete menuBar;
#endif
    }
    if (textArea) {
	RemoveChild(textArea);
	delete textArea;
    }
    gui.vimForm = NULL;
}

    void
VimFormView::init(BRect frame)
{
    menuBar = new BMenuBar(BRect(0,0,-MENUBAR_MARGIN,-MENUBAR_MARGIN),
	    "VimMenuBar");

    AddChild(menuBar);

    BRect remaining = frame;
    textArea = new VimTextAreaView(remaining);
    AddChild(textArea);
    /* The textArea will be resized later when menus are added */

    gui.vimForm = this;
}

    void
VimFormView::AllAttached()
{
    /*
     * Apparently signals are inherited by the created thread -
     * disable the most annoying ones.
     */
    signal(SIGINT, SIG_IGN);
    signal(SIGQUIT, SIG_IGN);

    if (menuBar && textArea) {
	/*
	 * Resize the textArea to fill the space left over by the menu.
	 * This is somewhat futile since it will be done again once
	 * menus are added to the menu bar.
	 */
	BRect remaining = Bounds();
	remaining.top = MenuHeight();
	textArea->ResizeTo(remaining.Width(), remaining.Height());
	textArea->MoveTo(remaining.left, remaining.top);

#ifdef FEAT_MENU
	menuBar->ResizeTo(remaining.right, remaining.top);
	gui.menu_height = (int) remaining.top;
#endif
    }
    Inherited::AllAttached();
}

    void
VimFormView::FrameResized(float new_width, float new_height)
{
    BWindow *w = Window();
#if 1
    /*
     * Look if there are more resize messages in the queue.
     * If so, ignore this one. The later one will be handled
     * eventually.
     */
    BMessageQueue *q = w->MessageQueue();
    if (q->FindMessage(B_VIEW_RESIZED, 0) != NULL) {
	return;
    }
#endif
    new_width += 1;	    // adjust from width to number of pixels occupied
    new_height += 1;

#if !HAVE_R3_OR_LATER
    int adjust_h, adjust_w;

    adjust_w = ((int)new_width - gui_get_base_width()) % gui.char_width;
    adjust_h = ((int)new_height - gui_get_base_height()) % gui.char_height;

    if (adjust_w > 0 || adjust_h > 0) {
	/*
	 * This will generate a new FrameResized() message.
	 * If we're running R3 or later, SetWindowAlignment() should make
	 * sure that this does not happen.
	 */
	w->ResizeBy(-adjust_w, -adjust_h);

	return;
    }
#endif

    struct VimResizeMsg sm;
    sm.width = (int) new_width;
    sm.height = (int) new_height;

    write_port(gui.vdcmp, VimMsg::Resize, &sm, sizeof(sm));
    // calls gui_resize_shell(new_width, new_height);

    return;

    /*
     * The area below the vertical scrollbar is erased to the colour
     * set with SetViewColor() automatically, because we had set
     * B_WILL_DRAW. Resizing the window tight around the vertical
     * scroll bar also helps to avoid debris.
     */
}

/* ---------------- VimTextAreaView ---------------- */

VimTextAreaView::VimTextAreaView(BRect frame):
    BView(frame, "VimTextAreaView", B_FOLLOW_ALL_SIDES,
	    B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE),
    mouseDragEventCount(0)
{
    init(frame);
}

VimTextAreaView::~VimTextAreaView()
{
    gui.vimTextArea = NULL;
}

    void
VimTextAreaView::init(BRect frame)
{
    /* set up global var for fast access */
    gui.vimTextArea = this;

    /*
     * Tell the app server not to erase the view: we will
     * fill it in completely by ourselves.
     * (Does this really work? Even if not, it won't harm either.)
     */
    SetViewColor(B_TRANSPARENT_32_BIT);
#define PEN_WIDTH   1
    SetPenSize(PEN_WIDTH);
}

    void
VimTextAreaView::Draw(BRect updateRect)
{
    /*
     * XXX Other ports call here:
     * out_flush();	     * make sure all output has been processed *
     * but we can't do that, since it involves too much information
     * that is owned by other threads...
     */

    /*
     *  No need to use gui.vimWindow->Lock(): we are locked already.
     *  However, it would not hurt.
     */
    gui_redraw((int) updateRect.left, (int) updateRect.top,
	    (int) (updateRect.Width() + PEN_WIDTH), (int) (updateRect.Height() + PEN_WIDTH));

    /* Clear the border areas if needed */
    rgb_color rgb = GUI_TO_RGB(gui.back_pixel);
    SetLowColor(rgb);

    if (updateRect.left < FILL_X(0))	// left border
	FillRect(BRect(updateRect.left, updateRect.top,
		       FILL_X(0)-PEN_WIDTH, updateRect.bottom), B_SOLID_LOW);
    if (updateRect.top < FILL_Y(0))	// top border
	FillRect(BRect(updateRect.left, updateRect.top,
		       updateRect.right, FILL_Y(0)-PEN_WIDTH), B_SOLID_LOW);
    if (updateRect.right >= FILL_X(Columns)) // right border
	FillRect(BRect(FILL_X((int)Columns), updateRect.top,
		       updateRect.right, updateRect.bottom), B_SOLID_LOW);
    if (updateRect.bottom >= FILL_Y(Rows))   // bottom border
	FillRect(BRect(updateRect.left, FILL_Y((int)Rows),
		       updateRect.right, updateRect.bottom), B_SOLID_LOW);
}

    void
VimTextAreaView::KeyDown(const char *bytes, int32 numBytes)
{
    struct VimKeyMsg km;
    char_u *dest = km.chars;

    BMessage *msg = Window()->CurrentMessage();
    assert(msg);
    //msg->PrintToStream();

    /*
     * Convert special keys to Vim codes.
     * I think it is better to do it in the window thread
     * so we use at least a little bit of the potential
     * of our 2 CPUs. Besides, due to the fantastic mapping
     * of special keys to UTF-8, we have quite some work to
     * do...
     * TODO: I'm not quite happy with detection of special
     * keys. Perhaps I should use scan codes after all...
     */
    if (numBytes > 1) {
	/* This cannot be a special key */
	if (numBytes > KEY_MSG_BUFSIZ)
	    numBytes = KEY_MSG_BUFSIZ;	    // should never happen... ???
	km.length = numBytes;
	memcpy((char *)dest, bytes, numBytes);
    } else {
	int32 scancode = 0;
	msg->FindInt32("key", &scancode);

	int32 beModifiers = 0;
	msg->FindInt32("modifiers", &beModifiers);

	char_u string[3];
	int len = 0;
	km.length = 0;

	bool canHaveVimModifiers = false;

	/*
	 * For normal, printable ASCII characters, don't look them up
	 * to check if they might be a special key. They aren't.
	 */
	assert(B_BACKSPACE <= 0x20);
	assert(B_DELETE == 0x7F);
	if (((char_u)bytes[0] <= 0x20 || (char_u)bytes[0] == 0x7F) &&
		numBytes == 1) {
	    /*
	     * Due to the great nature of Be's mapping of special keys,
	     * viz. into the range of the control characters,
	     * we can only be sure it is *really* a special key if
	     * if it is special without using ctrl. So, only if ctrl is
	     * used, we need to check it unmodified.
	     */
	    if (beModifiers & B_CONTROL_KEY) {
		int index = keyMap->normal_map[scancode];
		int newNumBytes = keyMapChars[index];
		char_u *newBytes = (char_u *)&keyMapChars[index + 1];

		/*
		 * Check if still special without the control key.
		 * This is needed for BACKSPACE: that key does produce
		 * different values with modifiers (DEL).
		 * Otherwise we could simply have checked for equality.
		 */
		if (newNumBytes != 1 || (*newBytes > 0x20 &&
					 *newBytes != 0x7F )) {
		    goto notspecial;
		}
		bytes = (char *)newBytes;
	    }
	    canHaveVimModifiers = true;

	    uint16 beoskey;
	    int first, last;

	    /*
	     * If numBytes == 0 that probably always indicates a special key.
	     * (does not happen yet)
	     */
	    if (numBytes == 0 || bytes[0] == B_FUNCTION_KEY) {
		beoskey = F(scancode);
		first = FIRST_FUNCTION_KEY;
		last = NUM_SPECIAL_KEYS;
	    } else if (*bytes == '\n' && scancode == 0x47) {
		 /* remap the (non-keypad) ENTER key from \n to \r. */
		string[0] = '\r';
		len = 1;
		first = last = 0;
	    } else {
		beoskey = K(bytes[0]);
		first = 0;
		last = FIRST_FUNCTION_KEY;
	    }

	    for (int i = first; i < last; i++) {
		if (special_keys[i].BeKeys == beoskey) {
		    string[0] = CSI;
		    string[1] = special_keys[i].vim_code0;
		    string[2] = special_keys[i].vim_code1;
		    len = 3;
		}
	    }
	}
    notspecial:
	if (len == 0) {
	    string[0] = bytes[0];
	    len = 1;
	}

	/* Special keys (and a few others) may have modifiers */
#if 0
	if (len == 3 ||
		bytes[0] == B_SPACE || bytes[0] == B_TAB ||
		bytes[0] == B_RETURN || bytes[0] == '\r' ||
		bytes[0] == B_ESCAPE)
#else
	if (canHaveVimModifiers)
#endif
	{
	    int modifiers;
	    modifiers = 0;
	    if (beModifiers & B_SHIFT_KEY)
		modifiers |= MOD_MASK_SHIFT;
	    if (beModifiers & B_CONTROL_KEY)
		modifiers |= MOD_MASK_CTRL;
	    if (beModifiers & B_OPTION_KEY)
		modifiers |= MOD_MASK_ALT;

	    /*
	     * For some keys a shift modifier is translated into another key
	     * code.  Do we need to handle the case where len != 1 and
	     * string[0] != CSI? (Not for BeOS, since len == 3 implies
	     * string[0] == CSI...)
	     */
	    int key;
	    if (string[0] == CSI && len == 3)
		key = TO_SPECIAL(string[1], string[2]);
	    else
		key = string[0];
	    key = simplify_key(key, &modifiers);
	    if (IS_SPECIAL(key))
	    {
		string[0] = CSI;
		string[1] = K_SECOND(key);
		string[2] = K_THIRD(key);
		len = 3;
	    }
	    else
	    {
		string[0] = key;
		len = 1;
	    }

	    if (modifiers)
	    {
		*dest++ = CSI;
		*dest++ = KS_MODIFIER;
		*dest++ = modifiers;
		km.length = 3;
	    }
	}
	memcpy((char *)dest, string, len);
	km.length += len;
    }

    write_port(gui.vdcmp, VimMsg::Key, &km, sizeof(km));

    /*
     * blank out the pointer if necessary
     */
    if (p_mh && !gui.pointer_hidden)
    {
	guiBlankMouse(true);
	gui.pointer_hidden = TRUE;
    }
}
    void
VimTextAreaView::guiSendMouseEvent(
    int	    button,
    int	    x,
    int	    y,
    int	    repeated_click,
    int_u   modifiers)
{
    VimMouseMsg mm;

    mm.button = button;
    mm.x = x;
    mm.y = y;
    mm.repeated_click = repeated_click;
    mm.modifiers = modifiers;

    write_port(gui.vdcmp, VimMsg::Mouse, &mm, sizeof(mm));
    // calls gui_send_mouse_event()

    /*
     * if our pointer is currently hidden, then we should show it.
     */
    if (gui.pointer_hidden)
    {
	guiBlankMouse(false);
	gui.pointer_hidden = FALSE;
    }
}

    void
VimTextAreaView::guiBlankMouse(bool should_hide)
{
    if (should_hide) {
	//gui.vimApp->HideCursor();
	gui.vimApp->ObscureCursor();
	/*
	 * ObscureCursor() would even be easier, but then
	 * Vim's idea of mouse visibility does not necessarily
	 * correspond to reality.
	 */
    } else {
	//gui.vimApp->ShowCursor();
    }
}

    int_u
VimTextAreaView::mouseModifiersToVim(int32 beModifiers)
{
    int_u vim_modifiers = 0x0;

    if (beModifiers & B_SHIFT_KEY)
	vim_modifiers |= MOUSE_SHIFT;
    if (beModifiers & B_CONTROL_KEY)
	vim_modifiers |= MOUSE_CTRL;
    if (beModifiers & B_OPTION_KEY)	    /* Alt or Meta key */
	vim_modifiers |= MOUSE_ALT;

    return vim_modifiers;
}

    void
VimTextAreaView::MouseDown(BPoint point)
{
    BMessage *m = Window()->CurrentMessage();
    assert(m);

    int32 buttons = 0;
    m->FindInt32("buttons", &buttons);

    int vimButton;

    if (buttons & B_PRIMARY_MOUSE_BUTTON)
	vimButton = MOUSE_LEFT;
    else if (buttons & B_SECONDARY_MOUSE_BUTTON)
	vimButton = MOUSE_RIGHT;
    else if (buttons & B_TERTIARY_MOUSE_BUTTON)
	vimButton = MOUSE_MIDDLE;
    else
	return;			/* Unknown button */

    vimMouseButton = 1;		/* don't care which one */

    /* Handle multiple clicks */
    int32 clicks = 0;
    m->FindInt32("clicks", &clicks);

    int32 modifiers = 0;
    m->FindInt32("modifiers", &modifiers);

    vimMouseModifiers = mouseModifiersToVim(modifiers);

    guiSendMouseEvent(vimButton, point.x, point.y,
	    clicks > 1 /* = repeated_click*/, vimMouseModifiers);
}

    void
VimTextAreaView::MouseUp(BPoint point)
{
    vimMouseButton = 0;

    BMessage *m = Window()->CurrentMessage();
    assert(m);
    //m->PrintToStream();

    int32 modifiers = 0;
    m->FindInt32("modifiers", &modifiers);

    vimMouseModifiers = mouseModifiersToVim(modifiers);

    guiSendMouseEvent(MOUSE_RELEASE, point.x, point.y,
	    0 /* = repeated_click*/, vimMouseModifiers);

    Inherited::MouseUp(point);
}

    void
VimTextAreaView::MouseMoved(BPoint point, uint32 transit, const BMessage *message)
{
    /*
     * if our pointer is currently hidden, then we should show it.
     */
    if (gui.pointer_hidden)
    {
	guiBlankMouse(false);
	gui.pointer_hidden = FALSE;
    }

    if (!vimMouseButton)    /* could also check m->"buttons" */
	return;

    atomic_add(&mouseDragEventCount, 1);

    /* Don't care much about "transit" */
    guiSendMouseEvent(MOUSE_DRAG, point.x, point.y, 0, vimMouseModifiers);
}

    void
VimTextAreaView::MessageReceived(BMessage *m)
{
    switch (m->what) {
    case 'menu':
	{
	    VimMenuMsg mm;
	    mm.guiMenu = NULL;	/* in case no pointer in msg */
	    m->FindPointer("VimMenu", (void **)&mm.guiMenu);

	    write_port(gui.vdcmp, VimMsg::Menu, &mm, sizeof(mm));
	}
	break;
    default:
	if (m->WasDropped()) {
	    BWindow *w = Window();
	    w->DetachCurrentMessage();
	    w->Minimize(false);
	    VimApp::SendRefs(m, (modifiers() & B_SHIFT_KEY) != 0);
	} else {
	    Inherited::MessageReceived(m);
	}
	break;
    }
}

    int
VimTextAreaView::mchInitFont(char_u *name)
{
    VimFont *newFont = (VimFont *)gui_mch_get_font(name, 0);

    gui.norm_font = (GuiFont)newFont;
    gui_mch_set_font((GuiFont)newFont);
    if (name)
	hl_set_font_name(name);

    SetDrawingMode(B_OP_COPY);

    /*
     * Try to load other fonts for bold, italic, and bold-italic.
     * We should also try to work out what font to use for these when they are
     * not specified by X resources, but we don't yet.
     */

    return OK;
}

    void
VimTextAreaView::mchDrawString(int row, int col, char_u *s, int len, int flags)
{
    /*
     * First we must erase the area, because DrawString won't do
     * that for us. XXX Most of the time this is a waste of effort
     * since the bachground has been erased already... DRAW_TRANSP
     * should be set when appropriate!!!
     * (Rectangles include the bottom and right edge)
     */
    if (!(flags & DRAW_TRANSP)) {
	BRect r(FILL_X(col), FILL_Y(row),
		FILL_X(col + len) - PEN_WIDTH, FILL_Y(row + 1) - PEN_WIDTH);
	FillRect(r, B_SOLID_LOW);
    }
    BPoint where(TEXT_X(col), TEXT_Y(row));
    DrawString((char *)s, len, where);

    if (flags & DRAW_BOLD) {
	where.x += 1.0;
	SetDrawingMode(B_OP_BLEND);
	DrawString((char *)s, len, where);
	SetDrawingMode(B_OP_COPY);
    }
    if (flags & DRAW_UNDERL) {
	BPoint start(FILL_X(col), FILL_Y(row + 1) - PEN_WIDTH);
	BPoint end(FILL_X(col + len) - PEN_WIDTH, start.y);

	StrokeLine(start, end);
    }
}

    void
VimTextAreaView::mchClearBlock(
    int		row1,
    int		col1,
    int		row2,
    int		col2)
{
    BRect r(FILL_X(col1), FILL_Y(row1),
	    FILL_X(col2 + 1) - PEN_WIDTH, FILL_Y(row2 + 1) - PEN_WIDTH);
    gui_mch_set_bg_color(gui.back_pixel);
    FillRect(r, B_SOLID_LOW);
}

    void
VimTextAreaView::mchClearAll()
{
    gui_mch_set_bg_color(gui.back_pixel);
    FillRect(Bounds(), B_SOLID_LOW);
}

/*
 * mchDeleteLines() Lock()s the window by itself.
 */
    void
VimTextAreaView::mchDeleteLines(int row, int num_lines)
{
    if (row + num_lines > gui.scroll_region_bot)
    {
	/* Scrolled out of region, just blank the lines out */
	gui_clear_block(row, gui.scroll_region_left,
		gui.scroll_region_bot, gui.scroll_region_right);
    }
    else
    {
	/* copy one extra pixel, for when bold has spilled over */
	int width = gui.char_width * (gui.scroll_region_right
				- gui.scroll_region_left + 1) + 1 - PEN_WIDTH;
	int height = gui.char_height *
		     (gui.scroll_region_bot - row - num_lines + 1) - PEN_WIDTH;

	BRect source, dest;

	source.left = FILL_X(gui.scroll_region_left);
	source.top = FILL_Y(row + num_lines);
	source.right = source.left + width;
	source.bottom = source.top + height;

	dest.left = FILL_X(gui.scroll_region_left);
	dest.top = FILL_Y(row);
	dest.right = dest.left + width;
	dest.bottom = dest.top + height;

	/* XXX Attempt at a hack: */
	gui.vimWindow->UpdateIfNeeded();
#if 0
	/* XXX Attempt at a hack: */
	if (gui.vimWindow->NeedsUpdate()) {
	    fprintf(stderr, "mchDeleteLines: NeedsUpdate!\n");
	    gui.vimWindow->UpdateIfNeeded();
	    while (gui.vimWindow->NeedsUpdate()) {
		if (false && gui.vimWindow->Lock()) {
		    Sync();
		    gui.vimWindow->Unlock();
		}
		snooze(2);
	    }
	}
#endif

	if (gui.vimWindow->Lock()) {
	    Sync();
	    CopyBits(source, dest);
	    //Sync();

	    /* Update gui.cursor_row if the cursor scrolled or copied over */
	    if (gui.cursor_row >= row
		&& gui.cursor_col >= gui.scroll_region_left
		&& gui.cursor_col <= gui.scroll_region_right)
	    {
		if (gui.cursor_row < row + num_lines)
		    gui.cursor_is_valid = FALSE;
		else if (gui.cursor_row <= gui.scroll_region_bot)
		    gui.cursor_row -= num_lines;
	    }

	    /* Clear one column more for when bold has spilled over */
	    gui_clear_block(gui.scroll_region_bot - num_lines + 1,
						       gui.scroll_region_left,
		gui.scroll_region_bot, gui.scroll_region_right);

	    gui.vimWindow->Unlock();
	    /*
	     * The Draw() callback will be called now if some of the source
	     * bits were not in the visible region.
	     */

	    //gui_x11_check_copy_area();
	}
    }
}

/*
 * mchInsertLines() Lock()s the window by itself.
 */
    void
VimTextAreaView::mchInsertLines(int row, int num_lines)
{
    if (row + num_lines > gui.scroll_region_bot)
    {
	/* Scrolled out of region, just blank the lines out */
	gui_clear_block(row, gui.scroll_region_left,
		gui.scroll_region_bot, gui.scroll_region_right);
    }
    else
    {
	/* copy one extra pixel, for when bold has spilled over */
	int width = gui.char_width * (gui.scroll_region_right
				- gui.scroll_region_left + 1) + 1 - PEN_WIDTH;
	int height = gui.char_height *
		     (gui.scroll_region_bot - row - num_lines + 1) - PEN_WIDTH;

	BRect source, dest;

	source.left = FILL_X(gui.scroll_region_left);
	source.top = FILL_Y(row);
	source.right = source.left + width;
	source.bottom = source.top + height;

	dest.left = FILL_X(gui.scroll_region_left);
	dest.top = FILL_Y(row + num_lines);
	dest.right = dest.left + width;
	dest.bottom = dest.top + height;

	/* XXX Attempt at a hack: */
	gui.vimWindow->UpdateIfNeeded();
#if 0
	/* XXX Attempt at a hack: */
	if (gui.vimWindow->NeedsUpdate())
	    fprintf(stderr, "mchInsertLines: NeedsUpdate!\n");
	gui.vimWindow->UpdateIfNeeded();
	while (gui.vimWindow->NeedsUpdate())
	    snooze(2);
#endif

	if (gui.vimWindow->Lock()) {
	    Sync();
	    CopyBits(source, dest);
	    //Sync();

	    /* Update gui.cursor_row if the cursor scrolled or copied over */
	    if (gui.cursor_row >= gui.row
		&& gui.cursor_col >= gui.scroll_region_left
		&& gui.cursor_col <= gui.scroll_region_right)
	    {
		if (gui.cursor_row <= gui.scroll_region_bot - num_lines)
		    gui.cursor_row += num_lines;
		else if (gui.cursor_row <= gui.scroll_region_bot)
		    gui.cursor_is_valid = FALSE;
	    }
	    /* Clear one column more for when bold has spilled over */
	    gui_clear_block(row, gui.scroll_region_left,
		    row + num_lines - 1, gui.scroll_region_right);

	    gui.vimWindow->Unlock();
	    /*
	     * The Draw() callback will be called now if some of the source
	     * bits were not in the visible region.
	     * However, if we scroll too fast it can't keep up and the
	     * update region gets messed up. This seems to be because copying
	     * un-Draw()n bits does not generate Draw() calls for the copy...
	     * I moved the hack to before the CopyBits() to reduce the
	     * amount of additional waiting needed.
	     */

	    //gui_x11_check_copy_area();
	}
    }

}

/* ---------------- VimScrollBar ---------------- */

/* BUG: XXX
 * It seems that BScrollBar determine their direction not from
 * "posture" but from if they are "tall" or "wide" in shape...
 *
 * Also, place them out of sight, because Vim enables them before
 * they are positioned.
 */
VimScrollBar::VimScrollBar(scrollbar_T *g, orientation posture):
    BScrollBar(posture == B_HORIZONTAL ?  BRect(-100,-100,-10,-90) :
					  BRect(-100,-100,-90,-10),
		"vim scrollbar", (BView *)NULL,
	    0.0, 10.0, posture),
    ignoreValue(-1),
    scrollEventCount(0)
{
    gsb = g;
    SetResizingMode(B_FOLLOW_NONE);
}

VimScrollBar::~VimScrollBar()
{
}

    void
VimScrollBar::ValueChanged(float newValue)
{
    if (ignoreValue >= 0.0 && newValue == ignoreValue) {
	ignoreValue = -1;
	return;
    }
    ignoreValue = -1;
    /*
     * We want to throttle the amount of scroll messages generated.
     * Normally I presume you won't get a new message before we've
     * handled the previous one, but because we're passing them on this
     * happens very quickly. So instead we keep a counter of how many
     * scroll events there are (or will be) in the VDCMP, and the
     * throttling happens at the receiving end.
     */
    atomic_add(&scrollEventCount, 1);

    struct VimScrollBarMsg sm;

    sm.sb = this;
    sm.value = (long) newValue;
    sm.stillDragging = TRUE;

    write_port(gui.vdcmp, VimMsg::ScrollBar, &sm, sizeof(sm));

    // calls gui_drag_scrollbar(sb, newValue, TRUE);
}

/*
 * When the mouse goes up, report that scrolling has stopped.
 * MouseUp() is NOT called when the mouse-up occurs outside
 * the window, even though the thumb does move while the mouse
 * is outside... This has some funny effects... XXX
 * So we do special processing when the window de/activates.
 */
    void
VimScrollBar::MouseUp(BPoint where)
{
    //BMessage *m = Window()->CurrentMessage();
    //m->PrintToStream();

    atomic_add(&scrollEventCount, 1);

    struct VimScrollBarMsg sm;

    sm.sb = this;
    sm.value = (long) Value();
    sm.stillDragging = FALSE;

    write_port(gui.vdcmp, VimMsg::ScrollBar, &sm, sizeof(sm));

    // calls gui_drag_scrollbar(sb, newValue, FALSE);

    Inherited::MouseUp(where);
}

    void
VimScrollBar::SetValue(float newValue)
{
    if (newValue == Value())
	return;

    ignoreValue = newValue;
    Inherited::SetValue(newValue);
}

/* ---------------- VimFont ---------------- */

VimFont::VimFont(): BFont()
{
    init();
}

VimFont::VimFont(const VimFont *rhs): BFont(rhs)
{
    init();
}

VimFont::VimFont(const BFont *rhs): BFont(rhs)
{
    init();
}

VimFont::VimFont(const VimFont &rhs): BFont(rhs)
{
    init();
}

VimFont::~VimFont()
{
}

    void
VimFont::init()
{
    next = NULL;
    refcount = 1;
    name = NULL;
}

/* ---------------- ---------------- */

// some global variables
static char appsig[] = "application/x-vnd.Rhialto-Vim-5";
key_map *keyMap;
char *keyMapChars;
int main_exitcode = 127;

    status_t
gui_beos_process_event(bigtime_t timeout)
{
    struct VimMsg vm;
    long what;
    ssize_t size;

    size = read_port_etc(gui.vdcmp, &what, &vm, sizeof(vm),
	    B_TIMEOUT, timeout);

    if (size >= 0) {
	switch (what) {
	case VimMsg::Key:
	    {
		char_u *string = vm.u.Key.chars;
		int len = vm.u.Key.length;
		if (len == 1 && string[0] == Ctrl_chr('C')) {
		    trash_input_buf();
		    got_int = TRUE;
		}
		add_to_input_buf(string, len);
	    }
	    break;
	case VimMsg::Resize:
	    gui_resize_shell(vm.u.NewSize.width, vm.u.NewSize.height);
	    break;
	case VimMsg::ScrollBar:
	    {
		/*
		 * If loads of scroll messages queue up, use only the last
		 * one. Always report when the scrollbar stops dragging.
		 * This is not perfect yet anyway: these events are queued
		 * yet again, this time in the keyboard input buffer.
		 */
		int32 oldCount =
		    atomic_add(&vm.u.Scroll.sb->scrollEventCount, -1);
		if (oldCount <= 1 || !vm.u.Scroll.stillDragging)
		    gui_drag_scrollbar(vm.u.Scroll.sb->getGsb(),
			    vm.u.Scroll.value, vm.u.Scroll.stillDragging);
	    }
	    break;
	case VimMsg::Menu:
	    gui_menu_cb(vm.u.Menu.guiMenu);
	    break;
	case VimMsg::Mouse:
	    {
		int32 oldCount;
		if (vm.u.Mouse.button == MOUSE_DRAG)
		    oldCount =
			atomic_add(&gui.vimTextArea->mouseDragEventCount, -1);
		else
		    oldCount = 0;
		if (oldCount <= 1)
		    gui_send_mouse_event(vm.u.Mouse.button, vm.u.Mouse.x,
			    vm.u.Mouse.y, vm.u.Mouse.repeated_click,
			    vm.u.Mouse.modifiers);
	    }
	    break;
	case VimMsg::Focus:
	    gui.in_focus = vm.u.Focus.active;
	    /* XXX Signal that scrollbar dragging has stopped?
	     * This is needed because we don't get a MouseUp if
	     * that happens while outside the window... :-(
	     */
	    if (gui.dragged_sb) {
		gui.dragged_sb = SBAR_NONE;
	    }
	    gui_update_cursor(TRUE, FALSE);
	    break;
	case VimMsg::Refs:
	    ::RefsReceived(vm.u.Refs.message, vm.u.Refs.changedir);
	    break;
	default:
	    // unrecognised message, ignore it
	    break;
	}
    }

    /*
     * If size < B_OK, it is an error code.
     */
    return size;
}

/*
 * Here are some functions to protect access to ScreenLines[] and
 * LineOffset[]. These are used from the window thread to respond
 * to a Draw() callback. When that occurs, the window is already
 * locked by the system.
 *
 * Other code that needs to lock is any code that changes these
 * variables. Other read-only access, or access merely to the
 * contents of the screen buffer, need not be locked.
 *
 * If there is no window, don't call Lock() but do succeed.
 */

    int
vim_lock_screen()
{
    return !gui.vimWindow || gui.vimWindow->Lock();
}

    void
vim_unlock_screen()
{
    if (gui.vimWindow)
	gui.vimWindow->Unlock();
}

#define RUN_BAPPLICATION_IN_NEW_THREAD	0

#if RUN_BAPPLICATION_IN_NEW_THREAD

    int32
run_vimapp(void *args)
{
    VimApp app(appsig);

    gui.vimApp = &app;
    app.Run();			    /* Run until Quit() called */

    return 0;
}

#else

    int32
call_main(void *args)
{
    struct MainArgs *ma = (MainArgs *)args;

    return main(ma->argc, ma->argv);
}
#endif

extern "C" {

/*
 * Parse the GUI related command-line arguments.  Any arguments used are
 * deleted from argv, and *argc is decremented accordingly.  This is called
 * when vim is started, whether or not the GUI has been started.
 */
    void
gui_mch_prepare(
    int		*argc,
    char	**argv)
{
    /*
     * We don't have any command line arguments for the BeOS GUI yet,
     * but this is an excellent place to create our Application object.
     */
    if (!gui.vimApp) {
	thread_info tinfo;
	get_thread_info(find_thread(NULL), &tinfo);

	/* May need the port very early on to process RefsReceived() */
	gui.vdcmp = create_port(B_MAX_PORT_COUNT, "vim VDCMP");

#if RUN_BAPPLICATION_IN_NEW_THREAD
	thread_id tid = spawn_thread(run_vimapp, "vim VimApp",
						tinfo.priority, NULL);
	if (tid >= B_OK) {
	    resume_thread(tid);
	} else {
	    getout(1);
	}
#else
	MainArgs ma = { *argc, argv };
	thread_id tid = spawn_thread(call_main, "vim main()",
						tinfo.priority, &ma);
	if (tid >= B_OK) {
	    VimApp app(appsig);

	    gui.vimApp = &app;
	    resume_thread(tid);
	    /*
	     * This is rather horrible.
	     * call_main will call main() again...
	     * There will be no infinite recursion since
	     * gui.vimApp is set now.
	     */
	    app.Run();			    /* Run until Quit() called */
	    //fprintf(stderr, "app.Run() returned...\n");
	    status_t dummy_exitcode;
	    (void)wait_for_thread(tid, &dummy_exitcode);

	    /*
	     * This path should be the normal one taken to exit Vim.
	     * The main() thread calls mch_exit() which calls
	     * gui_mch_exit() which terminates its thread.
	     */
	    exit(main_exitcode);
	}
#endif
    }
    /* Don't fork() when starting the GUI. Spawned threads are not
     * duplicated with a fork(). The result is a mess.
     */
    gui.dofork = FALSE;
    /*
     * XXX Try to determine whether we were started from
     * the Tracker or the terminal.
     * It would be nice to have this work, because the Tracker
     * follows symlinks, so even if you double-click on gvim,
     * when it is a link to vim it will still pass a command name
     * of vim...
     * We try here to see if stdin comes from /dev/null. If so,
     * (or if there is an error, which should never happen) start the GUI.
     * This does the wrong thing for vim - </dev/null, and we're
     * too early to see the command line parsing. Tough.
     * On the other hand, it starts the gui for vim file & which is nice.
     */
    if (!isatty(0)) {
	struct stat stat_stdin, stat_dev_null;

	if (fstat(0, &stat_stdin) == -1 ||
	    stat("/dev/null", &stat_dev_null) == -1 ||
	    (stat_stdin.st_dev == stat_dev_null.st_dev &&
	     stat_stdin.st_ino == stat_dev_null.st_ino))
	    gui.starting = TRUE;
    }
}

/*
 * Check if the GUI can be started.  Called before gvimrc is sourced.
 * Return OK or FAIL.
 */
    int
gui_mch_init_check(void)
{
    return OK;		/* TODO: GUI can always be started? */
}

/*
 * Initialise the GUI.  Create all the windows, set up all the call-backs
 * etc.
 */
    int
gui_mch_init()
{
    gui.def_norm_pixel = RGB(0x00, 0x00, 0x00);	// black
    gui.def_back_pixel = RGB(0xFF, 0xFF, 0xFF);	// white
    gui.norm_pixel = gui.def_norm_pixel;
    gui.back_pixel = gui.def_back_pixel;

    gui.scrollbar_width = (int) B_V_SCROLL_BAR_WIDTH;
    gui.scrollbar_height = (int) B_H_SCROLL_BAR_HEIGHT;
#ifdef FEAT_MENU
    gui.menu_height = 19;	// initial guess -
				// correct for my default settings
#endif
    gui.border_offset = 3;	// coordinates are inside window borders

    if (gui.vdcmp < B_OK)
	return FAIL;
    get_key_map(&keyMap, &keyMapChars);

    gui.vimWindow = new VimWindow();	/* hidden and locked */
    if (!gui.vimWindow)
	return FAIL;

    gui.vimWindow->Run();		/* Run() unlocks but does not show */

    /* Get the colors from the "Normal" group (set in syntax.c or in a vimrc
     * file) */
    set_normal_colors();

    /*
     * Check that none of the colors are the same as the background color
     */
    gui_check_colors();

    /* Get the colors for the highlight groups (gui_check_colors() might have
     * changed them) */
    highlight_gui_started();		/* re-init colors and fonts */

    gui_mch_new_colors();		/* window must exist for this */

    return OK;
}

/*
 * Called when the foreground or background color has been changed.
 */
    void
gui_mch_new_colors()
{
    rgb_color rgb = GUI_TO_RGB(gui.back_pixel);

    if (gui.vimWindow->Lock()) {
	gui.vimForm->SetViewColor(rgb);
	// Does this not have too much effect for those small rectangles?
	gui.vimForm->Invalidate();
	gui.vimWindow->Unlock();
    }
}

/*
 * Open the GUI window which was created by a call to gui_mch_init().
 */
    int
gui_mch_open()
{
    if (gui_win_x != -1 && gui_win_y != -1)
	gui_mch_set_winpos(gui_win_x, gui_win_y);

    /* Actually open the window */
    if (gui.vimWindow->Lock()) {
	gui.vimWindow->Show();
	gui.vimWindow->Unlock();

#if USE_THREAD_FOR_INPUT_WITH_TIMEOUT
	/* Kill the thread that may have been created for the Terminal */
	beos_cleanup_read_thread();
#endif

	return OK;
    }

    return FAIL;
}

    void
gui_mch_exit(int vim_exitcode)
{
    if (gui.vimWindow) {
	thread_id tid = gui.vimWindow->Thread();
	gui.vimWindow->Lock();
	gui.vimWindow->Quit();
	/* Wait until it is truely gone */
	int32 exitcode;
	wait_for_thread(tid, &exitcode);
    }
    delete_port(gui.vdcmp);
#if !RUN_BAPPLICATION_IN_NEW_THREAD
    /*
     * We are in the main() thread - quit the App thread and
     * quit ourselves (passing on the exitcode). Use a global since the
     * value from exit_thread() is only used if wait_for_thread() is
     * called in time (race condition).
     */
#endif
    if (gui.vimApp) {
	VimTextAreaView::guiBlankMouse(false);

	main_exitcode = vim_exitcode;
#if RUN_BAPPLICATION_IN_NEW_THREAD
	thread_id tid = gui.vimApp->Thread();
	int32 exitcode;
	gui.vimApp->Lock();
	gui.vimApp->Quit();
	gui.vimApp->Unlock();
	wait_for_thread(tid, &exitcode);
#else
	gui.vimApp->Lock();
	gui.vimApp->Quit();
	gui.vimApp->Unlock();
	/* suicide */
	exit_thread(vim_exitcode);
#endif
    }
    /* If we are somehow still here, let mch_exit() handle things. */
}

/*
 * Get the position of the top left corner of the window.
 */
    int
gui_mch_get_winpos(int *x, int *y)
{
    /* TODO */
    return FAIL;
}

/*
 * Set the position of the top left corner of the window to the given
 * coordinates.
 */
    void
gui_mch_set_winpos(int x, int y)
{
    /* TODO */
}

/*
 * Set the size of the window to the given width and height in pixels.
 */
    void
gui_mch_set_shellsize(
    int		width,
    int		height,
    int		min_width,
    int		min_height,
    int		base_width,
    int		base_height)
{
    /*
     * We are basically given the size of the VimForm, if I understand
     * correctly. Since it fills the window completely, this will also
     * be the size of the window.
     */
    if (gui.vimWindow->Lock()) {
	gui.vimWindow->ResizeTo(width - PEN_WIDTH, height - PEN_WIDTH);

	/* set size limits */
	float minWidth, maxWidth, minHeight, maxHeight;

	gui.vimWindow->GetSizeLimits(&minWidth, &maxWidth,
				     &minHeight, &maxHeight);
	gui.vimWindow->SetSizeLimits(min_width, maxWidth,
				     min_height, maxHeight);

#if HAVE_R3_OR_LATER
	/*
	 * Set the resizing alignment depending on font size.
	 * XXX This is untested, since I don't have R3 yet.
	 */
	SetWindowAlignment(
	    B_PIXEL_ALIGNMENT,		// window_alignment mode,
	    1,				// int32 h,
	    0,				// int32 hOffset = 0,
	    gui.char_width,		// int32 width = 0,
	    base_width,			// int32 widthOffset = 0,
	    1,				// int32 v = 0,
	    0,				// int32 vOffset = 0,
	    gui.char_height,		// int32 height = 0,
	    base_height			// int32 heightOffset = 0
	);
#else
	/* don't know what to do with base_{width,height}. */
#endif

	gui.vimWindow->Unlock();
    }
}

    void
gui_mch_get_screen_dimensions(
    int		*screen_w,
    int		*screen_h)
{
    BRect frame;

    {
	BScreen screen(gui.vimWindow);

	if (screen.IsValid()) {
	    frame = screen.Frame();
	} else {
	    frame.right = 640;
	    frame.bottom = 480;
	}
    }

    /* XXX approximations... */
    *screen_w = (int) frame.right - 2 * gui.scrollbar_width - 20;
    *screen_h = (int) frame.bottom - gui.scrollbar_height
#ifdef FEAT_MENU
	- gui.menu_height
#endif
	- 30;
}

    void
gui_mch_set_text_area_pos(
    int		x,
    int		y,
    int		w,
    int		h)
{
    if (!gui.vimTextArea)
	return;

    if (gui.vimWindow->Lock()) {
	gui.vimTextArea->MoveTo(x, y);
	gui.vimTextArea->ResizeTo(w - PEN_WIDTH, h - PEN_WIDTH);
	gui.vimWindow->Unlock();
    }
}


/*
 * Scrollbar stuff:
 */

    void
gui_mch_enable_scrollbar(
    scrollbar_T	*sb,
    int		flag)
{
    VimScrollBar *vsb = sb->id;
    if (gui.vimWindow->Lock()) {
	/*
	 * This function is supposed to be idempotent, but Show()/Hide()
	 * is not. Therefore we test if they are needed.
	 */
	if (flag) {
	    if (vsb->IsHidden()) {
		vsb->Show();
	    }
	} else {
	    if (!vsb->IsHidden()) {
		vsb->Hide();
	    }
	}
	gui.vimWindow->Unlock();
    }
}

    void
gui_mch_set_scrollbar_thumb(
    scrollbar_T *sb,
    int		val,
    int		size,
    int		max)
{
    if (gui.vimWindow->Lock()) {
	VimScrollBar *s = sb->id;
	if (max == 0) {
	    s->SetValue(0);
	    s->SetRange(0.0, 0.0);
	} else {
	    s->SetProportion((float)size / (max + 1.0));
	    s->SetSteps(1.0, size > 5 ? size - 2 : size);
#ifndef SCROLL_PAST_END		// really only defined in gui.c...
	    max = max + 1 - size;
#endif
	    if (max < s->Value()) {
		/*
		 * If the new maximum is lower than the current value,
		 * setting it would cause the value to be clipped and
		 * therefore a ValueChanged() call.
		 * We avoid this by setting the value first, because
		 * it presumably is <= max.
		 */
		s->SetValue(val);
		s->SetRange(0.0, max);
	    } else {
		/*
		 * In the other case, set the range first, since the
		 * new value might be higher than the current max.
		 */
		s->SetRange(0.0, max);
		s->SetValue(val);
	    }
	}
	gui.vimWindow->Unlock();
    }
}

    void
gui_mch_set_scrollbar_pos(
    scrollbar_T *sb,
    int		x,
    int		y,
    int		w,
    int		h)
{
    if (gui.vimWindow->Lock()) {
	VimScrollBar *vsb = sb->id;
	vsb->MoveTo(x, y);
	vsb->ResizeTo(w - PEN_WIDTH, h - PEN_WIDTH);
	gui.vimWindow->Unlock();
    }
}

    void
gui_mch_create_scrollbar(
    scrollbar_T *sb,
    int		orient)		/* SBAR_VERT or SBAR_HORIZ */
{
    orientation posture =
	(orient == SBAR_HORIZ) ? B_HORIZONTAL : B_VERTICAL;

    VimScrollBar *vsb = sb->id = new VimScrollBar(sb, posture);
    if (gui.vimWindow->Lock()) {
	vsb->SetTarget(gui.vimTextArea);
	vsb->Hide();
	gui.vimForm->AddChild(vsb);
	gui.vimWindow->Unlock();
    }
}

#if defined(FEAT_WINDOWS) || defined(PROTO)
    void
gui_mch_destroy_scrollbar(
    scrollbar_T	*sb)
{
    if (gui.vimWindow->Lock()) {
	sb->id->RemoveSelf();
	delete sb->id;
	gui.vimWindow->Unlock();
    }
}
#endif

/*
 * Cursor blink functions.
 *
 * This is a simple state machine:
 * BLINK_NONE	not blinking at all
 * BLINK_OFF	blinking, cursor is not shown
 * BLINK_ON	blinking, cursor is shown
 */

#define BLINK_NONE  0
#define BLINK_OFF   1
#define BLINK_ON    2

static int		blink_state = BLINK_NONE;
static long_u		blink_waittime = 700;
static long_u		blink_ontime = 400;
static long_u		blink_offtime = 250;
static int	blink_timer = 0;

    void
gui_mch_set_blinking(
    long    waittime,
    long    on,
    long    off)
{
	/* TODO */
    blink_waittime = waittime;
    blink_ontime = on;
    blink_offtime = off;
}

/*
 * Stop the cursor blinking.  Show the cursor if it wasn't shown.
 */
    void
gui_mch_stop_blink()
{
	/* TODO */
    if (blink_timer != 0)
    {
	//XtRemoveTimeOut(blink_timer);
	blink_timer = 0;
    }
    if (blink_state == BLINK_OFF)
	gui_update_cursor(TRUE, FALSE);
    blink_state = BLINK_NONE;
}

/*
 * Start the cursor blinking.  If it was already blinking, this restarts the
 * waiting time and shows the cursor.
 */
    void
gui_mch_start_blink()
{
	/* TODO */
    if (blink_timer != 0)
	;//XtRemoveTimeOut(blink_timer);
    /* Only switch blinking on if none of the times is zero */
    if (blink_waittime && blink_ontime && blink_offtime && gui.in_focus)
    {
	blink_timer = 1; //XtAppAddTimeOut(app_context, blink_waittime,
	blink_state = BLINK_ON;
	gui_update_cursor(TRUE, FALSE);
    }
}

/*
 * Initialise vim to use the font with the given name.	Return FAIL if the font
 * could not be loaded, OK otherwise.
 */
    int
gui_mch_init_font(
    char_u		*font_name,
    int			fontset)
{
    if (gui.vimWindow->Lock())
    {
	int rc = gui.vimTextArea->mchInitFont(font_name);
	gui.vimWindow->Unlock();

	return rc;
    }

    return FAIL;
}

    int
gui_mch_adjust_charsize()
{
    return FAIL;
}

    GuiFont
gui_mch_get_font(
    char_u		*name,
    int			giveErrorIfMissing)
{
    VimFont		*font = 0;
    static VimFont *fontList = NULL;

    if (!gui.in_use)		    /* can't do this when GUI not running */
	return NOFONT;

    if (!name)
	name = (char_u *)"be_fixed_font";

    VimFont *flp;
    for (flp = fontList; flp; flp = flp->next) {
	if (STRCMP(name, flp->name) == 0) {
	    flp->refcount++;
	    return (GuiFont)flp;
	}
    }

    font = new VimFont(be_fixed_font);

    /* Set some universal features: */
    font->SetSpacing(B_FIXED_SPACING);
    font->SetEncoding(B_ISO_8859_1);

    /* Remember font for later use */
    font->name = vim_strsave(name);
    font->next = fontList;
    fontList = font;

    font_family family;
    font_style style;
    int size;
    int len;
    char_u *end;

#ifdef never
    // This leads to SEGV/BUS on R4+
    // Replace underscores with spaces, and I can't see why ?
    // richard@whitequeen.com jul 99
    while (end = (char_u *)strchr((char *)name, '_'))
	*end = ' ';
#endif
    /*
     *  Parse font names as Family/Style/Size.
     *  On errors, just keep the be_fixed_font.
     */
    end = (char_u *)strchr((char *)name, '/');
    if (!end)
	goto error;
    strncpy(family, (char *)name, len = end - name);
    family[len] = '\0';

    name = end + 1;
    end = (char_u *)strchr((char *)name, '/');
    if (!end)
	goto error;
    strncpy(style, (char *)name, len = end - name);
    style[len] = '\0';

    name = end + 1;
    size = atoi((char *)name);
    if (size <= 0)
	goto error;

    font->SetFamilyAndStyle(family, style);
    font->SetSize(size);
    font->SetSpacing(B_FIXED_SPACING);
    font->SetEncoding(B_ISO_8859_1);
    //font->PrintToStream();

    return (GuiFont)font;

error:
    if (giveErrorIfMissing)
	EMSG2("(fe0) Unknown font: %s", name);

    return (GuiFont)font;
}

/*
 * Return the name of font "font" in allocated memory.
 */
    char_u *
gui_mch_get_fontname(GuiFont font, char_u *name)
{
    return vim_strsave(((VimFont *)font)->name);
}

/*
 * Set the current text font.
 */
    void
gui_mch_set_font(
    GuiFont	font)
{
    if (gui.vimWindow->Lock()) {
	VimFont *vf = (VimFont *)font;

	gui.vimTextArea->SetFont(vf);

	gui.char_width = (int) vf->StringWidth("n");
	font_height fh;
	vf->GetHeight(&fh);
	gui.char_height = (int)(fh.ascent + 0.9999)
		    + (int)(fh.descent + 0.9999) + (int)(fh.leading + 0.9999);
	gui.char_ascent = (int)(fh.ascent + 0.9999);

	gui.vimWindow->Unlock();
    }
}

#if 0 /* not used */
/*
 * Return TRUE if the two fonts given are equivalent.
 */
    int
gui_mch_same_font(
    GuiFont	f1,
    GuiFont	f2)
{
    VimFont *vf1 = (VimFont *)f1;
    VimFont *vf2 = (VimFont *)f2;

    return f1 == f2 ||
	    (vf1->FamilyAndStyle() == vf2->FamilyAndStyle() &&
	     vf1->Size() == vf2->Size());
}
#endif

/* XXX TODO This is apparently never called... */
    void
gui_mch_free_font(
    GuiFont	font)
{
    VimFont *f = (VimFont *)font;
    if (--f->refcount <= 0) {
	if (f->refcount < 0)
	    fprintf(stderr, "VimFont: refcount < 0\n");
	delete f;
    }
}

    static int
hex_digit(int c)
{
    if (isdigit(c))
	return c - '0';
    c = TOLOWER_ASC(c);
    if (c >= 'a' && c <= 'f')
	return c - 'a' + 10;
    return -1000;
}

/*
 * This function has been lifted from gui_w32.c and extended a bit.
 *
 * Return the Pixel value (color) for the given color name.
 * Return INVALCOLOR for error.
 */
    guicolor_T
gui_mch_get_color(
    char_u	*name)
{
    typedef struct GuiColourTable
    {
	char	    *name;
	guicolor_T     colour;
    } GuiColourTable;

#define NSTATIC_COLOURS		32
#define NDYNAMIC_COLOURS	33
#define NCOLOURS		(NSTATIC_COLOURS + NDYNAMIC_COLOURS)

    static GuiColourTable table[NCOLOURS] =
    {
	{"Black",	    RGB(0x00, 0x00, 0x00)},
	{"DarkGray",	    RGB(0x80, 0x80, 0x80)},
	{"DarkGrey",	    RGB(0x80, 0x80, 0x80)},
	{"Gray",	    RGB(0xC0, 0xC0, 0xC0)},
	{"Grey",	    RGB(0xC0, 0xC0, 0xC0)},
	{"LightGray",	    RGB(0xD3, 0xD3, 0xD3)},
	{"LightGrey",	    RGB(0xD3, 0xD3, 0xD3)},
	{"White",	    RGB(0xFF, 0xFF, 0xFF)},
	{"DarkRed",	    RGB(0x80, 0x00, 0x00)},
	{"Red",		    RGB(0xFF, 0x00, 0x00)},
	{"LightRed",	    RGB(0xFF, 0xA0, 0xA0)},
	{"DarkBlue",	    RGB(0x00, 0x00, 0x80)},
	{"Blue",	    RGB(0x00, 0x00, 0xFF)},
	{"LightBlue",	    RGB(0xA0, 0xA0, 0xFF)},
	{"DarkGreen",	    RGB(0x00, 0x80, 0x00)},
	{"Green",	    RGB(0x00, 0xFF, 0x00)},
	{"LightGreen",	    RGB(0xA0, 0xFF, 0xA0)},
	{"DarkCyan",	    RGB(0x00, 0x80, 0x80)},
	{"Cyan",	    RGB(0x00, 0xFF, 0xFF)},
	{"LightCyan",	    RGB(0xA0, 0xFF, 0xFF)},
	{"DarkMagenta",	    RGB(0x80, 0x00, 0x80)},
	{"Magenta",	    RGB(0xFF, 0x00, 0xFF)},
	{"LightMagenta",    RGB(0xFF, 0xA0, 0xFF)},
	{"Brown",	    RGB(0x80, 0x40, 0x40)},
	{"Yellow",	    RGB(0xFF, 0xFF, 0x00)},
	{"LightYellow",	    RGB(0xFF, 0xFF, 0xA0)},
	{"DarkYellow",	    RGB(0xBB, 0xBB, 0x00)},
	{"SeaGreen",	    RGB(0x2E, 0x8B, 0x57)},
	{"Orange",	    RGB(0xFF, 0xA5, 0x00)},
	{"Purple",	    RGB(0xA0, 0x20, 0xF0)},
	{"SlateBlue",	    RGB(0x6A, 0x5A, 0xCD)},
	{"Violet",	    RGB(0xEE, 0x82, 0xEE)},
    };

    static int endColour = NSTATIC_COLOURS;
    static int newColour = NSTATIC_COLOURS;

    int		    r, g, b;
    int		    i;

    if (name[0] == '#' && STRLEN(name) == 7)
    {
	/* Name is in "#rrggbb" format */
	r = hex_digit(name[1]) * 16 + hex_digit(name[2]);
	g = hex_digit(name[3]) * 16 + hex_digit(name[4]);
	b = hex_digit(name[5]) * 16 + hex_digit(name[6]);
	if (r < 0 || g < 0 || b < 0)
	    return INVALCOLOR;
	return RGB(r, g, b);
    }
    else
    {
	/* Check if the name is one of the colours we know */
	for (i = 0; i < endColour; i++)
	    if (STRICMP(name, table[i].name) == 0)
		return table[i].colour;
    }

    /*
     * Last attempt. Look in the file "$VIM/rgb.txt".
     */
    {
#define LINE_LEN 100
	FILE	*fd;
	char	line[LINE_LEN];
	char_u	*fname;

	fname = expand_env_save((char_u *)"$VIM/rgb.txt");
	if (fname == NULL)
	    return INVALCOLOR;

	fd = fopen((char *)fname, "rt");
	vim_free(fname);
	if (fd == NULL)
	    return INVALCOLOR;

	while (!feof(fd))
	{
	    int	    len;
	    int	    pos;
	    char    *colour;

	    fgets(line, LINE_LEN, fd);
	    len = strlen(line);

	    if (len <= 1 || line[len-1] != '\n')
		continue;

	    line[len-1] = '\0';

	    i = sscanf(line, "%d %d %d %n", &r, &g, &b, &pos);
	    if (i != 3)
		continue;

	    colour = line + pos;

	    if (STRICMP(colour, name) == 0)
	    {
		fclose(fd);
		/*
		 * Now remember this colour in the table.
		 * A LRU scheme might be better but this is simpler.
		 * Or could use a growing array.
		 */
		guicolor_T gcolour = RGB(r,g,b);

		vim_free(table[newColour].name);
		table[newColour].name = (char *)vim_strsave((char_u *)colour);
		table[newColour].colour = gcolour;

		newColour++;
		if (newColour >= NCOLOURS)
		    newColour = NSTATIC_COLOURS;
		if (endColour < NCOLOURS)
		    endColour = newColour;

		return gcolour;
	    }
	}

	fclose(fd);
    }

    return INVALCOLOR;
}

/*
 * Set the current text foreground color.
 */
    void
gui_mch_set_fg_color(
    guicolor_T	color)
{
    rgb_color rgb = GUI_TO_RGB(color);
    if (gui.vimWindow->Lock()) {
	gui.vimTextArea->SetHighColor(rgb);
	gui.vimWindow->Unlock();
    }
}

/*
 * Set the current text background color.
 */
    void
gui_mch_set_bg_color(
    guicolor_T	color)
{
    rgb_color rgb = GUI_TO_RGB(color);
    if (gui.vimWindow->Lock()) {
	gui.vimTextArea->SetLowColor(rgb);
	gui.vimWindow->Unlock();
    }
}

    void
gui_mch_draw_string(
    int		row,
    int		col,
    char_u	*s,
    int		len,
    int		flags)
{
    if (gui.vimWindow->Lock()) {
	gui.vimTextArea->mchDrawString(row, col, s, len, flags);
	gui.vimWindow->Unlock();
    }
}

/*
 * Return OK if the key with the termcap name "name" is supported.
 */
    int
gui_mch_haskey(
    char_u	*name)
{
    int i;

    for (i = 0; special_keys[i].BeKeys != 0; i++)
	if (name[0] == special_keys[i].vim_code0 &&
					 name[1] == special_keys[i].vim_code1)
	    return OK;
    return FAIL;
}

    void
gui_mch_beep()
{
    ::beep();
}

    void
gui_mch_flash(int msec)
{
    /* Do a visual beep by reversing the foreground and background colors */

    if (gui.vimWindow->Lock()) {
	BRect rect = gui.vimTextArea->Bounds();

	gui.vimTextArea->SetDrawingMode(B_OP_INVERT);
	gui.vimTextArea->FillRect(rect);
	gui.vimTextArea->Sync();
	snooze(msec * 1000);	 /* wait for a few msec */
	gui.vimTextArea->FillRect(rect);
	gui.vimTextArea->SetDrawingMode(B_OP_COPY);
	gui.vimTextArea->Flush();
	gui.vimWindow->Unlock();
    }
}

/*
 * Invert a rectangle from row r, column c, for nr rows and nc columns.
 */
    void
gui_mch_invert_rectangle(
    int		r,
    int		c,
    int		nr,
    int		nc)
{
    BRect rect;
    rect.left = FILL_X(c);
    rect.top = FILL_Y(r);
    rect.right = rect.left + nc * gui.char_width - PEN_WIDTH;
    rect.bottom = rect.top + nr * gui.char_height - PEN_WIDTH;

    if (gui.vimWindow->Lock()) {
	gui.vimTextArea->SetDrawingMode(B_OP_INVERT);
	gui.vimTextArea->FillRect(rect);
	gui.vimTextArea->SetDrawingMode(B_OP_COPY);
	gui.vimWindow->Unlock();
    }
}

/*
 * Iconify the GUI window.
 */
    void
gui_mch_iconify()
{
    if (gui.vimWindow->Lock()) {
	gui.vimWindow->Minimize(true);
	gui.vimWindow->Unlock();
    }
}

#if defined(FEAT_EVAL) || defined(PROTO)
/*
 * Bring the Vim window to the foreground.
 */
    void
gui_mch_set_foreground()
{
    /* TODO */
}
#endif

/*
 * Set the window title
 */
    void
gui_mch_settitle(
    char_u	*title,
    char_u	*icon)
{
    if (gui.vimWindow->Lock()) {
	gui.vimWindow->SetTitle((char *)title);
	gui.vimWindow->Unlock();
    }
}

/*
 * Draw a cursor without focus.
 */
    void
gui_mch_draw_hollow_cursor(guicolor_T color)
{
    gui_mch_set_fg_color(color);

    BRect r;
    r.left = FILL_X(gui.col);
    r.top = FILL_Y(gui.row);
    r.right = r.left + gui.char_width - PEN_WIDTH;
    r.bottom = r.top + gui.char_height - PEN_WIDTH;

    if (gui.vimWindow->Lock()) {
	gui.vimTextArea->StrokeRect(r);
	gui.vimWindow->Unlock();
	//gui_mch_flush();
    }
}

/*
 * Draw part of a cursor, only w pixels wide, and h pixels high.
 */
    void
gui_mch_draw_part_cursor(
    int		w,
    int		h,
    guicolor_T	color)
{
    gui_mch_set_fg_color(color);

    BRect r;
    r.left =
#ifdef FEAT_RIGHTLEFT
	/* vertical line should be on the right of current point */
	CURSOR_BAR_RIGHT ? FILL_X(gui.col + 1) - w :
#endif
	    FILL_X(gui.col);
    r.right = r.left + w - PEN_WIDTH;
    r.bottom = FILL_Y(gui.row + 1) - PEN_WIDTH;
    r.top = r.bottom - h + PEN_WIDTH;

    if (gui.vimWindow->Lock()) {
	gui.vimTextArea->FillRect(r);
	gui.vimWindow->Unlock();
	//gui_mch_flush();
    }
}

/*
 * Catch up with any queued events.  This may put keyboard input into the
 * input buffer, call resize call-backs, trigger timers etc.  If there is
 * nothing in the event queue (& no timers pending), then we return
 * immediately.
 */
    void
gui_mch_update()
{
    gui_mch_flush();
    while (port_count(gui.vdcmp) > 0 &&
	    !vim_is_input_buf_full() &&
	    gui_beos_process_event(0) >= B_OK)
	/* nothing */ ;
}

/*
 * GUI input routine called by gui_wait_for_chars().  Waits for a character
 * from the keyboard.
 *	wtime == -1		Wait forever.
 *	wtime == 0		This should never happen.
 *	wtime > 0		Wait wtime milliseconds for a character.
 * Returns OK if a character was found to be available within the given time,
 * or FAIL otherwise.
 */
    int
gui_mch_wait_for_chars(
    int		wtime)
{
    int		    focus;
    bigtime_t	    until, timeout;
    status_t	    st;

    if (wtime >= 0) {
	timeout = wtime * 1000;
	until = system_time() + timeout;
    } else {
	timeout = B_INFINITE_TIMEOUT;
    }

    focus = gui.in_focus;
    for (;;)
    {
	/* Stop or start blinking when focus changes */
	if (gui.in_focus != focus)
	{
	    if (gui.in_focus)
		gui_mch_start_blink();
	    else
		gui_mch_stop_blink();
	    focus = gui.in_focus;
	}

	gui_mch_flush();
	/*
	 * Don't use gui_mch_update() because then we will spin-lock until a
	 * char arrives, instead we use gui_beos_process_event() to hang until
	 * an event arrives.  No need to check for input_buf_full because we
	 * are returning as soon as it contains a single char.
	 */
	st = gui_beos_process_event(timeout);

	if (input_available())
	    return OK;
	if (st < B_OK)		    /* includes B_TIMED_OUT */
	    return FAIL;

	/*
	 * Calculate how much longer we're willing to wait for the
	 * next event.
	 */
	if (wtime >= 0) {
	    timeout = until - system_time();
	    if (timeout < 0)
		break;
	}
    }
    return FAIL;

}

/*
 * Output routines.
 */

/*
 * Flush any output to the screen. This is typically called before
 * the app goes to sleep.
 */
    void
gui_mch_flush()
{
    // does this need to lock the window? Apparently not but be safe.
    if (gui.vimWindow->Lock()) {
	gui.vimWindow->Flush();
	gui.vimWindow->Unlock();
    }
    return;
}

/*
 * Clear a rectangular region of the screen from text pos (row1, col1) to
 * (row2, col2) inclusive.
 */
    void
gui_mch_clear_block(
    int		row1,
    int		col1,
    int		row2,
    int		col2)
{
    if (gui.vimWindow->Lock()) {
	gui.vimTextArea->mchClearBlock(row1, col1, row2, col2);
	gui.vimWindow->Unlock();
    }
}

    void
gui_mch_clear_all()
{
    if (gui.vimWindow->Lock()) {
	gui.vimTextArea->mchClearAll();
	gui.vimWindow->Unlock();
    }
}

/*
 * Delete the given number of lines from the given row, scrolling up any
 * text further down within the scroll region.
 */
    void
gui_mch_delete_lines(
    int		row,
    int		num_lines)
{
    gui.vimTextArea->mchDeleteLines(row, num_lines);
}

/*
 * Insert the given number of lines before the given row, scrolling down any
 * following text within the scroll region.
 */
    void
gui_mch_insert_lines(
    int		row,
    int		num_lines)
{
    gui.vimTextArea->mchInsertLines(row, num_lines);
}

#if defined(FEAT_MENU) || defined(PROTO)
/*
 * Menu stuff.
 */

    void
gui_mch_enable_menu(
    int		flag)
{
    if (gui.vimWindow->Lock())
    {
	BMenuBar *menubar = gui.vimForm->MenuBar();
	menubar->SetEnabled(flag);
	gui.vimWindow->Unlock();
    }
}

    void
gui_mch_set_menu_pos(
    int		x,
    int		y,
    int		w,
    int		h)
{
    /* It will be in the right place anyway */
}

/*
 * Add a sub menu to the menu bar.
 */
    void
gui_mch_add_menu(
    vimmenu_T	*menu,
    int		idx)
{
    vimmenu_T	*parent = menu->parent;

    if (!menu_is_menubar(menu->name)
	    || (parent != NULL && parent->submenu_id == NULL))
	return;

    if (gui.vimWindow->Lock())
    {
/* Major re-write of the menu code, it was failing with memory corruption when
 * we started loading multiple files (the Buffer menu)
 *
 * Note we don't use the preference values yet, all are inserted into the
 * menubar on a first come-first served basis...
 *
 * richard@whitequeen.com jul 99
 */

	BMenu *tmp;

	if ( parent )
	    tmp = parent->submenu_id;
	else
	    tmp = gui.vimForm->MenuBar();
// make sure we don't try and add the same menu twice. The Buffers menu tries to
// do this and Be starts to crash...

	if ( ! tmp->FindItem((const char *) menu->dname)) {

	    BMenu *bmenu = new BMenu((char *)menu->dname);

	    menu->submenu_id = bmenu;

// when we add a BMenu to another Menu, it creates the interconnecting BMenuItem
	    tmp->AddItem(bmenu);

// Now its safe to query the menu for the associated MenuItem....
	    menu->id = tmp->FindItem((const char *) menu->dname);

	}
	gui.vimWindow->Unlock();
    }
}

    void
gui_mch_toggle_tearoffs(int enable)
{
    /* no tearoff menus */
}

    static BMessage *
MenuMessage(vimmenu_T *menu)
{
    BMessage *m = new BMessage('menu');
    m->AddPointer("VimMenu", (void *)menu);

    return m;
}

/*
 * Add a menu item to a menu
 */
    void
gui_mch_add_menu_item(
    vimmenu_T	*menu,
    int		idx)
{
    int		mnemonic = 0;
    vimmenu_T	*parent = menu->parent;

    if (parent->submenu_id == NULL)
	return;

#ifdef never
    /* why not add separators ?
     * richard
     */
    /* Don't add menu separator */
    if (menu_is_separator(menu->name))
	return;
#endif

    /* TODO: use menu->actext */
    /* This is difficult, since on Be, an accelerator must be a single char
     * and a lot of Vim ones are the standard VI commands.
     *
     * Punt for Now...
     * richard@whiequeen.com jul 99
     */
    if (gui.vimWindow->Lock())
    {
	if ( menu_is_separator(menu->name)) {
	    BSeparatorItem *item = new BSeparatorItem();
	    parent->submenu_id->AddItem(item);
	    menu->id = item;
	    menu->submenu_id = NULL;
	}
	else {
	    BMenuItem *item = new BMenuItem((char *)menu->dname,
		    MenuMessage(menu));
	    item->SetTarget(gui.vimTextArea);
	    item->SetTrigger((char) menu->mnemonic);
	    parent->submenu_id->AddItem(item);
	    menu->id = item;
	    menu->submenu_id = NULL;
	}
	gui.vimWindow->Unlock();
    }
}

/*
 * Destroy the machine specific menu widget.
 */
    void
gui_mch_destroy_menu(
    vimmenu_T	*menu)
{
    if (gui.vimWindow->Lock())
    {
	assert(menu->submenu_id == NULL || menu->submenu_id->CountItems() == 0);
	/*
	 * Detach this menu from its parent, so that it is not deleted
	 * twice once we get to delete that parent.
	 * Deleting a BMenuItem also deletes the associated BMenu, if any
	 * (which does not have any items anymore since they were
	 * removed and deleted before).
	 */
	BMenu *bmenu = menu->id->Menu();
	if (bmenu)
	{
	    bmenu->RemoveItem(menu->id);
	    /*
	     * If we removed the last item from the menu bar,
	     * resize it out of sight.
	     */
	    if (bmenu == gui.vimForm->MenuBar() && bmenu->CountItems() == 0)
	    {
		bmenu->ResizeTo(-MENUBAR_MARGIN, -MENUBAR_MARGIN);
	    }
	}
	delete menu->id;
	menu->id = NULL;
	menu->submenu_id = NULL;

	gui.menu_height = (int) gui.vimForm->MenuHeight();
	gui.vimWindow->Unlock();
    }
}

/*
 * Make a menu either grey or not grey.
 */
    void
gui_mch_menu_grey(
    vimmenu_T	*menu,
    int		grey)
{
    if (menu->id != NULL)
	menu->id->SetEnabled(!grey);
}

/*
 * Make menu item hidden or not hidden
 */
    void
gui_mch_menu_hidden(
    vimmenu_T	*menu,
    int		hidden)
{
    if (menu->id != NULL)
	menu->id->SetEnabled(!hidden);
}

/*
 * This is called after setting all the menus to grey/hidden or not.
 */
    void
gui_mch_draw_menubar()
{
    /* Nothing to do in BeOS */
}

#endif /* FEAT_MENU */

/* Mouse stuff */

#ifdef FEAT_CLIPBOARD
/*
 * Clipboard stuff, for cutting and pasting text to other windows.
 */
char textplain[] = "text/plain";
char vimselectiontype[] = "application/x-vnd.Rhialto-Vim-selectiontype";

/*
 * Get the current selection and put it in the clipboard register.
 */
    void
clip_mch_request_selection(VimClipboard *cbd)
{
    if (be_clipboard->Lock())
    {
	BMessage *m = be_clipboard->Data();
	//m->PrintToStream();

	char_u *string = NULL;
	ssize_t stringlen = -1;

	if (m->FindData(textplain, B_MIME_TYPE,
				   (const void **)&string, &stringlen) == B_OK
		|| m->FindString("text", (const char **)&string) == B_OK)
	{
	    if (stringlen == -1)
		stringlen = STRLEN(string);

	    int type;
	    char *seltype;
	    ssize_t seltypelen;

	    /*
	     * Try to get the special vim selection type first
	     */
	    if (m->FindData(vimselectiontype, B_MIME_TYPE,
		    (const void **)&seltype, &seltypelen) == B_OK)
	    {
		switch (*seltype)
		{
		    default:
		    case 'L':	type = MLINE;	break;
		    case 'C':	type = MCHAR;	break;
#ifdef FEAT_VISUAL
		    case 'B':	type = MBLOCK;	break;
#endif
		}
	    }
	    else
	    {
		/* Otherwise use heuristic as documented */
		type = memchr(string, stringlen, '\n') ? MLINE : MCHAR;
	    }
	    clip_yank_selection(type, string, (long)stringlen, cbd);
	}
	be_clipboard->Unlock();
    }
}
/*
 * Make vim the owner of the current selection.
 */
    void
clip_mch_lose_selection(VimClipboard *cbd)
{
    /* Nothing needs to be done here */
}

/*
 * Make vim the owner of the current selection.  Return OK upon success.
 */
    int
clip_mch_own_selection(VimClipboard *cbd)
{
    /*
     * Never actually own the clipboard.  If another application sets the
     * clipboard, we don't want to think that we still own it.
     */
    return FAIL;
}

/*
 * Send the current selection to the clipboard.
 */
    void
clip_mch_set_selection(VimClipboard *cbd)
{
    if (be_clipboard->Lock())
    {
	be_clipboard->Clear();
	BMessage *m = be_clipboard->Data();
	assert(m);

	/* If the '*' register isn't already filled in, fill it in now */
	cbd->owned = TRUE;
	clip_get_selection(cbd);
	cbd->owned = FALSE;

	char_u  *str = NULL;
	long_u  count;
	int	type;

	type = clip_convert_selection(&str, &count, cbd);

	if (type < 0)
	    return;

	m->AddData(textplain, B_MIME_TYPE, (void *)str, count);

	/* Add type of selection */
	char    vtype;
	switch (type)
	{
	    default:
	    case MLINE:    vtype = 'L';    break;
	    case MCHAR:    vtype = 'C';    break;
#ifdef FEAT_VISUAL
	    case MBLOCK:   vtype = 'B';    break;
#endif
	}
	m->AddData(vimselectiontype, B_MIME_TYPE, (void *)&vtype, 1);

	vim_free(str);

	be_clipboard->Commit();
	be_clipboard->Unlock();
    }
}

#endif	/* FEAT_CLIPBOARD */

/*
 * Return the RGB value of a pixel as long.
 */
    long_u
gui_mch_get_rgb(guicolor_T pixel)
{
    rgb_color rgb = GUI_TO_RGB(pixel);

    return ((rgb.red & 0xff) << 16) + ((rgb.green & 0xff) << 8)
							  + (rgb.blue & 0xff);
}

    void
gui_mch_setmouse(int x, int y)
{
    TRACE();
    /* TODO */
}

    void
gui_mch_show_popupmenu(vimmenu_T *menu)
{
    TRACE();
    /* TODO */
}

int
gui_mch_get_mouse_x()
{
    TRACE();
    return 0;
}


int
gui_mch_get_mouse_y()
{
    TRACE();
    return 0;
}

} /* extern "C" */