erGtkPageBar.c

Go to the documentation of this file.

/**
 * \file erGtkPageBar.c
 * \brief ereader gtk library - GtkPageBar widget for ereader system
 */
 
/*
 * 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 <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gtk/gtk.h>

#include "erGtkPageBar.h"
#include "erGtkDialogJumpToPage.h"

/* Default settings */
#define PAGEBAR_DEFAULT_PAGE_COUNT              1
#define PAGEBAR_DEFAULT_CURRENT_PAGE            1

#define PAGEBAR_INDICATOR_SPACE                 2
#define PAGEBAR_CPI_SPACE                       2
#define PAGEBAR_CPI_ADJACENT_SPACE              1

#define PAGEBAR_ADJACENT_PAGES_NUM              3

#define PAGEBAR_HORIZONTAL_LINE_WIDTH           2
#define PAGEBAR_INDICATOR_LINE_WIDTH            1
#define PAGEBAR_INDICATOR_LINE_HEIGHT           12

#define PAGEBAR_INDICATOR_COLOR                 0xAAAAAA
#define PAGEBAR_NEXT_PAGE_TEXT_COLOR            0x555555
#define PAGEBAR_LAST_PAGE_TEXT_COLOR            0x555555
 
#define PAGEBAR_BOOKMARK_SENSOR_RANGE           5

#define PAGEBAR_HORIZONTAL_MARGIN               4
#define PAGEBAR_VERTICAL_MARGIN                 0

#define PAGEBAR_MAX_PAGES                       1000000

/* Bitmap index */
typedef enum
{
    BITMAP_CPI = 0,
    BITMAP_CPI_BOOKMARK,
    BITMAP_PREV_CPI,
    BITMAP_PREV_CPI_BOOKMARK,
    BITMAP_SUCC_CPI,
    BITMAP_SUCC_CPI_BOOKMARK,
    BITMAP_BOOKMARK,
    BITMAP_COUNT
} BitmapIndex;

static const char * BITMAP_PATHS[BITMAP_COUNT] =
{
    DATADIR "/pagebar_pagefield_black.png",
    DATADIR "/pagebar_pagefield_black_bookmark.png",
    DATADIR "/pagebar_pagefield_grey.png",
    DATADIR "/pagebar_pagefield_grey_bookmark.png",
    DATADIR "/pagebar_pagefield_white.png",
    DATADIR "/pagebar_pagefield_white_bookmark.png",
    DATADIR "/pagebar_bookmark_black.png",
};

/* Page bar status */
typedef enum
{
    STATUS_NORMAL = 0,
    STATUS_DETAILS,
    STATUS_SHRINK
} PagebarStatus;

struct _GtkPagebar
{
    GtkDrawingArea  drawing_area;
    GdkPixmap       *pixmap;                  ///< The backend pixmap always has the same size as the widget.
    PangoLayout     *pango_layout;            ///< To display the text.
    GdkGC           *own_gc;                  ///< Own gc is used for drawing our lines.

    unsigned int    page_count;               ///< The total page number.
    unsigned int    current_page;             ///< Current page.
    unsigned int    last_selected_page;       ///< Page last selected.

    PagebarStatus   status;                   ///< Page bar status.

    GdkRectangle    cpi_area;                 ///< the area of current page indicator and adjacent pages
                                              ///  it is in pagebar coordination system

    GArray          *bookmarks;

    int             pagebar_width;
    int             pagebar_height;

    int             left_indicator_offset;
    int             right_indicator_offset;

    unsigned int    max_detailed_items;       ///< Max items can be displayed
};

struct _GtkPagebarClass
{
    GtkDrawingAreaClass parent_class;

    // Signal handlers.
    void (*pagebar_page_selected) (GtkPagebar * pagebar, int page);

};

static GtkDrawingAreaClass *g_parent_class = NULL;

typedef struct 
{
    GdkPixbuf       *bitmaps[BITMAP_COUNT];   ///< All pixbufs.

    int             cpi_width;
    int             cpi_height;
    int             page_field_width;
    int             page_field_height;
    int             bookmark_icon_width;
    int             bookmark_icon_height;
} bitmap_data_t;
static const bitmap_data_t g_bitmap_data;

enum 
{
    // signals emitted when the user selects a page, using the page bar
    PAGE_SELECTED,
    LAST_SIGNAL,
};

static gint pagebar_signals[LAST_SIGNAL] = { 0 };

/* gtk widget signal handlers. */
static gboolean on_pagebar_exposed(GtkWidget *, GdkEventExpose *, gpointer);
static gboolean on_pagebar_configured(GtkWidget *, GdkEventConfigure *, gpointer);
static gboolean on_pagebar_button_press_event(GtkWidget *, GdkEventButton *, gpointer);
static gboolean on_pagebar_button_release_event(GtkWidget *, GdkEventButton *, gpointer);

/* gtk pagebar init functions. */
static void gtk_pagebar_class_init(GtkPagebarClass * klass);
static void gtk_pagebar_init(GtkPagebar * pagebar);
static void gtk_pagebar_finalize(GObject *obj);

/* gtk pagebar bitmap helper functions */
static void pagebar_load_bitmaps(void);

/* gtk pagebar bookmark helper functions. */
static int get_bookmark_idx(GtkPagebar * pagebar, const unsigned int page_number);
static gboolean add_bookmark(GtkPagebar * pagebar, const unsigned int page_number);
static gboolean remove_bookmark(GtkPagebar * pagebar, const unsigned int page_number);

/* gtk pagebar calculation helper functions. */
static void pagebar_calculate_cpi(GtkPagebar * pagebar);
static void pagebar_calculate_cpi_overview(GtkPagebar * pagebar);
static void pagebar_calculate_cpi_shrink(GtkPagebar * pagebar);
static void pagebar_calculate_cpi_details(GtkPagebar * pagebar);

/* gtk pagebar drawing helper functions. */
static void gtk_pagebar_draw(GtkPagebar * pagebar);
static void pagebar_draw_details(GtkPagebar * pagebar);
static void pagebar_draw_overview(GtkPagebar * pagebar);

static void pagebar_draw_cpi_overview(GtkPagebar * pagebar);
static void pagebar_draw_cpi_shrink(GtkPagebar * pagebar);

static void pagebar_draw_markers(GtkPagebar * pagebar,
                                 const int bitmap,
                                 GArray *data,
                                 const int adjacent_pages);

/* gtk paggbar hit test function. */
static int pagebar_calibrate_x_of_marker(GtkPagebar * pagebar, const int origin_x,
                                         const int offset);
static int pagebar_get_x_of_marker(GtkPagebar * pagebar, const int page_number,
                                   const int adjacent_pages);

static gboolean pagebar_hit_test_markers(GtkPagebar * pagebar,
                                         int click_x, int click_y);
static void pagebar_hit_test_on_cpi_overview(GtkPagebar * pagebar,
                                             int click_x, int click_y,
                                             int pagebar_width, int pagebar_height);
static void pagebar_hit_test_on_indicator_overview(GtkPagebar * pagebar,
                                                   int click_x, int click_y,
                                                   int pagebar_width, int pagebar_height);
static void pagebar_hit_test_details(GtkPagebar * pagebar,
                                     int click_x, int click_y);
static void pagebar_hit_test_shrink(GtkPagebar * pagebar,
                                    int click_x, int click_y,
                                    int pagebar_width, int pagebar_height);
static void pagebar_transfer_position(const int x, const int y,
                                      int * click_x, int * click_y,
                                      gboolean widget_to_pagebar);
/* gtk pagebar signal emit helper function. */
static int on_current_page_changed(GtkPagebar * pagebar);


GType gtk_pagebar_get_type(void)
{
    static GType pagebar_type = 0;

    if (!pagebar_type)
    {
    static const GTypeInfo pagebar_info = {
        sizeof(GtkPagebarClass),
        NULL,       /* base_init */
        NULL,       /* base_finalize */
        (GClassInitFunc) gtk_pagebar_class_init,
        NULL,       /* class_finalize */
        NULL,       /* class_data */
        sizeof(GtkPagebar),
        0,          /* n_preallocs */
        (GInstanceInitFunc) gtk_pagebar_init,
        NULL        /* *value_table */
    };

    pagebar_type =
        g_type_register_static(GTK_TYPE_DRAWING_AREA,
                                "erGtkPagebar",
                                &pagebar_info,
                                (GTypeFlags)(0));
    }

    return pagebar_type;
}

