notepad_doc.cpp

Go to the documentation of this file.

/*
 * File Name: notepad_doc.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 <math.h>
#include <cstring>

#include "notepad_doc.h"
#include "notepad_filestore.h"
#include "notepad_ipc.h"
#include "log.h"
#include "notepad_point.h"


namespace notepad 
{
    CNotepadDoc::CNotepadDoc()
        : doc(0)
        , page(0)
        , stroke(0)
        , dirty(FALSE)
        , file_store( new CFileStore() )
    {
        erscribble_init();
        erscribble_doc_disable_autodelete(TRUE);
    }

    CNotepadDoc::~CNotepadDoc()
    {
        erscribble_uninit();
        delete file_store;
    }

    np_result CNotepadDoc::open(const gchar* filename)
    {
        LOGPRINTF("entry");

        g_assert(doc == 0);

        np_result result = file_store->openFile(filename);
        if (result == NP_OK)
        {
            doc = erscribble_doc_open_with_database(".", file_store->getFile());

            if (!doc)
            {
                result = NP_NO_DOCUMENT;
            }
        }

        LOGPRINTF("exit");
        return result;
    }

    np_result CNotepadDoc::create(const gchar* filename)
    {
        LOGPRINTF("entry filename='%s'", filename);

        g_assert(doc == 0);

        np_result result = file_store->createFile(filename);
        if (result == NP_OK)
        {
            doc = erscribble_doc_new_with_database(".", file_store->getFile());

            if (!doc) 
            { 
                result = NP_NO_DOCUMENT;
            }
        }
        LOGPRINTF("exit");
        return result;
    }

    gboolean CNotepadDoc::get_page_dirty()
    {
        return dirty;
    }

    np_result CNotepadDoc::save_page(const int pageno, bool update_last_read)
    {
        LOGPRINTF("entry");
        g_return_val_if_fail(doc != 0, NP_NO_DOCUMENT);

        if (dirty == FALSE)
        {
            LOGPRINTF("exit No changes to save");
            return NP_OK;
        }

        ScbPageId pid;
        generate_page_id(pid, pageno);
        ScbPagePtr thispage = erscribble_doc_get_page(doc, &pid);
        if (NULL == thispage)
        {
            LOGPRINTF("exit No page");
            return NP_OK; // no pages yet
        }
        if (ER_OK != erscribble_doc_save_page(doc, thispage)) 
        {
            LOGPRINTF("exit Saving page failed");
            return NP_SAVE_FAILED;
        }

        if ( update_last_read )
        {
            (void) set_last_read(pageno);
        }

        //TODO size and date are not updated in global.db here

        dirty = FALSE; // changes are saved

        LOGPRINTF("exit");
        return NP_OK;
    }

    void CNotepadDoc::close()
    {
        LOGPRINTF("entry");

        if (doc)
        {
            erscribble_doc_free(doc);
            file_store->closeFile();
            doc = 0;
            memset(&path, 0, sizeof(path));
            page = 0;
            stroke = 0;
        }

        LOGPRINTF("exit");
    }

    np_result CNotepadDoc::rename(const gchar* new_shortfilename)
    {
        LOGPRINTF("entry");
        g_return_val_if_fail( (new_shortfilename != 0) && (new_shortfilename[0] != '\0'), NP_NO_FILENAME);

        np_result result = file_store->renameFile(new_shortfilename);
        gchar* my_filename = file_store->getFileNameFilePartNoExt();
        ipc_change_filename(file_store->getFilename(), my_filename);
        g_free(my_filename);

        LOGPRINTF("exit");
        return result; 
    }

    gint     CNotepadDoc::get_num_pages()
    {
        gint num_pages = 0;
        if (doc)
        {
            num_pages = g_list_length((erscribble_doc_get_pages(doc))->pages); 
        }
        return num_pages;
    }

    gint    CNotepadDoc::get_last_read()
    {
        if (doc)
        {
            return file_store->get_last_read_location();
        }
        return -1;
    }

    gboolean CNotepadDoc::set_last_read(gint value)
    {
        if (doc)
        {
            return file_store->set_last_read_location(value);
        }
        return FALSE;
    }

    gchar*  CNotepadDoc::get_full_filename()
    {
        return file_store->getFilename();
    }

    gchar*  CNotepadDoc::get_filename_without_dir_and_ext()
    {
        return file_store->getFileNameFilePartNoExt();  // caller takes ownership
    }

    CFileStore* CNotepadDoc::getFileStore()
    {
        return file_store;
    }

    void CNotepadDoc::generate_page_id(ScbPageId& pid, const int pos)
    {
        gchar anchor[80];
        sprintf(anchor, "%d", pos);
        erscribble_page_set_id(&pid, pos, anchor, -1);
        LOGPRINTF("id %s, pos %d, anno %lld ", pid.id, pid.position, pid.annotation_id);
    }

    void CNotepadDoc::add_page(const int pageno)
    {
        LOGPRINTF("Append Empty Page!!");

        page = 0; 
        page = erscribble_page_new();
        ScbPageId pid;
        generate_page_id(pid, pageno);
        erscribble_page_copy_id(&page->id, &pid);
        page->attributes.style.orientation = 0;
        erscribble_doc_add_page(doc, page);
        page = 0;
        stroke = 0;
        dirty = TRUE; // changes must be saved
    }

    void CNotepadDoc::insert_page(const int pageno)
    {
        LOGPRINTF("Insert Empty Page!!");

        page = 0; 
        page = erscribble_page_new();
        ScbPageId pid;
        generate_page_id(pid, pageno);
        erscribble_page_copy_id(&page->id, &pid);
        page->attributes.style.orientation = 0;
        erscribble_doc_insert_page(doc, page);
        page = 0;
        stroke = 0;
        dirty = TRUE; // changes must be saved
    }

    void CNotepadDoc::delete_page(const int pageno) 
    {
        LOGPRINTF("Deleting page: %d", pageno);

        ScbPageId pid;
        generate_page_id(pid, pageno);
        erscribble_doc_delete_page(doc, &pid);
        page = 0; 
        stroke = 0;
    }

    void CNotepadDoc::clear_page(const int pageno) 
    {
        ScbPageId pid;
        generate_page_id(pid, pageno);
        ScbPagePtr thispage = erscribble_doc_get_page(doc, &pid);
        if (thispage == 0)
        {
            LOGPRINTF("no page to erase");
            return;
        }
        erscribble_page_clear_strokes(thispage);
        dirty = TRUE; // changes must be saved
    }


    // drawing functions

    void CNotepadDoc::draw_stroke(GCtx& gctx, GdkImage* image, ScbStrokePtr stroke)
    {
        g_assert(image != 0);
        g_assert(stroke != 0);

        int count = erscribble_stroke_get_point_count(stroke);
        ScbPointPtr pts = erscribble_stroke_get_point_data(stroke);
        // select color. 
        gctx.set_color(stroke->attributes.color);
        // select line width and line style.
        gctx.set_line_attributes(stroke->attributes.size_id);

        CNPoint  sp1(pts[0]); // init with storageview

        for (int i=1; i < count; i++)
        {
            CNPoint  sp2(pts[i]);
            gctx.draw_line(image, sp1.windowView(), sp2.windowView()); 
            sp1 = sp2;
        }
    }

    void CNotepadDoc::draw_erased_strokes(GCtx& gctx, GdkImage* image, ScbStrokesPtr strokes) 
    {
        LOGPRINTF("entry");

        g_assert(image != 0);

        // drawing can take a while, dont let device go idle
        ipc_sys_bg_busy(TRUE);

        if (strokes)
        {
            ScbStrokePtr stroke = NULL;
            GList *ptr = g_list_first(strokes->strokes);

            while (ptr)
            {
                stroke = (ScbStrokePtr)ptr->data;
                if (stroke)
                {
                    // adjust color and size to overdraw erased strokes
                    int count = erscribble_stroke_get_point_count(stroke);
                    stroke->attributes.color = ERSCRIBBLE_DEV_COLOR_WHITE;
                    gctx.set_color(stroke->attributes.color); //white
                    ScbPointPtr pts = erscribble_stroke_get_point_data(stroke);

                    int erase_offset_x = 0;
                    int erase_offset_y = 0;
                    // It is necessary to compensate for asymmetry of current kernel brush shape
                    // This depends on brush size and orientation
                    // Therefore an erase_offset is made here, which corresponds with 
                    // the rotated middle of the brush shapes defined in notepad_utils.cpp and deltadriver.
                    if (gctx.rotation != NP_PORTRAIT)
                    {
                        if (gctx.rotation == NP_ANTICLOCKWISE)
                        {
                            switch (stroke->attributes.size_id)
                            {
                                case 1:
                                case 3:
                                case 5:
                                    erase_offset_x = -1;
                                    break;
                                case 2:
                                case 4:
                                    erase_offset_x = -1;
                                    erase_offset_y = -1;
                                    break;
                                default:
                                    break;
                            }
                        }
                        else // NP_CLOCKWISE
                        {
                            switch (stroke->attributes.size_id)
                            {
                                case 1:
                                case 3:
                                case 5:
                                    erase_offset_y = -1;
                                    break;
                                case 2:
                                case 4:
                                    erase_offset_x =  1;
                                    erase_offset_y = -1;
                                    break;
                                default:
                                    break;
                            }
                        }
                    }

                    // move with offset
                    for (int i = 0; i < count; i++)
                    {
                        CNPoint p(pts[i]);
                        pts[i].x = p.deviceView().x + erase_offset_x;
                        pts[i].y = p.deviceView().y + erase_offset_y;
                    }

                    // draw on displaydriver
                    erscribble_stroke_driver_draw(stroke);

                    // move back with offset 
                    for (int i = 0; i < count; i++)
                    {
                        pts[i].x -= erase_offset_x;
                        pts[i].y -= erase_offset_y;
                    }

                    // also update gtk drawing to let lines stay after local display update
                    // because then only the damaged area is redrawn.
                    // point data
                    draw_stroke(gctx, image, stroke);
                }
                ptr = g_list_next(ptr);
            }
        }

        ipc_sys_bg_busy(FALSE);
        LOGPRINTF("exit");
    }


    void CNotepadDoc::on_scribble_begin(
            const int   pageno,
            GCtx&       gctx,
            GdkImage*   image,
            CNPoint&    apoint)
    {
        LOGPRINTF("entry");
        g_assert(image);

        if ((pageno > 0) && (page == 0) && (stroke == 0))
        {
            ScbPageId pid;
            generate_page_id(pid, pageno);

            // check page
            page = erscribble_doc_get_page(doc, &pid);
            if (page == 0)
            {
                // does not exist, needs to create a new one
                page = erscribble_page_new();
                erscribble_page_copy_id(&page->id, &pid);
                page->attributes.style.orientation = 0; // portrait, no orientation stored by Notepad app.
                LOGPRINTF("created new page %s", pid.id);
            }

            // check stroke
            if (stroke == 0)
            {
                stroke = erscribble_stroke_new_with_attributes(erscribble_doc_get_current_stroke_attributes(doc));
                stroke->attributes.zoom = 100.0; //notused
                stroke->attributes.size_id = ipc_get_pensize(); // pen_size from gconf
                stroke->attributes.color = ERSCRIBBLE_DEV_COLOR_BLACK;
                erscribble_page_add_stroke(page, stroke);
                LOGPRINTF("Created new stroke");
            }

            // Add to drawing
            ScbDevPoint point;
            point.point = apoint.storageView();
            point.pressure = 0;
            erscribble_stroke_add_point(stroke, &point);

            // draw in display
            point.point = apoint.deviceView();
            erscribble_stroke_driver_draw_point(stroke, &point, FALSE);
        }
    }

    void CNotepadDoc::on_scribble_move(
            const int   pageno,
            GCtx&       gctx,
            GdkImage*   image,
            CNPoint&    apoint)
    {
        g_assert(image);

        if (stroke)
        {
            // Add to drawing
            ScbDevPoint point;
            point.point = apoint.storageView();
            erscribble_stroke_add_point(stroke, &point);

            point.point = apoint.deviceView();
            erscribble_stroke_driver_draw_point(stroke, &point, FALSE);
        }
    }

    void CNotepadDoc::on_scribble_end(
            const int   pageno,
            GCtx&       gctx,
            GdkImage*   image,
            CNPoint&    apoint)
    {
        LOGPRINTF("End stroke!");

        g_assert(image);

        if ( (pageno > 0) && stroke && doc && page)
        {
            // add to drawing
            ScbDevPoint point;
            point.point = apoint.storageView();
            erscribble_stroke_add_point(stroke, &point);

            // draw on display
            point.point = apoint.deviceView();
            erscribble_stroke_driver_draw_point(stroke, &point, TRUE);

            // also update gtk drawing to let lines stay after local display update
            // because then only the damaged area is redrawn.
            // point data
            draw_stroke(gctx, image, stroke);

            // add & reset
            erscribble_doc_add_page(doc, page);
            page = 0; 
            stroke = 0;
        }
        dirty = TRUE; // changes must be saved
    }

    void CNotepadDoc::on_erase_begin(
            const int   pageno,
            GCtx&       gctx,
            GdkImage*   image,
            CNPoint&    apoint)
    {
        LOGPRINTF("entry");

        g_assert(image);

        if (pageno > 0)
        {

            ScbPageId pid;
            generate_page_id(pid, pageno);

            page = erscribble_doc_get_page(doc, &pid);
            if (page == 0)
            {
                return;
            }

            // prepare for erasing.
            erscribble_page_erase_init(&erase_context);

            ScbDevPoint point;
            point.point = apoint.storageView();
            erase_context.zoom = 100.0; //notused
            ScbStrokesPtr strokes = erscribble_page_erase_hit_test(page, &point, &erase_context);
            if (strokes)
            {
                LOGPRINTF("Erase strokes!");

                // draw 
                draw_erased_strokes(gctx, image, strokes);

                // free
                erscribble_strokes_free(strokes);

                dirty = TRUE; // changes must be saved
            }
        }
    }

    void CNotepadDoc::on_erase_move(
            const int   pageno,
            GCtx&       gctx,
            GdkImage*   image,
            CNPoint&    apoint )
    {
        g_assert(image);

        ScbDevPoint point;
        point.point = apoint.storageView(); 

        //Note: Compares current point with existing lines, so crossings can be missed, 
        //      although comparing linesize is big (5)
        ScbStrokesPtr strokes = erscribble_page_erase_hit_test(page, &point, &erase_context);
        if (strokes)
        {
            LOGPRINTF("Erase strokes!");
            // draw
            draw_erased_strokes(gctx, image, strokes);

            // free 
            erscribble_strokes_free(strokes);

            dirty = TRUE; // changes must be saved
        }
    }

    void CNotepadDoc::on_erase_end(
            const int   pageno,
            GCtx&       gctx,
            GdkImage*   image,
            CNPoint&    apoint)
    {
        g_assert(image);

        ScbDevPoint point;
        point.point = apoint.storageView();
        ScbStrokesPtr strokes = erscribble_page_erase_hit_test(page, &point, &erase_context);

        // reset
        page = 0;
        if (strokes) 
        {
            LOGPRINTF("Erase strokes!");
            //draw
            draw_erased_strokes(gctx, image, strokes);

            // free
            erscribble_strokes_free(strokes);

            dirty = TRUE; // changes must be saved
        }
    }

    void CNotepadDoc::draw_scribble_page(const int pageno, GCtx& gctx, GdkImage* image)
    {
        LOGPRINTF("entry");

        g_assert(image);

        // page from page id
        ScbPageId pid;
        generate_page_id(pid, pageno);

        ScbPagePtr thispage = erscribble_doc_get_page(doc, &pid);
        if (thispage == 0)
        {
            LOGPRINTF("page %s not found!", pid.id);
            return;
        }

        // drawing can take a while, dont let device go idle
        ipc_sys_bg_busy(TRUE);

        ScbStrokesPtr strokes = erscribble_page_get_strokes(thispage);

        if (strokes)
        {
            ScbStrokePtr stroke = NULL;
            GList *pstroke = g_list_first(strokes->strokes);
            while (pstroke)
            {
                stroke = (ScbStrokePtr)pstroke->data;
                if (stroke)
                {
                    draw_stroke(gctx, image, stroke);

                    // NOTE zoom not used in notepad, but if do transform with:
                    // float ratio = z / stroke->attributes.zoom;
                    // int x1 = (int)(ratio * pts[i].x); 
                    // and scale linesize with gctx.set_line_attributes(calc_line_size(stroke->attributes.size_id, gctx.realzoom, stroke->attributes.zoom));
                    // where linesize = (int)(penSize * strokeZoom / dispZoom);
                }
                pstroke = g_list_next(pstroke);
            }
        }

        ipc_sys_bg_busy(FALSE);

        LOGPRINTF("exit");
    }

} //namespace