src/common/popupcmn.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        common/popupcmn.cpp
// Purpose:     implementation of wxPopupTransientWindow
// Author:      Vadim Zeitlin
// Modified by:
// Created:     06.01.01
// RCS-ID:      $Id$
// Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// License:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
    #pragma implementation "popupwinbase.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_POPUPWIN

#include "wx/popupwin.h"

#ifndef WX_PRECOMP
    #include "wx/combobox.h"        // wxComboControl
    #include "wx/app.h"             // wxPostEvent
    #include "wx/log.h"
    #include "wx/app.h"
#endif //WX_PRECOMP

#ifdef __WXUNIVERSAL__
    #include "wx/univ/renderer.h"
#endif // __WXUNIVERSAL__

#ifdef __WXGTK__
    #include <gtk/gtk.h>
#endif
#ifdef __WXX11__
#include "wx/x11/private.h"
#endif

IMPLEMENT_DYNAMIC_CLASS(wxPopupWindow, wxWindow)
IMPLEMENT_DYNAMIC_CLASS(wxPopupTransientWindow, wxPopupWindow)

#if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
    IMPLEMENT_DYNAMIC_CLASS(wxPopupComboWindow, wxPopupTransientWindow)
#endif

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

// event handlers which we use to intercept events which cause the popup to
// disappear
class wxPopupWindowHandler : public wxEvtHandler
{
public:
    wxPopupWindowHandler(wxPopupTransientWindow *popup) : m_popup(popup) {}
    ~wxPopupWindowHandler();

protected:
    // event handlers
    void OnLeftDown(wxMouseEvent& event);

private:
    wxPopupTransientWindow *m_popup;

    DECLARE_EVENT_TABLE()
    DECLARE_NO_COPY_CLASS(wxPopupWindowHandler)
};

class wxPopupFocusHandler : public wxEvtHandler
{
public:
    wxPopupFocusHandler(wxPopupTransientWindow *popup) : m_popup(popup) {}
    ~wxPopupFocusHandler();

protected:
    void OnKillFocus(wxFocusEvent& event);
    void OnKeyDown(wxKeyEvent& event);

private:
    wxPopupTransientWindow *m_popup;

    DECLARE_EVENT_TABLE()
    DECLARE_NO_COPY_CLASS(wxPopupFocusHandler)
};

// ----------------------------------------------------------------------------
// event tables
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(wxPopupWindowHandler, wxEvtHandler)
    EVT_LEFT_DOWN(wxPopupWindowHandler::OnLeftDown)
END_EVENT_TABLE()

BEGIN_EVENT_TABLE(wxPopupFocusHandler, wxEvtHandler)
    EVT_KILL_FOCUS(wxPopupFocusHandler::OnKillFocus)
    EVT_KEY_DOWN(wxPopupFocusHandler::OnKeyDown)
END_EVENT_TABLE()

BEGIN_EVENT_TABLE(wxPopupTransientWindow, wxPopupWindow)
#ifdef __WXMSW__
    EVT_IDLE(wxPopupTransientWindow::OnIdle)
#endif
END_EVENT_TABLE()

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxPopupWindowBase
// ----------------------------------------------------------------------------

wxPopupWindowBase::~wxPopupWindowBase()
{
    // this destructor is required for Darwin
}

bool wxPopupWindowBase::Create(wxWindow* WXUNUSED(parent), int WXUNUSED(flags))
{
    return true;
}

void wxPopupWindowBase::Position(const wxPoint& ptOrigin,
                                 const wxSize& size)
{
    wxSize sizeScreen = wxGetDisplaySize(),
           sizeSelf = GetSize();

    // is there enough space to put the popup below the window (where we put it
    // by default)?
    wxCoord y = ptOrigin.y + size.y;
    if ( y + sizeSelf.y > sizeScreen.y )
    {
        // check if there is enough space above
        if ( ptOrigin.y > sizeSelf.y )
        {
            // do position the control above the window
            y -= size.y + sizeSelf.y;
        }
        //else: not enough space below nor above, leave below
    }

    // now check left/right too
    wxCoord x = ptOrigin.x + size.x;
    if ( x + sizeSelf.x > sizeScreen.x )
    {
        // check if there is enough space to the left
        if ( ptOrigin.x > sizeSelf.x )
        {
            // do position the control to the left
            x -= size.x + sizeSelf.x;
        }
        //else: not enough space there neither, leave in default position
    }

    Move(x, y, wxSIZE_NO_ADJUSTMENTS);
}

// ----------------------------------------------------------------------------
// wxPopupTransientWindow
// ----------------------------------------------------------------------------