void gtk_pagebar_class_init(GtkPagebarClass * klass)
{
    GObjectClass *object_class = (GObjectClass *) klass;

    // remember parent class struct, needed for chaining up to parent class
    g_parent_class = g_type_class_peek_parent(klass);

    // overload some virtual methods
    object_class->finalize = gtk_pagebar_finalize;

    // event to notify page update 
    pagebar_signals[PAGE_SELECTED] = g_signal_new("pagebar_page_selected",
                                        G_TYPE_FROM_CLASS(object_class), 
                                        G_SIGNAL_RUN_LAST,
                                        G_STRUCT_OFFSET(GtkPagebarClass, 
                                                   pagebar_page_selected),
                                        NULL, 
                                        NULL, 
                                        gtk_marshal_VOID__INT, 
                                        G_TYPE_NONE, 
                                        1, 
                                        G_TYPE_INT);

    // load bitmap details
    pagebar_load_bitmaps();
}

// init instance (constructor)
void gtk_pagebar_init(GtkPagebar * pagebar)
{
    gtk_widget_set_events(GTK_WIDGET(pagebar),
                          GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK |
                          GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);

    gtk_signal_connect(GTK_OBJECT(pagebar), 
                       "expose-event",
                       GTK_SIGNAL_FUNC(on_pagebar_exposed), 
                       pagebar);

    gtk_signal_connect(GTK_OBJECT(pagebar), 
                       "configure-event",
                       GTK_SIGNAL_FUNC(on_pagebar_configured), 
                       pagebar);

    g_signal_connect(G_OBJECT(pagebar), 
                     "button_press_event",
                     G_CALLBACK(on_pagebar_button_press_event), 
                     pagebar);

    g_signal_connect(G_OBJECT(pagebar),
                     "button_release_event",
                     G_CALLBACK(on_pagebar_button_release_event), 
                     pagebar);

    gtk_widget_show(GTK_WIDGET(pagebar));
}

// finalize instance (destructor)
static void gtk_pagebar_finalize (GObject *obj)
{
    g_return_if_fail( IS_GTK_PAGEBAR(obj) );
    GtkPagebar *pagebar = GTK_PAGEBAR(obj);

    // destroy instance data
    gtk_pagebar_reset(pagebar);
    //   private
    if (pagebar->own_gc)
    {
        g_object_unref(pagebar->own_gc);
        pagebar->own_gc = NULL;
    }
    if (pagebar->pango_layout)
    {
        g_object_unref(pagebar->pango_layout);
        pagebar->pango_layout = NULL;
    }
    if (pagebar->pixmap)
    {
        g_object_unref(pagebar->pixmap);
        pagebar->pixmap = NULL;
    }
    
    //   public: none

    // chain to parent class
    ((GObjectClass*)g_parent_class)->finalize( obj );
}

// Implement the public interfaces.
GtkWidget *gtk_pagebar_new()
{
    GtkPagebar *pagebar = 0;
    PangoFontDescription *fontdesc = 0;

    pagebar = (GtkPagebar *) g_object_new(GTK_PAGEBAR_TYPE, NULL);

    pagebar->bookmarks = NULL;

    // Initiailize with default values.
    gtk_pagebar_reset(pagebar);

    // Calculate layout. Hard code the font family here.
    // Any other good way to handle that? TODO
    pagebar->pango_layout =
        gtk_widget_create_pango_layout(GTK_WIDGET(pagebar),
                                       "X");
    fontdesc = 
        pango_font_description_from_string("Bitstream Vera Sans Roman 7.2");

    pango_layout_set_font_description(pagebar->pango_layout, fontdesc);
    pango_font_description_free(fontdesc);

    pagebar->pixmap = NULL;
    pagebar->own_gc = NULL;

    return GTK_WIDGET(pagebar);
}

/**
 * @brief Load a bitmaps from specified files.
 * @brief For simplicity these are loaded only once and never released.
 */
void pagebar_load_bitmaps(void)
{
    bitmap_data_t *data = (bitmap_data_t*) &g_bitmap_data;  // const_cast

    int i;
    GError *error = NULL;
    const gchar *filename = NULL;

    // Load the bitmaps.
    for(i = 0; i < BITMAP_COUNT; ++i)
    {
        if (data->bitmaps[i] == NULL)
        {
            filename = BITMAP_PATHS[i];
            data->bitmaps[i] = gdk_pixbuf_new_from_file(filename, &error);
            if (error)
            {
                g_error("Loading bitmap %s error (%s)\n", filename, error->message);
                g_error_free(error);
            }
        }
    }

    // Update the size values.
    if (data->bitmaps[BITMAP_CPI])
    {
        data->cpi_width  = gdk_pixbuf_get_width(data->bitmaps[BITMAP_CPI]);
        data->cpi_height = gdk_pixbuf_get_height(data->bitmaps[BITMAP_CPI]);
    }
    if (data->bitmaps[BITMAP_SUCC_CPI])
    {
        data->page_field_width = gdk_pixbuf_get_width(data->bitmaps[BITMAP_SUCC_CPI]);
        data->page_field_height = gdk_pixbuf_get_height(data->bitmaps[BITMAP_SUCC_CPI]);
    }
    if (data->bitmaps[BITMAP_BOOKMARK])
    {
        data->bookmark_icon_width = gdk_pixbuf_get_width(data->bitmaps[BITMAP_BOOKMARK]);
        data->bookmark_icon_height = gdk_pixbuf_get_height(data->bitmaps[BITMAP_BOOKMARK]);
    }
}

/**
 * @brief Add to boomark list.
 */
static gint compare_bookmark(gconstpointer a, gconstpointer b)
{
    gint bm_a = *((gint*)(a));
    gint bm_b = *((gint*)(b));
    if (bm_a > bm_b)
    {
        return 1;
    }
    else if (bm_a == bm_b)
    {
        return 0;
    }
    return -1;
}

int get_bookmark_idx(GtkPagebar * pagebar, const unsigned int page_number)
{
    unsigned int i;
    for(i=0; i < pagebar->bookmarks->len; ++i)
    {
        if (g_array_index(pagebar->bookmarks, guint, i) == page_number)
        {
            return i;
        }
    }

    return -1;
}

gboolean add_bookmark(GtkPagebar * pagebar, const unsigned int page_number)
{
    if (page_number <= 0 || page_number > pagebar->page_count)
    {
        return FALSE;
    }

    if (pagebar->bookmarks == NULL)
    {
        pagebar->bookmarks = g_array_new(FALSE, FALSE, sizeof(unsigned int));
    }

    if (get_bookmark_idx(pagebar, page_number) >= 0)
    {
        // the bookmark exists
        return TRUE;
    }

    g_array_append_val(pagebar->bookmarks, page_number);

    g_array_sort (pagebar->bookmarks, compare_bookmark);

    gtk_pagebar_draw(pagebar);

    return TRUE;
}

/**
 * @brief Remove a page from bookmark list.
 */
gboolean remove_bookmark(GtkPagebar * pagebar, const unsigned int page_number)
{
    if (pagebar->bookmarks == NULL)
    {
        return FALSE;
    }
    if (page_number <= 0 || page_number > pagebar->page_count)
    {
        return FALSE;
    }

    int idx = get_bookmark_idx(pagebar, page_number);
    if (idx < 0)
    {
        return FALSE;
    }

    pagebar->bookmarks = g_array_remove_index(pagebar->bookmarks, idx);
    gtk_pagebar_draw(pagebar);

    return TRUE;
}


