← Back to branch summary

~ubuntu-branches/ubuntu/trusty/cuneiform/trusty

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/rstr/src/snap.c

  • 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/rstr/src/snap.c
2
2
Copyright (c) 1993-2008, Cognitive Technologies
3
3
All rights reserved.
4
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
 
�������� ��� ������ ���� ���� �������� � ����������� ����� ������� � ������.
 
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
32
 
33
33
Redistribution and use in source and binary forms, with or without modification,
34
34
are permitted provided that the following conditions are met:
61
61
#include <stdio.h>
62
62
#include <stdlib.h>
63
63
#include <string.h>
64
 
#include "nt_types.h"
 
64
 
65
65
#include "func.h"
66
66
#include "struct.h"
67
67
#include "status.h"
77
77
#include "minmax.h"
78
78
 
79
79
static void snap_sticks(cell *,char *);
 
80
/* Chops off 32 bits on 64 bit machines, but it is ok, since
 
81
 * the result is only used informally.
 
82
 */
 
83
#define pointer_to_num(x) ((unsigned int)((unsigned long)(x)))
80
84
 
81
85
 
82
86
// from module PASSE
83
 
BOOL _spell(PCHAR s,BYTE lang);
84
 
BOOL _spell_agressive(PCHAR s,BYTE lang);
85
 
BOOL short_spell(BYTE *wrd,BYTE language );
86
 
BOOL short_spell_re(BYTE *wrd,BYTE language );
 
87
Bool _spell(pchar s,uchar lang);
 
88
Bool _spell_agressive(pchar s,uchar lang);
 
89
Bool short_spell(uchar *wrd,uchar language );
 
90
Bool short_spell_re(uchar *wrd,uchar language );
87
91
 
88
 
BYTE mwInput[80];
89
 
extern INT      line_number;
90
 
extern INT      show_cut_points;
91
 
extern BYTE     db_pass      ;
92
 
extern BYTE     db_trace_flag, language;
 
92
uchar mwInput[80];
 
93
extern int16_t      line_number;
 
94
extern int16_t      show_cut_points;
 
95
extern uchar     db_pass      ;
 
96
extern uchar     db_trace_flag, language;
93
97
extern  struct  cut_elm *my_cut_points;
94
 
extern  INT             show_cut_points;
95
 
extern  INT             flag_cut_point;
96
 
extern  INT     flag_ShiftF9;
 
98
extern  int16_t             show_cut_points;
 
99
extern  int16_t             flag_cut_point;
 
100
extern  int16_t     flag_ShiftF9;
97
101
extern  void    Cells2CSTR(CSTR_line lin,CSTR_line lino,cell *cur,Bool32 enable_scaled);
98
102
extern  void    CopyAttr2CSTR(CSTR_rast_attr *attr, cell *c);
99
103
extern  int     cell2UniVers(UniVersions *ver, cell *c);
100
104
// from EVN32.DLL
101
 
extern LONG EVNGetRepresent( RecRaster   *rRaster,
102
 
    Word8 *evn, Word8 *evn_rot, Int32 font);
103
 
