CScribbleMgr Class Reference

#include <ScribbleMgr.h>

List of all members.

Public Member Functions
	CScribbleMgr (void)
	~CScribbleMgr (void)
void	open (const char *)
void	close (GBool bSave=gTrue)
void	save ()
void	generatePageId (ScbPageIdPtr pid, const int pn)
ScbDocPtr	getScbDoc ()
void	onScribblePress (const int pn, Controller *ctrl, const int px, const int py, const int x, const int y, const int ox, const int oy)
void	onScribbleMove (const int pn, Controller *ctrl, const int px, const int py, const int x, const int y, const int ox, const int oy)
void	onScribbleRelease (const int pn, Controller *ctrl, const int px, const int py, const int x, const int y, const int ox, const int oy)
void	onErasePress (const int pn, Controller *ctrl, const int x, const int y, const int ox, const int oy)
void	onEraseMove (const int pn, Controller *ctrl, const int x, const int y, const int ox, const int oy)
void	onEraseRelease (const int pn, Controller *ctrl, const int x, const int y, const int ox, const int oy)
GBool	isEraseDirty () const
void	setEraseDirty (GBool b=gTrue)
void	drawScribblePage (const int pn, Controller *ctrl, const int x, const int y)
Private Member Functions
void	beginStroke (const int pn, Controller *ctrl, const int px, const int py, const int x, const int y, const int ox, const int oy)
void	addPoint (const int pn, Controller *ctrl, const int px, const int py, const int x, const int y, const int ox, const int oy)
void	endStroke (const int pn, Controller *ctrl, const int px, const int py, const int x, const int y, const int ox, const int oy)
void	endStroke (Controller *ctrl, const int px, const int py, const int x, const int y)
void	drawScribblePagePortrait (ScbPagePtr, Controller *ctrl, const int x, const int y)
void	drawScribblePageLandscape (ScbPagePtr, Controller *ctrl, const int x, const int y)
void	drawErasedStrokesPortrait (ScbStrokesPtr, Controller *ctrl, const int x, const int y)
void	drawErasedStrokesLandscape (ScbStrokesPtr, Controller *ctrl, const int x, const int y)
void	drawStroke (ScbStrokePtr stroke, Controller *ctrl, const int px, const int py)
void	drawStrokeDirectly (ScbStrokePtr stroke, Controller *ctrl)
int	calLineSize (const int penSize, const double strokeZoom, const double dispZoom)
void	setScbDirty (const GBool b=gTrue)
GBool	isScbDirty () const
Private Attributes
ScbPath	path
ScbDocPtr	doc
ScbPagePtr	page
ScbStrokePtr	stroke
int	pageNumber
ScbDevPoint	pagePoint
ScbDevPoint	point
ScbPageId	id
ScbPageEraseCtx	eraseCtx
GBool	bErased
GBool	bScbDirty

---

Detailed Description

Definition at line 49 of file ScribbleMgr.h.

---

Constructor & Destructor Documentation

CScribbleMgr::CScribbleMgr

(

void

)

Definition at line 29 of file ScribbleMgr.cpp.

: doc(NULL)
, page(NULL)
, stroke(NULL)
, pageNumber(-1)
, bErased(gFalse)
, bScbDirty(gFalse)
{
    scb_init();
}

CScribbleMgr::~CScribbleMgr

(

void

)

Definition at line 40 of file ScribbleMgr.cpp.

{
    scb_uninit();
}

---

Member Function Documentation

void CScribbleMgr::beginStroke	(	const int	pn,
		Controller *	ctrl,
		const int	px,
		const int	py,
		const int	x,
		const int	y,
		const int	ox,
		const int	oy
	)			[private]

Definition at line 98 of file ScribbleMgr.cpp.

