← Back to branch summary

~ubuntu-branches/ubuntu/precise/cuneiform/precise

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/hrk/cstr.h

  • Committer: Bazaar Package Importer
  • Author(s): Jakub Wilk, c-assert.diff, slovenian-slv.diff
  • Date: 2011-01-26 21:53:07 UTC
  • mfrom: (5.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20110126215307-62x61mcesr607qb7
Tags: 1.0.0+dfsg-2
http://bugs.debian.org/608345
http://bugs.debian.org/572061
http://bugs.debian.org/602512
* Upload to unstable.
* Explicitly build-depend on pkg-config. Thanks to Stefano Rivera for the
  bug report.
* Add Vcs-* fields.
* Use the standard C assert() macro, rather than custom Cuneiform one.
  [c-assert.diff]
* Pass CFLAGS, CXXFLAGS and LDFLAGS (get from dpkg-buildflags) to cmake
  (closes: #608345). Thanks to Sami Liedes for the bug report.
  + Build depend on dpkg-dev (>= 1.15.7).
* Pass --parallel to dh.
  + Bump debhelper minimum version to 7.4.10.
* Update debian/copyright to the latest DEP-5 version.
* Bump year in debian/copyright.
* Explicitly link to GraphicsMagick (rather than via the ImageMagick
  compatibility layer).
* Don't ship /usr/lib/cuneiform/*.so symlinks. These libraries are
  considered private, at least until #598616 is fixed.
* Rename some private variables in debian/rules to make them lowercase.
* Update patch headers.
* Provide proper ‘build-arch’ and ‘build-indep’ targets in debian/rules.
* Document input format in the manual page (closes: #572061). Thanks to
  Janusz S. Bień for the bug report.
* Use ‘slv’ (rather than ‘slo’) as language code for Slovenian.
  [slovenian-slv.diff]
* Fix package description: Slovenian is supported, Slovak is not.
* Improve documentation of the language (-l) option (closes: #602512).
  Thanks to Jari Aalto for the bug report.
* Install reasons file for vrms.

Show diffs side-by-side

added added

removed removed

Lines of Context:
cuneiform_src/Kern/hrk/cstr.h
1
1
/*
2
 
Copyright (c) 1993-2008, Cognitive Technologies
3
 
All rights reserved.
4
 
 
5
 
����������� ��������� ��������������� � ������������� ��� � ���� ��������� ����,
6
 
��� � � �������� �����, � ����������� ��� ���, ��� ���������� ��������� �������:
7
 
 
8
 
      * ��� ��������� ��������������� ��������� ���� ������ ���������� ���������
9
 
        ���� ����������� �� ��������� �����, ���� ������ ������� � �����������
10
 
        ����� �� ��������.
11
 
      * ��� ��������� ��������������� ��������� ���� � ������������ �/��� �
12
 
        ������ ����������, ������������ ��� ���������������, ������ �����������
13
 
        ��������� ���� ���������� �� ��������� �����, ���� ������ ������� �
14
 
        ����������� ����� �� ��������.
15
 
      * �� �������� Cognitive Technologies, �� ����� �� ����������� �� �����
16
 
        ���� ������������ � �������� �������� ��������� �/��� �����������
17
 
        ���������, ���������� �� ���� ��, ��� ���������������� �����������
18
 
        ����������.
19
 
 
20
 
��� ��������� ������������� ����������� ��������� ���� �/��� ������� ������ "���
21
 
��� ����" ��� ������-���� ���� ��������, ���������� ���� ��� ���������������,
22
 
������� �������� ������������ �������� � ����������� ��� ���������� ����, �� ��
23
 
������������� ���. �� �������� ��������� ���� � �� ���� ������ ����, �������
24
 
����� �������� �/��� �������� �������������� ���������, �� � ���� ������ ��
25
 
��Ѩ� ���������������, ������� ����� �����, ���������, ����������� ���
26
 
������������� ������, ��������� � �������������� ��� ���������� ����������
27
 
������������� ������������� ��������� (������� ������ ������, ��� ������,
28
 
������� ���������, ��� ������ �/��� ������ �������, ���������� ��-�� ��������
29
 
������� ��� �/��� ������ ��������� �������� ��������� � ������� �����������,
30
 
�� �� ������������� ����� ��������), �� �� ������������� ���, ���� ���� �����
31
 
�������� ��� ������ ���� ���� �������� � ����������� ����� ������� � ������.
32
 
 
33
 
Redistribution and use in source and binary forms, with or without modification,
34
 
are permitted provided that the following conditions are met:
35
 
 
36
 
    * Redistributions of source code must retain the above copyright notice,
37
 
      this list of conditions and the following disclaimer.
38
 
    * Redistributions in binary form must reproduce the above copyright notice,
39
 
      this list of conditions and the following disclaimer in the documentation
40
 
      and/or other materials provided with the distribution.
41
 
    * Neither the name of the Cognitive Technologies nor the names of its
42
 
      contributors may be used to endorse or promote products derived from this
43
 
      software without specific prior written permission.
44
 
 
45
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
46
 
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
47
 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48
 
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
49
 
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50
 
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
51
 
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
52
 
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
53
 
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
54
 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
55
 
*/
 
2
 Copyright (c) 1993-2008, Cognitive Technologies
 
3
 All rights reserved.
 
4
 
 
5
 Разрешается повторное распространение и использование как в виде исходного кода,
 
6
 так и в двоичной форме, с изменениями или без, при соблюдении следующих условий:
 
7
 
 
8
 * При повторном распространении исходного кода должны оставаться указанное
 
9
 выше уведомление об авторском праве, этот список условий и последующий
 
10
 отказ от гарантий.
 
11
 * При повторном распространении двоичного кода в документации и/или в
 
12
 других материалах, поставляемых при распространении, должны сохраняться
 
13
 указанная выше информация об авторском праве, этот список условий и
 
14
 последующий отказ от гарантий.
 
15
 * Ни название Cognitive Technologies, ни имена ее сотрудников не могут
 
16
 быть использованы в качестве средства поддержки и/или продвижения
 
17
 продуктов, основанных на этом ПО, без предварительного письменного
 
18
 разрешения.
 
19
 
 
20
 ЭТА ПРОГРАММА ПРЕДОСТАВЛЕНА ВЛАДЕЛЬЦАМИ АВТОРСКИХ ПРАВ И/ИЛИ ДРУГИМИ ЛИЦАМИ "КАК
 
21
 ОНА ЕСТЬ" БЕЗ КАКОГО-ЛИБО ВИДА ГАРАНТИЙ, ВЫРАЖЕННЫХ ЯВНО ИЛИ ПОДРАЗУМЕВАЕМЫХ,
 
22
 ВКЛЮЧАЯ ГАРАНТИИ КОММЕРЧЕСКОЙ ЦЕННОСТИ И ПРИГОДНОСТИ ДЛЯ КОНКРЕТНОЙ ЦЕЛИ, НО НЕ
 
23
 ОГРАНИЧИВАЯСЬ ИМИ. НИ ВЛАДЕЛЕЦ АВТОРСКИХ ПРАВ И НИ ОДНО ДРУГОЕ ЛИЦО, КОТОРОЕ
 
24
 МОЖЕТ ИЗМЕНЯТЬ И/ИЛИ ПОВТОРНО РАСПРОСТРАНЯТЬ ПРОГРАММУ, НИ В КОЕМ СЛУЧАЕ НЕ
 
25
 НЕСЁТ ОТВЕТСТВЕННОСТИ, ВКЛЮЧАЯ ЛЮБЫЕ ОБЩИЕ, СЛУЧАЙНЫЕ, СПЕЦИАЛЬНЫЕ ИЛИ
 
26
 ПОСЛЕДОВАВШИЕ УБЫТКИ, СВЯЗАННЫЕ С ИСПОЛЬЗОВАНИЕМ ИЛИ ПОНЕСЕННЫЕ ВСЛЕДСТВИЕ
 
27
 НЕВОЗМОЖНОСТИ ИСПОЛЬЗОВАНИЯ ПРОГРАММЫ (ВКЛЮЧАЯ ПОТЕРИ ДАННЫХ, ИЛИ ДАННЫЕ,
 
28
 СТАВШИЕ НЕГОДНЫМИ, ИЛИ УБЫТКИ И/ИЛИ ПОТЕРИ ДОХОДОВ, ПОНЕСЕННЫЕ ИЗ-ЗА ДЕЙСТВИЙ
 
29
 ТРЕТЬИХ ЛИЦ И/ИЛИ ОТКАЗА ПРОГРАММЫ РАБОТАТЬ СОВМЕСТНО С ДРУГИМИ ПРОГРАММАМИ,
 
30
 НО НЕ ОГРАНИЧИВАЯСЬ ЭТИМИ СЛУЧАЯМИ), НО НЕ ОГРАНИЧИВАЯСЬ ИМИ, ДАЖЕ ЕСЛИ ТАКОЙ
 
31
 ВЛАДЕЛЕЦ ИЛИ ДРУГОЕ ЛИЦО БЫЛИ ИЗВЕЩЕНЫ О ВОЗМОЖНОСТИ ТАКИХ УБЫТКОВ И ПОТЕРЬ.
 
32
 
 
33
 Redistribution and use in source and binary forms, with or without modification,
 
34
 are permitted provided that the following conditions are met:
 
35
 
 
36
 * Redistributions of source code must retain the above copyright notice,
 
37
 this list of conditions and the following disclaimer.
 
38
 * Redistributions in binary form must reproduce the above copyright notice,
 
39
 this list of conditions and the following disclaimer in the documentation
 
40
 and/or other materials provided with the distribution.
 
41
 * Neither the name of the Cognitive Technologies nor the names of its
 
42
 contributors may be used to endorse or promote products derived from this
 
43
 software without specific prior written permission.
 
44
 
 
45
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
46
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
47
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
48
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 
49
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
50
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
51
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 
52
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 
53
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
54
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
55
 */
56
56
 
57
57
////////////////////////////////////////////////////////////
58
58
// CONTAINER OF THE STRING                                //
64
64
// Modification : 21 Jul 1998                             //
65
65
////////////////////////////////////////////////////////////
66
66
#ifndef __CSTR_H
67
 
   #define __CSTR_H
68
 
 
69
 
   #ifndef __GLOBUS_H
70
 
   #include "globus.h"
71
 
   #endif
72
 
 
73
 
   #include "ccomdefs.h"
74
 
   #include "cstrdefs.h"
 
67
#define __CSTR_H
 
68
 
 
69
#include "globus.h"
 
70
#include "ccomdefs.h"
 
71
#include "cstrdefs.h"
75
72
 
76
73
#ifndef __RECDEFS_H
77
 
   #include "recdefs.h"
78
 
#endif
79
 
   #include "memfunc.h"
80
 
 
81
 
   #ifdef __CSTR__
82
 
      #define CSTR_FUNC  FUN_EXPO
83
 
   #else
84
 
      #define CSTR_FUNC  FUN_IMPO
85
 
   #endif
86
 
 
87
 
   #ifdef __cplusplus
88
 
   extern "C" {
89
 
   #endif
90
 
 
91
 
/////////////////////////////////
92
 
// AK 22.02.99
93
 
//#ifndef Handle
94
 
//typedef void * Handle ;
95
 
//#endif
96
 
#include "cttypext.h"
 
74
#include "recdefs.h"
 
75
#endif
 
76
#include "memfunc.h"
 
77
 
 
78
#ifdef __CSTR__
 
79
#define CSTR_FUNC  FUN_EXPO
 
80
#else
 
81
#define CSTR_FUNC  FUN_IMPO
 
82
#endif
 
83
 
 
84
#ifdef __cplusplus
 
85
extern "C" {
 
86
#endif
 
87
 
97
88
///////////////////////////////AK
98
89
 
99
 
   CSTR_FUNC(Bool32)  CSTR_Init( Word16 wHeightCode , Handle hStorage);
100
 
   CSTR_FUNC(void)    CSTR_Done(void);
101
 
   CSTR_FUNC(Word32)  CSTR_GetReturnCode(void);
102
 
   CSTR_FUNC(char*)   CSTR_GetReturnString(Word32 dwError);
103
 
   CSTR_FUNC(Bool32)  CSTR_SetImportData(Word32 dwType, void * pData);
104
 
   CSTR_FUNC(Bool32)  CSTR_GetExportData(Word32 dwType, void * pData);
105
 
 
106
 
    enum CSTRFunctionsExt
107
 
        {
108
 
        CSTR_FNNEWLINE,
109
 
        CSTR_FNDELLINE,
110
 
        CSTR_FNSETSTRATTR,
111
 
        CSTR_FNGETSTRATTR,
112
 
        CSTR_FNGETFIRST,
113
 
        CSTR_FNGETLAST,
114
 
        CSTR_FNGETNEXT,
115
 
        CSTR_FNGETPREV,
116
 
        CSTR_FNGETLINE,
117
 
        CSTR_FNSTORELINE,
118
 
        CSTR_FNNEWRASTER,
119
 
        CSTR_FNSTORERASTER,
120
 
        CSTR_FNSTORECOMP,
121
 
        CSTR_FNSTORECOLLECTION,
122
 
        CSTR_FNDELRASTER,
123
 
        CSTR_FNVERIFY,
124
 
        CSTR_FNGETRASTER,
125
 
        CSTR_FNGETATTR,
126
 
        CSTR_FNGETCOLLECT,
127
 
        CSTR_FNSETUSER,
128
 
        CSTR_FNGETUSER,
129
 
        CSTR_FNSETATTR,
130
 
        CSTR_FNCOPYLINE,
131
 
        CSTR_FNGETLNHND,
132
 
        CSTR_FNGETCOMP,
133
 
        CSTR_FNNEWUSERCODE,
134
 
        CSTR_FNVERSION,
135
 
        CSTR_FNTOTXT,
136
 
        CSTR_FNINSRST,
137
 
        CSTR_FNMAXNUM,
138
 
        CSTR_FNFIRSTLN,
139
 
        CSTR_FNNEXTTLN,
140
 
        CSTR_FNDELALL,
141
 
        CSTR_FNNEXT,
142
 
        CSTR_FNPREV,
143
 
        CSTR_FNSWAP,
144
 
        CSTR_FNDELSAVE,
145
 
        CSTR_FNRESTRAST,
146
 
        CSTR_FNCOMPOSE,
147
 
        CSTR_KILLIM,
148
 
        CSTR_FNSAVE,
149
 
        CSTR_FNGETLIST,
150
 
        CSTR_FNSETLIST,
151
 
        CSTR_FNGETCOLLECTIONUNI,
152
 
        CSTR_FNSTORECOLLECTIONUNI,
153
 
        CSTR_FNGETCONTAINER,
154
 
        CSTR_FNSTORESCALE,
155
 
        CSTR_FNGETLINEFIRST,
156
 
        CSTR_FNGETLINENEXT,
157
 
        CSTR_FNCLEARLINE,
158
 
        CSTR_FNGETRASTERLINE,
159
 
        CSTR_FNSETDUP    ,
160
 
        CSTR_FNSETDUPEND ,
161
 
        CSTR_FNGETDUP    ,
162
 
        CSTR_FNGETDUPEND ,
163
 
        CSTR_FNPACK,
164
 
        CSTR_FNUNPACK,
165
 
        CSTR_FNSORTFRAGM,
166
 
        CSTR_FNFIRSTLINEFRAGM,
167
 
        CSTR_FNNEXTLINEFRAGM,
168
 
        CSTR_FNSTORECOMPORIGINAL,
169
 
        CSTR_FNGETMAXFRAGMENT,
170
 
        CSTR_SAVECONT,
171
 
        CSTR_RESTORECONT,
172
 
        CSTR_INSERTRASTERDOWN,
173
 
        CSTR_COPYRASTER,
174
 
        CSTR_DELETELOOPS,
175
 
        CSTR_GETNEXTDOWN,
176
 
        CSTR_GETPREVDOWN,
177
 
        CSTR_GETNEXTUP,
178
 
        CSTR_GETPREVUP,
179
 
        CSTR_GETLENGTH,
180
 
        CSTR_FNTOTXT_COORD
181
 
        };
182
 
    enum CSTRFunctionsImp
183
 
        {
184
 
        CSTR_FNIMP_ALLOC,
185
 
        CSTR_FNIMP_REALLOC,
186
 
        CSTR_FNIMP_FREE,
187
 
        CSTR_FNIMP_OPEN,
188
 
        CSTR_FNIMP_CLOSE,
189
 
        CSTR_FNIMP_READ,
190
 
        CSTR_FNIMP_WRITE
191
 
        };
192
 
 
193
 
// 1    CSTR_FNNEWLINE      ���������� ����� ������
194
 
typedef CSTR_line       (*FNCSTR_NewLine)(Int32  lineno, Int32 version, Int32 container);
195
 
CSTR_FUNC(CSTR_line)    CSTR_NewLine (Int32  lineno, Int32 version, Int32 container);
196
 
// 2    CSTR_FNDELLINE      ������� ������
197
 
typedef Bool32          (*FNCSTR_DeleteLine)(CSTR_line  line);
198
 
CSTR_FUNC(Bool32)           CSTR_DeleteLine (CSTR_line  line);
199
 
// 3    CSTR_FNSETSTRATTR   ���������� �������� ������� ������
200
 
typedef Bool32          (*FNCSTR_SetLineAttr)(CSTR_line  line,CSTR_attr * attr);
201
 
CSTR_FUNC(Bool32)               CSTR_SetLineAttr (CSTR_line      line,CSTR_attr * attr);
202
 
// 4    CSTR_FNGETSTRATTR   �������� �������� ������� ������
203
 
typedef Bool32          (*FNCSTR_GetLineAttr)(CSTR_line  line,CSTR_attr * attr);
204
 
CSTR_FUNC(Bool32)           CSTR_GetLineAttr (CSTR_line  line,CSTR_attr * attr);
205
 
// 5    CSTR_FNGETFIRST     ���� ����� ������� (����������) ������ � ������
206
 
typedef CSTR_rast       (*FNCSTR_GetFirstRaster)(CSTR_line      line);
207
 
CSTR_FUNC(CSTR_rast)    CSTR_GetFirstRaster (CSTR_line  line);
208
 
// 6    CSTR_FNGETLAST      ���� ����� ���������� (����������) ������ � ������
209
 
typedef CSTR_rast       (*FNCSTR_GetLastRaster)(CSTR_line       line);
210
 
CSTR_FUNC(CSTR_rast)    CSTR_GetLastRaster (CSTR_line   line);
211
 
// 7    CSTR_FNGETNEXT      ���� ����� ���������� ������
212
 
typedef CSTR_rast       (*FNCSTR_GetNextRaster)(CSTR_rast  curr_raster, Word32 type_raster);
213
 
CSTR_FUNC(CSTR_rast)    CSTR_GetNextRaster (CSTR_rast  curr_raster, Word32 type_raster);
214
 
// 8    CSTR_FNGETPREV      ���� ����� ����������� ������
215
 
typedef CSTR_rast       (*FNCSTR_GetPrevRaster)(CSTR_rast  curr_raster, Word32 type_raster);
216
 
CSTR_FUNC(CSTR_rast)    CSTR_GetPrevRaster (CSTR_rast  curr_raster, Word32 type_raster);
217
 
// 9    CSTR_FNGETLINE      ���� ����� ������, ���������� � �������
218
 
typedef CSTR_line       (*FNCSTR_GetLine)(CSTR_rast  curr_raster);
219
 
CSTR_FUNC(CSTR_line)    CSTR_GetLine (CSTR_rast  curr_raster);
220
 
// 10   CSTR_FNSTORELINE    ������� ������ ������
221
 
typedef Bool32          (*FNCSTR_StoreLine)(CSTR_rast  curr_raster, CSTR_line line);
222
 
CSTR_FUNC(Bool32)               CSTR_StoreLine (CSTR_rast  curr_raster, CSTR_line line);
223
 
// 11   CSTR_FNNEWRASTER    ������� ����� ����� � ������� ������
224
 
typedef CSTR_rast               (*FNCSTR_NewRaster)(CSTR_line   line ,Int32 col, Int32 row, Int32 w);
225
 
CSTR_FUNC(CSTR_rast)            CSTR_NewRaster (CSTR_line       line ,Int32 col, Int32 row, Int32 w);
226
 
// 12   CSTR_FNSTORERASTER  ��������� ����� ��� �����������
227
 
typedef Bool32          (*FNCSTR_StoreRaster)(CSTR_rast  curr_raster, RecRaster *image);
228
 
CSTR_FUNC(Bool32)               CSTR_StoreRaster (CSTR_rast  curr_raster, RecRaster *image);
229
 
// 13   CSTR_FNSTORECOMP ��������� ����� ��� ���������� � ������������ ��������������
230
 
typedef Bool32          (*FNCSTR_StoreComp)(CSTR_rast  curr_raster, Word8 *lp, Bool32 raster_init, Word8 scale);
231
 
CSTR_FUNC(Bool32)               CSTR_StoreComp (CSTR_rast  curr_raster, Word8 *lp, Bool32 raster_init, Word8 scale);
232
 
// 14   CSTR_FNSTORECOLLECTION ��������� ���������
233
 
typedef Bool32          (*FNCSTR_StoreCollection)(CSTR_rast  curr_raster, RecVersions *collect);
234
 
CSTR_FUNC(Bool32)                   CSTR_StoreCollection (CSTR_rast  curr_raster, RecVersions *collect);
235
 
// 15   CSTR_FNDELRASTER    ������� �����
236
 
typedef CSTR_rast   (*FNCSTR_DelRaster)(CSTR_rast  curr_raster);
237
 
CSTR_FUNC(CSTR_rast)    CSTR_DelRaster (CSTR_rast  curr_raster);
238
 
// 16   CSTR_FNVERIFY       ������������� ������ ������
239
 
typedef Bool32          (*FNCSTR_VerifyLine)(CSTR_line  line);
240
 
CSTR_FUNC(Bool32)               CSTR_VerifyLine (CSTR_line      line);
241
 
// 17   CSTR_FNGETRASTER    �������� ����������� (����� ��� ���������)
242
 
typedef Bool32          (*FNCSTR_GetImage)(CSTR_rast  curr_raster, Word8 *out_res, Word32 type_image);
243
 
CSTR_FUNC(Bool32)               CSTR_GetImage (CSTR_rast  curr_raster, Word8 *out_res, Word32 type_image);
244
 
// 18   CSTR_FNGETATTR      �������� �������� ������
245
 
typedef Bool32          (*FNCSTR_GetAttr)(CSTR_rast  curr_raster, CSTR_rast_attr * attr);
246
 
CSTR_FUNC(Bool32)           CSTR_GetAttr (CSTR_rast  curr_raster, CSTR_rast_attr * attr);
247
 
// 19   CSTR_FNGETCOLLECT   �������� ���������
248
 
typedef Bool32          (*FNCSTR_GetCollection)(CSTR_rast  curr_raster, RecVersions *result_collect);
249
 
CSTR_FUNC(Bool32)                   CSTR_GetCollection (CSTR_rast  curr_raster, RecVersions *result_collect);
250
 
// 20   CSTR_FNSETUSER      �������� � ����� ���������������� ������
251
 
typedef Bool32          (*FNCSTR_SetUserAttr)(CSTR_rast raster, CCOM_USER_BLOCK  *ub);
252
 
CSTR_FUNC(Bool32)               CSTR_SetUserAttr (CSTR_rast raster, CCOM_USER_BLOCK  *ub);
253
 
// 21   CSTR_FNGETUSER      ��������� �� ������ ���������������� ������
254
 
typedef Bool32          (*FNCSTR_GetUserAttr)(CSTR_rast raster, CCOM_USER_BLOCK  *ub);
255
 
CSTR_FUNC(Bool32)               CSTR_GetUserAttr (CSTR_rast raster, CCOM_USER_BLOCK  *ub);
256
 
// 22   CSTR_FNSETATTR      �������� �������� ������
257
 
typedef Bool32          (*FNCSTR_SetAttr)(CSTR_rast  curr_raster, CSTR_rast_attr * attr);
258
 
CSTR_FUNC(Bool32)           CSTR_SetAttr (CSTR_rast  curr_raster, CSTR_rast_attr * attr);
259
 
// 23   CSTR_FNCOPYLINE     ����������� ���������� ������
260
 
typedef Bool32  (*FNCSTR_CopyLine)(CSTR_line    trg,CSTR_line   src);
261
 
CSTR_FUNC(Bool32)       CSTR_CopyLine (CSTR_line        trg,CSTR_line   src);
262
 
// 24   CSTR_FNGETLNHND     ���� ����� ������ �� ������ � ������
263
 
typedef CSTR_line   (*FNCSTR_GetLineHandle)(Int32 line_no, Int32 version);
264
 
CSTR_FUNC(CSTR_line )   CSTR_GetLineHandle (Int32 line_no, Int32 version);
265
 
// 25   CSTR_FNGETCOMP      �������� ���������y ������
266
 
typedef CCOM_comp *     (*FNCSTR_GetComp)(CSTR_rast  curr_raster);
267
 
CSTR_FUNC(CCOM_comp *)      CSTR_GetComp (CSTR_rast  curr_raster);
268
 
// 26   CSTR_FNNEWUSERCODE  �������� ��������� ��� ����������������� �����
269
 
typedef Int32      (*FNCSTR_NewUserCode) (void);
270
 
CSTR_FUNC(Int32)       CSTR_NewUserCode (void);
271
 
// 27   CSTR_FNVERSION      ������ ����������
272
 
// 28   CSTR_FNTOTXT        �������� ��������� ����� ������
273
 
typedef Bool32            (*FNCSTR_LineToTxt)(CSTR_line lin, char *txt);
274
 
CSTR_FUNC(Bool32)                 CSTR_LineToTxt (CSTR_line     lin, char *txt);
275
 
// 29   CSTR_FNINSRST       �������� ����� ����� ��������
276
 
typedef CSTR_rast       (*FNCSTR_InsertRaster)(CSTR_rast        curr_raster);
277
 
CSTR_FUNC(CSTR_rast)    CSTR_InsertRaster (CSTR_rast    curr_raster);
278
 
// 30   CSTR_FNMAXNUM       ���������� ����� ������ � ����������
279
 
typedef Int32  (*FNCSTR_GetMaxNumber)(void);
280
 
CSTR_FUNC(Int32)   CSTR_GetMaxNumber (void);
281
 
// 31   CSTR_FNFIRSTLN      ������ ������ ��������� ������
282
 
typedef CSTR_line (*FNCSTR_FirstLine)( Int32 version);
283
 
CSTR_FUNC(CSTR_line)  CSTR_FirstLine ( Int32 version);
284
 
// 32   CSTR_FNNEXTTLN      ��������� ������ ��������� ������
285
 
typedef CSTR_line (*FNCSTR_NextLine)( CSTR_line start, Int32 version);
286
 
CSTR_FUNC(CSTR_line)  CSTR_NextLine ( CSTR_line start,Int32 version);
287
 
// 33   CSTR_FNDELALL       ������� ��� ������
 
90
CSTR_FUNC(Bool32) CSTR_Init( uint16_t wHeightCode , Handle hStorage);
 
91
CSTR_FUNC(void) CSTR_Done(void);
 
92
CSTR_FUNC(uint32_t) CSTR_GetReturnCode(void);
 
93
CSTR_FUNC(char*) CSTR_GetReturnString(uint32_t dwError);
 
94
CSTR_FUNC(Bool32) CSTR_SetImportData(uint32_t dwType, void * pData);
 
95
CSTR_FUNC(Bool32) CSTR_GetExportData(uint32_t dwType, void * pData);
 
96
 
 
97
enum CSTRFunctionsExt {
 
98
        CSTR_FNNEWLINE,
 
99
        CSTR_FNDELLINE,
 
100
        CSTR_FNSETSTRATTR,
 
101
        CSTR_FNGETSTRATTR,
 
102
        CSTR_FNGETFIRST,
 
103
        CSTR_FNGETLAST,
 
104
        CSTR_FNGETNEXT,
 
105
        CSTR_FNGETPREV,
 
106
        CSTR_FNGETLINE,
 
107
        CSTR_FNSTORELINE,
 
108
        CSTR_FNNEWRASTER,
 
109
        CSTR_FNSTORERASTER,
 
110
        CSTR_FNSTORECOMP,
 
111
        CSTR_FNSTORECOLLECTION,
 
112
        CSTR_FNDELRASTER,
 
113
        CSTR_FNVERIFY,
 
114
        CSTR_FNGETRASTER,
 
115
        CSTR_FNGETATTR,
 
116
        CSTR_FNGETCOLLECT,
 
117
        CSTR_FNSETUSER,
 
118
        CSTR_FNGETUSER,
 
119
        CSTR_FNSETATTR,
 
120
        CSTR_FNCOPYLINE,
 
121
        CSTR_FNGETLNHND,
 
122
        CSTR_FNGETCOMP,
 
123
        CSTR_FNNEWUSERCODE,
 
124
        CSTR_FNVERSION,
 
125
        CSTR_FNTOTXT,
 
126
        CSTR_FNINSRST,
 
127
        CSTR_FNMAXNUM,
 
128
        CSTR_FNFIRSTLN,
 
129
        CSTR_FNNEXTTLN,
 
130
        CSTR_FNDELALL,
 
131
        CSTR_FNNEXT,
 
132
        CSTR_FNPREV,
 
133
        CSTR_FNSWAP,
 
134
        CSTR_FNDELSAVE,
 
135
        CSTR_FNRESTRAST,
 
136
        CSTR_FNCOMPOSE,
 
137
        CSTR_KILLIM,
 
138
        CSTR_FNSAVE,
 
139
        CSTR_FNGETLIST,
 
140
        CSTR_FNSETLIST,
 
141
        CSTR_FNGETCOLLECTIONUNI,
 
142
        CSTR_FNSTORECOLLECTIONUNI,
 
143
        CSTR_FNGETCONTAINER,
 
144
        CSTR_FNSTORESCALE,
 
145
        CSTR_FNGETLINEFIRST,
 
146
        CSTR_FNGETLINENEXT,
 
147
        CSTR_FNCLEARLINE,
 
148
        CSTR_FNGETRASTERLINE,
 
149
        CSTR_FNSETDUP,
 
150
        CSTR_FNSETDUPEND,
 
151
        CSTR_FNGETDUP,
 
152
        CSTR_FNGETDUPEND,
 
153
        CSTR_FNPACK,
 
154
        CSTR_FNUNPACK,
 
155
        CSTR_FNSORTFRAGM,
 
156
        CSTR_FNFIRSTLINEFRAGM,
 
157
        CSTR_FNNEXTLINEFRAGM,
 
158
        CSTR_FNSTORECOMPORIGINAL,
 
159
        CSTR_FNGETMAXFRAGMENT,
 
160
        CSTR_SAVECONT,
 
161
        CSTR_RESTORECONT,
 
162
        CSTR_INSERTRASTERDOWN,
 
163
        CSTR_COPYRASTER,
 
164
        CSTR_DELETELOOPS,
 
165
        CSTR_GETNEXTDOWN,
 
166
        CSTR_GETPREVDOWN,
 
167
        CSTR_GETNEXTUP,
 
168
        CSTR_GETPREVUP,
 
169
        CSTR_GETLENGTH,
 
170
        CSTR_FNTOTXT_COORD
 
171
};
 
172
enum CSTRFunctionsImp {
 
173
        CSTR_FNIMP_ALLOC,
 
174
        CSTR_FNIMP_REALLOC,
 
175
        CSTR_FNIMP_FREE,
 
176
        CSTR_FNIMP_OPEN,
 
177
        CSTR_FNIMP_CLOSE,
 
178
        CSTR_FNIMP_READ,
 
179
        CSTR_FNIMP_WRITE
 
180
};
 
181
 
 
182
// 1    CSTR_FNNEWLINE      Образовать новую строку
 
183
typedef CSTR_line (*FNCSTR_NewLine)(int32_t lineno, int32_t version,
 
184
                int32_t container);
 
185
CSTR_FUNC(CSTR_line) CSTR_NewLine (int32_t lineno, int32_t version, int32_t container);
 
186
// 2    CSTR_FNDELLINE      Удалить строку
 
187
typedef Bool32 (*FNCSTR_DeleteLine)(CSTR_line line);
 
188
CSTR_FUNC(Bool32) CSTR_DeleteLine (CSTR_line line);
 
189
// 3    CSTR_FNSETSTRATTR   установить атрибуты текущей строки
 
190
typedef Bool32 (*FNCSTR_SetLineAttr)(CSTR_line line, CSTR_attr * attr);
 
191
CSTR_FUNC(Bool32) CSTR_SetLineAttr (CSTR_line line,CSTR_attr * attr);
 
192
// 4    CSTR_FNGETSTRATTR   получить атрибуты текущей строки
 
193
typedef Bool32 (*FNCSTR_GetLineAttr)(CSTR_line line, CSTR_attr * attr);
 
194
CSTR_FUNC(Bool32) CSTR_GetLineAttr (CSTR_line line,CSTR_attr * attr);
 
195
// 5    CSTR_FNGETFIRST     дать хэндл первого (фиктивного) растра в строке
 
196
typedef CSTR_rast (*FNCSTR_GetFirstRaster)(CSTR_line line);
 
197
CSTR_FUNC(CSTR_rast) CSTR_GetFirstRaster (CSTR_line line);
 
198
// 6    CSTR_FNGETLAST      дать хэндл последнего (фиктивного) растра в строке
 
199
typedef CSTR_rast (*FNCSTR_GetLastRaster)(CSTR_line line);
 
200
CSTR_FUNC(CSTR_rast) CSTR_GetLastRaster (CSTR_line line);
 
201
// 7    CSTR_FNGETNEXT      дать хэндл следующего растра
 
202
typedef CSTR_rast (*FNCSTR_GetNextRaster)(CSTR_rast curr_raster,
 
203
                uint32_t type_raster);
 
204
CSTR_FUNC(CSTR_rast) CSTR_GetNextRaster (CSTR_rast curr_raster, uint32_t type_raster);
 
205
// 8    CSTR_FNGETPREV      дать хэндл предыдущего растра
 
206
typedef CSTR_rast (*FNCSTR_GetPrevRaster)(CSTR_rast curr_raster,
 
207
                uint32_t type_raster);
 
208
CSTR_FUNC(CSTR_rast) CSTR_GetPrevRaster (CSTR_rast curr_raster, uint32_t type_raster);
 
209
// 9    CSTR_FNGETLINE      дать хэндл строки, сопряжённой с растром
 
210
typedef CSTR_line (*FNCSTR_GetLine)(CSTR_rast curr_raster);
 
211
CSTR_FUNC(CSTR_line) CSTR_GetLine (CSTR_rast curr_raster);
 
212
// 10   CSTR_FNSTORELINE    придать растру строку
 
213
typedef Bool32 (*FNCSTR_StoreLine)(CSTR_rast curr_raster, CSTR_line line);
 
214
CSTR_FUNC(Bool32) CSTR_StoreLine (CSTR_rast curr_raster, CSTR_line line);
 
215
// 11   CSTR_FNNEWRASTER    создать новый растр в текущей строке
 
216
typedef CSTR_rast (*FNCSTR_NewRaster)(CSTR_line line, int32_t col, int32_t row,
 
217
                int32_t w);
 
218
CSTR_FUNC(CSTR_rast) CSTR_NewRaster (CSTR_line line ,int32_t col, int32_t row, int32_t w);
 
219
// 12   CSTR_FNSTORERASTER  запомнить растр как изображение
 
220
typedef Bool32 (*FNCSTR_StoreRaster)(CSTR_rast curr_raster, RecRaster *image);
 
221
CSTR_FUNC(Bool32) CSTR_StoreRaster (CSTR_rast curr_raster, RecRaster *image);
 
222
// 13   CSTR_FNSTORECOMP запомнить растр как компоненту с интервальным представлением
 
223
typedef Bool32 (*FNCSTR_StoreComp)(CSTR_rast curr_raster, uchar *lp,
 
224
                Bool32 raster_init, uchar scale);
 
225
CSTR_FUNC(Bool32) CSTR_StoreComp (CSTR_rast curr_raster, uchar *lp, Bool32 raster_init, uchar scale);
 
226
// 14   CSTR_FNSTORECOLLECTION запомнить коллекцию
 
227
typedef Bool32 (*FNCSTR_StoreCollection)(CSTR_rast curr_raster,
 
228
                RecVersions *collect);
 
229
CSTR_FUNC(Bool32) CSTR_StoreCollection (CSTR_rast curr_raster, RecVersions *collect);
 
230
// 15   CSTR_FNDELRASTER    удалить растр
 
231
typedef CSTR_rast (*FNCSTR_DelRaster)(CSTR_rast curr_raster);
 
232
CSTR_FUNC(CSTR_rast) CSTR_DelRaster (CSTR_rast curr_raster);
 
233
// 16   CSTR_FNVERIFY       отсортировать список строки
 
234
typedef Bool32 (*FNCSTR_VerifyLine)(CSTR_line line);
 
235
CSTR_FUNC(Bool32) CSTR_VerifyLine (CSTR_line line);
 
236
// 17   CSTR_FNGETRASTER    получить изображение (растр или интервалы)
 
237
typedef Bool32 (*FNCSTR_GetImage)(CSTR_rast curr_raster, uchar *out_res,
 
238
                uint32_t type_image);
 
239
CSTR_FUNC(Bool32) CSTR_GetImage (CSTR_rast curr_raster, uchar *out_res, uint32_t type_image);
 
240
// 18   CSTR_FNGETATTR      получить атрибуты растра
 
241
typedef Bool32 (*FNCSTR_GetAttr)(CSTR_rast curr_raster, CSTR_rast_attr * attr);
 
242
CSTR_FUNC(Bool32) CSTR_GetAttr (CSTR_rast curr_raster, CSTR_rast_attr * attr);
 
243
// 19   CSTR_FNGETCOLLECT   получить коллекцию
 
244
typedef Bool32 (*FNCSTR_GetCollection)(CSTR_rast curr_raster,
 
245
                RecVersions *result_collect);
 
246
CSTR_FUNC(Bool32) CSTR_GetCollection (CSTR_rast curr_raster, RecVersions *result_collect);
 
247
// 20   CSTR_FNSETUSER      записать в растр пользовательские данные
 
248
typedef Bool32 (*FNCSTR_SetUserAttr)(CSTR_rast raster, CCOM_USER_BLOCK *ub);
 
249
CSTR_FUNC(Bool32) CSTR_SetUserAttr (CSTR_rast raster, CCOM_USER_BLOCK *ub);
 
250
// 21   CSTR_FNGETUSER      прочитать из растра пользовательские данные
 
251
typedef Bool32 (*FNCSTR_GetUserAttr)(CSTR_rast raster, CCOM_USER_BLOCK *ub);
 
252
CSTR_FUNC(Bool32) CSTR_GetUserAttr (CSTR_rast raster, CCOM_USER_BLOCK *ub);
 
253
// 22   CSTR_FNSETATTR      записать атрибуты растра
 
254
typedef Bool32 (*FNCSTR_SetAttr)(CSTR_rast curr_raster, CSTR_rast_attr * attr);
 
255
CSTR_FUNC(Bool32) CSTR_SetAttr (CSTR_rast curr_raster, CSTR_rast_attr * attr);
 
256
// 23   CSTR_FNCOPYLINE     скопировать содержимое строки
 
257
typedef Bool32 (*FNCSTR_CopyLine)(CSTR_line trg, CSTR_line src);
 
258
CSTR_FUNC(Bool32) CSTR_CopyLine (CSTR_line trg,CSTR_line src);
 
259
// 24   CSTR_FNGETLNHND     дать хендл строки по номеру и версии
 
260
typedef CSTR_line (*FNCSTR_GetLineHandle)(int32_t line_no, int32_t version);
 
261
CSTR_FUNC(CSTR_line ) CSTR_GetLineHandle (int32_t line_no, int32_t version);
 
262
// 25   CSTR_FNGETCOMP      получить компонентy растра
 
263
typedef CCOM_comp * (*FNCSTR_GetComp)(CSTR_rast curr_raster);
 
264
CSTR_FUNC(CCOM_comp *) CSTR_GetComp (CSTR_rast curr_raster);
 
265
// 26   CSTR_FNNEWUSERCODE  получить доступный код пользовательского блока
 
266
typedef int32_t (*FNCSTR_NewUserCode)(void);
 
267
CSTR_FUNC(int32_t) CSTR_NewUserCode (void);
 
268
// 27   CSTR_FNVERSION      версия библиотеки
 
269
// 28   CSTR_FNTOTXT        получить текстовый обрах строки
 
270
typedef Bool32 (*FNCSTR_LineToTxt)(CSTR_line lin, char *txt);
 
271
CSTR_FUNC(Bool32) CSTR_LineToTxt (CSTR_line lin, char *txt);
 
272
// 29   CSTR_FNINSRST       вставить растр после текущего
 
273
typedef CSTR_rast (*FNCSTR_InsertRaster)(CSTR_rast curr_raster);
 
274
CSTR_FUNC(CSTR_rast) CSTR_InsertRaster (CSTR_rast curr_raster);
 
275
// 30   CSTR_FNMAXNUM       наибольший номер строки в контейнере
 
276
typedef int32_t (*FNCSTR_GetMaxNumber)(void);
 
277
CSTR_FUNC(int32_t) CSTR_GetMaxNumber (void);
 
278
// 31   CSTR_FNFIRSTLN      первая строка указанной версии
 
279
typedef CSTR_line (*FNCSTR_FirstLine)(int32_t version);
 
280
CSTR_FUNC(CSTR_line) CSTR_FirstLine ( int32_t version);
 
281
// 32   CSTR_FNNEXTTLN      следующая строка указанной версии
 
282
typedef CSTR_line (*FNCSTR_NextLine)(CSTR_line start, int32_t version);
 
283
CSTR_FUNC(CSTR_line) CSTR_NextLine ( CSTR_line start,int32_t version);
 
284
// 33   CSTR_FNDELALL       удалить все строки
288
285
typedef void (*FNCSTR_DeleteAll)(void);
289
286
CSTR_FUNC(void) CSTR_DeleteAll(void);
290
 
// 34   CSTR_FNNEXT         ��������� ����������� �����
291
 
typedef CSTR_rast  (*FNCSTR_GetNext)(CSTR_rast rst);
292
 
CSTR_FUNC(CSTR_rast)    CSTR_GetNext(CSTR_rast rst);
293
 
// 35   CSTR_FNPREV         ���������� ����������� �����
294
 
typedef CSTR_rast  (*FNCSTR_GetPrev)(CSTR_rast rst);
295
 
CSTR_FUNC(CSTR_rast)    CSTR_GetPrev(CSTR_rast rst);
296
 
// 36   CSTR_FNSWAP         �������� ������� 2 ������
 
287
// 34   CSTR_FNNEXT         следующий нефиктивный растр
 
288
typedef CSTR_rast (*FNCSTR_GetNext)(CSTR_rast rst);
 
289
CSTR_FUNC(CSTR_rast) CSTR_GetNext(CSTR_rast rst);
 
290
// 35   CSTR_FNPREV         предыдущий нефиктивный растр
 
291
typedef CSTR_rast (*FNCSTR_GetPrev)(CSTR_rast rst);
 
292
CSTR_FUNC(CSTR_rast) CSTR_GetPrev(CSTR_rast rst);
 
293
// 36   CSTR_FNSWAP         обменять местами 2 растра
297
294
typedef Bool32 (*FNCSTR_SwapRasters)(CSTR_rast r1, CSTR_rast r2);
298
295
CSTR_FUNC(Bool32) CSTR_SwapRasters(CSTR_rast r1, CSTR_rast r2);
299
 
// 37   CSTR_FNDELSAVE      ������� � �����������
 
296
// 37   CSTR_FNDELSAVE      удалить с сохранением
300
297
typedef CSTR_rast (*FNCSTR_DelSaveRaster)(CSTR_rast c);
301
 
CSTR_FUNC(CSTR_rast)    CSTR_DelSaveRaster(CSTR_rast c);
302
 
// 38   CSTR_FNRESTRAST     ������������
303
 
typedef CSTR_rast (*FNCSTR_RestoreRaster)(CSTR_line ln,CSTR_rast rst);
 
298
CSTR_FUNC(CSTR_rast) CSTR_DelSaveRaster(CSTR_rast c);
 
299
// 38   CSTR_FNRESTRAST     восстановить
 
300
typedef CSTR_rast (*FNCSTR_RestoreRaster)(CSTR_line ln, CSTR_rast rst);
304
301
CSTR_FUNC(CSTR_rast) CSTR_RestoreRaster(CSTR_line ln,CSTR_rast rst);
305
 
// 39   CSTR_FNCOMPOSE      ������� ������ �������
306
 
typedef CSTR_rast (*FNCSTR_compose_Cell)(Int32 n,CSTR_rast *clist, Int32 nIncline, Bool32 NeedDel);
307
 
CSTR_FUNC(CSTR_rast) CSTR_compose_Cell(Int32 n,CSTR_rast *clist, Int32 nIncline, Bool32 NeedDel);
308
 
// 40   CSTR_KILLIM         ����� ����� � ������
309
 
typedef Bool32  (*FNCSTR_KillImage)(CSTR_rast rst);
 
302
// 39   CSTR_FNCOMPOSE      склеить массив растров
 
303
typedef CSTR_rast (*FNCSTR_compose_Cell)(int32_t n, CSTR_rast *clist,
 
304
                int32_t nIncline, Bool32 NeedDel);
 
305
CSTR_FUNC(CSTR_rast) CSTR_compose_Cell(int32_t n,CSTR_rast *clist, int32_t nIncline, Bool32 NeedDel);
 
306
// 40   CSTR_KILLIM         убить образ в растре
 
307
typedef Bool32 (*FNCSTR_KillImage)(CSTR_rast rst);
310
308
CSTR_FUNC(Bool32) CSTR_KillImage(CSTR_rast rst);
311
309
// 41   CSTR_FNSAVE
312
 
typedef CSTR_rast    (*FNCSTR_SaveRaster)(CSTR_rast c);
313
 
CSTR_FUNC(CSTR_rast)    CSTR_SaveRaster(CSTR_rast c);
 
310
typedef CSTR_rast (*FNCSTR_SaveRaster)(CSTR_rast c);
 
311
CSTR_FUNC(CSTR_rast) CSTR_SaveRaster(CSTR_rast c);
314
312
// 42   CSTR_FNGETLIST
315
313
typedef CSTR_rast (*FNCSTR_GetComplist)(CSTR_rast rst);
316
314
CSTR_FUNC(CSTR_rast) CSTR_GetComplist(CSTR_rast rst);
317
315
// 43   CSTR_FNSETLIST
318
316
typedef Bool32 (*FNCSTR_SetComplist)(CSTR_rast rst, CSTR_rast complist);
319
317
CSTR_FUNC(Bool32) CSTR_SetComplist(CSTR_rast rst, CSTR_rast complist);
320
 
// 44   CSTR_FNGETCOLLECTIONUNI ���� ����������� ���������
321
 
typedef Bool32(*FNCSTR_GetCollectionUni) (CSTR_rast  curr_raster, UniVersions *result_collect);
322
 
CSTR_FUNC(Bool32)                   CSTR_GetCollectionUni (CSTR_rast  curr_raster, UniVersions *result_collect);
323
 
// 45   CSTR_FNSTORECOLLECTIONUNI ��������� ����������� ���������
324
 
typedef Bool32(*FNCSTR_StoreCollectionUni) (CSTR_rast  curr_raster, UniVersions *result_collect);
325
 
CSTR_FUNC(Bool32)                   CSTR_StoreCollectionUni (CSTR_rast  curr_raster, UniVersions *result_collect);
326
 
// 46   CSTR_FNGETCONTAINER ���� ����� ���������� ������
 
318
// 44   CSTR_FNGETCOLLECTIONUNI дать расширенную коллекцию
 
319
typedef Bool32(*FNCSTR_GetCollectionUni)(CSTR_rast curr_raster,
 
320
                UniVersions *result_collect);
 
321
CSTR_FUNC(Bool32) CSTR_GetCollectionUni (CSTR_rast curr_raster, UniVersions *result_collect);
 
322
// 45   CSTR_FNSTORECOLLECTIONUNI запомнить расширенную коллекцию
 
323
typedef Bool32(*FNCSTR_StoreCollectionUni)(CSTR_rast curr_raster,
 
324
                UniVersions *result_collect);
 
325
CSTR_FUNC(Bool32) CSTR_StoreCollectionUni (CSTR_rast curr_raster, UniVersions *result_collect);
 
326
// 46   CSTR_FNGETCONTAINER дать хэндл контейнера строки
327
327
typedef CCOM_handle (*FNCSTR_GetContainer)(CSTR_line ln);
328
328
CSTR_FUNC(CCOM_handle) CSTR_GetContainer(CSTR_line ln);
329
 
// 47   CSTR_FNSTORESCALE   ��������� ��� ���������������
330
 
typedef Bool32 (*FNCSTR_StoreScale)(CSTR_rast  curr_raster,Word8 scale);
331
 
CSTR_FUNC(Bool32)               CSTR_StoreScale(CSTR_rast  curr_raster,Word8 scale);
332
 
// 48   CSTR_GETLINEFIRST   ���� ����� ������ ������ ������ ��������� � ������
333
 
typedef CSTR_line (*FNCSTR_GetLineFirst) ( Int32 fragment_no, Int32 version);
334
 
CSTR_FUNC(CSTR_line )   CSTR_GetLineFirst ( Int32 fragment_no, Int32 version);
335
 
// 49   CSTR_GETLINENEXT    ���� ����� ��������� ������ ������ ��������� � ������
336
 
typedef CSTR_line (*FNCSTR_GetLineNext) (CSTR_line lin, Int32 fragment_no, Int32 version);
337
 
CSTR_FUNC(CSTR_line )   CSTR_GetLineNext (CSTR_line lin, Int32 fragment_no, Int32 version);
338
 
// 50   CSTR_FNCLEARLINE    ������� ������ �� ������
339
 
typedef Bool32 (*FNCSTR_ClearLine)(CSTR_line lin,Int16 left, Int16 right);
340
 
CSTR_FUNC(Bool32) CSTR_ClearLine(CSTR_line lin,Int16 left, Int16 right);
341
 
// 51   CSTR_GETRASTERLINE      ���� ����� ������ ������
342
 
typedef CSTR_line  (*FNCSTR_GetRasterLine) (CSTR_rast  curr_raster);
343
 
CSTR_FUNC(CSTR_line)    CSTR_GetRasterLine (CSTR_rast  curr_raster);
344
 
// 52   CSTR_SETDUP             ��������� ����� ����������� ������
345
 
typedef Bool32 (*FNCSTR_SetDup)(CSTR_rast   rus, CSTR_rast   eng);
346
 
CSTR_FUNC(Bool32) CSTR_SetDup(CSTR_rast   rus, CSTR_rast   eng);
347
 
// 53   CSTR_SETDUPEND          ��������� ����� ��������������� ����������� ������
348
 
typedef Bool32 (*FNCSTR_SetDupEnd)(CSTR_rast   rus,CSTR_rast    eng);
349
 
CSTR_FUNC(Bool32) CSTR_SetDupEnd(CSTR_rast   rus,CSTR_rast    eng);
350
 
// 54   CSTR_GETDUP             ���� ����� ����������� ������
 
329
// 47   CSTR_FNSTORESCALE   запомнить код масштабирования
 
330
typedef Bool32 (*FNCSTR_StoreScale)(CSTR_rast curr_raster, uchar scale);
 
331
CSTR_FUNC(Bool32) CSTR_StoreScale(CSTR_rast curr_raster,uchar scale);
 
332
// 48   CSTR_GETLINEFIRST   дать хэндл первой строки данных фрагмента и версии
 
333
typedef CSTR_line (*FNCSTR_GetLineFirst)(int32_t fragment_no, int32_t version);
 
334
CSTR_FUNC(CSTR_line ) CSTR_GetLineFirst ( int32_t fragment_no, int32_t version);
 
335
// 49   CSTR_GETLINENEXT    дать хэндл следующей строки данных фрагмента и версии
 
336
typedef CSTR_line (*FNCSTR_GetLineNext)(CSTR_line lin, int32_t fragment_no,
 
337
                int32_t version);
 
338
CSTR_FUNC(CSTR_line ) CSTR_GetLineNext (CSTR_line lin, int32_t fragment_no, int32_t version);
 
339
// 50   CSTR_FNCLEARLINE    Удалить растры из строки
 
340
typedef Bool32 (*FNCSTR_ClearLine)(CSTR_line lin, int16_t left, int16_t right);
 
341
CSTR_FUNC(Bool32) CSTR_ClearLine(CSTR_line lin,int16_t left, int16_t right);
 
342
// 51   CSTR_GETRASTERLINE      дать хэндл строки растра
 
343
typedef CSTR_line (*FNCSTR_GetRasterLine)(CSTR_rast curr_raster);
 
344
CSTR_FUNC(CSTR_line) CSTR_GetRasterLine (CSTR_rast curr_raster);
 
345
// 52   CSTR_SETDUP             запомнить хэндл сопряжённого растра
 
346
typedef Bool32 (*FNCSTR_SetDup)(CSTR_rast rus, CSTR_rast eng);
 
347
CSTR_FUNC(Bool32) CSTR_SetDup(CSTR_rast rus, CSTR_rast eng);
 
348
// 53   CSTR_SETDUPEND          запомнить хэндл дополнительного сопряжённого растра
 
349
typedef Bool32 (*FNCSTR_SetDupEnd)(CSTR_rast rus, CSTR_rast eng);
 
350
CSTR_FUNC(Bool32) CSTR_SetDupEnd(CSTR_rast rus,CSTR_rast eng);
 
351
// 54   CSTR_GETDUP             дать хэндл сопряжённого растра
351
352
typedef CSTR_rast (*FNCSTR_GetDup)(CSTR_rast rus);
352
353
CSTR_FUNC(CSTR_rast) CSTR_GetDup(CSTR_rast rus);
353
 
// 55   CSTR_GETDUPEND          ���� ����� ��������������� ����������� ������
 
354
// 55   CSTR_GETDUPEND          дать хэндл дополнительного сопряжённого растра
354
355
typedef CSTR_rast (*FNCSTR_GetDupEnd)(CSTR_rast rus);
355
356
CSTR_FUNC(CSTR_rast) CSTR_GetDupEnd(CSTR_rast rus);
356
 
// 56   CSTR_FNPACK:            ������� ����������� ����������
 
357
// 56   CSTR_FNPACK:            удалить дублирующую информацию
357
358
typedef Bool32 (*FNCSTR_PackLine)(CSTR_line line);
358
359
CSTR_FUNC(Bool32) CSTR_PackLine(CSTR_line line);
359
 
// 57   CSTR_FNUNPACK:          ������������ ����������� ����������
 
360
// 57   CSTR_FNUNPACK:          восстановить дублирующую информацию
360
361
typedef Bool32 (*FNCSTR_UnpackLine)(CSTR_line line);
361
362
CSTR_FUNC(Bool32) CSTR_UnpackLine(CSTR_line line);
362
 
// 58   CSTR_FNSORTFRAGM        ������������� �� ����������
363
 
typedef Bool32  (*FNCSTR_SortFragm)( Int32 version);
364
 
CSTR_FUNC(Bool32)       CSTR_SortFragm ( Int32 version);
365
 
// 59   CSTR_FNFIRSTLINEFRAGM   ������ �� ���������
366
 
typedef CSTR_line       (*FNCSTR_FirstLineFragm)( Int32 fragm, Int32 version );
367
 
CSTR_FUNC(CSTR_line)    CSTR_FirstLineFragm ( Int32 fragm, Int32 version );
368
 
// 60   CSTR_FNNEXTLINEFRAGM    ��������� �� ���������
369
 
typedef CSTR_line       (*FNCSTR_NextLineFragm)( CSTR_line start);
370
 
CSTR_FUNC(CSTR_line)    CSTR_NextLineFragm ( CSTR_line start);
371
 
// 61   CSTR_FNSTORECOMPORIGINAL    ��������� ���������� (��� ������������� ����������)
372
 
typedef Bool32          (*FNCSTR_StoreCompOriginal) (CSTR_rast  curr_raster, CCOM_comp   * comp, Bool32 raster_init);
373
 
CSTR_FUNC(Bool32)               CSTR_StoreCompOriginal (CSTR_rast  curr_raster, CCOM_comp   * comp, Bool32 raster_init);
374
 
// 62   CSTR_FNGETMAXFRAGMENT   ������������ ����� ���������
375
 
typedef Int32    (*FNCSTR_GetMaxFragment)(Int32 version);
376
 
CSTR_FUNC(Int32)    CSTR_GetMaxFragment(Int32 version);
377
 
// 63   CSTR_SAVECONT           ��������� ��������� �� �����
 
363
// 58   CSTR_FNSORTFRAGM        отсортировать по фрагментам
 
364
typedef Bool32 (*FNCSTR_SortFragm)(int32_t version);
 
365
CSTR_FUNC(Bool32) CSTR_SortFragm ( int32_t version);
 
366
// 59   CSTR_FNFIRSTLINEFRAGM   первая во фрагменте
 
367
typedef CSTR_line (*FNCSTR_FirstLineFragm)(int32_t fragm, int32_t version);
 
368
CSTR_FUNC(CSTR_line) CSTR_FirstLineFragm ( int32_t fragm, int32_t version );
 
369
// 60   CSTR_FNNEXTLINEFRAGM    следующая по фрагменту
 
370
typedef CSTR_line (*FNCSTR_NextLineFragm)(CSTR_line start);
 
371
CSTR_FUNC(CSTR_line) CSTR_NextLineFragm ( CSTR_line start);
 
372
// 61   CSTR_FNSTORECOMPORIGINAL    запомнить компоненту (для оригинального контейнера)
 
373
typedef Bool32 (*FNCSTR_StoreCompOriginal)(CSTR_rast curr_raster,
 
374
                CCOM_comp * comp, Bool32 raster_init);
 
375
CSTR_FUNC(Bool32) CSTR_StoreCompOriginal (CSTR_rast curr_raster, CCOM_comp * comp, Bool32 raster_init);
 
376
// 62   CSTR_FNGETMAXFRAGMENT   максимальный номер фрагмента
 
377
typedef int32_t (*FNCSTR_GetMaxFragment)(int32_t version);
 
378
CSTR_FUNC(int32_t) CSTR_GetMaxFragment(int32_t version);
 
379
// 63   CSTR_SAVECONT           сохранить контейнер на диске
378
380
typedef Bool32 (*FNCSTR_SaveCont)(char *filename);
379
381
CSTR_FUNC(Bool32) CSTR_SaveCont(char *filename);
380
 
// 64   CSTR_RESTORECONT        ������������ ��������� � �����
381
 
typedef Bool32 (*FNCSTR_RestoreCont)( char *filename);
 
382
// 64   CSTR_RESTORECONT        воостановить контейнер с диска
 
383
typedef Bool32 (*FNCSTR_RestoreCont)(char *filename);
382
384
CSTR_FUNC(Bool32) CSTR_RestoreCont(char *filename);
383
 
// 65   CSTR_INSERTRASTERDOWN   �������� ������ ����
384
 
typedef Bool32  (*FNCSTR_InsertRasterDown) (CSTR_rast   start_raster, CSTR_rast stop_raster);
385
 
CSTR_FUNC(CSTR_rast)            CSTR_InsertRasterDown (CSTR_rast        start_raster, CSTR_rast stop_raster);
386
 
// 66   CSTR_COPYRASTER                 ����������� ���������� ������
387
 
typedef Bool32  (*FNCSTR_CopyRaster)(CSTR_rast  trg,CSTR_rast   src);
388
 
CSTR_FUNC(Bool32)       CSTR_CopyRaster(CSTR_rast       trg,CSTR_rast   src);
389
 
// 67   CSTR_DELETELOOPS                ������� �������� ����
390
 
typedef Bool32              (*FNCSTR_DeleteLoops) (CSTR_line    lin);
391
 
CSTR_FUNC(Bool32)                   CSTR_DeleteLoops (CSTR_line lin);
392
 
// 68   CSTR_GETNEXTDOWN                ������ �� ����� �����
393
 
typedef CSTR_rast    (*FNCSTR_GetNextDown)(CSTR_rast rst);
394
 
CSTR_FUNC(CSTR_rast)    CSTR_GetNextDown(CSTR_rast rst);
395
 
// 69   CSTR_GETPREVDOWN                ������ �� ����� �����
396
 
typedef CSTR_rast    (*FNCSTR_GetPrevDown)(CSTR_rast rst);
397
 
CSTR_FUNC(CSTR_rast)    CSTR_GetPrevDown(CSTR_rast rst);
398
 
// 70   CSTR_GETNEXTUP                  ������ �� ����� �����
399
 
typedef CSTR_rast    (*FNCSTR_GetNextUp)(CSTR_rast rst);
400
 
CSTR_FUNC(CSTR_rast)    CSTR_GetNextUp(CSTR_rast rst);
401
 
// 71   CSTR_GETPREVUP                  ������ �� ����� �����
402
 
typedef CSTR_rast    (*FNCSTR_GetPrevUp)(CSTR_rast rst);
403
 
CSTR_FUNC(CSTR_rast)    CSTR_GetPrevUp(CSTR_rast rst);
404
 
// 72   CSTR_GETLENGTH                  ����� ������� ���������� ������
405
 
typedef Int32        (*FNCSTR_GetLength) (CSTR_line   lin);
406
 
CSTR_FUNC(Int32)        CSTR_GetLength (CSTR_line   lin);
407
 
// 73   CSTR_FNTOTXT_COORD              �������� ��������� ����� ������ � ������������
408
 
typedef Bool32       (*FNCSTR_LineToTxt_Coord)(CSTR_line lin, char *txt, Int32 len);
409
 
CSTR_FUNC(Bool32)       CSTR_LineToTxt_Coord (CSTR_line     lin, char *txt, Int32 len);
410
 
 
411
 
 
412
 
   #ifdef __cplusplus
413
 
            }
414
 
   #endif
 
385
// 65   CSTR_INSERTRASTERDOWN   вставить ссылку вниз
 
386
typedef Bool32 (*FNCSTR_InsertRasterDown)(CSTR_rast start_raster,
 
387
                CSTR_rast stop_raster);
 
388
CSTR_FUNC(CSTR_rast) CSTR_InsertRasterDown (CSTR_rast start_raster, CSTR_rast stop_raster);
 
389
// 66   CSTR_COPYRASTER                 скопировать содержимое растра
 
390
typedef Bool32 (*FNCSTR_CopyRaster)(CSTR_rast trg, CSTR_rast src);
 
391
CSTR_FUNC(Bool32) CSTR_CopyRaster(CSTR_rast trg,CSTR_rast src);
 
392
// 67   CSTR_DELETELOOPS                удалить обходные пути
 
393
typedef Bool32 (*FNCSTR_DeleteLoops)(CSTR_line lin);
 
394
CSTR_FUNC(Bool32) CSTR_DeleteLoops (CSTR_line lin);
 
395
// 68   CSTR_GETNEXTDOWN                ссылка на петлю вперёд
 
396
typedef CSTR_rast (*FNCSTR_GetNextDown)(CSTR_rast rst);
 
397
CSTR_FUNC(CSTR_rast) CSTR_GetNextDown(CSTR_rast rst);
 
398
// 69   CSTR_GETPREVDOWN                ссылка на петлю назад
 
399
typedef CSTR_rast (*FNCSTR_GetPrevDown)(CSTR_rast rst);
 
400
CSTR_FUNC(CSTR_rast) CSTR_GetPrevDown(CSTR_rast rst);
 
401
// 70   CSTR_GETNEXTUP                  ссылка из петли вперёд
 
402
typedef CSTR_rast (*FNCSTR_GetNextUp)(CSTR_rast rst);
 
403
CSTR_FUNC(CSTR_rast) CSTR_GetNextUp(CSTR_rast rst);
 
404
// 71   CSTR_GETPREVUP                  ссылка из петли назад
 
405
typedef CSTR_rast (*FNCSTR_GetPrevUp)(CSTR_rast rst);
 
406
CSTR_FUNC(CSTR_rast) CSTR_GetPrevUp(CSTR_rast rst);
 
407
// 72   CSTR_GETLENGTH                  длина нужного текстового буфера
 
408
typedef int32_t (*FNCSTR_GetLength)(CSTR_line lin);
 
409
CSTR_FUNC(int32_t) CSTR_GetLength (CSTR_line lin);
 
410
// 73   CSTR_FNTOTXT_COORD              получить текстовый обрах строки с координатами
 
411
typedef Bool32 (*FNCSTR_LineToTxt_Coord)(CSTR_line lin, char *txt, int32_t len);
 
412
CSTR_FUNC(Bool32) CSTR_LineToTxt_Coord (CSTR_line lin, char *txt, int32_t len);
 
413
 
 
414
#ifdef __cplusplus
 
415
}
 
416
#endif
415
417
 
416
418
#endif