notepad_pages.cpp

Go to the documentation of this file.

/*
 * File Name: notepad_pages.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 <set>

#include "notepad_ipc.h"
#include "notepad_utils.h"
#include "notepad_display_sched.h"
#include "notepad_doc.h"
#include "notepad_commandqueue.h"
#include "notepad_pages.h"
#include "log.h"

namespace notepad 
{

    // Operations ----------------------------------------------------------------------
    class renderCommand : public Command
    {
        public:
            renderCommand(CNotepadPages* pages, RenderPageCtx* aCtx) {the_pages = pages; params = aCtx; };
            bool execute() { bool r = the_pages->execRenderPage(params); LOGPRINTF(); delete params; return r; };

        private:
            CNotepadPages* the_pages;
            RenderPageCtx* params;
    };



    // object lifecycle
    CNotepadPages::CNotepadPages()
        : doc(0)
        , gctx(0)
        , current_page(0)
        , drawsem(0)
        , pages_rw_sem(1)
    {
        LOGPRINTF("entry");
        for (gint i = 0; i < NPAGES; i++)
        {
            pages[i].image = 0;
            pages[i].pageno = 0;
            pages[i].dirty = TRUE;
        }
        LOGPRINTF("exit");
    }

    CNotepadPages::~CNotepadPages()
    {
        stop();
        for (gint i = 0; i < NPAGES; i++)
        {
            if (pages[i].image != 0)
            {
                g_object_unref(G_OBJECT(pages[i].image) );
                pages[i].image = 0;
            }
        }
    }

    void CNotepadPages::init(CNotepadDoc* aDoc, GCtx* aCtx, int aPage, GdkVisual* aVisual) 
    {
        g_assert(aDoc   != 0);
        g_assert(aCtx   != 0);
        g_assert(aPage  > 0);
        g_assert(aVisual!= 0);

        visual          = aVisual;
        doc             = aDoc;
        gctx            = aCtx;
        current_page    = aPage;

        // Start the thread before executing the first task. 
        // The thread will only be started once!
        cmd_queue.start();
    }

    void CNotepadPages::stop() 
    {
        cmd_queue.stop();
    }



    // internal functions

    gint CNotepadPages::find_page(const int pageno)
    {
        LOGPRINTF("entry %d", pageno);

        g_assert(pageno > 0);

        // find page on pagenumber, return index in array, NOTFOUND (-1) if not found
        for (gint i = 0; i < NPAGES; i++)
        {
            if (pages[i].pageno == pageno)
            {
                LOGPRINTF("exit, page %d(%d) i %d dirty %d", pages[i].pageno, pageno, i, pages[i].dirty);
                return i;
            }
        } 

        LOGPRINTF("exit, not found");
        return NOTFOUND;
    }

    gint CNotepadPages::replace_page_at_index(gint index, int pageno)
    {
        LOGPRINTF("entry %d %d", index, pageno);

        g_assert(pageno > 0);
        g_assert(index >= 0 && index < NPAGES);

        GdkImage* image = pages[index].image; // to avoid array algebra in loop
        // replace image Note: delete and create new one, size may have changed due to rotation
        if (image != 0)
        {
            g_object_unref(G_OBJECT(image)); // delete previous image
            image = 0;
        }

        // note: use GDK_IMAGE_NORMAL, because GDK_IMAGE_SHARED will cause an XLib async error
        image = gdk_image_new(GDK_IMAGE_NORMAL, visual, gctx->width, gctx->height);
        LOGPRINTF("%p", image);

        // clear image / draw white background
        g_assert(image != 0);
        memset(image->mem, 0xFF, image->bpl*image->height); // draw white, Note: 1 byte per pixel; byte per line = bytes in width line.

        pages[index].image = image;
        pages[index].pageno = pageno;
        pages[index].dirty = TRUE; // mark for redraw

        LOGPRINTF("exit");
        return index;
    }

    gint CNotepadPages::remove_from_cache(const gint index)
    {
        // free element from cache
        LOGPRINTF("entry");

        g_assert(index >= 0 && index < NPAGES);

        if (pages[index].image != 0)
        {
            g_object_unref(G_OBJECT(pages[index].image) );
            pages[index].image = 0;
        }
        pages[index].pageno = 0;
        pages[index].dirty = TRUE;

        LOGPRINTF("exit");
        return index;
    }

    gint CNotepadPages::remove_page_from_cache(const int pageno)
    {
        // find page and free element from cache
        LOGPRINTF("entry");

        g_assert(pageno > 0);

        gint i = find_page(pageno);
        if (i != NOTFOUND)
        {
            i = remove_from_cache(i);
        }

        LOGPRINTF("exit");
        return i;
    }

    gint CNotepadPages::make_room(const int pageno)
    {
        // find farthest page on pagenumber and drop out of the cache, 
        // return index of free(d) element in array.
        // called in combination with replace_page_at_index to insert 
        // or add a page to the cache 
        LOGPRINTF("entry");

        g_assert(pageno > 0);

        gint ifarthest  = 0;
        gint dfarthest  = 0;
        gint i          = 0;

        for (i = 0; i < NPAGES; i++)
        {
            if (pages[i].pageno == 0) 
            {
                LOGPRINTF("exit, found free at %d", i);
                return i;
            }
            else
            {
                gint dist = ABS(pages[i].pageno - pageno);
                if (dist > dfarthest)
                {
                    dfarthest = dist;
                    ifarthest = i;
                }
            }
        } 

        // free farthest element
        i = remove_from_cache(ifarthest);

        LOGPRINTF("exit, freed %d", ifarthest);
        return i;
    }

    // pages interface functions
    void CNotepadPages::insert_page(const int pageno)
    {
        // insert page at position, and increase all next pages
        LOGPRINTF("entry");

        g_assert(pageno > 0);

        // flush running queue
        cmd_queue.flush();

        pages_rw_sem.p(); // guarded write

        gint ifree = make_room(pageno);
        g_assert(ifree >= 0 && ifree < NPAGES);

        for (gint i = 0; i < NPAGES; i++)
        {
            if (pages[i].pageno >= pageno)
            {
                // page positions are also increased inside scribble library;
                pages[i].pageno++;
            }
        }

        replace_page_at_index(ifree, pageno);
        pages_rw_sem.v();

        LOGPRINTF("exit");
    }

    void CNotepadPages::delete_page(const int pageno)
    {
        // remove page with same position, and decrease all next pages
        LOGPRINTF("entry");

        g_assert(pageno > 0);

        // flush running queue
        cmd_queue.flush();

        pages_rw_sem.p(); // guarded write

        gint i = find_page(pageno);
        if (i != NOTFOUND)
        {
            for (gint j = 0; j < NPAGES; j++)
            {
                if (pages[j].pageno > pageno)
                {
                    // page positions are also decreased inside scribble library;
                    pages[j].pageno--;
                }
            }
            remove_from_cache(i);
        }
        pages_rw_sem.v();

        LOGPRINTF("exit");
    }

    void CNotepadPages::clear_page(const int pageno)
    {
        // clear page: implemented here to mark for redraw in cache, where 
        // the data of the page is assumed to be cleared before. 
        LOGPRINTF("entry");

        g_assert(pageno > 0);

        mark_dirty(pageno); 

        LOGPRINTF("exit");
    }

    void CNotepadPages::mark_dirty(const int pageno)
    {
        // mark for redraw at update.
        LOGPRINTF("entry");

        g_assert(pageno > 0);

        gint i = find_page(pageno);
        if (i != NOTFOUND)
        {
            pages[i].dirty = TRUE; // mark for redraw at update.
        }

        LOGPRINTF("exit");
    }

    void CNotepadPages::mark_all_dirty()
    {
        // mark whole cache for redraw at update.
        LOGPRINTF("entry");

        for (gint i = 0; i < NPAGES; i++)
        {
            pages[i].dirty = TRUE; // mark for redraw at update.
        }

        LOGPRINTF("exit");
    }


    // drawing functions

    GdkImage*   CNotepadPages::get_page(const int pageno)
    {
        // returns image of current page, a commandqueue may be used to fetch the page
        LOGPRINTF("entry %d", pageno);

        g_assert(pageno > 0);

        int i = find_page(pageno);

        // queue render taks if page not in cache, pageflip or page marked dirty
        if ((i == NOTFOUND) || (pageno != current_page) || pages[i].dirty)
        {
            // flush running queue
            cmd_queue.flush();

            // Define smart order of caching
            const int order[NPAGES] = {0, +1, +2, -1, +3, -2, +4, -3, +5, -4, -5};
            // queue render task for current and adjacent pages.
            for (gint j = 0; j < NPAGES; j++)
            {
                int relpage = pageno + order[j];
                if ( (relpage > 0) && (relpage <= doc->get_num_pages()) )
                {
                    i = find_page(relpage);
                    if ((i == NOTFOUND) || (pages[i].dirty)) // rerender page
                    {
                        LOGPRINTF("add to queue [%d] page %d", j, relpage);
                        RenderPageCtx* params = new RenderPageCtx; // deleted by execute rendercommand
                        memset(params, 0, sizeof params);
                        params->pageno = relpage;
                        params->isCurrent = (j == 0); // if waiting for current page ready must be signalled.
                        renderCommand* rc = new renderCommand(this, params);
                        cmd_queue.add(rc);

                        if (j == 0) // current page
                        {
                            LOGPRINTF("waiting for semaphore");
                            ipc_sys_busy(true); // begin busy
                            drawsem.p(); // wait for render result of current window
                            LOGPRINTF("ready waiting for semaphore");
                        }
                    }
                }
            }
        }

        i = find_page(pageno);
        g_assert(i >= 0 && i < NPAGES); // return valid page

        // remember current page
        current_page = pageno;

        ipc_sys_busy(false); // end busy
 
        // return current image for use in scribbling
        LOGPRINTF("exit");
        return pages[i].image;
    }

    //--------------------------------------------------------------------------------------------------
    // workerthread below
    //--------------------------------------------------------------------------------------------------

    bool CNotepadPages::execRenderPage( RenderPageCtx* params )
    {
        // Called in render queue workerthread
        g_assert(params != 0);

        bool redraw = false;

        pages_rw_sem.p(); // guarded write

        // find out if page has to be redrawn
        int i = find_page(params->pageno);
        if (i == NOTFOUND) 
        {
            i = make_room(params->pageno);
            LOGPRINTF("added page %d in %d", params->pageno, i);
            redraw = true;
        }
        else
        {
            redraw = pages[i].dirty; 
        }

        if (redraw)
        {
            LOGPRINTF("redraw page %d : %d c %d i %d", params->pageno, redraw, params->isCurrent, i);

            // Create new image, page may be dirty because of rotation, deletion etc.
            i = replace_page_at_index(i, params->pageno);

            // render page. Offline drawing on gdk_image
            g_assert(i >= 0 && i < NPAGES);
            g_assert(pages[i].image != 0);
            doc->draw_scribble_page(params->pageno, *gctx, pages[i].image); 
            pages[i].dirty = FALSE;
        }

        pages_rw_sem.v();

        if (params->isCurrent)
        {
            LOGPRINTF("ready rendering current page");
            drawsem.v(); // unlock display of current page
        }

        LOGPRINTF("exit");
        return true;
    }

} // namespace