/* Create a new backing pixmap of the appropriate size */
gboolean on_pagebar_configured(GtkWidget * widget,
                               GdkEventConfigure * event, 
                               gpointer user_data)
{
    GtkPagebar *pagebar = GTK_PAGEBAR(user_data);

    if (pagebar->own_gc)
    {
        g_object_unref(pagebar->own_gc);
        pagebar->own_gc = NULL;
    }
    if (pagebar->pixmap)
    {
        g_object_unref(pagebar->pixmap);
        pagebar->pixmap = NULL;
    }

    // TODO. If we need the "goto" button, this may be changed.
    pagebar->pixmap = gdk_pixmap_new(widget->window,
                                     widget->allocation.width, 
                                     widget->allocation.height, 
                                     -1);

    pagebar->own_gc = gdk_gc_new(pagebar->pixmap);

    gdk_draw_rectangle(pagebar->pixmap,
                       widget->style->white_gc,
                       TRUE, 
                       0, 
                       0, 
                       widget->allocation.width, 
                       widget->allocation.height);

    // reset the max_detailed_items
    pagebar->max_detailed_items = (widget->allocation.width - g_bitmap_data.cpi_width) /
        (g_bitmap_data.page_field_width + PAGEBAR_CPI_SPACE) + 1;

    if (pagebar->page_count > pagebar->max_detailed_items)
    {
        pagebar->status = STATUS_NORMAL;
        int least_len = (g_bitmap_data.page_field_width << 1) +
            (g_bitmap_data.page_field_width + PAGEBAR_CPI_SPACE) * (PAGEBAR_ADJACENT_PAGES_NUM << 1) +
            (g_bitmap_data.cpi_width + PAGEBAR_CPI_SPACE);

        if (widget->allocation.width < least_len)
        {
            pagebar->status = STATUS_SHRINK;
        }
    }
    else
    {
        pagebar->status = STATUS_DETAILS;
    }

    // get the width and height of pagebar
    gdk_drawable_get_size(pagebar->pixmap, &pagebar->pagebar_width,
        &pagebar->pagebar_height);
    pagebar->pagebar_width -= (PAGEBAR_HORIZONTAL_MARGIN << 1);
    pagebar->pagebar_height -= (PAGEBAR_VERTICAL_MARGIN << 1);

    gtk_pagebar_draw(pagebar);

    return TRUE;
}

/* Redraw the screen from the backing pixmap */
gboolean on_pagebar_exposed(GtkWidget * widget,
                            GdkEventExpose * event,
                            gpointer user_data)
{

    GtkPagebar *pagebar = GTK_PAGEBAR(user_data);

    g_return_val_if_fail(IS_GTK_PAGEBAR(pagebar), FALSE);
    
    // Copy damaged region of image from pixmap to output 
    gdk_draw_drawable(widget->window,
                      widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
                      pagebar->pixmap,
                      event->area.x, event->area.y,
                      event->area.x, event->area.y,
                      event->area.width, event->area.height);

    return FALSE;
}

void pagebar_transfer_position(const int x, const int y,
                               int * click_x, int * click_y,
                               gboolean widget_to_pagebar)
{
    if (widget_to_pagebar)
    {
        *click_x = x - PAGEBAR_HORIZONTAL_MARGIN;
        *click_y = y - PAGEBAR_VERTICAL_MARGIN;
    }
    else
    {
        // page bar to widget
        *click_x = x + PAGEBAR_HORIZONTAL_MARGIN;
        *click_y = y + PAGEBAR_VERTICAL_MARGIN;
    }
}

gboolean pagebar_hit_test_markers(GtkPagebar * pagebar,
                                  int click_x, int click_y)
{
    // it is in page bar coordination system
    GArray *markers = pagebar->bookmarks;
    if (markers == NULL)
    {
        return FALSE;
    }

    int dst_page = -1;
    unsigned int idx = 0;
    for (; idx < markers->len; idx++)
    {
        // get pagenumber by mark
        int mark_page = g_array_index(markers, guint, idx);
        int marker_x = pagebar_get_x_of_marker(pagebar, mark_page, PAGEBAR_ADJACENT_PAGES_NUM);
        if (marker_x < 0)
        {
            continue;
        }
        if (click_x < (marker_x + PAGEBAR_BOOKMARK_SENSOR_RANGE +
            g_bitmap_data.bookmark_icon_width) &&
            click_x > (marker_x - PAGEBAR_BOOKMARK_SENSOR_RANGE))
        {
            // successfully find the bookmark
            dst_page = mark_page;
            break;
        }
    }

    if (dst_page > 0)
    {
        pagebar->current_page = dst_page;
        on_current_page_changed(pagebar);
        return TRUE;
    }

    return FALSE;
}

void pagebar_hit_test_on_cpi_overview(GtkPagebar * pagebar,
                                      int click_x, int click_y,
                                      int pagebar_width, int pagebar_height)
{
    // it is in page bar coordination system
    int first_page = pagebar->current_page - PAGEBAR_ADJACENT_PAGES_NUM;
    if (first_page < 1)
    {
        first_page = 1;
    }
    unsigned int last_page = pagebar->current_page + PAGEBAR_ADJACENT_PAGES_NUM;
    if (last_page > pagebar->page_count)
    {
        last_page = pagebar->page_count;
    }

    unsigned int idx = first_page;
    int cur_x = pagebar->cpi_area.x;
    int cur_width = g_bitmap_data.page_field_width;
    for (; idx <= last_page; ++idx)
    {
        if (idx == pagebar->current_page)
        {
            cur_width = g_bitmap_data.cpi_width + PAGEBAR_CPI_SPACE;
        }
        else if (idx == (pagebar->current_page - 1))
        {
            cur_width = g_bitmap_data.page_field_width + PAGEBAR_CPI_SPACE;
        }
        else
        {
            cur_width = g_bitmap_data.page_field_width + PAGEBAR_CPI_ADJACENT_SPACE;
        }

        if (click_x >= cur_x && click_x <= cur_x + cur_width)
        {
            // Test to see if the current page has been clicked
            if (idx == pagebar->current_page)
            {
                // Show a jump to page dialog and use the result
                GtkWidget* jump_to_page_dialog = ergtk_jump_to_page_dialog_new();
                int response = gtk_dialog_run(GTK_DIALOG(jump_to_page_dialog));
                gtk_widget_destroy(jump_to_page_dialog);

                if (response > 0)
                {
                    if (response <= (int) pagebar->page_count)
                    {
                        pagebar->current_page = response;
                    }
                    else
                    {
                        pagebar->current_page = pagebar->page_count;
                    }
                }
            }
            else
            {
                pagebar->current_page = idx;
            }
            break;
        }

        cur_x += cur_width;
    }
    on_current_page_changed(pagebar);
}

void pagebar_hit_test_on_indicator_overview(GtkPagebar * pagebar,
                                   int click_x, int click_y,
                                   int pagebar_width, int pagebar_height)
{
    // it is in page bar coordination system
    if (pagebar_hit_test_markers(pagebar, click_x, click_y))
    {
        return;
    }

    // calculate the left length and right length
    int left_len = 0, right_len = 0;
    if (pagebar->cpi_area.x > 0)
    {
        left_len = pagebar->cpi_area.x - g_bitmap_data.page_field_width;
    }
    int cpi_right = pagebar->cpi_area.x + pagebar->cpi_area.width;
    if (cpi_right < pagebar_width)
    {
        right_len = pagebar_width - g_bitmap_data.page_field_width - cpi_right;
    }

    // coordination transform
    int x = click_x;
    int first_page = 1;
    int pages_left = 0;
    int offset_page = 0;
    // check x is located in left or right
    if (x < pagebar->cpi_area.x)
    {
        // locate in left
        x -= g_bitmap_data.page_field_width;
        first_page = 1;
        pages_left = (pagebar->current_page - PAGEBAR_ADJACENT_PAGES_NUM) -
            first_page;
        offset_page = x * pages_left / left_len;
    }
    else
    {
        x -= cpi_right;
        first_page = pagebar->current_page + PAGEBAR_ADJACENT_PAGES_NUM;
        pages_left = (pagebar->page_count - 1) - first_page;
        offset_page = x * pages_left / right_len;
    }

    if (offset_page <= 0)
    {
        offset_page = 1;
    }
    pagebar->current_page = first_page + offset_page;

    on_current_page_changed(pagebar);
}

