notepad_window.cpp

Go to the documentation of this file.

/*
 * File Name: notepad_window.cpp
 */

/*
 * This file is part of notepad.
 *
 * notepad 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.
 *
 * notepad 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) 2010 IREX Technologies B.V.
 * All rights reserved.
 */

#include <cstring>
#include <glib.h>
#include <gdk/gdkkeysyms.h>
#include "notepad_rename.h"
#include <libergtk/erGtkDialogJumpToPage.h>

#include "log.h"
#include "i18n.h"
#include "notepad_display_sched.h"
#include "notepad_ipc.h"
#include "notepad_doc.h"
#include "notepad_pages.h"
#include "notepad_window.h"
#include "notepad_point.h"
#include "notepad_thumbnail.h"

namespace notepad 
{

    static const char ILLEGAL_FILENAME_CHARS[] = "/\\:*?<>|"; // forbidden filename characthers

    CNotepadWindow::CNotepadWindow()
        : main_window(0)
        , source(this)
        , notepad_doc()
        , notepad_pages()
        , gctx()
        , current_image(0)
        , erscribble_mode(TRUE)
        , erscribble_status(-1)
        , erase_status(-1)
        , current_page(1) 
        , invert_pageturn(FALSE)
        , skip_expose_events(FALSE)
        , doublepagefliptimout(0)
    {

    }

    bool CNotepadWindow::init(bool docreate, const gchar* filename)
    {
        //document
        np_result res = NP_OK;
        if (docreate)
        {
            res = notepad_doc.create(filename);
        }
        else
        {
            res = notepad_doc.open(filename);
        }

        if (res != NP_OK) 
        {
            menu_block(TRUE);
            GtkWidget* openfaildialog = gtk_message_dialog_new(
                    GTK_WINDOW(main_window), 
                    GTK_DIALOG_MODAL,
                    GTK_MESSAGE_WARNING, 
                    GTK_BUTTONS_OK,
                    (docreate) ? 
                        _("A new note cannot be created at this time. \n"
                          "It is possible that the memory card is full. "
                          "Consider deleting some items and then try again.")
                        : 
                        _("The note could not be opened. \n"
                          "It is possible that the file has been corrupted."));

            gtk_dialog_run(GTK_DIALOG(openfaildialog));
            menu_block(FALSE);
            gtk_widget_destroy(openfaildialog);

            return false;
        }

        //window
        main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        connect_event_handlers(main_window);
        g_signal_connect(main_window, "destroy", G_CALLBACK(gtk_widget_destroyed), &main_window);
        gtk_window_maximize(GTK_WINDOW(main_window));

        //page
        if ( notepad_doc.get_num_pages() < 1 )
        {
            notepad_doc.insert_page(current_page);
        }
        else
        {
            int num = notepad_doc.get_last_read();
            if (num > 0 )
            {
                current_page = num;
            }
        }

        // initialize pages cache
        gtk_widget_realize(main_window); // need gdk window now for depth/visual
        GdkVisual* visual = gdk_drawable_get_visual(GDK_DRAWABLE(main_window->window));
        notepad_pages.init(&notepad_doc, &gctx, current_page, visual); 

        // create gdk graphical context
        if (gctx.gc == 0)
        {
           gctx.gc = gdk_gc_new(GDK_DRAWABLE(main_window->window));
        }


        return true;
    }

    CNotepadWindow::~CNotepadWindow()
    {
        notepad_doc.set_last_read(current_page); // store the current page number
        notepad_doc.close(); // close scribble
        disconnect_event_handlers(main_window); // unref GDK events
        notepad_pages.stop();

        if (main_window)
        {
            gtk_widget_destroy(main_window);
            main_window = 0;
        }
        if (gctx.gc != 0)
        {
            g_object_unref(G_OBJECT(gctx.gc));
            gctx.gc = 0;
        }
    }

    void CNotepadWindow::quit()
    {
        LOGPRINTF("entry");

        CThumbnail saveThumbnail(*notepad_doc.getFileStore(), notepad_pages, gctx.margin); // store thumbnail

        notepad_pages.stop();
        gtk_main_quit();
    }

