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

#include "wx/gtk/dcclient.h"

#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" {
static gboolean gtk_window_own_expose_callback(GtkWidget* widget, GdkEventExpose* gdk_event, wxMiniFrame* win)
{
    if (!win->m_hasVMT || 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);

    int style = win->GetWindowStyle();

    wxClientDC dc(win);

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

    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 (!win->m_hasVMT || 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));

    gdk_pointer_grab( gtk_widget_get_window(widget), false,
                      (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),
                      NULL,
                      NULL,
                      (unsigned int) GDK_CURRENT_TIME );

    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 (!win->m_hasVMT || 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;

    gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
    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 *win)
{
    if (!win->m_hasVMT) return FALSE;
    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 (!win->m_hasVMT || gdk_event->window != gtk_widget_get_window(widget))
        return false;
    if (g_blockEventsOnDrag) return TRUE;
    if (g_blockEventsOnScroll) return TRUE;

    if (gdk_event->is_hint)
    {
       int x = 0;
       int y = 0;
       GdkModifierType state;
       gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
       gdk_event->x = x;
       gdk_event->y = y;
       gdk_event->state = state;
    }

    int style = win->GetWindowStyle();

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

    if (!win->m_isDragging)
    {
        if (style & 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)

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;

    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;

    // don't allow sizing smaller than decorations
    GdkGeometry geom;
    geom.min_width  = 2 * m_miniEdge;
    geom.min_height = 2 * m_miniEdge + m_miniTitle;
    gtk_window_set_geometry_hints(GTK_WINDOW(m_widget), NULL, &geom, GDK_HINT_MIN_SIZE);

    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 */
    g_signal_connect_after(eventbox, "expose_event",
                      G_CALLBACK (gtk_window_own_expose_callback), this );

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