void wxPopupTransientWindow::Init()
{
    m_child =
    m_focus = (wxWindow *)NULL;

    m_handlerFocus = NULL;
    m_handlerPopup = NULL;
}

wxPopupTransientWindow::wxPopupTransientWindow(wxWindow *parent, int style)
{
    Init();

    (void)Create(parent, style);
}

wxPopupTransientWindow::~wxPopupTransientWindow()
{
    PopHandlers();
}

void wxPopupTransientWindow::PopHandlers()
{
    if ( m_child )
    {
        if ( m_handlerPopup && !m_child->RemoveEventHandler(m_handlerPopup) )
        {
            // something is very wrong and someone else probably deleted our
            // handler - so don't risk deleting it second time
            m_handlerPopup = NULL;
        }
        if (m_child->HasCapture())
        {
            m_child->ReleaseMouse();
        }
        m_child = NULL;
    }

#ifdef __WXMSW__
    if ( m_focus )
    {
        if ( m_handlerFocus && !m_focus->RemoveEventHandler(m_handlerFocus) )
        {
            // see above
            m_handlerFocus = NULL;
        }
    }
#else
    if ( m_handlerFocus && !RemoveEventHandler(m_handlerFocus) )
    {
        // see above
        m_handlerFocus = NULL;
    }
#endif

    // delete the handlers, they'll be created as necessary in Popup()
    delete m_handlerPopup;
    m_handlerPopup = NULL;
    delete m_handlerFocus;
    m_handlerFocus = NULL;

    m_focus = NULL;
}

void wxPopupTransientWindow::Popup(wxWindow *winFocus)
{
    const wxWindowList& children = GetChildren();
    if ( children.GetCount() )
    {
        m_child = children.GetFirst()->GetData();
    }
    else
    {
        m_child = this;
    }

    Show();

    // There is is a problem if these are still valid
    wxASSERT_MSG(!m_handlerPopup, wxT("Popup handler not deleted"));
    wxASSERT_MSG(!m_handlerFocus, wxT("Focus handler not deleted"));

    delete m_handlerPopup;
    m_handlerPopup = new wxPopupWindowHandler(this);

    m_child->PushEventHandler(m_handlerPopup);

    m_focus = winFocus ? winFocus : this;
    m_focus->SetFocus();

#ifdef __WXMSW__
    // MSW doesn't allow to set focus to the popup window, but we need to
    // subclass the window which has the focus, and not winFocus passed in or
    // otherwise everything else breaks down
    m_focus = FindFocus();
    if ( m_focus )
    {
        delete m_handlerFocus;
        m_handlerFocus = new wxPopupFocusHandler(this);

        m_focus->PushEventHandler(m_handlerFocus);
    }
#else
    // GTK+ catches the activate events from the popup
    // window, not the focus events from the child window
    delete m_handlerFocus;
    m_handlerFocus = new wxPopupFocusHandler(this);
    PushEventHandler(m_handlerFocus);
#endif // __WXMSW__

    // catch destroy events, if you close a program with a popup shown in MSW
    // you get a segfault if m_child or m_focus are deleted before this is
    m_child->Connect(wxEVT_DESTROY,
                     wxWindowDestroyEventHandler(wxPopupTransientWindow::OnDestroy),
                     NULL, this);
    if (m_focus)
        m_focus->Connect(wxEVT_DESTROY,
                         wxWindowDestroyEventHandler(wxPopupTransientWindow::OnDestroy),
                         NULL, this);
}

bool wxPopupTransientWindow::Show( bool show )
{
#ifdef __WXGTK__
    if (!show)
    {
        gdk_pointer_ungrab( (guint32)GDK_CURRENT_TIME );

        gtk_grab_remove( m_widget );
    }
#endif

#ifdef __WXX11__
    if (!show)
    {
        XUngrabPointer( wxGlobalDisplay(), CurrentTime );
    }
#endif

#ifdef __WXMSW__
    if (!show && m_child && m_child->HasCapture())
    {
        m_child->ReleaseMouse();
    }
#endif

    bool ret = wxPopupWindow::Show( show );

#ifdef __WXGTK__
    if (show)
    {
        gtk_grab_add( m_widget );

        gdk_pointer_grab( m_widget->window, TRUE,
                          (GdkEventMask)
                            (GDK_BUTTON_PRESS_MASK |
                             GDK_BUTTON_RELEASE_MASK |
                             GDK_POINTER_MOTION_HINT_MASK |
                             GDK_POINTER_MOTION_MASK),
                          (GdkWindow *) NULL,
                          (GdkCursor *) NULL,
                          (guint32)GDK_CURRENT_TIME );
    }
#endif

#ifdef __WXX11__
    if (show)
    {
        Window xwindow = (Window) m_clientWindow;

        /* int res =*/ XGrabPointer(wxGlobalDisplay(), xwindow,
            True,
            ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
            GrabModeAsync,
            GrabModeAsync,
            None,
            None,
            CurrentTime );
    }
#endif

#ifdef __WXMSW__
    if (show && m_child)
    {
        // Assume that the mouse is outside the popup to begin with
        m_child->CaptureMouse();
    }
#endif

    return ret;
}

