← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/hdebug/__snp.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/hdebug/__snp.c
1
1
/*
2
 
Copyright (c) 1993-2008, Cognitive Technologies
3
 
All rights reserved.
4
 
 
5
 
����������� ��������� ��������������� � ������������� ��� � ���� ��������� ����,
6
 
��� � � �������� �����, � ����������� ��� ���, ��� ���������� ��������� �������:
7
 
 
8
 
      * ��� ��������� ��������������� ��������� ���� ������ ���������� ���������
9
 
        ���� ����������� �� ��������� �����, ���� ������ ������� � �����������
10
 
        ����� �� ��������.
11
 
      * ��� ��������� ��������������� ��������� ���� � ������������ �/��� �
12
 
        ������ ����������, ������������ ��� ���������������, ������ �����������
13
 
        ��������� ���� ���������� �� ��������� �����, ���� ������ ������� �
14
 
        ����������� ����� �� ��������.
15
 
      * �� �������� Cognitive Technologies, �� ����� �� ����������� �� �����
16
 
        ���� ������������ � �������� �������� ��������� �/��� �����������
17
 
        ���������, ���������� �� ���� ��, ��� ���������������� �����������
18
 
        ����������.
19
 
 
20
 
��� ��������� ������������� ����������� ��������� ���� �/��� ������� ������ "���
21
 
��� ����" ��� ������-���� ���� ��������, ���������� ���� ��� ���������������,
22
 
������� �������� ������������ �������� � ����������� ��� ���������� ����, �� ��
23
 
������������� ���. �� �������� ��������� ���� � �� ���� ������ ����, �������
24
 
����� �������� �/��� �������� �������������� ���������, �� � ���� ������ ��
25
 
��Ѩ� ���������������, ������� ����� �����, ���������, ����������� ���
26
 
������������� ������, ��������� � �������������� ��� ���������� ����������
27
 
������������� ������������� ��������� (������� ������ ������, ��� ������,
28
 
������� ���������, ��� ������ �/��� ������ �������, ���������� ��-�� ��������
29
 
������� ��� �/��� ������ ��������� �������� ��������� � ������� �����������,
30
 
�� �� ������������� ����� ��������), �� �� ������������� ���, ���� ���� �����
31
 
�������� ��� ������ ���� ���� �������� � ����������� ����� ������� � ������.
32
 
 
33
 
Redistribution and use in source and binary forms, with or without modification,
34
 
are permitted provided that the following conditions are met:
35
 
 
36
 
    * Redistributions of source code must retain the above copyright notice,
37
 
      this list of conditions and the following disclaimer.
38
 
    * Redistributions in binary form must reproduce the above copyright notice,
39
 
      this list of conditions and the following disclaimer in the documentation
40
 
      and/or other materials provided with the distribution.
41
 
    * Neither the name of the Cognitive Technologies nor the names of its
42
 
      contributors may be used to endorse or promote products derived from this
43
 
      software without specific prior written permission.
44
 
 
45
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
46
 
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
47
 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48
 
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
49
 
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50
 
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
51
 
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
52
 
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
53
 
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
54
 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
55
 
*/
 
2
 Copyright (c) 1993-2008, Cognitive Technologies
 
3
 All rights reserved.
 
4
 
 
5
 Разрешается повторное распространение и использование как в виде исходного кода,
 
6
 так и в двоичной форме, с изменениями или без, при соблюдении следующих условий:
 
7
 
 
8
 * При повторном распространении исходного кода должны оставаться указанное
 
9
 выше уведомление об авторском праве, этот список условий и последующий
 
10
 отказ от гарантий.
 
11
 * При повторном распространении двоичного кода в документации и/или в
 
12
 других материалах, поставляемых при распространении, должны сохраняться
 
13
 указанная выше информация об авторском праве, этот список условий и
 
14
 последующий отказ от гарантий.
 
15
 * Ни название Cognitive Technologies, ни имена ее сотрудников не могут
 
16
 быть использованы в качестве средства поддержки и/или продвижения
 
17
 продуктов, основанных на этом ПО, без предварительного письменного
 
18
 разрешения.
 
19
 
 
20
 ЭТА ПРОГРАММА ПРЕДОСТАВЛЕНА ВЛАДЕЛЬЦАМИ АВТОРСКИХ ПРАВ И/ИЛИ ДРУГИМИ ЛИЦАМИ "КАК
 
21
 ОНА ЕСТЬ" БЕЗ КАКОГО-ЛИБО ВИДА ГАРАНТИЙ, ВЫРАЖЕННЫХ ЯВНО ИЛИ ПОДРАЗУМЕВАЕМЫХ,
 
22
 ВКЛЮЧАЯ ГАРАНТИИ КОММЕРЧЕСКОЙ ЦЕННОСТИ И ПРИГОДНОСТИ ДЛЯ КОНКРЕТНОЙ ЦЕЛИ, НО НЕ
 
23
 ОГРАНИЧИВАЯСЬ ИМИ. НИ ВЛАДЕЛЕЦ АВТОРСКИХ ПРАВ И НИ ОДНО ДРУГОЕ ЛИЦО, КОТОРОЕ
 
24
 МОЖЕТ ИЗМЕНЯТЬ И/ИЛИ ПОВТОРНО РАСПРОСТРАНЯТЬ ПРОГРАММУ, НИ В КОЕМ СЛУЧАЕ НЕ
 
25
 НЕСЁТ ОТВЕТСТВЕННОСТИ, ВКЛЮЧАЯ ЛЮБЫЕ ОБЩИЕ, СЛУЧАЙНЫЕ, СПЕЦИАЛЬНЫЕ ИЛИ
 
26
 ПОСЛЕДОВАВШИЕ УБЫТКИ, СВЯЗАННЫЕ С ИСПОЛЬЗОВАНИЕМ ИЛИ ПОНЕСЕННЫЕ ВСЛЕДСТВИЕ
 
27
 НЕВОЗМОЖНОСТИ ИСПОЛЬЗОВАНИЯ ПРОГРАММЫ (ВКЛЮЧАЯ ПОТЕРИ ДАННЫХ, ИЛИ ДАННЫЕ,
 
28
 СТАВШИЕ НЕГОДНЫМИ, ИЛИ УБЫТКИ И/ИЛИ ПОТЕРИ ДОХОДОВ, ПОНЕСЕННЫЕ ИЗ-ЗА ДЕЙСТВИЙ
 
29
 ТРЕТЬИХ ЛИЦ И/ИЛИ ОТКАЗА ПРОГРАММЫ РАБОТАТЬ СОВМЕСТНО С ДРУГИМИ ПРОГРАММАМИ,
 
30
 НО НЕ ОГРАНИЧИВАЯСЬ ЭТИМИ СЛУЧАЯМИ), НО НЕ ОГРАНИЧИВАЯСЬ ИМИ, ДАЖЕ ЕСЛИ ТАКОЙ
 
31
 ВЛАДЕЛЕЦ ИЛИ ДРУГОЕ ЛИЦО БЫЛИ ИЗВЕЩЕНЫ О ВОЗМОЖНОСТИ ТАКИХ УБЫТКОВ И ПОТЕРЬ.
 
32
 
 
33
 Redistribution and use in source and binary forms, with or without modification,
 
34
 are permitted provided that the following conditions are met:
 
35
 
 
36
 * Redistributions of source code must retain the above copyright notice,
 
37
 this list of conditions and the following disclaimer.
 
38
 * Redistributions in binary form must reproduce the above copyright notice,
 
39
 this list of conditions and the following disclaimer in the documentation
 
40
 and/or other materials provided with the distribution.
 
41
 * Neither the name of the Cognitive Technologies nor the names of its
 
42
 contributors may be used to endorse or promote products derived from this
 
43
 software without specific prior written permission.
 
44
 
 
45
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
46
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
47
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
48
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 
49
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
50
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
51
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 
52
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 
53
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
54
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
55
 */
56
56
 
57
57
/*#include <windows.h>*/
58
58
/*#include <crtdbg.h>*/
62
62
 
63
63
#define __SNAP_C
64
64
 
65
 
 
66
65
#include "dpuma.h"
67
66
 
