diff --git a/src/gui_beos.cc b/src/gui_beos.cc
new file mode 100644
index 0000000..e2c6598
--- /dev/null
+++ b/src/gui_beos.cc
@@ -0,0 +1,3347 @@
+/* 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;
+}
+
+/*
+ * 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" */