{
    PV_SCBPRINTF("Create new stroke!");

    // record current page number and page position
    pageNumber = pn;
    pagePoint.x = px; 
    pagePoint.y = py;

    // check page
    generatePageId(&id, pn);
    page = scb_doc_get_page(doc, &id);
    if (NULL == page)
    {
        // does not exist, needs to create a new one
        page = scb_page_new();
        scb_page_set_id(page, &id);
        page->style.orientation = ctrl->settings.getRotate();
    }

    // check stroke
    if (NULL == stroke)
    {
        stroke = scb_stroke_new_with_style(scb_doc_get_current_stroke_style(doc));
        stroke->style.zoom = ctrl->calZoom(ctrl->settings.getCurrentPage());
        ScbStrokesPtr strokes = scb_page_get_strokes(page);
        scb_strokes_add_stroke(strokes, stroke);
    }

    // stroke point data, in offset
    point.x = ox;
    point.y = oy;
    point.pressure = 0;
    scb_stroke_add_point(stroke, &point);
    
    // for drawing
    point.x = x;
    point.y = y;
    scb_stroke_fast_draw_point(stroke, &point);
    
    // set dirty flag now
    setScbDirty();
}

Here is the call graph for this function:

void CScribbleMgr::addPoint	(	const int	pn,
		Controller *	ctrl,
		const int	px,
		const int	py,
		const int	x,
		const int	y,
		const int	ox,
		const int	oy
	)			[private]

Definition at line 145 of file ScribbleMgr.cpp.

{
    point.x = ox;
    point.y = oy;
    scb_stroke_add_point(stroke, &point);
    
    point.x = x;
    point.y = y;
    scb_stroke_fast_draw_point(stroke, &point);
    
    // set dirty flag now
    setScbDirty();
}

Here is the call graph for this function:

void CScribbleMgr::endStroke	(	const int	pn,
		Controller *	ctrl,
		const int	px,
		const int	py,
		const int	x,
		const int	y,
		const int	ox,
		const int	oy
	)			[private]

Definition at line 162 of file ScribbleMgr.cpp.

{
    PV_SCBPRINTF("End stroke!");
    
    // stroke data
    point.x = ox;
    point.y = oy;
    scb_stroke_add_point(stroke, &point);
    
    // drawing
    point.x = x;
    point.y = y;
    scb_stroke_fast_draw_point_done(stroke, &point);
    
    // draw in display
    drawStroke(stroke, ctrl, px, py);

    // add & reset
    scb_doc_add_page(doc, page);
    page = NULL;
    stroke = NULL;
    pageNumber = -1;
    
    // set dirty flag now
    setScbDirty();
}

Here is the call graph for this function:

void CScribbleMgr::endStroke	(	Controller *	ctrl,
		const int	px,
		const int	py,
		const int	x,
		const int	y
	)			[private]

Definition at line 193 of file ScribbleMgr.cpp.

{
    // drawing
    point.x = x;
    point.y = y;
    scb_stroke_fast_draw_point_done(stroke, &point);
    
    // draw
    drawStroke(stroke, ctrl, px, py);
    
    // add & reset
    scb_doc_add_page(doc, page);
    page = NULL;
    stroke = NULL;
    pageNumber = -1;
}

Here is the call graph for this function:

void CScribbleMgr::drawScribblePagePortrait	(	ScbPagePtr	ptr,
		Controller *	ctrl,
		const int	x,
		const int	y
	)			[private]

Definition at line 442 of file ScribbleMgr.cpp.

{
    ScbStrokesPtr strokes = scb_page_get_strokes(ptr);
    double z = ctrl->calZoom(ctrl->settings.getCurrentPage());
    if (strokes)
    {
        ScbStrokePtr stroke = NULL;
        GList *ptr = g_list_first(strokes->strokes);
        while (ptr)
        {
            stroke = (ScbStrokePtr)ptr->data;
            if (stroke)
            {
                // point data
                int count  = scb_stroke_get_point_count(stroke);
                ScbPoint * pts = (ScbPoint *)scb_stroke_get_point_data(stroke);

                // select color. 
                ScbColor color;
                scb_dev_color_to_color(&color, stroke->style.color);
                ctrl->gtkMgr.setLineColor(color.pixel);

                // select pen size
                ctrl->gtkMgr.setLineAttributes(
                    calLineSize(stroke->style.penSize, 
                    z, stroke->style.zoom));

                // draw lines now
                if (fabs(z - stroke->style.zoom) < e)
                {
                    int i = 0;
                    int x1 = x + pts[i].x, y1 = y + pts[i].y; ++i;
                    int x2, y2;
                    while (i < count)
                    {
                        x2 = x + pts[i].x, y2 = y + pts[i].y; ++i;
                        ctrl->gtkMgr.drawLine(x1, y1, x2, y2);
                        x1 = x2; y1 = y2;
                    }
                    
                    if (count <= 1)
                    {
                        ctrl->gtkMgr.drawLine(x1, y1, x1, y1);
                    }
                }
                else
                {
                    double ratio = z / stroke->style.zoom;
                    int i = 0;
                    int x1 = x + (int)(ratio * pts[i].x), y1 = y + (int)(ratio * pts[i].y); ++i;
                    int x2, y2;
                    while (i < count)
                    {
                        x2 = x + (int)(ratio * pts[i].x); y2 = y + (int)(ratio * pts[i].y); ++i;
                        ctrl->gtkMgr.drawLine(x1, y1, x2, y2);
                        x1 = x2; y1 = y2;
                    }

                    if (count <= 1)
                    {
                        ctrl->gtkMgr.drawLine(x1, y1, x1, y1);
                    }
                }
            }
            ptr = g_list_next(ptr);
        }
    }
}

