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