// TODO: move duplicate code in a common function; compare this function with pagebar_hit_test_on_cpi_overview()
void pagebar_hit_test_details(GtkPagebar * pagebar,
                              int click_x, int click_y)
{
    // it is in page bar coordination system
    // the detail is drawn
    unsigned int idx = 1;
    int cur_x = pagebar->cpi_area.x;
    int cur_width = g_bitmap_data.page_field_width;
    for (; idx <= pagebar->page_count; ++idx)
    {
        if (idx == pagebar->current_page)
        {
            cur_width = g_bitmap_data.cpi_width + PAGEBAR_CPI_SPACE;
        }
        else if (idx == (pagebar->current_page - 1))
        {
            cur_width = g_bitmap_data.page_field_width + PAGEBAR_CPI_SPACE;
        }
        else
        {
            cur_width = g_bitmap_data.page_field_width + PAGEBAR_CPI_ADJACENT_SPACE;
        }

        if (click_x >= cur_x && click_x <= cur_x + cur_width)
        {
            // Test to see if the current page has been clicked
            if (idx == pagebar->current_page)
            {
                // Show a jump to page dialog and use the result
                GtkWidget* jump_to_page_dialog = ergtk_jump_to_page_dialog_new();
                int response = gtk_dialog_run(GTK_DIALOG(jump_to_page_dialog));
                gtk_widget_destroy(jump_to_page_dialog);

                if (response > 0)
                {
                    if (response <= (int) pagebar->page_count)
                    {
                        pagebar->current_page = response;
                    }
                    else
                    {
                        pagebar->current_page = pagebar->page_count;
                    }
                }
            }
            else
            {
                pagebar->current_page = idx;
            }
            break;
        }

        cur_x += cur_width;
    }
    on_current_page_changed(pagebar);
}

void pagebar_hit_test_shrink(GtkPagebar * pagebar,
                             int click_x, int click_y,
                             int pagebar_width, int pagebar_height)
{
    // it is in page bar coordination system
    int x = click_x;
    if (x >= pagebar->cpi_area.x &&
        x <= pagebar->cpi_area.x + pagebar->cpi_area.width)
    {
        // it is current page
        // TODO: do we need to add the call to display the "JumpToPage" dialog here too?
        return;
    }
    else if (x >= 0 && x <= g_bitmap_data.page_field_width)
    {
        pagebar->current_page = 1;
    }
    else if (x <= pagebar_width && x >= pagebar_width - g_bitmap_data.page_field_width)
    {
        pagebar->current_page = pagebar->page_count;
    }
    else
    {
        if (pagebar_hit_test_markers(pagebar, click_x, click_y))
        {
            // hit test the bookmark at first
            return;
        }

        // calculate the position in overview
        int overview_length = pagebar_width - pagebar->cpi_area.width;
        if (pagebar->current_page > 1 && pagebar->current_page < pagebar->page_count)
        {
            overview_length -= g_bitmap_data.page_field_width << 1;
        }
        else
        {
            overview_length -= g_bitmap_data.page_field_width;
        }

        // coordination transform
        int cpi_shrink_x = x;
        if (pagebar->cpi_area.x > 0)
        {
            cpi_shrink_x -= g_bitmap_data.page_field_width;
        }

        if (x > pagebar->cpi_area.x)
        {
            cpi_shrink_x -= pagebar->cpi_area.width;
        }

        pagebar->current_page = cpi_shrink_x * pagebar->page_count / overview_length;
        if (pagebar->current_page < 1)
        {
            // current page might be 0
            pagebar->current_page = 1;
        }
    }

    on_current_page_changed(pagebar);
}

/**
 * Event handlers.
 */
gboolean on_pagebar_button_release_event(GtkWidget * widget,
                                         GdkEventButton * event, 
                                         gpointer user_data)
{

    return TRUE;
}

int on_current_page_changed(GtkPagebar * pagebar)
{
    if (pagebar->last_selected_page == pagebar->current_page)
    {
        return 0;
    }

    pagebar->last_selected_page = pagebar->current_page;
    gtk_pagebar_draw(pagebar);

    g_signal_emit(pagebar, 
                  pagebar_signals[PAGE_SELECTED], 
                  0, 
                  pagebar->current_page);
    return 1;
}

gboolean on_pagebar_button_press_event(GtkWidget * widget,
                                       GdkEventButton * event, 
                                       gpointer user_data)
{
    GtkPagebar *pagebar = GTK_PAGEBAR(user_data);
    int x = (int)(event->x);
    int y = (int)(event->y);
    pagebar_transfer_position(x, y, &x, &y, TRUE);

    int pagebar_width = pagebar->pagebar_width;
    int pagebar_height = pagebar->pagebar_height;

    if (pagebar->status == STATUS_NORMAL)
    {
        if (x >= pagebar->cpi_area.x &&
            x <= pagebar->cpi_area.x + pagebar->cpi_area.width)
        {
            pagebar_hit_test_on_cpi_overview(pagebar, x, y, pagebar_width, pagebar_height);
        }
        else if (x > g_bitmap_data.page_field_width && x < (pagebar_width - g_bitmap_data.page_field_width))
        {
            pagebar_hit_test_on_indicator_overview(pagebar, x, y, pagebar_width, pagebar_height);
        }
        else if (x <= g_bitmap_data.page_field_width)
        {
            pagebar->current_page = 1;
            on_current_page_changed(pagebar);
        }
        else if (x >= pagebar_width - g_bitmap_data.page_field_width)
        {
            pagebar->current_page = pagebar->page_count;
            on_current_page_changed(pagebar);
        }
    }
    else if (pagebar->status == STATUS_DETAILS)
    {
        pagebar_hit_test_details(pagebar, x, y);
    }
    else
    {
        pagebar_hit_test_shrink(pagebar, x, y, pagebar_width, pagebar_height);
    }

    return TRUE;
}

void gtk_pagebar_set_number_of_pages(GtkPagebar * pagebar,
                                     const unsigned int number)
{
    g_return_if_fail(IS_GTK_PAGEBAR(pagebar));
    g_return_if_fail((number <= PAGEBAR_MAX_PAGES));

    pagebar->page_count = number;

    if (pagebar->page_count > pagebar->max_detailed_items)
    {
        pagebar->status = STATUS_NORMAL;
    }
    else
    {
        pagebar->status = STATUS_DETAILS;
    }

    gtk_pagebar_draw(pagebar);
}

unsigned int gtk_pagebar_get_number_of_pages(GtkPagebar * pagebar)
{
    g_return_val_if_fail(IS_GTK_PAGEBAR(pagebar), -1);

    return pagebar->page_count;
}

gboolean gtk_pagebar_set_current_page(GtkPagebar * pagebar,
                                      const unsigned int current)
{
    g_return_val_if_fail(IS_GTK_PAGEBAR(pagebar), FALSE);

    if (pagebar->current_page != current)
    {
        pagebar->current_page = current;
        pagebar->last_selected_page = current;
        gtk_pagebar_draw(pagebar);
    }
    return TRUE;
}

unsigned int gtk_pagebar_get_current_page(GtkPagebar * pagebar)
{
    g_return_val_if_fail(IS_GTK_PAGEBAR(pagebar), -1);

    return pagebar->current_page;
}

gboolean gtk_pagebar_set_bookmark(GtkPagebar * pagebar,
                                  const unsigned int page)
{
    g_return_val_if_fail(IS_GTK_PAGEBAR(pagebar), FALSE);
    g_return_val_if_fail((page > 0 && page <= pagebar->page_count), FALSE);

    return add_bookmark(pagebar, page);
}

gboolean gtk_pagebar_delete_bookmark(GtkPagebar * pagebar,
                                     const unsigned int page)
{
    return remove_bookmark(pagebar, page);
}

const GArray* gtk_pagebar_get_bookmarks(GtkPagebar * pagebar)
{
    g_return_val_if_fail(IS_GTK_PAGEBAR(pagebar), NULL);

    return pagebar->bookmarks;
}