68
67
#include "compat_defs.h"
70
69
#ifdef __cplusplus
71
70
extern "C" {
72
71
#endif
73
 
HINSTANCE hDPuma = NULL;
74
 
 
75
 
static FNDPUMA_Init                     Init = NULL;
76
 
static FNDPUMA_Done                     Done = NULL;
77
 
static FNDPUMA_SetImportData SetImportData = NULL;
78
 
static FNDPUMA_GetExportData GetExportData = NULL;
79
 
 
80
 
 
81
 
//static FNDPUMA_CreateSnap,
82
 
//static FNDPUMA_DestroySnap,
83
 
static FNDPUMA_CreateSnap               CreateSnap = NULL;
84
 
static FNDPUMA_DestroySnap              DestroySnap= NULL;
85
 
static FNDPUMA_Console                  Console = NULL;
86
 
static FNDPUMA_StatusLine               StatusLine = NULL;
87
 
static FNDPUMA_Stop                             Stop = NULL;
88
 
static FNDPUMA_IsActive                 IsActive = NULL;
89
 
static FNDPUMA_Registry                 Registry = NULL;
90
 
static FNDPUMA_Skip                             Skip = NULL;
91
 
static FNDPUMA_StartLoop                StartLoop = NULL;
92
 
static FNDPUMA_LoopNext                 LoopNext = NULL;
93
 
static FNDPUMA_CreateWindow             fCreateWindow = NULL;
94
 
static FNDPUMA_MessageBoxOk             MessageBoxOk = NULL;
95
 
static FNDPUMA_MessageBoxYesNo  MessageBoxYesNo = NULL;
96
 
static FNDPUMA_WaitUserInput    WaitUserInput = NULL;
97
 
static FNDPUMA_DrawLine                 DrawLine = NULL;
98
 
static FNDPUMA_DrawRect                 DrawRect = NULL;
99
 
static FNDPUMA_DrawLineTip              DrawLineTip = NULL;
100
 
static FNDPUMA_DrawRectTip              DrawRectTip = NULL;
101
 
static FNDPUMA_DeleteRects              DeleteRects = NULL;
102
 
static FNDPUMA_DeleteLines              DeleteLines = NULL;
103
 
static FNDPUMA_GetUserPoint             GetUserPoint = NULL;
104
 
static FNDPUMA_GetUserRect              GetUserRect = NULL;
105
 
static FNDPUMA_UpdateView               UpdateView = NULL;
106
 
static FNDPUMA_DrawRaster               DrawRaster = NULL;
107
 
static FNDPUMA_RasterText               RasterText = NULL;
108
 
static FNDPUMA_ZoomToRect               ZoomToRect = NULL;
109
 
static FNDPUMA_RasterHeader             RasterHeader = NULL;
110
 
static FNDPUMA_DrawFocusRect    fnDrawFocusRect = NULL;
111
 
static FNDPUMA_RegVariable          RegVariable = NULL;
112
 
static FNDPUMA_UnregVariable    UnregVariable = NULL;
113
 
static FNDPUMA_GetDIBptr                GetDIBptr = NULL;
114
 
static FNDPUMA_DrawString               DrawString = NULL;
115
 
static FNDPUMA_DeleteStrings    DeleteStrings = NULL;
116
 
static FNDPUMA_SetCallbackWindowProc SetCallbackWindowProc = NULL;
117
 
static FNDPUMA_DeviceToImage    DeviceToImage = NULL;
118
 
static FNDPUMA_ImageToDevice    ImageToDevice = NULL;
119
 
static FNDPUMA_SetCallbackMainFrameWindowProc SetCallbackMainFrameWindowProc = NULL;
120
 
static FNDPUMA_DestroyWindow    fDestroyWindow = NULL;
121
 
static FNDPUMA_SendWindow               SendWindow = NULL;
122
 
static FNDPUMA_SendMainWnd              SendMainWnd = NULL;
123
 
static FNDPUMA_CSTR_Monitor             cstr_Monitor = NULL;
124
 
static FNDPUMA_CSTR_GetPosition cstr_GetPosition = NULL;
125
 
static FNDPUMA_CSTR_SetPosition cstr_SetPosition = NULL;
126
 
static FNDPUMA_DestroyRasterWnd DestroyRasterWnd = NULL;
127
 
static FNDPUMA_CSTR_GetLength   cstr_GetLength = NULL;
128
 
static FNDPUMA_ShowCutPoint             ShowCutPoint = NULL;
129
 
static FNDPUMA_GetRasterPixel   GetRasterPixel = NULL;
130
 
static FNDPUMA_CSTR_Update              cstr_Update = NULL;
131
 
static FNDPUMA_SkipEx               SkipEx = NULL;
132
 
static FNDPUMA_OpenFile                 fOpenFile = NULL;
133
 
static FNDPUMA_GetFileName              fGetFileName = NULL;
134
 
static FNDPUMA_HandLayout               fHandLayout = NULL;
135
 
static FNDPUMA_LockImage                fLockImage = NULL;
136
 
static FNDPUMA_RegistryHelp             RegistryHelp = NULL;
137
 
static FNDPUMA_SaveFile                 fSaveFile = NULL;
138
 
static FNDPUMA_ProgressStart    fProgressStart = NULL;
139
 
static FNDPUMA_ProgressFinish   fProgressFinish = NULL;
140
 
static FNDPUMA_ProgressStep             fProgressStep = NULL;
141
 
static FNDPUMA_SetConsoleProperty fSetConsoleProperty = NULL;
142
 
static FNDPUMA_CreateHistogramm fCreateHistogramm = NULL;
143
 
static FNDPUMA_AddPointToHistogramm fAddPointToHistogramm = NULL;
144
 
static FNDPUMA_DoHistogramm fDoHistogramm  = NULL;
145
 
static FNDPUMA_DestroyHistogramm fDestroyHistogramm = NULL;
146
 
static FNDPUMA_GetWindowHandle fGetWindowHandle = NULL;
147
 
static FNDPUMA_GetPrevSkipOwner fGetPrevSkipOwner = NULL;
148
 
static FNDPUMA_AllocHook                fAllocHook = NULL;
149
 
static _CRT_ALLOC_HOOK PrevAllocHook = NULL;
150
 
static FNDPUMA_ConsoleClear             fConsoleClear=NULL;
151
 
static FNDPUMA_ConsoleGetCurLine fConsoleGetCurLine=NULL;
152
 
static FNDPUMA_SetFileName fSetFileName = NULL;
153
 
static FNDPUMA_FOpen    fFOpen = NULL;
154
 
static FNDPUMA_FClose   fFClose=NULL;
155
 
static FNDPUMA_FPrintf1024      fFPrintf1024=NULL;
156
 
static FNDPUMA_FPuts    fFPuts = NULL;
157
 
 
158
 
static Handle hWriteFile = NULL;
159
 
//////////////////////////////////////////////
160
 
static int __DPUMA__AllocHook__( int allocType, void *userData, size_t size, int blockType,
161
 
   long requestNumber, const unsigned char *filename, int lineNumber)
162
 
{
163
 
        Word32 prevSize = 0;
164
 
        int rc = PrevAllocHook(allocType,userData,size,blockType,
165
 
                                                        requestNumber, filename, lineNumber);
166
 
        if(fAllocHook && rc > 0) // ���� rc ������ ����, ����� �� ��� ��������
 
72
        HINSTANCE hDPuma = NULL;
 
73
 
 
74
        static FNDPUMA_Init Init = NULL;
 
75
        static FNDPUMA_Done Done = NULL;
 
76
        static FNDPUMA_SetImportData SetImportData = NULL;
 
77
        static FNDPUMA_GetExportData GetExportData = NULL;
 
78
 
 
79
        //static FNDPUMA_CreateSnap,
 
80
        //static FNDPUMA_DestroySnap,
 
81
        static FNDPUMA_CreateSnap CreateSnap = NULL;
 
82
        static FNDPUMA_DestroySnap DestroySnap= NULL;
 
83
        static FNDPUMA_Console Console = NULL;
 
84
        static FNDPUMA_StatusLine StatusLine = NULL;
 
85
        static FNDPUMA_Stop Stop = NULL;
 
86
        static FNDPUMA_IsActive IsActive = NULL;
 
87
        static FNDPUMA_Registry Registry = NULL;
 
88
        static FNDPUMA_Skip Skip = NULL;
 
89
        static FNDPUMA_StartLoop StartLoop = NULL;
 
90
        static FNDPUMA_LoopNext LoopNext = NULL;
 
91
        static FNDPUMA_CreateWindow fCreateWindow = NULL;
 
92
        static FNDPUMA_MessageBoxOk MessageBoxOk = NULL;
 
93
        static FNDPUMA_MessageBoxYesNo MessageBoxYesNo = NULL;
 
94
        static FNDPUMA_WaitUserInput WaitUserInput = NULL;
 
95
        static FNDPUMA_DrawLine DrawLine = NULL;
 
96
        static FNDPUMA_DrawRect DrawRect = NULL;
 
97
        static FNDPUMA_DrawLineTip DrawLineTip = NULL;
 
98
        static FNDPUMA_DrawRectTip DrawRectTip = NULL;
 
99
        static FNDPUMA_DeleteRects DeleteRects = NULL;
 
100
        static FNDPUMA_DeleteLines DeleteLines = NULL;
 
101
        static FNDPUMA_GetUserPoint GetUserPoint = NULL;
 
102
        static FNDPUMA_GetUserRect GetUserRect = NULL;
 
103
        static FNDPUMA_UpdateView UpdateView = NULL;
 
104
        static FNDPUMA_DrawRaster DrawRaster = NULL;
 
105
        static FNDPUMA_RasterText RasterText = NULL;
 
106
        static FNDPUMA_ZoomToRect ZoomToRect = NULL;
 
107
        static FNDPUMA_RasterHeader RasterHeader = NULL;
 
108
        static FNDPUMA_DrawFocusRect fnDrawFocusRect = NULL;
 
109
        static FNDPUMA_RegVariable RegVariable = NULL;
 
110
        static FNDPUMA_UnregVariable UnregVariable = NULL;
 
111
        static FNDPUMA_GetDIBptr GetDIBptr = NULL;
 
112
        static FNDPUMA_DrawString DrawString = NULL;
 
113
        static FNDPUMA_DeleteStrings DeleteStrings = NULL;
 
114
        static FNDPUMA_SetCallbackWindowProc SetCallbackWindowProc = NULL;
 
115
        static FNDPUMA_DeviceToImage DeviceToImage = NULL;
 
116
        static FNDPUMA_ImageToDevice ImageToDevice = NULL;
 
117
        static FNDPUMA_SetCallbackMainFrameWindowProc SetCallbackMainFrameWindowProc = NULL;
 
118
        static FNDPUMA_DestroyWindow fDestroyWindow = NULL;
 
119
        static FNDPUMA_SendWindow SendWindow = NULL;
 
120
        static FNDPUMA_SendMainWnd SendMainWnd = NULL;
 
121
        static FNDPUMA_CSTR_Monitor cstr_Monitor = NULL;
 
122
        static FNDPUMA_CSTR_GetPosition cstr_GetPosition = NULL;
 
123
        static FNDPUMA_CSTR_SetPosition cstr_SetPosition = NULL;
 
124
        static FNDPUMA_DestroyRasterWnd DestroyRasterWnd = NULL;
 
125
        static FNDPUMA_CSTR_GetLength cstr_GetLength = NULL;
 
126
        static FNDPUMA_ShowCutPoint ShowCutPoint = NULL;
 
127
        static FNDPUMA_GetRasterPixel GetRasterPixel = NULL;
 
128
        static FNDPUMA_CSTR_Update cstr_Update = NULL;
 
129
        static FNDPUMA_SkipEx SkipEx = NULL;
 
130
        static FNDPUMA_OpenFile fOpenFile = NULL;
 
131
        static FNDPUMA_GetFileName fGetFileName = NULL;
 
132
        static FNDPUMA_HandLayout fHandLayout = NULL;
 
133
        static FNDPUMA_LockImage fLockImage = NULL;
 
134
        static FNDPUMA_RegistryHelp RegistryHelp = NULL;
 
135
        static FNDPUMA_SaveFile fSaveFile = NULL;
 
136
        static FNDPUMA_ProgressStart fProgressStart = NULL;
 
137
        static FNDPUMA_ProgressFinish fProgressFinish = NULL;
 
138
        static FNDPUMA_ProgressStep fProgressStep = NULL;
 
139
        static FNDPUMA_SetConsoleProperty fSetConsoleProperty = NULL;
 
140
        static FNDPUMA_CreateHistogramm fCreateHistogramm = NULL;
 
141
        static FNDPUMA_AddPointToHistogramm fAddPointToHistogramm = NULL;
 
142
        static FNDPUMA_DoHistogramm fDoHistogramm = NULL;
 
143
        static FNDPUMA_DestroyHistogramm fDestroyHistogramm = NULL;
 
144
        static FNDPUMA_GetWindowHandle fGetWindowHandle = NULL;
 
145
        static FNDPUMA_GetPrevSkipOwner fGetPrevSkipOwner = NULL;
 
146
        static FNDPUMA_AllocHook fAllocHook = NULL;
 
147
        static _CRT_ALLOC_HOOK PrevAllocHook = NULL;
 
148
        static FNDPUMA_ConsoleClear fConsoleClear=NULL;
 
149
        static FNDPUMA_ConsoleGetCurLine fConsoleGetCurLine=NULL;
 
150
        static FNDPUMA_SetFileName fSetFileName = NULL;
 
151
        static FNDPUMA_FOpen fFOpen = NULL;
 
152
        static FNDPUMA_FClose fFClose=NULL;
 
153
        static FNDPUMA_FPrintf1024 fFPrintf1024=NULL;
 
154
        static FNDPUMA_FPuts fFPuts = NULL;
 
155
 
 
156
        static Handle hWriteFile = NULL;
 
157
        //////////////////////////////////////////////
 
158
        static int __DPUMA__AllocHook__( int allocType, void *userData, size_t size, int blockType,
 
159
                        long requestNumber, const unsigned char *filename, int lineNumber)
167
160
        {
 
161
                uint32_t prevSize = 0;
 
162
                int rc = PrevAllocHook(allocType,userData,size,blockType,
 
163
                                requestNumber, filename, lineNumber);
 
164
                if(fAllocHook && rc > 0) // Если rc меньше нуля, тогда мы уже работали
 
165
                {
168
166
#ifdef _DEBUG
169
 
                if(userData)
 
167
                        if(userData)
170
168
                        prevSize = _msize_dbg(userData,blockType);
171
169
#endif
172
 
                if(LDPUMA_IsActive())
 
170
                        if(LDPUMA_IsActive())
173
171
                        rc = fAllocHook(allocType,userData,size,prevSize,blockType,
174
 
                                                                requestNumber,(PWord8)filename, lineNumber);
 
172
                                        requestNumber,(puchar)filename, lineNumber);
 
173
                }
 
174
                return rc;
175
175
        }
176
 
        return rc;
177
 
}
178
176
 
179
 
//////////////////////////////////////////////
180
 
Bool32   LDPUMA_Init(Word16 wHightCode, Handle hStorage)
181
 