extern LONG  EVNRecogCharPRN(   RecRaster  * rRaster,
 
105
extern int32_t EVNGetRepresent( RecRaster   *rRaster,
 
106
    uchar *evn, uchar *evn_rot, int32_t font);
 
107
extern int32_t  EVNRecogCharPRN(   RecRaster  * rRaster,
104
108
      RecVersions* EVNres       );
105
109
// from RCM.C
106
110
extern  void    ErrorExit(int Code);
107
 
extern  BYTE    decode_ASCII_to_[256][4];
108
 
extern  CHAR    StopPoint;
109
 
extern  BYTE    CodePages[];
110
 
//extern  INT     gbCol1,gbCol2;
 
111
extern  uchar    decode_ASCII_to_[256][4];
 
112
extern  char    StopPoint;
 
113
extern  uchar    CodePages[];
 
114
//extern  int16_t     gbCol1,gbCol2;
111
115
 
112
 
static  BOOL    exit_enable         = FALSE;
113
 
static  BOOL    cut_enable          = FALSE;
114
 
static  BOOL    snap_disable        = FALSE;
115
 
static  BOOL    snap_continue       = FALSE;
116
 
BOOL    snap_page_disable   = FALSE;
117
 
static  BYTE    db_skip_client;
 
116
static  Bool    exit_enable         = FALSE;
 
117
static  Bool    cut_enable          = FALSE;
 
118
static  Bool    snap_disable        = FALSE;
 
119
static  Bool    snap_continue       = FALSE;
 
120
Bool    snap_page_disable   = FALSE;
 
121
static  uchar    db_skip_client;
118
122
static  CSTR_line   snap_line;
119
123
static  cell        currcell;//,*db_stopcell;
120
124
static  Point32 cutpoints_show[128];
121
 
static  Word32  numpoints_show;
 
125
static  uint32_t  numpoints_show;
122
126
static  cell *  cutpoints_cell=NULL;
123
 
static  Int32   select_line=0, num_select_lines=0;
 
127
static  int32_t   select_line=0, num_select_lines=0;
124
128
cell   *stopcell=NULL;
125
129
static  int stop_number=0, curr_pass=-1;
126
130
 
127
 
static  BYTE *snap_pass[]={
 
131
static  uchar *snap_pass[]={
128
132
"Cut","Glue","Context","Line","Punct","Space","Lineout","(TM)(R)","Italic","Bold","Serif","Solid","Pass2","Digital","BLCut","\0"
129
133
// a   b      c         d      e       f       g          h        i        j      k       l       m       n         o
130
134
};
131
 
static  BYTE *snap_fict[]={
 
135
static  uchar *snap_fict[]={
132
136
"Fict0","Fict1","Fict2","Fict3","Fict4","Fict5","Fict6","Fict7","Fict8","Fict9","Fict10","Fict11","Fict12","Fict13","Fict14","\0"
133
137
// a    b       c       d       e       f       g       h       i       j       k        l        m         n        o
134
138
};
135
139
static char *snap_pass_help[]={
136
 
/* a */"���������� (� ���������� ��� ��������)",
137
 
/* b */"���������� ( ��� ����������)",
138
 
/* c */"�������� (+�����������)",
139
 
/* d */"����������� ������� ����� � �����",
140
 
/* e */"����������",
141
 
/* f */"�������",
142
 
/* g */"����� ��������� ������",
143
 
/* h */"������������� ��",
144
 
/* i */"������������� �����������",
145
 
/* j */"������������� ��������",
146
 
/* k */"������������� ����������",
147
 
/* l */"��������� ���������",
148
 
/* m */"������ ������",
149
 
/* n */"�������� ������",
150
 
/* o */"��������� ��������� ����� �� ��",
 
140
/* a */"разрезание (и склеивание для русского)",
 
141
/* b */"склеивание ( для нерусского)",
 
142
/* c */"контекст (+выпрямление)",
 
143
/* d */"определение базовых линий и диффы",
 
144
/* e */"пунктуация",
 
145
/* f */"пробелы",
 
146
/* g */"показ финальной строки",
 
147
/* h */"распознавание ®©",
 
148
/* i */"распознавание курсивности",
 
149
/* j */"распознавание жирности",
 
150
/* k */"распознавание серифности",
 
151
/* l */"словарная валидация",
 
152
/* m */"второй проход",
 
153
/* n */"цифровые строки",
 
154
/* o */"запретить обрезание грязи по БЛ",
151
155
""
152
156
};
153
157
static char *snap_fict_help[100]={0};
159
163
Handle hSnapLEO;
160
164
Handle hSnapSmartCut;
161
165
//IGOR
162
 
static  BYTE *snap_bl[]={
 
166
static  uchar *snap_bl[]={
163
167
"STAT Base Lines","PUMA & STAT Base Lines", "PUMA & STAT Base Lines & Differences","\0"
164
168
// a   b
165
169
};
166
170
static char *snap_bl_help[]={
167
 
/* a */"�������������� ����� ����������� ������� �����\x0D\x0A������� � ���������� ������� ����� �������������� � ������ ��������� �����",
168
 
/* b */"PUMA + c������������� �����.\x0D\x0A�������������� ����� �������� ��������.\x0D\x0A������� � ���������� ������� ����� �������������� � ������ ��������� �����",
169
 
/* c */"PUMA + c������������� �����.\x0D\x0A�������������� ����� �������� ��������.\x0D\x0A�������� �������� �� ���� ��������.",
 
171
/* a */"Статистический метод определения базовых линий\x0D\x0AОстанов и прорисовка базовых линий осуществляется в режиме установки точки",
 
172
/* b */"PUMA + cтатистический метод.\x0D\x0AСтатистический метод работает фиктивно.\x0D\x0AОстанов и прорисовка базовых линий осуществляется в режиме установки точки",
 
173
/* c */"PUMA + cтатистический метод.\x0D\x0AСтатистический метод работает фиктивно.\x0D\x0AПоказать различия на всей странице.",
170
174
""
171
175
};
172
176
Handle hSnapLineBL[sizeof(snap_bl)/sizeof(snap_bl[0])];
173
177
//IGOR
174
178
//Handle hUseCLine;
175
179
extern Handle hSnapBLcut;
176
 
static  BOOL    internal_skip[sizeof(snap_pass)/sizeof(snap_pass[0])];
 
180
static  Bool    internal_skip[sizeof(snap_pass)/sizeof(snap_pass[0])];
177
181
 
178
182
void reset_snap(void)
179
183
{
182
186
        CodePages[3],   NULL);
183
187
return;
184
188
}
185
 
static int Lang_Console(char *text, Word8 lang)
 
189
static int Lang_Console(char *text, uchar lang)
186
190
{
187
191
char    buf[1024];
188
192
//LDPUMA_SetConsoleProperty(Bool32 bold,Bool32 italic,
189
 
//      Bool32 strikeout,Bool32 underline,Int32 height, Int32 offset,   Word32 textcolor,
 
193
//      Bool32 strikeout,Bool32 underline,int32_t height, int32_t offset,   uint32_t textcolor,
190
194
//      int charset,    char * name )
191
195
LDPUMA_SetConsoleProperty(0,0,
192
196
        0,0,0,  0,      0,
206
210
return Lang_Console(text,3);
207
211
}
208
212
 
209
 
// �������������
210
 
static BOOL ASCII2ANSI(char *ascii,char *ansi)
 
213
// перекодировка
 
214
static Bool ASCII2ANSI(char *ascii,char *ansi)
211
215
{
212
216
*ansi='\0';
213
217
for(;*ascii ;ascii++)
214
218
    {
215
 
    strcat(ansi, decode_ASCII_to_[(BYTE)*ascii] );
 
219
    strcat(ansi, decode_ASCII_to_[(uchar)*ascii] );
216
220
    }
217
221
return TRUE;
218
222
}
219
223
 
220
 
// �� ���������� � cell
 
224
// из контейнера в cell
221
225
static  cell * snap_CSTR2cell(CSTR_rast rst)
222
226
{
223
227
cell *c;
240
244
return NULL;
241
245
}
242
246
 
243
 
// �� cell-a � ���������
 
247
// из cell-a в контейнер
244
248
static   CSTR_rast snap_cell2CSTR(cell *c)
245
249
{
246
250
CSTR_rast       rst=CSTR_GetFirstRaster(snap_line);
263
267
return (CSTR_rast)NULL;
264
268
}
265
269
 
266
 
// ������� cell-a
267
 
static Word32 snap_cell2pos(cell *cl)
 
270
// позиция cell-a
 
271
static uint32_t snap_cell2pos(cell *cl)
268
272
{
269
 
Word32 pos;
 
273
uint32_t pos;
270
274
cell    *c,*e;
271
275
for(pos=0,c=cell_f()->next,e=cell_l();c!=e;c=c->next,pos++)
272
276
    {
277
281
return pos;
278
282
}
279
283
 
280
 
// ����� ������������
281
 
BOOL snap_init(void)
 
284
// общая инициализаци
 
285
Bool snap_init(void)
282
286
{
283
287
int i;
284
288
static  init=FALSE;
286
290
    return TRUE;
287
291
init=TRUE;
288
292
LDPUMA_Init(0,NULL);
289
 
//LDPUMA_Registry (&hUseCLine,"������ � ����������� �����", NULL);
 
293
//LDPUMA_Registry (&hUseCLine,"Работа с контейнером линий", NULL);
290
294
 
291
 
LDPUMA_Registry(&hSnapMain,"������������� �����...",NULL);
 
295
LDPUMA_Registry(&hSnapMain,"Распознавание строк...",NULL);
292
296
for(i=0;snap_pass[i][0];i++)
293
297
    {
294
298
    LDPUMA_Registry(&hSnapPass[i],snap_pass[i],hSnapMain);
300
304
    LDPUMA_Registry(&hSnapFict[i],snap_fict[i],hSnapMainFict);
301
305
        LDPUMA_RegistryHelp(hSnapFict[i],snap_fict_help[i],FALSE);
302
306
    }
303
 
LDPUMA_Registry(&hSnapBLcut,"��������� ���������� �� �����",hSnapMain);
304
 
LDPUMA_Registry(&hSnapLEO,"��������� ���",hSnapMain);
 
307
LDPUMA_Registry(&hSnapBLcut,"Запретить разрезание по базам",hSnapMain);
 
308
LDPUMA_Registry(&hSnapLEO,"Запретить ЛЕО",hSnapMain);
305
309
LDPUMA_Registry(&hSnapSerifTrace,"Serif Dispaly",hSnapPass['k'-'a']);
306
310
LDPUMA_RegistryHelp(hSnapSerifTrace,"Draw rectangles",FALSE);
307
311
//IGOR
311
315
        LDPUMA_RegistryHelp(hSnapLineBL[i],snap_bl_help[i],FALSE);
312
316
    }
313
317
//IGOR
314
 
LDPUMA_RegVariable(hSnapMain,"�����������",&db_trace_flag,"char");
 
318
LDPUMA_RegVariable(hSnapMain,"Трассировка",&db_trace_flag,"char");
315
319
#ifdef MATCH_WORD
316
 
LDPUMA_RegVariable(hSnapMain,"��������� �����",mwInput,"char *");
 
320
LDPUMA_RegVariable(hSnapMain,"Наложение слова",mwInput,"char *");
317
321
#endif
318
 
LDPUMA_Registry(&hSnapSmartCut,"��������� ���������� ����������/���������� �� 2-�� �������",hSnapMain);
319
 
LDPUMA_RegistryHelp(hSnapSmartCut,"��������� ���������� ����������/���������� �� 2-�� �������",FALSE);
320
 
snap_page_disable = snap_disable = db_skip_client = FALSE;
321
 
memset(internal_skip,TRUE,snap_clients*sizeof(BOOL));
322
 
exit_enable=FALSE;
323
 
db_trace_flag=0;
324
 
db_skip_client=0;
325
 
cutpoints_cell=NULL;
326
 
return TRUE;
327
 
}
328
 
 
329
 
BOOL snap_init_variables(void)
330
 
{
331
 
snap_page_disable = snap_disable = db_skip_client = FALSE;
332
 
exit_enable=FALSE;
333
 
db_trace_flag=0;
334
 
db_skip_client=0;
335
 
cutpoints_cell=NULL;
336
 
return TRUE;
337
 
}
338
 
 
339
 
BOOL snap_fictive_skip(INT i)
340
 
{
341
 
return (BOOL)LDPUMA_SkipEx(hSnapFict[i],FALSE,TRUE,1);
342
 
}
343
 
 
344
 
// ����� ������������� �����
 
322
LDPUMA_Registry(&hSnapSmartCut,"Запретить кластерное разрезание/склеивание на 2-ом проходе",hSnapMain);
 
323
LDPUMA_RegistryHelp(hSnapSmartCut,"Запретить кластерное разрезание/склеивание на 2-ом проходе",FALSE);
 
324
snap_page_disable = snap_disable = db_skip_client = FALSE;
 
325
memset(internal_skip,TRUE,snap_clients*sizeof(Bool));
 
326
exit_enable=FALSE;
 
327
db_trace_flag=0;
 
328
db_skip_client=0;
 
329
cutpoints_cell=NULL;
 
330
return TRUE;
 
331
}
 
332
 
 
333
Bool snap_init_variables(void)
 
334
{
 
335
snap_page_disable = snap_disable = db_skip_client = FALSE;
 
336
exit_enable=FALSE;
 
337
db_trace_flag=0;
 
338
db_skip_client=0;
 
339
cutpoints_cell=NULL;
 
340
return TRUE;
 
341
}
 
342
 
 
343
Bool snap_fictive_skip(int16_t i)
 
344
{
 
345
return (Bool)LDPUMA_SkipEx(hSnapFict[i],FALSE,TRUE,1);
 
346
}
 
347
 
 
348
// показ распознавания эвент
345
349
static void snap_recogEVN(CSTR_rast r,cell * cl)
346
350
 {
347
 
 INT    i;
 
351
 int16_t    i;
348
352
 RecRaster  rRaster;
349
353
 char       evn[256], evnr[256],evnw[256], evnrw[256], buf[256];
350
354
 
353
357
  return;
354
358
 if (tenv(cl))
355
359
  {
356
 
  CSTR_GetImage(r,(Word8*)(&rRaster),CSTR_TYPE_IMAGE_RS);
 
360
  CSTR_GetImage(r,(uchar*)(&rRaster),CSTR_TYPE_IMAGE_RS);
357
361
 
358
362
  if( EVNGetRepresent( &rRaster, evn, evnr, 1)==-1  )
359
 
    RUS_Console("�� ���� �������� ��");
 
363
    RUS_Console("Не могу получить ЛП");
360
364
  else
361
365
    {
362
366
    ASCII2ANSI(evn,evnw);
372
376
    if( !pidx_skip(cl->h, cl->w,rv.Alt[i].Code) )
373
377
        {
374
378
        sprintf(buf,"PROP KILL : %s,pidx=%d",
375
 
            decode_ASCII_to_[(BYTE)rv.Alt[i].Code],
 
379
            decode_ASCII_to_[(uchar)rv.Alt[i].Code],
376
380
            prop_index(cl->h,cl->w));
377
381
        RUS_Console(buf);
378
382
        }
381
385
 return;
382
386
 }
383
387
 
384
 
// ����� �������������� ���������
 
388
// показ дискриминатора пропорций
385
389
static void show_prop(cell *c)
386
390
{
387
391
int i;
390
394
    {
391
395
    if( !pidx_skip(c->h, c->w,c->vers[i].let) )
392
396
        {
393
 
        sprintf(buf,"PROP KILL : %s",decode_ASCII_to_[(BYTE)c->vers[i].let]);
 
397
        sprintf(buf,"PROP KILL : %s",decode_ASCII_to_[(uchar)c->vers[i].let]);
394
398
        RUS_Console(buf);
395
399
        }
396
400
    }
398
402
}
399
403
 
400
404
 
401
 
// ����� ������ ��������� 3�5
 
405
// показ разных кластеров 3х5
402
406
static void snap_recog3X5(cell *b)
403
407
 {
404
408
 s_glue GL={0};
405
409
 cell   sb=*b;
406
 
 BYTE save_db_pass=db_pass;
 
410
 uchar save_db_pass=db_pass;
407
411
 
408
412
 db_pass='a';
409
413
 internal_skip[0]=FALSE;
431
435
return;
432
436
}
433
437
 
434
 
// ����� ������� ���������
 
438
// показ батонов Фараджева
435
439
static void snap_sticks(cell *c, char *str)
436
440
 {
437
 
 INT i,n;
 
441
 int16_t i,n;
438
442
 STICK *res,*r;
439
443
 
440
444
 n=sticks_in_letter(c,0,&res);
459
463
 
460
464
static void store_spell(cell *c)
461
465
{
462
 
Word8       wrd[80],buf[160],*w=wrd;
 
466
uchar       wrd[80],buf[160],*w=wrd;
463
467
FILE       *fp=fopen("frh.txt","at");
464
468
int         num_ln=0;
465
469
cell       *b, *e;
476
480
 
477
481
if( fp )
478
482
    {
479
 
    Int32       i;
 
483
    int32_t       i;
480
484
    //if( num_ln<2 && num_ln!=-1)
481
485
    //    fprintf(fp,"New Line\n");
482
486
    fprintf(fp,"-- line %d \n", num_ln);
505
509
 
506
510
static void show_spell(cell *c)
507
511
{
508
 
Word8   wrd[80],buf[160],*w=wrd, lang;
 
512
uchar   wrd[80],buf[160],*w=wrd, lang;
509
513
Bool32  nonrec=FALSE;
510
514
 
511
515
 
547
551
return;
548
552
}
549
553
 
550
 
Int32 snap_AddRecRaster(char *fname, RecRaster *r,Word8 let, Word8 font)
 
554
int32_t snap_AddRecRaster(char *fname, RecRaster *r,uchar let, uchar font)
551
555
{
552
556
#ifdef _USE_CTB_
553
557
CTB_handle  hnd;
554
 
Int32       num;
555
 
Word8       raster[4096],data[CTB_DATA_SIZE]={0};
556
 
Int32       wb;
 
558
int32_t       num;
 
559
uchar       raster[4096],data[CTB_DATA_SIZE]={0};
 
560
int32_t       wb;
557
561
Bool32      ret;
558
562
B_LINES     my_bases;
559
563
 
569
573
        return FALSE;
570
574
        }
571
575
    }
572
 
data[1] = (Word8)r->lnPixWidth;
573
 
data[2] = (Word8)r->lnPixHeight;
 
576
data[1] = (uchar)r->lnPixWidth;
 
577
data[2] = (uchar)r->lnPixHeight;
574
578
data[3] = let;
575
579
data[4] = 0; // typeface
576
580
if( font & CSTR_fp_it )
600
604
#endif
601
605
}
602
606
 
603
 
// �������� �� ��������� ������
 
607
// действия по изменению растра
604
608
#define END_RUN_CELL(s)                                     \
605
609
    {                                                       \
606
610
    CSTR_DelRaster(r);                                      \
612
616
        cell2UniVers(&uvs, c);                              \
613
617
        CSTR_StoreCollectionUni (r, &uvs);                  \
614
618
        if( c->env )                                        \
615
 
          CSTR_StoreComp (r, (Word8*)((Word8*)c->env+c->env->lines),1,c->env->scale); \
 
619
          CSTR_StoreComp (r, (uchar*)((uchar*)c->env+c->env->lines),1,c->env->scale); \
616
620
        RUS_Console(s);                                    \
617
621
        }                                                   \
618
622
    LDPUMA_CSTR_Update();                                   \
619
623
    }
620
624
 
621
625
#ifdef _USE_DFON_
622
 
  int (*DFon_SendRaster)(RecRaster* rr, Handle pPaintWnd, Word8 let);
623
 
  void (*DFon_Terminated)(Word32 wParam);
 
626
  int (*DFon_SendRaster)(RecRaster* rr, Handle pPaintWnd, uchar let);
 
627
  void (*DFon_Terminated)(uint32_t wParam);
624
628
#endif
625
629
 
626
 
// ����������  ���������
627
 
Word32 myMonitorProc(Handle wnd,Handle hwnd,Word32 message,Word32 wParam,Word32 lParam)
 
630
// обработчик  сообщений
 
631
uint32_t myMonitorProc(Handle wnd,Handle hwnd,uint32_t message,uint32_t wParam,uint32_t lParam)
628
632
{
629
633
int             ret=0;
630
634
CSTR_rast       r=(CSTR_rast)0;
633
637
RecRaster       rRaster;
634
638
CSTR_rast_attr  attr;
635
639
static Bool32   shift=0;
636
 
BYTE            str[1200];
 
640
uchar            str[1200];
637
641
static CSTR_rast s_r = (CSTR_rast)0;
638
642
unsigned int    i,ii;
639
 
static BOOL     no_process=TRUE;
640
 
Word32          pos;
 
643
static Bool     no_process=TRUE;
 
644
uint32_t          pos;
641
645
char            buf[256];
642
646
 
643
647
pos=LDPUMA_CSTR_GetPosition((int *)&r);
672
676
    // MOUSE CLICKS
673
677
    case WM_LBUTTONDBLCLK:
674
678
                { // select start cut point
675
 
                        Point32 p = { (Word16)(lParam), (Word16)(lParam>>16)};  // vertical position of cursor  }
 
679
                        Point32 p = { (uint16_t)(lParam), (uint16_t)(lParam>>16)};  // vertical position of cursor  }
676
680
                        p = LDPUMA_GetRasterPixel(wnd,p);
677
681
            for(ii=1,i=0;i<numpoints_show;i+=2,ii++)
678
682
                {
683
687
                { // setup start cut point
684
688
                            flag_cut_point = 1;
685
689
                StopPoint = my_cut_points[ii].x;
686
 
                sprintf(buf,"����� ���������� (%d)",ii-1);
 
690
                sprintf(buf,"Точка разрезания (%d)",ii-1);
687
691
                RUS_Console(buf);
688
692
                db_status=0;
689
693
                ret=-1;
693
697
 
694
698
    case WM_RBUTTONDBLCLK:
695
699
                { // show one cut point
696
 
                Point32 p = { (Word16)(lParam), (Word16)(lParam>>16)};  // vertical position of cursor  }
 
700
                Point32 p = { (uint16_t)(lParam), (uint16_t)(lParam>>16)};  // vertical position of cursor  }
697
701
                p = LDPUMA_GetRasterPixel(wnd,p);
698
702
                for(ii=1,i=0;i<numpoints_show;i+=2,ii++)
699
703
                    {
702
706
                    }
703
707
                if( i<numpoints_show )
704
708
                    {
705
 
                                sprintf(buf,"����� ���������� (%d) x=%i,dh=%i,h=%i,var=%i",ii-1,
 
709
                                sprintf(buf,"Точка разрезания (%d) x=%i,dh=%i,h=%i,var=%i",ii-1,
706
710
                        my_cut_points[ii].x,my_cut_points[ii].dh,
707
711
                        my_cut_points[ii].h,my_cut_points[ii].var);
708
712
                    RUS_Console(buf);
725
729
            if( c&&c->flg&(c_f_bad|c_f_let) )
726
730
                store_spell(c);
727
731
            else
728
 
                RUS_Console("�� �����");
 
732
                RUS_Console("Не буква");
729
733
            ret=1;
730
734
            break;
731
735
        case    'S':
732
736
            if( c&&c->flg&(c_f_bad|c_f_let) )
733
737
                show_spell(c);
734
738
            else
735
 
                RUS_Console("�� �����");
 
739
                RUS_Console("Не буква");
736
740
            ret=1;
737
741
            break;
738
742
        case    'X':    // ALT + X
747
751
                ret=0;
748
752
                }
749
753
            else
750
 
                RUS_Console("��� ����������");
 
754
                RUS_Console("Нет следующего");
751
755
            break;
752
756
        case    'P':    // ALT + P
753
757
            if( c->prevl && !(c->prevl->flg&c_f_fict))
757
761
                ret=0;
758
762
                }
759
763
            else
760
 
                RUS_Console("��� �����������");
 
764
                RUS_Console("Нет предыдущего");
761
765
            break;
762
766
        case    VK_F2:  // ALT + F2
763
767
            db_skip_client=1;
766
770
        case    VK_F8:  // ALT + F8
767
771
            if( r )
768
772
                {
769
 
                Word8 let;
770
 
                CSTR_GetImage(r,(Word8*)(&rRaster),CSTR_TYPE_IMAGE_RS);
771
 
                let = (Word8)(c->nvers? c->vers[0].let:'~');
 
773
                uchar let;
 
774
                CSTR_GetImage(r,(uchar*)(&rRaster),CSTR_TYPE_IMAGE_RS);
 
775
                let = (uchar)(c->nvers? c->vers[0].let:'~');
772
776
                if( decode_ASCII_to_[let][1]==0 )
773
777
                    let = decode_ASCII_to_[let][0];
774
778
                CSTR_GetAttr(r,&attr);
775
779
                snap_AddRecRaster("SQPROT", &rRaster,let,attr.font);
776
 
                RUS_Console("�������� � SQPROT.CTB");
 
780
                RUS_Console("Отписано в SQPROT.CTB");
777
781
                }
778
782
            break;
779
783
        default:
789
793
                {
790
794
        case    VK_ESCAPE:
791
795
            snap_page_disable = TRUE;
792
 
            RUS_Console("��������� �� �����");
 
796
            RUS_Console("распознай до конца");
793
797
            ret=-1;
794
798
            break;
795
799
        case    VK_DELETE:
806
810
                shift=0;
807
811
                snap_sticks(c,str);
808
812
                Snap_Console(str);
809
 
                RUS_Console("������ �������");
 
813
                RUS_Console("анализ батонов");
810
814
                }
811
815
            else
812
816
                {   // F1 : help
813
 
                RUS_Console("ESC - �� ����� ��� �����");
814
 
 
815
 
                RUS_Console("F1  - �������");
816
 
                RUS_Console("F2  - ����� ������");
817
 
                RUS_Console("F3  - ������ �����");
818
 
                RUS_Console("F4  - �������� ��������� �� 2-� �������");
819
 
                RUS_Console("F5  - �������� �������/���������� ���������� �� 2-� �������");
820
 
                RUS_Console("F7  - � ��������");
821
 
                RUS_Console("F9  - ���������� ������������� (� �.�. �� 2-� �������)");
822
 
                RUS_Console("F11 - ������ �����������");
823
 
                RUS_Console("F12 - ������� ������ ��������");
824
 
 
825
 
                RUS_Console("Shift+F1  - ������ �������");
826
 
                RUS_Console("Shift+F2  - ������ �����");
827
 
                RUS_Console("Shift+F3  - ������");
828
 
                RUS_Console("Shift+F4  - ������ ���� �� 2-� �������");
829
 
                RUS_Console("Shift+F5  - ��������� � ������");
830
 
                RUS_Console("Shift+F6  - ����� �����������");
831
 
                RUS_Console("Shift+F7  - ��������� �� ����");
832
 
                RUS_Console("Shift+F9  - �� c�������� �������");
833
 
                RUS_Console("Shift+F11 - ����� �����������");
834
 
 
835
 
                RUS_Console("Alt+F2 - ��������� ����");
836
 
                RUS_Console("Alt+F8 - ��������� ����� � CTBase");
837
 
                RUS_Console("Alt+F  - FRH ��� ������������");
838
 
                RUS_Console("Alt+N  - ��������� ������");
839
 
                RUS_Console("Alt+P  - ���������� ������");
840
 
                RUS_Console("Alt+S  - �������");
841
 
                RUS_Console("Alt+X  - ��������");
842
 
 
843
 
                RUS_Console("2(3,4...)- �������� 2-�(3,4...) ������");
844
 
                RUS_Console("Home/End - ������/����� ������");
845
 
                RUS_Console("+/- - ���������/��������� �����");
846
 
 
847
 
                            LDPUMA_RasterText("F1 - ���������. ��. �������.");
 
817
                RUS_Console("ESC - до конца без снэпа");
 
818
 
 
819
                RUS_Console("F1  - справка");
 
820
                RUS_Console("F2  - новая строка");
 
821
                RUS_Console("F3  - встать здесь");
 
822
                RUS_Console("F4  - просмотр кластеров на 2-м проходе");
 
823
                RUS_Console("F5  - просмотр склейки/разрезания кластерами на 2-м проходе");
 
824
                RUS_Console("F7  - в отладчик");
 
825
                RUS_Console("F9  - отладочное распознавание (в т.ч. на 2-м проходе)");
 
826
                RUS_Console("F11 - задать трассировку");
 
827
                RUS_Console("F12 - вывести адреса структур");
 
828
 
 
829
                RUS_Console("Shift+F1  - анализ батонов");
 
830
                RUS_Console("Shift+F2  - анализ стика");
 
831
                RUS_Console("Shift+F3  - обрить");
 
832
                RUS_Console("Shift+F4  - анализ слов на 2-м проходе");
 
833
                RUS_Console("Shift+F5  - выпрямить и обрить");
 
834
                RUS_Console("Shift+F6  - снять выпярмление");
 
835
                RUS_Console("Shift+F7  - выпрямить на брея");
 
836
                RUS_Console("Shift+F9  - на cледующую склейку");
 
837
                RUS_Console("Shift+F11 - снять трассировку");
 
838
 
 
839
                RUS_Console("Alt+F2 - следующий этап");
 
840
                RUS_Console("Alt+F8 - запомнить образ в CTBase");
 
841
                RUS_Console("Alt+F  - FRH для агрессивного");
 
842
                RUS_Console("Alt+N  - следующий символ");
 
843
                RUS_Console("Alt+P  - предыдущий символ");
 
844
                RUS_Console("Alt+S  - словари");
 
845
                RUS_Console("Alt+X  - прервать");
 
846
 
 
847
                RUS_Console("2(3,4...)- показать 2-ю(3,4...) строку");
 
848
                RUS_Console("Home/End - начало/конец строки");
 
849
                RUS_Console("+/- - увеличить/уменьшить шрифт");
 
850
 
 
851
                            LDPUMA_RasterText("F1 - подсказка. см. консоль.");
848
852
                }
849
853
                        break;
850
854
        case VK_F2:
853
857
                shift=0;
854
858
                if( !stick_center_study(c,NULL,0) )
855
859
                    {
856
 
                    END_RUN_CELL("������ �����");
 
860
                    END_RUN_CELL("анализ стика");
857
861
                    }
858
862
                }
859
863
            else
867
871
                {   // SHIFT + F3 : shaving
868
872
                shift=0;
869
873
                pimpleshave(c, 1, 1);
870
 
                END_RUN_CELL("�������� ������");
 
874
                END_RUN_CELL("удаление прыщей");
871
875
                }
872
876
            else
873
877
                {   // F3 : stop here
888
892
#endif
889
893
                    stopcell = c;
890
894
                ret=-1;
891
 
                RUS_Console("����� ���������");
 
895
                RUS_Console("точка остановки");
892
896
                }
893
897
            break;
894
898
        case VK_F4:
906
910
                    break;
907
911
                    }
908
912
 
909
 
                CSTR_GetImage(r,(Word8*)(&rRaster),CSTR_TYPE_IMAGE_RS);
910
 
                // ���� ��������� ?
 
913
                CSTR_GetImage(r,(uchar*)(&rRaster),CSTR_TYPE_IMAGE_RS);
 
914
                // надо повернуть ?
911
915
                p2_rotate(&rRaster);
912
 
                DFon_SendRaster( &rRaster, hwnd, (Word8)(c&&c->nvers?c->vers[0].let:'~'));
 
916
                DFon_SendRaster( &rRaster, hwnd, (uchar)(c&&c->nvers?c->vers[0].let:'~'));
913
917
#else
914
918
                RUS_Console("verrions without DFON.DLL");
915
919
#endif
916
920
                }
917
921
            else
918
 
                RUS_Console("��������� 2-�� �������");
 
922
                RUS_Console("дождитесь 2-го прохода");
919
923
            }
920
924
            break;
921
925
        case VK_F5:
925
929
                if( !(c->pos_inc&erect_rot) )
926
930
                    {
927
931
                    erector(c, 0, 1, 0,1);
928
 
                    END_RUN_CELL("����������� � �������");
 
932
                    END_RUN_CELL("выпрямление с бритьём");
929
933
                    }
930
934
                else
931
 
                    RUS_Console("��� ����������");
 
935
                    RUS_Console("уже выпрямлено");
932
936
                }
933
937
            else
934
938
                {   // F5
943
947
                shift=0;
944
948
                if( (c->pos_inc&erect_rot) )
945
949
                    {
946
 
                    erect_cell_value(c, (INT)(-c->stick_inc), 0, FALSE);
 
950
                    erect_cell_value(c, (int16_t)(-c->stick_inc), 0, FALSE);
947
951
                    c->stick_inc=NO_INCLINE;
948
952
                    c->pos_inc=erect_no;
949
 
                    END_RUN_CELL("����������� �����������");
 
953
                    END_RUN_CELL("уничтожение выпрямления");
950
954
                    }
951
955
                else
952
 
                    RUS_Console("��� �� ����������");
 
956
                    RUS_Console("ещё не выпрямлено");
953
957
                }
954
958
            else
955
959
                {   // F6
962
966
                if( !(c->pos_inc&erect_rot) )
963
967
                    {
964
968
                    erector(c, 0, 0, 0,1);
965
 
                    END_RUN_CELL("����������� ��� ������");
 
969
                    END_RUN_CELL("выпрямление без бритья");
966
970
                    }
967
971
                else
968
 
                    RUS_Console("��� ����������");
 
972
                    RUS_Console("уже выпрямлено");
969
973
                }
970
974
            else
971
975
                {   // F7 : debug
982
986
                shift=0;
983
987
                db_status=0;
984
988
                flag_ShiftF9=1;
985
 
                RUS_Console("�� ��������� �������");
 
989
                RUS_Console("на следующую склейку");
986
990
                ret=-1;
987
991
                }
988
992
            else
993
997
                    RecVersions vers;                                                                                                                                   char rere[256],rerew[256];
994
998
                    int i;
995
999
 
996
 
                    CSTR_GetImage(r,(Word8*)(&rRaster),CSTR_TYPE_IMAGE_RS);
 
1000
                    CSTR_GetImage(r,(uchar*)(&rRaster),CSTR_TYPE_IMAGE_RS);
997
1001
                    p2_recog(&rRaster,&vers,NULL,FALSE);
998
1002
                    rere[0]=0;
999
1003
                    for(i=0;i<vers.lnAltCnt;i++)
1010
1014
                    //show_prop(c);
1011
1015
                    snap_recog3X5(c);
1012
1016
                    }
1013
 
                 RUS_Console("�������������");
 
1017
                 RUS_Console("распознавание");
1014
1018
                 }
1015
1019
            break;
1016
1020
        case    VK_F10:
1021
1025
            else
1022
1026
                {
1023
1027
                snap_page_disable = TRUE;
1024
 
                RUS_Console("��������� �� �����");
 
1028
                RUS_Console("распознай до конца");
1025
1029
                ret=-1;
1026
1030
                }
1027
1031
            break;
1030
1034
            if( !shift )
1031
1035
                {   // F11 : set tracing
1032
1036
                db_trace_flag=6;
1033
 
                RUS_Console("����������� �����������");
 
1037
                RUS_Console("установлена трассировка");
1034
1038
                }
1035
1039
            else
1036
1040
                {   // F11 : clear tracing
1037
1041
                db_trace_flag=0;
1038
 
                RUS_Console("����a ����������a");
 
1042
                RUS_Console("снятa трассировкa");
1039
1043
                }
1040
1044
            break;
1041
1045
        case VK_F12:    // F12 : show positions
1042
 
                        sprintf(buf,"������� %i �� %i",pos,LDPUMA_CSTR_GetLength());
1043
 
            RUS_Console(buf);
1044
 
            sprintf(buf,"����� CSTR=0x%x(cell=0x%x,env=0x%x,prevl=0x%x,nextl=0x%x,prev=0x%x,next=0x%x)",
1045
 
                r, c,c?c->env:0,c?c->prevl:0,c?c->nextl:0,c?c->prev:0,c?c->next:0);
1046
 
            RUS_Console(buf);
1047
 
                        LDPUMA_RasterText("F12 - �������. ��. �������.");
 
1046
                        sprintf(buf,"Позиция %i из %i",pos,LDPUMA_CSTR_GetLength());
 
1047
            RUS_Console(buf);
 
1048
            sprintf(buf,"растр CSTR=0x%x(cell=0x%x,env=0x%x,prevl=0x%x,nextl=0x%x,prev=0x%x,next=0x%x)",
 
1049
                pointer_to_num(r),
 
1050
                pointer_to_num(c),
 
1051
                c?pointer_to_num(c->env):0,
 
1052
                c?pointer_to_num(c->prevl):0,
 
1053
                c?pointer_to_num(c->nextl):0,
 
1054
                c?pointer_to_num(c->prev):0,
 
1055
                c?pointer_to_num(c->next):0);
 
1056
            RUS_Console(buf);
 
1057
                        LDPUMA_RasterText("F12 - позиция. см. консоль.");
1048
1058
                        break;
1049
1059
        case    '1':
1050
1060
            select_line=0;
1079
1089
                break;
1080
1090
        }
1081
1091
 
1082
 
return (Word32)(ret);
 
1092
return (uint32_t)(ret);
1083
1093
}
1084
1094
 
1085
 
// ����� ����������� ������ � �������� �������
1086
 
static Int32 snap_monitor_calls=0;
1087
 
BOOL snap_monitor(void)
 
1095
// режим мониторинга строки и ожидания клавиши
 
1096
static int32_t snap_monitor_calls=0;
 
1097
Bool snap_monitor(void)
1088
1098
{
1089
1099
Handle hnd;
1090
1100
        int i,scale;
1148
1158
return TRUE;
1149
1159
}
1150
1160
 
1151
 
BOOL snap_monitor_ori(CSTR_line *snap_line, Int32 num_lines)
 
1161
Bool snap_monitor_ori(CSTR_line *snap_line, int32_t num_lines)
1152
1162
{
1153
1163
Handle hnd;
1154
1164
        int i,scale;
1206
1216
}
1207
1217
 
1208
1218
 
1209
 
// ������� �����
1210
 
BOOL snap_show_text(BYTE *txt)
 
1219
// вывести текст
 
1220
Bool snap_show_text(uchar *txt)
1211
1221
{
1212
1222
char text[256],texto[80*40];
1213
1223
if( snap_disable
1231
1241
    }
1232
1242
sprintf(texto,"line %d,%s, pass %d, language %d, lines %d\n",
1233
1243
    line_number,
1234
 
    (curr_pass>=snap_clients||curr_pass<0)?"":snap_pass[curr_pass],
 
1244
    (curr_pass>=snap_clients||curr_pass<0)?"":(const char*)(snap_pass[curr_pass]),
1235
1245
    p2_active+1, language,
1236
1246
    num_select_lines?num_select_lines:1);
1237
1247
while(1)
1240
1250
text[0]='\0';
1241
1251
for(;*txt && *txt!='\n';txt++)
1242
1252
    {
1243
 
    if( strlen(text)+strlen(decode_ASCII_to_[(BYTE)*txt])>256 )
 
1253
    if( strlen(text)+strlen(decode_ASCII_to_[(uchar)*txt])>256 )
1244
1254
           break;
1245
 
    strcat(text, decode_ASCII_to_[(BYTE)*txt] );
1246
 
    strcat(texto, decode_ASCII_to_[(BYTE)*txt] );
 
1255
    strcat(text, decode_ASCII_to_[(uchar)*txt] );
 
1256
    strcat(texto, decode_ASCII_to_[(uchar)*txt] );
1247
1257
    }
1248
1258
if( !text[0] )
1249
1259
    break;
1258
1268
return TRUE;
1259
1269
}
1260
1270
 
1261
 
BOOL    snap_is_marked(CSTR_line ln)
 
1271
Bool    snap_is_marked(CSTR_line ln)
1262
1272
{
1263
1273
Point16     p;
1264
1274
CSTR_attr   r;
1274
1284
          );
1275
1285
}
1276
1286
 
