← Back to branch summary

~hikiko/nux/arb-srgba-shader

« back to all changes in this revision

Viewing changes to Nux/TextView/TextDocument.h

  • Committer: Neil Jagdish Patel
  • Date: 2010-09-02 03:28:11 UTC
  • Revision ID: neil.patel@canonical.com-20100902032811-i2m18tfb6pkasnvt
Remove Win EOL chars

Show diffs side-by-side

added added

removed removed

Lines of Context:
Nux/TextView/TextDocument.h
20
20
 */
21
21
 
22
22
 
23
 
#ifndef TEXTDOCUMENT_H
24
 
#define TEXTDOCUMENT_H
25
 
 
26
 
#include "codepages.h"
27
 
#include "sequence.h"
28
 
 
29
 
NAMESPACE_BEGIN_GUI
30
 
 
31
 
class TextIterator;
32
 
 
33
 
class TextDocument
34
 
{
35
 
        friend class TextIterator;
36
 
        friend class TextView;
37
 
 
38
 
public:
39
 
        TextDocument();
40
 
        ~TextDocument();
41
 
 
42
 
        bool  init(HANDLE hFile);
43
 
        bool  init(TCHAR *filename);
44
 
        
45
 
        bool  clear();
46
 
        bool EmptyDoc();
47
 
 
48
 
        bool    Undo(t_u32 *offset_start, t_u32 *offset_end);
49
 
        bool    Redo(t_u32 *offset_start, t_u32 *offset_end);
50
 
 
51
 
        // UTF-16 text-editing interface
52
 
        t_u32   insert_text(t_u32 offset_chars, TCHAR *text, t_u32 length);
53
 
        t_u32   replace_text(t_u32 offset_chars, TCHAR *text, t_u32 length, t_u32 erase_len);
54
 
        t_u32   erase_text(t_u32 offset_chars, t_u32 length);
55
 
 
56
 
        t_u32 lineno_from_offset(t_u32 offset);
57
 
        t_u32 offset_from_lineno(t_u32 lineno);
58
 
 
59
 
        bool  lineinfo_from_offset(t_u32 offset_chars, t_u32 *lineno, t_u32 *lineoff_chars,  t_u32 *linelen_chars, t_u32 *lineoff_bytes, t_u32 *linelen_bytes);
60
 
        bool  lineinfo_from_lineno(t_u32 lineno, t_u32 *lineoff_chars,  t_u32 *linelen_chars, t_u32 *lineoff_bytes, t_u32 *linelen_bytes);      
61
 
 
62
 
        TextIterator iterate(t_u32 offset);
63
 
        TextIterator iterate_line(t_u32 lineno, t_u32 *linestart = 0, t_u32 *linelen = 0);
64
 
        TextIterator iterate_line_offset(t_u32 offset_chars, t_u32 *lineno, t_u32 *linestart = 0);
65
 
 
66
 
        t_u32 getdata(t_u32 offset, BYTE *buf, size_t len);
67
 
        t_size getline(t_size nLineNo, TCHAR *buf, t_size buflen, t_size *off_chars);
68
 
 
69
 
        int   getformat();
70
 
        t_u32 linecount();
71
 
        t_u32 longestline(int tabwidth);
72
 
        t_u32 size();
73
 
 
74
 
private:
75
 
        
76
 
        bool init_linebuffer();
77
 
 
78
 
        t_u32 charoffset_to_byteoffset(t_u32 offset_chars);
79
 
        t_u32 byteoffset_to_charoffset(t_u32 offset_bytes);
80
 
 
81
 
        t_u32 count_chars(t_u32 offset_bytes, t_u32 length_chars);
82
 
 
83
 
        size_t utf16_to_rawdata(TCHAR *utf16str, size_t utf16len, BYTE *rawdata, size_t *rawlen);
84
 
    size_t rawdata_to_utf16(BYTE *rawdata, size_t rawlen, TCHAR *utf16str, size_t *utf16len);
85
 
    size_t rawdata_to_utf8(BYTE *rawdata, size_t rawlen, BYTE *utf8str, size_t *utf8len);
86
 
 
87
 
        int   detect_file_format(int *headersize);
88
 
        t_size gettext(t_u32 offset, t_u32 lenbytes, TCHAR *buf, t_size *len);
89
 
        int   getchar(t_u32 offset, t_u32 lenbytes, t_u32 *pch32);
90
 
 
91
 
        // UTF-16 text-editing interface
92
 
        t_u32   insert_raw(t_u32 offset_bytes, TCHAR *text, t_u32 length);
93
 
        t_u32   replace_raw(t_u32 offset_bytes, TCHAR *text, t_u32 length, t_u32 erase_len);
94
 
        t_u32   erase_raw(t_u32 offset_bytes, t_u32 length);
95
 
 
96
 
 
97
 
        sequence m_seq;
98
 
 
99
 
        t_u32  m_nDocLength_chars;
100
 
        t_u32  m_nDocLength_bytes;
101
 
 
102
 
        t_u32 *m_pLineBuf_byte;
103
 
        t_u32 *m_pLineBuf_char;
104
 
        t_u32  m_nNumLines;
105
 
        
106
 
        int        m_nFileFormat;
107
 
        int    m_nHeaderSize;
108
 
};
109
 
 
110
 
