src/gtk/minifram.cpp

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