1277
 
// ������� �� ������
1278
 
BOOL snap_activity(BYTE a)
 
1287
// активен ли клиент
 
1288
Bool snap_activity(uchar a)
1279
1289
{
1280
1290
Bool32 ret;
1281
1291
if( snap_disable || snap_page_disable || db_skip_client || (a-'a')>=snap_clients)
1290
1300
return(!ret);
1291
1301
}
1292
1302
 
1293
 
// ������� �� ���� �� ���� ������
1294
 
BOOL snap_is_active(void)
 
1303
// активен ли хотя бы один клиент
 
1304
Bool snap_is_active(void)
1295
1305
{
1296
1306
int i;
1297
1307
snap_disable = FALSE;
1308
1318
db_status=0;
1309
1319
return FALSE;
1310
1320
}
1311
 
// ������ �� ������
1312
 
BOOL snap_newcell (cell *c)
 
1321
// встать на клетке
 
1322
Bool snap_newcell (cell *c)
1313
1323
{
1314
1324
if( snap_disable || snap_page_disable || db_skip_client )
1315
1325
    return FALSE;
1318
1328
return TRUE;
1319
1329
}
1320
1330
 
1321
 
static void snap_align8_lines(Word8 *bin,Int32 w, Int32 h)
 
1331
static void snap_align8_lines(uchar *bin,int32_t w, int32_t h)
1322
1332
{
1323
1333
int i,ii,iii, wb=(w+7)/8, wb_new=((w+63)/64)*8;
1324
 
Word8   buf[256];
 
1334
uchar   buf[256];
1325
1335
 
1326
1336
memset(buf,0,wb_new);
1327
1337
for(iii=(h-1)*wb_new,ii=(h-1)*wb,i=0;i<h;i++,ii-=wb,iii-=wb_new)
1333
1343
return;
1334
1344
}
1335
1345
 