class TextIterator
111
 
{
112
 
public:
113
 
        // default constructor sets all members to zero
114
 
        TextIterator()
115
 
                : text_doc(0), off_bytes(0), len_bytes(0)
116
 
        {
117
 
        }
118
 
 
119
 
        TextIterator(t_u32 off, t_u32 len, TextDocument *td)
120
 
                : text_doc(td), off_bytes(off), len_bytes(len)
121
 
        {
122
 
                
123
 
        }
124
 
 
125
 
        // default copy-constructor
126
 
        TextIterator(const TextIterator &ti) 
127
 
                : text_doc(ti.text_doc), off_bytes(ti.off_bytes), len_bytes(ti.len_bytes)
128
 
        {
129
 
        }
130
 
 
131
 
        // assignment operator
132
 
        TextIterator & operator= (TextIterator &ti)
133
 
        {
134
 
                text_doc  = ti.text_doc;
135
 
                off_bytes = ti.off_bytes;
136
 
                len_bytes = ti.len_bytes;
137
 
                return *this;
138
 
        }
139
 
 
140
 
        t_size gettext(TCHAR *buf, t_size buflen)
141
 
        {
142
 
                if(text_doc)
143
 
                {
144
 
                        // get text from the TextDocument at the specified byte-offset
145
 
                        t_u32 len = text_doc->gettext(off_bytes, len_bytes, buf, &buflen);
146
 
 
147
 
                        // adjust the iterator's internal position
148
 
                        off_bytes += len;
149
 
                        len_bytes -= len;
150
 
 
151
 
                        return buflen;
152
 
                }
153
 
                else
154
 
                {
155
 
                        return 0;
156
 
                }
157
 
        }
158
 
 
159
 
        /*int insert_text(TCHAR *buf, int buflen)
160
 
        {
161
 
                if(text_doc)
162
 
                {
163
 
                        // get text from the TextDocument at the specified byte-offset
164
 
                        int len = text_doc->insert(off_bytes, buf, buflen);
165
 
 
166
 
                        // adjust the iterator's internal position
167
 
                        off_bytes += len;
168
 
                        return buflen;
169
 
                }
170
 
                else
171
 
                {
172
 
                        return 0;
173
 
                }
174
 
        }
175
 
 
176
 
        int replace_text(TCHAR *buf, int buflen)
177
 
        {
178
 
                if(text_doc)
179
 
                {
180
 
                        // get text from the TextDocument at the specified byte-offset
181
 
                        int len = text_doc->replace(off_bytes, buf, buflen);
182
 
 
183
 
                        // adjust the iterator's internal position
184
 
                        off_bytes += len;
185
 
                        return buflen;
186
 
                }
187
 
                else
188
 
                {
189
 
                        return 0;
190
 
                }
191
 
        }
192
 
 
193
 
        int erase_text(int length)
194
 
        {
195
 
                if(text_doc)
196
 
                {
197
 
                        // get text from the TextDocument at the specified byte-offset
198
 
                        int len = text_doc->erase(off_bytes, length);
199
 
 
200
 
                        // adjust the iterator's internal position
201
 
                        off_bytes += len;
202
 
                        return len;
203
 
                }
204
 
                else
205
 
                {
206
 
                        return 0;
207
 
                }
208
 
        }*/
209
 
 
210
 
 
211
 
        operator bool()
212
 
        {
213
 
                return text_doc ? true : false;
214
 
        }
215
 
 
216
 
private:
217
 
 
218
 
        TextDocument *text_doc;
219
 
        
220
 
        t_u32 off_bytes;
221
 
        t_u32 len_bytes;
222
 
};
223
 
 
224
 
class LineIterator
225
 
{
226
 
public:
227
 
        LineIterator();
228
 
 
229
 
private:
230
 
        TextDocument *m_pTextDoc;
231
 
};
232
 
 
233
 
