diff options
Diffstat (limited to 'mate-panel/nothing.cP')
| -rw-r--r-- | mate-panel/nothing.cP | 1568 |
1 files changed, 1568 insertions, 0 deletions
diff --git a/mate-panel/nothing.cP b/mate-panel/nothing.cP new file mode 100644 index 00000000..4ce1f246 --- /dev/null +++ b/mate-panel/nothing.cP @@ -0,0 +1,1568 @@ +#include <string.h> +#include <math.h> +#include <unistd.h> + +#include <X11/Xlib.h> +#include <cairo.h> +#include <gdk/gdkkeysyms.h> +#include <canberra-gtk.h> + +#ifdef CA_CHECK_VERSION +#if CA_CHECK_VERSION(0, 13) +#define HAVE_CANBERRA_GTK_MULTIHEAD_SAFE +#endif +#endif + +#include "panel-util.h" +#include "nothing.h" + +static void +pixbuf_reverse (GdkPixbuf *gp) +{ + guchar *pixels = gdk_pixbuf_get_pixels (gp); + int rs = gdk_pixbuf_get_rowstride (gp); + int w = gdk_pixbuf_get_width (gp); + int h = gdk_pixbuf_get_height (gp); + int x, y; +#define DOSWAP(x,y) tmp = x; x = y; y = tmp; + for (y = 0; y < h; y++, pixels += rs) { + guchar *p = pixels; + guchar *p2 = pixels + w*4 - 4; + for (x = 0; x < w/2; x++, p+=4, p2-=4) { + guchar tmp; + DOSWAP (p[0], p2[0]); + DOSWAP (p[1], p2[1]); + DOSWAP (p[2], p2[2]); + DOSWAP (p[3], p2[3]); + } + } +#undef DOSWAP +} + +/* This unsea's the phsh */ +/*code snippet, not to be compiled separately*/ +static gboolean goat_loaded=FALSE; +static int goat_frame=0; +static GdkPixmap *goat_pix[2] = {NULL,NULL}; +static GdkPixmap *goat_pix_rev[2] = {NULL,NULL}; +static GtkWidget *goat_darea = NULL; +static int goat_width = 0,goat_height = 0; +static int goat_timeout = 0; +static int goat_x = -1, goat_y = -1; +static int goat_accx = -1, goat_accy = -1; + +static void +destroy_egg(GtkWidget *widget, gpointer data) +{ + int i; + goat_loaded = FALSE; + if(goat_timeout) { + g_source_remove(goat_timeout); + goat_timeout = 0; + } + for (i = 0; i < 2; i++) { + if (goat_pix[i] != NULL) + g_object_unref (G_OBJECT (goat_pix[i])); + goat_pix[i] = NULL; + if (goat_pix_rev[i] != NULL) + g_object_unref (G_OBJECT (goat_pix_rev[i])); + goat_pix_rev[i] = NULL; + } + goat_x = goat_y = -1; +} + +static int +goat_timeout_func(gpointer data) +{ + GtkAllocation allocation; + cairo_t *cr; + int real_goat_frame; + gboolean sound = FALSE; + int old_x; + int old_y; + + if(!gtk_widget_get_realized(goat_darea) || + !gtk_widget_is_drawable(goat_darea)) + return TRUE; + + if (!goat_pix[0] || !goat_pix[1]) { + destroy_egg (NULL, NULL); + return FALSE; + } + + gtk_widget_get_allocation (goat_darea, &allocation); + cr = gdk_cairo_create (gtk_widget_get_window (goat_darea)); + + if(goat_x == -1) { + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + + goat_x = 2; + goat_y = 2; + goat_accx = g_random_int()%4 +3; + goat_accy = g_random_int()%4 +3; + } + + old_x = goat_x; + old_y = goat_y; + goat_x += goat_accx; + goat_y += goat_accy; + + + if(goat_x>allocation.width-2-goat_width) { + goat_accx = -(g_random_int()%4 +3); + goat_x = allocation.width-2-goat_width; + sound = TRUE; + } else if(goat_x<2) { + goat_accx = g_random_int()%4 +3; + goat_x = 2; + sound = TRUE; + } + if(goat_y>allocation.height-2-goat_height) { + goat_accy = -(g_random_int()%4 +3); + goat_y = allocation.height-2-goat_height; + sound = TRUE; + } else if(goat_y<2) { + goat_accy = g_random_int()%4 +3; + goat_y = 2; + sound = TRUE; + } + + if (sound) { +#ifdef HAVE_CANBERRA_GTK_MULTIHEAD_SAFE + ca_context_cancel (ca_gtk_context_get_for_screen (gtk_widget_get_screen (goat_darea)), 42); +#else + ca_context_cancel (ca_gtk_context_get (), 42); +#endif + ca_gtk_play_for_widget (goat_darea, 42, + CA_PROP_EVENT_ID, "bell-window-system", + CA_PROP_EVENT_DESCRIPTION, "Ouch! This box is small!", + NULL); + } + + real_goat_frame = goat_frame/2; + + cairo_rectangle (cr, MIN(old_x, goat_x), MIN(old_y, goat_y), + goat_width + ABS(goat_x-old_x) + 6, + goat_height + ABS(goat_y-old_y) + 6); + + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + + gdk_cairo_set_source_pixmap (cr, + goat_accx<0?goat_pix[real_goat_frame]: + goat_pix_rev[real_goat_frame], + goat_x,goat_y); + + cairo_paint (cr); + + if(++goat_frame == 4) + goat_frame = 0; + + cairo_destroy (cr); + + return TRUE; +} + +static int +goat_expose(GtkWidget *widget, GdkEventExpose *event) +{ + cairo_t *cr; + + if(!gtk_widget_is_drawable(widget)) + return FALSE; + + cr = gdk_cairo_create (gtk_widget_get_window (goat_darea)); + + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + + cairo_destroy (cr); + + return FALSE; +} + +static void +goat_realize(GtkWidget *widget) +{ + GdkWindow *window; + int frame; + char *files[] = { + "mate-gegl2.png", + "mate-gegl2-2.png" + }; + if(goat_pix[0]) + return; + window = gtk_widget_get_window (widget); + for(frame=0;frame<2;frame++) { + GdkPixbuf *pb; + char *file; + int width; + int height; + cairo_t *cr; + cairo_matrix_t matrix; + cairo_pattern_t *pattern; + + file = g_strdup_printf ("%s/%s", ICONDIR, files[frame]); + if(!file) + return; + pb=gdk_pixbuf_new_from_file (file, NULL); + g_free(file); + + if(!pb) { + g_warning("Goat is not available!"); + return; + } + + width = gdk_pixbuf_get_width(pb); + height = gdk_pixbuf_get_height(pb); + + goat_pix[frame] = gdk_pixmap_new(window, + width, height, -1); + cr = gdk_cairo_create (goat_pix[frame]); + gdk_cairo_set_source_pixbuf (cr, pb, 0, 0); + cairo_paint (cr); + cairo_destroy (cr); + + goat_pix_rev[frame] = gdk_pixmap_new(window, + width, height, -1); + cr = gdk_cairo_create (goat_pix_rev[frame]); + gdk_cairo_set_source_pixbuf (cr, pb, 0, 0); + + cairo_matrix_init_identity (&matrix); + cairo_matrix_translate (&matrix, width, 0); + /* scale in -X direction to flip along X */ + cairo_matrix_scale (&matrix, -1.0, 1.0); + pattern = cairo_get_source (cr); + cairo_pattern_set_filter (pattern, CAIRO_FILTER_BEST); + cairo_pattern_set_matrix (pattern, &matrix); + + cairo_rectangle (cr, 0, 0, width, height); + cairo_fill (cr); + cairo_destroy (cr); + + goat_width = MAX (width, goat_width); + goat_height = MAX (height, goat_height); + + g_object_unref (pb); + } +} + +/*thy evil easter egg*/ +int +config_event(GtkWidget *widget,GdkEvent *event,GtkNotebook *nbook) +{ + static int clicks=0; + GdkEventButton *bevent; + + if (!nbook) + return FALSE; + + if(event->type != GDK_BUTTON_PRESS) + return FALSE; + + bevent = (GdkEventButton *)event; + if(bevent->button != 3) + clicks = 0; + else + clicks++; + + if(clicks<3) + return FALSE; + clicks = 0; + + if(!goat_loaded) { + goat_darea = gtk_drawing_area_new(); + + g_signal_connect (G_OBJECT(goat_darea),"destroy", + G_CALLBACK (destroy_egg),NULL); + g_signal_connect (GTK_OBJECT(goat_darea),"expose_event", + G_CALLBACK (goat_expose),NULL); + g_signal_connect_after (G_OBJECT(goat_darea),"realize", + G_CALLBACK (goat_realize),NULL); + + gtk_widget_show(goat_darea); + goat_timeout = g_timeout_add(60,goat_timeout_func,NULL); + /*the GEGL shall not be translated*/ + g_object_set (G_OBJECT (nbook), + "show_tabs", TRUE, + "show_border", TRUE, + NULL); + gtk_notebook_append_page (nbook, goat_darea, + gtk_label_new ("GEGL")); + gtk_notebook_set_current_page(nbook,-1); + goat_loaded = TRUE; + } else { + gtk_notebook_set_current_page(nbook,-1); + } + return FALSE; +} + +/* phish code */ +#define PHSHFRAMES 8 +#define PHSHORIGWIDTH 288 +#define PHSHORIGHEIGHT 22 +#define PHSHWIDTH (PHSHORIGWIDTH/PHSHFRAMES) +#define PHSHHEIGHT PHSHORIGHEIGHT +#define PHSHCHECKTIMEOUT (g_random_int()%120*1000) +#define PHSHTIMEOUT 120 +#define PHSHHIDETIMEOUT 80 +#define PHSHXS 5 +#define PHSHYS ((g_random_int() % 2) + 1) +#define PHSHXSHIDEFACTOR 2.5 +#define PHSHYSHIDEFACTOR 2.5 +#define PHSHPIXELSTOREMOVE(p) (p[3] < 55 || p[2] > 200) + +/* Some important code copied from PonG */ +typedef struct _AppletContainer AppletContainer; +struct _AppletContainer { + GdkWindow *win; + gboolean hide_mode; + int state; + int x, y, xs, ys; + int handler; + GdkPixmap *phsh[2*PHSHFRAMES]; + GdkBitmap *phsh_mask[2*PHSHFRAMES]; +}; +static AppletContainer phsh = {NULL}; + +static void +phsh_kill (void) +{ + int i; + for (i = 0; i < 2*PHSHFRAMES; i++) { + if (phsh.phsh[i] != NULL) + g_object_unref (G_OBJECT (phsh.phsh[i])); + phsh.phsh[i] = NULL; + if (phsh.phsh_mask[i] != NULL) + g_object_unref (G_OBJECT (phsh.phsh_mask[i])); + phsh.phsh_mask[i] = NULL; + } + gdk_window_destroy (phsh.win); + g_source_remove (phsh.handler); + memset (&phsh, 0, sizeof (AppletContainer)); +} + +static gboolean +phsh_move (gpointer data) +{ + int orient, state; + gboolean change = TRUE; + + phsh.x += phsh.xs; + phsh.y += phsh.ys; + if (phsh.x <= -PHSHWIDTH || + phsh.x >= gdk_screen_width ()) { + phsh_kill (); + return FALSE; + } + if (phsh.y <= 0 || + phsh.y >= gdk_screen_height () - PHSHHEIGHT || + g_random_int() % (phsh.hide_mode?10:50) == 0) + phsh.ys = -phsh.ys; + + phsh.state ++; + if (phsh.hide_mode) { + phsh.state ++; + if (phsh.state >= 2*PHSHFRAMES) + phsh.state = 0; + } else if (phsh.state >= PHSHFRAMES) + phsh.state = 0; + + if (!phsh.hide_mode || phsh.state % 2 == 0) + change = TRUE; + + state = phsh.state / (phsh.hide_mode?2:1); + orient = phsh.xs >= 0 ? 0 : 1; + + if (change) { + gdk_window_set_back_pixmap (phsh.win, phsh.phsh[orient + 2*state], FALSE); + gdk_window_shape_combine_mask (phsh.win, phsh.phsh_mask[orient + 2*state], 0, 0); + gdk_window_clear (phsh.win); + } + + gdk_window_move (phsh.win, phsh.x, phsh.y); + gdk_window_raise (phsh.win); + + return TRUE; +} + +static void +phsh_unsea(GdkPixbuf *gp) +{ + guchar *pixels = gdk_pixbuf_get_pixels (gp); + int rs = gdk_pixbuf_get_rowstride (gp); + int w = gdk_pixbuf_get_width (gp); + int h = gdk_pixbuf_get_height (gp); + int x, y; + + for (y = 0; y < h; y++, pixels += rs) { + guchar *p = pixels; + for (x = 0; x < w; x++, p+=4) { + if (PHSHPIXELSTOREMOVE(p)) + p[3] = 0; + } + } +} + +static GdkFilterReturn +phsh_filter (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data) +{ + XEvent *xevent = (XEvent *)gdk_xevent; + + if (xevent->type == ButtonPress && + ! phsh.hide_mode) { + g_source_remove (phsh.handler); + phsh.handler = g_timeout_add (PHSHHIDETIMEOUT, phsh_move, NULL); + phsh.xs *= PHSHXSHIDEFACTOR; + phsh.ys *= PHSHYSHIDEFACTOR; + phsh.hide_mode = TRUE; + if (phsh.x < (gdk_screen_width () / 2)) + phsh.xs *= -1; + } + return GDK_FILTER_CONTINUE; +} + +static char * +get_phsh_file (void) +{ + char *phsh_file; + + phsh_file = g_strdup_printf ("%s/%cand%c.png", ICONDIR, 'w', 'a'); + + return phsh_file; +} + +static GdkPixbuf * +get_phsh_frame (GdkPixbuf *pb, int frame) +{ + GdkPixbuf *newpb; + + newpb = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, + PHSHWIDTH, PHSHHEIGHT); + gdk_pixbuf_copy_area (pb, frame * PHSHWIDTH, 0, + PHSHWIDTH, PHSHHEIGHT, newpb, 0, 0); + + return newpb; +} + +/* this checks the screen */ +static void +check_screen (void) +{ + GdkWindowAttr attributes; + char *phsh_file; + GdkPixbuf *gp, *tmp; + int i; + + if (phsh.win != NULL) + return; + + phsh_file = get_phsh_file (); + + if (phsh_file == NULL) + return; + + tmp = gdk_pixbuf_new_from_file (phsh_file, NULL); + if (tmp == NULL) + return; + + g_free (phsh_file); + + if (gdk_pixbuf_get_width (tmp) != PHSHORIGWIDTH || + gdk_pixbuf_get_height (tmp) != PHSHORIGHEIGHT) { + g_object_unref (G_OBJECT (tmp)); + return; + } + + phsh.state = 0; + phsh.hide_mode = FALSE; + phsh.x = -PHSHWIDTH; + phsh.y = (g_random_int() % (gdk_screen_height() - PHSHHEIGHT - 2)) + 1; + phsh.xs = PHSHXS; + phsh.ys = PHSHYS; + + for (i = 0; i < PHSHFRAMES; i++) { + gp = get_phsh_frame (tmp, i); + phsh_unsea (gp); + gdk_pixbuf_render_pixmap_and_mask (gp, &phsh.phsh[2*i+1], + &phsh.phsh_mask[2*i+1], 128); + pixbuf_reverse (gp); + gdk_pixbuf_render_pixmap_and_mask (gp, &phsh.phsh[2*i], + &phsh.phsh_mask[2*i], 128); + g_object_unref (G_OBJECT (gp)); + } + + g_object_unref (G_OBJECT (tmp)); + + attributes.window_type = GDK_WINDOW_TEMP; + attributes.x = phsh.x; + attributes.y = phsh.y; + attributes.width = PHSHWIDTH; + attributes.height = PHSHHEIGHT; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gdk_rgb_get_visual(); + attributes.colormap = gdk_rgb_get_colormap(); + attributes.event_mask = GDK_BUTTON_PRESS_MASK; + + phsh.win = gdk_window_new (NULL, &attributes, + GDK_WA_X | GDK_WA_Y | + GDK_WA_VISUAL | GDK_WA_COLORMAP); + gdk_window_set_back_pixmap (phsh.win, phsh.phsh[0], FALSE); + gdk_window_shape_combine_mask (phsh.win, phsh.phsh_mask[0], 0, 0); + + /* setup the keys filter */ + gdk_window_add_filter (phsh.win, + phsh_filter, + NULL); + + gdk_window_show (phsh.win); + phsh.handler = g_timeout_add (PHSHTIMEOUT, phsh_move, NULL); +} + +static guint screen_check_id = 0; + +static gboolean +check_screen_timeout (gpointer data) +{ + screen_check_id = 0; + + check_screen (); + + screen_check_id = g_timeout_add (PHSHCHECKTIMEOUT, + check_screen_timeout, NULL); + return FALSE; +} + +void +start_screen_check (void) +{ + if (screen_check_id > 0) + g_source_remove (screen_check_id); + + check_screen_timeout (NULL); +} + +typedef struct { + gboolean live; + int x, y; +} InvGoat; + +typedef struct { + gboolean good; + int y; + int x; +} InvShot; + + +static GtkWidget *geginv = NULL; +static GtkWidget *geginv_canvas = NULL; +static GtkWidget *geginv_label = NULL; +static GdkPixmap *geginv_pixmap = NULL; +static GdkPixmap *inv_goat1 = NULL; +static GdkPixmap *inv_goat2 = NULL; +static GdkPixmap *inv_phsh1 = NULL; +static GdkBitmap *inv_phsh1_mask = NULL; +static GdkPixmap *inv_phsh2 = NULL; +static GdkBitmap *inv_phsh2_mask = NULL; +static int inv_phsh_state = 0; +static int inv_goat_state = 0; +static int inv_width = 0; +static int inv_height = 0; +static int inv_goat_width = 0; +static int inv_goat_height = 0; +static int inv_phsh_width = 0; +static int inv_phsh_height = 0; +#define INV_ROWS 3 +#define INV_COLS 5 +static InvGoat invs[INV_COLS][INV_ROWS] = { { { FALSE, 0, 0 } } }; +static int inv_num = INV_ROWS * INV_COLS; +static double inv_factor = 1.0; +static int inv_our_x = 0; +static int inv_x = 0; +static int inv_y = 0; +static int inv_first_col = 0; +static int inv_last_col = INV_COLS-1; +static int inv_level = 0; +static int inv_lives = 0; +static gboolean inv_do_pause = FALSE; +static gboolean inv_reverse = FALSE; +static gboolean inv_game_over = FALSE; +static gboolean inv_left_pressed = FALSE; +static gboolean inv_right_pressed = FALSE; +static gboolean inv_fire_pressed = FALSE; +static gboolean inv_left_released = FALSE; +static gboolean inv_right_released = FALSE; +static gboolean inv_fire_released = FALSE; +static gboolean inv_paused = FALSE; +static GSList *inv_shots = NULL; +static guint inv_draw_idle = 0; + +static void +inv_show_status (void) +{ + gchar *s, *t, *u, *v, *w; + if (geginv == NULL) + return; + + if (inv_game_over) { + t = g_strdup_printf (_("<b>GAME OVER</b> at level %d!"), + inv_level+1); + u = g_strdup_printf ("<big>%s</big>", t); + /* Translators: the first and third strings are similar to a + * title, and the second string is a small information text. + * The spaces are there only to separate all the strings, so + try to keep them as is. */ + s = g_strdup_printf (_("%1$s %2$s %3$s"), + u, _("Press 'q' to quit"), u); + g_free (t); + g_free (u); + + } else if (inv_paused) { + t = g_strdup_printf("<big><b>%s</b></big>", _("Paused")); + /* Translators: the first string is a title and the second + * string is a small information text. */ + s = g_strdup_printf (_("%1$s\t%2$s"), + t, _("Press 'p' to unpause")); + g_free (t); + + } else { + t = g_strdup_printf ("<b>%d</b>", inv_level+1); + u = g_strdup_printf ("<b>%d</b>", inv_lives); + v = g_strdup_printf (_("Level: %s, Lives: %s"), t, u); + w = g_strdup_printf ("<big>%s</big>", v); + /* Translators: the first string is a title and the second + * string is a small information text. */ + s = g_strdup_printf (_("%1$s\t%2$s"), w, + _("Left/Right to move, Space to fire, 'p' to pause, 'q' to quit")); + g_free (t); + g_free (u); + g_free (v); + g_free (w); + + } + gtk_label_set_markup (GTK_LABEL (geginv_label), s); + + g_free (s); +} + +static gboolean +inv_draw (gpointer data) +{ + GtkStyle *style; + GdkPixmap *goat; + GSList *li; + int i, j; + + if (data != geginv) { + inv_draw_idle = 0; + return FALSE; + } + + if ( ! gtk_widget_is_drawable (geginv_canvas) || + geginv_pixmap == NULL) + return TRUE; + + style = gtk_widget_get_style (geginv_canvas); + + gdk_draw_rectangle (geginv_pixmap, + style->white_gc, + TRUE /* filled */, + 0, 0, + inv_width, inv_height); + + if (inv_goat_state == 0) + goat = inv_goat1; + else + goat = inv_goat2; + + for (i = 0; i < INV_COLS; i++) { + for (j = 0; j < INV_ROWS; j++) { + int x, y; + if ( ! invs[i][j].live) + continue; + + x = invs[i][j].x*inv_factor - inv_goat_width/2, + y = invs[i][j].y*inv_factor - inv_goat_height/2, + + gdk_draw_drawable (geginv_pixmap, + style->white_gc, + goat, + 0, 0, + x, y, + inv_goat_width, + inv_goat_height); + } + } + + for (li = inv_shots; li != NULL; li = li->next) { + InvShot *shot = li->data; + + gdk_draw_rectangle (geginv_pixmap, + style->black_gc, + TRUE /* filled */, + (shot->x-1)*inv_factor, + (shot->y-4)*inv_factor, + 3, 8); + } + + if ( ! inv_game_over) { + GdkPixmap *phsh; + GdkBitmap *mask; + + if (inv_phsh_state < 5) { + phsh = inv_phsh1; + mask = inv_phsh1_mask; + } else { + phsh = inv_phsh2; + mask = inv_phsh2_mask; + } + + gdk_gc_set_clip_origin (style->white_gc, + inv_our_x*inv_factor - inv_phsh_width/2, + 550*inv_factor - inv_phsh_height/2); + + gdk_gc_set_clip_mask (style->white_gc, + mask); + + gdk_draw_drawable (geginv_pixmap, + style->white_gc, + phsh, + 0, 0, + inv_our_x*inv_factor - inv_phsh_width/2, + 550*inv_factor - inv_phsh_height/2, + inv_phsh_width, + inv_phsh_height); + + gdk_gc_set_clip_origin (style->white_gc, 0, 0); + + gdk_gc_set_clip_mask (style->white_gc, NULL); + } + + gdk_draw_drawable (gtk_widget_get_window (geginv_canvas), + style->white_gc, + geginv_pixmap, + 0, 0, + 0, 0, + inv_width, inv_height); + + gdk_flush (); + + if (inv_do_pause) { + sleep (1); + inv_do_pause = FALSE; + } + + inv_draw_idle = 0; + return FALSE; +} + +static void +inv_queue_draw (GtkWidget *window) +{ + if (inv_draw_idle == 0) + inv_draw_idle = g_idle_add (inv_draw, window); +} + +static void +inv_draw_explosion (int x, int y) +{ + GdkWindow *window; + GtkStyle *style; + int i; + GdkColormap *cmap; + GdkColor red; + GdkGC *gc; + + if ( ! gtk_widget_is_drawable (geginv_canvas)) + return; + + window = gtk_widget_get_window (geginv_canvas); + style = gtk_widget_get_style (geginv_canvas); + + cmap = gdk_drawable_get_colormap (window); + gdk_color_parse ("red", &red); + gdk_colormap_alloc_color (cmap, &red, FALSE, TRUE); + + gc = gdk_gc_new (window); + gdk_gc_set_foreground (gc, &red); + gdk_gc_set_background (gc, &red); + + for (i = 5; i < 100; i += 5) { + gdk_draw_arc (window, + gc, + TRUE /* filled */, + x-i, y-i, + i*2, i*2, + 0, 360*64); + gdk_flush (); + g_usleep (50000); + } + + g_object_unref (G_OBJECT (gc)); + + for (i = 5; i < 100; i += 5) { + gdk_draw_arc (window, + style->white_gc, + TRUE /* filled */, + x-i, y-i, + i*2, i*2, + 0, 360*64); + gdk_flush (); + g_usleep (50000); + } + + gdk_colormap_free_colors (cmap, &red, 1); + + inv_queue_draw (geginv); +} + + +static void +inv_do_game_over (void) +{ + GSList *li; + + inv_game_over = TRUE; + + for (li = inv_shots; li != NULL; li = li->next) { + InvShot *shot = li->data; + shot->good = FALSE; + } + + inv_queue_draw (geginv); + + inv_show_status (); +} + + +static GdkPixbuf * +pb_scale (GdkPixbuf *pb, double scale) +{ + int w, h; + + if (scale == 1.0) + return (GdkPixbuf *)g_object_ref ((GObject *)pb); + + w = gdk_pixbuf_get_width (pb) * scale; + h = gdk_pixbuf_get_height (pb) * scale; + + return gdk_pixbuf_scale_simple (pb, w, h, + GDK_INTERP_BILINEAR); +} + +static void +refind_first_and_last (void) +{ + int i, j; + + for (i = 0; i < INV_COLS; i++) { + gboolean all_null = TRUE; + for (j = 0; j < INV_ROWS; j++) { + if (invs[i][j].live) { + all_null = FALSE; + break; + } + } + if ( ! all_null) { + inv_first_col = i; + break; + } + } + + for (i = INV_COLS-1; i >= 0; i--) { + gboolean all_null = TRUE; + for (j = 0; j < INV_ROWS; j++) { + if (invs[i][j].live) { + all_null = FALSE; + break; + } + } + if ( ! all_null) { + inv_last_col = i; + break; + } + } +} + +static void +whack_gegl (int i, int j) +{ + if ( ! invs[i][j].live) + return; + + invs[i][j].live = FALSE; + inv_num --; + + if (inv_num > 0) { + refind_first_and_last (); + } else { + inv_x = 70; + inv_y = 70; + inv_first_col = 0; + inv_last_col = INV_COLS-1; + inv_reverse = FALSE; + + g_slist_foreach (inv_shots, (GFunc)g_free, NULL); + g_slist_free (inv_shots); + inv_shots = NULL; + + for (i = 0; i < INV_COLS; i++) { + for (j = 0; j < INV_ROWS; j++) { + invs[i][j].live = TRUE; + invs[i][j].x = 70 + i * 100; + invs[i][j].y = 70 + j * 80; + } + } + inv_num = INV_ROWS * INV_COLS; + + inv_level ++; + + inv_show_status (); + } + + inv_queue_draw (geginv); +} + +static gboolean +geginv_timeout (gpointer data) +{ + int i, j; + int limitx1; + int limitx2; + int speed; + int shots; + int max_shots; + + if (inv_paused) + return TRUE; + + if (geginv != data || + inv_num <= 0 || + inv_y > 700) + return FALSE; + + limitx1 = 70 - (inv_first_col * 100); + limitx2 = 800 - 70 - (inv_last_col * 100); + + if (inv_game_over) { + inv_y += 30; + } else { + if (inv_num < (INV_COLS*INV_ROWS)/3) + speed = 45+2*inv_level; + else if (inv_num < (2*INV_COLS*INV_ROWS)/3) + speed = 30+2*inv_level; + else + speed = 15+2*inv_level; + + if (inv_reverse) { + inv_x -= speed; + if (inv_x < limitx1) { + inv_reverse = FALSE; + inv_x = (limitx1 + (limitx1 - inv_x)); + inv_y += 30+inv_level; + } + } else { + inv_x += speed; + if (inv_x > limitx2) { + inv_reverse = TRUE; + inv_x = (limitx2 - (inv_x - limitx2)); + inv_y += 30+inv_level; + } + } + } + + for (i = 0; i < INV_COLS; i++) { + for (j = 0; j < INV_ROWS; j++) { + if (invs[i][j].live) { + invs[i][j].x = inv_x + i * 100; + invs[i][j].y = inv_y + j * 80; + + if ( ! inv_game_over && + invs[i][j].y >= 570) { + inv_do_game_over (); + } else if ( ! inv_game_over && + invs[i][j].y >= 530 && + invs[i][j].x + 40 > inv_our_x - 25 && + invs[i][j].x - 40 < inv_our_x + 25) { + whack_gegl (i,j); + inv_lives --; + inv_draw_explosion (inv_our_x, 550); + if (inv_lives <= 0) { + inv_do_game_over (); + } else { + g_slist_foreach (inv_shots, (GFunc)g_free, NULL); + g_slist_free (inv_shots); + inv_shots = NULL; + inv_our_x = 400; + inv_do_pause = TRUE; + inv_show_status (); + } + } + } + } + } + + shots = 0; + max_shots = (g_random_int () >> 3) % (2+inv_level); + while ( ! inv_game_over && shots < MIN (max_shots, inv_num)) { + int i = (g_random_int () >> 3) % INV_COLS; + for (j = INV_ROWS-1; j >= 0; j--) { + if (invs[i][j].live) { + InvShot *shot = g_new0 (InvShot, 1); + + shot->good = FALSE; + shot->x = invs[i][j].x + (g_random_int () % 6) - 3; + shot->y = invs[i][j].y + inv_goat_height/2 + (g_random_int () % 3); + + inv_shots = g_slist_prepend (inv_shots, shot); + shots++; + break; + } + } + } + + inv_goat_state = (inv_goat_state+1) % 2; + + inv_queue_draw (geginv); + + g_timeout_add (((inv_num/4)+1) * 100, geginv_timeout, geginv); + + return FALSE; +} + +static gboolean +find_gegls (int x, int y) +{ + int i, j; + + /* FIXME: this is stupid, we can do better */ + for (i = 0; i < INV_COLS; i++) { + for (j = 0; j < INV_ROWS; j++) { + int ix = invs[i][j].x; + int iy = invs[i][j].y; + + if ( ! invs[i][j].live) + continue; + + if (y >= iy - 30 && + y <= iy + 30 && + x >= ix - 40 && + x <= ix + 40) { + whack_gegl (i, j); + return TRUE; + } + } + } + + return FALSE; +} + + +static gboolean +geginv_move_timeout (gpointer data) +{ + GSList *li; + static int shot_inhibit = 0; + + if (inv_paused) + return TRUE; + + if (geginv != data || + inv_num <= 0 || + inv_y > 700) + return FALSE; + + inv_phsh_state = (inv_phsh_state+1)%10; + + /* we will be drawing something */ + if (inv_shots != NULL) + inv_queue_draw (geginv); + + li = inv_shots; + while (li != NULL) { + InvShot *shot = li->data; + + if (shot->good) { + shot->y -= 30; + if (find_gegls (shot->x, shot->y) || + shot->y <= 0) { + GSList *list = li; + /* we were restarted */ + if (inv_shots == NULL) + return TRUE; + li = li->next; + g_free (shot); + inv_shots = g_slist_delete_link (inv_shots, list); + continue; + } + } else /* bad */ { + shot->y += 30; + if ( ! inv_game_over && + shot->y >= 535 && + shot->y <= 565 && + shot->x >= inv_our_x - 25 && + shot->x <= inv_our_x + 25) { + inv_lives --; + inv_draw_explosion (inv_our_x, 550); + if (inv_lives <= 0) { + inv_do_game_over (); + } else { + g_slist_foreach (inv_shots, (GFunc)g_free, NULL); + g_slist_free (inv_shots); + inv_shots = NULL; + inv_our_x = 400; + inv_do_pause = TRUE; + inv_show_status (); + return TRUE; + } + } + + if (shot->y >= 600) { + GSList *list = li; + li = li->next; + g_free (shot); + inv_shots = g_slist_delete_link (inv_shots, list); + continue; + } + } + + li = li->next; + } + + if ( ! inv_game_over) { + if (inv_left_pressed && inv_our_x > 100) { + inv_our_x -= 20; + inv_queue_draw (geginv); + } else if (inv_right_pressed && inv_our_x < 700) { + inv_our_x += 20; + inv_queue_draw (geginv); + } + } + + if (shot_inhibit > 0) + shot_inhibit--; + + if ( ! inv_game_over && inv_fire_pressed && shot_inhibit == 0) { + InvShot *shot = g_new0 (InvShot, 1); + + shot->good = TRUE; + shot->x = inv_our_x; + shot->y = 540; + + inv_shots = g_slist_prepend (inv_shots, shot); + + shot_inhibit = 5; + + inv_queue_draw (geginv); + } + + if (inv_left_released) + inv_left_pressed = FALSE; + if (inv_right_released) + inv_right_pressed = FALSE; + if (inv_fire_released) + inv_fire_pressed = FALSE; + + return TRUE; +} + +static gboolean +inv_key_press (GtkWidget *widget, GdkEventKey *event, gpointer data) +{ + switch (event->keyval) { + case GDK_Left: + case GDK_KP_Left: + case GDK_Pointer_Left: + inv_left_pressed = TRUE; + inv_left_released = FALSE; + return TRUE; + case GDK_Right: + case GDK_KP_Right: + case GDK_Pointer_Right: + inv_right_pressed = TRUE; + inv_right_released = FALSE; + return TRUE; + case GDK_space: + case GDK_KP_Space: + inv_fire_pressed = TRUE; + inv_fire_released = FALSE; + return TRUE; + default: + break; + } + return FALSE; +} + +static gboolean +inv_key_release (GtkWidget *widget, GdkEventKey *event, gpointer data) +{ + switch (event->keyval) { + case GDK_Left: + case GDK_KP_Left: + case GDK_Pointer_Left: + inv_left_released = TRUE; + return TRUE; + case GDK_Right: + case GDK_KP_Right: + case GDK_Pointer_Right: + inv_right_released = TRUE; + return TRUE; + case GDK_space: + case GDK_KP_Space: + inv_fire_released = TRUE; + return TRUE; + case GDK_q: + case GDK_Q: + gtk_widget_destroy (widget); + return TRUE; + case GDK_p: + case GDK_P: + inv_paused = ! inv_paused; + inv_show_status (); + return TRUE; + default: + break; + } + return FALSE; +} + +static gboolean +ensure_creatures (void) +{ + GdkPixbuf *pb, *pb1, *phsh1, *phsh2, *goat1, *goat2; + char *phsh_file; + char *goat_file; + + if (inv_goat1 != NULL) + return TRUE; + + phsh_file = get_phsh_file (); + + if (phsh_file == NULL) + return FALSE; + + pb = gdk_pixbuf_new_from_file (phsh_file, NULL); + g_free (phsh_file); + if (pb == NULL) + return FALSE; + + pb1 = get_phsh_frame (pb, 1); + phsh1 = pb_scale (pb1, inv_factor); + g_object_unref (G_OBJECT (pb1)); + phsh_unsea (phsh1); + + pb1 = get_phsh_frame (pb, 2); + phsh2 = pb_scale (pb1, inv_factor); + g_object_unref (G_OBJECT (pb1)); + phsh_unsea (phsh2); + + g_object_unref (G_OBJECT (pb)); + + goat_file = g_strdup_printf ("%s/mate-gegl2.png", ICONDIR); + if (goat_file == NULL) { + g_object_unref (G_OBJECT (phsh1)); + g_object_unref (G_OBJECT (phsh2)); + return FALSE; + } + + pb = gdk_pixbuf_new_from_file (goat_file, NULL); + g_free (goat_file); + if (pb == NULL) { + g_object_unref (G_OBJECT (phsh1)); + g_object_unref (G_OBJECT (phsh2)); + return FALSE; + } + + goat1 = pb_scale (pb, inv_factor * 0.66); + g_object_unref (pb); + + goat_file = g_strdup_printf ("%s/mate-gegl2-2.png", ICONDIR); + if (goat_file == NULL) { + g_object_unref (G_OBJECT (goat1)); + g_object_unref (G_OBJECT (phsh1)); + g_object_unref (G_OBJECT (phsh2)); + return FALSE; + } + + pb = gdk_pixbuf_new_from_file (goat_file, NULL); + g_free (goat_file); + if (pb == NULL) { + g_object_unref (G_OBJECT (goat1)); + g_object_unref (G_OBJECT (phsh1)); + g_object_unref (G_OBJECT (phsh2)); + return FALSE; + } + + goat2 = pb_scale (pb, inv_factor * 0.66); + g_object_unref (pb); + + inv_goat_width = gdk_pixbuf_get_width (goat1); + inv_goat_height = gdk_pixbuf_get_height (goat1); + inv_phsh_width = gdk_pixbuf_get_width (phsh1); + inv_phsh_height = gdk_pixbuf_get_height (phsh1); + + gdk_pixbuf_render_pixmap_and_mask (goat1, &inv_goat1, NULL, 127); + g_object_unref (G_OBJECT (goat1)); + gdk_pixbuf_render_pixmap_and_mask (goat2, &inv_goat2, NULL, 127); + g_object_unref (G_OBJECT (goat2)); + gdk_pixbuf_render_pixmap_and_mask (phsh1, &inv_phsh1, &inv_phsh1_mask, 127); + g_object_unref (G_OBJECT (phsh1)); + gdk_pixbuf_render_pixmap_and_mask (phsh2, &inv_phsh2, &inv_phsh2_mask, 127); + g_object_unref (G_OBJECT (phsh2)); + + return TRUE; +} + +static void +geginv_destroyed (GtkWidget *w, gpointer data) +{ + geginv = NULL; + if (geginv_pixmap != NULL) + g_object_unref (G_OBJECT (geginv_pixmap)); + geginv_pixmap = NULL; +} + +static void +geginv_realized (GtkWidget *w, gpointer data) +{ + if (geginv_pixmap == NULL) + geginv_pixmap = gdk_pixmap_new (gtk_widget_get_window (w), + inv_width, inv_height, + gdk_visual_get_depth (gtk_widget_get_visual (w))); +} + +static gboolean +inv_expose (GtkWidget *widget, GdkEventExpose *event) +{ + if ( ! gtk_widget_is_drawable (widget) || + geginv_pixmap == NULL) + return FALSE; + + inv_queue_draw (geginv); + /* + gdk_draw_drawable (geginv_canvas->window, + geginv_canvas->style->white_gc, + geginv_pixmap, + event->area.x, event->area.x, + event->area.x, event->area.x, + event->area.width, event->area.height); + */ + + return FALSE; +} + +void +start_geginv (void) +{ + GtkWidget *vbox; + int i, j; + + if (geginv != NULL) { + gtk_window_present (GTK_WINDOW (geginv)); + return; + } + + inv_width = 800; + inv_height = 600; + + if (inv_width > gdk_screen_width () * 0.9) { + inv_width = gdk_screen_width () * 0.9; + inv_height = inv_width * (600.0/800.0); + } + + if (inv_height > gdk_screen_height () * 0.9) { + inv_height = gdk_screen_height () * 0.9; + inv_width = inv_height * (800.0/600.0); + } + + inv_factor = (double)inv_width / 800.0; + + if ( ! ensure_creatures ()) + return; + + geginv = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (geginv), _("Killer GEGLs from Outer Space")); + g_object_set (G_OBJECT (geginv), "resizable", FALSE, NULL); + g_signal_connect (G_OBJECT (geginv), "destroy", + G_CALLBACK (geginv_destroyed), + NULL); + + geginv_canvas = gtk_drawing_area_new (); + gtk_widget_set_double_buffered (GTK_WIDGET (geginv_canvas), FALSE); + gtk_widget_set_size_request (geginv_canvas, inv_width, inv_height); + + vbox = gtk_vbox_new (FALSE, 0); + gtk_container_add (GTK_CONTAINER (geginv), vbox); + gtk_box_pack_start (GTK_BOX (vbox), geginv_canvas, TRUE, TRUE, 0); + + geginv_label = gtk_label_new (""); + gtk_box_pack_start (GTK_BOX (vbox), geginv_label, FALSE, FALSE, 0); + + inv_our_x = 400; + inv_x = 70; + inv_y = 70; + inv_first_col = 0; + inv_level = 0; + inv_lives = 3; + inv_last_col = INV_COLS-1; + inv_reverse = FALSE; + inv_game_over = FALSE; + inv_left_pressed = FALSE; + inv_right_pressed = FALSE; + inv_fire_pressed = FALSE; + inv_left_released = FALSE; + inv_right_released = FALSE; + inv_fire_released = FALSE; + inv_paused = FALSE; + + gtk_widget_add_events (geginv, GDK_KEY_RELEASE_MASK); + + g_signal_connect (G_OBJECT (geginv), "key_press_event", + G_CALLBACK (inv_key_press), NULL); + g_signal_connect (G_OBJECT (geginv), "key_release_event", + G_CALLBACK (inv_key_release), NULL); + g_signal_connect (G_OBJECT (geginv), "realize", + G_CALLBACK (geginv_realized), NULL); + g_signal_connect (GTK_OBJECT (geginv_canvas), "expose_event", + G_CALLBACK (inv_expose), NULL); + + g_slist_foreach (inv_shots, (GFunc)g_free, NULL); + g_slist_free (inv_shots); + inv_shots = NULL; + + for (i = 0; i < INV_COLS; i++) { + for (j = 0; j < INV_ROWS; j++) { + invs[i][j].live = TRUE; + invs[i][j].x = 70 + i * 100; + invs[i][j].y = 70 + j * 80; + } + } + inv_num = INV_ROWS * INV_COLS; + + g_timeout_add (((inv_num/4)+1) * 100, geginv_timeout, geginv); + g_timeout_add (90, geginv_move_timeout, geginv); + + inv_show_status (); + + gtk_widget_show_all (geginv); +} + +static gboolean +move_window_handler (gpointer data) +{ + int x, y, sx, sy, wx, wy, foox, fooy; + GtkWidget *win = data; + GtkAllocation allocation; + + data = g_object_get_data (G_OBJECT (win), "move_speed_x"); + sx = GPOINTER_TO_INT (data); + data = g_object_get_data (G_OBJECT (win), "move_speed_y"); + sy = GPOINTER_TO_INT (data); + + gtk_widget_get_allocation (win, &allocation); + + gdk_window_get_pointer (NULL, &x, &y, NULL); + wx = allocation.x; + wy = allocation.y; + + foox = wx + (allocation.width / 2); + fooy = wy + (allocation.height / 2); + + if (sqrt ((foox - x)*(foox - x) + (fooy - y)*(fooy - y)) < + MAX (allocation.width, allocation.height)) { + if (foox < x) sx -= 5; + else sx += 5; + if (fooy < y) sy -= 5; + else sy += 5; + } else { + sx /= 2; + sy /= 2; + } + + if (sx > 50) sx = 50; + else if (sx < -50) sx = -50; + if (sy > 50) sy = 50; + else if (sy < -50) sy = -50; + + wx += sx; + wy += sy; + + if (wx < 0) wx = 0; + if (wy < 0) wy = 0; + if (wx + allocation.width > gdk_screen_width ()) + wx = gdk_screen_width () - allocation.width; + if (wy + allocation.height > gdk_screen_height ()) + wy = gdk_screen_height () - allocation.height; + + gtk_window_move (GTK_WINDOW (win), wx, wy); + allocation.x = wx; + allocation.y = wy; + gtk_widget_set_allocation (win, &allocation); + + data = GINT_TO_POINTER (sx); + g_object_set_data (G_OBJECT (win), "move_speed_x", data); + data = GINT_TO_POINTER (sy); + g_object_set_data (G_OBJECT (win), "move_speed_y", data); + + return TRUE; +} + +static void +move_window_destroyed (GtkWidget *win) +{ + gpointer data = g_object_get_data (G_OBJECT (win), "move_window_handler"); + int handler = GPOINTER_TO_INT (data); + + if (handler != 0) + g_source_remove (handler); + g_object_set_data (G_OBJECT (win), "move_window_handler", NULL); +} + +static void +doblah (GtkWidget *window) +{ + gpointer data = g_object_get_data (G_OBJECT (window), "move_window_handler"); + int handler = GPOINTER_TO_INT (data); + + if (handler == 0) { + handler = g_timeout_add (30, move_window_handler, window); + data = GINT_TO_POINTER (handler); + g_object_set_data (G_OBJECT (window), "move_window_handler", data); + g_signal_connect (G_OBJECT (window), "destroy", + G_CALLBACK (move_window_destroyed), + NULL); + } +} + +gboolean +panel_dialog_window_event (GtkWidget *window, + GdkEvent *event) +{ + switch (event->type) { + static int foo = 0; + case GDK_KEY_PRESS: + if((event->key.state & GDK_CONTROL_MASK) && foo < 4) { + switch (event->key.keyval) { + case GDK_r: + case GDK_R: + if(foo == 3) { doblah (window); } foo = 0; break; + case GDK_a: + case GDK_A: + if(foo == 2) { foo++; } else { foo = 0; } break; + case GDK_e: + case GDK_E: + if(foo == 1) { foo++; } else { foo = 0; } break; + case GDK_f: + case GDK_F: + if(foo == 0) { foo++; } else { foo = 0; } break; + default: + foo = 0; + } + } + default: + break; + } + + return FALSE; +} |