{
182
 
Bool32 rc = FALSE;
 
177
        //////////////////////////////////////////////
 
178
        Bool32 LDPUMA_Init(uint16_t wHightCode, Handle hStorage)
 
179
        {
 
180
                Bool32 rc = FALSE;
183
181
#ifdef _DEBUG
184
 
        _CrtDbgReport( _CRT_WARN,NULL,__LINE__,__FILE__,
185
 
                "LDPUMA_Init(%i,%x)\n",wHightCode, hStorage);
 
182
                _CrtDbgReport( _CRT_WARN,NULL,__LINE__,__FILE__,
 
183
                                "LDPUMA_Init(%i,%x)\n",wHightCode, hStorage);
186
184
#endif
187
 
        hDPuma = LoadLibrary("DPUMA.DLL");
188
 
        if(hDPuma)
189
 
        {
190
 
                Init = (FNDPUMA_Init)GetProcAddress(hDPuma,"DPUMA_Init");
191
 
                Done = (FNDPUMA_Done)GetProcAddress(hDPuma,"DPUMA_Done");
192
 
                GetExportData = (FNDPUMA_GetExportData)GetProcAddress(hDPuma,"DPUMA_GetExportData");
193
 
                SetImportData = (FNDPUMA_SetImportData)GetProcAddress(hDPuma,"DPUMA_SetImportData"); //tanya
194
 
        }
195
 
        if(Init && GetExportData)
196
 
        {
197
 
                if(GetExportData(DPUMA_FNDPUMA_Console,&Console)&&
198
 
                        GetExportData(DPUMA_FNDPUMA_CreateSnap,&CreateSnap)&&
199
 
                        GetExportData(DPUMA_FNDPUMA_DestroySnap,&DestroySnap)&&
200
 
                        GetExportData(DPUMA_FNDPUMA_Stop,&Stop)&&
201
 
                        GetExportData(DPUMA_FNDPUMA_IsActive,&IsActive)&&
202
 
                        GetExportData(DPUMA_FNDPUMA_StatusLine,&StatusLine)&&
203
 
                        GetExportData(DPUMA_FNDPUMA_Registry,&Registry)&&
204
 
                        GetExportData(DPUMA_FNDPUMA_Skip,&Skip)&&
205
 
                        GetExportData(DPUMA_FNDPUMA_StartLoop,&StartLoop)&&
206
 
                        GetExportData(DPUMA_FNDPUMA_LoopNext,&LoopNext)&&
207
 
                        GetExportData(DPUMA_FNDPUMA_CreateWindow,&fCreateWindow)&&
208
 
                        GetExportData(DPUMA_FNDPUMA_MessageBoxOk,&MessageBoxOk)&&
209
 
                        GetExportData(DPUMA_FNDPUMA_MessageBoxYesNo,&MessageBoxYesNo)&&
210
 
                        GetExportData(DPUMA_FNDPUMA_WaitUserInput,&WaitUserInput)&&
211
 
                        GetExportData(DPUMA_FNDPUMA_DrawLine,&DrawLine)&&
212
 
                        GetExportData(DPUMA_FNDPUMA_DrawRect,&DrawRect)&&
213
 
                        GetExportData(DPUMA_FNDPUMA_DrawLineTip,&DrawLineTip)&&
214
 
                        GetExportData(DPUMA_FNDPUMA_DrawRectTip,&DrawRectTip)&&
215
 
                        GetExportData(DPUMA_FNDPUMA_DeleteRects,&DeleteRects)&&
216
 
                        GetExportData(DPUMA_FNDPUMA_DeleteLines,&DeleteLines)&&
217
 
                        GetExportData(DPUMA_FNDPUMA_GetUserPoint,&GetUserPoint)&&
218
 
                        GetExportData(DPUMA_FNDPUMA_GetUserRect,&GetUserRect)&&
219
 
                        GetExportData(DPUMA_FNDPUMA_UpdateView,&UpdateView)&&
220
 
                        GetExportData(DPUMA_FNDPUMA_DrawRaster,&DrawRaster)&&
221
 
                        GetExportData(DPUMA_FNDPUMA_ZoomToRect,&ZoomToRect)&&
222
 
                        GetExportData(DPUMA_FNDPUMA_RasterHeader,&RasterHeader)&&
223
 
                        GetExportData(DPUMA_FNDPUMA_DrawFocusRect,&fnDrawFocusRect)&&
224
 
                        GetExportData(DPUMA_FNDPUMA_RegVariable,&RegVariable)&&
225
 
                        GetExportData(DPUMA_FNDPUMA_UnregVariable,&UnregVariable)&&
226
 
                        GetExportData(DPUMA_FNDPUMA_GetDIBptr,&GetDIBptr)&&
227
 
                        GetExportData(DPUMA_FNDPUMA_DrawString,&DrawString)&&
228
 
                        GetExportData(DPUMA_FNDPUMA_DeleteStrings,&DeleteStrings)&&
229
 
                        GetExportData(DPUMA_FNDPUMA_SetCallbackWindowProc,&SetCallbackWindowProc)&&
230
 
                        GetExportData(DPUMA_FNDPUMA_DeviceToImage,&DeviceToImage)&&
231
 
                        GetExportData(DPUMA_FNDPUMA_ImageToDevice,&ImageToDevice)&&
232
 
                        GetExportData(DPUMA_FNDPUMA_SetCallbackMainFrameWindowProc,&SetCallbackMainFrameWindowProc)&&
233
 
                        GetExportData(DPUMA_FNDPUMA_DestroyWindow,&fDestroyWindow)&&
234
 
                        GetExportData(DPUMA_FNDPUMA_SendWindow,&SendWindow)&&
235
 
                        GetExportData(DPUMA_FNDPUMA_SendMainWnd,&SendMainWnd)&&
236
 
                        GetExportData(DPUMA_FNDPUMA_CSTR_Monitor,&cstr_Monitor)&&
237
 
                        GetExportData(DPUMA_FNDPUMA_CSTR_GetPosition,&cstr_GetPosition)&&
238
 
                        GetExportData(DPUMA_FNDPUMA_CSTR_SetPosition,&cstr_SetPosition)&&
239
 
                        GetExportData(DPUMA_FNDPUMA_DestroyRasterWnd,&DestroyRasterWnd)&&
240
 
                        GetExportData(DPUMA_FNDPUMA_CSTR_GetLength,&cstr_GetLength)&&
241
 
                        GetExportData(DPUMA_FNDPUMA_ShowCutPoint,&ShowCutPoint)&&
242
 
                        GetExportData(DPUMA_FNDPUMA_GetRasterPixel,&GetRasterPixel)&&
243
 
                        GetExportData(DPUMA_FNDPUMA_CSTR_Update,&cstr_Update)&&
244
 
                        GetExportData(DPUMA_FNDPUMA_SkipEx,&SkipEx)&&
245
 
                        GetExportData(DPUMA_FNDPUMA_OpenFile,&fOpenFile)&&
246
 
                        GetExportData(DPUMA_FNDPUMA_GetFileName,&fGetFileName)&&
247
 
                        GetExportData(DPUMA_FNDPUMA_HandLayout,&fHandLayout)&&
248
 
                        GetExportData(DPUMA_FNDPUMA_LockImage,&fLockImage)&&
249
 
                        GetExportData(DPUMA_FNDPUMA_RegistryHelp,&RegistryHelp)&&
250
 
                        GetExportData(DPUMA_FNDPUMA_SaveFile,&fSaveFile)&&
251
 
                        GetExportData(DPUMA_FNDPUMA_ProgressStart, &fProgressStart )&&
252
 
                        GetExportData(DPUMA_FNDPUMA_ProgressFinish,&fProgressFinish)&&
253
 
                        GetExportData(DPUMA_FNDPUMA_ProgressStep,  &fProgressStep )&&
254
 
                        GetExportData(DPUMA_FNDPUMA_SetConsoleProperty,  &fSetConsoleProperty )&&
255
 
                        GetExportData(DPUMA_FNDPUMA_CreateHistogramm,  &fCreateHistogramm )&&
256
 
                        GetExportData(DPUMA_FNDPUMA_AddPointToHistogramm,  &fAddPointToHistogramm )&&
257
 
                        GetExportData(DPUMA_FNDPUMA_DoHistogramm,  &fDoHistogramm )&&
258
 
                        GetExportData(DPUMA_FNDPUMA_DestroyHistogramm, &fDestroyHistogramm )&&
259
 
                        GetExportData(DPUMA_FNDPUMA_GetWindowHandle,&fGetWindowHandle)&&
260
 
                        GetExportData(DPUMA_FNDPUMA_GetPrevSkipOwner,&fGetPrevSkipOwner)&&
261
 
                        GetExportData(DPUMA_FNDPUMA_AllocHook,&fAllocHook)&&
262
 
                        GetExportData(DPUMA_FNDPUMA_ConsoleClear,&fConsoleClear)&&
263
 
                        GetExportData(DPUMA_FNDPUMA_ConsoleGetCurLine,&fConsoleGetCurLine)&&
264
 
                        GetExportData(DPUMA_FNDPUMA_SetFileName,&fSetFileName )&&
265
 
                        GetExportData(DPUMA_FNDPUMA_FOpen,&fFOpen )&&
266
 
                        GetExportData(DPUMA_FNDPUMA_FClose,&fFClose)&&
267
 
                        GetExportData(DPUMA_FNDPUMA_FPrintf1024,&fFPrintf1024)&&
268
 
                        GetExportData(DPUMA_FNDPUMA_FPuts,&fFPuts)&&
269
 
                        GetExportData(DPUMA_FNDPUMA_RasterText,&RasterText)&&
270
 
                        SetImportData != NULL/*tanya*/
 
185
                hDPuma = LoadLibrary("DPUMA.DLL");
 
186
                if(hDPuma)
 
187
                {
 
188
                        Init = (FNDPUMA_Init)GetProcAddress(hDPuma,"DPUMA_Init");
 
189
                        Done = (FNDPUMA_Done)GetProcAddress(hDPuma,"DPUMA_Done");
 
190
                        GetExportData = (FNDPUMA_GetExportData)GetProcAddress(hDPuma,"DPUMA_GetExportData");
 
191
                        SetImportData = (FNDPUMA_SetImportData)GetProcAddress(hDPuma,"DPUMA_SetImportData"); //tanya
 
192
                }
 
193
                if(Init && GetExportData)
 
194
                {
 
195
                        if(GetExportData(DPUMA_FNDPUMA_Console,&Console)&&
 
196
                                        GetExportData(DPUMA_FNDPUMA_CreateSnap,&CreateSnap)&&
 
197
                                        GetExportData(DPUMA_FNDPUMA_DestroySnap,&DestroySnap)&&
 
198
                                        GetExportData(DPUMA_FNDPUMA_Stop,&Stop)&&
 
199
                                        GetExportData(DPUMA_FNDPUMA_IsActive,&IsActive)&&
 
200
                                        GetExportData(DPUMA_FNDPUMA_StatusLine,&StatusLine)&&
 
201
                                        GetExportData(DPUMA_FNDPUMA_Registry,&Registry)&&
 
202
                                        GetExportData(DPUMA_FNDPUMA_Skip,&Skip)&&
 
203
                                        GetExportData(DPUMA_FNDPUMA_StartLoop,&StartLoop)&&
 
204
                                        GetExportData(DPUMA_FNDPUMA_LoopNext,&LoopNext)&&
 
205
                                        GetExportData(DPUMA_FNDPUMA_CreateWindow,&fCreateWindow)&&
 
206
                                        GetExportData(DPUMA_FNDPUMA_MessageBoxOk,&MessageBoxOk)&&
 
207
                                        GetExportData(DPUMA_FNDPUMA_MessageBoxYesNo,&MessageBoxYesNo)&&
 
208
                                        GetExportData(DPUMA_FNDPUMA_WaitUserInput,&WaitUserInput)&&
 
209
                                        GetExportData(DPUMA_FNDPUMA_DrawLine,&DrawLine)&&
 
210
                                        GetExportData(DPUMA_FNDPUMA_DrawRect,&DrawRect)&&
 
211
                                        GetExportData(DPUMA_FNDPUMA_DrawLineTip,&DrawLineTip)&&
 
212
                                        GetExportData(DPUMA_FNDPUMA_DrawRectTip,&DrawRectTip)&&
 
213
                                        GetExportData(DPUMA_FNDPUMA_DeleteRects,&DeleteRects)&&
 
214
                                        GetExportData(DPUMA_FNDPUMA_DeleteLines,&DeleteLines)&&
 
215
                                        GetExportData(DPUMA_FNDPUMA_GetUserPoint,&GetUserPoint)&&
 
216
                                        GetExportData(DPUMA_FNDPUMA_GetUserRect,&GetUserRect)&&
 
217
                                        GetExportData(DPUMA_FNDPUMA_UpdateView,&UpdateView)&&
 
218
                                        GetExportData(DPUMA_FNDPUMA_DrawRaster,&DrawRaster)&&
 
219
                                        GetExportData(DPUMA_FNDPUMA_ZoomToRect,&ZoomToRect)&&
 
220
                                        GetExportData(DPUMA_FNDPUMA_RasterHeader,&RasterHeader)&&
 
221
                                        GetExportData(DPUMA_FNDPUMA_DrawFocusRect,&fnDrawFocusRect)&&
 
222
                                        GetExportData(DPUMA_FNDPUMA_RegVariable,&RegVariable)&&
 
223
                                        GetExportData(DPUMA_FNDPUMA_UnregVariable,&UnregVariable)&&
 
224
                                        GetExportData(DPUMA_FNDPUMA_GetDIBptr,&GetDIBptr)&&
 
225
                                        GetExportData(DPUMA_FNDPUMA_DrawString,&DrawString)&&
 
226
                                        GetExportData(DPUMA_FNDPUMA_DeleteStrings,&DeleteStrings)&&
 
227
                                        GetExportData(DPUMA_FNDPUMA_SetCallbackWindowProc,&SetCallbackWindowProc)&&
 
228
                                        GetExportData(DPUMA_FNDPUMA_DeviceToImage,&DeviceToImage)&&
 
229
                                        GetExportData(DPUMA_FNDPUMA_ImageToDevice,&ImageToDevice)&&
 
230
                                        GetExportData(DPUMA_FNDPUMA_SetCallbackMainFrameWindowProc,&SetCallbackMainFrameWindowProc)&&
 
231
                                        GetExportData(DPUMA_FNDPUMA_DestroyWindow,&fDestroyWindow)&&
 
232
                                        GetExportData(DPUMA_FNDPUMA_SendWindow,&SendWindow)&&
 
233
                                        GetExportData(DPUMA_FNDPUMA_SendMainWnd,&SendMainWnd)&&
 
234
                                        GetExportData(DPUMA_FNDPUMA_CSTR_Monitor,&cstr_Monitor)&&
 
235
                                        GetExportData(DPUMA_FNDPUMA_CSTR_GetPosition,&cstr_GetPosition)&&
 
236
                                        GetExportData(DPUMA_FNDPUMA_CSTR_SetPosition,&cstr_SetPosition)&&
 
237
                                        GetExportData(DPUMA_FNDPUMA_DestroyRasterWnd,&DestroyRasterWnd)&&
 
238
                                        GetExportData(DPUMA_FNDPUMA_CSTR_GetLength,&cstr_GetLength)&&
 
239
                                        GetExportData(DPUMA_FNDPUMA_ShowCutPoint,&ShowCutPoint)&&
 
240
                                        GetExportData(DPUMA_FNDPUMA_GetRasterPixel,&GetRasterPixel)&&
 
241
                                        GetExportData(DPUMA_FNDPUMA_CSTR_Update,&cstr_Update)&&
 
242
                                        GetExportData(DPUMA_FNDPUMA_SkipEx,&SkipEx)&&
 
243
                                        GetExportData(DPUMA_FNDPUMA_OpenFile,&fOpenFile)&&
 
244
                                        GetExportData(DPUMA_FNDPUMA_GetFileName,&fGetFileName)&&
 
245
                                        GetExportData(DPUMA_FNDPUMA_HandLayout,&fHandLayout)&&
 
246
                                        GetExportData(DPUMA_FNDPUMA_LockImage,&fLockImage)&&
 
247
                                        GetExportData(DPUMA_FNDPUMA_RegistryHelp,&RegistryHelp)&&
 
248
                                        GetExportData(DPUMA_FNDPUMA_SaveFile,&fSaveFile)&&
 
249
                                        GetExportData(DPUMA_FNDPUMA_ProgressStart, &fProgressStart )&&
 
250
                                        GetExportData(DPUMA_FNDPUMA_ProgressFinish,&fProgressFinish)&&
 
251
                                        GetExportData(DPUMA_FNDPUMA_ProgressStep, &fProgressStep )&&
 
252
                                        GetExportData(DPUMA_FNDPUMA_SetConsoleProperty, &fSetConsoleProperty )&&
 
253
                                        GetExportData(DPUMA_FNDPUMA_CreateHistogramm, &fCreateHistogramm )&&
 
254
                                        GetExportData(DPUMA_FNDPUMA_AddPointToHistogramm, &fAddPointToHistogramm )&&
 
255
                                        GetExportData(DPUMA_FNDPUMA_DoHistogramm, &fDoHistogramm )&&
 
256
                                        GetExportData(DPUMA_FNDPUMA_DestroyHistogramm, &fDestroyHistogramm )&&
 
257
                                        GetExportData(DPUMA_FNDPUMA_GetWindowHandle,&fGetWindowHandle)&&
 
258
                                        GetExportData(DPUMA_FNDPUMA_GetPrevSkipOwner,&fGetPrevSkipOwner)&&
 
259
                                        GetExportData(DPUMA_FNDPUMA_AllocHook,&fAllocHook)&&
 
260
                                        GetExportData(DPUMA_FNDPUMA_ConsoleClear,&fConsoleClear)&&
 
261
                                        GetExportData(DPUMA_FNDPUMA_ConsoleGetCurLine,&fConsoleGetCurLine)&&
 
262
                                        GetExportData(DPUMA_FNDPUMA_SetFileName,&fSetFileName )&&
 
263
                                        GetExportData(DPUMA_FNDPUMA_FOpen,&fFOpen )&&
 
264
                                        GetExportData(DPUMA_FNDPUMA_FClose,&fFClose)&&
 
265
                                        GetExportData(DPUMA_FNDPUMA_FPrintf1024,&fFPrintf1024)&&
 
266
                                        GetExportData(DPUMA_FNDPUMA_FPuts,&fFPuts)&&
 
267
                                        GetExportData(DPUMA_FNDPUMA_RasterText,&RasterText)&&
 
268
                                        SetImportData != NULL/*tanya*/
271
269
                        )
272
270
                        {
273
271
                                rc = Init(wHightCode,hStorage);
274
272
                                if(rc)
275
273
                                {
276
274
#ifdef _DEBUG
277
 
                                        // �� ������, ���� ���������� �� ���� ���.
278
 
                                        _CRT_ALLOC_HOOK pHook =  _CrtSetAllocHook(__DPUMA__AllocHook__);
 
275
                                        // На случай, если вызывается не один раз.
 
276
                                        _CRT_ALLOC_HOOK pHook = _CrtSetAllocHook(__DPUMA__AllocHook__);
279
277
                                        if(__DPUMA__AllocHook__ != pHook)
280
 
                                                PrevAllocHook = pHook;
 
278
                                        PrevAllocHook = pHook;
281
279
#endif
282
280
                                        fCreateWindow("Main",NULL);
283
 
                    LDPUMA_Registry(&hWriteFile,"��������� ���������� ������ � ����.",NULL);
284
 
                    LDPUMA_RegistryHelp(hWriteFile,"��������� ���������� ������ ��������� DPUMA.",FALSE);
 
281
                                        LDPUMA_Registry(&hWriteFile,"Выполнять отладочную запись в файл.",NULL);
 
282
                                        LDPUMA_RegistryHelp(hWriteFile,"Разрешает отладочную запись функциями DPUMA.",FALSE);
285
283
                                }
286
284
                        }
 
285
                }
 
286
                return rc;
287
287
        }
288
 
        return rc;
289
 
}
290
 
//////////////////////////////////////////////
291
 
Bool32 LDPUMA_Done()
292
 
{
293
 
        Bool32 rc = FALSE;
 
288
        //////////////////////////////////////////////
 
289
        Bool32 LDPUMA_Done()
 
290
        {
 
291
                Bool32 rc = FALSE;
294
292
#ifdef _DEBUG
295
 
        _CrtDbgReport( _CRT_WARN,NULL,__LINE__,__FILE__,
296
 
                "LDPUMA_Done()\n");
297
 
        if(PrevAllocHook)
298
 
                        _CrtSetAllocHook(PrevAllocHook);
 
293
                _CrtDbgReport( _CRT_WARN,NULL,__LINE__,__FILE__,
 
294
                                "LDPUMA_Done()\n");
 
295
                if(PrevAllocHook)
 
296
                _CrtSetAllocHook(PrevAllocHook);
299
297
#endif
300
298
 
301
 
        if(Done)
 
299
                if(Done)
302
300
                rc = Done();
303
 
        if(hDPuma)
 
301
                if(hDPuma)
 
302
                {
 
303
                        FreeLibrary(hDPuma);
 
304
                        hDPuma = NULL;
 
305
                }
 
306
                return rc;
 
307
        }
 
308
        //////////////////////////////////////////////
 
309
        Bool32 LDPUMA_SetImportData(uint32_t wType, void * pData)
304
310
        {
305
 
                FreeLibrary(hDPuma);
306
 
                hDPuma = NULL;
307
 
        }
308
 
        return rc;
309
 
}
310
 
//////////////////////////////////////////////
311
 
Bool32 LDPUMA_SetImportData(Word32 wType, void * pData)
312
 
{
313
 
        if(SetImportData)
 
311
                if(SetImportData)
314
312
                return SetImportData(wType,pData);
315
 
        return FALSE;
316
 
}
317
 
//////////////////////////////////////////////
318
 
Bool32 LDPUMA_GetExportData(Word32 wType, void * pData)
319
 
{
320
 
        if(GetExportData)
 
313
                return FALSE;
 
314
        }
 
315
        //////////////////////////////////////////////
 
316
        Bool32 LDPUMA_GetExportData(uint32_t wType, void * pData)
 
317
        {
 
318
                if(GetExportData)
321
319
                return GetExportData(wType,pData);
322
 
        return FALSE;
323
 
}
324
 
//////////////////////////////////////////////
325
 
void   LDPUMA_DestroySnap()
326
 
{
 
320
                return FALSE;
 
321
        }
 
322
        //////////////////////////////////////////////
 
323
        void LDPUMA_DestroySnap()
 
324
        {
327
325
#ifdef _DEBUG
328
 
        _CrtDbgReport( _CRT_WARN,NULL,__LINE__,__FILE__,
329
 
                "LDPUMA_DestroySnap()\n");
 
326
                _CrtDbgReport( _CRT_WARN,NULL,__LINE__,__FILE__,
 
327
                                "LDPUMA_DestroySnap()\n");
330
328
#endif
331
 
        if(DestroySnap)
 
329
                if(DestroySnap)
332
330
                DestroySnap();
333
 
}
334
 
//////////////////////////////////////////////
335
 
Word32   LDPUMA_CreateSnap()
336
 
{
337
 
        Word32 rc = 0;
 
331
        }
 
332
        //////////////////////////////////////////////
 
333
        uint32_t LDPUMA_CreateSnap()
 
334
        {
 
335
                uint32_t rc = 0;
338
336
#ifdef _DEBUG
339
 
        _CrtDbgReport( _CRT_WARN,NULL,__LINE__,__FILE__,
340
 
                "LDPUMA_CreateSnap()\n");
 
337
                _CrtDbgReport( _CRT_WARN,NULL,__LINE__,__FILE__,
 
338
                                "LDPUMA_CreateSnap()\n");
341
339
#endif
342
 
        if(CreateSnap)
 
340
                if(CreateSnap)
343
341
                rc = CreateSnap();
344
 
        return rc;
345
 
}
346
 
//////////////////////////////////////////////
347
 
void LDPUMA_Stop()
348
 
{
349
 
        if(Stop)
350
 
                 Stop();
351
 
}
352
 
//////////////////////////////////////////////
353
 
Handle LDPUMA_CreateWindow(const char * lpName, void * lpDIB)
354
 
{
355
 
        if(fCreateWindow)
 
342
                return rc;
 
343
        }
 
344
        //////////////////////////////////////////////
 
345
        void LDPUMA_Stop()
 
346
        {
 
347
                if(Stop)
 
348
                Stop();
 
349
        }
 
350
        //////////////////////////////////////////////
 
351
        Handle LDPUMA_CreateWindow(const char * lpName, void * lpDIB)
 
352
        {
 
353
                if(fCreateWindow)
356
354
                return fCreateWindow(lpName,lpDIB);
357
 
        return NULL;
358
 
}
359
 
//////////////////////////////////////////////
360
 
Bool32 LDPUMA_IsActive(void)
361
 
{
362
 
        return IsActive ? IsActive():FALSE;
363
 
};
364
 
//////////////////////////////////////////////
365
 
void   LDPUMA_DrawRect(Handle wnd,Rect16* rc, Int32 skew, Word32 rgb_color,
366
 
      Int16 pen_width,Word32 key)
367
 
{
368
 
        if(DrawRect)
369
 
                DrawRect(wnd,rc,skew,rgb_color,(Int16)pen_width,key);
370
 
}
371
 
//////////////////////////////////////////////
372
 
void   LDPUMA_DrawRectTip(Handle wnd,Rect16* rc, Int32 skew, Word32 rgb_color,
373
 
      Int16 pen_width,Word32 key,const char* pTip)
374
 
{
375
 
        if(DrawRectTip)
376
 
                DrawRectTip(wnd,rc,skew,rgb_color,(Int16)pen_width,key,pTip);
377
 
}
378
 
//////////////////////////////////////////////
379
 
void   LDPUMA_DeleteRects(Handle wnd, Word32 key)
380
 
{
381
 
        if(DeleteRects)
 
355
                return NULL;
 
356
        }
 
357
        //////////////////////////////////////////////
 
358
        Bool32 LDPUMA_IsActive(void)
 
359
        {
 
360
                return IsActive ? IsActive():FALSE;
 
361
        };
 
362
        //////////////////////////////////////////////
 
363
        void LDPUMA_DrawRect(Handle wnd,Rect16* rc, int32_t skew, uint32_t rgb_color,
 
364
                        int16_t pen_width,uint32_t key)
 
365
        {
 
366
                if(DrawRect)
 
367
                DrawRect(wnd,rc,skew,rgb_color,(int16_t)pen_width,key);
 
368
        }
 
369
        //////////////////////////////////////////////
 
370
        void LDPUMA_DrawRectTip(Handle wnd,Rect16* rc, int32_t skew, uint32_t rgb_color,
 
371
                        int16_t pen_width,uint32_t key,const char* pTip)
 
372
        {
 
373
                if(DrawRectTip)
 
374
                DrawRectTip(wnd,rc,skew,rgb_color,(int16_t)pen_width,key,pTip);
 
375
        }
 
376
        //////////////////////////////////////////////
 
377
        void LDPUMA_DeleteRects(Handle wnd, uint32_t key)
 
378
        {
 
379
                if(DeleteRects)
382
380
                DeleteRects(wnd,key);
383
 
};
384
 
//////////////////////////////////////////////
385
 
void  LDPUMA_DrawLine(Handle wnd,Point16* start, Point16* end, Int32 skew,
386
 
      Word32 rgb_color,Int16 pen_width,Word32 key )
387
 
{
388
 
        if(DrawLine)
 
381
        };
 
382
        //////////////////////////////////////////////
 
383
        void LDPUMA_DrawLine(Handle wnd,Point16* start, Point16* end, int32_t skew,
 
384
                        uint32_t rgb_color,int16_t pen_width,uint32_t key )
 
385
        {
 
386
                if(DrawLine)
389
387
                DrawLine(wnd,start,end,skew,rgb_color,pen_width,key);
390
 
};
391
 
//////////////////////////////////////////////
392
 
void  LDPUMA_DrawLineTip(Handle wnd,Point16* start, Point16* end, Int32 skew,
393
 
      Word32 rgb_color,Int16 pen_width,Word32 key,const char* pTip)
394
 
{
395
 
        if(DrawLineTip)
 
388
        };
 
389
        //////////////////////////////////////////////
 
390
        void LDPUMA_DrawLineTip(Handle wnd,Point16* start, Point16* end, int32_t skew,
 
391
                        uint32_t rgb_color,int16_t pen_width,uint32_t key,const char* pTip)
 
392
        {
 
393
                if(DrawLineTip)
396
394
                DrawLineTip(wnd,start,end,skew,rgb_color,pen_width,key,pTip);
397
 
};
398
 
//////////////////////////////////////////////
399
 
void   LDPUMA_DeleteLines(Handle wnd,Word32 key)
400
 
{
401
 
        if(DeleteLines)
 
395
        };
 
396
        //////////////////////////////////////////////
 
397
        void LDPUMA_DeleteLines(Handle wnd,uint32_t key)
 
398
        {
 
399
                if(DeleteLines)
402
400
                DeleteLines(wnd,key);
403
 
};
404
 
//////////////////////////////////////////////
405
 
void   LDPUMA_UpdateView(Handle wnd)
406
 
{
407
 
        if(UpdateView)
 
401
        };
 
402
        //////////////////////////////////////////////
 
403
        void LDPUMA_UpdateView(Handle wnd)
 
404
        {
 
405
                if(UpdateView)
408
406
                UpdateView(wnd);
409
 
}
410
 
//////////////////////////////////////////////
411
 
Int32 LDPUMA_Console(const char * message,...)
412
 
{
 
407
        }
 
408
        //////////////////////////////////////////////
 
409
        int32_t LDPUMA_Console(const char * message,...)
 
410
        {
413
411
#ifdef WIN32
414
 
    int rc = 0;
415
 
    if(Console)
416
 
    {
417
 
        va_list marker;
418
 
        va_start( marker, message);
419
 
        rc = Console(message,marker);
420
 
        va_end(marker);
421
 
    }
422
 
    return rc;
423
 
#else   
424
 
    #ifdef _DEBUG // console output only in debug mode
425
 
    va_list marker;
426
 
    va_start(marker, message);
427
 
    vprintf(message, marker);
428
 
    va_end(marker);
429
 
    #endif // _DEBUG
430
 
    return 1;
 
412
                int rc = 0;
 
413
                if(Console)
 
414
                {
 
415
                        va_list marker;
 
416
                        va_start( marker, message);
 
417
                        rc = Console(message,marker);
 
418
                        va_end(marker);
 
419
                }
 
420
                return rc;
 
421
#else
 
422
#ifdef _DEBUG // console output only in debug mode
 
423
                va_list marker;
 
424
                va_start(marker, message);
 
425
                vprintf(message, marker);
 
426
                va_end(marker);
 
427
#endif // _DEBUG
 
428
                return 1;
431
429
#endif
432
 
}
433
 
Int32 LDPUMA_ConsoleN(const char * message,...)
434
 
{
435
 
        Int32 rc = 0;
436
 
        if(Console)
437
 
        {
438
 
                va_list marker;
439
 
                va_start( marker, message);
440
 
                rc = Console(message,marker);
441
 
                va_end(marker);
442
 
                LDPUMA_Console("\n");
443
 
        }
444
 
        return rc;
445
 
}
446
 
//////////////////////////////////////////////
447
 
void LDPUMA_StatusLine(const char * message,...)
448
 
{
449
 
        if(StatusLine)
450
 
        {
451
 
                va_list marker;
452
 
                va_start( marker, message);
453
 
                StatusLine(message,marker);
454
 
                va_end(marker);
455
 
        }
456
 
}
457
 
//////////////////////////////////////////////
458
 
void   LDPUMA_MessageBoxOk( const char * message,...)
459
 
{
460
 
        if(MessageBoxOk)
461
 
        {
462
 
                va_list marker;
463
 
                va_start( marker, message);
464
 
                MessageBoxOk(message,marker);
465
 
                va_end(marker);
466
 
        }
467
 
};
468
 
//////////////////////////////////////////////
469
 
Bool16 LDPUMA_MessageBoxYesNo(const char * message,...)
470
 
{
471
 
        Bool16 rc = FALSE;
472
 
        if(MessageBoxYesNo)
473
 
        {
474
 
                va_list marker;
475
 
                va_start( marker, message);
476
 
                rc = MessageBoxYesNo(message,marker);
477
 
                va_end(marker);
478
 
        }
479
 
        return rc;
480
 
};
481
 
//////////////////////////////////////////////
482
 
Bool16 LDPUMA_GetUserRect(Handle wnd, Rect16* rect )
483
 
{
484
 
        Bool16 rc = FALSE;
485
 
        if(GetUserRect)
 
430
        }
 
431
        int32_t LDPUMA_ConsoleN(const char * message,...)
 
432
        {
 
433
                int32_t rc = 0;
 
434
                if(Console)
 
435
                {
 
436
                        va_list marker;
 
437
                        va_start( marker, message);
 
438
                        rc = Console(message,marker);
 
439
                        va_end(marker);
 
440
                        LDPUMA_Console("\n");
 
441
                }
 
442
                return rc;
 
443
        }
 
444
        //////////////////////////////////////////////
 
445
        void LDPUMA_StatusLine(const char * message,...)
 
446
        {
 
447
                if(StatusLine)
 
448
                {
 
449
                        va_list marker;
 
450
                        va_start( marker, message);
 
451
                        StatusLine(message,marker);
 
452
                        va_end(marker);
 
453
                }
 
454
        }
 
455
        //////////////////////////////////////////////
 
456
        void LDPUMA_MessageBoxOk( const char * message,...)
 
457
        {
 
458
                if(MessageBoxOk)
 
459
                {
 
460
                        va_list marker;
 
461
                        va_start( marker, message);
 
462
                        MessageBoxOk(message,marker);
 
463
                        va_end(marker);
 
464
                }
 
465
        };
 
466
        //////////////////////////////////////////////
 
467
        Bool16 LDPUMA_MessageBoxYesNo(const char * message,...)
 
468
        {
 
469
                Bool16 rc = FALSE;
 
470
                if(MessageBoxYesNo)
 
471
                {
 
472
                        va_list marker;
 
473
                        va_start( marker, message);
 
474
                        rc = MessageBoxYesNo(message,marker);
 
475
                        va_end(marker);
 
476
                }
 
477
                return rc;
 
478
        };
 
479
        //////////////////////////////////////////////
 
480
        Bool16 LDPUMA_GetUserRect(Handle wnd, Rect16* rect )
 
481
        {
 
482
                Bool16 rc = FALSE;
 
483
                if(GetUserRect)
486
484
                rc = GetUserRect(wnd,rect);
487
 
        return rc;
488
 
};
489
 
//////////////////////////////////////////////
490
 
Bool16 LDPUMA_GetUserPoint(Handle wnd,Point16* pnt)
491
 
{
492
 
        Bool16 rc = FALSE;
493
 
        if(GetUserPoint)
 
485
                return rc;
 
486
        };
 
487
        //////////////////////////////////////////////
 
488
        Bool16 LDPUMA_GetUserPoint(Handle wnd,Point16* pnt)
 
489
        {
 
490
                Bool16 rc = FALSE;
 
491
                if(GetUserPoint)
494
492
                rc = GetUserPoint(wnd,pnt);
495
 
        return rc;
496
 
};
497
 
//////////////////////////////////////////////
498
 
Word32 LDPUMA_WaitUserInput(Handle cur_node,Handle wnd)
499
 
{
500
 
        Word32 rc = 0;
501
 
        if(WaitUserInput)
 
493
                return rc;
 
494
        };
 
495
        //////////////////////////////////////////////
 
496
        uint32_t LDPUMA_WaitUserInput(Handle cur_node,Handle wnd)
 
497
        {
 
498
                uint32_t rc = 0;
 
499
                if(WaitUserInput)
502
500
                rc = WaitUserInput(cur_node,wnd);
503
 
        return rc;
504
 
};
505
 
//////////////////////////////////////////////
506
 
void LDPUMA_Registry( Handle node, const char * name,Handle parent )
507
 
{
508
 
        if(Registry)
 
501
                return rc;
 
502
        };
 
503
        //////////////////////////////////////////////
 
504
        void LDPUMA_Registry( Handle node, const char * name,Handle parent )
 
505
        {
 
506
                if(Registry)
509
507
                Registry(node,name,parent);
510
 
};
511
 
//////////////////////////////////////////////
512
 
void LDPUMA_StartLoop( Handle node, Word32 iter_total )
513
 
{
514
 
        if(StartLoop)
 
508
        };
 
509
        //////////////////////////////////////////////
 
510
        void LDPUMA_StartLoop( Handle node, uint32_t iter_total )
 
511
        {
 
512
                if(StartLoop)
515
513
                StartLoop(node,iter_total);
516
 
};
517
 
//////////////////////////////////////////////
518
 
void LDPUMA_LoopNext( Handle node )
519
 
{
520
 
        if(LoopNext)
 
514
        };
 
515
        //////////////////////////////////////////////
 
516
        void LDPUMA_LoopNext( Handle node )
 
517
        {
 
518
                if(LoopNext)
521
519
                LoopNext(node);
522
 
};
523
 
//////////////////////////////////////////////
524
 
Bool16  LDPUMA_Skip( Handle node )
525
 
{
526
 
        return Skip ? Skip(node):TRUE;
527
 
};
528
 
//////////////////////////////////////////////
529
 
void LDPUMA_DrawRaster(DPUMA_RecRaster * raster)
530
 
{
531
 
        if(DrawRaster)
 
520
        };
 
521
        //////////////////////////////////////////////
 
522
        Bool16 LDPUMA_Skip( Handle node )
 
523
        {
 
524
                return Skip ? Skip(node):TRUE;
 
525
        };
 
526
        //////////////////////////////////////////////
 
527
        void LDPUMA_DrawRaster(DPUMA_RecRaster * raster)
 
528
        {
 
529
                if(DrawRaster)
532
530
                DrawRaster((DPUMA_RecRaster *)raster);
533
 
};
534
 
//////////////////////////////////////////////
535
 
void LDPUMA_RasterText(char * lpText)
536
 
{
537
 
        if(RasterText)
 
531
        };
 
532
        //////////////////////////////////////////////
 
533
        void LDPUMA_RasterText(char * lpText)
 
534
        {
 
535
                if(RasterText)
538
536
                RasterText(lpText);
539
 
};
540
 
//////////////////////////////////////////////
541
 
void LDPUMA_ZoomToRect(Handle wnd,Rect16 * lpRect)
542
 
{
543
 
        if(ZoomToRect)
 
537
        };
 
538
        //////////////////////////////////////////////
 
539
        void LDPUMA_ZoomToRect(Handle wnd,Rect16 * lpRect)
 
540
        {
 
541
                if(ZoomToRect)
544
542
                ZoomToRect(wnd,lpRect);
545
 
};
546
 
//////////////////////////////////////////////
547
 
void LDPUMA_RasterHeader(char * lpText,Word32 num)
548
 
{
549
 
        if(RasterHeader)
 
543
        };
 
544
        //////////////////////////////////////////////
 
545
        void LDPUMA_RasterHeader(char * lpText,uint32_t num)
 
546
        {
 
547
                if(RasterHeader)
550
548
                RasterHeader(lpText,num);
551
 
};
552
 
//////////////////////////////////////////////
553
 
void   LDPUMA_DrawFocusRect(Handle wnd,Rect16* rc)
554
 
{
555
 
        if(fnDrawFocusRect)
 
549
        };
 
550
        //////////////////////////////////////////////
 
551
        void LDPUMA_DrawFocusRect(Handle wnd,Rect16* rc)
 
552
        {
 
553
                if(fnDrawFocusRect)
556
554
                fnDrawFocusRect(wnd,rc);
557
 
};
558
 
//////////////////////////////////////////////
559
 
Bool32 LDPUMA_RegVariable(Handle owner, const char * lpText,void * lpData, const char * lpType)
560
 
{
561
 
        BOOL rc = FALSE;
562
 
        if(RegVariable)
 
555
        };
 
556
        //////////////////////////////////////////////
 
557
        Bool32 LDPUMA_RegVariable(Handle owner, const char * lpText,void * lpData, const char * lpType)
 
558
        {
 
559
                Bool rc = FALSE;
 
560
                if(RegVariable)
563
561
                rc = RegVariable(owner,lpText,lpData,lpType);
564
 
        return rc;
565
 
};
 
562
                return rc;
 
563
        };
566
564
 
567
 
void LDPUMA_UnregVariable(void * lpData)
568
 
{
569
 
        if(UnregVariable)
 
565
        void LDPUMA_UnregVariable(void * lpData)
 
566
        {
 
567
                if(UnregVariable)
570
568
                UnregVariable(lpData);
571
 
};
 
569
        };
572
570
 
573
 
void * LDPUMA_GetDIBptr(Handle wnd)
574
 
{
575
 
        if(GetDIBptr)
 
571
        void * LDPUMA_GetDIBptr(Handle wnd)
 
572
        {
 
573
                if(GetDIBptr)
576
574
                return GetDIBptr(wnd);
577
 
return NULL;
578
 
};
579
 
//////////////////////////////////////////////
580
 
void  LDPUMA_DrawString(Handle wnd,Point16* start, const char * string, Int32 align,
581
 
      Word32 rgb_color,Int16 size,Word32 key )
582
 
{
583
 
        if(DrawString)
 
575
                return NULL;
 
576
        };
 
577
        //////////////////////////////////////////////
 
578
        void LDPUMA_DrawString(Handle wnd,Point16* start, const char * string, int32_t align,
 
579
                        uint32_t rgb_color,int16_t size,uint32_t key )
 
580
        {
 
581
                if(DrawString)
584
582
                DrawString(wnd,start,string,align,rgb_color,size,key);
585
 
};
586
 
//////////////////////////////////////////////
587
 
void   LDPUMA_DeleteStrings(Handle wnd,Word32 key)
588
 
{
589
 
        if(DeleteStrings)
 
583
        };
 
584
        //////////////////////////////////////////////
 
585
        void LDPUMA_DeleteStrings(Handle wnd,uint32_t key)
 
586
        {
 
587
                if(DeleteStrings)
590
588
                DeleteStrings(wnd,key);
591
 
};
592
 
//////////////////////////////////////////////
593
 
DPUMA_Callback_WindowProc   LDPUMA_SetCallbackWindowProc(Handle wnd, DPUMA_Callback_WindowProc func)
594
 
{
595
 
        if(SetCallbackWindowProc)
 
589
        };
 
590
        //////////////////////////////////////////////
 
591
        DPUMA_Callback_WindowProc LDPUMA_SetCallbackWindowProc(Handle wnd, DPUMA_Callback_WindowProc func)
 
592
        {
 
593
                if(SetCallbackWindowProc)
596
594
                return SetCallbackWindowProc(wnd,func);
597
 
        return NULL;
598
 
};
599
 
//////////////////////////////////////////////
600
 
void   LDPUMA_DeviceToImage(Handle wnd, Point32 * p, Word32 number)
601
 
{
602
 
        if(DeviceToImage)
 
595
                return NULL;
 
596
        };
 
597
        //////////////////////////////////////////////
 
598
        void LDPUMA_DeviceToImage(Handle wnd, Point32 * p, uint32_t number)
 
599
        {
 
600
                if(DeviceToImage)
603
601
                DeviceToImage( wnd, p, number);
604
 
};
605
 
//////////////////////////////////////////////
606
 
void   LDPUMA_ImageToDevice(Handle wnd, Point32 * p, Word32 number)
607
 
{
608
 
        if(ImageToDevice)
 
602
        };
 
603
        //////////////////////////////////////////////
 
604
        void LDPUMA_ImageToDevice(Handle wnd, Point32 * p, uint32_t number)
 
605
        {
 
606
                if(ImageToDevice)
609
607
                ImageToDevice( wnd, p, number);
610
 
};
611
 
//////////////////////////////////////////////
612
 
DPUMA_Callback_WindowProc   LDPUMA_SetCallbackMainFrameWindowProc(DPUMA_Callback_WindowProc func)
613
 
{
614
 
        if(SetCallbackMainFrameWindowProc)
 
608
        };
 
609
        //////////////////////////////////////////////
 
610
        DPUMA_Callback_WindowProc LDPUMA_SetCallbackMainFrameWindowProc(DPUMA_Callback_WindowProc func)
 
611
        {
 
612
                if(SetCallbackMainFrameWindowProc)
615
613
                return SetCallbackMainFrameWindowProc(func);
616
 
        return NULL;
617
 
};
618
 
//////////////////////////////////////////////
619
 
void  LDPUMA_DestroyWindow(Handle wnd)
620
 
{
621
 
        if(fDestroyWindow)
 
614
                return NULL;
 
615
        };
 
616
        //////////////////////////////////////////////
 
617
        void LDPUMA_DestroyWindow(Handle wnd)
 
618
        {
 
619
                if(fDestroyWindow)
622
620
                fDestroyWindow( wnd );
623
 
};
624
 
//////////////////////////////////////////////
625
 
Word32  LDPUMA_SendWindow(Handle wnd,Word32 message, Word32 wParam, Word32 lParam)
626
 
{
627
 
        Word32 rc = 0;
628
 
        if(SendWindow)
 
621
        };
 
622
        //////////////////////////////////////////////
 
623
        uint32_t LDPUMA_SendWindow(Handle wnd,uint32_t message, uint32_t wParam, uint32_t lParam)
 
624
        {
 
625
                uint32_t rc = 0;
 
626
                if(SendWindow)
629
627
                rc = SendWindow(wnd,message,wParam,lParam);
630
 
        return rc;
631
 
};
632
 
//////////////////////////////////////////////
633
 
Word32  LDPUMA_SendMainWnd(Word32 message, Word32 wParam, Word32 lParam)
634
 
{
635
 
        Word32 rc = 0;
636
 
        if(SendMainWnd)
 
628
                return rc;
 
629
        };
 
630
        //////////////////////////////////////////////
 
631
        uint32_t LDPUMA_SendMainWnd(uint32_t message, uint32_t wParam, uint32_t lParam)
 
632
        {
 
633
                uint32_t rc = 0;
 
634
                if(SendMainWnd)
637
635
                rc = SendMainWnd(message,wParam,lParam);
638
 
        return rc;
639
 
};
640
 
//////////////////////////////////////////////
641
 
Word32 LDPUMA_CSTR_Monitor(Handle owner, Word32 cstr_line, Word32 pos,
642
 
                                                                          DPUMA_Callback_WindowProc lpproc)
643
 
{
644
 
        Word32 rc = 0;
645
 
        if(cstr_Monitor)
 
636
                return rc;
 
637
        };
 
638
        //////////////////////////////////////////////
 
639
        uint32_t LDPUMA_CSTR_Monitor(Handle owner, Handle cstr_line, uint32_t pos,
 
640
                        DPUMA_Callback_WindowProc lpproc)
 
641
        {
 
642
                uint32_t rc = 0;
 
643
                if(cstr_Monitor)
646
644
                rc = cstr_Monitor(owner,cstr_line,pos,lpproc);
647
 
return rc;
648
 
}
649
 
//////////////////////////////////////////////
650
 
Word32 LDPUMA_CSTR_GetPosition(Word32 * cstr_raster)
651
 
{
652
 
        Word32 rc = 0;
653
 
        if(cstr_GetPosition)
 
645
                return rc;
 
646
        }
 
647
        //////////////////////////////////////////////
 
648
        uint32_t LDPUMA_CSTR_GetPosition(uint32_t * cstr_raster)
 
649
        {
 
650
                uint32_t rc = 0;
 
651
                if(cstr_GetPosition)
654
652
                cstr_GetPosition(cstr_raster);
655
653
 
656
 
return rc;
657
 
}
658
 
//////////////////////////////////////////////
659
 
void LDPUMA_CSTR_SetPosition(Word32 pos)
660
 
{
661
 
        if(cstr_SetPosition)
 
654
                return rc;
 
655
        }
 
656
        //////////////////////////////////////////////
 
657
        void LDPUMA_CSTR_SetPosition(uint32_t pos)
 
658
        {
 
659
                if(cstr_SetPosition)
662
660
                cstr_SetPosition(pos);
663
 
}
664
 
//////////////////////////////////////////////
665
 
void LDPUMA_DestroyRasterWnd()
666
 
{
667
 
        if(DestroyRasterWnd)
 
661
        }
 
662
        //////////////////////////////////////////////
 
663
        void LDPUMA_DestroyRasterWnd()
 
664
        {
 
665
                if(DestroyRasterWnd)
668
666
                DestroyRasterWnd();
669
 
}
670
 
//////////////////////////////////////////////
671
 
Word32 LDPUMA_CSTR_GetLength()
672
 
{
673
 
Word32 rc = 0;
674
 
        if(cstr_GetLength)
 
667
        }
 
668
        //////////////////////////////////////////////
 
669
        uint32_t LDPUMA_CSTR_GetLength()
 
670
        {
 
671
                uint32_t rc = 0;
 
672
                if(cstr_GetLength)
675
673
                rc = cstr_GetLength();
676
 
return rc;
677
 
}
678
 
//////////////////////////////////////////////
679
 
void LDPUMA_ShowCutPoint(Word32 number, Point32 * lppoint)
680
 
{
681
 
        if(ShowCutPoint)
 
674
                return rc;
 
675
        }
 
676
        //////////////////////////////////////////////
 
677
        void LDPUMA_ShowCutPoint(uint32_t number, Point32 * lppoint)
 
678
        {
 
679
                if(ShowCutPoint)
682
680
                ShowCutPoint(number,lppoint);
683
 
}
684
 
//////////////////////////////////////////////
685
 
Point32 LDPUMA_GetRasterPixel(Handle wnd, Point32 point )
686
 
{
687
 
        Point32 rc = {-1,-1};
688
 
        if(GetRasterPixel)
 
681
        }
 
682
        //////////////////////////////////////////////
 
683
        Point32 LDPUMA_GetRasterPixel(Handle wnd, Point32 point )
 
684
        {
 
685
                Point32 rc = {-1,-1};
 
686
                if(GetRasterPixel)
689
687
                rc = GetRasterPixel(wnd,point);
690
 
return rc;
691
 
}
692
 
//////////////////////////////////////////////
693
 
void LDPUMA_CSTR_Update( )
694
 
{
695
 
        if(cstr_Update)
 
688
                return rc;
 
689
        }
 
690
        //////////////////////////////////////////////
 
691
        void LDPUMA_CSTR_Update( )
 
692
        {
 
693
                if(cstr_Update)
696
694
                cstr_Update();
697
 
}
 
695
        }
698
696
 
699
 
//////////////////////////////////////////////
700
 
Bool32 LDPUMA_SkipEx(Handle owner, Bool32 bIter, Bool32 bParent, Int32 nSign )
701
 
{
702
 
        Bool32 rc = TRUE;
703
 
        if(SkipEx)
 
697
        //////////////////////////////////////////////
 
698
        Bool32 LDPUMA_SkipEx(Handle owner, Bool32 bIter, Bool32 bParent, int32_t nSign )
 
699
        {
 
700
                Bool32 rc = TRUE;
 
701
                if(SkipEx)
704
702
                rc = SkipEx(owner, bIter, bParent, nSign);
705
 
return rc;
706
 
}
707
 
//////////////////////////////////////////////
708
 
Bool32 LDPUMA_OpenFile(Handle wnd, char * name )
709
 
{
710
 
        Bool32 rc = FALSE;
711
 
        if(fOpenFile)
 
703
                return rc;
 
704
        }
 
705
        //////////////////////////////////////////////
 
706
        Bool32 LDPUMA_OpenFile(Handle wnd, char * name )
 
707
        {
 
708
                Bool32 rc = FALSE;
 
709
                if(fOpenFile)
712
710
                rc = fOpenFile(wnd,name);
713
 
        return rc;
714
 
}
715
 
//////////////////////////////////////////////
716
 
char * LDPUMA_GetFileName(Handle wnd)
717
 
{
718
 
        char * rc = "";
719
 
        if(fGetFileName)
 
711
                return rc;
 
712
        }
 
713
        //////////////////////////////////////////////
 
714
        char * LDPUMA_GetFileName(Handle wnd)
 
715
        {
 
716
                char * rc = "";
 
717
                if(fGetFileName)
720
718
                rc = fGetFileName(wnd);
721
 
        return rc;
722
 
}
723
 
//////////////////////////////////////////////
724
 
void *  LDPUMA_HandLayout( void * lpDIB, Word32 flags ,Point32 * p)
725
 
{
726
 
        void * rc = NULL;
727
 
        if(fHandLayout)
 
719
                return rc;
 
720
        }
 
721
        //////////////////////////////////////////////
 
722
        void * LDPUMA_HandLayout( void * lpDIB, uint32_t flags ,Point32 * p)
 
723
        {
 
724
                void * rc = NULL;
 
725
                if(fHandLayout)
728
726
                rc = fHandLayout(lpDIB,flags,p);
729
 
return rc;
730
 
}
731
 
//////////////////////////////////////////////
732
 
Bool32 LDPUMA_LockImage( Handle wnd, Bool32 bLock )
733
 
{
734
 
        Bool32 rc = FALSE;
 
727
                return rc;
 
728
        }
 
729
        //////////////////////////////////////////////
 
730
        Bool32 LDPUMA_LockImage( Handle wnd, Bool32 bLock )
 
731
        {
 
732
                Bool32 rc = FALSE;
735
733
 
736
 
        if(fLockImage)
 
734
                if(fLockImage)
737
735
                rc = fLockImage(wnd,bLock);
738
736
 
739
 
return rc;
740
 
}
741
 
//////////////////////////////////////////////
742
 
void LDPUMA_RegistryHelp( Handle owner, const char * lpstrHelp,Bool32 bAppend )
743
 
{
744
 
        if(RegistryHelp)
 
737
                return rc;
 
738
        }
 
739
        //////////////////////////////////////////////
 
740
        void LDPUMA_RegistryHelp( Handle owner, const char * lpstrHelp,Bool32 bAppend )
 
741
        {
 
742
                if(RegistryHelp)
745
743
                RegistryHelp(owner,lpstrHelp,bAppend);
746
 
}
747
 
//////////////////////////////////////////////
748
 
Bool32 LDPUMA_SaveFile( void * lpDIB,char * lpFileName,Word32 nFormat )
749
 
{
750
 
        Bool32 rc = FALSE;
751
 
        if(fSaveFile)
 
744
        }
 
745
        //////////////////////////////////////////////
 
746
        Bool32 LDPUMA_SaveFile( void * lpDIB,char * lpFileName,uint32_t nFormat )
 
747
        {
 
748
                Bool32 rc = FALSE;
 
749
                if(fSaveFile)
752
750
                rc = fSaveFile(lpDIB,lpFileName,nFormat);
753
 
        return rc;
754
 
}
755
 
//////////////////////////////////////////////
756
 
void LDPUMA_ProgressStart( void )
757
 
{
758
 
        if(fProgressStart)
 
751
                return rc;
 
752
        }
 
753
        //////////////////////////////////////////////
 
754
        void LDPUMA_ProgressStart( void )
 
755
        {
 
756
                if(fProgressStart)
759
757
                fProgressStart();
760
 
}
761
 
//////////////////////////////////////////////
762
 
void LDPUMA_ProgressFinish( void )
763
 
{
764
 
        if(fProgressFinish)
 
758
        }
 
759
        //////////////////////////////////////////////
 
760
        void LDPUMA_ProgressFinish( void )
 
761
        {
 
762
                if(fProgressFinish)
765
763
                fProgressFinish();
766
 
}
767
 
//////////////////////////////////////////////
768
 
Bool32 LDPUMA_ProgressStep(Word32 step, const char * name, Word32 percent)
769
 
{
770
 
        Bool32 rc = TRUE;
771
 
        if(fProgressStep)
 
764
        }
 
765
        //////////////////////////////////////////////
 
766
        Bool32 LDPUMA_ProgressStep(uint32_t step, const char * name, uint32_t percent)
 
767
        {
 
768
                Bool32 rc = TRUE;
 
769
                if(fProgressStep)
772
770
                rc = fProgressStep(step,name,percent);
773
 
        return rc;
774
 
}
775
 
//////////////////////////////////////////////
776
 
Bool32 LDPUMA_SetConsoleProperty(Bool32 bold,Bool32 italic,
777
 
        Bool32 strikeout,Bool32 underline,Int32 height, Int32 offset,   Word32 textcolor,
778
 
        Int32 charset,  const char * name )
779
 
{
780
 
        Bool32 rc = TRUE;
 
771
                return rc;
 
772
        }
 
773
        //////////////////////////////////////////////
 
774
        Bool32 LDPUMA_SetConsoleProperty(Bool32 bold,Bool32 italic,
 
775
                        Bool32 strikeout,Bool32 underline,int32_t height, int32_t offset, uint32_t textcolor,
 
776
                        int32_t charset, const char * name )
 
777
        {
 
778
                Bool32 rc = TRUE;
781
779
 
782
 
        if(fSetConsoleProperty)
 
780
                if(fSetConsoleProperty)
783
781
                rc = fSetConsoleProperty(bold,italic,
784
 
        strikeout,underline,height,     offset, textcolor,
785
 
        charset,        name );
 
782
                                strikeout,underline,height, offset, textcolor,
 
783
                                charset, name );
786
784
 
787
 
        return rc;
788
 
}
789
 
///////////////////////////////////////
790
 
Handle LDPUMA_CreateHistogramm(const char * name, Word32 size, PInt32 lpVal)
791
 
{
792
 
        Handle rc = NULL;
793
 
        if(fCreateHistogramm)
 
785
                return rc;
 
786
        }
 
787
        ///////////////////////////////////////
 
788
        Handle LDPUMA_CreateHistogramm(const char * name, uint32_t size, int32_t * lpVal)
 
789
        {
 
790
                Handle rc = NULL;
 
791
                if(fCreateHistogramm)
794
792
                rc = fCreateHistogramm(name,size,lpVal);
795
 
        return rc;
796
 
}
797
 
//////////////////////////////////////////////
798
 
void LDPUMA_AddPointToHistogramm(Handle hDlg, Word32 point)
799
 
{
800
 
        if(fAddPointToHistogramm)
 
793
                return rc;
 
794
        }
 
795
        //////////////////////////////////////////////
 
796
        void LDPUMA_AddPointToHistogramm(Handle hDlg, uint32_t point)
 
797
        {
 
798
                if(fAddPointToHistogramm)
801
799
                fAddPointToHistogramm(hDlg,point);
802
 
}
803
 
//////////////////////////////////////////////
804
 
Bool32 LDPUMA_DoHistogramm(Handle hDlg, PWord32 lpCurpos)
805
 
{
806
 
        Bool32 rc = FALSE;
807
 
        if(fDoHistogramm)
 
800
        }
 
801
        //////////////////////////////////////////////
 
802
        Bool32 LDPUMA_DoHistogramm(Handle hDlg, uint32_t * lpCurpos)
 
803
        {
 
804
                Bool32 rc = FALSE;
 
805
                if(fDoHistogramm)
808
806
                rc = fDoHistogramm(hDlg,lpCurpos);
809
 
        return rc;
810
 
}
811
 
//////////////////////////////////////////////
812
 
void LDPUMA_DestroyHistogramm(Handle hDlg)
813
 
{
814
 
        if(fDestroyHistogramm)
 
807
                return rc;
 
808
        }
 
809
        //////////////////////////////////////////////
 
810
        void LDPUMA_DestroyHistogramm(Handle hDlg)
 
811
        {
 
812
                if(fDestroyHistogramm)
815
813
                fDestroyHistogramm(hDlg);
816
 
}
817
 
//////////////////////////////////////////////
818
 
Handle LDPUMA_TimeStamp(const char * name,Handle hTimer)
819
 
{
820
 
        time_t ltime = 0;
821
 
        int     clock1 = 0;
822
 
        if(LDPUMA_IsActive())
823
 
        {
824
 
                time( &ltime );
825
 
                clock1=clock();
826
 
                if(name==NULL)
827
 
                        name = "Time stamp";
828
 
                if(hTimer==NULL)
829
 
                        LDPUMA_Console("%s : %s\n",name,asctime(localtime(&ltime)));
830
 
                else
831
 
                {
832
 
                int clockprev = (int)hTimer;
833
 
                        LDPUMA_Console("%s : %i msec.\n",name,clock1-clockprev);
834
 
                }
835
 
        }
836
 
return (Handle) clock1;
837
 
}
838
 
//////////////////////////////////////////////
839
 
Handle LDPUMA_GetWindowHandle(const char * name)
840
 
{
841
 
        Handle rc = NULL;
842
 
        if(fGetWindowHandle)
 
814
        }
 
815
        //////////////////////////////////////////////
 
816
        Handle LDPUMA_TimeStamp(const char * name,Handle hTimer)
 
817
        {
 
818
                time_t ltime = 0;
 
819
                int clock1 = 0;
 
820
                if(LDPUMA_IsActive())
 
821
                {
 
822
                        time( &ltime );
 
823
                        clock1=clock();
 
824
                        if(name==NULL)
 
825
                        name = "Time stamp";
 
826
                        if(hTimer==NULL)
 
827
                        LDPUMA_Console("%s : %s\n",name,asctime(localtime(&ltime)));
 
828
                        else
 
829
                        {
 
830
                                int clockprev = (int)hTimer;
 
831
                                LDPUMA_Console("%s : %i msec.\n",name,clock1-clockprev);
 
832
                        }
 
833
                }
 
834
                return (Handle) clock1;
 
835
        }
 
836
        //////////////////////////////////////////////
 
837
        Handle LDPUMA_GetWindowHandle(const char * name)
 
838
        {
 
839
                Handle rc = NULL;
 
840
                if(fGetWindowHandle)
843
841
                rc = fGetWindowHandle(name);
844
 
        return rc;
845
 
}
846
 
//////////////////////////////////////////////
847
 
Handle LDPUMA_GetPrevSkipOwner()
848
 
{
849
 
        Handle rc = NULL;
850
 
        if(fGetPrevSkipOwner)
 
842
                return rc;
 
843
        }
 
844
        //////////////////////////////////////////////
 
845
        Handle LDPUMA_GetPrevSkipOwner()
 
846
        {
 
847
                Handle rc = NULL;
 
848
                if(fGetPrevSkipOwner)
851
849
                rc = fGetPrevSkipOwner();
852
 
        return rc;
853
 
}
854
 
//////////////////////////////////////////////
855
 
void LDPUMA_ConsoleClear(Int32 beforeline)
856
 
{
857
 
        if(fConsoleClear)
 
850
                return rc;
 
851
        }
 
852
        //////////////////////////////////////////////
 
853
        void LDPUMA_ConsoleClear(int32_t beforeline)
 
854
        {
 
855
                if(fConsoleClear)
858
856
                fConsoleClear(beforeline);
859
 
}
860
 
//////////////////////////////////////////////
861
 
Int32 LDPUMA_ConsoleGetCurLine()
862
 
{
863
 
        Int32 rc = -1;
864
 
        if(fConsoleGetCurLine)
 
857
        }
 
858
        //////////////////////////////////////////////
 
859
        int32_t LDPUMA_ConsoleGetCurLine()
 
860
        {
 
861
                int32_t rc = -1;
 
862
                if(fConsoleGetCurLine)
865
863
                rc = fConsoleGetCurLine();
866
 
return rc;
867
 
}
868
 
//////////////////////////////////////////////
869
 
Bool32 LDPUMA_SetFileName(Handle wnd,char * lpName)
870
 
{
871
 
        Bool32 rc = FALSE;
872
 
        if(fSetFileName)
 
864
                return rc;
 
865
        }
 
866
        //////////////////////////////////////////////
 
867
        Bool32 LDPUMA_SetFileName(Handle wnd, const char * lpName)
 
868
        {
 
869
                Bool32 rc = FALSE;
 
870
                if(fSetFileName)
873
871
                rc = fSetFileName(wnd,lpName);
874
 
        return rc;
875
 
}
876
 
//////////////////////////////////////////////
877
 
Handle  LDPUMA_FOpen(const char * lpName,const char * lpMode)
878
 
{
879
 
        Handle hFile = NULL;
 
872
                return rc;
 
873
        }
 
874
        //////////////////////////////////////////////
 
875
        Handle LDPUMA_FOpen(const char * lpName,const char * lpMode)
 
876
        {
 
877
                Handle hFile = NULL;
880
878
 
881
 
        if(fFOpen && !LDPUMA_Skip(hWriteFile))
 
879
                if(fFOpen && !LDPUMA_Skip(hWriteFile))
882
880
                hFile = fFOpen(lpName,lpMode);
883
 
        return hFile;
884
 
}
885
 
//////////////////////////////////////////////
886
 
void LDPUMA_FClose(Handle hFile)
887
 
{
888
 
        if(fFClose && hFile)
889
 
                 fFClose(hFile);
890
 
}
891
 
//////////////////////////////////////////////
892
 
Int32  LDPUMA_FPrintf1024(Handle hFile,const char * lpFormat,...)
893
 
{
894
 
        Int32 rc = 0;
895
 
        if(fFPrintf1024 && hFile)
896
 
        {
897
 
                va_list marker;
898
 
                va_start( marker, lpFormat);
899
 
                rc = fFPrintf1024(hFile,lpFormat,marker);
900
 
                va_end(marker);
901
 
        }
902
 
        return rc;
903
 
}
904
 
//////////////////////////////////////////////
905
 
Int32  LDPUMA_FPuts(Handle hFile,const char * lpString)
906
 
{
907
 
        Int32 rc = 0;
908
 
        if(fFPuts && hFile)
 
881
                return hFile;
 
882
        }
 
883
        //////////////////////////////////////////////
 
884
        void LDPUMA_FClose(Handle hFile)
 
885
        {
 
886
                if(fFClose && hFile)
 
887
                fFClose(hFile);
 
888
        }
 
889
        //////////////////////////////////////////////
 
890
        int32_t LDPUMA_FPrintf1024(Handle hFile,const char * lpFormat,...)
 
891
        {
 
892
                int32_t rc = 0;
 
893
                if(fFPrintf1024 && hFile)
 
894
                {
 
895
                        va_list marker;
 
896
                        va_start( marker, lpFormat);
 
897
                        rc = fFPrintf1024(hFile,lpFormat,marker);
 
898
                        va_end(marker);
 
899
                }
 
900
                return rc;
 
901
        }
 
902
        //////////////////////////////////////////////
 
903
        int32_t LDPUMA_FPuts(Handle hFile,const char * lpString)
 
904
        {
 
905
                int32_t rc = 0;
 
906
                if(fFPuts && hFile)
909
907
                rc = fFPuts(hFile,lpString);
910
 
        return rc;
911
 
}
912
 
//////////////////////////////////////////////
 
908
                return rc;
 
909
        }
 
