Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

simplify wxPizza a bit by always drawing the border on parent

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@56797 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Paul Cornett
2008-11-16 18:31:19 +00:00
parent b7bc9d806b
commit 75f661bbc8
2 changed files with 71 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
src/gtk/win_gtk.cpp
View File

@@ -22,11 +22,8 @@ GtkScrolledWindow. Child widget positions are adjusted for the scrolling
position in size_allocate. A second same-size GdkWindow is placed behind
widget->window, to allow GDK to use a more efficient scrolling technique.
For borders, space is reserved in realize and size_allocate.
For non-scrolling wxWindows, a second GdkWindow is used for the
border; scrolling wxWindows draw their border on wxPizza's parent
(a GtkScrolledWindow) GdkWindow. Border widths for sunken and raised
styles are taken from widget->style, so they will match the current theme.
For borders, space is reserved in realize and size_allocate. The border is
drawn on wxPizza's parent GdkWindow.
For RTL, child widget positions are mirrored in size_allocate.
*/
@@ -71,31 +68,11 @@ static void size_allocate(GtkWidget* widget, GtkAllocation* alloc)
if (is_resize)
gdk_window_resize(widget->window, w, h);
}
else if (pizza->m_backing_window)
{
// two windows, widget->window is smaller by border widths (need to
// move widget->window as well as resize because border can change)
gdk_window_move_resize(pizza->m_backing_window,
alloc->x, alloc->y, alloc->width, alloc->height);
gdk_window_move_resize(widget->window, border_x, border_y, w, h);
}
else
{
// one window
gdk_window_move_resize(widget->window,
alloc->x, alloc->y, alloc->width, alloc->height);
}
if (is_resize && pizza->m_backing_window)
{
// wxWidgets turns off redraw-on-allocate by default,
// so border area needs to be invalidated
if (border_x > 1 || border_y > 1)
{
if (pizza->m_is_scrollable)
; // invalidate does not seem to be needed in this case
else
gdk_window_invalidate_rect(pizza->m_backing_window, NULL, false);
}
alloc->x + border_x, alloc->y + border_y, w, h);
}
}
// adjust child positions
@@ -128,28 +105,25 @@ static void realize(GtkWidget* widget)
parent_class->realize(widget);
wxPizza* pizza = WX_PIZZA(widget);
// second window is created if there is a border, or wxWindow is scrollable
if (pizza->m_border_style || pizza->m_is_scrollable)
{
GdkWindowAttr attr;
attr.event_mask = pizza->m_is_scrollable ? 0 : GDK_EXPOSURE_MASK;
attr.x = widget->allocation.x;
attr.y = widget->allocation.y;
attr.width = widget->allocation.width;
attr.height = widget->allocation.height;
int border_x, border_y;
pizza->get_border_widths(border_x, border_y);
int x = widget->allocation.x + border_x;
int y = widget->allocation.y + border_y;
int w = widget->allocation.width - 2 * border_x;
int h = widget->allocation.height - 2 * border_y;
if (w < 0) w = 0;
if (h < 0) h = 0;
if (pizza->m_is_scrollable)
{
attr.x += border_x;
attr.y += border_y;
// second window is created if wxWindow is scrollable
GdkWindowAttr attr;
attr.event_mask = 0;
attr.x = x;
attr.y = y;
attr.width = w;
attr.height = h;
}
attr.wclass = GDK_INPUT_OUTPUT;
attr.visual = gtk_widget_get_visual(widget);
attr.colormap = gtk_widget_get_colormap(widget);
@@ -161,17 +135,17 @@ static void realize(GtkWidget* widget)
GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP);
gdk_window_set_user_data(pizza->m_backing_window, widget);
if (pizza->m_is_scrollable)
gdk_window_reparent(widget->window, pizza->m_backing_window, 0, 0);
else
gdk_window_reparent(widget->window, pizza->m_backing_window, border_x, border_y);
gdk_window_resize(widget->window, w, h);
// Parts of m_backing_window which are supposed to be obscured may be
// exposed temporarily while resizing. Setting the backing pixmap to
// None prevents those areas from being briefly painted black.
// Parts of m_backing_window may be exposed temporarily while
// resizing. Setting the backing pixmap to None prevents those
// areas from being briefly painted black.
gdk_window_set_back_pixmap(pizza->m_backing_window, NULL, false);
}
else
gdk_window_move_resize(widget->window, x, y, w, h);
}
}
static void unrealize(GtkWidget* widget)
@@ -386,6 +360,7 @@ void wxPizza::scroll(int dx, int dy)
void wxPizza::get_border_widths(int& x, int& y)
{
x = y = 0;
#ifndef __WXUNIVERSAL__
if (m_border_style & wxBORDER_SIMPLE)
x = y = 1;
else if (m_border_style)
@@ -397,4 +372,5 @@ void wxPizza::get_border_widths(int& x, int& y)
y = entry_widget->style->ythickness;
}
}
#endif
}

