src/gtk/minifram.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/gtk/minifram.cpp
// Purpose:
// Author:      Robert Roebling
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#if wxUSE_MINIFRAME

#include "wx/minifram.h"

#ifndef WX_PRECOMP
    #include "wx/settings.h"
    #include "wx/dcclient.h"
    #include "wx/image.h"
#endif

#ifdef __WXGTK3__
#include "wx/gtk/dc.h"
#else
#include "wx/gtk/dcclient.h"
#endif

#include <gtk/gtk.h>
#include "wx/gtk/private/gtk2-compat.h"

//-----------------------------------------------------------------------------
// data
//-----------------------------------------------------------------------------

extern bool        g_blockEventsOnDrag;
extern bool        g_blockEventsOnScroll;

//-----------------------------------------------------------------------------
// "expose_event" of m_mainWidget
//-----------------------------------------------------------------------------

// StepColour() it a utility function that simply darkens
// or lightens a color, based on the specified percentage
static wxColor StepColour(const wxColor& c, int percent)
{
    int r = c.Red(), g = c.Green(), b = c.Blue();
    return wxColour((unsigned char)wxMin((r*percent)/100,255),
                    (unsigned char)wxMin((g*percent)/100,255),
                    (unsigned char)wxMin((b*percent)/100,255));
}

static wxColor LightContrastColour(const wxColour& c)
{
    int amount = 120;

    // if the color is especially dark, then
    // make the contrast even lighter
    if (c.Red() < 128 && c.Green() < 128 && c.Blue() < 128)
        amount = 160;

    return StepColour(c, amount);
}

extern "C" {
#ifdef __WXGTK3__
static gboolean draw(GtkWidget* widget, cairo_t* cr, wxMiniFrame* win)
#else
static gboolean expose_event(GtkWidget* widget, GdkEventExpose* gdk_event, wxMiniFrame* win)
#endif
{
#ifdef __WXGTK3__
    if (!gtk_cairo_should_draw_window(cr, gtk_widget_get_window(widget)))
        return false;

    GtkStyleContext* sc = gtk_widget_get_style_context(widget);
    gtk_style_context_save(sc);
    gtk_style_context_add_class(sc, GTK_STYLE_CLASS_BUTTON);
    gtk_render_frame(sc, cr, 0, 0, win->m_width, win->m_height);
    gtk_style_context_restore(sc);

    wxGTKCairoDC dc(cr);
#else
    if (gdk_event->count > 0 ||
        gdk_event->window != gtk_widget_get_window(widget))
    {
        return false;
    }

    gtk_paint_shadow (gtk_widget_get_style(widget),
                      gtk_widget_get_window(widget),
                      GTK_STATE_NORMAL,
                      GTK_SHADOW_OUT,
                      NULL, NULL, NULL, // FIXME: No clipping?
                      0, 0,
                      win->m_width, win->m_height);

    wxClientDC dc(win);

    wxDCImpl *impl = dc.GetImpl();
    wxClientDCImpl *gtk_impl = wxDynamicCast( impl, wxClientDCImpl );
    gtk_impl->m_gdkwindow = gtk_widget_get_window(widget); // Hack alert
#endif

    int style = win->GetWindowStyle();

    if (style & wxRESIZE_BORDER)
    {
        dc.SetBrush( *wxGREY_BRUSH );
        dc.SetPen( *wxTRANSPARENT_PEN );
        dc.DrawRectangle( win->m_width - 14, win->m_height-14, 14, 14 );
    }

    if (win->m_miniTitle && !win->GetTitle().empty())
    {
        dc.SetFont( *wxSMALL_FONT );

        wxBrush brush( LightContrastColour( wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT) ) );
        dc.SetBrush( brush );
        dc.SetPen( *wxTRANSPARENT_PEN );
        dc.DrawRectangle( win->m_miniEdge-1,
                          win->m_miniEdge-1,
                          win->m_width - (2*(win->m_miniEdge-1)),
                          15  );

        dc.SetTextForeground( *wxWHITE );
        dc.DrawText( win->GetTitle(), 6, 4 );

        if (style & wxCLOSE_BOX)
            dc.DrawBitmap( win->m_closeButton, win->m_width-18, 3, true );
    }

    return false;
}
}

