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

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

    // need to reset default size after changing m_gdkDecor
    gtk_window_set_default_size(GTK_WINDOW(m_widget), m_width, m_height);

    // 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
	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	// wxMiniFrame
	304	//-----------------------------------------------------------------------------
	305
	306	static unsigned char close_bits[]={
	307	0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
	308	0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
	309	0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
	310
	311
	312	IMPLEMENT_DYNAMIC_CLASS(wxMiniFrame,wxFrame)
	313
	314	bool wxMiniFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
	315	const wxPoint &pos, const wxSize &size,
	316	long style, const wxString &name )
	317	{
	318	if ((style & wxCAPTION) \|\| (style & wxTINY_CAPTION_HORIZ) \|\| (style & wxTINY_CAPTION_VERT))
	319	m_miniTitle = 16;
	320
	321	if (style & wxRESIZE_BORDER)
	322	m_miniEdge = 4;
	323	else
	324	m_miniEdge = 3;
	325	m_isDragging = false;
	326	m_oldX = -1;
	327	m_oldY = -1;
	328	m_diffX = 0;
	329	m_diffY = 0;
	330
	331	wxFrame::Create( parent, id, title, pos, size, style, name );
	332
	333	// Use a GtkEventBox for the title and borders. Using m_widget for this
	334	// almost works, except that setting the resize cursor has no effect.
	335	GtkWidget* eventbox = gtk_event_box_new();
	336	gtk_widget_add_events(eventbox,
	337	GDK_POINTER_MOTION_MASK \|
	338	GDK_POINTER_MOTION_HINT_MASK);
	339	gtk_widget_show(eventbox);
	340	// Use a GtkAlignment to position m_mainWidget inside the decorations
	341	GtkWidget* alignment = gtk_alignment_new(0, 0, 1, 1);
	342	gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
	343	m_miniTitle + m_miniEdge, m_miniEdge, m_miniEdge, m_miniEdge);
	344	gtk_widget_show(alignment);
	345	// The GtkEventBox and GtkAlignment go between m_widget and m_mainWidget
	346	gtk_widget_reparent(m_mainWidget, alignment);
	347	gtk_container_add(GTK_CONTAINER(eventbox), alignment);
	348	gtk_container_add(GTK_CONTAINER(m_widget), eventbox);
	349
	350	m_gdkDecor = 0;
	351	m_gdkFunc = 0;
	352	if (style & wxRESIZE_BORDER)
	353	m_gdkFunc = GDK_FUNC_RESIZE;
	354
	355	// need to reset default size after changing m_gdkDecor
	356	gtk_window_set_default_size(GTK_WINDOW(m_widget), m_width, m_height);
	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 ((style & wxCLOSE_BOX) &&
	370	((style & wxCAPTION) \|\| (style & wxTINY_CAPTION_HORIZ) \|\| (style & wxTINY_CAPTION_VERT)))
	371	{
	372	wxImage img = wxBitmap((const char*)close_bits, 16, 16).ConvertToImage();
	373	img.Replace(0,0,0,123,123,123);
	374	img.SetMaskColour(123,123,123);
	375	m_closeButton = wxBitmap( img );
	376	}
	377
	378	/* these are called when the borders are drawn */
	379	g_signal_connect_after(eventbox, "expose_event",
	380	G_CALLBACK (gtk_window_own_expose_callback), this );
	381
	382	/* these are required for dragging the mini frame around */
	383	g_signal_connect (eventbox, "button_press_event",
	384	G_CALLBACK (gtk_window_button_press_callback), this);
	385	g_signal_connect (eventbox, "button_release_event",
	386	G_CALLBACK (gtk_window_button_release_callback), this);
	387	g_signal_connect (eventbox, "motion_notify_event",
	388	G_CALLBACK (gtk_window_motion_notify_callback), this);
	389	g_signal_connect (eventbox, "leave_notify_event",
	390	G_CALLBACK (gtk_window_leave_callback), this);
	391	return true;
	392	}
	393
	394	void wxMiniFrame::DoGetClientSize(int* width, int* height) const
	395	{
	396	wxFrame::DoGetClientSize(width, height);
	397	if (width)
	398	{
	399	width -= 2 m_miniEdge;
	400	if (width < 0) width = 0;
	401	}
	402	if (height)
	403	{
	404	height -= m_miniTitle + 2 m_miniEdge;
	405	if (height < 0) height = 0;
	406	}
	407	}
	408
	409	// Keep min size at least as large as decorations
	410	void wxMiniFrame::DoSetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
	411	{
	412	const int w = 2 * m_miniEdge;
	413	const int h = 2 * m_miniEdge + m_miniTitle;
	414	if (minW < w) minW = w;
	415	if (minH < h) minH = h;
	416	wxFrame::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
	417	}
	418
	419	void wxMiniFrame::SetTitle( const wxString &title )
	420	{
	421	wxFrame::SetTitle( title );
	422
	423	GtkWidget* widget = GTK_BIN(m_widget)->child;
	424	if (widget->window)
	425	gdk_window_invalidate_rect(widget->window, NULL, false);
	426	}
	427
	428	#endif // wxUSE_MINIFRAME