home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 June / PCWorld_1998-06_cd.bin / software / sharware / grafika / EROICA16 / UTDDE.C_ / UTDDE.C
C/C++ Source or Header  |  1998-01-15  |  98KB  |  4,040 lines
  1. /*-------------------------- Parallax Standard C_File ----------------------------
  2.       C_File: utdde.c
  3.       
  4.       Purpose: This file contains the C-interface for all Eroica's
  5.                DDE functions.
  6.               
  7.       
  8. --------------------------------------------------------------------------------
  9.           Copyright (c)1996 Parallax Software , All rights reserved.            
  10. ------------------------------------------------------------------------------*/
  11.  
  12. #include "dde_test.h"
  13.  
  14. #include <windows.h>
  15. #include <string.h>
  16. #include <stdio.h>
  17. #include <ddeml.h>
  18.  
  19. #include "utdde.h"
  20.  
  21. #include <stdlib.h>
  22. #include <malloc.h>
  23.  
  24. static DWORD IMG_Execute(HCONV ghConv, void FAR *szBuffer, WORD size, HDDEDATA* hData);
  25. static DWORD IMG_Request(HCONV ghConv, void FAR *szBuffer, HDDEDATA* hData);
  26. static int   IMG_GetData(HDDEDATA hData, char FAR* pData, int n) ;
  27.  
  28. char nulltitle[] = " ";
  29. #define SYNCTIMEOUT    120000L
  30. #define PARMSIZE       120
  31. #define STARTUP_PATH   "C:\\EROICA\\OTHER\\PICTUREZ\\"
  32.  
  33. /* ================ */
  34. /* global variables */
  35. /* ================ */
  36. HWND hViewWnd = NULL;
  37. static char pDdeErrMsg[] = "*Error - call failed.";
  38. extern void STS_Message(HWND, LPSTR);
  39.  
  40. /* 970224 jk add redefinitions of far string functions */
  41. #ifdef _WIN32
  42. static char *_fstrncpy(char *string1, const char *string2, size_t count)
  43. {
  44.   return strncpy(string1, string2, count) ;
  45. }
  46. static char *_fstrcpy(char *string1, const char *string2)
  47. {
  48.   return strcpy(string1, string2);
  49. }
  50. #endif
  51. /* 970224 jk end */
  52.  
  53. /* ========================================= Parallax C Function ==================
  54.  
  55.    @Name: _GetDocWin
  56.    @Desc: 
  57.  
  58. ============================================================================== */
  59.  
  60. int _GetDocWin(HCONV ghConv, char bMessage)
  61. {
  62.   DOCWINID hViewWnd = 0;
  63.   HDDEDATA hData = NULL;
  64.   DWORD   result;
  65.   DWORD   buf_size;
  66.  
  67. #ifdef __BORLANDC__
  68.   LPSTR   img_buf;
  69. #else
  70.   PSTR    img_buf;
  71. #endif
  72.   int     ret = FALSE;
  73.   HSZ     hszString;
  74.  
  75.   if (ghConv == NULL) goto cleanup;
  76.  
  77.   hszString = DdeCreateStringHandle(idInst, (LPSTR)"GETDOCWIN", CP_WINANSI);
  78.  
  79.   hData = DdeClientTransaction(NULL,
  80.                                0,
  81.                                ghConv,
  82.                                hszString,
  83.                                CF_TEXT,
  84.                                XTYP_REQUEST,
  85.                                3000,
  86.                                (DWORD FAR *)&result);
  87.                                  
  88.   DdeFreeStringHandle(idInst, hszString);
  89.  
  90.   if (hData)
  91.   {
  92.     buf_size = DdeGetData(hData, NULL, 0, 0L);
  93.     buf_size++;
  94.     img_buf = malloc((WORD)buf_size);
  95.     if (img_buf)
  96.     {
  97.       if (DdeGetData(hData, (LPSTR)img_buf, buf_size, 0L))
  98.       {
  99.         sscanf(img_buf, "%d", &hViewWnd);
  100.         ret = (int)hViewWnd;
  101.       } /* if (DdeGetData(hData, (LPSTR)img_buf, buf_size, 0L)) */
  102.  
  103.       free(img_buf);
  104.     } /* if (img_buf) */
  105.  
  106.     DdeFreeDataHandle(hData);
  107.   } /* if (hData) */
  108.  
  109. cleanup:
  110.   if ((!ret) && (bMessage == TRUE))
  111.   {
  112.     _MSG("**No active window.");
  113.   } /* if (!ret) */
  114.  
  115.   return (ret);
  116. } /* _GetDocWin() */
  117.  
  118. /* ========================================= Parallax C Function ==================
  119.  
  120.    @Name: _GetActiveEditLayer
  121.    @Desc: 
  122.  
  123. ============================================================================== */
  124.  
  125. LAYERID _GetActiveEditLayer(HCONV ghConv, DOCWINID docWinID)
  126. {
  127.   HDDEDATA hData;
  128.   char     szBuffer[256];
  129.   LAYERID  ret = 0;
  130.  
  131.   if (ghConv == NULL) goto cleanup;
  132.  
  133.   /* docWinID = 0 */
  134.   if (!docWinID)
  135.   {
  136.     HCONV ghConvLoc = ghConv;
  137.       
  138.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, FALSE);
  139.   } /* if (!docWinId) */
  140.    
  141.   if (!docWinID) return (0);
  142.  
  143.   wsprintf(szBuffer, "[GETACTIVELAYER(%d)]", docWinID);
  144.  
  145.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  146.  
  147.   if (hData)
  148.   {
  149.     char pData[2*PARMSIZE];
  150.  
  151.     int igd;
  152.     igd = IMG_GetData(hData, (char FAR*)pData, 2);
  153.       
  154.     if (igd == 2)
  155.     {
  156.       LAYERID tmp;
  157.       sscanf(&pData[PARMSIZE*1], "%d", &tmp);
  158.  
  159.       ret = tmp;
  160.     } /* if (igd == 2) */
  161.   } /* if (hData) */
  162.  
  163. cleanup:
  164.   return (ret);
  165. } /* _GetActiveEditLayer() */
  166.  
  167.  
  168. /* ========================================= Parallax C Function ==================
  169.  
  170.    @Name: img_ATOI
  171.    @Desc: 
  172.  
  173. ============================================================================== */
  174. int img_ATOI(LPSTR inStr)
  175. {
  176.   static char staticStr[21];
  177.  
  178.   _fstrncpy((LPSTR)staticStr, inStr, 20);
  179.  
  180.   return (atoi(staticStr));
  181. } /* img_ATOI() */
  182.  
  183. /* ========================================= Parallax C Function ==================
  184.  
  185.    @Name: img_ATOF
  186.    @Desc: 
  187.  
  188. ============================================================================== */
  189. float img_ATOF(LPSTR inStr)
  190. {
  191.   static char staticStr[21];
  192.  
  193.   _fstrncpy((LPSTR)staticStr, inStr, 20);
  194.  
  195.   return ((float)atof(staticStr));
  196. } /* img_ATOF() */
  197.  
  198. /* ========================================= Parallax C Function ==================
  199.  
  200.    @Name: IMG_GetData
  201.    @Desc: 
  202.  
  203. ============================================================================== */
  204. static int IMG_GetData(HDDEDATA hData, char FAR* pData, int n)
  205. {
  206.   DWORD buf_size;
  207.   char  pBuf[2000];
  208.   char* pTmp0;
  209.   char* pTmp1;
  210.   int i = 0;
  211.  
  212.   if (hData > (HDDEDATA)1)
  213.   {
  214.     buf_size = DdeGetData(hData, (void FAR *)NULL, 0, 0L);
  215.     buf_size++;
  216.     DdeGetData(hData, pBuf, buf_size, 0L);
  217.  
  218.     i = 0;
  219.     pTmp0 = (char*)pBuf;
  220.     pTmp1 = strchr(pTmp0, ',');
  221.  
  222.     while (pTmp1 != NULL && (i+1) < n)
  223.     {
  224.       *pTmp1 = 0;
  225.       lstrcpyn (&pData[PARMSIZE*i], (LPSTR)pTmp0, PARMSIZE);
  226.       pTmp0 = pTmp1+1;
  227.       pTmp1 = strchr(pTmp0, ',');
  228.       i++;
  229.     } /* while (pTmp1 != NULL && (i+1) < n) */
  230.     lstrcpyn (&pData[PARMSIZE*i], (LPSTR)pTmp0, PARMSIZE);
  231.     i++;
  232.  
  233.     DdeFreeDataHandle(hData);
  234.   } /* if (hData > (HDDEDATA)1) */
  235.  
  236.   return (i);
  237. } /* IMG_GetData() */
  238.  
  239. /* ========================================= Parallax C Function ==================
  240.  
  241.    @Name: IMG_Execute
  242.    @Desc: 
  243.  
  244. ============================================================================== */
  245.  
  246. static DWORD IMG_Execute(HCONV ghConv, void FAR *szBuffer, WORD size, HDDEDATA* hData)
  247. {
  248.   HDDEDATA hTmp;
  249.   DWORD    result = 0;
  250.  
  251.   STS_Message(ghWndMain, (LPSTR)szBuffer);
  252.  
  253.   hTmp = DdeClientTransaction(szBuffer, size, ghConv, NULL, CF_TEXT, XTYP_EXECUTE, SYNCTIMEOUT, &result);
  254.   if (hData!=0) *hData = hTmp;
  255.  
  256.   return (result);
  257. } /* IMG_Execute() */
  258.  
  259. /* ========================================= Parallax C Function ==================
  260.  
  261.    @Name: IMG_Request
  262.    @Desc: 
  263.  
  264. ============================================================================== */
  265.  
  266. static DWORD IMG_Request(HCONV ghConv, void FAR *szBuffer, HDDEDATA* hData)
  267. {
  268.   DWORD    result = 0;
  269.   HSZ      hszString;
  270.   HDDEDATA hTmp;
  271.  
  272.   STS_Message(ghWndMain, (LPSTR)szBuffer);
  273.  
  274.   hszString = DdeCreateStringHandle(idInst, (LPSTR)szBuffer, CP_WINANSI);
  275.  
  276.   hTmp = DdeClientTransaction(NULL, 0, ghConv, hszString, CF_TEXT, XTYP_REQUEST, SYNCTIMEOUT, (DWORD FAR *)&result);
  277.   if (hData!=0) *hData = hTmp;
  278.  
  279.   DdeFreeStringHandle(idInst, hszString);
  280.  
  281.   return (result);
  282. } /* IMG_Request() */
  283.  
  284. /* ========================================= Parallax C Function ==================
  285.  
  286.    @Name: IMG_Advise
  287.    @Desc: 
  288.  
  289. ============================================================================== */
  290.  
  291. static DWORD IMG_Advise(HCONV ghConv, void FAR *szBuffer, HDDEDATA* hData)
  292. {
  293.   DWORD    result = 0;
  294.   HSZ      hszString;
  295.   HDDEDATA hTmp;
  296.  
  297.   STS_Message(ghWndMain, (LPSTR)szBuffer);
  298.  
  299.   hszString = DdeCreateStringHandle(idInst, (LPSTR)szBuffer, CP_WINANSI);
  300.  
  301.   hTmp = DdeClientTransaction(NULL, 0, ghConv, hszString, CF_TEXT, XTYP_ADVSTART, SYNCTIMEOUT, (DWORD FAR *)&result);
  302.   if (hData!=0) *hData = hTmp;
  303.  
  304.   DdeFreeStringHandle(idInst, hszString);
  305.  
  306.   return (result);
  307. } /* IMG_Advise */
  308.  
  309. /* ========================================= Parallax C Function ==================
  310.  
  311.    @Name: IMG_AdviseStop
  312.    @Desc: 
  313.  
  314. ============================================================================== */
  315.  
  316. static DWORD IMG_AdviseStop(HCONV ghConv, void FAR *szBuffer, HDDEDATA* hData)
  317. {
  318.   DWORD    result = 0;
  319.   HSZ      hszString;
  320.   HDDEDATA hTmp;
  321.  
  322.   STS_Message(ghWndMain, (LPSTR)szBuffer);
  323.  
  324.   hszString = DdeCreateStringHandle(idInst, (LPSTR)szBuffer, CP_WINANSI);
  325.  
  326.   hTmp = DdeClientTransaction(NULL, 0, ghConv, hszString, CF_TEXT, XTYP_ADVSTOP, SYNCTIMEOUT, (DWORD FAR *)&result);
  327.   if (hData!=0) *hData = hTmp;
  328.  
  329.   DdeFreeStringHandle(idInst, hszString);
  330.  
  331.   return (result);
  332. } /* IMG_AdviseStop */
  333.  
  334. /* ========================================= Parallax C Function ==================
  335.  
  336.    @Name: IMG_Connect
  337.    @Desc: 
  338.  
  339. ============================================================================== */
  340.  
  341. HCONV IMG_Connect(HWND ghWndMain, DWORD idInst, HSZ hszServer, HSZ ghszTopic)
  342. {
  343.   HCONV        ghConv = NULL;
  344.   static char  IMG_Connect_szBuffer[256];
  345.   WORD         wError;
  346.  
  347.   if ( ghWndMain );
  348.  
  349.   ghConv = DdeConnect(idInst, hszServer, ghszTopic, (LPVOID)NULL);
  350.   if (!ghConv)
  351.   {
  352.     wError = (WORD)DdeGetLastError(idInst);
  353. /* removed by Cerda
  354.     wsprintf((LPSTR)IMG_Connect_szBuffer, (LPSTR)"Error - DDE Connect failed.  Error #%#0x.", wError);
  355.     STS_Message((HWND)ghWndMain, (LPSTR)IMG_Connect_szBuffer);
  356. */
  357.     _FMTMSG( "**Err #%#0x - DDE Connect failed.", wError);
  358.     _MSG( "Check if EROICA.EXE is running." );
  359.   } /* if (!ghConv) */
  360.  
  361.   return (ghConv);
  362. } /* IMG_Connect() */
  363.  
  364. /* ========================================= Parallax C Function ==================
  365.  
  366.    @Name: IMG_StartUp
  367.    @Desc: 
  368.  
  369. ============================================================================== */
  370. int IMG_StartUp(HCONV ghConv)
  371. {
  372.   char  szBuffer[256];
  373.   WORD  size;
  374.   int   ret = FALSE;
  375.  
  376.   if (ghConv == NULL) goto cleanup;
  377.  
  378.   wsprintf(szBuffer, "[OPENDOCWIN(0, 0, \"" STARTUP_PATH "16cx.tif\", \"16cx (TIF)\", 10, 0, 0)]");
  379.   size = (WORD)(lstrlen(szBuffer) + 1);
  380.   IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL);
  381.  
  382.   wsprintf(szBuffer, "[OPENDOCWIN(0, 0, \"" STARTUP_PATH "256cx.tif\", \"256cx (TIF)\", 10, 0, 0)]");
  383.   size = (WORD)(lstrlen(szBuffer) + 1);
  384.   IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL);
  385.  
  386.   wsprintf(szBuffer, "[OPENDOCWIN(0, 0, \"" STARTUP_PATH "16mcx.tif\", \"16mcx (TIF)\", 10, 0, 0)]");
  387.   size = (WORD)(lstrlen(szBuffer) + 1);
  388.   IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL);
  389.  
  390.   wsprintf(szBuffer, "[OPENDOCWIN(0, 0, \"" STARTUP_PATH "edit16.clf\", \"edit16 (CLF)\", 10, 0, 0)]");
  391.   size = (WORD)(lstrlen(szBuffer) + 1);
  392.   IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL);
  393.  
  394.   wsprintf(szBuffer, "[OPENDOCWIN(0, 0, \"" STARTUP_PATH "edit256.clf\", \"edit256 (CLF)\", 10, 0, 0)]");
  395.   size = (WORD)(lstrlen(szBuffer) + 1);
  396.   IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL);
  397.  
  398.   wsprintf(szBuffer, "[OPENDOCWIN(0, 0, \"" STARTUP_PATH "edit16m.clf\", \"edit16m (CLF)\", 10, 0, 0)]");
  399.   size = (WORD)(lstrlen(szBuffer) + 1);
  400.   IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL);
  401.  
  402.   wsprintf(szBuffer, "[ARRANGEDOCWINS(1)]");
  403.   size = (WORD)(lstrlen(szBuffer) + 1);
  404.   IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL);
  405.  
  406.   wsprintf(szBuffer, "[SETDOCWIN(5, 0)]");
  407.   size = (WORD)(lstrlen(szBuffer) + 1);
  408.   IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL);
  409.  
  410.   /* window 5 layer 2 - FullEdit */
  411.   wsprintf(szBuffer, "[SETACTIVELAYER(5, 1030, 1)]");
  412.   size = (WORD)(lstrlen(szBuffer) + 1);
  413.   IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL);
  414.  
  415.   ret = TRUE;
  416.  
  417. cleanup:
  418.   if (!ret) _MSG(pDdeErrMsg);
  419.  
  420.   return (TRUE);
  421. } /* IMG_StartUp() */
  422.  
  423. /* ========================================= Parallax C Function ==================
  424.  
  425.    @Name: IMG_RasterDPIChange
  426.    @Desc: 
  427.  
  428. ============================================================================== */
  429. int IMG_RasterDPIChange(HCONV ghConv, int xres, int yres)
  430. {
  431.   char  szBuffer[256];
  432.   WORD  size;
  433.   int   ret = FALSE;
  434.   HCONV ghConvLoc = ghConv;
  435.  
  436.   if (ghConv == NULL) goto cleanup;
  437.  
  438.  
  439.   if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE))
  440.   {
  441.     _MSG("No open document. Cannot change Raster DPI.");
  442.  
  443.     ret = TRUE;
  444.   } else /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  445.   {
  446.     _FMTMSG2("Raster DPI change to %d x %d.", xres, yres);
  447.    
  448.     wsprintf(szBuffer, "[CHANGERASTER(0, 0, %d, %d, 0, 0, 0)]", xres, yres);
  449.     size = (WORD)(lstrlen(szBuffer) + 1);
  450.     if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  451.   } /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  452.  
  453. cleanup:
  454.   if (!ret) _MSG(pDdeErrMsg);
  455.  
  456.    return (ret);
  457. } /* IMG_RasterDPIChange() */
  458.  
  459. /* ========================================= Parallax C Function ==================
  460.  
  461.    @Name: IMG_ArrangeDocWins
  462.    @Desc: 
  463.  
  464. ============================================================================== */
  465.  
  466. int IMG_ArrangeDocWins(HCONV ghConv, int arrangement)
  467. {
  468.   char  szBuffer[256];
  469.   WORD  size;
  470.   int   ret = FALSE;
  471.  
  472.   HCONV ghConvLoc = ghConv;
  473.  
  474.   if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE))
  475.   {
  476.     _MSG("No open windows. Nothing to arrange.");
  477.  
  478.     ret = TRUE;
  479.   } else /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  480.   {
  481.     switch (arrangement)
  482.     {
  483.       case ARRANGE_TILE:
  484.       {
  485.         _MSG("Arrange windows by tiling.");
  486.  
  487.         break;
  488.       } /* case ARRANGE_TILE */
  489.  
  490.       case ARRANGE_CASCADE:
  491.       {
  492.         _MSG("Arrange windows by cascading.");
  493.  
  494.         break;
  495.       } /* case ARRANGE_CASCADE */
  496.  
  497.       case ARRANGE_HORZSTRIP:
  498.       {
  499.         _MSG("Arrange windows by horizontal strips.");
  500.  
  501.         break;
  502.       } /* case ARRANGE_HORSTRIP */
  503.  
  504.       case ARRANGE_VERTSTRIP:
  505.       {
  506.         _MSG("Arrange windows by vertical strips.");
  507.  
  508.         break;
  509.       } /* case ARRANGE_HORSTRIP */
  510.  
  511.       default:
  512.       {
  513.         _FMTMSG("Arrange windows by %d.", arrangement);
  514.  
  515.         break;
  516.       } /* case default */
  517.     } /* switch (arrangement) */
  518.  
  519.     if (ghConv == NULL) goto cleanup;
  520.  
  521.     wsprintf(szBuffer, "[ARRANGEDOCWINS(%d)]", arrangement);
  522.  
  523.     size = (WORD)(lstrlen(szBuffer) + 1);
  524.     if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  525.   } /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  526.  
  527. cleanup:
  528.   if (!ret) _MSG(pDdeErrMsg);
  529.  
  530.   return (ret);
  531. } /* IMG_ArrangeDocWins() */
  532.  
  533. /* ========================================= Parallax C Function ==================
  534.  
  535.    @Name: IMG_NotifyHotSpot
  536.    @Desc: 
  537.  
  538. ============================================================================== */
  539.  
  540. int IMG_NotifyHotSpot(HCONV ghConv)
  541. {
  542.   char  szBuffer[256];
  543.   int   ret = FALSE;
  544.  
  545.   _MSG("Notify of HotSpot Activation.");
  546.  
  547.   if (ghConv == NULL) goto cleanup;
  548.  
  549.   lstrcpy(szBuffer, "NotifyIM -- HotSpotActivated");
  550.  
  551.   if (IMG_Advise(ghConv, (void FAR*)szBuffer, NULL) == DDE_FACK) ret = TRUE;
  552.  
  553. cleanup:
  554.   if (!ret) _MSG(pDdeErrMsg);
  555.  
  556.   return (ret);
  557. } /* IMG_NotifyHotSpot() */
  558.  
  559.  
  560. /* ========================================= Parallax C Function ==================
  561.  
  562.    @Name: IMG_NotifyHotSpotPlaced
  563.    @Desc: 
  564.  
  565. ============================================================================== */
  566.  
  567. int IMG_NotifyHotSpotPlaced(HCONV ghConv)
  568. {
  569.   char  szBuffer[256];
  570.   int   ret = FALSE;
  571.  
  572.   _MSG("Notify of HotSpot Placement.");
  573.  
  574.   if (ghConv == NULL) goto cleanup;
  575.  
  576.   lstrcpy(szBuffer, "NotifyIM -- HotSpotPlaced");
  577.  
  578.   if (IMG_Advise(ghConv, (void FAR*)szBuffer, NULL) == DDE_FACK) ret = TRUE;
  579.  
  580. cleanup:
  581.   if (!ret) _MSG(pDdeErrMsg);
  582.  
  583.   return (ret);
  584. } /* IMG_NotifyHotSpotPlaced() */
  585.  
  586.  
  587. /* ========================================= Parallax C Function ==================
  588.  
  589.    @Name: IMG_NotifyHotSpotHighlighted
  590.    @Desc: 
  591.  
  592. ============================================================================== */
  593.  
  594. int IMG_NotifyHotSpotHighlighted(HCONV ghConv)
  595. {
  596.   char  szBuffer[256];
  597.   int   ret = FALSE;
  598.  
  599.   _MSG("Notify of HotSpot Highlight.");
  600.  
  601.   if (ghConv == NULL) goto cleanup;
  602.  
  603.   lstrcpy(szBuffer, "NotifyIM -- HotSpotHighlighted");
  604.  
  605.   if (IMG_Advise(ghConv, (void FAR*)szBuffer, NULL) == DDE_FACK) ret = TRUE;
  606.  
  607. cleanup:
  608.   if (!ret) _MSG(pDdeErrMsg);
  609.  
  610.   return (ret);
  611. } /* IMG_NotifyHotSpotHighlighted() */
  612.  
  613. /* ========================================= Parallax C Function ==================
  614.  
  615.    @Name: IMG_NotifyApi
  616.    @Desc: 
  617.  
  618. ============================================================================== */
  619.  
  620. int IMG_NotifyApi(HCONV ghConv)
  621. {
  622.   char  szBuffer[256];
  623.   int   ret = FALSE;
  624.  
  625.   _MSG("Notify of API Use.");
  626.  
  627.   if (ghConv == NULL) goto cleanup;
  628.  
  629.   lstrcpy(szBuffer, "NotifyIM -- API In Use");
  630.  
  631.   if (IMG_Advise(ghConv, (void FAR*)szBuffer, NULL) == DDE_FACK) ret = TRUE;
  632.  
  633. cleanup:
  634.   if (!ret) _MSG(pDdeErrMsg);
  635.  
  636.   return (ret);
  637. } /* IMG_NotifyApi() */
  638.  
  639. /* ========================================= Parallax C Function ==================
  640.  
  641.    @Name: IMG_NotifyHotSpotPlacedStop
  642.    @Desc: 
  643.  
  644. ============================================================================== */
  645.  
  646. int IMG_NotifyHotSpotPlacedStop(HCONV ghConv)
  647. {
  648.   char  szBuffer[256];
  649.   int   ret = FALSE;
  650.  
  651.   _MSG("Stop Notification of HotSpot Placement.");
  652.  
  653.   if (ghConv == NULL) goto cleanup;
  654.  
  655.   lstrcpy(szBuffer, "NotifyIM -- HotSpotPlaced");
  656.  
  657.   if (IMG_AdviseStop(ghConv, (void FAR*)szBuffer, NULL) == DDE_FACK) ret = TRUE;
  658.  
  659. cleanup:
  660.   if (!ret) _MSG(pDdeErrMsg);
  661.  
  662.   return (ret);
  663. } /* IMG_NotifyHotSpotPlacedStop() */
  664.  
  665. /* ========================================= Parallax C Function ==================
  666.  
  667.    @Name: IMG_NotifyHotSpotHighlightedStop
  668.    @Desc: 
  669.  
  670. ============================================================================== */
  671.  
  672. int IMG_NotifyHotSpotHighlightedStop(HCONV ghConv)
  673. {
  674.   char  szBuffer[256];
  675.   int   ret = FALSE;
  676.  
  677.   _MSG("Stop Notification of HotSpot Highlight.");
  678.  
  679.   if (ghConv == NULL) goto cleanup;
  680.  
  681.   lstrcpy(szBuffer, "NotifyIM -- HotSpotHighlighted");
  682.  
  683.   if (IMG_AdviseStop(ghConv, (void FAR*)szBuffer, NULL) == DDE_FACK) ret = TRUE;
  684.  
  685. cleanup:
  686.   if (!ret) _MSG(pDdeErrMsg);
  687.  
  688.   return (ret);
  689. } /* IMG_NotifyHotSpotHighlightedStop() */
  690.  
  691.  
  692. /* ========================================= Parallax C Function ==================
  693.  
  694.    @Name: IMG_NotifyHotSpotStop
  695.    @Desc: 
  696.  
  697. ============================================================================== */
  698.  
  699. int IMG_NotifyHotSpotStop(HCONV ghConv)
  700. {
  701.   char  szBuffer[256];
  702.   int   ret = FALSE;
  703.  
  704.   _MSG("Stop Notification of HotSpot Activation.");
  705.  
  706.   if (ghConv == NULL) goto cleanup;
  707.  
  708.   lstrcpy(szBuffer, "NotifyIM -- HotSpotActivated");
  709.  
  710.   if (IMG_AdviseStop(ghConv, (void FAR*)szBuffer, NULL) == DDE_FACK) ret = TRUE;
  711.  
  712. cleanup:
  713.   if (!ret) _MSG(pDdeErrMsg);
  714.  
  715.   return (ret);
  716. } /* IMG_NotifyHotSpotStop() */
  717.  
  718. /* ========================================= Parallax C Function ==================
  719.  
  720.    @Name: IMG_NotifyApiStop
  721.    @Desc: 
  722.  
  723. ============================================================================== */
  724.  
  725. int IMG_NotifyApiStop(HCONV ghConv)
  726. {
  727.   char  szBuffer[256];
  728.   int   ret = FALSE;
  729.  
  730.   _MSG("Stop Notification of API Use.");
  731.  
  732.   if (ghConv == NULL) goto cleanup;
  733.  
  734.   lstrcpy(szBuffer, "NotifyIM -- API In Use");
  735.  
  736.   if (IMG_AdviseStop(ghConv, (void FAR*)szBuffer, NULL) == DDE_FACK) ret = TRUE;
  737.  
  738. cleanup:
  739.   if (!ret) _MSG(pDdeErrMsg);
  740.  
  741.   return (ret);
  742. } /* IMG_NotifyApiStop() */
  743.  
  744. /* ========================================= Parallax C Function ==================
  745.  
  746.    @Name: IMG_Checkin
  747.    @Desc: 
  748.  
  749. ============================================================================== */
  750.  
  751. int IMG_Checkin(HCONV ghConv, DOCWINID docWinID, BOOL bClose)
  752. {
  753.   char  szBuffer[256];
  754.   WORD  size;
  755.   int   ret = FALSE;
  756.  
  757.   /* docWinID = 0 */
  758.   if (!docWinID)
  759.   {
  760.     HCONV ghConvLoc = ghConv;
  761.  
  762.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  763.   } /* if (!docWinID) */
  764.  
  765.   if (!docWinID) return (FALSE);
  766.  
  767.   if (bClose)
  768.   {
  769.     _FMTMSG("Checkin and close docWinID %d.", docWinID);
  770.   } else /* if (bClose) */
  771.   {
  772.     _FMTMSG("Checkin docWinID %d.", docWinID);
  773.   } /* if (bClose) */
  774.  
  775.   if (ghConv == NULL) goto cleanup;
  776.  
  777.   wsprintf(szBuffer, "[CHECKIN(%d,%d)]", docWinID, bClose);
  778.  
  779.   size = (WORD)(lstrlen(szBuffer) + 1);
  780.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  781.  
  782. cleanup:
  783.   if (!ret) _MSG(pDdeErrMsg);
  784.  
  785.   return (ret);
  786. } /* IMG_Checkin() */
  787.  
  788. /* ========================================= Parallax C Function ==================
  789.  
  790.    @Name: IMG_CheckinAll
  791.    @Desc: 
  792.  
  793. ============================================================================== */
  794.  
  795. int IMG_CheckinAll(HCONV ghConv, BOOL bClose)
  796. {
  797.   char  szBuffer[256];
  798.   WORD  size;
  799.   int   ret = FALSE;
  800.  
  801.   if (bClose)
  802.   {
  803.     _MSG("Checkin and close all docWins.");
  804.   } else /* if (bClose) */
  805.   {
  806.     _MSG("Checkin all docWins");
  807.   } /* if (bClose) */
  808.  
  809.   if (ghConv == NULL) goto cleanup;
  810.  
  811.   wsprintf(szBuffer, "[CHECKINALL(%d)]", bClose);
  812.  
  813.   size = (WORD)(lstrlen(szBuffer) + 1);
  814.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  815.  
  816. cleanup:
  817.   if (!ret) _MSG(pDdeErrMsg);
  818.  
  819.   return (ret);
  820. } /* IMG_CheckinAll() */
  821.  
  822. /* ========================================= Parallax C Function ==================
  823.  
  824.    @Name: IMG_CloseAllDocWin
  825.    @Desc: 
  826.  
  827. ============================================================================== */
  828.  
  829. int IMG_CloseAllDocWin(HCONV ghConv, BOOL bSave)
  830. {
  831.   char  szBuffer[256];
  832.   WORD  size;
  833.   int   ret = FALSE;
  834.  
  835.   HCONV ghConvLoc = ghConv;
  836.  
  837.   if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE))
  838.   {
  839.     _MSG("No open windows. Nothing to close.");
  840.  
  841.     ret = TRUE;
  842.   } else /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  843.   {
  844.     if (bSave)
  845.     {
  846.       _MSG("Save and close all docWins");
  847.     } else /* if (bSave) */
  848.     {
  849.       _MSG("Close all docWins");
  850.     } /* if (bSave) */
  851.  
  852.     if (ghConv == NULL) goto cleanup;
  853.  
  854.     wsprintf(szBuffer, "[CLOSEALLDOCWIN(%d)]", bSave);
  855.  
  856.     size = (WORD)(lstrlen(szBuffer) + 1);
  857.     if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  858.   } /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  859.  
  860. cleanup:
  861.   if (!ret) _MSG(pDdeErrMsg);
  862.  
  863.   return (ret);
  864. } /* IMG_CloseAllDocWin() */
  865.  
  866. /* ========================================= Parallax C Function ==================
  867.  
  868.    @Name: IMG_CloseDocWin
  869.    @Desc: 
  870.  
  871. ============================================================================== */
  872.  
  873. int IMG_CloseDocWin(HCONV ghConv, DOCWINID docWinID, BOOL bSave)
  874. {
  875.   char  szBuffer[256];
  876.   WORD  size;
  877.   int   ret = FALSE;
  878.     
  879.   /* docWinID = 0 */
  880.   if (!docWinID)
  881.   {
  882.     HCONV ghConvLoc = ghConv;
  883.  
  884.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  885.   } /* if (!docWinID) */
  886.    
  887.   if (!docWinID) return (FALSE);
  888.  
  889.   if (bSave)
  890.   {
  891.     _FMTMSG("Save and close docWinID %d.", docWinID);
  892.   } else /* if (bSave) */
  893.   {
  894.     _FMTMSG("Close docWinID %d.", docWinID);
  895.   } /* if (bSave) */
  896.  
  897.   if (ghConv == NULL) goto cleanup;
  898.  
  899.   wsprintf(szBuffer, "[CLOSEDOCWIN(%d,%d)]", docWinID, bSave);
  900.  
  901.   size = (WORD)(lstrlen(szBuffer) + 1);
  902.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  903.  
  904. cleanup:
  905.   if (!ret) _MSG(pDdeErrMsg);
  906.  
  907.   return (ret);
  908. } /* IMG_CloseDocWin() */
  909.  
  910. /* ========================================= Parallax C Function ==================
  911.  
  912.    @Name: IMG_CreateDocWin
  913.    @Desc: 
  914.  
  915. ============================================================================== */
  916.  
  917. int IMG_CreateDocWin(HCONV ghConv, void FAR* title, DOCWINID FAR* docWinID)
  918. {
  919.   HDDEDATA hData;
  920.   char     szBuffer[256];
  921.   int      ret = FALSE;
  922.  
  923.   if (title == NULL) title = (void FAR*)nulltitle;
  924.  
  925.   _FMTMSG("Create docWin with title \"%s\".", title);
  926.  
  927.   if (ghConv == NULL) goto cleanup;
  928.  
  929.   wsprintf(szBuffer, "[CREATEDOCWIN (\"%s\")]", (LPSTR)title);
  930.  
  931.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  932.  
  933.   if (hData)
  934.   {
  935.     char pData[2*PARMSIZE];
  936.       
  937.     int igd;
  938.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  939.       
  940.     if (igd == 1)
  941.     {
  942.       int tmp = 0;
  943.  
  944.       sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  945.  
  946.       if (docWinID) *docWinID = tmp;
  947.  
  948.       _FMTMSG("   Created docWinID %d.", tmp);
  949.  
  950.       ret = TRUE;
  951.     } /* if (igd == 1) */
  952.   } /* if (hData) */
  953.  
  954. cleanup:
  955.   if (!ret) _MSG(pDdeErrMsg);
  956.  
  957.   return (ret);
  958. } /* IMG_CreateDocWin() */
  959.  
  960. /* ========================================= Parallax C Function ==================
  961.  
  962.    @Name: IMG_DeleteLayer
  963.    @Desc: 
  964.  
  965. ============================================================================== */
  966.  
  967. int IMG_DeleteLayer(HCONV ghConv, DOCWINID docWinID, LAYERID layerID)
  968. {
  969.   char  szBuffer[256];
  970.   WORD  size;
  971.   int   ret = FALSE;
  972.  
  973.   _FMTMSG2("Delete layerID %d of docWin %d.", layerID, docWinID);
  974.  
  975.   if (ghConv == NULL) goto cleanup;
  976.  
  977.   /* docWinID = 0 */
  978.   if (!docWinID)
  979.   {
  980.     HCONV ghConvLoc = ghConv;
  981.       
  982.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  983.   } /* if (!docWinID) */
  984.    
  985.   if (!docWinID) return (FALSE);
  986.  
  987.   wsprintf(szBuffer, "[DELETELAYER(%d,%d)]", docWinID, layerID);
  988.  
  989.   size = (WORD)(lstrlen(szBuffer) + 1);
  990.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  991.  
  992. cleanup:
  993.   if (!ret) _MSG(pDdeErrMsg);
  994.  
  995.   return (ret);
  996. } /* IMG_DeleteLayer() */
  997.  
  998. /* ========================================= Parallax C Function ==================
  999.  
  1000.    @Name: IMG_EndEroica
  1001.    @Desc: 
  1002.  
  1003. ============================================================================== */
  1004.  
  1005. int IMG_EndEroica(HCONV ghConv)
  1006. {
  1007.   char  szBuffer[256];
  1008.   WORD  size;
  1009.   int   ret = FALSE;
  1010.  
  1011.   _MSG("End program.");
  1012.  
  1013.   if (ghConv == NULL) goto cleanup;
  1014.  
  1015.   wsprintf(szBuffer, "[ENDFRAME]");
  1016.  
  1017.   size = (WORD)(lstrlen(szBuffer) + 1);
  1018.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  1019.  
  1020. cleanup:
  1021.   if (!ret) _MSG(pDdeErrMsg);
  1022.  
  1023.   return (ret);
  1024. } /* IMG_EndEroica() */
  1025.  
  1026. /* ========================================= Parallax C Function ==================
  1027.  
  1028.    @Name: IMG_ExportLayer
  1029.    @Desc: 
  1030.  
  1031. ============================================================================== */
  1032.  
  1033. int IMG_ExportLayer(HCONV ghConv, DOCWINID docWinID, LAYERID layerID, BOOL bSaveAs, void FAR* fname, void FAR* title, BOOL bOverwrite)
  1034. {
  1035.   char  szBuffer[256];
  1036.   WORD  size;
  1037.   int   ret = FALSE;
  1038.  
  1039.   if (title == NULL) title=(void FAR*)nulltitle;
  1040.  
  1041.   /* docWinID = 0 */
  1042.   if (!docWinID)
  1043.   {
  1044.     HCONV ghConvLoc = ghConv;
  1045.       
  1046.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1047.   } /* if (!docWinID) */
  1048.    
  1049.   if (!docWinID) return (FALSE);
  1050.  
  1051.   _FMTMSG2("Export layerID %d of docWin %d.", layerID, docWinID);
  1052.   _FMTMSG( "   Layer Title = \"%s\".", title);
  1053.  
  1054.   if (bSaveAs)
  1055.   {
  1056.     _MSG( "   SaveAs      = Yes.");
  1057.   } else /* if (bSaveAs) */
  1058.   {
  1059.     _MSG( "   SaveAs      = No.");
  1060.   } /* if (bSaveAs) */
  1061.  
  1062.   if (fname == NULL) goto cleanup;
  1063.  
  1064.   _FMTMSG( "   Filename    = \"%s\".", fname);
  1065.  
  1066.   if (bOverwrite)
  1067.   {
  1068.      _MSG( "   Overwrite   = Yes.");
  1069.   } else /* if (bOverwrite) */
  1070.   {
  1071.     _MSG( "   Overwrite   = No.");
  1072.   } /* if (bOverwrite) */
  1073.     /* if (bSaveAs) */
  1074.   if (ghConv == NULL) goto cleanup;
  1075.  
  1076.   wsprintf(szBuffer, "[EXPORTLAYER(%d,%d,%d,\"%s\",\"%s\",%d,0,0)]", docWinID, layerID, bSaveAs, (LPSTR)fname, (LPSTR)title, bOverwrite);
  1077.  
  1078.   size = (WORD)(lstrlen(szBuffer) + 1);
  1079.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  1080.  
  1081. cleanup:
  1082.   if (!ret) _MSG(pDdeErrMsg);
  1083.  
  1084.   return (ret);
  1085. } /* IMG_ExportLayer() */
  1086.  
  1087. /* ========================================= Parallax C Function ==================
  1088.  
  1089.    @Name: IMG_GetActiveEditLayer
  1090.    @Desc: 
  1091.  
  1092. ============================================================================== */
  1093.  
  1094. int IMG_GetActiveEditLayer(HCONV ghConv, DOCWINID docWinID, LAYERID FAR* layerID)
  1095. {
  1096.   HDDEDATA hData;
  1097.   char     szBuffer[256];
  1098.   int      ret = FALSE;
  1099.  
  1100.   if (ghConv == NULL) goto cleanup;
  1101.  
  1102.   /* docWinID = 0 */
  1103.   if (!docWinID)
  1104.   {
  1105.     HCONV ghConvLoc = ghConv;
  1106.       
  1107.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1108.   } /* if (!docWinId) */
  1109.    
  1110.   if (!docWinID) return (FALSE);
  1111.  
  1112.   wsprintf(szBuffer, "[GETACTIVELAYER(%d)]", docWinID);
  1113.  
  1114.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1115.  
  1116.   if (hData)
  1117.   {
  1118.     char pData[2*PARMSIZE];
  1119.  
  1120.     int igd;
  1121.     igd = IMG_GetData(hData, (char FAR*)pData, 2);
  1122.       
  1123.     if (igd == 2)
  1124.     {
  1125.       LAYERID tmp;
  1126.       sscanf(&pData[PARMSIZE*1], "%d", &tmp);
  1127.       if (layerID) *layerID = tmp;
  1128.  
  1129.       if (tmp == 0)
  1130.       {
  1131.         _FMTMSG("No active edit layer for docWinID %d.", docWinID);
  1132.       } else /* if (tmp == 0) */
  1133.       {
  1134.         _FMTMSG2("Active edit layerID is %d for docWinID %d.", tmp, docWinID);
  1135.       } /* if (tmp == 0) */
  1136.  
  1137.       ret = TRUE;
  1138.     } /* if (igd == 2) */
  1139.   } /* if (hData) */
  1140.  
  1141. cleanup:
  1142.   if (!ret) _MSG(pDdeErrMsg);
  1143.  
  1144.   return (ret);
  1145. } /* IMG_GetActiveEditLayer() */
  1146.  
  1147. /* ========================================= Parallax C Function ==================
  1148.  
  1149.    @Name: IMG_GetActiveRasterLayer
  1150.    @Desc: 
  1151.  
  1152. ============================================================================== */
  1153.  
  1154. int IMG_GetActiveRasterLayer(HCONV ghConv, DOCWINID docWinID, LAYERID FAR* layerID)
  1155. {
  1156.   HDDEDATA hData;
  1157.   char     szBuffer[256];
  1158.   int      ret = FALSE;
  1159.  
  1160.   if (ghConv == NULL) goto cleanup;
  1161.  
  1162.   /* docWinID = 0 */
  1163.   if (!docWinID)
  1164.   {
  1165.     HCONV ghConvLoc = ghConv;
  1166.       
  1167.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1168.   } /* if (!docWinID) */
  1169.    
  1170.   if (!docWinID) return (FALSE);
  1171.  
  1172.   wsprintf(szBuffer, "[GETACTIVELAYER(%d)]", docWinID);
  1173.  
  1174.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1175.  
  1176.   if (hData)
  1177.   {
  1178.     char pData[2*PARMSIZE];
  1179.  
  1180.     int igd;
  1181.     igd = IMG_GetData(hData, (char FAR*)pData, 2);
  1182.       
  1183.     if (igd == 2)
  1184.     {
  1185.       LAYERID tmp;
  1186.       sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  1187.       if (layerID) *layerID = tmp;
  1188.  
  1189.       if (tmp == 0)
  1190.       {
  1191.         _FMTMSG("No active raster layer for docWinID %d.", docWinID);
  1192.       } else /* if (tmp == 0) */
  1193.       {
  1194.         _FMTMSG2("Active raster layerID is %d for docWinID %d.", tmp, docWinID);
  1195.       } /* if (tmp == 0) */
  1196.  
  1197.       ret = TRUE;
  1198.     } /* if (igd == 2) */
  1199.   } /* if (hData) */
  1200.  
  1201. cleanup:
  1202.   if (!ret) _MSG(pDdeErrMsg);
  1203.  
  1204.   return (ret);
  1205. } /* IMG_GetActiveRasterLayer() */
  1206.  
  1207. /* ========================================= Parallax C Function ==================
  1208.  
  1209.    @Name: IMG_GetDisplayLayer
  1210.    @Desc: 
  1211.  
  1212. ============================================================================== */
  1213.  
  1214. int IMG_GetDisplayLayer(HCONV ghConv, DOCWINID docWinID, LAYERID layerID, BOOL FAR* bDisplay)
  1215. {
  1216.   HDDEDATA hData;
  1217.   char     szBuffer[256];
  1218.   int      ret = FALSE;
  1219.  
  1220.   if (ghConv == NULL) goto cleanup;
  1221.  
  1222.   /* docWinID = 0 */
  1223.   if (!docWinID)
  1224.   {
  1225.     HCONV ghConvLoc = ghConv;
  1226.  
  1227.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1228.   } /* if (!docWinID) */
  1229.    
  1230.   if (!docWinID) return (FALSE);
  1231.  
  1232.   wsprintf(szBuffer, "[GETDISPLAYLAYER(%d,%d)]", docWinID, layerID);
  1233.  
  1234.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1235.  
  1236.   if (hData)
  1237.   {
  1238.     char pData[1*PARMSIZE];
  1239.  
  1240.     int igd;
  1241.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  1242.       
  1243.     if (igd == 1)
  1244.     {
  1245.       int tmp;
  1246.       sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  1247.       if (bDisplay) *bDisplay = tmp;
  1248.  
  1249.       if (tmp)
  1250.       {
  1251.         _FMTMSG2("LayerID %d of docWin %d is displayed.", layerID, docWinID);
  1252.       } else /* if (tmp) */
  1253.       {
  1254.         _FMTMSG2("LayerID %d of docWin %d is NOT displayed.", layerID, docWinID);
  1255.       } /* if (tmp) */
  1256.  
  1257.       ret = TRUE;
  1258.     } /* if (igd == 1) */
  1259.   } /*  if (hData) */
  1260.  
  1261. cleanup:
  1262.   if (!ret) _MSG(pDdeErrMsg);
  1263.  
  1264.   return (ret);
  1265. } /* IMG_GetDisplayLayer() */
  1266.  
  1267. /* ========================================= Parallax C Function ==================
  1268.  
  1269.    @Name: IMG_GetDocumentDirtyStatus
  1270.    @Desc: 
  1271.  
  1272. ============================================================================== */
  1273.  
  1274. int IMG_GetDocumentDirtyStatus(HCONV ghConv, DOCWINID docWinID, int FAR* status)
  1275. {
  1276.   HDDEDATA hData;
  1277.   char     szBuffer[256];
  1278.   int      ret = FALSE;
  1279.  
  1280.   if (ghConv == NULL) goto cleanup;
  1281.  
  1282.   /* docWinID = 0 */
  1283.   if (!docWinID)
  1284.   {
  1285.     HCONV ghConvLoc = ghConv;
  1286.       
  1287.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1288.   } /* if (!docWinID) */
  1289.    
  1290.   if (!docWinID) return (FALSE);
  1291.  
  1292.   wsprintf(szBuffer, "[GETDOCUMENTDIRTYSTATUS(%d)]", docWinID);
  1293.  
  1294.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1295.  
  1296.   if (hData)
  1297.   {
  1298.     char pData[1*PARMSIZE];
  1299.  
  1300.     int igd;
  1301.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  1302.       
  1303.     if (igd == 1)
  1304.     {
  1305.       int tmp;
  1306.       sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  1307.       if (status) *status = tmp;
  1308.  
  1309.       _FMTMSG2("docWinID %d has dirty status 0x%x.", docWinID, tmp);
  1310.       strcpy(szBuffer, "   -->");
  1311.  
  1312.       if (tmp & 0x01) strcpy(&szBuffer[strlen(szBuffer)], "CLEAN ");
  1313.  
  1314.       if (tmp & 0x02) strcpy(&szBuffer[strlen(szBuffer)], "MODIFIED ");
  1315.  
  1316.       if (tmp & 0x04) strcpy(&szBuffer[strlen(szBuffer)], "DELETED ");
  1317.  
  1318.       if (tmp & 0x08) strcpy(&szBuffer[strlen(szBuffer)], "NEW ");
  1319.  
  1320.       if (tmp & 0x10) strcpy(&szBuffer[strlen(szBuffer)], "DBI_MOD ");
  1321.  
  1322.       if (tmp & 0x20) strcpy(&szBuffer[strlen(szBuffer)], "DBI_NEW ");
  1323.  
  1324.       if (tmp & 0x40) strcpy(&szBuffer[strlen(szBuffer)], "DBI_OPEN ");
  1325.  
  1326.       _MSG(szBuffer);
  1327.  
  1328.       ret = TRUE;
  1329.     }  /* if (igd == 1) */
  1330.   } /* if (hData) */
  1331.  
  1332. cleanup:
  1333.   if (!ret) _MSG(pDdeErrMsg);
  1334.  
  1335.   return (ret);
  1336. } /* IMG_GetDocumentDirtyStatus() */
  1337.  
  1338. /* ========================================= Parallax C Function ==================
  1339.  
  1340.    @Name: IMG_GetDocumentTitle
  1341.    @Desc: 
  1342.  
  1343. ============================================================================== */
  1344.  
  1345. int IMG_GetDocumentTitle(HCONV ghConv, DOCWINID docWinID, char FAR* title)
  1346. {
  1347.   HDDEDATA hData;
  1348.   char     szBuffer[256];
  1349.   int      ret = FALSE;
  1350.  
  1351.   if (ghConv == NULL) goto cleanup;
  1352.  
  1353.   /* docWinID = 0 */
  1354.   if (!docWinID)
  1355.   {
  1356.     HCONV ghConvLoc = ghConv;
  1357.       
  1358.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1359.   } /* if (!docWinID) */
  1360.    
  1361.   if (!docWinID) return (FALSE);
  1362.  
  1363.   wsprintf(szBuffer, "[GETDOCUMENTTITLE(%d)]", docWinID);
  1364.  
  1365.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1366.  
  1367.   if (hData)
  1368.   {
  1369.     if (title) IMG_GetData(hData, title, 1);
  1370.  
  1371.     _FMTMSG2("DocWinID %d has title \"%s\".", docWinID, title);
  1372.  
  1373.     ret = TRUE;
  1374.   }
  1375.  
  1376. cleanup:
  1377.   if (!ret) _MSG(pDdeErrMsg);
  1378.  
  1379.   return (ret);
  1380. } /* IMG_GetDocumentTitle() */
  1381.  
  1382. /* ========================================= Parallax C Function ==================
  1383.  
  1384.    @Name: IMG_GetDocWin
  1385.    @Desc: 
  1386.  
  1387. ============================================================================== */
  1388.  
  1389. int IMG_GetDocWin(HCONV ghConv, DOCWINID FAR* docWinID)
  1390. {
  1391.   DOCWINID hViewWnd = 0;
  1392.   HDDEDATA hData = NULL;
  1393.   DWORD    result;
  1394.   DWORD    buf_size;
  1395.  
  1396. #ifdef __BORLANDC__
  1397.   LPSTR    img_buf;
  1398. #else
  1399.   PSTR     img_buf;
  1400. #endif
  1401.  
  1402.   int      ret = FALSE;
  1403.   HSZ      hszString;
  1404.  
  1405.   if (ghConv == NULL) goto cleanup;
  1406.  
  1407.   hszString = DdeCreateStringHandle(idInst, (LPSTR)"GETDOCWIN", CP_WINANSI);
  1408.  
  1409.   hData = DdeClientTransaction(NULL,
  1410.                                0,
  1411.                                ghConv,
  1412.                                hszString,
  1413.                                CF_TEXT,
  1414.                                XTYP_REQUEST,
  1415.                                3000,
  1416.                                (DWORD FAR *)&result);
  1417.  
  1418.   DdeFreeStringHandle(idInst, hszString);
  1419.  
  1420.   if (hData)
  1421.   {
  1422.     buf_size = DdeGetData(hData, NULL, 0, 0L);
  1423.     buf_size++;
  1424.     img_buf = malloc((WORD)buf_size);
  1425.     if (img_buf)
  1426.     {
  1427.       if (DdeGetData(hData, (LPSTR)img_buf, buf_size, 0L))
  1428.       {
  1429.         sscanf(img_buf, "%d", &hViewWnd);
  1430.         if (docWinID) *docWinID = hViewWnd;
  1431.  
  1432.         _FMTMSG((LPSTR)"Active docWinID is %d.", (int)hViewWnd);
  1433.       } /* if (DdeGetData(hData, (LPSTR)img_buf, buf_size, 0L)) */
  1434.  
  1435.       free(img_buf);
  1436.  
  1437.       ret = TRUE;
  1438.     } /* if (img_buf) */
  1439.  
  1440.     DdeFreeDataHandle(hData);
  1441.   } else /* if (hData) */
  1442.   {            
  1443.     ret = TRUE;
  1444.     
  1445.     _MSG("No active docWin.");
  1446.   } /* if (hData) */
  1447.  
  1448. cleanup:
  1449.   if (!ret) _MSG(pDdeErrMsg);
  1450.  
  1451.   return (ret);
  1452. } /* IMG_GetDocWin() */
  1453.  
  1454. /* ========================================= Parallax C Function ==================
  1455.  
  1456.    @Name: IMG_GetLayerDirtyStatus
  1457.    @Desc: 
  1458.  
  1459. ============================================================================== */
  1460.  
  1461. int IMG_GetLayerDirtyStatus(HCONV ghConv, DOCWINID docWinID, LAYERID layerID, int FAR* status)
  1462. {
  1463.   HDDEDATA hData;
  1464.   char     szBuffer[256];
  1465.   int      ret = FALSE;
  1466.  
  1467.   if (ghConv == NULL) goto cleanup;
  1468.  
  1469.   /* docWinID = 0 */
  1470.   if (!docWinID)
  1471.   {
  1472.     HCONV ghConvLoc = ghConv;
  1473.       
  1474.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1475.   } /* if (!docWinID) */
  1476.    
  1477.   if (!docWinID) return (FALSE);
  1478.  
  1479.   wsprintf(szBuffer, "[GETLAYERDIRTYSTATUS(%d,%d)]", docWinID, layerID);
  1480.  
  1481.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1482.  
  1483.   if (hData)
  1484.   {
  1485.     char pData[1*PARMSIZE];
  1486.     int igd;
  1487.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  1488.       
  1489.     if (igd == 1)
  1490.     {
  1491.       int tmp;
  1492.       sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  1493.       if (status) *status = tmp;
  1494.  
  1495.       _FMTMSG3("LayerID %d of docWin %d has status 0x%x.", layerID, docWinID, tmp);
  1496.       strcpy(szBuffer, "   -->");
  1497.  
  1498.       if (tmp & 0x01) strcpy(&szBuffer[strlen(szBuffer)], "CLEAN ");
  1499.  
  1500.       if (tmp & 0x02) strcpy(&szBuffer[strlen(szBuffer)], "MODIFIED ");
  1501.  
  1502.       if (tmp & 0x04) strcpy(&szBuffer[strlen(szBuffer)], "DELETED ");
  1503.  
  1504.       if (tmp & 0x08) strcpy(&szBuffer[strlen(szBuffer)], "NEW ");
  1505.  
  1506.       if (tmp & 0x10) strcpy(&szBuffer[strlen(szBuffer)], "DBI_MOD ");
  1507.  
  1508.       if (tmp & 0x20) strcpy(&szBuffer[strlen(szBuffer)], "DBI_NEW ");
  1509.  
  1510.       if (tmp & 0x40) strcpy(&szBuffer[strlen(szBuffer)], "DBI_OPEN ");
  1511.  
  1512.       _MSG(szBuffer);
  1513.  
  1514.       ret = TRUE;
  1515.     } /* if (igd == 1) */
  1516.   } /* if (hData) */
  1517.  
  1518. cleanup:
  1519.   if (!ret) _MSG(pDdeErrMsg);
  1520.  
  1521.   return (ret);
  1522. } /* IMG_GetLayerDirtyStatus() */
  1523.  
  1524. /* ========================================= Parallax C Function ==================
  1525.  
  1526.    @Name: IMG_GetLayerFormat
  1527.    @Desc: 
  1528.  
  1529. ============================================================================== */
  1530.  
  1531. int IMG_GetLayerFormat(HCONV ghConv, DOCWINID docWinID, LAYERID layerID, int FAR* format)
  1532. {
  1533.   HDDEDATA hData;
  1534.   char     szBuffer[256];
  1535.   int      ret = FALSE;
  1536.  
  1537.   if (ghConv == NULL) goto cleanup;
  1538.  
  1539.   /* docWinID = 0 */
  1540.   if (!docWinID)
  1541.   {
  1542.     HCONV ghConvLoc = ghConv;
  1543.  
  1544.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1545.   } /* if (!docWinID) */
  1546.  
  1547.   if (!docWinID) return (FALSE);
  1548.  
  1549.   wsprintf(szBuffer, "[GETLAYERFORMAT(%d,%d)]", docWinID, layerID);
  1550.  
  1551.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1552.  
  1553.   if (hData)
  1554.   {
  1555.     char pData[1*PARMSIZE];
  1556.     int igd;
  1557.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  1558.  
  1559.     if (igd == 1)
  1560.     {
  1561.       int tmp;
  1562.       sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  1563.       if (format) *format = tmp;
  1564.  
  1565.       switch (tmp)
  1566.       {
  1567.         case 0:
  1568.         {
  1569.           _FMTMSG2("LayerID %d of docWin %d is an UNKNOWN layer.", layerID, docWinID);
  1570.  
  1571.           break;
  1572.         } /* case 0 */
  1573.  
  1574.         case 1:
  1575.         {
  1576.           _FMTMSG2("LayerID %d of docWin %d is an edit layer.", layerID, docWinID);
  1577.  
  1578.           break;
  1579.         } /* case 1 */
  1580.  
  1581.         case 2:
  1582.         {
  1583.           _FMTMSG2("LayerID %d of docWin %d is a raster layer.", layerID, docWinID);
  1584.  
  1585.           break;
  1586.         } /* case 2 */
  1587.  
  1588.         case 3:
  1589.         {
  1590.           _FMTMSG2("LayerID %d of docWin %d is a text layer.", layerID, docWinID);
  1591.  
  1592.           break;
  1593.         } /* case 3 */
  1594.  
  1595.         default:
  1596.         {
  1597.           _FMTMSG2("LayerID %d of docWin %d is of an ???unrecognized??? type.", layerID, docWinID);
  1598.  
  1599.           break;
  1600.         } /* case default */
  1601.       } /* switch (tmp) */
  1602.  
  1603.       ret = TRUE;
  1604.     } /* if (igd == 1) */
  1605.   } /* if (hData) */
  1606.  
  1607. cleanup:
  1608.   if (!ret) _MSG(pDdeErrMsg);
  1609.  
  1610.   return (ret);
  1611. } /* IMG_GetLayerFormat() */
  1612.  
  1613. /* ========================================= Parallax C Function ==================
  1614.  
  1615.    @Name: IMG_GetLayerFormatList
  1616.    @Desc: 
  1617.  
  1618. ============================================================================== */
  1619.  
  1620. int IMG_GetLayerFormatList(HCONV ghConv)
  1621. {
  1622.   int      ret = FALSE;
  1623.   HDDEDATA hData;
  1624.   char     szBuffer[256];
  1625.   int      dflt, count;
  1626.   int      max=50;
  1627.   int      maxent=max*3+2;
  1628.   char     pDataArea[PARMSIZE * (50*3+2) ];
  1629.   char*    pData;
  1630.  
  1631.   if (ghConv == NULL) goto cleanup;
  1632.  
  1633.   wsprintf(szBuffer, "[GETLAYERFORMATLIST(2)]");
  1634.  
  1635.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1636.  
  1637.   if (hData)
  1638.   {
  1639.     int i,j;
  1640.     BOOL bDefaultFound = FALSE;
  1641.  
  1642.     pData = pDataArea;
  1643.  
  1644.     j = IMG_GetData(hData, (char FAR*)pData, maxent);
  1645.     sscanf(pData, "%d", &count);
  1646.     pData += PARMSIZE;
  1647.     if (count > max) count=max;
  1648.  
  1649.     j = (j-2)/3;
  1650.     if (count > j) count=j;
  1651.  
  1652.     sscanf(pData, "%d", &dflt);
  1653.     pData += PARMSIZE;
  1654.  
  1655.     for (i=0; i<count; i++)
  1656.     {
  1657.       int id;
  1658.       char szExt[5];
  1659.       char szDesc[50];
  1660.       lstrcpyn (szExt, pData, sizeof(szExt));
  1661.       pData += PARMSIZE;
  1662.       lstrcpyn (szDesc, pData, sizeof(szDesc));
  1663.       pData += PARMSIZE;
  1664.       id = img_ATOI(pData);
  1665.       pData += PARMSIZE;
  1666.  
  1667.       if (i == dflt)
  1668.       {
  1669.         _FMTMSG3(" * %3.3d (%3.3s) -- %s", id, szExt, szDesc);
  1670.         bDefaultFound = TRUE;
  1671.       } else  /* if (i == dflt) */
  1672.       {
  1673.         _FMTMSG3("   %3.3d (%3.3s) -- %s", id, szExt, szDesc);
  1674.       } /* if (i ==  dflt) */
  1675.     } /* for (i=0; i<count; i++) */
  1676.  
  1677.     /* either default format is found or we read more entries
  1678.        than sent */
  1679.     ret = bDefaultFound || ( count == max );
  1680.  
  1681.   } /* if (hData) */
  1682.  
  1683. cleanup:
  1684.   if (!ret) _MSG(pDdeErrMsg);
  1685.  
  1686.   return (ret);
  1687. } /* IMG_GetLayerFormatList() */
  1688.  
  1689. /* ========================================= Parallax C Function ==================
  1690.  
  1691.    @Name: IMG_GetLayerIDs
  1692.    @Desc: 
  1693.  
  1694. ============================================================================== */
  1695.  
  1696. int IMG_GetLayerIDs(HCONV ghConv, DOCWINID docWinID, LAYERID FAR* pLayers, int max, int FAR* count)
  1697. {
  1698.   HDDEDATA hData;
  1699.   char     szBuffer[256];
  1700.   int      ret = FALSE;
  1701.  
  1702.   if (ghConv == NULL) goto cleanup;
  1703.  
  1704.   /* docWinID = 0 */
  1705.   if (!docWinID)
  1706.   {
  1707.     HCONV ghConvLoc = ghConv;
  1708.       
  1709.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1710.   } /* if (!docWinID) */
  1711.    
  1712.   if (!docWinID) return (FALSE);
  1713.  
  1714.   wsprintf(szBuffer, "[GETLAYERIDS(%d)]", docWinID);
  1715.  
  1716.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1717.  
  1718.   if (hData)
  1719.   {
  1720.     int i;
  1721.     char * pData;
  1722.     pData = (char*) malloc(PARMSIZE * (max+1));
  1723.  
  1724.     IMG_GetData(hData, (char FAR*)pData, max+1);
  1725.     sscanf(&pData[PARMSIZE*0], "%d", count);
  1726.     if (*count > max) *count=max;
  1727.  
  1728.     for (i=0; i<*count; i++)
  1729.     {
  1730.       int tmp;
  1731.       sscanf(&pData[PARMSIZE*(i+1)], "%d", &tmp);
  1732.       pLayers[i] = tmp;
  1733.     } /* for (i=0; i<*count; i++) */
  1734.  
  1735.     free(pData);
  1736.     ret = TRUE;
  1737.   }
  1738.  
  1739. cleanup:
  1740.   if (!ret) _MSG(pDdeErrMsg);
  1741.  
  1742.   return (ret);
  1743. } /* IMG_GetLayerIDs() */
  1744.  
  1745. /* ========================================= Parallax C Function ==================
  1746.  
  1747.    @Name: IMG_GetLayerTitle
  1748.    @Desc: 
  1749.  
  1750. ============================================================================== */
  1751.  
  1752. int IMG_GetLayerTitle(HCONV ghConv, DOCWINID docWinID, LAYERID layerID, char FAR* title)
  1753. {
  1754.   HDDEDATA hData;
  1755.   char     szBuffer[256];
  1756.   int      ret = FALSE;
  1757.  
  1758.   if (ghConv == NULL) goto cleanup;
  1759.  
  1760.   /* docWinID = 0 */
  1761.   if (!docWinID)
  1762.   {
  1763.     HCONV ghConvLoc = ghConv;
  1764.       
  1765.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1766.   } /* if (!docWinID) */
  1767.    
  1768.   if (!docWinID) return (FALSE);
  1769.  
  1770.   wsprintf(szBuffer, "[GETLAYERTITLE(%d,%d)]", docWinID, layerID);
  1771.  
  1772.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1773.  
  1774.   if (hData)
  1775.   {
  1776.     IMG_GetData(hData, title, 1);
  1777.  
  1778.     _FMTMSG3("LayerID %d of docWin %d has title \"%s\".", layerID, docWinID, title);
  1779.  
  1780.     ret = TRUE;
  1781.   } /* if (hData) */
  1782.  
  1783. cleanup:
  1784.   if (!ret) _MSG(pDdeErrMsg);
  1785.  
  1786.   return (ret);
  1787. } /* IMG_GetLayerTitle() */
  1788.  
  1789. /* ========================================= Parallax C Function ==================
  1790.  
  1791.    @Name: IMG_GetNumberDocWins
  1792.    @Desc: 
  1793.  
  1794. ============================================================================== */
  1795.  
  1796. int IMG_GetNumberDocWins(HCONV ghConv, int FAR* count)
  1797. {
  1798.   HDDEDATA hData;
  1799.   char     szBuffer[256];
  1800.   int      ret = FALSE;
  1801.  
  1802.   if (ghConv == NULL) goto cleanup;
  1803.  
  1804.   wsprintf(szBuffer, "[GETNUMBERDOCWINS]");
  1805.  
  1806.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1807.  
  1808.   if (hData)
  1809.   {
  1810.     char pData[1*PARMSIZE];
  1811.     int igd;
  1812.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  1813.       
  1814.     if (igd == 1)
  1815.     {
  1816.       int  tmp;
  1817.       sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  1818.       if (count) *count = tmp;
  1819.  
  1820.       _FMTMSG("Number of docWins is %d.", tmp);
  1821.  
  1822.       ret = TRUE;
  1823.     } /* if (igd == 1) */
  1824.   } /* if (hData) */
  1825.  
  1826. cleanup:
  1827.   if (!ret) _MSG(pDdeErrMsg);
  1828.  
  1829.   return (ret);
  1830. } /* IMG_GetNumberDocWins() */
  1831.  
  1832. /* ========================================= Parallax C Function ==================
  1833.  
  1834.    @Name: IMG_GetNumberLayers
  1835.    @Desc: 
  1836.  
  1837. ============================================================================== */
  1838.  
  1839. int IMG_GetNumberLayers(HCONV ghConv, DOCWINID docWinID, int FAR* count)
  1840. {
  1841.   HDDEDATA hData;
  1842.   char     szBuffer[256];
  1843.   int      ret = FALSE;
  1844.  
  1845.   if (ghConv == NULL) goto cleanup;
  1846.  
  1847.   /* docWinID = 0 */
  1848.   if (!docWinID)
  1849.   {
  1850.     HCONV ghConvLoc = ghConv;
  1851.       
  1852.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1853.   } /* if (!docWinID) */
  1854.    
  1855.   if (!docWinID) return (FALSE);
  1856.  
  1857.   wsprintf(szBuffer, "[GETNUMBERLAYERS(%d)]", docWinID);
  1858.  
  1859.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1860.  
  1861.   if (hData)
  1862.   {
  1863.     char pData[1*PARMSIZE];
  1864.  
  1865.     int igd = 0;
  1866.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  1867.  
  1868.     if (igd == 1)
  1869.     {
  1870.       int tmp;
  1871.       sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  1872.       if (count) *count = tmp;
  1873.  
  1874.       _FMTMSG2("DocWinID %d has %d layers.", docWinID, tmp);
  1875.  
  1876.       ret = TRUE;
  1877.     } /* if (igd == 1) */
  1878.   } /* if (hData) */
  1879.  
  1880. cleanup:
  1881.   if (!ret) _MSG(pDdeErrMsg);
  1882.  
  1883.   return (ret);
  1884. } /* IMG_GetNumberLayers() */
  1885.  
  1886. /* ========================================= Parallax C Function ==================
  1887.  
  1888.    @Name: IMG_GetTool
  1889.    @Desc: 
  1890.  
  1891. ============================================================================== */
  1892.  
  1893. int IMG_GetTool(HCONV ghConv, DOCWINID docWinID, int FAR* tooltype)
  1894. {
  1895.   HDDEDATA hData;
  1896.   char     szBuffer[256];
  1897.   int      ret = FALSE;
  1898.  
  1899.   if (ghConv == NULL) goto cleanup;
  1900.  
  1901.   /* docWinID = 0 */
  1902.   if (!docWinID)
  1903.   {
  1904.     HCONV ghConvLoc = ghConv;
  1905.       
  1906.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  1907.   } /* if (!docWinID) */
  1908.    
  1909.   if (!docWinID) return (FALSE);
  1910.  
  1911.   if (!_GetActiveEditLayer(ghConv, docWinID))
  1912.   {
  1913.     _MSG("No active edit layer. No tool could be active.");
  1914.  
  1915.     ret = TRUE;
  1916.   } else /* if (!_GetActiveEditLayer(ghConv, docWinID)) */
  1917.   {
  1918.     wsprintf(szBuffer, "[GETTOOL(%d)]", docWinID);
  1919.  
  1920.     IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  1921.  
  1922.     if (hData)
  1923.     {
  1924.       char pData[1*PARMSIZE];
  1925.  
  1926.       int igd = 0;
  1927.       igd = IMG_GetData(hData, (char FAR*)pData, 1);
  1928.  
  1929.       if (igd == 1)
  1930.       {
  1931.         int tmp;
  1932.         sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  1933.         if (tooltype) *tooltype = tmp;
  1934.  
  1935.         switch (tmp)
  1936.         {
  1937.           case TOOL_NONE:
  1938.           {
  1939.             _FMTMSG("No Active tool for docWinID %d.", docWinID);
  1940.  
  1941.             break;
  1942.           } /* case TOOL_NONE */
  1943.  
  1944.           case TOOL_CUT:
  1945.           {
  1946.             _FMTMSG("Active tool is CUT for docWinID %d.", docWinID);
  1947.  
  1948.             break;
  1949.           } /* case TOOL_CUT */
  1950.  
  1951.           case TOOL_COPY:
  1952.           {
  1953.             _FMTMSG("Active tool is COPY for docWinID %d.", docWinID);
  1954.  
  1955.             break;
  1956.           } /* case TOOL_COPY */
  1957.  
  1958.           case TOOL_PASTE:
  1959.           {
  1960.             _FMTMSG("Active tool is PASTE for docWinID %d.", docWinID);
  1961.  
  1962.             break;
  1963.           } /* case TOOL_PASTE */
  1964.  
  1965.           case TOOL_LINE:
  1966.           {
  1967.             _FMTMSG("Active tool is LINE for docWinID %d.", docWinID);
  1968.  
  1969.             break;
  1970.           } /* case TOOL_LINE */
  1971.  
  1972.           case TOOL_BOX:
  1973.           {
  1974.             _FMTMSG("Active tool is BOX for docWinID %d.", docWinID);
  1975.  
  1976.             break;
  1977.           } /* case TOOL_BOX */
  1978.  
  1979.           case TOOL_CIRCLE:
  1980.           {
  1981.             _FMTMSG("Active tool is CIRCLE for docWinID %d.", docWinID);
  1982.  
  1983.             break;
  1984.           } /* case TOOL_CIRCLE */
  1985.  
  1986.           case TOOL_ELLIPSE:
  1987.           {
  1988.             _FMTMSG("Active tool is ELLIPSE for docWinID %d.", docWinID);
  1989.  
  1990.             break;
  1991.           } /* case TOOL_ELLIPSE */
  1992.  
  1993.           case TOOL_ARROW:
  1994.           {
  1995.             _FMTMSG("Active tool is ARROW for docWinID %d.", docWinID);
  1996.  
  1997.             break;
  1998.           } /* case TOOL_ARROW */
  1999.  
  2000.           case TOOL_SKETCH:
  2001.           {
  2002.             _FMTMSG("Active tool is SKETCH for docWinID %d.", docWinID);
  2003.  
  2004.             break;
  2005.           } /* case TOOL_SKETCH */
  2006.  
  2007.           case TOOL_POLYLINE:
  2008.           {
  2009.             _FMTMSG("Active tool is POLYLINE for docWinID %d.", docWinID);
  2010.  
  2011.             break;
  2012.           } /* case TOOL_POLYLINE */
  2013.  
  2014.           case TOOL_POLYGON:
  2015.           {
  2016.             _FMTMSG("Active tool is POLYGON for docWinID %d.", docWinID);
  2017.  
  2018.             break;
  2019.           } /* case TOOL_POLYGON */
  2020.  
  2021.           case TOOL_TEXT:
  2022.           {
  2023.             _FMTMSG("Active tool is TEXT for docWinID %d.", docWinID);
  2024.  
  2025.             break;
  2026.           } /* case TOOL_TEXT */
  2027.  
  2028.           case TOOL_ANNOTATION:
  2029.           {
  2030.             _FMTMSG("Active tool is ANNOTATION for docWinID %d.", docWinID);
  2031.  
  2032.             break;
  2033.           } /* case TOOL_ANNOTATION */
  2034.  
  2035.           case TOOL_DIMENSION:
  2036.           {
  2037.             _FMTMSG("Active tool is DIMENSION for docWinID %d.", docWinID);
  2038.  
  2039.             break;
  2040.           } /* case TOOL_DIMENSION */
  2041.  
  2042.           case TOOL_SYMBOL:
  2043.           {
  2044.             _FMTMSG("Active tool is SYMBOL for docWinID %d.", docWinID);
  2045.  
  2046.             break;
  2047.           } /* case TOOL_SYMBOL */
  2048.  
  2049.           case TOOL_HOTSPOT:
  2050.           {
  2051.             _FMTMSG("Active tool is HOTSPOT for docWinID %d.", docWinID);
  2052.  
  2053.             break;
  2054.           } /* case TOOL_HOTSPOT */
  2055.  
  2056.           case TOOL_RUBOUT:
  2057.           {
  2058.             _FMTMSG("Active tool is RUBOUT for docWinID %d.", docWinID);
  2059.  
  2060.             break;
  2061.           } /* case TOOL_RUBOUT */
  2062.  
  2063.           case TOOL_ERASER:
  2064.           {
  2065.             _FMTMSG("Active tool is ERASER for docWinID %d.", docWinID);
  2066.  
  2067.             break;
  2068.           } /* case TOOL_ERASER */
  2069.  
  2070.           case TOOL_SELECT:
  2071.           {
  2072.             _FMTMSG("Active tool is SELECT for docWinID %d.", docWinID);
  2073.  
  2074.             break;
  2075.           } /* case TOOL_SELECT */
  2076.  
  2077.           case TOOL_MOVERESIZE:
  2078.           {
  2079.             _FMTMSG("Active tool is MOVERESIZE for docWinID %d.", docWinID);
  2080.  
  2081.             break;
  2082.           } /* case TOOL_MOVERESIZE */
  2083.  
  2084.           case TOOL_ROTATE:
  2085.           {
  2086.             _FMTMSG("Active tool is ROTATE for docWinID %d.", docWinID);
  2087.  
  2088.             break;
  2089.           } /* case TOOL_ROTATE */
  2090.  
  2091.           case TOOL_CHANGETEXT:
  2092.           {
  2093.             _FMTMSG("Active tool is CHANGETEXT for docWinID %d.", docWinID);
  2094.  
  2095.             break;
  2096.           } /* case TOOL_CHANGETEXT */
  2097.  
  2098.           case TOOL_ARC:
  2099.           {
  2100.             _FMTMSG("Active tool is ARC for docWinID %d.", docWinID);
  2101.  
  2102.             break;
  2103.           } /* case TOOL_ARC */
  2104.  
  2105.           default:
  2106.           {
  2107.             _FMTMSG("***Unrecognized tool for docWinID %d.", docWinID);
  2108.  
  2109.             break;
  2110.           } /* case default */
  2111.         } /* switch (tmp) */
  2112.  
  2113.         ret = TRUE;
  2114.       } /* if (igd == 1) */
  2115.     } /* if (hData) */
  2116.   } /* if (!_GetActiveEditLayer(ghConv, docWinID)) */
  2117.  
  2118. cleanup:
  2119.   if (!ret) _MSG(pDdeErrMsg);
  2120.  
  2121.   return (ret);
  2122. } /* IMG_GetTool() */
  2123.  
  2124. /* ========================================= Parallax C Function ==================
  2125.  
  2126.    @Name: IMG_GetWindowTitle
  2127.    @Desc: 
  2128.  
  2129. ============================================================================== */
  2130.  
  2131. int IMG_GetWindowTitle(HCONV ghConv, DOCWINID docWinID, char FAR* title)
  2132. {
  2133.   HDDEDATA hData;
  2134.   char     szBuffer[256];
  2135.   int      ret = FALSE;
  2136.  
  2137.   if (ghConv == NULL) goto cleanup;
  2138.  
  2139.   /* docWinID = 0 */
  2140.   if (!docWinID)
  2141.   {
  2142.     HCONV ghConvLoc = ghConv;
  2143.       
  2144.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2145.   } /* if (!docWinID) */
  2146.    
  2147.   if (!docWinID) return (FALSE);
  2148.  
  2149.   wsprintf(szBuffer, "[GETWINDOWTITLE(%d)]", docWinID);
  2150.  
  2151.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  2152.  
  2153.   if (hData)
  2154.   {
  2155.     IMG_GetData(hData, title, 1);
  2156.     _FMTMSG2("DocWinID %d has window title \"%s\".", docWinID, title);
  2157.  
  2158.     ret = TRUE;
  2159.   } /* if (hData) */
  2160.  
  2161. cleanup:
  2162.   if (!ret) _MSG(pDdeErrMsg);
  2163.  
  2164.   return (ret);
  2165. } /* IMG_GetWindowTitle() */
  2166.  
  2167. /* ========================================= Parallax C Function ==================
  2168.  
  2169.    @Name: IMG_ImportLayer
  2170.    @Desc: 
  2171.  
  2172. ============================================================================== */
  2173.  
  2174. int IMG_ImportLayer(HCONV ghConv, DOCWINID docWinID, void FAR* fname, void FAR* title, int layerType, LAYERID FAR* layerID)
  2175. {
  2176.   HDDEDATA hData;
  2177.   char  szBuffer[256];
  2178.   int   ret = FALSE;
  2179.  
  2180.   if (ghConv == NULL) goto cleanup;
  2181.   if (fname == NULL) goto cleanup;
  2182.  
  2183.   /* docWinID = 0 */
  2184.   if (!docWinID)
  2185.   {
  2186.     HCONV ghConvLoc = ghConv;
  2187.       
  2188.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2189.   } /* if (!docWinID) */
  2190.    
  2191.   if (!docWinID) return (FALSE);
  2192.  
  2193.   if (title == NULL) title = (void FAR*)nulltitle;
  2194.  
  2195.   _FMTMSG("Import layer into docWinID %d.", docWinID);
  2196.   _FMTMSG("   -->filename    = \"%s\".", fname);
  2197.   _FMTMSG("   -->layer title = \"%s\".", title);
  2198.  
  2199.    switch (layerType)
  2200.    {
  2201.      case 0:
  2202.      {
  2203.        _MSG("   -->import as non-text layer.");
  2204.  
  2205.        break;
  2206.     } /* case 0 */
  2207.  
  2208.     case 1:
  2209.     {
  2210.       _MSG("   -->import as an edit layer.");
  2211.  
  2212.       break;
  2213.     } /* case 1 */
  2214.  
  2215.     case 2:
  2216.     {
  2217.       _MSG("   -->import as a raster layer.");
  2218.  
  2219.       break;
  2220.     } /* case 2 */
  2221.  
  2222.     case 3:
  2223.     {
  2224.       _MSG("   -->import as a text layer.");
  2225.  
  2226.       break;
  2227.     } /* case 3 */
  2228.  
  2229.     default:
  2230.     {
  2231.       _MSG("   ***unknown layer type.");
  2232.  
  2233.       break;
  2234.     } /* case default */
  2235.   } /* switch (layerType) */
  2236.  
  2237.   wsprintf(szBuffer, "[IMPORTLAYER(%d,\"%s\",\"%s\",%d)]", docWinID, (LPSTR)fname, (LPSTR)title, layerType);
  2238.  
  2239.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  2240.  
  2241.   if (hData)
  2242.   {
  2243.     char pData[1*PARMSIZE];
  2244.     int igd;
  2245.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  2246.       
  2247.     if (igd == 1)
  2248.     {
  2249.       int tmp;
  2250.       sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  2251.       if (layerID) *layerID = tmp;
  2252.  
  2253.       _FMTMSG("   -->layerID is %d.", tmp);
  2254.  
  2255.       ret = TRUE;
  2256.     } /* if (igd == 1) */
  2257.   } /* if (hData) */
  2258.  
  2259. cleanup:
  2260.   if (!ret) _MSG(pDdeErrMsg);
  2261.  
  2262.   return (ret);
  2263. } /* IMG_ImportLayer() */
  2264.  
  2265. /* ========================================= Parallax C Function ==================
  2266.  
  2267.    @Name: IMG_Merge
  2268.    @Desc: 
  2269.  
  2270. ============================================================================== */
  2271.  
  2272. int IMG_Merge(HCONV ghConv, DOCWINID docWinID, int mergetype, DOCWINID FAR* newDocWinID)
  2273. {
  2274.   HDDEDATA hData;
  2275.   char     szBuffer[256];
  2276.   int      ret = FALSE;
  2277.  
  2278.   if (ghConv == NULL) goto cleanup;
  2279.  
  2280.   /* docWinID = 0 */
  2281.   if (!docWinID)
  2282.   {
  2283.     HCONV ghConvLoc = ghConv;
  2284.       
  2285.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2286.   } /* if (!docWinID) */
  2287.    
  2288.   if (!docWinID) return (FALSE);
  2289.  
  2290.   _FMTMSG("Merge layers of docWinID %d.", docWinID);
  2291.  
  2292.   if (mergetype == MERGE_USER)             _MSG("   -->merge using dialog box. ");
  2293.  
  2294.   if (mergetype & MERGE_WHOLEDOC)          _MSG("   -->merge whole document.");
  2295.  
  2296.   if (mergetype & MERGE_DISPLAYEDLAYERS)   _MSG("   -->merge displayed layers.");
  2297.  
  2298.   if (mergetype & MERGE_ASDISPLAYED)       _MSG("   -->merge as displayed.");
  2299.  
  2300.   if (mergetype & MERGE_ACTIVERASTER)      _MSG("   -->merge active raster.");
  2301.  
  2302.   if (mergetype & MERGE_ACTIVEEDIT)        _MSG("   -->merge active edit.");
  2303.  
  2304.   if (mergetype & MERGE_DISPLAYEDRASTERS)  _MSG("   -->merge displayed raster layers.");
  2305.  
  2306.   if (mergetype & MERGE_DISPLAYEDEDITS)    _MSG("   -->merge displayed edit layers.");
  2307.  
  2308.   wsprintf(szBuffer, "[MERGE(%d,%d)]", docWinID, mergetype);
  2309.  
  2310.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  2311.  
  2312.   if (hData)
  2313.   {
  2314.     char pData[1*PARMSIZE];
  2315.     int igd;
  2316.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  2317.       
  2318.     if (igd == 1)
  2319.     {
  2320.       int tmp;
  2321.       sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  2322.       if (newDocWinID) *newDocWinID = tmp;
  2323.  
  2324.       _FMTMSG("   -->new docWinID is %d.", tmp);
  2325.  
  2326.       ret = TRUE;
  2327.     } /* if (igd == 1) */
  2328.   } /* if (hData) */
  2329.  
  2330. cleanup:
  2331.   if (!ret) _MSG(pDdeErrMsg);
  2332.  
  2333.   return (ret);
  2334. } /* IMG_Merge() */
  2335.  
  2336. /* ========================================= Parallax C Function ==================
  2337.  
  2338.    @Name: IMG_NewDocument
  2339.    @Desc: 
  2340.  
  2341. ============================================================================== */
  2342.  
  2343. int IMG_NewDocument(HCONV ghConv, char FAR* title, char FAR* fname, DOCWINID FAR* docWinID)
  2344. {
  2345.   HDDEDATA hData;
  2346.   char     szBuffer[256];
  2347.   int      ret = FALSE;
  2348.  
  2349.   if (ghConv == NULL) goto cleanup;
  2350.   if (fname == NULL) fname=(void FAR*)nulltitle;
  2351.   if (title == NULL) title=(void FAR*)nulltitle;
  2352.  
  2353.   _MSG("Create new document.");
  2354.   _FMTMSG("   -->filename = \"%s\".", fname);
  2355.   _FMTMSG("   -->title    = \"%s\".", title);
  2356.  
  2357.   wsprintf(szBuffer, "[NEWDOCUMENT(\"%s\",\"%s\")]", (LPSTR)title, (LPSTR)fname);
  2358.  
  2359.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  2360.  
  2361.   if (hData)
  2362.   {
  2363.     char pData[2*PARMSIZE];
  2364.  
  2365.     int igd;
  2366.     igd = IMG_GetData(hData, (char FAR*)pData, 2);
  2367.       
  2368.     if (igd == 2)
  2369.     {
  2370.       int tmp;
  2371.       sscanf(&pData[PARMSIZE*1], "%d", &tmp);
  2372.       if (docWinID) *docWinID = tmp;
  2373.  
  2374.       _FMTMSG("   -->docWinID is %d.", tmp);
  2375.  
  2376.       ret = TRUE;
  2377.     } /* if (igd == 2) */
  2378.   } /* if (hData) */
  2379.  
  2380. cleanup:
  2381.   if (!ret) _MSG(pDdeErrMsg);
  2382.  
  2383.   return (ret);
  2384. } /* IMG_NewDocument() */
  2385.  
  2386. /* ========================================= Parallax C Function ==================
  2387.  
  2388.    @Name: IMG_NewLayer
  2389.    @Desc: 
  2390.  
  2391. ============================================================================== */
  2392.  
  2393. int IMG_NewLayer(HCONV ghConv, DOCWINID docWinID, int layerType, LAYERID FAR* layerID)
  2394. {
  2395.   HDDEDATA hData;
  2396.   char     szBuffer[256];
  2397.   int      ret = FALSE;
  2398.  
  2399.   if (ghConv == NULL) goto cleanup;
  2400.  
  2401.   /* docWinID = 0 */
  2402.   if (!docWinID)
  2403.   {
  2404.     HCONV ghConvLoc = ghConv;
  2405.       
  2406.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2407.   } /* if (!docWinID) */
  2408.    
  2409.   if (!docWinID) return (FALSE);
  2410.  
  2411.   _FMTMSG("Create new layer for docWinID %d.", docWinID);
  2412.   switch (layerType)
  2413.   {
  2414.     case 1:
  2415.     {
  2416.       _MSG("   -->Redline layer.");
  2417.  
  2418.       break;
  2419.     } /* case 1 */
  2420.  
  2421.     case 2:
  2422.     {
  2423.       _MSG("   -->Edit layer.");
  2424.  
  2425.       break;
  2426.     } /* case 2 */
  2427.  
  2428.     case 3:
  2429.     {
  2430.       _MSG("   -->Full edit layer.");
  2431.  
  2432.       break;
  2433.     } /* case 3 */
  2434.  
  2435.     case 4:
  2436.     {
  2437.       _MSG("   -->Annotation layer.");
  2438.  
  2439.       break;
  2440.     } /* case 4 */
  2441.  
  2442.     case 5:
  2443.     {
  2444.       _MSG("   -->Hotspot layer.");
  2445.  
  2446.       break;
  2447.     } /* case 5 */
  2448.  
  2449.     default:
  2450.     {
  2451.       _MSG("   ***unknown layer type.");
  2452.  
  2453.       break;
  2454.     } /* case default */
  2455.   } /* switch (layerType) */
  2456.  
  2457.   wsprintf(szBuffer, "[NEWLAYER(%d,%d)]", docWinID, layerType);
  2458.  
  2459.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  2460.  
  2461.   if (hData)
  2462.   {
  2463.     char pData[1*PARMSIZE];
  2464.  
  2465.     int igd;
  2466.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  2467.       
  2468.     if (igd == 1)
  2469.     {
  2470.       int tmp;
  2471.       sscanf(&pData[PARMSIZE*0], "%d", &tmp);
  2472.       if (layerID) *layerID = tmp;
  2473.  
  2474.       _FMTMSG("   -->layerID is %d.", tmp);
  2475.  
  2476.       ret = TRUE;
  2477.     } /* if (igd == 1) */
  2478.   } /* if (hData) */
  2479.  
  2480. cleanup:
  2481.   if (!ret) _MSG(pDdeErrMsg);
  2482.  
  2483.   return (ret);
  2484. } /* IMG_NewLayer() */
  2485.  
  2486. /* ========================================= Parallax C Function ==================
  2487.  
  2488.    @Name: IMG_OpenDocWin
  2489.    @Desc: 
  2490.  
  2491. ============================================================================== */
  2492.  
  2493. int IMG_OpenDocWin(HCONV ghConv, int location, int fileType, void FAR* fname, void FAR* title, int perms, int wother, int lother, DOCWINID FAR* docWinID)
  2494. {
  2495.   HDDEDATA hData;
  2496.   char  szBuffer[256];
  2497.   int   ret = FALSE;
  2498.  
  2499.   if (ghConv == NULL) goto cleanup;
  2500.   if (fname == NULL) goto cleanup;
  2501.   if (title == NULL) title=(void FAR*)nulltitle;
  2502.  
  2503.   _MSG("Open file as new docWin.");
  2504.   _FMTMSG("   -->location is %d.", location);
  2505.  
  2506.   switch (fileType)
  2507.   {
  2508.     case 0:
  2509.     {
  2510.       _MSG("   -->open as non-text file.");
  2511.  
  2512.       break;
  2513.     } /* case 0 */
  2514.  
  2515.     case 1:
  2516.     {
  2517.       _MSG("   -->open as an edit file.");
  2518.  
  2519.       break;
  2520.     } /* case 1 */
  2521.  
  2522.     case 2:
  2523.     {
  2524.       _MSG("   -->open as a raster file.");
  2525.  
  2526.       break;
  2527.     } /* case 2 */
  2528.  
  2529.     case 3:
  2530.     {
  2531.       _MSG("   -->open as a text file.");
  2532.  
  2533.       break;
  2534.     } /* case 3 */
  2535.  
  2536.     default:
  2537.     {
  2538.       _MSG("   ***unknown file type.");
  2539.  
  2540.       break;
  2541.     } /* case default */
  2542.   } /* switch (fileType) */
  2543.  
  2544.   _FMTMSG("   -->docWin title= \"%s\".", title);
  2545.   _FMTMSG("   -->file name   = \"%s\".", fname);
  2546.  
  2547.   wsprintf(szBuffer, "[OPENDOCWIN(%d,%d,\"%s\",\"%s\",%d,%d,%d)]", location, fileType, (LPSTR)fname, (LPSTR)title, perms, wother, lother);
  2548.  
  2549.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  2550.  
  2551.   if (hData)
  2552.   {
  2553.     char pData[2*PARMSIZE];
  2554.  
  2555.     int igd;
  2556.     igd = IMG_GetData(hData, (char FAR*)pData, 2);
  2557.       
  2558.     if (igd == 2)
  2559.     {
  2560.       int tmp;
  2561.       sscanf(&pData[PARMSIZE*1], "%d", &tmp);
  2562.       if (docWinID) *docWinID = tmp;
  2563.  
  2564.       _FMTMSG("   -->docWinID is %d.", tmp);
  2565.  
  2566.       ret = TRUE;
  2567.     } /* if (igd == 2) */
  2568.   } /* if (hData) */
  2569.  
  2570. cleanup:
  2571.   if (!ret) _MSG(pDdeErrMsg);
  2572.  
  2573.   return (ret);
  2574. } /* IMG_OpenDocWin() */
  2575.  
  2576. /* ========================================= Parallax C Function ==================
  2577.  
  2578.    @Name: IMG_PrintDocWin
  2579.    @Desc: 
  2580.  
  2581. ============================================================================== */
  2582.  
  2583. int IMG_PrintDocWin(HCONV ghConv, DOCWINID docWinID, int pagerange, int firstpage, int lastpage, int ncopies, BOOL bUseDialog)
  2584. {
  2585.   char  szBuffer[256];
  2586.   WORD  size;
  2587.   int   ret = FALSE;
  2588.  
  2589.   if (ghConv == NULL) goto cleanup;
  2590.    
  2591.   /* docWinID = 0 */
  2592.   if (!docWinID)
  2593.   {
  2594.     HCONV ghConvLoc = ghConv;
  2595.       
  2596.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2597.   } /* if (!docWinID) */
  2598.    
  2599.   if (!docWinID) return (FALSE);
  2600.  
  2601.   _FMTMSG3("Print docWinID %d from page %d to page %d.", docWinID, firstpage, lastpage);
  2602.  
  2603.   wsprintf(szBuffer, "[PRINTDOCWIN(%d,%d,%d,%d,%d,%d,8)]", docWinID, pagerange, firstpage, lastpage, ncopies, bUseDialog);
  2604.  
  2605.   size = (WORD)(lstrlen(szBuffer) + 1);
  2606.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  2607.  
  2608. cleanup:
  2609.   if (!ret) _MSG(pDdeErrMsg);
  2610.  
  2611.   return (ret);
  2612. } /* IMG_PrintDocWin() */
  2613.  
  2614. /* ========================================= Parallax C Function ==================
  2615.  
  2616.    @Name: IMG_Refresh
  2617.    @Desc: 
  2618.  
  2619. ============================================================================== */
  2620.  
  2621. int IMG_Refresh(HCONV ghConv, DOCWINID docWinID)
  2622. {
  2623.   char  szBuffer[256];
  2624.   WORD  size;
  2625.   int   ret = FALSE;
  2626.  
  2627.   if (ghConv == NULL) goto cleanup;
  2628.    
  2629.   /* docWinID = 0 */
  2630.   if (!docWinID)
  2631.   {
  2632.     HCONV ghConvLoc = ghConv;
  2633.       
  2634.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2635.   } /* if (!docWinID) */
  2636.  
  2637.   if (!docWinID) return (FALSE);
  2638.  
  2639.   _FMTMSG("Refresh docWinID %d.", docWinID);
  2640.  
  2641.   wsprintf(szBuffer, "[REFRESH(%d)]", docWinID);
  2642.  
  2643.   size = (WORD)(lstrlen(szBuffer) + 1);
  2644.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  2645.  
  2646. cleanup:
  2647.   if (!ret) _MSG(pDdeErrMsg);
  2648.  
  2649.   return (ret);
  2650. } /* IMG_Refresh() */
  2651.  
  2652. /* ========================================= Parallax C Function ==================
  2653.  
  2654.    @Name: IMG_SetShowStatusDialogs
  2655.    @Desc: 
  2656.  
  2657. ============================================================================== */
  2658.  
  2659. int IMG_SetShowStatusDialogs(HCONV ghConv, BOOL status)
  2660. {
  2661.   char  szBuffer[256];
  2662.   WORD  size;
  2663.   int   ret = FALSE;
  2664.  
  2665.   if (ghConv == NULL) goto cleanup;
  2666.  
  2667.   wsprintf(szBuffer, "[SETSHOWSTATUSDIALOGS(%d)]", status);
  2668.  
  2669.   size = (WORD)(lstrlen(szBuffer) + 1);
  2670.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  2671.  
  2672. cleanup:
  2673.   if (!ret) _MSG(pDdeErrMsg);
  2674.  
  2675.   return (ret);
  2676. } /* IMG_SetShowStatusDialogs() */
  2677.  
  2678. /* ========================================= Parallax C Function ==================
  2679.  
  2680.    @Name: IMG_ReorderLayer
  2681.    @Desc: 
  2682.  
  2683. ============================================================================== */
  2684.  
  2685. int IMG_ReorderLayer(HCONV ghConv, DOCWINID docWinID, LAYERID layerID, int position)
  2686. {
  2687.   char  szBuffer[256];
  2688.   WORD  size;
  2689.   int   ret = FALSE;
  2690.  
  2691.   if (ghConv == NULL) goto cleanup;
  2692.  
  2693.   /* docWinID = 0 */
  2694.   if (!docWinID)
  2695.   {
  2696.     HCONV ghConvLoc = ghConv;
  2697.       
  2698.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2699.   } /* if (!docWinID) */
  2700.    
  2701.   if (!docWinID) return (FALSE);
  2702.  
  2703.   _FMTMSG3("Reorder layerID %d of docWinID %d to position %d.", layerID, docWinID, position);
  2704.  
  2705.   wsprintf(szBuffer, "[REORDERLAYER(%d,%d,%d)]", docWinID, layerID, position);
  2706.  
  2707.   size = (WORD)(lstrlen(szBuffer) + 1);
  2708.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  2709.  
  2710. cleanup:
  2711.   if (!ret) _MSG(pDdeErrMsg);
  2712.  
  2713.   return (ret);
  2714. } /* IMG_ReorderLayer() */
  2715.  
  2716. /* ========================================= Parallax C Function ==================
  2717.  
  2718.    @Name: IMG_Save
  2719.    @Desc: 
  2720.  
  2721. ============================================================================== */
  2722.  
  2723. int IMG_Save(HCONV ghConv, DOCWINID docWinID, BOOL bSaveAs, void FAR* fname, void FAR* title, BOOL bOverwrite)
  2724. {
  2725.   char  szBuffer[256];
  2726.   char  szTmpFname[256];
  2727.   char  szTmpTitle[256];
  2728.   WORD  size;
  2729.   int   ret = FALSE;
  2730.  
  2731.   if (ghConv == NULL) goto cleanup;
  2732.   if (fname == NULL) goto cleanup;
  2733.  
  2734.   /* docWinID = 0 */
  2735.   if (!docWinID)
  2736.   {
  2737.     HCONV ghConvLoc = ghConv;
  2738.       
  2739.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2740.   } /* if (!docWinID) */
  2741.    
  2742.   if (!docWinID) return (FALSE);
  2743.  
  2744.   if (title == NULL) title = (void FAR*)nulltitle;
  2745.  
  2746.   _fstrcpy(szTmpFname, fname);
  2747.   _fstrcpy(szTmpTitle, title);
  2748.  
  2749.   _FMTMSG("Save docWinID %d.", docWinID);
  2750.   _FMTMSG("   -->filename  = \"%s\".", szTmpFname);
  2751.   _FMTMSG("   -->title     = \"%s\".", szTmpTitle);
  2752.  
  2753.   if (bOverwrite)
  2754.   {
  2755.     _MSG("   -->overwrite = Yes.");
  2756.   } else /* if (bOverwrite) */
  2757.   {
  2758.     _MSG("   -->overwrite = No.");
  2759.   } /* if (bOverwrite) */
  2760.  
  2761.   if (bSaveAs)
  2762.   {
  2763.     _MSG("   -->save as   = Yes.");
  2764.   } else /* if (bSaveAs) */
  2765.   {
  2766.     _MSG("   -->save as   = No.");
  2767.   } /* if (bSaveAs) */
  2768.  
  2769.   wsprintf(szBuffer, "[SAVE(%d,%d,\"%s\",\"%s\",%d)]", docWinID, bSaveAs, (LPSTR)szTmpFname, (LPSTR)szTmpTitle, bOverwrite);
  2770.  
  2771.   size = (WORD)(lstrlen(szBuffer) + 1);
  2772.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  2773.  
  2774. cleanup:
  2775.   if (!ret) _MSG(pDdeErrMsg);
  2776.  
  2777.   return (ret);
  2778. } /* IMG_Save() */
  2779.  
  2780. /* ========================================= Parallax C Function ==================
  2781.  
  2782.    @Name: IMG_SaveLayer
  2783.    @Desc: 
  2784.  
  2785. ============================================================================== */
  2786.  
  2787. int IMG_SaveLayer(HCONV ghConv, DOCWINID docWinID, LAYERID layerID, BOOL bSaveAs, void FAR* fname, void FAR* title, BOOL bOverwrite, int format, int rotation)
  2788. {
  2789.   char  szBuffer[256];
  2790.   char  szTmpFname[256];
  2791.   char  szTmpTitle[256];
  2792.   WORD  size;
  2793.   int   ret = FALSE;
  2794.  
  2795.   if (ghConv == NULL) goto cleanup;
  2796.   if (fname == NULL) goto cleanup;
  2797.  
  2798.   /* docWinID = 0 */
  2799.   if (!docWinID)
  2800.   {
  2801.     HCONV ghConvLoc = ghConv;
  2802.       
  2803.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2804.   } /* if (!docWinID) */
  2805.    
  2806.   if (!docWinID) return (FALSE);
  2807.  
  2808.   if (title == NULL) title = (void FAR*)nulltitle;
  2809.  
  2810.   _fstrcpy(szTmpFname, fname);
  2811.   _fstrcpy(szTmpTitle, title);
  2812.  
  2813.   _FMTMSG2("Save layerID %d of docWinID %d.", layerID, docWinID);
  2814.   _FMTMSG("   -->filename  = \"%s\".", szTmpFname);
  2815.   _FMTMSG("   -->title     = \"%s\".", szTmpTitle);
  2816.  
  2817.   if (bOverwrite)
  2818.   {
  2819.     _MSG("   -->overwrite = Yes.");
  2820.   } else /* if (bOverwrite) */
  2821.   {
  2822.     _MSG("   -->overwrite = No.");
  2823.   } /* if (bOverwrite) */
  2824.  
  2825.   if (bSaveAs)
  2826.   {
  2827.     _MSG("   -->save as   = Yes.");
  2828.   } else /* if (bSaveAs) */
  2829.   {
  2830.     _MSG("   -->save as   = No.");
  2831.   } /* if (bSaveAs) */
  2832.  
  2833.   _FMTMSG("   -->rotation  = %d.", rotation);
  2834.  
  2835.   wsprintf(szBuffer, "[SAVELAYER(%d,%d,%d,\"%s\",\"%s\",%d,%d,%d)]", docWinID, layerID, bSaveAs, (LPSTR)szTmpFname, (LPSTR)szTmpTitle, bOverwrite, format, rotation);
  2836.  
  2837.   size = (WORD)(lstrlen(szBuffer) + 1);
  2838.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  2839.  
  2840. cleanup:
  2841.   if (!ret) _MSG(pDdeErrMsg);
  2842.  
  2843.   return (ret);
  2844. } /* IMG_SaveLayer() */
  2845.  
  2846. /* ========================================= Parallax C Function ==================
  2847.  
  2848.    @Name: IMG_SetActiveLayer
  2849.    @Desc: 
  2850.  
  2851. ============================================================================== */
  2852.  
  2853. int IMG_SetActiveLayer(HCONV ghConv, DOCWINID docWinID, LAYERID layerID, BOOL bActivate)
  2854. {
  2855.   char  szBuffer[256];
  2856.   WORD  size;
  2857.   int   ret = FALSE;
  2858.  
  2859.   if (ghConv == NULL) goto cleanup;
  2860.  
  2861.   /* docWinID = 0 */
  2862.   if (!docWinID)
  2863.   {
  2864.     HCONV ghConvLoc = ghConv;
  2865.       
  2866.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2867.   } /* if (!docWinID) */
  2868.    
  2869.   if (!docWinID) return (FALSE);
  2870.  
  2871.   _FMTMSG2("Set active layer of docWinID %d to layerID %d.", docWinID, layerID);
  2872.  
  2873.   if (bActivate)
  2874.   {
  2875.     _MSG("   -->activate = Yes.");
  2876.   } else /* if (bActivate) */
  2877.   {
  2878.     _MSG("   -->activate = No.");
  2879.   } /* if (bActivate) */
  2880.  
  2881.   wsprintf(szBuffer, "[SETACTIVELAYER(%d,%d,%d)]", docWinID, layerID, bActivate);
  2882.  
  2883.   size = (WORD)(lstrlen(szBuffer) + 1);
  2884.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  2885.  
  2886. cleanup:
  2887.   if (!ret) _MSG(pDdeErrMsg);
  2888.  
  2889.   return (ret);
  2890. } /* IMG_SetActiveLayer() */
  2891.  
  2892. /* ========================================= Parallax C Function ==================
  2893.  
  2894.    @Name: IMG_SetDisplayLayer
  2895.    @Desc: 
  2896.  
  2897. ============================================================================== */
  2898.  
  2899. int IMG_SetDisplayLayer(HCONV ghConv, DOCWINID docWinID, LAYERID layerID, BOOL bDisplay)
  2900. {
  2901.   char  szBuffer[256];
  2902.   WORD  size;
  2903.   int   ret = FALSE;
  2904.  
  2905.   if (ghConv == NULL) goto cleanup;
  2906.  
  2907.   /* docWinID = 0 */
  2908.   if (!docWinID)
  2909.   {
  2910.     HCONV ghConvLoc = ghConv;
  2911.       
  2912.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2913.   } /* if (!docWinID) */
  2914.    
  2915.   if (!docWinID) return (FALSE);
  2916.  
  2917.   _FMTMSG2("Set display status of layerID %d in docWinID %d.", layerID, docWinID);
  2918.  
  2919.   if (bDisplay)
  2920.   {
  2921.     _MSG("   -->display = Yes.");
  2922.   } else /* if (bDisplay) */
  2923.   {
  2924.     _MSG("   -->display = No.");
  2925.   } /* if (bDisplay) */
  2926.  
  2927.   wsprintf(szBuffer, "[SETDISPLAYLAYER(%d,%d,%d)]", docWinID, layerID, bDisplay);
  2928.  
  2929.   size = (WORD)(lstrlen(szBuffer) + 1);
  2930.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  2931.  
  2932. cleanup:
  2933.   if (!ret) _MSG(pDdeErrMsg);
  2934.  
  2935.   return (ret);
  2936. } /* IMG_SetDisplayLayer() */
  2937.  
  2938. /* ========================================= Parallax C Function ==================
  2939.  
  2940.    @Name: IMG_SetDocumentTitle
  2941.    @Desc: 
  2942.  
  2943. ============================================================================== */
  2944.  
  2945. int IMG_SetDocumentTitle(HCONV ghConv, DOCWINID docWinID, void FAR* title)
  2946. {
  2947.   char  szBuffer[256];
  2948.   int   ret = FALSE;
  2949.   WORD  size;
  2950.  
  2951.   if (ghConv == NULL) goto cleanup;
  2952.  
  2953.   /* docWinID = 0 */
  2954.   if (!docWinID)
  2955.   {
  2956.     HCONV ghConvLoc = ghConv;
  2957.       
  2958.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  2959.   } /* if (!docWinID) */
  2960.    
  2961.   if (!docWinID) return (FALSE);
  2962.  
  2963.   if (title == NULL) title=(void FAR*)nulltitle;
  2964.  
  2965.   _FMTMSG("Set document title of docWinID %d.", docWinID);
  2966.   _FMTMSG("   -->title     = \"%s\".", title);
  2967.  
  2968.   wsprintf(szBuffer, "[SETDOCUMENTTITLE(%d,\"%s\")]", docWinID, (LPSTR)title);
  2969.  
  2970.   size = (WORD)(lstrlen(szBuffer) + 1);
  2971.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  2972.  
  2973. cleanup:
  2974.   if (!ret) _MSG(pDdeErrMsg);
  2975.  
  2976.   return (ret);
  2977. } /* IMG_SetDocumentTitle() */
  2978.  
  2979. /* ========================================= Parallax C Function ==================
  2980.  
  2981.    @Name: IMG_SetDocWin
  2982.    @Desc: 
  2983.  
  2984. ============================================================================== */
  2985.  
  2986. int IMG_SetDocWin(HCONV ghConv, DOCWINID docWinID, BOOL bStep, DOCWINID FAR* newDocWinID)
  2987. {
  2988.   HDDEDATA hData;
  2989.   char  szBuffer[256];
  2990.   int   ret = FALSE;
  2991.  
  2992.   if (ghConv == NULL) goto cleanup;
  2993.  
  2994.   /* docWinID = 0 */
  2995.   if (!docWinID)
  2996.   {
  2997.     HCONV ghConvLoc = ghConv;
  2998.  
  2999.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  3000.   } /* if (!docWinID) */
  3001.  
  3002.   if (!docWinID) return (FALSE);
  3003.  
  3004.   _MSG("Set active docWinID.");
  3005.   _FMTMSG("   -->from docWinID %d.", docWinID);
  3006.  
  3007.   if (bStep)
  3008.   {
  3009.     _MSG("   -->step forward = Yes.");
  3010.   } else /* if (bStep) */
  3011.   {
  3012.     _MSG("   -->step forward = No.");
  3013.   } /* if (bStep) */
  3014.  
  3015.   wsprintf(szBuffer, "[SETDOCWIN(%d,%d)]", docWinID, bStep);
  3016.  
  3017.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  3018.  
  3019.   if (hData)
  3020.   {
  3021.     char pData[1*PARMSIZE];
  3022.  
  3023.     int igd;
  3024.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  3025.  
  3026.     if (igd == 1)
  3027.     {
  3028.       int tmp;
  3029.       sscanf(&pData[PARMSIZE*1], "%d", &tmp);
  3030.       if (newDocWinID) *newDocWinID = tmp;
  3031.  
  3032.       {
  3033.         HCONV ghConvLoc = ghConv;
  3034.  
  3035.         tmp = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  3036.       } /* */
  3037.  
  3038.       _FMTMSG("   -->active docWinID is %d.", tmp);
  3039.  
  3040.       ret = TRUE;
  3041.     } /* if (igd == 1) */
  3042.   } /* if (hData) */
  3043.  
  3044. cleanup:
  3045.   if (!ret) _MSG(pDdeErrMsg);
  3046.  
  3047.   return (ret);
  3048. } /* IMG_SetDocWIn() */
  3049.  
  3050. /* ========================================= Parallax C Function ==================
  3051.  
  3052.    @Name: IMG_SetFocus
  3053.    @Desc: 
  3054.  
  3055. ============================================================================== */
  3056.  
  3057. int IMG_SetFocus(HCONV ghConv)
  3058. {
  3059.   char  szBuffer[256];
  3060.   WORD  size;
  3061.   int   ret = FALSE;
  3062.  
  3063.   if (ghConv == NULL) goto cleanup;
  3064.  
  3065.   _MSG("Set focus to program.");
  3066.  
  3067.   wsprintf(szBuffer, "[SETFOCUS]");
  3068.  
  3069.   size = (WORD)(lstrlen(szBuffer) + 1);
  3070.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3071.  
  3072. cleanup:
  3073.   if (!ret) _MSG(pDdeErrMsg);
  3074.  
  3075.   return (ret);
  3076. } /* IMG_SetFocus() */
  3077.  
  3078. /* ========================================= Parallax C Function ==================
  3079.  
  3080.    @Name: IMG_SetLayerTitle
  3081.    @Desc: 
  3082.  
  3083. ============================================================================== */
  3084.  
  3085. int IMG_SetLayerTitle(HCONV ghConv, DOCWINID docWinID, LAYERID layerID, void FAR* title)
  3086. {
  3087.   char  szBuffer[256];
  3088.   WORD  size;
  3089.   int   ret = FALSE;
  3090.  
  3091.   if (ghConv == NULL) goto cleanup;
  3092.  
  3093.   /* docWinID = 0 */
  3094.   if (!docWinID)
  3095.   {
  3096.     HCONV ghConvLoc = ghConv;
  3097.  
  3098.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  3099.   } /* if (!docWinID) */
  3100.  
  3101.   if (!docWinID) return (FALSE);
  3102.  
  3103.   if (title == NULL) title=(void FAR*)nulltitle;
  3104.  
  3105.   _FMTMSG2("Set layer title of layerID %d in docWinID %d.", layerID, docWinID);
  3106.   _FMTMSG("   -->title     = \"%s\".", title);
  3107.  
  3108.   wsprintf(szBuffer, "[SETLAYERTITLE(%d,%d\"%s\")]", docWinID, layerID, (LPSTR)title);
  3109.  
  3110.   size = (WORD)(lstrlen(szBuffer) + 1);
  3111.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3112.  
  3113. cleanup:
  3114.   if (!ret) _MSG(pDdeErrMsg);
  3115.  
  3116.   return (ret);
  3117. } /* IMG_SetLayerTitle() */
  3118.  
  3119. /* ========================================= Parallax C Function ==================
  3120.  
  3121.    @Name: IMG_SetScrollStep
  3122.    @Desc: 
  3123.  
  3124. ============================================================================== */
  3125.  
  3126. int IMG_SetScrollStep(HCONV ghConv, DOCWINID docWinID, float scrollstep)
  3127. {
  3128.   char  szBuffer[256];
  3129.   WORD  size;
  3130.   int   ret = FALSE;
  3131.   char    ptr[10];
  3132.  
  3133.   if (ghConv == NULL) goto cleanup;
  3134.  
  3135.   /* docWinID = 0 */
  3136.   if (!docWinID)
  3137.   {
  3138.     HCONV ghConvLoc = ghConv;
  3139.  
  3140.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  3141.   } /* if (!docWinID) */
  3142.  
  3143.   if (!docWinID) return (FALSE);
  3144.  
  3145.   _FMTMSG("Set scroll step for docWinID %d.", docWinID);
  3146.   gcvt((double)scrollstep, 5, ptr);
  3147.   _FMTMSG("   -->step = %s.", (LPSTR)ptr);
  3148.  
  3149.   wsprintf(szBuffer, "[SETSCROLLSTEP(%d,%s)]", docWinID, (LPSTR)ptr);
  3150.  
  3151.   size = (WORD)(lstrlen(szBuffer) + 1);
  3152.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3153.  
  3154. cleanup:
  3155.   if (!ret) _MSG(pDdeErrMsg);
  3156.  
  3157.   return (ret);
  3158. } /* IMG_SetScrollStep() */
  3159.  
  3160. /* ========================================= Parallax C Function ==================
  3161.  
  3162.    @Name: IMG_SetScrollView
  3163.    @Desc: 
  3164.  
  3165. ============================================================================== */
  3166.  
  3167. int IMG_SetScrollView(HCONV ghConv, DOCWINID docWinID, int scrollmode)
  3168. {
  3169.   char  szBuffer[256];
  3170.   WORD  size;
  3171.   int   ret = FALSE;
  3172.  
  3173.   if (ghConv == NULL) goto cleanup;
  3174.  
  3175.   /* docWinID = 0 */
  3176.   if (!docWinID)
  3177.   {
  3178.     HCONV ghConvLoc = ghConv;
  3179.  
  3180.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  3181.   } /* if (!docWinID) */
  3182.  
  3183.   if (!docWinID) return (FALSE);
  3184.  
  3185.   switch (scrollmode)
  3186.   {
  3187.     case SCROLLVIEW_CENTER:
  3188.     {
  3189.       _FMTMSG("Scroll docWinID %d center.", docWinID);
  3190.  
  3191.       break;
  3192.     } /* case SCROLLVIEW_CENTER */
  3193.  
  3194.     case SCROLLVIEW_BOTTOMLEFT:
  3195.     {
  3196.       _FMTMSG("Scroll docWinID %d bottom left.", docWinID);
  3197.  
  3198.       break;
  3199.     } /* case SCROLLVIEW_BOTTOMLEFT */
  3200.  
  3201.     case SCROLLVIEW_BOTTOMRIGHT:
  3202.     {
  3203.       _FMTMSG("Scroll docWinID %d bottom right.", docWinID);
  3204.  
  3205.       break;
  3206.     } /* case SCROLLVIEW_BOTTOMRIGHT */
  3207.  
  3208.     case SCROLLVIEW_TOPLEFT:
  3209.     {
  3210.       _FMTMSG("Scroll docWinID %d top left.", docWinID);
  3211.  
  3212.       break;
  3213.     } /* case SCROLLVIEW_TOPLEFT */
  3214.  
  3215.     case SCROLLVIEW_TOPRIGHT:
  3216.     {
  3217.       _FMTMSG("Scroll docWinID %d top right.", docWinID);
  3218.  
  3219.       break;
  3220.     } /* case SCROLLVIEW_TOPRIGHT */
  3221.  
  3222.     case SCROLLVIEW_UPSTEP:
  3223.     {
  3224.       _FMTMSG("Scroll docWinID %d step up.", docWinID);
  3225.  
  3226.       break;
  3227.     } /* case SCROLLVIEW_UPSTEP */
  3228.  
  3229.     case SCROLLVIEW_DOWNSTEP:
  3230.     {
  3231.       _FMTMSG("Scroll docWinID %d step down.", docWinID);
  3232.  
  3233.       break;
  3234.     } /* case SCROLLVIEW_DOWNSTEP */
  3235.  
  3236.     case SCROLLVIEW_RIGHTSTEP:
  3237.     {
  3238.       _FMTMSG("Scroll docWinID %d step right.", docWinID);
  3239.  
  3240.       break;
  3241.     } /* case SCROLLVIEW_RIGHTSTEP */
  3242.  
  3243.     case SCROLLVIEW_LEFTSTEP:
  3244.     {
  3245.       _FMTMSG("Scroll docWinID %d step left.", docWinID);
  3246.  
  3247.       break;
  3248.     } /* case SCROLLVIEW_LEFTSTEP */
  3249.  
  3250.     case SCROLLVIEW_UPPAGE:
  3251.     {
  3252.       _FMTMSG("Scroll docWinID %d page up.", docWinID);
  3253.  
  3254.       break;
  3255.     } /* case SCROLLVIEW_UPPAGE */
  3256.  
  3257.     case SCROLLVIEW_DOWNPAGE:
  3258.     {
  3259.       _FMTMSG("Scroll docWinID %d page down.", docWinID);
  3260.  
  3261.       break;
  3262.     } /* case SCROLLVIEW_DOWNPAGE */
  3263.  
  3264.     case SCROLLVIEW_LEFTPAGE:
  3265.     {
  3266.       _FMTMSG("Scroll docWinID %d page left.", docWinID);
  3267.  
  3268.       break;
  3269.     } /* case SCROLLVIEW_LEFTPAGE */
  3270.  
  3271.     case SCROLLVIEW_RIGHTPAGE:
  3272.     {
  3273.       _FMTMSG("Scroll docWinID %d page right.", docWinID);
  3274.  
  3275.       break;
  3276.     } /* case SCROLLVIEW_RIGHTPAGE */
  3277.  
  3278.     case SCROLLVIEW_LEFTDOWNSTEP:
  3279.     {
  3280.       _FMTMSG("Scroll docWinID %d step left and down.", docWinID);
  3281.  
  3282.       break;
  3283.     } /* case SCROLLVIEW_LEFTDOWNSTEP */
  3284.  
  3285.     case SCROLLVIEW_RIGHTDOWNSTEP:
  3286.     {
  3287.       _FMTMSG("Scroll docWinID %d step right and down.", docWinID);
  3288.  
  3289.       break;
  3290.     } /* case SCROLLVIEW_RIGHTDOWNSTEP */
  3291.  
  3292.     case SCROLLVIEW_LEFTUPSTEP:
  3293.     {
  3294.       _FMTMSG("Scroll docWinID %d tep left and up.", docWinID);
  3295.  
  3296.       break;
  3297.     } /* case SCROLLVIEW_LEFTUPSTEP */
  3298.  
  3299.     case SCROLLVIEW_RIGHTUPSTEP:
  3300.     {
  3301.       _FMTMSG("Scroll docWinID %d step right and up.", docWinID);
  3302.  
  3303.       break;
  3304.     } /* case SCROLLVIEW_RIGHTUPSTEP */
  3305.  
  3306.     case SCROLLVIEW_LEFTDOWNPAGE:
  3307.     {
  3308.       _FMTMSG("Scroll docWinID %d page left and down.", docWinID);
  3309.  
  3310.       break;
  3311.     } /* case SCROLLVIEW_LEFTDOWNPAGE */
  3312.  
  3313.     case SCROLLVIEW_RIGHTDOWNPAGE:
  3314.     {
  3315.       _FMTMSG("Scroll docWinID %d page right and down.", docWinID);
  3316.  
  3317.       break;
  3318.     } /* case SCROLLVIEW_RIGHTDOWNPAGE */
  3319.  
  3320.     case SCROLLVIEW_LEFTUPPAGE:
  3321.     {
  3322.       _FMTMSG("Scroll docWinID %d page left and up.", docWinID);
  3323.  
  3324.       break;
  3325.     } /* case SCROLLVIEW_LEFTUPPAGE */
  3326.  
  3327.     case SCROLLVIEW_RIGHTUPPAGE:
  3328.     {
  3329.       _FMTMSG("Scroll docWinID %d page right and up.", docWinID);
  3330.  
  3331.       break;
  3332.     } /* case SCROLLVIEW_RIGHTUPPAGE */
  3333.  
  3334.     default:
  3335.     {
  3336.       _FMTMSG("***Unrecognized scrollmode for docWinID %d.", docWinID);
  3337.  
  3338.       break;
  3339.     } /* case default */
  3340.   } /* switch (scrollmode) */
  3341.  
  3342.   wsprintf(szBuffer, "[SETSCROLLVIEW(%d,%d)]", docWinID, scrollmode);
  3343.  
  3344.   size = (WORD)(lstrlen(szBuffer) + 1);
  3345.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3346.  
  3347. cleanup:
  3348.   if (!ret) _MSG(pDdeErrMsg);
  3349.  
  3350.   return (ret);
  3351. } /* IMG_SetScrollView() */
  3352.  
  3353. /* ========================================= Parallax C Function ==================
  3354.  
  3355.    @Name: IMG_SetTool
  3356.    @Desc: 
  3357.  
  3358. ============================================================================== */
  3359.  
  3360. int IMG_SetTool(HCONV ghConv, DOCWINID docWinID, int tooltype)
  3361. {
  3362.   char  szBuffer[256];
  3363.   WORD  size;
  3364.   int   ret = FALSE;
  3365.  
  3366.   if (ghConv == NULL) goto cleanup;
  3367.  
  3368.   /* docWinID = 0 */
  3369.   if (!docWinID)
  3370.   {
  3371.     HCONV ghConvLoc = ghConv;
  3372.  
  3373.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  3374.   } /* if (!docWinID) */
  3375.  
  3376.   if (!docWinID) return (FALSE);
  3377.  
  3378.   if (!_GetActiveEditLayer(ghConv, docWinID))
  3379.   {
  3380.     _MSG("No active edit layer. Couldn't set any tool.");
  3381.  
  3382.     ret = TRUE;
  3383.   } else /* if (!_GetActiveEditLayer(ghConv, docWinID)) */
  3384.   {
  3385.     switch (tooltype)
  3386.     {
  3387.       case TOOL_NONE:
  3388.       {
  3389.         _FMTMSG("Set no active tool for docWinID %d.", docWinID);
  3390.  
  3391.         break;                                        
  3392.       } /* case TOOL_NONE */
  3393.  
  3394.       case TOOL_CUT:
  3395.       {
  3396.         _FMTMSG("Set active tool to CUT for docWinID %d.", docWinID);
  3397.  
  3398.         break;
  3399.       } /* case TOOL_CUT */
  3400.  
  3401.       case TOOL_COPY:
  3402.       {
  3403.         _FMTMSG("Set active tool to COPY for docWinID %d.", docWinID);
  3404.  
  3405.         break;
  3406.       } /* case TOOL_COPY */
  3407.  
  3408.       case TOOL_PASTE:
  3409.       {
  3410.         _FMTMSG("Set active tool to PASTE for docWinID %d.", docWinID);
  3411.  
  3412.         break;
  3413.       } /* case TOOL_PASTE */
  3414.  
  3415.       case TOOL_LINE:
  3416.       {
  3417.         _FMTMSG("Set active tool to LINE for docWinID %d.", docWinID);
  3418.  
  3419.         break;
  3420.       } /* case TOOL_LINE */
  3421.  
  3422.       case TOOL_BOX:
  3423.       {
  3424.         _FMTMSG("Set active tool to BOX for docWinID %d.", docWinID);
  3425.  
  3426.         break;
  3427.       } /* case TOOL_BOX */
  3428.  
  3429.       case TOOL_CIRCLE:
  3430.       {
  3431.         _FMTMSG("Set active tool to CIRCLE for docWinID %d.", docWinID);
  3432.  
  3433.         break;
  3434.       } /* case TOOL_CIRCLE */
  3435.  
  3436.       case TOOL_ELLIPSE:
  3437.       {
  3438.         _FMTMSG("Set active tool to ELLIPSE for docWinID %d.", docWinID);
  3439.  
  3440.         break;
  3441.       } /* case TOOL_ELLPISE */
  3442.  
  3443.       case TOOL_ARROW:
  3444.       {
  3445.         _FMTMSG("Set active tool to ARROW for docWinID %d.", docWinID);
  3446.  
  3447.         break;
  3448.       } /* case TOOL_ARROW */
  3449.  
  3450.       case TOOL_SKETCH:
  3451.       {
  3452.         _FMTMSG("Set active tool to SKETCH for docWinID %d.", docWinID);
  3453.  
  3454.         break;
  3455.       } /* case TOOL_SKETCH */
  3456.  
  3457.       case TOOL_POLYLINE:
  3458.       {
  3459.         _FMTMSG("Set active tool to POLYLINE for docWinID %d.", docWinID);
  3460.  
  3461.         break;
  3462.       } /* case TOOL_POLYLINE */
  3463.  
  3464.       case TOOL_POLYGON:
  3465.       {
  3466.         _FMTMSG("Set active tool to POLYGON for docWinID %d.", docWinID);
  3467.  
  3468.         break;
  3469.       } /* case TOOL_POLYGON */
  3470.  
  3471.       case TOOL_TEXT:
  3472.       {
  3473.         _FMTMSG("Set active tool to TEXT for docWinID %d.", docWinID);
  3474.  
  3475.         break;
  3476.       } /* case TOOL_TEXT */
  3477.  
  3478.       case TOOL_ANNOTATION:
  3479.       {
  3480.         _FMTMSG("Set active tool to ANNOTATION for docWinID %d.", docWinID);
  3481.  
  3482.         break;
  3483.       } /* case TOOL_ANNOTATION */
  3484.  
  3485.       case TOOL_DIMENSION:
  3486.       {
  3487.         _FMTMSG("Set active tool to DIMENSION for docWinID %d.", docWinID);
  3488.  
  3489.         break;
  3490.       } /* case TOOL_DIMENSION */
  3491.  
  3492.       case TOOL_SYMBOL:
  3493.       {
  3494.         _FMTMSG("Set active tool to SYMBOL for docWinID %d.", docWinID);
  3495.  
  3496.         break;
  3497.       } /* case TOOL_SYMBOL */
  3498.  
  3499.       case TOOL_HOTSPOT:
  3500.       {
  3501.         _FMTMSG("Set active tool to HOTSPOT for docWinID %d.", docWinID);
  3502.  
  3503.         break;
  3504.       } /* case TOOL_HOTSPOT */
  3505.  
  3506.       case TOOL_RUBOUT:
  3507.       {
  3508.         _FMTMSG("Set active tool to RUBOUT for docWinID %d.", docWinID);
  3509.  
  3510.         break;
  3511.       } /* case TOOL_RUBOUT */
  3512.  
  3513.       case TOOL_ERASER:
  3514.       {
  3515.         _FMTMSG("Set active tool to ERASER for docWinID %d.", docWinID);
  3516.  
  3517.         break;
  3518.       } /* case TOOL_ERASER */
  3519.  
  3520.       case TOOL_SELECT:
  3521.       {
  3522.         _FMTMSG("Set active tool to SELECT for docWinID %d.", docWinID);
  3523.  
  3524.         break;
  3525.       } /* case TOOL_SELECT */
  3526.  
  3527.       case TOOL_MOVERESIZE:
  3528.       {
  3529.         _FMTMSG("Set active tool to MOVERESIZE for docWinID %d.", docWinID);
  3530.  
  3531.         break;
  3532.       } /* case TOOL_MOVERESIZE */
  3533.  
  3534.       case TOOL_ROTATE:
  3535.       {
  3536.         _FMTMSG("Set active tool to ROTATE for docWinID %d.", docWinID);
  3537.  
  3538.         break;
  3539.       } /* case TOOL_ROTATE */
  3540.  
  3541.       case TOOL_CHANGETEXT:
  3542.       {
  3543.         _FMTMSG("Set active tool to CHANGETEXT for docWinID %d.", docWinID);
  3544.  
  3545.         break;
  3546.       } /* case TOOL_CHANGETEXT */
  3547.  
  3548.       case TOOL_ARC:
  3549.       {
  3550.         _FMTMSG("Set active tool to ARC for docWinID %d.", docWinID);
  3551.  
  3552.         break;
  3553.       } /* case TOOL_ARC */
  3554.  
  3555.       default:
  3556.       {
  3557.         _FMTMSG("***Unrecognized tool set for docWinID %d.", docWinID);
  3558.  
  3559.         break;
  3560.       } /* case default */
  3561.  
  3562.     } /* switch (toolType) */
  3563.  
  3564.     wsprintf(szBuffer, "[SETTOOL(%d,%d)]", docWinID, tooltype);
  3565.  
  3566.     size = (WORD)(lstrlen(szBuffer) + 1);
  3567.     if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3568.   } /* if (!_GetActiveEditLayer(ghConv, docWinID)) */
  3569.  
  3570. cleanup:
  3571.   if (!ret) _MSG(pDdeErrMsg);
  3572.  
  3573.   return (ret);
  3574. } /* IMG_SetTool() */
  3575.  
  3576. /* ========================================= Parallax C Function ==================
  3577.  
  3578.    @Name: IMG_SetWindowTitle
  3579.    @Desc: 
  3580.  
  3581. ============================================================================== */
  3582.  
  3583. int IMG_SetWindowTitle(HCONV ghConv, DOCWINID docWinID, void FAR* title)
  3584. {
  3585.   char  szBuffer[256];
  3586.   WORD  size;
  3587.   int   ret = FALSE;
  3588.  
  3589.   if (ghConv == NULL) goto cleanup;
  3590.  
  3591.   /* docWinID = 0 */
  3592.   if (!docWinID)
  3593.   {
  3594.     HCONV ghConvLoc = ghConv;
  3595.  
  3596.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  3597.   } /* if (!docWinID) */
  3598.  
  3599.   if (!docWinID) return (FALSE);
  3600.  
  3601.   if (title == NULL) title=(void FAR*)nulltitle;
  3602.  
  3603.   _FMTMSG("Set window title of docWinID %d.", docWinID);
  3604.   _FMTMSG("   -->title     = \"%s\".", title);
  3605.  
  3606.   wsprintf(szBuffer, "[SETWINDOWTITLE(%d,\"%s\")]", docWinID, (LPSTR)title);
  3607.  
  3608.   size = (WORD)(lstrlen(szBuffer) + 1);
  3609.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3610.  
  3611. cleanup:
  3612.   if (!ret) _MSG(pDdeErrMsg);
  3613.  
  3614.   return (ret);
  3615. } /* IMG_SetWindowTitle() */
  3616.  
  3617. /* ========================================= Parallax C Function ==================
  3618.  
  3619.    @Name: IMG_SetZoom
  3620.    @Desc: 
  3621.  
  3622. ============================================================================== */
  3623.  
  3624. int IMG_SetZoom(HCONV ghConv, DOCWINID docWinID, int zoomLevel, float factor, int xpos, int ypos)
  3625. {
  3626.   char  szBuffer[256];
  3627.   WORD  size;
  3628.        int   ret = FALSE;
  3629.   char ptr[10];
  3630.  
  3631.   if (ghConv == NULL) goto cleanup;
  3632.  
  3633.   /* docWinID = 0 */
  3634.   if (!docWinID)
  3635.   {
  3636.      HCONV ghConvLoc = ghConv;
  3637.  
  3638.      docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  3639.   }
  3640.  
  3641.   if (!docWinID) return (FALSE);
  3642.  
  3643.   _FMTMSG("Set zoom level for docWinID %d.", docWinID);
  3644.   switch (zoomLevel)
  3645.   {
  3646.     case ZOOM_IN:
  3647.     {
  3648.       _MSG("   -->Zoom in.");
  3649.  
  3650.       break;
  3651.     } /* case ZOOM_IN */
  3652.  
  3653.     case ZOOM_OUT:
  3654.     {
  3655.       _MSG("   -->Zoom out.");
  3656.  
  3657.       break;
  3658.     } /* case ZOOM_OUT */
  3659.  
  3660.     case ZOOM_FIT:
  3661.     {
  3662.       _MSG("   -->Zoom to fit.");
  3663.  
  3664.       break;
  3665.     } /* case ZOOM_FIT */
  3666.  
  3667.     case ZOOM_HFIT:
  3668.     {
  3669.       _MSG("   -->Zoom horizontal fit.");
  3670.  
  3671.       break;
  3672.     } /* case ZOOM_HFIT */
  3673.  
  3674.     case ZOOM_VFIT:
  3675.     {
  3676.       _MSG("   -->Zoom vertical fit.");
  3677.  
  3678.       break;
  3679.     } /* case ZOOM_VFIT */
  3680.  
  3681.     case ZOOM_ACTUAL:
  3682.     {
  3683.       _MSG("   -->Zoom to actual size.");
  3684.  
  3685.       break;
  3686.     } /* case ZOOM_ACTUAL */
  3687.  
  3688.     case ZOOM_1TO1:
  3689.     {
  3690.       _MSG("   -->Zoom to 1:1.");
  3691.  
  3692.       break;
  3693.     } /* case ZOOM_1TO1 */
  3694.  
  3695.     default:
  3696.     {
  3697.       _MSG("   ***unrecognized zoom level.");
  3698.  
  3699.       break;
  3700.     } /* case default */
  3701.  
  3702.   } /* switch (zoomLevel) */
  3703.  
  3704.   gcvt((double)factor, 5, ptr);
  3705.  
  3706.   _FMTMSG("   -->scale factor = %s", ptr);
  3707.   _FMTMSG("   -->x position   = %d", xpos);
  3708.   _FMTMSG("   -->y position   = %d", ypos);
  3709.  
  3710.   wsprintf(szBuffer, "[SETZOOM(%d,%d,%s,%d,%d)]", docWinID, zoomLevel, (LPSTR)ptr, xpos, ypos);
  3711.  
  3712.   size = (WORD)(lstrlen(szBuffer) + 1);
  3713.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3714.  
  3715. cleanup:
  3716.   if (!ret) _MSG(pDdeErrMsg);
  3717.  
  3718.   return (ret);
  3719. } /* IMG_SetZoom() */
  3720.  
  3721. /* ========================================= Parallax C Function ==================
  3722.  
  3723.    @Name: IMG_SetZoomStep
  3724.    @Desc: 
  3725.  
  3726. ============================================================================== */
  3727.  
  3728. int IMG_SetZoomStep(HCONV ghConv, DOCWINID docWinID, float zoomstep)
  3729. {
  3730.   char  szBuffer[256];
  3731.   WORD  size;
  3732.        int   ret = FALSE;
  3733.   char ptr[10];
  3734.  
  3735.   if (ghConv == NULL) goto cleanup;
  3736.  
  3737.   /* docWinID = 0 */
  3738.   if (!docWinID)
  3739.   {
  3740.     HCONV ghConvLoc = ghConv;
  3741.  
  3742.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  3743.   } /* if (!docWinID) */
  3744.  
  3745.   if (!docWinID) return (FALSE);
  3746.  
  3747.   _FMTMSG("Set zoom step for docWinID %d.", docWinID);
  3748.   gcvt((double)zoomstep, 5, ptr);
  3749.   _FMTMSG("   -->zoom step = %s.", ptr);
  3750.  
  3751.   wsprintf(szBuffer, "[SETZOOMSTEP(%d,%s)]", docWinID, (LPSTR)ptr);
  3752.  
  3753.   size = (WORD)(lstrlen(szBuffer) + 1);
  3754.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3755.  
  3756. cleanup:
  3757.   if (!ret) _MSG(pDdeErrMsg);
  3758.  
  3759.   return (ret);
  3760. } /* IMG_SetZoomStep() */
  3761.  
  3762. /* ========================================= Parallax C Function ==================
  3763.  
  3764.    @Name: IMG_ShowDocWin
  3765.    @Desc: 
  3766.  
  3767. ============================================================================== */
  3768.  
  3769. int IMG_ShowDocWin(HCONV ghConv, DOCWINID docWinID, int arrangement)
  3770. {
  3771.   char  szBuffer[256];
  3772.   WORD  size;
  3773.   int   ret = FALSE;
  3774.  
  3775.   if (ghConv == NULL) goto cleanup;
  3776.  
  3777.   /* docWinID = 0 */
  3778.   if (!docWinID)
  3779.   {
  3780.     HCONV ghConvLoc = ghConv;
  3781.  
  3782.     docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  3783.   } /* if (!docWinID) */
  3784.  
  3785.   if (!docWinID) return (FALSE);
  3786.  
  3787.   switch (arrangement)
  3788.   {
  3789.     case SHOW_MINIMIZE:
  3790.     {
  3791.       _FMTMSG("Minimize docWinID %d.", docWinID);
  3792.  
  3793.       break;
  3794.     } /* case SHOW_MINIMIZE */
  3795.  
  3796.     case SHOW_MAXIMIZE:
  3797.     {
  3798.       _FMTMSG("Maximize docWinID %d.", docWinID);
  3799.  
  3800.       break;
  3801.     } /* case SHOW_MAXIMIZE */
  3802.  
  3803.     case SHOW_RESTORE:
  3804.     {
  3805.       _FMTMSG("Restore docWinID %d.", docWinID);
  3806.  
  3807.       break;
  3808.     } /* case SHOW_RESTORE */
  3809.  
  3810.     case SHOW_HIDE:
  3811.     {
  3812.       _FMTMSG("Hide docWinID %d.", docWinID);
  3813.  
  3814.       break;
  3815.     } /* case SHOW_HIDE */
  3816.  
  3817.     case SHOW_UNHIDE:
  3818.     {
  3819.       _FMTMSG("Unhide docWinID %d.", docWinID);
  3820.  
  3821.       break;
  3822.     } /* case SHOW_UNHIDE */
  3823.  
  3824.     default:
  3825.     {
  3826.       _MSG("***Unrecognized show command.");
  3827.  
  3828.       break;
  3829.     } /* case default */
  3830.   } /* switch (arrangement) */
  3831.  
  3832.   wsprintf(szBuffer, "[SHOWDOCWIN(%d,%d)]", docWinID, arrangement);
  3833.  
  3834.   size = (WORD)(lstrlen(szBuffer) + 1);
  3835.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3836.  
  3837. cleanup:
  3838.   if (!ret) _MSG(pDdeErrMsg);
  3839.  
  3840.   return (ret);
  3841. } /* IMG_ShowDocWin() */
  3842.  
  3843. /* ========================================= Parallax C Function ==================
  3844.  
  3845.    @Name: IMG_Terminate
  3846.    @Desc: 
  3847.  
  3848. ============================================================================== */
  3849.  
  3850. int IMG_Terminate(HCONV ghConv)
  3851. {
  3852.   char  szBuffer[256];
  3853.   WORD  size;
  3854.   int   ret = FALSE;
  3855.  
  3856.   if (ghConv == NULL) goto cleanup;
  3857.   _MSG("Terminate program.");
  3858.  
  3859.   wsprintf(szBuffer, "[TERMINATE]");
  3860.  
  3861.   size = (WORD)(lstrlen(szBuffer) + 1);
  3862.   if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3863.  
  3864. cleanup:
  3865.   if (!ret) _MSG(pDdeErrMsg);
  3866.  
  3867.   return (ret);
  3868. } /* IMG_Terminate() */
  3869.  
  3870. /* ========================================= Parallax C Function ==================
  3871.  
  3872.    @Name: IMG_Despeckle
  3873.    @Desc: 
  3874.  
  3875. ============================================================================== */
  3876.  
  3877. int IMG_Despeckle(HCONV ghConv, HWND docWinId, int speckle)
  3878. {
  3879.   char  szBuffer[256];
  3880.   WORD  size;
  3881.   int   ret = FALSE;
  3882.   HCONV ghConvLoc = ghConv;
  3883.  
  3884.   if (ghConv == NULL) goto cleanup;
  3885.  
  3886.   if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE))
  3887.   {
  3888.     _MSG("No open document. Nothing to despeckle.");
  3889.  
  3890.     ret = TRUE;
  3891.   } else /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  3892.   {
  3893.     _FMTMSG("Despeckle Current DocWin %d speckles", speckle);
  3894.  
  3895.     wsprintf(szBuffer, "[DESPECKLE(%d,%d,%d)]", docWinId, 0, speckle);
  3896.  
  3897.     size = (WORD)(lstrlen(szBuffer) + 1);
  3898.     if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3899.   } /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  3900.  
  3901. cleanup:
  3902.   if (!ret) _MSG(pDdeErrMsg);
  3903.  
  3904.   return (ret);
  3905. } /* IMG_Despeckle() */
  3906.  
  3907.  
  3908. /* ========================================= Parallax C Function ==================
  3909.  
  3910.    @Name: IMG_Deskew
  3911.    @Desc: 
  3912.  
  3913. ============================================================================== */
  3914. int IMG_Deskew(HCONV ghConv, HWND docWinId, float angle)
  3915. {
  3916.   char  szBuffer[256];
  3917.   WORD  size;
  3918.   int   ret = FALSE;
  3919.   char ptr[10];
  3920.   HCONV ghConvLoc = ghConv;
  3921.  
  3922.   if (ghConv == NULL) goto cleanup;
  3923.  
  3924.   if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE))
  3925.   {
  3926.     _MSG("No open document. Nothing to deskew.");
  3927.  
  3928.     ret = TRUE;
  3929.   } else /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  3930.   {
  3931.     gcvt((double)angle, 5, ptr);
  3932.     _FMTMSG("Deskew current doc win %s degrees.", (LPSTR)ptr);
  3933.  
  3934.     wsprintf(szBuffer, "[DESKEW(%d,%d,%s)]", docWinId, 0, (LPSTR)ptr);
  3935.  
  3936.     size = (WORD)(lstrlen(szBuffer) + 1);
  3937.     if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3938.   } /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  3939.  
  3940. cleanup:
  3941.   if (!ret) _MSG(pDdeErrMsg);
  3942.  
  3943.   return (ret);
  3944. } /* IMG_Deskew() */
  3945.  
  3946. /* ========================================= Parallax C Function ==================
  3947.  
  3948.    @Name: IMG_Crop
  3949.    @Desc: 
  3950.  
  3951. ============================================================================== */
  3952. int IMG_Crop(HCONV ghConv, HWND docWinId, long x1, long y1, long x2, long y2)
  3953. {
  3954.   char  szBuffer[256];
  3955.   WORD  size;
  3956.   int   ret = FALSE;
  3957.   HCONV ghConvLoc = ghConv;
  3958.  
  3959.   if (ghConv == NULL) goto cleanup;
  3960.  
  3961.   if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE))
  3962.   {
  3963.     _MSG("No open document. Nothing to crop.");
  3964.  
  3965.     ret = TRUE;
  3966.   } else /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  3967.   {
  3968.     wsprintf(szBuffer, "Crop DocWin:%d, Layer:%d at (%lu,%lu) -- (%lu,%lu)", docWinId, 0, x1, y1, x2, y2);
  3969.     _MSG(szBuffer);
  3970.  
  3971.     wsprintf(szBuffer, "[CROPLAYER(%d,%d,%d,0,0,%lu.0,%lu.0,%lu.0,%lu.0)]", docWinId, 1, 1, x1, y1, x2, y2);
  3972.  
  3973.     size = (WORD)(lstrlen(szBuffer) + 1);
  3974.     if (IMG_Execute(ghConv, (void FAR*)szBuffer, size, NULL) == DDE_FACK) ret = TRUE;
  3975.   } /* if (!(DOCWINID)_GetDocWin(ghConvLoc, FALSE)) */
  3976.  
  3977. cleanup:
  3978.   if (!ret) _MSG(pDdeErrMsg);
  3979.  
  3980.   return (ret);
  3981. } /* IMG_Crop() */
  3982.  
  3983. /* ========================================= Parallax C Function ==================
  3984.  
  3985.    @Name: IMG_GetDeskewLimit
  3986.    @Desc: 
  3987.  
  3988. ============================================================================== */
  3989.  
  3990. int IMG_GetDeskewLimit(HCONV ghConv, DOCWINID docWinID, LAYERID layerId, double FAR* angle)
  3991. {
  3992.   HDDEDATA hData;
  3993.   char     szBuffer[256];
  3994.   int      ret = FALSE;
  3995.   double   tmp = 0.0;
  3996.  
  3997.   if (ghConv == NULL) goto cleanup;
  3998.  
  3999.   /* docWinID = 0 */
  4000.   if (!docWinID)
  4001.   {
  4002.      HCONV ghConvLoc = ghConv;
  4003.  
  4004.      docWinID = (DOCWINID)_GetDocWin(ghConvLoc, TRUE);
  4005.   } /* if (!docWinID) */
  4006.  
  4007.   if (!docWinID) return (FALSE);
  4008.  
  4009.   wsprintf(szBuffer, "[GETDESKEWLIMITS(%d,%d)]", docWinID, layerId);
  4010.  
  4011.   IMG_Request(ghConv, (void FAR*)szBuffer, &hData);
  4012.  
  4013.   if (hData)
  4014.   {
  4015.     char pData[2*PARMSIZE];
  4016.  
  4017.     int igd;
  4018.     igd = IMG_GetData(hData, (char FAR*)pData, 1);
  4019.  
  4020.     if (igd == 1)
  4021.     {
  4022.       tmp = img_ATOF(pData);
  4023.  
  4024.       if (angle) *angle = tmp;
  4025.  
  4026.       _FMTMSG2("Deskew Limit for Active Raster layer is %s for docWinID %x.", (LPSTR)pData, (short)docWinID);
  4027.  
  4028.       ret = TRUE;
  4029.     } /* if (igd == 1) */
  4030.   } /* if (hData) */
  4031.  
  4032. cleanup:
  4033.   if (!ret) _MSG(pDdeErrMsg);
  4034.  
  4035.   return (ret);
  4036. } /* IMG_GetDeskewLimit() */
  4037.  
  4038. /* UTDDE.C */
  4039. /* end of file */
  4040.