//-----------------------------------------------------------------------------
// "button_press_event" of m_mainWidget
//-----------------------------------------------------------------------------

extern "C" {
static gboolean
gtk_window_button_press_callback(GtkWidget* widget, GdkEventButton* gdk_event, wxMiniFrame* win)
{
    if (gdk_event->window != gtk_widget_get_window(widget))
        return false;
    if (g_blockEventsOnDrag) return TRUE;
    if (g_blockEventsOnScroll) return TRUE;

    if (win->m_isDragging) return TRUE;

    int style = win->GetWindowStyle();

    int y = (int)gdk_event->y;
    int x = (int)gdk_event->x;

    if ((style & wxRESIZE_BORDER) &&
        (x > win->m_width-14) && (y > win->m_height-14))
    {
        GtkWidget *ancestor = gtk_widget_get_toplevel( widget );

        GdkWindow *source = gtk_widget_get_window(widget);

        int org_x = 0;
        int org_y = 0;
        gdk_window_get_origin( source, &org_x, &org_y );

        gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
                                  GDK_WINDOW_EDGE_SOUTH_EAST,
                                  1,
                                  org_x + x,
                                  org_y + y,
                                  0);

        return TRUE;
    }

    if (win->m_miniTitle && (style & wxCLOSE_BOX))
    {
        if ((y > 3) && (y < 19) && (x > win->m_width-19) && (x < win->m_width-3))
        {
            win->Close();
            return TRUE;
        }
    }

    if (y >= win->m_miniEdge + win->m_miniTitle)
        return true;

    gdk_window_raise(gtk_widget_get_window(win->m_widget));

    const GdkEventMask mask = GdkEventMask(
        GDK_BUTTON_PRESS_MASK |
        GDK_BUTTON_RELEASE_MASK |
        GDK_POINTER_MOTION_MASK |
        GDK_POINTER_MOTION_HINT_MASK |
        GDK_BUTTON_MOTION_MASK |
        GDK_BUTTON1_MOTION_MASK);
#ifdef __WXGTK3__
    gdk_device_grab(
        gdk_event->device, gdk_event->window, GDK_OWNERSHIP_NONE,
        false, mask, NULL, gdk_event->time);
#else
    gdk_pointer_grab(gdk_event->window, false, mask, NULL, NULL, gdk_event->time);
#endif

    win->m_diffX = x;
    win->m_diffY = y;
    win->m_oldX = 0;
    win->m_oldY = 0;

    win->m_isDragging = true;

    return TRUE;
}
}

//-----------------------------------------------------------------------------
// "button_release_event" of m_mainWidget
//-----------------------------------------------------------------------------

extern "C" {
static gboolean
gtk_window_button_release_callback(GtkWidget* widget, GdkEventButton* gdk_event, wxMiniFrame* win)
{
    if (gdk_event->window != gtk_widget_get_window(widget))
        return false;
    if (g_blockEventsOnDrag) return TRUE;
    if (g_blockEventsOnScroll) return TRUE;
    if (!win->m_isDragging) return TRUE;

    win->m_isDragging = false;

    int x = (int)gdk_event->x;
    int y = (int)gdk_event->y;

#ifdef __WXGTK3__
    gdk_device_ungrab(gdk_event->device, gdk_event->time);
#else
    gdk_pointer_ungrab(gdk_event->time);
#endif
    int org_x = 0;
    int org_y = 0;
    gdk_window_get_origin(gtk_widget_get_window(widget), &org_x, &org_y);
    x += org_x - win->m_diffX;
    y += org_y - win->m_diffY;
    win->m_x = x;
    win->m_y = y;
    gtk_window_move( GTK_WINDOW(win->m_widget), x, y );

    return TRUE;
}
}

//-----------------------------------------------------------------------------
// "leave_notify_event" of m_mainWidget
//-----------------------------------------------------------------------------

extern "C" {
static gboolean
gtk_window_leave_callback(GtkWidget *widget,
                          GdkEventCrossing* gdk_event,
                          wxMiniFrame*)
{
    if (g_blockEventsOnDrag) return FALSE;
    if (gdk_event->window != gtk_widget_get_window(widget))
        return false;

    gdk_window_set_cursor(gtk_widget_get_window(widget), NULL);

    return FALSE;
}
}

