diff --git a/Graphics/UI/Gtk/ModelView/CellRendererCairo.chs b/Graphics/UI/Gtk/ModelView/CellRendererCairo.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/ModelView/CellRendererCairo.chs @@ -0,0 +1,173 @@ +{-# LANGUAGE CPP, ForeignFunctionInterface #-} +{-# OPTIONS_GHC -fno-warn-missing-signatures #-} + +-- -*-haskell-*- +-- GIMP Toolkit (GTK) CellRendererCairo +-- +-- Author : John W. Lato +-- +-- Created: June 2012 +-- +-- Copyright (C) 2012 Tsuru Capital SG LLC +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : jwlato@gmail.com +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Renders a cell +-- +module Graphics.UI.Gtk.ModelView.CellRendererCairo ( +-- * Detail +-- +-- | A 'CellRendererCairo' can be used to render an image in a cell. It +-- allows to render via an arbitrary 'Render ()' command. +-- + +-- * Class Hierarchy +-- | +-- @ +-- | 'GObject' +-- | +----'Object' +-- | +----'CellRenderer' +-- | +----CellRendererCairo +-- @ + +-- * Types + CellRendererCairo, + CellRendererCairoClass, + castToCellRendererCairo, gTypeCellRendererCairo, + toCellRendererCairo, + withCellRendererCairo, + +-- * Constructors + cellRendererCairoNew, + +-- * Functions + cellRendererSetRenderer, + +-- * Attributes + cellRenderer + ) where + +import Control.Monad (liftM, unless) +import Control.Monad.Reader (runReaderT) + +import System.Glib.FFI +import System.Glib.GType +import System.Glib.Types +import Graphics.UI.Gtk.Abstract.Object (makeNewObject) +import Graphics.UI.Gtk +import Graphics.Rendering.Cairo.Internal + +#include "gtkcellrenderercairo.h" + +{# context lib="gtk" prefix="gtk" #} + +-- ---------------------------------------------------- +-- CellRendererCairo type binding/boilerplate + + +-- | A Cairo-based CellRenderer +{#pointer *CellRendererCairo foreign newtype #} + +mkCellRendererCairo = (CellRendererCairo, objectUnrefFromMainloop) +unCellRendererCairo (CellRendererCairo o) = o + +class CellRendererClass o => CellRendererCairoClass o +toCellRendererCairo :: CellRendererCairoClass o => o -> CellRendererCairo +toCellRendererCairo = unsafeCastGObject . toGObject + +instance CellRendererCairoClass CellRendererCairo +instance CellRendererClass CellRendererCairo +instance ObjectClass CellRendererCairo +instance GObjectClass CellRendererCairo where + toGObject = GObject . castForeignPtr . unCellRendererCairo + unsafeCastGObject = CellRendererCairo . castForeignPtr . unGObject + +castToCellRendererCairo :: GObjectClass obj => obj -> CellRendererCairo +castToCellRendererCairo = castTo gTypeCellRendererCairo "CellRendererCairo" + +gTypeCellRendererCairo :: GType +gTypeCellRendererCairo = + {# call fun unsafe gtk_cell_renderer_cairo_get_type #} + + +-------------------- +-- Constructors + +-- | Create a new CellRendererCairo object. +-- +cellRendererCairoNew :: IO CellRendererCairo +cellRendererCairoNew = do + obj <- makeNewObject mkCellRendererCairo $ + liftM castPtr $ {# call unsafe cell_renderer_cairo_new #} + return obj + +-------------------- +-- Attributes + +-- | The current rendering function. +cellRenderer + :: CellRendererCairoClass self => WriteAttr self (Rectangle -> Render ()) +cellRenderer = writeAttr cellRendererSetRenderer + + +-------------------- +-- marshallers + +-- | set the rendering function used by a 'CellRendererCairo' +cellRendererSetRenderer + :: CellRendererCairoClass self => self -> (Rectangle -> Render ()) -> IO () +cellRendererSetRenderer self callback = do + -- closure args + -- Cairo Ptr + -- x + -- y + -- width + -- height + sptr <- newStablePtr cb + gclosurePtr <- gtk2hs_closure_new sptr + withForeignPtr (unGObject $ toGObject self) + (\p -> set_cell_renderer (castPtr p) gclosurePtr) + where + cb cptr x y width height = do + let rect = Rectangle x y width height + context = Cairo cptr + runReaderT (runRender (callback rect)) context + status context >>= \stat -> unless + (stat == StatusSuccess) $ fail =<< statusToString stat + +-------------------- +-- foreign code +-- + +foreign import ccall "gtk_cell_renderer_cairo_set_cell_renderer" + set_cell_renderer :: Ptr () -> Ptr GClosure -> IO () + +-- this stuff isn't exported by gtk2hs, so we need to define it again.... + +foreign import ccall unsafe "gtk2hs_closure_new" + gtk2hs_closure_new :: StablePtr a -> IO (Ptr GClosure) + +foreign import ccall unsafe "hsgthread.h >k2hs_g_object_unref_from_mainloop" + objectUnrefFromMainloop :: FinalizerPtr a + +castTo :: (GObjectClass obj, GObjectClass obj') => GType -> String + -> (obj -> obj') +castTo gtype objTypeName obj = + case toGObject obj of + gobj@(GObject objFPtr) + | typeInstanceIsA ((unsafeForeignPtrToPtr.castForeignPtr) objFPtr) gtype + -> unsafeCastGObject gobj + | otherwise -> error $ "Cannot cast object to " ++ objTypeName diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +Copyright (c) 2012, John W. Lato + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of John W. Lato nor the names of other + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/c-exts/gtkcellrenderercairo.c b/c-exts/gtkcellrenderercairo.c new file mode 100644 --- /dev/null +++ b/c-exts/gtkcellrenderercairo.c @@ -0,0 +1,282 @@ +/* gtkcellrenderercairo.c + * Copyright (C) 2000 Tsuru Capital + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + + +#include +#include +#include "gtkcellrenderercairo.h" + +static void gtk_cell_renderer_cairo_get_property (GObject *object, + guint param_id, + GValue *value, + GParamSpec *pspec); +static void gtk_cell_renderer_cairo_set_property (GObject *object, + guint param_id, + const GValue *value, + GParamSpec *pspec); +static void gtk_cell_renderer_cairo_finalize (GObject *object); +static void gtk_cell_renderer_cairo_get_size (GtkCellRenderer *cell, + GtkWidget *widget, + GdkRectangle *rectangle, + gint *x_offset, + gint *y_offset, + gint *width, + gint *height); +static void gtk_cell_renderer_cairo_render (GtkCellRenderer *cell, + GdkDrawable *window, + GtkWidget *widget, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GdkRectangle *expose_area, + GtkCellRendererState flags); + + +enum { + PROP_0, + PROP_CELL_RENDERER, +}; + +G_DEFINE_TYPE (GtkCellRendererCairo, gtk_cell_renderer_cairo, GTK_TYPE_CELL_RENDERER) + +static void +gtk_cell_renderer_cairo_init (GtkCellRendererCairo *cellcairo) +{ + /* in pixbuf, this initialized a private struct. Don't know yet if we'll + * need it here + */ +} + +static void +gtk_cell_renderer_cairo_class_init (GtkCellRendererCairoClass *class) +{ + GObjectClass *object_class = G_OBJECT_CLASS (class); + GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class); + + object_class->finalize = gtk_cell_renderer_cairo_finalize; + + object_class->get_property = gtk_cell_renderer_cairo_get_property; + object_class->set_property = gtk_cell_renderer_cairo_set_property; + + cell_class->get_size = gtk_cell_renderer_cairo_get_size; + cell_class->render = gtk_cell_renderer_cairo_render; + + g_object_class_install_property (object_class, + PROP_CELL_RENDERER, + g_param_spec_pointer ("cellRenderer", + "Cell rendering function", + "The callback function used to render a cell", + G_PARAM_READWRITE)); + +} + +static void +gtk_cell_renderer_cairo_finalize (GObject *object) +{ + GtkCellRendererCairo *cellcairo = GTK_CELL_RENDERER_CAIRO (object); + + if (cellcairo->cairo_render) + g_closure_unref (cellcairo->cairo_render); + + G_OBJECT_CLASS (gtk_cell_renderer_cairo_parent_class)->finalize (object); +} + +static void +gtk_cell_renderer_cairo_get_property (GObject *object, + guint param_id, + GValue *value, + GParamSpec *pspec) +{ + GtkCellRendererCairo *cellcairo = GTK_CELL_RENDERER_CAIRO (object); + + switch (param_id) + { + case PROP_CELL_RENDERER: + g_value_set_object (value, cellcairo->cairo_render); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); + break; + } +} + +static void +gtk_cell_renderer_cairo_set_property (GObject *object, + guint param_id, + const GValue *value, + GParamSpec *pspec) +{ + GtkCellRendererCairo *cellcairo = GTK_CELL_RENDERER_CAIRO (object); + + switch (param_id) + { + case PROP_CELL_RENDERER: + if (cellcairo->cairo_render) + g_closure_unref (cellcairo->cairo_render); + cellcairo->cairo_render = (GClosure*) g_value_dup_object (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); + break; + } +} + +void gtk_cell_renderer_cairo_set_cell_renderer( + GtkCellRendererCairo *cellcairo, + GClosure *renderer) +{ + if (cellcairo) + { + if (cellcairo->cairo_render) + g_closure_unref (cellcairo->cairo_render); + + cellcairo->cairo_render = g_closure_ref(renderer); + } +} + +/** + * gtk_cell_renderer_cairo_new: + * + * Creates a new #GtkCellRendererCairo. Adjust rendering + * parameters using object properties. Object properties can be set + * globally (with g_object_set()). Also, with #GtkTreeViewColumn, you + * can bind a property to a value in a #GtkTreeModel. + * + * Return value: the new cell renderer + **/ +GtkCellRenderer * +gtk_cell_renderer_cairo_new (void) +{ + GtkCellRenderer *cellcairo; + + cellcairo = g_object_new (GTK_TYPE_CELL_RENDERER_CAIRO, NULL); + + return cellcairo; +} + + +static void +gtk_cell_renderer_cairo_get_size (GtkCellRenderer *cell, + GtkWidget *widget, + GdkRectangle *cell_area, + gint *x_offset, + gint *y_offset, + gint *width, + gint *height) +{ + GtkCellRendererCairo *cellcairo = (GtkCellRendererCairo *) cell; + + if (cell_area) + { + + if (x_offset) + { + *x_offset = cell->xalign * cell->xpad; + *x_offset = MAX (*x_offset, 0); + } + if (y_offset) + { + *y_offset = cell->yalign * cell->ypad; + *y_offset = MAX (*y_offset, 0); + } + if (width) + *width = cell_area->x - cell->xpad * 2; + + if (height) + *height = cell_area->y - cell->ypad *2; + } + else + { + if (x_offset) *x_offset = 0; + if (y_offset) *y_offset = 0; + if (width) *width = 0; + if (height) *height = 0; + } +} + +static void +gtk_cell_renderer_cairo_render (GtkCellRenderer *cell, + GdkWindow *window, + GtkWidget *widget, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GdkRectangle *expose_area, + GtkCellRendererState flags) + +{ + GtkCellRendererCairo *cellcairo = (GtkCellRendererCairo *) cell; + + GClosure *render_function; + + GdkRectangle draw_rect; + GValue cairo_args[5] = { { 0, }, { 0, }, { 0, }, { 0, }, { 0, } }; + GValue *arg1; + GValue *arg; + cairo_t *cr; + int ix; + cairo_status_t stat; + + arg1 = cairo_args; + + draw_rect = *cell_area; + if ( !gdk_rectangle_intersect (expose_area, &draw_rect, &draw_rect)) + return; + + render_function = cellcairo->cairo_render; + + if (!render_function) + return; + + cr = gdk_cairo_create (window); + + g_value_init(arg1, G_TYPE_POINTER); + g_assert (G_VALUE_HOLDS(arg1, G_TYPE_POINTER)); + g_value_set_pointer(arg1, (gpointer) cr); + + arg=cairo_args+1; + g_value_init(arg, G_TYPE_INT); + g_assert (G_VALUE_HOLDS(arg, G_TYPE_INT)); + g_value_set_int(arg, draw_rect.x); + + arg++; + g_value_init(arg, G_TYPE_INT); + g_assert (G_VALUE_HOLDS(arg, G_TYPE_INT)); + g_value_set_int(arg, draw_rect.y); + + arg++; + g_value_init(arg, G_TYPE_INT); + g_assert (G_VALUE_HOLDS(arg, G_TYPE_INT)); + g_value_set_int(arg, draw_rect.width); + + arg++; + g_value_init(arg, G_TYPE_INT); + g_assert (G_VALUE_HOLDS(arg, G_TYPE_INT)); + g_value_set_int(arg, draw_rect.height); + + g_closure_invoke(render_function, NULL,5, cairo_args, NULL); + + for(ix=4;ix>=0;ix--) + { + g_value_unset(cairo_args+ix); + } + + cairo_destroy (cr); + +} + +#define __GTK_CELL_RENDERER_CAIRO_C__ diff --git a/c-exts/gtkcellrenderercairo.h b/c-exts/gtkcellrenderercairo.h new file mode 100644 --- /dev/null +++ b/c-exts/gtkcellrenderercairo.h @@ -0,0 +1,70 @@ +/* gtkcellrenderercairo.h + * Copyright (C) 2012 Tsuru Capital LLC + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + + +#ifndef __GTK_CELL_RENDERER_CAIRO_H__ +#define __GTK_CELL_RENDERER_CAIRO_H__ + +#include + + +G_BEGIN_DECLS + + +#define GTK_TYPE_CELL_RENDERER_CAIRO (gtk_cell_renderer_cairo_get_type ()) +#define GTK_CELL_RENDERER_CAIRO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_CAIRO, GtkCellRendererCairo)) +#define GTK_CELL_RENDERER_CAIRO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_CAIRO, GtkCellRendererCairoClass)) +#define GTK_IS_CELL_RENDERER_CAIRO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_CAIRO)) +#define GTK_IS_CELL_RENDERER_CAIRO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_CAIRO)) +#define GTK_CELL_RENDERER_CAIRO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_CAIRO, GtkCellRendererCairoClass)) + + +typedef struct _GtkCellRendererCairo GtkCellRendererCairo; +typedef struct _GtkCellRendererCairoClass GtkCellRendererCairoClass; + +struct _GtkCellRendererCairo +{ + GtkCellRenderer parent; + + /*< private >*/ + GClosure *cairo_render; +}; + +struct _GtkCellRendererCairoClass +{ + GtkCellRendererClass parent_class; + + /* Padding for future expansion */ + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); +}; + +GType gtk_cell_renderer_cairo_get_type (void) G_GNUC_CONST; +GtkCellRenderer *gtk_cell_renderer_cairo_new (void); + +void gtk_cell_renderer_cairo_set_cell_renderer( + GtkCellRendererCairo *obj, + GClosure *renderer); + +G_END_DECLS + + +#endif /* __GTK_CELL_RENDERER_CAIRO_H__ */ diff --git a/cellrenderer-cairo.cabal b/cellrenderer-cairo.cabal new file mode 100644 --- /dev/null +++ b/cellrenderer-cairo.cabal @@ -0,0 +1,35 @@ +name: cellrenderer-cairo +version: 1.0.0.0 +synopsis: Cairo-based CellRenderer +description: A CellRenderer instance that allows for arbitrary Cairo + rendering functions to render each item in a TreeView. +license: BSD3 +license-file: LICENSE +author: John W. Lato +maintainer: jwlato@gmail.com +-- copyright: +category: Graphics +build-type: Simple +cabal-version: >=1.8 +extra-source-files: c-exts/gtkcellrenderercairo.c, + c-exts/gtkcellrenderercairo.h + + +library + exposed-modules: Graphics.UI.Gtk.ModelView.CellRendererCairo + -- other-modules: + c-sources: c-exts/gtkcellrenderercairo.c + include-dirs: c-exts + ghc-options: -Wall + includes: gtk/gtk.h, gtkcellrenderercairo.h + pkgconfig-depends: gtk+-2.0 + build-depends: base >= 4 && < 5, + glib ==0.12.*, + gtk ==0.12.*, + cairo ==0.12.*, + mtl == 2.* + build-tools: c2hs + +source-repository head + type: git + location: git://github.com/tsurucapital/cellrenderer-cairo.git