notepad::CNotepadPages Class Reference

#include <notepad_pages.h>

Collaboration diagram for notepad::CNotepadPages:

[legend]

Data Structures
struct	NpPage
Public Member Functions
	CNotepadPages ()
	~CNotepadPages ()
void	init (CNotepadDoc *aDoc, GCtx *aCtx, int pageno, GdkVisual *visual=0)
void	stop ()
void	insert_page (const int pageno)
void	delete_page (const int pageno)
void	clear_page (const int pageno)
void	mark_dirty (const int pageno)
void	mark_all_dirty ()
GdkImage *	get_page (const int pageno)
bool	execRenderPage (RenderPageCtx *ctx)

---

Detailed Description

Definition at line 53 of file notepad_pages.h.

---

Constructor & Destructor Documentation

notepad::CNotepadPages::CNotepadPages

(

)

Definition at line 56 of file notepad_pages.cpp.

References LOGPRINTF, and NPAGES.

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

notepad::CNotepadPages::~CNotepadPages

(

)

Definition at line 73 of file notepad_pages.cpp.

References NPAGES, and stop().

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

Here is the call graph for this function:

---

Member Function Documentation

void notepad::CNotepadPages::clear_page

(

const int

pageno

)

Definition at line 299 of file notepad_pages.cpp.

References LOGPRINTF, and mark_dirty().

Referenced by notepad::CNotepadWindow::delete_current_page_impl().

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

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadPages::delete_page

(

const int

pageno

)

Definition at line 269 of file notepad_pages.cpp.

References notepad::CmdQueue::flush(), LOGPRINTF, NOTFOUND, notepad::CSemaphore::p(), and notepad::CSemaphore::v().

Referenced by notepad::CNotepadWindow::delete_current_page_impl().

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool notepad::CNotepadPages::execRenderPage

(

RenderPageCtx *

ctx

)

Definition at line 407 of file notepad_pages.cpp.

References notepad::CNotepadDoc::draw_scribble_page(), notepad::RenderPageCtx::isCurrent, LOGPRINTF, NOTFOUND, notepad::CSemaphore::p(), notepad::RenderPageCtx::pageno, and notepad::CSemaphore::v().

Referenced by notepad::renderCommand::execute().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GdkImage * notepad::CNotepadPages::get_page

(

const int

pageno

)

Definition at line 344 of file notepad_pages.cpp.

References notepad::CmdQueue::add(), notepad::CmdQueue::flush(), notepad::ipc_sys_busy(), notepad::RenderPageCtx::isCurrent, LOGPRINTF, NOTFOUND, notepad::CSemaphore::p(), and notepad::RenderPageCtx::pageno.

Referenced by notepad::CNotepadWindow::update().

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

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadPages::init	(	CNotepadDoc *	aDoc,
		GCtx *	aCtx,
		int	pageno,
		GdkVisual *	visual = 0
	)

Definition at line 86 of file notepad_pages.cpp.

References notepad::CmdQueue::start().

Referenced by notepad::CNotepadWindow::init().

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

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadPages::insert_page

(

const int

pageno

)

Definition at line 239 of file notepad_pages.cpp.

References notepad::CmdQueue::flush(), LOGPRINTF, notepad::CSemaphore::p(), and notepad::CSemaphore::v().

Referenced by notepad::CNotepadWindow::insert_page(), and notepad::CNotepadWindow::pageflip_or_create().

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

Here is the call graph for this function:

Here is the caller graph for this function:

void notepad::CNotepadPages::mark_all_dirty

(

)

Definition at line 328 of file notepad_pages.cpp.

References LOGPRINTF.

Referenced by notepad::CNotepadWindow::set_rotation().

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

Here is the caller graph for this function:

void notepad::CNotepadPages::mark_dirty

(

const int

pageno

)

Definition at line 312 of file notepad_pages.cpp.

References LOGPRINTF, and NOTFOUND.

Referenced by clear_page(), and notepad::CNotepadWindow::erase().

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

Here is the caller graph for this function:

void notepad::CNotepadPages::stop

(

void

)

Definition at line 103 of file notepad_pages.cpp.

References notepad::CmdQueue::stop().

Referenced by notepad::CNotepadWindow::quit(), ~CNotepadPages(), and notepad::CNotepadWindow::~CNotepadWindow().

    {
        cmd_queue.stop();
    }

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_pages.h
• notepad_pages.cpp