gtask-window.c

Go to the documentation of this file.

#include <gtask-ui/gtask-window.h>

#include <gtk/gtkvbox.h>
#include <gtk/gtklabel.h>

#include <gconf/gconf-client.h>

#include "gtask-internals.h"

/* @{ */

#define GTASK_GCONF_ROOT_KEY "/apps/gtask"

enum {
    COL_VIEW_ID,
    COL_VIEW_NAME,
    N_VIEW_COLUMNS
};

static gpointer parent_class;

static void
gtask_window_init( GTaskWindow *window, gpointer g_class );

static void
gtask_window_class_init( GTaskWindowClass *klass );

static void
gtask_window_destroy( GtkObject *obj );

static void
gtask_window_finalize( GObject *obj );

/* callbacks */
void
filter_text_clear( GtkButton *button, gpointer data );

void
filter_text_changed( GtkEntry *text, gpointer data );

void
view_mode_changed( GObject *widget, gpointer data );

GType gtask_window_get_type( void ) {
    static GType type = 0;

    if( type == 0 ) {
        static const GTypeInfo info = {
            sizeof( GTaskWindowClass ),
            NULL,   /* base init */
            NULL,   /* base_finalize */
            (GClassInitFunc) gtask_window_class_init,   /* class_init */
            NULL,   /* class_finalize */
            NULL,   /* class_data */
            sizeof( GTaskWindow ),
            0,      /* n_preallocs */
            (GInstanceInitFunc) gtask_window_init
        };
    
        type = g_type_register_static( GTK_TYPE_WINDOW,
                                       "GTaskWindow",
                                       &info,
                                       0 );
    }

    return type;
}