910
        //////////////////////////////////////////////
913
911
#ifdef DPUMA_SNAP
914
912
 
915
913
#include "snptools.h"
916
914
 
917
 
void SnpSetTools(__SnpToolBox* tools)
918
 
{
919
 
        LDPUMA_Init(0,NULL);
920
 
};
921
 
void   SnpDrawFocusRect(Rect16* rc)
922
 
{
923
 
        LDPUMA_DrawFocusRect(NULL,rc);
924
 
}
925
 
Bool16 SnpGetUserLong(char * static_text,Int32 * result_long)
926
 
{
927
 
        return LDPUMA_MessageBoxYesNo(static_text);
928
 
};
929
 
Bool16 SnpGetUserString (char * static_text,
930
 
          char * result_string, Word32 result_string_length )
931
 
{
932
 
        return LDPUMA_MessageBoxYesNo(static_text);
933
 
};
934
 
Bool16 SnpGetUserRect( Rect16* rect )
935
 
{
936
 
        return LDPUMA_GetUserRect(NULL, rect );
937
 
}
938
 
Bool16 SnpGetUserPoint(Point16* pnt)
939
 
{
940
 
        return LDPUMA_GetUserPoint(NULL,pnt);
941
 
};
942
 
Word32 SnpWaitUserInput(SnpTreeNode* cur_node)
943
 