void gtk_pagebar_reset(GtkPagebar * pagebar)
{
    g_return_if_fail(IS_GTK_PAGEBAR(pagebar));

    pagebar->page_count = PAGEBAR_DEFAULT_PAGE_COUNT;
    pagebar->current_page = PAGEBAR_DEFAULT_CURRENT_PAGE;
    pagebar->status = STATUS_NORMAL;

    if (pagebar->bookmarks)
    {
        g_array_free(pagebar->bookmarks, TRUE);
        pagebar->bookmarks = NULL;
    }

    // Do not release the bitmap here.
}

unsigned int gtk_pagebar_get_minimal_height(GtkPagebar * pagebar)
{
    g_return_val_if_fail(IS_GTK_PAGEBAR(pagebar), 0);

    return MAX(g_bitmap_data.cpi_height, g_bitmap_data.page_field_height);
}

gboolean is_page_marked(GArray * markers, int page_number)
{
    if (markers == NULL)
    {
        return FALSE;
    }

    unsigned int idx = 0;
    int mark_page = 0;
    for (; idx < markers->len; idx++)
    {
        mark_page = g_array_index(markers, guint, idx);
        if (mark_page == page_number)
        {
            return TRUE;
        }
    }

    return FALSE;
}

int pagebar_calibrate_x_of_marker(GtkPagebar * pagebar, const int origin_x,
                                  const int offset)
{
    int x = origin_x;
    x -= offset;

    int num_lines = x / (PAGEBAR_INDICATOR_SPACE + PAGEBAR_INDICATOR_LINE_WIDTH);
    if (num_lines > 0)
    {
        num_lines --;
    }
    x = offset + num_lines * (PAGEBAR_INDICATOR_SPACE + PAGEBAR_INDICATOR_LINE_WIDTH)
        - (g_bitmap_data.bookmark_icon_width >> 1);

    return x;
}

int pagebar_get_x_of_marker(GtkPagebar * pagebar, const int page_number,
                            const int adjacent_pages)
{
    // it is in page bar coordination system

    int pagebar_width = pagebar->pagebar_width;
    // int pagebar_height = pagebar->pagebar_height;

    int x = 0;
    int start_x = 0;
    int offset = 0;

    if (page_number >= (int) (pagebar->current_page - adjacent_pages) &&
        page_number <= (int) (pagebar->current_page + adjacent_pages))
    {
        return -1;
    }
    else if (page_number == 1)
    {
        return -1;
    }
    else if (page_number == (int) pagebar->page_count)
    {
        return -1;
    }

    if (page_number > (int) pagebar->current_page)
    {
        // calculate the length of right part
        start_x = pagebar->cpi_area.x + pagebar->cpi_area.width;
        int right_len = (pagebar_width - g_bitmap_data.page_field_width) - start_x;

        x = (page_number - pagebar->current_page- adjacent_pages) * right_len /
            (pagebar->page_count - pagebar->current_page - adjacent_pages - 1);

        offset = pagebar->right_indicator_offset;
    }
    else
    {
        // calculate the length of left part
        start_x = g_bitmap_data.page_field_width;
        int left_len = pagebar->cpi_area.x - start_x;

        x = (page_number - 1) * left_len /
            (pagebar->current_page - 1 - adjacent_pages - 1);

        offset = pagebar->left_indicator_offset;
    }

    // calibrate the value
    return (pagebar_calibrate_x_of_marker(pagebar, x, offset) + start_x);
}

/**
 * @brief Draw the markers for overview mode.
 */
void pagebar_draw_markers(GtkPagebar * pagebar,
                          const int bitmap,
                          GArray * markers,
                          const int adjacent_pages)
{
    if (markers == NULL)
    {
        return;
    }

    unsigned int idx = 0;
    guint mark_page = 0;
    int x = 0, y = 0;
    int display_x = 0, display_y = 0;
    int last_drawn_location = x;

    for (; idx < markers->len; idx++)
    {
        // get pagenumber by mark
        mark_page = g_array_index(markers, guint, idx);

        x = pagebar_get_x_of_marker(pagebar, mark_page, adjacent_pages);
        if (x < 0)
        {
            continue;
        }

        // the bookmarks are sorted already
        if (x < last_drawn_location + g_bitmap_data.bookmark_icon_width)
        {
            // if two bookmarks overlap, do not draw the bigger one
            continue;
        }

        y = pagebar->cpi_area.y + (g_bitmap_data.cpi_height - g_bitmap_data.page_field_height);

        // transfer the position to widget position;
        pagebar_transfer_position(x, y, &display_x, &display_y, FALSE);
        gdk_draw_pixbuf(pagebar->pixmap, NULL,
                g_bitmap_data.bitmaps[bitmap], 0, 0, display_x, display_y, -1, -1,
                GDK_RGB_DITHER_NONE, 0, 0);

        last_drawn_location = x;
    }
}

/**
 * @brief Draw the whole pagebar.
 * - Draw background.
 * - Draw cpi (current page indicator).
 * - Draw left and right 
 */
void gtk_pagebar_draw(GtkPagebar * pagebar)
{
    g_return_if_fail((IS_GTK_PAGEBAR(pagebar)));

    if (!pagebar->pixmap)
    {
        return;
    }

    if (pagebar->pagebar_width <= 1 || pagebar->pagebar_height <= 1)
    {
        return;
    }

    // clear the area.
    int width;
    int height;
    gdk_drawable_get_size(pagebar->pixmap, &width, &height);
    gdk_draw_rectangle(pagebar->pixmap,
                        GTK_WIDGET(pagebar)->style->white_gc,
                        TRUE,
                        0,
                        0,
                        width,
                        height);

    pagebar_calculate_cpi(pagebar);

    int line_x1 = 0;
    int line_x2 = 0;
    int line_y1 = pagebar->cpi_area.y + 1;
    int line_y2 = line_y1 + (g_bitmap_data.cpi_height - g_bitmap_data.page_field_height);
    int line_y_max = MAX(line_y1, line_y2);
    int line_y_min = MIN(line_y1, line_y2);

    GdkColor color;
    color.pixel = 0;
    gdk_gc_set_foreground(pagebar->own_gc, &color);
    gdk_gc_set_line_attributes(pagebar->own_gc,
                               PAGEBAR_HORIZONTAL_LINE_WIDTH,
                               GDK_LINE_SOLID,
                               GDK_CAP_PROJECTING,
                               GDK_JOIN_MITER);

    // translate the position from page bar to widget
    gdk_draw_line(pagebar->pixmap,
                  pagebar->own_gc,
                  line_x1, line_y_min,
                  (line_x1 + width), line_y_min);

    // draw bottom line
    pagebar_transfer_position(line_x2, line_y_max, &line_x2, &line_y_max, FALSE);
    gdk_draw_line(pagebar->pixmap,
                  pagebar->own_gc,
                  line_x2 + 1, line_y_max,
                  (line_x2 + pagebar->pagebar_width - 1), line_y_max);

    if (pagebar->status == STATUS_DETAILS)
    {
        // draw the details of each page, highlight the current one
        pagebar_draw_details(pagebar);
    }
    else if (pagebar->status == STATUS_NORMAL)
    {
        pagebar_draw_overview(pagebar);

        pagebar_draw_cpi_overview(pagebar);

        pagebar_draw_markers(pagebar, BITMAP_BOOKMARK, pagebar->bookmarks,
            PAGEBAR_ADJACENT_PAGES_NUM);
    }
    else
    {
        pagebar_draw_overview(pagebar);

        pagebar_draw_cpi_shrink(pagebar);

        pagebar_draw_markers(pagebar, BITMAP_BOOKMARK, pagebar->bookmarks, 0);
    }

    // draw bookmarks

    // make things appear on the screen 
    gtk_widget_queue_draw(GTK_WIDGET(pagebar));
}

/**
 * @brief Calculate the cpi position.
 */