Here is the call graph for this function:

void CScribbleMgr::drawScribblePageLandscape	(	ScbPagePtr	ptr,
		Controller *	ctrl,
		const int	x,
		const int	y
	)			[private]

Definition at line 512 of file ScribbleMgr.cpp.

{
    ScbStrokesPtr strokes = scb_page_get_strokes(ptr);
    double z = ctrl->calZoom(ctrl->settings.getCurrentPage());
    if (strokes)
    {
        ScbStrokePtr stroke = NULL;
        GList *ptr = g_list_first(strokes->strokes);
        while (ptr)
        {
            stroke = (ScbStrokePtr)ptr->data;
            if (stroke)
            {
                // point data
                int count  = scb_stroke_get_point_count(stroke);
                ScbPoint * pts = (ScbPoint *)scb_stroke_get_point_data(stroke);

                // select color.  
                ScbColor color;
                scb_dev_color_to_color(&color, stroke->style.color);
                ctrl->gtkMgr.setLineColor(color.pixel);

                // select pen size
                ctrl->gtkMgr.setLineAttributes(
                    calLineSize(stroke->style.penSize,
                    z, stroke->style.zoom));

                // draw lines now
                if (fabs(z - stroke->style.zoom) < e)
                {
                    int i = 0;
                    int x1 = y - pts[i].x, y1 = x + pts[i].y; ++i;
                    int x2, y2;
                    while (i < count)
                    {
                        x2 = y - pts[i].x, y2 = x + pts[i].y; ++i;
                        ctrl->gtkMgr.drawLine(y1, x1, y2, x2);  // swap
                        x1 = x2; y1 = y2;
                    }
                    
                    // single point
                    if (1 >= count)
                    {
                        ctrl->gtkMgr.drawLine(y1, x1, y1, x1);
                    }
                }
                else
                {
                    double ratio = z / stroke->style.zoom;
                    int i = 0;
                    int x1 = y - (int)(ratio * pts[i].x), y1 = x + (int)(ratio * pts[i].y); ++i;
                    int x2, y2;
                    while (i < count)
                    {
                        x2 = y - (int)(ratio * pts[i].x), y2 = x + (int)(ratio * pts[i].y); ++i;
                        ctrl->gtkMgr.drawLine(y1, x1, y2, x2);
                        x1 = x2; y1 = y2;
                    }

                    // single point
                    if (1 >= count)
                    {
                        ctrl->gtkMgr.drawLine(y1, x1, y1, x1);
                    }
                }
            }
            ptr = g_list_next(ptr);
        }
    }
}

Here is the call graph for this function:

void CScribbleMgr::drawErasedStrokesPortrait	(	ScbStrokesPtr	strokes,
		Controller *	ctrl,
		const int	x,
		const int	y
	)			[private]

Definition at line 586 of file ScribbleMgr.cpp.

