atk-adaptor/adaptors/streamablecontent-adaptor.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap) *
   4  * Copyright 2001, 2002 Sun Microsystems Inc.,
   5  * Copyright 2001, 2002 Ximian, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 /* streamablecontent.c : implements the StreamableContent interface */
  24
  25 #include "config.h"
  26
  27 #include <libspi/component.h>
  28 #include <libspi/streamablecontent.h>
  29
  30 #include <stdio.h>
  31 #include <string.h>
  32
  33 /* Our parent Gtk object type */
  34 #define PARENT_TYPE SPI_TYPE_BASE
  35
  36 /* A pointer to our parent object class */
  37 static GObjectClass *spi_streamable_parent_class;
  38
  39 #define SPI_CONTENT_STREAM_TYPE            (spi_content_stream_get_type ())
  40 #define SPI_CONTENT_STREAM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SPI_CONTENT_STREAM_TYPE, SpiContentStream))
  41 #define SPI_CONTENT_STREAM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), SPI_CONTENT_STREAM_TYPE, SpiContentStreamClass))
  42 #define SPI_IS_CONTENT_STREAM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SPI_CONTENT_STREAM_TYPE))
  43 #define SPI_IS_CONTENT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SPI_CONTENT_STREAM_TYPE))
  44
  45 typedef struct _SpiContentStream SpiContentStream;
  46 typedef struct _SpiContentStreamClass SpiContentStreamClass;
  47
  48 struct _SpiContentStream
  49 {
  50   BonoboObject parent;
  51   GIOChannel *gio;
  52 };
  53
  54 struct _SpiContentStreamClass
  55 {
  56   BonoboObjectClass parent_class;
  57   POA_Accessibility_ContentStream__epv epv;
  58 };
  59
  60 GType spi_content_stream_get_type (void);
  61
  62 static SpiContentStream *
  63 spi_content_stream_new (GIOChannel * gio)
  64 {
  65   SpiContentStream *new_stream = g_object_new (SPI_CONTENT_STREAM_TYPE, NULL);
  66   new_stream->gio = gio;
  67   return new_stream;
  68 }
  69
  70 static void
  71 spi_content_stream_dispose (GObject * o)
  72 {
  73   if (SPI_IS_CONTENT_STREAM (o))
  74     {
  75       SpiContentStream *stream = SPI_CONTENT_STREAM (o);
  76       if (stream->gio)
  77         g_io_channel_unref (stream->gio);
  78     }
  79 }
  80
  81 static CORBA_long
  82 impl_content_stream_seek (PortableServer_Servant servant,
  83                           const CORBA_long offset,
  84                           const Accessibility_ContentStream_SeekType whence,
  85                           CORBA_Environment * ev)
  86 {
  87   SpiContentStream *stream =
  88     SPI_CONTENT_STREAM (bonobo_object_from_servant (servant));
  89   if (stream && stream->gio)
  90     {
  91       GError *err;
  92       GSeekType seektype = G_SEEK_SET;
  93       switch (whence)
  94         {
  95         case Accessibility_ContentStream_SEEK_CURRENT:
  96           seektype = G_SEEK_CUR;
  97           break;
  98         case Accessibility_ContentStream_SEEK_END:
  99           seektype = G_SEEK_END;
 100           break;
 101         }
 102       if (g_io_channel_seek_position (stream->gio, (gint64) offset,
 103                                       seektype, &err) == G_IO_STATUS_NORMAL)
 104         return offset;
 105       else
 106         return -1;
 107     }
 108   else
 109     return -1;
 110 }
 111
 112 static CORBA_long
 113 impl_content_stream_read (PortableServer_Servant servant,
 114                           const CORBA_long count,
 115                           Accessibility_ContentStream_iobuf ** buffer,
 116                           CORBA_Environment * ev)
 117 {
 118   SpiContentStream *stream =
 119     SPI_CONTENT_STREAM (bonobo_object_from_servant (servant));
 120   CORBA_long realcount = 0;
 121
 122   if (stream && stream->gio)
 123     {
 124       gchar *gbuf = NULL;
 125       GIOStatus status;
 126       GError *err = NULL;
 127
 128       /* read the giochannel and determine the actual bytes read... */
 129       if (count != -1)
 130         {
 131           gbuf = g_malloc (count + 1);
 132           status =
 133             g_io_channel_read_chars (stream->gio, gbuf, count, &realcount,
 134                                      &err);
 135         }
 136       else
 137         status =
 138           g_io_channel_read_to_end (stream->gio, &gbuf, &realcount, &err);
 139
 140       if (status == G_IO_STATUS_NORMAL || status == G_IO_STATUS_EOF)
 141         {
 142           *buffer = Bonobo_Stream_iobuf__alloc ();
 143           CORBA_sequence_set_release (*buffer, TRUE);
 144
 145           (*buffer)->_buffer =
 146             CORBA_sequence_CORBA_octet_allocbuf (realcount);
 147           (*buffer)->_length = realcount;
 148
 149           g_memmove ((*buffer)->_buffer, gbuf, realcount);
 150         }
 151
 152       g_free (gbuf);
 153     }
 154
 155   return realcount;
 156 }
 157
 158 static void
 159 impl_content_stream_close (PortableServer_Servant servant,
 160                            CORBA_Environment * ev)
 161 {
 162   GIOStatus status;
 163   GError *err;
 164   SpiContentStream *stream =
 165     SPI_CONTENT_STREAM (bonobo_object_from_servant (servant));
 166   if (stream && stream->gio)
 167     {
 168       status = g_io_channel_shutdown (stream->gio, TRUE, &err);
 169       g_io_channel_unref (stream->gio);
 170     }
 171   if (err)
 172     g_free (err);
 173 }
 174
 175 static void
 176 spi_content_stream_class_init (SpiContentStreamClass * klass)
 177 {
 178   POA_Accessibility_ContentStream__epv *epv = &klass->epv;
 179   GObjectClass *object_class = (GObjectClass *) klass;
 180
 181   epv->seek = impl_content_stream_seek;
 182   epv->read = impl_content_stream_read;
 183   epv->close = impl_content_stream_close;
 184
 185   object_class->dispose = spi_content_stream_dispose;
 186 }
 187
 188
 189 static void
 190 spi_content_stream_init (SpiContentStream * stream)
 191 {
 192 }
 193
 194
 195 BONOBO_TYPE_FUNC_FULL (SpiContentStream,
 196                        Accessibility_ContentStream,
 197                        BONOBO_TYPE_OBJECT, spi_content_stream)
 198      static AtkStreamableContent
 199        *get_streamable_from_servant (PortableServer_Servant servant)
 200 {
 201   SpiBase *object = SPI_BASE (bonobo_object_from_servant (servant));
 202   g_return_val_if_fail (object != NULL, NULL);
 203   g_return_val_if_fail (ATK_IS_STREAMABLE_CONTENT (object->gobj), NULL);
 204   return ATK_STREAMABLE_CONTENT (object->gobj);
 205 }
 206
 207 /*
 208  * CORBA Accessibility::StreamableContent::getContentTypes method implementation
 209  */
 210 static Accessibility_StringSeq *
 211 impl_accessibility_streamable_get_content_types (PortableServer_Servant
 212                                                  servant,
 213                                                  CORBA_Environment * ev)
 214 {
 215   Accessibility_StringSeq *typelist = Accessibility_StringSeq__alloc ();
 216   AtkStreamableContent *streamable = get_streamable_from_servant (servant);
 217   int n_types, i;
 218
 219   typelist->_length = typelist->_maximum = 0;
 220
 221   g_return_val_if_fail (streamable != NULL, typelist);
 222
 223   n_types = atk_streamable_content_get_n_mime_types (streamable);
 224
 225   if (n_types)
 226     {
 227       typelist->_length = typelist->_maximum = n_types;
 228       typelist->_buffer = Accessibility_StringSeq_allocbuf (n_types);
 229       for (i = 0; i < n_types; ++i)
 230         {
 231           const gchar *mimetype =
 232             atk_streamable_content_get_mime_type (streamable, i);
 233           typelist->_buffer[i] = CORBA_string_dup (mimetype ? mimetype : "");
 234         }
 235     }
 236   return typelist;
 237 }
 238
 239 /*
 240  * CORBA Accessibility::StreamableContent::getContent method implementation
 241  */
 242 static Bonobo_Stream
 243 impl_accessibility_streamable_get_content (PortableServer_Servant servant,
 244                                            const CORBA_char * content_type,
 245                                            CORBA_Environment * ev)
 246 {
 247   Bonobo_Stream stream;
 248   AtkStreamableContent *streamable = get_streamable_from_servant (servant);
 249   GIOChannel *gio;
 250
 251   g_return_val_if_fail (streamable != NULL, NULL);
 252
 253   gio = atk_streamable_content_get_stream (streamable, content_type);
 254
 255   stream = CORBA_OBJECT_NIL;    /* deprecated,
 256                                  * and it was never implemented,
 257                                  * so don't bother fixing this
 258                                  */
 259   return stream;
 260 }
 261
 262 /*
 263  * CORBA Accessibility::StreamableContent::getStream method implementation
 264  */
 265 static Accessibility_ContentStream
 266 impl_accessibility_streamable_get_stream (PortableServer_Servant servant,
 267                                           const CORBA_char * content_type,
 268                                           CORBA_Environment * ev)
 269 {
 270   SpiContentStream *stream;
 271   AtkStreamableContent *streamable = get_streamable_from_servant (servant);
 272   GIOChannel *gio;
 273
 274   g_return_val_if_fail (streamable != NULL, NULL);
 275
 276   gio = atk_streamable_content_get_stream (streamable, content_type);
 277
 278   stream = spi_content_stream_new (gio);
 279
 280   return bonobo_object_dup_ref (BONOBO_OBJREF (stream), ev);
 281 }
 282
 283 /*
 284  * CORBA Accessibility::StreamableContent::GetURI method implementation
 285  */
 286 static CORBA_string
 287 impl_accessibility_streamable_get_uri (PortableServer_Servant servant,
 288                                        const CORBA_char * content_type,
 289                                        CORBA_Environment * ev)
 290 {
 291   gchar *uri;
 292   AtkStreamableContent *streamable = get_streamable_from_servant (servant);
 293
 294   g_return_val_if_fail (streamable != NULL, NULL);
 295
 296   uri = atk_streamable_content_get_uri (streamable, content_type);
 297
 298   return (uri != NULL ? CORBA_string_dup (uri) : CORBA_string_dup (""));
 299 }
 300
 301 static void
 302 spi_streamable_class_init (SpiStreamableClass * klass)
 303 {
 304   POA_Accessibility_StreamableContent__epv *epv = &klass->epv;
 305   spi_streamable_parent_class = g_type_class_peek_parent (klass);
 306
 307   epv->getContentTypes = impl_accessibility_streamable_get_content_types;
 308   epv->getContent = impl_accessibility_streamable_get_content;
 309   epv->getStream = impl_accessibility_streamable_get_stream;
 310   epv->GetURI = impl_accessibility_streamable_get_uri;
 311 }
 312
 313 static void
 314 spi_streamable_init (SpiStreamable * streamable)
 315 {
 316 }
 317
 318
 319 SpiStreamable *
 320 spi_streamable_interface_new (AtkObject * o)
 321 {
 322   SpiStreamable *retval = g_object_new (SPI_STREAMABLE_TYPE, NULL);
 323
 324   spi_base_construct (SPI_BASE (retval), G_OBJECT (o));
 325
 326   return retval;
 327 }
 328
 329 BONOBO_TYPE_FUNC_FULL (SpiStreamable,
 330                        Accessibility_StreamableContent,
 331                        PARENT_TYPE, spi_streamable)