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"
#include "wx/gtk/dcclient.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);

    wxDCImpl *impl = dc.GetImpl();
    wxClientDCImpl *gtk_impl = wxDynamicCast( impl, wxClientDCImpl );
    gtk_impl->m_gdkwindow = widget->window; // 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->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;
}
}

//-----------------------------------------------------------------------------
// 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 );

    // 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;

    // 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 ((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(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 );

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