    GtkWidget* CNotepadWindow::getWindow()
    {
        return main_window;
    }

    gchar* CNotepadWindow::getLabel()
    {
        CFileStore* store = notepad_doc.getFileStore();
        return store->getFileNameFilePartNoExt();
    }

    const gchar* CNotepadWindow::getFilename()
    {
        CFileStore* store = notepad_doc.getFileStore();
        return store->getFilename();
    }


    void CNotepadWindow::show(bool show)
    {
        LOGPRINTF("entry");
        if (show)
            gtk_widget_show(main_window);
        else
            gtk_widget_hide(main_window);
        LOGPRINTF("exit");
    }

    void CNotepadWindow::connect_event_handlers(GtkWidget *widget)
    {
        // Install event handlers by using member functions.
        source.connect_event_handlers(widget);
        source.set_event_handler(EventSource::EVENT_EXPOSE,
                &CNotepadWindow::on_expose);
        source.set_event_handler(EventSource::EVENT_VISIBILITY_NOTIFY,
                &CNotepadWindow::on_visibility_notify);
        source.set_event_handler(EventSource::EVENT_CONFIG,
                &CNotepadWindow::on_configure);
        source.set_event_handler(EventSource::EVENT_BUTTON_PRESS,
                &CNotepadWindow::on_button_press);
        source.set_event_handler(EventSource::EVENT_BUTTON_RELEASE,
                &CNotepadWindow::on_button_release);
        source.set_event_handler(EventSource::EVENT_MOTION_NOTIFY,
                &CNotepadWindow::on_motion_notify);
        source.set_event_handler(EventSource::EVENT_KEY_PRESS,
                &CNotepadWindow::on_key_press);
        source.set_event_handler(EventSource::EVENT_KEY_RELEASE,
                &CNotepadWindow::on_key_release);
        source.set_event_handler(EventSource::EVENT_DELETE,
                &CNotepadWindow::on_delete);
    }

    void CNotepadWindow::on_configure(GdkEvent* event)
    {
        LOGPRINTF("entry");

        // At first we need to update all widget related stuffs.
        GdkEventConfigure *cfg_event = reinterpret_cast<GdkEventConfigure *>(event);

        // Ignore 2nd configure event while rotating
        // Recognized if send_event is true
        if (cfg_event->send_event == TRUE)
        {
            LOGPRINTF("exit, skipped, send_event == true");
            return;
        }

        // Check if size has changed
        if (  (gctx.width  == cfg_event->width )
           && (gctx.height == cfg_event->height) )
        {
            LOGPRINTF("exit, size not changed, skip");
            return;
        }

        // set_rotation
        set_rotation( ipc_get_rotation() );

        LOGPRINTF("exit");
    }

    void CNotepadWindow::on_expose(GdkEvent* event)
    {
        LOGPRINTF("entry");
        static bool blockedstate = false;

        // dont upate while being rotated
        if (skip_expose_events)
        {
            blockedstate = true;
            LOGPRINTF("exit, skipped");
            return;
        }
        if (blockedstate)
        {
            blockedstate = false;
        }
        if (gctx.gc != 0)
        {
            update(); // refresh screen
        }

        LOGPRINTF("exit");
    }

    void CNotepadWindow::on_visibility_notify(GdkEvent* event)
    {
        // Block expose events while rotating the x-server.
        // Rotating begins with a GDK_VISIBILITY_FULLY_OBSCURED event
        // and ends with a GDK_VISIBILITY_UNOBSCURED event

        GdkEventVisibility* v_event = reinterpret_cast<GdkEventVisibility *>(event);
        LOGPRINTF("%d", v_event->state);
        if (!skip_expose_events) 
        {
            if (v_event->state == GDK_VISIBILITY_FULLY_OBSCURED)
            {
                skip_expose_events = true;
                LOGPRINTF("GDK_VISIBILITY_FULLY_OBSCURED, skip_expose_events");
            }
            else
            {
                // Refresh screen now. 
                // NOTE: This is important: otherwise the strokes become invisible when 
                // the popupmenu appears. Because they are drawn on the image and the 
                // delta driver but not on the window. 
                LOGPRINTF("quick refresh screen");
                draw_image_to_window();
            }
        }
        else 
        {
            if (v_event->state == GDK_VISIBILITY_UNOBSCURED)
            {
                skip_expose_events = false;
                LOGPRINTF("GDK_VISIBILITY_UNOBSCURED, pass expose_events and invalidate whole window");
                // invalidate whole area, not only part of, important while rotating
                GdkRectangle rect = {0,0, gctx.width, gctx.height};
                gdk_window_invalidate_rect(main_window->window, &rect, FALSE); 
            }
        }
    }