{
944
 
        return LDPUMA_WaitUserInput(cur_node ? *(Handle *)cur_node:NULL,NULL);
945
 
};
946
 
void SnpAddNode( SnpTreeNode *  node, const char * name,SnpTreeNode * parent )
947
 
{
948
 
        LDPUMA_Registry( node, name,parent ? *(Handle *)parent:NULL );
949
 
};
950
 
void SnpStartLoop( SnpTreeNode* node, Word32 iter_total )
951
 
{
952
 
        LDPUMA_StartLoop( node ? *(Handle *)node:NULL, iter_total );
953
 
};
954
 
void SnpLoopNext( SnpTreeNode* node )
955
 
{
956
 
        LDPUMA_LoopNext( node ? *(Handle *)node:NULL );
957
 
};
958
 
Bool16  SnpSkip( SnpTreeNode* node )
959
 
{
960
 
        return LDPUMA_Skip( node ? *(Handle *)node:NULL);
961
 
};
962
 
void SnpDrawRaster(RecRaster * raster)
963
 
{
964
 
        LDPUMA_DrawRaster((DPUMA_RecRaster *)raster);
965
 
};
966
 
void SnpRasterText(char * lpText)
967
 
{
968
 
        LDPUMA_RasterText(lpText);
969
 
};
970
 
