text::TextModel Class Reference

#include <text_model.h>

Collaboration diagram for text::TextModel:

[legend]

Data Structures
struct	Paragraph
Public Member Functions
	TextModel ()
	Constructors and destructors.
	~TextModel ()
PluginStatus	open (const std::string &path)
	Open specified document with default encoding.
PluginStatus	open (const std::string &path, const std::string &encoding)
	Open document with specified encoding.
bool	is_open () const
	Check if document is already open.
void	close ()
	Close document.
const std::string &	get_encoding () const
	Get current encoding.
const std::string &	get_path () const
unsigned int	get_paragraph_count () const
	Get number of paragraphs.
const std::string *	get_paragraph (unsigned int index) const
	Get 1 paragraph.
bool	search (std::vector< Range > &result_ranges, SearchContext *sc)
	Search specified pattern given by search criteria.
bool	has_anchor (const Position &pos)
	Check if the document contains the anchor or not.
bool	get_file_pos_from_anchor (size_t &file_pos, const Position &pos)
	Get absolute file position from anchor.
bool	get_word_from_anchor (const Position &pos, Position &word_start_pos, Position &word_end_pos)
	Get a word from specified document position.
bool	get_words_from_range (const Position &range_start, const Position &range_end, Position &words_start, Position &words_end)
	Get the words from range, the range will be extended/shrinked to words boundary.
bool	get_text_from_range (std::string &result, const Position &start_pos, const Position &end_pos)
	Get the text between start_pos and end_pos.
void	dump ()
	Dump the content to disk file.
void	set_aborting_search_task_id (unsigned int id)
	Abort specified search task.
unsigned int	get_aborting_search_task_id ()
Data Fields
utils::Signal< const std::vector< Range > &, const SearchContext * >	search_done_signal
	Signals.

---

Detailed Description

Definition at line 44 of file text_model.h.

---

Constructor & Destructor Documentation

text::TextModel::TextModel

(

)

Constructors and destructors.

Definition at line 44 of file text_model.cpp.

: file_p(0)
, encoding("")
, path()
, b_open(false)
, aborting_search_task_id(0)
, incomplete_line(false)
{
}

text::TextModel::~TextModel

(

)

Definition at line 54 of file text_model.cpp.

References close().

{
    if (b_open)
    {
        close();
    }
}

Here is the call graph for this function:

---

Member Function Documentation

void text::TextModel::close

(

)

Close document.

Definition at line 111 of file text_model.cpp.

Referenced by open(), and ~TextModel().

{
    clear();
    fclose(file_p);
    file_p = NULL;
    b_open = false;
    encoding.clear();
}

Here is the caller graph for this function:

void text::TextModel::dump

(

)

Dump the content to disk file.

Definition at line 647 of file text_model.cpp.

{
    // Generate the dump file.
    std::string dump_path = path + ".converted";
    FILE* fp = fopen(dump_path.c_str(), "w");
    
    if (fp != NULL)
    {
        for (unsigned int i=0; i<doc.size(); i++)
        {
            fputs(doc[i].text->c_str(), fp);
        }

        fclose(fp);
    }
}

unsigned int text::TextModel::get_aborting_search_task_id

(

)

[inline]

Definition at line 131 of file text_model.h.

Referenced by text::SearchTask::execute().

    {
        return aborting_search_task_id;
    }

Here is the caller graph for this function:

const std::string& text::TextModel::get_encoding

(

)

const [inline]

Get current encoding.

Definition at line 68 of file text_model.h.

Referenced by text::TextView::TextView().

    {
        return encoding;
    }

Here is the caller graph for this function:

bool text::TextModel::get_file_pos_from_anchor	(	size_t &	file_pos,
		const Position &	pos
	)

Get absolute file position from anchor.

Definition at line 477 of file text_model.cpp.

References text::Position::offset, and text::Position::paragraph.