struct _BOM_LOOKUP
234
 
{
235
 
        DWORD  bom;
236
 
        t_u32  len;
237
 
        int    type;
238
 
};
239
 
 
240
 
NAMESPACE_END_GUI
241
 
 
242
 
#endif // TEXTDOCUMENT_H
 
23
#ifndef TEXTDOCUMENT_H
 
24
#define TEXTDOCUMENT_H
 
25
 
 
26
#include "codepages.h"
 
27
#include "sequence.h"
 
28
 
 
29
NAMESPACE_BEGIN_GUI
 
30
 
 
31
class TextIterator;
 
32
 
 
33
class TextDocument
 
34
{
 
35
        friend class TextIterator;
 
36
        friend class TextView;
 
37
 
 
38
public:
 
39
        TextDocument();
 
40
        ~TextDocument();
 
41
 
 
42
        bool  init(HANDLE hFile);
 
43
        bool  init(TCHAR *filename);
 
44
        
 
45
        bool  clear();
 
46
        bool EmptyDoc();
 
47
 
 
48
        bool    Undo(t_u32 *offset_start, t_u32 *offset_end);
 
49
        bool    Redo(t_u32 *offset_start, t_u32 *offset_end);
 
50
 
 
51
        // UTF-16 text-editing interface
 
52
        t_u32   insert_text(t_u32 offset_chars, TCHAR *text, t_u32 length);
 
53
        t_u32   replace_text(t_u32 offset_chars, TCHAR *text, t_u32 length, t_u32 erase_len);
 
54
        t_u32   erase_text(t_u32 offset_chars, t_u32 length);
 
55
 
 
56
        t_u32 lineno_from_offset(t_u32 offset);
 
57
        t_u32 offset_from_lineno(t_u32 lineno);
 
58
 
 
59
        bool  lineinfo_from_offset(t_u32 offset_chars, t_u32 *lineno, t_u32 *lineoff_chars,  t_u32 *linelen_chars, t_u32 *lineoff_bytes, t_u32 *linelen_bytes);
 
60
        bool  lineinfo_from_lineno(t_u32 lineno, t_u32 *lineoff_chars,  t_u32 *linelen_chars, t_u32 *lineoff_bytes, t_u32 *linelen_bytes);      
 
61
 
 
62
        TextIterator iterate(t_u32 offset);
 
63
        TextIterator iterate_line(t_u32 lineno, t_u32 *linestart = 0, t_u32 *linelen = 0);
 
64
        TextIterator iterate_line_offset(t_u32 offset_chars, t_u32 *lineno, t_u32 *linestart = 0);
 
65
 
 
66
        t_u32 getdata(t_u32 offset, BYTE *buf, size_t len);
 
67
        t_size getline(t_size nLineNo, TCHAR *buf, t_size buflen, t_size *off_chars);
 
68
 
 
69
        int   getformat();
 
70
        t_u32 linecount();
 
71
        t_u32 longestline(int tabwidth);
 
72
        t_u32 size();
 
73
 
 
74
private:
 
75
        
 
76
        bool init_linebuffer();
 
77
 
 
78
        t_u32 charoffset_to_byteoffset(t_u32 offset_chars);
 
79
        t_u32 byteoffset_to_charoffset(t_u32 offset_bytes);
 
80
 
 
81
        t_u32 count_chars(t_u32 offset_bytes, t_u32 length_chars);
 
82
 
 
83
        size_t utf16_to_rawdata(TCHAR *utf16str, size_t utf16len, BYTE *rawdata, size_t *rawlen);
 
84
    size_t rawdata_to_utf16(BYTE *rawdata, size_t rawlen, TCHAR *utf16str, size_t *utf16len);
 
85
    size_t rawdata_to_utf8(BYTE *rawdata, size_t rawlen, BYTE *utf8str, size_t *utf8len);
 
86
 
 
87
        int   detect_file_format(int *headersize);
 
88
        t_size gettext(t_u32 offset, t_u32 lenbytes, TCHAR *buf, t_size *len);
 
89
        int   getchar(t_u32 offset, t_u32 lenbytes, t_u32 *pch32);
 
90
 
 
91
        // UTF-16 text-editing interface
 
92
        t_u32   insert_raw(t_u32 offset_bytes, TCHAR *text, t_u32 length);
 
93
        t_u32   replace_raw(t_u32 offset_bytes, TCHAR *text, t_u32 length, t_u32 erase_len);
 
94
        t_u32   erase_raw(t_u32 offset_bytes, t_u32 length);
 
95
 
 
96
 
 
97
        sequence m_seq;
 
98
 
 
99
        t_u32  m_nDocLength_chars;
 
100
        t_u32  m_nDocLength_bytes;
 
101
 
 
102
        t_u32 *m_pLineBuf_byte;
 
103
        t_u32 *m_pLineBuf_char;
 
104
        t_u32  m_nNumLines;
 
105
        
 
106
        int        m_nFileFormat;
 
107
        int    m_nHeaderSize;
 
108
};
 