{
    double z = ctrl->calZoom(ctrl->settings.getCurrentPage());
    if (strokes)
    {
        ScbStrokePtr stroke = NULL;
        GList *ptr = g_list_first(strokes->strokes);
        while (ptr)
        {
            stroke = (ScbStrokePtr)ptr->data;
            if (stroke)
            {
                // adjust position
                int count  = scb_stroke_get_point_count(stroke);
                ScbPoint * pts = (ScbPoint *)scb_stroke_get_point_data(stroke);
                
                // draw                
                if (fabs(z - stroke->style.zoom) < e)
                {
                    int i = 0;
                    while (i < count)
                    {
                        pts[i].x += x, pts[i].y += y; ++i;
                    }                        
                }
                else
                {
                    double ratio = z / stroke->style.zoom;
                    int i = 0;
                    while (i < count)
                    {
                        pts[i].x = x + (int)(pts[i].x * ratio);
                        pts[i].y = y + (int)(pts[i].y * ratio);
                        ++i;
                    }                        
                }
                stroke->style.color = SCB_DEV_COLOR_WHITE;
                scb_stroke_fast_draw(stroke);
                drawStrokeDirectly(stroke, ctrl);                
            }
            ptr = g_list_next(ptr);
        }
    }
}

Here is the call graph for this function:

void CScribbleMgr::drawErasedStrokesLandscape	(	ScbStrokesPtr	strokes,
		Controller *	ctrl,
		const int	x,
		const int	y
	)			[private]

Definition at line 632 of file ScribbleMgr.cpp.

{
    double z = ctrl->calZoom(ctrl->settings.getCurrentPage());
    if (strokes)
    {
        ScbStrokePtr stroke = NULL;
        GList *ptr = g_list_first(strokes->strokes);
        while (ptr)
        {
            stroke = (ScbStrokePtr)ptr->data;
            if (stroke)
            {
                // adjust position
                int count  = scb_stroke_get_point_count(stroke);
                ScbPoint * pts = (ScbPoint *)scb_stroke_get_point_data(stroke);
                
                // draw                
                if (fabs(z - stroke->style.zoom) < e)
                {
                    int i = 0;
                    while (i < count)
                    {
                        pts[i].x = y - pts[i].x;
                        pts[i].y = x + pts[i].y;
                        swap(pts[i].x, pts[i].y);
                        ++i;
                    }                        
                }
                else
                {
                    double ratio = z / stroke->style.zoom;
                    int i = 0;
                    while (i < count)
                    {
                        pts[i].x = y - (int)(pts[i].x * ratio);
                        pts[i].y = x + (int)(pts[i].y * ratio);
                        swap(pts[i].x, pts[i].y);
                        ++i;
                    }                        
                }
                stroke->style.color = SCB_DEV_COLOR_WHITE;
                scb_stroke_fast_draw(stroke);
                drawStrokeDirectly(stroke, ctrl);
            }
            ptr = g_list_next(ptr);
        }
    }
}

Here is the call graph for this function:

void CScribbleMgr::drawStroke	(	ScbStrokePtr	stroke,
		Controller *	ctrl,
		const int	px,
		const int	py
	)			[private]

Definition at line 682 of file ScribbleMgr.cpp.

{
    if (ctrl->settings.getRotate() == 0)
    {
        // point data
        int count  = scb_stroke_get_point_count(stroke);
        ScbPoint * pts = (ScbPoint *)scb_stroke_get_point_data(stroke);

        // select color. 
        ScbColor color;
        scb_dev_color_to_color(&color, stroke->style.color);
        ctrl->gtkMgr.setLineColor(color.pixel);

        // select pen size
        ctrl->gtkMgr.setLineAttributes(stroke->style.penSize);

        int i = 0;
        int x1 = px + pts[i].x, y1 = py + pts[i].y; ++i;
        int x2, y2;

        while (i < count)
        {
            x2 = px + pts[i].x, y2 = py + pts[i].y; ++i;
            ctrl->gtkMgr.drawLine(x1, y1, x2, y2);
            x1 = x2; y1 = y2;
        }
        
        if (count <= 1)
        {
            ctrl->gtkMgr.drawLine(x1, y1, x1, y1);
        }            
    }
    else if (ctrl->settings.getRotate() == 270)
    {
        // point data
        int count  = scb_stroke_get_point_count(stroke);
        ScbPoint * pts = (ScbPoint *)scb_stroke_get_point_data(stroke);

        // select color. 
        ScbColor color;
        scb_dev_color_to_color(&color, stroke->style.color);
        ctrl->gtkMgr.setLineColor(color.pixel);

        // select pen size
        ctrl->gtkMgr.setLineAttributes(stroke->style.penSize);
        int i = 0;
        int x1 = py - pts[i].x, y1 = px + pts[i].y; ++i;
        int x2, y2;
        while (i < count)
        {
            x2 = py - pts[i].x, y2 = px + pts[i].y; ++i;
            ctrl->gtkMgr.drawLine(y1, x1, y2, x2);    // swap x & y
            x1 = x2; y1 = y2;
        }
         
        if (count <= 1)
        {
            ctrl->gtkMgr.drawLine(y1, x1, y1, x1);
        }            
    }
}

