← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/puma/c/common.cpp

  • 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/puma/c/common.cpp
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:
65
65
{
66
66
        PAGEINFO           PInfo = {0};
67
67
//
68
 
// �������� ���������� ��������� � ������� ���������
 
68
// Сохраним последенне состояние и очистим контейнер
69
69
//
70
70
        if(ghEdPage)
71
71
        {
86
86
        SetPageInfo(hCPAGE,PInfo);
87
87
 
88
88
        CCOM_DeleteAll();  hCCOM = NULL;
89
 
        CIMAGE_DeleteImage((PWord8)PUMA_IMAGE_BINARIZE );
90
 
        CIMAGE_DeleteImage((PWord8)PUMA_IMAGE_DELLINE   );
91
 
//  ���������� ����������� ( PUMA_IMAGE_ROTATE) ������� ������, ��� � ��������,
92
 
//  ��������� ��� ������������ � ����������. ��� ����� �������
93
 
//  ���� ��� ��������� ������ ����������� �����������, ���� ���
94
 
//  �������� �����
95
 
        CIMAGE_DeleteImage((PWord8)PUMA_IMAGE_TURN              );
 
89
        CIMAGE_DeleteImage((puchar)PUMA_IMAGE_BINARIZE );
 
90
        CIMAGE_DeleteImage((puchar)PUMA_IMAGE_DELLINE   );
 
91
//  Повернутое изображение ( PUMA_IMAGE_ROTATE) удалять нельзя, как и исходное,
 
92
//  поскольку оно отображается в интерфейсе. Его нужно удалять
 
93
//  либо при получении нового довернутого изображения, либо при
 
94
//  закрытии файла
 
95
        CIMAGE_DeleteImage((puchar)PUMA_IMAGE_TURN              );
96
96
        /*
97
97
        if(hCPAGE && CPAGE_GetCountBlock(hCPAGE))
98
98
        {
107
107
        */
108
108
}
109
109
///////////////////////////////////////////////////////
110
 
// ������� �������� ����������
111
 
Bool32 rexcProgressStep  (Word32 step)
 
110
// Функции прогресс индикатора
 
111
Bool32 rexcProgressStep  (uint32_t step)
112
112
{
113
113
        return ProgressStep(2,NULL,step);
114
114
}
115
115
///////////////////////////////////////////////////////
116
 
Bool32  ExtractComponents( Bool32 bIsRotate, Handle * prev_ccom, PWord8 name)
 
116
Bool32  ExtractComponents( Bool32 bIsRotate, Handle * prev_ccom, puchar name)
117
117
{
118
118
        Bool32 rc = TRUE;
119
119
        ExcControl      exc = {0};
135
135
                return FALSE;
136
136
        }
137
137
 
138
 
        // ����� ������������� ��������
 
138
        // будет распознавания эвентами
139
139
        exc.Control  = Ex_ExtraComp|/*Ex_EvnRecog|*/Ex_Picture;
140
140
    //exc.Control |= Ex_NetRecog;
141
141
 
144
144
    if( gnPictures )
145
145
        exc.Control |= Ex_PictureLarge;
146
146
/*
147
 
        if(rc && !REXC_SetEVNProperties(exc, GetModulePath(),(Word8)gnLanguage) )
148
 
        { // ���������������� ������������� �� ������� � ������ �������
 
147
        if(rc && !REXC_SetEVNProperties(exc, GetModulePath(),(uchar)gnLanguage) )
 
148
        { // инициализировать распознавание по эвентам и задать алфавит
149
149
                SetReturnCode_puma(REXC_GetReturnCode());
150
150
                rc = FALSE;
151
151
        }
152
152
        else
153
153
*/
154
154
        {
155
 
                Word8 w8 = (Word8)gbDotMatrix;
 
155
                uchar w8 = (uchar)gbDotMatrix;
156
156
                        REXC_SetImportData(REXC_Word8_Matrix,&w8);
157
157
 
158
 
                w8 = (Word8)gbFax100;
 
158
                w8 = (uchar)gbFax100;
159
159
                        REXC_SetImportData(REXC_Word8_Fax1x2,&w8);
160
160
        }
161
161
/*
162
 
        if(rc && !REXCExtraDIB( exc, lpdata,0,0,0,0) ) // ����� ��������� � DIB-e
 
162
        if(rc && !REXCExtraDIB( exc, lpdata,0,0,0,0) ) // поиск компонент в DIB-e
163
163
*/
164
164
    CIMAGEIMAGECALLBACK clbk;
165
165
    if(rc && !CIMAGE_GetCallbackImage(name, &clbk))
167
167
                SetReturnCode_puma(CIMAGE_GetReturnCode());
168
168
        rc = FALSE;
169
169
    }
