text::TextView Class Reference

#include <text_view.h>

Collaboration diagram for text::TextView:

[legend]

Public Member Functions
	TextView (TextModel *m)
	Constructors and destructors.
	~TextView ()
void	initialize ()
	Initialize pango related stuff.
void	deinitialize ()
	Release pango related stuff.
void	set_controller (TextController *c)
TextController *	get_controller ()
bool	paginate (const Position &start_pos)
	Pagination.
void	clear_pages ()
	Reset the page table.
Position	render (unsigned char *bmp, const Position &start_pos)
	Render a page start with start_pos.
const TextModel *	get_model () const
int	get_font_size () const
	Get font size.
bool	set_font_size (int font_size)
	Set font size.
const std::string &	get_font_family () const
	Get font family.
void	set_font_family (const std::string &font_family)
	Set font family.
void	get_display_size (int &width, int &height)
	Get output display size.
void	set_display_size (unsigned int width, unsigned int height)
	Set output display size.
unsigned int	get_DPI ()
	Get dpi settings.
void	set_DPI (unsigned int dpi)
	Set dpi.
unsigned int	get_color_depth ()
	Get color depth.
void	set_color_depth (unsigned int color_depth)
	Set color depth.
int	get_page_count ()
void	check_page_table (const Position &rendering_pos)
	Check if re-pagination is needed given by anchor to be rendered.
bool	get_anchor_by_page (unsigned int page_index, Position &pos)
	Get start anchor of specified page.
unsigned int	get_page_index_by_anchor (const Position &anchor)
	Get page index given by anchor.
Position	get_page_anchor_by_anchor (const Position &anchor)
	Get the start anchor of page which contains the specified anchor.
unsigned int	get_current_page_index ()
	Get current page index.
bool	map_doc_pos_to_view_pos (const Position &page_anchor, const Position &doc_pos, ViewPosition &view_pos, bool trailing)
	Find view position given by document position (anchor).
bool	map_view_pos_to_doc_pos (const Position &page_anchor, const ViewPosition &view_pos, Position &doc_pos)
	Find doc position (anchor) given by view position.
bool	get_bounding_rectangles (const Position &page_anchor, std::vector< Rect > &bounding_rect, const Range &range)
	Get bounding rectangels given by range.
bool	calculate_next_page_pos (const Position &in_pos, Position &out_pos)
	Calculate start position of next page.
bool	calculate_prev_page_pos (const Position &in_pos, Position &out_pos)
	Calculate start position of previous page.
bool	need_repagination ()
	Check if repagination is needed.
Data Fields
utils::Signal< unsigned int >	pagination_start_signal
	signals.
utils::Signal< unsigned int, unsigned int >	pagination_end_signal
utils::Signal< unsigned int, const Position &, const Position &, void * >	render_done_signal

---

Detailed Description

Definition at line 49 of file text_view.h.

---

Constructor & Destructor Documentation

text::TextView::TextView

(

TextModel *

m

)

Constructors and destructors.

Definition at line 39 of file text_view.cpp.

References DEFAULT_CHINESE_FONT, text::TextModel::get_encoding(), and initialize().

: model(m),
  ctrl(0),
  font_family(DEFAULT_ASCII_FONT),
  font_size(DEFAULT_FONT_SIZE),
  display_width(DEFAULT_SURFACE_WIDTH),
  display_height(DEFAULT_SURFACE_HEIGHT),
  dpi(DEFAULT_DPI),
  color_depth(DEFAULT_COLOR_DEPTH),
  line_height(0),
  lines_per_page(0),
  left_margin(DEFAULT_LEFT_MARGIN),
  right_margin(DEFAULT_RIGHT_MARGIN),
  top_margin(DEFAULT_TOP_MARGIN),
  bottom_margin(DEFAULT_BOTTOM_MARGIN),
  client_width(display_width - left_margin - right_margin),
  client_height(display_height - top_margin - bottom_margin),
  pango_context(0),
  pango_mutex(0),
  font_hash_code(0),
  is_repagination_needed(false),
  blank_lines(0)
{
    // Special handling for Chinese font.
    const char *enc = model->get_encoding().c_str();
#ifdef WIN32
    if (_stricmp(enc, "GB2312") == 0 || _stricmp(enc, "GBK") == 0)
#else
    if (strcasecmp(enc, "GB2312") == 0 || strcasecmp(enc, "GBK") == 0)
#endif
    {
        font_family = DEFAULT_CHINESE_FONT;
    }
    initialize();
}

