scribble_manager.h

Go to the documentation of this file.

/*
 * File Name: scribble_manager.h
 */

/*
 * This file is part of liberscribble.
 *
 * liberscribble 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.
 *
 * liberscribble 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) 2008 iRex Technologies B.V.
 * All rights reserved.
 */
 
#ifndef SCRIBBLE_MANAGER_H_
#define SCRIBBLE_MANAGER_H_

#include <liberscribble/scb.h>
#include <string>
#include <list>

#include "gtk_widget.h"

namespace test
{

/// Point structure.
struct Point
{
    Point() 
        : x(0), y(0)
    {}

    Point(const int ptx, const int pty)
        : x(ptx), y(pty)
    {}

    void reset(const int ptx, const int pty)
    {
        x = ptx; y = pty;
    }

    void move_x(const int ptx)
    {
        x = ptx;
    }

    void move_y(const int pty)
    {
        y = pty;
    }

    int x, y;
};

/// Scribble graphics context. 
/// The scribble graphics context will be used by scribble manager to
/// - Draw strokes new added.
/// - Draw strokes removed.
/// - Draw storkes loaded from scribble document.
/// Usually scribble manager will draw storkes both on e-ink screen and on
/// gdk window.
struct ScribbleGC
{
public:
    float  realZoom;        ///< The real zoom factor (0, maxZoom).
    int    rotation;        ///< Currently it must be one of {0, 270}. It could be {90, 180, 270}. 
    GtkWidget *widget;      ///< The widget scribble will be drawn on.
    GdkGC     *gc;          ///< X11 graphics context.

    ScribbleGC()
    : realZoom(100.0f)
    , rotation(0)
    , widget(0)
    , gc(0)
    {}

    ~ScribbleGC() {}
public:
    
    /// @brief Change the X11 gc to use new line color.
    inline void set_line_color(const unsigned long c)
    {
        GdkColor color;
        color.pixel = c;
        gdk_gc_set_foreground(gc, &color);
    }

    /// @brief Change the X11 gc to use new line attributes. 
    /// Currently, only change the width. Always use LineSolid.
    inline void set_line_attributes(const int width)
    {
        gdk_gc_set_line_attributes(gc
            , width
            , GDK_LINE_SOLID
            , GDK_CAP_PROJECTING
            , GDK_JOIN_MITER);
    }

    /// @brief Draw line on widget by using current line color, line width and 
    /// line style.
    inline void draw_line(const int x1, const int y1, const int x2, const int y2)
    {
        gdk_draw_line(widget->window, gc, x1, y1, x2, y2);
    }
};


/// Scribble manager.
/// - Drawing scribble new added.
/// - Drawing scribble just removed.
/// - Redraw the scribbles with different zoom factor.
/// - Redraw the scribbles in portrait and landscape.
/// - Maintain scribble data by using erscribble library.
class ScribbleMgr
{
public:
    ScribbleMgr(void);
    ~ScribbleMgr(void);

public:
    /// Open scribble document.
    /// @param path The document absolute path.
    /// @return It returns true if the document has been successfully opened.
    /// Otherwise this function returns false.
    bool open(const char *doc_path);

    /// Close scribble document. This function will check the
    /// scribble data is dirty or not.
    /// bSave Whether or not to save current scribble data into
    /// persistent document.
    void close(bool bSave = true);

    /// @brief Save scribble document directly.
    void save();

    /// @brief Retrieve raw scribble document pointer.
    inline ScbDocPtr get_erscribble_doc() { return doc; }

    void clear_page(const ScbPageId &pageId);

    /// @brief Scribble stylus press event handler.
    /// This function will draw the new added scribbles both on
    /// e-ink screen and on gdk window.
    /// @param pageId The page id provided by caller. 
    /// @param sgc The scribble graphics context.
    /// @param absoluteX The point screen coordinate x.
    /// @param absoluteY The point screen coordinate y.
    /// @param offsetX The x offset value within the page.
    /// @param offsetY The y offset value within the page.
    /// @param pageX The x offset of the page display position.
    /// @param pageY The y offset of the page display position.
    void on_scribble_begin(const ScbPageId & pageId,
                           ScribbleGC & sgc,
                           const int absoluteX,
                           const int absoluteY,
                           const int offsetX,
                           const int offsetY,
                           const int pageX,
                           const int pageY);