Here is the call graph for this function:

void CScribbleMgr::drawStrokeDirectly	(	ScbStrokePtr	stroke,
		Controller *	ctrl
	)			[private]

Definition at line 745 of file ScribbleMgr.cpp.

{
    // point data
    int count  = scb_stroke_get_point_count(stroke);
    ScbPoint * pts = (ScbPoint *)scb_stroke_get_point_data(stroke);

    // select color. 
    ScbColor color;
    scb_dev_color_to_color(&color, stroke->style.color);
    ctrl->gtkMgr.setLineColor(color.pixel);

    // select pen size
    ctrl->gtkMgr.setLineAttributes(stroke->style.penSize);

    for(int i = 0; i < count - 1; ++i)
    {
        ctrl->gtkMgr.drawLine(pts[i].x, pts[i].y, pts[i + 1].x, pts[i + 1].y);
    }
}

Here is the call graph for this function:

int CScribbleMgr::calLineSize	(	const int	penSize,
		const double	strokeZoom,
		const double	dispZoom
	)			[private]

Definition at line 430 of file ScribbleMgr.cpp.

{
    if (fabs(strokeZoom - dispZoom) < e)
    {
        return penSize;
    }
    int ret = (int)(penSize * strokeZoom / dispZoom);
    if (ret < 1) return 1;
    if (ret > 10) return 10;
    return ret;
}

void CScribbleMgr::setScbDirty

(

const GBool

b = gTrue

)

[private]

Definition at line 78 of file ScribbleMgr.cpp.

{ 
    bScbDirty = b; 
}

GBool CScribbleMgr::isScbDirty

(

)

const [inline, private]

Definition at line 97 of file ScribbleMgr.h.

{ return bScbDirty; }

void CScribbleMgr::open

(

const char *

dirName

)

Definition at line 47 of file ScribbleMgr.cpp.

{
    close();
    
    // construct scribble file name
    if (NULL == dirName) return;
    strncpy(path.scbname, dirName, SCB_MAX_PATH);
    char *pos = strrchr(path.scbname, '/');
    strcpy(++pos, "scribble.irx");      
    pos += strlen("scribble.irx");
    *pos = 0;

    // open file
    doc = scb_doc_make_sure_exist(&path);
}

Here is the call graph for this function:

void CScribbleMgr::close

(

GBool

bSave = gTrue

)

Definition at line 63 of file ScribbleMgr.cpp.

{
    if (doc && bSave && isScbDirty())
    {
        PV_SCBPRINTF("Save scribble now!");
        scb_doc_save(doc);
    }
    scb_doc_free(doc);
    doc = NULL;
    memset(&path, 0, sizeof(path));
    page = NULL;
    stroke = NULL;
    setScbDirty(gFalse);
}

Here is the call graph for this function:

void CScribbleMgr::save

(

)

Definition at line 83 of file ScribbleMgr.cpp.

{
    if (doc && isScbDirty())
    {
        PV_SCBPRINTF("Save scribble now!");
        scb_doc_save(doc);
    }
    setScbDirty(gFalse);
}

Here is the call graph for this function:

void CScribbleMgr::generatePageId	(	ScbPageIdPtr	pid,
		const int	pn
	)

Definition at line 93 of file ScribbleMgr.cpp.

{
    snprintf(pid->id, SCB_MAX_PAGEID_LEN, "%d", pn);
}

ScbDocPtr CScribbleMgr::getScbDoc

(

)

[inline]

Definition at line 109 of file ScribbleMgr.h.

{ return doc; }

