hvirtual/guicast/bcwindowbase.C

Go to the documentation of this file.

#include "bcbitmap.h"
#include "bcclipboard.h"
#include "bcdisplayinfo.h"
#include "bcmenubar.h"
#include "bcpixmap.h"
#include "bcpopup.h"
#include "bcpopupmenu.h"
#include "bcrepeater.h"
#include "bcresources.h"
#include "bcsignals.h"
#include "bcsubwindow.h"
#include "bcsynchronous.h"
#include "bctimer.h"
#include "bcwidgetgrid.h"
#include "bcwindowbase.h"
#include "bcwindowevents.h"
#include "colormodels.h"
#include "colors.h"
#include "condition.h"
#include "cursors.h"
#include "bchash.h"
#include "fonts.h"
#include "keys.h"
#include "language.h"
#include "mutex.h"
#include "sizes.h"
#include "vframe.h"

#ifdef HAVE_GL
#include <GL/gl.h>
#endif
#include <string.h>
#include <unistd.h>

#include <X11/extensions/Xvlib.h>
#include <X11/extensions/shape.h>


BC_ResizeCall::BC_ResizeCall(int w, int h)
{
        this->w = w;
        this->h = h;
}











BC_Resources BC_WindowBase::resources;

Window XGroupLeader = 0;

BC_WindowBase::BC_WindowBase()
{
//printf("BC_WindowBase::BC_WindowBase 1\n");
        BC_WindowBase::initialize();
}

BC_WindowBase::~BC_WindowBase()
{
#ifdef HAVE_LIBXXF86VM
   if(window_type == VIDMODE_SCALED_WINDOW && vm_switched)
   {
           restore_vm();   
   }
#endif

        hide_tooltip();
        if(window_type != MAIN_WINDOW)
        {
                if(top_level->active_menubar == this) top_level->active_menubar = 0;
                if(top_level->active_popup_menu == this) top_level->active_popup_menu = 0;
                if(top_level->active_subwindow == this) top_level->active_subwindow = 0;
// Remove pointer from parent window to this
                parent_window->subwindows->remove(this);
        }


// Delete the subwindows
        is_deleting = 1;
        if(subwindows)
        {
                while(subwindows->total)
                {
// Subwindow removes its own pointer
                        delete subwindows->values[0];
                }
                delete subwindows;
        }

        if(widgetgrids)
        {
                while (widgetgrids->total) 
                {
                        delete widgetgrids->last();
                        widgetgrids->remove();
                }
                delete widgetgrids;
        }
                

        delete pixmap;

// Destroyed in synchronous thread if gl context exists.
#ifdef HAVE_GL
        if(!gl_win_context || !get_resources()->get_synchronous())
#endif
                XDestroyWindow(top_level->display, win);

        if(bg_pixmap && !shared_bg_pixmap) delete bg_pixmap;
        if(icon_pixmap) delete icon_pixmap;
        if(temp_bitmap) delete temp_bitmap;





        if(window_type == MAIN_WINDOW) 
        {
                XFreeGC(display, gc);
#ifdef HAVE_XFT
                if(largefont_xft) 
                        XftFontClose (display, (XftFont*)largefont_xft);
                if(mediumfont_xft) 
                        XftFontClose (display, (XftFont*)mediumfont_xft);
                if(smallfont_xft) 
                        XftFontClose (display, (XftFont*)smallfont_xft);
#endif
                flush();
// Can't close display if another thread is waiting for events.
// Synchronous thread must delete display if gl_context exists.
#ifdef HAVE_GL
                if(!gl_win_context || !get_resources()->get_synchronous())
#endif
                        XCloseDisplay(display);
                clipboard->stop_clipboard();
                delete clipboard;
        }
        else
        {
                flush();
        }

// Must be last reference to display.
// This only works if it's a MAIN_WINDOW since the display deletion for
// a subwindow is not determined by the subwindow.
#ifdef HAVE_GL
        if(gl_win_context && get_resources()->get_synchronous())
        {
                printf("BC_WindowBase::~BC_WindowBase window deleted but opengl deletion is not\n"
                        "implemented for BC_Pixmap.\n");
                get_resources()->get_synchronous()->delete_window(this);
        }
#endif

        resize_history.remove_all_objects();
        common_events.remove_all_objects();
        delete event_lock;
        delete event_condition;

        UNSET_ALL_LOCKS(this)
}