    /// @brief Scribble stylus move event handler.
    /// This function will draw the new added scribbles both on
    /// e-ink screen and on gdk window.
    /// @param pageId The page id provided by caller. 
    /// @param sgc The scribble graphics context.
    /// @param absoluteX The point screen coordinate x.
    /// @param absoluteY The point screen coordinate y.
    /// @param offsetX The x offset value within the page.
    /// @param offsetY The y offset value within the page.
    /// @param pageX The x offset of the page display position.
    /// @param pageY The y offset of the page display position.
    void on_scribble_move(const ScbPageId & pageId, 
                          ScribbleGC & sgc,
                          const int absoluteX, 
                          const int absoluteY,      
                          const int offsetX, 
                          const int offsetY,
                          const int pageX,
                          const int pageY);

    /// @brief Scribble stylus release event handler.
    /// This function will draw the new added scribbles both on
    /// e-ink screen and on gdk window.
    /// @param pageId The page id provided by caller. 
    /// @param sgc The scribble graphics context.
    /// @param absoluteX The point screen coordinate x.
    /// @param absoluteY The point screen coordinate y.
    /// @param offsetX The x offset value within the page.
    /// @param offsetY The y offset value within the page.
    /// @param pageX The x offset of the page display position.
    /// @param pageY The y offset of the page display position.
    void on_scribble_end(const ScbPageId & pageId,
                         ScribbleGC & sgc,
                         const int absoluteX,
                         const int absoluteY,
                         const int offsetX,
                         const int offsetY,
                         const int pageX,
                         const int pageY);

    /// @brief Scribble stylus erase press event handler.
    /// This function will draw the strokes to be removed both on
    /// e-ink screen and on gdk window with color different from normal strokes.
    /// @param pageId The page id provided by caller. 
    /// @param sgc The scribble graphics context.
    /// @param absoluteX The point screen coordinate x.
    /// @param absoluteY The point screen coordinate y.
    /// @param offsetX The x offset value within the page.
    /// @param offsetY The y offset value within the page.
    /// @param pageX The x offset of the page display position.
    /// @param pageY The y offset of the page display position.
    void on_erase_begin(const ScbPageId & pageId,
                        ScribbleGC & sgc,
                        const int absoluteX,
                        const int absoluteY,
                        const int offsetX,
                        const int offsetY,
                        const int pageX,
                        const int pageY);

    /// @brief Scribble stylus erase move event handler.
    /// This function will draw the strokes to be removed both on
    /// e-ink screen and on gdk window with color different from normal strokes.
    /// @param pageId The page id provided by caller. 
    /// @param sgc The scribble graphics context.
    /// @param absoluteX The point screen coordinate x.
    /// @param absoluteY The point screen coordinate y.
    /// @param offsetX The x offset value within the page.
    /// @param offsetY The y offset value within the page.
    /// @param pageX The x offset of the page display position.
    /// @param pageY The y offset of the page display position.
    void on_erase_move(const ScbPageId & pageId,
                       ScribbleGC & sgc,
                       const int absoluteX,
                       const int absoluteY,
                       const int offsetX,
                       const int offsetY,
                       const int pageX,
                       const int pageY);

    /// @brief Scribble stylus erase release event handler.
    /// This function will draw the strokes to be removed both on
    /// e-ink screen and on gdk window with color different from normal strokes.
    /// @param pageId The page id provided by caller. 
    /// @param sgc The scribble graphics context.
    /// @param absoluteX The point screen coordinate x.
    /// @param absoluteY The point screen coordinate y.
    /// @param offsetX The x offset value within the page.
    /// @param offsetY The y offset value within the page.
    /// @param pageX The x offset of the page display position.
    /// @param pageY The y offset of the page display position.
    void on_erase_end(const ScbPageId & pageId,
                      ScribbleGC & sgc,
                      const int absoluteX,
                      const int absoluteY,
                      const int offsetX,
                      const int offsetY,
                      const int pageX,
                      const int pageY);

