main_window.cpp

Go to the documentation of this file.

/*
 * File Name: main_window.cpp
 */

/*
 * This file is part of liberscribble.
 *
 * liberscribble 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.
 *
 * liberscribble 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 <gdk/gdkkeysyms.h>
#include <sstream>

#include "main_window.h"

namespace test
{

MainWindow::MainWindow()
: main_window(0)
, source(this)
, erscribble_mgr()
, erscribble_gc()
, cur_page_id()
, page_number(0)
, erscribble_status(-1)
, erase_status(-1)
, erscribble_mode(true)
, target_doc_path("test")
{
    create();

    std::stringstream str;
    str << page_number;
    int num = page_number;
    erscribble_mgr.generate_page_id(cur_page_id, str.str(), num);
    page_number = num;

    add_document_to_db();

    int len1 = sizeof(unsigned long);
    int len2 = sizeof(unsigned short);
    int len3 = sizeof(int);
    int len4 = sizeof(float);
}

MainWindow::~MainWindow()
{
    gdk_gc_unref(erscribble_gc.gc);
    destroy();

    erscribble_mgr.close();
    gtk_main_quit();
}

void MainWindow::add_document_to_db()
{
    // 1. parse the folder and file name
    //size_t idx = target_doc_path.rfind('\\');
    //std::string folder = target_doc_path.substr(0, idx);
    //std::string file_name = target_doc_path.substr(idx + 1, target_doc_path.length());

    // 2. open the database
    /*erMetadb *metadata_db = ermetadb_new();
    GString *folder_str = g_string_new(folder.c_str());
    GString *file_name_str = g_string_new(file_name.c_str());
    ermetadb_open_database(metadata_db, folder_str);

    ermetadb_add_document(metadata_db, file_name_str, 10, 1000);

    ermetadb_close_database(metadata_db);
    ermetadb_free(metadata_db);

    g_string_free(folder_str, TRUE);
    g_string_free(file_name_str, TRUE);*/
}

/// Create the main widget. The main widget will be 
/// used as container for all ViewCtrl and the sub views.
void MainWindow::create()
{
    // check
    if (main_window)
    {
        printf("Main window has already been created %p!\n", main_window);
        return;
    }

    // create main window
    main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_fullscreen(GTK_WINDOW(main_window));

    // initialize the display
    //Display * display = gdk_x11_display_get_xdisplay(gdk_display_get_default());
    //GlobalComponents::instance().set_display(display);

    printf("View window %p create done!\n", main_window);

    // install event handlers
    connect_event_handlers(main_window);

    // add document into database if it does not exist
    add_document_to_db();
    // initialize the scribble manager
    // scribble manager cannot be used when open fails.
    erscribble_mgr.open(target_doc_path.c_str());

}

void MainWindow::show(bool show)
{
    if (show)
    {
        gtk_widget_show(main_window);
    }
    else
    {
        gtk_widget_hide(main_window);
    }
}

/// Destroy the main widget and related resouce.
void MainWindow::destroy()
{
    g_object_unref(main_window);
    main_window = 0;
}

    /// @brief Enable main window to handle events.
void MainWindow::connect_event_handlers(GtkWidget *widget)
{
    /// Install event handlers by using member functions.
    source.connect_event_handlers(widget);
    source.set_event_handler(EventSource::EVENT_EXPOSE,
                             &MainWindow::on_expose);
    source.set_event_handler(EventSource::EVENT_CONFIG,
                             &MainWindow::on_configure);
    source.set_event_handler(EventSource::EVENT_BUTTON_PRESS,
                             &MainWindow::on_button_press);
    source.set_event_handler(EventSource::EVENT_BUTTON_RELEASE,
                             &MainWindow::on_button_release);
    source.set_event_handler(EventSource::EVENT_MOTION_NOTIFY,
                             &MainWindow::on_motion_notify);
    source.set_event_handler(EventSource::EVENT_KEY_PRESS,
                             &MainWindow::on_key_press);
    source.set_event_handler(EventSource::EVENT_KEY_RELEASE,
                             &MainWindow::on_key_release);
    source.set_event_handler(EventSource::EVENT_DELETE,
                             &MainWindow::on_delete);
}

void MainWindow::update()
{
    // clear background
    GdkColor white = {0, 0xffff, 0xffff, 0xffff};
    gdk_gc_set_rgb_fg_color(erscribble_gc.gc, &white);
    gdk_draw_rectangle(main_window->window,
                       erscribble_gc.gc,
                       TRUE,
                       0, 0, 
                       main_window->allocation.width,
                       main_window->allocation.height);
    draw_scribble_page();
}

gboolean MainWindow::on_expose(GtkWidget *widget, 
                               GdkEvent *event) 
{
    update();
    return TRUE;
}

gboolean MainWindow::on_configure(GtkWidget *widget, 
                               GdkEvent *event) 
{
    // initialize the scribble gc
    if (erscribble_gc.gc)
    {
        gdk_gc_unref(erscribble_gc.gc);
    }

    erscribble_gc.widget = main_window;
    erscribble_gc.gc = gdk_gc_new(main_window->window);
    erscribble_gc.realZoom = 100.0f;
    erscribble_gc.rotation = 0;
    return TRUE;
}