void pagebar_calculate_cpi(GtkPagebar * pagebar)
{
    switch (pagebar->status)
    {
    case STATUS_NORMAL:
        pagebar_calculate_cpi_overview(pagebar);
        break;
    case STATUS_DETAILS:
        pagebar_calculate_cpi_details(pagebar);
        break;
    case STATUS_SHRINK:
        pagebar_calculate_cpi_shrink(pagebar);
        break;
    default:
        break;
    }
}

void pagebar_calculate_cpi_details(GtkPagebar * pagebar)
{
    // only calculate the y position to reduce redundant calculation
    // pagebar->cpi_area.y = ((pagebar_height - pagebar->cpi_height) >> 1);
    pagebar->cpi_area.y = 0;
}

// This function will calculate the position of current pages indicators
// including current page and adjacent pages.
void pagebar_calculate_cpi_overview(GtkPagebar * pagebar)
{
    // it is in page bar coordination system
    int pagebar_width = pagebar->pagebar_width;
    // int pagebar_height = pagebar->pagebar_height;

    int cpi_pages_num = 0;
    int cpi_width = 0;
    int cpi_height = MAX(g_bitmap_data.page_field_height, g_bitmap_data.cpi_height);

    if (pagebar->current_page <= 1 + PAGEBAR_ADJACENT_PAGES_NUM)
    {
        // cpi = 1 +...+ x + x+1 + x+2
        cpi_pages_num = pagebar->current_page + PAGEBAR_ADJACENT_PAGES_NUM;
        // width = bitmap length + adjacent cpi spaces length + cpi space length
        cpi_width = (g_bitmap_data.page_field_width + PAGEBAR_CPI_ADJACENT_SPACE) * (cpi_pages_num - 1)+
            g_bitmap_data.cpi_width;
        if (pagebar->current_page == 1)
        {
            cpi_width -= (PAGEBAR_CPI_ADJACENT_SPACE - PAGEBAR_CPI_SPACE);
        }
        else
        {
            cpi_width -= ((PAGEBAR_CPI_ADJACENT_SPACE - PAGEBAR_CPI_SPACE) << 1);
        }

        pagebar->cpi_area.x = 0;
    }
    else if (pagebar->current_page >= pagebar->page_count - PAGEBAR_ADJACENT_PAGES_NUM)
    {
        // cpi = x-2 + x-1 + x +...+ last page
        cpi_pages_num = pagebar->page_count - pagebar->current_page +
            PAGEBAR_ADJACENT_PAGES_NUM + 1;
        cpi_width = (g_bitmap_data.page_field_width + PAGEBAR_CPI_ADJACENT_SPACE) * (cpi_pages_num - 1) +
            g_bitmap_data.cpi_width;
        if (pagebar->current_page == pagebar->page_count)
        {
            cpi_width -= (PAGEBAR_CPI_ADJACENT_SPACE - PAGEBAR_CPI_SPACE);
        }
        else
        {
            cpi_width -= ((PAGEBAR_CPI_ADJACENT_SPACE - PAGEBAR_CPI_SPACE) << 1);
        }

        pagebar->cpi_area.x = pagebar_width - cpi_width;
    }
    else
    {
        // cpi = x-2 + x-1 + x + x+1 + x+2
        cpi_pages_num = (PAGEBAR_ADJACENT_PAGES_NUM << 1) + 1;
        cpi_width = (g_bitmap_data.page_field_width + PAGEBAR_CPI_ADJACENT_SPACE) * (cpi_pages_num - 1) +
            g_bitmap_data.cpi_width;
        cpi_width -= ((PAGEBAR_CPI_ADJACENT_SPACE - PAGEBAR_CPI_SPACE) << 1);

        // calculate the position of cpi
        int overview_length = pagebar_width - (g_bitmap_data.page_field_width << 1) - cpi_width;

        // calculate the x position in overview
        if (pagebar->current_page == (1 + PAGEBAR_ADJACENT_PAGES_NUM + 1))
        {
            // near the first page
            // TODO. we need a better way to solve this problem
            pagebar->cpi_area.x = g_bitmap_data.page_field_width + PAGEBAR_CPI_ADJACENT_SPACE;
        }
        else if (pagebar->current_page == (pagebar->page_count - PAGEBAR_ADJACENT_PAGES_NUM - 1))
        {
            // near the last page
            pagebar->cpi_area.x = pagebar_width - g_bitmap_data.page_field_width -
                PAGEBAR_CPI_ADJACENT_SPACE - cpi_width;
        }
        else
        {
            pagebar->cpi_area.x = g_bitmap_data.page_field_width +
                (pagebar->current_page - PAGEBAR_ADJACENT_PAGES_NUM - 2) *
                overview_length / (pagebar->page_count - cpi_pages_num - 2);
        }

    }

    pagebar->cpi_area.width = cpi_width;
    pagebar->cpi_area.height = cpi_height;
    // cpi_area.y is the original coordination for every calculation
    // pagebar->cpi_area.y = ((pagebar_height - cpi_height) >> 1);
    pagebar->cpi_area.y = 0;
}

void pagebar_calculate_cpi_shrink(GtkPagebar * pagebar)
{
    int pagebar_width = pagebar->pagebar_width;
    //int pagebar_height = pagebar->pagebar_height;

    pagebar->cpi_area.width = g_bitmap_data.cpi_width;
    pagebar->cpi_area.height = g_bitmap_data.cpi_height;
    // pagebar->cpi_area.y = ((pagebar_height - pagebar->cpi_height) >> 1);
    pagebar->cpi_area.y = 0;
    if (pagebar->current_page == 1)
    {
        pagebar->cpi_area.x = 0;
        return;
    }

    if (pagebar->current_page == pagebar->page_count)
    {
        pagebar->cpi_area.x = pagebar_width - g_bitmap_data.cpi_width;
        return;
    }

    // calculate the position of cpi
    int overview_length = pagebar_width - (g_bitmap_data.page_field_width << 1) - g_bitmap_data.cpi_width;
    int cpi_overview_x = pagebar->current_page * overview_length / (pagebar->page_count - 2);
    pagebar->cpi_area.x = g_bitmap_data.page_field_width + cpi_overview_x;

}