//-----------------------------------------------------------------------------
// "motion_notify_event" of m_mainWidget
//-----------------------------------------------------------------------------

extern "C" {
static gboolean
gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxMiniFrame *win )
{
    if (gdk_event->window != gtk_widget_get_window(widget))
        return false;
    if (g_blockEventsOnDrag) return TRUE;
    if (g_blockEventsOnScroll) return TRUE;

    int x = int(gdk_event->x);
    int y = int(gdk_event->y);

    if (gdk_event->is_hint)
    {
#ifdef __WXGTK3__
       gdk_window_get_device_position(gdk_event->window, gdk_event->device, &x, &y, NULL);
#else
       gdk_window_get_pointer(gdk_event->window, &x, &y, NULL);
#endif
    }

    if (!win->m_isDragging)
    {
        if (win->GetWindowStyle() & wxRESIZE_BORDER)
        {
            if ((x > win->m_width-14) && (y > win->m_height-14))
               gdk_window_set_cursor(gtk_widget_get_window(widget), gdk_cursor_new(GDK_BOTTOM_RIGHT_CORNER));
            else
               gdk_window_set_cursor(gtk_widget_get_window(widget), NULL);
            win->GTKUpdateCursor(false);
        }
        return TRUE;
    }

    win->m_oldX = x - win->m_diffX;
    win->m_oldY = y - win->m_diffY;

    int org_x = 0;
    int org_y = 0;
    gdk_window_get_origin(gtk_widget_get_window(widget), &org_x, &org_y);
    x += org_x - win->m_diffX;
    y += org_y - win->m_diffY;
    win->m_x = x;
    win->m_y = y;
    gtk_window_move( GTK_WINDOW(win->m_widget), x, y );

    return TRUE;
}
}

//-----------------------------------------------------------------------------
// wxMiniFrame
//-----------------------------------------------------------------------------

static unsigned char close_bits[]={
    0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
    0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
    0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };


IMPLEMENT_DYNAMIC_CLASS(wxMiniFrame,wxFrame)

wxMiniFrame::~wxMiniFrame()
{
    if (m_widget)
    {
        GtkWidget* eventbox = gtk_bin_get_child(GTK_BIN(m_widget));
        GTKDisconnect(eventbox);
    }
}

bool wxMiniFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
      const wxPoint &pos, const wxSize &size,
      long style, const wxString &name )
{
    m_miniTitle = 0;
    if (style & wxCAPTION)
        m_miniTitle = 16;

    if (style & wxRESIZE_BORDER)
        m_miniEdge = 4;
    else
        m_miniEdge = 3;
    m_isDragging = false;
    m_oldX = -1;
    m_oldY = -1;
    m_diffX = 0;
    m_diffY = 0;

    // don't allow sizing smaller than decorations
    int minWidth = 2 * m_miniEdge;
    int minHeight = 2 * m_miniEdge + m_miniTitle;
    if (m_minWidth < minWidth)
        m_minWidth = minWidth;
    if (m_minHeight < minHeight)
        m_minHeight = minHeight;

    wxFrame::Create( parent, id, title, pos, size, style, name );

    // Use a GtkEventBox for the title and borders. Using m_widget for this
    // almost works, except that setting the resize cursor has no effect.
    GtkWidget* eventbox = gtk_event_box_new();
    gtk_widget_add_events(eventbox,
        GDK_POINTER_MOTION_MASK |
        GDK_POINTER_MOTION_HINT_MASK);
    gtk_widget_show(eventbox);
    // Use a GtkAlignment to position m_mainWidget inside the decorations
    GtkWidget* alignment = gtk_alignment_new(0, 0, 1, 1);
    gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
        m_miniTitle + m_miniEdge, m_miniEdge, m_miniEdge, m_miniEdge);
    gtk_widget_show(alignment);
    // The GtkEventBox and GtkAlignment go between m_widget and m_mainWidget
    gtk_widget_reparent(m_mainWidget, alignment);
    gtk_container_add(GTK_CONTAINER(eventbox), alignment);
    gtk_container_add(GTK_CONTAINER(m_widget), eventbox);

    m_gdkDecor = 0;
    m_gdkFunc = 0;
    if (style & wxRESIZE_BORDER)
       m_gdkFunc = GDK_FUNC_RESIZE;
    gtk_window_set_default_size(GTK_WINDOW(m_widget), m_width, m_height);
    memset(&m_decorSize, 0, sizeof(m_decorSize));
    m_deferShow = false;

    if (m_parent && (GTK_IS_WINDOW(m_parent->m_widget)))
    {
        gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
    }

    if (m_miniTitle && (style & wxCLOSE_BOX))
    {
        wxImage img = wxBitmap((const char*)close_bits, 16, 16).ConvertToImage();
        img.Replace(0,0,0,123,123,123);
        img.SetMaskColour(123,123,123);
        m_closeButton = wxBitmap( img );
    }

    /* these are called when the borders are drawn */