void SnpZoomToRect(Rect16 * lpRect)
971
 
{
972
 
        LDPUMA_ZoomToRect(NULL,lpRect);
973
 
};
974
 
void SnpRasterHeader(char * lpText,Word32 num)
975
 
{
976
 
        LDPUMA_RasterHeader(lpText,num);
977
 
};
978
 
void   SnpDrawLine(Point16* start, Point16* end, Int32 skew,
979
 
      Word32 rgb_color, Int16 pen_width, Handle key )
980
 
{
981
 
        LDPUMA_DrawLine(NULL,start,end,skew,rgb_color,pen_width,key );
982
 
};
983
 
void   SnpHideLines(Handle key)
984
 
{
985
 
        LDPUMA_DeleteLines(NULL,key);
986
 
};
987
 
void   SnpUpdateViews(void)
988
 
{
989
 
        LDPUMA_UpdateView(NULL);
990
 
};
991
 
int  SnpLog(const char * message,...)
992
 
{
993
 
        int rc = 0;
994
 
        if(Console)
995
 
        {
996
 
                va_list marker;
997
 
                va_start( marker, message);
998
 
                rc = Console(message,marker);
999
 
                va_end(marker);
1000
 
        }
1001
 
        return rc;
1002
 
}
1003
 
void SnpStatusLine(const char * message,...)
1004
 
