Commit a0d4440b authored by Elliot Lee's avatar Elliot Lee

In notify_location_change, send progress back (because the Bonobo control,



* src/ntl-view-bonobo-control.c: In notify_location_change, send
progress back (because the Bonobo control, which might be the
content view, can't do it).

* src/ntl-view-bonobo-subdoc.c: As above, plus don't use
PersistFile interface, plus use bonobo-stream-vfs instead of
bonobo-stream-fs.

* src/ntl-uri-map.c: If no content type is found, default to text/plain.

* libnautilus/bonobo-stream-vfs.[ch], libnautilus/Makefile.am:
Initial implementation of bonobo streams in terms of Gnome VFS.
parent 48be0110
2000-02-09 Elliot Lee <sopwith@redhat.com>
* src/ntl-view-bonobo-control.c: In notify_location_change, send
progress back (because the Bonobo control, which might be the
content view, can't do it).
* src/ntl-view-bonobo-subdoc.c: As above, plus don't use
PersistFile interface, plus use bonobo-stream-vfs instead of
bonobo-stream-fs.
* src/ntl-uri-map.c: If no content type is found, default to text/plain.
* libnautilus/bonobo-stream-vfs.[ch], libnautilus/Makefile.am:
Initial implementation of bonobo streams in terms of Gnome VFS.
2000-02-09 Maciej Stachowiak <mjs@eazel.com>
* src/ntl-meta-view.c: To avoid a bug which caused parts of the
......
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* libnautilus: A library for nautilus view implementations.
*
* Copyright (C) 2000 Red Hat, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Author: Elliot Lee <sopwith@redhat.com>, based on bonobo-stream-fs.c by Miguel de Icaza.
* bonobo-stream-vfs.c: Gnome VFS-based Stream implementation
*/
#include <config.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <gnome.h>
#include "bonobo-stream-vfs.h"
#include <errno.h>
static BonoboStreamClass *bonobo_stream_vfs_parent_class;
static CORBA_long
vfs_write (BonoboStream *stream, const Bonobo_Stream_iobuf *buffer,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
GnomeVFSResult res;
GnomeVFSFileSize written = 0;
res = gnome_vfs_write(sfs->fd, buffer->_buffer, buffer->_length, &written);
if (res != GNOME_VFS_OK) {
CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Storage_NameExists, NULL);
return 0;
}
return written;
}
static CORBA_long
vfs_read (BonoboStream *stream, CORBA_long count,
Bonobo_Stream_iobuf ** buffer,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
CORBA_octet *data;
GnomeVFSResult res;
GnomeVFSFileSize nread = 0;
*buffer = Bonobo_Stream_iobuf__alloc ();
CORBA_sequence_set_release (*buffer, TRUE);
data = CORBA_sequence_CORBA_octet_allocbuf (count);
res = gnome_vfs_read(sfs->fd, data, count, &nread);
if (res == GNOME_VFS_OK){
(*buffer)->_buffer = data;
(*buffer)->_length = nread;
} else
CORBA_free (data);
sfs->got_eof = (res == GNOME_VFS_ERROR_EOF);
return nread;
}
static CORBA_long
vfs_seek (BonoboStream *stream,
CORBA_long ofvfset, Bonobo_Stream_SeekType whence,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
GnomeVFSSeekPosition gwhence;
GnomeVFSFileSize pos;
GnomeVFSResult res;
switch(whence)
{
case Bonobo_Stream_SEEK_CUR:
gwhence = GNOME_VFS_SEEK_CURRENT;
break;
case Bonobo_Stream_SEEK_END:
gwhence = GNOME_VFS_SEEK_END;
break;
default:
gwhence = GNOME_VFS_SEEK_START;
break;
}
res = gnome_vfs_seek(sfs->fd, gwhence, ofvfset);
if(res != GNOME_VFS_OK)
{
pos = -1;
goto out;
}
res = gnome_vfs_tell(sfs->fd, &pos);
if(res != GNOME_VFS_OK)
{
pos = -1;
goto out;
}
out:
sfs->got_eof = (res == GNOME_VFS_ERROR_EOF);
return pos;
}
static void
vfs_truncate (BonoboStream *stream,
const CORBA_long new_size,
CORBA_Environment *ev)
{
g_warning ("vfs_truncate NYI");
}
static void
vfs_copy_to (BonoboStream *stream,
const CORBA_char *dest,
const CORBA_long bytes,
CORBA_long *read_bytes,
CORBA_long *written_bytes,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
CORBA_octet *data;
CORBA_unsigned_long more = bytes;
GnomeVFSHandle *fd_out;
GnomeVFSResult res;
GnomeVFSFileSize rsize, wsize;
#define READ_CHUNK_SIZE 65536
data = CORBA_sequence_CORBA_octet_allocbuf (READ_CHUNK_SIZE);
*read_bytes = 0;
*written_bytes = 0;
res = gnome_vfs_create(&fd_out, dest, GNOME_VFS_OPEN_WRITE, FALSE, 0666);
if(res != GNOME_VFS_OK)
return;
do {
res = gnome_vfs_read(sfs->fd, data, MIN(READ_CHUNK_SIZE, more), &rsize);
sfs->got_eof = (res == GNOME_VFS_ERROR_EOF);
if (res == GNOME_VFS_OK) {
*read_bytes += rsize;
more -= rsize;
res = gnome_vfs_write(fd_out, data, rsize, &wsize);
if (res == GNOME_VFS_OK)
*written_bytes += wsize;
else
break;
} else
rsize = 0;
} while(more > 0 && rsize > 0);
gnome_vfs_close(fd_out);
}
static void
vfs_commit (BonoboStream *stream,
CORBA_Environment *ev)
{
g_warning ("Commit NI");
}
static void
vfs_close (BonoboStream *stream,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
if (gnome_vfs_close (sfs->fd) != GNOME_VFS_OK)
g_warning ("Close failed");
sfs->fd = NULL;
sfs->got_eof = FALSE;
}
static CORBA_boolean
vfs_eos (BonoboStream *stream,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
return sfs->got_eof;
}
static CORBA_long
vfs_length (BonoboStream *stream,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
GnomeVFSFileInfo fi;
CORBA_long retval;
gnome_vfs_file_info_init(&fi);
if(gnome_vfs_get_file_info_from_handle(sfs->fd, &fi, GNOME_VFS_FILE_INFO_DEFAULT, NULL) != GNOME_VFS_OK)
return 0;
retval = fi.size;
gnome_vfs_file_info_clear(&fi);
return retval;
}
static void
bonobo_stream_vfs_class_init (BonoboStreamVFSClass *klass)
{
BonoboStreamClass *sclass = BONOBO_STREAM_CLASS (klass);
bonobo_stream_vfs_parent_class = gtk_type_class (bonobo_stream_get_type ());
sclass->write = vfs_write;
sclass->read = vfs_read;
sclass->seek = vfs_seek;
sclass->truncate = vfs_truncate;
sclass->copy_to = vfs_copy_to;
sclass->commit = vfs_commit;
sclass->close = vfs_close;
sclass->eos = vfs_eos;
sclass->length = vfs_length;
}
/**
* bonobo_stream_vfs_get_type:
*
* Returns the GtkType for the BonoboStreamVFS class.
*/
GtkType
bonobo_stream_vfs_get_type (void)
{
static GtkType type = 0;
if (!type){
GtkTypeInfo info = {
"IDL:GNOME/StreamVFS:1.0",
sizeof (BonoboStreamVFS),
sizeof (BonoboStreamVFSClass),
(GtkClassInitFunc) bonobo_stream_vfs_class_init,
(GtkObjectInitFunc) NULL,
NULL, /* reserved 1 */
NULL, /* reserved 2 */
(GtkClassInitFunc) NULL
};
type = gtk_type_unique (bonobo_stream_get_type (), &info);
}
return type;
}
/**
* bonobo_stream_vfs_construct:
* @stream: The BonoboStreamVFS object to initialize.
* @corba_stream: The CORBA server which implements the BonoboStreamVFS service.
*
* This function initializes an object of type BonoboStreamVFS using the
* provided CORBA server @corba_stream.
*
* Returns the constructed BonoboStreamVFS @stream.
*/
BonoboStream *
bonobo_stream_vfs_construct (BonoboStreamVFS *stream,
Bonobo_Stream corba_stream)
{
g_return_val_if_fail (stream != NULL, NULL);
g_return_val_if_fail (BONOBO_IS_STREAM (stream), NULL);
g_return_val_if_fail (corba_stream != CORBA_OBJECT_NIL, NULL);
bonobo_object_construct (BONOBO_OBJECT (stream), corba_stream);
return BONOBO_STREAM (stream);
}
static Bonobo_Stream
create_bonobo_stream_vfs (BonoboObject *object)
{
POA_Bonobo_Stream *servant;
CORBA_Environment ev;
servant = (POA_Bonobo_Stream *) g_new0 (BonoboObjectServant, 1);
servant->vepv = &bonobo_stream_vepv;
CORBA_exception_init (&ev);
POA_Bonobo_Stream__init ((PortableServer_Servant) servant, &ev);
if (ev._major != CORBA_NO_EXCEPTION){
g_free (servant);
CORBA_exception_free (&ev);
return CORBA_OBJECT_NIL;
}
CORBA_exception_free (&ev);
return (Bonobo_Stream) bonobo_object_activate_servant (object, servant);
}
static BonoboStream *
bonobo_stream_create (GnomeVFSHandle *fd)
{
BonoboStreamVFS *stream_vfs;
Bonobo_Stream corba_stream;
stream_vfs = gtk_type_new (bonobo_stream_vfs_get_type ());
if (stream_vfs == NULL)
return NULL;
stream_vfs->fd = fd;
corba_stream = create_bonobo_stream_vfs (
BONOBO_OBJECT (stream_vfs));
if (corba_stream == CORBA_OBJECT_NIL){
gtk_object_destroy (GTK_OBJECT (stream_vfs));
return NULL;
}
return bonobo_stream_vfs_construct (stream_vfs, corba_stream);
}
/**
* bonobo_stream_vfs_open:
* @uri: The path to the file to be opened.
* @mode: The mode with which the file should be opened.
*
* Creates a new BonoboStream object for the filename specified by
* @path.
*/
BonoboStream *
bonobo_stream_vfs_open (const char *uri, Bonobo_Storage_OpenMode mode)
{
GnomeVFSHandle *fd = NULL;
GnomeVFSResult res;
g_return_val_if_fail (uri != NULL, NULL);
if (mode == Bonobo_Storage_READ)
res = gnome_vfs_open(&fd, uri, GNOME_VFS_OPEN_READ);
else if (mode == Bonobo_Storage_WRITE)
res = gnome_vfs_open(&fd, uri, GNOME_VFS_OPEN_WRITE);
if(fd && res == GNOME_VFS_OK)
return bonobo_stream_create (fd);
else
return NULL;
}
/**
* bonobo_stream_vfs_create:
* @uri: The path to the file to be opened.
*
* Creates a new BonoboStreamVFS object which is bound to the file
* specified by @path.
*
* When data is read out of or written into the returned BonoboStream
* object, the read() and write() operations are mapped to the
* corresponding operations on the specified file.
*
* Returns: the constructed BonoboStream object which is bound to the specified file.
*/
BonoboStream *
bonobo_stream_vfs_create (const char *uri)
{
GnomeVFSHandle *fd = NULL;
GnomeVFSResult res;
g_return_val_if_fail (uri != NULL, NULL);
res = gnome_vfs_create(&fd, uri, GNOME_VFS_OPEN_READ|GNOME_VFS_OPEN_WRITE, FALSE, 0666);
if(fd && res == GNOME_VFS_OK)
return bonobo_stream_create (fd);
else
return NULL;
}
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* libnautilus: A library for nautilus view implementations.
*
* Copyright (C) 2000 Red Hat, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Author: Elliot Lee <sopwith@redhat.com>, based on bonobo-stream-fs.h by Miguel de Icaza.
* bonobo-stream-vfs.h: Gnome VFS-based Stream interface
*/
#ifndef _BONOBO_STREAM_VFS_H_
#define _BONOBO_STREAM_VFS_H_
#include <bonobo/bonobo-stream.h>
#include <libgnomevfs/gnome-vfs.h>
BEGIN_GNOME_DECLS
struct _BonoboStreamVFS;
typedef struct _BonoboStreamVFS BonoboStreamVFS;
#ifndef _BONOBO_STORAGE_VFS_H_
struct _BonoboStorageVFS;
typedef struct _BonoboStorageVFS BonoboStorageVFS;
#endif
#define BONOBO_STREAM_VFS_TYPE (bonobo_stream_vfs_get_type ())
#define BONOBO_STREAM_VFS(o) (GTK_CHECK_CAST ((o), BONOBO_STREAM_VFS_TYPE, BonoboStreamVFS))
#define BONOBO_STREAM_VFS_CLASS(k) (GTK_CHECK_CLASS_CAST((k), BONOBO_STREAM_VFS_TYPE, BonoboStreamVFSClass))
#define BONOBO_IS_STREAM_VFS(o) (GTK_CHECK_TYPE ((o), BONOBO_STREAM_VFS_TYPE))
#define BONOBO_IS_STREAM_VFS_CLASS(k) (GTK_CHECK_CLASS_TYPE ((k), BONOBO_STREAM_VFS_TYPE))
typedef struct _BonoboStreamVFSPrivate BonoboStreamVFSPrivate;
struct _BonoboStreamVFS {
BonoboStream stream;
GnomeVFSURI *uri;
GnomeVFSHandle *fd;
gboolean got_eof;
BonoboStreamVFSPrivate *priv;
};
typedef struct {
BonoboStreamClass parent_class;
} BonoboStreamVFSClass;
GtkType bonobo_stream_vfs_get_type (void);
BonoboStream *bonobo_stream_vfs_open (const char *uri, Bonobo_Storage_OpenMode mode);
BonoboStream *bonobo_stream_vfs_create (const char *uri);
BonoboStream *bonobo_stream_vfs_construct (BonoboStreamVFS *stream,
Bonobo_Stream corba_stream);
END_GNOME_DECLS
#endif /* _BONOBO_STREAM_VFS_H_ */
......@@ -24,6 +24,7 @@ BUILT_SOURCES=$(nautilus_idl_sources)
libnautilusincludedir=$(includedir)/libnautilus
libnautilusinclude_HEADERS= \
bonobo-stream-vfs.h \
gdk-extensions.h \
gnome-icon-container-dnd.h \
gnome-icon-container-private.h \
......@@ -50,6 +51,7 @@ libnautilusinclude_HEADERS= \
ntl-view-frame.h
libnautilus_la_SOURCES=$(nautilus_idl_sources) \
bonobo-stream-vfs.c \
gdk-extensions.c \
gnome-icon-container-dnd.c \
gnome-icon-container.c \
......
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* libnautilus: A library for nautilus view implementations.
*
* Copyright (C) 2000 Red Hat, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Author: Elliot Lee <sopwith@redhat.com>, based on bonobo-stream-fs.c by Miguel de Icaza.
* bonobo-stream-vfs.c: Gnome VFS-based Stream implementation
*/
#include <config.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <gnome.h>
#include "bonobo-stream-vfs.h"
#include <errno.h>
static BonoboStreamClass *bonobo_stream_vfs_parent_class;
static CORBA_long
vfs_write (BonoboStream *stream, const Bonobo_Stream_iobuf *buffer,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
GnomeVFSResult res;
GnomeVFSFileSize written = 0;
res = gnome_vfs_write(sfs->fd, buffer->_buffer, buffer->_length, &written);
if (res != GNOME_VFS_OK) {
CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
ex_Bonobo_Storage_NameExists, NULL);
return 0;
}
return written;
}
static CORBA_long
vfs_read (BonoboStream *stream, CORBA_long count,
Bonobo_Stream_iobuf ** buffer,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
CORBA_octet *data;
GnomeVFSResult res;
GnomeVFSFileSize nread = 0;
*buffer = Bonobo_Stream_iobuf__alloc ();
CORBA_sequence_set_release (*buffer, TRUE);
data = CORBA_sequence_CORBA_octet_allocbuf (count);
res = gnome_vfs_read(sfs->fd, data, count, &nread);
if (res == GNOME_VFS_OK){
(*buffer)->_buffer = data;
(*buffer)->_length = nread;
} else
CORBA_free (data);
sfs->got_eof = (res == GNOME_VFS_ERROR_EOF);
return nread;
}
static CORBA_long
vfs_seek (BonoboStream *stream,
CORBA_long ofvfset, Bonobo_Stream_SeekType whence,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
GnomeVFSSeekPosition gwhence;
GnomeVFSFileSize pos;
GnomeVFSResult res;
switch(whence)
{
case Bonobo_Stream_SEEK_CUR:
gwhence = GNOME_VFS_SEEK_CURRENT;
break;
case Bonobo_Stream_SEEK_END:
gwhence = GNOME_VFS_SEEK_END;
break;
default:
gwhence = GNOME_VFS_SEEK_START;
break;
}
res = gnome_vfs_seek(sfs->fd, gwhence, ofvfset);
if(res != GNOME_VFS_OK)
{
pos = -1;
goto out;
}
res = gnome_vfs_tell(sfs->fd, &pos);
if(res != GNOME_VFS_OK)
{
pos = -1;
goto out;
}
out:
sfs->got_eof = (res == GNOME_VFS_ERROR_EOF);
return pos;
}
static void
vfs_truncate (BonoboStream *stream,
const CORBA_long new_size,
CORBA_Environment *ev)
{
g_warning ("vfs_truncate NYI");
}
static void
vfs_copy_to (BonoboStream *stream,
const CORBA_char *dest,
const CORBA_long bytes,
CORBA_long *read_bytes,
CORBA_long *written_bytes,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
CORBA_octet *data;
CORBA_unsigned_long more = bytes;
GnomeVFSHandle *fd_out;
GnomeVFSResult res;
GnomeVFSFileSize rsize, wsize;
#define READ_CHUNK_SIZE 65536
data = CORBA_sequence_CORBA_octet_allocbuf (READ_CHUNK_SIZE);
*read_bytes = 0;
*written_bytes = 0;
res = gnome_vfs_create(&fd_out, dest, GNOME_VFS_OPEN_WRITE, FALSE, 0666);
if(res != GNOME_VFS_OK)
return;
do {
res = gnome_vfs_read(sfs->fd, data, MIN(READ_CHUNK_SIZE, more), &rsize);
sfs->got_eof = (res == GNOME_VFS_ERROR_EOF);
if (res == GNOME_VFS_OK) {
*read_bytes += rsize;
more -= rsize;
res = gnome_vfs_write(fd_out, data, rsize, &wsize);
if (res == GNOME_VFS_OK)
*written_bytes += wsize;
else
break;
} else
rsize = 0;
} while(more > 0 && rsize > 0);
gnome_vfs_close(fd_out);
}
static void
vfs_commit (BonoboStream *stream,
CORBA_Environment *ev)
{
g_warning ("Commit NI");
}
static void
vfs_close (BonoboStream *stream,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
if (gnome_vfs_close (sfs->fd) != GNOME_VFS_OK)
g_warning ("Close failed");
sfs->fd = NULL;
sfs->got_eof = FALSE;
}
static CORBA_boolean
vfs_eos (BonoboStream *stream,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
return sfs->got_eof;
}
static CORBA_long
vfs_length (BonoboStream *stream,
CORBA_Environment *ev)
{
BonoboStreamVFS *sfs = BONOBO_STREAM_VFS (stream);
GnomeVFSFileInfo fi;
CORBA_long retval;
gnome_vfs_file_info_init(&fi);
if(gnome_vfs_get_file_info_from_handle(sfs->fd, &fi, GNOME_VFS_FILE_INFO_DEFAULT, NULL) != GNOME_VFS_OK)
return 0;