70
src/gtk/window.cpp
View File

@@ -295,30 +295,27 @@ gtk_window_expose_callback( GtkWidget* widget,
}
}
//-----------------------------------------------------------------------------
// "expose_event" from m_widget, for drawing border
//-----------------------------------------------------------------------------
#ifndef __WXUNIVERSAL__
//-----------------------------------------------------------------------------
// "expose_event" from m_wxwindow->parent, for drawing border
//-----------------------------------------------------------------------------
extern "C" {
static gboolean
expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
{
// if this event is not for the GdkWindow the border is drawn on
if (win->m_wxwindow == win->m_widget && gdk_event->window == widget->window)
if (gdk_event->window != widget->window)
return false;
const GtkAllocation& alloc = win->m_wxwindow->allocation;
const int x = alloc.x;
const int y = alloc.y;
const int w = alloc.width;
const int h = alloc.height;
if (w <= 0 || h <= 0)
return false;
int x = 0;
int y = 0;
// GtkScrolledWindow is GTK_NO_WINDOW
if (GTK_WIDGET_NO_WINDOW(widget))
{
x = widget->allocation.x;
y = widget->allocation.y;
}
int w = win->m_wxwindow->allocation.width;
int h = win->m_wxwindow->allocation.height;
if (win->HasFlag(wxBORDER_SIMPLE))
{
gdk_draw_rectangle(gdk_event->window,
@@ -332,7 +329,7 @@ expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
// Style detail to use
const char* detail;
if (widget == win->m_wxwindow)
if (win->m_widget == win->m_wxwindow)
// for non-scrollable wxWindows
detail = "entry";
else
@@ -343,9 +340,28 @@ expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
win->m_wxwindow->style, gdk_event->window, GTK_STATE_NORMAL,
shadow, NULL, wxGTKPrivate::GetEntryWidget(), detail, x, y, w, h);
}
return false;
}
}
// no further painting is needed for border-only GdkWindow
return win->m_wxwindow == win->m_widget;
//-----------------------------------------------------------------------------
// "parent_set" from m_wxwindow
//-----------------------------------------------------------------------------
extern "C" {
static void
parent_set(GtkWidget* widget, GtkObject* old_parent, wxWindow* win)
{
if (old_parent)
{
g_signal_handlers_disconnect_by_func(
old_parent, (void*)expose_event_border, win);
}
if (widget->parent)
{
g_signal_connect_after(widget->parent, "expose_event",
G_CALLBACK(expose_event_border), win);
}
}
}
#endif // !__WXUNIVERSAL__
@@ -2040,6 +2056,13 @@ bool wxWindowGTK::Create( wxWindow *parent,
m_wxwindow = wxPizza::New(m_windowStyle);
#ifndef __WXUNIVERSAL__
if (HasFlag(wxPizza::BORDER_STYLES))
{
g_signal_connect(m_wxwindow, "parent_set",
G_CALLBACK(parent_set), this);
}
#endif
if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
m_widget = m_wxwindow;
else
@@ -2215,15 +2238,6 @@ void wxWindowGTK::PostCreation()
g_signal_connect (m_imData->context, "commit",
G_CALLBACK (gtk_wxwindow_commit_cb), this);
// border drawing
#ifndef __WXUNIVERSAL__
if (HasFlag(wxPizza::BORDER_STYLES))
{
g_signal_connect(m_widget, "expose_event",
G_CALLBACK(expose_event_border), this);
}
#endif
}
// focus handling