git.maemo.org Git - modest/blob - src/modest-tny-stream-gtkhtml.c

   1 /* Copyright (c) 2006, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  * * Redistributions in binary form must reproduce the above copyright
  11  *   notice, this list of conditions and the following disclaimer in the
  12  *   documentation and/or other materials provided with the distribution.
  13  * * Neither the name of the Nokia Corporation nor the names of its
  14  *   contributors may be used to endorse or promote products derived from
  15  *   this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30
  31 /* modest-tny-stream-gtkhtml.c */
  32
  33 #include "modest-tny-stream-gtkhtml.h"
  34 #include <gtkhtml/gtkhtml-stream.h>
  35 #include <gtkhtml/gtkhtml-search.h>
  36
  37 /* 'private'/'protected' functions */
  38 static void  modest_tny_stream_gtkhtml_class_init   (ModestTnyStreamGtkhtmlClass *klass);
  39 static void  modest_tny_stream_gtkhtml_init         (ModestTnyStreamGtkhtml *obj);
  40 static void  modest_tny_stream_gtkhtml_finalize     (GObject *obj);
  41
  42 static void  modest_tny_stream_gtkhml_iface_init (gpointer g_iface, gpointer iface_data);
  43
  44 /* list my signals */
  45 enum {
  46         /* MY_SIGNAL_1, */
  47         /* MY_SIGNAL_2, */
  48         LAST_SIGNAL
  49 };
  50
  51 typedef struct _ModestTnyStreamGtkhtmlPrivate ModestTnyStreamGtkhtmlPrivate;
  52 struct _ModestTnyStreamGtkhtmlPrivate {
  53         GtkHTMLStream *stream;
  54 };
  55 #define MODEST_TNY_STREAM_GTKHTML_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  56                                                        MODEST_TYPE_TNY_STREAM_GTKHTML, \
  57                                                        ModestTnyStreamGtkhtmlPrivate))
  58 /* globals */
  59 static GObjectClass *parent_class = NULL;
  60
  61 /* uncomment the following if you have defined any signals */
  62 /* static guint signals[LAST_SIGNAL] = {0}; */
  63
  64 GType
  65 modest_tny_stream_gtkhtml_get_type (void)
  66 {
  67         static GType my_type = 0;
  68         if (!my_type) {
  69                 static const GTypeInfo my_info = {
  70                         sizeof(ModestTnyStreamGtkhtmlClass),
  71                         NULL,           /* base init */
  72                         NULL,           /* base finalize */
  73                         (GClassInitFunc) modest_tny_stream_gtkhtml_class_init,
  74                         NULL,           /* class finalize */
  75                         NULL,           /* class data */
  76                         sizeof(ModestTnyStreamGtkhtml),
  77                         1,              /* n_preallocs */
  78                         (GInstanceInitFunc) modest_tny_stream_gtkhtml_init,
  79                 };
  80
  81                 static const GInterfaceInfo iface_info = {
  82                         (GInterfaceInitFunc) modest_tny_stream_gtkhml_iface_init,
  83                         NULL,         /* interface_finalize */
  84                         NULL          /* interface_data */
  85                 };
  86
  87                 my_type = g_type_register_static (G_TYPE_OBJECT,
  88                                                   "ModestTnyStreamGtkhtml",
  89                                                   &my_info, 0);
  90
  91                 g_type_add_interface_static (my_type, TNY_TYPE_STREAM_IFACE,
  92                                              &iface_info);
  93
  94         }
  95         return my_type;
  96 }
  97
  98 static void
  99 modest_tny_stream_gtkhtml_class_init (ModestTnyStreamGtkhtmlClass *klass)
 100 {
 101         GObjectClass *gobject_class;
 102         gobject_class = (GObjectClass*) klass;
 103
 104         parent_class            = g_type_class_peek_parent (klass);
 105         gobject_class->finalize = modest_tny_stream_gtkhtml_finalize;
 106
 107         g_type_class_add_private (gobject_class, sizeof(ModestTnyStreamGtkhtmlPrivate));
 108 }
 109
 110 static void
 111 modest_tny_stream_gtkhtml_init (ModestTnyStreamGtkhtml *obj)
 112 {
 113         ModestTnyStreamGtkhtmlPrivate *priv;
 114         priv = MODEST_TNY_STREAM_GTKHTML_GET_PRIVATE(obj);
 115
 116         priv->stream  = NULL;
 117 }
 118
 119 static void
 120 modest_tny_stream_gtkhtml_finalize (GObject *obj)
 121 {
 122         ModestTnyStreamGtkhtmlPrivate *priv;
 123
 124         priv = MODEST_TNY_STREAM_GTKHTML_GET_PRIVATE(obj);
 125         priv->stream = NULL;
 126 }
 127
 128 GObject*
 129 modest_tny_stream_gtkhtml_new (GtkHTMLStream *stream)
 130 {
 131         GObject *obj;
 132         ModestTnyStreamGtkhtmlPrivate *priv;
 133
 134         obj  = G_OBJECT(g_object_new(MODEST_TYPE_TNY_STREAM_GTKHTML, NULL));
 135         priv = MODEST_TNY_STREAM_GTKHTML_GET_PRIVATE(obj);
 136
 137         g_return_val_if_fail (stream, NULL);
 138
 139         priv->stream = stream;
 140
 141         return obj;
 142 }
 143
 144
 145 /* the rest are interface functions */
 146
 147
 148 static ssize_t
 149 gtkhtml_read (TnyStreamIface *self, char *buffer, size_t n)
 150 {
 151         return -1; /* we cannot read */
 152 }
 153
 154
 155 static ssize_t
 156 gtkhtml_write (TnyStreamIface *self, const char *buffer, size_t n)
 157 {
 158         ModestTnyStreamGtkhtmlPrivate *priv;
 159
 160         priv = MODEST_TNY_STREAM_GTKHTML_GET_PRIVATE(self);
 161
 162         if (!priv->stream) {
 163                 g_warning ("cannot write to closed stream");
 164                 return 0;
 165         }
 166
 167         if (n == 0 || !buffer)
 168                 return 0;
 169
 170         gtk_html_stream_write (priv->stream, buffer, n);
 171         return n; /* hmmm */
 172 }
 173
 174
 175 static gint
 176 gtkhtml_flush (TnyStreamIface *self)
 177 {
 178         return 0;
 179 }
 180
 181
 182 static gint
 183 gtkhtml_close (TnyStreamIface *self)
 184 {
 185         ModestTnyStreamGtkhtmlPrivate *priv;
 186         g_return_val_if_fail (self, 0);
 187         priv = MODEST_TNY_STREAM_GTKHTML_GET_PRIVATE(self);
 188
 189         gtk_html_stream_close   (priv->stream, GTK_HTML_STREAM_OK);
 190         priv->stream = NULL;
 191
 192         return 0;
 193 }
 194
 195
 196 static gboolean
 197 gtkhtml_eos (TnyStreamIface *self)
 198 {
 199         return TRUE;
 200 }
 201
 202
 203
 204 static gint
 205 gtkhtml_reset (TnyStreamIface *self)
 206 {
 207         return 0;
 208 }
 209
 210
 211 static ssize_t
 212 gtkhtml_write_to_stream (TnyStreamIface *self, TnyStreamIface *output)
 213 {
 214         return 0;
 215 }
 216
 217
 218 static void
 219 modest_tny_stream_gtkhml_iface_init (gpointer g_iface, gpointer iface_data)
 220 {
 221         TnyStreamIfaceClass *klass;
 222
 223         g_return_if_fail (g_iface);
 224
 225         klass = (TnyStreamIfaceClass *)g_iface;
 226
 227         klass->read_func  = gtkhtml_read;
 228         klass->write_func = gtkhtml_write;
 229         klass->flush_func = gtkhtml_flush;
 230         klass->close_func = gtkhtml_close;
 231         klass->eos_func   = gtkhtml_eos;
 232         klass->reset_func = gtkhtml_reset;
 233         klass->write_to_stream_func = gtkhtml_write_to_stream;
 234 }