{
    // Sanity check.
    if (pos.paragraph >= doc.size() || pos.offset >= doc[pos.paragraph].text->size())
    {
        return false;
    }

    file_pos = doc[pos.paragraph].start_file_pos + pos.offset;
    return true;
}

const std::string* text::TextModel::get_paragraph

(

unsigned int

index

)

const [inline]

Get 1 paragraph.

Definition at line 85 of file text_model.h.

Referenced by text::TextView::calculate_next_page_pos(), text::TextView::calculate_prev_page_pos(), main(), text::TextView::map_doc_pos_to_view_pos(), text::TextView::map_view_pos_to_doc_pos(), text::TextView::render(), and widget_event_handler().

    {
        assert(index < doc.size());
        return doc[index].text;
    }

Here is the caller graph for this function:

unsigned int text::TextModel::get_paragraph_count

(

)

const [inline]

Get number of paragraphs.

Definition at line 79 of file text_model.h.

Referenced by text::TextView::calculate_next_page_pos(), main(), and text::TextView::map_view_pos_to_doc_pos().

    {
        return static_cast<unsigned int>(doc.size());
    }

Here is the caller graph for this function:

const std::string& text::TextModel::get_path

(

)

const [inline]

Definition at line 73 of file text_model.h.

    {
        return path;
    }

bool text::TextModel::get_text_from_range	(	std::string &	result,
		const Position &	start_pos,
		const Position &	end_pos
	)

Get the text between start_pos and end_pos.

Definition at line 614 of file text_model.cpp.

References text::Position::offset, and text::Position::paragraph.

{
    unsigned int start_paragraph = start_pos.paragraph;
    unsigned int end_paragraph = end_pos.paragraph;

    for (unsigned int i = start_paragraph; 
            (i <= end_paragraph) && (i < doc.size()); 
            i++)
    {
        if (doc[i].text)
        {
            const char* start_p = doc[i].text->c_str();
            if (i == start_paragraph)
            {
                start_p += start_pos.offset;
            }

            size_t len = doc[i].text->length();
            if (i == end_paragraph)
            {
                const char* p = doc[i].text->c_str() + end_pos.offset;
                len = g_utf8_next_char(p) - start_p;
            }

            result.append(start_p, len);
        }
    }

    return true;
}

bool text::TextModel::get_word_from_anchor	(	const Position &	pos,
		Position &	word_start_pos,
		Position &	word_end_pos
	)

Get a word from specified document position.

Definition at line 510 of file text_model.cpp.

References text::Position::offset, and text::Position::paragraph.

Referenced by get_words_from_range().

{
    
    const char* paragraph = doc[pos.paragraph].text->c_str();
    word_start_pos.paragraph = word_end_pos.paragraph = pos.paragraph;

    const char* p = paragraph + pos.offset;

    // Check if the character at pos is a seperator.
    if (is_seperator(p))
    {
        // Then there is no word at pos.
        word_start_pos.offset = word_end_pos.offset = pos.offset;
        return false;
    }

    // Find the first space before pos.
    for (; p > paragraph; p = g_utf8_prev_char(p))
    {
        if (is_seperator(p))
        {
            p = g_utf8_next_char(p);
            break;
        }
    }
    word_start_pos.offset = static_cast<int>(p - paragraph);

    // Find the first space after pos.
    for (p = paragraph + pos.offset; *p != 0; p = g_utf8_next_char(p))
    {
        if (is_seperator(p))
        {
            p = g_utf8_prev_char(p);
            break;
        }
    }
    word_end_pos.offset = static_cast<int>(p - paragraph);

    return true;
}

Here is the caller graph for this function:

bool text::TextModel::get_words_from_range	(	const Position &	range_start,
		const Position &	range_end,
		Position &	words_start,
		Position &	words_end
	)

Get the words from range, the range will be extended/shrinked to words boundary.

Definition at line 553 of file text_model.cpp.

References ERRORPRINTF, get_word_from_anchor(), text::Position::offset, text::Position::paragraph, and text::Position::to_string().

