gtask-file.c

Go to the documentation of this file.

#include <string.h>

#include <gtask/gtask-file.h>

/* @{ */

enum {
    C_PROP_0,
    C_PROP_URI,
    C_PROP_MIME_TYPE,
    C_PROP_THUMBNAIL_URI,
    C_PROP_DESCRIPTION,
    C_PROP_COMPLETED
};

static gpointer parent_class;

static void
gtask_file_class_init( GTaskFileClass *klass );

static void
gtask_file_init( GTaskFile *gtask );

static void
gtask_file_finalize( GObject *obj );


static void
gtask_file_set_property( GObject *object,
                         guint param_id,
                         const GValue *value,
                         GParamSpec *pspec );

static void
gtask_file_get_property( GObject *object,
                         guint param_id,
                         GValue *value,
                         GParamSpec *pspec );

GType gtask_file_get_type( ) {
    static GType type = 0;

    if( type == 0 ) {
        static const GTypeInfo info = {
            sizeof( GTaskFileClass ),
            NULL,   /* base_init */
            NULL,   /* base_finalize */
            (GClassInitFunc) gtask_file_class_init,  /* class_init */
            NULL,   /* class_finalize */
            NULL,   /* class_data */
            sizeof( GTaskFile ),
            0,      /* n_preallocs */
            (GInstanceInitFunc) gtask_file_init
        };

        type = g_type_register_static( G_TYPE_OBJECT,
                                       "GTaskFile",
                                       &info,
                                       0 );
    }

    return type;
}

static void
gtask_file_init( GTaskFile *file ) {
    GTaskFilePrivate *private = g_new0( GTaskFilePrivate, 1 );

    file->private = private;

    private->uri = g_string_new( NULL );
    private->thumbnail_uri = g_string_new( NULL );
    private->description = g_string_new( NULL );
    private->mime_type = g_string_new( NULL );
    private->completed = FALSE;
}

static void
gtask_file_class_init( GTaskFileClass *klass ) {
    GObjectClass *gobject_class = G_OBJECT_CLASS( klass );

    parent_class = g_type_class_peek_parent( klass );

    gobject_class->finalize = gtask_file_finalize;

    gobject_class->get_property = gtask_file_get_property;
    gobject_class->set_property = gtask_file_set_property;

    g_object_class_install_property( gobject_class,
                                     C_PROP_URI,
                                     g_param_spec_string( "uri",
                                                          "URIApplication",
                                                          "The uri of the file.",
                                                          "",
                                                          G_PARAM_READWRITE ) );

    g_object_class_install_property( gobject_class,
                                     C_PROP_THUMBNAIL_URI,
                                     g_param_spec_string( "thumbnail-uri",
                                                          "Thumbnail URI",
                                                          "The URI of a thumbnail to be used while the GTaskFile has yet to be completed",
                                                          "",
                                                          G_PARAM_READWRITE ) );

    g_object_class_install_property( gobject_class,
                                     C_PROP_MIME_TYPE,
                                     g_param_spec_string( "mime-type",
                                                          "Mime Type",
                                                          "The mime type of the file.",
                                                          "",
                                                          G_PARAM_READWRITE ) );

    g_object_class_install_property( gobject_class,
                                     C_PROP_DESCRIPTION,
                                     g_param_spec_string( "description",
                                                          "Description",
                                                          "An optional human readable description of the file. This is generally used instead of printing out the uri.",
                                                          "",
                                                          G_PARAM_READWRITE ) );

    g_object_class_install_property( gobject_class,
                                     C_PROP_COMPLETED,
                                     g_param_spec_boolean( "completed",
                                                           "Completed",
                                                           "Whether or not all task interactions with this file have been completed.",
                                                           FALSE,
                                                           G_PARAM_READWRITE ) );
}

static void
gtask_file_finalize( GObject *obj ) {
    GTaskFile        *task = GTASK_FILE( obj );
    GTaskFilePrivate *private = task->private;

    g_string_free( private->uri, TRUE );

    g_string_free( private->thumbnail_uri, TRUE );

    g_string_free( private->mime_type, TRUE );

    g_string_free( private->description, TRUE );

    g_free( task->private );

    if( G_OBJECT_CLASS( parent_class )->finalize )
        G_OBJECT_CLASS( parent_class )->finalize( obj );
}

