Exemplo n.º 1
0
void show_yearly_stats()
{
    GtkWidget *window;
    GtkWidget *sw;

    if (yearly_tree)
        return;

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    sw = gtk_scrolled_window_new (NULL, NULL);
    yearly_tree = gtk_tree_view_new ();

    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(window), 640, 480);
    gtk_window_set_title(GTK_WINDOW(window), _("Yearly Statistics"));
    gtk_container_set_border_width(GTK_CONTAINER(window), 5);
    GTK_WINDOW(window)->allow_shrink = TRUE;
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);

    gtk_container_add (GTK_CONTAINER (sw), yearly_tree);
    gtk_container_add (GTK_CONTAINER (window), sw);

    /* Display the yearly statistics on top level
     * Monthly statistics are available by expanding a year */
    init_tree();
    update_yearly_stats();

    g_signal_connect (G_OBJECT (window), "key_press_event", G_CALLBACK (key_press_event), NULL);
    g_signal_connect (G_OBJECT (window), "delete-event", G_CALLBACK (on_delete), NULL);
    gtk_widget_show_all(window);
}
Exemplo n.º 2
0
YearlyStatisticsModel::YearlyStatisticsModel(QObject* parent)
{
	columns = COLUMNS;
	update_yearly_stats();
}
Exemplo n.º 3
0
static void process_all_dives(struct dive *dive, struct dive **prev_dive)
{
    int idx;
    struct dive *dp;
    struct tm tm;
    int current_year = 0;
    int current_month = 0;
    int year_iter = 0;
    int month_iter = 0;
    int prev_month = 0, prev_year = 0;
    unsigned int size;

    *prev_dive = NULL;
    memset(&stats, 0, sizeof(stats));
    if (dive_table.nr > 0) {
        stats.shortest_time.seconds = dive_table.dives[0]->duration.seconds;
        stats.min_depth.mm = dive_table.dives[0]->maxdepth.mm;
        stats.selection_size = dive_table.nr;
    }

    /* allocate sufficient space to hold the worst
     * case (one dive per year or all dives during
     * one month) for yearly and monthly statistics*/

    if (stats_yearly != NULL) {
        free(stats_yearly);
        free(stats_monthly);
    }
    size = sizeof(stats_t) * (dive_table.nr + 1);
    stats_yearly = malloc(size);
    stats_monthly = malloc(size);
    if (!stats_yearly || !stats_monthly)
        return;
    memset(stats_yearly, 0, size);
    memset(stats_monthly, 0, size);

    /* this relies on the fact that the dives in the dive_table
     * are in chronological order */
    for (idx = 0; idx < dive_table.nr; idx++) {
        dp = dive_table.dives[idx];
        if (dp->when == dive->when) {
            /* that's the one we are showing */
            if (idx > 0)
                *prev_dive = dive_table.dives[idx-1];
        }
        process_dive(dp, &stats);

        /* yearly statistics */
        utc_mkdate(dp->when, &tm);
        if (current_year == 0)
            current_year = tm.tm_year + 1900;

        if (current_year != tm.tm_year + 1900) {
            current_year = tm.tm_year + 1900;
            process_dive(dp, &(stats_yearly[++year_iter]));
        } else
            process_dive(dp, &(stats_yearly[year_iter]));

        stats_yearly[year_iter].selection_size++;
        stats_yearly[year_iter].period = current_year;

        /* monthly statistics */
        if (current_month == 0) {
            current_month = tm.tm_mon + 1;
        } else {
            if (current_month != tm.tm_mon + 1)
                current_month = tm.tm_mon + 1;
            if (prev_month != current_month || prev_year != current_year)
                month_iter++;
        }

        process_dive(dp, &(stats_monthly[month_iter]));
        stats_monthly[month_iter].selection_size++;
        stats_monthly[month_iter].period = current_month;
        prev_month = current_month;
        prev_year = current_year;
    }
    if (yearly_tree)
        update_yearly_stats();
}