home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 February / PCWorld_2000-02_cd.bin / Software / TemaCD / tcvpa / data1.cab / MyFileGroup / INCLUDE / Lio.hpp < prev    next >
C/C++ Source or Header  |  1999-06-03  |  18KB  |  727 lines
  1. #ifndef _INC_LIO_HPP
  2. #define _INC_LIO_HPP
  3. typedef short Int2;
  4. typedef unsigned short UInt2;
  5. typedef int Int4;
  6. typedef unsigned int UInt4;
  7.  
  8. typedef int SLong;
  9. typedef unsigned int ULong;
  10. typedef short SWord;
  11. typedef unsigned short UWord;
  12.  
  13. typedef int Boolean;
  14.  
  15. #define true    1
  16. #define false    0
  17.  
  18. #define LOSHORT(l)            ((short)((WORD)(l)))
  19. #define HISHORT(l)            ((short)((WORD)((DWORD)(l) >> 16)))
  20.  
  21. #define SetClassCursor(hwnd,hc)        SetClassLong( hwnd, GCL_HCURSOR, (DWORD)hc )
  22. #define GetClassCursor(hwnd)        ((HCURSOR)GetClassLong( hwnd, GCL_HCURSOR ))
  23. #define SetWindowStyle(hwnd,dw)        SetWindowLong(hwnd,GWL_STYLE,dw)
  24. #define SetWindowExStyle(hwnd,dw)    SetWindowLong(hwnd,GWL_EXSTYLE,dw)
  25. #define SetRedraw(hwnd, fRedraw)    SendMessage(hwnd,WM_SETREDRAW,fRedraw,0)
  26.  
  27. //#define GetWindowInstance(hwnd)        ((HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE))
  28. //#define GetWindowStyle(hwnd)        GetWindowLong(hwnd,GWL_STYLE)
  29. //#define GetWindowExStyle(hwnd)        GetWindowLong(hwnd,GWL_EXSTYLE)
  30.  
  31. //#define SetWindowFont(hwnd,hFont,fRedraw)    SendMessage(hwnd,WM_SETFONT,(WPARAM)hFont,fRedraw)
  32. //#define GetWindowFont(hwnd)                    ((HFONT)SendMessage(hwnd,WM_GETFONT,0,0))
  33.  
  34.  
  35. #define Loop for(;;)
  36. #define sizeofarray(a)        (sizeof(a)/sizeof(a[0]))
  37. //#define _PRINT_BUF_SIZE        8000
  38. #define SPLIT_D        6
  39.  
  40. #define ConstrInit0(a,b)    memset( (char*)&a, 0,\
  41.     sizeof(b) + (((char*)&b) - ((char*)&a)) )
  42.  
  43. #define ZeroMem(a)    memset(&a,0,sizeof(a))
  44.  
  45. #define Make4C(ch0, ch1, ch2, ch3)                              \
  46.                 ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |   \
  47.                 ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
  48. #define COLORIDX_Black        0
  49. #define COLORIDX_DkRed        1
  50. #define COLORIDX_DkGreen    2
  51. #define COLORIDX_Brown        3
  52. #define COLORIDX_DkBlue        4
  53. #define COLORIDX_DkMagenta    5
  54. #define COLORIDX_DkCyan        6
  55. #define COLORIDX_LtGray        7
  56. #define COLORIDX_Gray        7
  57. #define COLORIDX_DkGray        8
  58. #define COLORIDX_Red        9
  59. #define COLORIDX_LtRed        9
  60. #define COLORIDX_Green        10
  61. #define COLORIDX_LtGreen    10
  62. #define COLORIDX_Yellow        11
  63. #define COLORIDX_Blue        12
  64. #define COLORIDX_LtBlue        12
  65. #define COLORIDX_Magenta    13
  66. #define COLORIDX_Cyan        14
  67. #define COLORIDX_LtCyan        14
  68. #define COLORIDX_White        15
  69.  
  70. #define COLORIDX_SysText    16
  71. #define COLORIDX_SysBack    17
  72. #define COLORIDX_SysSelText    18
  73. #define COLORIDX_SysSelBack    19
  74.  
  75.  
  76. #define STD_VGA_COLORS_16    \
  77.     RGB(0,0,0),       RGB(128,0,0),   RGB(0,128,0),   RGB(128,128,0),\
  78.     RGB(0,0,128),     RGB(128,0,128), RGB(0,128,128), RGB(192,192,192),\
  79.     RGB(128,128,128), RGB(255,0,0),   RGB(0,255,0),   RGB(255,255,0),\
  80.     RGB(0,0,255),     RGB(255,0,255), RGB(0,255,255), RGB(255,255,255)
  81.  
  82.  
  83. inline COLORREF VgaColor(int idx)
  84. {
  85.     static COLORREF colors[16] = { STD_VGA_COLORS_16 };
  86.     static int sc[4] = {
  87.     COLOR_WINDOWTEXT, COLOR_WINDOW,
  88.     COLOR_HIGHLIGHTTEXT, COLOR_HIGHLIGHT };
  89.  
  90.     if( idx >= 0 && idx < 16 ) return colors[idx];
  91.     return GetSysColor( sc[idx-16] );
  92. }
  93.  
  94. extern "C"
  95. {
  96.  
  97. typedef struct POSITION_Tag
  98. {
  99.     int x;
  100.     int y;
  101.     int cx;
  102.     int cy;
  103. }
  104. POSITION;
  105.  
  106. typedef struct SPOSITION_Tag
  107. {
  108.     short x;
  109.     short y;
  110.     short cx;
  111.     short cy;
  112. }
  113. SPOSITION;
  114.  
  115. }; // extern "C"
  116. typedef struct
  117. {
  118.     BITMAPINFOHEADER bih;
  119.     RGBQUAD rgbq [ 256 ];
  120. }
  121. BITMAPINFO256;
  122.  
  123. typedef struct
  124. {
  125.     BITMAPINFOHEADER bih;
  126.     RGBQUAD rgbq [ 16 ];
  127. }
  128. BITMAPINFO16;
  129.  
  130. typedef struct {
  131.     BITMAPINFOHEADER bih;
  132.     RGBQUAD rgbq [ 2 ];
  133. }
  134. BITMAPINFO2;
  135.  
  136.  
  137.  
  138. #pragma pack(1)
  139. typedef struct
  140. {
  141.     WORD    w1;   // 0
  142.     WORD    type; // 1-icon, 2-cursor
  143.     WORD    w2;   // 1
  144.     BYTE    cx;
  145.     BYTE    cy;
  146.     WORD    colors;
  147.     WORD    xhs;
  148.     WORD    yhs;
  149.     DWORD    size2; // sizeof(file) - sizeof(ICON_HEADER)
  150.     DWORD    size1; // sizeof(ICON_HEADER)
  151. }
  152. ICON_HEADER;
  153. #pragma pack()
  154.  
  155. #define GET_CHILD_RECT(hwnd,rc)    \
  156.     GetWindowRect( hwnd, rc );\
  157.     {POINT pt; pt.x=pt.y=0;\
  158.     ClientToScreen( GetParent(hwnd), &pt);\
  159.     OffsetRect( rc, -pt.x, -pt.y );}
  160.  
  161. #define sNull            tc_sNull
  162. #define String            TC_CString
  163.  
  164. #define ArrayC            TC_TArrayC
  165. #define ArrayCPP        TC_TArrayCPP
  166. #define ArrayPTR        TC_TArrayPTR
  167. #define ArrayString        TC_CArrayString
  168. #define ArrayStrStr        TCArrayStrStr
  169. #define ArrayINT        TCArrayINT
  170. #define ArrayUINT        TCArrayUINT
  171. #define ArrayLONG        TCArrayLONG
  172. #define ArrayULONG        TCArrayULONG
  173.  
  174. #define ArrayHWND        TCArrayHWND
  175. #define ArrayCHAR        TCArrayCHAR
  176.  
  177. #define AReg            TC_CRegistry
  178. #define AWin            TC_CWindow
  179. #define AWaitCursor        TC_CWaitCursor
  180.  
  181.  
  182. // **********************************************************************
  183. class APen 
  184. {
  185. public:  HPEN m_HPen ;
  186. public:   APen (COLORREF color, int width=1) 
  187. {
  188. m_HPen = CreatePen( PS_SOLID, width, color );
  189.  
  190. } // end of func
  191. // **********************************************************************
  192.  
  193. public:   ~APen () 
  194. {
  195. if(m_HPen) DeleteObject(m_HPen);
  196. } // end of func
  197. // **********************************************************************
  198.  
  199. public:   operator HPEN () 
  200. {
  201. return m_HPen;
  202. } // end of func
  203. // **********************************************************************
  204.  
  205.  
  206. }; // end of class APen
  207.  
  208. // **********************************************************************
  209.  
  210. // **********************************************************************
  211. class ABrush 
  212. {
  213. public:  HBRUSH m_HBrush ;
  214. public:   ABrush (COLORREF color) 
  215. {
  216. m_HBrush = CreateSolidBrush( color );
  217. } // end of func
  218. // **********************************************************************
  219.  
  220. public:   ~ABrush () 
  221. {
  222. if(m_HBrush) DeleteObject(m_HBrush);
  223. } // end of func
  224. // **********************************************************************
  225.  
  226. public:   operator HBRUSH () 
  227. {
  228. return m_HBrush;
  229. } // end of func
  230. // **********************************************************************
  231.  
  232.  
  233. }; // end of class ABrush
  234.  
  235. // **********************************************************************
  236.  
  237. // **********************************************************************
  238. class ADC 
  239. {
  240. public: 
  241. enum  {
  242.  Mode_Simple,
  243.  Mode_Paint,
  244.  Mode_Get,
  245.  Mode_Create,
  246. };
  247. public:  HDC hDC ;
  248. public:  HWND hWnd ;
  249. public:  PAINTSTRUCT P_S ;
  250. public:  int _Mode ;
  251. public:   ADC (HWND hwnd, int mode, HDC hdc=0) 
  252. {
  253. hWnd = hwnd;
  254. _Mode = mode;
  255.  
  256. switch(_Mode)
  257. {
  258. case Mode_Simple    : hDC = hdc; break;
  259. case Mode_Paint        : hDC = BeginPaint(hWnd,&P_S); break;
  260. case Mode_Get        : hDC = GetDC(hWnd); break;
  261. case Mode_Create    : hDC = CreateCompatibleDC(0); break;
  262. }
  263. } // end of func
  264. // **********************************************************************
  265.  
  266. public:   ~ADC () 
  267. {
  268. switch(_Mode)
  269. {
  270. case Mode_Simple    : break;
  271. case Mode_Paint        : EndPaint(hWnd,&P_S); break;
  272. case Mode_Get        : ReleaseDC(hWnd,hDC); break;
  273. case Mode_Create    : DeleteDC(hDC); break;
  274. }
  275.  
  276. hWnd = 0;
  277. hDC = 0;
  278. _Mode = 0;
  279.  
  280. } // end of func
  281. // **********************************************************************
  282.  
  283. public:   operator HDC () 
  284. {
  285. return hDC;
  286. } // end of func
  287. // **********************************************************************
  288.  
  289.  
  290. }; // end of class ADC
  291.  
  292. // **********************************************************************
  293.  
  294. // **********************************************************************
  295. class ACheckHDC 
  296. {
  297. public:  HDC m_hDC ;
  298. public:  HWND m_hWnd ;
  299. public:   ACheckHDC (HWND hWnd, HDC &hDC) 
  300. {
  301. m_hDC = 0;
  302. m_hWnd = 0;
  303.  
  304. if( hDC == 0 )
  305. {
  306.     hDC = GetDC(hWnd);
  307.     m_hDC = hDC;
  308.     m_hWnd = hWnd;
  309. }
  310. } // end of func
  311. // **********************************************************************
  312.  
  313. public:   ~ACheckHDC () 
  314. {
  315. if( m_hDC ) ReleaseDC(m_hWnd,m_hDC);
  316. } // end of func
  317. // **********************************************************************
  318.  
  319.  
  320. }; // end of class ACheckHDC
  321.  
  322. // **********************************************************************
  323.  
  324. // **********************************************************************
  325. class ASimpleFont 
  326. {
  327. public:  HFONT hMS [2];
  328. public:  HFONT hSM [2];
  329. public:  int cy_MS ;
  330. public:  int cy_SM ;
  331. public:   ASimpleFont () 
  332. {
  333. LOGFONT lf;
  334.  
  335. memset( &lf, 0, sizeof(lf) );
  336. lf. lfHeight = -11;
  337. lf. lfOutPrecision = OUT_DEFAULT_PRECIS;
  338. lf. lfClipPrecision = CLIP_DEFAULT_PRECIS;
  339. lf. lfQuality = DEFAULT_QUALITY;
  340. lf. lfPitchAndFamily = FF_ROMAN;
  341. strcpy( lf. lfFaceName, "MS Sans Serif" );
  342.  
  343. lf. lfWeight = 400;
  344. hMS[0] = CreateFontIndirect( &lf );
  345. lf. lfWeight = 700;
  346. hMS[1] = CreateFontIndirect( &lf );
  347.  
  348. memset( &lf, 0, sizeof(lf) );
  349. lf. lfHeight = -9;
  350. lf. lfOutPrecision = OUT_DEFAULT_PRECIS;
  351. lf. lfClipPrecision = CLIP_DEFAULT_PRECIS;
  352. lf. lfQuality = DEFAULT_QUALITY;
  353. lf. lfPitchAndFamily = FF_ROMAN;
  354. strcpy( lf. lfFaceName, "Small Fonts" );
  355.  
  356. lf. lfWeight = 400;
  357. hSM[0] = CreateFontIndirect( &lf );
  358. lf. lfWeight = 700;
  359. hSM[1] = CreateFontIndirect( &lf );
  360.  
  361.  
  362. HDC hDC = GetDC(0);
  363. TEXTMETRIC tm;
  364. HFONT old_f =
  365.  
  366. SelectObject( hDC, hMS[0] );
  367. GetTextMetrics(hDC,&tm);
  368. cy_MS = tm.tmHeight;
  369.  
  370. SelectObject( hDC, hSM[0] );
  371. GetTextMetrics(hDC,&tm);
  372. cy_SM = tm.tmHeight;
  373.  
  374. SelectObject( hDC, old_f );
  375. ReleaseDC(0,hDC);
  376. } // end of func
  377. // **********************************************************************
  378.  
  379. public:   ~ASimpleFont () 
  380. {
  381. if( hMS[0] ) DeleteObject(hMS[0]);
  382. if( hMS[1] ) DeleteObject(hMS[1]);
  383. if( hSM[0] ) DeleteObject(hSM[0]);
  384. if( hSM[1] ) DeleteObject(hSM[1]);
  385. } // end of func
  386. // **********************************************************************
  387.  
  388. public:  HFONT MS (int idx) 
  389. {
  390. return hMS[idx];
  391. } // end of func
  392. // **********************************************************************
  393.  
  394. public:  HFONT SM (int idx) 
  395. {
  396. return hSM[idx];
  397. } // end of func
  398. // **********************************************************************
  399.  
  400. public:  int CyMS () 
  401. {
  402. return cy_MS;
  403. } // end of func
  404. // **********************************************************************
  405.  
  406. public:  int CySM () 
  407. {
  408. return cy_SM;
  409. } // end of func
  410. // **********************************************************************
  411.  
  412.  
  413. }; // end of class ASimpleFont
  414.  
  415. // **********************************************************************
  416. inline void Line ( HDC hDC, int x1, int y1, int x2, int y2 ) 
  417. {
  418. MoveToEx(hDC,x1,y1,0);
  419. LineTo(hDC,x2,y2);
  420. } // end of func
  421. // **********************************************************************
  422.  
  423. inline void VLine (HDC hDC, int x, int y1, int y2) 
  424. {
  425. MoveToEx( hDC, x, y1, 0 );
  426. LineTo  ( hDC, x, y2 );
  427. } // end of func
  428. // **********************************************************************
  429.  
  430. inline void HLine (HDC hDC, int y, int x1, int x2) 
  431. {
  432. MoveToEx( hDC, x1, y, 0 );
  433. LineTo  ( hDC, x2, y );
  434. } // end of func
  435. // **********************************************************************
  436.  
  437. inline void VLine (HDC hDC,HPEN pen,int x,int y1,int y2) 
  438. {
  439. HPEN old = SelectObject( hDC, pen );
  440. MoveToEx( hDC, x, y1, 0 );
  441. LineTo  ( hDC, x, y2 );
  442. SelectObject( hDC, old );
  443. } // end of func
  444. // **********************************************************************
  445.  
  446. inline void HLine (HDC hDC,HPEN pen,int y,int x1,int x2) 
  447. {
  448. HPEN old = SelectObject( hDC, pen );
  449. MoveToEx( hDC, x1, y, 0 );
  450. LineTo  ( hDC, x2, y );
  451. SelectObject( hDC, old );
  452. } // end of func
  453. // **********************************************************************
  454.  
  455. inline void Beep (int i =0) 
  456. {
  457. ::MessageBeep( i );
  458. } // end of func
  459. // **********************************************************************
  460.  
  461. inline void Fill_Rect (HDC hDC,RECT *rc,COLORREF color) 
  462. {
  463. FillRect( hDC, rc, ABrush(color) );
  464. } // end of func
  465. // **********************************************************************
  466.  
  467. inline void Fill_Rect (HDC hDC,HBRUSH br,int x,int y,int cx,int cy) 
  468. {
  469. RECT r; SetRect(&r,x,y,x+cx,y+cy);
  470. FillRect(hDC,&r,br);
  471. } // end of func
  472. // **********************************************************************
  473.  
  474. inline void RectLines (HDC hDC, int x, int y, int cx, int cy) 
  475. {
  476. Line( hDC, x, y, x, y+cy );
  477. Line( hDC, x, y, x+cx, y );
  478. Line( hDC, x+cx-1, y, x+cx-1, y+cy );
  479. Line( hDC, x, y+cy-1, x+cx, y+cy-1 );
  480. } // end of func
  481. // **********************************************************************
  482.  
  483. inline void swinout (LPCSTR text) 
  484. {
  485. ATOM at = GlobalAddAtom(text);
  486. if( at )
  487. {
  488.     SendMessage( FindWindow("WINOUT",0), WM_USER+666, at, 0 );
  489.     GlobalDeleteAtom(at);
  490. }
  491. } // end of func
  492. // **********************************************************************
  493.  
  494. inline int GetVScrollPos (HWND hwnd) 
  495. {
  496. return GetScrollPos(hwnd,SB_VERT);
  497. } // end of func
  498. // **********************************************************************
  499.  
  500. inline int GetHScrollPos (HWND hwnd) 
  501. {
  502. return GetScrollPos(hwnd,SB_HORZ);
  503. } // end of func
  504. // **********************************************************************
  505.  
  506. inline int GetVScrollMax (HWND hwnd) 
  507. {
  508. int min_,max_=0;
  509. GetScrollRange(hwnd,SB_VERT,&min_,&max_);
  510. return max_;
  511. } // end of func
  512. // **********************************************************************
  513.  
  514. inline int GetHScrollMax (HWND hwnd) 
  515. {
  516. int min_,max_=0;
  517. GetScrollRange(hwnd,SB_HORZ,&min_,&max_);
  518. return max_;
  519. } // end of func
  520. // **********************************************************************
  521.  
  522. inline void Release_Capture (HWND hwnd) 
  523. {
  524. if( hwnd && GetCapture() == hwnd ) ReleaseCapture();
  525. } // end of func
  526. // **********************************************************************
  527.  
  528. inline POINT LioPtClientToScreen (HWND hWnd) 
  529. {
  530. POINT pt;
  531. pt.x=pt.y=0;
  532. ClientToScreen(hWnd,&pt);
  533. return pt;
  534. } // end of func
  535. // **********************************************************************
  536.  
  537. inline HBITMAP HBitmapFromBuffer (LPCSTR src) 
  538. {
  539. HDC hDC = GetDC(0);
  540.  
  541. HBITMAP hbmp =
  542.     CreateDIBitmap(hDC,
  543.     (BITMAPINFOHEADER*)(src+sizeof(BITMAPFILEHEADER)),
  544.     CBM_INIT,
  545.     src + ((BITMAPFILEHEADER*)src)->bfOffBits,
  546.     (BITMAPINFO*)(src+sizeof(BITMAPFILEHEADER)),
  547.     DIB_RGB_COLORS
  548. );
  549.  
  550. ReleaseDC(0,hDC);
  551.  
  552. return hbmp;
  553. } // end of func
  554. // **********************************************************************
  555.  
  556. inline HCURSOR HCursorFromBuffer (LPCSTR src) 
  557. {
  558. int cnt;
  559. int add1 = 22 + sizeof(BITMAPINFOHEADER) + 4*2;
  560. int add2 = add1 + 32*4;
  561.  
  562. DWORD * p1 = (DWORD*)(src+add1);
  563. DWORD * p2 = p1+31;
  564. DWORD * p3 = (DWORD*)(src+add2);
  565. DWORD * p4 = p3+31;
  566.  
  567. for( cnt=0; cnt < 16; cnt++ )
  568. {
  569.     DWORD dw = *p1;
  570.     *p1 = *p2;
  571.     *p2 = dw;
  572.     p1++;
  573.     p2--;
  574.  
  575.     dw = *p3;
  576.     *p3 = *p4;
  577.     *p4 = dw;
  578.     p3++;
  579.     p4--;
  580. }
  581.  
  582. short * hs = (short*)(src+10);
  583. return CreateCursor( GetModuleHandle(0),
  584.         hs[0], hs[1], 32, 32,
  585.         src+add2, src+add1 );
  586. } // end of func
  587. // **********************************************************************
  588.  
  589. inline int Strlen ( const char * str ) 
  590. {
  591. return (str ? strlen(str) : 0);
  592. } // end of func
  593. // **********************************************************************
  594.  
  595. inline int Strcmp (const char *s1, const char *s2) 
  596. {
  597. return strcmp( (s1) ? s1 : "", (s2) ? s2 : "" );
  598. } // end of func
  599. // **********************************************************************
  600.  
  601. inline BOOL Zero (const char * s) 
  602. {
  603. if( ! s || ! *s ) return TRUE;
  604. return FALSE;
  605. } // end of func
  606. // **********************************************************************
  607.  
  608. inline BOOL Clipboard_WritePtr (UINT type, void *ptr, int size) 
  609. {
  610. if( type == CF_TEXT && size == -1 ) size = 1+strlen( (char*)ptr );
  611.  
  612. //if( !IsWindow(hwnd) ) return FALSE;
  613. if( !OpenClipboard(0) ) return FALSE;
  614. EmptyClipboard();
  615. HGLOBAL hg = GlobalAlloc( GMEM_DDESHARE | GMEM_MOVEABLE, size );
  616. if( !hg ) { CloseClipboard(); return FALSE; }
  617. char * lpc = (char*)GlobalLock( hg );
  618. if( !lpc ) { GlobalFree(hg); CloseClipboard(); return FALSE; }
  619. memcpy( lpc, ptr, size );
  620. GlobalUnlock( hg );
  621. SetClipboardData( type, hg );
  622. CloseClipboard();
  623. return TRUE;
  624. } // end of func
  625. // **********************************************************************
  626.  
  627.  
  628. // **********************************************************************
  629. class Clipboard_ReadPtr 
  630. {
  631. private:  char* m_Ptr ;
  632. private:  HGLOBAL m_HG ;
  633. private:  BOOL m_Open ;
  634. private:  int m_Size ;
  635. public:   Clipboard_ReadPtr (UINT type) 
  636. {
  637. m_HG = 0;
  638. m_Open = 0;
  639. m_Ptr = 0;
  640. m_Size = 0;
  641.  
  642. //if( !IsWindow(hwnd) ) return;
  643. if( !IsClipboardFormatAvailable(type) ) return;
  644. if( !OpenClipboard(0) ) return;
  645. m_Open = TRUE;
  646.  
  647. m_HG = (HGLOBAL)GetClipboardData(type);
  648. if( m_HG )
  649. {
  650.     m_Size = GlobalSize(m_HG);
  651.     m_Ptr = (char*)GlobalLock(m_HG);
  652. }
  653. } // end of func
  654. // **********************************************************************
  655.  
  656. public:   ~Clipboard_ReadPtr () 
  657. {
  658. if( m_HG && m_Ptr ) GlobalUnlock(m_HG);
  659. if( m_Open ) CloseClipboard();
  660. } // end of func
  661. // **********************************************************************
  662.  
  663. public:  BOOL Ok () 
  664. {
  665. return (m_Ptr != 0);
  666. } // end of func
  667. // **********************************************************************
  668.  
  669. public:  void* Ptr () 
  670. {
  671. return m_Ptr;
  672. } // end of func
  673. // **********************************************************************
  674.  
  675. public:  int Size () 
  676. {
  677. return m_Size;
  678. } // end of func
  679. // **********************************************************************
  680.  
  681.  
  682. }; // end of class Clipboard_ReadPtr
  683.  
  684. // **********************************************************************
  685.  
  686. // **********************************************************************
  687. class Clipboard_ReadHandle 
  688. {
  689. private:  HANDLE m_Handle ;
  690. private:  BOOL m_Open ;
  691. public:   Clipboard_ReadHandle (UINT type) 
  692. {
  693. m_Handle = 0;
  694. m_Open = 0;
  695.  
  696. if( !IsClipboardFormatAvailable(type) ) return;
  697. if( !OpenClipboard(0) ) return;
  698. m_Open = TRUE;
  699. m_Handle = GetClipboardData(type);
  700. } // end of func
  701. // **********************************************************************
  702.  
  703. public:   ~Clipboard_ReadHandle () 
  704. {
  705. if( m_Open ) CloseClipboard();
  706. } // end of func
  707. // **********************************************************************
  708.  
  709. public:  BOOL Ok () 
  710. {
  711. return (m_Handle != 0);
  712. } // end of func
  713. // **********************************************************************
  714.  
  715. public:  HANDLE Handle () 
  716. {
  717. return m_Handle;
  718. } // end of func
  719. // **********************************************************************
  720.  
  721.  
  722. }; // end of class Clipboard_ReadHandle
  723.  
  724. // **********************************************************************
  725.  
  726. #endif // _INC_LIO_HPP
  727.