{
1005
 
        if(StatusLine)
1006
 
        {
1007
 
                va_list marker;
1008
 
                va_start( marker, message);
1009
 
                StatusLine(message,marker);
1010
 
                va_end(marker);
1011
 
        }
1012
 
}
1013
 
void   SnpMessBoxOk( char * message )
1014
 
{
1015
 
        LDPUMA_MessageBoxOk( message );
1016
 
}
1017
 
Bool16 SnpMessBoxYesNo( char * message)
1018
 
{
1019
 
        return LDPUMA_MessageBoxYesNo( message);
1020
 
};
1021
 
Bool SnpIsActive(void)
1022
 
{
1023
 
        return LDPUMA_IsActive();
1024
 
};
1025
 
void   SnpDrawRect(Rect16* rc, Int32 skew, Word32 rgb_color,
1026
 
      Int32 pen_width,Word32 key)
1027
 
{
1028
 
        LDPUMA_DrawRect(NULL,rc,skew,rgb_color,(Int16)pen_width,key);
1029
 
}
1030
 
void   SnpHideRects(Word32 key)
1031
 
{
1032
 
        LDPUMA_DeleteRects(NULL,key);
1033
 
}
1034
 
Word32 SnpSetZoneOn(Rect16*  zone_rect,
1035
 
          Word32   rgb_color,char* status_line_comment,
1036
 
          Word32  users_zone_handle, FTOnMouseDown  on_mouse_down )