void wxPopupTransientWindow::Dismiss()
{
    Hide();
    PopHandlers();
}

void wxPopupTransientWindow::DismissAndNotify()
{
    Dismiss();
    OnDismiss();
}

void wxPopupTransientWindow::OnDismiss()
{
    // nothing to do here - but it may be interesting for derived class
}

bool wxPopupTransientWindow::ProcessLeftDown(wxMouseEvent& WXUNUSED(event))
{
    // no special processing here
    return false;
}

void wxPopupTransientWindow::OnDestroy(wxWindowDestroyEvent& event)
{
    if (event.GetEventObject() == m_child)
        m_child = NULL;
    if (event.GetEventObject() == m_focus)
        m_focus = NULL;
}

#ifdef __WXMSW__
void wxPopupTransientWindow::OnIdle(wxIdleEvent& event)
{
    event.Skip();

    if (IsShown() && m_child)
    {
        wxPoint pos = ScreenToClient(wxGetMousePosition());
        wxRect rect(GetSize());

        if ( rect.Inside(pos) )
        {
            if ( m_child->HasCapture() )
            {
                m_child->ReleaseMouse();
            }
        }
        else
        {
            if ( !m_child->HasCapture() )
            {
                m_child->CaptureMouse();
            }
        }
    }
}
#endif


#if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)

// ----------------------------------------------------------------------------
// wxPopupComboWindow
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(wxPopupComboWindow, wxPopupTransientWindow)
    EVT_KEY_DOWN(wxPopupComboWindow::OnKeyDown)
END_EVENT_TABLE()

wxPopupComboWindow::wxPopupComboWindow(wxComboControl *parent)
                  : wxPopupTransientWindow(parent)
{
    m_combo = parent;
}

bool wxPopupComboWindow::Create(wxComboControl *parent)
{
    m_combo = parent;

    return wxPopupWindow::Create(parent);
}

void wxPopupComboWindow::PositionNearCombo()
{
    // the origin point must be in screen coords
    wxPoint ptOrigin = m_combo->ClientToScreen(wxPoint(0,0));

#if 0 //def __WXUNIVERSAL__
    // account for the fact that (0, 0) is not the top left corner of the
    // window: there is also the border
    wxRect rectBorders = m_combo->GetRenderer()->
                            GetBorderDimensions(m_combo->GetBorder());
    ptOrigin.x -= rectBorders.x;
    ptOrigin.y -= rectBorders.y;
#endif // __WXUNIVERSAL__

    // position below or above the combobox: the width is 0 to put it exactly
    // below us, not to the left or to the right
    Position(ptOrigin, wxSize(0, m_combo->GetSize().y));
}

void wxPopupComboWindow::OnDismiss()
{
    m_combo->OnDismiss();
}

void wxPopupComboWindow::OnKeyDown(wxKeyEvent& event)
{
    m_combo->ProcessEvent(event);
}

#endif // wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)

// ----------------------------------------------------------------------------
// wxPopupWindowHandler
// ----------------------------------------------------------------------------
wxPopupWindowHandler::~wxPopupWindowHandler()
{
    if (m_popup && (m_popup->m_handlerPopup == this))
        m_popup->m_handlerPopup = NULL;
}

