1 /*
2 * Author: William Chia-Wei Cheng (bill.cheng@acm.org)
3 *
4 * Copyright (C) 2001-2009, William Chia-Wei Cheng.
5 *
6 * This file may be distributed under the terms of the Q Public License
7 * as defined by Trolltech AS of Norway and appearing in the file
8 * LICENSE.QPL included in the packaging of this file.
9 *
10 * THIS FILE IS PROVIDED AS IS WITH NO WARRANTY OF ANY KIND, INCLUDING
11 * THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
12 * PURPOSE. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
13 * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
14 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
15 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
16 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 *
18 * @(#)$Header: /mm2/home/cvs/bc-src/tgif/xprtfltr.c,v 1.6 2011/05/16 16:22:00 william Exp $
19 */
20
21 #define _INCLUDE_FROM_XPRTFLTR_C_
22
23 #include "tgifdefs.h"
24 #include "expfdefs.h"
25
26 #include "color.e"
27 #include "dialog.e"
28 #include "drawing.e"
29 #include "file.e"
30 #include "grid.e"
31 #include "msg.e"
32 #include "names.e"
33 #include "obj.e"
34 #include "page.e"
35 #include "ps.e"
36 #include "raster.e"
37 #include "setup.e"
38 #include "strtbl.e"
39 #include "text.e"
40 #include "util.e"
41 #include "xbitmap.e"
42 #include "xprtfltr.e"
43
44 #ifndef _NO_DL_SUPPORT
45 #define CLOSE_DL(handle) dlclose(handle)
46 #define OPEN_DL(path,flag) dlopen((path),(flag))
47 #define GET_DL_SYM(handle,symbol) dlsym((handle),(symbol))
48 #ifndef RTLD_NOW
49 #define OPEN_DL_MODE 1
50 #else /* RTLD_NOW */
51 #define OPEN_DL_MODE (RTLD_NOW|RTLD_GLOBAL)
52 #endif /* ~RTLD_NOW */
53 #else /* _NO_DL_SUPPORT */
54 #define CLOSE_DL(handle)
55 #define OPEN_DL(path,flag) NULL
56 #define GET_DL_SYM(handle,symbol) NULL
57 #define OPEN_DL_MODE 0
58 #endif /* ~_NO_DL_SUPPORT */
59
60 int gnMaxExportFilters=0;
61
62 Pixmap *gaExportFilterBitmaps=NULL;
63
64 TgEFInfo *gpTgEFInfo=NULL;
65
66 /* --------------------- Utility Functions --------------------- */
67
68 static
GetSharedLibVersion(pszPath)69 int GetSharedLibVersion(pszPath)
70 char *pszPath;
71 {
72 char *psz=UtilStrRChr(pszPath, DIR_SEP), *psz1=NULL;
73 int nReturn=0;
74
75 if (psz == NULL) {
76 psz = pszPath;
77 } else {
78 psz++;
79 }
80 if ((psz=strchr(psz, '.')) == NULL) return 0;
81 if ((psz=strchr(++psz, '.')) == NULL) return 0;
82 if ((psz1=strchr(++psz, '.')) != NULL) {
83 *psz1 = '\0';
84 nReturn = atoi(psz);
85 *psz1 = '.';
86 } else {
87 nReturn = atoi(psz);
88 }
89 return nReturn;
90 }
91
92 static
TgEFSendMsg(pTgEFInfo,nUserInfo,nMsg,nArg,pvArg)93 long TgEFSendMsg(pTgEFInfo, nUserInfo, nMsg, nArg, pvArg)
94 TgEFInfo *pTgEFInfo;
95 int nUserInfo; /* if TRUE, use &pTgEFInfo->pTgEFUserInfo, else use NULL */
96 int nMsg; /* one of TGEF_MSG_* */
97 int nArg;
98 void *pvArg;
99 {
100 if (nUserInfo) {
101 return (pTgEFInfo->pfnTgEFMain)(&pTgEFInfo->pTgEFUserInfo,
102 nMsg, nArg, pvArg);
103 } else {
104 return (pTgEFInfo->pfnTgEFMain)(NULL, nMsg, nArg, pvArg);
105 }
106 }
107
108 /* --------------------- Global Routines --------------------- */
109
CleanUpExportFilters()110 void CleanUpExportFilters()
111 {
112 int i=0;
113
114 for (i=0; i < gnMaxExportFilters; i++) {
115 if (gaExportFilterBitmaps[i] != None) {
116 XFreePixmap(mainDisplay, gaExportFilterBitmaps[i]);
117 }
118 }
119 if (gpTgEFInfo != NULL) {
120 for (i=0; i < gnMaxExportFilters; i++) {
121 TgEFInfo *pTgEFInfo=(&gpTgEFInfo[i]);
122
123 if (pTgEFInfo != NULL) {
124 if (pTgEFInfo->pSharedLibHandle != NULL) {
125 TGEF_MAIN *pfnTgEFMain=pTgEFInfo->pfnTgEFMain;
126
127 if (pfnTgEFMain != NULL) {
128 TgEFSendMsg(pTgEFInfo, TRUE, TGEF_MSG_UNLOAD, 0, NULL);
129 TgEFSendMsg(pTgEFInfo, FALSE, TGEF_MSG_CLEANUP, 0, NULL);
130 }
131 CLOSE_DL(pTgEFInfo->pSharedLibHandle);
132 }
133 if (pTgEFInfo->pszSharedLibPath != NULL) {
134 UtilFree(pTgEFInfo->pszSharedLibPath);
135 }
136 }
137 }
138 free(gpTgEFInfo);
139 }
140 gpTgEFInfo = NULL;
141 }
142
143 static
SharedLibLoadFailed(pTgEFInfo,pszSharedLibPath,nNeedUnload)144 int SharedLibLoadFailed(pTgEFInfo, pszSharedLibPath, nNeedUnload)
145 TgEFInfo *pTgEFInfo;
146 char *pszSharedLibPath;
147 int nNeedUnload;
148 /*
149 * This is called when TGEF_MSG_LOAD failed for one reason or another.
150 */
151 {
152 if (nNeedUnload) {
153 TgEFSendMsg(pTgEFInfo, TRUE, TGEF_MSG_UNLOAD, 0, NULL);
154 }
155 TgEFSendMsg(pTgEFInfo, FALSE, TGEF_MSG_CLEANUP, 0, NULL);
156 CLOSE_DL(pTgEFInfo->pSharedLibHandle);
157 return FALSE;
158 }
159
160 static
LoadSharedLib(pszSharedLibPath)161 int LoadSharedLib(pszSharedLibPath)
162 char *pszSharedLibPath;
163 {
164 TgEFInfo *pTgEFInfo=(&gpTgEFInfo[gnMaxExportFilters]);
165 int nSharedLibVersion=0;
166 long lReturn=0L;
167
168 pTgEFInfo->pszSharedLibPath = UtilStrDup(pszSharedLibPath);
169 if (pTgEFInfo->pszSharedLibPath == NULL) {
170 FailAllocMessage();
171 }
172 pTgEFInfo->nSharedLibVersion =
173 GetSharedLibVersion(pTgEFInfo->pszSharedLibPath);
174 if (pTgEFInfo->nSharedLibVersion == 0) {
175 sprintf(gszMsgBox, TgLoadString(STID_INVALID_SHARELIB_VER_IN_FILE),
176 pszSharedLibPath);
177 MsgBox(gszMsgBox, TOOL_NAME, INFO_MB);
178 return FALSE;
179 }
180 pTgEFInfo->pSharedLibHandle = OPEN_DL(pszSharedLibPath, OPEN_DL_MODE);
181 if (pTgEFInfo->pSharedLibHandle == NULL) {
182 sprintf(gszMsgBox, TgLoadString(STID_FAIL_LOAD_SHARELIB),
183 pszSharedLibPath);
184 MsgBox(gszMsgBox, TOOL_NAME, INFO_MB);
185 return FALSE;
186 }
187 pTgEFInfo->pfnTgEFMain = (TGEF_MAIN*)GET_DL_SYM(pTgEFInfo->pSharedLibHandle,
188 TGEF_MAIN_NAME);
189 if (pTgEFInfo->pfnTgEFMain == NULL) {
190 sprintf(gszMsgBox, TgLoadString(STID_FAIL_GET_ENTRY_PT_IN_SHARELIB),
191 TGEF_MAIN_NAME, pszSharedLibPath);
192 MsgBox(gszMsgBox, TOOL_NAME, INFO_MB);
193 return FALSE;
194 }
195 lReturn = TgEFSendMsg(pTgEFInfo, FALSE, TGEF_MSG_INIT, 0, NULL);
196 if (lReturn != TGEF_STATUS_OK) {
197 sprintf(gszMsgBox, TgLoadString(STID_SHARELIB_TGEF_MSG_INIT_FAIL),
198 pszSharedLibPath, lReturn);
199 MsgBox(gszMsgBox, TOOL_NAME, INFO_MB);
200 CLOSE_DL(pTgEFInfo->pSharedLibHandle);
201 return FALSE;
202 }
203 nSharedLibVersion = TgEFSendMsg(pTgEFInfo, FALSE,
204 TGEF_MSG_GET_PROTOCOL_VERSION, 0, NULL);
205 if (nSharedLibVersion != pTgEFInfo->nSharedLibVersion) {
206 sprintf(gszMsgBox, TgLoadString(STID_SHARELIB_CNFLCT_PROTOCOL_VER),
207 nSharedLibVersion, pszSharedLibPath);
208 MsgBox(gszMsgBox, TOOL_NAME, INFO_MB);
209 CLOSE_DL(pTgEFInfo->pSharedLibHandle);
210 return FALSE;
211 }
212 switch (nSharedLibVersion) {
213 case 1:
214 memset(&pTgEFInfo->detail.stProtocolInfo_1, 0,
215 sizeof(TgEFProtocolInfo_1));
216
217 pTgEFInfo->detail.stProtocolInfo_1.dpy = mainDisplay;
218 pTgEFInfo->detail.stProtocolInfo_1.win = mainWindow;
219 pTgEFInfo->detail.stProtocolInfo_1.pfnMsgBox = (NLFN*)MsgBox;
220 pTgEFInfo->detail.stProtocolInfo_1.pfnDialog = (NLFN*)Dialog;
221 pTgEFInfo->detail.stProtocolInfo_1.pfnFailAllocMessage =
222 (NLFN*)FailAllocMessage;
223 pTgEFInfo->detail.stProtocolInfo_1.pfnUtilCopyFile = (NLFN*)UtilCopyFile;
224 pTgEFInfo->detail.stProtocolInfo_1.pfnObjInVisibleLayer =
225 (NLFN*)ObjInVisibleLayer;
226 pTgEFInfo->detail.stProtocolInfo_1.pfnUtilStrDup = (NLFN*)UtilStrDup;
227 pTgEFInfo->detail.stProtocolInfo_1.pfnUtilFree = (VDFN*)UtilFree;
228 pTgEFInfo->detail.stProtocolInfo_1.pfnMsg = (VDFN*)Msg;
229 pTgEFInfo->detail.stProtocolInfo_1.pfnSetStringStatus =
230 (VDFN*)SetStringStatus;
231 pTgEFInfo->detail.stProtocolInfo_1.pfnUtilTrimBlanks =
232 (VDFN*)UtilTrimBlanks;
233 pTgEFInfo->detail.stProtocolInfo_1.pfnDynStrSet = (VDFN*)DynStrSet;
234
235 strcpy(pTgEFInfo->detail.stProtocolInfo_1.sz_sl_path, pszSharedLibPath);
236 pTgEFInfo->detail.stProtocolInfo_1.bm_bits = NULL;
237 pTgEFInfo->detail.stProtocolInfo_1.bm_width = 0;
238 pTgEFInfo->detail.stProtocolInfo_1.bm_height = 0;
239 lReturn = TgEFSendMsg(pTgEFInfo, TRUE, TGEF_MSG_LOAD, 0,
240 &pTgEFInfo->detail.stProtocolInfo_1);
241 if (lReturn != TGEF_STATUS_OK) {
242 sprintf(gszMsgBox, TgLoadString(STID_SHARELIB_TGEF_MSG_LOAD_FAIL),
243 pszSharedLibPath, lReturn);
244 MsgBox(gszMsgBox, TOOL_NAME, INFO_MB);
245 return SharedLibLoadFailed(pTgEFInfo, pszSharedLibPath, FALSE);
246 }
247 if (pTgEFInfo->detail.stProtocolInfo_1.bm_bits == None) {
248 sprintf(gszMsgBox, TgLoadString(STID_SHARELIB_TGEF_MSG_LOAD_FAIL),
249 pszSharedLibPath);
250 MsgBox(gszMsgBox, TOOL_NAME, INFO_MB);
251 return SharedLibLoadFailed(pTgEFInfo, pszSharedLibPath, TRUE);
252 }
253 gaExportFilterBitmaps[gnMaxExportFilters] =
254 XCreateBitmapFromData(mainDisplay, mainWindow,
255 pTgEFInfo->detail.stProtocolInfo_1.bm_bits,
256 pTgEFInfo->detail.stProtocolInfo_1.bm_width,
257 pTgEFInfo->detail.stProtocolInfo_1.bm_height);
258 if (gaExportFilterBitmaps[gnMaxExportFilters] == None) {
259 sprintf(gszMsgBox, TgLoadString(STID_ALLOC_BMP_FAIL_FOR_SHARELIB),
260 pszSharedLibPath);
261 MsgBox(gszMsgBox, TOOL_NAME, INFO_MB);
262 return SharedLibLoadFailed(pTgEFInfo, pszSharedLibPath, TRUE);
263 }
264 break;
265 default:
266 sprintf(gszMsgBox, TgLoadString(STID_UNSUP_PROTOCOL_VER_SHARELIB),
267 nSharedLibVersion, pszSharedLibPath);
268 MsgBox(gszMsgBox, TOOL_NAME, INFO_MB);
269 CLOSE_DL(pTgEFInfo->pSharedLibHandle);
270 return FALSE;
271 }
272 return TRUE;
273 }
274
InitExportFilters()275 int InitExportFilters()
276 {
277 char *psz=NULL;
278
279 gnMaxExportFilters = 0;
280 if ((psz=XGetDefault(mainDisplay, TOOL_NAME, "MaxExportFilters")) !=
281 NULL) {
282 int nMax=atoi(psz);
283
284 if (nMax <= 0) {
285 sprintf(gszMsgBox, TgLoadString(STID_BAD_XDEF_MUST_BE_GT_0),
286 TOOL_NAME, "MaxExportFilters", psz);
287 MsgBox(gszMsgBox, TOOL_NAME, INFO_MB);
288 } else {
289 int i=0;
290
291 gpTgEFInfo = (TgEFInfo*)malloc(nMax*sizeof(TgEFInfo));
292 if (gpTgEFInfo == NULL) FailAllocMessage();
293 memset(gpTgEFInfo, 0, nMax*sizeof(TgEFInfo));
294 gaExportFilterBitmaps = (Pixmap*)malloc(nMax*sizeof(Pixmap));
295 if (gaExportFilterBitmaps == NULL) FailAllocMessage();
296 memset(gaExportFilterBitmaps, 0, nMax*sizeof(Pixmap));
297
298 for (i=0; i < nMax; i++) {
299 char szBuf[80];
300 int nOK=TRUE;
301
302 sprintf(szBuf, "ExportFilter%1d", i);
303 if ((psz=XGetDefault(mainDisplay, TOOL_NAME, szBuf)) == NULL) {
304 nOK = FALSE;
305 sprintf(gszMsgBox,
306 TgLoadString(STID_CANT_FIND_XDEF_CONT_LOOK_FLTR),
307 TOOL_NAME, szBuf);
308 if (MsgBox(gszMsgBox, TOOL_NAME, YNC_MB) != MB_ID_YES) {
309 break;
310 }
311 } else {
312 UtilTrimBlanks(psz);
313 nOK = LoadSharedLib(psz);
314 }
315 if (nOK) {
316 gnMaxExportFilters++;
317 }
318 }
319 if (gnMaxExportFilters > 0) {
320 whereToPrintPixmap = (Pixmap*)realloc(whereToPrintPixmap,
321 (MAXDEFWHERETOPRINT+gnMaxExportFilters)*sizeof(Pixmap));
322 if (whereToPrintPixmap == NULL) FailAllocMessage();
323 for (i=0; i < gnMaxExportFilters; i++) {
324 whereToPrintPixmap[MAXDEFWHERETOPRINT+i] =
325 gaExportFilterBitmaps[i];
326 }
327 maxWhereToPrint += gnMaxExportFilters;
328 }
329 }
330 }
331 return TRUE;
332 }
333
334 /* do not translate -- program constants */
335 static char *gpszColorExportName[MAXDEFWHERETOPRINT] = {
336 "Printer", "EPS", "PS", "XPM", "ASCII", "EPSI", "GIF/ISMAP", "HTML/USEMAP",
337 "PDF", "TiffEPSI", "PNG", "JPEG", "PPM", "NetList"
338 };
339
340 static char *gpszBWExportName[MAXDEFWHERETOPRINT] = {
341 "Printer", "EPS", "PS", "XBM", "ASCII", "EPSI", "GIF/ISMAP", "HTML/USEMAP",
342 "PDF", "TiffEPSI", "PNG", "JPEG", "PBM", "NetList"
343 };
344
345 static char *gpszColorExportExt[MAXDEFWHERETOPRINT] = {
346 NULL, EPSF_FILE_EXT, PS_FILE_EXT, XPM_FILE_EXT, TEXT_FILE_EXT,
347 EPSF_FILE_EXT, "gif", "html", "pdf", EPSF_FILE_EXT, "png", "jpg", "ppm",
348 NETLIST_FILE_EXT
349 };
350
351 static char *gpszBWExportExt[MAXDEFWHERETOPRINT] = {
352 NULL, EPSF_FILE_EXT, PS_FILE_EXT, XBM_FILE_EXT, TEXT_FILE_EXT,
353 EPSF_FILE_EXT, "gif", "html", "pdf", EPSF_FILE_EXT, "png", "jpg", "pbm",
354 NETLIST_FILE_EXT
355 };
356
GetExportIndex(nWhereToPrint,nMode)357 int GetExportIndex(nWhereToPrint, nMode)
358 int nWhereToPrint, nMode;
359 {
360 if (nMode == 0) {
361 } else if (nMode > 0 ){
362 nWhereToPrint = (nWhereToPrint+1) % maxWhereToPrint;
363 } else if (nMode < 0 ){
364 nWhereToPrint = (nWhereToPrint+maxWhereToPrint-1) % maxWhereToPrint;
365 }
366 return nWhereToPrint;
367 }
368
GetExportName(nWhereToPrint,nMode)369 char *GetExportName(nWhereToPrint, nMode)
370 int nWhereToPrint, nMode;
371 {
372 TgEFInfo *pTgEFInfo=NULL;
373
374 nWhereToPrint = GetExportIndex(nWhereToPrint, nMode);
375
376 if (nWhereToPrint < MAXDEFWHERETOPRINT) {
377 if (nWhereToPrint == NETLIST_FILE && preDumpSetup) {
378 /* do not translate -- program constants */
379 return "Component";
380 } else if (colorDump) {
381 return gpszColorExportName[nWhereToPrint];
382 } else {
383 return gpszBWExportName[nWhereToPrint];
384 }
385 }
386 if (gpTgEFInfo == NULL) return TgLoadCachedString(CSTID_PARANED_UNKNOWN);
387
388 pTgEFInfo = (&gpTgEFInfo[nWhereToPrint-MAXDEFWHERETOPRINT]);
389
390 switch (pTgEFInfo->nSharedLibVersion) {
391 case 1:
392 if (colorDump) {
393 return pTgEFInfo->detail.stProtocolInfo_1.color_format_name;
394 } else {
395 return pTgEFInfo->detail.stProtocolInfo_1.bw_format_name;
396 }
397 }
398 return TgLoadCachedString(CSTID_PARANED_UNKNOWN);
399 }
400
GetExportExt(nWhereToPrint)401 char *GetExportExt(nWhereToPrint)
402 int nWhereToPrint;
403 {
404 TgEFInfo *pTgEFInfo=NULL;
405
406 if (nWhereToPrint < MAXDEFWHERETOPRINT) {
407 if (nWhereToPrint == NETLIST_FILE && preDumpSetup) {
408 return COMP_FILE_EXT;
409 } else if (colorDump) {
410 return gpszColorExportExt[nWhereToPrint];
411 } else {
412 return gpszBWExportExt[nWhereToPrint];
413 }
414 }
415 if (gpTgEFInfo == NULL) return TgLoadCachedString(CSTID_PARANED_UNKNOWN);
416
417 pTgEFInfo = (&gpTgEFInfo[nWhereToPrint-MAXDEFWHERETOPRINT]);
418
419 switch (pTgEFInfo->nSharedLibVersion) {
420 case 1:
421 if (colorDump) {
422 return pTgEFInfo->detail.stProtocolInfo_1.color_ext;
423 } else {
424 return pTgEFInfo->detail.stProtocolInfo_1.bw_ext;
425 }
426 }
427 return TgLoadCachedString(CSTID_PARANED_UNKNOWN);
428 }
429
GetExportFilterCapability(nWhereToPrint)430 int GetExportFilterCapability(nWhereToPrint)
431 int nWhereToPrint;
432 {
433 TgEFInfo *pTgEFInfo=(&gpTgEFInfo[nWhereToPrint-MAXDEFWHERETOPRINT]);
434
435 switch (pTgEFInfo->nSharedLibVersion) {
436 case 1:
437 return pTgEFInfo->detail.stProtocolInfo_1.capability;
438 }
439 return 0;
440 }
441
442 static
ExportVectorFile_1(pTgEFInfo,pDumpFile,nPageNumInFileName,nPrintingPageNum,nPrintingFirstPageNum,nPrintingPageRow,nPrintingPageCol)443 int ExportVectorFile_1(pTgEFInfo, pDumpFile, nPageNumInFileName,
444 nPrintingPageNum, nPrintingFirstPageNum, nPrintingPageRow,
445 nPrintingPageCol)
446 TgEFInfo *pTgEFInfo;
447 FILE *pDumpFile;
448 int nPageNumInFileName, nPrintingPageNum, nPrintingFirstPageNum;
449 int nPrintingPageRow, nPrintingPageCol;
450 {
451 long lReturn=0L;
452
453 TgEFProtocolInfo_1 *pProtocolInfo_1=(&pTgEFInfo->detail.stProtocolInfo_1);
454
455 pProtocolInfo_1->fp = pDumpFile;
456 pProtocolInfo_1->color_dump = colorDump;
457 pProtocolInfo_1->color_layers = colorLayers;
458 pProtocolInfo_1->printing_page_num = nPrintingPageNum;
459 pProtocolInfo_1->printing_first_page_num = nPrintingFirstPageNum;
460 pProtocolInfo_1->printing_page_row = nPrintingPageRow;
461 pProtocolInfo_1->printing_page_col = nPrintingPageCol;
462 pProtocolInfo_1->page_layout_mode = pageLayoutMode;
463 pProtocolInfo_1->last_page_num = lastPageNum;
464 pProtocolInfo_1->top_obj = topObj;
465 pProtocolInfo_1->bot_obj = botObj;
466 pProtocolInfo_1->write_file_failed = FALSE;
467
468 lReturn = TgEFSendMsg(pTgEFInfo, TRUE, TGEF_MSG_DO_EXPORT, 0,
469 &pTgEFInfo->detail.stProtocolInfo_1);
470 if (lReturn != TGEF_STATUS_OK) {
471 sprintf(gszMsgBox, TgLoadString(STID_SHARELIB_TGEF_MSG_DO_EXPORT_F),
472 pTgEFInfo->pszSharedLibPath, lReturn);
473 MsgBox(gszMsgBox, TOOL_NAME, INFO_MB);
474 return FALSE;
475 }
476 if (pProtocolInfo_1->write_file_failed) writeFileFailed = TRUE;
477 return TRUE;
478 }
479
ExportVectorFile(pDumpFile,nPageNumInFileName,nPrintingPageNum,nPrintingFirstPageNum,nPrintingPageRow,nPrintingPageCol)480 int ExportVectorFile(pDumpFile, nPageNumInFileName, nPrintingPageNum,
481 nPrintingFirstPageNum, nPrintingPageRow, nPrintingPageCol)
482 FILE *pDumpFile;
483 int nPageNumInFileName, nPrintingPageNum, nPrintingFirstPageNum;
484 int nPrintingPageRow, nPrintingPageCol;
485 {
486 TgEFInfo *pTgEFInfo=(&gpTgEFInfo[whereToPrint-MAXDEFWHERETOPRINT]);
487
488 switch (pTgEFInfo->nSharedLibVersion) {
489 case 1:
490 return ExportVectorFile_1(pTgEFInfo, pDumpFile, nPageNumInFileName,
491 nPrintingPageNum, nPrintingFirstPageNum, nPrintingPageRow,
492 nPrintingPageCol);
493 }
494 return FALSE;
495 }
496
497