1037
 
          { return 0; };
1038
 
void   SnpSetZoneOff( Word32 zone_handle ){;};
 
915
        void SnpSetTools(__SnpToolBox* tools)
 
916
        {
 
917
                LDPUMA_Init(0,NULL);
 
918
        };
 
919
        void SnpDrawFocusRect(Rect16* rc)
 
920
        {
 
921
                LDPUMA_DrawFocusRect(NULL,rc);
 
922
        }
 
923
        Bool16 SnpGetUserLong(char * static_text,int32_t * result_long)
 
924
        {
 
925
                return LDPUMA_MessageBoxYesNo(static_text);
 
926
        };
 
927
        Bool16 SnpGetUserString (char * static_text,
 
928
                        char * result_string, uint32_t result_string_length )
 
929
        {
 
930
                return LDPUMA_MessageBoxYesNo(static_text);
 
931
        };
 
932
        Bool16 SnpGetUserRect( Rect16* rect )
 
933
        {
 
934
                return LDPUMA_GetUserRect(NULL, rect );
 
935
        }
 
936
        Bool16 SnpGetUserPoint(Point16* pnt)
 
937
        {
 
938
                return LDPUMA_GetUserPoint(NULL,pnt);
 
939
        };
 
940
        uint32_t SnpWaitUserInput(SnpTreeNode* cur_node)
 
941
        {
 
942
                return LDPUMA_WaitUserInput(cur_node ? *(Handle *)cur_node:NULL,NULL);
 
943
        };
 
944
        void SnpAddNode( SnpTreeNode * node, const char * name,SnpTreeNode * parent )
 
945
        {
 
946
                LDPUMA_Registry( node, name,parent ? *(Handle *)parent:NULL );
 
947
        };
 
948
        void SnpStartLoop( SnpTreeNode* node, uint32_t iter_total )
 
949
        {
 
950
                LDPUMA_StartLoop( node ? *(Handle *)node:NULL, iter_total );
 
951
        };
 
952
        void SnpLoopNext( SnpTreeNode* node )
 
953
        {
 
954
                LDPUMA_LoopNext( node ? *(Handle *)node:NULL );
 
955
        };
 
956
        Bool16 SnpSkip( SnpTreeNode* node )
 
957
        {
 
958
                return LDPUMA_Skip( node ? *(Handle *)node:NULL);
 
959
        };
 
960
        void SnpDrawRaster(RecRaster * raster)
 
961
        {
 
962
                LDPUMA_DrawRaster((DPUMA_RecRaster *)raster);
 
963
        };
 
964
        void SnpRasterText(char * lpText)
 
965
        {
 
966
                LDPUMA_RasterText(lpText);
 
967
        };
 
968
        void SnpZoomToRect(Rect16 * lpRect)
 
969
        {
 
970
                LDPUMA_ZoomToRect(NULL,lpRect);
 
971
        };
 
972
        void SnpRasterHeader(char * lpText,uint32_t num)
 
973
        {
 
974
                LDPUMA_RasterHeader(lpText,num);
 
975
        };
 
976
        void SnpDrawLine(Point16* start, Point16* end, int32_t skew,
 
977
                        uint32_t rgb_color, int16_t pen_width, Handle key )
 
978
        {
 
979
                LDPUMA_DrawLine(NULL,start,end,skew,rgb_color,pen_width,key );
 
980
        };
 
981
        void SnpHideLines(Handle key)
 
982
        {
 
983
                LDPUMA_DeleteLines(NULL,key);
 
984
        };
 
985
        void SnpUpdateViews(void)
 
986
        {
 
987
                LDPUMA_UpdateView(NULL);
 
988
        };
 
989
        int SnpLog(const char * message,...)
 
990
        {
 
991
                int rc = 0;
 
992
                if(Console)
 
993
                {
 
994
                        va_list marker;
 
995
                        va_start( marker, message);
 
996
                        rc = Console(message,marker);
 
997
                        va_end(marker);
 
998
                }
 
999
                return rc;
 
1000
        }
 
1001
        void SnpStatusLine(const char * message,...)
 
1002
        {
 
1003
                if(StatusLine)
 
1004
                {
 
1005
                        va_list marker;
 
1006
                        va_start( marker, message);
 
1007
                        StatusLine(message,marker);
 
1008
                        va_end(marker);
 
1009
                }
 
1010
        }
 
1011
        void SnpMessBoxOk( char * message )
 
1012
        {
 
1013
                LDPUMA_MessageBoxOk( message );
 
1014
        }
 
1015
        Bool16 SnpMessBoxYesNo( char * message)
 
1016
        {
 
1017
                return LDPUMA_MessageBoxYesNo( message);
 
1018
        };
 
1019
        Bool SnpIsActive(void)
 
1020
        {
 
1021
                return LDPUMA_IsActive();
 
1022
        };
 
1023
        void SnpDrawRect(Rect16* rc, int32_t skew, uint32_t rgb_color,
 
1024
                        int32_t pen_width,uint32_t key)
 
1025
        {
 
1026
                LDPUMA_DrawRect(NULL,rc,skew,rgb_color,(int16_t)pen_width,key);
 
1027
        }
 
1028
        void SnpHideRects(uint32_t key)
 
1029
        {
 
1030
                LDPUMA_DeleteRects(NULL,key);
 
1031
        }
 
1032
        uint32_t SnpSetZoneOn(Rect16* zone_rect,
 
1033
                        uint32_t rgb_color,char* status_line_comment,
 
1034
                        uint32_t users_zone_handle, FTOnMouseDown on_mouse_down )
 
1035
        {       return 0;};
 
1036
        void SnpSetZoneOff( uint32_t zone_handle ) {;};
1039
1037
 
1040
 
void SnpNotifyAppl(SnpTreeNode* cur_node){;};
1041
 
// tree manipulation
1042
 
void __SnpIterParent( SnpTreeNode* node, Bool activate ){;};
 
1038
        void SnpNotifyAppl(SnpTreeNode* cur_node) {;};
 
1039
        // tree manipulation
 
1040
        void __SnpIterParent( SnpTreeNode* node, Bool activate ) {;};
1043
1041
#else
1044
 
int  SnpLog(const char * message,...)
1045
 
{
1046
 
        return 0;
1047
 
}
 
1042
        int SnpLog(const char * message,...)
 
1043
        {
 
1044
                return 0;
 
1045
        }
1048
1046
#endif
1049
 
//////////////////////////////////////////////////////////////////
1050
 
//////////////////////////////////////////////////////////////////
 
1047
        //////////////////////////////////////////////////////////////////
 
1048
        //////////////////////////////////////////////////////////////////
1051
1049
#ifdef __cplusplus
1052
1050
}
1053
1051
#endif