Debian Codegraph @

cuneiform_src/Kern/itigerole/sources/tiger/h/lib_main.c

raw
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 */
56
57 //////////////////////////////////////////////////////////////////////////////
58 // //
59 // T I G E R O C R L I B R A R Y //
60 // //
61 // Copyright (C) 1996 Cognitive Technology Ltd. //
62 // //
63 //////////////////////////////////////////////////////////////////////////////
64 #define FILELIB_TIGERAPI
65 //////////////////////////////////////////////////////////////////////////////
66 # include <windows.h>
67 //////////////////////////////////////////////////////////////////////////////
68 # include "dlltypes.h"
69 # include "tgcall.h"
70 # include "tgcallbk.h"
71 # include "tgerrors.h"
72 # include "_tgcall.h"
73 //////////////////////////////////////////////////////////////////////////////
74 # define MESSAGE(s)
75 #define ST_OK 0
76 #define ST_LIBRARY_NOT_LOAD 1
77 #define ST_ENTRY_NOT_FOUND 2
78 #define TIGERNAME "Tiger32.dll"
79 //////////////////////////////////////////////////////////////////////////////
80 static char * strErrorMessage[] =
81 {
82 "Ok!",
83 "Library TIGER32.DLL not load.",
84 "Entry point not found."
85 };
86 //////////////////////////////////////////////////////////////////////////////
87 static BOOL16 Init = FALSE;
88 static HMODULE hTiger = NULL;
89 static uint16_t wStatus = ST_OK ;
90 //////////////////////////////////////////////////////////////////////////////
91 static void Tiger_SetStatus(uint16_t wStat)
92 {
93 wStatus = wStat;
94 }
95 //////////////////////////////////////////////////////////////////////////////
96 static char* Tiger_Message(uint16_t wStat)
97 {
98 return strErrorMessage[wStat];
99 }
100 //////////////////////////////////////////////////////////////////////////////
101 // Tiger entries
102 FNBOOL16 __Tiger_Load( fpTiger_Callback fpCallback,char* lpPath)
103 {
104 typedef BOOL16 (TIGERFUN(*)fp__Tiger_Load)( fpTiger_Callback ,char* );
105 fp__Tiger_Load proc;
106
107 if(hTiger==NULL)
108 return FALSE;
109
110 proc= (fp__Tiger_Load)GetProcAddress(hTiger,TIGER_LOAD_FN);
111 if(proc==NULL)
112 {
113 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
114 return FALSE;
115 }
116
117 return (*proc)(fpCallback,lpPath);
118 }
119 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
120 FNBOOL16 __BCR_Load( fpTiger_Callback fpCallback,char* lpPath)
121 {
122 typedef BOOL16 (TIGERFUN(*)fp__BCR_Load)( fpTiger_Callback ,char* );
123 fp__BCR_Load proc;
124
125 if(hTiger==NULL)
126 return FALSE;
127
128 proc = (fp__BCR_Load)GetProcAddress(hTiger,TIGER_BCR_LOAD_FN);
129 if(proc==NULL)
130 {
131 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
132 return FALSE;
133 }
134
135 return (*proc)(fpCallback,lpPath);
136 }
137 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
138 FNBOOL16 Cards_Init
139 (
140 HANDLE wTGCALL_DLL, // Instance of TGCALL for callback
141 char* lpPath, // Path name
142 LPDWORD lpParams, // Parameters pass buffer
143 char* lpBuffer // Image pass buffer
144 )
145 {
146 typedef BOOL16 (TIGERFUN(*)lpCards_Init)
147 ( HANDLE , char* , LPDWORD , char* );
148 lpCards_Init proc;
149
150 Init = FALSE;
151
152 if(hTiger==NULL)
153 return FALSE;
154
155 proc = (lpCards_Init)GetProcAddress(hTiger,TIGER_CARDS_INIT_FN);
156
157 if(proc)
158 Init = (*proc)(wTGCALL_DLL,lpPath,lpParams,lpBuffer);
159 else
160 {
161 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
162 return FALSE;
163 }
164 return Init;
165 }
166 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
167 FNBOOL16 Tiger_Reset (void)
168 {
169 typedef BOOL16 (TIGERFUN(*)fpTiger_Reset) (void);
170 fpTiger_Reset proc;
171
172 if(!hTiger || !Init)
173 return FALSE;
174
175 proc = (fpTiger_Reset)GetProcAddress(hTiger,TIGER_RESET_FN);
176
177 if(proc==NULL)
178 {
179 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
180 return FALSE;
181 }
182
183 return (*proc)();
184 }
185 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
186 FNBOOL16 Tiger_SetRecognitionOptions (uint16_t wOptions)
187 {
188 typedef BOOL16 (TIGERFUN(*)fpTiger_SetRecognitionOptions) (uint16_t);
189 fpTiger_SetRecognitionOptions proc;
190
191 if(!hTiger || !Init)
192 return FALSE;
193
194 proc = (fpTiger_SetRecognitionOptions)GetProcAddress(hTiger,TIGER_SET_REC_OPT_FN);
195
196 if(proc==NULL)
197 {
198 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
199 return FALSE;
200 }
201
202 return (*proc)(wOptions);
203 }
204 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
205 FNBOOL16 Tiger_Recognition (char* lpEdFileName)
206 {
207 typedef BOOL16 (TIGERFUN(*)lpTiger_Recognition)(char* );
208 lpTiger_Recognition proc;
209
210 if(!hTiger || !Init)
211 return FALSE;
212
213 proc = (lpTiger_Recognition)GetProcAddress(hTiger,TIGER_RECOG_FN);
214 if(proc==NULL)
215 {
216 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
217 return FALSE;
218 }
219
220 return (*proc) (lpEdFileName);
221 }
222 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
223 FNBOOL16 Tiger_PageAnalysis (void)
224 {
225 typedef BOOL16 (TIGERFUN(*)fpTiger_PageAnalysis) (void);
226 fpTiger_PageAnalysis proc;
227
228 if(!hTiger || !Init)
229 return FALSE;
230
231 proc = (fpTiger_PageAnalysis)GetProcAddress(hTiger,TIGER_PAGE_AN_FN);
232
233 if(proc==NULL)
234 {
235 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
236 return FALSE;
237 }
238
239 return (*proc) ();
240 }
241 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
242 FNBOOL16 Tiger_FinalRecognition (char* lpEdFileName)
243 {
244 typedef BOOL16 (TIGERFUN(*)lpTiger_FinalRecognition) (char*);
245 lpTiger_FinalRecognition proc;
246
247 if(!hTiger || !Init)
248 return FALSE;
249
250 proc = (lpTiger_FinalRecognition)GetProcAddress(hTiger,
251 TIGER_FIN_RECOG_FN);
252 if(proc==NULL)
253 {
254 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
255 return FALSE;
256 }
257
258 return (*proc) (lpEdFileName);
259 }
260 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
261 FNWORD Tiger_Status (void)
262 {
263 typedef uint16_t (TIGERFUN(*)fpTiger_Status) (void);
264 fpTiger_Status proc;
265
266 if(!hTiger)
267 return FALSE;
268
269 proc = (fpTiger_Status)GetProcAddress(hTiger,TIGER_STATUS_FN);
270
271 if(proc==NULL)
272 {
273 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
274 return FALSE;
275 }
276
277 return (*proc)();
278 }
279 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
280 FNLPSTR Tiger_ErrorMessage (uint16_t wErrorNumber)
281 {
282 typedef char* (TIGERFUN(*)lpTiger_ErrorMessage) (uint16_t);
283 lpTiger_ErrorMessage proc;
284
285 if(!hTiger)
286 {
287 Tiger_SetStatus(ST_LIBRARY_NOT_LOAD);
288 return Tiger_Message(wStatus);
289 }
290
291 proc = (lpTiger_ErrorMessage)GetProcAddress(hTiger,
292 TIGER_ERR_MESSAGE_FN);
293
294 if(proc==NULL)
295 {
296 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
297 return Tiger_Message(wStatus);
298 }
299
300 return (*proc)(wErrorNumber);
301 }
302 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
303 FNBOOL16 Tiger_EdToText
304 (
305 char* lpEdFileName,
306 char* lpTextFileName,
307 uint16_t wOptions,
308 uint16_t wBadCharacter
309 )
310 {
311 typedef BOOL16 (TIGERFUN(*)fpTiger_EdToText)(char* ,char*, uint16_t ,uint16_t );
312 fpTiger_EdToText proc;
313
314 if(!hTiger || !Init)
315 return FALSE;
316
317 proc = (fpTiger_EdToText)GetProcAddress(hTiger,TIGER_ED_2_TEXT_FN);
318
319 if(proc==NULL)
320 {
321 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
322 return FALSE;
323 }
324
325 return (*proc)(lpEdFileName,lpTextFileName,wOptions,wBadCharacter);
326 }
327 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
328 FNBOOL16 Tiger_ExtEdToText
329 (
330 char* lpEdFileName,
331 char* lpTextFileName,
332 uint16_t wOptions,
333 uint16_t wCodePage,
334 uint16_t wBadCharacter
335 )
336 {
337 typedef BOOL16 (TIGERFUN(*)fpTiger_ExtEdToText)(char* ,char*, uint16_t, uint16_t ,uint16_t );
338 fpTiger_ExtEdToText proc;
339
340 if(!hTiger || !Init)
341 return FALSE;
342
343 proc = (fpTiger_ExtEdToText)GetProcAddress(hTiger,TIGER_EXT_ED_2_TEXT_FN);
344
345 if(proc==NULL)
346 {
347 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
348 return FALSE;
349 }
350
351 return (*proc)(lpEdFileName,lpTextFileName,wOptions,wCodePage,wBadCharacter);
352 }
353 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
354 FNWORD Tiger_ProgressList (LPWORD lpList, uint16_t wMode)
355 {
356 typedef uint16_t (TIGERFUN(*)fpTiger_ProgressList) (LPWORD, uint16_t );
357 fpTiger_ProgressList proc;
358
359 if(!hTiger || !Init)
360 return FALSE;
361
362 proc = (fpTiger_ProgressList)GetProcAddress(hTiger,
363 TIGER_PROGRESS_LIST_FN);
364 if(proc==NULL)
365 {
366 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
367 return FALSE;
368 }
369
370 return (*proc)(lpList,wMode);
371 }
372 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
373 FNBOOL16 TigerLayout_GetPageIncline (LPINT16 lpnNumerator, LPINT16 lpnDenominator)
374 {
375 typedef BOOL16 (TIGERFUN(*)fpTigerLayout_GetPageIncline)(char* , char* );
376 fpTigerLayout_GetPageIncline proc;
377
378 if(!hTiger || !Init)
379 return FALSE;
380
381 proc = (fpTigerLayout_GetPageIncline)GetProcAddress(
382 hTiger,TIGER_LAY_GET_P_INCL_L_FN);
383 if(proc==NULL)
384 {
385 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
386 return FALSE;
387 }
388
389 return (*proc)((char*)lpnNumerator, (char*)lpnDenominator);
390 }
391 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
392 FNBOOL16 TigerLayout_UpdateBlocks (LPINT16 lpNumber,LPLPTIGER_LAYOUTBLOCK lplpBlocks)
393 {
394 typedef BOOL16 (TIGERFUN(*)fpTigerLayout_UpdateBlocks) (char* , char* );
395 fpTigerLayout_UpdateBlocks proc;
396
397 if(!hTiger || !Init)
398 return FALSE;
399
400 proc = (fpTigerLayout_UpdateBlocks)GetProcAddress(
401 hTiger,TIGER_LAY_UPD_BL_FN);
402 if(proc==NULL)
403 {
404 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
405 return FALSE;
406 }
407
408 return (*proc)((char*)lpNumber,(char*)lplpBlocks);
409 }
410 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
411 FNBOOL16 TigerLayout_HorzSplitBlocks
412 ( POINT w1, POINT w2, LPBOOL16 lpSuccess)
413 {
414 typedef BOOL16 (TIGERFUN(*)lpTigerLayout_HorzSplitBlocks)
415 (uint16_t ,uint16_t ,uint16_t ,uint16_t ,char* );
416 lpTigerLayout_HorzSplitBlocks proc;
417
418 if(!hTiger || !Init)
419 return FALSE;
420
421 proc = (lpTigerLayout_HorzSplitBlocks)GetProcAddress(
422 hTiger,TIGER_LAY_H_SP_BL_FN);
423 if(proc==NULL)
424 {
425 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
426 return FALSE;
427 }
428
429 return (*proc)((uint16_t)w1.x,(uint16_t)w1.y,(uint16_t)w2.x,(uint16_t)w2.y,(char*)lpSuccess);
430 }
431 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
432 FNBOOL16 TigerLayout_VertSplitBlocks
433 ( POINT w1,POINT w2, LPBOOL16 lpSuccess)
434 {
435 typedef BOOL16 (TIGERFUN(*)lpTigerLayout_VertSplitBlocks)
436 (uint16_t ,uint16_t ,uint16_t ,uint16_t ,char* );
437 lpTigerLayout_VertSplitBlocks proc;
438
439 if(!hTiger || !Init)
440 return FALSE;
441
442 proc = (lpTigerLayout_VertSplitBlocks)GetProcAddress(
443 hTiger,TIGER_LAY_V_SP_BL_FN);
444 if(proc==NULL)
445 {
446 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
447 return FALSE;
448 }
449
450
451 return (*proc)((uint16_t)w1.x,(uint16_t)w1.y,(uint16_t)w2.x,(uint16_t)w2.y,(char*)lpSuccess);
452 }
453 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
454 //
455 FNBOOL16 TigerLayout_ExtractRectBlock(RECT rect, LPBOOL16 lpSuccess)
456 {
457 uint16_t l,t,r,b;
458 typedef BOOL16 (TIGERFUN(*)fpTigerLayout_ExtractRectBlock)
459 (uint16_t ,uint16_t ,uint16_t ,uint16_t ,char* );
460 fpTigerLayout_ExtractRectBlock proc;
461
462 if(!hTiger || !Init)
463 return FALSE;
464
465 proc = (fpTigerLayout_ExtractRectBlock)GetProcAddress(
466 hTiger,TIGER_LAY_EXT_RECT_BL_FN);
467 if(proc==NULL)
468 {
469 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
470 return FALSE;
471 }
472 l=(uint16_t)rect.left;t=(uint16_t)rect.top;r=(uint16_t)rect.right;b=(uint16_t)rect.bottom;
473 /**
474 { char buf[256];
475 sprintf(buf, "ERB: %u %u %u %u", l,t,r,b);
476 OutputDebugString(buf);
477 }
478 **/
479 return (*proc)( l,t,r,b, (char*)lpSuccess);
480 }
481 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
482 //
483 FNBOOL16 TigerLayout_ExtractPicture (RECT rect,LPBOOL16 lpSuccess)
484 {
485 typedef BOOL16 (TIGERFUN(*)fpTigerLayout_ExtractPicture)
486 (uint16_t ,uint16_t ,uint16_t ,uint16_t ,char* );
487 fpTigerLayout_ExtractPicture proc;
488
489 if(!hTiger || !Init)
490 return FALSE;
491
492 proc = (fpTigerLayout_ExtractPicture)GetProcAddress(
493 hTiger,TIGER_LAY_EXT_PIC_FN);
494 if(proc==NULL)
495 {
496 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
497 return FALSE;
498 }
499
500
501 return (*proc)((uint16_t)rect.left,(uint16_t)rect.top,(uint16_t)rect.right,
502 (uint16_t)rect.bottom,(char*)lpSuccess);
503 }
504 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
505 //
506 FNBOOL16 TigerLayout_GlueBlocks (uint16_t iBlock1, uint16_t iBlock2,
507 LPBOOL16 lpSuccess)
508 {
509 typedef BOOL16 (TIGERFUN(*)fpTigerLayout_GlueBlocks) (uint16_t, uint16_t , char* );
510 fpTigerLayout_GlueBlocks proc;
511
512 if(!hTiger || !Init)
513 return FALSE;
514
515 proc = (fpTigerLayout_GlueBlocks)GetProcAddress(
516 hTiger,TIGER_LAY_GLUE_BL_FN);
517 if(proc==NULL)
518 {
519 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
520 return FALSE;
521 }
522
523 return (*proc)((uint16_t)iBlock1,(uint16_t)iBlock2,(char*)lpSuccess);
524 }
525 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
526 //
527 FNBOOL16 TigerLayout_DeleteBlock (uint16_t iBlock, LPBOOL16 lpSuccess)
528 {
529 typedef BOOL16 (TIGERFUN(*)fpTigerLayout_DeleteBlock) (uint16_t , char* );
530 fpTigerLayout_DeleteBlock proc;
531
532 if(!hTiger || !Init)
533 return FALSE;
534
535 proc = (fpTigerLayout_DeleteBlock)GetProcAddress(
536 hTiger,TIGER_LAY_DEL_BL_FN);
537 if(proc==NULL)
538 {
539 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
540 return FALSE;
541 }
542
543 return (*proc)((uint16_t)iBlock,(char*)lpSuccess);
544 }
545 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
546 //
547 FNBOOL16 TigerLayout_EnglishBlock (uint16_t iBlock, LPBOOL16 lpSuccess)
548 {
549 typedef BOOL16 (TIGERFUN(*)fpTigerLayout_EnglishBlock) (uint16_t , char* );
550 fpTigerLayout_EnglishBlock proc;
551
552 if(!hTiger || !Init)
553 return FALSE;
554
555 proc = (fpTigerLayout_EnglishBlock)GetProcAddress(
556 hTiger,TIGER_LAY_ENGL_BL_FN);
557 if(proc==NULL)
558 {
559 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
560 return FALSE;
561 }
562
563 return (*proc)((uint16_t)iBlock,(char*)lpSuccess);
564 }
565 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
566 //
567 FNBOOL16 TigerLayout_Backup (LPBOOL16 lpbError)
568 {
569 typedef BOOL16 (TIGERFUN(*)fpTigerLayout_Backup) (char* );
570 fpTigerLayout_Backup proc;
571
572 if(!hTiger || !Init)
573 return FALSE;
574
575 proc = (fpTigerLayout_Backup)GetProcAddress(
576 hTiger,TIGER_LAY_BACKUP_FN);
577
578 if(proc==NULL)
579 {
580 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
581 return FALSE;
582 }
583
584 return (*proc)((char*)lpbError);
585 }
586 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
587 //
588 FNBOOL16 TigerLayout_Undo (LPBOOL16 lpbError)
589 {
590 typedef BOOL16 (TIGERFUN(*)fpTigerLayout_Undo) (char* );
591 fpTigerLayout_Undo proc;
592
593 if(!hTiger || !Init)
594 return FALSE;
595
596 proc = (fpTigerLayout_Undo)GetProcAddress(
597 hTiger,TIGER_LAY_UNDO_FN);
598
599 if(proc==NULL)
600 {
601 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
602 return FALSE;
603 }
604
605 return (*proc)((char*)lpbError);
606 }
607 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
608 //
609 FNBOOL16 TigerLayout_Redo (LPBOOL16 lpbError)
610 {
611 typedef BOOL16 (TIGERFUN(*)fpTigerLayout_Redo) (char* );
612 fpTigerLayout_Redo proc;
613
614 if(!hTiger || !Init)
615 return FALSE;
616
617 proc = (fpTigerLayout_Redo)GetProcAddress(
618 hTiger,TIGER_LAY_REDO_FN);
619
620 if(proc==NULL)
621 {
622 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
623 return FALSE;
624 }
625
626 return (*proc)((char*)lpbError);
627 }
628 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
629 //
630 FNBOOL16 Tiger_SetLanguage(uint16_t lng)
631 {
632 typedef BOOL16 (TIGERFUN(*)fpTiger_SetLanguage)(uint16_t);
633 fpTiger_SetLanguage proc;
634
635 if(!hTiger || !Init)
636 return FALSE;
637
638 proc = (fpTiger_SetLanguage)GetProcAddress(hTiger,TIGER_SET_LANG_FN);
639 if(proc==NULL)
640 {
641 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
642 return FALSE;
643 }
644
645
646 return (*proc)(lng);
647 }
648 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
649 //
650 FNBOOL16 Tiger_OpenEdFile (char* lpFilename)
651 {
652 typedef BOOL16 (TIGERFUN(*)fpTiger_OpenEdFile) (char* );
653 fpTiger_OpenEdFile proc;
654
655 if(!hTiger || !Init)
656 return FALSE;
657
658 proc = (fpTiger_OpenEdFile)GetProcAddress(hTiger,
659 TIGER_OPEN_ED_FILE_FN);
660 return (*proc)(lpFilename);
661 }
662 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
663 //
664 FNBOOL16 Tiger_GetEdPage (LPED_PAGE lpEdPage)
665 {
666 typedef BOOL16 (TIGERFUN(*)fpTiger_GetEdPage) (char*);
667 fpTiger_GetEdPage proc;
668
669 if(!hTiger || !Init)
670 return FALSE;
671
672 proc = (fpTiger_GetEdPage)GetProcAddress(hTiger,TIGER_GET_ED_PAGE_FN);
673 if(proc==NULL)
674 {
675 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
676 return FALSE;
677 }
678
679 return (*proc)((char*)lpEdPage);
680 }
681 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
682 //
683 FNBOOL16 Tiger_GetEdFragment (uint16_t wFragmentID,
684 LPED_FRAGMENT lpEdFragment)
685 {
686 typedef BOOL16 (TIGERFUN(*)fpTiger_GetEdFragment) (uint16_t, char* );
687 fpTiger_GetEdFragment proc;
688
689 if(!hTiger || !Init)
690 return FALSE;
691
692 proc = (fpTiger_GetEdFragment)GetProcAddress(hTiger,TIGER_GET_ED_FRAG_FN);
693 if(proc==NULL)
694 {
695 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
696 return FALSE;
697 }
698
699 return (*proc)(wFragmentID,(char*)lpEdFragment);
700 }
701 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
702 //
703 FNBOOL16 Tiger_GetEdString (uint16_t wStringID,
704 LPED_STRING lpEdString)
705 {
706 typedef BOOL16 (TIGERFUN(*)fpTiger_GetEdString) (uint16_t, char* );
707 fpTiger_GetEdString proc;
708
709 if(!hTiger || !Init)
710 return FALSE;
711
712 proc = (fpTiger_GetEdString)GetProcAddress(hTiger,
713 TIGER_GET_ED_STR_FN);
714 if(proc==NULL)
715 {
716 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
717 return FALSE;
718 }
719
720
721 return (*proc)(wStringID,(char*) lpEdString);
722 }
723
724 FNBOOL16 Tiger_GetEdWord (uint16_t wWordID,LPED_WORD lpEdWord)
725 {
726 typedef BOOL16 (TIGERFUN(*)fpTiger_GetEdWord) (uint16_t, char* );
727 fpTiger_GetEdWord proc;
728
729 if(!hTiger || !Init)
730 return FALSE;
731
732 proc = (fpTiger_GetEdWord)GetProcAddress(hTiger,TIGER_GET_ED_WORD_FN);
733 if(proc==NULL)
734 {
735 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
736 return FALSE;
737 }
738
739 return (*proc)(wWordID,(char*)lpEdWord);
740 }
741 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
742 //
743 FNBOOL16 Tiger_GetEdCharacter (uint16_t wCharacterID,
744 LPED_CHARACTER lpEdCharacter)
745 {
746 typedef BOOL16 (TIGERFUN(*)fpTiger_GetEdCharacter) (uint16_t , char* );
747 fpTiger_GetEdCharacter proc;
748
749 if(!hTiger || !Init)
750 return FALSE;
751
752 proc = (fpTiger_GetEdCharacter)GetProcAddress(hTiger,TIGER_GET_ED_CHAR_FN);
753 if(proc==NULL)
754 {
755 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
756 return FALSE;
757 }
758
759 return (*proc)(wCharacterID,(char*)lpEdCharacter);
760 }
761 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
762 //
763 FNBOOL16 Tiger_CloseEdFile (void)
764 {
765 typedef BOOL16 (TIGERFUN(*)fpTiger_CloseEdFile) (void);
766 fpTiger_CloseEdFile proc;
767
768 if(!hTiger || !Init)
769 return FALSE;
770
771 proc = (fpTiger_CloseEdFile)GetProcAddress(hTiger,
772 TIGER_CLOSE_ED_FILE_FN);
773 if(proc==NULL)
774 {
775 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
776 return FALSE;
777 }
778
779 return (*proc)();
780 }
781 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
782 //
783 FNBOOL16 Tiger_SetEdSaveRtfOptions (
784 uint16_t wFrame,
785 char* lpNameSerif,
786 char* lpNameNonSerif,
787 char* lpNameMono,
788 char* lpSerif,
789 char* lpNonSerif,
790 char* lpMono
791 )
792 {
793 typedef BOOL16 (TIGERFUN(*)fpTiger_SetEdSaveRtfOptions) (
794 uint16_t ,char* ,char* ,char* ,char* ,char* ,char*);
795 fpTiger_SetEdSaveRtfOptions proc;
796 if(!hTiger || !Init)
797 return FALSE;
798
799 proc = (fpTiger_SetEdSaveRtfOptions)GetProcAddress(
800 hTiger,TIGER_SET_ED_SAV_RTF_OPT_FN);
801
802 if(proc==NULL)
803 {
804 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
805 return FALSE;
806 }
807
808 return (*proc)(wFrame,lpNameSerif,lpNameNonSerif,
809 lpNameMono,lpSerif,lpNonSerif,lpMono);
810 }
811 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
812 //
813 FNBOOL16 TigerLayout_UpdateSheets (uint16_t FuncNumber, LPINT16 * lplpSheets)
814 {
815 typedef BOOL16 (TIGERFUN(*)fpTigerLayout_UpdateSheets) (uint16_t, char* );
816 fpTigerLayout_UpdateSheets proc;
817
818 if(!hTiger || !Init)
819 return FALSE;
820
821 proc = (fpTigerLayout_UpdateSheets)GetProcAddress(
822 hTiger,TIGER_LAY_UPD_SHEETS_FN);
823 if(proc==NULL)
824 {
825 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
826 return FALSE;
827 }
828
829 return (*proc)(FuncNumber,(char*)lplpSheets);
830 }
831 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
832 //
833 FNBOOL16 Tiger_RW_Options (uint16_t FuncNumber, char* lpData)
834 {
835 typedef BOOL16 (TIGERFUN(*)fpTiger_RW_Options) (uint16_t, char* );
836 fpTiger_RW_Options proc;
837
838 if(!hTiger || !Init)
839 return FALSE;
840
841 proc = (fpTiger_RW_Options)GetProcAddress(hTiger,
842 TIGER_RW_OPTIONS_FN);
843 if(proc==NULL)
844 {
845 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
846 return FALSE;
847 }
848
849
850 return (*proc)(FuncNumber,lpData);
851 }
852 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
853 //
854 FNBOOL16 Tiger_Load (HANDLE hApplicationInstance, char* lpTigerPathName)
855 {
856 char TigerFileName[256];
857
858 MESSAGE ("_Tiger_Load");
859
860 hApplicationInstance=hApplicationInstance;
861
862 if(Init)
863 return Init;
864
865 if((strlen(lpTigerPathName)+strlen(TIGERNAME))>=256)
866 return FALSE;
867
868 if(lpTigerPathName)
869 {
870 strcpy(TigerFileName,lpTigerPathName);
871 strcat(TigerFileName,TIGERNAME);
872 }
873 else
874 strcpy(TigerFileName,TIGERNAME);
875
876 hTiger = LoadLibrary(TigerFileName);
877
878 if(hTiger==NULL)
879 return FALSE;
880
881 Init = __Tiger_Load (Tiger_CallBack, lpTigerPathName);
882
883 return Init;
884 }
885 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
886 //
887 FNBOOL16 BCR_Load (HANDLE hApplicationInstance, char* lpTigerPathName)
888 {
889 char TigerFileName[256];
890
891 MESSAGE ("BCR_Load");
892 hApplicationInstance=hApplicationInstance;
893
894 if(Init)
895 return Init;
896
897 if((strlen(lpTigerPathName)+strlen(TIGERNAME))>=256)
898 return FALSE;
899
900 if(lpTigerPathName)
901 {
902 strcpy(TigerFileName,lpTigerPathName);
903 strcat(TigerFileName,TIGERNAME);
904 }
905 else
906 strcpy(TigerFileName,TIGERNAME);
907
908 hTiger = LoadLibrary(TigerFileName);
909
910 if(hTiger==NULL)
911 return FALSE;
912
913 Init = __BCR_Load (Tiger_CallBack, lpTigerPathName);
914
915 return Init;
916 }
917 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
918 //
919 FNBOOL16 Tiger_Unload (void)
920 {
921 BOOL16 ret = FALSE;
922
923 MESSAGE ("Tiger_Unload");
924
925 if(hTiger)
926 {
927 ret = FreeLibrary(hTiger);
928 if(hTiger) hTiger = NULL;
929 if(ret) Init = FALSE;
930 }
931
932 return ret;
933 }
934 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
935 //Call Back entries
936 CBDWORD Tiger_CallBack (uint16_t wFuncNumber, LPDWORD lpParams)
937 {
938 switch (wFuncNumber)
939 {
940 default:
941 return ((uint32_t) 0);
942
943 case TCB_IMAGE_OPEN_XY:
944 return ((uint32_t) Tiger_Callback_ImageOpen_xy
945 (
946 (LPTIGER_IMAGEINFO) lpParams [0],
947 (uint16_t) lpParams [1],
948 (uint16_t) lpParams [2],
949 (uint16_t) lpParams [3],
950 (uint16_t) lpParams [4]
951 ));
952 case TCB_PROCESS_PICTURES: // Valdemar
953 return ((uint32_t) Tiger_Callback_ProcessPictures
954 (
955 (char*) lpParams [0],
956 (uint32_t) lpParams [1]
957 ));
958
959 case TCB_IMAGE_OPEN:
960 return ((uint32_t) Tiger_Callback_ImageOpen
961 (
962 (LPTIGER_IMAGEINFO) lpParams [0]
963 ));
964
965 case TCB_IMAGE_READ:
966 return ((uint32_t) Tiger_Callback_ImageRead
967 (
968 (char*) lpParams [0],
969 (uint16_t) lpParams [1]
970 ));
971
972 case TCB_IMAGE_CLOSE:
973 return ((uint32_t) Tiger_Callback_ImageClose ());
974
975 case TCB_REPORT_ERROR:
976 Tiger_Callback_ReportError ((uint16_t) lpParams [0], (char*) lpParams [1]);
977 return ((uint32_t) TRUE);
978
979 case TCB_PROGRESS_START:
980 return ((uint32_t) Tiger_Callback_ProgressStart ());
981
982 case TCB_PROGRESS_FINISH:
983 return ((uint32_t) Tiger_Callback_ProgressFinish ());
984
985 case TCB_PROGRESS_SET_PERCENTAGE:
986 return ((uint32_t) Tiger_Callback_ProgressSetPerc ((uint16_t) lpParams [0]));
987
988 case TCB_PROGRESS_SET_STAGE:
989 return ((uint32_t) Tiger_Callback_ProgressSetStage
990 (
991 (uint16_t) lpParams [0],
992 (char*) lpParams [1],
993 (uint16_t) lpParams [2]
994 ));
995 case TCB_TIGER_GET_WORD:
996 return ((uint32_t) Tiger_Callback_Get_One_Word( (char*) lpParams[0] ));
997 }
998 }
999 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
1000 //
1001 FNWORD Tiger_GetLanguage()
1002 {
1003 typedef uint16_t (TIGERFUN(*)fpTiger_GetLanguage)();
1004 fpTiger_GetLanguage proc;
1005
1006 if(!hTiger || !Init)
1007 return (uint16_t)-1;
1008
1009 proc = (fpTiger_GetLanguage)GetProcAddress(hTiger,
1010 TIGER_GET_LANG_FN);
1011 if(proc==NULL)
1012 {
1013 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
1014 return (uint16_t)-1;
1015 }
1016
1017 return (*proc)();
1018 }
1019 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
1020 //
1021 FNWORD Tiger_EnumLanguage(uint16_t prev)
1022 {
1023 typedef uint16_t (TIGERFUN(*)fpTiger_EnumLanguage)(uint16_t);
1024 fpTiger_EnumLanguage proc;
1025
1026 if(!hTiger || !Init)
1027 return (uint16_t)-1;
1028
1029 proc = (fpTiger_EnumLanguage)GetProcAddress(hTiger,
1030 TIGER_ENUM_LANG_FN);
1031 if(proc==NULL)
1032 {
1033 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
1034 return (uint16_t)-1;
1035 }
1036
1037 return (*proc)(prev);
1038 }
1039 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
1040 //
1041 FNBOOL Tiger_SpellerExist(uint16_t language)
1042 {
1043 typedef Bool (TIGERFUN(*)fpTiger_SpellerExist)(uint16_t);
1044 fpTiger_SpellerExist proc;
1045
1046 if(!hTiger || !Init)
1047 return (uint16_t)-1;
1048
1049 proc = (fpTiger_SpellerExist)GetProcAddress(hTiger,
1050 TIGER_SPELL_EXIST_FN);
1051 if(proc==NULL)
1052 {
1053 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
1054 return FALSE;
1055 }
1056
1057 return (*proc)(language);
1058 }
1059 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
1060 //
1061 FNBOOL16 Tiger_RunWithDIB( void * lpDIB, void * lpRes )
1062 {
1063 typedef Bool (TIGERFUN(*)fpTigerRunWithDIB)(void *, void *);
1064 fpTigerRunWithDIB proc;
1065
1066 if ( !hTiger || !Init )
1067 return (uint16_t) -1;
1068
1069 proc = (fpTigerRunWithDIB)GetProcAddress(hTiger,
1070 TIGER_RUN_WITH_DIB_FN);
1071
1072 if ( proc == NULL )
1073 {
1074 Tiger_SetStatus(ST_ENTRY_NOT_FOUND);
1075 return FALSE;
1076 }
1077
1078 return (*proc)(lpDIB, lpRes);
1079 }
1080 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1081 //end of file