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 <gtk/gtk.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)
        return false;

    gtk_paint_shadow (widget->style,
                      widget->window,
                      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);

#if wxUSE_NEW_DC
    wxImplDC *impl = dc.GetImpl();
    wxGTKClientImplDC *client_impl = wxDynamicCast( impl, wxGTKClientImplDC );
    // Hack alert
    client_impl->m_window = widget->window;
#else
    // Hack alert
    dc.m_window = widget->window;
#endif

    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->GetTitle().empty() &&
        ((style & wxCAPTION) ||
         (style & wxTINY_CAPTION_HORIZ) ||
         (style & wxTINY_CAPTION_VERT)))
    {
        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 gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxMiniFrame *win )
{
    if (!win->m_hasVMT) 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 = widget->window;

        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 ((style & wxCLOSE_BOX) &&
        ((style & wxCAPTION) || (style & wxTINY_CAPTION_HORIZ) || (style & wxTINY_CAPTION_VERT)))
    {
        if ((y > 3) && (y < 19) && (x > win->m_width-19) && (x < win->m_width-3))
        {
            win->Close();
            return TRUE;
        }
    }

    if (y > win->m_miniEdge-1 + 15) return TRUE;

    gdk_window_raise( win->m_widget->window );

    gdk_pointer_grab( widget->window, 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),
                      (GdkWindow *) NULL,
                      (GdkCursor *) 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 gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxMiniFrame *win )
{
    if (!win->m_hasVMT) 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( widget->window, &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 * WXUNUSED(gdk_event),
                          wxMiniFrame *win)
{
    if (!win->m_hasVMT) return FALSE;
    if (g_blockEventsOnDrag) return FALSE;

    gdk_window_set_cursor( widget->window, NULL );

    return FALSE;
}
}

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

extern "C" {
static gint
gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxMiniFrame *win )
{
    if (!win->m_hasVMT) 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( widget->window, gdk_cursor_new( GDK_BOTTOM_RIGHT_CORNER ) );
            else
               gdk_window_set_cursor( widget->window, NULL );
        }
        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( widget->window, &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;
}
}

//-----------------------------------------------------------------------------
// "size_allocate" from GtkFixed, parent of m_mainWidget
//-----------------------------------------------------------------------------

extern "C" {
static void size_allocate(GtkWidget*, GtkAllocation* alloc, wxMiniFrame* win)
{
    // place m_mainWidget inside of decorations drawn on the GtkFixed
    GtkAllocation alloc2 = win->m_mainWidget->allocation;
    alloc2.width = alloc->width - 2 * win->m_miniEdge;
    alloc2.height = alloc->height - win->m_miniTitle - 2 * win->m_miniEdge;
    gtk_widget_size_allocate(win->m_mainWidget, &alloc2);
}
}

//-----------------------------------------------------------------------------
// 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 )
{
    if ((style & wxCAPTION) || (style & wxTINY_CAPTION_HORIZ) || (style & wxTINY_CAPTION_VERT))
        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 );

    // borders and title are on a GtkFixed between m_widget and m_mainWidget
    GtkWidget* fixed = gtk_fixed_new();
    gtk_fixed_set_has_window((GtkFixed*)fixed, true);
    gtk_widget_add_events(fixed,
        GDK_POINTER_MOTION_MASK |
        GDK_POINTER_MOTION_HINT_MASK |
        GDK_BUTTON_MOTION_MASK |
        GDK_BUTTON_PRESS_MASK |
        GDK_BUTTON_RELEASE_MASK |
        GDK_LEAVE_NOTIFY_MASK);
    gtk_widget_show(fixed);
    gtk_widget_reparent(m_mainWidget, fixed);
    gtk_container_add((GtkContainer*)m_widget, fixed);
    gtk_fixed_move((GtkFixed*)fixed, m_mainWidget, m_miniEdge, m_miniTitle + m_miniEdge);
    g_signal_connect(fixed, "size_allocate", G_CALLBACK(size_allocate), this);

    m_gdkDecor = 0;
    m_gdkFunc = 0;
    if (style & wxRESIZE_BORDER)
       m_gdkFunc = GDK_FUNC_RESIZE;

    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 ((style & wxCLOSE_BOX) &&
        ((style & wxCAPTION) || (style & wxTINY_CAPTION_HORIZ) || (style & wxTINY_CAPTION_VERT)))
    {
        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(fixed, "expose_event",
                      G_CALLBACK (gtk_window_own_expose_callback), this );

    /* these are required for dragging the mini frame around */
    g_signal_connect (fixed, "button_press_event",
                      G_CALLBACK (gtk_window_button_press_callback), this);
    g_signal_connect (fixed, "button_release_event",
                      G_CALLBACK (gtk_window_button_release_callback), this);
    g_signal_connect (fixed, "motion_notify_event",
                      G_CALLBACK (gtk_window_motion_notify_callback), this);
    g_signal_connect (fixed, "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;
    }
}

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

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