virtual int GetMax() const;
// implementation
+ void OnChar( wxKeyEvent &event );
+
bool IsOwnGtkWindow( GdkWindow *window );
void ApplyWidgetStyle();
private:
DECLARE_DYNAMIC_CLASS(wxSpinCtrl)
+ DECLARE_EVENT_TABLE()
};
#endif
/* ///////////////////////////////////////////////////////////////////////////
// Name: win_gtk.h
-// Purpose: wxWindows's GTK base widget
+// Purpose: wxWindows's GTK base widget = GtkPizza
// Author: Robert Roebling
// Id: $Id$
// Copyright: (c) 1998 Robert Roebling
/////////////////////////////////////////////////////////////////////////// */
-#ifndef __GTK_MYFIXED_H__
-#define __GTK_MYFIXED_H__
+#ifndef __GTK_PIZZA_H__
+#define __GTK_PIZZA_H__
#include <gdk/gdk.h>
#include <gtk/gtkcontainer.h>
#endif /* __cplusplus */
-#define GTK_MYFIXED(obj) GTK_CHECK_CAST (obj, gtk_myfixed_get_type (), GtkMyFixed)
-#define GTK_MYFIXED_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_myfixed_get_type (), GtkMyFixedClass)
-#define GTK_IS_MYFIXED(obj) GTK_CHECK_TYPE (obj, gtk_myfixed_get_type ())
+#define GTK_PIZZA(obj) GTK_CHECK_CAST (obj, gtk_pizza_get_type (), GtkPizza)
+#define GTK_PIZZA_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_pizza_get_type (), GtkPizzaClass)
+#define GTK_IS_PIZZA(obj) GTK_CHECK_TYPE (obj, gtk_pizza_get_type ())
/* Shadow types */
typedef enum
GTK_MYSHADOW_OUT
} GtkMyShadowType;
-typedef struct _GtkMyFixed GtkMyFixed;
-typedef struct _GtkMyFixedClass GtkMyFixedClass;
+typedef struct _GtkPizza GtkPizza;
+typedef struct _GtkPizzaClass GtkPizzaClass;
-struct _GtkMyFixed
+struct _GtkPizza
{
GtkContainer container;
GList *children;
gboolean clear_on_draw;
};
-struct _GtkMyFixedClass
+struct _GtkPizzaClass
{
GtkContainerClass parent_class;
- void (*set_scroll_adjustments) (GtkMyFixed *myfixed,
+ void (*set_scroll_adjustments) (GtkPizza *pizza,
GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment);
};
-guint gtk_myfixed_get_type (void);
-GtkWidget* gtk_myfixed_new (void);
+guint gtk_pizza_get_type (void);
+GtkWidget* gtk_pizza_new (void);
-void gtk_myfixed_set_shadow_type (GtkMyFixed *myfixed,
+void gtk_pizza_set_shadow_type (GtkPizza *pizza,
GtkMyShadowType type);
-void gtk_my_fixed_set_clear (GtkMyFixed *myfixed,
+void gtk_pizza_set_clear (GtkPizza *pizza,
gboolean clear);
-void gtk_myfixed_scroll (GtkMyFixed *myfixed,
+void gtk_pizza_scroll (GtkPizza *pizza,
gint dx,
gint dy);
-void gtk_myfixed_put (GtkMyFixed *myfixed,
+void gtk_pizza_put (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y,
gint width,
gint height);
-void gtk_myfixed_move (GtkMyFixed *myfixed,
+void gtk_pizza_move (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y );
-void gtk_myfixed_resize (GtkMyFixed *myfixed,
+void gtk_pizza_resize (GtkPizza *pizza,
GtkWidget *widget,
gint width,
gint height );
-void gtk_myfixed_set_size (GtkMyFixed *myfixed,
+void gtk_pizza_set_size (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y,
#endif /* __cplusplus */
-#endif /* __GTK_MYFIXED_H__ */
+#endif /* __GTK_PIZZA_H__ */
virtual int GetMax() const;
// implementation
+ void OnChar( wxKeyEvent &event );
+
bool IsOwnGtkWindow( GdkWindow *window );
void ApplyWidgetStyle();
private:
DECLARE_DYNAMIC_CLASS(wxSpinCtrl)
+ DECLARE_EVENT_TABLE()
};
#endif
/* ///////////////////////////////////////////////////////////////////////////
// Name: win_gtk.h
-// Purpose: wxWindows's GTK base widget
+// Purpose: wxWindows's GTK base widget = GtkPizza
// Author: Robert Roebling
// Id: $Id$
// Copyright: (c) 1998 Robert Roebling
/////////////////////////////////////////////////////////////////////////// */
-#ifndef __GTK_MYFIXED_H__
-#define __GTK_MYFIXED_H__
+#ifndef __GTK_PIZZA_H__
+#define __GTK_PIZZA_H__
#include <gdk/gdk.h>
#include <gtk/gtkcontainer.h>
#endif /* __cplusplus */
-#define GTK_MYFIXED(obj) GTK_CHECK_CAST (obj, gtk_myfixed_get_type (), GtkMyFixed)
-#define GTK_MYFIXED_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_myfixed_get_type (), GtkMyFixedClass)
-#define GTK_IS_MYFIXED(obj) GTK_CHECK_TYPE (obj, gtk_myfixed_get_type ())
+#define GTK_PIZZA(obj) GTK_CHECK_CAST (obj, gtk_pizza_get_type (), GtkPizza)
+#define GTK_PIZZA_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_pizza_get_type (), GtkPizzaClass)
+#define GTK_IS_PIZZA(obj) GTK_CHECK_TYPE (obj, gtk_pizza_get_type ())
/* Shadow types */
typedef enum
GTK_MYSHADOW_OUT
} GtkMyShadowType;
-typedef struct _GtkMyFixed GtkMyFixed;
-typedef struct _GtkMyFixedClass GtkMyFixedClass;
+typedef struct _GtkPizza GtkPizza;
+typedef struct _GtkPizzaClass GtkPizzaClass;
-struct _GtkMyFixed
+struct _GtkPizza
{
GtkContainer container;
GList *children;
gboolean clear_on_draw;
};
-struct _GtkMyFixedClass
+struct _GtkPizzaClass
{
GtkContainerClass parent_class;
- void (*set_scroll_adjustments) (GtkMyFixed *myfixed,
+ void (*set_scroll_adjustments) (GtkPizza *pizza,
GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment);
};
-guint gtk_myfixed_get_type (void);
-GtkWidget* gtk_myfixed_new (void);
+guint gtk_pizza_get_type (void);
+GtkWidget* gtk_pizza_new (void);
-void gtk_myfixed_set_shadow_type (GtkMyFixed *myfixed,
+void gtk_pizza_set_shadow_type (GtkPizza *pizza,
GtkMyShadowType type);
-void gtk_my_fixed_set_clear (GtkMyFixed *myfixed,
+void gtk_pizza_set_clear (GtkPizza *pizza,
gboolean clear);
-void gtk_myfixed_scroll (GtkMyFixed *myfixed,
+void gtk_pizza_scroll (GtkPizza *pizza,
gint dx,
gint dy);
-void gtk_myfixed_put (GtkMyFixed *myfixed,
+void gtk_pizza_put (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y,
gint width,
gint height);
-void gtk_myfixed_move (GtkMyFixed *myfixed,
+void gtk_pizza_move (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y );
-void gtk_myfixed_resize (GtkMyFixed *myfixed,
+void gtk_pizza_resize (GtkPizza *pizza,
GtkWidget *widget,
gint width,
gint height );
-void gtk_myfixed_set_size (GtkMyFixed *myfixed,
+void gtk_pizza_set_size (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y,
#endif /* __cplusplus */
-#endif /* __GTK_MYFIXED_H__ */
+#endif /* __GTK_PIZZA_H__ */
wxButton::~wxButton()
{
- if (m_clientData) delete m_clientData;
}
bool wxButton::Create( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxValidator& validator, const wxString &name )
{
- m_clientData = (wxClientData*) NULL;
m_needParent = TRUE;
m_acceptsFocus = TRUE;
return TRUE;
}
-void wxButton::SetDefault(void)
+void wxButton::SetDefault()
{
GTK_WIDGET_SET_FLAGS( m_widget, GTK_CAN_DEFAULT );
gtk_widget_grab_default( m_widget );
wxASSERT_MSG( widget, wxT("DC needs a widget") );
- GtkMyFixed *myfixed = GTK_MYFIXED( widget );
- m_window = myfixed->bin_window;
+ GtkPizza *pizza = GTK_PIZZA( widget );
+ m_window = pizza->bin_window;
/* not realized ? */
if (!m_window)
static void wxInsertChildInDialog( wxDialog* parent, wxWindow* child )
{
- gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
+ gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
GTK_SIGNAL_FUNC(gtk_dialog_delete_callback), (gpointer)this );
- m_wxwindow = gtk_myfixed_new();
+ m_wxwindow = gtk_pizza_new();
gtk_widget_show( m_wxwindow );
GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
{
/* these are outside the client area */
wxFrame* frame = (wxFrame*) parent;
- gtk_myfixed_put( GTK_MYFIXED(frame->m_mainWidget),
+ gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
else
{
/* these are inside the client area */
- gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
+ gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );
/* m_mainWidget holds the toolbar, the menubar and the client area */
- m_mainWidget = gtk_myfixed_new();
+ m_mainWidget = gtk_pizza_new();
gtk_widget_show( m_mainWidget );
GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
#endif
/* m_wxwindow only represents the client area without toolbar and menubar */
- m_wxwindow = gtk_myfixed_new();
+ m_wxwindow = gtk_pizza_new();
gtk_widget_show( m_wxwindow );
gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
m_frameMenuBar->m_y = yy;
m_frameMenuBar->m_width = ww;
m_frameMenuBar->m_height = hh;
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
m_frameMenuBar->m_widget,
xx, yy, ww, hh );
client_area_y_offset += hh;
m_frameToolBar->m_y = yy;
/* m_frameToolBar->m_height = hh; don't change the toolbar's reported size
m_frameToolBar->m_width = ww; */
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
m_frameToolBar->m_widget,
xx, yy, ww, hh );
client_area_y_offset += hh;
int client_y = client_area_y_offset + m_miniEdge + m_miniTitle;
int client_w = m_width - 2*m_miniEdge;
int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle;
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
m_wxwindow,
client_x, client_y, client_w, client_h );
}
m_frameStatusBar->m_y = yy;
m_frameStatusBar->m_width = ww;
m_frameStatusBar->m_height = hh;
- gtk_myfixed_set_size( GTK_MYFIXED(m_wxwindow),
+ gtk_pizza_set_size( GTK_PIZZA(m_wxwindow),
m_frameStatusBar->m_widget,
xx, yy, ww, hh );
}
if (m_frameMenuBar->GetParent() != this)
{
m_frameMenuBar->SetParent(this);
- gtk_myfixed_put( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_put( GTK_PIZZA(m_mainWidget),
m_frameMenuBar->m_widget,
m_frameMenuBar->m_x,
m_frameMenuBar->m_y,
menu_bar->m_y = 0;
menu_bar->m_width = m_width;
menu_bar->m_height = wxMENU_HEIGHT;
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
menu_bar->m_widget,
0, 0, m_width, wxMENU_HEIGHT );
}
{
menu_bar->m_width = m_width;
menu_bar->m_height = wxMENU_HEIGHT;
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
menu_bar->m_widget,
0, 0, m_width, wxMENU_HEIGHT );
menu_bar->SetInvokingWindow( child_frame );
m_frameMenuBar->m_width = m_width;
m_frameMenuBar->m_height = wxMENU_HEIGHT;
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
m_frameMenuBar->m_widget,
0, 0, m_width, wxMENU_HEIGHT );
}
m_menuBar->SetParent( mdi_frame );
/* insert the invisible menu bar into the _parent_ mdi frame */
- gtk_myfixed_put( GTK_MYFIXED(mdi_frame->m_mainWidget),
+ gtk_pizza_put( GTK_PIZZA(mdi_frame->m_mainWidget),
m_menuBar->m_widget,
0, 0, mdi_frame->m_width, wxMENU_HEIGHT );
}
if (!win->m_hasVMT) return;
if (gdk_event->count > 0) return;
- GtkMyFixed *myfixed = GTK_MYFIXED(widget);
+ GtkPizza *pizza = GTK_PIZZA(widget);
gtk_draw_shadow( widget->style,
- myfixed->bin_window,
+ pizza->bin_window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
0, 0,
(win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) ||
(win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
{
- GdkGC *gc = gdk_gc_new( myfixed->bin_window );
+ GdkGC *gc = gdk_gc_new( pizza->bin_window );
GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
int x = 2;
if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 18;
gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
- gdk_draw_rectangle( myfixed->bin_window, gc, TRUE,
+ gdk_draw_rectangle( pizza->bin_window, gc, TRUE,
x,
3,
win->m_width - 4 - x,
font->ascent + font->descent+1 );
gdk_gc_set_foreground( gc, &widget->style->white );
- gdk_draw_string( myfixed->bin_window, font, gc,
+ gdk_draw_string( pizza->bin_window, font, gc,
x+2,
3+font->ascent,
win->m_title.mb_str() );
if (!win->m_hasVMT) return;
- GtkMyFixed *myfixed = GTK_MYFIXED(widget);
+ GtkPizza *pizza = GTK_PIZZA(widget);
gtk_draw_shadow( widget->style,
- myfixed->bin_window,
+ pizza->bin_window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
0, 0,
(win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) ||
(win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
{
- GdkGC *gc = gdk_gc_new( myfixed->bin_window );
+ GdkGC *gc = gdk_gc_new( pizza->bin_window );
GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
int x = 2;
if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 17;
gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
- gdk_draw_rectangle( myfixed->bin_window, gc, TRUE,
+ gdk_draw_rectangle( pizza->bin_window, gc, TRUE,
x,
3,
win->m_width - 4 - x,
font->ascent + font->descent+1 );
gdk_gc_set_foreground( gc, &widget->style->white );
- gdk_draw_string( myfixed->bin_window, font, gc,
+ gdk_draw_string( pizza->bin_window, font, gc,
x+2,
3+font->ascent,
win->m_title.mb_str() );
{
GtkWidget *close_button = gtk_button_new_with_label( "x" );
- gtk_myfixed_put( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_put( GTK_PIZZA(m_mainWidget),
close_button,
4, 4, 12, 11 );
gtk_signal_connect( GTK_OBJECT(m_radio), "clicked",
GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
- gtk_myfixed_put( GTK_MYFIXED(m_parent->m_wxwindow),
+ gtk_pizza_put( GTK_PIZZA(m_parent->m_wxwindow),
GTK_WIDGET(m_radio),
m_x+10, m_y+10+(i*24), 10, 10 );
}
int len = 22+gdk_string_measure( font, label->label );
if (len > max_len) max_len = len;
- gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y );
+ gtk_pizza_move( GTK_PIZZA(m_parent->m_wxwindow), button, m_x+x, m_y+y );
y += 22;
node = node->Next();
{
GtkWidget *button = GTK_WIDGET( node->Data() );
- gtk_myfixed_resize( GTK_MYFIXED(m_parent->m_wxwindow), button, max_len, 20 );
+ gtk_pizza_resize( GTK_PIZZA(m_parent->m_wxwindow), button, max_len, 20 );
node = node->Next();
if (!node) break;
{
GtkWidget *button = GTK_WIDGET( node->Data() );
- gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y, max, 20 );
+ gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), button, m_x+x, m_y+y, max, 20 );
x += max;
node = node->Next();
IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrl,wxControl)
+BEGIN_EVENT_TABLE(wxSpinCtrl, wxControl)
+ EVT_CHAR(wxSpinCtrl::OnChar)
+END_EVENT_TABLE()
+
bool wxSpinCtrl::Create(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos, const wxSize& size,
SetFocus();
}
+void wxSpinCtrl::OnChar( wxKeyEvent &event )
+{
+ wxCHECK_RET( m_widget != NULL, wxT("invalid spin ctrl") );
+
+ if (event.KeyCode() == WXK_RETURN)
+ {
+ wxWindow *top_frame = m_parent;
+ while (top_frame->GetParent() && !(top_frame->GetParent()->m_isFrame))
+ top_frame = top_frame->GetParent();
+ GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
+
+ if (window->default_widget)
+ {
+ gtk_widget_activate (window->default_widget);
+ return;
+ }
+ }
+
+ event.Skip();
+}
+
bool wxSpinCtrl::IsOwnGtkWindow( GdkWindow *window )
{
return GTK_SPIN_BUTTON(m_widget)->panel == window;
if (GetEventHandler()->ProcessEvent(event)) return;
}
+ if ((key_event.KeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
+ {
+ wxWindow *top_frame = m_parent;
+ while (top_frame->GetParent() && !(top_frame->GetParent()->m_isFrame))
+ top_frame = top_frame->GetParent();
+ GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
+
+ if (window->default_widget)
+ {
+ gtk_widget_activate (window->default_widget);
+ return;
+ }
+ }
+
key_event.Skip();
}
#define IS_ONSCREEN(x,y) ((x >= G_MINSHORT) && (x <= G_MAXSHORT) && \
(y >= G_MINSHORT) && (y <= G_MAXSHORT))
-typedef struct _GtkMyFixedAdjData GtkMyFixedAdjData;
-typedef struct _GtkMyFixedChild GtkMyFixedChild;
+typedef struct _GtkPizzaAdjData GtkPizzaAdjData;
+typedef struct _GtkPizzaChild GtkPizzaChild;
-struct _GtkMyFixedAdjData
+struct _GtkPizzaAdjData
{
gint dx;
gint dy;
};
-struct _GtkMyFixedChild
+struct _GtkPizzaChild
{
GtkWidget *widget;
gint x;
gint height;
};
-static void gtk_myfixed_class_init (GtkMyFixedClass *klass);
-static void gtk_myfixed_init (GtkMyFixed *myfixed);
+static void gtk_pizza_class_init (GtkPizzaClass *klass);
+static void gtk_pizza_init (GtkPizza *pizza);
-static void gtk_myfixed_realize (GtkWidget *widget);
-static void gtk_myfixed_unrealize (GtkWidget *widget);
+static void gtk_pizza_realize (GtkWidget *widget);
+static void gtk_pizza_unrealize (GtkWidget *widget);
-static void gtk_myfixed_map (GtkWidget *widget);
+static void gtk_pizza_map (GtkWidget *widget);
-static void gtk_myfixed_size_request (GtkWidget *widget,
+static void gtk_pizza_size_request (GtkWidget *widget,
GtkRequisition *requisition);
-static void gtk_myfixed_size_allocate (GtkWidget *widget,
+static void gtk_pizza_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
-static void gtk_myfixed_draw (GtkWidget *widget,
+static void gtk_pizza_draw (GtkWidget *widget,
GdkRectangle *area);
-static gint gtk_myfixed_expose (GtkWidget *widget,
+static gint gtk_pizza_expose (GtkWidget *widget,
GdkEventExpose *event);
-static void gtk_myfixed_add (GtkContainer *container,
+static void gtk_pizza_add (GtkContainer *container,
GtkWidget *widget);
-static void gtk_myfixed_remove (GtkContainer *container,
+static void gtk_pizza_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_myfixed_forall (GtkContainer *container,
+static void gtk_pizza_forall (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
-static void gtk_myfixed_position_child (GtkMyFixed *myfixed,
- GtkMyFixedChild *child);
-static void gtk_myfixed_allocate_child (GtkMyFixed *myfixed,
- GtkMyFixedChild *child);
-static void gtk_myfixed_position_children (GtkMyFixed *myfixed);
+static void gtk_pizza_position_child (GtkPizza *pizza,
+ GtkPizzaChild *child);
+static void gtk_pizza_allocate_child (GtkPizza *pizza,
+ GtkPizzaChild *child);
+static void gtk_pizza_position_children (GtkPizza *pizza);
-static void gtk_myfixed_adjust_allocations_recurse (GtkWidget *widget,
+static void gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
gpointer cb_data);
-static void gtk_myfixed_adjust_allocations (GtkMyFixed *myfixed,
+static void gtk_pizza_adjust_allocations (GtkPizza *pizza,
gint dx,
gint dy);
-static void gtk_myfixed_expose_area (GtkMyFixed *myfixed,
+static void gtk_pizza_expose_area (GtkPizza *pizza,
gint x,
gint y,
gint width,
gint height);
-static void gtk_myfixed_adjustment_changed (GtkAdjustment *adjustment,
- GtkMyFixed *myfixed);
-static GdkFilterReturn gtk_myfixed_filter (GdkXEvent *gdk_xevent,
+static void gtk_pizza_adjustment_changed (GtkAdjustment *adjustment,
+ GtkPizza *pizza);
+static GdkFilterReturn gtk_pizza_filter (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data);
-static GdkFilterReturn gtk_myfixed_main_filter (GdkXEvent *gdk_xevent,
+static GdkFilterReturn gtk_pizza_main_filter (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data);
-static GtkType gtk_myfixed_child_type (GtkContainer *container);
+static GtkType gtk_pizza_child_type (GtkContainer *container);
-static void gtk_myfixed_scroll_set_adjustments (GtkMyFixed *myfixed,
+static void gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
GtkAdjustment *hadj,
GtkAdjustment *vadj);
static gboolean gravity_works;
guint
-gtk_myfixed_get_type ()
+gtk_pizza_get_type ()
{
- static guint myfixed_type = 0;
+ static guint pizza_type = 0;
- if (!myfixed_type)
+ if (!pizza_type)
{
- GtkTypeInfo myfixed_info =
+ GtkTypeInfo pizza_info =
{
- "GtkMyFixed",
- sizeof (GtkMyFixed),
- sizeof (GtkMyFixedClass),
- (GtkClassInitFunc) gtk_myfixed_class_init,
- (GtkObjectInitFunc) gtk_myfixed_init,
+ "GtkPizza",
+ sizeof (GtkPizza),
+ sizeof (GtkPizzaClass),
+ (GtkClassInitFunc) gtk_pizza_class_init,
+ (GtkObjectInitFunc) gtk_pizza_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
- myfixed_type = gtk_type_unique (gtk_container_get_type (), &myfixed_info);
+ pizza_type = gtk_type_unique (gtk_container_get_type (), &pizza_info);
}
- return myfixed_type;
+ return pizza_type;
}
static void
-gtk_myfixed_class_init (GtkMyFixedClass *klass)
+gtk_pizza_class_init (GtkPizzaClass *klass)
{
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
container_class = (GtkContainerClass*) klass;
parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
- widget_class->map = gtk_myfixed_map;
- widget_class->realize = gtk_myfixed_realize;
- widget_class->unrealize = gtk_myfixed_unrealize;
- widget_class->size_request = gtk_myfixed_size_request;
- widget_class->size_allocate = gtk_myfixed_size_allocate;
- widget_class->draw = gtk_myfixed_draw;
- widget_class->expose_event = gtk_myfixed_expose;
+ widget_class->map = gtk_pizza_map;
+ widget_class->realize = gtk_pizza_realize;
+ widget_class->unrealize = gtk_pizza_unrealize;
+ widget_class->size_request = gtk_pizza_size_request;
+ widget_class->size_allocate = gtk_pizza_size_allocate;
+ widget_class->draw = gtk_pizza_draw;
+ widget_class->expose_event = gtk_pizza_expose;
- container_class->add = gtk_myfixed_add;
- container_class->remove = gtk_myfixed_remove;
- container_class->forall = gtk_myfixed_forall;
+ container_class->add = gtk_pizza_add;
+ container_class->remove = gtk_pizza_remove;
+ container_class->forall = gtk_pizza_forall;
- container_class->child_type = gtk_myfixed_child_type;
+ container_class->child_type = gtk_pizza_child_type;
- klass->set_scroll_adjustments = gtk_myfixed_scroll_set_adjustments;
+ klass->set_scroll_adjustments = gtk_pizza_scroll_set_adjustments;
widget_class->set_scroll_adjustments_signal =
gtk_signal_new ("set_scroll_adjustments",
GTK_RUN_LAST,
object_class->type,
- GTK_SIGNAL_OFFSET (GtkMyFixedClass, set_scroll_adjustments),
+ GTK_SIGNAL_OFFSET (GtkPizzaClass, set_scroll_adjustments),
gtk_marshal_NONE__POINTER_POINTER,
GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
}
static GtkType
-gtk_myfixed_child_type (GtkContainer *container)
+gtk_pizza_child_type (GtkContainer *container)
{
return GTK_TYPE_WIDGET;
}
static void
-gtk_myfixed_init (GtkMyFixed *myfixed)
+gtk_pizza_init (GtkPizza *pizza)
{
- GTK_WIDGET_UNSET_FLAGS (myfixed, GTK_NO_WINDOW);
+ GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW);
- myfixed->shadow_type = GTK_MYSHADOW_NONE;
+ pizza->shadow_type = GTK_MYSHADOW_NONE;
- myfixed->children = NULL;
+ pizza->children = NULL;
- myfixed->width = 20;
- myfixed->height = 20;
+ pizza->width = 20;
+ pizza->height = 20;
- myfixed->bin_window = NULL;
+ pizza->bin_window = NULL;
- myfixed->configure_serial = 0;
- myfixed->scroll_x = 0;
- myfixed->scroll_y = 0;
- myfixed->visibility = GDK_VISIBILITY_PARTIAL;
+ pizza->configure_serial = 0;
+ pizza->scroll_x = 0;
+ pizza->scroll_y = 0;
+ pizza->visibility = GDK_VISIBILITY_PARTIAL;
- myfixed->clear_on_draw = TRUE;
+ pizza->clear_on_draw = TRUE;
}
GtkWidget*
-gtk_myfixed_new ()
+gtk_pizza_new ()
{
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
- myfixed = gtk_type_new (gtk_myfixed_get_type ());
+ pizza = gtk_type_new (gtk_pizza_get_type ());
- return GTK_WIDGET (myfixed);
+ return GTK_WIDGET (pizza);
}
void
-gtk_myfixed_scroll_set_adjustments (GtkMyFixed *myfixed,
+gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
GtkAdjustment *hadj,
GtkAdjustment *vadj)
{
}
void
-gtk_myfixed_set_shadow_type (GtkMyFixed *myfixed,
+gtk_pizza_set_shadow_type (GtkPizza *pizza,
GtkMyShadowType type)
{
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
- if ((GtkMyShadowType) myfixed->shadow_type != type)
+ if ((GtkMyShadowType) pizza->shadow_type != type)
{
- myfixed->shadow_type = type;
+ pizza->shadow_type = type;
- if (GTK_WIDGET_VISIBLE (myfixed))
+ if (GTK_WIDGET_VISIBLE (pizza))
{
- gtk_widget_size_allocate (GTK_WIDGET (myfixed), &(GTK_WIDGET (myfixed)->allocation));
- gtk_widget_queue_draw (GTK_WIDGET (myfixed));
+ gtk_widget_size_allocate (GTK_WIDGET (pizza), &(GTK_WIDGET (pizza)->allocation));
+ gtk_widget_queue_draw (GTK_WIDGET (pizza));
}
}
}
void
-gtk_my_fixed_set_clear (GtkMyFixed *myfixed,
+gtk_pizza_set_clear (GtkPizza *pizza,
gboolean clear)
{
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
- myfixed->clear_on_draw = clear;
+ pizza->clear_on_draw = clear;
}
void
-gtk_myfixed_put (GtkMyFixed *myfixed,
+gtk_pizza_put (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y,
gint width,
gint height)
{
- GtkMyFixedChild *child_info;
+ GtkPizzaChild *child_info;
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
g_return_if_fail (widget != NULL);
- child_info = g_new (GtkMyFixedChild, 1);
+ child_info = g_new (GtkPizzaChild, 1);
child_info->widget = widget;
child_info->x = x;
child_info->width = width;
child_info->height = height;
- myfixed->children = g_list_append (myfixed->children, child_info);
+ pizza->children = g_list_append (pizza->children, child_info);
- gtk_widget_set_parent (widget, GTK_WIDGET (myfixed));
+ gtk_widget_set_parent (widget, GTK_WIDGET (pizza));
- if (GTK_WIDGET_REALIZED (myfixed))
- gtk_widget_set_parent_window (widget, myfixed->bin_window);
+ if (GTK_WIDGET_REALIZED (pizza))
+ gtk_widget_set_parent_window (widget, pizza->bin_window);
if (!IS_ONSCREEN (x, y))
GTK_PRIVATE_SET_FLAG (widget, GTK_IS_OFFSCREEN);
- if (GTK_WIDGET_REALIZED (myfixed))
+ if (GTK_WIDGET_REALIZED (pizza))
gtk_widget_realize (widget);
gtk_widget_set_usize (widget, width, height);
- if (GTK_WIDGET_VISIBLE (myfixed) && GTK_WIDGET_VISIBLE (widget))
+ if (GTK_WIDGET_VISIBLE (pizza) && GTK_WIDGET_VISIBLE (widget))
{
- if (GTK_WIDGET_MAPPED (myfixed))
+ if (GTK_WIDGET_MAPPED (pizza))
gtk_widget_map (widget);
gtk_widget_queue_resize (widget);
}
void
-gtk_myfixed_move (GtkMyFixed *myfixed,
+gtk_pizza_move (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y)
{
- GtkMyFixedChild *child;
+ GtkPizzaChild *child;
GList *children;
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
g_return_if_fail (widget != NULL);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
child->x = x;
child->y = y;
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
+ if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
gtk_widget_queue_resize (widget);
break;
}
}
void
-gtk_myfixed_resize (GtkMyFixed *myfixed,
+gtk_pizza_resize (GtkPizza *pizza,
GtkWidget *widget,
gint width,
gint height)
{
- GtkMyFixedChild *child;
+ GtkPizzaChild *child;
GList *children;
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
g_return_if_fail (widget != NULL);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
gtk_widget_set_usize (widget, width, height);
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
+ if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
gtk_widget_queue_resize (widget);
break;
}
}
void
-gtk_myfixed_set_size (GtkMyFixed *myfixed,
+gtk_pizza_set_size (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y,
gint width,
gint height)
{
- GtkMyFixedChild *child;
+ GtkPizzaChild *child;
GList *children;
GtkAllocation child_allocation;
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
g_return_if_fail (widget != NULL);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
gtk_widget_set_usize (widget, width, height);
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
+ if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
gtk_widget_queue_resize (widget);
return;
}
static void
-gtk_myfixed_map (GtkWidget *widget)
+gtk_pizza_map (GtkWidget *widget)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GList *children;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (widget));
+ g_return_if_fail (GTK_IS_PIZZA (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
}
gdk_window_show (widget->window);
- gdk_window_show (myfixed->bin_window);
+ gdk_window_show (pizza->bin_window);
}
static void
-gtk_myfixed_realize (GtkWidget *widget)
+gtk_pizza_realize (GtkWidget *widget)
{
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
GdkWindowAttr attributes;
gint attributes_mask;
- GtkMyFixedChild *child;
+ GtkPizzaChild *child;
GList *children;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (widget));
+ g_return_if_fail (GTK_IS_PIZZA (widget));
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
- if (myfixed->shadow_type == GTK_MYSHADOW_NONE)
+ if (pizza->shadow_type == GTK_MYSHADOW_NONE)
{
/* no border, no changes to sizes */
} else
- if (myfixed->shadow_type == GTK_MYSHADOW_THIN)
+ if (pizza->shadow_type == GTK_MYSHADOW_THIN)
{
/* GTK_MYSHADOW_THIN == wxSIMPLE_BORDER */
attributes.x += 1;
GDK_LEAVE_NOTIFY_MASK |
GDK_FOCUS_CHANGE_MASK;
- myfixed->bin_window = gdk_window_new (widget->window,
+ pizza->bin_window = gdk_window_new (widget->window,
&attributes, attributes_mask);
- gdk_window_set_user_data (myfixed->bin_window, widget);
+ gdk_window_set_user_data (pizza->bin_window, widget);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
- gtk_style_set_background (widget->style, myfixed->bin_window, GTK_STATE_NORMAL);
+ gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL);
/* add filters for intercepting visibility and expose events */
- gdk_window_add_filter (widget->window, gtk_myfixed_main_filter, myfixed);
- gdk_window_add_filter (myfixed->bin_window, gtk_myfixed_filter, myfixed);
+ gdk_window_add_filter (widget->window, gtk_pizza_main_filter, pizza);
+ gdk_window_add_filter (pizza->bin_window, gtk_pizza_filter, pizza);
/* we NEED gravity or we'll give up */
- gravity_works = gdk_window_set_static_gravities (myfixed->bin_window, TRUE);
+ gravity_works = gdk_window_set_static_gravities (pizza->bin_window, TRUE);
/* cannot be done before realisation */
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
children = children->next;
- gtk_widget_set_parent_window (child->widget, myfixed->bin_window);
+ gtk_widget_set_parent_window (child->widget, pizza->bin_window);
}
}
static void
-gtk_myfixed_unrealize (GtkWidget *widget)
+gtk_pizza_unrealize (GtkWidget *widget)
{
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (widget));
+ g_return_if_fail (GTK_IS_PIZZA (widget));
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
- gdk_window_set_user_data (myfixed->bin_window, NULL);
- gdk_window_destroy (myfixed->bin_window);
- myfixed->bin_window = NULL;
+ gdk_window_set_user_data (pizza->bin_window, NULL);
+ gdk_window_destroy (pizza->bin_window);
+ pizza->bin_window = NULL;
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}
static void
-gtk_myfixed_size_request (GtkWidget *widget,
+gtk_pizza_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GList *children;
GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (widget));
+ g_return_if_fail (GTK_IS_PIZZA (widget));
g_return_if_fail (requisition != NULL);
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
}
static void
-gtk_myfixed_size_allocate (GtkWidget *widget,
+gtk_pizza_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
gint border;
gint x,y,w,h;
- GtkMyFixedChild *child;
+ GtkPizzaChild *child;
GtkAllocation child_allocation;
GList *children;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED(widget));
+ g_return_if_fail (GTK_IS_PIZZA(widget));
g_return_if_fail (allocation != NULL);
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
widget->allocation = *allocation;
- if (myfixed->shadow_type == GTK_MYSHADOW_NONE)
+ if (pizza->shadow_type == GTK_MYSHADOW_NONE)
border = 0;
else
- if (myfixed->shadow_type == GTK_MYSHADOW_THIN)
+ if (pizza->shadow_type == GTK_MYSHADOW_THIN)
border = 1;
else
border = 2;
if (GTK_WIDGET_REALIZED (widget))
{
gdk_window_move_resize( widget->window, x, y, w, h );
- gdk_window_move_resize( myfixed->bin_window, 0, 0, w, h );
+ gdk_window_move_resize( pizza->bin_window, 0, 0, w, h );
}
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
children = children->next;
- gtk_myfixed_position_child (myfixed, child);
- gtk_myfixed_allocate_child (myfixed, child);
+ gtk_pizza_position_child (pizza, child);
+ gtk_pizza_allocate_child (pizza, child);
}
}
static void
-gtk_myfixed_draw (GtkWidget *widget,
+gtk_pizza_draw (GtkWidget *widget,
GdkRectangle *area)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GdkRectangle child_area;
GList *children;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (widget));
+ g_return_if_fail (GTK_IS_PIZZA (widget));
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
- children = myfixed->children;
+ children = pizza->children;
if ( !(GTK_WIDGET_APP_PAINTABLE (widget)) &&
- (myfixed->clear_on_draw))
+ (pizza->clear_on_draw))
{
- gdk_window_clear_area( myfixed->bin_window,
+ gdk_window_clear_area( pizza->bin_window,
area->x, area->y, area->width, area->height);
}
}
static gint
-gtk_myfixed_expose (GtkWidget *widget,
+gtk_pizza_expose (GtkWidget *widget,
GdkEventExpose *event)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GdkEventExpose child_event;
GList *children;
g_return_val_if_fail (widget != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_MYFIXED (widget), FALSE);
+ g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
/*
if (event->window == widget->window)
{
- gtk_myfixed_draw_border( myfixed );
+ gtk_pizza_draw_border( pizza );
return FALSE;
}
*/
- if (event->window != myfixed->bin_window)
+ if (event->window != pizza->bin_window)
return FALSE;
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
}
static void
-gtk_myfixed_add (GtkContainer *container,
+gtk_pizza_add (GtkContainer *container,
GtkWidget *widget)
{
g_return_if_fail (container != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (container));
+ g_return_if_fail (GTK_IS_PIZZA (container));
g_return_if_fail (widget != NULL);
- gtk_myfixed_put (GTK_MYFIXED (container), widget, 0, 0, 20, 20 );
+ gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
}
static void
-gtk_myfixed_remove (GtkContainer *container,
+gtk_pizza_remove (GtkContainer *container,
GtkWidget *widget)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GList *children;
g_return_if_fail (container != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (container));
+ g_return_if_fail (GTK_IS_PIZZA (container));
g_return_if_fail (widget != NULL);
- myfixed = GTK_MYFIXED (container);
+ pizza = GTK_PIZZA (container);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
/* security checks */
g_return_if_fail (GTK_IS_WIDGET (widget));
- myfixed->children = g_list_remove_link (myfixed->children, children);
+ pizza->children = g_list_remove_link (pizza->children, children);
g_list_free (children);
g_free (child);
}
static void
-gtk_myfixed_forall (GtkContainer *container,
+gtk_pizza_forall (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
gpointer callback_data)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GList *children;
g_return_if_fail (container != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (container));
+ g_return_if_fail (GTK_IS_PIZZA (container));
g_return_if_fail (callback != NULL);
- myfixed = GTK_MYFIXED (container);
+ pizza = GTK_PIZZA (container);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
*/
static void
-gtk_myfixed_position_child (GtkMyFixed *myfixed,
- GtkMyFixedChild *child)
+gtk_pizza_position_child (GtkPizza *pizza,
+ GtkPizzaChild *child)
{
gint x;
gint y;
- x = child->x - myfixed->xoffset;
- y = child->y - myfixed->yoffset;
+ x = child->x - pizza->xoffset;
+ y = child->y - pizza->yoffset;
if (IS_ONSCREEN (x,y))
{
- if (GTK_WIDGET_MAPPED (myfixed) &&
+ if (GTK_WIDGET_MAPPED (pizza) &&
GTK_WIDGET_VISIBLE (child->widget))
{
if (!GTK_WIDGET_MAPPED (child->widget))
}
static void
-gtk_myfixed_allocate_child (GtkMyFixed *myfixed,
- GtkMyFixedChild *child)
+gtk_pizza_allocate_child (GtkPizza *pizza,
+ GtkPizzaChild *child)
{
GtkAllocation allocation;
GtkRequisition requisition;
- allocation.x = child->x - myfixed->xoffset;
- allocation.y = child->y - myfixed->yoffset;
+ allocation.x = child->x - pizza->xoffset;
+ allocation.y = child->y - pizza->yoffset;
gtk_widget_get_child_requisition (child->widget, &requisition);
allocation.width = requisition.width;
allocation.height = requisition.height;
}
static void
-gtk_myfixed_position_children (GtkMyFixed *myfixed)
+gtk_pizza_position_children (GtkPizza *pizza)
{
GList *tmp_list;
- tmp_list = myfixed->children;
+ tmp_list = pizza->children;
while (tmp_list)
{
- GtkMyFixedChild *child = tmp_list->data;
+ GtkPizzaChild *child = tmp_list->data;
tmp_list = tmp_list->next;
- gtk_myfixed_position_child (myfixed, child);
+ gtk_pizza_position_child (pizza, child);
}
}
static void
-gtk_myfixed_adjust_allocations_recurse (GtkWidget *widget,
+gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
gpointer cb_data)
{
- GtkMyFixedAdjData *data = cb_data;
+ GtkPizzaAdjData *data = cb_data;
widget->allocation.x += data->dx;
widget->allocation.y += data->dy;
if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget))
{
gtk_container_forall (GTK_CONTAINER (widget),
- gtk_myfixed_adjust_allocations_recurse,
+ gtk_pizza_adjust_allocations_recurse,
cb_data);
}
}
static void
-gtk_myfixed_adjust_allocations (GtkMyFixed *myfixed,
+gtk_pizza_adjust_allocations (GtkPizza *pizza,
gint dx,
gint dy)
{
GList *tmp_list;
- GtkMyFixedAdjData data;
+ GtkPizzaAdjData data;
data.dx = dx;
data.dy = dy;
- tmp_list = myfixed->children;
+ tmp_list = pizza->children;
while (tmp_list)
{
- GtkMyFixedChild *child = tmp_list->data;
+ GtkPizzaChild *child = tmp_list->data;
tmp_list = tmp_list->next;
child->widget->allocation.x += dx;
if (GTK_WIDGET_NO_WINDOW (child->widget) &&
GTK_IS_CONTAINER (child->widget))
gtk_container_forall (GTK_CONTAINER (child->widget),
- gtk_myfixed_adjust_allocations_recurse,
+ gtk_pizza_adjust_allocations_recurse,
&data);
}
}
/* Send a synthetic expose event to the widget
*/
static void
-gtk_myfixed_expose_area (GtkMyFixed *myfixed,
+gtk_pizza_expose_area (GtkPizza *pizza,
gint x, gint y, gint width, gint height)
{
- if (myfixed->visibility == GDK_VISIBILITY_UNOBSCURED)
+ if (pizza->visibility == GDK_VISIBILITY_UNOBSCURED)
{
GdkEventExpose event;
event.type = GDK_EXPOSE;
event.send_event = TRUE;
- event.window = myfixed->bin_window;
+ event.window = pizza->bin_window;
event.count = 0;
event.area.x = x;
event.area.height = height;
gdk_window_ref (event.window);
- gtk_widget_event (GTK_WIDGET (myfixed), (GdkEvent *)&event);
+ gtk_widget_event (GTK_WIDGET (pizza), (GdkEvent *)&event);
gdk_window_unref (event.window);
}
}
*/
static Bool
-gtk_myfixed_expose_predicate (Display *display,
+gtk_pizza_expose_predicate (Display *display,
XEvent *xevent,
XPointer arg)
{
*/
void
-gtk_myfixed_scroll (GtkMyFixed *myfixed, gint dx, gint dy)
+gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
{
GtkWidget *widget;
XEvent xevent;
gint x,y,w,h,border;
- widget = GTK_WIDGET (myfixed);
+ widget = GTK_WIDGET (pizza);
- myfixed->xoffset += dx;
- myfixed->yoffset += dy;
+ pizza->xoffset += dx;
+ pizza->yoffset += dy;
- if (!GTK_WIDGET_MAPPED (myfixed))
+ if (!GTK_WIDGET_MAPPED (pizza))
{
- gtk_myfixed_position_children (myfixed);
+ gtk_pizza_position_children (pizza);
return;
}
- gtk_myfixed_adjust_allocations (myfixed, -dx, -dy);
+ gtk_pizza_adjust_allocations (pizza, -dx, -dy);
- if (myfixed->shadow_type == GTK_MYSHADOW_NONE)
+ if (pizza->shadow_type == GTK_MYSHADOW_NONE)
border = 0;
else
- if (myfixed->shadow_type == GTK_MYSHADOW_THIN)
+ if (pizza->shadow_type == GTK_MYSHADOW_THIN)
border = 1;
else
border = 2;
{
if (gravity_works)
{
- gdk_window_resize (myfixed->bin_window,
+ gdk_window_resize (pizza->bin_window,
w + dx,
h);
- gdk_window_move (myfixed->bin_window, x-dx, y);
- gdk_window_move_resize (myfixed->bin_window, x, y, w, h );
+ gdk_window_move (pizza->bin_window, x-dx, y);
+ gdk_window_move_resize (pizza->bin_window, x, y, w, h );
}
else
{
/* FIXME */
}
- gtk_myfixed_expose_area (myfixed,
+ gtk_pizza_expose_area (pizza,
MAX ((gint)w - dx, 0),
0,
MIN (dx, w),
{
if (gravity_works)
{
- gdk_window_move_resize (myfixed->bin_window,
+ gdk_window_move_resize (pizza->bin_window,
x + dx,
y,
w - dx,
h);
- gdk_window_move (myfixed->bin_window, x, y);
- gdk_window_resize (myfixed->bin_window, w, h );
+ gdk_window_move (pizza->bin_window, x, y);
+ gdk_window_resize (pizza->bin_window, w, h );
}
else
{
/* FIXME */
}
- gtk_myfixed_expose_area (myfixed,
+ gtk_pizza_expose_area (pizza,
0,
0,
MIN (-dx, w),
{
if (gravity_works)
{
- gdk_window_resize (myfixed->bin_window, w, h + dy);
- gdk_window_move (myfixed->bin_window, x, y-dy);
- gdk_window_move_resize (myfixed->bin_window,
+ gdk_window_resize (pizza->bin_window, w, h + dy);
+ gdk_window_move (pizza->bin_window, x, y-dy);
+ gdk_window_move_resize (pizza->bin_window,
x, y, w, h );
}
else
/* FIXME */
}
- gtk_myfixed_expose_area (myfixed,
+ gtk_pizza_expose_area (pizza,
0,
MAX ((gint)h - dy, 0),
w,
{
if (gravity_works)
{
- gdk_window_move_resize (myfixed->bin_window,
+ gdk_window_move_resize (pizza->bin_window,
x, y+dy, w, h - dy );
- gdk_window_move (myfixed->bin_window, x, y);
- gdk_window_resize (myfixed->bin_window, w, h );
+ gdk_window_move (pizza->bin_window, x, y);
+ gdk_window_resize (pizza->bin_window, w, h );
}
else
{
/* FIXME */
}
- gtk_myfixed_expose_area (myfixed,
+ gtk_pizza_expose_area (pizza,
0,
0,
w,
MIN (-dy, (gint)h));
}
- gtk_myfixed_position_children (myfixed);
+ gtk_pizza_position_children (pizza);
/* We have to make sure that all exposes from this scroll get
* processed before we scroll again, or the expose events will
*/
gdk_flush();
- while (XCheckIfEvent(GDK_WINDOW_XDISPLAY (myfixed->bin_window),
+ while (XCheckIfEvent(GDK_WINDOW_XDISPLAY (pizza->bin_window),
&xevent,
- gtk_myfixed_expose_predicate,
- (XPointer)&GDK_WINDOW_XWINDOW (myfixed->bin_window)))
+ gtk_pizza_expose_predicate,
+ (XPointer)&GDK_WINDOW_XWINDOW (pizza->bin_window)))
{
GdkEvent event;
GtkWidget *event_widget;
- if ((xevent.xany.window == GDK_WINDOW_XWINDOW (myfixed->bin_window)) &&
- (gtk_myfixed_filter (&xevent, &event, myfixed) == GDK_FILTER_REMOVE))
+ if ((xevent.xany.window == GDK_WINDOW_XWINDOW (pizza->bin_window)) &&
+ (gtk_pizza_filter (&xevent, &event, pizza) == GDK_FILTER_REMOVE))
continue;
if (xevent.type == Expose)
* or not.
*/
static GdkFilterReturn
-gtk_myfixed_filter (GdkXEvent *gdk_xevent,
+gtk_pizza_filter (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
XEvent *xevent;
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
xevent = (XEvent *)gdk_xevent;
- myfixed = GTK_MYFIXED (data);
+ pizza = GTK_PIZZA (data);
switch (xevent->type)
{
case Expose:
- if (xevent->xexpose.serial == myfixed->configure_serial)
+ if (xevent->xexpose.serial == pizza->configure_serial)
{
- if (myfixed->visibility == GDK_VISIBILITY_UNOBSCURED)
+ if (pizza->visibility == GDK_VISIBILITY_UNOBSCURED)
return GDK_FILTER_REMOVE;
else
{
- xevent->xexpose.x += myfixed->scroll_x;
- xevent->xexpose.y += myfixed->scroll_y;
+ xevent->xexpose.x += pizza->scroll_x;
+ xevent->xexpose.y += pizza->scroll_y;
break;
}
case ConfigureNotify:
if ((xevent->xconfigure.x != 0) || (xevent->xconfigure.y != 0))
{
- myfixed->configure_serial = xevent->xconfigure.serial;
- myfixed->scroll_x = xevent->xconfigure.x;
- myfixed->scroll_y = xevent->xconfigure.y;
+ pizza->configure_serial = xevent->xconfigure.serial;
+ pizza->scroll_x = xevent->xconfigure.x;
+ pizza->scroll_y = xevent->xconfigure.y;
}
break;
}
* to get the events from a filter
*/
static GdkFilterReturn
-gtk_myfixed_main_filter (GdkXEvent *gdk_xevent,
+gtk_pizza_main_filter (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
XEvent *xevent;
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
xevent = (XEvent *)gdk_xevent;
- myfixed = GTK_MYFIXED (data);
+ pizza = GTK_PIZZA (data);
if (xevent->type == VisibilityNotify)
{
switch (xevent->xvisibility.state)
{
case VisibilityFullyObscured:
- myfixed->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
+ pizza->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
break;
case VisibilityPartiallyObscured:
- myfixed->visibility = GDK_VISIBILITY_PARTIAL;
+ pizza->visibility = GDK_VISIBILITY_PARTIAL;
break;
case VisibilityUnobscured:
- myfixed->visibility = GDK_VISIBILITY_UNOBSCURED;
+ pizza->visibility = GDK_VISIBILITY_UNOBSCURED;
break;
}
can find in m_widget (defined in wxWindow)
When the class has a client area for drawing into and for containing children
- it has to handle the client area widget (of the type GtkMyFixed, defined in
+ it has to handle the client area widget (of the type GtkPizza, defined in
win_gtk.c), but there could be any number of widgets, handled by a class
The common rule for all windows is only, that the widget that interacts with
the rest of GTK must be referenced in m_widget and all other widgets must be
children of this widget on the GTK level. The top-most widget, which also
represents the client area, must be in the m_wxwindow field and must be of
- the type GtkMyFixed.
+ the type GtkPizza.
As I said, the window classes that display a GTK native widget only have
one widget, so in the case of e.g. the wxButton class m_widget holds a
pointer to a GtkButton widget. But windows with client areas (for drawing
and children) have a m_widget field that is a pointer to a GtkScrolled-
- Window and a m_wxwindow field that is pointer to a GtkMyFixed and this
+ Window and a m_wxwindow field that is pointer to a GtkPizza and this
one is (in the GTK sense) a child of the GtkScrolledWindow.
If the m_wxwindow field is set, then all input to this widget is inter-
clicking on a scrollbar belonging to scrolled window will inevitably move
the window. In wxWindows, the scrollbar will only emit an event, send this
to (normally) a wxScrolledWindow and that class will call ScrollWindow()
- which actually moves the window and its subchildren. Note that GtkMyFixed
+ which actually moves the window and its subchildren. Note that GtkPizza
memorizes how much it has been scrolled but that wxWindows forgets this
so that the two coordinates systems have to be kept in synch. This is done
- in various places using the myfixed->xoffset and myfixed->yoffset values.
+ in various places using the pizza->xoffset and pizza->yoffset values.
III)
// local code (see below)
//-----------------------------------------------------------------------------
-#if (GTK_MINOR_VERSION > 0)
-
static void draw_frame( GtkWidget *widget, wxWindow *win )
{
if (!win->m_hasVMT)
draw_frame( widget, win );
}
-#endif // GTK_MINOR_VERSION > 0
-
//-----------------------------------------------------------------------------
-// key event conversion routines
+// key code mapping routines
//-----------------------------------------------------------------------------
-#if (GTK_MINOR_VERSION == 0)
-/* these functions are copied verbatim from GTK 1.2 */
-static void
-gdkx_XConvertCase (KeySym symbol,
- KeySym *lower,
- KeySym *upper)
-{
- register KeySym sym = symbol;
-
- g_return_if_fail (lower != NULL);
- g_return_if_fail (upper != NULL);
-
- *lower = sym;
- *upper = sym;
-
- switch (sym >> 8)
- {
-#if defined (GDK_A) && defined (GDK_Ooblique)
- case 0: /* Latin 1 */
- if ((sym >= GDK_A) && (sym <= GDK_Z))
- *lower += (GDK_a - GDK_A);
- else if ((sym >= GDK_a) && (sym <= GDK_z))
- *upper -= (GDK_a - GDK_A);
- else if ((sym >= GDK_Agrave) && (sym <= GDK_Odiaeresis))
- *lower += (GDK_agrave - GDK_Agrave);
- else if ((sym >= GDK_agrave) && (sym <= GDK_odiaeresis))
- *upper -= (GDK_agrave - GDK_Agrave);
- else if ((sym >= GDK_Ooblique) && (sym <= GDK_Thorn))
- *lower += (GDK_oslash - GDK_Ooblique);
- else if ((sym >= GDK_oslash) && (sym <= GDK_thorn))
- *upper -= (GDK_oslash - GDK_Ooblique);
- break;
-#endif /* LATIN1 */
-
-#if defined (GDK_Aogonek) && defined (GDK_tcedilla)
- case 1: /* Latin 2 */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym == GDK_Aogonek)
- *lower = GDK_aogonek;
- else if (sym >= GDK_Lstroke && sym <= GDK_Sacute)
- *lower += (GDK_lstroke - GDK_Lstroke);
- else if (sym >= GDK_Scaron && sym <= GDK_Zacute)
- *lower += (GDK_scaron - GDK_Scaron);
- else if (sym >= GDK_Zcaron && sym <= GDK_Zabovedot)
- *lower += (GDK_zcaron - GDK_Zcaron);
- else if (sym == GDK_aogonek)
- *upper = GDK_Aogonek;
- else if (sym >= GDK_lstroke && sym <= GDK_sacute)
- *upper -= (GDK_lstroke - GDK_Lstroke);
- else if (sym >= GDK_scaron && sym <= GDK_zacute)
- *upper -= (GDK_scaron - GDK_Scaron);
- else if (sym >= GDK_zcaron && sym <= GDK_zabovedot)
- *upper -= (GDK_zcaron - GDK_Zcaron);
- else if (sym >= GDK_Racute && sym <= GDK_Tcedilla)
- *lower += (GDK_racute - GDK_Racute);
- else if (sym >= GDK_racute && sym <= GDK_tcedilla)
- *upper -= (GDK_racute - GDK_Racute);
- break;
-#endif /* LATIN2 */
-
-#if defined (GDK_Hstroke) && defined (GDK_Cabovedot)
- case 2: /* Latin 3 */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= GDK_Hstroke && sym <= GDK_Hcircumflex)
- *lower += (GDK_hstroke - GDK_Hstroke);
- else if (sym >= GDK_Gbreve && sym <= GDK_Jcircumflex)
- *lower += (GDK_gbreve - GDK_Gbreve);
- else if (sym >= GDK_hstroke && sym <= GDK_hcircumflex)
- *upper -= (GDK_hstroke - GDK_Hstroke);
- else if (sym >= GDK_gbreve && sym <= GDK_jcircumflex)
- *upper -= (GDK_gbreve - GDK_Gbreve);
- else if (sym >= GDK_Cabovedot && sym <= GDK_Scircumflex)
- *lower += (GDK_cabovedot - GDK_Cabovedot);
- else if (sym >= GDK_cabovedot && sym <= GDK_scircumflex)
- *upper -= (GDK_cabovedot - GDK_Cabovedot);
- break;
-#endif /* LATIN3 */
-
-#if defined (GDK_Rcedilla) && defined (GDK_Amacron)
- case 3: /* Latin 4 */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= GDK_Rcedilla && sym <= GDK_Tslash)
- *lower += (GDK_rcedilla - GDK_Rcedilla);
- else if (sym >= GDK_rcedilla && sym <= GDK_tslash)
- *upper -= (GDK_rcedilla - GDK_Rcedilla);
- else if (sym == GDK_ENG)
- *lower = GDK_eng;
- else if (sym == GDK_eng)
- *upper = GDK_ENG;
- else if (sym >= GDK_Amacron && sym <= GDK_Umacron)
- *lower += (GDK_amacron - GDK_Amacron);
- else if (sym >= GDK_amacron && sym <= GDK_umacron)
- *upper -= (GDK_amacron - GDK_Amacron);
- break;
-#endif /* LATIN4 */
-
-#if defined (GDK_Serbian_DJE) && defined (GDK_Cyrillic_yu)
- case 6: /* Cyrillic */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= GDK_Serbian_DJE && sym <= GDK_Serbian_DZE)
- *lower -= (GDK_Serbian_DJE - GDK_Serbian_dje);
- else if (sym >= GDK_Serbian_dje && sym <= GDK_Serbian_dze)
- *upper += (GDK_Serbian_DJE - GDK_Serbian_dje);
- else if (sym >= GDK_Cyrillic_YU && sym <= GDK_Cyrillic_HARDSIGN)
- *lower -= (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
- else if (sym >= GDK_Cyrillic_yu && sym <= GDK_Cyrillic_hardsign)
- *upper += (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
- break;
-#endif /* CYRILLIC */
-
-#if defined (GDK_Greek_ALPHAaccent) && defined (GDK_Greek_finalsmallsigma)
- case 7: /* Greek */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= GDK_Greek_ALPHAaccent && sym <= GDK_Greek_OMEGAaccent)
- *lower += (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
- else if (sym >= GDK_Greek_alphaaccent && sym <= GDK_Greek_omegaaccent &&
- sym != GDK_Greek_iotaaccentdieresis &&
- sym != GDK_Greek_upsilonaccentdieresis)
- *upper -= (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
- else if (sym >= GDK_Greek_ALPHA && sym <= GDK_Greek_OMEGA)
- *lower += (GDK_Greek_alpha - GDK_Greek_ALPHA);
- else if (sym >= GDK_Greek_alpha && sym <= GDK_Greek_omega &&
- sym != GDK_Greek_finalsmallsigma)
- *upper -= (GDK_Greek_alpha - GDK_Greek_ALPHA);
- break;
-#endif /* GREEK */
- }
-}
-
-static guint
-gdk_keyval_to_upper (guint keyval)
-{
- if (keyval)
- {
- KeySym lower_val = 0;
- KeySym upper_val = 0;
-
- gdkx_XConvertCase (keyval, &lower_val, &upper_val);
- return upper_val;
- }
- return 0;
-}
-#endif
-
static long map_to_unmodified_wx_keysym( KeySym keysym )
{
guint key_code = 0;
ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
break;
}
+ if (ancestor->m_isFrame)
+ break;
ancestor = ancestor->GetParent();
}
}
}
#if (GTK_MINOR_VERSION > 0)
- /* pressing F10 will activate the menu bar of the top frame */
+ /* Pressing F10 will activate the menu bar of the top frame. */
+ /* Doesn't work. */
/*
if ( (!ret) &&
(gdk_event->keyval == GDK_F10) )
int y = event.m_y;
if (win->m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(win->m_wxwindow);
- x += myfixed->xoffset;
- y += myfixed->yoffset;
+ GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
+ x += pizza->xoffset;
+ y += pizza->yoffset;
}
wxNode *node = win->GetChildren().First();
int y = event.m_y;
if (win->m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(win->m_wxwindow);
- x += myfixed->xoffset;
- y += myfixed->yoffset;
+ GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
+ x += pizza->xoffset;
+ y += pizza->yoffset;
}
wxNode *node = win->GetChildren().First();
int y = event.m_y;
if (win->m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(win->m_wxwindow);
- x += myfixed->xoffset;
- y += myfixed->yoffset;
+ GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
+ x += pizza->xoffset;
+ y += pizza->yoffset;
}
wxNode *node = win->GetChildren().First();
{
/* the window might have been scrolled already, do we
have to adapt the position */
- GtkMyFixed *myfixed = GTK_MYFIXED(parent->m_wxwindow);
- child->m_x += myfixed->xoffset;
- child->m_y += myfixed->yoffset;
+ GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
+ child->m_x += pizza->xoffset;
+ child->m_y += pizza->yoffset;
- gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
+ gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
- m_wxwindow = gtk_myfixed_new();
+ m_wxwindow = gtk_pizza_new();
#ifdef __WXDEBUG__
debug_focus_in( m_wxwindow, wxT("wxWindow::m_wxwindow"), name );
gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
#if (GTK_MINOR_VERSION > 0)
- GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
+ GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
if (HasFlag(wxRAISED_BORDER))
{
- gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_OUT );
+ gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
}
else if (HasFlag(wxSUNKEN_BORDER))
{
- gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_IN );
+ gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
}
else if (HasFlag(wxSIMPLE_BORDER))
{
- gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_THIN );
+ gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
}
else
{
- gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_NONE );
+ gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
}
#else // GTK_MINOR_VERSION == 0
GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
}
else
{
- GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
+ GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
{
- if (x != -1) m_x = x + myfixed->xoffset;
- if (y != -1) m_y = y + myfixed->yoffset;
+ if (x != -1) m_x = x + pizza->xoffset;
+ if (y != -1) m_y = y + pizza->yoffset;
if (width != -1) m_width = width;
if (height != -1) m_height = height;
}
else
{
- m_x = x + myfixed->xoffset;
- m_y = y + myfixed->yoffset;
+ m_x = x + pizza->xoffset;
+ m_y = y + pizza->yoffset;
m_width = width;
m_height = height;
}
bottom_border = 5;
}
- gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow),
+ gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow),
m_widget,
m_x-border,
m_y-border,
if (m_wxwindow)
{
- GdkWindow *window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
if (window)
gdk_window_set_cursor( window, cursor.GetCursor() );
int dy = 0;
if (m_parent && m_parent->m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
- dx = myfixed->xoffset;
- dy = myfixed->yoffset;
+ GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
+ dx = pizza->xoffset;
+ dy = pizza->yoffset;
}
if (x) (*x) = m_x - dx;
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
- source = GTK_MYFIXED(m_wxwindow)->bin_window;
+ source = GTK_PIZZA(m_wxwindow)->bin_window;
else
source = m_widget->window;
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
- source = GTK_MYFIXED(m_wxwindow)->bin_window;
+ source = GTK_PIZZA(m_wxwindow)->bin_window;
else
source = m_widget->window;
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
{
if (rect)
{
- gdk_window_clear_area( GTK_MYFIXED(m_wxwindow)->bin_window,
+ gdk_window_clear_area( GTK_PIZZA(m_wxwindow)->bin_window,
rect->x, rect->y,
rect->width, rect->height );
}
else
{
- gdk_window_clear( GTK_MYFIXED(m_wxwindow)->bin_window );
+ gdk_window_clear( GTK_PIZZA(m_wxwindow)->bin_window );
}
}
/* there is no GTK equivalent of "draw only, don't clear" so we
- invent our own in the GtkMyFixed widget */
+ invent our own in the GtkPizza widget */
if (!rect)
{
if (m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
- gboolean old_clear = myfixed->clear_on_draw;
- gtk_my_fixed_set_clear( myfixed, FALSE );
+ GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
+ gboolean old_clear = pizza->clear_on_draw;
+ gtk_pizza_set_clear( pizza, FALSE );
gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
- gtk_my_fixed_set_clear( myfixed, old_clear );
+ gtk_pizza_set_clear( pizza, old_clear );
}
else
gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
if (m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
- gboolean old_clear = myfixed->clear_on_draw;
- gtk_my_fixed_set_clear( myfixed, FALSE );
+ GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
+ gboolean old_clear = pizza->clear_on_draw;
+ gtk_pizza_set_clear( pizza, FALSE );
gtk_widget_draw( m_wxwindow, &gdk_rect );
- gtk_my_fixed_set_clear( myfixed, old_clear );
+ gtk_pizza_set_clear( pizza, old_clear );
}
else
gtk_widget_draw( m_widget, &gdk_rect );
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
{
if (m_wxwindow)
- return (window == GTK_MYFIXED(m_wxwindow)->bin_window);
+ return (window == GTK_PIZZA(m_wxwindow)->bin_window);
return (window == m_widget->window);
}
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
- gtk_myfixed_scroll( GTK_MYFIXED(m_wxwindow), -dx, -dy );
+ gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
/*
if (!m_scrollGC)
wxButton::~wxButton()
{
- if (m_clientData) delete m_clientData;
}
bool wxButton::Create( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxValidator& validator, const wxString &name )
{
- m_clientData = (wxClientData*) NULL;
m_needParent = TRUE;
m_acceptsFocus = TRUE;
return TRUE;
}
-void wxButton::SetDefault(void)
+void wxButton::SetDefault()
{
GTK_WIDGET_SET_FLAGS( m_widget, GTK_CAN_DEFAULT );
gtk_widget_grab_default( m_widget );
wxASSERT_MSG( widget, wxT("DC needs a widget") );
- GtkMyFixed *myfixed = GTK_MYFIXED( widget );
- m_window = myfixed->bin_window;
+ GtkPizza *pizza = GTK_PIZZA( widget );
+ m_window = pizza->bin_window;
/* not realized ? */
if (!m_window)
static void wxInsertChildInDialog( wxDialog* parent, wxWindow* child )
{
- gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
+ gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
GTK_SIGNAL_FUNC(gtk_dialog_delete_callback), (gpointer)this );
- m_wxwindow = gtk_myfixed_new();
+ m_wxwindow = gtk_pizza_new();
gtk_widget_show( m_wxwindow );
GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
{
/* these are outside the client area */
wxFrame* frame = (wxFrame*) parent;
- gtk_myfixed_put( GTK_MYFIXED(frame->m_mainWidget),
+ gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
else
{
/* these are inside the client area */
- gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
+ gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );
/* m_mainWidget holds the toolbar, the menubar and the client area */
- m_mainWidget = gtk_myfixed_new();
+ m_mainWidget = gtk_pizza_new();
gtk_widget_show( m_mainWidget );
GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
#endif
/* m_wxwindow only represents the client area without toolbar and menubar */
- m_wxwindow = gtk_myfixed_new();
+ m_wxwindow = gtk_pizza_new();
gtk_widget_show( m_wxwindow );
gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
m_frameMenuBar->m_y = yy;
m_frameMenuBar->m_width = ww;
m_frameMenuBar->m_height = hh;
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
m_frameMenuBar->m_widget,
xx, yy, ww, hh );
client_area_y_offset += hh;
m_frameToolBar->m_y = yy;
/* m_frameToolBar->m_height = hh; don't change the toolbar's reported size
m_frameToolBar->m_width = ww; */
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
m_frameToolBar->m_widget,
xx, yy, ww, hh );
client_area_y_offset += hh;
int client_y = client_area_y_offset + m_miniEdge + m_miniTitle;
int client_w = m_width - 2*m_miniEdge;
int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle;
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
m_wxwindow,
client_x, client_y, client_w, client_h );
}
m_frameStatusBar->m_y = yy;
m_frameStatusBar->m_width = ww;
m_frameStatusBar->m_height = hh;
- gtk_myfixed_set_size( GTK_MYFIXED(m_wxwindow),
+ gtk_pizza_set_size( GTK_PIZZA(m_wxwindow),
m_frameStatusBar->m_widget,
xx, yy, ww, hh );
}
if (m_frameMenuBar->GetParent() != this)
{
m_frameMenuBar->SetParent(this);
- gtk_myfixed_put( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_put( GTK_PIZZA(m_mainWidget),
m_frameMenuBar->m_widget,
m_frameMenuBar->m_x,
m_frameMenuBar->m_y,
menu_bar->m_y = 0;
menu_bar->m_width = m_width;
menu_bar->m_height = wxMENU_HEIGHT;
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
menu_bar->m_widget,
0, 0, m_width, wxMENU_HEIGHT );
}
{
menu_bar->m_width = m_width;
menu_bar->m_height = wxMENU_HEIGHT;
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
menu_bar->m_widget,
0, 0, m_width, wxMENU_HEIGHT );
menu_bar->SetInvokingWindow( child_frame );
m_frameMenuBar->m_width = m_width;
m_frameMenuBar->m_height = wxMENU_HEIGHT;
- gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
m_frameMenuBar->m_widget,
0, 0, m_width, wxMENU_HEIGHT );
}
m_menuBar->SetParent( mdi_frame );
/* insert the invisible menu bar into the _parent_ mdi frame */
- gtk_myfixed_put( GTK_MYFIXED(mdi_frame->m_mainWidget),
+ gtk_pizza_put( GTK_PIZZA(mdi_frame->m_mainWidget),
m_menuBar->m_widget,
0, 0, mdi_frame->m_width, wxMENU_HEIGHT );
}
if (!win->m_hasVMT) return;
if (gdk_event->count > 0) return;
- GtkMyFixed *myfixed = GTK_MYFIXED(widget);
+ GtkPizza *pizza = GTK_PIZZA(widget);
gtk_draw_shadow( widget->style,
- myfixed->bin_window,
+ pizza->bin_window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
0, 0,
(win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) ||
(win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
{
- GdkGC *gc = gdk_gc_new( myfixed->bin_window );
+ GdkGC *gc = gdk_gc_new( pizza->bin_window );
GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
int x = 2;
if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 18;
gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
- gdk_draw_rectangle( myfixed->bin_window, gc, TRUE,
+ gdk_draw_rectangle( pizza->bin_window, gc, TRUE,
x,
3,
win->m_width - 4 - x,
font->ascent + font->descent+1 );
gdk_gc_set_foreground( gc, &widget->style->white );
- gdk_draw_string( myfixed->bin_window, font, gc,
+ gdk_draw_string( pizza->bin_window, font, gc,
x+2,
3+font->ascent,
win->m_title.mb_str() );
if (!win->m_hasVMT) return;
- GtkMyFixed *myfixed = GTK_MYFIXED(widget);
+ GtkPizza *pizza = GTK_PIZZA(widget);
gtk_draw_shadow( widget->style,
- myfixed->bin_window,
+ pizza->bin_window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
0, 0,
(win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) ||
(win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
{
- GdkGC *gc = gdk_gc_new( myfixed->bin_window );
+ GdkGC *gc = gdk_gc_new( pizza->bin_window );
GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
int x = 2;
if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 17;
gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
- gdk_draw_rectangle( myfixed->bin_window, gc, TRUE,
+ gdk_draw_rectangle( pizza->bin_window, gc, TRUE,
x,
3,
win->m_width - 4 - x,
font->ascent + font->descent+1 );
gdk_gc_set_foreground( gc, &widget->style->white );
- gdk_draw_string( myfixed->bin_window, font, gc,
+ gdk_draw_string( pizza->bin_window, font, gc,
x+2,
3+font->ascent,
win->m_title.mb_str() );
{
GtkWidget *close_button = gtk_button_new_with_label( "x" );
- gtk_myfixed_put( GTK_MYFIXED(m_mainWidget),
+ gtk_pizza_put( GTK_PIZZA(m_mainWidget),
close_button,
4, 4, 12, 11 );
gtk_signal_connect( GTK_OBJECT(m_radio), "clicked",
GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
- gtk_myfixed_put( GTK_MYFIXED(m_parent->m_wxwindow),
+ gtk_pizza_put( GTK_PIZZA(m_parent->m_wxwindow),
GTK_WIDGET(m_radio),
m_x+10, m_y+10+(i*24), 10, 10 );
}
int len = 22+gdk_string_measure( font, label->label );
if (len > max_len) max_len = len;
- gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y );
+ gtk_pizza_move( GTK_PIZZA(m_parent->m_wxwindow), button, m_x+x, m_y+y );
y += 22;
node = node->Next();
{
GtkWidget *button = GTK_WIDGET( node->Data() );
- gtk_myfixed_resize( GTK_MYFIXED(m_parent->m_wxwindow), button, max_len, 20 );
+ gtk_pizza_resize( GTK_PIZZA(m_parent->m_wxwindow), button, max_len, 20 );
node = node->Next();
if (!node) break;
{
GtkWidget *button = GTK_WIDGET( node->Data() );
- gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y, max, 20 );
+ gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), button, m_x+x, m_y+y, max, 20 );
x += max;
node = node->Next();
IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrl,wxControl)
+BEGIN_EVENT_TABLE(wxSpinCtrl, wxControl)
+ EVT_CHAR(wxSpinCtrl::OnChar)
+END_EVENT_TABLE()
+
bool wxSpinCtrl::Create(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos, const wxSize& size,
SetFocus();
}
+void wxSpinCtrl::OnChar( wxKeyEvent &event )
+{
+ wxCHECK_RET( m_widget != NULL, wxT("invalid spin ctrl") );
+
+ if (event.KeyCode() == WXK_RETURN)
+ {
+ wxWindow *top_frame = m_parent;
+ while (top_frame->GetParent() && !(top_frame->GetParent()->m_isFrame))
+ top_frame = top_frame->GetParent();
+ GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
+
+ if (window->default_widget)
+ {
+ gtk_widget_activate (window->default_widget);
+ return;
+ }
+ }
+
+ event.Skip();
+}
+
bool wxSpinCtrl::IsOwnGtkWindow( GdkWindow *window )
{
return GTK_SPIN_BUTTON(m_widget)->panel == window;
if (GetEventHandler()->ProcessEvent(event)) return;
}
+ if ((key_event.KeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
+ {
+ wxWindow *top_frame = m_parent;
+ while (top_frame->GetParent() && !(top_frame->GetParent()->m_isFrame))
+ top_frame = top_frame->GetParent();
+ GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
+
+ if (window->default_widget)
+ {
+ gtk_widget_activate (window->default_widget);
+ return;
+ }
+ }
+
key_event.Skip();
}
#define IS_ONSCREEN(x,y) ((x >= G_MINSHORT) && (x <= G_MAXSHORT) && \
(y >= G_MINSHORT) && (y <= G_MAXSHORT))
-typedef struct _GtkMyFixedAdjData GtkMyFixedAdjData;
-typedef struct _GtkMyFixedChild GtkMyFixedChild;
+typedef struct _GtkPizzaAdjData GtkPizzaAdjData;
+typedef struct _GtkPizzaChild GtkPizzaChild;
-struct _GtkMyFixedAdjData
+struct _GtkPizzaAdjData
{
gint dx;
gint dy;
};
-struct _GtkMyFixedChild
+struct _GtkPizzaChild
{
GtkWidget *widget;
gint x;
gint height;
};
-static void gtk_myfixed_class_init (GtkMyFixedClass *klass);
-static void gtk_myfixed_init (GtkMyFixed *myfixed);
+static void gtk_pizza_class_init (GtkPizzaClass *klass);
+static void gtk_pizza_init (GtkPizza *pizza);
-static void gtk_myfixed_realize (GtkWidget *widget);
-static void gtk_myfixed_unrealize (GtkWidget *widget);
+static void gtk_pizza_realize (GtkWidget *widget);
+static void gtk_pizza_unrealize (GtkWidget *widget);
-static void gtk_myfixed_map (GtkWidget *widget);
+static void gtk_pizza_map (GtkWidget *widget);
-static void gtk_myfixed_size_request (GtkWidget *widget,
+static void gtk_pizza_size_request (GtkWidget *widget,
GtkRequisition *requisition);
-static void gtk_myfixed_size_allocate (GtkWidget *widget,
+static void gtk_pizza_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
-static void gtk_myfixed_draw (GtkWidget *widget,
+static void gtk_pizza_draw (GtkWidget *widget,
GdkRectangle *area);
-static gint gtk_myfixed_expose (GtkWidget *widget,
+static gint gtk_pizza_expose (GtkWidget *widget,
GdkEventExpose *event);
-static void gtk_myfixed_add (GtkContainer *container,
+static void gtk_pizza_add (GtkContainer *container,
GtkWidget *widget);
-static void gtk_myfixed_remove (GtkContainer *container,
+static void gtk_pizza_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_myfixed_forall (GtkContainer *container,
+static void gtk_pizza_forall (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
-static void gtk_myfixed_position_child (GtkMyFixed *myfixed,
- GtkMyFixedChild *child);
-static void gtk_myfixed_allocate_child (GtkMyFixed *myfixed,
- GtkMyFixedChild *child);
-static void gtk_myfixed_position_children (GtkMyFixed *myfixed);
+static void gtk_pizza_position_child (GtkPizza *pizza,
+ GtkPizzaChild *child);
+static void gtk_pizza_allocate_child (GtkPizza *pizza,
+ GtkPizzaChild *child);
+static void gtk_pizza_position_children (GtkPizza *pizza);
-static void gtk_myfixed_adjust_allocations_recurse (GtkWidget *widget,
+static void gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
gpointer cb_data);
-static void gtk_myfixed_adjust_allocations (GtkMyFixed *myfixed,
+static void gtk_pizza_adjust_allocations (GtkPizza *pizza,
gint dx,
gint dy);
-static void gtk_myfixed_expose_area (GtkMyFixed *myfixed,
+static void gtk_pizza_expose_area (GtkPizza *pizza,
gint x,
gint y,
gint width,
gint height);
-static void gtk_myfixed_adjustment_changed (GtkAdjustment *adjustment,
- GtkMyFixed *myfixed);
-static GdkFilterReturn gtk_myfixed_filter (GdkXEvent *gdk_xevent,
+static void gtk_pizza_adjustment_changed (GtkAdjustment *adjustment,
+ GtkPizza *pizza);
+static GdkFilterReturn gtk_pizza_filter (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data);
-static GdkFilterReturn gtk_myfixed_main_filter (GdkXEvent *gdk_xevent,
+static GdkFilterReturn gtk_pizza_main_filter (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data);
-static GtkType gtk_myfixed_child_type (GtkContainer *container);
+static GtkType gtk_pizza_child_type (GtkContainer *container);
-static void gtk_myfixed_scroll_set_adjustments (GtkMyFixed *myfixed,
+static void gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
GtkAdjustment *hadj,
GtkAdjustment *vadj);
static gboolean gravity_works;
guint
-gtk_myfixed_get_type ()
+gtk_pizza_get_type ()
{
- static guint myfixed_type = 0;
+ static guint pizza_type = 0;
- if (!myfixed_type)
+ if (!pizza_type)
{
- GtkTypeInfo myfixed_info =
+ GtkTypeInfo pizza_info =
{
- "GtkMyFixed",
- sizeof (GtkMyFixed),
- sizeof (GtkMyFixedClass),
- (GtkClassInitFunc) gtk_myfixed_class_init,
- (GtkObjectInitFunc) gtk_myfixed_init,
+ "GtkPizza",
+ sizeof (GtkPizza),
+ sizeof (GtkPizzaClass),
+ (GtkClassInitFunc) gtk_pizza_class_init,
+ (GtkObjectInitFunc) gtk_pizza_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
- myfixed_type = gtk_type_unique (gtk_container_get_type (), &myfixed_info);
+ pizza_type = gtk_type_unique (gtk_container_get_type (), &pizza_info);
}
- return myfixed_type;
+ return pizza_type;
}
static void
-gtk_myfixed_class_init (GtkMyFixedClass *klass)
+gtk_pizza_class_init (GtkPizzaClass *klass)
{
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
container_class = (GtkContainerClass*) klass;
parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
- widget_class->map = gtk_myfixed_map;
- widget_class->realize = gtk_myfixed_realize;
- widget_class->unrealize = gtk_myfixed_unrealize;
- widget_class->size_request = gtk_myfixed_size_request;
- widget_class->size_allocate = gtk_myfixed_size_allocate;
- widget_class->draw = gtk_myfixed_draw;
- widget_class->expose_event = gtk_myfixed_expose;
+ widget_class->map = gtk_pizza_map;
+ widget_class->realize = gtk_pizza_realize;
+ widget_class->unrealize = gtk_pizza_unrealize;
+ widget_class->size_request = gtk_pizza_size_request;
+ widget_class->size_allocate = gtk_pizza_size_allocate;
+ widget_class->draw = gtk_pizza_draw;
+ widget_class->expose_event = gtk_pizza_expose;
- container_class->add = gtk_myfixed_add;
- container_class->remove = gtk_myfixed_remove;
- container_class->forall = gtk_myfixed_forall;
+ container_class->add = gtk_pizza_add;
+ container_class->remove = gtk_pizza_remove;
+ container_class->forall = gtk_pizza_forall;
- container_class->child_type = gtk_myfixed_child_type;
+ container_class->child_type = gtk_pizza_child_type;
- klass->set_scroll_adjustments = gtk_myfixed_scroll_set_adjustments;
+ klass->set_scroll_adjustments = gtk_pizza_scroll_set_adjustments;
widget_class->set_scroll_adjustments_signal =
gtk_signal_new ("set_scroll_adjustments",
GTK_RUN_LAST,
object_class->type,
- GTK_SIGNAL_OFFSET (GtkMyFixedClass, set_scroll_adjustments),
+ GTK_SIGNAL_OFFSET (GtkPizzaClass, set_scroll_adjustments),
gtk_marshal_NONE__POINTER_POINTER,
GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
}
static GtkType
-gtk_myfixed_child_type (GtkContainer *container)
+gtk_pizza_child_type (GtkContainer *container)
{
return GTK_TYPE_WIDGET;
}
static void
-gtk_myfixed_init (GtkMyFixed *myfixed)
+gtk_pizza_init (GtkPizza *pizza)
{
- GTK_WIDGET_UNSET_FLAGS (myfixed, GTK_NO_WINDOW);
+ GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW);
- myfixed->shadow_type = GTK_MYSHADOW_NONE;
+ pizza->shadow_type = GTK_MYSHADOW_NONE;
- myfixed->children = NULL;
+ pizza->children = NULL;
- myfixed->width = 20;
- myfixed->height = 20;
+ pizza->width = 20;
+ pizza->height = 20;
- myfixed->bin_window = NULL;
+ pizza->bin_window = NULL;
- myfixed->configure_serial = 0;
- myfixed->scroll_x = 0;
- myfixed->scroll_y = 0;
- myfixed->visibility = GDK_VISIBILITY_PARTIAL;
+ pizza->configure_serial = 0;
+ pizza->scroll_x = 0;
+ pizza->scroll_y = 0;
+ pizza->visibility = GDK_VISIBILITY_PARTIAL;
- myfixed->clear_on_draw = TRUE;
+ pizza->clear_on_draw = TRUE;
}
GtkWidget*
-gtk_myfixed_new ()
+gtk_pizza_new ()
{
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
- myfixed = gtk_type_new (gtk_myfixed_get_type ());
+ pizza = gtk_type_new (gtk_pizza_get_type ());
- return GTK_WIDGET (myfixed);
+ return GTK_WIDGET (pizza);
}
void
-gtk_myfixed_scroll_set_adjustments (GtkMyFixed *myfixed,
+gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
GtkAdjustment *hadj,
GtkAdjustment *vadj)
{
}
void
-gtk_myfixed_set_shadow_type (GtkMyFixed *myfixed,
+gtk_pizza_set_shadow_type (GtkPizza *pizza,
GtkMyShadowType type)
{
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
- if ((GtkMyShadowType) myfixed->shadow_type != type)
+ if ((GtkMyShadowType) pizza->shadow_type != type)
{
- myfixed->shadow_type = type;
+ pizza->shadow_type = type;
- if (GTK_WIDGET_VISIBLE (myfixed))
+ if (GTK_WIDGET_VISIBLE (pizza))
{
- gtk_widget_size_allocate (GTK_WIDGET (myfixed), &(GTK_WIDGET (myfixed)->allocation));
- gtk_widget_queue_draw (GTK_WIDGET (myfixed));
+ gtk_widget_size_allocate (GTK_WIDGET (pizza), &(GTK_WIDGET (pizza)->allocation));
+ gtk_widget_queue_draw (GTK_WIDGET (pizza));
}
}
}
void
-gtk_my_fixed_set_clear (GtkMyFixed *myfixed,
+gtk_pizza_set_clear (GtkPizza *pizza,
gboolean clear)
{
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
- myfixed->clear_on_draw = clear;
+ pizza->clear_on_draw = clear;
}
void
-gtk_myfixed_put (GtkMyFixed *myfixed,
+gtk_pizza_put (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y,
gint width,
gint height)
{
- GtkMyFixedChild *child_info;
+ GtkPizzaChild *child_info;
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
g_return_if_fail (widget != NULL);
- child_info = g_new (GtkMyFixedChild, 1);
+ child_info = g_new (GtkPizzaChild, 1);
child_info->widget = widget;
child_info->x = x;
child_info->width = width;
child_info->height = height;
- myfixed->children = g_list_append (myfixed->children, child_info);
+ pizza->children = g_list_append (pizza->children, child_info);
- gtk_widget_set_parent (widget, GTK_WIDGET (myfixed));
+ gtk_widget_set_parent (widget, GTK_WIDGET (pizza));
- if (GTK_WIDGET_REALIZED (myfixed))
- gtk_widget_set_parent_window (widget, myfixed->bin_window);
+ if (GTK_WIDGET_REALIZED (pizza))
+ gtk_widget_set_parent_window (widget, pizza->bin_window);
if (!IS_ONSCREEN (x, y))
GTK_PRIVATE_SET_FLAG (widget, GTK_IS_OFFSCREEN);
- if (GTK_WIDGET_REALIZED (myfixed))
+ if (GTK_WIDGET_REALIZED (pizza))
gtk_widget_realize (widget);
gtk_widget_set_usize (widget, width, height);
- if (GTK_WIDGET_VISIBLE (myfixed) && GTK_WIDGET_VISIBLE (widget))
+ if (GTK_WIDGET_VISIBLE (pizza) && GTK_WIDGET_VISIBLE (widget))
{
- if (GTK_WIDGET_MAPPED (myfixed))
+ if (GTK_WIDGET_MAPPED (pizza))
gtk_widget_map (widget);
gtk_widget_queue_resize (widget);
}
void
-gtk_myfixed_move (GtkMyFixed *myfixed,
+gtk_pizza_move (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y)
{
- GtkMyFixedChild *child;
+ GtkPizzaChild *child;
GList *children;
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
g_return_if_fail (widget != NULL);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
child->x = x;
child->y = y;
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
+ if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
gtk_widget_queue_resize (widget);
break;
}
}
void
-gtk_myfixed_resize (GtkMyFixed *myfixed,
+gtk_pizza_resize (GtkPizza *pizza,
GtkWidget *widget,
gint width,
gint height)
{
- GtkMyFixedChild *child;
+ GtkPizzaChild *child;
GList *children;
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
g_return_if_fail (widget != NULL);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
gtk_widget_set_usize (widget, width, height);
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
+ if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
gtk_widget_queue_resize (widget);
break;
}
}
void
-gtk_myfixed_set_size (GtkMyFixed *myfixed,
+gtk_pizza_set_size (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y,
gint width,
gint height)
{
- GtkMyFixedChild *child;
+ GtkPizzaChild *child;
GList *children;
GtkAllocation child_allocation;
- g_return_if_fail (myfixed != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (myfixed));
+ g_return_if_fail (pizza != NULL);
+ g_return_if_fail (GTK_IS_PIZZA (pizza));
g_return_if_fail (widget != NULL);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
gtk_widget_set_usize (widget, width, height);
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
+ if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
gtk_widget_queue_resize (widget);
return;
}
static void
-gtk_myfixed_map (GtkWidget *widget)
+gtk_pizza_map (GtkWidget *widget)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GList *children;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (widget));
+ g_return_if_fail (GTK_IS_PIZZA (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
}
gdk_window_show (widget->window);
- gdk_window_show (myfixed->bin_window);
+ gdk_window_show (pizza->bin_window);
}
static void
-gtk_myfixed_realize (GtkWidget *widget)
+gtk_pizza_realize (GtkWidget *widget)
{
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
GdkWindowAttr attributes;
gint attributes_mask;
- GtkMyFixedChild *child;
+ GtkPizzaChild *child;
GList *children;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (widget));
+ g_return_if_fail (GTK_IS_PIZZA (widget));
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
- if (myfixed->shadow_type == GTK_MYSHADOW_NONE)
+ if (pizza->shadow_type == GTK_MYSHADOW_NONE)
{
/* no border, no changes to sizes */
} else
- if (myfixed->shadow_type == GTK_MYSHADOW_THIN)
+ if (pizza->shadow_type == GTK_MYSHADOW_THIN)
{
/* GTK_MYSHADOW_THIN == wxSIMPLE_BORDER */
attributes.x += 1;
GDK_LEAVE_NOTIFY_MASK |
GDK_FOCUS_CHANGE_MASK;
- myfixed->bin_window = gdk_window_new (widget->window,
+ pizza->bin_window = gdk_window_new (widget->window,
&attributes, attributes_mask);
- gdk_window_set_user_data (myfixed->bin_window, widget);
+ gdk_window_set_user_data (pizza->bin_window, widget);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
- gtk_style_set_background (widget->style, myfixed->bin_window, GTK_STATE_NORMAL);
+ gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL);
/* add filters for intercepting visibility and expose events */
- gdk_window_add_filter (widget->window, gtk_myfixed_main_filter, myfixed);
- gdk_window_add_filter (myfixed->bin_window, gtk_myfixed_filter, myfixed);
+ gdk_window_add_filter (widget->window, gtk_pizza_main_filter, pizza);
+ gdk_window_add_filter (pizza->bin_window, gtk_pizza_filter, pizza);
/* we NEED gravity or we'll give up */
- gravity_works = gdk_window_set_static_gravities (myfixed->bin_window, TRUE);
+ gravity_works = gdk_window_set_static_gravities (pizza->bin_window, TRUE);
/* cannot be done before realisation */
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
children = children->next;
- gtk_widget_set_parent_window (child->widget, myfixed->bin_window);
+ gtk_widget_set_parent_window (child->widget, pizza->bin_window);
}
}
static void
-gtk_myfixed_unrealize (GtkWidget *widget)
+gtk_pizza_unrealize (GtkWidget *widget)
{
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (widget));
+ g_return_if_fail (GTK_IS_PIZZA (widget));
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
- gdk_window_set_user_data (myfixed->bin_window, NULL);
- gdk_window_destroy (myfixed->bin_window);
- myfixed->bin_window = NULL;
+ gdk_window_set_user_data (pizza->bin_window, NULL);
+ gdk_window_destroy (pizza->bin_window);
+ pizza->bin_window = NULL;
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}
static void
-gtk_myfixed_size_request (GtkWidget *widget,
+gtk_pizza_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GList *children;
GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (widget));
+ g_return_if_fail (GTK_IS_PIZZA (widget));
g_return_if_fail (requisition != NULL);
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
}
static void
-gtk_myfixed_size_allocate (GtkWidget *widget,
+gtk_pizza_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
gint border;
gint x,y,w,h;
- GtkMyFixedChild *child;
+ GtkPizzaChild *child;
GtkAllocation child_allocation;
GList *children;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED(widget));
+ g_return_if_fail (GTK_IS_PIZZA(widget));
g_return_if_fail (allocation != NULL);
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
widget->allocation = *allocation;
- if (myfixed->shadow_type == GTK_MYSHADOW_NONE)
+ if (pizza->shadow_type == GTK_MYSHADOW_NONE)
border = 0;
else
- if (myfixed->shadow_type == GTK_MYSHADOW_THIN)
+ if (pizza->shadow_type == GTK_MYSHADOW_THIN)
border = 1;
else
border = 2;
if (GTK_WIDGET_REALIZED (widget))
{
gdk_window_move_resize( widget->window, x, y, w, h );
- gdk_window_move_resize( myfixed->bin_window, 0, 0, w, h );
+ gdk_window_move_resize( pizza->bin_window, 0, 0, w, h );
}
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
children = children->next;
- gtk_myfixed_position_child (myfixed, child);
- gtk_myfixed_allocate_child (myfixed, child);
+ gtk_pizza_position_child (pizza, child);
+ gtk_pizza_allocate_child (pizza, child);
}
}
static void
-gtk_myfixed_draw (GtkWidget *widget,
+gtk_pizza_draw (GtkWidget *widget,
GdkRectangle *area)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GdkRectangle child_area;
GList *children;
g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (widget));
+ g_return_if_fail (GTK_IS_PIZZA (widget));
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
- children = myfixed->children;
+ children = pizza->children;
if ( !(GTK_WIDGET_APP_PAINTABLE (widget)) &&
- (myfixed->clear_on_draw))
+ (pizza->clear_on_draw))
{
- gdk_window_clear_area( myfixed->bin_window,
+ gdk_window_clear_area( pizza->bin_window,
area->x, area->y, area->width, area->height);
}
}
static gint
-gtk_myfixed_expose (GtkWidget *widget,
+gtk_pizza_expose (GtkWidget *widget,
GdkEventExpose *event)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GdkEventExpose child_event;
GList *children;
g_return_val_if_fail (widget != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_MYFIXED (widget), FALSE);
+ g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
- myfixed = GTK_MYFIXED (widget);
+ pizza = GTK_PIZZA (widget);
/*
if (event->window == widget->window)
{
- gtk_myfixed_draw_border( myfixed );
+ gtk_pizza_draw_border( pizza );
return FALSE;
}
*/
- if (event->window != myfixed->bin_window)
+ if (event->window != pizza->bin_window)
return FALSE;
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
}
static void
-gtk_myfixed_add (GtkContainer *container,
+gtk_pizza_add (GtkContainer *container,
GtkWidget *widget)
{
g_return_if_fail (container != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (container));
+ g_return_if_fail (GTK_IS_PIZZA (container));
g_return_if_fail (widget != NULL);
- gtk_myfixed_put (GTK_MYFIXED (container), widget, 0, 0, 20, 20 );
+ gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
}
static void
-gtk_myfixed_remove (GtkContainer *container,
+gtk_pizza_remove (GtkContainer *container,
GtkWidget *widget)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GList *children;
g_return_if_fail (container != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (container));
+ g_return_if_fail (GTK_IS_PIZZA (container));
g_return_if_fail (widget != NULL);
- myfixed = GTK_MYFIXED (container);
+ pizza = GTK_PIZZA (container);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
/* security checks */
g_return_if_fail (GTK_IS_WIDGET (widget));
- myfixed->children = g_list_remove_link (myfixed->children, children);
+ pizza->children = g_list_remove_link (pizza->children, children);
g_list_free (children);
g_free (child);
}
static void
-gtk_myfixed_forall (GtkContainer *container,
+gtk_pizza_forall (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
gpointer callback_data)
{
- GtkMyFixed *myfixed;
- GtkMyFixedChild *child;
+ GtkPizza *pizza;
+ GtkPizzaChild *child;
GList *children;
g_return_if_fail (container != NULL);
- g_return_if_fail (GTK_IS_MYFIXED (container));
+ g_return_if_fail (GTK_IS_PIZZA (container));
g_return_if_fail (callback != NULL);
- myfixed = GTK_MYFIXED (container);
+ pizza = GTK_PIZZA (container);
- children = myfixed->children;
+ children = pizza->children;
while (children)
{
child = children->data;
*/
static void
-gtk_myfixed_position_child (GtkMyFixed *myfixed,
- GtkMyFixedChild *child)
+gtk_pizza_position_child (GtkPizza *pizza,
+ GtkPizzaChild *child)
{
gint x;
gint y;
- x = child->x - myfixed->xoffset;
- y = child->y - myfixed->yoffset;
+ x = child->x - pizza->xoffset;
+ y = child->y - pizza->yoffset;
if (IS_ONSCREEN (x,y))
{
- if (GTK_WIDGET_MAPPED (myfixed) &&
+ if (GTK_WIDGET_MAPPED (pizza) &&
GTK_WIDGET_VISIBLE (child->widget))
{
if (!GTK_WIDGET_MAPPED (child->widget))
}
static void
-gtk_myfixed_allocate_child (GtkMyFixed *myfixed,
- GtkMyFixedChild *child)
+gtk_pizza_allocate_child (GtkPizza *pizza,
+ GtkPizzaChild *child)
{
GtkAllocation allocation;
GtkRequisition requisition;
- allocation.x = child->x - myfixed->xoffset;
- allocation.y = child->y - myfixed->yoffset;
+ allocation.x = child->x - pizza->xoffset;
+ allocation.y = child->y - pizza->yoffset;
gtk_widget_get_child_requisition (child->widget, &requisition);
allocation.width = requisition.width;
allocation.height = requisition.height;
}
static void
-gtk_myfixed_position_children (GtkMyFixed *myfixed)
+gtk_pizza_position_children (GtkPizza *pizza)
{
GList *tmp_list;
- tmp_list = myfixed->children;
+ tmp_list = pizza->children;
while (tmp_list)
{
- GtkMyFixedChild *child = tmp_list->data;
+ GtkPizzaChild *child = tmp_list->data;
tmp_list = tmp_list->next;
- gtk_myfixed_position_child (myfixed, child);
+ gtk_pizza_position_child (pizza, child);
}
}
static void
-gtk_myfixed_adjust_allocations_recurse (GtkWidget *widget,
+gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
gpointer cb_data)
{
- GtkMyFixedAdjData *data = cb_data;
+ GtkPizzaAdjData *data = cb_data;
widget->allocation.x += data->dx;
widget->allocation.y += data->dy;
if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget))
{
gtk_container_forall (GTK_CONTAINER (widget),
- gtk_myfixed_adjust_allocations_recurse,
+ gtk_pizza_adjust_allocations_recurse,
cb_data);
}
}
static void
-gtk_myfixed_adjust_allocations (GtkMyFixed *myfixed,
+gtk_pizza_adjust_allocations (GtkPizza *pizza,
gint dx,
gint dy)
{
GList *tmp_list;
- GtkMyFixedAdjData data;
+ GtkPizzaAdjData data;
data.dx = dx;
data.dy = dy;
- tmp_list = myfixed->children;
+ tmp_list = pizza->children;
while (tmp_list)
{
- GtkMyFixedChild *child = tmp_list->data;
+ GtkPizzaChild *child = tmp_list->data;
tmp_list = tmp_list->next;
child->widget->allocation.x += dx;
if (GTK_WIDGET_NO_WINDOW (child->widget) &&
GTK_IS_CONTAINER (child->widget))
gtk_container_forall (GTK_CONTAINER (child->widget),
- gtk_myfixed_adjust_allocations_recurse,
+ gtk_pizza_adjust_allocations_recurse,
&data);
}
}
/* Send a synthetic expose event to the widget
*/
static void
-gtk_myfixed_expose_area (GtkMyFixed *myfixed,
+gtk_pizza_expose_area (GtkPizza *pizza,
gint x, gint y, gint width, gint height)
{
- if (myfixed->visibility == GDK_VISIBILITY_UNOBSCURED)
+ if (pizza->visibility == GDK_VISIBILITY_UNOBSCURED)
{
GdkEventExpose event;
event.type = GDK_EXPOSE;
event.send_event = TRUE;
- event.window = myfixed->bin_window;
+ event.window = pizza->bin_window;
event.count = 0;
event.area.x = x;
event.area.height = height;
gdk_window_ref (event.window);
- gtk_widget_event (GTK_WIDGET (myfixed), (GdkEvent *)&event);
+ gtk_widget_event (GTK_WIDGET (pizza), (GdkEvent *)&event);
gdk_window_unref (event.window);
}
}
*/
static Bool
-gtk_myfixed_expose_predicate (Display *display,
+gtk_pizza_expose_predicate (Display *display,
XEvent *xevent,
XPointer arg)
{
*/
void
-gtk_myfixed_scroll (GtkMyFixed *myfixed, gint dx, gint dy)
+gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
{
GtkWidget *widget;
XEvent xevent;
gint x,y,w,h,border;
- widget = GTK_WIDGET (myfixed);
+ widget = GTK_WIDGET (pizza);
- myfixed->xoffset += dx;
- myfixed->yoffset += dy;
+ pizza->xoffset += dx;
+ pizza->yoffset += dy;
- if (!GTK_WIDGET_MAPPED (myfixed))
+ if (!GTK_WIDGET_MAPPED (pizza))
{
- gtk_myfixed_position_children (myfixed);
+ gtk_pizza_position_children (pizza);
return;
}
- gtk_myfixed_adjust_allocations (myfixed, -dx, -dy);
+ gtk_pizza_adjust_allocations (pizza, -dx, -dy);
- if (myfixed->shadow_type == GTK_MYSHADOW_NONE)
+ if (pizza->shadow_type == GTK_MYSHADOW_NONE)
border = 0;
else
- if (myfixed->shadow_type == GTK_MYSHADOW_THIN)
+ if (pizza->shadow_type == GTK_MYSHADOW_THIN)
border = 1;
else
border = 2;
{
if (gravity_works)
{
- gdk_window_resize (myfixed->bin_window,
+ gdk_window_resize (pizza->bin_window,
w + dx,
h);
- gdk_window_move (myfixed->bin_window, x-dx, y);
- gdk_window_move_resize (myfixed->bin_window, x, y, w, h );
+ gdk_window_move (pizza->bin_window, x-dx, y);
+ gdk_window_move_resize (pizza->bin_window, x, y, w, h );
}
else
{
/* FIXME */
}
- gtk_myfixed_expose_area (myfixed,
+ gtk_pizza_expose_area (pizza,
MAX ((gint)w - dx, 0),
0,
MIN (dx, w),
{
if (gravity_works)
{
- gdk_window_move_resize (myfixed->bin_window,
+ gdk_window_move_resize (pizza->bin_window,
x + dx,
y,
w - dx,
h);
- gdk_window_move (myfixed->bin_window, x, y);
- gdk_window_resize (myfixed->bin_window, w, h );
+ gdk_window_move (pizza->bin_window, x, y);
+ gdk_window_resize (pizza->bin_window, w, h );
}
else
{
/* FIXME */
}
- gtk_myfixed_expose_area (myfixed,
+ gtk_pizza_expose_area (pizza,
0,
0,
MIN (-dx, w),
{
if (gravity_works)
{
- gdk_window_resize (myfixed->bin_window, w, h + dy);
- gdk_window_move (myfixed->bin_window, x, y-dy);
- gdk_window_move_resize (myfixed->bin_window,
+ gdk_window_resize (pizza->bin_window, w, h + dy);
+ gdk_window_move (pizza->bin_window, x, y-dy);
+ gdk_window_move_resize (pizza->bin_window,
x, y, w, h );
}
else
/* FIXME */
}
- gtk_myfixed_expose_area (myfixed,
+ gtk_pizza_expose_area (pizza,
0,
MAX ((gint)h - dy, 0),
w,
{
if (gravity_works)
{
- gdk_window_move_resize (myfixed->bin_window,
+ gdk_window_move_resize (pizza->bin_window,
x, y+dy, w, h - dy );
- gdk_window_move (myfixed->bin_window, x, y);
- gdk_window_resize (myfixed->bin_window, w, h );
+ gdk_window_move (pizza->bin_window, x, y);
+ gdk_window_resize (pizza->bin_window, w, h );
}
else
{
/* FIXME */
}
- gtk_myfixed_expose_area (myfixed,
+ gtk_pizza_expose_area (pizza,
0,
0,
w,
MIN (-dy, (gint)h));
}
- gtk_myfixed_position_children (myfixed);
+ gtk_pizza_position_children (pizza);
/* We have to make sure that all exposes from this scroll get
* processed before we scroll again, or the expose events will
*/
gdk_flush();
- while (XCheckIfEvent(GDK_WINDOW_XDISPLAY (myfixed->bin_window),
+ while (XCheckIfEvent(GDK_WINDOW_XDISPLAY (pizza->bin_window),
&xevent,
- gtk_myfixed_expose_predicate,
- (XPointer)&GDK_WINDOW_XWINDOW (myfixed->bin_window)))
+ gtk_pizza_expose_predicate,
+ (XPointer)&GDK_WINDOW_XWINDOW (pizza->bin_window)))
{
GdkEvent event;
GtkWidget *event_widget;
- if ((xevent.xany.window == GDK_WINDOW_XWINDOW (myfixed->bin_window)) &&
- (gtk_myfixed_filter (&xevent, &event, myfixed) == GDK_FILTER_REMOVE))
+ if ((xevent.xany.window == GDK_WINDOW_XWINDOW (pizza->bin_window)) &&
+ (gtk_pizza_filter (&xevent, &event, pizza) == GDK_FILTER_REMOVE))
continue;
if (xevent.type == Expose)
* or not.
*/
static GdkFilterReturn
-gtk_myfixed_filter (GdkXEvent *gdk_xevent,
+gtk_pizza_filter (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
XEvent *xevent;
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
xevent = (XEvent *)gdk_xevent;
- myfixed = GTK_MYFIXED (data);
+ pizza = GTK_PIZZA (data);
switch (xevent->type)
{
case Expose:
- if (xevent->xexpose.serial == myfixed->configure_serial)
+ if (xevent->xexpose.serial == pizza->configure_serial)
{
- if (myfixed->visibility == GDK_VISIBILITY_UNOBSCURED)
+ if (pizza->visibility == GDK_VISIBILITY_UNOBSCURED)
return GDK_FILTER_REMOVE;
else
{
- xevent->xexpose.x += myfixed->scroll_x;
- xevent->xexpose.y += myfixed->scroll_y;
+ xevent->xexpose.x += pizza->scroll_x;
+ xevent->xexpose.y += pizza->scroll_y;
break;
}
case ConfigureNotify:
if ((xevent->xconfigure.x != 0) || (xevent->xconfigure.y != 0))
{
- myfixed->configure_serial = xevent->xconfigure.serial;
- myfixed->scroll_x = xevent->xconfigure.x;
- myfixed->scroll_y = xevent->xconfigure.y;
+ pizza->configure_serial = xevent->xconfigure.serial;
+ pizza->scroll_x = xevent->xconfigure.x;
+ pizza->scroll_y = xevent->xconfigure.y;
}
break;
}
* to get the events from a filter
*/
static GdkFilterReturn
-gtk_myfixed_main_filter (GdkXEvent *gdk_xevent,
+gtk_pizza_main_filter (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
XEvent *xevent;
- GtkMyFixed *myfixed;
+ GtkPizza *pizza;
xevent = (XEvent *)gdk_xevent;
- myfixed = GTK_MYFIXED (data);
+ pizza = GTK_PIZZA (data);
if (xevent->type == VisibilityNotify)
{
switch (xevent->xvisibility.state)
{
case VisibilityFullyObscured:
- myfixed->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
+ pizza->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
break;
case VisibilityPartiallyObscured:
- myfixed->visibility = GDK_VISIBILITY_PARTIAL;
+ pizza->visibility = GDK_VISIBILITY_PARTIAL;
break;
case VisibilityUnobscured:
- myfixed->visibility = GDK_VISIBILITY_UNOBSCURED;
+ pizza->visibility = GDK_VISIBILITY_UNOBSCURED;
break;
}
can find in m_widget (defined in wxWindow)
When the class has a client area for drawing into and for containing children
- it has to handle the client area widget (of the type GtkMyFixed, defined in
+ it has to handle the client area widget (of the type GtkPizza, defined in
win_gtk.c), but there could be any number of widgets, handled by a class
The common rule for all windows is only, that the widget that interacts with
the rest of GTK must be referenced in m_widget and all other widgets must be
children of this widget on the GTK level. The top-most widget, which also
represents the client area, must be in the m_wxwindow field and must be of
- the type GtkMyFixed.
+ the type GtkPizza.
As I said, the window classes that display a GTK native widget only have
one widget, so in the case of e.g. the wxButton class m_widget holds a
pointer to a GtkButton widget. But windows with client areas (for drawing
and children) have a m_widget field that is a pointer to a GtkScrolled-
- Window and a m_wxwindow field that is pointer to a GtkMyFixed and this
+ Window and a m_wxwindow field that is pointer to a GtkPizza and this
one is (in the GTK sense) a child of the GtkScrolledWindow.
If the m_wxwindow field is set, then all input to this widget is inter-
clicking on a scrollbar belonging to scrolled window will inevitably move
the window. In wxWindows, the scrollbar will only emit an event, send this
to (normally) a wxScrolledWindow and that class will call ScrollWindow()
- which actually moves the window and its subchildren. Note that GtkMyFixed
+ which actually moves the window and its subchildren. Note that GtkPizza
memorizes how much it has been scrolled but that wxWindows forgets this
so that the two coordinates systems have to be kept in synch. This is done
- in various places using the myfixed->xoffset and myfixed->yoffset values.
+ in various places using the pizza->xoffset and pizza->yoffset values.
III)
// local code (see below)
//-----------------------------------------------------------------------------
-#if (GTK_MINOR_VERSION > 0)
-
static void draw_frame( GtkWidget *widget, wxWindow *win )
{
if (!win->m_hasVMT)
draw_frame( widget, win );
}
-#endif // GTK_MINOR_VERSION > 0
-
//-----------------------------------------------------------------------------
-// key event conversion routines
+// key code mapping routines
//-----------------------------------------------------------------------------
-#if (GTK_MINOR_VERSION == 0)
-/* these functions are copied verbatim from GTK 1.2 */
-static void
-gdkx_XConvertCase (KeySym symbol,
- KeySym *lower,
- KeySym *upper)
-{
- register KeySym sym = symbol;
-
- g_return_if_fail (lower != NULL);
- g_return_if_fail (upper != NULL);
-
- *lower = sym;
- *upper = sym;
-
- switch (sym >> 8)
- {
-#if defined (GDK_A) && defined (GDK_Ooblique)
- case 0: /* Latin 1 */
- if ((sym >= GDK_A) && (sym <= GDK_Z))
- *lower += (GDK_a - GDK_A);
- else if ((sym >= GDK_a) && (sym <= GDK_z))
- *upper -= (GDK_a - GDK_A);
- else if ((sym >= GDK_Agrave) && (sym <= GDK_Odiaeresis))
- *lower += (GDK_agrave - GDK_Agrave);
- else if ((sym >= GDK_agrave) && (sym <= GDK_odiaeresis))
- *upper -= (GDK_agrave - GDK_Agrave);
- else if ((sym >= GDK_Ooblique) && (sym <= GDK_Thorn))
- *lower += (GDK_oslash - GDK_Ooblique);
- else if ((sym >= GDK_oslash) && (sym <= GDK_thorn))
- *upper -= (GDK_oslash - GDK_Ooblique);
- break;
-#endif /* LATIN1 */
-
-#if defined (GDK_Aogonek) && defined (GDK_tcedilla)
- case 1: /* Latin 2 */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym == GDK_Aogonek)
- *lower = GDK_aogonek;
- else if (sym >= GDK_Lstroke && sym <= GDK_Sacute)
- *lower += (GDK_lstroke - GDK_Lstroke);
- else if (sym >= GDK_Scaron && sym <= GDK_Zacute)
- *lower += (GDK_scaron - GDK_Scaron);
- else if (sym >= GDK_Zcaron && sym <= GDK_Zabovedot)
- *lower += (GDK_zcaron - GDK_Zcaron);
- else if (sym == GDK_aogonek)
- *upper = GDK_Aogonek;
- else if (sym >= GDK_lstroke && sym <= GDK_sacute)
- *upper -= (GDK_lstroke - GDK_Lstroke);
- else if (sym >= GDK_scaron && sym <= GDK_zacute)
- *upper -= (GDK_scaron - GDK_Scaron);
- else if (sym >= GDK_zcaron && sym <= GDK_zabovedot)
- *upper -= (GDK_zcaron - GDK_Zcaron);
- else if (sym >= GDK_Racute && sym <= GDK_Tcedilla)
- *lower += (GDK_racute - GDK_Racute);
- else if (sym >= GDK_racute && sym <= GDK_tcedilla)
- *upper -= (GDK_racute - GDK_Racute);
- break;
-#endif /* LATIN2 */
-
-#if defined (GDK_Hstroke) && defined (GDK_Cabovedot)
- case 2: /* Latin 3 */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= GDK_Hstroke && sym <= GDK_Hcircumflex)
- *lower += (GDK_hstroke - GDK_Hstroke);
- else if (sym >= GDK_Gbreve && sym <= GDK_Jcircumflex)
- *lower += (GDK_gbreve - GDK_Gbreve);
- else if (sym >= GDK_hstroke && sym <= GDK_hcircumflex)
- *upper -= (GDK_hstroke - GDK_Hstroke);
- else if (sym >= GDK_gbreve && sym <= GDK_jcircumflex)
- *upper -= (GDK_gbreve - GDK_Gbreve);
- else if (sym >= GDK_Cabovedot && sym <= GDK_Scircumflex)
- *lower += (GDK_cabovedot - GDK_Cabovedot);
- else if (sym >= GDK_cabovedot && sym <= GDK_scircumflex)
- *upper -= (GDK_cabovedot - GDK_Cabovedot);
- break;
-#endif /* LATIN3 */
-
-#if defined (GDK_Rcedilla) && defined (GDK_Amacron)
- case 3: /* Latin 4 */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= GDK_Rcedilla && sym <= GDK_Tslash)
- *lower += (GDK_rcedilla - GDK_Rcedilla);
- else if (sym >= GDK_rcedilla && sym <= GDK_tslash)
- *upper -= (GDK_rcedilla - GDK_Rcedilla);
- else if (sym == GDK_ENG)
- *lower = GDK_eng;
- else if (sym == GDK_eng)
- *upper = GDK_ENG;
- else if (sym >= GDK_Amacron && sym <= GDK_Umacron)
- *lower += (GDK_amacron - GDK_Amacron);
- else if (sym >= GDK_amacron && sym <= GDK_umacron)
- *upper -= (GDK_amacron - GDK_Amacron);
- break;
-#endif /* LATIN4 */
-
-#if defined (GDK_Serbian_DJE) && defined (GDK_Cyrillic_yu)
- case 6: /* Cyrillic */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= GDK_Serbian_DJE && sym <= GDK_Serbian_DZE)
- *lower -= (GDK_Serbian_DJE - GDK_Serbian_dje);
- else if (sym >= GDK_Serbian_dje && sym <= GDK_Serbian_dze)
- *upper += (GDK_Serbian_DJE - GDK_Serbian_dje);
- else if (sym >= GDK_Cyrillic_YU && sym <= GDK_Cyrillic_HARDSIGN)
- *lower -= (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
- else if (sym >= GDK_Cyrillic_yu && sym <= GDK_Cyrillic_hardsign)
- *upper += (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
- break;
-#endif /* CYRILLIC */
-
-#if defined (GDK_Greek_ALPHAaccent) && defined (GDK_Greek_finalsmallsigma)
- case 7: /* Greek */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= GDK_Greek_ALPHAaccent && sym <= GDK_Greek_OMEGAaccent)
- *lower += (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
- else if (sym >= GDK_Greek_alphaaccent && sym <= GDK_Greek_omegaaccent &&
- sym != GDK_Greek_iotaaccentdieresis &&
- sym != GDK_Greek_upsilonaccentdieresis)
- *upper -= (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
- else if (sym >= GDK_Greek_ALPHA && sym <= GDK_Greek_OMEGA)
- *lower += (GDK_Greek_alpha - GDK_Greek_ALPHA);
- else if (sym >= GDK_Greek_alpha && sym <= GDK_Greek_omega &&
- sym != GDK_Greek_finalsmallsigma)
- *upper -= (GDK_Greek_alpha - GDK_Greek_ALPHA);
- break;
-#endif /* GREEK */
- }
-}
-
-static guint
-gdk_keyval_to_upper (guint keyval)
-{
- if (keyval)
- {
- KeySym lower_val = 0;
- KeySym upper_val = 0;
-
- gdkx_XConvertCase (keyval, &lower_val, &upper_val);
- return upper_val;
- }
- return 0;
-}
-#endif
-
static long map_to_unmodified_wx_keysym( KeySym keysym )
{
guint key_code = 0;
ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
break;
}
+ if (ancestor->m_isFrame)
+ break;
ancestor = ancestor->GetParent();
}
}
}
#if (GTK_MINOR_VERSION > 0)
- /* pressing F10 will activate the menu bar of the top frame */
+ /* Pressing F10 will activate the menu bar of the top frame. */
+ /* Doesn't work. */
/*
if ( (!ret) &&
(gdk_event->keyval == GDK_F10) )
int y = event.m_y;
if (win->m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(win->m_wxwindow);
- x += myfixed->xoffset;
- y += myfixed->yoffset;
+ GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
+ x += pizza->xoffset;
+ y += pizza->yoffset;
}
wxNode *node = win->GetChildren().First();
int y = event.m_y;
if (win->m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(win->m_wxwindow);
- x += myfixed->xoffset;
- y += myfixed->yoffset;
+ GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
+ x += pizza->xoffset;
+ y += pizza->yoffset;
}
wxNode *node = win->GetChildren().First();
int y = event.m_y;
if (win->m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(win->m_wxwindow);
- x += myfixed->xoffset;
- y += myfixed->yoffset;
+ GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
+ x += pizza->xoffset;
+ y += pizza->yoffset;
}
wxNode *node = win->GetChildren().First();
{
/* the window might have been scrolled already, do we
have to adapt the position */
- GtkMyFixed *myfixed = GTK_MYFIXED(parent->m_wxwindow);
- child->m_x += myfixed->xoffset;
- child->m_y += myfixed->yoffset;
+ GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
+ child->m_x += pizza->xoffset;
+ child->m_y += pizza->yoffset;
- gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
+ gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
- m_wxwindow = gtk_myfixed_new();
+ m_wxwindow = gtk_pizza_new();
#ifdef __WXDEBUG__
debug_focus_in( m_wxwindow, wxT("wxWindow::m_wxwindow"), name );
gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
#if (GTK_MINOR_VERSION > 0)
- GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
+ GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
if (HasFlag(wxRAISED_BORDER))
{
- gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_OUT );
+ gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
}
else if (HasFlag(wxSUNKEN_BORDER))
{
- gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_IN );
+ gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
}
else if (HasFlag(wxSIMPLE_BORDER))
{
- gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_THIN );
+ gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
}
else
{
- gtk_myfixed_set_shadow_type( myfixed, GTK_MYSHADOW_NONE );
+ gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
}
#else // GTK_MINOR_VERSION == 0
GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
}
else
{
- GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
+ GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
{
- if (x != -1) m_x = x + myfixed->xoffset;
- if (y != -1) m_y = y + myfixed->yoffset;
+ if (x != -1) m_x = x + pizza->xoffset;
+ if (y != -1) m_y = y + pizza->yoffset;
if (width != -1) m_width = width;
if (height != -1) m_height = height;
}
else
{
- m_x = x + myfixed->xoffset;
- m_y = y + myfixed->yoffset;
+ m_x = x + pizza->xoffset;
+ m_y = y + pizza->yoffset;
m_width = width;
m_height = height;
}
bottom_border = 5;
}
- gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow),
+ gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow),
m_widget,
m_x-border,
m_y-border,
if (m_wxwindow)
{
- GdkWindow *window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
if (window)
gdk_window_set_cursor( window, cursor.GetCursor() );
int dy = 0;
if (m_parent && m_parent->m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(m_parent->m_wxwindow);
- dx = myfixed->xoffset;
- dy = myfixed->yoffset;
+ GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
+ dx = pizza->xoffset;
+ dy = pizza->yoffset;
}
if (x) (*x) = m_x - dx;
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
- source = GTK_MYFIXED(m_wxwindow)->bin_window;
+ source = GTK_PIZZA(m_wxwindow)->bin_window;
else
source = m_widget->window;
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
- source = GTK_MYFIXED(m_wxwindow)->bin_window;
+ source = GTK_PIZZA(m_wxwindow)->bin_window;
else
source = m_widget->window;
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
{
if (rect)
{
- gdk_window_clear_area( GTK_MYFIXED(m_wxwindow)->bin_window,
+ gdk_window_clear_area( GTK_PIZZA(m_wxwindow)->bin_window,
rect->x, rect->y,
rect->width, rect->height );
}
else
{
- gdk_window_clear( GTK_MYFIXED(m_wxwindow)->bin_window );
+ gdk_window_clear( GTK_PIZZA(m_wxwindow)->bin_window );
}
}
/* there is no GTK equivalent of "draw only, don't clear" so we
- invent our own in the GtkMyFixed widget */
+ invent our own in the GtkPizza widget */
if (!rect)
{
if (m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
- gboolean old_clear = myfixed->clear_on_draw;
- gtk_my_fixed_set_clear( myfixed, FALSE );
+ GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
+ gboolean old_clear = pizza->clear_on_draw;
+ gtk_pizza_set_clear( pizza, FALSE );
gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
- gtk_my_fixed_set_clear( myfixed, old_clear );
+ gtk_pizza_set_clear( pizza, old_clear );
}
else
gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
if (m_wxwindow)
{
- GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
- gboolean old_clear = myfixed->clear_on_draw;
- gtk_my_fixed_set_clear( myfixed, FALSE );
+ GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
+ gboolean old_clear = pizza->clear_on_draw;
+ gtk_pizza_set_clear( pizza, FALSE );
gtk_widget_draw( m_wxwindow, &gdk_rect );
- gtk_my_fixed_set_clear( myfixed, old_clear );
+ gtk_pizza_set_clear( pizza, old_clear );
}
else
gtk_widget_draw( m_widget, &gdk_rect );
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
{
if (m_wxwindow)
- return (window == GTK_MYFIXED(m_wxwindow)->bin_window);
+ return (window == GTK_PIZZA(m_wxwindow)->bin_window);
return (window == m_widget->window);
}
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_MYFIXED(m_wxwindow)->bin_window;
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
- gtk_myfixed_scroll( GTK_MYFIXED(m_wxwindow), -dx, -dy );
+ gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
/*
if (!m_scrollGC)
{
if (m_glContext)
{
- GdkWindow *window = GTK_MYFIXED(m_widget)->bin_window;
+ GdkWindow *window = GTK_PIZZA(m_widget)->bin_window;
glXSwapBuffers( GDK_DISPLAY(), GDK_WINDOW_XWINDOW( window ) );
}
}
{
if (m_glContext)
{
- GdkWindow *window = GTK_MYFIXED(m_widget)->bin_window;
+ GdkWindow *window = GTK_PIZZA(m_widget)->bin_window;
glXMakeCurrent( GDK_DISPLAY(), GDK_WINDOW_XWINDOW(window), m_glContext );
}
}
m_glWidget = m_wxwindow;
- gtk_my_fixed_set_clear( GTK_MYFIXED(m_wxwindow), FALSE );
+ gtk_pizza_set_clear( GTK_PIZZA(m_wxwindow), FALSE );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
GTK_SIGNAL_FUNC(gtk_glwindow_realized_callback), (gpointer) this );
projects / wxWidgets.git / commitdiff