void CScribbleMgr::onScribblePress	(	const int	pn,
		Controller *	ctrl,
		const int	px,
		const int	py,
		const int	x,
		const int	y,
		const int	ox,
		const int	oy
	)

Definition at line 212 of file ScribbleMgr.cpp.

{
    if (pn > 0 && page && stroke)
    {
        addPoint(pn, ctrl, px, py,  x, y, ox, oy);
        return;
    }
    
    if (pn > 0 && NULL == page && NULL == stroke)
    {            
        beginStroke(pn, ctrl, px, py, x, y, ox, oy);
    }        
}

Here is the call graph for this function:

void CScribbleMgr::onScribbleMove	(	const int	pn,
		Controller *	ctrl,
		const int	px,
		const int	py,
		const int	x,
		const int	y,
		const int	ox,
		const int	oy
	)

Definition at line 233 of file ScribbleMgr.cpp.

{
    // out of page, end stroke now.
    if (pn < 0 && stroke && page)
    {
        // end without adding it
        endStroke(ctrl, pagePoint.x, pagePoint.y, x, y);
        return;
    }

    // re-enter page bound
    if (pn > 0 && stroke == NULL && page == NULL)
    {
        beginStroke(pn, ctrl, px, py, x, y, ox, oy);
        return;
    }

    // from one page to the other, should use old px and py
    if (pn > 0 && pageNumber > 0 && pn != pageNumber && stroke && page)
    {
        endStroke(ctrl, pagePoint.x, pagePoint.y, x, y);
        beginStroke(pn, ctrl, px, py, x, y, ox, oy);
        return;
    }

    // scribble mode
    if (stroke)
    {
        addPoint(pn, ctrl, px, py, x, y, ox, oy);
    }
}

Here is the call graph for this function:

void CScribbleMgr::onScribbleRelease	(	const int	pn,
		Controller *	ctrl,
		const int	px,
		const int	py,
		const int	x,
		const int	y,
		const int	ox,
		const int	oy
	)

Definition at line 268 of file ScribbleMgr.cpp.

{
    if (pn > 0 && stroke && doc && page)
    {
        endStroke(pn, ctrl, px, py, x, y, ox, oy);
    }
}

Here is the call graph for this function:

void CScribbleMgr::onErasePress	(	const int	pn,
		Controller *	ctrl,
		const int	x,
		const int	y,
		const int	ox,
		const int	oy
	)

Definition at line 290 of file ScribbleMgr.cpp.

{
    if (pn < 0) return;
    scb_page_erase_init(&eraseCtx);
    generatePageId(&id, pn);
    page = scb_doc_get_page(doc, &id);
    if (NULL == page) return;

    // record
    pageNumber = pn;
    point.x = ox; point.y = oy;
    eraseCtx.zoom = ctrl->calZoom(ctrl->settings.getCurrentPage());
    ScbStrokesPtr strokes = scb_page_erase_hit_test(page, &point, &eraseCtx);
    if (strokes)
    {
        PV_LOGPRINTF("Erase strokes!");
        
        // draw and free
        if (ctrl->settings.getRotate() == 270)
        {
            drawErasedStrokesLandscape(strokes, ctrl, x, y);
        }
        else
        {
            drawErasedStrokesPortrait(strokes, ctrl, x, y);
        }
        
        // set dirty flag
        setEraseDirty();
               
        // free
        scb_strokes_free(strokes);
    }
}

Here is the call graph for this function:

void CScribbleMgr::onEraseMove	(	const int	pn,
		Controller *	ctrl,
		const int	x,
		const int	y,
		const int	ox,
		const int	oy
	)

Definition at line 327 of file ScribbleMgr.cpp.

{
    if (pn < 0) return;
    if (pageNumber != pn)
    {
        pageNumber = pn;
        scb_page_erase_init(&eraseCtx);
        eraseCtx.zoom = ctrl->calZoom(ctrl->settings.getCurrentPage());
    }

    generatePageId(&id, pn);
    page = scb_doc_get_page(doc, &id);
    if (NULL == page) return;
     
    point.x = ox; point.y = oy;

    ScbStrokesPtr strokes = scb_page_erase_hit_test(page, &point, &eraseCtx);
    if (strokes)
    {
        PV_LOGPRINTF("Erase strokes!");
        if (ctrl->settings.getRotate() == 270)
        {
            drawErasedStrokesLandscape(strokes, ctrl, x, y);
        }
        else
        {
            drawErasedStrokesPortrait(strokes, ctrl, x, y);
        }

        // set dirty flag
        setEraseDirty();

        // free 
        scb_strokes_free(strokes);
    }
}