1336
 
// ������� �����
1337
 
BOOL snap_show_raster(PBYTE raster, INT height, INT width)
 
1346
// вывести растр
 
1347
Bool snap_show_raster(puchar raster, int16_t height, int16_t width)
1338
1348
{
1339
1349
DPUMA_RecRaster rs={0};
1340
1350
 
1359
1369
return TRUE;
1360
1370
}
1361
1371
 
1362
 
// + ������������, ���� ����� B,E
 
1372
// + остановиться, если между B,E
1363
1373
// can be call after setup stopcell (F3)
1364
 
BOOL snap_stopcell(cell *B,cell *E)
 
1374
Bool snap_stopcell(cell *B,cell *E)
1365
1375
{
1366
1376
if( snap_disable || snap_page_disable || db_skip_client || !stopcell)
1367
1377
    return FALSE;
1373
1383
return stopcell;
1374
1384
}
1375
1385
 
1376
 
// ���� �� ����������.
 
1386
// снэп из разрезания.
1377
1387
void snap_show_cuts(cell *C, struct cut_elm *cut_points)
1378
1388
{
1379
1389
struct cut_elm  *cpnt;
1419
1429
return ;
1420
1430
}
1421
1431
 
1422
 
// ������ ������ ����
1423
 
BOOL snap_newpass(BYTE pass)
 