    /// @brief Is the scribble manager active?
    inline bool is_active() const {return doc != 0;}

    /// @brief Draw strokes belong to the specified page.
    /// @param pageId The page id provided by caller. 
    /// @param sgc The scribble graphics context.
    /// @param pageX The page screen coordinate x.
    /// @param pageY The page screen coordinate y.
    /// @param page_width width of the page, useful when in landscape mode
    /// @param page_height height of the page, useful when in landscape mode
    void draw_scribble_page(const ScbPageId & pageId, 
                            ScribbleGC & sgc,
                            const int pageX, 
                            const int pageY);

    /// TODO: This function should be provided by caller now.
    /// @brief Generate page id from anchor.
    /// @param pid The erscribble page id which will store the result.
    /// @param anchor The input anchor.
    /// @param pos The page number
    void generate_page_id(ScbPageId & pid, const std::string &anchor, const int pos);

    /// @brief Duplicate page id.
    static void copy_page_id(ScbPageId & dst, const ScbPageId & src); 

    /// @brief Clear page id.
    static void clear_page_id(ScbPageId & pageId);

    /// @brief Check page id is empty.
    static bool is_page_id_empty(const ScbPageId & pageId);

    /// @brief Compare two anchor objects.
    static bool cmp_page_id(const ScbPageId & src, const ScbPageId & dst);

private:
    /// @brief Add a new stroke helper function.
    /// This function will draw the new added scribbles both on
    /// e-ink screen and on gdk window.
    /// @param pageId The page id provided by caller. 
    /// @param sgc The scribble graphics context.
    /// @param absoluteX The point screen coordinate x.
    /// @param absoluteY The point screen coordinate y.
    /// @param offsetX The x offset value within the page.
    /// @param offsetY The y offset value within the page.
    void begin_stroke(const ScbPageId & pageId,
                      ScribbleGC & sgc,
                      const int absoluteX,
                      const int absoluteY,
                      const int offsetX,
                      const int offsetY);

    /// @brief Add a new point to existing stroke.
    /// This function will draw the new added scribble both on
    /// e-ink screen and on gdk window.
    /// @param pageId The page id provided by caller. 
    /// @param sgc The scribble graphics context.
    /// @param absoluteX The point screen coordinate x.
    /// @param absoluteY The point screen coordinate y.
    /// @param offsetX The x offset value within the page.
    /// @param offsetY The y offset value within the page.
    void add_point(const ScbPageId & pageId, 
                   ScribbleGC & sgc,
                   const int absoluteX,
                   const int absoluteY,
                   const int offsetX,
                   const int offsetY);

    /// @brief Add the last point to existing stroke.
    /// This function will draw the last point both on
    /// e-ink screen and on gdk window.
    /// @param pageId The page id provided by caller. 
    /// @param sgc The scribble graphics context.
    /// @param absoluteX The point screen coordinate x.
    /// @param absoluteY The point screen coordinate y.
    /// @param offsetX The x offset value within the page.
    /// @param offsetY The y offset value within the page.
    /// @param pageX The x display position of the page.
    /// @param pageY The y display position of the page.
    void end_stroke(const ScbPageId & pageId, 
                    ScribbleGC & sgc,
                    const int absoluteX,
                    const int absoluteY,
                    const int offsetX,
                    const int offsetY,
                    const int pageX,
                    const int pageY);

    /// @brief Draw the last point without adding the point to stroke.
    /// This function will draw the last point both on
    /// e-ink screen and on gdk window.
    /// @param sgc The scribble graphics context.
    /// @param absoluteX The point screen coordinate x.
    /// @param absoluteY The point screen coordinate y.
    /// @param pageX The x offset value of the page.
    /// @param pageY The y offset value of the page.
    void end_stroke(ScribbleGC & sgc,
                    const int absoluteX,
                    const int absoluteY,
                    const int pageX,
                    const int pageY);

