AC_SUBST(LT_VERSION_INFO)
### REQUIREMENTS ##############################################################
-# Recommended GTK version: at least 2.12
-# Recommended Glib version: at least 2.16
-GTK_REQUIRED_VERSION=2.6
-GLIB_REQUIRED_VERSION=2.6
+GTK_REQUIRED_VERSION=3.2
+GLIB_REQUIRED_VERSION=2.16
GTK_DOC_REQUIRED_VERSION=1.12
AC_SUBST(GTK_REQUIRED_VERSION)
AC_SUBST(GLIB_REQUIRED_VERSION)
# Libraries needed to build Chimara library
PKG_CHECK_MODULES([CHIMARA], [
glib-2.0 >= $GLIB_REQUIRED_VERSION
- gtk+-2.0 >= $GTK_REQUIRED_VERSION
+ gtk+-3.0 >= $GTK_REQUIRED_VERSION
gthread-2.0
gmodule-2.0
pango
# Libraries needed to build Chimara player
PKG_CHECK_MODULES([PLAYER], [
glib-2.0 >= $GLIB_REQUIRED_VERSION
- gtk+-2.0 >= $GTK_REQUIRED_VERSION
+ gtk+-3.0 >= $GTK_REQUIRED_VERSION
gmodule-2.0
- libgda-4.0
+ dnl libgda-4.0
libsoup-2.4
])
# Libraries needed to build test programs
PKG_CHECK_MODULES([TEST], [
- gtk+-2.0 >= $GTK_REQUIRED_VERSION
+ gtk+-3.0 >= $GTK_REQUIRED_VERSION
gmodule-2.0 >= $GLIB_REQUIRED_VERSION
])
chimara-if.c chimara-if.h
Chimara-1.0.gir: libchimara.la
-Chimara_1_0_gir_INCLUDES = GObject-2.0 GLib-2.0 Gtk-2.0
+Chimara_1_0_gir_INCLUDES = GObject-2.0 GLib-2.0 Gtk-3.0
Chimara_1_0_gir_CFLAGS = @CHIMARA_CFLAGS@ -I$(top_srcdir)
Chimara_1_0_gir_LIBS = libchimara.la
Chimara_1_0_gir_FILES = $(introspection_sources)
if BUILDING_VAPI
chimara.vapi: $(INTROSPECTION_GIRS)
- $(AM_V_GEN)$(VAPIGEN) --library=chimara --pkg gtk+-2.0 Chimara-1.0.gir && \
+ $(AM_V_GEN)$(VAPIGEN) --library=chimara --pkg gtk+-3.0 Chimara-1.0.gir && \
touch $@
endif
gtk_widget_size_request(win->frame, requisition);
}
-/* Overrides gtk_widget_size_request */
+/* Old GTK 2 functionality overriding gtk_widget_size_request();
+get_preferred_width() and get_preferred_height() are implemented in terms of
+this function. */
static void
chimara_glk_size_request(GtkWidget *widget, GtkRequisition *requisition)
{
}
}
+/* Minimal implementation of width-for-height request, in terms of the old
+GTK 2 mechanism. FIXME: make this more efficient. */
+static void
+chimara_glk_get_preferred_width(GtkWidget *widget, int *minimal, int *natural)
+{
+ g_return_if_fail(widget || CHIMARA_IS_GLK(widget));
+ g_return_if_fail(minimal);
+ g_return_if_fail(natural);
+
+ GtkRequisition requisition;
+
+ chimara_glk_size_request(widget, &requisition);
+ *minimal = *natural = requisition.width;
+}
+
+/* Minimal implementation of height-for-width request, in terms of the old
+GTK 2 mechanism. FIXME: make this more efficient. */
+static void
+chimara_glk_get_preferred_height(GtkWidget *widget, int *minimal, int *natural)
+{
+ g_return_if_fail(widget || CHIMARA_IS_GLK(widget));
+ g_return_if_fail(minimal);
+ g_return_if_fail(natural);
+
+ GtkRequisition requisition;
+
+ chimara_glk_size_request(widget, &requisition);
+ *minimal = *natural = requisition.height;
+}
+
/* Recursively give the Glk windows their allocated space. Returns a window
containing all children of this window that must be redrawn, or NULL if there
are no children that require redrawing. */
object_class->finalize = chimara_glk_finalize;
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
- widget_class->size_request = chimara_glk_size_request;
+ widget_class->get_preferred_width = chimara_glk_get_preferred_width;
+ widget_class->get_preferred_height = chimara_glk_get_preferred_height;
widget_class->size_allocate = chimara_glk_size_allocate;
GtkContainerClass *container_class = GTK_CONTAINER_CLASS(klass);
return draw_image_common(win, info->pixbuf, val1, val2);
}
-/* Internal function: draws a pixbuf to a graphics window of text buffer */
+/* Internal function: draws a pixbuf to a graphics window or text buffer */
glui32
draw_image_common(winid_t win, GdkPixbuf *pixbuf, glsi32 val1, glsi32 val2)
{
switch(win->type) {
case wintype_Graphics:
{
- GdkPixmap *canvas;
-
gdk_threads_enter();
- gtk_image_get_pixmap( GTK_IMAGE(win->widget), &canvas, NULL );
- if(canvas == NULL) {
- WARNING("Could not get pixmap");
- return FALSE;
- }
-
- gdk_draw_pixbuf( GDK_DRAWABLE(canvas), NULL, pixbuf, 0, 0, val1, val2, -1, -1, GDK_RGB_DITHER_NONE, 0, 0 );
+ cairo_t *cr = cairo_create(win->backing_store);
+ gdk_cairo_set_source_pixbuf(cr, pixbuf, val1, val2);
+ cairo_paint(cr);
+ cairo_destroy(cr);
/* Update the screen */
gtk_widget_queue_draw(win->widget);
win->background_color = color;
}
+static void
+glkcairo_set_source_glkcolor(cairo_t *cr, glui32 val)
+{
+ double r, g, b;
+ r = ((val & 0xff0000) >> 16) / 256.0;
+ g = ((val & 0x00ff00) >> 8) / 256.0;
+ b = (val & 0x0000ff) / 256.0;
+ cairo_set_source_rgb(cr, r, g, b);
+}
+
/**
* glk_window_fill_rect:
* @win: A graphics window.
gdk_threads_enter();
- GdkPixmap *map;
- gtk_image_get_pixmap( GTK_IMAGE(win->widget), &map, NULL );
-
- GdkGC *gc = gdk_gc_new(map);
- GdkColor gdkcolor;
- glkcolor_to_gdkcolor(color, &gdkcolor);
- gdk_gc_set_rgb_fg_color(gc, &gdkcolor);
- gdk_draw_rectangle( GDK_DRAWABLE(map), gc, TRUE, left, top, width, height);
+ cairo_t *cr = cairo_create(win->backing_store);
+ glkcairo_set_source_glkcolor(cr, color);
+ cairo_rectangle(cr, (double)left, (double)top, (double)width, (double)height);
+ cairo_fill(cr);
gtk_widget_queue_draw(win->widget);
- g_object_unref(gc);
+ cairo_destroy(cr);
gdk_threads_leave();
}
VALID_WINDOW(win, return);
}
-/*** Called when the graphics window is resized. Resize the backing pixmap if necessary ***/
-void
-on_graphics_size_allocate(GtkWidget *widget, GtkAllocation *allocation, winid_t win)
-{
- GdkPixmap *oldmap;
- gtk_image_get_pixmap( GTK_IMAGE(widget), &oldmap, NULL );
- gint oldwidth = 0;
- gint oldheight = 0;
-
- /* Determine whether a pixmap exists with the correct size */
+/* Called when the graphics window is resized, restacked, or moved. Resize the
+backing store if necessary. */
+gboolean
+on_graphics_configure(GtkWidget *widget, GdkEventConfigure *event, winid_t win)
+{
+ int oldwidth = 0, oldheight = 0;
+
+ /* Determine whether the backing store can stay the same size */
gboolean needs_resize = FALSE;
- if(oldmap == NULL)
+ if(win->backing_store == NULL)
needs_resize = TRUE;
else {
- gdk_drawable_get_size( GDK_DRAWABLE(oldmap), &oldwidth, &oldheight );
- if(oldwidth != allocation->width || oldheight != allocation->height)
+ oldwidth = cairo_image_surface_get_width(win->backing_store);
+ oldheight = cairo_image_surface_get_height(win->backing_store);
+ if(oldwidth != event->width || oldheight != event->height)
needs_resize = TRUE;
}
if(needs_resize) {
- /* Create a new pixmap */
- GdkPixmap *newmap = gdk_pixmap_new(widget->window, allocation->width, allocation->height, -1);
- gdk_draw_rectangle( GDK_DRAWABLE(newmap), widget->style->white_gc, TRUE, 0, 0, allocation->width, allocation->height);
-
- /* Copy the contents of the old pixmap */
- if(oldmap != NULL)
- gdk_draw_drawable( GDK_DRAWABLE(newmap), widget->style->white_gc, GDK_DRAWABLE(oldmap), 0, 0, 0, 0, oldwidth, oldheight);
-
- /* Use the new pixmap */
- gtk_image_set_from_pixmap( GTK_IMAGE(widget), newmap, NULL );
- g_object_unref(newmap);
+ /* Create a new backing store */
+ cairo_surface_t *new_backing_store = gdk_window_create_similar_surface( gtk_widget_get_window(widget), CAIRO_CONTENT_COLOR, gtk_widget_get_allocated_width(widget), gtk_widget_get_allocated_height(widget) );
+ cairo_t *cr = cairo_create(new_backing_store);
+
+ /* Clear to background color */
+ glkcairo_set_source_glkcolor(cr, win->background_color);
+ cairo_paint(cr);
+
+ if(win->backing_store != NULL) {
+ /* Copy the contents of the old backing store */
+ cairo_set_source_surface(cr, win->backing_store, 0, 0);
+ cairo_paint(cr);
+ cairo_surface_destroy(win->backing_store);
+ }
+
+ cairo_destroy(cr);
+ /* Use the new backing store */
+ win->backing_store = new_backing_store;
}
+
+ return TRUE; /* Event handled, stop processing */
}
+/* Draw the backing store to the screen. Called whenever the drawing area is
+exposed. */
+gboolean
+on_graphics_draw(GtkWidget *widget, cairo_t *cr, winid_t win)
+{
+ cairo_set_source_surface(cr, win->backing_store, 0, 0);
+ cairo_paint(cr);
+ return FALSE;
+}
gboolean scaled;
};
-void on_graphics_size_allocate(GtkWidget *widget, GtkAllocation *allocation, winid_t win);
+gboolean on_graphics_configure(GtkWidget *widget, GdkEventConfigure *event, winid_t win);
+gboolean on_graphics_draw(GtkWidget *widget, cairo_t *cr, winid_t win);
void clear_image_cache(struct image_info *data, gpointer user_data);
#endif
gtk_text_buffer_get_selection_bounds(buffer, &selection_start, &selection_end);
if(gtk_text_iter_compare(&selection_start, &input_position_iter) < 0) {
// Cursor is somewhere else in the text, place it at the end if the user starts typing
- if(event->keyval >= GDK_space && event->keyval <= GDK_asciitilde) {
+ if(event->keyval >= GDK_KEY_space && event->keyval <= GDK_KEY_asciitilde) {
gtk_text_buffer_place_cursor(buffer, &end_iter);
} else {
// User is walking around, let him be.
pager_update(win);
/* History up/down */
- if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up
- || event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
+ if(event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up
+ || event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
{
/* Prevent falling off the end of the history list */
if(win->history == NULL)
return TRUE;
- if( (event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
+ if( (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
&& win->history_pos && win->history_pos->next == NULL)
return TRUE;
- if( (event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
+ if( (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
&& (win->history_pos == NULL || win->history_pos->prev == NULL) )
return TRUE;
gtk_text_buffer_delete(buffer, &input_position_iter, &end_iter);
- if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
+ if(event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
{
if(win->history_pos)
win->history_pos = g_list_next(win->history_pos);
}
/* Move to beginning/end of input field */
- else if(event->keyval == GDK_Home) {
+ else if(event->keyval == GDK_KEY_Home) {
GtkTextIter input_iter;
GtkTextMark *input_position = gtk_text_buffer_get_mark(buffer, "input_position");
gtk_text_buffer_get_iter_at_mark(buffer, &input_iter, input_position);
gtk_text_buffer_place_cursor(buffer, &input_iter);
return TRUE;
}
- else if(event->keyval == GDK_End) {
+ else if(event->keyval == GDK_KEY_End) {
gtk_text_buffer_place_cursor(buffer, &end_iter);
return TRUE;
}
/* Handle the line terminators */
- else if(event->keyval == GDK_Return || event->keyval == GDK_KP_Enter
+ else if(event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_KP_Enter
|| g_slist_find(win->current_extra_line_terminators, GUINT_TO_POINTER(event->keyval)))
{
/* Remove signal handlers */
/* If this is a text grid window, then redirect the key press to the line input GtkEntry */
case wintype_TextGrid:
{
- if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up
- || event->keyval == GDK_Down || event->keyval == GDK_KP_Down
- || event->keyval == GDK_Left || event->keyval == GDK_KP_Left
- || event->keyval == GDK_Right || event->keyval == GDK_KP_Right
- || event->keyval == GDK_Tab || event->keyval == GDK_KP_Tab
- || event->keyval == GDK_Page_Up || event->keyval == GDK_KP_Page_Up
- || event->keyval == GDK_Page_Down || event->keyval == GDK_KP_Page_Down
- || event->keyval == GDK_Home || event->keyval == GDK_KP_Home
- || event->keyval == GDK_End || event->keyval == GDK_KP_End)
+ if(event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up
+ || event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down
+ || event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
+ || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right
+ || event->keyval == GDK_KEY_Tab || event->keyval == GDK_KEY_KP_Tab
+ || event->keyval == GDK_KEY_Page_Up || event->keyval == GDK_KEY_KP_Page_Up
+ || event->keyval == GDK_KEY_Page_Down || event->keyval == GDK_KEY_KP_Page_Down
+ || event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home
+ || event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
return FALSE; /* Don't redirect these keys */
gtk_widget_grab_focus(win->input_entry);
gtk_editable_set_position(GTK_EDITABLE(win->input_entry), -1);
gboolean
on_input_entry_key_press_event(GtkEntry *input_entry, GdkEventKey *event, winid_t win)
{
- if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up
- || event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
+ if(event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up
+ || event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
{
/* Prevent falling off the end of the history list */
- if( (event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
+ if( (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
&& win->history_pos && win->history_pos->next == NULL)
return TRUE;
- if( (event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
+ if( (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
&& (win->history_pos == NULL || win->history_pos->prev == NULL) )
return TRUE;
win->history_pos = win->history;
}
- if(event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
+ if(event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
{
if(win->history_pos)
win->history_pos = g_list_next(win->history_pos);
{
glui32 keycode;
switch(keyval) {
- case GDK_Up:
- case GDK_KP_Up: return keycode_Up;
- case GDK_Down:
- case GDK_KP_Down: return keycode_Down;
- case GDK_Left:
- case GDK_KP_Left: return keycode_Left;
- case GDK_Right:
- case GDK_KP_Right: return keycode_Right;
- case GDK_Linefeed:
- case GDK_Return:
- case GDK_KP_Enter: return keycode_Return;
- case GDK_Delete:
- case GDK_BackSpace:
- case GDK_KP_Delete: return keycode_Delete;
- case GDK_Escape: return keycode_Escape;
- case GDK_Tab:
- case GDK_KP_Tab: return keycode_Tab;
- case GDK_Page_Up:
- case GDK_KP_Page_Up: return keycode_PageUp;
- case GDK_Page_Down:
- case GDK_KP_Page_Down: return keycode_PageDown;
- case GDK_Home:
- case GDK_KP_Home: return keycode_Home;
- case GDK_End:
- case GDK_KP_End: return keycode_End;
- case GDK_F1:
- case GDK_KP_F1: return keycode_Func1;
- case GDK_F2:
- case GDK_KP_F2: return keycode_Func2;
- case GDK_F3:
- case GDK_KP_F3: return keycode_Func3;
- case GDK_F4:
- case GDK_KP_F4: return keycode_Func4;
- case GDK_F5: return keycode_Func5;
- case GDK_F6: return keycode_Func6;
- case GDK_F7: return keycode_Func7;
- case GDK_F8: return keycode_Func8;
- case GDK_F9: return keycode_Func9;
- case GDK_F10: return keycode_Func10;
- case GDK_F11: return keycode_Func11;
- case GDK_F12: return keycode_Func12;
+ case GDK_KEY_Up:
+ case GDK_KEY_KP_Up: return keycode_Up;
+ case GDK_KEY_Down:
+ case GDK_KEY_KP_Down: return keycode_Down;
+ case GDK_KEY_Left:
+ case GDK_KEY_KP_Left: return keycode_Left;
+ case GDK_KEY_Right:
+ case GDK_KEY_KP_Right: return keycode_Right;
+ case GDK_KEY_Linefeed:
+ case GDK_KEY_Return:
+ case GDK_KEY_KP_Enter: return keycode_Return;
+ case GDK_KEY_Delete:
+ case GDK_KEY_BackSpace:
+ case GDK_KEY_KP_Delete: return keycode_Delete;
+ case GDK_KEY_Escape: return keycode_Escape;
+ case GDK_KEY_Tab:
+ case GDK_KEY_KP_Tab: return keycode_Tab;
+ case GDK_KEY_Page_Up:
+ case GDK_KEY_KP_Page_Up: return keycode_PageUp;
+ case GDK_KEY_Page_Down:
+ case GDK_KEY_KP_Page_Down: return keycode_PageDown;
+ case GDK_KEY_Home:
+ case GDK_KEY_KP_Home: return keycode_Home;
+ case GDK_KEY_End:
+ case GDK_KEY_KP_End: return keycode_End;
+ case GDK_KEY_F1:
+ case GDK_KEY_KP_F1: return keycode_Func1;
+ case GDK_KEY_F2:
+ case GDK_KEY_KP_F2: return keycode_Func2;
+ case GDK_KEY_F3:
+ case GDK_KEY_KP_F3: return keycode_Func3;
+ case GDK_KEY_F4:
+ case GDK_KEY_KP_F4: return keycode_Func4;
+ case GDK_KEY_F5: return keycode_Func5;
+ case GDK_KEY_F6: return keycode_Func6;
+ case GDK_KEY_F7: return keycode_Func7;
+ case GDK_KEY_F8: return keycode_Func8;
+ case GDK_KEY_F9: return keycode_Func9;
+ case GDK_KEY_F10: return keycode_Func10;
+ case GDK_KEY_F11: return keycode_Func11;
+ case GDK_KEY_F12: return keycode_Func12;
default:
keycode = gdk_keyval_to_unicode(keyval);
/* If keycode is 0, then keyval was not recognized; also return
switch (keycode)
{
case keycode_Left:
- return GDK_Left;
+ return GDK_KEY_Left;
case keycode_Right:
- return GDK_Right;
+ return GDK_KEY_Right;
case keycode_Up:
- return GDK_Up;
+ return GDK_KEY_Up;
case keycode_Down:
- return GDK_Down;
+ return GDK_KEY_Down;
case keycode_Return:
- return GDK_Return;
+ return GDK_KEY_Return;
case keycode_Delete:
- return GDK_Delete;
+ return GDK_KEY_Delete;
case keycode_Escape:
- return GDK_Escape;
+ return GDK_KEY_Escape;
case keycode_Tab:
- return GDK_Tab;
+ return GDK_KEY_Tab;
case keycode_PageUp:
- return GDK_Page_Up;
+ return GDK_KEY_Page_Up;
case keycode_PageDown:
- return GDK_Page_Down;
+ return GDK_KEY_Page_Down;
case keycode_Home:
- return GDK_Home;
+ return GDK_KEY_Home;
case keycode_End:
- return GDK_End;
+ return GDK_KEY_End;
case keycode_Func1:
- return GDK_F1;
+ return GDK_KEY_F1;
case keycode_Func2:
- return GDK_F2;
+ return GDK_KEY_F2;
case keycode_Func3:
- return GDK_F3;
+ return GDK_KEY_F3;
case keycode_Func4:
- return GDK_F4;
+ return GDK_KEY_F4;
case keycode_Func5:
- return GDK_F5;
+ return GDK_KEY_F5;
case keycode_Func6:
- return GDK_F6;
+ return GDK_KEY_F6;
case keycode_Func7:
- return GDK_F7;
+ return GDK_KEY_F7;
case keycode_Func8:
- return GDK_F8;
+ return GDK_KEY_F8;
case keycode_Func9:
- return GDK_F9;
+ return GDK_KEY_F9;
case keycode_Func10:
- return GDK_F10;
+ return GDK_KEY_F10;
case keycode_Func11:
- return GDK_F11;
+ return GDK_KEY_F11;
case keycode_Func12:
- return GDK_F12;
+ return GDK_KEY_F12;
case keycode_Erase:
- return GDK_BackSpace;
+ return GDK_KEY_BackSpace;
}
unsigned keyval = gdk_unicode_to_keyval(keycode);
if(keyval < 0x01000000) /* magic number meaning illegal unicode point */
NULL);
switch (event->keyval) {
- case GDK_space: case GDK_KP_Space:
- case GDK_Page_Down: case GDK_KP_Page_Down:
- case GDK_Return: case GDK_KP_Enter:
+ case GDK_KEY_space: case GDK_KEY_KP_Space:
+ case GDK_KEY_Page_Down: case GDK_KEY_KP_Page_Down:
+ case GDK_KEY_Return: case GDK_KEY_KP_Enter:
gtk_adjustment_set_value(adj, CLAMP(value + page_size, lower, upper - page_size));
return TRUE;
- case GDK_Page_Up: case GDK_KP_Page_Up:
+ case GDK_KEY_Page_Up: case GDK_KEY_KP_Page_Up:
gtk_adjustment_set_value(adj, CLAMP(value - page_size, lower, upper - page_size));
return TRUE;
/* don't handle "up" and "down", they're used for input history */
return FALSE; /* if the key wasn't handled here, pass it to other handlers */
}
-/* Draw the "more" prompt on top of the buffer, after the regular expose event has run */
+/* Draw the "more" prompt on top of the buffer, after the regular draw event has run */
gboolean
-pager_on_expose(GtkTextView *textview, GdkEventExpose *event, winid_t win)
+pager_on_draw(GtkTextView *textview, cairo_t *cr, winid_t win)
{
/* Calculate the position of the 'more' tag */
gint promptwidth, promptheight;
pango_layout_get_pixel_size(win->pager_layout, &promptwidth, &promptheight);
- gint winx, winy, winwidth, winheight;
- gdk_window_get_position(event->window, &winx, &winy);
- gdk_drawable_get_size(GDK_DRAWABLE(event->window), &winwidth, &winheight);
+ int winwidth = gtk_widget_get_allocated_width( GTK_WIDGET(textview) );
+ int winheight = gtk_widget_get_allocated_height( GTK_WIDGET(textview) );
/* Draw the 'more' tag */
- GdkGC *context = gdk_gc_new(GDK_DRAWABLE(event->window));
- gdk_draw_layout(event->window, context,
- winx + winwidth - promptwidth,
- winy + winheight - promptheight,
- win->pager_layout);
+ cairo_move_to(cr, winwidth - promptwidth, winheight - promptheight);
+ pango_cairo_show_layout(cr, win->pager_layout);
return FALSE; /* Propagate event further */
}
/* Check whether paging should be done. This function is called after the
* textview has finished validating text positions. */
void
-pager_after_size_request(GtkTextView *textview, GtkRequisition *requisition, winid_t win)
+pager_after_size_allocate(GtkTextView *textview, GdkRectangle *allocation, winid_t win)
{
/* Move the pager to the last visible character in the buffer */
gint view_height, scroll_distance;
#include "glk.h"
#include "window.h"
-G_GNUC_INTERNAL gboolean pager_on_expose(GtkTextView *textview, GdkEventExpose *event, winid_t win);
+G_GNUC_INTERNAL gboolean pager_on_draw(GtkTextView *textview, cairo_t *cr, winid_t win);
G_GNUC_INTERNAL gboolean pager_on_key_press_event(GtkTextView *textview, GdkEventKey *event, winid_t win);
G_GNUC_INTERNAL void pager_after_adjustment_changed(GtkAdjustment *adj, winid_t win);
-G_GNUC_INTERNAL void pager_after_size_request(GtkTextView *textview, GtkRequisition *requisition, winid_t win);
+G_GNUC_INTERNAL void pager_after_size_allocate(GtkTextView *textview, GdkRectangle *allocation, winid_t win);
G_GNUC_INTERNAL void pager_update(winid_t win);
#endif
gtk_text_tag_copy(GtkTextTag *tag)
{
GtkTextTag *copy;
+ char *tag_name;
+ GParamSpec **properties;
+ unsigned nprops, count;
g_return_val_if_fail(tag != NULL, NULL);
- copy = gtk_text_tag_new(tag->name);
- gtk_text_attributes_copy_values(tag->values, copy->values);
-
- #define _COPY_FLAG(flag) copy->flag = tag->flag
- _COPY_FLAG (bg_color_set);
- _COPY_FLAG (bg_color_set);
- _COPY_FLAG (bg_stipple_set);
- _COPY_FLAG (fg_color_set);
- _COPY_FLAG (fg_stipple_set);
- _COPY_FLAG (justification_set);
- _COPY_FLAG (left_margin_set);
- _COPY_FLAG (indent_set);
- _COPY_FLAG (rise_set);
- _COPY_FLAG (strikethrough_set);
- _COPY_FLAG (right_margin_set);
- _COPY_FLAG (pixels_above_lines_set);
- _COPY_FLAG (pixels_below_lines_set);
- _COPY_FLAG (pixels_inside_wrap_set);
- _COPY_FLAG (tabs_set);
- _COPY_FLAG (underline_set);
- _COPY_FLAG (wrap_mode_set);
- _COPY_FLAG (bg_full_height_set);
- _COPY_FLAG (invisible_set);
- _COPY_FLAG (editable_set);
- _COPY_FLAG (language_set);
- _COPY_FLAG (scale_set);
- #undef _COPY_FLAG
+ g_object_get(tag, "name", &tag_name, NULL);
+ copy = gtk_text_tag_new(tag_name);
+ g_free(tag_name);
+
+ /* Copy all the original tag's properties to the new tag */
+ properties = g_object_class_list_properties( G_OBJECT_GET_CLASS(tag), &nprops );
+ for(count = 0; count < nprops; count++) {
+
+ /* Only copy properties that are readable, writable, not construct-only,
+ and not deprecated */
+ GParamFlags flags = properties[count]->flags;
+ if(flags & G_PARAM_CONSTRUCT_ONLY
+ || flags & G_PARAM_DEPRECATED
+ || !(flags & G_PARAM_READABLE)
+ || !(flags & G_PARAM_WRITABLE))
+ continue;
+
+ const char *prop_name = g_param_spec_get_name(properties[count]);
+ GValue prop_value = G_VALUE_INIT;
+
+ g_value_init( &prop_value, G_PARAM_SPEC_VALUE_TYPE(properties[count]) );
+ g_object_get_property( G_OBJECT(tag), prop_name, &prop_value );
+ /* Don't copy the PangoTabArray if it is NULL, that prints a warning */
+ if(strcmp(prop_name, "tabs") == 0 && g_value_get_boxed(&prop_value) == NULL) {
+ g_value_unset(&prop_value);
+ continue;
+ }
+ g_object_set_property( G_OBJECT(copy), prop_name, &prop_value );
+ g_value_unset(&prop_value);
+ }
+ g_free(properties);
/* Copy the data that was added manually */
gpointer reverse_color = g_object_get_data( G_OBJECT(tag), "reverse-color" );
if(win->pager_layout)
g_object_unref(win->pager_layout);
+ if(win->backing_store)
+ cairo_surface_destroy(win->backing_store);
g_free(win);
}
/* Connect signal handlers */
/* Pager */
- g_signal_connect_after( textview, "size-request", G_CALLBACK(pager_after_size_request), win );
- win->pager_expose_handler = g_signal_connect_after( textview, "expose-event", G_CALLBACK(pager_on_expose), win );
+ g_signal_connect_after( textview, "size-allocate", G_CALLBACK(pager_after_size_allocate), win );
+ win->pager_expose_handler = g_signal_connect_after( textview, "draw", G_CALLBACK(pager_on_draw), win );
g_signal_handler_block(textview, win->pager_expose_handler);
win->pager_keypress_handler = g_signal_connect( textview, "key-press-event", G_CALLBACK(pager_on_key_press_event), win );
g_signal_handler_block(textview, win->pager_keypress_handler);
case wintype_Graphics:
{
- GtkWidget *image = gtk_image_new_from_pixmap(NULL, NULL);
+ GtkWidget *image = gtk_drawing_area_new();
gtk_widget_show(image);
win->unit_width = 1;
win->widget = image;
win->frame = image;
win->background_color = 0x00FFFFFF;
-
+ win->backing_store = NULL;
+
/* Connect signal handlers */
win->button_press_event_handler = g_signal_connect(image, "button-press-event", G_CALLBACK(on_window_button_press), win);
g_signal_handler_block(image, win->button_press_event_handler);
win->shutdown_keypress_handler = g_signal_connect(image, "key-press-event", G_CALLBACK(on_shutdown_key_press_event), win);
g_signal_handler_block(image, win->shutdown_keypress_handler);
- win->size_allocate_handler = g_signal_connect(image, "size-allocate", G_CALLBACK(on_graphics_size_allocate), win);
+ g_signal_connect(image, "configure-event", G_CALLBACK(on_graphics_configure), win);
+ g_signal_connect(image, "draw", G_CALLBACK(on_graphics_draw), win);
}
break;
case wintype_Graphics:
{
+ GtkAllocation allocation;
+
/* Wait for the window's size to be updated */
g_mutex_lock(glk_data->arrange_lock);
if(glk_data->needs_rearrange)
g_cond_wait(glk_data->rearranged, glk_data->arrange_lock);
g_mutex_unlock(glk_data->arrange_lock);
- glk_window_erase_rect(win, 0, 0, win->widget->allocation.width, win->widget->allocation.height);
+ gdk_threads_enter();
+ gtk_widget_get_allocation(win->widget, &allocation);
+ gdk_threads_leave();
+
+ glk_window_erase_rect(win, 0, 0, allocation.width, allocation.height);
}
break;
{
VALID_WINDOW(win, return);
+ GtkAllocation allocation;
ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
switch(win->type)
g_mutex_unlock(glk_data->arrange_lock);
gdk_threads_enter();
+ gtk_widget_get_allocation(win->widget, &allocation);
/* Cache the width and height */
- win->width = (glui32)(win->widget->allocation.width / win->unit_width);
- win->height = (glui32)(win->widget->allocation.height / win->unit_height);
+ win->width = (glui32)(allocation.width / win->unit_width);
+ win->height = (glui32)(allocation.height / win->unit_height);
gdk_threads_leave();
if(widthptr != NULL)
g_mutex_unlock(glk_data->arrange_lock);
gdk_threads_enter();
+ gtk_widget_get_allocation(win->widget, &allocation);
if(widthptr != NULL)
- *widthptr = (glui32)(win->widget->allocation.width / win->unit_width);
+ *widthptr = (glui32)(allocation.width / win->unit_width);
if(heightptr != NULL)
- *heightptr = (glui32)(win->widget->allocation.height / win->unit_height);
+ *heightptr = (glui32)(allocation.height / win->unit_height);
gdk_threads_leave();
break;
g_mutex_unlock(glk_data->arrange_lock);
gdk_threads_enter();
+ gtk_widget_get_allocation(win->widget, &allocation);
if(widthptr != NULL)
- *widthptr = (glui32)(win->widget->allocation.width);
+ *widthptr = (glui32)(allocation.width);
if(heightptr != NULL)
- *heightptr = (glui32)(win->widget->allocation.height);
+ *heightptr = (glui32)(allocation.height);
gdk_threads_leave();
break;
gboolean hyperlink_event_requested;
/* Graphics */
glui32 background_color;
+ cairo_surface_t *backing_store;
/* Pager (textbuffer only) */
gboolean currently_paging;
PangoLayout *pager_layout;
PACKAGE_VERSION = '''@PACKAGE_VERSION@'''
+GETTEXT_PACKAGE = '''@GETTEXT_PACKAGE@'''
+PACKAGE_DATA_DIR = '''@prefix@/@DATADIRNAME@/@PACKAGE@'''
+PACKAGE_SRC_DIR = '''@srcdir@'''
+PACKAGE_LOCALE_DIR = '''@prefix@/@DATADIRNAME@/locale'''
+ENABLE_NLS = ('''@USE_NLS@''' == 'yes')
+DEBUG = ('-DDEBUG' in '''@CPPFLAGS@''')
/* DON'T UNCOMMENT THIS your eyes will burn
but it is a good test of programmatically altering just one style
chimara_glk_set_css_from_string(CHIMARA_GLK(glk),
- "buffer.normal { font-family: 'Comic Sans MS'; }");*/
+ "buffer { font-family: 'Comic Sans MS'; }");*/
GtkBox *vbox = GTK_BOX( gtk_builder_get_object(builder, "vbox") );
if(vbox == NULL)
import sys
import os.path
+import argparse
from gi.repository import GObject, GLib, Gdk, Gio, Gtk, Chimara
import config
-# FIXME: Dummy translation function, for now
-_ = lambda x: x
+if config.ENABLE_NLS:
+ import gettext
+ gettext.install(config.GETTEXT_PACKAGE, config.PACKAGE_LOCALE_DIR,
+ unicode=True, codeset='UTF-8')
+else:
+ _ = lambda x: x
class Player(GObject.GObject):
__gtype_name__ = 'ChimaraPlayer'
- def __init__(self):
+ def __init__(self, graphics_file=None):
super(Player, self).__init__()
- # FIXME: should use the Keyfile backend, but that's not available from
- # Python
- self.prefs_settings = Gio.Settings('org.chimara-if.player.preferences')
- self.state_settings = Gio.Settings('org.chimara-if.player.state')
+ # Initialize settings file; it can be overridden by a "chimara-config"
+ # file in the current directory
+ if os.path.exists('chimara-config'):
+ keyfile = 'chimara-config'
+ else:
+ keyfile = os.path.expanduser('~/.chimara/config')
+ try:
+ # This only works on my custom-built gobject-introspection; opened
+ # bug #682702
+ backend = Gio.keyfile_settings_backend_new(keyfile,
+ "/org/chimara-if/player/", None)
+ except AttributeError:
+ backend = None
+ self.prefs_settings = Gio.Settings('org.chimara-if.player.preferences',
+ backend=backend)
+ self.state_settings = Gio.Settings('org.chimara-if.player.state',
+ backend=backend)
builder = Gtk.Builder()
- builder.add_from_file('chimara.ui')
+ try:
+ builder.add_from_file(os.path.join(config.PACKAGE_DATA_DIR,
+ 'chimara.ui'))
+ except GLib.GError:
+ if config.DEBUG:
+ builder.add_from_file(os.path.join(config.PACKAGE_SRC_DIR,
+ 'chimara.ui'))
+ else:
+ raise
self.window = builder.get_object('chimara')
self.aboutwindow = builder.get_object('aboutwindow')
self.prefswindow = builder.get_object('prefswindow')
'active', Gio.SettingsBindFlags.SET)
filt = Gtk.RecentFilter()
+ # TODO: Use mimetypes and construct the filter dynamically depending on
+ # what plugins are installed
for pattern in ['*.z[1-8]', '*.[zg]lb', '*.[zg]blorb', '*.ulx', '*.blb',
'*.blorb']:
filt.add_pattern(pattern)
recent.add_filter(filt)
uimanager = Gtk.UIManager()
- uimanager.add_ui_from_file('chimara.menus')
- uimanager.insert_action_group(actiongroup, 0)
+ try:
+ uimanager.add_ui_from_file(os.path.join(config.PACKAGE_DATA_DIR,
+ 'chimara.menus'))
+ except GLib.GError:
+ if config.DEBUG:
+ uimanager.add_ui_from_file(os.path.join(config.PACKAGE_SRC_DIR,
+ 'chimara.menus'))
+ else:
+ raise
+ uimanager.insert_action_group(actiongroup)
menubar = uimanager.get_widget('/menubar')
toolbar = uimanager.get_widget('/toolbar')
toolbar.no_show_all = True
accels = uimanager.get_accel_group()
self.window.add_accel_group(accels)
- self.glk = Chimara.IF()
- self.glk.props.ignore_errors = True
- self.glk.set_css_from_file('style.css')
+ self.glk = Chimara.IF(ignore_errors=True,
+ # interpreter_number=Chimara.IFZmachineVersion.TANDY_COLOR,
+ graphics_file=graphics_file)
+ css_file = _maybe(self.prefs_settings.get_value('css-file'))
+ if css_file is None:
+ css_file = 'style.css'
+ self.glk.set_css_from_file(css_file)
+
+ # DON'T UNCOMMENT THIS your eyes will burn
+ # but it is a good test of programmatically altering just one style
+ # self.glk.set_css_from_string("buffer{font-family: 'Comic Sans MS';}")
vbox = builder.get_object('vbox')
vbox.pack_end(self.glk, True, True, 0)
vbox.pack_start(menubar, False, False, 0)
vbox.pack_start(toolbar, False, False, 0)
- #builder.connect_signals(self) # FIXME Segfaults?!
- builder.get_object('open').connect('activate', self.on_open_activate)
- builder.get_object('restore').connect('activate',
- self.on_restore_activate)
- builder.get_object('save').connect('activate', self.on_save_activate)
- builder.get_object('stop').connect('activate', self.on_stop_activate)
- builder.get_object('recent').connect('item-activated',
- self.on_recent_item_activated)
- builder.get_object('undo').connect('activate', self.on_undo_activate)
- builder.get_object('quit').connect('activate', self.on_quit_activate)
- builder.get_object('copy').connect('activate', self.on_copy_activate)
- builder.get_object('paste').connect('activate', self.on_paste_activate)
- builder.get_object('preferences').connect('activate',
- self.on_preferences_activate)
- builder.get_object('about').connect('activate', self.on_about_activate)
- toolbar_action.connect('toggled', self.on_toolbar_toggled)
- self.aboutwindow.connect('response', lambda x, *args: x.hide())
- self.aboutwindow.connect('delete-event',
- lambda x, *args: x.hide_on_delete())
- self.window.connect('delete-event', self.on_window_delete_event)
- self.prefswindow.connect('response', lambda x, *args: x.hide())
- self.prefswindow.connect('delete-event',
- lambda x, *args: x.hide_on_delete())
- # FIXME Delete to here when above bug is fixed
-
+ builder.connect_signals(self)
self.glk.connect('notify::program-name', self.change_window_title)
self.glk.connect('notify::story-name', self.change_window_title)
manager = Gtk.RecentManager.get_default()
manager.add_item(uri)
- def on_stop_activate(self, action, data=None):
+ def on_stop_activate(self, *args):
self.glk.stop()
- def on_quit_chimara_activate(self, action, data=None):
+ def on_quit_chimara_activate(self, *args):
Gtk.main_quit()
- def on_copy_activate(self, action, data=None):
+ def on_copy_activate(self, *args):
focus = self.window.get_focus()
# Call "copy clipboard" on any widget that defines it
if (isinstance(focus, Gtk.Label)
or isinstance(focus, Gtk.TextView)):
focus.emit('copy-clipboard')
- def on_paste_activate(self, action, data=None):
+ def on_paste_activate(self, *args):
focus = self.window.get_focus()
# Call "paste clipboard" on any widget that defines it
if isinstance(focus, Gtk.Entry) or isinstance(focus, Gtk.TextView):
focus.emit('paste-clipboard')
- def on_preferences_activate(self, action, data=None):
+ def on_preferences_activate(self, *args):
self.prefswindow.present()
- def on_toolbar_toggled(self, action, data=None):
+ def on_toolbar_toggled(self, action, *args):
if action.get_active():
self.toolbar.show()
else:
self.toolbar.hide()
- def on_undo_activate(self, action, data=None):
+ def on_undo_activate(self, *args):
self.glk.feed_line_input('undo')
- def on_save_activate(self, action, data=None):
+ def on_save_activate(self, *args):
self.glk.feed_line_input('save')
- def on_restore_activate(self, action, data=None):
+ def on_restore_activate(self, *args):
self.glk.feed_line_input('restore')
- def on_restart_activate(self, action, data=None):
+ def on_restart_activate(self, *args):
self.glk.feed_line_input('restart')
- def on_quit_activate(self, action, data=None):
+ def on_quit_activate(self, *args):
self.glk.feed_line_input('quit')
- def on_about_activate(self, action, data=None):
+ def on_about_activate(self, *args):
self.aboutwindow.set_version(config.PACKAGE_VERSION)
self.aboutwindow.present()
- def on_window_delete_event(self, widget, event, data=None):
+ def on_window_delete_event(self, *args):
Gtk.main_quit()
return True
if os.path.exists(blorbfile):
self.glk.graphics_file = blorbfile
+ # Various signal handlers for GtkBuilder file
+ def gtk_widget_hide(self, widget, *args):
+ return Gtk.Widget.hide(widget)
+
+ def gtk_widget_hide_on_delete(self, widget, *args):
+ return Gtk.Widget.hide_on_delete(widget)
+
+ def dummy_handler(self, *args):
+ pass
+
+ on_resource_file_set = dummy_handler
+ on_interpreter_cell_changed = dummy_handler
+ on_toggle_underline = dummy_handler
+ on_toggle_italic = dummy_handler
+ on_toggle_bold = dummy_handler
+ on_toggle_justify = dummy_handler
+ on_toggle_right = dummy_handler
+ on_toggle_center = dummy_handler
+ on_toggle_left = dummy_handler
+ on_background_color_set = dummy_handler
+ on_foreground_color_set = dummy_handler
+ on_font_set = dummy_handler
+ on_css_filechooser_file_set = dummy_handler
+
def _maybe(variant):
"""Gets a maybe value from a GVariant - not handled in PyGI"""
dialog.destroy()
if __name__ == '__main__':
+ parser = argparse.ArgumentParser()
+ parser.add_argument('game_file', nargs='?', default=None,
+ metavar='GAME FILE', help='the game file to load and start')
+ parser.add_argument('graphics_file', nargs='?', default=None,
+ metavar='GRAPHICS FILE', help='a Blorb resource file to include')
+ args = parser.parse_args()
+
Gdk.threads_init()
- player = Player()
+ # Create configuration dir ~/.chimara
+ try:
+ os.mkdir(os.path.expanduser('~/.chimara'))
+ except OSError:
+ # already exists
+ assert os.path.isdir(os.path.expanduser('~/.chimara'))
+
+ player = Player(graphics_file=args.graphics_file)
player.window.show_all()
- if len(sys.argv) == 3:
- player.glk.props.graphics_file = sys.argv[2]
- if len(sys.argv) >= 2:
+ if args.game_file is not None:
try:
- player.glk.run_game(sys.argv[1])
+ player.glk.run_game(args.game_file)
except GLib.Error as e:
error_dialog(player.window,
_("Error starting Glk library: {errmsg}").format(
w->stop = LOAD_WIDGET("stop");
w->interp = chimara_if_new();
gtk_widget_set_size_request(w->interp, 500, 600);
- gtk_box_pack_end_defaults(GTK_BOX(vbox), w->interp);
+ gtk_box_pack_end(GTK_BOX(vbox), w->interp, TRUE, TRUE, 0);
chimara_glk_set_css_from_string(CHIMARA_GLK(w->interp),
"buffer { font-size: 12; } buffer.input { color: #00a; font-style: italic; }");
chimara_glk_set_spacing(CHIMARA_GLK(w->interp), 1);
projects / projects / chimara / chimara.git / commitdiff