void wxPopupWindowHandler::OnLeftDown(wxMouseEvent& event)
{
    // let the window have it first (we're the first event handler in the chain
    // of handlers for this window)
    if ( m_popup->ProcessLeftDown(event) )
    {
        return;
    }

    wxPoint pos = event.GetPosition();

    // scrollbar on which the click occured
    wxWindow *sbar = NULL;

    wxWindow *win = (wxWindow *)event.GetEventObject();

    switch ( win->HitTest(pos.x, pos.y) )
    {
        case wxHT_WINDOW_OUTSIDE:
            {
                // do the coords translation now as after DismissAndNotify()
                // m_popup may be destroyed
                wxMouseEvent event2(event);

                m_popup->ClientToScreen(&event2.m_x, &event2.m_y);

                // clicking outside a popup dismisses it
                m_popup->DismissAndNotify();

                // dismissing a tooltip shouldn't waste a click, i.e. you
                // should be able to dismiss it and press the button with the
                // same click, so repost this event to the window beneath us
                wxWindow *win = wxFindWindowAtPoint(event2.GetPosition());
                if ( win )
                {
                    // translate the event coords to the ones of the window
                    // which is going to get the event
                    win->ScreenToClient(&event2.m_x, &event2.m_y);

                    event2.SetEventObject(win);
                    wxPostEvent(win, event2);
                }
            }
            break;

#ifdef __WXUNIVERSAL__
        case wxHT_WINDOW_HORZ_SCROLLBAR:
            sbar = win->GetScrollbar(wxHORIZONTAL);
            break;

        case wxHT_WINDOW_VERT_SCROLLBAR:
            sbar = win->GetScrollbar(wxVERTICAL);
            break;
#endif

        default:
            // forgot to update the switch after adding a new hit test code?
            wxFAIL_MSG( _T("unexpected HitTest() return value") );
            // fall through

        case wxHT_WINDOW_CORNER:
            // don't actually know if this one is good for anything, but let it
            // pass just in case

        case wxHT_WINDOW_INSIDE:
            // let the normal processing take place
            event.Skip();
            break;
    }

    if ( sbar )
    {
        // translate the event coordinates to the scrollbar ones
        pos = sbar->ScreenToClient(win->ClientToScreen(pos));

        // and give the event to it
        wxMouseEvent event2 = event;
        event2.m_x = pos.x;
        event2.m_y = pos.y;

        (void)sbar->GetEventHandler()->ProcessEvent(event2);
    }
}

// ----------------------------------------------------------------------------
// wxPopupFocusHandler
// ----------------------------------------------------------------------------
wxPopupFocusHandler::~wxPopupFocusHandler()
{
    if (m_popup && (m_popup->m_handlerFocus == this))
        m_popup->m_handlerFocus = NULL;
}

void wxPopupFocusHandler::OnKillFocus(wxFocusEvent& event)
{
    // when we lose focus we always disappear - unless it goes to the popup (in
    // which case we don't really lose it)
    wxWindow *win = event.GetWindow();
    while ( win )
    {
        if ( win == m_popup )
            return;
        win = win->GetParent();
    }

    m_popup->DismissAndNotify();
}

void wxPopupFocusHandler::OnKeyDown(wxKeyEvent& event)
{
    // let the window have it first, it might process the keys
    if ( !m_popup->ProcessEvent(event) )
    {
        // by default, dismiss the popup
        m_popup->DismissAndNotify();
    }
}