static void
gtask_file_set_property( GObject *object,
                         guint param_id,
                         const GValue *value,
                         GParamSpec *pspec )
{
    GTaskFile *file = GTASK_FILE( object );

    switch( param_id ) {
        case C_PROP_URI:
            gtask_file_set_uri( file, g_value_get_string( value ) );
            break;
        case C_PROP_THUMBNAIL_URI:
            gtask_file_set_thumbnail_uri( file, g_value_get_string( value ) );
            break;
        case C_PROP_MIME_TYPE:
            gtask_file_set_mime_type( file, g_value_get_string( value ) );
            break;
        case C_PROP_DESCRIPTION:
            gtask_file_set_description( file, g_value_get_string( value ) );
            break;
        case C_PROP_COMPLETED:
            gtask_file_set_completed( file, g_value_get_boolean( value ) );
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID( object, param_id, pspec );
    }
}

static void
gtask_file_get_property( GObject *object,
                         guint param_id,
                         GValue *value,
                         GParamSpec *pspec )
{
    GTaskFile        *file = GTASK_FILE( object );
    GTaskFilePrivate *private = file->private;

    switch( param_id ) {
        case C_PROP_URI:
            g_value_set_string( value, private->uri->str );
            break;
        case C_PROP_THUMBNAIL_URI:
            g_value_set_string( value, private->thumbnail_uri->str );
            break;
        case C_PROP_MIME_TYPE:
            g_value_set_string( value, private->mime_type->str );
            break;
        case C_PROP_DESCRIPTION:
            g_value_set_string( value, private->description->str );
            break;
        case C_PROP_COMPLETED:
            g_value_set_boolean( value, private->completed );
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID( object, param_id, pspec );
    }
}


GTaskFile *
gtask_file_new( ) {
    return g_object_new( GTASK_FILE_TYPE, NULL );
}

GTaskFile *
gtask_file_new_with_properties( const char *uri,
                                const char *mime_type,
                                const char *thumbnail_uri,
                                const char *description )
{
    GTaskFile *file = gtask_file_new( );

    gtask_file_set_uri( file, uri );
    gtask_file_set_mime_type( file, mime_type );
    gtask_file_set_thumbnail_uri( file, thumbnail_uri );
    gtask_file_set_description( file, description );

    return file;
}

void
gtask_file_set_uri( GTaskFile *file, const char *uri ) {
    g_return_if_fail( GTASK_IS_FILE( file ) );
    g_return_if_fail( uri != NULL );

    g_string_assign( file->private->uri, uri );

    g_object_notify( (GObject *) file, "uri" );
}

const char *
gtask_file_get_uri( GTaskFile *file ) {
    g_return_val_if_fail( GTASK_IS_FILE( file ), "" );

    return file->private->uri->str;
}

void
gtask_file_set_thumbnail_uri( GTaskFile *file, const char *thumbnail_uri ) {
    g_return_if_fail( GTASK_IS_FILE( file ) );
    g_return_if_fail( thumbnail_uri != NULL );

    g_string_assign( file->private->thumbnail_uri, thumbnail_uri );

    g_object_notify( (GObject *) file, "thumbnail-uri" );
}

const char *
gtask_file_get_thumbnail_uri( GTaskFile *file ) {
    g_return_val_if_fail( GTASK_IS_FILE( file ), "" );

    return file->private->thumbnail_uri->str;
}

void
gtask_file_set_mime_type( GTaskFile *file, const char *mime_type ) {
    g_return_if_fail( GTASK_IS_FILE( file ) );
    g_return_if_fail( mime_type != NULL );

    g_string_assign( file->private->mime_type, mime_type );

    g_object_notify( (GObject *) file, "mime-type" );
}

const char *
gtask_file_get_mime_type( GTaskFile *file ) {
    g_return_val_if_fail( GTASK_IS_FILE( file ), "" );

    return file->private->mime_type->str;
}

void
gtask_file_set_description( GTaskFile *file, const char *description ) {
    g_return_if_fail( GTASK_IS_FILE( file ) );
    g_return_if_fail( description != NULL );

    g_string_assign( file->private->description, description );

    g_object_notify( (GObject *) file, "description" );
}

const char *
gtask_file_get_description( GTaskFile *file ) {
    g_return_val_if_fail( GTASK_IS_FILE( file ), "" );

    return file->private->description->str;
}

void
gtask_file_set_completed( GTaskFile *file, gboolean completed ) {
    g_return_if_fail( GTASK_IS_FILE( file ) );

    file->private->completed = completed;

    g_object_notify( (GObject *) file, "completed" );
}

gboolean
gtask_file_get_completed( GTaskFile *file ) {
    g_return_val_if_fail( GTASK_IS_FILE( file ), FALSE );

    return file->private->completed;
}

---