home *** CD-ROM | disk | FTP | other *** search
/ ActiveX Programming Unleashed CD / AXU.iso / componen / interact / demo / data.1 / CIFACE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-21  |  56.2 KB  |  2,342 lines
  1. /***************************************************************************\
  2.  
  3.    (c) 1995-1996, ProtoView Development Co., All rights reserved
  4. \***************************************************************************/
  5.  
  6. /*
  7.  *  These functions interface C and C++ programs with the IDO.
  8.  *  This removes the need for using a message-based architecture,
  9.  *  hiding many of the details from the programmer, and allowing
  10.  *  the IDO to expose the same interfaces for the DLL and OCX programmer.
  11.  *
  12.  *  Copyright (c) 1995-1996 ProtoView Development Corp.
  13.  */
  14.  
  15. #include <windows.h>
  16. #include <stdlib.h>
  17. #include <memory.h>
  18.  
  19. #include "..\h\pvido.h"
  20.  
  21.  
  22. #define IDO_I SendMessage
  23. #define MAX_TEMP_LEN 200+1
  24.  
  25. static LPSTR      lpszText = NULL;
  26. static IDO_FONT   idoFont;
  27.  
  28. void idoShutDown()
  29. {
  30.    if(lpszText)
  31.       free(lpszText);
  32. }
  33.  
  34.  
  35. ///////////////////////////////////////////////////////////////////////
  36. ///////////////////////////////////////////////////////////////////////
  37. // PROPERTIES
  38. ///////////////////////////////////////////////////////////////////////
  39.  
  40. int  WINAPI idoGetGridHeight(HWND hIDO)
  41. {
  42.    if(!IsWindow(hIDO))
  43.       return FALSE;
  44.  
  45.    return (int)IDO_I(hIDO, IDOM_GETGRIDHEIGHT, 0, 0L);
  46. }
  47. void WINAPI idoSetGridHeight(HWND hIDO, int cHeight)
  48. {
  49.    if(!IsWindow(hIDO))
  50.       return;
  51.  
  52.    IDO_I(hIDO, IDOM_SETGRIDHEIGHT, cHeight, 0L);
  53. }
  54. int  WINAPI idoGetGridWidth(HWND hIDO)
  55. {
  56.    if(!IsWindow(hIDO))
  57.       return FALSE;
  58.  
  59.    return (int)IDO_I(hIDO, IDOM_GETGRIDWIDTH, 0, 0L);
  60. }
  61. void WINAPI idoSetGridWidth(HWND hIDO, int cWidth)
  62. {
  63.    if(!IsWindow(hIDO))
  64.       return;
  65.  
  66.    IDO_I(hIDO, IDOM_SETGRIDWIDTH, cWidth, 0L);
  67. }
  68.  
  69.  
  70. COLORREF WINAPI idoGetGridLineColor(HWND hIDO)
  71. {
  72.    if(!IsWindow(hIDO))
  73.       return FALSE;
  74.  
  75.    return (COLORREF)IDO_I(hIDO, IDOM_GETGRIDCOLOR, 0, 0L);
  76. }
  77. void     WINAPI idoSetGridLineColor(HWND hIDO, COLORREF cColor)
  78. {
  79.    if(!IsWindow(hIDO))
  80.       return;
  81.  
  82.    IDO_I(hIDO, IDOM_SETGRIDCOLOR, 0, (LRESULT)cColor);
  83. }
  84. COLORREF WINAPI idoGetBackColor(HWND hIDO)
  85. {
  86.    if(!IsWindow(hIDO))
  87.       return FALSE;
  88.  
  89.    return (COLORREF)IDO_I(hIDO, IDOM_GETIDOBKCOLOR, 0, 0L);
  90. }
  91. void     WINAPI idoSetBackColor(HWND hIDO, COLORREF cColor)
  92. {
  93.    if(!IsWindow(hIDO))
  94.       return;
  95.  
  96.    IDO_I(hIDO, IDOM_SETIDOBKCOLOR, 0, (LRESULT)cColor);
  97. }
  98.  
  99.  
  100. BOOL WINAPI idoGetGridLines(HWND hIDO)
  101. {
  102.    if(!IsWindow(hIDO))
  103.       return FALSE;
  104.  
  105.    return (BOOL)IDO_I(hIDO, IDOM_ISGRIDVISIBLE, 0, 0L);
  106. }
  107. void WINAPI idoSetGridLines(HWND hIDO, BOOL bEnable)
  108. {
  109.    if(!IsWindow(hIDO))
  110.       return;
  111.  
  112.    IDO_I(hIDO, IDOM_SETGRIDLINES, bEnable, 0L);
  113. }
  114.  
  115.  
  116. BOOL WINAPI idoGetSnapToGrid(HWND hIDO)
  117. {
  118.    if(!IsWindow(hIDO))
  119.       return FALSE;
  120.  
  121.    return (BOOL)IDO_I(hIDO, IDOM_ISSNAPTOGRID, 0, 0L);
  122. }
  123. void WINAPI idoSetSnapToGrid(HWND hIDO, BOOL bEnable)
  124. {
  125.    if(!IsWindow(hIDO))
  126.       return;
  127.  
  128.    IDO_I(hIDO, IDOM_SETSNAPTOGRID, bEnable, 0L);
  129. }
  130.  
  131.  
  132. BOOL WINAPI idoGetPrinterLines(HWND hIDO)
  133. {
  134.    if(!IsWindow(hIDO))
  135.       return FALSE;
  136.  
  137.    return (BOOL)IDO_I(hIDO, IDOM_GETSHOWPRINTPAGES, 0, 0L);
  138. }
  139. void WINAPI idoSetPrinterLines(HWND hIDO, BOOL bEnable)
  140. {
  141.    if(!IsWindow(hIDO))
  142.       return;
  143.  
  144.    IDO_I(hIDO, IDOM_SETSHOWPRINTPAGES, bEnable, 0L);
  145. }
  146.  
  147.  
  148. BOOL WINAPI idoGetPrinterLandscape(HWND hIDO)
  149. {
  150.    long lStyle;
  151.  
  152.    if(!IsWindow(hIDO))
  153.       return -1;
  154.  
  155.  
  156.    IDO_I(hIDO, IDOM_GETINTERACTPROPERTY, PROP_IPRINTLANDSCAPE, (LPARAM)(LPVOID)&lStyle);
  157.    return (BOOL)lStyle;
  158. }
  159. void WINAPI idoSetPrinterLandscape(HWND hIDO, BOOL bEnable)
  160. {
  161.    if(!IsWindow(hIDO))
  162.       return;
  163.  
  164.    IDO_I(hIDO, IDOM_SETINTERACTPROPERTY, PROP_IPRINTLANDSCAPE, bEnable);
  165. }
  166.  
  167.  
  168. BOOL WINAPI idoSetToolsPaletteButtonText(HWND hIDO, LPCSTR lpText)
  169. {
  170.    if(!IsWindow(hIDO))
  171.       return FALSE;
  172.    if(!lpText)
  173.       return FALSE;
  174.  
  175.    return (BOOL)IDO_I(hIDO, IDOM_SETTOOLSPALETTEBUTTONTEXT, 0, (LPARAM)(LPCSTR)lpText);
  176. }
  177.  
  178. BOOL WINAPI idoGetToolsPalette(HWND hIDO)
  179. {
  180.    if(!IsWindow(hIDO))
  181.       return FALSE;
  182.  
  183.    return (BOOL)IDO_I(hIDO, IDOM_ISPALETTEVISIBLE, 0, 0L);
  184. }
  185. void WINAPI idoSetToolsPalette(HWND hIDO, BOOL bEnable)
  186. {
  187.    if(!IsWindow(hIDO))
  188.       return;
  189.  
  190.    IDO_I(hIDO, IDOM_SETPALETTEVISIBLE, bEnable, 0L);
  191. }
  192.  
  193.  
  194. BOOL WINAPI idoGetEditMode(HWND hIDO)
  195. {
  196.    if(!IsWindow(hIDO))
  197.       return FALSE;
  198.  
  199.    return (BOOL)IDO_I(hIDO, IDOM_GETEDITMODE, 0, 0L);
  200. }
  201. void WINAPI idoSetEditMode(HWND hIDO, BOOL bEnable)
  202. {
  203.    if(!IsWindow(hIDO))
  204.       return;
  205.  
  206.    IDO_I(hIDO, IDOM_SETEDITMODE, bEnable, 0L);
  207. }
  208.  
  209.  
  210. BOOL WINAPI idoGetRulesEnforced(HWND hIDO)
  211. {
  212.    if(!IsWindow(hIDO))
  213.       return FALSE;
  214.  
  215.    return (BOOL)IDO_I(hIDO, IDOM_ARERULESENFORCED, 0, 0L);
  216. }
  217. void WINAPI idoSetRulesEnforced(HWND hIDO, BOOL bEnable)
  218. {
  219.    if(!IsWindow(hIDO))
  220.       return;
  221.  
  222.    IDO_I(hIDO, IDOM_SETENFORCERULES, bEnable, 0L);
  223. }
  224.  
  225.  
  226. BOOL WINAPI idoGetCurrentEntity(HWND hIDO, LPENTITY lpEnt)
  227. {
  228.    if(!IsWindow(hIDO))
  229.       return FALSE;
  230.    if(!lpEnt)
  231.       return FALSE;
  232.  
  233.     if(IDOR_SUCCESS == IDO_I(hIDO, IDOM_GETCURRENTENTITY, 0, (LPARAM)(LPVOID)lpEnt))
  234.        return TRUE;
  235.  
  236.     return FALSE;
  237. }
  238. BOOL WINAPI idoSetCurrentEntity(HWND hIDO, LPENTITY lpEnt)
  239. {
  240.    if(!IsWindow(hIDO))
  241.       return FALSE;
  242.    if(!lpEnt)
  243.       return FALSE;
  244.  
  245.    return (BOOL)IDO_I(hIDO, IDOM_SETCURRENTENTITY, 0, (LPARAM)(LPVOID)lpEnt);
  246. }
  247.  
  248.  
  249. BOOL WINAPI idoGetCurrentRelation(HWND hIDO, LPRELATION lpRel)
  250. {
  251.    if(!IsWindow(hIDO))
  252.       return FALSE;
  253.    if(!lpRel)
  254.       return FALSE;
  255.  
  256.     if(IDOR_SUCCESS == IDO_I(hIDO, IDOM_GETCURRENTLINE, 0, (LPARAM)(LPVOID)lpRel))
  257.        return TRUE;
  258.  
  259.     return FALSE;
  260. }
  261. BOOL WINAPI idoSetCurrentRelation(HWND hIDO, LPRELATION lpRel)
  262. {
  263.    if(!IsWindow(hIDO))
  264.       return FALSE;
  265.    if(!lpRel)
  266.       return FALSE;
  267.  
  268.     if(IDOR_SUCCESS == IDO_I(hIDO, IDOM_SETCURRENTLINE, 0, (LPARAM)(LPVOID)lpRel))
  269.        return TRUE;
  270.  
  271.     return FALSE;
  272. }
  273.  
  274.  
  275.  
  276. void WINAPI idoSetWindowStyle(HWND hIDO, long lStyle)
  277. {
  278.    if(!IsWindow(hIDO))
  279.       return;
  280.  
  281.    SetWindowLong(hIDO, GWL_STYLE, lStyle);
  282.    InvalidateRect(hIDO, NULL, TRUE);
  283.    UpdateWindow(hIDO);
  284. }
  285. long WINAPI idoGetWindowStyle(HWND hIDO)
  286. {
  287.    if(!IsWindow(hIDO))
  288.       return 0L;
  289.  
  290.    return GetWindowLong(hIDO, GWL_STYLE);
  291. }
  292.  
  293.  
  294. void WINAPI idoSetModified(HWND hIDO, BOOL bVal)
  295. {
  296.    if(!IsWindow(hIDO))
  297.       return;
  298.  
  299.    IDO_I(hIDO, IDOM_SETMODIFIED, bVal, 0L);
  300. }
  301. BOOL WINAPI idoGetModified(HWND hIDO)
  302. {
  303.    if(!IsWindow(hIDO))
  304.       return -1;
  305.  
  306.    return(BOOL)IDO_I(hIDO, IDOM_GETMODIFIED, 0, 0L);
  307. }
  308.  
  309.  
  310. void WINAPI idoSetBorder(HWND hIDO, BOOL bVal)
  311. {
  312.    long lStyle;
  313.  
  314.    if(!IsWindow(hIDO))
  315.       return;
  316.  
  317.    lStyle = idoGetWindowStyle(hIDO);
  318.    if(bVal)
  319.       lStyle |= WS_BORDER;
  320.    else
  321.       lStyle &= !WS_BORDER;
  322.  
  323.    idoSetWindowStyle(hIDO, lStyle);
  324. }
  325. BOOL WINAPI idoGetBorder(HWND hIDO)
  326. {
  327.    long lStyle;
  328.  
  329.    if(!IsWindow(hIDO))
  330.       return FALSE;
  331.  
  332.    lStyle = idoGetWindowStyle(hIDO);
  333.    return (BOOL)(lStyle & WS_BORDER);
  334. }
  335.  
  336. void WINAPI idoSetScrollBars(HWND hIDO, long lVal)
  337. {
  338.    long lStyle;
  339.  
  340.    if(!IsWindow(hIDO))
  341.       return;
  342.  
  343.    lStyle = idoGetWindowStyle(hIDO);
  344.    switch(lVal)
  345.    {
  346.       case IDO_NONE :
  347.          lStyle &= !WS_HSCROLL;
  348.          lStyle &= !WS_VSCROLL;
  349.          break;
  350.       case IDO_HSCROLL :
  351.          lStyle &= !WS_VSCROLL;
  352.          lStyle |= WS_HSCROLL;
  353.          break;
  354.       case IDO_VSCROLL :
  355.          lStyle &= !WS_HSCROLL;
  356.          lStyle |= WS_VSCROLL;
  357.          break;
  358.       case IDO_BOTH :
  359.          lStyle |= WS_HSCROLL;
  360.          lStyle |= WS_VSCROLL;
  361.          break;
  362.    }
  363.    idoSetWindowStyle(hIDO, lStyle);
  364. }
  365. long WINAPI idoGetScrollBars(HWND hIDO)
  366. {
  367.    long lStyle;
  368.  
  369.    if(!IsWindow(hIDO))
  370.       return (long)-1;
  371.  
  372.    lStyle = idoGetWindowStyle(hIDO);
  373.    if(lStyle & WS_HSCROLL && lStyle & WS_VSCROLL)
  374.       return (long)IDO_BOTH;
  375.    if(lStyle & WS_HSCROLL)
  376.       return (long)IDO_HSCROLL;
  377.    if(lStyle & WS_VSCROLL)
  378.       return (long)IDO_VSCROLL;
  379.  
  380.    return (long)IDO_NONE;
  381. }
  382.  
  383.  
  384. BOOL WINAPI idoGetRedraw(HWND hIDO)
  385. {
  386.    return TRUE;
  387. }
  388. void WINAPI idoSetRedraw(HWND hIDO, BOOL bVal)
  389. {
  390.    if(!IsWindow(hIDO))
  391.       return;
  392.  
  393.    SendMessage(hIDO, WM_SETREDRAW, bVal, 0L);
  394.    InvalidateRect(hIDO, NULL, TRUE);
  395.    UpdateWindow(hIDO);
  396. }
  397.  
  398. ///////////////////////////////////////////////////////////////////////
  399. ///////////////////////////////////////////////////////////////////////
  400. // METHODS
  401. ///////////////////////////////////////////////////////////////////////
  402.  
  403. void WINAPI idoCancelAction(HWND hIDO)
  404. {
  405.    if(!IsWindow(hIDO))
  406.       return;
  407.  
  408.    SendMessage(hIDO, IDOM_NOTIFYRESULT, 0, 1); // 1 always means cancel
  409. }
  410. void WINAPI idoAllowAction(HWND hIDO)
  411. {
  412.    if(!IsWindow(hIDO))
  413.       return;
  414.  
  415.    SendMessage(hIDO, IDOM_NOTIFYRESULT, 0, 2); // 2 always means allow action
  416. }
  417.  
  418.  
  419. BOOL WINAPI idoDragAddEntity(HWND hIDO, LPCSTR lpClassName)
  420. {
  421.    if(!IsWindow(hIDO))
  422.       return FALSE;
  423.  
  424.    return (BOOL)IDO_I(hIDO, IDOM_DRAGADDENTITY, 0, (LPARAM)(LPSTR)lpClassName);
  425. }
  426.  
  427. BOOL WINAPI idoAddEntityClass(HWND hIDO, LPSTR szClassName, LPSTR szBitmapName, LPENTITY lpEnt)
  428. {
  429.    IDO_NEWCLASS newclass;
  430.  
  431.  
  432.    if(!IsWindow(hIDO))
  433.       return FALSE;
  434.    if(!szClassName)
  435.       return FALSE;
  436.    if(!szBitmapName)
  437.       return FALSE;
  438.  
  439.    lstrcpy(newclass.szClassName, szClassName);
  440.    lstrcpy(newclass.szBitmapName, szBitmapName);
  441.  
  442.    if(IDOR_SUCCESS == IDO_I(hIDO, IDOM_ADDENTITYCLASS, 0, (LPARAM)(LPVOID)&newclass))
  443.    {
  444.       // if we successfully create a class, return an ENTITY structure to it.
  445.       if(lpEnt)
  446.          idoGetEntityClass(hIDO, szClassName, lpEnt);
  447.       return TRUE;
  448.    }
  449.  
  450.    return FALSE;
  451. }
  452. BOOL WINAPI idoDeleteEntityClass(HWND hIDO, LPSTR szClassName)
  453. {
  454.    if(!IsWindow(hIDO))
  455.       return FALSE;
  456.    if(!szClassName)
  457.       return FALSE;
  458.  
  459.    return (BOOL)IDO_I(hIDO, IDOM_DELETEENTITYCLASS, 0, (LPARAM)(LPVOID)szClassName);
  460. }
  461. BOOL WINAPI idoDoesEntityClassExist(HWND hIDO, LPSTR szClassName)
  462. {
  463.    if(!IsWindow(hIDO))
  464.       return FALSE;
  465.    if(!szClassName)
  466.       return FALSE;
  467.  
  468.    return (BOOL)IDO_I(hIDO, IDOM_DOESENTITYCLASSEXIST, 0, (LPARAM)(LPVOID)szClassName);
  469. }
  470. BOOL WINAPI idoRedefineFromEntityClass(HWND hIDO, LPSTR szClassName)
  471. {
  472.    if(!IsWindow(hIDO))
  473.       return FALSE;
  474.    if(!szClassName)
  475.       return FALSE;
  476.  
  477.    return (BOOL)IDO_I(hIDO, IDOM_REDEFINEFROMENTITYCLASS, 0, (LPARAM)(LPVOID)szClassName);
  478. }
  479.  
  480. BOOL WINAPI idoAddEntityFromClass(HWND hIDO, long lID, LPSTR szName,
  481.                                   LPSTR szClass, LPSTR szText,
  482.                                   int cX, int cY, int cWidth, int cHeight)
  483. {
  484.     ENTITY_CLASS_STRUCT eClass;
  485.  
  486.  
  487.    if(!IsWindow(hIDO))
  488.       return FALSE;
  489.    if(!szClass)
  490.       return FALSE;
  491.  
  492.     eClass.id = lID;
  493.     if(szName)
  494.        lstrcpy((LPSTR)eClass.name, (LPSTR)szName);
  495.     lstrcpy((LPSTR)eClass.classname, (LPSTR)szClass);
  496.     if(szText)
  497.        lstrcpy((LPSTR)eClass.text, (LPSTR)szText);
  498.     SetRect(&eClass.rect, cX, cY, cX+cWidth, cY+cHeight);
  499.  
  500.     return (BOOL)IDO_I(hIDO, IDOM_ADDENTITYFROMCLASS, 0, (LPARAM)(LPVOID)&eClass);
  501. }
  502. BOOL WINAPI idoDeleteEntity(HWND hIDO, LPENTITY lpEnt)
  503. {
  504.    if(!IsWindow(hIDO))
  505.       return FALSE;
  506.  
  507.    if(!lpEnt)
  508.       return FALSE;
  509.  
  510.    return (BOOL)IDO_I(hIDO, IDOM_DELETEENTITY, 0, (LPARAM)(LPVOID)lpEnt);
  511. }
  512. BOOL WINAPI idoEntityDelete(LPENTITY lpEnt)
  513. {
  514.    if(!lpEnt)
  515.       return FALSE;
  516.  
  517.    return (BOOL)IDO_I(lpEnt->hIDO, IDOM_DELETEENTITY, 0, (LPARAM)(LPVOID)lpEnt);
  518. }
  519. BOOL WINAPI idoDoesEntityExist(HWND hIDO, long lID, LPCSTR lpszName)
  520. {
  521.    ENTITY entity;
  522.  
  523.  
  524.    if(!IsWindow(hIDO))
  525.       return FALSE;
  526.  
  527.    entity.id = lID;
  528.    if(lpszName)
  529.       lstrcpy(entity.name, lpszName);
  530.    return (BOOL)IDO_I(hIDO, IDOM_DOESENTITYEXIST, 0, (LPARAM)(LPVOID)&entity);
  531. }
  532. long WINAPI idoGetNumberOfSelectedEntities(HWND hIDO)
  533. {
  534.    if(!IsWindow(hIDO))
  535.       return FALSE;
  536.  
  537.    return IDO_I(hIDO, IDOM_GETSELENTITYCOUNT, 0, 0L);
  538. }
  539. long WINAPI idoGetNumberOfEntities(HWND hIDO)
  540. {
  541.    if(!IsWindow(hIDO))
  542.       return FALSE;
  543.  
  544.    return IDO_I(hIDO, IDOM_GETNUMENTITIES, 0, 0L);
  545. }
  546. long WINAPI idoGetNumberOfRelations(HWND hIDO)
  547. {
  548.    if(!IsWindow(hIDO))
  549.       return FALSE;
  550.  
  551.    return IDO_I(hIDO, IDOM_GETNUMLINES, 0, 0L);
  552. }
  553.  
  554. BOOL WINAPI idoDragAddRelation(HWND hIDO, LPCSTR lpClassName)
  555. {
  556.    if(!IsWindow(hIDO))
  557.       return FALSE;
  558.    if(!lpClassName)
  559.       return FALSE;
  560.  
  561.    return (BOOL)IDO_I(hIDO, IDOM_DRAGADDRELATION, 0, (LPARAM)(LPSTR)lpClassName);
  562. }
  563.  
  564. BOOL WINAPI idoAddRelationClass(HWND hIDO, LPSTR szClassName, LPSTR szBitmapName, LPRELATION lpRel)
  565. {
  566.    IDO_NEWCLASS newclass;
  567.  
  568.  
  569.    if(!IsWindow(hIDO))
  570.       return FALSE;
  571.    if(!szClassName)
  572.       return FALSE;
  573.    if(!szBitmapName)
  574.       return FALSE;
  575.  
  576.    lstrcpy(newclass.szClassName, szClassName);
  577.    lstrcpy(newclass.szBitmapName, szBitmapName);
  578.  
  579.    if(IDOR_SUCCESS == IDO_I(hIDO, IDOM_ADDRELATIONCLASS, 0, (LPARAM)(LPVOID)&newclass))
  580.    {
  581.       // if we successfully create a class, return an ENTITY structure to it.
  582.       if(lpRel)
  583.          idoGetRelationClass(hIDO, szClassName, lpRel);
  584.       return TRUE;
  585.    }
  586.  
  587.    return FALSE;
  588. }
  589. BOOL WINAPI idoDeleteRelationClass(HWND hIDO, LPSTR szClassName)
  590. {
  591.    if(!IsWindow(hIDO))
  592.       return FALSE;
  593.    if(!szClassName)
  594.       return FALSE;
  595.  
  596.    return (BOOL)IDO_I(hIDO, IDOM_DELETERELATIONCLASS, 0, (LPARAM)(LPVOID)szClassName);
  597. }
  598. BOOL WINAPI idoDoesRelationClassExist(HWND hIDO, LPSTR szClassName)
  599. {
  600.    if(!IsWindow(hIDO))
  601.       return FALSE;
  602.    if(!szClassName)
  603.       return FALSE;
  604.  
  605.    return (BOOL)IDO_I(hIDO, IDOM_DOESRELATIONCLASSEXIST, 0, (LPARAM)(LPVOID)szClassName);
  606. }
  607. BOOL WINAPI idoRedefineFromRelationClass(HWND hIDO, LPSTR szClassName)
  608. {
  609.    if(!IsWindow(hIDO))
  610.       return FALSE;
  611.    if(!szClassName)
  612.       return FALSE;
  613.  
  614.    return (BOOL)IDO_I(hIDO, IDOM_REDEFINEFROMRELATIONCLASS, 0, (LPARAM)(LPVOID)szClassName);
  615. }
  616.  
  617. BOOL WINAPI idoAddRelationFromClass(HWND hIDO, long lID, LPSTR szName,
  618.                                     LPSTR szClass, LPSTR szText,
  619.                                     long Src_ID, LPSTR Src_Name, long Dst_ID, LPSTR Dst_Name)
  620. {
  621.     LINE_CLASS_STRUCT lClass;
  622.  
  623.  
  624.    if(!IsWindow(hIDO))
  625.       return FALSE;
  626.    if(!szClass)
  627.       return FALSE;
  628.  
  629.     lClass.id = lID;
  630.     if(szName)
  631.        lstrcpy((LPSTR)lClass.name, (LPSTR)szName);
  632.     lstrcpy((LPSTR)lClass.classname, (LPSTR)szClass);
  633.     if(szText)
  634.        lstrcpy((LPSTR)lClass.text, (LPSTR)szText);
  635.     lClass.Src_id = Src_ID;
  636.     if(Src_Name)
  637.        lstrcpy((LPSTR)lClass.Src_name, (LPSTR)Src_Name);
  638.     lClass.Dst_id = Dst_ID;
  639.     if(Dst_Name)
  640.        lstrcpy((LPSTR)lClass.Dst_name, (LPSTR)Dst_Name);
  641.  
  642.     return (BOOL)IDO_I(hIDO, IDOM_ADDRELATIONFROMCLASS, 0, (LPARAM)(LPVOID)&lClass);
  643. }
  644. BOOL WINAPI idoDeleteRelation(HWND hIDO, LPRELATION lpRel)
  645. {
  646.    if(!lpRel)
  647.       return FALSE;
  648.  
  649.    return (BOOL)IDO_I(hIDO, IDOM_DELETERELATION, 0, (LPARAM)(LPVOID)lpRel);
  650. }
  651. BOOL WINAPI idoRelationDelete(LPRELATION lpRel)
  652. {
  653.    if(!lpRel)
  654.       return FALSE;
  655.  
  656.    return (BOOL)IDO_I(lpRel->hIDO, IDOM_DELETERELATION, 0, (LPARAM)(LPVOID)lpRel);
  657. }
  658. BOOL WINAPI idoDoesRelationExist(HWND hIDO, long lID, LPCSTR lpszName)
  659. {
  660.    RELATION relation;
  661.  
  662.  
  663.    if(!IsWindow(hIDO))
  664.       return FALSE;
  665.  
  666.    relation.id = lID;
  667.    if(lpszName)
  668.       lstrcpy(relation.name, lpszName);
  669.  
  670.    return (BOOL)IDO_I(hIDO, IDOM_DOESRELATIONEXIST, 0, (LPARAM)(LPVOID)&relation);
  671. }
  672.  
  673.  
  674. BOOL WINAPI idoReadDiagram(HWND hIDO, LPSTR szFileName)
  675. {
  676.    if(!IsWindow(hIDO))
  677.       return FALSE;
  678.    if(!szFileName)
  679.       return FALSE;
  680.  
  681.    return (BOOL)IDO_I(hIDO, IDOM_READFILE, 0, (LPARAM)(LPSTR)szFileName);
  682. }
  683. BOOL WINAPI idoSaveDiagram(HWND hIDO, LPSTR szFileName)
  684. {
  685.    if(!IsWindow(hIDO))
  686.       return FALSE;
  687.  
  688.    return (BOOL)IDO_I(hIDO, IDOM_SAVEFILE, 0, (LPARAM)(LPSTR)szFileName);
  689. }
  690. void WINAPI idoResetDiagram(HWND hIDO)
  691. {
  692.    if(!IsWindow(hIDO))
  693.       return;
  694.  
  695.    IDO_I(hIDO, IDOM_RESET, 0, 0L);
  696. }
  697. BOOL WINAPI idoReadPalette(HWND hIDO, LPSTR szFileName)
  698. {
  699.    if(!IsWindow(hIDO))
  700.       return FALSE;
  701.    if(!szFileName)
  702.       return FALSE;
  703.  
  704.    return (BOOL)IDO_I(hIDO, IDOM_READPALETTE, 0, (LPARAM)(LPSTR)szFileName);
  705. }
  706. BOOL WINAPI idoSavePalette(HWND hIDO, LPSTR szFileName)
  707. {
  708.    if(!IsWindow(hIDO))
  709.       return FALSE;
  710.    if(!szFileName)
  711.       return FALSE;
  712.  
  713.    return (BOOL)IDO_I(hIDO, IDOM_SAVEPALETTE, 0, (LPARAM)(LPSTR)szFileName);
  714. }
  715. void WINAPI idoResetPalette(HWND hIDO)
  716. {
  717.    if(!IsWindow(hIDO))
  718.       return;
  719.  
  720.    IDO_I(hIDO, IDOM_RESETPALETTE, 0, 0L);
  721. }
  722.  
  723. long WINAPI idoGetVersion(HWND hIDO)
  724. {
  725.    if(!IsWindow(hIDO))
  726.       return -1;
  727.  
  728.    return IDO_I(hIDO, IDOM_GETVERSION, 0, 0L);
  729. }
  730.  
  731. LPCSTR WINAPI idoGetFileName(HWND hIDO)
  732. {
  733.    if(lpszText)
  734.       free(lpszText);
  735.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  736.  
  737.    if(!IsWindow(hIDO))
  738.       return NULL;
  739.  
  740.    IDO_I(hIDO, IDOM_GETFILENAME, MAX_TEMP_LEN, (LPARAM)(LPSTR)lpszText);
  741.  
  742.    return lpszText;
  743. }
  744.  
  745. void WINAPI idoSetFileName(HWND hIDO, LPCSTR lpFile)
  746. {
  747.    if(!IsWindow(hIDO))
  748.       return;
  749.    if(!lpFile)
  750.       return;
  751.  
  752.    IDO_I(hIDO, IDOM_SETFILENAME, 0, (LPARAM)(LPVOID)lpFile);
  753. }
  754.  
  755. LPCSTR WINAPI idoGetInetPath(HWND hIDO)
  756. {
  757.    if(lpszText)
  758.       free(lpszText);
  759.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  760.  
  761.    if(!IsWindow(hIDO))
  762.       return NULL;
  763.  
  764.    IDO_I(hIDO, IDOM_GETINETPATH, MAX_TEMP_LEN, (LPARAM)(LPSTR)lpszText);
  765.  
  766.    return lpszText;
  767. }
  768.  
  769. void WINAPI idoSetInetPath(HWND hIDO, LPCSTR lpPath)
  770. {
  771.    if(!IsWindow(hIDO))
  772.       return;
  773.    if(!lpPath)
  774.       return;
  775.  
  776.    IDO_I(hIDO, IDOM_SETINETPATH, 0, (LPARAM)(LPVOID)lpPath);
  777. }
  778.  
  779.  
  780. BOOL WINAPI idoReadJobsFile(HWND hIDO, LPSTR lpFile)
  781. {
  782.    if(!IsWindow(hIDO))
  783.       return FALSE;
  784.    if(!lpFile)
  785.       return FALSE;
  786.  
  787.    return (BOOL)IDO_I(hIDO, IDOM_READJOBSFILE, 0, (LPARAM)(LPVOID)lpFile);
  788. }
  789.  
  790. void WINAPI idoZoom(HWND hIDO, int cMode, long lAmount)
  791. {
  792.    if(!IsWindow(hIDO))
  793.       return;
  794.  
  795.    IDO_I(hIDO, IDOM_ZOOM, cMode, lAmount);
  796. }
  797.  
  798.  
  799. short WINAPI idoGetZoomValue(HWND hIDO)
  800. {
  801.    if(!IsWindow(hIDO))
  802.       return - 1;
  803.  
  804.    return(short)IDO_I(hIDO, IDOM_GETZOOMVALUE, 0, 0L);
  805. }
  806. void WINAPI idoSetZoomValue(HWND hIDO, short lValue)
  807. {
  808.    short zAmount;
  809.  
  810.    if(!IsWindow(hIDO))
  811.       return;
  812.  
  813.    zAmount = idoGetZoomValue(hIDO);
  814.    IDO_I(hIDO, IDOM_ZOOM, IDO_ZOOM_PERCENT, (LPARAM)(lValue - zAmount));
  815. }
  816.  
  817. void WINAPI idoCut(HWND hIDO)
  818. {
  819.    if(!IsWindow(hIDO))
  820.       return;
  821.  
  822.    IDO_I(hIDO, WM_CUT, 0, 0L);
  823. }
  824. void WINAPI idoCopy(HWND hIDO)
  825. {
  826.    if(!IsWindow(hIDO))
  827.       return;
  828.  
  829.    IDO_I(hIDO, WM_COPY, 0, 0L);
  830. }
  831. void WINAPI idoPaste(HWND hIDO)
  832. {
  833.    if(!IsWindow(hIDO))
  834.       return;
  835.  
  836.    IDO_I(hIDO, WM_PASTE, 0, 0L);
  837. }
  838.  
  839.  
  840. void WINAPI idoManageClasses(HWND hIDO)
  841. {
  842.    if(!IsWindow(hIDO))
  843.       return;
  844.  
  845.    IDO_I(hIDO, IDOM_MANAGECLASSES, 0, 0L);
  846. }
  847. void WINAPI idoManageRules(HWND hIDO)
  848. {
  849.    if(!IsWindow(hIDO))
  850.       return;
  851.  
  852.    IDO_I(hIDO, IDOM_MANAGERULES, 0, 0L);
  853. }
  854. void WINAPI idoPrintDiagram(HWND hIDO)
  855. {
  856.    if(!IsWindow(hIDO))
  857.       return;
  858.  
  859.    IDO_I(hIDO, IDOM_PRINT, 0, 0L);
  860. }
  861. void WINAPI idoPropertyPage(HWND hIDO, int cPage)
  862. {
  863.    if(!IsWindow(hIDO))
  864.       return;
  865.  
  866.    IDO_I(hIDO, IDOM_PROPERTYPAGEIDO, cPage, 0L);
  867. }
  868. void WINAPI idoEntityPropertyPage(LPENTITY lpEntity, int cPage)
  869. {
  870.    if(!lpEntity)
  871.       return;
  872.  
  873.    IDO_I(lpEntity->hIDO, IDOM_PROPERTYPAGEENTITY, cPage, (LPARAM)(LPVOID)lpEntity);
  874. }
  875. void WINAPI idoRelationPropertyPage(LPRELATION lpRel, int cPage)
  876. {
  877.    if(!lpRel)
  878.       return;
  879.    IDO_I(lpRel->hIDO, IDOM_PROPERTYPAGELINE, cPage, (LPARAM)(LPVOID)lpRel);
  880. }
  881.  
  882.  
  883. BOOL WINAPI idoIterateEntityFirst(HWND hIDO)
  884. {
  885.    if(!IsWindow(hIDO))
  886.       return FALSE;
  887.  
  888.    if(!(idoGetNumberOfEntities(hIDO)))
  889.       return FALSE;
  890.  
  891.   return (BOOL)IDO_I(hIDO, IDOM_ITERATEENTITYFIRST, 0, 0L);
  892. }
  893. BOOL WINAPI idoIterateEntityNext(HWND hIDO, LPENTITY lpEnt)
  894. {
  895.    if(!IsWindow(hIDO))
  896.       return FALSE;
  897.    if(!lpEnt)
  898.       return FALSE;
  899.  
  900.    if(IDO_I(hIDO, IDOM_ITERATEENTITYNEXT, 0, (LPARAM)(LPVOID)lpEnt))
  901.       return TRUE;
  902.  
  903.    return FALSE;
  904. }
  905. BOOL WINAPI idoIterateSelectedEntityFirst(HWND hIDO)
  906. {
  907.    if(!IsWindow(hIDO))
  908.       return FALSE;
  909.  
  910.    if(!(idoGetNumberOfSelectedEntities(hIDO)))
  911.       return FALSE;
  912.  
  913.   return (BOOL)IDO_I(hIDO, IDOM_ITERATESELENTITYFIRST, 0, 0L);
  914. }
  915. BOOL WINAPI idoIterateSelectedEntityNext(HWND hIDO, LPENTITY lpEnt)
  916. {
  917.    if(!IsWindow(hIDO))
  918.       return FALSE;
  919.    if(!lpEnt)
  920.       return FALSE;
  921.  
  922.    if(IDO_I(hIDO, IDOM_ITERATESELENTITYNEXT, 0, (LPARAM)(LPVOID)lpEnt))
  923.       return TRUE;
  924.  
  925.    return FALSE;
  926. }
  927.  
  928.  
  929. BOOL WINAPI idoIterateEntityClassFirst(HWND hIDO)
  930. {
  931.    if(!IsWindow(hIDO))
  932.       return FALSE;
  933.  
  934.   return (BOOL)IDO_I(hIDO, IDOM_ITERATEENTITYCLASSFIRST, 0, 0L);
  935. }
  936. BOOL WINAPI idoIterateEntityClassNext(HWND hIDO, LPSTR szName)
  937. {
  938.    if(!IsWindow(hIDO))
  939.       return FALSE;
  940.  
  941.    if(!szName)
  942.       return FALSE;
  943.  
  944.    if(IDO_I(hIDO, IDOM_ITERATEENTITYCLASSNEXT, 0, (LPARAM)(LPSTR)szName))
  945.       return TRUE;
  946.  
  947.    return FALSE;
  948. }
  949.  
  950.  
  951. BOOL WINAPI idoIterateRelationFirst(HWND hIDO)
  952. {
  953.    if(!IsWindow(hIDO))
  954.       return FALSE;
  955.  
  956.   return (BOOL)IDO_I(hIDO, IDOM_ITERATERELATIONFIRST, 0, 0L);
  957. }
  958. BOOL WINAPI idoIterateRelationNext(HWND hIDO, LPRELATION lpRel)
  959. {
  960.    if(!IsWindow(hIDO))
  961.       return FALSE;
  962.    if(!lpRel)
  963.       return FALSE;
  964.  
  965.    if(IDO_I(hIDO, IDOM_ITERATERELATIONNEXT, 0, (LPARAM)(LPVOID)lpRel))
  966.       return TRUE;
  967.  
  968.    return FALSE;
  969. }
  970. BOOL WINAPI idoIterateRelationClassFirst(HWND hIDO)
  971. {
  972.    if(!IsWindow(hIDO))
  973.       return FALSE;
  974.  
  975.   return (BOOL)IDO_I(hIDO, IDOM_ITERATERELATIONCLASSFIRST, 0, 0L);
  976. }
  977. BOOL WINAPI idoIterateRelationClassNext(HWND hIDO, LPSTR szName)
  978. {
  979.    if(!IsWindow(hIDO))
  980.       return FALSE;
  981.  
  982.    if(!szName)
  983.       return FALSE;
  984.  
  985.    if(IDO_I(hIDO, IDOM_ITERATERELATIONCLASSNEXT, 0, (LPARAM)(LPSTR)szName))
  986.       return TRUE;
  987.  
  988.    return FALSE;
  989. }
  990.  
  991. BOOL WINAPI idoIterateRuleFirst(HWND hIDO)
  992. {
  993.    if(!IsWindow(hIDO))
  994.       return FALSE;
  995.  
  996.   return (BOOL)IDO_I(hIDO, IDOM_ITERATERULEFIRST, 0, 0L);
  997. }
  998. BOOL WINAPI idoIterateRuleNext(HWND hIDO, LPIDO_RULE lpRule)
  999. {
  1000.    if(!IsWindow(hIDO))
  1001.       return FALSE;
  1002.  
  1003.    if(!lpRule)
  1004.       return FALSE;
  1005.  
  1006.    if(IDO_I(hIDO, IDOM_ITERATERULENEXT, 0, (LPARAM)(LPVOID)lpRule))
  1007.       return TRUE;
  1008.  
  1009.    return FALSE;
  1010. }
  1011. BOOL WINAPI idoAddRule(HWND hIDO, LPSTR E1Class, LPSTR RClass, LPSTR E2Class)
  1012. {
  1013.    IDO_RULE rule;
  1014.  
  1015.  
  1016.    if(!IsWindow(hIDO))
  1017.       return FALSE;
  1018.    if(!E1Class)
  1019.       return FALSE;
  1020.    if(!RClass)
  1021.       return FALSE;
  1022.    if(!E2Class)
  1023.       return FALSE;
  1024.  
  1025.    lstrcpy(rule.E1, E1Class);
  1026.    lstrcpy(rule.R1, RClass);
  1027.    lstrcpy(rule.E2, E2Class);
  1028.    if(IDO_I(hIDO, IDOM_ADDRULE, 0, (LPARAM)(LPVOID)&rule))
  1029.       return TRUE;
  1030.  
  1031.    return FALSE;
  1032. }
  1033. BOOL WINAPI idoDeleteRule(HWND hIDO, LPIDO_RULE lpRule)
  1034. {
  1035.    if(!IsWindow(hIDO))
  1036.       return FALSE;
  1037.  
  1038.    if(!lpRule)
  1039.       return FALSE;
  1040.  
  1041.    if(IDO_I(hIDO, IDOM_DELETERULE, 0, (LPARAM)(LPVOID)lpRule))
  1042.       return TRUE;
  1043.  
  1044.    return FALSE;
  1045. }
  1046. BOOL WINAPI idoDoesRuleExist(HWND hIDO, LPSTR E1Class, LPSTR RClass, LPSTR E2Class)
  1047. {
  1048.    IDO_RULE rule;
  1049.  
  1050.  
  1051.    if(!IsWindow(hIDO))
  1052.       return FALSE;
  1053.    if(!E1Class)
  1054.       return FALSE;
  1055.    if(!RClass)
  1056.       return FALSE;
  1057.    if(!E2Class)
  1058.       return FALSE;
  1059.  
  1060.    lstrcpy(rule.E1, E1Class);
  1061.    lstrcpy(rule.R1, RClass);
  1062.    lstrcpy(rule.E2, E2Class);
  1063.    if(IDO_I(hIDO, IDOM_DOESRULEEXIST, 0, (LPARAM)(LPVOID)&rule))
  1064.       return TRUE;
  1065.  
  1066.    return FALSE;
  1067. }
  1068.  
  1069.  
  1070. BOOL WINAPI idoGetPopupMenu(HWND hIDO, long lFlag)
  1071. {
  1072.    if(!IsWindow(hIDO))
  1073.       return FALSE;
  1074.  
  1075.    return (BOOL)IDO_I(hIDO, IDOM_GETUSERMENU, 0, (LPARAM)lFlag);
  1076. }
  1077. BOOL WINAPI idoSetPopupMenu(HWND hIDO, long lFlag, BOOL bEnable)
  1078. {
  1079.    if(!IsWindow(hIDO))
  1080.       return FALSE;
  1081.  
  1082.    if(IDO_I(hIDO, IDOM_SETUSERMENU, bEnable, (LPARAM)lFlag))
  1083.       return TRUE;
  1084.  
  1085.    return FALSE;
  1086. }
  1087.  
  1088. BOOL WINAPI idoGetNotifyEntity(HWND hIDO, LPENTITY lpEnt)
  1089. {
  1090.    long lID;
  1091.    char szName[100+1];
  1092.  
  1093.    if(!lpEnt)
  1094.       return FALSE;
  1095.  
  1096.    lID = idoGetNotifyID(hIDO);
  1097.    lstrcpy(szName, idoGetNotifyName(hIDO));
  1098.  
  1099.    return idoGetEntity(hIDO, lID, szName, lpEnt);
  1100. }
  1101. BOOL WINAPI idoGetNotifyRelation(HWND hIDO, LPRELATION lpRel)
  1102. {
  1103.    long lID;
  1104.    char szName[100+1];
  1105.  
  1106.    if(!lpRel)
  1107.       return FALSE;
  1108.  
  1109.    lID = idoGetNotifyID(hIDO);
  1110.    lstrcpy(szName, idoGetNotifyName(hIDO));
  1111.  
  1112.    return idoGetRelation(hIDO, lID, szName, lpRel);
  1113. }
  1114.  
  1115. long WINAPI idoGetNotifyID(HWND hIDO)
  1116. {
  1117.    long lVal;
  1118.  
  1119.    IDO_I(hIDO, IDOM_GETCURRENTID, 0, (LPARAM)(LPVOID)&lVal);
  1120.    return lVal;
  1121. }
  1122. LPCSTR WINAPI idoGetNotifyName(HWND hIDO)
  1123. {
  1124.    if(lpszText)
  1125.       free(lpszText);
  1126.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  1127.  
  1128.    IDO_I(hIDO, IDOM_GETCURRENTNAME, 0, (LPARAM)(LPSTR)lpszText);
  1129.    return (LPCSTR)lpszText;
  1130. }
  1131.  
  1132. ///////////////////////////////////////////////////////////////////////
  1133. ///////////////////////////////////////////////////////////////////////
  1134. // PROPERTIES & METHODS FOR OBJECTS
  1135. ///////////////////////////////////////////////////////////////////////
  1136.  
  1137. BOOL WINAPI idoGetEntityClass(HWND hIDO, LPSTR szClassName, LPENTITY lpEntity)
  1138. {
  1139.    LPENTITY lpEnt = NULL;
  1140.  
  1141.  
  1142.    if(!IsWindow(hIDO))
  1143.       return FALSE;
  1144.    if(!szClassName)
  1145.       return FALSE;
  1146.    if(!lpEntity)
  1147.       return FALSE;
  1148.  
  1149.    lpEnt = (LPENTITY)IDO_I(hIDO, IDOM_SELECTOBJECT, BY_CLASSNAME | OBJ_ENTITY, (LPARAM)(LPSTR)szClassName);
  1150.  
  1151.    if(lpEnt == NULL || lpEnt < 0)
  1152.       return FALSE;
  1153.  
  1154.    memcpy(lpEntity, lpEnt, sizeof(ENTITY));
  1155.  
  1156.    return TRUE;
  1157. }
  1158.  
  1159. BOOL WINAPI idoGetEntity(HWND hIDO, long lID, LPSTR szName, LPENTITY lpEntity)
  1160. {
  1161.    LPENTITY lpEnt = NULL;
  1162.  
  1163.  
  1164.    if(!IsWindow(hIDO))
  1165.       return FALSE;
  1166.  
  1167.    if(!lID && !szName)
  1168.       return FALSE;
  1169.    if(!lpEntity)
  1170.       return FALSE;
  1171.  
  1172.    if(lID == -1 && szName != NULL)
  1173.       lpEnt = (LPENTITY)IDO_I(hIDO, IDOM_SELECTOBJECT, BY_CLASSNAME | OBJ_ENTITY, (LPARAM)(LPSTR)szName);
  1174.    else
  1175.       if(lID)
  1176.          lpEnt = (LPENTITY)IDO_I(hIDO, IDOM_SELECTOBJECT, BY_ID | OBJ_ENTITY, lID);
  1177.       else
  1178.          lpEnt = (LPENTITY)IDO_I(hIDO, IDOM_SELECTOBJECT, BY_NAME | OBJ_ENTITY, (LPARAM)(LPSTR)szName);
  1179.  
  1180.    if(lpEnt == NULL || lpEnt < 0)
  1181.       return FALSE;
  1182.  
  1183.    memcpy(lpEntity, lpEnt, sizeof(ENTITY));
  1184.  
  1185.    return TRUE;
  1186. }
  1187.  
  1188. BOOL WINAPI idoGetRelationClass(HWND hIDO, LPSTR szClassName, LPRELATION lpRelation)
  1189. {
  1190.    LPRELATION lpRel = NULL;
  1191.  
  1192.  
  1193.    if(!IsWindow(hIDO))
  1194.       return FALSE;
  1195.    if(!szClassName)
  1196.       return FALSE;
  1197.    if(!lpRelation)
  1198.       return FALSE;
  1199.  
  1200.    lpRel = (LPRELATION)IDO_I(hIDO, IDOM_SELECTOBJECT, BY_CLASSNAME | OBJ_LINE, (LPARAM)(LPSTR)szClassName);
  1201.  
  1202.    if(lpRel == NULL || lpRel < 0)
  1203.       return FALSE;
  1204.  
  1205.    memcpy(lpRelation, lpRel, sizeof(RELATION));
  1206.  
  1207.    return TRUE;
  1208. }
  1209.  
  1210. BOOL WINAPI idoGetRelation(HWND hIDO, long lID, LPSTR szName, LPRELATION lpRelation)
  1211. {
  1212.    LPRELATION lpRel = NULL;
  1213.  
  1214.  
  1215.    if(!IsWindow(hIDO))
  1216.       return FALSE;
  1217.  
  1218.    if(!lID && !szName)
  1219.       return FALSE;
  1220.    if(!lpRelation)
  1221.       return FALSE;
  1222.  
  1223.    if(lID == -1 && szName != NULL)
  1224.       lpRel = (LPRELATION)IDO_I(hIDO, IDOM_SELECTOBJECT, BY_CLASSNAME | OBJ_LINE, (LPARAM)(LPSTR)szName);
  1225.    else
  1226.       if(lID)
  1227.          lpRel = (LPRELATION)IDO_I(hIDO, IDOM_SELECTOBJECT, BY_ID | OBJ_LINE, lID);
  1228.       else
  1229.          lpRel = (LPRELATION)IDO_I(hIDO, IDOM_SELECTOBJECT, BY_NAME | OBJ_LINE, (LPARAM)(LPSTR)szName);
  1230.  
  1231.    if(lpRel == NULL || lpRel < 0)
  1232.       return FALSE;
  1233.  
  1234.    memcpy(lpRelation, lpRel, sizeof(RELATION));
  1235.  
  1236.    return TRUE;
  1237. }
  1238.  
  1239.  
  1240.  
  1241. BOOL WINAPI idoEntityRepaint(LPENTITY lpEnt)
  1242. {
  1243.    if(!lpEnt)
  1244.       return FALSE;
  1245.  
  1246.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1247.       return (BOOL)IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_OBJECT_REPAINT, 0L);
  1248. }
  1249. BOOL WINAPI idoRelationRepaint(LPRELATION lpRel)
  1250. {
  1251.    if(!lpRel)
  1252.       return FALSE;
  1253.  
  1254.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1255.       return (BOOL)IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LOBJECT_REPAINT, 0L);
  1256. }
  1257.  
  1258.  
  1259. BOOL WINAPI idoEntityBringIntoView(LPENTITY lpEnt)
  1260. {
  1261.    if(!lpEnt)
  1262.       return FALSE;
  1263.  
  1264.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1265.       return (BOOL)IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_BRINGINTOVIEW, 0L);
  1266. }
  1267. BOOL WINAPI idoRelationBringIntoView(LPRELATION lpRel)
  1268. {
  1269.    if(!lpRel)
  1270.       return FALSE;
  1271.  
  1272.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1273.       return (BOOL)IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LBRINGINTOVIEW, 0L);
  1274. }
  1275.  
  1276.  
  1277. void WINAPI idoEntitySetBackColor(LPENTITY lpEnt, COLORREF lColor)
  1278. {
  1279.    if(!lpEnt)
  1280.       return;
  1281.  
  1282.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1283.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_BKCOLOR, (LPARAM)lColor);
  1284. }
  1285. COLORREF WINAPI idoEntityGetBackColor(LPENTITY lpEnt)
  1286. {
  1287.    COLORREF color = 0L;
  1288.  
  1289.    if(!lpEnt)
  1290.       return 0;
  1291.  
  1292.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1293.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_BKCOLOR, (LPARAM)(LPVOID)&color);
  1294.    return color;
  1295. }
  1296. void WINAPI idoRelationSetBackColor(LPRELATION lpRel, COLORREF lColor)
  1297. {
  1298.    if(!lpRel)
  1299.       return;
  1300.  
  1301.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1302.       IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LBKCOLOR, (LPARAM)lColor);
  1303. }
  1304. COLORREF WINAPI idoRelationGetBackColor(LPRELATION lpRel)
  1305. {
  1306.    COLORREF color = 0L;
  1307.  
  1308.    if(!lpRel)
  1309.       return 0;
  1310.  
  1311.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1312.       IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LBKCOLOR, (LPARAM)(LPVOID)&color);
  1313.    return color;
  1314. }
  1315.  
  1316.  
  1317. void WINAPI idoEntitySetTextColor(LPENTITY lpEnt, COLORREF lColor)
  1318. {
  1319.    if(!lpEnt)
  1320.       return;
  1321.  
  1322.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1323.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_TEXTCOLOR, (LPARAM)lColor);
  1324. }
  1325. COLORREF WINAPI idoEntityGetTextColor(LPENTITY lpEnt)
  1326. {
  1327.    COLORREF color = 0L;
  1328.  
  1329.    if(!lpEnt)
  1330.       return 0;
  1331.  
  1332.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1333.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_TEXTCOLOR, (LPARAM)(LPVOID)&color);
  1334.    return color;
  1335. }
  1336. void WINAPI idoRelationSetTextColor(LPRELATION lpRel, COLORREF lColor)
  1337. {
  1338.    if(!lpRel)
  1339.       return;
  1340.  
  1341.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1342.       IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LTEXTCOLOR, (LPARAM)lColor);
  1343. }
  1344. COLORREF WINAPI idoRelationGetTextColor(LPRELATION lpRel)
  1345. {
  1346.    COLORREF color = 0L;
  1347.  
  1348.    if(!lpRel)
  1349.       return 0;
  1350.  
  1351.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1352.       IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LTEXTCOLOR, (LPARAM)(LPVOID)&color);
  1353.    return color;
  1354. }
  1355.  
  1356.  
  1357. void WINAPI idoEntitySetText(LPENTITY lpEnt, LPCSTR szText)
  1358. {
  1359.    if(!lpEnt)
  1360.       return;
  1361.    if(!szText)
  1362.       return;
  1363.  
  1364.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1365.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_TEXT, (LPARAM)(LPCSTR)szText);
  1366. }
  1367. LPCSTR WINAPI idoEntityGetText(LPENTITY lpEnt)
  1368. {
  1369.    if(lpszText)
  1370.       free(lpszText);
  1371.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  1372.  
  1373.    if(!lpEnt)
  1374.       return NULL;
  1375.  
  1376.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1377.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_TEXT, (LPARAM)(LPSTR)lpszText);
  1378.    return (LPCSTR)lpszText;
  1379. }
  1380. void WINAPI idoRelationSetText(LPRELATION lpRel, LPCSTR szText)
  1381. {
  1382.    if(!lpRel)
  1383.       return;
  1384.    if(!szText)
  1385.       return;
  1386.  
  1387.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1388.       IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LTEXT, (LPARAM)(LPCSTR)szText);
  1389. }
  1390. LPCSTR WINAPI idoRelationGetText(LPRELATION lpRel)
  1391. {
  1392.    if(lpszText)
  1393.       free(lpszText);
  1394.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  1395.  
  1396.    if(!lpRel)
  1397.       return NULL;
  1398.  
  1399.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1400.       IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LTEXT, (LPARAM)(LPSTR)lpszText);
  1401.    return (LPCSTR)lpszText;
  1402. }
  1403.  
  1404.  
  1405. void WINAPI idoEntitySetUserData(LPENTITY lpEnt, LPVOID lpData)
  1406. {
  1407.    if(!lpEnt)
  1408.       return;
  1409.  
  1410.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1411.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_USERDATA, (LPARAM)lpData);
  1412. }
  1413. LPVOID WINAPI idoEntityGetUserData(LPENTITY lpEnt)
  1414. {
  1415.    LPVOID lpData = 0L;
  1416.  
  1417.    if(!lpEnt)
  1418.       return NULL;
  1419.  
  1420.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1421.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_USERDATA, (LPARAM)(LPVOID)&lpData);
  1422.    return lpData;
  1423. }
  1424. void WINAPI idoRelationSetUserData(LPRELATION lpRel, LPVOID lpData)
  1425. {
  1426.    if(!lpRel)
  1427.       return;
  1428.  
  1429.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1430.       IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LUSERDATA, (LPARAM)lpData);
  1431. }
  1432. LPVOID WINAPI idoRelationGetUserData(LPRELATION lpRel)
  1433. {
  1434.    LPVOID lpData = 0L;
  1435.  
  1436.    if(!lpRel)
  1437.       return NULL;
  1438.  
  1439.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1440.       IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LUSERDATA, (LPARAM)(LPVOID)&lpData);
  1441.    return lpData;
  1442. }
  1443.  
  1444.  
  1445. void WINAPI idoEntitySetFont(LPENTITY lpEnt, LPIDO_FONT lpFont)
  1446. {
  1447.    if(!lpEnt || !lpFont)
  1448.       return;
  1449.  
  1450.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1451.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_FONT, (LPARAM)lpFont);
  1452. }
  1453. LPIDO_FONT WINAPI idoEntityGetFont(LPENTITY lpEnt)
  1454. {
  1455.    LPVOID lpData = 0L;
  1456.  
  1457.    if(!lpEnt)
  1458.       return NULL;
  1459.  
  1460.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1461.    {
  1462.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_FONT, (LPARAM)(LPVOID)&idoFont);
  1463.       return &idoFont;
  1464.    }
  1465.    return NULL;
  1466. }
  1467. void WINAPI idoRelationSetFont(LPRELATION lpRel, LPIDO_FONT lpFont)
  1468. {
  1469.    if(!lpRel || !lpFont)
  1470.       return;
  1471.  
  1472.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1473.       IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LFONT, (LPARAM)lpFont);
  1474. }
  1475. LPIDO_FONT WINAPI idoRelationGetFont(LPRELATION lpRel)
  1476. {
  1477.    if(!lpRel)
  1478.       return NULL;
  1479.  
  1480.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  1481.    {
  1482.       IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LFONT, (LPARAM)(LPVOID)&idoFont);
  1483.       return &idoFont;
  1484.    }
  1485.    return NULL;
  1486. }
  1487.  
  1488.  
  1489. long WINAPI idoRelationUserID(LPRELATION lpRel)
  1490. {
  1491.    if(!lpRel)
  1492.       return 0;
  1493.  
  1494.    return lpRel->id;
  1495. }
  1496. long WINAPI idoEntityUserID(LPENTITY lpEnt)
  1497. {
  1498.    if(!lpEnt)
  1499.       return 0;
  1500.  
  1501.    return lpEnt->id;
  1502. }
  1503. LPCSTR WINAPI idoRelationUserName(LPRELATION lpRel)
  1504. {
  1505.    if(lpszText)
  1506.       free(lpszText);
  1507.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  1508.  
  1509.    if(!lpRel)
  1510.       return 0;
  1511.  
  1512.    lstrcpy(lpszText, lpRel->name);
  1513.    return lpszText;
  1514. }
  1515. LPCSTR WINAPI idoEntityUserName(LPENTITY lpEnt)
  1516. {
  1517.    if(lpszText)
  1518.       free(lpszText);
  1519.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  1520.  
  1521.    if(!lpEnt)
  1522.       return 0;
  1523.  
  1524.    lstrcpy(lpszText, lpEnt->name);
  1525.    return lpszText;
  1526. }
  1527. LPCSTR WINAPI idoRelationClassName(LPRELATION lpRel)
  1528. {
  1529.    if(lpszText)
  1530.       free(lpszText);
  1531.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  1532.  
  1533.    if(!lpRel)
  1534.       return 0;
  1535.  
  1536.    lstrcpy(lpszText, lpRel->classname);
  1537.    return lpszText;
  1538. }
  1539. LPCSTR WINAPI idoEntityClassName(LPENTITY lpEnt)
  1540. {
  1541.    if(lpszText)
  1542.       free(lpszText);
  1543.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  1544.  
  1545.    if(!lpEnt)
  1546.       return 0;
  1547.  
  1548.    lstrcpy(lpszText, lpEnt->classname);
  1549.    return lpszText;
  1550. }
  1551.  
  1552. /////////////////////////////////////////
  1553. /////////////////////////////////////////
  1554. /////////////////////////////////////////
  1555.  
  1556.  
  1557. void WINAPI idoEntitySetInetHost(LPENTITY lpEnt, INET_HOST host)
  1558. {
  1559.    if(!lpEnt)
  1560.       return;
  1561.  
  1562.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1563.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_INETHOST, (LPARAM)(long)host);
  1564. }
  1565. INET_HOST WINAPI idoEntityGetInetHost(LPENTITY lpEnt)
  1566. {
  1567.    INET_HOST Host = (INET_HOST)-1;
  1568.  
  1569.    if(!lpEnt)
  1570.       return -1;
  1571.  
  1572.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1573.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_INETHOST, (LPARAM)(LPVOID)(INET_HOST *)&Host);
  1574.    return Host;
  1575. }
  1576. void WINAPI idoEntitySetInetUrl(LPENTITY lpEnt, LPCSTR szUrl)
  1577. {
  1578.    if(!lpEnt)
  1579.       return;
  1580.    if(!szUrl)
  1581.       return;
  1582.  
  1583.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1584.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_INETURL, (LPARAM)(LPCSTR)szUrl);
  1585. }
  1586. LPCSTR WINAPI idoEntityGetInetUrl(LPENTITY lpEnt)
  1587. {
  1588.    if(lpszText)
  1589.       free(lpszText);
  1590.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  1591.  
  1592.    if(!lpEnt)
  1593.       return NULL;
  1594.  
  1595.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1596.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_INETURL, (LPARAM)(LPSTR)lpszText);
  1597.    return (LPCSTR)lpszText;
  1598.  
  1599. }
  1600.  
  1601.  
  1602. void WINAPI idoEntitySetShape(LPENTITY lpEnt, ENTITYSHAPE shape)
  1603. {
  1604.    if(!lpEnt)
  1605.       return;
  1606.  
  1607.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1608.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_SHAPE, (LPARAM)(long)shape);
  1609. }
  1610. ENTITYSHAPE WINAPI idoEntityGetShape(LPENTITY lpEnt)
  1611. {
  1612.    ENTITYSHAPE eShape = (ENTITYSHAPE)-1;
  1613.  
  1614.    if(!lpEnt)
  1615.       return -1;
  1616.  
  1617.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1618.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_SHAPE, (LPARAM)(LPVOID)(ENTITYSHAPE *)&eShape);
  1619.    return eShape;
  1620. }
  1621.  
  1622.  
  1623. void WINAPI idoEntitySetBorder(LPENTITY lpEnt, BOOL bBorder)
  1624. {
  1625.    if(!lpEnt)
  1626.       return;
  1627.  
  1628.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1629.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_BORDER, (LPARAM)bBorder);
  1630. }
  1631. BOOL WINAPI idoEntityGetBorder(LPENTITY lpEnt)
  1632. {
  1633.    BOOL border = (BOOL)-1;
  1634.  
  1635.    if(!lpEnt)
  1636.       return -1;
  1637.  
  1638.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1639.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_BORDER, (LPARAM)(LPVOID)(BOOL *)&border);
  1640.    return border;
  1641. }
  1642.  
  1643.  
  1644. void WINAPI idoEntitySetFrame(LPENTITY lpEnt, THREE_D_STYLE style)
  1645. {
  1646.    if(!lpEnt)
  1647.       return;
  1648.  
  1649.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1650.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_3D, (LPARAM)(long)style);
  1651. }
  1652. THREE_D_STYLE WINAPI idoEntityGetFrame(LPENTITY lpEnt)
  1653. {
  1654.    THREE_D_STYLE td = (THREE_D_STYLE)-1;
  1655.  
  1656.    if(!lpEnt)
  1657.       return -1;
  1658.  
  1659.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1660.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_3D, (LPARAM)(LPVOID)(THREE_D_STYLE *)&td);
  1661.    return td;
  1662. }
  1663.  
  1664.  
  1665. void WINAPI idoEntitySetContainer(LPENTITY lpEnt, long bVal)
  1666. {
  1667.    if(!lpEnt)
  1668.       return;
  1669.  
  1670.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1671.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_CONTAINER, (LPARAM)bVal);
  1672. }
  1673. long WINAPI idoEntityGetContainer(LPENTITY lpEnt)
  1674. {
  1675.    long bVal = -1;
  1676.  
  1677.    if(!lpEnt)
  1678.       return - 1;
  1679.  
  1680.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1681.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_CONTAINER, (LPARAM)(LPVOID)&bVal);
  1682.    return bVal;
  1683. }
  1684.  
  1685.  
  1686. void WINAPI idoEntitySetGraphic(LPENTITY lpEnt, LPCSTR szGraphic)
  1687. {
  1688.    if(!lpEnt)
  1689.       return;
  1690.    if(!szGraphic)
  1691.       return;
  1692.  
  1693.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1694.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_GRAPHIC, (LPARAM)(LPCSTR)szGraphic);
  1695. }
  1696. LPCSTR WINAPI idoEntityGetGraphic(LPENTITY lpEnt)
  1697. {
  1698.    if(lpszText)
  1699.       free(lpszText);
  1700.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  1701.  
  1702.    if(!lpEnt)
  1703.       return NULL;
  1704.  
  1705.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1706.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_GRAPHIC, (LPARAM)(LPSTR)lpszText);
  1707.    return (LPCSTR)lpszText;
  1708. }
  1709.  
  1710. void WINAPI idoEntitySetTextOrientation(LPENTITY lpEnt, TEXTPOSSTYLE Style)
  1711. {
  1712.    if(!lpEnt)
  1713.       return;
  1714.  
  1715.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1716.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_TEXTORIENTATION, (LPARAM)(long)Style);
  1717. }
  1718. TEXTPOSSTYLE WINAPI idoEntityGetTextOrientation(LPENTITY lpEnt)
  1719. {
  1720.    TEXTPOSSTYLE Style = -1;
  1721.  
  1722.    if(!lpEnt)
  1723.       return -1;
  1724.  
  1725.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1726.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_TEXTORIENTATION, (LPARAM)(LPVOID)(TEXTPOSSTYLE *)&Style);
  1727.    return (TEXTPOSSTYLE)Style;
  1728. }
  1729.  
  1730.  
  1731. int  WINAPI idoEntityGetCoordX(LPENTITY lpEnt)
  1732. {
  1733.    if(!lpEnt)
  1734.       return -1;
  1735.  
  1736.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1737.       return (int)IDO_I(lpEnt->hIDO, IDOM_GETENTITYCOORDX, 0, (LPARAM)(LPVOID)lpEnt);
  1738. }
  1739. void WINAPI idoEntitySetCoordX(LPENTITY lpEnt, int cCoord)
  1740. {
  1741.    if(!lpEnt)
  1742.       return;
  1743.  
  1744.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1745.       IDO_I(lpEnt->hIDO, IDOM_SETENTITYCOORDX, cCoord, (LPARAM)(LPVOID)lpEnt);
  1746. }
  1747. int  WINAPI idoEntityGetCoordY(LPENTITY lpEnt)
  1748. {
  1749.    if(!lpEnt)
  1750.       return -1;
  1751.  
  1752.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1753.       return (int)IDO_I(lpEnt->hIDO, IDOM_GETENTITYCOORDY, 0, (LPARAM)(LPVOID)lpEnt);
  1754. }
  1755. void WINAPI idoEntitySetCoordY(LPENTITY lpEnt, int cCoord)
  1756. {
  1757.    if(!lpEnt)
  1758.       return;
  1759.  
  1760.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1761.       IDO_I(lpEnt->hIDO, IDOM_SETENTITYCOORDY, cCoord, (LPARAM)(LPVOID)lpEnt);
  1762. }
  1763.  
  1764.  
  1765. long WINAPI idoEntityGetRelationInCount(LPENTITY lpEnt)
  1766. {
  1767.    long count = -1;
  1768.  
  1769.  
  1770.    if(!lpEnt)
  1771.       return -1;
  1772.  
  1773.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1774.       if(IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_GETNUMHOMELINES, (LPARAM)(LPVOID)&count))
  1775.          return count;
  1776.  
  1777.    return -1;
  1778. }
  1779. BOOL WINAPI idoEntityIterateRelationInFirst(LPENTITY lpEnt)
  1780. {
  1781.    if(!lpEnt)
  1782.       return 0;
  1783.  
  1784.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1785.       return (BOOL)IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_ITERATEFIRSTHOMELINE, 0L);
  1786. }
  1787. BOOL WINAPI idoEntityIterateRelationInNext(LPENTITY lpEnt, LPRELATION lpRel)
  1788. {
  1789.    if(!lpEnt || !lpRel)
  1790.       return 0;
  1791.  
  1792.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1793.       return (BOOL)IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_ITERATENEXTHOMELINE, (LPARAM)(LPVOID)lpRel);
  1794. }
  1795.  
  1796. long WINAPI idoEntityGetRelationOutCount(LPENTITY lpEnt)
  1797. {
  1798.    long count = -1;
  1799.  
  1800.  
  1801.    if(!lpEnt)
  1802.       return -1;
  1803.  
  1804.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1805.       if(IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_GETNUMAWAYLINES, (LPARAM)(LPVOID)&count))
  1806.          return count;
  1807.  
  1808.    return -1;
  1809. }
  1810. BOOL WINAPI idoEntityIterateRelationOutFirst(LPENTITY lpEnt)
  1811. {
  1812.    if(!lpEnt)
  1813.       return 0;
  1814.  
  1815.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1816.       return (BOOL)IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_ITERATEFIRSTAWAYLINE, 0L);
  1817. }
  1818. BOOL WINAPI idoEntityIterateRelationOutNext(LPENTITY lpEnt, LPRELATION lpRel)
  1819. {
  1820.    if(!lpEnt || !lpRel)
  1821.       return 0;
  1822.  
  1823.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1824.       return (BOOL)IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_ITERATENEXTAWAYLINE, (LPARAM)(LPVOID)lpRel);
  1825. }
  1826.  
  1827. BOOL WINAPI idoEntityIterateContainedEntityFirst(LPENTITY lpEnt)
  1828. {
  1829.    if(!lpEnt)
  1830.       return 0;
  1831.  
  1832.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1833.       return (BOOL)IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_ITERATEFIRSTCONTAINED, 0L);
  1834. }
  1835. BOOL WINAPI idoEntityIterateContainedEntityNext(LPENTITY lpEnt, LPENTITY lpOut)
  1836. {
  1837.    if(!lpEnt || !lpOut)
  1838.       return 0;
  1839.  
  1840.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1841.       return (BOOL)IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_ITERATENEXTCONTAINED, (LPARAM)(LPVOID)lpOut);
  1842. }
  1843. long WINAPI idoEntityGetContainedEntityCount(LPENTITY lpEnt)
  1844. {
  1845.    if(!lpEnt)
  1846.       return 0;
  1847.  
  1848.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1849.       return (long)IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_CONTAINEDCOUNT, 0L);
  1850. }
  1851.  
  1852.  
  1853. BOOL WINAPI idoEntityAddEntityToContainer(LPENTITY lpContainer, LPENTITY lpEntity)
  1854. {
  1855.    if(!lpEntity || !lpContainer)
  1856.       return 0;
  1857.  
  1858.    if(idoGetEntity(lpContainer->hIDO, lpContainer->id, (LPSTR)lpContainer->name, lpContainer))
  1859.       return (BOOL)IDO_I(lpContainer->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_ADDTOCONTAINER, (LPARAM)(LPVOID)lpEntity);
  1860. }
  1861. BOOL WINAPI idoEntityRemoveEntityFromContainer(LPENTITY lpContainer, LPENTITY lpEntity)
  1862. {
  1863.    if(!lpEntity || !lpContainer)
  1864.       return 0;
  1865.  
  1866.    if(idoGetEntity(lpContainer->hIDO, lpContainer->id, (LPSTR)lpContainer->name, lpContainer))
  1867.       return (BOOL)IDO_I(lpContainer->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_REMOVEFROMCONTAINER, (LPARAM)(LPVOID)lpEntity);
  1868. }
  1869.  
  1870.  
  1871. BOOL WINAPI idoEntityGetSelect(LPENTITY lpEnt)
  1872. {
  1873.    if(!lpEnt)
  1874.       return FALSE;
  1875.  
  1876.    return (BOOL)IDO_I(lpEnt->hIDO, IDOM_GETSELECTENTITY, 0, (LPARAM)(LPVOID)lpEnt);
  1877. }
  1878. void WINAPI idoEntitySetSelect(LPENTITY lpEnt, BOOL bSelect)
  1879. {
  1880.    if(!lpEnt)
  1881.       return;
  1882.  
  1883.    IDO_I(lpEnt->hIDO, IDOM_SETSELECTENTITY, bSelect, (LPARAM)(LPVOID)lpEnt);
  1884. }
  1885.  
  1886.  
  1887. int WINAPI idoEntityGetTop(LPENTITY lpEnt)
  1888. {
  1889.    RECT rect;
  1890.  
  1891.  
  1892.    if(!lpEnt)
  1893.       return 0;
  1894.  
  1895.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1896.       if(IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect))
  1897.          return rect.top;
  1898. }
  1899. void WINAPI idoEntitySetTop(LPENTITY lpEnt, int cVal)
  1900. {
  1901.    RECT rect;
  1902.  
  1903.  
  1904.    if(!lpEnt)
  1905.       return;
  1906.  
  1907.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1908.       if(IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect))
  1909.       {
  1910.          rect.top = cVal;
  1911.          IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect);
  1912.       }
  1913. }
  1914.  
  1915. int WINAPI idoEntityGetLeft(LPENTITY lpEnt)
  1916. {
  1917.    RECT rect;
  1918.  
  1919.  
  1920.    if(!lpEnt)
  1921.       return 0;
  1922.  
  1923.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1924.       if(IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect))
  1925.          return rect.left;
  1926. }
  1927. void WINAPI idoEntitySetLeft(LPENTITY lpEnt, int cVal)
  1928. {
  1929.    RECT rect;
  1930.  
  1931.  
  1932.    if(!lpEnt)
  1933.       return;
  1934.  
  1935.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1936.       if(IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect))
  1937.       {
  1938.          rect.left = cVal;
  1939.          IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect);
  1940.       }
  1941. }
  1942.  
  1943. int WINAPI idoEntityGetRight(LPENTITY lpEnt)
  1944. {
  1945.    RECT rect;
  1946.  
  1947.  
  1948.    if(!lpEnt)
  1949.       return 0;
  1950.  
  1951.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1952.       if(IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect))
  1953.          return rect.right;
  1954. }
  1955. void WINAPI idoEntitySetRight(LPENTITY lpEnt, int cVal)
  1956. {
  1957.    RECT rect;
  1958.  
  1959.  
  1960.    if(!lpEnt)
  1961.       return;
  1962.  
  1963.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1964.       if(IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect))
  1965.       {
  1966.          rect.right = cVal;
  1967.          IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect);
  1968.       }
  1969. }
  1970.  
  1971. int WINAPI idoEntityGetBottom(LPENTITY lpEnt)
  1972. {
  1973.    RECT rect;
  1974.  
  1975.  
  1976.    if(!lpEnt)
  1977.       return 0;
  1978.  
  1979.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1980.       if(IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect))
  1981.          return rect.bottom;
  1982. }
  1983. void WINAPI idoEntitySetBottom(LPENTITY lpEnt, int cVal)
  1984. {
  1985.    RECT rect;
  1986.  
  1987.  
  1988.    if(!lpEnt)
  1989.       return;
  1990.  
  1991.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  1992.       if(IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect))
  1993.       {
  1994.          rect.bottom = cVal;
  1995.          IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)&rect);
  1996.       }
  1997. }
  1998.  
  1999. BOOL WINAPI idoEntityGetRect(LPENTITY lpEnt, LPRECT lpRect)
  2000. {
  2001.    if(!lpEnt)
  2002.       return 0;
  2003.    if(!lpRect)
  2004.       return 0;
  2005.  
  2006.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  2007.       return (BOOL)IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)lpRect);
  2008. }
  2009. void WINAPI idoEntitySetRect(LPENTITY lpEnt, LPRECT lpRect)
  2010. {
  2011.    if(!lpEnt)
  2012.       return;
  2013.    if(!lpRect)
  2014.       return;
  2015.  
  2016.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  2017.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_ENTITY_RECT, (LPARAM)(LPVOID)lpRect);
  2018. }
  2019.  
  2020.  
  2021. BOOL WINAPI idoEntityGetValidRelationDragSource(LPENTITY lpEnt)
  2022. {
  2023.    return !(idoEntityGetStyle(lpEnt, IDOS_NOSOURCE));
  2024. }
  2025. void WINAPI idoEntitySetValidRelationDragSource(LPENTITY lpEnt, BOOL bVal)
  2026. {
  2027.    idoEntitySetStyle(lpEnt, !bVal, IDOS_NOSOURCE);
  2028. }
  2029.  
  2030. BOOL WINAPI idoEntityGetCanResize(LPENTITY lpEnt)
  2031. {
  2032.    return !(idoEntityGetStyle(lpEnt, IDOS_NORESIZE));
  2033. }
  2034. void WINAPI idoEntitySetCanResize(LPENTITY lpEnt, BOOL bVal)
  2035. {
  2036.    idoEntitySetStyle(lpEnt, !bVal, IDOS_NORESIZE);
  2037. }
  2038.  
  2039. BOOL WINAPI idoEntityGetCanMove(LPENTITY lpEnt)
  2040. {
  2041.    return !(idoEntityGetStyle(lpEnt, IDOS_NOMOVE));
  2042. }
  2043. void WINAPI idoEntitySetCanMove(LPENTITY lpEnt, BOOL bVal)
  2044. {
  2045.    idoEntitySetStyle(lpEnt, !bVal, IDOS_NOMOVE);
  2046. }
  2047.  
  2048. BOOL WINAPI idoEntityGetCanDelete(LPENTITY lpEnt)
  2049. {
  2050.    return !(idoEntityGetStyle(lpEnt, IDOS_NOEDIT));
  2051. }
  2052. void WINAPI idoEntitySetCanDelete(LPENTITY lpEnt, BOOL bVal)
  2053. {
  2054.    idoEntitySetStyle(lpEnt, !bVal, IDOS_NOEDIT);
  2055. }
  2056.  
  2057. BOOL WINAPI idoEntityGetReadOnly(LPENTITY lpEnt)
  2058. {
  2059.    return idoEntityGetStyle(lpEnt, IDOS_NOEDIT);
  2060. }
  2061. void WINAPI idoEntitySetReadOnly(LPENTITY lpEnt, BOOL bVal)
  2062. {
  2063.    idoEntitySetStyle(lpEnt, bVal, IDOS_NOEDIT);
  2064. }
  2065.  
  2066. BOOL WINAPI idoEntityGetAutoResize(LPENTITY lpEnt)
  2067. {
  2068.    return idoEntityGetStyle(lpEnt, IDOS_AUTORESIZE);
  2069. }
  2070. void WINAPI idoEntitySetAutoResize(LPENTITY lpEnt, BOOL bVal)
  2071. {
  2072.    idoEntitySetStyle(lpEnt, bVal, IDOS_AUTORESIZE);
  2073. }
  2074.  
  2075. BOOL WINAPI idoEntityGetStretchBitmap(LPENTITY lpEnt)
  2076. {
  2077.    return idoEntityGetStyle(lpEnt, IDOS_STRETCHBITMAP);
  2078. }
  2079. void WINAPI idoEntitySetStretchBitmap(LPENTITY lpEnt, BOOL bVal)
  2080. {
  2081.    idoEntitySetStyle(lpEnt, bVal, IDOS_STRETCHBITMAP);
  2082. }
  2083.  
  2084. BOOL WINAPI idoEntityGetTransparent(LPENTITY lpEnt)
  2085. {
  2086.    return idoEntityGetStyle(lpEnt, IDOS_TRANSPARENT);
  2087. }
  2088. void WINAPI idoEntitySetTransparent(LPENTITY lpEnt, BOOL bVal)
  2089. {
  2090.    idoEntitySetStyle(lpEnt, bVal, IDOS_TRANSPARENT);
  2091. }
  2092.  
  2093. BOOL WINAPI idoEntityGetStyle(LPENTITY lpEnt, long Style)
  2094. {
  2095.    long lStyle;
  2096.  
  2097.    if(!lpEnt)
  2098.       return 0;
  2099.  
  2100.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  2101.    {
  2102.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_STYLE, (LPARAM)(LPVOID)&lStyle);
  2103.       return (BOOL)(lStyle & Style);
  2104.    }
  2105.    return -1;
  2106. }
  2107. void WINAPI idoEntitySetStyle(LPENTITY lpEnt, BOOL bVal, long Style)
  2108. {
  2109.    long lStyle;
  2110.  
  2111.    if(!lpEnt)
  2112.       return;
  2113.  
  2114.    if(idoGetEntity(lpEnt->hIDO, lpEnt->id, (LPSTR)lpEnt->name, lpEnt))
  2115.    {
  2116.       IDO_I(lpEnt->hIDO, IDOM_GETPROPERTY, PROP_STYLE, (LPARAM)(LPVOID)&lStyle);
  2117.       if(bVal)
  2118.          lStyle |= Style;
  2119.       else
  2120.          lStyle &= !Style;
  2121.       IDO_I(lpEnt->hIDO, IDOM_SETPROPERTY, PROP_STYLE, (LPARAM)(LPVOID)lStyle);
  2122.    }
  2123. }
  2124.  
  2125.  
  2126. //////////////////////////
  2127. //////////////////////////
  2128. //////////////////////////
  2129.  
  2130.  
  2131. void WINAPI idoRelationSetSourceArrow(LPRELATION lpRel, ARROWSTYLE style)
  2132. {
  2133.    if(!lpRel)
  2134.       return;
  2135.  
  2136.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2137.       IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LINE_SRC_ARROW_STYLE, (LPARAM)(long)style);
  2138. }
  2139. ARROWSTYLE WINAPI idoRelationGetSourceArrow(LPRELATION lpRel)
  2140. {
  2141.    ARROWSTYLE as = (ARROWSTYLE)-1;
  2142.  
  2143.    if(!lpRel)
  2144.       return -1;
  2145.  
  2146.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2147.       IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LINE_SRC_ARROW_STYLE, (LPARAM)(LPVOID)(ARROWSTYLE *)&as);
  2148.    return as;
  2149. }
  2150. void WINAPI idoRelationSetDestinationArrow(LPRELATION lpRel, ARROWSTYLE style)
  2151. {
  2152.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2153.       IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LINE_DST_ARROW_STYLE, (LPARAM)(long)style);
  2154. }
  2155. ARROWSTYLE WINAPI idoRelationGetDestinationArrow(LPRELATION lpRel)
  2156. {
  2157.    ARROWSTYLE as = (ARROWSTYLE)-1;
  2158.  
  2159.    if(!lpRel)
  2160.       return -1;
  2161.  
  2162.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2163.       IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LINE_DST_ARROW_STYLE, (LPARAM)(LPVOID)(ARROWSTYLE *)&as);
  2164.    return as;
  2165. }
  2166.  
  2167.  
  2168. void WINAPI idoRelationSetType(LPRELATION lpRel, LINESTYLE style)
  2169. {
  2170.    if(!lpRel)
  2171.       return;
  2172.  
  2173.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2174.       IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LINE_STYLE, (LPARAM)(long)style);
  2175. }
  2176. LINESTYLE WINAPI idoRelationGetType(LPRELATION lpRel)
  2177. {
  2178.    LINESTYLE ls = (LINESTYLE)-1;
  2179.  
  2180.    if(!lpRel)
  2181.       return -1;
  2182.  
  2183.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2184.       IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LINE_STYLE, (LPARAM)(LPVOID)(LINESTYLE *)&ls);
  2185.    return ls;
  2186. }
  2187.  
  2188.  
  2189. void WINAPI idoRelationSetThickness(LPRELATION lpRel, long width)
  2190. {
  2191.    if(!lpRel)
  2192.       return;
  2193.  
  2194.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2195.       IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LINE_THICKNESS, (LPARAM)(long)width);
  2196. }
  2197. long WINAPI idoRelationGetThickness(LPRELATION lpRel)
  2198. {
  2199.    long width = -1;
  2200.  
  2201.    if(!lpRel)
  2202.       return -1;
  2203.  
  2204.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2205.       IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LINE_THICKNESS, (LPARAM)(LPVOID)(long *)&width);
  2206.    return width;
  2207. }
  2208.  
  2209.  
  2210. BOOL WINAPI idoRelationSourceEntity(LPRELATION lpRel, LPENTITY lpEnt)
  2211. {
  2212.    if(!lpEnt || !lpRel)
  2213.       return 0;
  2214.  
  2215.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2216.       return (BOOL)IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LINE_SRCENTITY, (LPARAM)(LPVOID)lpEnt);
  2217. }
  2218.  
  2219. BOOL WINAPI idoRelationDestinationEntity(LPRELATION lpRel, LPENTITY lpEnt)
  2220. {
  2221.    if(!lpEnt || !lpRel)
  2222.       return 0;
  2223.  
  2224.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2225.       return (BOOL)IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LINE_DSTENTITY, (LPARAM)(LPVOID)lpEnt);
  2226. }
  2227.  
  2228.  
  2229.  
  2230. BOOL WINAPI idoRelationGetReadOnly(LPRELATION lpRel)
  2231. {
  2232.    return idoRelationGetStyle(lpRel, IDOS_NOEDIT);
  2233. }
  2234. void WINAPI idoRelationSetReadOnly(LPRELATION lpRel, BOOL bVal)
  2235. {
  2236.    idoRelationSetStyle(lpRel, bVal, IDOS_NOEDIT);
  2237. }
  2238.  
  2239. BOOL WINAPI idoRelationGetCanDelete(LPRELATION lpRel)
  2240. {
  2241.    return !(idoRelationGetStyle(lpRel, IDOS_NODELETE));
  2242. }
  2243. void WINAPI idoRelationSetCanDelete(LPRELATION lpRel, BOOL bVal)
  2244. {
  2245.    idoRelationSetStyle(lpRel, !bVal, IDOS_NODELETE);
  2246. }
  2247.  
  2248. BOOL WINAPI idoRelationGetCanMoveEndPoints(LPRELATION lpRel)
  2249. {
  2250.    return !(idoRelationGetStyle(lpRel, IDOS_NOMOVEENDPOINTS));
  2251. }
  2252. void WINAPI idoRelationSetCanMoveEndPoints(LPRELATION lpRel, BOOL bVal)
  2253. {
  2254.    idoRelationSetStyle(lpRel, !bVal, IDOS_NOMOVEENDPOINTS);
  2255. }
  2256.  
  2257. BOOL WINAPI idoRelationGetCanMoveMidPoints(LPRELATION lpRel)
  2258. {
  2259.    return !(idoRelationGetStyle(lpRel, IDOS_NOMOVEMIDPOINTS));
  2260. }
  2261. void WINAPI idoRelationSetCanMoveMidPoints(LPRELATION lpRel, BOOL bVal)
  2262. {
  2263.    idoRelationSetStyle(lpRel, !bVal, IDOS_NOMOVEMIDPOINTS);
  2264. }
  2265.  
  2266.  
  2267. BOOL WINAPI idoRelationGetStyle(LPRELATION lpRel, long Style)
  2268. {
  2269.    long lStyle;
  2270.  
  2271.    if(!lpRel)
  2272.       return 0;
  2273.  
  2274.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2275.    {
  2276.       IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LSTYLE, (LPARAM)(LPVOID)&lStyle);
  2277.       return (BOOL)(lStyle & Style);
  2278.    }
  2279.    return -1;
  2280. }
  2281. void WINAPI idoRelationSetStyle(LPRELATION lpRel, BOOL bVal, long Style)
  2282. {
  2283.    long lStyle;
  2284.  
  2285.    if(!lpRel)
  2286.       return;
  2287.  
  2288.    if(idoGetRelation(lpRel->hIDO, lpRel->id, (LPSTR)lpRel->name, lpRel))
  2289.    {
  2290.       IDO_I(lpRel->hIDO, IDOM_GETPROPERTY, PROP_LSTYLE, (LPARAM)(LPVOID)&lStyle);
  2291.       if(bVal)
  2292.          lStyle |= Style;
  2293.       else
  2294.          lStyle &= !Style;
  2295.       IDO_I(lpRel->hIDO, IDOM_SETPROPERTY, PROP_LSTYLE, (LPARAM)(LPVOID)lStyle);
  2296.    }
  2297. }
  2298.  
  2299. /////////////////////////////////////////
  2300. /////////////////////////////////////////
  2301. /////////////////////////////////////////
  2302.  
  2303.  
  2304. LPCSTR WINAPI idoRuleDestinationEntityClassName(LPIDO_RULE lpRule)
  2305. {
  2306.    if(lpszText)
  2307.       free(lpszText);
  2308.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  2309.  
  2310.    if(!lpRule)
  2311.       return 0;
  2312.  
  2313.    lstrcpy(lpszText, lpRule->E2);
  2314.    return lpszText;
  2315. }
  2316. LPCSTR WINAPI idoRuleSourceEntityClassName(LPIDO_RULE lpRule)
  2317. {
  2318.    if(lpszText)
  2319.       free(lpszText);
  2320.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  2321.  
  2322.    if(!lpRule)
  2323.       return 0;
  2324.  
  2325.    lstrcpy(lpszText, lpRule->E1);
  2326.    return lpszText;
  2327. }
  2328. LPCSTR WINAPI idoRuleRelationClassName(LPIDO_RULE lpRule)
  2329. {
  2330.    if(lpszText)
  2331.       free(lpszText);
  2332.    lpszText = calloc(sizeof(char), MAX_TEMP_LEN);
  2333.  
  2334.    if(!lpRule)
  2335.       return 0;
  2336.  
  2337.    lstrcpy(lpszText, lpRule->R1);
  2338.    return lpszText;
  2339. }
  2340.  
  2341.  
  2342.