170
 
    if( rc && !REXCExtracomp3CB(exc, // ����� ��������� by 3CallBacks
 
170
    if( rc && !REXCExtracomp3CB(exc, // поиск компонент by 3CallBacks
171
171
        (TImageOpen)clbk.CIMAGE_ImageOpen,
172
172
        (TImageClose)clbk.CIMAGE_ImageClose,
173
173
        (TImageRead)clbk.CIMAGE_ImageRead)
201
201
        return rc ;
202
202
}
203
203
/////////////////////////////////////////////////////////////////////////////////////////////////////
204
 
// ����� ���������� � RSource.dll
 
204
// Будет перенесено в RSource.dll
205
205
Bool32  comp_over(CCOM_comp *sour,CCOM_comp *cur)
206
206
{
207
 
        Int32   le,ri,up,dn,w,h;
 
207
        int32_t   le,ri,up,dn,w,h;
208
208
 
209
209
        if( sour->left+sour->w<=cur->left || cur->left+cur->w<=sour->left )
210
210
                return FALSE;
238
238
        return FALSE;
239
239
}
240
240
/////////////////////////////////////////////////////////////////////////////////////////////////////
241
 
// ����� ���������� � RSource.dll
 
241
// будет перенесено в RSource.dll
242
242
Bool32  remove_overlayed(CCOM_comp *sour,CCOM_handle haCCOM)
243
243
{
244
244
CCOM_comp   *cur=CCOM_GetFirst(haCCOM,NULL), *curn;
245
 
Int32       over=0;
 
245
int32_t       over=0;
246
246
 
247
247
do  {
248
248
    curn=CCOM_GetNext(cur,NULL);
263
263
return (over>0);
264
264
}
265
265
/////////////////////////////////////////////////////////////////////////////////////////////////////
266
 
// ����� ���������� � RSource.dll
267
 
// ��������� ����������� AlMi
268
 
Bool32 MyGetZher (void **vvZher, Int32 *nZher, Int32 MaxZher, Handle hCPage)
 
266
// будет перенесено в RSource.dll
 
267
// авторство принадлежит AlMi
 
268
Bool32 MyGetZher (void **vvZher, int32_t *nZher, int32_t MaxZher, Handle hCPage)
269
269
{
270
 
        Word32 err32, nTeor, nReal;
 
270
        uint32_t err32, nTeor, nReal;
271
271
        Handle hBlockZher;
272
272
        Handle hBlockPrev;
273
273
        int i;
306
306
        return TRUE;
307
307
}
308
308
/////////////////////////////////////////////////////////////////////////////////////////////////////
309
 
// ����� ���������� � RSource.dll
310
 
Bool32 RemoveLines(Handle hccom,Handle hcpage,PWord8 * lppDIB)
 
309
// будет перенесено в RSource.dll
 
310
Bool32 RemoveLines(Handle hccom,Handle hcpage,puchar * lppDIB)
311
311
{
312
 
        PWord8 hDIB = NULL;
 
312
        puchar hDIB = NULL;
313
313
        Bool32 rc = TRUE;
314
314
    hLinesCCOM = NULL;
315
315
    CCOM_comp   *victim[100];
316
 
    Int32       nvict,i;
 
316
    int32_t       nvict,i;
317
317
    Bool32      yes_victim = FALSE;
318
318
//
319
 
//       ������ �����
 
319
//       Удалим линии
320
320
//
321
321
        if(rc && !RLINE_DeleteLines(hcpage,PUMA_IMAGE_DELLINE))
322
322
        {
324
324
                rc = FALSE;
325
325
        }
326
326
//
327
 
//       ������� ����������� � ���������� �������
 
327
//       Получим изображение с удаленными линиями
328
328
//
329
 
        if(rc && !CIMAGE_ReadDIB((PWord8)PUMA_IMAGE_DELLINE,(Handle*)&hDIB,TRUE))
 
329
        if(rc && !CIMAGE_ReadDIB((puchar)PUMA_IMAGE_DELLINE,(Handle*)&hDIB,TRUE))
330
330
        {
331
331
                SetReturnCode_puma(CIMAGE_GetReturnCode());
332
332
                rc = FALSE;
334
334
        if(hDIB)
335
335
        {
336
336
//
337
 
//               ������ ���������� � ������� �� ������.
 
337
//               Удалим компоненты и выделим их заново.
338
338
//
339
 
                *lppDIB = (PWord8)hDIB;
 
339
                *lppDIB = (puchar)hDIB;
340
340
                if(rc)
341
341
                {
342
342
        if( CCOM_GetContainerVolume((CCOM_handle)hCCOM)<60000 &&
349
349
            hCCOM=0;
350
350
            }
351
351
 
352
 
                if(!ExtractComponents(FALSE,&hLinesCCOM,(PWord8)PUMA_IMAGE_DELLINE))
 
352
                if(!ExtractComponents(FALSE,&hLinesCCOM,(puchar)PUMA_IMAGE_DELLINE))
353
353
                {
354
354
                                rc = FALSE;
355
355
                }
382
382
                {
383
383
                /*
384
384
                Rect16 rect1;
385
 
                    Word32 key = 111;
 
385
                    uint32_t key = 111;
386
386
                for(i=0;i<nvict;i++)
387
387
                    {
388
388
                    exa = victim[i];
395
395
 
396
396
                if(!LDPUMA_Skip(hShowCheckLetters))
397
397
                        {
398
 
                                LDPUMA_Console("Puma_������� �����  \n");
 
398
                                LDPUMA_Console("Puma_Коробки жертв  \n");
399
399
                                LDPUMA_WaitUserInput(NULL, NULL);
400
400
                                LDPUMA_DeleteRects(NULL, key);
401
401
                        }
424
424
                }
425
425
                        }
426
426
                        else
427
 
                                LDPUMA_Console("�������� ���� ��������� ��������� ����� �������� �����.\n");
 
427
                                LDPUMA_Console("Пропущен этап выделения компонент после удаления линий.\n");
428
428
                }
429
429
        }
430
430
return rc;
516
516
}
517
517
/////////////////////////////////////////////////////////////////////////////////////////////////////
518
518
//
519
 
Bool32 ProgressStep(Word32 step,char*name,Word32 percent)
 
519
Bool32 ProgressStep(uint32_t step,char*name,uint32_t percent)
520
520
{
521
521
        Bool32 rc = TRUE;
522
 
        static Word32 old = 0;
 
522
        static uint32_t old = 0;
523
523
 
524
524
        g_PrgTime.dwStep = step;
525
525
        g_PrgTime.name = name ? name : g_PrgTime.name;
526
526
 
527
 
        Word32 perc = g_PrgTime.dwBeg + percent*(g_PrgTime.dwEnd - g_PrgTime.dwBeg)/100;
 
527
        uint32_t perc = g_PrgTime.dwBeg + percent*(g_PrgTime.dwEnd - g_PrgTime.dwBeg)/100;
528
528
        rc = LDPUMA_ProgressStep(step,g_PrgTime.name,perc);
529
529
//      _ASSERT(perc>=old);
530
530
        if(fnProgressStep)
535
535
}
536
536
/////////////////////////////////////////////////////////////////////////////////////////////////////
537
537
//
538
 
Bool32 ProgressStepLayout(Word32 step,Word32 percent)
 
538
Bool32 ProgressStepLayout(uint32_t step,uint32_t percent)
539
539
{
540
540
        return ProgressStep(step, GetResourceString(IDS_PRG_OPEN), percent);
541
541
}
542
542
/////////////////////////////////////////////////////////////////////////////////////////////////////
543
543
//
544
 
Bool32 ProgressStepLines(Word32 step,Word32 percent)
 
544
Bool32 ProgressStepLines(uint32_t step,uint32_t percent)
545
545
{
546
546
        return ProgressStep(step, GetResourceString(IDS_REMOVELINE), percent);
547
547
}
548
548
/////////////////////////////////////////////////////////////////////////////////////////////////////
549
549
//
550
 
Bool32 ProgressStepTables(Word32 step,Word32 percent)
 
550
Bool32 ProgressStepTables(uint32_t step,uint32_t percent)
551
551
{
552
552
        return ProgressStep(step, GetResourceString(IDS_REMOVELINE), percent);
553
553
}
554
554
//////////////////////////////////////////////////////
555
 
Bool32 ProgressStepSearchTables(Word32 step,Word32 percent)
 
555
Bool32 ProgressStepSearchTables(uint32_t step,uint32_t percent)
556
556
{
557
557
        return ProgressStep(step, GetResourceString(IDS_SEARCHTABLE), percent);
558
558
}
559
559
//////////////////////////////////////////////////////
560
 
Bool32 ProgressStepAutoLayout(Word32 step,Word32 percent)
 
560
Bool32 ProgressStepAutoLayout(uint32_t step,uint32_t percent)
561
561
{
562
562
        return ProgressStep(step, GetResourceString(IDS_AUTOLAYOUT), percent);
563
563
}
564
564
 
565
 
static Word32 bInitPrgTime = 0;
 
565
static uint32_t bInitPrgTime = 0;
566
566
void ResetPRGTIME()
567
567
{
568
568
        bInitPrgTime = 0;
596
596
}
597
597
/////////////////////////////////////////////////////////////////////////////////////////////////////
598
598
//
599
 
PRGTIME  StorePRGTIME(Word32 beg, Word32 end)
 
599
PRGTIME  StorePRGTIME(uint32_t beg, uint32_t end)
600
600
{
601
601
        PRGTIME rc = g_PrgTime;
602
602
 
603
 
        Word32 newBeg = g_PrgTime.dwBeg + (g_PrgTime.dwEnd - g_PrgTime.dwBeg)*beg/100;
604
 
        Word32 newEnd = g_PrgTime.dwBeg + (g_PrgTime.dwEnd - g_PrgTime.dwBeg)*end/100;
 
603
        uint32_t newBeg = g_PrgTime.dwBeg + (g_PrgTime.dwEnd - g_PrgTime.dwBeg)*beg/100;
 
604
        uint32_t newEnd = g_PrgTime.dwBeg + (g_PrgTime.dwEnd - g_PrgTime.dwBeg)*end/100;
605
605
 
606
606
        g_PrgTime.dwBeg = newBeg;
607
607
        g_PrgTime.dwEnd = newEnd;
628
628
        Bool32 italic = 0;
629
629
        Bool32 strikeout = 0;
630
630
        Bool32 underline = 0;
631
 
        Int32 height = 0;
632
 
        Int32 offset = 0;
633
 
        Word32 textcolor = 0;
 
631
        int32_t height = 0;
 
632
        int32_t offset = 0;
 
633
        uint32_t textcolor = 0;
634
634
        int charset = RUSSIAN_CHARSET;
635
635
        const char * name = NULL;
636
 
        static Int32  nFragment = -1;
637
 
        static Word32 deftextcolor = 0;
 
636
        static int32_t  nFragment = -1;
 
637
        static uint32_t deftextcolor = 0;
638
638
        Bool32 bOutputKegl = TRUE;
639
639
 
640
640
        CSTR_GetLineAttr (lout,&line_attr);
646
646
                Handle hBlock = CPAGE_GetBlockFirst(hCPAGE,0);
647
647
                while(hBlock)
648
648
                {
649
 
                        if(CPAGE_GetBlockInterNum(hCPAGE,hBlock) == (Word32)line_attr.fragment)
 
649
                        if(CPAGE_GetBlockInterNum(hCPAGE,hBlock) == (uint32_t)line_attr.fragment)
650
650
                        {
651
651
                                nFragment = line_attr.fragment;
652
652
                                goto lNext;
660
660
 
661
661
 
662
662
        LDPUMA_SetConsoleProperty(0,0,0,0,0,0,deftextcolor,RUSSIAN_CHARSET,"Courier New");
663
 
        LDPUMA_Console("��.%2i ���.%3i: <",line_attr.fragment,num);
 
663
        LDPUMA_Console("Фр.%2i Стр.%3i: <",line_attr.fragment,num);
664
664
 
665
665
        if( start && stop )
666
666
        {
753
753
}
754
754
/////////////////////////////////////////////////////////////////////////////////////////////////////
755
755
//
756
 
Bool32  HL_TableExtractEx( Handle hPAGE, Word32 perc, Rect32 rect )
 
756
Bool32  HL_TableExtractEx( Handle hPAGE, uint32_t perc, Rect32 rect )
757
757
{
758
758
        return RMARKER_SearchTableInZone(hPAGE,hCCOM,perc,rect);
759
759
}
760
760
/////////////////////////////////////////////////////////////////////////////////////////////////////
761
761
//
762
 
Bool32 IsUpdate(Word32 flg)
 
762
Bool32 IsUpdate(uint32_t flg)
763
763
{
764
764
        return (g_flgUpdate & flg) > 0;
765
765
}
766
766
 
767
 
void   SetUpdate(Word32 flgAdd,Word32 flgRemove)
 
767
void   SetUpdate(uint32_t flgAdd,uint32_t flgRemove)
768
768
{
769
769
        g_flgUpdate = (g_flgUpdate | flgAdd) & ~flgRemove;
770
770
}