int BC_WindowBase::initialize()
{
        test_keypress = 0;
        is_deleting = 0;
        window_lock = 0;
        x = 0; 
        y = 0; 
        w = 0; 
        h = 0;
        bg_color = -1;
        top_level = 0;
        parent_window = 0;
        subwindows = 0;
        widgetgrids = 0;
        xvideo_port_id = -1;
        video_on = 0;
        motion_events = 0;
        resize_events = 0;
        translation_events = 0;
        ctrl_mask = shift_mask = alt_mask = 0;
        cursor_x = cursor_y = button_number = 0;
        button_down = 0;
        button_pressed = 0;
        button_time1 = button_time2 = 0;
        double_click = 0;
        last_motion_win = 0;
        key_pressed = 0;
        active_menubar = 0;
        active_popup_menu = 0;
        active_subwindow = 0;
        pixmap = 0;
        bg_pixmap = 0;
        tooltip_text[0] = 0;
        persistant_tooltip = 0;
//      next_repeat_id = 0;
        tooltip_popup = 0;
        tooltip_done = 0;
        current_font = MEDIUMFONT;
        current_color = BLACK;
        current_cursor = ARROW_CURSOR;
        hourglass_total = 0;
        is_dragging = 0;
        shared_bg_pixmap = 0;
        icon_pixmap = 0;
        window_type = MAIN_WINDOW;
        translation_count = 0;
        x_correction = y_correction = 0;
        temp_bitmap = 0;
        tooltip_on = 0;
        temp_cursor = 0;
        toggle_value = 0;
        toggle_drag = 0;
        has_focus = 0;
        is_hourglass = 0;
        is_transparent = 0;
#ifdef HAVE_LIBXXF86VM
    vm_switched = 0;
#endif
        largefont_xft = 0;
        mediumfont_xft = 0;
        smallfont_xft = 0;
// Need these right away since put_event is called before run_window sometimes.
        event_lock = new Mutex("BC_WindowBase::event_lock");
        event_condition = new Condition(0, "BC_WindowBase::event_condition");
        cursor_timer = new Timer;
        event_thread = 0;
#ifdef HAVE_GL
        gl_win_context = 0;
#endif

        return 0;
}

#define DEFAULT_EVENT_MASKS EnterWindowMask | \
                        LeaveWindowMask | \
                        ButtonPressMask | \
                        ButtonReleaseMask | \
                        PointerMotionMask | \
                        FocusChangeMask
                        

