diff options
Diffstat (limited to 'atk-adaptor/streamablecontent-adaptor.c')
| -rw-r--r-- | atk-adaptor/streamablecontent-adaptor.c | 316 |
1 files changed, 316 insertions, 0 deletions
diff --git a/atk-adaptor/streamablecontent-adaptor.c b/atk-adaptor/streamablecontent-adaptor.c new file mode 100644 index 0000000..8b3d40b --- /dev/null +++ b/atk-adaptor/streamablecontent-adaptor.c @@ -0,0 +1,316 @@ +/* + * AT-SPI - Assistive Technology Service Provider Interface + * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap) * + * Copyright 2001, 2002 Sun Microsystems Inc., + * Copyright 2001, 2002 Ximian, Inc. + * + * 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. + */ + +/* streamablecontent.c : implements the StreamableContent interface */ + +#include <config.h> +#include <stdio.h> +#include <string.h> + +#include <libspi/component.h> +#include <libspi/streamablecontent.h> + +/* Our parent Gtk object type */ +#define PARENT_TYPE SPI_TYPE_BASE + +/* A pointer to our parent object class */ +static GObjectClass *spi_streamable_parent_class; + +#define SPI_CONTENT_STREAM_TYPE (spi_content_stream_get_type ()) +#define SPI_CONTENT_STREAM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SPI_CONTENT_STREAM_TYPE, SpiContentStream)) +#define SPI_CONTENT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), SPI_CONTENT_STREAM_TYPE, SpiContentStreamClass)) +#define SPI_IS_CONTENT_STREAM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SPI_CONTENT_STREAM_TYPE)) +#define SPI_IS_CONTENT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SPI_CONTENT_STREAM_TYPE)) + +typedef struct _SpiContentStream SpiContentStream; +typedef struct _SpiContentStreamClass SpiContentStreamClass; + +struct _SpiContentStream { + BonoboObject parent; + GIOChannel *gio; +}; + +struct _SpiContentStreamClass { + BonoboObjectClass parent_class; + POA_Accessibility_ContentStream__epv epv; +}; + +GType spi_content_stream_get_type (void); + +static SpiContentStream* +spi_content_stream_new (GIOChannel *gio) +{ + SpiContentStream *new_stream = g_object_new (SPI_CONTENT_STREAM_TYPE, NULL); + new_stream->gio = gio; + return new_stream; +} + +static void +spi_content_stream_dispose (GObject *o) +{ + if (SPI_IS_CONTENT_STREAM (o)) + { + SpiContentStream *stream = SPI_CONTENT_STREAM (o); + if (stream->gio) g_io_channel_unref (stream->gio); + } +} + +static CORBA_long +impl_content_stream_seek (PortableServer_Servant servant, + const CORBA_long offset, + const Accessibility_ContentStream_SeekType whence, + CORBA_Environment *ev) +{ + SpiContentStream *stream = SPI_CONTENT_STREAM (bonobo_object_from_servant(servant)); + if (stream && stream->gio) + { + GError *err; + GSeekType seektype = G_SEEK_SET; + switch (whence) { + case Accessibility_ContentStream_SEEK_CURRENT: + seektype = G_SEEK_CUR; + break; + case Accessibility_ContentStream_SEEK_END: + seektype = G_SEEK_END; + break; + } + if (g_io_channel_seek_position (stream->gio, (gint64) offset, + seektype, &err) == G_IO_STATUS_NORMAL) + return offset; + else + return -1; + } + else + return -1; +} + +static CORBA_long +impl_content_stream_read (PortableServer_Servant servant, + const CORBA_long count, + Accessibility_ContentStream_iobuf** buffer, + CORBA_Environment *ev) +{ + SpiContentStream *stream = SPI_CONTENT_STREAM (bonobo_object_from_servant(servant)); + CORBA_long realcount = 0; + + if (stream && stream->gio) + { + gchar *gbuf = NULL; + GIOStatus status; + GError *err = NULL; + + /* read the giochannel and determine the actual bytes read...*/ + if (count != -1) { + gbuf = g_malloc (count+1); + status = g_io_channel_read_chars (stream->gio, gbuf, count, &realcount, &err); + } + else + status = g_io_channel_read_to_end (stream->gio, &gbuf, &realcount, &err); + + if (status == G_IO_STATUS_NORMAL || status == G_IO_STATUS_EOF) + { + *buffer = Bonobo_Stream_iobuf__alloc (); + CORBA_sequence_set_release (*buffer, TRUE); + + (*buffer)->_buffer = CORBA_sequence_CORBA_octet_allocbuf (realcount); + (*buffer)->_length = realcount; + + g_memmove ((*buffer)->_buffer, gbuf, realcount); + } + + g_free (gbuf); + } + + return realcount; +} + +static void +impl_content_stream_close (PortableServer_Servant servant, + CORBA_Environment *ev) +{ + GIOStatus status; + GError *err; + SpiContentStream *stream = SPI_CONTENT_STREAM (bonobo_object_from_servant(servant)); + if (stream && stream->gio) { + status = g_io_channel_shutdown (stream->gio, TRUE, &err); + g_io_channel_unref (stream->gio); + } + if (err) g_free (err); +} + +static void +spi_content_stream_class_init (SpiContentStreamClass *klass) +{ + POA_Accessibility_ContentStream__epv *epv = &klass->epv; + GObjectClass * object_class = (GObjectClass *) klass; + + epv->seek = impl_content_stream_seek; + epv->read = impl_content_stream_read; + epv->close = impl_content_stream_close; + + object_class->dispose = spi_content_stream_dispose; +} + + +static void +spi_content_stream_init (SpiContentStream *stream) +{ +} + + +BONOBO_TYPE_FUNC_FULL (SpiContentStream, + Accessibility_ContentStream, + BONOBO_TYPE_OBJECT, + spi_content_stream) + +static AtkStreamableContent * +get_streamable_from_servant (PortableServer_Servant servant) +{ + SpiBase *object = SPI_BASE (bonobo_object_from_servant (servant)); + g_return_val_if_fail (object != NULL, NULL); + g_return_val_if_fail (ATK_IS_STREAMABLE_CONTENT(object->gobj), NULL); + return ATK_STREAMABLE_CONTENT (object->gobj); +} + +/* + * CORBA Accessibility::StreamableContent::getContentTypes method implementation + */ +static Accessibility_StringSeq* +impl_accessibility_streamable_get_content_types (PortableServer_Servant servant, + CORBA_Environment *ev) +{ + Accessibility_StringSeq *typelist = Accessibility_StringSeq__alloc (); + AtkStreamableContent *streamable = get_streamable_from_servant (servant); + int n_types, i; + + typelist->_length = typelist->_maximum = 0; + + g_return_val_if_fail (streamable != NULL, typelist); + + n_types = atk_streamable_content_get_n_mime_types (streamable); + + if (n_types) + { + typelist->_length = typelist->_maximum = n_types; + typelist->_buffer = Accessibility_StringSeq_allocbuf (n_types); + for (i = 0; i < n_types; ++i) { + const gchar *mimetype = atk_streamable_content_get_mime_type (streamable, i); + typelist->_buffer[i] = CORBA_string_dup (mimetype ? mimetype : ""); + } + } + return typelist; +} + +/* + * CORBA Accessibility::StreamableContent::getContent method implementation + */ +static Bonobo_Stream +impl_accessibility_streamable_get_content (PortableServer_Servant servant, + const CORBA_char * content_type, + CORBA_Environment *ev) +{ + Bonobo_Stream stream; + AtkStreamableContent *streamable = get_streamable_from_servant (servant); + GIOChannel *gio; + + g_return_val_if_fail (streamable != NULL, NULL); + + gio = atk_streamable_content_get_stream (streamable, content_type); + + stream = CORBA_OBJECT_NIL; /* deprecated, + * and it was never implemented, + * so don't bother fixing this + */ + return stream; +} + +/* + * CORBA Accessibility::StreamableContent::getStream method implementation + */ +static Accessibility_ContentStream +impl_accessibility_streamable_get_stream (PortableServer_Servant servant, + const CORBA_char * content_type, + CORBA_Environment *ev) +{ + SpiContentStream *stream; + AtkStreamableContent *streamable = get_streamable_from_servant (servant); + GIOChannel *gio; + + g_return_val_if_fail (streamable != NULL, NULL); + + gio = atk_streamable_content_get_stream (streamable, content_type); + + stream = spi_content_stream_new (gio); + + return bonobo_object_dup_ref (BONOBO_OBJREF (stream), ev); +} + +/* + * CORBA Accessibility::StreamableContent::getURI method implementation + */ +static CORBA_string +impl_accessibility_streamable_get_uri (PortableServer_Servant servant, + const CORBA_char * content_type, + CORBA_Environment *ev) +{ + gchar *uri; + AtkStreamableContent *streamable = get_streamable_from_servant (servant); + + g_return_val_if_fail (streamable != NULL, NULL); + + uri = atk_streamable_content_get_uri (streamable, content_type); + + return (uri != NULL ? CORBA_string_dup (uri) : CORBA_string_dup ("")); +} + +static void +spi_streamable_class_init (SpiStreamableClass *klass) +{ + POA_Accessibility_StreamableContent__epv *epv = &klass->epv; + spi_streamable_parent_class = g_type_class_peek_parent (klass); + + epv->getContentTypes = impl_accessibility_streamable_get_content_types; + epv->getContent = impl_accessibility_streamable_get_content; + epv->getStream = impl_accessibility_streamable_get_stream; + epv->getURI = impl_accessibility_streamable_get_uri; +} + +static void +spi_streamable_init (SpiStreamable *streamable) +{ +} + + +SpiStreamable * +spi_streamable_interface_new (AtkObject *o) +{ + SpiStreamable *retval = g_object_new (SPI_STREAMABLE_TYPE, NULL); + + spi_base_construct (SPI_BASE (retval), G_OBJECT(o)); + + return retval; +} + +BONOBO_TYPE_FUNC_FULL (SpiStreamable, + Accessibility_StreamableContent, + PARENT_TYPE, + spi_streamable) |