109
 
 
110
class TextIterator
 
111
{
 
112
public:
 
113
        // default constructor sets all members to zero
 
114
        TextIterator()
 
115
                : text_doc(0), off_bytes(0), len_bytes(0)
 
116
        {
 
117
        }
 
118
 
 
119
        TextIterator(t_u32 off, t_u32 len, TextDocument *td)
 
120
                : text_doc(td), off_bytes(off), len_bytes(len)
 
121
        {
 
122
                
 
123
        }
 
124
 
 
125
        // default copy-constructor
 
126
        TextIterator(const TextIterator &ti) 
 
127
                : text_doc(ti.text_doc), off_bytes(ti.off_bytes), len_bytes(ti.len_bytes)
 
128
        {
 
129
        }
 
130
 
 
131
        // assignment operator
 
132
        TextIterator & operator= (TextIterator &ti)
 
133
        {
 
134
                text_doc  = ti.text_doc;
 
135
                off_bytes = ti.off_bytes;
 
136
                len_bytes = ti.len_bytes;
 
137
                return *this;
 
138
        }
 
139
 
 
140
        t_size gettext(TCHAR *buf, t_size buflen)
 
141
        {
 
142
                if(text_doc)
 
143
                {
 
144
                        // get text from the TextDocument at the specified byte-offset
 
145
                        t_u32 len = text_doc->gettext(off_bytes, len_bytes, buf, &buflen);
 
146
 
 
147
                        // adjust the iterator's internal position
 
148
                        off_bytes += len;
 
149
                        len_bytes -= len;
 
150
 
 
151
                        return buflen;
 
152
                }
 
153
                else
 
154
                {
 
155
                        return 0;
 
156
                }
 
157
        }
 
158
 
 
159
        /*int insert_text(TCHAR *buf, int buflen)
 
160
        {
 
161
                if(text_doc)
 
162
                {
 
163
                        // get text from the TextDocument at the specified byte-offset
 
164
                        int len = text_doc->insert(off_bytes, buf, buflen);
 
165
 
 
166
                        // adjust the iterator's internal position
 
167
                        off_bytes += len;
 
168
                        return buflen;
 
169
                }
 
170
                else
 
171
                {
 
172
                        return 0;
 
173
                }
 
174
        }
 
175
 
 
176
        int replace_text(TCHAR *buf, int buflen)
 
177
        {
 
178
                if(text_doc)
 
179
                {
 
180
                        // get text from the TextDocument at the specified byte-offset
 
181
                        int len = text_doc->replace(off_bytes, buf, buflen);
 
182
 
 
183
                        // adjust the iterator's internal position
 
184
                        off_bytes += len;
 
185
                        return buflen;
 
186
                }
 
187
                else
 
188
                {
 
189
                        return 0;
 
190
                }
 
191
        }
 
192
 
 
193
        int erase_text(int length)
 
194
        {
 
195
                if(text_doc)
 
196
                {
 
197
                        // get text from the TextDocument at the specified byte-offset
 
198
                        int len = text_doc->erase(off_bytes, length);
 
199
 
 
200
                        // adjust the iterator's internal position
 
201
                        off_bytes += len;
 
202
                        return len;
 
203
                }
 
204
                else
 
205
                {
 
206
                        return 0;
 
207
                }
 
208
        }*/
 
209
 
 
210
 
 
211
        operator bool()
 
212
        {
 
213
                return text_doc ? true : false;
 
214
        }
 
215
 
 
216
private:
 
217
 
 
218
        TextDocument *text_doc;
 
219
        
 
220
        t_u32 off_bytes;
 
221
        t_u32 len_bytes;
 
222
};
 
223
 
 
224
class LineIterator
 
225
{
 
226
public:
 
227
        LineIterator();
 
228
 
 
229
private:
 
230
        TextDocument *m_pTextDoc;
 
231
};
 
232
 
 
233
struct _BOM_LOOKUP
 
234
{
 
235
        DWORD  bom;
 
236
        t_u32  len;
 
237
        int    type;
 
238
};
 
239
 
 
240
NAMESPACE_END_GUI
 
241
 
 
242
#endif // TEXTDOCUMENT_H