Skip to content

IGR_Text_Compare_Elements

Compares elements within pages of documents and returns an enumerator for iterating through the differences.

Prototype

IGR_RETURN_CODE IGR_Text_Compare_Elements(
    IGR_HPAGE page1,
    const struct IGR_Page_Element* page1_ele_root,
    IGR_HPAGE page2,
    const struct IGR_Page_Element* page2_ele_root,
    const struct IGR_Text_Compare_Settings* settings,
    IGR_HTEXTCOMPARE* enumerator,
    Error_Control_Block* error
)

Parameters

page1: IGR_HPAGE

The first page containing elements to compare.

page1_ele_root: Pointer to IGR_Page_Element

The root element of the first page to start comparison.

page2: IGR_HPAGE

The second page containing elements to compare.

page2_ele_root: Pointer to IGR_Page_Element

The root element of the second page to start comparison.

settings: Pointer to IGR_Text_Compare_Settings

Settings for text comparison.

enumerator: Pointer to IGR_HTEXTCOMPARE

Pointer to store the enumerator for iterating through differences.

error: Pointer to Error_Control_Block

Contains any error text.

Return value

Success: IGR_LONG

Returns IGR_OK.

Failure: IGR_LONG

Returns one of the possible IGR_E error codes.

Sample Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <DocumentFilters.h>
#include <string.h>
#include <string>

#define UCS2(src) reinterpret_cast<const IGR_UCS2 *>(std::u16string(src).c_str())

bool findSectionElement(IGR_HPAGE page, IGR_Page_Element& res)
{
    struct helper_t
    {
        IGR_Page_Element result;

        helper_t() : result()
        {
        }
        static IGR_LONG CALLBACK cb(IGR_HPAGE page, const struct IGR_Page_Element* item, void* context)
        {
            if (item->type == IGR_PAGE_ELEMENT_TYPE_SECTION)
            {
                static_cast<helper_t*>(context)->result = *item;
                return IGR_NO_MORE;
            }
            return IGR_OK;
        }
    };

    Error_Control_Block ecb = { 0 };
    helper_t h;

    if (IGR_Enum_Page_Elements(page, NULL, 0, 0xffff, helper_t::cb, &h, &ecb) == IGR_OK)
    {
        res = h.result;
        return true;
    }
    return false;
}

int main(int argc, char **argv)
{
    Instance_Status_Block isb = {0};
    Error_Control_Block ecb = {0};
    IGR_SHORT df;
    IGR_LONG caps, type, pageCount = 0;
    IGR_HDOC doc1_handle = 0, doc2_handle = 0; 
    IGR_HPAGE doc1_page1_handle = 0, doc2_page1_handle = 0;
    IGR_HTEXTCOMPARE compare = 0;
    IGR_Page_Element doc1_page1_root = { sizeof(IGR_Page_Element) };
    IGR_Page_Element doc2_page1_root = { sizeof(IGR_Page_Element) };

    strncpy(isb.Licensee_ID1, "License Code", sizeof(isb.Licensee_ID1) - 1);
    Init_Instance(0, ".", &isb, &df, &ecb);

    if ((res = IGR_Open_File_Ex(UCS2(u"original.doc"), IGR_FORMAT_IMAGE, UCS2(u""), &caps, &type, &doc1_handle, &ecb)) == IGR_OK
        && (res = IGR_Open_File_Ex(UCS2(u"revised.doc"), IGR_FORMAT_IMAGE, UCS2(u""), &caps, &type, &doc2_handle, &ecb)) == IGR_OK
        && (res = IGR_Open_Page(doc1_handle, 0, &doc1_page1_handle, &ecb)) == IGR_OK
        && (res = IGR_Open_Page(doc2_handle, 0, &doc2_page1_handle, &ecb)) == IGR_OK
        && findSectionElement(doc1_page1_handle, doc1_page1_root)
        && findSectionElement(doc2_page1_handle, doc2_page1_root))

    {
        IGR_Text_Compare_Settings settings = { sizeof(IGR_Text_Compare_Settings) };
        IGR_Compare_Documents_Difference diff = { sizeof(IGR_Compare_Documents_Difference) };

        if ((ret = IGR_Text_Compare_Elements(doc1_page1_handle, &doc1_page1_root, doc2_page1_handle, &doc2_page1_root, &settings, &compare, &ecb)) == IGR_OK)
        {
            while (IGR_Text_Compare_Next(compare, &diff, &ecb) == IGR_OK)
            {
                // ... work with diff object

                IGR_Text_Compare_Difference_Dispose(&diff, &ecb);
            }

            IGR_Text_Compare_Close(compare, &ecb);
        }
    }

    if (doc1_page1_handle)
        IGR_Close_Page(doc1_page1_handle, &ecb);
    if (doc2_page1_handle)
        IGR_Close_Page(doc2_page1_handle, &ecb);
    if (doc1_handle)
        IGR_Close_File(doc1_handle, &ecb);
    if (doc2_handle)
        IGR_Close_File(doc2_handle, &ecb);
    return 0;
}

See Also