test_pagebar.c

Go to the documentation of this file.

/**
 * \file test_pagebar.c
 * \brief Test pagebar functions
 */
 
/*
 * This file is part of libergtk.
 *
 * libergtk 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.
 *
 * libergtk 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 <stdlib.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "erGtkPageBar.h"

static GtkWidget *thePagebar;
static gint g_current_page = 0;
static gint g_number_of_pages = 1;

static void on_destroy(GtkWidget * widget, gpointer data)
{
    gtk_main_quit();
}

static gboolean on_configured(GtkWidget * widget,
                              GdkEventConfigure * event, 
                              gpointer user_data)
{
    return FALSE;
}

static void on_page_selected(GtkWidget * widget, gint page, gpointer data)
{
    g_print("page %d has been selected!\n", page);
    g_current_page = page;
}

static gboolean key_release_callback(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
    switch (event->keyval)
    {
        case GDK_KP_Left:
        case GDK_Left:
            g_current_page--;
            break;

        case GDK_KP_Right:
        case GDK_Right:
            g_current_page++;
            break;
        
        case GDK_Page_Up:
            g_current_page = g_current_page + 5;
            break;

        case GDK_Page_Down:
            g_current_page = g_current_page - 5;
            break;

        default:
            return FALSE;
    }
    if (g_current_page > g_number_of_pages)
    {
        g_current_page = g_number_of_pages;
    }
    else if (g_current_page < 0)
    {
        g_current_page = 0;
    }
    gtk_pagebar_set_current_page(GTK_PAGEBAR(data), g_current_page);
    return TRUE;
}

void test_assertions(GtkPagebar * pagebar)
{
    g_print("--- Test assertions ---\n");
    g_print("** The assertions below are expected behavior:");
    gtk_pagebar_set_number_of_pages(NULL, -1);
    gtk_pagebar_set_number_of_pages(pagebar, -1);
    gtk_pagebar_get_number_of_pages(NULL);
    gtk_pagebar_set_current_page(NULL, -1);
    gtk_pagebar_set_current_page(pagebar, -1);
    gtk_pagebar_get_current_page(NULL);
    gtk_pagebar_set_bookmark(NULL, 0);
    gtk_pagebar_set_bookmark(pagebar, 0);
    gtk_pagebar_get_bookmarks(NULL);
    gtk_pagebar_reset(NULL);
    gtk_pagebar_get_minimal_height(NULL);
    g_print("--- End test assertions ---\n\n");
}

int main(int argc, char *argv[])
{
    GtkWidget *window;
    GtkWidget *layout_box;

    unsigned int num_pages = 300;
    unsigned int selected_page = 10;

    if (argc == 3)
    {
        num_pages = atoi(argv[1]);
        selected_page = atoi(argv[2]);
    }
    
    g_current_page = selected_page;
    g_number_of_pages = num_pages;

    /* init threads */
    g_thread_init(NULL);
    gdk_threads_init();
    gdk_threads_enter();
    gtk_init(&argc, &argv);

    // create the main, top level, window 
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

    gtk_window_set_title(GTK_WINDOW(window), "pagebar_test");
    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
    gtk_container_set_border_width(GTK_CONTAINER(window), 0);
    gtk_window_set_modal(GTK_WINDOW(window), TRUE);
    gtk_widget_set_size_request(GTK_WIDGET(window), 1024, 60);

    // Construct layout.
    layout_box = gtk_vbox_new(FALSE, 0);
    thePagebar = gtk_pagebar_new();

    // Test erGtkPageBar assertions
    test_assertions(GTK_PAGEBAR(thePagebar));

    g_signal_connect(G_OBJECT(window), "destroy",
                     G_CALLBACK(on_destroy), thePagebar);
    g_signal_connect(G_OBJECT (window), "key_release_event", 
                     G_CALLBACK (key_release_callback), thePagebar);

    gtk_pagebar_set_number_of_pages(GTK_PAGEBAR(thePagebar), num_pages);
    gtk_pagebar_set_current_page(GTK_PAGEBAR(thePagebar), selected_page);

    // TODO Yehong
    gtk_pagebar_set_bookmark(GTK_PAGEBAR(thePagebar), selected_page);
    gtk_pagebar_set_bookmark(GTK_PAGEBAR(thePagebar), (int)(selected_page/2)+1);
    gtk_pagebar_set_bookmark(GTK_PAGEBAR(thePagebar), (int)(selected_page/4)+1);

    int idx = 0;
    for (; idx < (g_number_of_pages >> 1); ++idx)
    {
        gtk_pagebar_set_bookmark(GTK_PAGEBAR(thePagebar), idx);
    }


    g_signal_connect(G_OBJECT(thePagebar), "pagebar_page_selected",
                     G_CALLBACK(on_page_selected), NULL);

    g_signal_connect(G_OBJECT(window), 
                     "configure-event",
                     G_CALLBACK(on_configured), 
                     thePagebar);

    // gtk_container_add(GTK_CONTAINER(fixedContainer), thePagebar);
    gtk_box_pack_start(GTK_BOX(layout_box), thePagebar, TRUE, TRUE, 0);
    gtk_container_add(GTK_CONTAINER(window), layout_box);

    gtk_widget_show_all(layout_box);
    gtk_widget_show(window);

    // test get bookmarks
    const GArray * bookmarks = gtk_pagebar_get_bookmarks(GTK_PAGEBAR(thePagebar));
    if (bookmarks != NULL)
    {
        g_print("bookmarks number:%d\n", bookmarks->len);
        int i = 0;
        for (; i < bookmarks->len; ++i)
        {
            int mark_page = g_array_index(bookmarks, guint, i);
            g_print("current bookmark:%d\n", mark_page);
        }
    }

    gtk_main();
    gdk_threads_leave();

    return 0;
}