    void CNotepadWindow::set_rotation(np_rotation rotation)
    {
        // drawn for the first time, or being resized/rotated: set dimensions, create new pixmap and draw 
        LOGPRINTF("entry");

        if (gctx.width != 0 && gctx.height != 0)
        {
            // only in initialized state, that is: after first set_rotation()
            (void) save(); // save current page 
        }

        if (rotation != gctx.rotation)
        {
            LOGPRINTF("change rotation, erase page cache");
            notepad_pages.mark_all_dirty(); // all cached pages are invalid because of rotation
        }

        // inner border
        int width, height;
        gtk_window_get_size(GTK_WINDOW(main_window), &width, &height);

        // root border
        int root_width, root_height;
        gdk_window_get_geometry(gdk_get_default_root_window(), NULL, NULL, &root_width, &root_height, NULL);

        int posx = 0, posy = 0;
        gdk_window_get_position(main_window->window, &posx, &posy);

        gctx.rotation  = rotation; 
        gctx.width     = width;
        gctx.height    = height;

        int my_border = root_height - height;
        gctx.margin = my_border;

        CNPoint::setRotation(rotation);
        CNPoint::setScreen(root_width, root_height);
        CNPoint::setClipBorder(my_border);

        LOGPRINTF("gdk_window_get_position: x = %d, y = %d\n", posx, posy);
        LOGPRINTF("rotation %d", gctx.rotation);
        LOGPRINTF("root_widht %d, root_height %d", root_width, root_height);
        LOGPRINTF("widht %d, height %d", width, height);
        LOGPRINTF("border %d", my_border);

        // Note: screen update called by on_expose event
        LOGPRINTF("exit");
    }

    void CNotepadWindow::disconnect_event_handlers(GtkWidget *widget)
    {
        source.disconnect_event_handlers(widget);
    }