int BC_WindowBase::create_window(BC_WindowBase *parent_window,
                                char *title, 
                                int x,
                                int y,
                                int w, 
                                int h, 
                                int minw, 
                                int minh, 
                                int allow_resize,
                                int private_color, 
                                int hide,
                                int bg_color,
                                char *display_name,
                                int window_type,
                                BC_Pixmap *bg_pixmap,
                                int group_it)
{
        XSetWindowAttributes attr;
        unsigned long mask;
        XSizeHints size_hints;
        int root_w;
        int root_h;
#ifdef HAVE_LIBXXF86VM
    int vm;
#endif

        id = get_resources()->get_id();


        get_resources()->create_window_lock->lock("BC_WindowBase::create_window");

    if(parent_window) top_level = parent_window->top_level;

#ifdef HAVE_LIBXXF86VM
    if(window_type == VIDMODE_SCALED_WINDOW)
            closest_vm(&vm,&w,&h);
#endif

        this->x = x;
        this->y = y;
        this->w = w;
        this->h = h;
        this->bg_color = bg_color;
        this->window_type = window_type;
        this->hidden = hide;
        this->private_color = private_color;
        this->parent_window = parent_window;
        this->bg_pixmap = bg_pixmap;
        this->allow_resize = allow_resize;
        strcpy(this->title, _(title));
        if(bg_pixmap) shared_bg_pixmap = 1;

        if(parent_window) top_level = parent_window->top_level;

        subwindows = new BC_SubWindowList;
        widgetgrids = new BC_WidgetGridList;

// Mandatory setup
        if(window_type == MAIN_WINDOW)
        {
                top_level = this;
                parent_window = this;

// This function must be the first Xlib
// function a multi-threaded program calls
                XInitThreads();


// get the display connection
                display = init_display(display_name);
//              event_display = init_display(display_name);

// Fudge window placement
                root_w = get_root_w(1, 0);
                root_h = get_root_h(0);
                if(this->x + this->w > root_w) this->x = root_w - this->w;
                if(this->y + this->h > root_h) this->y = root_h - this->h;
                if(this->x < 0) this->x = 0;
                if(this->y < 0) this->y = 0;
                screen = DefaultScreen(display);
                rootwin = RootWindow(display, screen);


                vis = DefaultVisual(display, screen);
                default_depth = DefaultDepth(display, screen);

                client_byte_order = (*(u_int32_t*)"a   ") & 0x00000001;
                server_byte_order = (XImageByteOrder(display) == MSBFirst) ? 0 : 1;


// This must be done before fonts to know if antialiasing is available.
                init_colors();
// get the resources
                if(resources.use_shm < 0) resources.initialize_display(this);
                x_correction = get_resources()->get_left_border();
                y_correction = get_resources()->get_top_border();

                if(this->bg_color == -1)
                        this->bg_color = resources.get_bg_color();

// printf("bcwindowbase 1 %s\n", title);
// if(window_type == MAIN_WINDOW) sleep(1);
// printf("bcwindowbase 10\n");
                init_fonts();
                init_gc();
                init_cursors();

// Create the window
                mask = CWEventMask | 
                                CWBackPixel | 
                                CWColormap | 
                                CWCursor;

                attr.event_mask = DEFAULT_EVENT_MASKS |
                        StructureNotifyMask | 
                        KeyPressMask;

                attr.background_pixel = get_color(this->bg_color);
                attr.colormap = cmap;
                attr.cursor = get_cursor_struct(ARROW_CURSOR);

                win = XCreateWindow(display, 
                        rootwin, 
                        this->x, 
                        this->y, 
                        this->w, 
                        this->h, 
                        0, 
                        top_level->default_depth, 
                        InputOutput, 
                        vis, 
                        mask, 
                        &attr);

                XGetNormalHints(display, win, &size_hints);

                size_hints.flags = PSize | PMinSize | PMaxSize;
                size_hints.width = this->w;
                size_hints.height = this->h;
                size_hints.min_width = allow_resize ? minw : this->w;
                size_hints.max_width = allow_resize ? 32767 : this->w; 
                size_hints.min_height = allow_resize ? minh : this->h;
                size_hints.max_height = allow_resize ? 32767 : this->h; 
                if(x > -BC_INFINITY && x < BC_INFINITY)
                {
                        size_hints.flags |= PPosition;
                        size_hints.x = this->x;
                        size_hints.y = this->y;
                }

                XSetStandardProperties(display, 
                        win, 
                        title, 
                        title, 
                        None, 
                        0, 
                        0, 
                        &size_hints);
                get_atoms();
                
                clipboard = new BC_Clipboard(display_name);
                clipboard->start_clipboard();

                if (group_it)
                {
                        Atom ClientLeaderXAtom;
                        if (XGroupLeader == 0)
                                XGroupLeader = win;
                        char *instance_name = "cinelerra";
                        char *class_name = "Cinelerra";
                        XClassHint *class_hints = XAllocClassHint(); 
                        class_hints->res_name = instance_name;
                        class_hints->res_class = class_name;
                        XSetClassHint(top_level->display, win, class_hints);
                        XFree(class_hints);
                        ClientLeaderXAtom = XInternAtom(display, "WM_CLIENT_LEADER", True);
                        XChangeProperty(display, 
                                        win, 
                                        ClientLeaderXAtom, 
                                        XA_WINDOW, 
                                        32, 
                                        PropModeReplace, 
                                        (unsigned char *)&XGroupLeader, 
                                        true);

                }
                
        }

#ifdef HAVE_LIBXXF86VM
    if(window_type == VIDMODE_SCALED_WINDOW && vm != -1)
    {
            scale_vm (vm);
            vm_switched = 1;
    }
#endif

#ifdef HAVE_LIBXXF86VM
    if(window_type == POPUP_WINDOW || window_type == VIDMODE_SCALED_WINDOW)
#else
    if(window_type == POPUP_WINDOW)
#endif
        {
                mask = CWEventMask | 
                        CWBackPixel | 
                        CWColormap | 
                        CWOverrideRedirect | 
                        CWSaveUnder | 
                        CWCursor;

                attr.event_mask = DEFAULT_EVENT_MASKS |
                        KeyPressMask;

                if(this->bg_color == -1)
                        this->bg_color = resources.get_bg_color();
                attr.background_pixel = top_level->get_color(bg_color);
                attr.colormap = top_level->cmap;
                if(top_level->is_hourglass)
                        attr.cursor = top_level->get_cursor_struct(HOURGLASS_CURSOR);
                else
                        attr.cursor = top_level->get_cursor_struct(ARROW_CURSOR);
                attr.override_redirect = True;
                attr.save_under = True;

                win = XCreateWindow(top_level->display, 
                        top_level->rootwin, 
                        this->x, 
                        this->y, 
                        this->w, 
                        this->h, 
                        0, 
                        top_level->default_depth, 
                        InputOutput, 
                        top_level->vis, 
                        mask, 
                        &attr);
        }

        if(window_type == SUB_WINDOW)
        {
                mask = CWBackPixel | 
                        CWEventMask | 
                        CWCursor;
                attr.event_mask = DEFAULT_EVENT_MASKS;
                attr.background_pixel = top_level->get_color(this->bg_color);
                if(top_level->is_hourglass)
                        attr.cursor = top_level->get_cursor_struct(HOURGLASS_CURSOR);
                else
                        attr.cursor = top_level->get_cursor_struct(ARROW_CURSOR);
                win = XCreateWindow(top_level->display, 
                        parent_window->win, 
                        this->x, 
                        this->y, 
                        this->w, 
                        this->h, 
                        0, 
                        top_level->default_depth, 
                        InputOutput, 
                        top_level->vis, 
                        mask, 
                        &attr);
                init_window_shape();
                XMapWindow(top_level->display, win);
        }

// Create pixmap for all windows
        pixmap = new BC_Pixmap(this, this->w, this->h);


// Set up options for main window
        if(window_type == MAIN_WINDOW)
        {
                if(get_resources()->bg_image && !bg_pixmap && bg_color < 0)
                {
                        this->bg_pixmap = new BC_Pixmap(this, 
                                get_resources()->bg_image, 
                                PIXMAP_OPAQUE);
                }

                if(!hidden) show_window();

        }




        draw_background(0, 0, this->w, this->h);
        flash();

// Set up options for popup window
#ifdef HAVE_LIBXXF86VM
    if(window_type == POPUP_WINDOW || window_type == VIDMODE_SCALED_WINDOW)
#else
    if(window_type == POPUP_WINDOW)
#endif
        {
                init_window_shape();
                if(!hidden) show_window();
        }
        get_resources()->create_window_lock->unlock();

        return 0;
}