{
    if (range_end < range_start)
    {
        ERRORPRINTF("Invalid range, range_start = %s, range_end = %s",
            range_start.to_string().c_str(),
            range_end.to_string().c_str());
        return false;
    }

    Position tmp;

    // Get the object range the range_start anchor points to.
    get_word_from_anchor(range_start, words_start, tmp);

    // Get the object range the range_end anchor points to.
    get_word_from_anchor(range_end, tmp, words_end);

    // Strip any leading seperators.
    const char* start_paragraph = 0;
    const char* p = 0;
    while (true)
    {
        start_paragraph = doc[words_start.paragraph].text->c_str();
        for (p = start_paragraph + words_start.offset; *p != 0; p = g_utf8_next_char(p))
        {
            if (!is_seperator(p))
            {
                break;
            }
        }

        if (*p == 0)
        {
            words_start.paragraph++;
            words_start.offset = 0;
        }
        else
        {
            break;
        }
    }
    words_start.offset = static_cast<int>(p - start_paragraph);

    // Strip any trailing seperators.
    const char* end_paragraph = doc[words_end.paragraph].text->c_str();
    for (p = end_paragraph + words_end.offset; p > end_paragraph; p = g_utf8_prev_char(p))
    {
        if (!is_seperator(p))
        {
            break;
        }
    }
    words_end.offset = static_cast<int>(p - end_paragraph);

    return words_end >= words_start;
}

Here is the call graph for this function:

bool text::TextModel::has_anchor

(

const Position &

pos

)

Check if the document contains the anchor or not.

Definition at line 466 of file text_model.cpp.

References text::Position::offset, and text::Position::paragraph.

{
    // Sanity check.
    if (pos.paragraph >= doc.size() || pos.offset >= doc[pos.paragraph].text->size())
    {
        return false;
    }

    return true;
}

bool text::TextModel::is_open

(

)

const [inline]

Check if document is already open.

Definition at line 59 of file text_model.h.

    {
        return b_open;
    }

PluginStatus text::TextModel::open	(	const std::string &	path,
		const std::string &	encoding
	)

Open document with specified encoding.

Definition at line 67 of file text_model.cpp.

References close(), PLUGIN_FAIL, and PLUGIN_OK.

{
    PluginStatus result = PLUGIN_FAIL;

    // The document was opened already, close it first.
    if (b_open)
    {
        close();
    }

    // Try to open specified file.
    file_p = fopen(doc_path.c_str(), "r");
    if (file_p == NULL)
    {
        return PLUGIN_FAIL;
    }

    // Detect encodings if necessary.
    if (encoding.empty())
    {
        detect_encoding();
    }

    // Update document information.
    path = doc_path;
    b_open = true;

    // Build up paragraphs.
    result = read_text();
    if (result != PLUGIN_OK)
    {
        close();
        return result;
    }

    if (doc.empty())
    {
        doc.push_back(Paragraph(0, new std::string(" ")));
    }

    return result;
}

Here is the call graph for this function:

PluginStatus text::TextModel::open

(

const std::string &

path

)

Open specified document with default encoding.

Definition at line 62 of file text_model.cpp.

Referenced by main().

{
    return open(doc_path, "");
}

Here is the caller graph for this function:

bool text::TextModel::search	(	std::vector< Range > &	result_ranges,
		SearchContext *	sc
	)

Search specified pattern given by search criteria.

Parameters:

	result_ranges	Output range collection.
	search_context	Search criteria.

Returns:

Return true if search is complete (i.e. we reach the start/end of the document, or find an occurrence if SearchType is SEARCH_NEXT), otherwise false is returned, user needs to call this function again to get the search procedure complete.

Definition at line 345 of file text_model.cpp.

References text::SearchContext::case_sensitive, e, text::Range::end, text::SearchContext::forward, text::SearchContext::from, is_whole_word(), text::SearchContext::match_whole_word, text::Position::offset, text::Position::paragraph, text::SearchContext::pattern, text::SEARCH_NEXT, text::SearchContext::search_type, text::Range::start, utf8_strrstr(), and utf8_strstr().