    /// @brief Draw the strokes of specified page in portrait view.
    /// This function will draw the strokes both on
    /// e-ink screen and on gdk window.
    /// @param page The raw scribble page pointer.
    /// @param sgc The scribble graphics context.
    /// @param pageX The page screen coordinate x.
    /// @param pageY The page screen coordinate y.
    /// @param page_width width of the page
    /// @param page_height height of the page
    void draw_scribble_page_portrait(ScbPagePtr page, 
                                     ScribbleGC & sgc, 
                                     const int pageX, 
                                     const int pageY);

    /// @brief Draw the strokes of specified page in landscape view.
    /// This function will draw the strokes both on
    /// e-ink screen and on gdk window.
    /// @param page The raw scribble page pointer.
    /// @param sgc The scribble graphics context.
    /// @param pageX The page screen coordinate x.
    /// @param pageY The page screen coordinate y.
    /// @param page_width width of the page
    /// @param page_height height of the page
    void draw_scribble_page_landscape(ScbPagePtr page, 
                                      ScribbleGC & sgc, 
                                      const int pageX, 
                                      const int pageY);

    /// @brief Draw the strokes erased in portrait view.
    /// This function will draw the erased strokes both on
    /// e-ink screen and on gdk window.
    /// @param strokes The raw scribble strokes pointer.
    /// @param sgc The scribble graphics context.
    /// @param pageX The page screen coordinate x.
    /// @param pageY The page screen coordinate y.
    void draw_erased_strokes_portrait(ScbStrokesPtr strokes,
                                      ScribbleGC & sgc, 
                                      const int pageX, 
                                      const int pageY);

    /// @brief Draw the strokes erased in landscape view.
    /// This function will draw the erased strokes both on
    /// e-ink screen and on gdk window.
    /// @param strokes The raw scribble strokes pointer.
    /// @param sgc The scribble graphics context.
    /// @param pageX The page screen coordinate x.
    /// @param pageY The page screen coordinate y.
    void draw_erased_strokes_landscape(ScbStrokesPtr strokes,
                                       ScribbleGC & sgc, 
                                       const int pageX, 
                                       const int pageY);

    /// @brief Draw specified stroke both on e-ink screen and on gdk window.
    /// @param stroke The storke pointer caller wants to draw.
    /// @param sgc The scribble graphics context.
    /// @param pageX The page screen coordinate x.
    /// @param pageY The page screen coordinate y.
    void draw_stroke(ScbStrokePtr stroke,
                     ScribbleGC & sgc,
                     const int pageX,
                     const int pageY);

    /// @brief Draw stroke directly on gdk window.
    /// @param stroke The stroke caller wants to draw.
    /// @param sgc The scribble graphics context.
    void draw_stroke_directly(ScbStrokePtr stroke,
                              ScribbleGC & sgc);

    /// @brief Helper function used to calculate the line size according to 
    /// storke zoomfactor and the display zoomfactor.
    /// @param penSize The input pen size.
    /// @param strokeZoom The zoom factor when storke is added.
    /// @param dispZoom The zoom factor currently to display.
    /// @return The result pen size in pixel.
    int calc_line_size(const int penSize, 
                       const float strokeZoom,
                       const float dispZoom);

    /// Is the page dirty
    bool is_page_dirty(ScbPagePtr page);

    /// Set the page to be dirty
    void set_page_dirty(ScbPagePtr page);

private:
    typedef std::list<ScbPagePtr>   DirtyPages;
    typedef DirtyPages::iterator    DirtyPagesIter;

private:
    ScbPath         path;           ///< The scribble document path.
    ScbDocPtr       doc;            ///< The scribble document.
    ScbPagePtr      page;           ///< Page currently used.
    ScbStrokePtr    stroke;         ///< Stroke currently used.
    ScbPageEraseCtx erase_context;  ///< Used by erscribble library.

    ScbPageId       last_page_id;   ///< ID of last page.
    bool            is_erased;      ///< When strokes have been erased.

    Point           last_absolute_point; ///< last absolute point
    Point           last_page_point;     ///< last point in page
    Point           last_page_position;  ///< display position of last page

    DirtyPages      dirty_pages;    ///< A list of dirty pages.
};

}; //namespace test

#endif