gtask-factory.c

Go to the documentation of this file.

#include <string.h>

#include <gtask/gtask-factory.h>

/* @{ */

enum {
    PROP_0,
    PROP_APP,
    PROP_PROGRAM,
    PROP_CONN_GROUP
};

static gpointer parent_class;
static GTaskFactory *default_factory = NULL;

static void
gtask_factory_class_init( GTaskFactoryClass *factory );

static void
gtask_factory_init( GTaskFactory *factory );

static void
gtask_factory_dispose( GObject *obj );

static void
gtask_factory_finalize( GObject *obj );

static gchar *
gtask_factory_next_task_id( GTaskFactory *factory );

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

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

static GTaskFactory *
gtask_factory_default( void );

GType gtask_factory_get_type( ) {
    static GType type = 0;

    if( type == 0 ) {
        static const GTypeInfo info = {
            sizeof( GTaskFactoryClass ),
            NULL,   /* base init */
            NULL,   /* base_finalize */
            (GClassInitFunc) gtask_factory_class_init,   /* class_init */
            NULL,   /* class_finalize */
            NULL,   /* class_data */
            sizeof( GTaskFactory ),
            0,      /* n_preallocs */
            (GInstanceInitFunc) gtask_factory_init
        };

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

    return type;
}

static void
gtask_factory_class_init( GTaskFactoryClass *klass ) {
    GObjectClass *gobject_class = G_OBJECT_CLASS( klass );

    parent_class = g_type_class_peek_parent( klass );

    gobject_class->dispose = gtask_factory_dispose;
    gobject_class->finalize = gtask_factory_finalize;
    gobject_class->get_property= gtask_factory_get_property;
    gobject_class->set_property= gtask_factory_set_property;

    g_object_class_install_property( (GObjectClass *) klass,
                                     PROP_PROGRAM,
                                     g_param_spec_string( "program",
                                                          "Program",
                                                          "The name of the program (used as a key in for program preferences, etc).",
                                                                                                                                           "",
                                                          G_PARAM_READWRITE ) );

    g_object_class_install_property( (GObjectClass *) klass,
                                     PROP_APP,
                                     g_param_spec_string( "application",
                                                          "Application",
                                                          "A human readable name of the application.",
                                                                                                                                           "",
                                                          G_PARAM_READWRITE ) );

    g_object_class_install_property( (GObjectClass *) klass,
                                     PROP_CONN_GROUP,
                                     g_param_spec_object( "connection-group",
                                                          "Connection Group",
                                                          "The GTaskConnectionGroup that all objects created through the factory will serialize to by default.",
                                                                                                                                           GTASK_CONNECTION_GROUP_TYPE,
                                                           G_PARAM_READWRITE ) );
}


static void
gtask_factory_init( GTaskFactory *factory ) {
    GTaskFactoryPrivate *private = g_new0( GTaskFactoryPrivate, 1 );

    factory->private = private;

    if( !g_get_application_name( ) )
        private->application = g_string_new( "No Application Name Specified" );
    else
        private->application = g_string_new( g_get_application_name( ) );

    if( !g_get_prgname( ) )
        private->program = g_string_new( "-unspecified-program-" );
    else
        private->program = g_string_new( g_get_prgname( ) );
    private->last_task_id = 0;

    private->dispose_has_run = FALSE;
}

static void
gtask_factory_dispose( GObject *obj ) {
    GTaskFactory *factory = GTASK_FACTORY( obj );

    if( factory->private->dispose_has_run )
        return;

    g_object_unref( factory->private->conn_group );
    factory->private->dispose_has_run = TRUE;

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

static void
gtask_factory_finalize( GObject *obj ) {
    GTaskFactory *factory = GTASK_FACTORY( obj );

    g_string_free( factory->private->application, TRUE );
    g_string_free( factory->private->program, TRUE );
    g_free( factory->private );

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

static void
gtask_factory_set_property( GObject *object,
                            guint param_id,
                            const GValue *value,
                            GParamSpec *pspec  )
{
    GTaskFactory *factory = GTASK_FACTORY( object );

    switch( param_id ) {
        case PROP_APP:
            gtask_factory_set_application( factory, g_value_get_string( value ) );
            break;
        case PROP_PROGRAM:
            gtask_factory_set_program( factory, g_value_get_string( value ) );
            break;
        case PROP_CONN_GROUP:
            gtask_factory_set_connection_group( factory, g_value_get_object( value ) );
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID( object, param_id, pspec );
    }
}

static void
gtask_factory_get_property( GObject *object,
                            guint param_id,
                            GValue *value,
                            GParamSpec *pspec  )
{
    GTaskFactory *factory = GTASK_FACTORY( object );

    switch( param_id ) {
        case PROP_APP:
            g_value_set_string( value, factory->private->application->str );
            break;
        case PROP_PROGRAM:
            g_value_set_string( value, factory->private->program->str );
            break;
        case PROP_CONN_GROUP:
            g_value_set_object( value, factory->private->conn_group );
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID( object, param_id, pspec );
    }
}

GTaskFactory *
gtask_factory_new( ) {
    return g_object_new( GTASK_FACTORY_TYPE, NULL );
}

static GTaskFactory *
gtask_factory_default( void ) {
    if( !default_factory )
        default_factory = gtask_factory_new( );

    return default_factory;
}

GTaskFactory *
gtask_factory_new_with_resources( GTaskConnectionGroup *conn_group,
                                  const gchar *program,
                                  const gchar *application )
{
    GTaskFactory *factory = gtask_factory_new( );

    gtask_factory_set_application( factory, application );
    gtask_factory_set_program( factory, program );
    gtask_factory_set_connection_group( factory, conn_group );

    return factory;
}

GTaskGenericTask *
gtask_factory_create_task( GTaskFactory *factory, gchar *task_type ) {
    GTaskGenericTask *task;
    char             *fact_task_id;
    char             *task_id;

    if( !factory )
        factory = gtask_factory_default( );
    else
        g_return_val_if_fail( GTASK_IS_FACTORY( factory ), NULL );

    if( !task_type )
        task_type = "GTaskGenericTask";

    task = gtask_generic_task_new_with_connection_group( factory->private->conn_group );

    if( strcmp( task_type, "GTaskDownloadTask" ) == 0 ) {
        gtask_generic_task_set_category( task, "Downloads" );
    } else if( strcmp( task_type, "GTaskPrintTask" ) == 0 ) {
        gtask_generic_task_set_category( task, "Print Jobs" );
    } else {
        gtask_generic_task_set_category( task, "Unspecified" );
    }

    fact_task_id = gtask_factory_next_task_id( factory );

    task_id = g_strdup_printf( "%s-%s", gtask_factory_get_program( factory ),
                                        fact_task_id );

    gtask_generic_task_set_id( task, task_id );
    gtask_generic_task_set_application( task, factory->private->application->str );

    g_free( fact_task_id );
    g_free( task_id );

    return task;
}

static gchar *
gtask_factory_next_task_id( GTaskFactory *factory ) {
    g_return_val_if_fail( GTASK_IS_FACTORY( factory ), "" );

    return g_strdup_printf( "%d", factory->private->last_task_id++ );
}

const gchar *
gtask_factory_get_program( GTaskFactory *factory ) {
    if( !factory )
        factory = gtask_factory_default( );
    else
        g_return_val_if_fail( GTASK_IS_FACTORY( factory ), "" );

    return factory->private->program->str;
}

void
gtask_factory_set_program( GTaskFactory *factory, const char *program ) {
    if( !factory )
        factory = gtask_factory_default( );
    else
        g_return_if_fail( GTASK_IS_FACTORY( factory ) );

    g_return_if_fail( program != NULL );

    g_string_assign( factory->private->program, program );

    g_object_notify( (GObject *) factory, "program" );
}

const gchar *
gtask_factory_get_application( GTaskFactory *factory ) {
    if( !factory )
        factory = gtask_factory_default( );
    else
        g_return_val_if_fail( GTASK_IS_FACTORY( factory ), "" );

    return factory->private->application->str;
}

void
gtask_factory_set_application( GTaskFactory *factory,
                               const char   *application )
{
    if( !factory )
        factory = gtask_factory_default( );
    else
        g_return_if_fail( GTASK_IS_FACTORY( factory ) );

    g_return_if_fail( application != NULL );

    g_string_assign( factory->private->application, application );

    g_object_notify( (GObject *) factory, "application" );
}

GTaskConnectionGroup *
gtask_factory_get_connection_group( GTaskFactory *factory ) {
    if( !factory )
        factory = gtask_factory_default( );
    else
        g_return_val_if_fail( GTASK_IS_FACTORY( factory ), NULL );

    g_return_val_if_fail( !factory->private->dispose_has_run, NULL );

    return factory->private->conn_group;
}

void
gtask_factory_set_connection_group( GTaskFactory         *factory,
                                    GTaskConnectionGroup *conn_group ) {
    g_return_if_fail( GTASK_IS_CONNECTION_GROUP( conn_group ) );

    if( !factory )
        factory = gtask_factory_default( );
    else
        g_return_if_fail( GTASK_IS_FACTORY( factory ) );

    g_return_if_fail( !factory->private->dispose_has_run );

    if( factory->private->conn_group )
        g_object_unref( factory->private->conn_group );

    g_object_ref( conn_group );

    factory->private->conn_group = conn_group;

    g_object_notify( (GObject *) factory, "connection-group" );
}

/* @} */

---