shoes 3.0.1

data/shoes/code.h

@@ -0,0 +1,14 @@
+//
+// shoes/code.h
+// Success and error codes.
+//
+#ifndef SHOES_CODE_H
+#define SHOES_CODE_H
+
+typedef unsigned long shoes_code;
+
+#define SHOES_OK       0
+#define SHOES_FAIL     1
+#define SHOES_QUIT     2
+
+#endif

data/shoes/config.h

@@ -0,0 +1,232 @@
+//
+// shoes/config.h
+// Most platform-specific definitions.  Window handles and GUI elements for GTK,
+// OSX and Win32.
+//
+// About SHOES_APP_OS and SHOES_SLOT_OS:
+// =========================
+//
+// Okay, so I should mention why these two are split up.  Obviously, these structures
+// contain anything which is unique to a platform.  So, on GTK, you'll see a bunch of
+// GtkWidget pointers in these two structures.  I try to isolate anything of that nature
+// into SHOES_APP_OS or SHOES_SLOT_OS.  Of course, for native widgets, I just go ahead and put it
+// in the widget structures, to fit that all in here would be too pedantic.
+//
+// SHOES_APP_OS covers the toplevel window.  So, there should only be one SHOES_APP_OS structure
+// floating around.  In fact, the `global_app` variable in shoes/app.c should always
+// point to that one struct.  Still, this struct has a pretty low visibility.  I don't
+// like to use `global_app`, except to get around platform limitations.  So the SHOES_APP_OS
+// struct is low-viz, it's only touched in the app-level API and in event handlers.
+//
+// SHOES_SLOT_OS travels down through nested windows, nested canvases.  It's always handy at
+// any level in the canvas stack.  But, keep in mind, one is allocated per window or
+// canvas.  I guess I think of each drawing layer as a "slot".  Each slot copies its
+// parent slot.  So, it's possible that the bottom slot will simply reference pointers
+// that are kept in the top slot.  But, in the case of nested fixed canvases (similar
+// to a browser's IFRAMEs,) the slot will point to new window handles and pass that
+// on to its children.
+//
+// Anyway, ultimately the idea is to occassionally use the native environment's window
+// nesting, because these operating systems offer scrollbars (and some offer compositing)
+// which would be wasteful to try to emulate.
+//
+#ifndef SHOES_CONFIG_H
+#define SHOES_CONFIG_H
+
+#define SHOES_BUFSIZE    4096
+
+//
+// gtk window struct
+//
+#ifdef SHOES_GTK
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk/gdkx.h>
+#include <curl/curl.h>
+#include <curl/types.h>
+#include <curl/easy.h>
+
+#define SHOES_SIGNAL
+#define SHOES_INIT_ARGS void
+#define SHOES_EXTERN
+
+typedef struct {
+  GtkWidget *vscroll, *canvas;
+  GdkEventExpose *expose;
+  int scrolly, scrollh, scrollw;
+  void *owner;
+} shoes_slot_gtk, SHOES_SLOT_OS;
+
+typedef struct {
+  GtkWidget *layout;
+  GtkWidget *radios;
+} shoes_group_gtk, SHOES_GROUP_OS;
+
+typedef struct {
+  GtkWidget *window;
+} shoes_app_gtk, SHOES_APP_OS;
+
+typedef struct {
+  int nada;
+} shoes_world_gtk, SHOES_WORLD_OS;
+
+#define USTR(str) str
+#define SHOES_CONTROL_REF GtkWidget *
+#define SHOES_SURFACE_REF GtkWidget *
+#define SHOES_BOOL gboolean
+#define SHOES_TIMER_REF guint
+#define DC(slot) slot->canvas
+#define HAS_DRAWABLE(slot) slot->canvas->window != 0
+#define DRAWABLE(ref) GDK_DRAWABLE_XID(ref->window)
+#define APP_WINDOW(app) (app == NULL ? NULL : GTK_WINDOW(app->os.window))
+#define SHOES_TIME struct timespec
+#define SHOES_DOWNLOAD_HEADERS struct curl_slist *
+#define SHOES_DOWNLOAD_ERROR CURLcode
+#endif
+
+//
+// quartz (osx) window struct
+//
+#ifdef SHOES_QUARTZ
+// hacks to prevent T_DATA conflict between Ruby and Carbon headers
+# define __OPENTRANSPORT__
+# define __OPENTRANSPORTPROTOCOL__
+# define __OPENTRANSPORTPROVIDERS__
+#include <Cocoa/Cocoa.h>
+#include "shoes/native/cocoa.h"
+#include <cairo-quartz.h>
+
+#define SHOES_SIGNAL
+#define SHOES_HELP_MANUAL 3044
+#define SHOES_CONTROL1    3045
+#define SHOES_INIT_ARGS void
+#define SHOES_EXTERN
+
+typedef struct {
+  NSView *view;
+  NSScroller *vscroll;
+  CGContextRef context;
+  cairo_surface_t *surface;
+  VALUE controls;
+  int scrolly;
+  void *owner;
+} shoes_slot_quartz, SHOES_SLOT_OS;
+
+typedef struct {
+  char none;
+} shoes_group_quartz, SHOES_GROUP_OS;
+
+typedef struct {
+  ShoesWindow *window;
+  NSView *view;
+  NSRect normal;
+} shoes_app_quartz, SHOES_APP_OS;
+
+typedef struct {
+  ShoesEvents *events;
+} shoes_world_quartz, SHOES_WORLD_OS;
+
+#define kShoesViewClassID CFSTR("org.hackety.ShoesView")
+#define kShoesBoundEvent  'Boun'
+#define kShoesSlotData    'SLOT'
+
+#define USTR(str) str
+#define SHOES_CONTROL_REF NSControl *
+#define SHOES_SURFACE_REF CGrafPtr
+#define SHOES_BOOL BOOL
+#define SHOES_TIMER_REF ShoesTimer *
+#define DC(slot) slot->view
+#define HAS_DRAWABLE(slot) slot->context != NULL
+#define DRAWABLE(ref) ref
+#define SHOES_TIME struct timeval
+#define SHOES_DOWNLOAD_HEADERS NSDictionary *
+#define SHOES_DOWNLOAD_ERROR NSError *
+
+#endif
+
+#ifdef SHOES_WIN32
+#include <windows.h>
+#include <commctrl.h>
+#include <shellapi.h>
+#include <cairo-win32.h>
+
+#ifdef RUBY_1_9
+#include "ruby/win32.h"
+#else
+#include "win32/win32.h"
+#endif
+
+#ifndef WM_MOUSEWHEEL
+#define WM_MOUSEWHEEL 0x020A
+#endif
+#ifndef WHEEL_DELTA
+#define WHEEL_DELTA 120
+#endif
+#ifndef SPI_GETWHEELSCROLLLINES
+#define SPI_GETWHEELSCROLLLINES 104
+#endif
+#ifndef WHEEL_PAGESCROLL
+#define WHEEL_PAGESCROLL UINT_MAX
+#endif
+
+#define SHOES_CONTROL1   3045
+#define SHOES_WM_MESSAGE (WM_APP + 3045)
+#define SHOES_INIT_ARGS  HINSTANCE inst, int style
+#define SHOES_EXTERN __declspec(dllexport)
+
+typedef struct {
+  PAINTSTRUCT ps;
+  HDC dc, dc2;
+  HWND window;
+  VALUE focus;
+  VALUE controls;
+  cairo_surface_t *surface;
+  int scrolly;
+  char vscroll;
+  void *owner;
+  void *parent;
+} shoes_slot_win32, SHOES_SLOT_OS;
+
+typedef struct {
+  char none;
+} shoes_group_win32, SHOES_GROUP_OS;
+
+typedef struct {
+  LONG style;
+  RECT normal;
+  BOOL ctrlkey, altkey, shiftkey;
+  HWND window;
+} shoes_app_win32, SHOES_APP_OS;
+
+typedef struct {
+  HINSTANCE instance;
+  int style;
+  HWND hidden;
+  WNDCLASSEX classex, slotex, vlclassex, hiddenex;
+  ATOM classatom;
+  BOOL doublebuffer;
+} shoes_world_win32, SHOES_WORLD_OS;
+
+#define USTR(str) (const char *)L##str
+#define SHOES_CONTROL_REF HWND
+#define SHOES_SURFACE_REF HWND
+#define SHOES_BOOL BOOL
+#define SHOES_TIMER_REF long
+#define DC(slot) slot->window
+#define HAS_DRAWABLE(slot) slot->window != NULL
+#define DRAWABLE(ref) (libvlc_drawable_t)ref
+#define APP_WINDOW(app) (app == NULL ? NULL : app->slot->window)
+#define SHOES_TIME DWORD
+#define SHOES_DOWNLOAD_HEADERS LPWSTR
+#define SHOES_DOWNLOAD_ERROR DWORD
+
+#endif
+
+#define KEY_STATE(sym) \
+  { \
+    VALUE str = rb_str_new2("" # sym "_"); \
+    rb_str_append(str, rb_funcall(v, s_to_s, 0)); \
+    v = rb_str_intern(str); \
+  }
+
+#endif

data/shoes/effects.c

@@ -0,0 +1,243 @@
+//
+// shoes/effects.c
+// The blurring and shadowing effects.
+//
+#include "shoes/internal.h"
+#include "shoes/app.h"
+#include "shoes/canvas.h"
+#include "shoes/ruby.h"
+#include <math.h>
+
+static unsigned char *
+box_run(unsigned int size)
+{
+  int i;
+  unsigned char *tmp = SHOE_ALLOC_N(unsigned char, size * 256);
+  for (i = 0; i < 256; i++)
+    memset(tmp + i * size, i, size);
+  return tmp;
+}
+
+#define BOX_H 1
+#define BOX_V 2
+
+static void
+box_blur(unsigned char *in, unsigned char *out,
+  int stride, shoes_place *place,
+  unsigned int edge1, unsigned int edge2,
+  const unsigned char *run, int dir)
+{
+  int i, j1, j2, l = 0, l2, l3, l4, lx = 0, c1, c2, c3, c4, start;
+  int boxSize = edge1 + edge2 + 1;
+  if (dir == BOX_H)
+  {
+    c1 = place->y;
+    c2 = place->y + place->h;
+    c3 = place->x;
+    c4 = place->x + place->w;
+  }
+  else
+  {
+    c1 = place->x;
+    c2 = place->x + place->w;
+    c3 = place->y;
+    c4 = place->y + place->h;
+  }
+
+  start = c3 - edge1;
+  for (j1 = c1; j1 < c2; j1++) {
+    unsigned int sums[4] = {0, 0, 0, 0};
+    if (dir == BOX_H)
+      l = stride * j1;
+    else
+      lx = j1 << 2;
+    for (i = 0; i < boxSize; i++) {
+      int pos = start + i;
+      pos = max(pos, c3);
+      pos = min(pos, c4 - 1);
+      if (dir == BOX_V)
+        l = stride * pos + lx;
+      sums[0] += in[l];
+      sums[1] += in[l + 1];
+      sums[2] += in[l + 2];
+      sums[3] += in[l + 3];
+    }
+    for (j2 = c3; j2 < c4; j2++) {
+      if (dir == BOX_H)
+        l2 = l + (j2 << 2);
+      else
+        l2 = stride * j2 + lx;
+      out[l2] = run[sums[0]];
+      out[l2 + 1] = run[sums[1]];
+      out[l2 + 2] = run[sums[2]];
+      out[l2 + 3] = run[sums[3]];
+
+      int tmp = j2 - edge1;
+      int last = max(tmp, c3);
+      int next = min(tmp + boxSize, c4 - 1);
+      if (dir == BOX_H)
+      {
+        l3 = l + (next << 2);
+        l4 = l + (last << 2);
+      }
+      else
+      {
+        l3 = stride * next + lx;
+        l4 = stride * last + lx;
+      }
+
+      sums[0] += in[l3] - in[l4];
+      sums[1] += in[l3 + 1] - in[l4 + 1];
+      sums[2] += in[l3 + 2] - in[l4 + 2];
+      sums[3] += in[l3 + 3] - in[l4 + 3];
+    }
+  }
+}
+
+#define RAW_FILTER_START(place) \
+  int width, height, stride; \
+  guchar *out; \
+  static const cairo_user_data_key_t key; \
+  cairo_surface_t *source = cairo_get_target(cr); \
+  cairo_surface_t *target; \
+  unsigned char *in = cairo_image_surface_get_data(source); \
+  \
+  place->x = place->y = 0; \
+  place->w = width  = cairo_image_surface_get_width(source); \
+  place->h = height = cairo_image_surface_get_height(source); \
+  stride = cairo_image_surface_get_stride(source); \
+  \
+  out = (guchar *)g_malloc(4 * width * height); \
+  target = cairo_image_surface_create_for_data((unsigned char *)out, \
+    CAIRO_FORMAT_ARGB32, \
+    width, height, 4 * width); \
+  cairo_surface_set_user_data(target, &key, out, (cairo_destroy_func_t)g_free); \
+  unsigned int len = 4 * width * height
+   
+#define RAW_FILTER_END() \
+  cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); \
+  cairo_paint(cr); \
+  cairo_set_operator(cr, CAIRO_OPERATOR_OVER); \
+  cairo_set_source_surface(cr, target, 0, 0); \
+  cairo_paint(cr); \
+  cairo_surface_destroy(target);
+
+void
+shoes_gaussian_blur_filter(cairo_t *cr, VALUE attr, shoes_place *place)
+{
+  float blur_d = ATTR2(dbl, attr, radius, 2.);
+  float blur_x = blur_d, blur_y = blur_d;
+  RAW_FILTER_START(place);
+  if (blur_x < 0 || blur_y < 0)
+    return;
+
+  if (blur_x == 0 || blur_y == 0)
+    memset(out, 0, len);
+
+  unsigned int dX, dY;
+  dX = (unsigned int) floor(blur_x * 3*sqrt(2*SHOES_PI)/4 + 0.5);
+  dY = (unsigned int) floor(blur_y * 3*sqrt(2*SHOES_PI)/4 + 0.5);
+
+  unsigned char *tmp = SHOE_ALLOC_N(unsigned char, len);
+
+  if (dX & 1) {
+    unsigned char *run = box_run(2 * (dX / 2) + 1);
+    box_blur(in, tmp,  stride, place, dX/2, dX/2, run, BOX_H);
+    box_blur(tmp, out, stride, place, dX/2, dX/2, run, BOX_H);
+    box_blur(out, tmp, stride, place, dX/2, dX/2, run, BOX_H);
+    SHOE_FREE(run);
+  } else {
+    if (dX == 0) {
+      memcpy(tmp, in, len);
+    } else {
+      unsigned char *run1 = box_run(2 * (dX / 2) + 1);
+      unsigned char *run2 = box_run(2 * (dX / 2));
+      box_blur(in, tmp,  stride, place, dX/2,     dX/2 - 1, run2, BOX_H);
+      box_blur(tmp, out, stride, place, dX/2 - 1, dX/2,     run2, BOX_H);
+      box_blur(out, tmp, stride, place, dX/2,     dX/2,     run1, BOX_H);
+      SHOE_FREE(run1);
+      SHOE_FREE(run2);
+    }
+  }
+
+  if (dY & 1) {
+    unsigned char *run = box_run(2 * (dY / 2) + 1);
+    box_blur(tmp, out, stride, place, dY/2, dY/2, run, BOX_V);
+    box_blur(out, tmp, stride, place, dY/2, dY/2, run, BOX_V);
+    box_blur(tmp, out, stride, place, dY/2, dY/2, run, BOX_V);
+    SHOE_FREE(run);
+  } else {
+    if (dY == 0) {
+      memcpy(out, tmp, len);
+    } else {
+      unsigned char *run1 = box_run(2 * (dY / 2) + 1);
+      unsigned char *run2 = box_run(2 * (dY / 2));
+      box_blur(tmp, out, stride, place, dY/2,     dY/2 - 1, run2, BOX_V);
+      box_blur(out, tmp, stride, place, dY/2 - 1, dY/2,     run2, BOX_V);
+      box_blur(tmp, out, stride, place, dY/2,     dY/2,     run1, BOX_V);
+      SHOE_FREE(run1);
+      SHOE_FREE(run2);
+    }
+  }
+
+  SHOE_FREE(tmp);
+  RAW_FILTER_END();
+}
+
+static void
+shoes_layer_blur_filter(cairo_t *cr, VALUE attr, shoes_place *place,
+  cairo_operator_t blur_op, cairo_operator_t merge_op, int distance)
+{
+  cairo_surface_t *source = cairo_get_target(cr);
+  int width  = cairo_image_surface_get_width(source);
+  int height = cairo_image_surface_get_height(source);
+  VALUE fill = ATTR(attr, fill);
+
+  cairo_surface_t *target = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
+  cairo_t *cr2 = cairo_create(target);
+  cairo_set_source_surface(cr2, source, distance, distance);
+  cairo_paint(cr2);
+  cairo_set_operator(cr2, blur_op);
+  if (NIL_P(fill))
+    cairo_set_source_rgb(cr2, 0., 0., 0.);
+  else if (rb_obj_is_kind_of(fill, cColor))
+  {
+    shoes_color *color;
+    Data_Get_Struct(fill, shoes_color, color);
+    cairo_set_source_rgba(cr, color->r / 255., color->g / 255., color->b / 255., color->a / 255.);
+  }
+  else
+  {
+    shoes_pattern *pattern;
+    Data_Get_Struct(fill, shoes_pattern, pattern);
+    cairo_set_source(cr2, PATTERN(pattern));
+  }
+  cairo_rectangle(cr2, 0, 0, width, height);
+  cairo_paint(cr2);
+  shoes_gaussian_blur_filter(cr2, attr, place);
+  cairo_set_operator(cr, merge_op);
+  cairo_set_source_surface(cr, target, 0, 0);
+  cairo_paint(cr);
+  cairo_destroy(cr2);
+}
+
+void
+shoes_shadow_filter(cairo_t *cr, VALUE attr, shoes_place *place)
+{
+  int distance = ATTR2(int, attr, distance, 4);
+  shoes_layer_blur_filter(cr, attr, place, CAIRO_OPERATOR_IN, CAIRO_OPERATOR_DEST_OVER, distance);
+}
+
+void
+shoes_glow_filter(cairo_t *cr, VALUE attr, shoes_place *place)
+{
+  cairo_operator_t blur_op = CAIRO_OPERATOR_IN;
+  cairo_operator_t merge_op = CAIRO_OPERATOR_DEST_OVER;
+  if (RTEST(ATTR(attr, inner)))
+  {
+    blur_op = CAIRO_OPERATOR_OUT;
+    merge_op = CAIRO_OPERATOR_ATOP;
+  }
+  shoes_layer_blur_filter(cr, attr, place, blur_op, merge_op, 0);
+}
+