gboolean MainWindow::on_button_press(GtkWidget *widget, 
                                     GdkEvent *event)
{
    // Record the position inside the widget.
    GdkEventButton * button_event = reinterpret_cast<GdkEventButton *>(event);

    // Usually, on the device, only the left button.
    switch (button_event->button)
    {
    case 1:
        {
            ScbPoint pos;
            pos.x = static_cast<int>(((GdkEventButton*)event)->x);
            pos.y = static_cast<int>(((GdkEventButton*)event)->y);

            if (erscribble_mode)
            {
                if (erscribble_status < 0)
                {
                    erscribble_status = 0;
                    scribble(pos, erscribble_status);
                }
            }
            else
            {
                if (erase_status < 0)
                {
                    erase_status = 0;
                    erase(pos, erase_status);
                }
            }
        }
        break;
    default:
        break;
    }

    return TRUE;
}

gboolean MainWindow::on_button_release(GtkWidget *widget, 
                                       GdkEvent *event) 
{
    // Record the position inside the widget.
    GdkEventButton * button_event = reinterpret_cast<GdkEventButton *>(event);

    // Usually, on the device, only the left button.
    switch (button_event->button)
    {
    case 1:
        {
            ScbPoint pos;
            pos.x = static_cast<int>(((GdkEventButton*)event)->x);
            pos.y = static_cast<int>(((GdkEventButton*)event)->y);

            if (erscribble_mode)
            {
                if (erscribble_status >= 0)
                {
                    erscribble_status = 2;
                    scribble(pos, erscribble_status);

                    // reset the status
                    erscribble_status = -1;
                }
            }
            else
            {
                if (erase_status >= 0)
                {
                    erase_status = 2;
                    erase(pos, erase_status);

                    // reset the status
                    erase_status = -1;
                }
            }
        }
        break;
    default:
        break;
    }

    return TRUE;
}

gboolean MainWindow::on_motion_notify(GtkWidget *widget, 
                                      GdkEvent *event)
{
    ScbPoint pos;
    pos.x = static_cast<int>(((GdkEventButton*)event)->x);
    pos.y = static_cast<int>(((GdkEventButton*)event)->y);

    if (erscribble_mode)
    {
        if (erscribble_status == 0)
        {
            erscribble_status = 1;
        }

        if (erscribble_status == 1)
        {
            scribble(pos, erscribble_status);
        }
    }
    else
    {
        if (erase_status == 0)
        {
            erase_status = 1;
        }

        if (erase_status == 1)
        {
            erase(pos, erase_status);
        }
    }
    return TRUE;
}

gboolean MainWindow::on_key_press(GtkWidget *widget,
                                GdkEvent *event)
{
    return FALSE;
}

void MainWindow::goto_prev_page()
{
    erscribble_mgr.save();

    page_number --;
    int num = page_number;
    std::stringstream str;
    str << page_number;
    erscribble_mgr.generate_page_id(cur_page_id, str.str(), num);
    page_number = num;
    update();
    show(0);
    show(1);
}

void MainWindow::goto_next_page()
{
    erscribble_mgr.save();

    page_number ++;
    int num = page_number;
    std::stringstream str;
    str << page_number;
    erscribble_mgr.generate_page_id(cur_page_id, str.str(), num);
    page_number = num;
    update();
    show(0);
    show(1);
}

gboolean MainWindow::on_key_release(GtkWidget *widget,
                                  GdkEvent *event)
{
    guint key_code = ((GdkEventKey*)event)->keyval;

    switch(key_code)
    {
    case GDK_Up:
        
        //Turn to the previous page
        goto_prev_page();

        break;
    case GDK_Down:
        
        //Turn to the next page
        goto_next_page();

        break;
    
    case GDK_Left:
    case GDK_Right:

        erscribble_mode = !erscribble_mode;

        break;

    case GDK_Return:
        erscribble_mgr.clear_page(cur_page_id);
        show(0);
        show(1);
        break;

    default:
        break;
    }
    return FALSE;
}

gboolean MainWindow::on_delete(GtkWidget *widget,
                              GdkEvent *event)
{
    return FALSE;
}

void MainWindow::draw_scribble_page()
{
    erscribble_mgr.draw_scribble_page(cur_page_id, erscribble_gc, 0, 0);
}

void MainWindow::scribble(const ScbPoint &pos, int status)
{
    
    switch(status)
    {
    case 0:
        erscribble_mgr.on_scribble_begin(cur_page_id
            , erscribble_gc
            , pos.x
            , pos.y
            , pos.x
            , pos.y
            , 0
            , 0);

        break;
    case 1:
        erscribble_mgr.on_scribble_move(cur_page_id
            , erscribble_gc
            , pos.x
            , pos.y
            , pos.x
            , pos.y
            , 0
            , 0);

        break;
    case 2:
        erscribble_mgr.on_scribble_end(cur_page_id
            , erscribble_gc
            , pos.x
            , pos.y
            , pos.x
            , pos.y
            , 0
            , 0);

        break;
    default:
        break;
    }
}

void MainWindow::erase(const ScbPoint &pos, int status)
{
    switch(status)
    {
    case 0:
        erscribble_mgr.on_erase_begin(cur_page_id
            , erscribble_gc
            , pos.x
            , pos.y
            , pos.x
            , pos.y
            , 0
            , 0);

        break;
    case 1:
        erscribble_mgr.on_erase_move(cur_page_id
            , erscribble_gc
            , pos.x
            , pos.y
            , pos.x
            , pos.y
            , 0
            , 0);

        break;
    case 2:
        erscribble_mgr.on_erase_end(cur_page_id
            , erscribble_gc
            , pos.x
            , pos.y
            , pos.x
            , pos.y
            , 0
            , 0);

        break;
    default:
        break;
    }
}


} //namespace uds