// XTPSystemHelpers // // This file is a part of the XTREME TOOLKIT PRO MFC class library. // (c)1998-2012 Codejock Software, All Rights Reserved. // // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN // CONSENT OF CODEJOCK SOFTWARE. // // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A // SINGLE COMPUTER. // // CONTACT INFORMATION: // support@codejock.com // http://www.codejock.com // ///////////////////////////////////////////////////////////////////////////// //{{AFX_CODEJOCK_PRIVATE #if !defined(__XTPSYSTEMHELPERS_H__) #define __XTPSYSTEMHELPERS_H__ //}}AFX_CODEJOCK_PRIVATE #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include class CXTPSystemVersion; // ----------------------------------------------------------------------- // Summary: // The XTPSystemVersion function is used for access to the // CXTPSystemVersion class. // Remarks: // Call this function to access CXTPSystemVersion members. Since // this class is designed as a single instance object you can only // access its members through this method. You cannot directly // instantiate an object of type CXTPSystemVersion. // Returns: // A pointer to the one and only CXTPSystemVersion instance. // Example: // The following example demonstrates the use of XTPSystemVersion. // // bool bIsWinNT = XTPSystemVersion()-\>IsWinNT4(); // // See Also: // CXTPSystemVersion // ----------------------------------------------------------------------- _XTP_EXT_CLASS CXTPSystemVersion* AFXAPI XTPSystemVersion(); //=========================================================================== // Summary: // CXTPSystemVersion is a OSVERSIONINFO derived class. This class // wraps the Win32 API GetVersionEx(...), used to get the current // Windows OS version. CXTPSystemVersion is a single instance, or // "singleton" object, that is accessed with the Get() method. //=========================================================================== class _XTP_EXT_CLASS CXTPSystemVersion : public OSVERSIONINFO { private: //----------------------------------------------------------------------- // Summary: // Constructs a CXTPSystemVersion object. //----------------------------------------------------------------------- CXTPSystemVersion(); public: //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is Windows 3.1. // Returns: // true if the OS is Windows 3.1, otherwise returns false. //----------------------------------------------------------------------- bool IsWin31() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is Windows 95. // Returns: // true if the OS is Windows 95, otherwise returns false. //----------------------------------------------------------------------- bool IsWin95() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is Windows 98. // Returns: // true if the OS is Windows 98, otherwise returns false. //----------------------------------------------------------------------- bool IsWin98() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is Windows ME. // Returns: // true if the OS is Windows ME, otherwise returns false. //----------------------------------------------------------------------- bool IsWinME() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is Windows NT 4. // Returns: // true if the OS is Windows NT 4, otherwise returns false. //----------------------------------------------------------------------- bool IsWinNT4() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is Windows 2000. // Returns: // true if the OS is Windows 2000, otherwise returns false. //----------------------------------------------------------------------- bool IsWin2K() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is Windows XP. // Returns: // true if the OS is Windows XP, otherwise returns false. //----------------------------------------------------------------------- bool IsWinXP() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is greater than or equal to Windows 3.1. // Returns: // true if the OS is greater than or equal to Windows 3.1, // otherwise returns false. //----------------------------------------------------------------------- bool IsWin31OrGreater() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is of the Windows 9x family, and if it is // Windows 95 or a later version. // Returns: // true if the OS is of the Windows 9x family, and is Windows 95 /// or a later version, otherwise returns false. //----------------------------------------------------------------------- bool IsWin95OrGreater() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is of the Windows 9x family, and if it is // Windows 98 or a later version. // Returns: // true if the OS is of the Windows 9x family, and is Windows 98 // or a later version, otherwise returns false. //----------------------------------------------------------------------- bool IsWin98OrGreater() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is of the Windows 9x family // Returns: // true if the OS is of the Windows 9x family //----------------------------------------------------------------------- bool IsWin9x() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is of the Windows 9x family, and if it is // Windows ME or a later version. // Returns: // true if the OS is of the Windows 9x family, and is Windows ME // or a later version, otherwise returns false. //----------------------------------------------------------------------- bool IsWinMEOrGreater() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is of the Windows NT family, and if it is // Windows NT 4 or a later version. // Returns: // true if the OS is of the Windows NT family, and is Windows NT // 4 or a later version, otherwise returns false. //----------------------------------------------------------------------- bool IsWinNT4OrGreater() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is of the Windows NT family, and if it is // Windows 2000 or a later version. // Returns: // true if the OS is of the Windows NT family, and is Windows // 2000 or a later version, otherwise returns false. //----------------------------------------------------------------------- bool IsWin2KOrGreater() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is of the Windows NT family, and if it is // Windows XP or a later version. // Returns: // true if the OS is of the Windows NT family, and is Windows XP // or a later version, otherwise returns false. //----------------------------------------------------------------------- bool IsWinXPOrGreater() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is of the Windows NT family, and if it is // Windows Vista or a later version. // Returns: // true if the OS is of the Windows NT family, and is Windows Vista // or a later version, otherwise returns false. //----------------------------------------------------------------------- bool IsWinVistaOrGreater() const; //----------------------------------------------------------------------- // Summary: // Call this member function to check whether or not the // operating system is of the Windows NT family, and if it is // Windows 7 or a later version. // Returns: // true if the OS is of the Windows NT family, and is Windows 7 // or a later version, otherwise returns false. //----------------------------------------------------------------------- bool IsWin7OrGreater() const; public: //----------------------------------------------------------------------- // Summary: // Use this member function to return the version number of the // comctl32.dll. The high-order word of the return // value represents the major version number and the low-order // word of the returned value represents the minor version number. // Returns: // A DWORD value if successful, otherwise 0L. //----------------------------------------------------------------------- DWORD GetComCtlVersion() const; public: //----------------------------------------------------------------------- // Summary: // Determines if right-to-left (RTL) formatting is supported by current OS // Returns: // TRUE if right-to-left (RTL) formatting is supported. //----------------------------------------------------------------------- BOOL IsLayoutRTLSupported() const; //----------------------------------------------------------------------- // Summary: // Determines if ClearType text is supported by current OS //----------------------------------------------------------------------- BOOL IsClearTypeTextQualitySupported() const; //----------------------------------------------------------------------- // Summary: // Determines if MBCS is enabled //----------------------------------------------------------------------- int GetMaxCharSize() const; private: //----------------------------------------------------------------------- // Summary: // Checks to see if the OS is greater or equal to the specified // version number // Returns: // true if the OS is greater than or equal to the specified // version. //----------------------------------------------------------------------- bool GreaterThanEqualTo(const DWORD maj, const DWORD min) const; //----------------------------------------------------------------------- // Summary: // Checks to see if the OS is equal to the specified version // number // Returns: // true if the OS is equal to the specified version. //----------------------------------------------------------------------- bool EqualTo(const DWORD maj, const DWORD min) const; private: friend _XTP_EXT_CLASS CXTPSystemVersion* AFXAPI XTPSystemVersion(); }; // Depricated #define XTOSVersionInfo XTPSystemVersion //=========================================================================== // CXTPModuleHandle class is helper for LoadLibray/GetModuleHandle methods //=========================================================================== class _XTP_EXT_CLASS CXTPModuleHandle { public: //----------------------------------------------------------------------- // Module state //----------------------------------------------------------------------- enum XTPModuleState { xtpModNone, // Indicates no module found. xtpModMapped, // Indicates the module handle was set using GetModuleHandle xtpModLoaded // Indicates the module handle was set using LoadLibrary. }; public: //----------------------------------------------------------------------- // Summary: // Constructs a CXTPModuleHandle object. //----------------------------------------------------------------------- CXTPModuleHandle(); //----------------------------------------------------------------------- // Summary: // Constructs a CXTPModuleHandle object. // Parameters: // lpszModuleName - Pointer to a null-terminated string that names // the .DLL file. The name specified is the // filename of the module and is not related to the // name stored in the library module itself, as // specified by the LIBRARY keyword in the module- // definition (.DEF) file. // If the string specifies a path but the file does // not exist in the specified directory, the // function fails. When specifying a path, be sure // to use backslashes (\), not forward slashes (/). //----------------------------------------------------------------------- CXTPModuleHandle(LPCTSTR lpszModuleName); //----------------------------------------------------------------------- // Summary: // Destroys a CXTPModuleHandle object, handles cleanup and deallocation //----------------------------------------------------------------------- virtual ~CXTPModuleHandle(); //----------------------------------------------------------------------- // Summary: // Call this method to LoadLibrary //----------------------------------------------------------------------- BOOL Init(LPCTSTR lpszModuleName); //----------------------------------------------------------------------- // Summary: // This member function is called to load the library specified // by 'lpszModule'. Once the library is loaded, you can // retrieve the instance handle by using the HINSTANCE operator. // Parameters: // lpszModuleName - Pointer to a null-terminated string that names // the .DLL file. The name specified is the // filename of the module and is not related to the // name stored in the library module itself, as // specified by the LIBRARY keyword in the module- // definition (.DEF) file. // If the string specifies a path but the file does // not exist in the specified directory, the // function fails. When specifying a path, be sure // to use backslashes (\), not forward slashes (/). //----------------------------------------------------------------------- BOOL LoadLibrary(LPCTSTR lpszModuleName); //----------------------------------------------------------------------- // Summary: // The GetModuleHandle function retrieves a module handle for the specified module // if the file has been mapped into the address space of the calling process. // Parameters: // lpModuleName - Pointer to a null-terminated string that contains the name // of the module (either a .dll or .exe file). //----------------------------------------------------------------------- BOOL GetModuleHandle(LPCTSTR lpszModuleName); //----------------------------------------------------------------------- // Summary: // The FreeLibrary function decrements the reference count of the loaded // dynamic-link library (DLL). //----------------------------------------------------------------------- BOOL FreeLibrary(); //----------------------------------------------------------------------- // Summary: // The GetProcAddress function retrieves the address of the specified // exported dynamic-link library (DLL) function. //----------------------------------------------------------------------- BOOL GetProcAddress(FARPROC* ppFnPtr, LPCSTR lpProcName, DWORD dwMinVer = NULL); //----------------------------------------------------------------------- // Summary: // Use this member function to return the version number of the // module attached to this CLoadLibrary object. The high-order // word of the return value represents the major version number // and the low-order word of the returned value represents the // minor version number. // Returns: // A DWORD value if successful, otherwise 0L. //----------------------------------------------------------------------- DWORD GetVersion(); //----------------------------------------------------------------------- // Summary: // This overloaded operator returns a handle to the module // indicating success. NULL indicates failure. // Returns: // A handle to the module if successful, otherwise returns NULL. //----------------------------------------------------------------------- operator HMODULE () const; //----------------------------------------------------------------------- // Summary: // This method returns a handle to the module // indicating success. NULL indicates failure. // Returns: // A handle to the module if successful, otherwise returns NULL. //----------------------------------------------------------------------- HMODULE GetHandle() const; //----------------------------------------------------------------------- // Summary: // Returns Path to loaded library //----------------------------------------------------------------------- CString GetName() const; //----------------------------------------------------------------------- // Summary: // Returns module state //----------------------------------------------------------------------- XTPModuleState GetModuleState() const; private: BOOL GetVersionInfo(); struct XTP_DLLVERSIONINFO { DWORD cbSize; DWORD dwMajorVersion; // Major version DWORD dwMinorVersion; // Minor version DWORD dwBuildNumber; // Build number DWORD dwPlatformID; // DLLVER_PLATFORM_* }; CString m_strModuleName; // Module path HMODULE m_hModule; // A handle to the module indicates success. XTPModuleState m_eModuleState; // Module state XTP_DLLVERSIONINFO m_dvInfo; // Version information }; AFX_INLINE HMODULE CXTPModuleHandle::GetHandle() const { return m_hModule; } AFX_INLINE CXTPModuleHandle::operator HMODULE () const { return m_hModule; } AFX_INLINE CString CXTPModuleHandle::GetName() const { return m_strModuleName; } AFX_INLINE CXTPModuleHandle::XTPModuleState CXTPModuleHandle::GetModuleState() const { return m_eModuleState; } // Obsolete name //#define CXTLoadLibrary CXTPModuleHandle //----------------------------------------------------------------------- // Summary: // MultiMonitor API wrapper class //----------------------------------------------------------------------- class _XTP_EXT_CLASS CXTPMultiMonitor { private: DECLARE_HANDLE(XTP_HMONITOR); private: struct XTP_MONITORINFO { DWORD cbSize; RECT rcMonitor; RECT rcWork; DWORD dwFlags; }; private: CXTPMultiMonitor(); public: //----------------------------------------------------------------------- // Summary: // This function retrieves work area for the display monitor that // the mouse cursor is currently positioned over. // Parameters: // rect - Reference to a CRect class that specifies the // coordinates of the rectangle of interest in virtual // screen coordinates. // pWnd - Pointer to the window of interest. // hWnd - Handle to the window of interest. // point - Point of interest. // Returns: // If the mouse cursor is positioned over a display monitor, the // return value is a CRect object that specifies the work area // rectangle of the display monitor, expressed in virtual-screen // coordinates. Otherwise, returns the size of the work area on // the primary display monitor. //----------------------------------------------------------------------- CRect GetWorkArea(); CRect GetWorkArea(const POINT& point); // CRect GetWorkArea(LPCRECT rect); // CRect GetWorkArea(const CWnd* pWnd); // CRect GetWorkArea(HWND hWnd); // CRect GetScreenArea(const CWnd* pWnd); // CRect GetScreenArea(HWND hWnd); // CRect GetScreenArea(const POINT& point); // CRect GetScreenArea(LPCRECT rect); // private: BOOL GetMonitorInfo(XTP_HMONITOR hMonitor, XTP_MONITORINFO* lpMonitorInfo); CRect GetWorkArea(XTP_HMONITOR hMonitor); CRect GetScreenArea(XTP_HMONITOR hMonitor); int (WINAPI* m_pfnGetSystemMetrics)(int); XTP_HMONITOR (WINAPI* m_pfnMonitorFromWindow)(HWND, DWORD); XTP_HMONITOR (WINAPI* m_pfnMonitorFromRect)(LPCRECT, DWORD); XTP_HMONITOR (WINAPI* m_pfnMonitorFromPoint)(POINT, DWORD); BOOL (WINAPI* m_pfnGetMonitorInfo)(XTP_HMONITOR, XTP_MONITORINFO*); CXTPModuleHandle m_modUser32; friend _XTP_EXT_CLASS CXTPMultiMonitor* AFX_CDECL XTPMultiMonitor(); }; //--------------------------------------------------------------------------- // Summary: // Call this function to access CXTPMultiMonitor members. // Since this class is designed as a single instance object you can // only access its members through this method. You cannot // directly instantiate an object of type CXTPMultiMonitor. // Example: // CRect rcWork = XTPMultiMonitor()->GetWorkArea(); //--------------------------------------------------------------------------- _XTP_EXT_CLASS CXTPMultiMonitor* AFX_CDECL XTPMultiMonitor(); //=========================================================================== // Summary: Critical Section Wrapper //=========================================================================== class _XTP_EXT_CLASS CXTPCriticalSection { public: //----------------------------------------------------------------------- // Summary: // Constructs a CXTPCriticalSection object //----------------------------------------------------------------------- CXTPCriticalSection(); //------------------------------------------------------------------------- // Summary: // Destroys a CXTPCriticalSection object, handles cleanup and deallocation //------------------------------------------------------------------------- ~CXTPCriticalSection(); public: //------------------------------------------------------------------------- // Summary: // The EnterCriticalSection function waits for ownership of the // specified critical section object //------------------------------------------------------------------------- void EnterCritical(); //------------------------------------------------------------------------- // Summary: // The LeaveCriticalSection function releases ownership of the // specified critical section object //------------------------------------------------------------------------- void LeaveCritical(); //------------------------------------------------------------------------- // Summary: // Returns CRITICAL_SECTION reference //------------------------------------------------------------------------- operator CRITICAL_SECTION& () { return m_csMutex; } private: CRITICAL_SECTION m_csMutex; }; //=========================================================================== // Summary: Critical Sections Lock/Unlock helper //=========================================================================== class _XTP_EXT_CLASS CXTPLockGuard { public: //----------------------------------------------------------------------- // Summary: // Constructs a CXTPLockGuard object // Parameters: // key - CRITICAL_SECTION used to lock thread //----------------------------------------------------------------------- CXTPLockGuard(CRITICAL_SECTION& key); //------------------------------------------------------------------------- // Summary: // Destroys a CXTPCriticalSection object, handles cleanup and deallocation //------------------------------------------------------------------------- ~CXTPLockGuard(); public: //------------------------------------------------------------------------- // Summary: This method call EnterCritical of key object //------------------------------------------------------------------------- void LockThread(); //------------------------------------------------------------------------- // Summary: This method call LeaveCritical of key object //------------------------------------------------------------------------- void UnLockThread(); private: DISABLE_COPY_OPERATOR(CXTPLockGuard) private: CRITICAL_SECTION& m_key; }; //{{AFX_CODEJOCK_PRIVATE #ifndef CHILDID_SELF #define CHILDID_SELF 0 #endif #ifndef WM_GETOBJECT #define WM_GETOBJECT 0x003D #endif #ifndef EVENT_OBJECT_FOCUS #define EVENT_OBJECT_FOCUS 0x8005 #endif #ifndef OBJID_MENU #define OBJID_MENU 0xFFFFFFFD #endif #ifndef OBJID_CLIENT #define OBJID_CLIENT 0xFFFFFFFC #endif #ifndef OBJID_WINDOW #define OBJID_WINDOW 0x00000000 #endif class _XTP_EXT_CLASS CXTPAccessible { public: CXTPAccessible(); virtual ~CXTPAccessible(); public: virtual HRESULT GetAccessibleParent(IDispatch** ppdispParent); virtual HRESULT GetAccessibleChildCount(long* pcountChildren); virtual HRESULT GetAccessibleChild(VARIANT varChild, IDispatch** ppdispChild); virtual HRESULT GetAccessibleName(VARIANT varChild, BSTR* pszName); virtual HRESULT GetAccessibleValue(VARIANT varChild, BSTR* pszValue); virtual HRESULT GetAccessibleDescription(VARIANT varChild, BSTR* pszDescription); virtual HRESULT GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole); virtual HRESULT GetAccessibleState(VARIANT varChild, VARIANT* pvarState); virtual HRESULT GetAccessibleHelp(VARIANT varChild, BSTR* pszHelp); virtual HRESULT GetAccessibleHelpTopic(BSTR *pszHelpFile, VARIANT varChild, long* pidTopic); virtual HRESULT GetAccessibleKeyboardShortcut(VARIANT varChild, BSTR* pszKeyboardShortcut); virtual HRESULT GetAccessibleFocus(VARIANT* pvarChild); virtual HRESULT GetAccessibleSelection(VARIANT* pvarChildren); virtual HRESULT GetAccessibleDefaultAction(VARIANT varChild, BSTR* pszDefaultAction); virtual HRESULT AccessibleSelect(long flagsSelect, VARIANT varChild); virtual HRESULT AccessibleLocation(long *pxLeft, long *pyTop, long *pcxWidth, long* pcyHeight, VARIANT varChild); virtual HRESULT AccessibleNavigate(long navDir, VARIANT varStart, VARIANT* pvarEndUpAt); virtual HRESULT AccessibleHitTest(long xLeft, long yTop, VARIANT* pvarChild); virtual HRESULT AccessibleDoDefaultAction(VARIANT varChild); //Obsolete virtual HRESULT PutAccessibleName(VARIANT varChild, BSTR szName); //Obsolete virtual HRESULT PutAccessibleValue(VARIANT varChild, BSTR szValue); virtual CCmdTarget* GetAccessible(); void AccessibleNotifyWinEvent(DWORD event, HWND hwnd, LONG idObject, LONG idChild); protected: HRESULT AccessibleObjectFromWindow(HWND hwnd, DWORD dwId, REFIID riid, void** ppvObject); LRESULT LresultFromObject(REFIID riid, WPARAM wParam, LPUNKNOWN punk); long GetChildIndex(VARIANT* varChild); public: BEGIN_INTERFACE_PART(Accessible, IAccessible) STDMETHOD(GetTypeInfoCount)(UINT FAR* pctinfo); STDMETHOD(GetTypeInfo)(UINT itinfo, LCID lcid, ITypeInfo FAR* FAR* pptinfo); STDMETHOD(GetIDsOfNames)(REFIID riid, OLECHAR FAR* FAR* rgszNames, UINT cNames, LCID lcid, DISPID FAR* rgdispid); STDMETHOD(Invoke)(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR* pdispparams, VARIANT FAR* pvarResult, EXCEPINFO FAR* pexcepinfo, UINT FAR* puArgErr); STDMETHOD(get_accParent)(IDispatch* FAR* ppdispParent); STDMETHOD(get_accChildCount)(long FAR* pChildCount); STDMETHOD(get_accChild)(VARIANT varChildIndex, IDispatch* FAR* ppdispChild); STDMETHOD(get_accName)(VARIANT varChild, BSTR* pszName); STDMETHOD(get_accValue)(VARIANT varChild, BSTR* pszValue); STDMETHOD(get_accDescription)(VARIANT varChild, BSTR FAR* pszDescription); STDMETHOD(get_accRole)(VARIANT varChild, VARIANT* pvarRole); STDMETHOD(get_accState)(VARIANT varChild, VARIANT* pvarState); STDMETHOD(get_accHelp)(VARIANT varChild, BSTR* pszHelp); STDMETHOD(get_accHelpTopic)(BSTR* pszHelpFile, VARIANT varChild, long* pidTopic); STDMETHOD(get_accKeyboardShortcut)(VARIANT varChild, BSTR* pszKeyboardShortcut); STDMETHOD(get_accFocus)(VARIANT FAR* pvarFocusChild); STDMETHOD(get_accSelection)(VARIANT FAR* pvarSelectedChildren); STDMETHOD(get_accDefaultAction)(VARIANT varChild, BSTR* pszDefaultAction); STDMETHOD(accSelect)(long flagsSelect, VARIANT varChild); STDMETHOD(accLocation)(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild); STDMETHOD(accNavigate)(long navDir, VARIANT varStart, VARIANT* pvarEndUpAt); STDMETHOD(accHitTest)(long xLeft, long yTop, VARIANT* pvarChildAtPoint); STDMETHOD(accDoDefaultAction)(VARIANT varChild); STDMETHOD(put_accName)(VARIANT varChild, BSTR szName); STDMETHOD(put_accValue)(VARIANT varChild, BSTR pszValue); END_INTERFACE_PART(ExternalAccessible) private: typedef VOID (WINAPI* LPFNNOTIFYWINEVENT)(DWORD event, HWND hwnd, LONG idObject, LONG idChild); LPFNNOTIFYWINEVENT m_pNotifyWinEvent; LPFNLRESULTFROMOBJECT m_pLresultFromObject; LPFNACCESSIBLEOBJECTFROMWINDOW m_pAccessibleObjectFromWindow; HMODULE m_hUser32; HMODULE m_hOleAcc; }; //}}AFX_CODEJOCK_PRIVATE //----------------------------------------------------------------------- // Summary: // Enumeration used to play system sound. // Example: // XTPSoundManager()->PlaySystemSound(xtpSoundMenuCommand); // See Also: CXTPSoundManager // // //----------------------------------------------------------------------- enum XTPSoundManagerState { xtpSoundNone, // No Sound (default) xtpSoundMenuCommand, // Menu command system sound xtpSoundMenuPopup, // Menu popup system sound }; //=========================================================================== // Summary: // CXTPSoundManager is standalone class. It used to play system sound. // See Also: XTPSoundManagerState, XTPSoundManager //=========================================================================== class _XTP_EXT_CLASS CXTPSoundManager { friend _XTP_EXT_CLASS CXTPSoundManager* AFX_CDECL XTPSoundManager(); //------------------------------------------------------------------------- // Summary: // Constructs a CXTPSoundManager object. //------------------------------------------------------------------------- CXTPSoundManager(); public: //------------------------------------------------------------------------- // Summary: // Destroys a CXTPSoundManager object, handles cleanup and deallocation //------------------------------------------------------------------------- ~CXTPSoundManager(); //----------------------------------------------------------------------- // Summary: // Call this method to play system sound // Parameters: // state - System sound to play. Can be any of the values listed in // the remarks section. // Remarks: // State parameter can be one of the following: // * xtpSoundMenuCommand Play menu command system sound // * xtpSoundMenuPopup Play menu popup system sound //----------------------------------------------------------------------- void PlaySystemSound(XTPSoundManagerState state); //----------------------------------------------------------------------- // Summary: // Call this method to disable all system sounds for application // Parameters: // bEnable - FALSE to disable system sounds. // Remarks: // Call this method to force system settings and disable all sounds. //----------------------------------------------------------------------- void EnableSystemSounds(BOOL bEnable); //------------------------------------------------------------------------- // Summary: // This method is called to stop all sounds and terminate sound thread. //------------------------------------------------------------------------- void StopThread(); private: void StartThread(); static DWORD WINAPI SoundThreadProc(LPVOID); public: BOOL m_bSoundAvailable; // FALSE to disable sound. you can use "m_bSoundAvailable = waveOutGetNumDevs()" private: XTPSoundManagerState m_soundState; BOOL m_bSystemSounds; HANDLE m_hThread; BOOL m_bTerminate; HANDLE m_hEvent; }; //--------------------------------------------------------------------------- // Summary: // Call this function to access CXTPSoundManager members. // Since this class is designed as a single instance object you can // only access version info through this method. You cannot // directly instantiate an object of type CXTPSoundManager. // Example: // XTPSoundManager()->PlaySystemSound(xtpSoundMenuCommand); //--------------------------------------------------------------------------- _XTP_EXT_CLASS CXTPSoundManager* AFX_CDECL XTPSoundManager(); //--------------------------------------------------------------------------- // Summary: // Zipped memory file //--------------------------------------------------------------------------- class _XTP_EXT_CLASS CXTPZipMemFile : public CMemFile { struct ZIPBUFFERHEADER { DWORD dwType; DWORD dwSize; }; struct ZIPBUFFERINFO { ZIPBUFFERHEADER bh; BYTE bBuffer[1]; }; public: CXTPZipMemFile(); CXTPZipMemFile(BYTE* lpBuffer, UINT nBufferSize); ~CXTPZipMemFile(); public: void AttachCompressedBuffer(BYTE* lpBuffer, UINT nBufferSize, BOOL bAutoDelete = FALSE); void DetachCompressedBuffer(BYTE*& lpBuffer, DWORD& dwCount); BOOL OpenCompressedFile(LPCTSTR lpszFileName); public: }; _XTP_EXT_CLASS CWinThread* AFX_CDECL XTPGetThread(); #endif // !defined(__XTPMANAGESTATE_H__)