Referenced by text::SearchTask::execute().

{
    // Exact search type and search criteria from search context.
    SearchType search_type      = sc->search_type;
    Position   &from            = sc->from;
    const char *pattern         = sc->pattern.c_str();
    bool       case_sensitive   = sc->case_sensitive;
    bool       forward          = sc->forward;
    bool       match_whole_word = sc->match_whole_word;

    size_t pattern_len = strlen(pattern);
    const char *paragraph_head = doc[from.paragraph].text->c_str();

    bool new_search = is_new_search(sc);
    
    // Remember last search context.
    last_sc = *sc;

    // Clear the last search result range.
    Position s(0, 0), e(0,0);
    last_search_result.start = s;
    last_search_result.end = e;

    if (forward)
    {
        const char *p = paragraph_head + from.offset;
        if (p && !new_search)
        {
            // It's searching next again, move the start position of searching one character.
            // Otherwize, searching one letter results in deadlock.
            //
            // See more in  0003861: [UDS TXT plugin] TXT Search next 
            // for single character word does not work.
            // 
            // The solution is very dirty. But txt plugin has low priority 
            // which is not specified for dr1000 and dr800. 
            // And redefinition what is range takes much more time and has more effects.
            p++;
        }
        while (true)
        {
            const char* find = utf8_strstr(p, pattern, case_sensitive);
            if (find)
            {
                // See if matching whole word.
                if (!match_whole_word || is_whole_word(paragraph_head, find, pattern_len))
                {
                    // Pattern found.
                    Position start(from.paragraph, static_cast<unsigned int>(find - paragraph_head));
                    const char* last_char = g_utf8_prev_char(find + pattern_len);
                    Position end(from.paragraph, static_cast<unsigned int>(last_char - paragraph_head));
                    result_ranges.push_back(Range(start, end));
                    
                    if (search_type == SEARCH_NEXT)
                    {
                        // Remember last search result.
                        last_search_result.start = start;
                        last_search_result.end = end;

                         // Search complete.
                        return true;
                    }

                    // If SEARCH_ALL we must continue with current paragraph.
                }

                p = find + pattern_len;
            }
            else
            {
                // Can't find any match in current paragraph.
                from.offset = 0;
                return ++(from.paragraph) == doc.size();
            }
        }
    }
    else
    {
        // Backward search.
        int len = static_cast<int>(from.offset);
        while (true)
        {
            const char *find = utf8_strrstr(paragraph_head, len, pattern, case_sensitive);
            if (find)
            {
                // See if matching whole word.
                if (!match_whole_word || is_whole_word(paragraph_head, find, pattern_len))
                {
                    // Pattern found.
                    Position start(from.paragraph, static_cast<unsigned int>(find - paragraph_head));
                    const char* last_char = g_utf8_prev_char(find + pattern_len);
                    Position end(from.paragraph, static_cast<unsigned int>(last_char - paragraph_head));
                    result_ranges.push_back(Range(start, end));

                    // Remember last search result.
                    last_search_result.start = start;
                    last_search_result.end = end;

                    return true;
                }

                len = static_cast<int>(find - paragraph_head);
            }
            else
            {
                // Can't find any match in current paragraph.
                if (from.paragraph == 0)
                {
                    return true;
                }
                else
                {
                    from.paragraph--;
                    from.offset = static_cast<unsigned int>(doc[from.paragraph].text->size());
                    return false;
                }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void text::TextModel::set_aborting_search_task_id

(

unsigned int

id

)

[inline]

Abort specified search task.

Definition at line 126 of file text_model.h.

    {
        aborting_search_task_id = id;
    }

---

Field Documentation

utils::Signal<const std::vector<Range>&, const SearchContext*> text::TextModel::search_done_signal

Signals.

Definition at line 138 of file text_model.h.

Referenced by text::SearchTask::execute(), main(), and text::PluginDocImpl::PluginDocImpl().

---

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

• text_model.h
• text_model.cpp