← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Jakub Wilk
  • Date: 2010-09-14 15:53:54 UTC
  • mto: (5.1.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 6.
  • Revision ID: james.westby@ubuntu.com-20100914155354-i3uu2woc5aucphax
Tags: upstream-1.0.0+dfsg
Import upstream version 1.0.0+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
cuneiform_src/Kern/rstr/src/rstr_bl.c
59
59
#include <string.h>
60
60
#include <stdio.h>
61
61
 
62
 
#include "nt_types.h"
 
62
 
63
63
#include "struct.h"
64
64
#include "cstr.h"
65
65
#include "func.h"
70
70
 
71
71
#include "bal.h"
72
72
 
73
 
extern BYTE fax1x2;
74
 
extern Word8 language;
75
 
extern BYTE multy_language;
76
 
 
77
 
extern Word16 actual_resolution;
78
 
extern BOOL   line_BL;
79
 
extern Word8  spec_camera;
80
 
extern Word8  no_linpen;
81
 
extern Int16  prop_l_delta, prop_r_delta;
82
 
extern Word8  db_pass;
83
 
 
84
 
extern Word8 *letters_pidx_table;  // 512
85
 
extern Word8 decode_ASCII_to_[256][4];
86
 
 
87
 
 
88
 
INT     minrow,mincol, maxrow, maxcol;
89
 
INT     bs_got=0;     // in baton.c - LONG - error!?
90
 
 
91
 
INT                       bbs0,bbs1, bbs2, bbs3, bbs4, bbsm;  // bbst,
92
 
INT           bsdust_upper, bsdust_lower, bsdust_ps;
93
 
INT           Nb1, Nb2, Nb3, Nb4, Nbt, Ps, Psf;
94
 
BYTE          multi_bas;
95
 
 
96
 
INT           Ns1=0,Ns2=0;        // in Iot.c   only  !!!
97
 
//INT           pen_up;         // for otladka 't' in St_tools.c
98
 
 
99
 
BYTE          let_to_dust=0;
100
 
 
101
 
CHAR          all_caps=0;
102
 
CHAR          all_diffs_made=0;
 
73
extern uchar fax1x2;
 
74
extern uchar language;
 
75
extern uchar multy_language;
 
76
 
 
77
extern uint16_t actual_resolution;
 
78
extern Bool   line_BL;
 
79
extern uchar  spec_camera;
 
80
extern uchar  no_linpen;
 
81
extern int16_t  prop_l_delta, prop_r_delta;
 
82
extern uchar  db_pass;
 
83
 
 
84
extern uchar *letters_pidx_table;  // 512
 
85
extern uchar decode_ASCII_to_[256][4];
 
86
 
 
87
 
 
88
int16_t     minrow,mincol, maxrow, maxcol;
 
89
int16_t     bs_got=0;     // in baton.c - int32_t - error!?
 
90
 
 
91
int16_t                   bbs0,bbs1, bbs2, bbs3, bbs4, bbsm;  // bbst,
 
92
int16_t           bsdust_upper, bsdust_lower, bsdust_ps;
 
93
int16_t           Nb1, Nb2, Nb3, Nb4, Nbt, Ps, Psf;
 
94
uchar          multi_bas;
 
95
 
 
96
int16_t           Ns1=0,Ns2=0;        // in Iot.c   only  !!!
 
97
//int16_t           pen_up;         // for otladka 't' in St_tools.c
 
98
 
 
99
uchar          let_to_dust=0;
 
100
 
 
101
char          all_caps=0;
 
102
char          all_diffs_made=0;
103
103
CSTR_line     lin_str=(CSTR_line)NULL;     // pass3.c only
104
104
 
105
 
CHAR          dust_in = 0;
 
105
char          dust_in = 0;
106
106
 
107
107
static BAL_bas_ln all_bases[32];
108
108
 
109
109
// Linpon.c
110
 
INT sMALL_SIZE=SMALL_SIZE;
 
110
int16_t sMALL_SIZE=SMALL_SIZE;
111
111
 
112
 
INT obtain_diff(INT arg);
 
112
int16_t obtain_diff(int16_t arg);
113
113
 
114
114
/////////////////////
115
115
 
116
 
INT get_bsm()
 
116
int16_t get_bsm()
117
117
 { return (bbsm+minrow); }
118
118
/////////
119
 
INT def_locbas(cell *cl)
 
119
int16_t def_locbas(cell *cl)
120
120
{
121
121
 BAL_bas_ln *bc, *bn, *bsp;
122
 
 INT i, x, y, dc, dn;
123
 
 Word8 fl_defb;
 
122
 int16_t i, x, y, dc, dn;
 
123
 uchar fl_defb;
124
124
 
125
125
 if ((multi_bas & 128) == 0)
126
126
   goto retps;  // multiple bases not set
177
177
//////////
178
178
void get_b_lines(cell *C, B_LINES *bas)
179
179
 {
180
 
 INT dif;
 
180
 int16_t dif;
181
181
 
182
182
 if (C)
183
183
 {
228
228
 bas->n4=Nb4;
229
229
 }
230
230
///////////////////////////
231
 
LONG get_size()                                                   //16.01.97
 
231
int32_t get_size()                                                   //16.01.97
232
232
 { if (multi_bas & 128)
233
233
      def_locbas(NULL);
234
 
   return (LONG) Ps;                                              //16.01.97
 
234
   return (int32_t) Ps;                                              //16.01.97
235
235
 }
236
236
///////////////////////
237
237
//
240
240
 
241
241
/*============= Func prototypes ==================*/
242
242
 
243
 
BYTE to_lower(BYTE c);
244
 
BYTE to_upper(BYTE c);
245
 
INT  is_lower(BYTE ch);
246
 
INT  is_upper(BYTE ch);
247
 
INT  isletter(BYTE ch);
248
 
BYTE get_homot(BYTE ch);
249
 
INT  draft_cut_hyps(INT bs,INT fl);
 
243
uchar to_lower(uchar c);
 
244
uchar to_upper(uchar c);
 
245
int16_t  is_lower(uchar ch);
 
246
int16_t  is_upper(uchar ch);
 
247
int16_t  isletter(uchar ch);
 
248
uchar get_homot(uchar ch);
 
249
int16_t  draft_cut_hyps(int16_t bs,int16_t fl);
250
250
 
251
251
/*============= Source code ============*/
252
 
BOOL is_liga_ff(BYTE c)
 
252
Bool is_liga_ff(uchar c)
253
253
{
254
254
// ��� ���� ��������� ����� ����� � ligas.h 05.09.2000 E.P.
255
255
  return (c==liga_ff);
256
256
}
257
 
BOOL is_liga_ffl(BYTE c)
 
257
Bool is_liga_ffl(uchar c)
258
258
{
259
259
// ��� ���� ��������� ����� ����� � ligas.h 05.09.2000 E.P.
260
260
  return (c==liga_ffl);
261
261
}
262
262
 
263
 
INT is_russian(BYTE ch)
 
263
int16_t is_russian(uchar ch)
264
264
{
265
265
if( language==LANG_RUSSIAN || language==LANG_ENGLISH && multy_language )
266
266
switch(fEdCode){
267
267
  case ED_ASCII: // for ASCII
268
 
   if((ch >=(BYTE)'�' && ch <=(BYTE)'�') ||
269
 
      (ch >=(BYTE)'�' && ch <=(BYTE)'�') ||
270
 
      (ch >=(BYTE)'�' && ch <=(BYTE)'�') ||
 
268
   if((ch >=(uchar)'�' && ch <=(uchar)'�') ||
 
269
      (ch >=(uchar)'�' && ch <=(uchar)'�') ||
 
270
      (ch >=(uchar)'�' && ch <=(uchar)'�') ||
271
271
       memchr("��������",ch,8)
272
272
     ) return 1;
273
273
  break;
274
274
  case ED_WIN: // for Windows (ANSI)
275
 
      if( (ch >=0xE0 && ch <=0xFF)||(ch >=(BYTE)'�' && ch <=(BYTE)'�'))
 
275
      if( (ch >=0xE0 && ch <=0xFF)||(ch >=(uchar)'�' && ch <=(uchar)'�'))
276
276
        return 1;
277
277
  break;
278
278
  case ED_MAC: // for Macintosh
284
284
return 0;
285
285
}
286
286
 
287
 
INT is_english(BYTE ch)
 
287
int16_t is_english(uchar ch)
288
288
{
289
289
return (ch >= 'a' && ch <= 'z')||(ch >= 'A' && ch <= 'Z')||
290
290
       (
295
295
           ;
296
296
}
297
297
 
298
 
INT is_serbian_special(BYTE ch)
 
298
int16_t is_serbian_special(uchar ch)
299
299
{
300
300
return (ch == SERB_j  ||   ch == SERB_J  ||
301
301
        ch == SERB_n  ||   ch == SERB_N  ||
306
306
 
307
307
}
308
308
 
309
 
INT is_polish_special(BYTE ch)
 
309
int16_t is_polish_special(uchar ch)
310
310
{
311
311
return (ch == POLISH_SS  ||   ch == POLISH_s  ||
312
312
        ch == POLISH_ZZD ||   ch == POLISH_zd ||
320
320
    );
321
321
}
322
322
 
323
 
INT is_czech_special(BYTE let)
 
323
int16_t is_czech_special(uchar let)
324
324
{
325
325
return (
326
326
     let == AA_right_accent || let == a_right_accent    ||
341
341
    );
342
342
}
343
343
 
344
 
INT is_roman_special(BYTE let)
 
344
int16_t is_roman_special(uchar let)
345
345
{
346
346
return (
347
347
     let == AA_semicircle                       ||      let == a_semicircle                             ||
352
352
    );
353
353
}
354
354
 
355
 
INT is_hungar_special(BYTE let)
 
355
int16_t is_hungar_special(uchar let)
356
356
{
357
357
return (
358
358
     let == AA_right_accent ||          let == a_right_accent ||
363
363
     let == OO_double_right ||          let == o_double_right
364
364
    );
365
365
}
366
 
INT is_slovenian_special(BYTE let)
 
366
int16_t is_slovenian_special(uchar let)
367
367
{
368
368
return (
369
369
     let == CC_inv_roof                 || let == c_inv_roof            ||
372
372
    );
373
373
}
374
374
 
375
 
INT isnot_slovenian(BYTE let)
 
375
int16_t isnot_slovenian(uchar let)
376
376
{
377
377
return (
378
378
     let == 'Q' || let == 'q' ||
382
382
    );
383
383
}
384
384
 
385
 
INT is_baltic_palka(BYTE c)
 
385
int16_t is_baltic_palka(uchar c)
386
386
{
387
387
// ����������� ���������� �����. 30.05.2002 E.P.
388
388
 
397
397
                        );
398
398
}
399
399
 
400
 
INT is_latvian_special(BYTE let)
 
400
int16_t is_latvian_special(uchar let)
401
401
{
402
402
return (
403
403
     let == AA_macron                   ||let == a_macron                       ||
415
415
    );
416
416
}
417
417
 
418
 
INT isnot_latvian(BYTE let)
 
418
int16_t isnot_latvian(uchar let)
419
419
{
420
420
return (
421
421
     let == 'Q' || let == 'q' ||
425
425
    );
426
426
}
427
427
 
428
 
INT is_lithuanian_special(BYTE let)
 
428
int16_t is_lithuanian_special(uchar let)
429
429
{
430
430
return (
431
431
     let == AA_bottom_accent    ||      let == a_bottom_accent  ||
441
441
    );
442
442
}
443
443
 
444
 
INT isnot_lithuanian(BYTE let)
 
444
int16_t isnot_lithuanian(uchar let)
445
445
{
446
446
return (
447
447
     let == 'Q' || let == 'q' ||
450
450
    );
451
451
}
452
452
 
453
 
INT is_estonian_special(BYTE let)
 
453
int16_t is_estonian_special(uchar let)
454
454
{
455
455
return (
456
456
     let == AA_2dot_accent              ||      let == a_2dot_accent            ||
463
463
    );
464
464
}
465
465
 
466
 
INT isnot_estonian(BYTE let)
 
466
int16_t isnot_estonian(uchar let)
467
467
{
468
468
return (
469
469
     let == 'C' || let == 'c' ||
474
474
    );
475
475
}
476
476
 
477
 
INT is_turkish_special(BYTE let)
 
477
int16_t is_turkish_special(uchar let)
478
478
{
479
479
return (
480
480
     let == AA_roof_accent                      ||      let == a_roof_accent                    ||
490
490
    );
491
491
}
492
492
 
493
 
INT is_turkish_bottom_accent(BYTE c)
 
493
int16_t is_turkish_bottom_accent(uchar c)
494
494
{
495
495
// ����������� ������� �������. 20.05.2002 E.P.
496
496
        return (
501
501
        0);
502
502
}
503
503
 
504
 
INT is_turkish_palka(BYTE c)
 
504
int16_t is_turkish_palka(uchar c)
505
505
{
506
506
// ����������� �������� �����. 21.05.2002 E.P.
507
507
 
515
515
                        );
516
516
}
517
517
 
518
 
INT is_russian_turkish_conflict(BYTE c)
 
518
int16_t is_russian_turkish_conflict(uchar c)
519
519
{
520
520
/*
521
521
        ����������� ��������� ����� ��������
555
555
        return FALSE;
556
556
}
557
557
 
558
 
INT isnot_turkish(BYTE let)
 
558
int16_t isnot_turkish(uchar let)
559
559
{
560
560
extern  char    alphabet[256];
561
561
 
568
568
}
569
569
 
570
570
///////////////////////////////////////
571
 
INT is_lower(BYTE ch)
 
571
int16_t is_lower(uchar ch)
572
572
{
573
573
 
574
574
if(language==LANG_RUSSIAN)
575
575
        switch(fEdCode){
576
576
  case ED_ASCII: // for ASCII
577
 
   if((ch >=(BYTE)'�' && ch <=(BYTE)'�') ||
578
 
      (ch >=(BYTE)'�' && ch <=(BYTE)'�') ||
 
577
   if((ch >=(uchar)'�' && ch <=(uchar)'�') ||
 
578
      (ch >=(uchar)'�' && ch <=(uchar)'�') ||
579
579
       memchr("�������",ch,7)
580
580
     ) return 1;
581
581
  break;
591
591
 if(ch >= 'a' && ch <= 'z') return 1;
592
592
 return 0;
593
593
}
594
 
INT is_upper(BYTE ch)
 
594
int16_t is_upper(uchar ch)
595
595
{
596
596
if(language==LANG_RUSSIAN)
597
597
    switch(fEdCode){
598
598
    case ED_ASCII:
599
599
    case ED_MAC: // for ASCII and Macintosh
600
 
      if(ch >=(BYTE)'�' && ch <=(BYTE)'�'||
601
 
         ch==(BYTE)r_EE_2dot
 
600
      if(ch >=(uchar)'�' && ch <=(uchar)'�'||
 
601
         ch==(uchar)r_EE_2dot
602
602
        )  return 1;
603
603
    break;
604
604
    case ED_WIN: // for Windows (ANSI)
610
610
 return 0;
611
611
}
612
612
 
613
 
BOOL is_digit(BYTE ch)
 
613
Bool is_digit(uchar ch)
614
614
{
615
 
if(ch >= (BYTE)'0' && ch <= (BYTE)'9') return TRUE;
 
615
if(ch >= (uchar)'0' && ch <= (uchar)'9') return TRUE;
616
616
else return FALSE;
617
617
}
618
618
 
619
 
INT isletter(BYTE ch)
 
619
int16_t isletter(uchar ch)
620
620
{
621
621
if(is_lower(ch) || is_upper(ch)) return 1;
622
622
else return 0;
623
623
}
624
624
 
625
 
static const BYTE non_twin[]="������";
626
 
static const BYTE lat_twins[]="cCoOpPsSvVwWxXzZ";
 
625
static const uchar non_twin[]="������";
 
626
static const uchar lat_twins[]="cCoOpPsSvVwWxXzZ";
627
627
 
628
 
INT twin(BYTE ch)
 
628
int16_t twin(uchar ch)
629
629
{
630
630
if(!isletter(ch)) return 0;
631
631
if( language==LANG_RUSSIAN )
635
635
return 0;
636
636
}
637
637
 
638
 
BYTE get_homot(BYTE ch )
 
638
uchar get_homot(uchar ch )
639
639
{
640
 
 if(ch == '0') return ((BYTE)'�');
 
640
 if(ch == '0') return ((uchar)'�');
641
641
 if(is_upper(ch)) return to_lower(ch);
642
642
 if(is_lower(ch)) return to_upper(ch);
643
643
 return ch;
644
644
}
645
645
 
646
646
/* Function returns UPPER CASE variant of the letter.             */
647
 
BYTE to_upper( BYTE c )
 
647
uchar to_upper( uchar c )
648
648
{
649
 
  if ( c >= (BYTE)'a' && c <= (BYTE)'z') return c - (BYTE)'a' + (BYTE)'A';
 
649
  if ( c >= (uchar)'a' && c <= (uchar)'z') return c - (uchar)'a' + (uchar)'A';
650
650
  if(language==LANG_RUSSIAN)
651
651
       switch(fEdCode){
652
652
  case ED_ASCII:  // for ASCII
653
 
    if ( c >= (BYTE)'�' && c <= (BYTE)'�') return c - (BYTE)'�' + (BYTE)'�';
654
 
    if ( c >= (BYTE)'�' && c <= (BYTE)'�') return c - (BYTE)'�' + (BYTE)'�';
 
653
    if ( c >= (uchar)'�' && c <= (uchar)'�') return c - (uchar)'�' + (uchar)'�';
 
654
    if ( c >= (uchar)'�' && c <= (uchar)'�') return c - (uchar)'�' + (uchar)'�';
655
655
  break;
656
656
  case ED_WIN: // for Windows (ANSI)
657
657
    if ( c >= 0xE0 && c <= 0xFF ) return c - 0xE0 + 0xC0;
665
665
}
666
666
 
667
667
 /* Function returns LOWER CASE variant of the letter.             */
668
 
BYTE to_lower(BYTE c)
 
668
uchar to_lower(uchar c)
669
669
{
670
 
  if ( c >= (BYTE)'A' && c <= (BYTE)'Z') return c - (BYTE)'A'+ (BYTE)'a' ;
 
670
  if ( c >= (uchar)'A' && c <= (uchar)'Z') return c - (uchar)'A'+ (uchar)'a' ;
671
671
  if(language==LANG_RUSSIAN)
672
672
        switch(fEdCode){
673
673
  case ED_ASCII: // for ASCII
674
 
    if ( c >= (BYTE)'�' && c <= (BYTE)'�') return c - (BYTE)'�'+ (BYTE)'�' ;
675
 
    if ( c >= (BYTE)'�' && c <= (BYTE)'�') return c - (BYTE)'�'+ (BYTE)'�' ;
 
674
    if ( c >= (uchar)'�' && c <= (uchar)'�') return c - (uchar)'�'+ (uchar)'�' ;
 
675
    if ( c >= (uchar)'�' && c <= (uchar)'�') return c - (uchar)'�'+ (uchar)'�' ;
676
676
  break;
677
677
  case ED_WIN: // for Windows
678
678
    if ( c >= 0xC0 && c <= 0xDF) return c - 0xC0 + 0xE0 ;
685
685
    return c;
686
686
}
687
687
/////////////////////
688
 
INT is_cen_bottom_accent(BYTE c)
 
688
int16_t is_cen_bottom_accent(uchar c)
689
689
{
690
690
// ����������� ������� ������� 12.09.2000 E.P.
691
691
        return (
699
699
        0);
700
700
}
701
701
/////////////////////
702
 
INT is_baltic_bottom_accent(BYTE c)
 
702
int16_t is_baltic_bottom_accent(uchar c)
703
703
{
704
704
// ����������� ������� ������� 10.07.2001 E.P.
705
705
        return (
715
715
        0);
716
716
}
717
717
 
718
 
INT is_russian_baltic_conflict(BYTE c)
 
718
int16_t is_russian_baltic_conflict(uchar c)
719
719
{
720
720
// ����������� ��������� ����� �������� � ����������� �������. 17.07.2001 E.P.
721
721
        if (!is_baltic_language(language))
728
728
}
729
729
/////////////////////////////////
730
730
// Linpon.c
731
 
INT is_defis(cell *C)
732
 
 {   INT bs2m, bsm3;
733
 
 INT i, j;
 
731
int16_t is_defis(cell *C)
 
732
 {   int16_t bs2m, bsm3;
 
733
 int16_t i, j;
734
734
 if ((C->w < 3) || (C->h < 2) || (2*C->h > C->w) || (9 * (C->h) > 4 * Ps))
735
735
  return 0;
736
736
 i=C->row-minrow+C->bdiff; j=i+C->h;
741
741
 }
742
742
//////////////////////
743
743
// Linpon.c
744
 
INT if_dust(cell *C)
745
 
 { INT rb, w1, wh, wps;
 
744
int16_t if_dust(cell *C)
 
745
 { int16_t rb, w1, wh, wps;
746
746
 // Check position in the string - have to intersect with string middle
747
747
 // MUST request local BASELINES !!!!!!!!!!!!!!
748
748
 rb = 0;
767
767
//////////////////////
768
768
static void SetRstrGlobals(BAL_RSTR_GLOBALS  *rstrGlob)
769
769
{
770
 
INT rast_is_BOX_solid (CSTR_rast B1);
 
770
int16_t rast_is_BOX_solid (CSTR_rast B1);
771
771
 
772
772
        rstrGlob->language = language;
773
773
        rstrGlob->line_number = line_number;
836
836
        Ps  = balGlob->Ps  ;
837
837
        Psf = balGlob->Psf ;
838
838
 
839
 
        nIncline = (Int16)balGlob->nIncline;
 
839
        nIncline = (int16_t)balGlob->nIncline;
840
840
}
841
841
/////////////////////
842
842
static void SetBalGlobals(BAL_INOUT_GLOBALS  *balGlob)
875
875
}
876
876
//////////////////////
877
877
static CSTR_head *llRaw=(CSTR_head *)NULL;
878
 
static Word16 SetNoScaleLine(CSTR_line ln )
 
878
static uint16_t SetNoScaleLine(CSTR_line ln )
879
879
{
880
880
        CSTR_attr lattr;
881
881
        CSTR_rast rast;
882
882
        CSTR_rast_attr attr;
883
883
        CCOM_comp *cmp;
884
 
        Word16 scale;
 
884
        uint16_t scale;
885
885
 
886
886
    llRaw = (CSTR_head *)ln;
887
887
 
927
927
}
928
928
///////////////
929
929
//////////////////////
930
 
static Word16 RestoreScaleLine(CSTR_line ln , Word16 scale)
 
930
static uint16_t RestoreScaleLine(CSTR_line ln , uint16_t scale)
931
931
{
932
932
        CSTR_attr lattr;
933
933
        CSTR_rast rast;
939
939
 
940
940
        CSTR_GetLineAttr(ln,&lattr);
941
941
        lattr.Flags |= CSTR_STR_SCALED;
942
 
        lattr.scale  = (Word8)scale;
 
942
        lattr.scale  = (uchar)scale;
943
943
        CSTR_SetLineAttr(ln,&lattr);
944
944
 
945
945
        for(rast=CSTR_GetNext(CSTR_GetFirstRaster(ln));rast;
973
973
void clear_cells(void);
974
974
void Cells2CSTR(CSTR_line lin,CSTR_line lino,cell *cur,Bool32 enable_scaled);
975
975
// ��� CopyAttr2CSTR � Cells2CSTR() !!!
976
 
BOOL SetFontReady(BOOL fready);
977
 
Int32 p2_Cstr2Cell( CSTR_line lin,CSTR_rast first,CSTR_rast last,Bool32 needVers, Word32 disable );
 
976
Bool SetFontReady(Bool fready);
 
977
int32_t p2_Cstr2Cell( CSTR_line lin,CSTR_rast first,CSTR_rast last,Bool32 needVers, uint32_t disable );
978
978
// ��������������� ����� ������� �����
979
979
void basedraft(CSTR_line ln)
980
980
{
984
984
 int  i;
985
985
 CSTR_rast rast;
986
986
 int  ret;
987
 
 Word16 saveScale;
 
987
 uint16_t saveScale;
988
988
 Bool32 retBaseDraft;
989
989
 CSTR_attr lattr,lattr_bal;
990
990
 
1004
1004
        // ��������� cell_f()-> � ���� �����, ���������
1005
1005
        // �������� ln
1006
1006
        {
1007
 
          BOOL old_ready = SetFontReady(TRUE);
 
1007
          Bool old_ready = SetFontReady(TRUE);
1008
1008
      Cells2CSTR( ln, line_bal, NULL, 1);
1009
1009
          SetFontReady(old_ready);
1010
1010
        }
1048
1048
    // ��������� cell_f()-> � ���� �����, ���������
1049
1049
        // �������� ln
1050
1050
    {
1051
 
          BOOL old_ready = SetFontReady(TRUE);
 
1051
          Bool old_ready = SetFontReady(TRUE);
1052
1052
      Cells2CSTR( ln, line_bal, NULL, 1);
1053
1053
          SetFontReady(old_ready);
1054
1054
        }
1091
1091
    // ��������� cell_f()-> � ���� �����, ���������
1092
1092
        // �������� ln
1093
1093
     {
1094
 
          BOOL old_ready = SetFontReady(TRUE);
 
1094
          Bool old_ready = SetFontReady(TRUE);
1095
1095
      Cells2CSTR( ln, line_bal, NULL, 1);
1096
1096
          SetFontReady(old_ready);
1097
1097
        }
1131
1131
 CSTR_line line_bal=(CSTR_line)NULL;
1132
1132
 int  i;
1133
1133
 int  ret;
1134
 
 Word16 saveScale;
 
1134
 uint16_t saveScale;
1135
1135
 
1136
1136
   lin_str = ln;
1137
1137
 
1148
1148
        // ��������� cell_f()-> � ���� �����, ���������
1149
1149
        // �������� ln
1150
1150
    {
1151
 
          BOOL old_ready = SetFontReady(TRUE);
 
1151
          Bool old_ready = SetFontReady(TRUE);
1152
1152
      Cells2CSTR( ln, line_bal, NULL, 1);
1153
1153
          SetFontReady(old_ready);
1154
1154
        }
1182
1182
 CSTR_line line_bal=(CSTR_line)NULL;
1183
1183
 int  i;
1184
1184
 int  ret;
1185
 
 Word16 saveScale;
 
1185
 uint16_t saveScale;
1186
1186
 
1187
1187
   lin_str = ln;
1188
1188
 
1199
1199
        // ��������� cell_f()-> � ���� �����, ���������
1200
1200
        // �������� ln
1201
1201
    {
1202
 
          BOOL old_ready = SetFontReady(TRUE);
 
1202
          Bool old_ready = SetFontReady(TRUE);
1203
1203
      Cells2CSTR( ln, line_bal, NULL, 1);
1204
1204
          SetFontReady(old_ready);
1205
1205
        }