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>

//-----------------------------------------------------------------------------
// 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 != widget->window)
    {
        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->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 != widget->window)
        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 (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( 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 gboolean
gtk_window_button_release_callback(GtkWidget* widget, GdkEventButton* gdk_event, wxMiniFrame* win)
{
    if (!win->m_hasVMT || gdk_event->window != widget->window)
        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* gdk_event,
                          wxMiniFrame *win)
{
    if (!win->m_hasVMT) return FALSE;
    if (g_blockEventsOnDrag) return FALSE;
    if (gdk_event->window != widget->window)
        return false;

    gdk_window_set_cursor( widget->window, 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 != widget->window)
        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 )
{
    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;

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

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