Display* BC_WindowBase::init_display(char *display_name)
{
        Display* display;

        if(display_name && display_name[0] == 0) display_name = NULL;
        if((display = XOpenDisplay(display_name)) == NULL)
        {
                printf("BC_WindowBase::init_display: cannot connect to X server %s\n", 
                        display_name);
                if(getenv("DISPLAY") == NULL)
        {
                        printf("'DISPLAY' environment variable not set.\n");
                        exit(1);
                }
                else
// Try again with default display.
                {
                        if((display = XOpenDisplay(0)) == NULL)
                        {
                                printf("BC_WindowBase::init_display: cannot connect to default X server.\n");
                                exit(1);
                        }
                }
        }
        return display;
}

Display* BC_WindowBase::get_display()
{
        return top_level->display;
}

int BC_WindowBase::get_screen()
{
        return top_level->screen;
}

int BC_WindowBase::run_window()
{
        done = 0;
        return_value = 0;


// Events may have been sent before run_window so can't initialize them here.

// Start tooltips
        if(window_type == MAIN_WINDOW)
        {
//              tooltip_id = get_repeat_id();
                set_repeat(get_resources()->tooltip_delay);
        }

// Start X server events
        event_thread = new BC_WindowEvents(this);
        event_thread->start();

// Start common events
        while(!done)
        {
                dispatch_event();
        }

        unset_all_repeaters();
        hide_tooltip();
        delete event_thread;
        event_thread = 0;
        event_condition->reset();
        common_events.remove_all_objects();
        done = 0;

        return return_value;
}