#ifdef __WXGTK3__
    g_signal_connect_after(eventbox, "draw", G_CALLBACK(draw), this);
#else
    g_signal_connect_after(eventbox, "expose_event", G_CALLBACK(expose_event), this);
#endif

    /* these are required for dragging the mini frame around */
    g_signal_connect (eventbox, "button_press_event",
                      G_CALLBACK (gtk_window_button_press_callback), this);
    g_signal_connect (eventbox, "button_release_event",
                      G_CALLBACK (gtk_window_button_release_callback), this);
    g_signal_connect (eventbox, "motion_notify_event",
                      G_CALLBACK (gtk_window_motion_notify_callback), this);
    g_signal_connect (eventbox, "leave_notify_event",
                      G_CALLBACK (gtk_window_leave_callback), this);
    return true;
}

void wxMiniFrame::DoGetClientSize(int* width, int* height) const
{
    wxFrame::DoGetClientSize(width, height);

    if (m_useCachedClientSize)
        return;

    if (width)
    {
        *width -= 2 * m_miniEdge;
        if (*width < 0) *width = 0;
    }
    if (height)
    {
        *height -= m_miniTitle + 2 * m_miniEdge;
        if (*height < 0) *height = 0;
    }
}

// Keep min size at least as large as decorations
void wxMiniFrame::DoSetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
{
    const int w = 2 * m_miniEdge;
    const int h = 2 * m_miniEdge + m_miniTitle;
    if (minW < w) minW = w;
    if (minH < h) minH = h;
    wxFrame::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
}

void wxMiniFrame::SetTitle( const wxString &title )
{
    wxFrame::SetTitle( title );

    GdkWindow* window = gtk_widget_get_window(gtk_bin_get_child(GTK_BIN(m_widget)));
    if (window)
        gdk_window_invalidate_rect(window, NULL, false);
}