    void CNotepadWindow::on_button_press(GdkEvent* event)
    {
        // Record the position inside the widget.
        GdkEventButton * button_event = reinterpret_cast<GdkEventButton*>(event);
        int win_x = static_cast<int>(button_event->x);
        int win_y = static_cast<int>(button_event->y);

        // Usually, on the device, only the left button.
        switch (button_event->button)
        {
            case 1:
                {
                    CNPoint cpos(win_x, win_y);
                    LOGPRINTF("cpos %d, %d", win_x , win_y);
                    LOGPRINTF(">>cpos %d, %d", cpos.storageView().x, cpos.storageView().y);

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

    void CNotepadWindow::on_button_release(GdkEvent* event)
    {
        // Record the position inside the widget.
        GdkEventButton * button_event = reinterpret_cast<GdkEventButton *>(event);
        int win_x = static_cast<int>(button_event->x);
        int win_y = static_cast<int>(button_event->y);

        // Usually, on the device, only the left button.
        switch (button_event->button)
        {
            case 1:
                {
                    CNPoint cpos(win_x, win_y);

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

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

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

    void CNotepadWindow::on_motion_notify(GdkEvent* event)
    {
        GdkEventButton * button_event = reinterpret_cast<GdkEventButton *>(event);
        int win_x = static_cast<int>(button_event->x);
        int win_y = static_cast<int>(button_event->y);

        CNPoint cpos(win_x, win_y);

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

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

            if (erase_status == 1)
            {
                erase(cpos, erase_status);
            }
        }
    }

    void CNotepadWindow::on_key_press(GdkEvent* event)
    {
    }

    void CNotepadWindow::on_key_release(GdkEvent* event)
    {
        guint key_code = ((GdkEventKey*)event)->keyval;

        switch(key_code)
        {
            case GDK_Page_Up:
            case GDK_Home:
                if (invert_pageturn)
                    goto_relative_page(5);  
                else 
                    goto_relative_page(-5);  
                break;
            case GDK_Page_Down:
            case GDK_End:
                if (invert_pageturn)
                    goto_relative_page(-5);  
                else 
                    goto_relative_page(5);  
                break;
            case GDK_Up:
                if (invert_pageturn)
                    pageflip_forward();
                else 
                    pageflip_back();
                break;
            case GDK_Down:
                if (invert_pageturn)
                    pageflip_back();
                else 
                    pageflip_forward();
                break;
            case GDK_Left:
                pageflip_back();
                break;
            case GDK_Right:
                pageflip_forward();
                break;
            case GDK_Return:
            default:
                break;
        }
    }

    void CNotepadWindow::on_delete(GdkEvent* event)
    {
        quit();
    }

    void CNotepadWindow::scribble(CNPoint& pos, int status)
    {
        switch(status)
        {
            case 0:
                notepad_doc.on_scribble_begin(current_page, gctx, current_image, pos ); 
                break;
            case 1:
                notepad_doc.on_scribble_move(current_page, gctx, current_image, pos ); 
                break;
            case 2:
                notepad_doc.on_scribble_end(current_page, gctx, current_image, pos ); 
                break;
            default:
                break;
        }
    }

    void CNotepadWindow::erase(CNPoint& pos, int status)
    {
        switch(status)
        {
            case 0:
                notepad_doc.on_erase_begin(current_page, gctx, current_image, pos);
                break;
            case 1:
                notepad_doc.on_erase_move(current_page, gctx, current_image, pos);
                break;
            case 2:
                notepad_doc.on_erase_end(current_page, gctx, current_image, pos);
                notepad_pages.mark_dirty(current_page); // mark dirty, deleted lines may overlap existing lines, so redraw is required
                break;
            default:
                break;
        }
    }

    void CNotepadWindow::draw_page_margin()
    {
        // Draw two rectangles around the page as the margin: one lightgrey and one darkgrey.
        // The bottom margin is the statusbar in both potrait and landscape
        LOGPRINTF("entry");

        g_assert(main_window != 0);
        g_assert(main_window->window != 0);

        // Create a fresh graphics context, otherwise the line width will change with pen-size
        GdkGC* border_gc = gdk_gc_new(main_window->window);
        if (border_gc != 0)
        {
            gdk_gc_set_line_attributes(border_gc, 3, GDK_LINE_SOLID, GDK_CAP_PROJECTING, GDK_JOIN_MITER);

            GdkColor darkgrey = {0xAAAAAAAA, 0xAAAA, 0xAAAA, 0xAAAA}; 

            // outer rectangle
            gdk_gc_set_rgb_fg_color(border_gc, &darkgrey);

#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
            gdk_draw_rectangle(main_window->window, border_gc, FALSE, gctx.margin-1, gctx.margin-1, (gctx.width - gctx.margin + 1), (gctx.height - gctx.margin + 1));
#endif
#if MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
            gdk_draw_rectangle(main_window->window, border_gc, FALSE, gctx.margin-1, gctx.margin-1, (gctx.width - 2*gctx.margin + 2), (gctx.height - gctx.margin + 1));
#endif

            g_object_unref(border_gc);
        }
        LOGPRINTF("exit");
    }

    void CNotepadWindow::draw_image_to_window()
    {
        // draw region of image within border to display
        if (current_image && main_window &&  main_window->window)
        {
#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
            gdk_draw_image(GDK_DRAWABLE(main_window->window), gctx.gc, current_image, 
                gctx.margin, gctx.margin, 
                gctx.margin, gctx.margin, 
                (gctx.width - gctx.margin), (gctx.height - gctx.margin));
#endif
#if MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
            gdk_draw_image(GDK_DRAWABLE(main_window->window), gctx.gc, current_image, 
                gctx.margin, gctx.margin, 
                gctx.margin, gctx.margin, 
                (gctx.width - 2*gctx.margin), (gctx.height - gctx.margin));
#endif
        }
    }

    void CNotepadWindow::update(bool full)
    {
        LOGPRINTF("entry %d", current_page);

        g_assert(gctx.gc != 0);

        // Ask pages cache for page image. 
        current_image = notepad_pages.get_page(current_page);

        // draw current page image to screen
        draw_image_to_window();

        // draw gray page margin
        draw_page_margin(); 

        // screen update
        if (full) // default
        {
            notepad_stop_display_update(); // full display update 
            notepad_on_idle_display_yield(DM_HINT_FULL);
        }
        else
        {
            notepad_start_display_update(); // nonflashing display update
        }

        LOGPRINTF("exit");
    }

    void CNotepadWindow::goto_relative_page(gint delta)
    {
        gint pageno = current_page + delta;
        LOGPRINTF("current_page %d delta %d pageno %d", current_page, delta, pageno);
        goto_page(pageno);
    }

    void CNotepadWindow::on_jump_to_page_dialog_response(GtkDialog* dialog, gint pageno, gpointer data) 
    {
        LOGPRINTF("entry %d", pageno);
        g_assert(data != 0);

        if (pageno >= 0) // response is negative on cancel (GTK_RESPONSE codes) 
        {
            CNotepadWindow* instance = static_cast<CNotepadWindow*>(data);
            instance->goto_page(pageno);
        }

        menu_block(FALSE);
        gtk_widget_destroy(GTK_WIDGET(dialog));

        LOGPRINTF("exit");
    }

    void CNotepadWindow::goto_page() // show gotopage dialog
    {
        LOGPRINTF("entry");
        (void) save();

        menu_block(TRUE);
        GtkWidget* jumptopagedialog = ergtk_jump_to_page_dialog_new();
        g_signal_connect(jumptopagedialog,
                "response", 
                G_CALLBACK (CNotepadWindow::on_jump_to_page_dialog_response),
                static_cast<gpointer>(this) );
        gtk_widget_show_all(jumptopagedialog);
        LOGPRINTF("exit");
    }

    void CNotepadWindow::goto_page(gint pageno)
    {
        LOGPRINTF("entry %d", pageno);
        (void) save();

        current_page = pageno;
        if (current_page > notepad_doc.get_num_pages()) // limit to range
        {
            current_page = notepad_doc.get_num_pages();
        }
        if (current_page < 1)
        {
            current_page = 1;
        }
        update_page_counter();
        update(); // show new page

        LOGPRINTF("exit");
    }



    void CNotepadWindow::pageflip_or_create()
    {
        LOGPRINTF("entry %d", pageflipto);

        // save previous page and set new page to screen 
        save();

        current_page = pageflipto;

        if (current_page < 1)
        {
            current_page = 1;
        }

        if (current_page > notepad_doc.get_num_pages()) 
        {
            current_page = notepad_doc.get_num_pages() + 1;
            notepad_doc.add_page(current_page);
            notepad_pages.insert_page(current_page);
            LOGPRINTF("increased: %d", current_page);
        }

        LOGPRINTF("to %d", current_page);
        update_page_counter();
        update(); // show new page

        LOGPRINTF("exit");
        doublepagefliptimout = 0;
    }

    gboolean static_pageflip(gpointer data)
    {
        CNotepadWindow* instance = (CNotepadWindow*) data;
        instance->pageflip_or_create(); // given pageno as class variable pageflipto
        return FALSE;
    }


    void CNotepadWindow::pageflip_back()
    {
        LOGPRINTF("entry");

        if (doublepagefliptimout) 
        {
            GSource* gsrc = g_main_context_find_source_by_id(NULL, doublepagefliptimout);
            g_source_destroy(gsrc); // restart delay
            --pageflipto;
        }
        else
        {
            pageflipto = current_page - 1;
        }

        // delay
        doublepagefliptimout = g_timeout_add(500, static_pageflip, this);

        LOGPRINTF("exit");
    }

    void CNotepadWindow::pageflip_forward()
    {
        LOGPRINTF("entry");

        if (doublepagefliptimout) 
        {
            GSource* gsrc = g_main_context_find_source_by_id(NULL, doublepagefliptimout);
            g_source_destroy(gsrc); // restart delay
            ++pageflipto;
        }
        else
        {
            pageflipto = current_page + 1;
        }
        // delay
        doublepagefliptimout = g_timeout_add(500, static_pageflip, this);

        LOGPRINTF("exit");
    }

    void CNotepadWindow::insert_page()
    {
        LOGPRINTF("entry");
        (void) save();

        notepad_doc.insert_page(current_page);
        // note: call pages.insert to keep pagecache in sync // note: perhaps place pages as layer between buffer and doc to prevent double call.
        notepad_pages.insert_page(current_page);

        update_page_counter();
        update(); // show new page
       
        LOGPRINTF("exit");
    }


    void CNotepadWindow::on_sureclear_dialog_response(GtkDialog* dialog, gint response, gpointer data) 
    {
        LOGPRINTF("entry");
        g_assert(data != 0);
        CNotepadWindow* instance = static_cast<CNotepadWindow*>(data);

        if (response == GTK_RESPONSE_YES)
        {
            instance->notepad_doc.clear_page(instance->current_page);
            instance->notepad_pages.clear_page(instance->current_page); // force page cache update
            instance->update(); // show new page
            (void) instance->save();
        }

        menu_block(FALSE);
        gtk_widget_destroy(GTK_WIDGET(dialog));

        LOGPRINTF("exit");
    }

    void CNotepadWindow::on_suredelete_dialog_response(GtkDialog* dialog, gint response, gpointer data) 
    {
        LOGPRINTF("entry");
        g_assert(data != 0);
        CNotepadWindow* instance = static_cast<CNotepadWindow*>(data);

        if (response == GTK_RESPONSE_YES)
        {
            instance->delete_current_page_impl();
        }

        menu_block(FALSE);
        gtk_widget_destroy(GTK_WIDGET(dialog));

        LOGPRINTF("exit");
    }


    void CNotepadWindow::clear_current_page()
    {
        LOGPRINTF("entry");
        GtkWidget* surecleardialog = gtk_message_dialog_new(
                                      GTK_WINDOW(main_window), 
                                      GTK_DIALOG_MODAL,
                                      GTK_MESSAGE_QUESTION, 
                                      GTK_BUTTONS_YES_NO,
                                      _("Are you sure you want to clear the writing from this page?") );

        g_signal_connect(surecleardialog,
                "response", 
                G_CALLBACK (CNotepadWindow::on_sureclear_dialog_response),
                static_cast<gpointer>(this) );
        gtk_widget_show_all(surecleardialog);

        LOGPRINTF("exit");
    }    

    void CNotepadWindow::delete_current_page()
    {
        LOGPRINTF("entry");
        GtkWidget* suredeletedialog = gtk_message_dialog_new(
                                      GTK_WINDOW(main_window), 
                                      GTK_DIALOG_MODAL,
                                      GTK_MESSAGE_QUESTION, 
                                      GTK_BUTTONS_YES_NO,
                                      _("Are you sure you want to delete this page from the notepad?") );

        g_signal_connect(suredeletedialog,
                "response", 
                G_CALLBACK (CNotepadWindow::on_suredelete_dialog_response),
                static_cast<gpointer>(this) );
        gtk_widget_show_all(suredeletedialog);

        LOGPRINTF("exit");
     }

    void CNotepadWindow::delete_current_page_impl()
    {
        LOGPRINTF("entry");

        if (notepad_doc.get_num_pages() <= 1)
        {
            LOGPRINTF("current_pages %d", current_page);
            current_page = 1;
            notepad_doc.clear_page(1);
            notepad_pages.clear_page(1); // force page cache update
        }
        else 
        {
            notepad_doc.delete_page(current_page);
            // note: call pages.delete to keep pagecache in sync
            // note: perhaps place pages as layer between buffer and doc to prevent double call.
            notepad_pages.delete_page(current_page);
            LOGPRINTF("current_pages %d", current_page);

            if (current_page > notepad_doc.get_num_pages())
            {
                LOGPRINTF("current_pages %d", current_page);
                current_page = notepad_doc.get_num_pages();
            }
        }
        update_page_counter();
        update(); // show new page
        
        LOGPRINTF("exit");
    }
    
    void CNotepadWindow::update_page_counter()
    {
        LOGPRINTF("entry");
        ipc_menu_set_pagecounter(current_page, notepad_doc.get_num_pages() );
    }

    void CNotepadWindow::on_failure_dialog_response(GtkDialog* dialog, gint response, gpointer data) 
    {
        LOGPRINTF("entry");
        g_assert(data != 0);
        CNotepadWindow* instance = static_cast<CNotepadWindow*>(data);
        instance->quit();
    }

    gboolean CNotepadWindow::save(bool update_last_read) 
    {
        if (gctx.width == 0 || gctx.height == 0)
        {
            WARNPRINTF("try to save in uninitialized state");
            return FALSE;
        }

        LOGPRINTF("entry");

        // save thumbnail of coverpage at changed page1
        if (current_page == 1 && notepad_doc.get_page_dirty())
        {
            // Note: Call get_page_dirty (to determine need to save thumbnail) before save_page, 
            //       because doc.save_page resets the dirtyflag
            CThumbnail saveThumbnail(*notepad_doc.getFileStore(), notepad_pages, gctx.margin);
        }
        // save page
        np_result res = notepad_doc.save_page(current_page, update_last_read);

        if (res != NP_OK) //exception
        {
            GtkWidget* save_failuredialog = gtk_message_dialog_new(
                                        GTK_WINDOW(main_window), 
                                        GTK_DIALOG_MODAL,
                                        GTK_MESSAGE_WARNING, 
                                        GTK_BUTTONS_OK,
                                        /* TRANSLATORS: 'Notes' refers to the name of the application */
                                        _("The changes to the page could not be saved. \n"
                                          "Notes must close because of this problem."));


            g_signal_connect(save_failuredialog,
                    "response", 
                    G_CALLBACK (CNotepadWindow::on_failure_dialog_response),
                    static_cast<gpointer>(this) );
            gtk_widget_show_all(save_failuredialog);
        }

        return (res == NP_OK);
    }

    // check on empty or invalid filename
    //TODO perhaps store on a more generic library location
    static gboolean check_filename_valid(const char* filename)
    {
        gboolean name_valid = TRUE;
        glong len = strlen(filename);

        if (len == 0)
        {
            // empty filename
            WARNPRINTF("rename to empty filename");
            name_valid = FALSE;
        }
        else if (len > 200)
        {
            // long filename
            WARNPRINTF("filename to long");
            name_valid = FALSE;
        }
        else if (filename[0] == '.')
        {
            // no . allowed on first character
            WARNPRINTF("hiddenfile not allowed");
            name_valid = FALSE;
        } 
        else if (g_unichar_isspace(filename[0]))
        {
            // no space allowed on first character
            WARNPRINTF("no spaces allowed on first character");
            name_valid = FALSE;
        }
        else
        {
            // check on illegal filename characters
            // note: filename can be utf8, but the illegal chars are ascii
            int n_illegal = strlen(ILLEGAL_FILENAME_CHARS);
            for (int i = 0; ((name_valid) && (i < n_illegal)); i++)
            {
                if ( NULL != strchr(filename, ILLEGAL_FILENAME_CHARS[i]) )
                {
                    LOGPRINTF("illegal character %c found", ILLEGAL_FILENAME_CHARS[i]);
                    name_valid = FALSE;
                }
            }
        }
        return name_valid;
    }
   
    void CNotepadWindow::on_rename_dialog_response(GtkDialog* dialog, gint response, gpointer data) 
    {
        LOGPRINTF("entry");
        g_assert(data != 0);
        CNotepadWindow* instance = static_cast<CNotepadWindow*>(data);

        if (response == GTK_RESPONSE_ACCEPT)
        {   
            np_result rename_result = NP_OK;

            const gchar* newfilename = rename_get_text(); 

            gchar* my_file = instance->notepad_doc.get_filename_without_dir_and_ext();
            if (0 == g_strcmp0(newfilename, my_file))
            {
                LOGPRINTF("rename to same file");
                // NOTE: assumed window has saved page before rename.
                rename_result = NP_OK;
            }
            else if ( ! check_filename_valid(newfilename) )
            {
                LOGPRINTF("invalid filename entered %s", newfilename);
                rename_result = NP_NO_FILENAME;
            }
            else
            {
                rename_result = instance->notepad_doc.rename(newfilename);
            }
            g_free(my_file); my_file = 0;


            switch (rename_result)
            {
            case NP_OK:
                break;
            case NP_NO_FILENAME:
                {
                    notepad_stop_display_update();
                    GtkWidget* infodialog = gtk_message_dialog_new(
                                GTK_WINDOW(instance->main_window), 
                                GTK_DIALOG_MODAL,
                                GTK_MESSAGE_WARNING, 
                                GTK_BUTTONS_OK,
                                _("The file name is not valid. \n"
                                  "Remember that  / \\ |: * ? < or > cannot be used in the name and it cannot begin with a space or period.") );

                    notepad_on_timeout_display_yield(400, DM_HINT_FULL);
                    gtk_dialog_run(GTK_DIALOG(infodialog));
                    gtk_widget_destroy(infodialog);
                    rename_set_focus();
                    // return, keep keyboard window alive to enter another name
                    return;
                }
                break;
            case NP_FILE_EXISTS:
                {
                    notepad_stop_display_update();
                    GtkWidget* infodialog = gtk_message_dialog_new(
                                GTK_WINDOW(instance->main_window), 
                                GTK_DIALOG_MODAL,
                                GTK_MESSAGE_WARNING, 
                                GTK_BUTTONS_OK,
                                _("This name has already been used for another note. \n"
                                  "Please choose a different name.") );

                    notepad_on_timeout_display_yield(400, DM_HINT_FULL);
                    gtk_dialog_run(GTK_DIALOG(infodialog));
                    gtk_widget_destroy(infodialog);
                    // return, keep keyboard window alive to enter another name
                    rename_set_focus();
                    return;
                }
                break;
            default:
                {
                    notepad_stop_display_update();
                    GtkWidget* infodialog = gtk_message_dialog_new(
                                GTK_WINDOW(instance->main_window), 
                                GTK_DIALOG_MODAL,
                                GTK_MESSAGE_WARNING, 
                                GTK_BUTTONS_OK,
                                _("The note could not be renamed for an unexpected reason. \n"
                                  "Please try again or contact customer support if you continue to experience this problem.") );

                    notepad_on_timeout_display_yield(400, DM_HINT_FULL);
                    gtk_dialog_run(GTK_DIALOG(infodialog));
                    gtk_widget_destroy(infodialog);
                }
                break;
            }
        }
        menu_block(FALSE);
        gtk_widget_destroy(GTK_WIDGET(dialog));

        LOGPRINTF("exit");
    }

    gboolean CNotepadWindow::rename() 
    {
        LOGPRINTF("entry");

        menu_block(TRUE);
        (void) save();
        gchar* my_file = notepad_doc.get_filename_without_dir_and_ext();
        GtkWidget* renamedialog = rename_dialog_create(main_window, my_file);
        g_signal_connect(renamedialog,
                "response", 
                G_CALLBACK (CNotepadWindow::on_rename_dialog_response),
                static_cast<gpointer>(this) );

        g_free(my_file);
        my_file = 0;
        LOGPRINTF("exit");
        return FALSE;
    }

    void CNotepadWindow::set_scribble_mode(gboolean scribble_mode) // write/erase
    {
        erscribble_mode = scribble_mode;
        update(false); // fills the whitespaces in strokes overlapped with erased strokes
    }
    
    gboolean CNotepadWindow::get_scribble_mode() // get write/erase mode
    {
        return erscribble_mode;
    }

    void     CNotepadWindow::set_pageturn_inverted(gboolean is_inverted)
    { 
        invert_pageturn = is_inverted;
    }
}