static void
gtask_window_init_ui( GTaskWindow *window ) {
    GTaskWindowPrivate *private = window->private;

    GtkWidget          *vbox = gtk_vbox_new( FALSE, 6 );
    GtkWidget          *header_hbox = gtk_hbox_new( FALSE, 6 );

    GtkWidget          *view_hbox = gtk_hbox_new( FALSE, 6 );
    GtkWidget          *filter_hbox = gtk_hbox_new( FALSE, 6 );

    GtkWidget          *app_label;
    GtkWidget          *app_icon;

    GtkWidget          *view_as_label;
    GtkWidget          *view_as_combo;

    GtkWidget          *filter_label;
    GtkWidget          *filter_entry;
    GtkWidget          *filter_clear_button;

    GtkListStore       *list_store;
    GtkTreeIter         iter;
    GtkCellRenderer    *rend;

    char               *title;

    private->task_view = gtask_view_new( );

    gtk_container_set_border_width( GTK_CONTAINER( vbox ), 12 );

    gtk_box_pack_start( (GtkBox *) vbox, header_hbox, FALSE, FALSE, 0 );
    gtk_box_pack_start( (GtkBox *) vbox, view_hbox, FALSE, FALSE, 0 );
    gtk_box_pack_start( (GtkBox *) vbox, GTK_WIDGET( private->task_view ), TRUE, TRUE, 0 );
    gtk_box_pack_start( (GtkBox *) vbox, filter_hbox, FALSE, FALSE, 0 );

    /* set up the header */
    app_icon = gtk_image_new( );
    app_label = gtk_label_new( NULL );

    title = g_strdup_printf( "<span weight=\"bold\" size=\"x-large\">%s</span>",
                             private->window_title );
    
    gtk_label_set_markup( GTK_LABEL( app_label ), title );
    
    g_free( title );

    gtk_misc_set_alignment( GTK_MISC( app_label ), 0, 0.5 );

    gtk_box_pack_start( GTK_BOX( header_hbox ), app_icon, FALSE, FALSE, 0 );
    gtk_box_pack_start( GTK_BOX( header_hbox ), app_label, TRUE, TRUE, 0 );

    view_as_label = gtk_label_new( "View As:" );
    gtk_misc_set_alignment( GTK_MISC( view_as_label ), 0, 0.5 );

    list_store = gtk_list_store_new( N_VIEW_COLUMNS,
                                     GTASK_VIEW_MODE_TYPE,
                                     G_TYPE_STRING );

    gtk_list_store_append( list_store, &iter );
    gtk_list_store_set( list_store, &iter,
                        COL_VIEW_ID, GTASK_VIEW_MODE_BASIC,
                        COL_VIEW_NAME, "Basic View", 
                        -1 );

    gtk_list_store_append( list_store, &iter );
    gtk_list_store_set( list_store, &iter,
                        COL_VIEW_ID, GTASK_VIEW_MODE_LIST,
                        COL_VIEW_NAME, "List View", 
                        -1 );

    view_as_combo = gtk_combo_box_new_with_model( GTK_TREE_MODEL( list_store ) );

    g_signal_connect( G_OBJECT( view_as_combo ),
                      "changed",
                      (GCallback) view_mode_changed,
                      window );

    rend = gtk_cell_renderer_text_new( );
    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( view_as_combo ), rend, TRUE );
    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( view_as_combo ), rend, 
                                    "text", COL_VIEW_NAME,
                                    NULL );

    private->view_combo = GTK_COMBO_BOX( view_as_combo );

    gtk_box_pack_start( GTK_BOX( view_hbox ), view_as_label, TRUE, TRUE, 0 );
    gtk_box_pack_start( GTK_BOX( view_hbox ), view_as_combo, FALSE, FALSE, 0 );

    /* set up the footer */
    filter_label = gtk_label_new( "Filter" );
    filter_entry = gtk_entry_new( );
    filter_clear_button = gtk_button_new_with_label( "Show All" );

    private->filter_entry = GTK_ENTRY( filter_entry );

    g_signal_connect( filter_clear_button,
                      "clicked",
                      G_CALLBACK( filter_text_clear ),
                      filter_entry );

    g_signal_connect( filter_entry,
                      "changed",
                      G_CALLBACK( filter_text_changed ),
                      window );

    gtk_box_pack_start( GTK_BOX( filter_hbox ), filter_label, FALSE, FALSE, 0 );
    gtk_box_pack_start( GTK_BOX( filter_hbox ), filter_entry, TRUE, TRUE, 0 );
    gtk_box_pack_start( GTK_BOX( filter_hbox ), filter_clear_button, FALSE, FALSE, 0 );

    gtk_container_add( GTK_CONTAINER( window ), vbox );
}

static char *
gtask_window_get_gconf_root( GTaskWindow *window ) {
    const char *prgname = g_get_prgname( );
    char       *root;

    g_debug( "IN: gtask_window_get_gconf_root" );

    if( prgname ) {
        root = g_strdup_printf( "%s/windows/%s/%s",
                                GTASK_GCONF_ROOT_KEY,
                                prgname,
                                window->private->name );
    } else {
        /* just in case someone has mistakenly not set their application
         * name, I suppose we should give them a chance, meh */
        root = g_strdup_printf( "%s/default_window/%s",
                                GTASK_GCONF_ROOT_KEY,
                                window->private->name );

    }

    g_debug( "LEAVING: gtask_window_get_gconf_root" );

    return root;
}