Here is the call graph for this function:

void CScribbleMgr::onEraseRelease	(	const int	pn,
		Controller *	ctrl,
		const int	x,
		const int	y,
		const int	ox,
		const int	oy
	)

Definition at line 366 of file ScribbleMgr.cpp.

{
    if (pn < 0 || NULL == page) return;
    point.x = ox; point.y = oy;
    ScbStrokesPtr strokes = scb_page_erase_hit_test(page, &point, &eraseCtx);

    // reset
    page = NULL;
    if (strokes) 
    {
        PV_LOGPRINTF("Erase strokes!");
        if (ctrl->settings.getRotate() == 270)
        {
            drawErasedStrokesLandscape(strokes, ctrl, x, y);
        }
        else
        {
            drawErasedStrokesPortrait(strokes, ctrl, x, y);
        }
        
        // set dirty flag
        setEraseDirty();
        
        // draw and free
        scb_strokes_free(strokes);
    }                
}

Here is the call graph for this function:

GBool CScribbleMgr::isEraseDirty

(

)

const [inline]

Definition at line 136 of file ScribbleMgr.h.

{ return bErased; }

void CScribbleMgr::setEraseDirty

(

GBool

b = gTrue

)

Definition at line 279 of file ScribbleMgr.cpp.

{
    bErased = b; 
    if (b)
    {
        setScbDirty();
    }        
}     

Here is the call graph for this function:

void CScribbleMgr::drawScribblePage	(	const int	pn,
		Controller *	ctrl,
		const int	x,
		const int	y
	)

Definition at line 398 of file ScribbleMgr.cpp.

{
#if (PV_PROFILE_ON)
    int t1 = ctrl->getHighTimeStamp();
#endif 

    // page from page id
    generatePageId(&id, pn);
    ScbPagePtr ptr = scb_doc_get_page(doc, &id);
    if (NULL == ptr) 
    {
        PV_LOGPRINTF("page %s not found!", id.id);
        return;
    }

    if (ctrl->settings.getRotate() == 270)
    {
        drawScribblePageLandscape(ptr, ctrl, x, y);
    }
    else
    {
        drawScribblePagePortrait(ptr, ctrl, x, y);
    }

#if (PV_PROFILE_ON)
        int t2 = ctrl->getHighTimeStamp();
        PV_DUMP("Scribble Manager drawScribblePage uses %d\n", t2 - t1);
#endif 
}

Here is the call graph for this function:

---

Member Data Documentation

ScbPath CScribbleMgr::path [private]

Definition at line 52 of file ScribbleMgr.h.

ScbDocPtr CScribbleMgr::doc [private]

Definition at line 53 of file ScribbleMgr.h.

ScbPagePtr CScribbleMgr::page [private]

Definition at line 54 of file ScribbleMgr.h.

ScbStrokePtr CScribbleMgr::stroke [private]

Definition at line 55 of file ScribbleMgr.h.

int CScribbleMgr::pageNumber [private]

Definition at line 56 of file ScribbleMgr.h.

ScbDevPoint CScribbleMgr::pagePoint [private]

Definition at line 57 of file ScribbleMgr.h.

ScbDevPoint CScribbleMgr::point [private]

Definition at line 58 of file ScribbleMgr.h.

ScbPageId CScribbleMgr::id [private]

Definition at line 59 of file ScribbleMgr.h.

ScbPageEraseCtx CScribbleMgr::eraseCtx [private]

Definition at line 60 of file ScribbleMgr.h.

GBool CScribbleMgr::bErased [private]

Definition at line 61 of file ScribbleMgr.h.

GBool CScribbleMgr::bScbDirty [private]

Definition at line 62 of file ScribbleMgr.h.

---

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

• ipdf-svn/inc/ScribbleMgr.h
• ipdf-svn/src/ScribbleMgr.cpp