notepad::CNotepadWindow Class Reference

#include <notepad_window.h>

Collaboration diagram for notepad::CNotepadWindow:

[legend]

Public Member Functions
	CNotepadWindow ()
	~CNotepadWindow ()
bool	init (bool create, const gchar *filename)
GtkWidget *	getWindow ()
void	show (bool show)
void	quit ()
void	scribble (CNPoint &pos, int status)
void	erase (CNPoint &pos, int status)
void	pageflip_or_create ()
void	pageflip_back ()
void	pageflip_forward ()
void	goto_relative_page (gint delta)
void	goto_page ()
void	goto_page (gint pageno)
void	insert_page ()
void	clear_current_page ()
void	delete_current_page ()
void	delete_current_page_impl ()
void	update_page_counter ()
void	update (bool full=true)
void	set_scribble_mode (gboolean scribble_mode)
gboolean	get_scribble_mode ()
gboolean	save (bool update_last_read=false)
gboolean	rename ()
gchar *	getLabel ()
void	set_rotation (np_rotation nrotation)
void	set_pageturn_inverted (gboolean is_inverted)
const gchar *	getFilename ()

---

Detailed Description

Definition at line 36 of file notepad_window.h.

---

Constructor & Destructor Documentation

notepad::CNotepadWindow::CNotepadWindow

(

)

Definition at line 48 of file notepad_window.cpp.

        : 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)
    {

    }

notepad::CNotepadWindow::~CNotepadWindow

(

)

Definition at line 137 of file notepad_window.cpp.

References notepad::CNotepadDoc::close(), notepad::GCtx::gc, notepad::CNotepadDoc::set_last_read(), and notepad::CNotepadPages::stop().

    {
        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;
        }
    }

Here is the call graph for this function:

---

Member Function Documentation

void notepad::CNotepadWindow::clear_current_page

(

)

Definition at line 844 of file notepad_window.cpp.

References LOGPRINTF.

Referenced by notepad::on_menu_item().

    {
        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");
    }    

Here is the caller graph for this function:

void notepad::CNotepadWindow::delete_current_page

(

)

Definition at line 863 of file notepad_window.cpp.

References LOGPRINTF.

Referenced by notepad::on_menu_item().

    {
        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");
     }

Here is the caller graph for this function:

void notepad::CNotepadWindow::delete_current_page_impl

(

)

Definition at line 882 of file notepad_window.cpp.

References notepad::CNotepadPages::clear_page(), notepad::CNotepadDoc::clear_page(), notepad::CNotepadPages::delete_page(), notepad::CNotepadDoc::delete_page(), notepad::CNotepadDoc::get_num_pages(), LOGPRINTF, update(), and update_page_counter().

    {
        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");
    }

Here is the call graph for this function:

void notepad::CNotepadWindow::erase	(	CNPoint &	pos,
		int	status
	)

Definition at line 550 of file notepad_window.cpp.

References notepad::CNotepadPages::mark_dirty(), notepad::CNotepadDoc::on_erase_begin(), notepad::CNotepadDoc::on_erase_end(), and notepad::CNotepadDoc::on_erase_move().

    {
        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;
        }
    }

Here is the call graph for this function:

gboolean notepad::CNotepadWindow::get_scribble_mode

(

)

Definition at line 1139 of file notepad_window.cpp.

Referenced by notepad::menu_show().

    {
        return erscribble_mode;
    }

Here is the caller graph for this function:

const gchar * notepad::CNotepadWindow::getFilename

(

void

)

Definition at line 177 of file notepad_window.cpp.

References notepad::CFileStore::getFilename(), and notepad::CNotepadDoc::getFileStore().

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

Here is the call graph for this function:

gchar * notepad::CNotepadWindow::getLabel

(

)

Definition at line 171 of file notepad_window.cpp.

References notepad::CFileStore::getFileNameFilePartNoExt(), and notepad::CNotepadDoc::getFileStore().

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

Here is the call graph for this function:

GtkWidget * notepad::CNotepadWindow::getWindow

(

)

Definition at line 166 of file notepad_window.cpp.

    {
        return main_window;
    }

void notepad::CNotepadWindow::goto_page

(

gint

pageno

)

Definition at line 689 of file notepad_window.cpp.

References notepad::CNotepadDoc::get_num_pages(), LOGPRINTF, save(), update(), and update_page_counter().

    {
        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");
    }

Here is the call graph for this function:

void notepad::CNotepadWindow::goto_page

(

)

Definition at line 674 of file notepad_window.cpp.

References ergtk_jump_to_page_dialog_new(), LOGPRINTF, notepad::menu_block(), and save().