#endif // wxUSE_POPUPWIN
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: common/popupcmn.cpp
	3	// Purpose: implementation of wxPopupTransientWindow
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 06.01.01
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	// License: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
	21	#pragma implementation "popupwinbase.h"
	22	#endif
	23
	24	// For compilers that support precompilation, includes "wx.h".
	25	#include "wx/wxprec.h"
	26
	27	#ifdef __BORLANDC__
	28	#pragma hdrstop
	29	#endif
	30
	31	#if wxUSE_POPUPWIN
	32
	33	#include "wx/popupwin.h"
	34
	35	#ifndef WX_PRECOMP
	36	#include "wx/combobox.h" // wxComboControl
	37	#include "wx/app.h" // wxPostEvent
	38	#include "wx/log.h"
	39	#include "wx/app.h"
	40	#endif //WX_PRECOMP
	41
	42	#ifdef __WXUNIVERSAL__
	43	#include "wx/univ/renderer.h"
	44	#endif // __WXUNIVERSAL__
	45
	46	#ifdef __WXGTK__
	47	#include <gtk/gtk.h>
	48	#endif
	49	#ifdef __WXX11__
	50	#include "wx/x11/private.h"
	51	#endif
	52
	53	IMPLEMENT_DYNAMIC_CLASS(wxPopupWindow, wxWindow)
	54	IMPLEMENT_DYNAMIC_CLASS(wxPopupTransientWindow, wxPopupWindow)
	55
	56	#if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
	57	IMPLEMENT_DYNAMIC_CLASS(wxPopupComboWindow, wxPopupTransientWindow)
	58	#endif
	59
	60	// ----------------------------------------------------------------------------
	61	// private classes
	62	// ----------------------------------------------------------------------------
	63
	64	// event handlers which we use to intercept events which cause the popup to
	65	// disappear
	66	class wxPopupWindowHandler : public wxEvtHandler
	67	{
	68	public:
	69	wxPopupWindowHandler(wxPopupTransientWindow *popup) : m_popup(popup) {}
	70	~wxPopupWindowHandler();
	71
	72	protected:
	73	// event handlers
	74	void OnLeftDown(wxMouseEvent& event);
	75
	76	private:
	77	wxPopupTransientWindow *m_popup;
	78
	79	DECLARE_EVENT_TABLE()
	80	DECLARE_NO_COPY_CLASS(wxPopupWindowHandler)
	81	};
	82
	83	class wxPopupFocusHandler : public wxEvtHandler
	84	{
	85	public:
	86	wxPopupFocusHandler(wxPopupTransientWindow *popup) : m_popup(popup) {}
	87	~wxPopupFocusHandler();
	88
	89	protected:
	90	void OnKillFocus(wxFocusEvent& event);
	91	void OnKeyDown(wxKeyEvent& event);
	92
	93	private:
	94	wxPopupTransientWindow *m_popup;
	95
	96	DECLARE_EVENT_TABLE()
	97	DECLARE_NO_COPY_CLASS(wxPopupFocusHandler)
	98	};
	99
	100	// ----------------------------------------------------------------------------
	101	// event tables
	102	// ----------------------------------------------------------------------------
	103
	104	BEGIN_EVENT_TABLE(wxPopupWindowHandler, wxEvtHandler)
	105	EVT_LEFT_DOWN(wxPopupWindowHandler::OnLeftDown)
	106	END_EVENT_TABLE()
	107
	108	BEGIN_EVENT_TABLE(wxPopupFocusHandler, wxEvtHandler)
	109	EVT_KILL_FOCUS(wxPopupFocusHandler::OnKillFocus)
	110	EVT_KEY_DOWN(wxPopupFocusHandler::OnKeyDown)
	111	END_EVENT_TABLE()
	112
	113	BEGIN_EVENT_TABLE(wxPopupTransientWindow, wxPopupWindow)
	114	#ifdef __WXMSW__
	115	EVT_IDLE(wxPopupTransientWindow::OnIdle)
	116	#endif
	117	END_EVENT_TABLE()
	118
	119	// ============================================================================
	120	// implementation
	121	// ============================================================================
	122
	123	// ----------------------------------------------------------------------------
	124	// wxPopupWindowBase
	125	// ----------------------------------------------------------------------------
	126
	127	wxPopupWindowBase::~wxPopupWindowBase()
	128	{
	129	// this destructor is required for Darwin
	130	}
	131
	132	bool wxPopupWindowBase::Create(wxWindow* WXUNUSED(parent), int WXUNUSED(flags))
	133	{
	134	return true;
	135	}
	136
	137	void wxPopupWindowBase::Position(const wxPoint& ptOrigin,
	138	const wxSize& size)
	139	{
	140	wxSize sizeScreen = wxGetDisplaySize(),
	141	sizeSelf = GetSize();
	142
	143	// is there enough space to put the popup below the window (where we put it
	144	// by default)?
	145	wxCoord y = ptOrigin.y + size.y;
	146	if ( y + sizeSelf.y > sizeScreen.y )
	147	{
	148	// check if there is enough space above
	149	if ( ptOrigin.y > sizeSelf.y )
	150	{
	151	// do position the control above the window
	152	y -= size.y + sizeSelf.y;
	153	}
	154	//else: not enough space below nor above, leave below
	155	}
	156
	157	// now check left/right too
	158	wxCoord x = ptOrigin.x + size.x;
	159	if ( x + sizeSelf.x > sizeScreen.x )
	160	{
	161	// check if there is enough space to the left
	162	if ( ptOrigin.x > sizeSelf.x )
	163	{
	164	// do position the control to the left
	165	x -= size.x + sizeSelf.x;
	166	}
	167	//else: not enough space there neither, leave in default position
	168	}
	169
	170	Move(x, y, wxSIZE_NO_ADJUSTMENTS);
	171	}
	172
	173	// ----------------------------------------------------------------------------
	174	// wxPopupTransientWindow
	175	// ----------------------------------------------------------------------------
	176
	177	void wxPopupTransientWindow::Init()
	178	{
	179	m_child =
	180	m_focus = (wxWindow *)NULL;
	181
	182	m_handlerFocus = NULL;
	183	m_handlerPopup = NULL;
	184	}
	185
	186	wxPopupTransientWindow::wxPopupTransientWindow(wxWindow *parent, int style)
	187	{
	188	Init();
	189
	190	(void)Create(parent, style);
	191	}
	192
	193	wxPopupTransientWindow::~wxPopupTransientWindow()
	194	{
	195	PopHandlers();
	196	}
	197
	198	void wxPopupTransientWindow::PopHandlers()
	199	{
	200	if ( m_child )
	201	{
	202	if ( m_handlerPopup && !m_child->RemoveEventHandler(m_handlerPopup) )
	203	{
	204	// something is very wrong and someone else probably deleted our
	205	// handler - so don't risk deleting it second time
	206	m_handlerPopup = NULL;
	207	}
	208	if (m_child->HasCapture())
	209	{
	210	m_child->ReleaseMouse();
	211	}
	212	m_child = NULL;
	213	}
	214
	215	#ifdef __WXMSW__
	216	if ( m_focus )
	217	{
	218	if ( m_handlerFocus && !m_focus->RemoveEventHandler(m_handlerFocus) )
	219	{
	220	// see above
	221	m_handlerFocus = NULL;
	222	}
	223	}
	224	#else
	225	if ( m_handlerFocus && !RemoveEventHandler(m_handlerFocus) )
	226	{
	227	// see above
	228	m_handlerFocus = NULL;
	229	}
	230	#endif
	231
	232	// delete the handlers, they'll be created as necessary in Popup()
	233	delete m_handlerPopup;
	234	m_handlerPopup = NULL;
	235	delete m_handlerFocus;
	236	m_handlerFocus = NULL;
	237
	238	m_focus = NULL;
	239	}
	240
	241	void wxPopupTransientWindow::Popup(wxWindow *winFocus)
	242	{
	243	const wxWindowList& children = GetChildren();
	244	if ( children.GetCount() )
	245	{
	246	m_child = children.GetFirst()->GetData();
	247	}
	248	else
	249	{
	250	m_child = this;
	251	}
	252
	253	Show();
	254
	255	// There is is a problem if these are still valid
	256	wxASSERT_MSG(!m_handlerPopup, wxT("Popup handler not deleted"));
	257	wxASSERT_MSG(!m_handlerFocus, wxT("Focus handler not deleted"));
	258
	259	delete m_handlerPopup;
	260	m_handlerPopup = new wxPopupWindowHandler(this);
	261
	262	m_child->PushEventHandler(m_handlerPopup);
	263
	264	m_focus = winFocus ? winFocus : this;
	265	m_focus->SetFocus();
	266
	267	#ifdef __WXMSW__
	268	// MSW doesn't allow to set focus to the popup window, but we need to
	269	// subclass the window which has the focus, and not winFocus passed in or
	270	// otherwise everything else breaks down
	271	m_focus = FindFocus();
	272	if ( m_focus )
	273	{
	274	delete m_handlerFocus;
	275	m_handlerFocus = new wxPopupFocusHandler(this);
	276
	277	m_focus->PushEventHandler(m_handlerFocus);
	278	}
	279	#else
	280	// GTK+ catches the activate events from the popup
	281	// window, not the focus events from the child window
	282	delete m_handlerFocus;
	283	m_handlerFocus = new wxPopupFocusHandler(this);
	284	PushEventHandler(m_handlerFocus);
	285	#endif // __WXMSW__
	286
	287	// catch destroy events, if you close a program with a popup shown in MSW
	288	// you get a segfault if m_child or m_focus are deleted before this is
	289	m_child->Connect(wxEVT_DESTROY,
	290	wxWindowDestroyEventHandler(wxPopupTransientWindow::OnDestroy),
	291	NULL, this);
	292	if (m_focus)
	293	m_focus->Connect(wxEVT_DESTROY,
	294	wxWindowDestroyEventHandler(wxPopupTransientWindow::OnDestroy),
	295	NULL, this);
	296	}
	297
	298	bool wxPopupTransientWindow::Show( bool show )
	299	{
	300	#ifdef __WXGTK__
	301	if (!show)
	302	{
	303	gdk_pointer_ungrab( (guint32)GDK_CURRENT_TIME );
	304
	305	gtk_grab_remove( m_widget );
	306	}
	307	#endif
	308
	309	#ifdef __WXX11__
	310	if (!show)
	311	{
	312	XUngrabPointer( wxGlobalDisplay(), CurrentTime );
	313	}
	314	#endif
	315
	316	#ifdef __WXMSW__
	317	if (!show && m_child && m_child->HasCapture())
	318	{
	319	m_child->ReleaseMouse();
	320	}
	321	#endif
	322
	323	bool ret = wxPopupWindow::Show( show );
	324
	325	#ifdef __WXGTK__
	326	if (show)
	327	{
	328	gtk_grab_add( m_widget );
	329
	330	gdk_pointer_grab( m_widget->window, TRUE,
	331	(GdkEventMask)
	332	(GDK_BUTTON_PRESS_MASK \|
	333	GDK_BUTTON_RELEASE_MASK \|
	334	GDK_POINTER_MOTION_HINT_MASK \|
	335	GDK_POINTER_MOTION_MASK),
	336	(GdkWindow *) NULL,
	337	(GdkCursor *) NULL,
	338	(guint32)GDK_CURRENT_TIME );
	339	}
	340	#endif
	341
	342	#ifdef __WXX11__
	343	if (show)
	344	{
	345	Window xwindow = (Window) m_clientWindow;
	346
	347	/* int res =*/ XGrabPointer(wxGlobalDisplay(), xwindow,
	348	True,
	349	ButtonPressMask \| ButtonReleaseMask \| ButtonMotionMask \| EnterWindowMask \| LeaveWindowMask \| PointerMotionMask,
	350	GrabModeAsync,
	351	GrabModeAsync,
	352	None,
	353	None,
	354	CurrentTime );
	355	}
	356	#endif
	357
	358	#ifdef __WXMSW__
	359	if (show && m_child)
	360	{
	361	// Assume that the mouse is outside the popup to begin with
	362	m_child->CaptureMouse();
	363	}
	364	#endif
	365
	366	return ret;
	367	}
	368
	369	void wxPopupTransientWindow::Dismiss()
	370	{
	371	Hide();
	372	PopHandlers();
	373	}
	374
	375	void wxPopupTransientWindow::DismissAndNotify()
	376	{
	377	Dismiss();
	378	OnDismiss();
	379	}
	380
	381	void wxPopupTransientWindow::OnDismiss()
	382	{
	383	// nothing to do here - but it may be interesting for derived class
	384	}
	385
	386	bool wxPopupTransientWindow::ProcessLeftDown(wxMouseEvent& WXUNUSED(event))
	387	{
	388	// no special processing here
	389	return false;
	390	}
	391
	392	void wxPopupTransientWindow::OnDestroy(wxWindowDestroyEvent& event)
	393	{
	394	if (event.GetEventObject() == m_child)
	395	m_child = NULL;
	396	if (event.GetEventObject() == m_focus)
	397	m_focus = NULL;
	398	}
	399
	400	#ifdef __WXMSW__
	401	void wxPopupTransientWindow::OnIdle(wxIdleEvent& event)
	402	{
	403	event.Skip();
	404
	405	if (IsShown() && m_child)
	406	{
	407	wxPoint pos = ScreenToClient(wxGetMousePosition());
	408	wxRect rect(GetSize());
	409
	410	if ( rect.Inside(pos) )
	411	{
	412	if ( m_child->HasCapture() )
	413	{
	414	m_child->ReleaseMouse();
	415	}
	416	}
	417	else
	418	{
	419	if ( !m_child->HasCapture() )
	420	{
	421	m_child->CaptureMouse();
	422	}
	423	}
	424	}
	425	}
	426	#endif
	427
	428
	429	#if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
	430
	431	// ----------------------------------------------------------------------------
	432	// wxPopupComboWindow
	433	// ----------------------------------------------------------------------------
	434
	435	BEGIN_EVENT_TABLE(wxPopupComboWindow, wxPopupTransientWindow)
	436	EVT_KEY_DOWN(wxPopupComboWindow::OnKeyDown)
	437	END_EVENT_TABLE()
	438
	439	wxPopupComboWindow::wxPopupComboWindow(wxComboControl *parent)
	440	: wxPopupTransientWindow(parent)
	441	{
	442	m_combo = parent;
	443	}
	444
	445	bool wxPopupComboWindow::Create(wxComboControl *parent)
	446	{
	447	m_combo = parent;
	448
	449	return wxPopupWindow::Create(parent);
	450	}
	451
	452	void wxPopupComboWindow::PositionNearCombo()
	453	{
	454	// the origin point must be in screen coords
	455	wxPoint ptOrigin = m_combo->ClientToScreen(wxPoint(0,0));
	456
	457	#if 0 //def __WXUNIVERSAL__
	458	// account for the fact that (0, 0) is not the top left corner of the
	459	// window: there is also the border
	460	wxRect rectBorders = m_combo->GetRenderer()->
	461	GetBorderDimensions(m_combo->GetBorder());
	462	ptOrigin.x -= rectBorders.x;
	463	ptOrigin.y -= rectBorders.y;
	464	#endif // __WXUNIVERSAL__
	465
	466	// position below or above the combobox: the width is 0 to put it exactly
	467	// below us, not to the left or to the right
	468	Position(ptOrigin, wxSize(0, m_combo->GetSize().y));
	469	}
	470
	471	void wxPopupComboWindow::OnDismiss()
	472	{
	473	m_combo->OnDismiss();
	474	}
	475
	476	void wxPopupComboWindow::OnKeyDown(wxKeyEvent& event)
	477	{
	478	m_combo->ProcessEvent(event);
	479	}
	480
	481	#endif // wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
	482
	483	// ----------------------------------------------------------------------------
	484	// wxPopupWindowHandler
	485	// ----------------------------------------------------------------------------
	486	wxPopupWindowHandler::~wxPopupWindowHandler()
	487	{
	488	if (m_popup && (m_popup->m_handlerPopup == this))
	489	m_popup->m_handlerPopup = NULL;
	490	}
	491
	492	void wxPopupWindowHandler::OnLeftDown(wxMouseEvent& event)
	493	{
	494	// let the window have it first (we're the first event handler in the chain
	495	// of handlers for this window)
	496	if ( m_popup->ProcessLeftDown(event) )
	497	{
	498	return;
	499	}
	500
	501	wxPoint pos = event.GetPosition();
	502
	503	// scrollbar on which the click occured
	504	wxWindow *sbar = NULL;
	505
	506	wxWindow win = (wxWindow )event.GetEventObject();
	507
	508	switch ( win->HitTest(pos.x, pos.y) )
	509	{
	510	case wxHT_WINDOW_OUTSIDE:
	511	{
	512	// do the coords translation now as after DismissAndNotify()
	513	// m_popup may be destroyed
	514	wxMouseEvent event2(event);
	515
	516	m_popup->ClientToScreen(&event2.m_x, &event2.m_y);
	517
	518	// clicking outside a popup dismisses it
	519	m_popup->DismissAndNotify();
	520
	521	// dismissing a tooltip shouldn't waste a click, i.e. you
	522	// should be able to dismiss it and press the button with the
	523	// same click, so repost this event to the window beneath us
	524	wxWindow *win = wxFindWindowAtPoint(event2.GetPosition());
	525	if ( win )
	526	{
	527	// translate the event coords to the ones of the window
	528	// which is going to get the event
	529	win->ScreenToClient(&event2.m_x, &event2.m_y);
	530
	531	event2.SetEventObject(win);
	532	wxPostEvent(win, event2);
	533	}
	534	}
	535	break;
	536
	537	#ifdef __WXUNIVERSAL__
	538	case wxHT_WINDOW_HORZ_SCROLLBAR:
	539	sbar = win->GetScrollbar(wxHORIZONTAL);
	540	break;
	541
	542	case wxHT_WINDOW_VERT_SCROLLBAR:
	543	sbar = win->GetScrollbar(wxVERTICAL);
	544	break;
	545	#endif
	546
	547	default:
	548	// forgot to update the switch after adding a new hit test code?
	549	wxFAIL_MSG( _T("unexpected HitTest() return value") );
	550	// fall through
	551
	552	case wxHT_WINDOW_CORNER:
	553	// don't actually know if this one is good for anything, but let it
	554	// pass just in case
	555
	556	case wxHT_WINDOW_INSIDE:
	557	// let the normal processing take place
	558	event.Skip();
	559	break;
	560	}
	561
	562	if ( sbar )
	563	{
	564	// translate the event coordinates to the scrollbar ones
	565	pos = sbar->ScreenToClient(win->ClientToScreen(pos));
	566
	567	// and give the event to it
	568	wxMouseEvent event2 = event;
	569	event2.m_x = pos.x;
	570	event2.m_y = pos.y;
	571
	572	(void)sbar->GetEventHandler()->ProcessEvent(event2);
	573	}
	574	}
	575
	576	// ----------------------------------------------------------------------------
	577	// wxPopupFocusHandler
	578	// ----------------------------------------------------------------------------
	579	wxPopupFocusHandler::~wxPopupFocusHandler()
	580	{
	581	if (m_popup && (m_popup->m_handlerFocus == this))
	582	m_popup->m_handlerFocus = NULL;
	583	}
	584
	585	void wxPopupFocusHandler::OnKillFocus(wxFocusEvent& event)
	586	{
	587	// when we lose focus we always disappear - unless it goes to the popup (in
	588	// which case we don't really lose it)
	589	wxWindow *win = event.GetWindow();
	590	while ( win )
	591	{
	592	if ( win == m_popup )
	593	return;
	594	win = win->GetParent();
	595	}
	596
	597	m_popup->DismissAndNotify();
	598	}
	599
	600	void wxPopupFocusHandler::OnKeyDown(wxKeyEvent& event)
	601	{
	602	// let the window have it first, it might process the keys
	603	if ( !m_popup->ProcessEvent(event) )
	604	{
	605	// by default, dismiss the popup
	606	m_popup->DismissAndNotify();
	607	}
	608	}
	609
	610	#endif // wxUSE_POPUPWIN
	611