1432
// начало нового шага
 
1433
Bool snap_newpass(uchar pass)
1424
1434
{
1425
1435
if( snap_disable || snap_page_disable  )
1426
1436
    return FALSE;
1433
1443
return TRUE;
1434
1444
}
1435
1445
 
1436
 
// ������� ��������� � ������ ���������
 
1446
// задание остановки в точках разрезани
1437
1447
void snap_stop_cuts(void)
1438
1448
{
1439
1449
if( snap_disable || snap_page_disable || db_skip_client )
1445
1455
return;
1446
1456
}
1447
1457
 
1448
 
// ������ ����� ��� �������� � ��������� �������
 
1458
// флагов снэпа для перехода к следующей склейке
1449
1459
void snap_newcut(void)
1450
1460
{
1451
1461
if( snap_disable || snap_page_disable || db_skip_client )
1455
1465
return;
1456
1466
}
1457
1467
 
1458
 
// ����� ��������� � ����������
1459
 
void snap_newpoint(INT i)
 
1468
// точка остановки в разрезании
 
1469
void snap_newpoint(int16_t i)
1460
1470
{
1461
1471
if( snap_disable || snap_page_disable || db_skip_client )
1462
1472
    return ;
1468
1478
 
1469
1479
 
1470
1480
// knot for Alik debug. Absent pass 'j'
1471
 
BOOL Alik_snap_show_raster(PBYTE raster,PBYTE raster1,PBYTE buf,INT height,
1472
 
                           INT width,PCHAR product,PCHAR product_two,
1473
 
                           PINT penalty)
 
1481
Bool Alik_snap_show_raster(puchar raster,puchar raster1,puchar buf,int16_t height,
 
1482
                           int16_t width,pchar product,pchar product_two,
 
1483
                           pint16_t penalty)
1474
1484
 
1475
1485
{
1476
1486
return FALSE;
1477
1487
}
1478
1488
 
1479
1489
// knot for EVENT snap
1480
 
void snap_keep(BYTE user, PBYTE addr, WORD lth)
 
1490
void snap_keep(uchar user, puchar addr, uint16_t lth)
1481
1491
{
1482
1492
if( snap_disable || snap_page_disable || db_skip_client)
1483
1493
    return ;
1485
1495
}
1486
1496
 
1487
1497
// knot for DOS-init
1488
 
BOOL snap_newline(void)
 
1498
Bool snap_newline(void)
1489
1499
{
1490
1500
if( snap_disable && db_skip_client )
1491
1501
    return FALSE;
1493
1503
}
1494
1504
 
1495
1505
//IGOR
1496
 
BOOL snap_baselines(BYTE a)
 
1506
Bool snap_baselines(uchar a)
1497
1507
{
1498
1508
        if(!hSnapLineBL[a - 'a'])
1499
1509
                return FALSE;
1501
1511
        return !LDPUMA_Skip(hSnapLineBL[a - 'a']);
1502
1512
}
1503
1513
 
1504
 
void snap_draw_line(Handle wnd, Point16 *start, Point16 *end, Int32 skew, Word32 rgb, Int16 pen, Word32 key)//IGOR
 
1514
void snap_draw_line(Handle wnd, Point16 *start, Point16 *end, int32_t skew, uint32_t rgb, int16_t pen, uint32_t key)//IGOR
1505
1515
{
1506
1516
        LDPUMA_DrawLine(wnd,start, end, skew, rgb, pen, key);
1507
1517
        return;
1508
1518
}
1509
1519
 
1510
 
void snap_del_line(Handle wnd, Word32 key)
 
1520
void snap_del_line(Handle wnd, uint32_t key)
1511
1521
{
1512
1522
        LDPUMA_DeleteLines(wnd, key);
1513
1523
        return;