static void
gtask_window_restore_preferences( GTaskWindow *window ) {
    GConfClient *client = window->private->gconf_client;

    char *top_level = gtask_window_get_gconf_root( window );

    GString *key = g_string_new( NULL );

    gint x, y;
    gint width, height;

    char *filter_string;
    gint view_mode;

    g_debug( "IN: gtask_window_restore_preferences" );

    g_string_printf( key, "%s/x", top_level );
    x = gconf_client_get_int( client, key->str, NULL );

    g_string_printf( key, "%s/y", top_level );
    y = gconf_client_get_int( client, key->str, NULL );

    g_string_printf( key, "%s/width", top_level );
    width = gconf_client_get_int( client, key->str, NULL );

    g_string_printf( key, "%s/height", top_level );
    height = gconf_client_get_int( client, key->str, NULL );

    g_string_printf( key, "%s/filter_string", top_level );
    filter_string = gconf_client_get_string( client, key->str, NULL );

    g_string_printf( key, "%s/view_mode", top_level );
    view_mode = gconf_client_get_int( client, key->str, NULL );

    if( x > 0 && y > 0 )
        gtk_window_move( GTK_WINDOW( window ), x, y );

    if( width > 0 && height > 0 )
        gtk_window_resize( GTK_WINDOW( window ), width, height );

    if( view_mode != GTASK_VIEW_MODE_BASIC && view_mode != GTASK_VIEW_MODE_LIST )
        view_mode = GTASK_VIEW_MODE_BASIC;

    //gtk_combo_box_set_active( window->private->view_combo, view_mode );

    gtask_view_set_view_mode( window->private->task_view, view_mode );

    g_string_free( key, TRUE );
    g_free( top_level );

    g_debug( "LEAVING: gtask_window_restore_preferences" );
}

static void
gtask_window_save_preferences( GTaskWindow *window ) {
    GTaskWindowPrivate *private = window->private;
    GConfClient        *client;
    char               *top_level;
    GTaskViewMode       view_mode;

    GString *key = g_string_new( NULL );

    g_debug( "IN: gtask_window_save_preferences" );

    if( !private->save_prefs ) {
        g_debug( "LEAVING: gtask_window_save_preferences w/o save" );
        return;
    }

    client = private->gconf_client;
    top_level = gtask_window_get_gconf_root( window );

    g_string_printf( key, "%s/x", top_level );
    gconf_client_set_int( client, key->str, private->x, NULL );

    g_string_printf( key, "%s/y", top_level );
    gconf_client_set_int( client, key->str, private->y, NULL );

    g_string_printf( key, "%s/width", top_level );
    gconf_client_set_int( client, key->str, private->width, NULL );

    g_string_printf( key, "%s/height", top_level );
    gconf_client_set_int( client, key->str, private->height, NULL );

    view_mode = gtask_view_get_view_mode( private->task_view );

    g_string_printf( key, "%s/view_mode", top_level );
    gconf_client_set_int( client, key->str, view_mode, NULL );

    private->save_prefs = FALSE;

    g_string_free( key, TRUE );
    g_free( top_level );

    g_debug( "LEAVING: gtask_window_save_preferences w/ save" );
}

static gboolean
gtask_window_save_prefs_timeout( gpointer data ) {
    GTaskWindow *window = GTASK_WINDOW( data );

    g_debug( "IN: gtask_window_save_prefs_timeout" );

    gtask_window_save_preferences( window );

    window->private->save_prefs_timeout = 0;

    g_debug( "LEAVING: gtask_window_save_prefs_timeout" );

    return FALSE;
}

static void
gtask_window_queue_prefs_save( GTaskWindow *window ) {
    GTaskWindowPrivate *private = window->private;

    g_warning( "IN: gtask_window_queue_prefs_save" );

    if( !private->save_prefs_timeout ) {
        private->save_prefs_timeout = g_timeout_add( 5000,
                                                gtask_window_save_prefs_timeout,
                                                window );
    }

    g_warning( "LEAVING: gtask_window_queue_prefs_save" );
}

static gboolean
gtask_window_configure_event( GtkWidget *widget,
                              GdkEventConfigure *config,
                              gpointer data ) {
    GTaskWindow        *window = GTASK_WINDOW( widget );
    GTaskWindowPrivate *private = window->private;

    g_warning( "IN: gtask_window_configure_event" );

    private->x      = config->x;
    private->y      = config->y;
    private->width  = config->width;
    private->height = config->height;

    private->save_prefs = TRUE;

    gtask_window_queue_prefs_save( window );

    g_warning( "LEAVING: gtask_window_configure_event" );

    return FALSE;
}