#endif // wxUSE_MINIFRAME
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/gtk/minifram.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Copyright: (c) 1998 Robert Roebling
	6	// Licence: wxWindows licence
	7	/////////////////////////////////////////////////////////////////////////////
	8
	9	// For compilers that support precompilation, includes "wx.h".
	10	#include "wx/wxprec.h"
	11
	12	#if wxUSE_MINIFRAME
	13
	14	#include "wx/minifram.h"
	15
	16	#ifndef WX_PRECOMP
	17	#include "wx/settings.h"
	18	#include "wx/dcclient.h"
	19	#include "wx/image.h"
	20	#endif
	21
	22	#ifdef __WXGTK3__
	23	#include "wx/gtk/dc.h"
	24	#else
	25	#include "wx/gtk/dcclient.h"
	26	#endif
	27
	28	#include <gtk/gtk.h>
	29	#include "wx/gtk/private/gtk2-compat.h"
	30
	31	//-----------------------------------------------------------------------------
	32	// data
	33	//-----------------------------------------------------------------------------
	34
	35	extern bool g_blockEventsOnDrag;
	36	extern bool g_blockEventsOnScroll;
	37
	38	//-----------------------------------------------------------------------------
	39	// "expose_event" of m_mainWidget
	40	//-----------------------------------------------------------------------------
	41
	42	// StepColour() it a utility function that simply darkens
	43	// or lightens a color, based on the specified percentage
	44	static wxColor StepColour(const wxColor& c, int percent)
	45	{
	46	int r = c.Red(), g = c.Green(), b = c.Blue();
	47	return wxColour((unsigned char)wxMin((r*percent)/100,255),
	48	(unsigned char)wxMin((g*percent)/100,255),
	49	(unsigned char)wxMin((b*percent)/100,255));
	50	}
	51
	52	static wxColor LightContrastColour(const wxColour& c)
	53	{
	54	int amount = 120;
	55
	56	// if the color is especially dark, then
	57	// make the contrast even lighter
	58	if (c.Red() < 128 && c.Green() < 128 && c.Blue() < 128)
	59	amount = 160;
	60
	61	return StepColour(c, amount);
	62	}
	63
	64	extern "C" {
	65	#ifdef __WXGTK3__
	66	static gboolean draw(GtkWidget* widget, cairo_t* cr, wxMiniFrame* win)
	67	#else
	68	static gboolean expose_event(GtkWidget* widget, GdkEventExpose* gdk_event, wxMiniFrame* win)
	69	#endif
	70	{
	71	#ifdef __WXGTK3__
	72	if (!gtk_cairo_should_draw_window(cr, gtk_widget_get_window(widget)))
	73	return false;
	74
	75	GtkStyleContext* sc = gtk_widget_get_style_context(widget);
	76	gtk_style_context_save(sc);
	77	gtk_style_context_add_class(sc, GTK_STYLE_CLASS_BUTTON);
	78	gtk_render_frame(sc, cr, 0, 0, win->m_width, win->m_height);
	79	gtk_style_context_restore(sc);
	80
	81	wxGTKCairoDC dc(cr);
	82	#else
	83	if (gdk_event->count > 0 \|\|
	84	gdk_event->window != gtk_widget_get_window(widget))
	85	{
	86	return false;
	87	}
	88
	89	gtk_paint_shadow (gtk_widget_get_style(widget),
	90	gtk_widget_get_window(widget),
	91	GTK_STATE_NORMAL,
	92	GTK_SHADOW_OUT,
	93	NULL, NULL, NULL, // FIXME: No clipping?
	94	0, 0,
	95	win->m_width, win->m_height);
	96
	97	wxClientDC dc(win);
	98
	99	wxDCImpl *impl = dc.GetImpl();
	100	wxClientDCImpl *gtk_impl = wxDynamicCast( impl, wxClientDCImpl );
	101	gtk_impl->m_gdkwindow = gtk_widget_get_window(widget); // Hack alert
	102	#endif
	103
	104	int style = win->GetWindowStyle();
	105
	106	if (style & wxRESIZE_BORDER)
	107	{
	108	dc.SetBrush( *wxGREY_BRUSH );
	109	dc.SetPen( *wxTRANSPARENT_PEN );
	110	dc.DrawRectangle( win->m_width - 14, win->m_height-14, 14, 14 );
	111	}
	112
	113	if (win->m_miniTitle && !win->GetTitle().empty())
	114	{
	115	dc.SetFont( *wxSMALL_FONT );
	116
	117	wxBrush brush( LightContrastColour( wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT) ) );
	118	dc.SetBrush( brush );
	119	dc.SetPen( *wxTRANSPARENT_PEN );
	120	dc.DrawRectangle( win->m_miniEdge-1,
	121	win->m_miniEdge-1,
	122	win->m_width - (2*(win->m_miniEdge-1)),
	123	15 );
	124
	125	dc.SetTextForeground( *wxWHITE );
	126	dc.DrawText( win->GetTitle(), 6, 4 );
	127
	128	if (style & wxCLOSE_BOX)
	129	dc.DrawBitmap( win->m_closeButton, win->m_width-18, 3, true );
	130	}
	131
	132	return false;
	133	}
	134	}
	135
	136	//-----------------------------------------------------------------------------
	137	// "button_press_event" of m_mainWidget
	138	//-----------------------------------------------------------------------------
	139
	140	extern "C" {
	141	static gboolean
	142	gtk_window_button_press_callback(GtkWidget* widget, GdkEventButton* gdk_event, wxMiniFrame* win)
	143	{
	144	if (gdk_event->window != gtk_widget_get_window(widget))
	145	return false;
	146	if (g_blockEventsOnDrag) return TRUE;
	147	if (g_blockEventsOnScroll) return TRUE;
	148
	149	if (win->m_isDragging) return TRUE;
	150
	151	int style = win->GetWindowStyle();
	152
	153	int y = (int)gdk_event->y;
	154	int x = (int)gdk_event->x;
	155
	156	if ((style & wxRESIZE_BORDER) &&
	157	(x > win->m_width-14) && (y > win->m_height-14))
	158	{
	159	GtkWidget *ancestor = gtk_widget_get_toplevel( widget );
	160
	161	GdkWindow *source = gtk_widget_get_window(widget);
	162
	163	int org_x = 0;
	164	int org_y = 0;
	165	gdk_window_get_origin( source, &org_x, &org_y );
	166
	167	gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
	168	GDK_WINDOW_EDGE_SOUTH_EAST,
	169	1,
	170	org_x + x,
	171	org_y + y,
	172	0);
	173
	174	return TRUE;
	175	}
	176
	177	if (win->m_miniTitle && (style & wxCLOSE_BOX))
	178	{
	179	if ((y > 3) && (y < 19) && (x > win->m_width-19) && (x < win->m_width-3))
	180	{
	181	win->Close();
	182	return TRUE;
	183	}
	184	}
	185
	186	if (y >= win->m_miniEdge + win->m_miniTitle)
	187	return true;
	188
	189	gdk_window_raise(gtk_widget_get_window(win->m_widget));
	190
	191	const GdkEventMask mask = GdkEventMask(
	192	GDK_BUTTON_PRESS_MASK \|
	193	GDK_BUTTON_RELEASE_MASK \|
	194	GDK_POINTER_MOTION_MASK \|
	195	GDK_POINTER_MOTION_HINT_MASK \|
	196	GDK_BUTTON_MOTION_MASK \|
	197	GDK_BUTTON1_MOTION_MASK);
	198	#ifdef __WXGTK3__
	199	gdk_device_grab(
	200	gdk_event->device, gdk_event->window, GDK_OWNERSHIP_NONE,
	201	false, mask, NULL, gdk_event->time);
	202	#else
	203	gdk_pointer_grab(gdk_event->window, false, mask, NULL, NULL, gdk_event->time);
	204	#endif
	205
	206	win->m_diffX = x;
	207	win->m_diffY = y;
	208	win->m_oldX = 0;
	209	win->m_oldY = 0;
	210
	211	win->m_isDragging = true;
	212
	213	return TRUE;
	214	}
	215	}
	216
	217	//-----------------------------------------------------------------------------
	218	// "button_release_event" of m_mainWidget
	219	//-----------------------------------------------------------------------------
	220
	221	extern "C" {
	222	static gboolean
	223	gtk_window_button_release_callback(GtkWidget* widget, GdkEventButton* gdk_event, wxMiniFrame* win)
	224	{
	225	if (gdk_event->window != gtk_widget_get_window(widget))
	226	return false;
	227	if (g_blockEventsOnDrag) return TRUE;
	228	if (g_blockEventsOnScroll) return TRUE;
	229	if (!win->m_isDragging) return TRUE;
	230
	231	win->m_isDragging = false;
	232
	233	int x = (int)gdk_event->x;
	234	int y = (int)gdk_event->y;
	235
	236	#ifdef __WXGTK3__
	237	gdk_device_ungrab(gdk_event->device, gdk_event->time);
	238	#else
	239	gdk_pointer_ungrab(gdk_event->time);
	240	#endif
	241	int org_x = 0;
	242	int org_y = 0;
	243	gdk_window_get_origin(gtk_widget_get_window(widget), &org_x, &org_y);
	244	x += org_x - win->m_diffX;
	245	y += org_y - win->m_diffY;
	246	win->m_x = x;
	247	win->m_y = y;
	248	gtk_window_move( GTK_WINDOW(win->m_widget), x, y );
	249
	250	return TRUE;
	251	}
	252	}
	253
	254	//-----------------------------------------------------------------------------
	255	// "leave_notify_event" of m_mainWidget
	256	//-----------------------------------------------------------------------------
	257
	258	extern "C" {
	259	static gboolean
	260	gtk_window_leave_callback(GtkWidget *widget,
	261	GdkEventCrossing* gdk_event,
	262	wxMiniFrame*)
	263	{
	264	if (g_blockEventsOnDrag) return FALSE;
	265	if (gdk_event->window != gtk_widget_get_window(widget))
	266	return false;
	267
	268	gdk_window_set_cursor(gtk_widget_get_window(widget), NULL);
	269
	270	return FALSE;
	271	}
	272	}
	273
	274	//-----------------------------------------------------------------------------
	275	// "motion_notify_event" of m_mainWidget
	276	//-----------------------------------------------------------------------------
	277
	278	extern "C" {
	279	static gboolean
	280	gtk_window_motion_notify_callback( GtkWidget widget, GdkEventMotion gdk_event, wxMiniFrame *win )
	281	{
	282	if (gdk_event->window != gtk_widget_get_window(widget))
	283	return false;
	284	if (g_blockEventsOnDrag) return TRUE;
	285	if (g_blockEventsOnScroll) return TRUE;
	286
	287	int x = int(gdk_event->x);
	288	int y = int(gdk_event->y);
	289
	290	if (gdk_event->is_hint)
	291	{
	292	#ifdef __WXGTK3__
	293	gdk_window_get_device_position(gdk_event->window, gdk_event->device, &x, &y, NULL);
	294	#else
	295	gdk_window_get_pointer(gdk_event->window, &x, &y, NULL);
	296	#endif
	297	}
	298
	299	if (!win->m_isDragging)
	300	{
	301	if (win->GetWindowStyle() & wxRESIZE_BORDER)
	302	{
	303	if ((x > win->m_width-14) && (y > win->m_height-14))
	304	gdk_window_set_cursor(gtk_widget_get_window(widget), gdk_cursor_new(GDK_BOTTOM_RIGHT_CORNER));
	305	else
	306	gdk_window_set_cursor(gtk_widget_get_window(widget), NULL);
	307	win->GTKUpdateCursor(false);
	308	}
	309	return TRUE;
	310	}
	311
	312	win->m_oldX = x - win->m_diffX;
	313	win->m_oldY = y - win->m_diffY;
	314
	315	int org_x = 0;
	316	int org_y = 0;
	317	gdk_window_get_origin(gtk_widget_get_window(widget), &org_x, &org_y);
	318	x += org_x - win->m_diffX;
	319	y += org_y - win->m_diffY;
	320	win->m_x = x;
	321	win->m_y = y;
	322	gtk_window_move( GTK_WINDOW(win->m_widget), x, y );
	323
	324	return TRUE;
	325	}
	326	}
	327
	328	//-----------------------------------------------------------------------------
	329	// wxMiniFrame
	330	//-----------------------------------------------------------------------------
	331
	332	static unsigned char close_bits[]={
	333	0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
	334	0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
	335	0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
	336
	337
	338	IMPLEMENT_DYNAMIC_CLASS(wxMiniFrame,wxFrame)
	339
	340	wxMiniFrame::~wxMiniFrame()
	341	{
	342	if (m_widget)
	343	{
	344	GtkWidget* eventbox = gtk_bin_get_child(GTK_BIN(m_widget));
	345	GTKDisconnect(eventbox);
	346	}
	347	}
	348
	349	bool wxMiniFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
	350	const wxPoint &pos, const wxSize &size,
	351	long style, const wxString &name )
	352	{
	353	m_miniTitle = 0;
	354	if (style & wxCAPTION)
	355	m_miniTitle = 16;
	356
	357	if (style & wxRESIZE_BORDER)
	358	m_miniEdge = 4;
	359	else
	360	m_miniEdge = 3;
	361	m_isDragging = false;
	362	m_oldX = -1;
	363	m_oldY = -1;
	364	m_diffX = 0;
	365	m_diffY = 0;
	366
	367	// don't allow sizing smaller than decorations
	368	int minWidth = 2 * m_miniEdge;
	369	int minHeight = 2 * m_miniEdge + m_miniTitle;
	370	if (m_minWidth < minWidth)
	371	m_minWidth = minWidth;
	372	if (m_minHeight < minHeight)
	373	m_minHeight = minHeight;
	374
	375	wxFrame::Create( parent, id, title, pos, size, style, name );
	376
	377	// Use a GtkEventBox for the title and borders. Using m_widget for this
	378	// almost works, except that setting the resize cursor has no effect.
	379	GtkWidget* eventbox = gtk_event_box_new();
	380	gtk_widget_add_events(eventbox,
	381	GDK_POINTER_MOTION_MASK \|
	382	GDK_POINTER_MOTION_HINT_MASK);
	383	gtk_widget_show(eventbox);
	384	// Use a GtkAlignment to position m_mainWidget inside the decorations
	385	GtkWidget* alignment = gtk_alignment_new(0, 0, 1, 1);
	386	gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
	387	m_miniTitle + m_miniEdge, m_miniEdge, m_miniEdge, m_miniEdge);
	388	gtk_widget_show(alignment);
	389	// The GtkEventBox and GtkAlignment go between m_widget and m_mainWidget
	390	gtk_widget_reparent(m_mainWidget, alignment);
	391	gtk_container_add(GTK_CONTAINER(eventbox), alignment);
	392	gtk_container_add(GTK_CONTAINER(m_widget), eventbox);
	393
	394	m_gdkDecor = 0;
	395	m_gdkFunc = 0;
	396	if (style & wxRESIZE_BORDER)
	397	m_gdkFunc = GDK_FUNC_RESIZE;
	398	gtk_window_set_default_size(GTK_WINDOW(m_widget), m_width, m_height);
	399	memset(&m_decorSize, 0, sizeof(m_decorSize));
	400	m_deferShow = false;
	401
	402	if (m_parent && (GTK_IS_WINDOW(m_parent->m_widget)))
	403	{
	404	gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
	405	}
	406
	407	if (m_miniTitle && (style & wxCLOSE_BOX))
	408	{
	409	wxImage img = wxBitmap((const char*)close_bits, 16, 16).ConvertToImage();
	410	img.Replace(0,0,0,123,123,123);
	411	img.SetMaskColour(123,123,123);
	412	m_closeButton = wxBitmap( img );
	413	}
	414
	415	/* these are called when the borders are drawn */
	416	#ifdef __WXGTK3__
	417	g_signal_connect_after(eventbox, "draw", G_CALLBACK(draw), this);
	418	#else
	419	g_signal_connect_after(eventbox, "expose_event", G_CALLBACK(expose_event), this);
	420	#endif
	421
	422	/* these are required for dragging the mini frame around */
	423	g_signal_connect (eventbox, "button_press_event",
	424	G_CALLBACK (gtk_window_button_press_callback), this);
	425	g_signal_connect (eventbox, "button_release_event",
	426	G_CALLBACK (gtk_window_button_release_callback), this);
	427	g_signal_connect (eventbox, "motion_notify_event",
	428	G_CALLBACK (gtk_window_motion_notify_callback), this);
	429	g_signal_connect (eventbox, "leave_notify_event",
	430	G_CALLBACK (gtk_window_leave_callback), this);
	431	return true;
	432	}
	433
	434	void wxMiniFrame::DoGetClientSize(int* width, int* height) const
	435	{
	436	wxFrame::DoGetClientSize(width, height);
	437
	438	if (m_useCachedClientSize)
	439	return;
	440
	441	if (width)
	442	{
	443	width -= 2 m_miniEdge;
	444	if (width < 0) width = 0;
	445	}
	446	if (height)
	447	{
	448	height -= m_miniTitle + 2 m_miniEdge;
	449	if (height < 0) height = 0;
	450	}
	451	}
	452
	453	// Keep min size at least as large as decorations
	454	void wxMiniFrame::DoSetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
	455	{
	456	const int w = 2 * m_miniEdge;
	457	const int h = 2 * m_miniEdge + m_miniTitle;
	458	if (minW < w) minW = w;
	459	if (minH < h) minH = h;
	460	wxFrame::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
	461	}
	462
	463	void wxMiniFrame::SetTitle( const wxString &title )
	464	{
	465	wxFrame::SetTitle( title );
	466
	467	GdkWindow* window = gtk_widget_get_window(gtk_bin_get_child(GTK_BIN(m_widget)));
	468	if (window)
	469	gdk_window_invalidate_rect(window, NULL, false);
	470	}
	471
	472	#endif // wxUSE_MINIFRAME