void pagebar_draw_details(GtkPagebar * pagebar)
{
    // int pagebar_width = pagebar->pagebar_width;
    // int pagebar_height = pagebar->pagebar_height;

    // calculate the display position of "real" page bar
    int x = 0;
    int y = 0;
    int inc_length = 0;
    int w = 0, h = 0;
    char text[16] = { 0 };

    // borrow cpi area's x to record the position of real page bar
    pagebar->cpi_area.x = x;

    // set own gc to draw text of succeed pages after current page
    GdkColor color;
    color.pixel = PAGEBAR_NEXT_PAGE_TEXT_COLOR;
    gdk_gc_set_foreground(pagebar->own_gc, &color);

    // draw each page
    int display_x = 0, display_y = 0;

    unsigned int idx = 1;
    for (; idx <= pagebar->page_count; ++idx)
    {
        int bitmap_kind = BITMAP_SUCC_CPI;
        GdkGC *gc = GTK_WIDGET(pagebar)->style->black_gc;
        int size_x = 0;
        int size_y = 0;
        if (idx == pagebar->current_page)
        {
            // draw CPI
            y = pagebar->cpi_area.y;

            if (is_page_marked(pagebar->bookmarks, idx))
            {
                bitmap_kind = BITMAP_CPI_BOOKMARK;
            }
            else
            {
                bitmap_kind = BITMAP_CPI;
            }

            pagebar_transfer_position(x, y, &display_x, &display_y, FALSE);
            gdk_draw_pixbuf(pagebar->pixmap,
                            NULL, g_bitmap_data.bitmaps[bitmap_kind],
                            0, 0, display_x, display_y,
                            g_bitmap_data.cpi_width,
                            g_bitmap_data.cpi_height,
                            GDK_RGB_DITHER_NONE, 0, 0);

            inc_length = g_bitmap_data.cpi_width;
            gc = GTK_WIDGET(pagebar)->style->white_gc;

            size_x = g_bitmap_data.cpi_width;
            size_y = g_bitmap_data.cpi_height;
        }
        else
        {
            if (idx < pagebar->current_page)
            {
                if (is_page_marked(pagebar->bookmarks, idx))
                {
                    bitmap_kind = BITMAP_PREV_CPI_BOOKMARK;
                }
                else
                {
                    bitmap_kind = BITMAP_PREV_CPI;
                }

                gc = GTK_WIDGET(pagebar)->style->white_gc;
            }
            else
            {
                if (is_page_marked(pagebar->bookmarks, idx))
                {
                    bitmap_kind = BITMAP_SUCC_CPI_BOOKMARK;
                }
                else
                {
                    bitmap_kind = BITMAP_SUCC_CPI;
                }

                gc = pagebar->own_gc;
            }

            // draw adjacent page
            y = pagebar->cpi_area.y + (g_bitmap_data.cpi_height - g_bitmap_data.page_field_height);

            pagebar_transfer_position(x, y, &display_x, &display_y, FALSE);
            gdk_draw_pixbuf(pagebar->pixmap,
                            NULL, g_bitmap_data.bitmaps[bitmap_kind],
                            0, 0, display_x, display_y,
                            -1, -1,
                            GDK_RGB_DITHER_NONE, 0, 0);

            inc_length = g_bitmap_data.page_field_width;
            size_x = g_bitmap_data.page_field_width;
            size_y = g_bitmap_data.page_field_height;
        }

        sprintf(text, "%d", idx);
        pango_layout_set_text(pagebar->pango_layout, text, -1);
        pango_layout_get_pixel_size(pagebar->pango_layout, (int *)&w, (int *)&h);
        //pagebar_transfer_position(x, y, &display_x, &display_y, FALSE);
        gdk_draw_layout(pagebar->pixmap,
                        gc,
                        display_x + (size_x - w) / 2,
                        display_y + (size_y - h) / 2,
                        pagebar->pango_layout);

        if (idx == pagebar->current_page || idx == (pagebar->current_page - 1))
        {
            x += (inc_length + PAGEBAR_CPI_SPACE);
        }
        else
        {
            x += (inc_length + PAGEBAR_CPI_ADJACENT_SPACE);
        }
    }
}

void pagebar_draw_overview(GtkPagebar * pagebar)
{
    int pagebar_width = pagebar->pagebar_width;
    // int pagebar_height = pagebar->pagebar_height;

    // calculate the left length and right length
    int left_length = 0, right_length = 0;
    int cpi_right = pagebar->cpi_area.x + pagebar->cpi_area.width;

    int x = 0;
    int y = pagebar->cpi_area.y + (g_bitmap_data.cpi_height - g_bitmap_data.page_field_height) +
        ((g_bitmap_data.page_field_height - PAGEBAR_INDICATOR_LINE_HEIGHT) >> 1) + 2;
    int display_x = 0, display_y = 0;

    // reset the offsets of indicators
    pagebar->left_indicator_offset = 0;
    pagebar->right_indicator_offset = 0;

    char text[16] = { 0 };
    unsigned int w = 0, h = 0;

    // draw the first page and last page
    gboolean draw_first = TRUE;
    gboolean draw_last  = TRUE;
    if (pagebar->cpi_area.x == 0)
    {
        draw_first = FALSE;
        right_length = pagebar_width - g_bitmap_data.page_field_width - cpi_right;
        x = cpi_right;
    }
    if (pagebar->cpi_area.x == (pagebar_width - pagebar->cpi_area.width))
    {
        draw_last = FALSE;
        left_length = pagebar->cpi_area.x - g_bitmap_data.page_field_width;
        x = g_bitmap_data.page_field_width;
    }
    else
    {
        left_length = pagebar->cpi_area.x - g_bitmap_data.page_field_width;
        right_length = pagebar_width - cpi_right - g_bitmap_data.page_field_width;
        x = g_bitmap_data.page_field_width;
    }

    int left_indicators_num = left_length / (PAGEBAR_INDICATOR_LINE_WIDTH +
        PAGEBAR_INDICATOR_SPACE);
    if (left_indicators_num > 0)
    {
        int left_indicators_len = left_indicators_num * (PAGEBAR_INDICATOR_LINE_WIDTH +
            PAGEBAR_INDICATOR_SPACE);
        pagebar->left_indicator_offset = (((PAGEBAR_INDICATOR_SPACE << 1) +
                PAGEBAR_INDICATOR_LINE_WIDTH) >> 1);
        if (left_indicators_len != left_length)
        {
            pagebar->left_indicator_offset += ((left_length - left_indicators_len) >> 1);
        }
        left_indicators_num--;
    }

    int right_indicators_num = right_length / (PAGEBAR_INDICATOR_LINE_WIDTH +
        PAGEBAR_INDICATOR_SPACE);
    if (right_indicators_num > 0)
    {
        int right_indicators_len = right_indicators_num * (PAGEBAR_INDICATOR_LINE_WIDTH +
            PAGEBAR_INDICATOR_SPACE);
        pagebar->right_indicator_offset = (((PAGEBAR_INDICATOR_SPACE << 1) +
                PAGEBAR_INDICATOR_LINE_WIDTH) >> 1);
        if (right_indicators_len != right_length)
        {
            pagebar->right_indicator_offset += ((right_length - right_indicators_len) >> 1);
        }
        right_indicators_num--;
    }

    // draw page indicators
    GdkColor color;
    color.pixel = PAGEBAR_INDICATOR_COLOR;
    gdk_gc_set_foreground(pagebar->own_gc, &color);
    gdk_gc_set_line_attributes(pagebar->own_gc,
                               PAGEBAR_INDICATOR_LINE_WIDTH,
                               GDK_LINE_SOLID,
                               GDK_CAP_PROJECTING,
                               GDK_JOIN_MITER);

    x += pagebar->left_indicator_offset;
    int idx = 0;
    while (idx < left_indicators_num)
    {
        pagebar_transfer_position(x, y, &display_x, &display_y, FALSE);
        gdk_draw_line(pagebar->pixmap,
                      pagebar->own_gc,
                      display_x, display_y,
                      display_x, display_y + PAGEBAR_INDICATOR_LINE_HEIGHT);

        idx++;
        x += (PAGEBAR_INDICATOR_SPACE + PAGEBAR_INDICATOR_LINE_WIDTH);
    }

    color.pixel = 0;
    gdk_gc_set_foreground(pagebar->own_gc, &color);
    x = cpi_right + pagebar->right_indicator_offset;
    idx = 0;
    while (idx < right_indicators_num)
    {
        pagebar_transfer_position(x, y, &display_x, &display_y, FALSE);
        gdk_draw_line(pagebar->pixmap,
                      pagebar->own_gc,
                      display_x, display_y,
                      display_x, display_y + PAGEBAR_INDICATOR_LINE_HEIGHT);

        idx++;
        x += (PAGEBAR_INDICATOR_SPACE + PAGEBAR_INDICATOR_LINE_WIDTH);
    }

    // draw first page and last page field
    int bitmap_kind = BITMAP_SUCC_CPI;
    // update y to draw the first and last page indicator
    y = pagebar->cpi_area.y + (g_bitmap_data.cpi_height - g_bitmap_data.page_field_height);
    if (draw_first)
    {
        // draw page 1.
        x = 0;

        if (is_page_marked(pagebar->bookmarks, 1))
        {
            bitmap_kind = BITMAP_PREV_CPI_BOOKMARK;
        }
        else
        {
            bitmap_kind = BITMAP_PREV_CPI;
        }

        pagebar_transfer_position(x, y, &display_x, &display_y, FALSE);
        gdk_draw_pixbuf(pagebar->pixmap, NULL,
                        g_bitmap_data.bitmaps[bitmap_kind],
                        0, 0, display_x, display_y, -1, -1,
                        GDK_RGB_DITHER_NONE, 0, 0);

        sprintf(text, "1");
        pango_layout_set_text(pagebar->pango_layout, text, -1);
        pango_layout_get_pixel_size(pagebar->pango_layout, (int *)&w,(int*)&h);
        // make sure position is transformed before
        gdk_draw_layout(pagebar->pixmap,
                        GTK_WIDGET(pagebar)->style->white_gc,
                        display_x + ((g_bitmap_data.page_field_width - w) >> 1),
                        display_y + ((g_bitmap_data.page_field_height - h) >> 1),
                        pagebar->pango_layout);
    }

    if (draw_last)
    {
        // draw last page
        x = pagebar_width - g_bitmap_data.page_field_width;

        if (is_page_marked(pagebar->bookmarks, pagebar->page_count))
        {
            bitmap_kind = BITMAP_SUCC_CPI_BOOKMARK;
        }
        else
        {
            bitmap_kind = BITMAP_SUCC_CPI;
        }

        pagebar_transfer_position(x, y, &display_x, &display_y, FALSE);
        gdk_draw_pixbuf(pagebar->pixmap,
                        NULL,
                        g_bitmap_data.bitmaps[bitmap_kind],
                        0, 0, display_x, display_y, -1, -1,
                        GDK_RGB_DITHER_NONE, 0, 0);

        // set own gc to draw text of last page
        GdkColor color;
        color.pixel = PAGEBAR_LAST_PAGE_TEXT_COLOR;
        gdk_gc_set_foreground(pagebar->own_gc, &color);

        sprintf(text, "%d", pagebar->page_count);
        pango_layout_set_text(pagebar->pango_layout, text, -1);
        pango_layout_get_pixel_size(pagebar->pango_layout, (int *)&w, (int *)&h);

        gdk_draw_layout(pagebar->pixmap,
                        pagebar->own_gc,
                        display_x + ((g_bitmap_data.page_field_width - w) >> 1),
                        display_y + ((g_bitmap_data.page_field_height - h) >> 1),
                        pagebar->pango_layout);
    }
}