static void
gtask_window_init( GTaskWindow *window, gpointer g_class ) {
    GTaskWindowPrivate *private = g_new0( GTaskWindowPrivate, 1 );

    window->private = private;

    private->gconf_client = gconf_client_get_default( );

    private->save_prefs_timeout = 0;
    private->save_prefs = FALSE;

//    gtask_window_init_ui( window );

    g_signal_connect( window,
                      "configure-event",
                      (GCallback) gtask_window_configure_event,
                      NULL );
}

static void
gtask_window_class_init( GTaskWindowClass *klass ) {
    GObjectClass *gobject_class = G_OBJECT_CLASS( klass );
    GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS( klass );

    parent_class = g_type_class_peek_parent( klass );

    gobject_class->finalize = gtask_window_finalize;

    gtk_object_class->destroy = gtask_window_destroy;
}

static void
gtask_window_destroy( GtkObject *obj ) {
    GTaskWindow *window = GTASK_WINDOW( obj );

    gtask_window_save_preferences( window );

    g_object_unref( (GObject *) window->private->gconf_client );

}

static void
gtask_window_finalize( GObject *obj ) {
}


GTaskWindow *
gtask_window_new_with_name( const char *name, const char *window_title ) {
    char *n_window_title;

    GTaskWindow *window = g_object_new( GTASK_WINDOW_TYPE, NULL );

    if( !window_title ) {
        const char *tmp = g_get_application_name( );

        if( !tmp )
            n_window_title = g_strdup( "Application Tasks" );
        else
            n_window_title = g_strdup( tmp );
    } else
        n_window_title = g_strdup( window_title );

    window->private->name = g_strdup( ( name ) ? name : "default" );
    window->private->window_title = n_window_title;

    gtask_window_init_ui( window );

    gtask_window_restore_preferences( window );

    return window;
}

void
gtask_window_add_task( GTaskWindow *window, GTaskGenericTask *task ) {
    g_return_if_fail( GTASK_IS_WINDOW( window ) );
    g_return_if_fail( GTASK_IS_GENERIC_TASK( task ) );

    g_debug( "IN: gtask_window_add_task" );

    gtask_view_add_task( window->private->task_view, task );

    g_debug( "LEAVING: gtask_window_add_task" );
}

GTaskView *
gtask_window_get_view( GTaskWindow *window ) {
    g_return_val_if_fail( GTASK_IS_WINDOW( window ), NULL );

    g_object_ref( window->private->task_view );

    return window->private->task_view;
}

/* callbacks */
void
filter_text_clear( GtkButton *button, gpointer data ) {
    GtkEntry *entry = GTK_ENTRY( data );

    g_debug( "IN: filter_text_clear" );

    gtk_editable_delete_text( GTK_EDITABLE( entry ), 0, -1 );
    
    g_debug( "LEAVING: filter_text_clear" );
}

void
filter_text_changed( GtkEntry *text, gpointer data ) {
    GTaskWindow        *window = GTASK_WINDOW( data );
    GTaskWindowPrivate *private = window->private;

    g_debug( "IN: filter_text_changed" );

    gtask_view_set_filter_string( private->task_view,
                                  gtk_entry_get_text( text ) );

    g_debug( "LEAVING: filter_text_changed" );
}

void
view_mode_changed( GObject *widget, gpointer data ) {
    GTaskWindow   *window = GTASK_WINDOW( data );
    GTaskViewMode  view_mode;
    GtkTreeIter    iter;
    GtkTreeModel  *model;
    GValue         value = { 0, };

    g_debug( "IN: view_mode_changed" );

    if( !gtk_combo_box_get_active_iter( GTK_COMBO_BOX( widget ), &iter ) )
        return;

    window->private->save_prefs = TRUE;

    model = gtk_combo_box_get_model( GTK_COMBO_BOX( widget ) );

    gtk_tree_model_get_value( model, &iter, COL_VIEW_ID, &value );

    view_mode = g_value_get_enum( &value );

    g_value_unset( &value );

    gtask_view_set_view_mode( window->private->task_view, view_mode );

    gtask_window_queue_prefs_save( window );

    g_debug( "LEAVING: view_mode_changed" );
}

/* @} */

---