sd_capacity.c

Go to the documentation of this file.

/*
 * File Name: sd_capacity.c
 */

/*
 * This file is part of settings.
 *
 * settings is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * settings 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >
#ifndef WIN32
#include <sys/stat.h>
#include <sys/statfs.h>
#include <sys/types.h>
#include <sys/wait.h>
#endif

#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <sched.h>

#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <glib.h>

#include <libergtk/ergtk.h>

#include "i18n.h"
#include "log.h"
#include "ipc.h"
#include "settings.h"
#include "settings_utils.h"
#include "settings_style.h"
#include "sd_capacity.h"


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------
static gboolean g_sd_card_mounted = FALSE;  // SD card currently mounted or not

static GtkWidget* g_sdcapacity_window = NULL ; 
static GtkWidget* g_capacity_bar = NULL ; 
static GtkWidget* g_used_space_label = NULL ; 
static GtkWidget* g_free_space_label = NULL ;

static volatile gboolean g_is_updating = FALSE;

//============================================================================
// Local Function Definitions
//============================================================================

static GtkWidget* create_sdcapacity_widgets         (GtkBox* parent);
static void update_sd_widgets();

static void init_widgets_with_settings          (void);
static void on_listview_row_activated ( GtkTreeView       *view,
                                        GtkTreePath       *path,
                                        GtkTreeViewColumn *column,
                                        gpointer          user_data );

static void on_listview_navigate_cursor ( erGtkListView         *er_listview,
        erGtkListViewKeyPress keycode,
        gpointer              user_data );

static gboolean on_focus_in(GtkWidget* widget, gpointer data );
static gboolean on_focus_out(GtkWidget* widget, gpointer data );

//============================================================================
// Functions Implementation
//============================================================================

GtkWidget* create_sdcapacity_window(GtkWidget* parent)
{
    // create top window
    GtkWidget* top_window = parent;
    gtk_window_maximize(GTK_WINDOW(top_window));
    gtk_window_set_resizable(GTK_WINDOW(top_window), FALSE);
    gtk_container_set_border_width(GTK_CONTAINER(top_window),WINDOW_BORDER_PADDING  );
    gtk_window_set_modal(GTK_WINDOW(top_window), TRUE);

    // top level vbox (vboxtop)
    GtkWidget* vboxtop = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(top_window), vboxtop);

    // add header container the title and subtitle of this settings page
    create_title(GTK_VBOX(vboxtop), _("Settings"), _("SD Card Information"));
    
    // add the back/exit bar below the title 
    GtkWidget* view = create_settingsview();
    gtk_box_pack_start(GTK_BOX(vboxtop), view, FALSE, FALSE,0 ); 
    g_signal_connect(view, "row-activated", G_CALLBACK(on_listview_row_activated), NULL ) ;
    g_signal_connect(view, "navigate-cursor", G_CALLBACK(on_listview_navigate_cursor), NULL ) ;
    g_signal_connect(view, "focus-in-event", G_CALLBACK(on_focus_in), NULL );
    g_signal_connect(view, "focus-out-event", G_CALLBACK(on_focus_out), NULL );

    // add an alignment below the exit bar
    GtkWidget* alignment = gtk_alignment_new(0, 0, 1.0, 0.0);
    gtk_container_add(GTK_CONTAINER(vboxtop), alignment);

    // introdude a frame in the alignment
    GtkWidget* frame = gtk_frame_new(NULL);
    gtk_widget_set_name(frame, "irex-margins-frame");
    gtk_container_add(GTK_CONTAINER(alignment), frame);
    gtk_container_set_border_width(GTK_CONTAINER(frame), 3);

    // alignment in frame 
    GtkWidget* alignment2 = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
    gtk_container_add(GTK_CONTAINER(frame), alignment2);
    gtk_alignment_set_padding(GTK_ALIGNMENT(alignment2),
                              WINDOW_TOP_ALT_PADDING,
                              WINDOW_BOTTOM_PADDING,
                              WINDOW_H_PADDING,
                              WINDOW_H_PADDING);
   
    // vbox in alignment2
    GtkWidget* innervbox = gtk_vbox_new(FALSE, SMALL_SPACING);
    gtk_container_add(GTK_CONTAINER(alignment2), innervbox);
    
    // The margin settings section.
    create_sdcapacity_widgets(GTK_BOX(innervbox));

    // Update widget with current settings.
    init_widgets_with_settings();

    gtk_widget_grab_focus(view);
    
    gtk_widget_show_all(top_window);

    g_sdcapacity_window = top_window;

    return top_window;
}


void load_sdcapacity_settings()
{
    ;
}


void save_sdcapacity_settings()
{
    ;
}


void sd_card_mounted(gboolean is_mounted)
{
    LOGPRINTF("entry: is_mounted [%d]", is_mounted);
    
    while (g_is_updating == TRUE) {
        sched_yield();
    }

    g_is_updating = TRUE;
    
    // remember card state
    g_sd_card_mounted = is_mounted;

    // show free space

    if (g_sdcapacity_window != NULL)
    {
        update_sd_widgets();
    }
    g_is_updating = FALSE;
}

//============================================================================
// Local Functions Implementation
//============================================================================

static void on_listview_row_activated ( GtkTreeView       *view,
                                        GtkTreePath       *path,
                                        GtkTreeViewColumn *column,
                                        gpointer          user_data )
{
    main_quit();
    return;
}

static void on_listview_navigate_cursor ( erGtkListView         *er_listview,
                                          erGtkListViewKeyPress keycode,
                                          gpointer              user_data )
{
    GtkTreeSelection* my_selection = gtk_tree_view_get_selection((GtkTreeView*) er_listview);
    g_assert( my_selection != NULL ) ;

    // determine new cursor position
    switch (keycode)
    {
        case ERGTK_LIST_VIEW_PRESS_SHORT_DOWN:
        case ERGTK_LIST_VIEW_PRESS_LONG_DOWN:
            //gtk_widget_grab_focus(GTK_WIDGET(g_calibrate_button));
            gtk_tree_selection_unselect_all(my_selection);
            break;
        default:
            LOGPRINTF("illegal erGtkListViewKeyPress [%d]", keycode);
            ;  // ignore
            break;
    }

}

static GtkWidget* create_sdcapacity_widgets(GtkBox* parent)
{
    // Top level vbox.
    GtkWidget* top_level_vbox = gtk_vbox_new(FALSE, 3);
    gtk_box_pack_start(parent, top_level_vbox, FALSE, FALSE, 0);

    // The label "Card Storage Capacity".
    GtkWidget* label = gtk_label_new(_("SD Card Memory"));
    gtk_widget_set_name(label, "irex-normal-text");
    gtk_widget_set_size_request(label, -1, -1);
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
    gtk_box_pack_start(GTK_BOX(top_level_vbox), label, FALSE, FALSE, 6);

    // The GtkProgressBar.
    g_capacity_bar = gtk_progress_bar_new();
    // gtk_widget_set_name(g_capacity_bar, "capacity");
    gtk_box_pack_start(GTK_BOX(top_level_vbox), g_capacity_bar, FALSE, FALSE, 6);

    // The label "Used Space:"
    g_used_space_label = gtk_label_new(NULL);
    gtk_widget_set_name(g_used_space_label, "irex-normal-text");
    gtk_widget_set_size_request(g_used_space_label, -1, -1);
    gtk_misc_set_alignment(GTK_MISC(g_used_space_label), 0.0, 0.0);
    gtk_box_pack_start(GTK_BOX(top_level_vbox), g_used_space_label, FALSE, FALSE, 6);

    // The label "Free Space:"
    g_free_space_label = gtk_label_new(NULL);
    gtk_widget_set_name(g_free_space_label, "irex-normal-text");
    gtk_widget_set_size_request(g_free_space_label, -1, -1);
    gtk_misc_set_alignment(GTK_MISC(g_free_space_label), 0.0, 0.0);
    gtk_box_pack_start(GTK_BOX(top_level_vbox), g_free_space_label, FALSE, FALSE, 6);


    return top_level_vbox;
}

static void init_widgets_with_settings()
{
   
    if ( g_is_updating == FALSE )
    {
        g_is_updating = TRUE;
        update_sd_widgets();
        g_is_updating = FALSE; 
    }

}

static gboolean on_focus_in(GtkWidget* widget, gpointer data )
{
    g_assert(widget != NULL ) ;
    ergtk_list_view_set_cursor( ERGTK_LIST_VIEW(widget), 0); // row = 0;
    return FALSE;
}

static gboolean on_focus_out(GtkWidget* widget, gpointer data )
{
    g_assert(widget != NULL ) ;
    GtkTreeSelection* my_selection = gtk_tree_view_get_selection((GtkTreeView*) widget);
    g_assert( my_selection != NULL ) ;
    gtk_tree_selection_unselect_all(my_selection);
    return FALSE;
}

static void update_sd_widgets()
{
#ifndef WIN32
    int           rc;
    struct statfs stat;
    long          used_blocks;
    gdouble       usage;
    gchar*        message = NULL ; 

    LOGPRINTF("entry");

    rc = statfs(SD_CARD_MOUNTPOINT, &stat);

    if ( rc == 0  &&  g_sd_card_mounted )
    {
        // update filesystem usage
        used_blocks = stat.f_blocks - stat.f_bfree;
        usage       = (gdouble)used_blocks / (gdouble)stat.f_blocks;
        /* TRANSLATORS: '%ld' is the percentage of remaining free space on the SD card 
         *              Example: "95% remaining"
         *              Note: '%%' creates literally a %-sign
         */
        gchar* progress_text  = g_strdup_printf(_("%ld%% remaining"), (long)(100-(100*usage)));
        gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(g_capacity_bar), usage);
        gtk_widget_show(g_capacity_bar);
        gtk_progress_bar_set_text(GTK_PROGRESS_BAR(g_capacity_bar), progress_text);
        g_free(progress_text);

        /* TRANSLATORS: '%ld' is the total number of Megabytes
         *              Example: "Total: 1024 MB"
         */
         message = g_strdup_printf(_("Total: %ld MB"), stat.f_blocks / (1048576 / stat.f_bsize));
        gtk_label_set_label(GTK_LABEL(g_used_space_label), message);
        gtk_widget_show(g_used_space_label);
        g_free(message);

        /* TRANSLATORS: '%ld' is the number of Megabytes available
         *              Example: "Available: 560 MB"
         */
         message = g_strdup_printf(_("Available: %ld MB"), stat.f_bfree / (1048576 / stat.f_bsize));
        gtk_label_set_label(GTK_LABEL(g_free_space_label), message);
        gtk_widget_show(g_free_space_label);
        g_free(message);
    }
    else
    {
        /* TRANSLATORS: N/A stands for not applicable
         */
         gtk_label_set_label(GTK_LABEL(g_used_space_label), _("Total: N/A"));
        gtk_widget_show(g_capacity_bar);
        gtk_label_set_label(GTK_LABEL(g_free_space_label), _("Available: N/A"));
        gtk_widget_show(g_free_space_label);

        gchar* progress_text  = g_strdup_printf(_("Unknown remaining"));
        gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(g_capacity_bar), 0.0);
        gtk_progress_bar_set_text(GTK_PROGRESS_BAR(g_capacity_bar), progress_text);
        g_free(progress_text);

        gtk_widget_show(g_capacity_bar);
    }

#endif
}