void pagebar_draw_cpi_overview(GtkPagebar * pagebar)
{
    unsigned int cpi_pages_count = 0;
    unsigned int idx = 0;
    int x = pagebar->cpi_area.x;
    int y = 0;
    char text[16] = { 0 };
    int w = 0, h = 0;
    int inc_length = 0;
    int display_x = 0, display_y = 0;

    // int pagebar_width = pagebar->pagebar_width;
    // int pagebar_height = pagebar->pagebar_height;

    if (pagebar->current_page <= 1 + PAGEBAR_ADJACENT_PAGES_NUM)
    {
        // cpi = 1 +...+ x + x+1 + x+2
        idx = 1;
        cpi_pages_count = pagebar->current_page + PAGEBAR_ADJACENT_PAGES_NUM;
    }
    else if (pagebar->current_page >= pagebar->page_count - PAGEBAR_ADJACENT_PAGES_NUM)
    {
        // cpi = x-2 + x-1 + x +...+ last page
        idx = pagebar->current_page - PAGEBAR_ADJACENT_PAGES_NUM;
        cpi_pages_count = pagebar->page_count;
    }
    else
    {
        idx = pagebar->current_page - PAGEBAR_ADJACENT_PAGES_NUM;
        cpi_pages_count = pagebar->current_page + PAGEBAR_ADJACENT_PAGES_NUM;
    }

    int bitmap_kind = BITMAP_SUCC_CPI;

    // reset the own gc to draw the text after current page
    GdkColor color;
    color.pixel = PAGEBAR_NEXT_PAGE_TEXT_COLOR;
    gdk_gc_set_foreground(pagebar->own_gc, &color);

    for (; idx <= cpi_pages_count; ++idx)
    {
        GdkGC *gc = GTK_WIDGET(pagebar)->style->black_gc;
        int size_x = 0;
        int size_y = 0;
        if (idx == pagebar->current_page)
        {
            // draw CPI
            y = pagebar->cpi_area.y;

            if (is_page_marked(pagebar->bookmarks, idx))
            {
                bitmap_kind = BITMAP_CPI_BOOKMARK;
            }
            else
            {
                bitmap_kind = BITMAP_CPI;
            }

            pagebar_transfer_position(x, y, &display_x, &display_y, FALSE);
            gdk_draw_pixbuf(pagebar->pixmap,
                NULL, g_bitmap_data.bitmaps[bitmap_kind],
                0, 0, display_x, display_y,
                g_bitmap_data.cpi_width,
                g_bitmap_data.cpi_height,
                GDK_RGB_DITHER_NONE, 0, 0);

            inc_length = g_bitmap_data.cpi_width;
            gc = GTK_WIDGET(pagebar)->style->white_gc;

            size_x = g_bitmap_data.cpi_width;
            size_y = g_bitmap_data.cpi_height;
        }
        else
        {
            // draw adjacent page
            y = pagebar->cpi_area.y + (g_bitmap_data.cpi_height - g_bitmap_data.page_field_height);

            if (idx < pagebar->current_page)
            {
                if (is_page_marked(pagebar->bookmarks, idx))
                {
                    bitmap_kind = BITMAP_PREV_CPI_BOOKMARK;
                }
                else
                {
                    bitmap_kind = BITMAP_PREV_CPI;
                }

                gc = GTK_WIDGET(pagebar)->style->white_gc;
            }
            else
            {
                if (is_page_marked(pagebar->bookmarks, idx))
                {
                    bitmap_kind = BITMAP_SUCC_CPI_BOOKMARK;
                }
                else
                {
                    bitmap_kind = BITMAP_SUCC_CPI;
                }

                gc = pagebar->own_gc;
            }

            pagebar_transfer_position(x, y, &display_x, &display_y, FALSE);
            gdk_draw_pixbuf(pagebar->pixmap,
                NULL, g_bitmap_data.bitmaps[bitmap_kind],
                0, 0, display_x, display_y,
                -1, -1,
                GDK_RGB_DITHER_NONE, 0, 0);

            inc_length = g_bitmap_data.page_field_width;

            size_x = g_bitmap_data.page_field_width;
            size_y = g_bitmap_data.page_field_height;
        }

        sprintf(text, "%d", idx);
        pango_layout_set_text(pagebar->pango_layout, text, -1);
        pango_layout_get_pixel_size(pagebar->pango_layout, (int *)&w, (int *)&h);

        pagebar_transfer_position(x, y, &display_x, &display_y, FALSE);
        gdk_draw_layout(pagebar->pixmap,
                        gc,
                        display_x + (size_x - w) / 2,
                        display_y + (size_y - h) / 2,
                        pagebar->pango_layout);

        if (idx == pagebar->current_page || idx == pagebar->current_page - 1)
        {
            x += (inc_length + PAGEBAR_CPI_SPACE);
        }
        else
        {
            x += (inc_length + PAGEBAR_CPI_ADJACENT_SPACE);
        }
    }
}

void pagebar_draw_cpi_shrink(GtkPagebar * pagebar)
{
    int x = pagebar->cpi_area.x;
    int y = pagebar->cpi_area.y;
    char text[16] = { 0 };
    int w = 0, h = 0;

    int bitmap_kind = BITMAP_CPI;

    if (is_page_marked(pagebar->bookmarks, pagebar->current_page))
    {
        bitmap_kind = BITMAP_CPI_BOOKMARK;
    }

    pagebar_transfer_position(x, y, &x, &y, FALSE);
    gdk_draw_pixbuf(pagebar->pixmap,
                    NULL, g_bitmap_data.bitmaps[bitmap_kind],
                    0, 0, x, y,
                    g_bitmap_data.cpi_width,
                    g_bitmap_data.cpi_height,
                    GDK_RGB_DITHER_NONE, 0, 0);

    sprintf(text, "%d", pagebar->current_page);
    pango_layout_set_text(pagebar->pango_layout, text, -1);
    pango_layout_get_pixel_size(pagebar->pango_layout, (int *)&w, (int *)&h);
    gdk_draw_layout(pagebar->pixmap,
                    GTK_WIDGET(pagebar)->style->white_gc,
                    x + (g_bitmap_data.cpi_width - w) / 2,
                    y + (g_bitmap_data.cpi_height - h) / 2,
                    pagebar->pango_layout);

}

void gtk_pagebar_update(GtkPagebar * pagebar)
{
    gtk_pagebar_draw(pagebar);
}