Referenced by goto_relative_page(), and notepad::on_menu_item().

    {
        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");
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadWindow::goto_relative_page

(

gint

delta

)

Definition at line 650 of file notepad_window.cpp.

References goto_page(), and LOGPRINTF.

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

Here is the call graph for this function:

bool notepad::CNotepadWindow::init	(	bool	create,
		const gchar *	filename
	)

Definition at line 66 of file notepad_window.cpp.

References notepad::CNotepadDoc::create(), notepad::GCtx::gc, notepad::CNotepadDoc::get_last_read(), notepad::CNotepadDoc::get_num_pages(), notepad::CNotepadPages::init(), notepad::CNotepadDoc::insert_page(), notepad::menu_block(), notepad::NP_OK, and notepad::CNotepadDoc::open().

Referenced by main().

    {
        //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;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadWindow::insert_page

(

)

Definition at line 790 of file notepad_window.cpp.

References notepad::CNotepadPages::insert_page(), notepad::CNotepadDoc::insert_page(), LOGPRINTF, save(), update(), and update_page_counter().

Referenced by notepad::on_menu_item().

    {
        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");
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadWindow::pageflip_back

(

)

Definition at line 749 of file notepad_window.cpp.

References LOGPRINTF, and notepad::static_pageflip().

Referenced by notepad::on_page_change().

    {
        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");
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadWindow::pageflip_forward

(

)

Definition at line 770 of file notepad_window.cpp.

References LOGPRINTF, and notepad::static_pageflip().

Referenced by notepad::on_page_change().

    {
        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");
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadWindow::pageflip_or_create

(

)

Definition at line 711 of file notepad_window.cpp.

References notepad::CNotepadDoc::add_page(), notepad::CNotepadDoc::get_num_pages(), notepad::CNotepadPages::insert_page(), LOGPRINTF, save(), update(), and update_page_counter().

Referenced by notepad::static_pageflip().

    {
        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;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadWindow::quit

(

)

Definition at line 156 of file notepad_window.cpp.

References notepad::CNotepadDoc::getFileStore(), LOGPRINTF, notepad::GCtx::margin, and notepad::CNotepadPages::stop().

Referenced by notepad::on_menu_item(), notepad::on_prepare_unmount(), notepad::on_volume_unmounted(), and notepad::on_window_deactivated().

    {
        LOGPRINTF("entry");

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

        notepad_pages.stop();
        gtk_main_quit();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean notepad::CNotepadWindow::rename

(

)

Definition at line 1114 of file notepad_window.cpp.

References notepad::CNotepadDoc::get_filename_without_dir_and_ext(), LOGPRINTF, notepad::menu_block(), rename_dialog_create(), and save().

Referenced by notepad::on_menu_item().

    {
        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;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean notepad::CNotepadWindow::save

(

bool

update_last_read = false

)

Definition at line 927 of file notepad_window.cpp.

References notepad::CNotepadDoc::get_page_dirty(), notepad::CNotepadDoc::getFileStore(), notepad::GCtx::height, LOGPRINTF, notepad::GCtx::margin, notepad::NP_OK, notepad::CNotepadDoc::save_page(), WARNPRINTF, and notepad::GCtx::width.

Referenced by goto_page(), insert_page(), notepad::on_menu_item(), notepad::on_prepare_standby(), notepad::on_prepare_unmount(), notepad::on_window_activated(), notepad::on_window_deactivated(), pageflip_or_create(), rename(), and set_rotation().

    {
        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);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadWindow::scribble	(	CNPoint &	pos,
		int	status
	)

Definition at line 532 of file notepad_window.cpp.

References notepad::CNotepadDoc::on_scribble_begin(), notepad::CNotepadDoc::on_scribble_end(), and notepad::CNotepadDoc::on_scribble_move().

    {
        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;
        }
    }

Here is the call graph for this function:

void notepad::CNotepadWindow::set_pageturn_inverted

(

gboolean

is_inverted

)

Definition at line 1144 of file notepad_window.cpp.

Referenced by main(), and notepad::on_changed_orientation().

    { 
        invert_pageturn = is_inverted;
    }

Here is the caller graph for this function:

void notepad::CNotepadWindow::set_rotation

(

np_rotation

nrotation

)

Definition at line 309 of file notepad_window.cpp.

References notepad::GCtx::height, LOGPRINTF, notepad::GCtx::margin, notepad::CNotepadPages::mark_all_dirty(), notepad::GCtx::rotation, save(), notepad::CNPoint::setClipBorder(), notepad::CNPoint::setRotation(), notepad::CNPoint::setScreen(), and notepad::GCtx::width.

    {
        // 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");
    }

Here is the call graph for this function:

void notepad::CNotepadWindow::set_scribble_mode

(

gboolean

scribble_mode

)

Definition at line 1133 of file notepad_window.cpp.

References update().

Referenced by notepad::on_changed_pen(), and notepad::on_menu_item().

    {
        erscribble_mode = scribble_mode;
        update(false); // fills the whitespaces in strokes overlapped with erased strokes
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadWindow::show

(

bool

show

)

Definition at line 184 of file notepad_window.cpp.

References LOGPRINTF.

    {
        LOGPRINTF("entry");
        if (show)
            gtk_widget_show(main_window);
        else
            gtk_widget_hide(main_window);
        LOGPRINTF("exit");
    }

void notepad::CNotepadWindow::update

(

bool

full = true

)

Definition at line 621 of file notepad_window.cpp.

References DM_HINT_FULL, notepad::GCtx::gc, notepad::CNotepadPages::get_page(), LOGPRINTF, notepad_on_idle_display_yield(), notepad_start_display_update(), and notepad_stop_display_update().

Referenced by delete_current_page_impl(), goto_page(), insert_page(), pageflip_or_create(), and set_scribble_mode().

    {
        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");
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadWindow::update_page_counter

(

)

Definition at line 913 of file notepad_window.cpp.

References notepad::CNotepadDoc::get_num_pages(), notepad::ipc_menu_set_pagecounter(), and LOGPRINTF.

Referenced by delete_current_page_impl(), goto_page(), insert_page(), notepad::menu_show(), notepad::on_window_activated(), and pageflip_or_create().

    {
        LOGPRINTF("entry");
        ipc_menu_set_pagecounter(current_page, notepad_doc.get_num_pages() );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• notepad_window.h
• notepad_window.cpp