int BC_WindowBase::get_key_masks(XEvent *event)
{
// printf("BC_WindowBase::get_key_masks %llx\n", 
// event->xkey.state);
// ctrl key down
        ctrl_mask = (event->xkey.state & ControlMask) ? 1 : 0;
// shift key down
        shift_mask = (event->xkey.state & ShiftMask) ? 1 : 0;
        alt_mask = (event->xkey.state & Mod1Mask) ? 1 : 0;
        return 0;
}







int BC_WindowBase::dispatch_event()
{
        XEvent *event = 0;
    Window tempwin;
        KeySym keysym;
        char keys_return[2];
        int result;
        XClientMessageEvent *ptr;
        int temp;
        int cancel_resize, cancel_translation;

        key_pressed = 0;

// If an event is waiting get it, otherwise
// wait for next event only if there are no compressed events.
        if(get_event_count() || 
                (!motion_events && !resize_events && !translation_events))
        {
//              XNextEvent(display, event);
                event = get_event();
// Lock out window deletions
                lock_window("BC_WindowBase::dispatch_event 1");
//              get_key_masks(event);
        }
        else
// Handle compressed events
        {
                lock_window("BC_WindowBase::dispatch_event 2");
                if(resize_events)
                        dispatch_resize_event(last_resize_w, last_resize_h);
                else
                if(motion_events)
                        dispatch_motion_event();
                else
                if(translation_events)
                        dispatch_translation_event();

                unlock_window();
                return 0;
        }

//printf("1 %s %p %d\n", title, event, event->type);
        switch(event->type)
        {
                case ClientMessage:
// Clear the resize buffer
                        if(resize_events) dispatch_resize_event(last_resize_w, last_resize_h);
// Clear the motion buffer since this can clear the window
                        if(motion_events)
                        {
                                dispatch_motion_event();
                        }

                        ptr = (XClientMessageEvent*)event;


                if(ptr->message_type == ProtoXAtom && 
                                ptr->data.l[0] == DelWinXAtom)
                {
                                close_event();
                        }
                        else
                        if(ptr->message_type == RepeaterXAtom)
                        {
                                dispatch_repeat_event(ptr->data.l[0]);
// Make sure the repeater still exists.
//                              for(int i = 0; i < repeaters.total; i++)
//                              {
//                                      if(repeaters.values[i]->repeat_id == ptr->data.l[0])
//                                      {
//                                              dispatch_repeat_event_master(ptr->data.l[0]);
//                                              break;
//                                      }
//                              }
                        }
                        else
                        if(ptr->message_type == SetDoneXAtom)
                        {
                                done = 1;
                        } else
                        { // We currently use X marshalling for xatom events, we can switch to something else later
                                recieve_custom_xatoms((xatom_event *)ptr);
                        }
                        break;

                case FocusIn:
                        has_focus = 1;
                        dispatch_focus_in();
                        break;

                case FocusOut:
                        has_focus = 0;
                        dispatch_focus_out();
                        break;

// Maximized
                case MapNotify:
                        break;

// Minimized
                case UnmapNotify:
                        break;

                case ButtonPress:
                        get_key_masks(event);
                        cursor_x = event->xbutton.x;
                        cursor_y = event->xbutton.y;
                        button_number = event->xbutton.button;
                        event_win = event->xany.window;
                        if (button_number != 4 && button_number != 5)
                                button_down = 1;
                        button_pressed = event->xbutton.button;
                        button_time1 = button_time2;
                        button_time2 = event->xbutton.time;
                        drag_x = cursor_x;
                        drag_y = cursor_y;
                        drag_win = event_win;
                        drag_x1 = cursor_x - get_resources()->drag_radius;
                        drag_x2 = cursor_x + get_resources()->drag_radius;
                        drag_y1 = cursor_y - get_resources()->drag_radius;
                        drag_y2 = cursor_y + get_resources()->drag_radius;

                        if(button_time2 - button_time1 < resources.double_click)
                        {
// Ignore triple clicks
                                double_click = 1; 
                                button_time2 = button_time1 = 0; 
                        }
                        else 
                                double_click = 0;

                        dispatch_button_press();
                        break;

                case ButtonRelease:
                        get_key_masks(event);
                        button_number = event->xbutton.button;
                        event_win = event->xany.window;
                        if (button_number != 4 && button_number != 5) 
                                button_down = 0;

                        dispatch_button_release();

                        break;

                case Expose:
                        event_win = event->xany.window;
                        dispatch_expose_event();
                        break;

                case MotionNotify:
                        get_key_masks(event);
// Dispatch previous motion event if this is a subsequent motion from a different window
                        if(motion_events && last_motion_win != event->xany.window)
                        {
                                dispatch_motion_event();
                        }

// Buffer the current motion
                        motion_events = 1;
                        last_motion_x = event->xmotion.x;
                        last_motion_y = event->xmotion.y;
                        last_motion_win = event->xany.window;
                        break;

                case ConfigureNotify:
                        get_key_masks(event);
                        XTranslateCoordinates(top_level->display, 
                                top_level->win, 
                                top_level->rootwin, 
                                0, 
                                0, 
                                &last_translate_x, 
                                &last_translate_y, 
                                &tempwin);
                        last_resize_w = event->xconfigure.width;
                        last_resize_h = event->xconfigure.height;

                        cancel_resize = 0;
                        cancel_translation = 0;

// Resize history prevents responses to recursive resize requests
                        for(int i = 0; i < resize_history.total && !cancel_resize; i++)
                        {
                                if(resize_history.values[i]->w == last_resize_w &&
                                        resize_history.values[i]->h == last_resize_h)
                                {
                                        delete resize_history.values[i];
                                        resize_history.remove_number(i);
                                        cancel_resize = 1;
                                }
                        }

                        if(last_resize_w == w && last_resize_h == h)
                                cancel_resize = 1;

                        if(!cancel_resize)
                        {
                                resize_events = 1;
                        }

                        if((last_translate_x == x && last_translate_y == y))
                                cancel_translation = 1;

                        if(!cancel_translation)
                        {
                                translation_events = 1;
                        }

                        translation_count++;
                        break;

                case KeyPress:
                        get_key_masks(event);
                        keys_return[0] = 0;
                        XLookupString((XKeyEvent*)event, keys_return, 1, &keysym, 0);

// printf("BC_WindowBase::dispatch_event 2 %llx\n", 
// event->xkey.state);
// block out control keys
                        if(keysym > 0xffe0 && keysym < 0xffff) break;


                        if(test_keypress) printf("BC_WindowBase::dispatch_event %x\n", keysym);


                        switch(keysym)
                        {
// block out extra keys
                        case XK_Alt_L:      
                        case XK_Alt_R:      
                        case XK_Shift_L:    
                        case XK_Shift_R:    
                        case XK_Control_L:  
                        case XK_Control_R:  
                                        key_pressed = 0;         
                                        break;

// Translate key codes
                                case XK_Return:     key_pressed = RETURN;    break;
                        case XK_Up:         key_pressed = UP;        break;
                                case XK_Down:       key_pressed = DOWN;      break;
                                case XK_Left:       key_pressed = LEFT;      break;
                        case XK_Right:      key_pressed = RIGHT;     break;
                        case XK_Next:       key_pressed = PGDN;      break;
                        case XK_Prior:      key_pressed = PGUP;      break;
                        case XK_BackSpace:  key_pressed = BACKSPACE; break;
                        case XK_Escape:     key_pressed = ESC;       break;
                        case XK_Tab:
                                        if(shift_down())
                                                key_pressed = LEFTTAB;
                                        else
                                                key_pressed = TAB;       
                                        break;
                                case XK_ISO_Left_Tab: key_pressed = LEFTTAB; break;
                                case XK_underscore: key_pressed = '_';       break;
                        case XK_asciitilde: key_pressed = '~';       break;
                                case XK_Delete:     key_pressed = DELETE;    break;
                                case XK_Home:       key_pressed = HOME;      break;
                                case XK_End:        key_pressed = END;       break;

// number pad
                                case XK_KP_Enter:       key_pressed = KPENTER;   break;
                                case XK_KP_Add:         key_pressed = KPPLUS;    break;
                                case XK_KP_1:
                                case XK_KP_End:         key_pressed = KP1;       break;
                                case XK_KP_2:
                                case XK_KP_Down:        key_pressed = KP2;       break;
                                case XK_KP_3:
                                case XK_KP_Page_Down:   key_pressed = KP3;       break;
                                case XK_KP_4:
                                case XK_KP_Left:        key_pressed = KP4;       break;
                                case XK_KP_5:
                                case XK_KP_Begin:       key_pressed = KP5;       break;
                                case XK_KP_6:
                                case XK_KP_Right:       key_pressed = KP6;       break;
                                case XK_KP_0:
                                case XK_KP_Insert:      key_pressed = KPINS;     break;
                                case XK_KP_Decimal:
                                case XK_KP_Delete:      key_pressed = KPDEL;     break;
                        default:           
                                        //key_pressed = keys_return[0]; 
                                        key_pressed = keysym & 0xff;
                                        break;
                        }

//printf("BC_WindowBase::dispatch_event %d %d %x\n", shift_down(), alt_down(), key_pressed);
                        result = dispatch_keypress_event();
// Handle some default keypresses
                        if(!result)
                        {
                                if(key_pressed == 'w' ||
                                        key_pressed == 'W')
                                {
                                        close_event();
                                }
                        }
                        break;

                case LeaveNotify:
                        event_win = event->xany.window;
                        dispatch_cursor_leave();
                        break;

                case EnterNotify:
                        event_win = event->xany.window;
                        cursor_x = event->xcrossing.x;
                        cursor_y = event->xcrossing.y;
                        dispatch_cursor_enter();
                        break;
        }
//printf("100 %s %p %d\n", title, event, event->type);

        unlock_window();
        if(event) delete event;
        return 0;
}

int BC_WindowBase::dispatch_expose_event()
{
        int result = 0;
        for(int i = 0; i < subwindows->total && !result; i++)
        {
                result = subwindows->values[i]->dispatch_expose_event();
        }

// Propagate to user
        if(!result) expose_event();
        return result;
}

int BC_WindowBase::dispatch_resize_event(int w, int h)
{
// Can't store new w and h until the event is handles 
// because bcfilebox depends on the old w and h to
// reposition widgets.
        if(window_type == MAIN_WINDOW)
        {
                resize_events = 0;
                delete pixmap;
                pixmap = new BC_Pixmap(this, w, h);

                clear_box(0, 0, w, h);
        }

// Propagate to subwindows
        for(int i = 0; i < subwindows->total; i++)
        {
                subwindows->values[i]->dispatch_resize_event(w, h);
        }

// Propagate to user
        resize_event(w, h);

        if(window_type == MAIN_WINDOW)
        {
                this->w = w;
                this->h = h;