Here is the call graph for this function:

text::TextView::~TextView

(

)

Definition at line 75 of file text_view.cpp.

References deinitialize().

{
    deinitialize();
}

Here is the call graph for this function:

---

Member Function Documentation

bool text::TextView::calculate_next_page_pos	(	const Position &	in_pos,
		Position &	out_pos
	)

Calculate start position of next page.

Parameters:

	in_pos	start position of current page
	out_pos	start position of next page

Returns:

If no next page, false is returned, otherwise return true.

Check if we can get next page anchor from page table.

Definition at line 341 of file text_view.cpp.

References text::TextModel::get_paragraph(), text::TextModel::get_paragraph_count(), text::Position::offset, text::Position::paragraph, and text::SafeDeque< T >::size().

Referenced by paginate().

{
    /// Check if we can get next page anchor from page table.
    size_t page_count = pages.size();
    for (unsigned int i=0; i<page_count; i++)
    {
        if (pages[i].start == in_pos)
        {
            out_pos = pages[i].end;
            return out_pos != Position(0, 0);
        }
    }

    unsigned int start_paragraph = in_pos.paragraph;
    unsigned int start_offset    = in_pos.offset;
    unsigned int total_lines = 0;

    g_mutex_lock(pango_mutex);
    PangoLayout *layout = NULL;
    while (total_lines < lines_per_page)
    {
        if (start_paragraph >= model->get_paragraph_count())
        {
            break;
        }

        if (layout != NULL)
        {
            g_object_unref(layout);
            layout = NULL;
        }
        const std::string *str = model->get_paragraph(start_paragraph);
        layout = create_layout(str->c_str(), static_cast<int>(str->size()));

        int line_count = pango_layout_get_line_count(layout);
        int line_offset = 0;
        if (start_offset != 0)
        {
            // We are calculating from the second half part of a paragraph
            int x_pos;
            pango_layout_index_to_line_x(layout, start_offset, FALSE, &line_offset, &x_pos);
            line_count -= line_offset;
        }

        if (total_lines + line_count < lines_per_page)
        {
            // We have enough space to load more paragraphs for current page
            total_lines += line_count;
            start_paragraph++;
            start_offset = 0;
        }
        else if (total_lines + line_count == lines_per_page)
        {
            if (++start_paragraph < model->get_paragraph_count())
            {
                out_pos.paragraph = start_paragraph;
                out_pos.offset = 0;
            }
            break;
        }
        else
        {
            // The remained space is not enough for current paragraph
            PangoLayoutIter *iter = pango_layout_get_iter(layout);
            for (unsigned int i=0; i<lines_per_page-total_lines+line_offset; i++)
            {
                pango_layout_iter_next_line(iter);
            }

            out_pos.offset = pango_layout_iter_get_index(iter);
            out_pos.paragraph = start_paragraph;
            pango_layout_iter_free(iter);
            break;
        }
    }

    if (layout != NULL)
    {
        g_object_unref(layout);
        layout = NULL;
    }
    g_mutex_unlock(pango_mutex);
    return (start_paragraph < model->get_paragraph_count());
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool text::TextView::calculate_prev_page_pos	(	const Position &	in_pos,
		Position &	out_pos
	)

Calculate start position of previous page.

Parameters:

	in_pos	start position of current page
	out_pos	start position of previous page

Returns:

If no previous page, false is returned, otherwise return true.

Definition at line 245 of file text_view.cpp.

References text::TextModel::get_paragraph(), text::Position::offset, text::Position::paragraph, and text::SafeDeque< T >::size().

Referenced by paginate().

{
    // Check if we are already the first page.
    if (in_pos == Position(0, 0))
    {
        return false;
    }

    // Check if we can get next page anchor from page table.
    size_t page_count = pages.size();
    for (unsigned int i=0; i<page_count; i++)
    {
        if (pages[i].end == in_pos)
        {
            out_pos = pages[i].start;
            return true;
        }
    }

    g_mutex_lock(pango_mutex);
    unsigned int start_paragraph = in_pos.paragraph;
    unsigned int start_offset    = in_pos.offset;
    PangoLayout *layout = NULL;
    if (start_offset == 0)
    {
        start_paragraph--;
    }

    unsigned int total_lines = 0;
    while (total_lines < lines_per_page)
    {
        if (static_cast<int>(start_paragraph) < 0)
        {
            if (in_pos > Position(0, 0))
            {
                blank_lines = lines_per_page - total_lines;
            }
            break;
        }

        if (layout != NULL)
        {
            g_object_unref(layout);
            layout = NULL;
        }
        const std::string *str = model->get_paragraph(start_paragraph);
        layout = create_layout(str->c_str(), static_cast<int>(str->size()));

        int line_count = pango_layout_get_line_count(layout);
        if (start_offset != 0)
        {
            // We are calculating from the second half part of a paragraph
            int line_offset, x_pos;
            pango_layout_index_to_line_x(layout, start_offset, FALSE, &line_offset, &x_pos);
            line_count = line_offset;
        }

        if (total_lines + line_count < lines_per_page)
        {
            // We have enough space to load more paragraphs for current page
            total_lines += line_count;
            start_paragraph--;
            start_offset = 0;
        }
        else if (total_lines + line_count == lines_per_page)
        {
            out_pos.paragraph = start_paragraph;
            out_pos.offset = 0;
            break;
        }
        else
        {
            // The remained space is not enough for current paragraph
            PangoLayoutIter *iter = pango_layout_get_iter(layout);
            unsigned int line_index = line_count - (lines_per_page - total_lines);
            for (unsigned int i=0; i<line_index; i++)
            {
                pango_layout_iter_next_line(iter);
            }

            out_pos.paragraph = start_paragraph;
            out_pos.offset = pango_layout_iter_get_index(iter);
            pango_layout_iter_free(iter);
            break;
        }
    }

    if (layout != NULL)
    {
        g_object_unref(layout);
        layout = NULL;
    }
    g_mutex_unlock(pango_mutex);
    return (static_cast<int>(start_paragraph) >= 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void text::TextView::check_page_table

(

const Position &

rendering_pos

)

Check if re-pagination is needed given by anchor to be rendered.

Definition at line 426 of file text_view.cpp.

References text::SafeDeque< T >::size().

Referenced by text::TextController::render(), and text::TextController::restart_pagination().

{
    size_t page_count = pages.size();
    for (unsigned int i=0; i<page_count; i++)
    {
        if (pages[i].start == rendering_pos)
        {
            return;
        }
    }

    // Can't find page boundaries for specified anchor.
    // Re-pagination is needed.
    is_repagination_needed = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void text::TextView::clear_pages

(

)

[inline]

Reset the page table.

Definition at line 80 of file text_view.h.

References text::SafeDeque< T >::clear().

    {

Here is the call graph for this function:

void text::TextView::deinitialize

(

)

Release pango related stuff.

Definition at line 91 of file text_view.cpp.

Referenced by text::DeinitializationTask::execute(), and ~TextView().

{
    // Release pango stuff
    pango_context_final();
    g_mutex_free(pango_mutex);
}

Here is the caller graph for this function:

bool text::TextView::get_anchor_by_page	(	unsigned int	page_index,
		Position &	pos
	)

Get start anchor of specified page.

Definition at line 181 of file text_view.cpp.

References text::SafeDeque< T >::size().

Referenced by text::TextController::render().

{
    if (pages.size() == 0)
    {
        // Pagination hasn't been started yet.
        if (page_index == 0)
        {
            // We can render page 0 despite pagination is not ready.
            pos = Position(0, 0);
            return true;
        }
        else
        {
            return false;
        }
    }
    else
    {
        // Pagination starts, but maybe partial is successful.
        if (page_index >= pages.size())
        {
            return false;
        }
        else
        {
            pos = pages[page_index].start;
            return true;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool text::TextView::get_bounding_rectangles	(	const Position &	page_anchor,
		std::vector< Rect > &	bounding_rect,
		const Range &	range
	)

Get bounding rectangels given by range.

Definition at line 863 of file text_view.cpp.

References DEFAULT_LINE_SPACING, text::Range::end, map_doc_pos_to_view_pos(), text::Range::start, text::ViewPosition::x, and text::ViewPosition::y.

Referenced by text::PluginViewImpl::get_bounding_rectangles_from_range_impl(), and main().

{
    // A flag indicating that the start position and end position of specified
    // range is in different pages.
    bool span_pages = false;
    ViewPosition view_pos_start, view_pos_end;
      
    if (!map_doc_pos_to_view_pos(page_anchor, range.start, view_pos_start, false))
    {
        // The range's start position is not inside the page which starts with
        // page_anchor.
        return false;
    }

    if (!map_doc_pos_to_view_pos(page_anchor, range.end, view_pos_end, true))
    {
        // The range's end position is not inside the page which starts with
        // page_anchor.
        span_pages = true;
    }

    unsigned int line_height_with_spacing = line_height + DEFAULT_LINE_SPACING;

    // Check if thhe start position and end position are in the same line.
    if (view_pos_start.y == view_pos_end.y)
    {
        // The start position and end position are in the same line.
        bounding_rect.push_back(Rect(view_pos_start.x,
                                     view_pos_start.y + DEFAULT_LINE_SPACING,
                                     view_pos_end.x - view_pos_start.x,
                                     line_height));
    }
    else
    {
        // More lines.
        bounding_rect.push_back(Rect(view_pos_start.x,
                                     view_pos_start.y + DEFAULT_LINE_SPACING,
                                     display_width - view_pos_start.x - right_margin,
                                     line_height));

        for (unsigned int y_offset = view_pos_start.y+line_height_with_spacing;
             static_cast<int>(y_offset) < view_pos_end.y &&
             y_offset < top_margin + line_height_with_spacing * lines_per_page;
             y_offset += line_height_with_spacing)
        {
            bounding_rect.push_back(Rect(left_margin,
                                         y_offset + DEFAULT_LINE_SPACING,
                                         client_width,
                                         line_height));
        }

        if (!span_pages)
        {
            bounding_rect.push_back(Rect(left_margin,
                                         view_pos_end.y + DEFAULT_LINE_SPACING,
                                         view_pos_end.x - left_margin,
                                         line_height));
        }
    }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned int text::TextView::get_color_depth

(

)

[inline]

Get color depth.

Definition at line 138 of file text_view.h.

    {

TextController* text::TextView::get_controller

(

)

[inline]

Definition at line 68 of file text_view.h.

    {

unsigned int text::TextView::get_current_page_index

(

)

Get current page index.

Returns:

The index of page which has just been rendered. return 1 if page table is not ready.

Definition at line 484 of file text_view.cpp.

References get_page_index_by_anchor().

Referenced by text::PaginationTask::execute(), and text::TextController::pause_pagination().

{
    return get_page_index_by_anchor(rendering_pos);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void text::TextView::get_display_size	(	int &	width,
		int &	height
	)			[inline]

Get output display size.

Definition at line 116 of file text_view.h.

    {
        width  = display_width;

unsigned int text::TextView::get_DPI

(

)

[inline]

Get dpi settings.

Definition at line 126 of file text_view.h.

    {

const std::string& text::TextView::get_font_family

(

)

const [inline]

Get font family.

Definition at line 104 of file text_view.h.

    {

int text::TextView::get_font_size

(

)

const [inline]

Get font size.

Definition at line 95 of file text_view.h.

Referenced by widget_event_handler().

    {

Here is the caller graph for this function:

const TextModel* text::TextView::get_model

(

)

const [inline]

Definition at line 89 of file text_view.h.

Referenced by widget_event_handler().

    {

Here is the caller graph for this function:

Position text::TextView::get_page_anchor_by_anchor

(

const Position &

anchor

)

Get the start anchor of page which contains the specified anchor.

Check if we can get next page anchor from page table.

Definition at line 464 of file text_view.cpp.

References text::Position::paragraph, and text::SafeDeque< T >::size().

{
    /// Check if we can get next page anchor from page table.
    size_t page_count = pages.size();
    for (unsigned int i=0; i<page_count; i++)
    {
        if (pages[i].end > anchor && pages[i].start <= anchor)
        {
            return pages[i].start;
        }
    }

    if (page_count>0 && pages[page_count-1].end == Position(0, 0))
    {
        return pages[page_count-1].start;
    }

    return Position(anchor.paragraph, 0);
}

Here is the call graph for this function:

int text::TextView::get_page_count

(

)

[inline]

Definition at line 149 of file text_view.h.

Referenced by text::PaginationTask::execute(), main(), text::TextController::pause_pagination(), and widget_event_handler().

    {
        if (!pages.empty() && pages.back().end == Position(0, 0))
        {
            return static_cast<int>(pages.size());
        }

Here is the caller graph for this function:

unsigned int text::TextView::get_page_index_by_anchor

(

const Position &

anchor

)

Get page index given by anchor.

Returns:

The page index of the specified anchor. return 0 if page table is not ready.

Check if we can get next page anchor from page table.

Definition at line 442 of file text_view.cpp.

References text::SafeDeque< T >::size().

Referenced by get_current_page_index().

{
    /// Check if we can get next page anchor from page table.
    size_t page_count = pages.size();

    // Always return 0 if pagination is not complete.
    if (page_count == 0 || pages[page_count-1].end != Position(0, 0))
    {
        return 0;
    }

    for (unsigned int i=0; i<page_count; i++)
    {
        if (pages[i].end > anchor && pages[i].start <= anchor)
        {
            return i;
        }
    }

    return static_cast<unsigned int>(page_count-1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void text::TextView::initialize

(

)

Initialize pango related stuff.

Definition at line 80 of file text_view.cpp.

Referenced by text::InitializationTask::execute(), main(), and TextView().

{
    // Create mutex for synchronous access to pango stuff.
    pango_mutex = g_mutex_new();

    // Initialize pango context.
    pango_context_init();

    calculate_lines_per_page();
}

Here is the caller graph for this function:

bool text::TextView::map_doc_pos_to_view_pos	(	const Position &	page_anchor,
		const Position &	doc_pos,
		ViewPosition &	view_pos,
		bool	trailing
	)

Find view position given by document position (anchor).

Parameters:

	page_anchor	Start anchor of current page.
	doc_pos	Input anchor.
	view_pos	Output view position (x,y).

Returns:

True if successfully mapped, otherwise false is returned.

Definition at line 687 of file text_view.cpp.

References DEFAULT_LINE_SPACING, text::TextModel::get_paragraph(), text::Position::offset, text::Position::paragraph, text::ViewPosition::x, and text::ViewPosition::y.

Referenced by get_bounding_rectangles().

{
    if (doc_pos < page_anchor)
    {
        return false;
    }

    unsigned int line_height_with_spacing = line_height + DEFAULT_LINE_SPACING;

    // Calculate the line offset and x offset inside layout corresponding to doc pos.
    const std::string *str = model->get_paragraph(doc_pos.paragraph);
    PangoLayout *layout = create_layout(str->c_str(), static_cast<int>(str->size()));

    int line_offset_pos, x_offset_pos;
    pango_layout_index_to_line_x(layout, doc_pos.offset, trailing, &line_offset_pos, &x_offset_pos);

    unsigned int total_lines = 0;
    unsigned int start_paragraph = page_anchor.paragraph;
    unsigned int start_offset    = page_anchor.offset;
    if (start_paragraph == 0 && start_offset == 0)
    {
        total_lines += blank_lines;
    }

    if (start_offset != 0)
    {
        // The page does not start with a new paragraph.
        if (layout != NULL)
        {
            g_object_unref(layout);
            layout = NULL;
        }
        const std::string *str = model->get_paragraph(start_paragraph);
        layout = create_layout(str->c_str(), static_cast<int>(str->size()));

        int line_offset_start, x_pos;
        pango_layout_index_to_line_x(layout, start_offset, FALSE, &line_offset_start, &x_pos);

        if (doc_pos.paragraph == start_paragraph)
        {
            total_lines = line_offset_pos - line_offset_start;
            goto MapEnd;
        }
        else
        {
            total_lines = pango_layout_get_line_count(layout) - line_offset_start;
            start_paragraph++;
        }
    }

    for (; start_paragraph != doc_pos.paragraph; start_paragraph++)
    {
        if (layout != NULL)
        {
            g_object_unref(layout);
            layout = NULL;
        }
        const std::string *str = model->get_paragraph(start_paragraph);
        layout = create_layout(str->c_str(), static_cast<int>(str->size()));

        total_lines += pango_layout_get_line_count(layout);
    }

    total_lines += line_offset_pos;

MapEnd:
    if (layout != NULL)
    {
        g_object_unref(layout);
        layout = NULL;
    }
    if (total_lines < lines_per_page)
    {
        view_pos.x = PANGO_PIXELS(x_offset_pos) + left_margin;
        view_pos.y = top_margin + line_height_with_spacing * total_lines;
        return true;
    }
    else
    {
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool text::TextView::map_view_pos_to_doc_pos	(	const Position &	page_anchor,
		const ViewPosition &	view_pos,
		Position &	doc_pos
	)

Find doc position (anchor) given by view position.

Parameters:

	page_anchor	Start anchor of current page.
	view_pos	Input view position.
	doc_pos	Output anchor.

Returns:

True if successfully mapped, otherwise false is returned.

Definition at line 773 of file text_view.cpp.

References DEFAULT_LINE_SPACING, text::TextModel::get_paragraph(), text::TextModel::get_paragraph_count(), text::Position::offset, text::Position::paragraph, text::ViewPosition::x, and text::ViewPosition::y.

Referenced by text::PluginViewImpl::get_anchor_from_coordinates_impl(), and widget_event_handler().

{
    int x_offset_pos = view_pos.x - left_margin;
    int y_offset_pos = view_pos.y - top_margin;

    unsigned int start_paragraph = page_anchor.paragraph;
    unsigned int start_offset    = page_anchor.offset;
    unsigned int line_height_with_spacing = line_height + DEFAULT_LINE_SPACING;

    if (start_paragraph == 0 && start_offset == 0)
    {
        y_offset_pos -= blank_lines * line_height_with_spacing;
    }

    PangoLayout *layout = NULL;
    bool found = false;

    if (start_offset != 0)
    {
        const std::string *str = model->get_paragraph(start_paragraph);
        layout = create_layout(str->c_str(), static_cast<int>(str->size()));

        int line_offset_start, x_pos;
        pango_layout_index_to_line_x(layout, start_offset, FALSE, &line_offset_start, &x_pos);

        int lines_left = pango_layout_get_line_count(layout) - line_offset_start;
        if (static_cast<int>(lines_left * line_height_with_spacing) > y_offset_pos)
        {
            // The corresponding doc pos is inside this paragraph.
            doc_pos.paragraph = start_paragraph;

            // Calculate offset.
            int bytes_index, trailing;
            pango_layout_xy_to_index(layout, 
                                     x_offset_pos * PANGO_SCALE,
                                     (line_offset_start*line_height_with_spacing+y_offset_pos) * PANGO_SCALE,
                                     &bytes_index, &trailing);
            doc_pos.offset = bytes_index;
            found = true;
            goto MapEnd;
        }
        else
        {
            y_offset_pos -= lines_left * line_height_with_spacing;
            start_paragraph++;
        }
    }

    for (; start_paragraph < model->get_paragraph_count(); start_paragraph++)
    {
        if (layout != NULL)
        {
            g_object_unref(layout);
            layout = NULL;
        }
        const std::string *str = model->get_paragraph(start_paragraph);
        layout = create_layout(str->c_str(), static_cast<int>(str->size()));

        int line_count = pango_layout_get_line_count(layout);
        if (static_cast<int>(line_count * line_height_with_spacing) > y_offset_pos)
        {
            break;
        }
        else
        {
            y_offset_pos -= line_count * line_height_with_spacing;
        }
    }

    if (start_paragraph == model->get_paragraph_count())
    {
        goto MapEnd;
    }

    int bytes_index, trailing;
    pango_layout_xy_to_index(layout, x_offset_pos * PANGO_SCALE, y_offset_pos * PANGO_SCALE, &bytes_index, &trailing);
    doc_pos.paragraph = start_paragraph;
    doc_pos.offset    = bytes_index;
    found = true;

MapEnd:
    if (layout)
    {
        g_object_unref(layout);
    }
    return found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool text::TextView::need_repagination

(

)

[inline]

Check if repagination is needed.

Definition at line 214 of file text_view.h.

    {

bool text::TextView::paginate

(

const Position &

start_pos

)

Pagination.

Parameters:

start_pos

If page table is empty, then this parameter tells the view from which position the pagination starts.

Returns:

True if pagination is complete. else false is returned.

Definition at line 139 of file text_view.cpp.

References text::SafeDeque< T >::back(), calculate_next_page_pos(), calculate_prev_page_pos(), text::Range::end, text::SafeDeque< T >::front(), text::SafeDeque< T >::push_back(), text::SafeDeque< T >::push_front(), text::SafeDeque< T >::size(), and text::Range::start.

Referenced by text::PaginationTask::execute(), and main().

{

    Position in_pos(0, 0);
    Position out_pos;
    bool forward = true;
    
    size_t page_count = pages.size();
    if (page_count == 0)
    {
        in_pos = start_pos;
    }
    else if (pages.back().end != Position(0, 0))
    {
        // The forward pagination is not finished yet.
        in_pos = pages.back().end;
    }
    else if (pages.front().start != Position(0, 0))
    {
        // The backward pagination is not finished yet.
        in_pos = pages.front().start;
        forward = false;
    }
    else
    {
        // The pagination is complete.
        return true;
    }

    if (forward)
    {
        calculate_next_page_pos(in_pos, out_pos);
        pages.push_back(PageInfo(in_pos, out_pos));
    }
    else
    {
        calculate_prev_page_pos(in_pos, out_pos);
        pages.push_front(PageInfo(out_pos, in_pos));
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Position text::TextView::render	(	unsigned char *	bmp,
		const Position &	start_pos
	)

Render a page start with start_pos.

Returns:

The position where render ends.

Definition at line 489 of file text_view.cpp.

References text::SafeDeque< T >::clear(), DEFAULT_LINE_SPACING, text::TextModel::get_paragraph(), text::Position::offset, text::TextController::paginate(), text::Position::paragraph, and render_single_line().

Referenced by text::RenderTask::execute(), main(), and widget_event_handler().

{
    if (is_repagination_needed)
    {
        pages.clear();
        blank_lines = 0;
        ctrl->paginate(start_pos, true /* Send start notification */);
        is_repagination_needed = false;
    }

    g_mutex_lock(pango_mutex);
    unsigned int start_paragraph = start_pos.paragraph;
    unsigned int start_offset    = start_pos.offset;
    PangoLayout *layout = NULL;

    rendering_pos = start_pos;

    unsigned int total_lines = 0;
    if (start_pos == Position(0, 0))
    {
        total_lines = blank_lines;
    }
    int y_offset = (line_height + DEFAULT_LINE_SPACING)*total_lines*PANGO_SCALE;

    // If we don't start with a new paragraph, then we must render the
    // remained part of current paragraph first.
    if (start_offset != 0)
    {
        if (layout != NULL)
        {
            g_object_unref(layout);
            layout = NULL;
        }
        const std::string *str = model->get_paragraph(start_paragraph);
        layout = create_layout(str->c_str(), static_cast<int>(str->size()));

        PangoLayoutIter *iter = pango_layout_get_iter(layout);

        int line_offset, x_pos;
        pango_layout_index_to_line_x(layout, start_offset, FALSE, &line_offset, &x_pos);
        y_offset = (line_height + DEFAULT_LINE_SPACING)*line_offset*PANGO_SCALE;

        int baseline = 0;
        for (int i=0; i<line_offset; i++)
        {
            pango_layout_iter_next_line(iter);
        }

        do
        {
            baseline = pango_layout_iter_get_baseline(iter) - y_offset;
            PangoLayoutLine *pango_line = pango_layout_iter_get_line_readonly(iter);
            render_single_line(bmp,
                               pango_line,
                               font_hash_code,
                               left_margin * PANGO_SCALE,
                               baseline+top_margin*PANGO_SCALE,
                               (display_width+3)/4*4);
            if (++total_lines == lines_per_page)
            {
                // Calculate the offset of the rightmost character.
                int index, trailing;
                pango_layout_line_x_to_index(pango_line, client_width - 1, &index, &trailing);
                start_offset = index;
                pango_layout_iter_free(iter);
                goto RenderEnd;
            }
        } while (pango_layout_iter_next_line(iter));
        
        // Release iter since we finish with it.
        pango_layout_iter_free(iter);

        start_paragraph++;
        y_offset = (line_height + DEFAULT_LINE_SPACING)*total_lines*PANGO_SCALE;
    }

    // Render the remained paragraphs
    while (start_paragraph < model->get_paragraph_count())
    {
        // Render current paragraph
        if (layout != NULL)
        {
            g_object_unref(layout);
            layout = NULL;
        }
        const std::string *str = model->get_paragraph(start_paragraph);
        layout = create_layout(str->c_str(), static_cast<int>(str->size()));

        PangoLayoutIter *iter = pango_layout_get_iter(layout);
        int baseline = 0;
        do 
        {
            baseline = pango_layout_iter_get_baseline(iter) + y_offset;
            PangoLayoutLine *pango_line = pango_layout_iter_get_line_readonly(iter);
            render_single_line(bmp, 
                               pango_line,
                               font_hash_code,
                               left_margin * PANGO_SCALE,
                               baseline+top_margin*PANGO_SCALE,
                               (display_width+3)/4*4);
            if (++total_lines == lines_per_page)
            {
                int index, trailing;
                pango_layout_line_x_to_index(pango_line, client_width - 1, &index, &trailing);
                start_offset = index;
                pango_layout_iter_free(iter);
                goto RenderEnd;
            }
        } while (pango_layout_iter_next_line(iter));
        pango_layout_iter_free(iter);

        start_paragraph++;
        y_offset = (line_height + DEFAULT_LINE_SPACING)*total_lines*PANGO_SCALE;
    }

RenderEnd:
    // Release pango layout generated by render.
    if (layout != NULL)
    {
        g_object_unref(layout);
        layout = NULL;
    }
    g_mutex_unlock(pango_mutex);

    return Position(start_paragraph, start_offset);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void text::TextView::set_color_depth

(

unsigned int

color_depth

)

[inline]

Set color depth.

Definition at line 144 of file text_view.h.

    {

void text::TextView::set_controller

(

TextController *

c

)

[inline]

Definition at line 63 of file text_view.h.

Referenced by text::TextController::TextController().

    {

Here is the caller graph for this function:

void text::TextView::set_display_size	(	unsigned int	width,
		unsigned int	height
	)

Set output display size.

Definition at line 658 of file text_view.cpp.

References LOGPRINTF.

Referenced by widget_event_handler().

{
    LOGPRINTF("\n\nwidth=%d, height=%d\n\n", width, height);
    if (width == display_width && height == display_height)
    {
        return;
    }

   g_mutex_lock(pango_mutex);
    if (height != display_height)
    {
        // Display height changed. The current layout can be reused.
        // But we need to re-calculate lines per page.
        display_height = height;
        client_height = display_height - top_margin - bottom_margin;
        calculate_lines_per_page();
    }

    if (width != display_width)
    {
        display_width = width;
        client_width = display_width - left_margin - right_margin;
    }

    // Change the repagination flag to true.
    is_repagination_needed = true;
    g_mutex_unlock(pango_mutex);
}

Here is the caller graph for this function:

void text::TextView::set_DPI

(

unsigned int

dpi

)

[inline]

Set dpi.

Definition at line 132 of file text_view.h.

    {

void text::TextView::set_font_family

(

const std::string &

font_family

)

[inline]

Set font family.

Definition at line 110 of file text_view.h.

    {

bool text::TextView::set_font_size

(

int

font_size

)

Set font size.

Definition at line 616 of file text_view.cpp.

References FontCache::clear(), FontCache::instance(), and make_hash_code().

Referenced by widget_event_handler().

{
    if (this->font_size == font_size)
    {
        return true;
    }

    this->font_size = font_size;

    g_mutex_lock(pango_mutex);

    // Release font caches in font map.
    PangoFT2FontMap* font_map = PANGO_FT2_FONT_MAP(pango_context_get_font_map(pango_context));
    pango_ft2_font_map_substitute_changed(font_map);

    // Create new pango font description and copy it to pango context.
    PangoFontDescription* font_desc = pango_font_description_new();
    pango_font_description_set_family(font_desc, font_family.c_str());
    pango_font_description_set_size(font_desc, font_size * PANGO_SCALE);
    pango_context_set_font_description(pango_context, font_desc);

    char *desc_str = pango_font_description_to_string(font_desc);
    font_hash_code = make_hash_code(desc_str, 
        static_cast<unsigned int>(strlen(desc_str)));
    g_free(desc_str);

    // Since pango_context has copied the font description from us,
    // our font description can be freed safely.
    pango_font_description_free(font_desc);
    calculate_lines_per_page();

    // Change the repagination flag to true.
    is_repagination_needed = true;

    // Clear font cache.
    FontCache& font_cache = FontCache::instance();
    font_cache.clear();

    g_mutex_unlock(pango_mutex);
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Field Documentation

utils::Signal<unsigned int, unsigned int> text::TextView::pagination_end_signal

Definition at line 222 of file text_view.h.

Referenced by text::PaginationTask::execute(), main(), text::TextController::paginate(), text::TextController::pause_pagination(), and text::PluginViewImpl::PluginViewImpl().

utils::Signal<unsigned int> text::TextView::pagination_start_signal

signals.

Definition at line 221 of file text_view.h.

Referenced by text::PaginationTask::execute(), main(), and text::PluginViewImpl::PluginViewImpl().

utils::Signal<unsigned int, const Position&, const Position&, void *> text::TextView::render_done_signal

Definition at line 226 of file text_view.h.

Referenced by text::RenderTask::execute(), main(), and text::PluginViewImpl::PluginViewImpl().

---

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

• text_view.h
• text_view.cpp