6870 lines
216 KiB
C++
6870 lines
216 KiB
C++
/*************************************************************************/
|
|
/* Copyright (C) 1999 Microsoft Corporation */
|
|
/* File: MFBar.cpp */
|
|
/* Description: Control that is scriptable and contains other controls. */
|
|
/* Designed specifically for DVD/TV control plates. */
|
|
/* Author: David Janecek */
|
|
/*************************************************************************/
|
|
#include "stdafx.h"
|
|
#include "MFBar.h"
|
|
#include "ccobj.h"
|
|
#include "eobj.h"
|
|
#include "CBitmap.h"
|
|
#include "HtmlHelp.h"
|
|
|
|
/*************************************************************************/
|
|
/* Local defines */
|
|
/* Could not find these under windows headers, so if there is a conflict */
|
|
/* it is good idea to ifdef these out. */
|
|
/*************************************************************************/
|
|
#define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
|
|
#define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))
|
|
#define RECTWIDTH(lpRect) ((lpRect)->right - (lpRect)->left)
|
|
#define RECTHEIGHT(lpRect) ((lpRect)->bottom - (lpRect)->top)
|
|
#define ID_EV_TIMER 0xff
|
|
#define VK_LEFT 0x25
|
|
#define VK_UP 0x26
|
|
#define VK_RIGHT 0x27
|
|
#define VK_DOWN 0x28
|
|
#define VK_SELECT 0x29
|
|
#define VK_SPACE 0x20
|
|
#define VK_RETURN 0x0D
|
|
#define SYS_MOVE_SIZE 8
|
|
#define SYS_TITLEBAR_WIDTH 25
|
|
|
|
/*************************************************************************/
|
|
/* Windows defines not present, remove when doing the real BUILD. */
|
|
/*************************************************************************/
|
|
typedef WINUSERAPI BOOL ( WINAPI * SETLAYEREDWINDATR)(
|
|
HWND hwnd,
|
|
COLORREF crKey,
|
|
BYTE bAlpha,
|
|
DWORD dwFlags);
|
|
#if 0
|
|
#define LWA_COLORKEY 0x00000001
|
|
#endif
|
|
/*************************************************************************/
|
|
/* Local functions */
|
|
/*************************************************************************/
|
|
inline long MAX(long l1, long l2){return(l1 > l2 ? l1 : l2);}
|
|
inline long MIN(long l1, long l2){return(l1 < l2 ? l1 : l2);}
|
|
|
|
/*************************************************************************/
|
|
/* Statics for window class info */
|
|
/*************************************************************************/
|
|
HICON CMFBar::m_hIcon = NULL;
|
|
#if 0
|
|
HICON CMFBar::m_hIconSmall = NULL;
|
|
#endif
|
|
|
|
/*****************************************************************/
|
|
/* change this depending if the file was saved as Unicode or not */
|
|
/*****************************************************************/
|
|
#define _UNICODE_SCRIPT_FILE
|
|
//#define _UNICODE_TEST_SCRIPT_FILE
|
|
|
|
#if WINVER < 0x0500
|
|
#define MNS_NOCHECK 0x80000000
|
|
#define MNS_MODELESS 0x40000000
|
|
#define MNS_DRAGDROP 0x20000000
|
|
#define MNS_AUTODISMISS 0x10000000
|
|
#define MNS_NOTIFYBYPOS 0x08000000
|
|
#define MNS_CHECKORBMP 0x04000000
|
|
|
|
#define MIM_MAXHEIGHT 0x00000001
|
|
#define MIM_BACKGROUND 0x00000002
|
|
#define MIM_HELPID 0x00000004
|
|
#define MIM_MENUDATA 0x00000008
|
|
#define MIM_STYLE 0x00000010
|
|
#define MIM_APPLYTOSUBMENUS 0x80000000
|
|
|
|
typedef struct tagMENUINFO
|
|
{
|
|
DWORD cbSize;
|
|
DWORD fMask;
|
|
DWORD dwStyle;
|
|
UINT cyMax;
|
|
HBRUSH hbrBack;
|
|
DWORD dwContextHelpID;
|
|
ULONG_PTR dwMenuData;
|
|
} MENUINFO, FAR *LPMENUINFO;
|
|
typedef MENUINFO CONST FAR *LPCMENUINFO;
|
|
|
|
static BOOL (WINAPI *pfnGetMenuInfo)(HMENU, LPMENUINFO);
|
|
static BOOL (WINAPI *pfnSetMenuInfo)(HMENU, LPCMENUINFO);
|
|
typedef BOOL (WINAPI *PFNGETMENUINFOHANDLE)(HMENU, LPMENUINFO);
|
|
typedef BOOL (WINAPI *PFNSETMENUINFOHANDLE)(HMENU, LPCMENUINFO);
|
|
|
|
HRESULT CallGetMenuInfo(HMENU hMenu, LPMENUINFO pmInfo)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
HINSTANCE hinstDll = ::LoadLibrary(TEXT("USER32.DLL"));
|
|
|
|
if (hinstDll)
|
|
{
|
|
pfnGetMenuInfo = (PFNGETMENUINFOHANDLE)GetProcAddress(hinstDll, "GetMenuInfo");
|
|
|
|
if (pfnGetMenuInfo)
|
|
{
|
|
hr = pfnGetMenuInfo(hMenu, pmInfo);
|
|
}
|
|
|
|
FreeLibrary(hinstDll);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CallSetMenuInfo(HMENU hMenu, LPCMENUINFO pmInfo)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
HINSTANCE hinstDll = ::LoadLibrary(TEXT("USER32.DLL"));
|
|
|
|
if (hinstDll)
|
|
{
|
|
pfnSetMenuInfo = (PFNSETMENUINFOHANDLE)GetProcAddress(hinstDll, "SetMenuInfo");
|
|
|
|
if (pfnSetMenuInfo)
|
|
{
|
|
hr = pfnSetMenuInfo(hMenu, pmInfo);
|
|
}
|
|
|
|
FreeLibrary(hinstDll);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
#define MIIM_STRING 0x00000040
|
|
#define MIIM_BITMAP 0x00000080
|
|
#define MIIM_FTYPE 0x00000100
|
|
#define HBMMENU_POPUP_CLOSE ((HBITMAP) 8)
|
|
#define HBMMENU_POPUP_RESTORE ((HBITMAP) 9)
|
|
#define HBMMENU_POPUP_MAXIMIZE ((HBITMAP) 10)
|
|
#define HBMMENU_POPUP_MINIMIZE ((HBITMAP) 11)
|
|
|
|
typedef struct tagMENUITEMINFOAInternal
|
|
{
|
|
UINT cbSize;
|
|
UINT fMask;
|
|
UINT fType; // used if MIIM_TYPE (4.0) or MIIM_FTYPE (>4.0)
|
|
UINT fState; // used if MIIM_STATE
|
|
UINT wID; // used if MIIM_ID
|
|
HMENU hSubMenu; // used if MIIM_SUBMENU
|
|
HBITMAP hbmpChecked; // used if MIIM_CHECKMARKS
|
|
HBITMAP hbmpUnchecked; // used if MIIM_CHECKMARKS
|
|
ULONG_PTR dwItemData; // used if MIIM_DATA
|
|
LPSTR dwTypeData; // used if MIIM_TYPE (4.0) or MIIM_STRING (>4.0)
|
|
UINT cch; // used if MIIM_TYPE (4.0) or MIIM_STRING (>4.0)
|
|
HBITMAP hbmpItem; // used if MIIM_BITMAP
|
|
} MENUITEMINFOAInternal, FAR *LPMENUITEMINFOAInternal;
|
|
typedef struct tagMENUITEMINFOWInternal
|
|
{
|
|
UINT cbSize;
|
|
UINT fMask;
|
|
UINT fType; // used if MIIM_TYPE (4.0) or MIIM_FTYPE (>4.0)
|
|
UINT fState; // used if MIIM_STATE
|
|
UINT wID; // used if MIIM_ID
|
|
HMENU hSubMenu; // used if MIIM_SUBMENU
|
|
HBITMAP hbmpChecked; // used if MIIM_CHECKMARKS
|
|
HBITMAP hbmpUnchecked; // used if MIIM_CHECKMARKS
|
|
ULONG_PTR dwItemData; // used if MIIM_DATA
|
|
LPWSTR dwTypeData; // used if MIIM_TYPE (4.0) or MIIM_STRING (>4.0)
|
|
UINT cch; // used if MIIM_TYPE (4.0) or MIIM_STRING (>4.0)
|
|
HBITMAP hbmpItem; // used if MIIM_BITMAP
|
|
} MENUITEMINFOWInternal, FAR *LPMENUITEMINFOWInternal;
|
|
|
|
#ifdef UNICODE
|
|
typedef MENUITEMINFOWInternal MENUITEMINFOInternal;
|
|
typedef LPMENUITEMINFOWInternal LPMENUITEMINFOInternal;
|
|
#else
|
|
typedef MENUITEMINFOAInternal MENUITEMINFOInternal;
|
|
typedef LPMENUITEMINFOAInternal LPMENUITEMINFOInternal;
|
|
#endif // UNICODE
|
|
|
|
typedef MENUITEMINFOAInternal CONST FAR *LPCMENUITEMINFOAInternal;
|
|
typedef MENUITEMINFOWInternal CONST FAR *LPCMENUITEMINFOWInternal;
|
|
|
|
#ifdef UNICODE
|
|
typedef LPCMENUITEMINFOWInternal LPCMENUITEMINFOInternal;
|
|
#else
|
|
typedef LPCMENUITEMINFOAInternal LPCMENUITEMINFOInternal;
|
|
#endif // UNICODE
|
|
#endif /* WINVER < 0x0500 */
|
|
|
|
|
|
/*************************************************************************/
|
|
/* CMFBar Implementation */
|
|
/*************************************************************************/
|
|
|
|
/*************************************************************************/
|
|
/* Function: Init */
|
|
/* Description: Initializes memeber variables. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::Init(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
// #### BEGIN CONTAINER SUPPORT ####
|
|
m_bCanWindowlessActivate = true;
|
|
// #### END CONTAINER SUPPORT ####
|
|
|
|
#if 1 // used for getting the windowed case working DJ
|
|
m_bWindowOnly = TRUE;
|
|
#endif
|
|
m_fSelfHosted = false;
|
|
|
|
// TODO: Investigate if it works in pallete mode
|
|
m_clrBackColor = ::GetSysColor(COLOR_BTNFACE);
|
|
m_lMinWidth = -1; // disable it
|
|
m_lMinHeight = -1; // disable it by default
|
|
m_fHandleHelp = false;
|
|
m_blitType = DISABLE;
|
|
m_bMouseDown = false;
|
|
|
|
m_nReadyState = READYSTATE_LOADING;
|
|
m_fAutoLoad = VARIANT_TRUE;
|
|
m_pBackBitmap = NULL;
|
|
m_fForceKey = false;
|
|
m_lTimeout = 0;
|
|
m_fUserActivity = false;
|
|
m_fWaitingForActivity = false;
|
|
|
|
// setup the default resource DLL to be this binary
|
|
m_hRes = _Module.m_hInstResource; // set the resource DLL Name
|
|
TCHAR szModule[_MAX_PATH+10];
|
|
::GetModuleFileName(m_hRes, szModule, _MAX_PATH);
|
|
|
|
USES_CONVERSION;
|
|
m_strResDLL = T2OLE(szModule);
|
|
|
|
if(NULL == m_hIcon){
|
|
|
|
m_hIcon = ::LoadIcon(m_hRes, MAKEINTRESOURCE(IDI_ICON1));
|
|
}/* end of if statement */
|
|
#if 0
|
|
if(NULL == m_hIconSmall){
|
|
|
|
m_hIconSmall = (HICON)::LoadImage(m_hRes, MAKEINTRESOURCE(IDI_ICON1), IMAGE_ICON,
|
|
::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR);
|
|
}/* end of if statement */
|
|
#endif
|
|
m_HitRegion = NOHIT; // Initialize the hit region
|
|
|
|
m_hMenu = NULL;
|
|
m_bSysMenuOn = FALSE;
|
|
m_bHandleEnter = FALSE;
|
|
m_hCursor = NULL;
|
|
m_hinstHelpDll = NULL;
|
|
|
|
::ZeroMemory(&m_rcWnd, sizeof(RECT));
|
|
::ZeroMemory(&m_rcWndOld, sizeof(RECT));
|
|
::ZeroMemory(&m_ptMouse, sizeof(POINT));
|
|
::ZeroMemory(&m_ptMouseOld, sizeof(POINT));
|
|
|
|
m_bHandleUserFocus = TRUE;
|
|
|
|
return(hr);
|
|
}/* end of function Init */
|
|
|
|
/*************************************************************************/
|
|
/* Function: Cleanup */
|
|
/* Description: Makes sure the script engine is released. Also cleans */
|
|
/* up the contained objects in the containers. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::Cleanup(){
|
|
|
|
// Release the language engine, since it may hold on to us
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
if (m_psp){
|
|
|
|
m_psp.Release();
|
|
}/* end of if statement */
|
|
|
|
if (m_ps){
|
|
|
|
m_ps->Close();
|
|
m_ps.Release();
|
|
}/* end of if statement */
|
|
|
|
// Reset the Active Object
|
|
m_spActiveObject.Release();
|
|
|
|
// cleanup the event list
|
|
for(CNTEVNT::iterator i = m_cntEvnt.begin(); false == m_cntEvnt.empty(); ){
|
|
|
|
CEventObject* pObj = (*i);
|
|
delete pObj;
|
|
i = m_cntEvnt.erase(i);
|
|
}/* end of if statement */
|
|
|
|
CHostedObject* pSelfObj = NULL;
|
|
CContainerObject* pSelfContainer = NULL;
|
|
|
|
// cleanup the object list
|
|
for(CNTOBJ::iterator j = m_cntObj.begin(); false == m_cntObj.empty(); ){
|
|
|
|
CHostedObject* pObj = (*j);
|
|
CContainerObject* pContainerObj;
|
|
HRESULT hrCont = pObj->GetContainerObject(&pContainerObj);
|
|
|
|
#ifdef _DEBUG
|
|
CComBSTR strOBJID = pObj->GetID();
|
|
#endif
|
|
|
|
#if 1
|
|
if(pObj->GetUnknown() != GetUnknown()){
|
|
|
|
try {
|
|
|
|
delete pObj; // do not delete our self at the moment
|
|
}
|
|
catch(...){
|
|
#if _DEBUG
|
|
USES_CONVERSION;
|
|
ATLTRACE(TEXT(" Failed to destroy %s "), OLE2T(strOBJID));
|
|
#endif
|
|
}/* end of catch statement */
|
|
}
|
|
else {
|
|
|
|
pSelfObj = pObj;
|
|
}/* end of if statement */
|
|
#endif
|
|
|
|
|
|
#if 1
|
|
if(pObj->GetUnknown() != GetUnknown()){
|
|
|
|
try {
|
|
|
|
delete pContainerObj; // do not delete our self at the moment
|
|
}
|
|
catch(...){
|
|
#if _DEBUG
|
|
USES_CONVERSION;
|
|
ATLTRACE(TEXT(" Failed to destroy wrapper for %s "), OLE2T(strOBJID));
|
|
#endif
|
|
}/* end of catch statement */
|
|
}
|
|
else {
|
|
|
|
pSelfContainer = pContainerObj;
|
|
}/* end of if statement */
|
|
#endif
|
|
|
|
j = m_cntObj.erase(j);
|
|
}/* end of if statement */
|
|
|
|
ResetFocusArray();
|
|
|
|
try {
|
|
|
|
delete pSelfObj;
|
|
delete pSelfContainer;
|
|
}
|
|
catch(...){
|
|
|
|
ATLTRACE(TEXT(" The container failed to destroy it self properly"));
|
|
}/* end of if statemnent */
|
|
|
|
if(m_pBackBitmap){
|
|
|
|
delete m_pBackBitmap;
|
|
m_pBackBitmap = NULL;
|
|
}/* end of if statement */
|
|
|
|
CBitmap::FinalRelease(); // cleanup the mosaic if present
|
|
|
|
if (m_hMenu) {
|
|
::DestroyMenu(m_hMenu);
|
|
m_hMenu = NULL;
|
|
}
|
|
|
|
if (m_hCursor) {
|
|
::DestroyCursor(m_hCursor);
|
|
m_hCursor = NULL;
|
|
}
|
|
|
|
hr = Init();
|
|
|
|
if (m_hIcon) {
|
|
::DestroyIcon(m_hIcon);
|
|
m_hIcon = NULL;
|
|
}/* end of if statement */
|
|
|
|
#if 0
|
|
if (m_hIconSmall) {
|
|
::DestroyIcon(m_hIconSmall);
|
|
m_hIconSmall = NULL;
|
|
}/* end of if statement */
|
|
#endif
|
|
if(m_hinstHelpDll){
|
|
|
|
::FreeLibrary(m_hinstHelpDll);
|
|
}/* end of if statement */
|
|
|
|
}
|
|
catch(...){
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
|
|
return (hr);
|
|
}/* end of function Cleanup */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ~CMFBar */
|
|
/*************************************************************************/
|
|
CMFBar::~CMFBar(){
|
|
|
|
Cleanup();
|
|
ATLTRACE(TEXT("Exiting CMFBar destructor! \n"));
|
|
}/* end of function ~CMFBar */
|
|
|
|
/*************************************************************************/
|
|
/* Message handling. */
|
|
/*************************************************************************/
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnPaint */
|
|
/* Description: Had to overwrite the the deafult OnPaint so I could */
|
|
/* somehow get the real update rects. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnPaint(UINT /* uMsg */, WPARAM wParam,
|
|
LPARAM /* lParam */, BOOL& /* lResult */){
|
|
|
|
RECT rc;
|
|
PAINTSTRUCT ps;
|
|
|
|
HDC hdc = (wParam != NULL) ? (HDC)wParam : ::BeginPaint(m_hWndCD, &ps);
|
|
if (hdc == NULL)
|
|
return 0;
|
|
::GetClientRect(m_hWndCD, &rc);
|
|
|
|
ATL_DRAWINFO di;
|
|
memset(&di, 0, sizeof(di));
|
|
di.cbSize = sizeof(di);
|
|
di.dwDrawAspect = DVASPECT_CONTENT;
|
|
di.lindex = -1;
|
|
di.hdcDraw = hdc;
|
|
// DJ change here, keep the real update rect from the PAINTSTRUCT
|
|
// Set the window size to the size of the window
|
|
di.prcWBounds = (LPCRECTL)&rc;
|
|
di.prcBounds = (LPCRECTL)&ps.rcPaint;
|
|
|
|
OnDrawAdvanced(di); // Eventually propagates to OnDraw
|
|
if (wParam == NULL)
|
|
::EndPaint(m_hWndCD, &ps);
|
|
return 0;
|
|
}/* end of function OnPaint */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnDraw */
|
|
/* Description: Just Draws the rectangular background and contained */
|
|
/* windowless controls. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::OnDraw(ATL_DRAWINFO& di){
|
|
|
|
try {
|
|
HDC hdc = di.hdcDraw;
|
|
|
|
RECT rcClient = *(RECT*)di.prcBounds;
|
|
RECT rcWClient = *(RECT*)di.prcWBounds;
|
|
|
|
// this might not work if you overlapp the controls
|
|
// controls like to be painted as a whole so if
|
|
// we need to update the are that contains the control
|
|
// we need to find all the controls that intersect it, combine the
|
|
// rectangle and then repaint the whole region
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
if(!::EqualRect(&rcClient, &rcWClient)){
|
|
|
|
RECT rcNewClient = rcClient; // the original update are which we are enlarging
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// iterate through all the contained objects and draw them
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if((NULL != pObj) && (pObj->IsActive())){
|
|
|
|
if(pObj->IsWindowless()){
|
|
|
|
RECT rcCntrl;
|
|
pObj->GetPos(&rcCntrl); // get the position of the object
|
|
|
|
RECT rcInt;
|
|
if(!::IntersectRect(&rcInt, &rcCntrl, &rcClient)){
|
|
|
|
continue;
|
|
}
|
|
else {
|
|
// OK we need to add this control rect to our rect union
|
|
::UnionRect(&rcNewClient, &rcClient, &rcCntrl);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
rcClient = rcNewClient; // update our are with enlarged client
|
|
}/* end of if statement */
|
|
// else if the rects are the same we are updating the whole
|
|
// window so there is no point to do the calculations
|
|
}/* end of if statement */
|
|
|
|
COLORREF clr;
|
|
HPALETTE hPal = NULL;
|
|
|
|
if(m_pBackBitmap){
|
|
|
|
hPal = CBitmap::GetSuperPal();
|
|
m_pBackBitmap->SelectRelizePalette(hdc, hPal);
|
|
}/* end of if statement */
|
|
|
|
::OleTranslateColor (m_clrBackColor, hPal, &clr);
|
|
|
|
// fill in the background and get ready to fill in the objects
|
|
LONG lBmpWidth = RECTWIDTH(&rcWClient);
|
|
LONG lBmpHeight = RECTHEIGHT(&rcWClient);
|
|
|
|
HBITMAP hBitmap = ::CreateCompatibleBitmap(hdc, lBmpWidth, lBmpHeight);
|
|
|
|
if(NULL == hBitmap){
|
|
|
|
ATLASSERT(FALSE);
|
|
return(0);
|
|
}/* end of if statement */
|
|
|
|
HDC hdcCompatible = ::CreateCompatibleDC(hdc);
|
|
|
|
if(NULL == hdcCompatible){
|
|
|
|
ATLASSERT(FALSE);
|
|
::DeleteObject(hBitmap);
|
|
return(0);
|
|
}/* end of if statement */
|
|
|
|
// Draw background on the faceplate bitmap
|
|
::SelectObject(hdcCompatible, hBitmap);
|
|
|
|
if (!m_pBackBitmap){
|
|
// fill background of specific color
|
|
HBRUSH hbrBack = ::CreateSolidBrush(clr);
|
|
|
|
if(NULL == hbrBack){
|
|
|
|
ATLASSERT(FALSE);
|
|
::DeleteObject(hBitmap);
|
|
return(0);
|
|
}/* end of if statement */
|
|
|
|
//::FillRect(hdc, &rcClient, hbrBack);
|
|
::FillRect(hdcCompatible, &rcClient, hbrBack);
|
|
::DeleteObject(hbrBack);
|
|
}
|
|
else {
|
|
m_pBackBitmap->SelectRelizePalette(hdcCompatible, hPal);
|
|
|
|
//BOOL bRet = m_pBackBitmap->PaintTransparentDIB(hdc, &rcWClient, &rcClient, m_blitType, true);
|
|
BOOL bRet = m_pBackBitmap->PaintTransparentDIB(hdcCompatible, &rcWClient, &rcClient);
|
|
|
|
if(!bRet){
|
|
|
|
ATLTRACE(TEXT(" The transparent Blit did not work!"));
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// iterate through all the contained objects and draw them
|
|
CHostedObject* pObj = (*i);
|
|
|
|
CComPtr<IViewObjectEx> pViewObject = NULL;
|
|
|
|
if((NULL != pObj) && (pObj->IsActive()) && (SUCCEEDED(pObj->GetViewObject(&pViewObject)))){
|
|
|
|
if(pObj->IsWindowless()){
|
|
|
|
if(pViewObject){
|
|
|
|
if(GetUnknown() == pObj->GetUnknown()){
|
|
// in case we are windowless and we are trying to draw our self again
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
RECT rcCntrl;
|
|
pObj->GetPos(&rcCntrl);
|
|
|
|
RECT rcInt;
|
|
if(!::IntersectRect(&rcInt, &rcCntrl, &rcClient)){
|
|
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
LONG lBmpWidth = RECTWIDTH(&rcCntrl);
|
|
LONG lBmpHeight = RECTHEIGHT(&rcCntrl);
|
|
RECT rcCntrlBitmap = {0, 0, lBmpWidth, lBmpHeight};
|
|
|
|
POINT ptNewOffset = {rcCntrl.left, rcCntrl.top};
|
|
|
|
POINT ptOldOffset;
|
|
|
|
::GetViewportOrgEx(hdcCompatible, &ptOldOffset);
|
|
LPtoDP(hdcCompatible, &ptNewOffset, 1);
|
|
// offset the rect we are catually going to draw
|
|
//::OffsetRect(&rcInt, -ptNewOffset.x, -ptNewOffset.y);
|
|
// offset the DC
|
|
::OffsetViewportOrgEx(hdcCompatible, ptNewOffset.x, ptNewOffset.y, &ptOldOffset);
|
|
|
|
// draw
|
|
ATLTRACE2(atlTraceWindowing, 31, TEXT("Drawing CONTROL into rcClient.left = %d, rcClient.right = %d, rcClient.bottom =%d, rcClient.top = %d\n"),rcCntrl.left, rcCntrl.right, rcCntrl.bottom, rcCntrl.top);
|
|
#if 1 // used to redraw the whole control, now we are just doinf part of it
|
|
//HRGN hrgnOld = NULL;
|
|
//HRGN hrgnNew = NULL;
|
|
//if(::IsWindow(m_hWnd)){
|
|
//
|
|
// hrgnNew = ::CreateRectRgnIndirect(&rcInt);
|
|
// hrgnOld = (HRGN)::SelectObject(hdc, hrgnNew);
|
|
//}/* end of if statement */
|
|
|
|
pViewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcCompatible, (RECTL*)&rcCntrlBitmap, (RECTL*)&rcCntrlBitmap, NULL, NULL);
|
|
#else
|
|
pViewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcCompatible, (RECTL*)&rcInt, (RECTL*)&rcCntrlBitmap, NULL, NULL);
|
|
#endif
|
|
::SetViewportOrgEx(hdcCompatible, ptOldOffset.x, ptOldOffset.y, NULL);
|
|
}
|
|
#ifdef _DEBUG
|
|
else {
|
|
|
|
ATLTRACE2(atlTraceWindowing, 30,TEXT("FAILED Drawing the object since pView is NULL\n"));
|
|
}/* end of if statement */
|
|
#endif
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
::BitBlt(hdc, rcClient.left, rcClient.top, lBmpWidth, lBmpHeight, hdcCompatible, rcClient.left, rcClient.top, SRCCOPY);
|
|
// cleanup
|
|
::DeleteDC(hdcCompatible);
|
|
::DeleteObject(hBitmap);
|
|
|
|
return(1);
|
|
}/* end of try statement */
|
|
catch(...){
|
|
return(0);
|
|
}/* end of catch statement */
|
|
}/* end of function OnDraw */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnErase */
|
|
/* Description: Skip the erasing to avoid flickers. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnErase(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
ATLTRACE2(atlTraceWindowing, 32, TEXT("Received WM_ERASE MESSAGE \n"));
|
|
|
|
#if 0
|
|
POINT pt; pt.x =0; pt.y = 0;
|
|
::MapWindowPoints(m_hWnd, hWndPar, &pt, 1);
|
|
::OffsetWindowOrgEx(hdc, pt.x, pt.y, &pt);
|
|
::SendMessage(hWndPar, WM_ERASEBKGND, (WPARAM) hdc, 0);
|
|
::SetWindowOrgEx(hdc, pt.x, pt.y, NULL);
|
|
|
|
#endif
|
|
|
|
//InvalidateRect(&m_rcPos, FALSE);
|
|
|
|
bHandled = TRUE;
|
|
return 1;
|
|
}/* end of function OnErase */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnClose */
|
|
/* Description: Skip the erasing to avoid flickers. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnClose(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
::DestroyWindow(m_hWnd);
|
|
}/* end of if statement */
|
|
|
|
HRESULT hr = Close(OLECLOSE_SAVEIFDIRTY);
|
|
ATLTRACE(TEXT("Closing \n"));
|
|
|
|
if(SUCCEEDED(hr)){
|
|
|
|
bHandled = TRUE;
|
|
}/* end of if statement */
|
|
|
|
return 0;
|
|
}/* end of function OnClose */
|
|
|
|
/*************************************************************/
|
|
/* Name:
|
|
/* Description:
|
|
/*************************************************************/
|
|
LRESULT CMFBar::OnActivate(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled) {
|
|
|
|
switch (LOWORD(wParam)) {
|
|
case WA_ACTIVE:
|
|
case WA_CLICKACTIVE:
|
|
Fire_OnActivate(VARIANT_TRUE);
|
|
break;
|
|
case WA_INACTIVE:
|
|
Fire_OnActivate(VARIANT_FALSE);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnSysCommand */
|
|
/* Description: Handles the on syscommand. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnSysCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
ATLTRACE2(atlTraceWindowing, 20, TEXT("Received WM_SYSCOMMAND MESSAGE \n"));
|
|
LRESULT lRet = 0;
|
|
|
|
switch (wParam) {
|
|
case SC_CONTEXTHELP :
|
|
m_fHandleHelp = true;
|
|
bHandled = FALSE;
|
|
lRet = 1;
|
|
break;
|
|
|
|
case SC_RESTORE:
|
|
case SC_MOVE:
|
|
case SC_SIZE:
|
|
case SC_MINIMIZE:
|
|
case SC_MAXIMIZE:
|
|
case SC_CLOSE:
|
|
OnCommand(WM_COMMAND, wParam, lParam, bHandled);
|
|
bHandled = TRUE;
|
|
lRet = 0;
|
|
break;
|
|
|
|
default:
|
|
bHandled = FALSE;
|
|
return ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
return(lRet);
|
|
}/* end of function OnSysCommand */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnCommand */
|
|
/* Description: Handles the on command. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
ATLTRACE2(atlTraceWindowing, 20, TEXT("Received WM_COMMAND MESSAGE \n"));
|
|
LRESULT lRet = 0;
|
|
|
|
if (NULL == m_hMenu)
|
|
return lRet;
|
|
|
|
switch (LOWORD(wParam)) {
|
|
case ID_SYSTEMMENU_RESTORE:
|
|
case SC_RESTORE:
|
|
ShowSelfSite(SW_RESTORE);
|
|
break;
|
|
|
|
case ID_SYSTEMMENU_MOVE:
|
|
case SC_MOVE: {
|
|
|
|
// Save window size and position
|
|
::GetWindowRect(m_hWnd, &m_rcWndOld);
|
|
::GetCursorPos(&m_ptMouseOld);
|
|
|
|
RECT rc;
|
|
::GetClientRect(m_hWnd, &rc);
|
|
POINT point = {(rc.left+rc.right)/2, rc.top + SYS_TITLEBAR_WIDTH/2};
|
|
|
|
POINT screenPt = point;
|
|
::ClientToScreen(m_hWnd, &screenPt);
|
|
|
|
RECT rcDeskt;
|
|
::GetWindowRect(::GetDesktopWindow(), &rcDeskt);
|
|
|
|
LONG lx = LONG((FLOAT)screenPt.x/ RECTWIDTH(&rcDeskt) * 0xFFFF);
|
|
LONG ly = LONG((FLOAT)screenPt.y/ RECTHEIGHT(&rcDeskt) * 0xFFFF);
|
|
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, lx, ly, 0, 0);
|
|
m_HitRegion = PREMOVE;
|
|
UpdateCursor(m_HitRegion);
|
|
|
|
m_bHandleEnter = TRUE;
|
|
break;
|
|
}
|
|
|
|
case ID_SYSTEMMENU_SIZE:
|
|
case SC_SIZE: {
|
|
|
|
// Save window size and position
|
|
::GetWindowRect(m_hWnd, &m_rcWndOld);
|
|
::GetCursorPos(&m_ptMouseOld);
|
|
|
|
RECT rc;
|
|
::GetClientRect(m_hWnd, &rc);
|
|
POINT point = {rc.right/2, rc.bottom/2};
|
|
|
|
POINT screenPt = point;
|
|
::ClientToScreen(m_hWnd, &screenPt);
|
|
|
|
RECT rcDeskt;
|
|
::GetWindowRect(::GetDesktopWindow(), &rcDeskt);
|
|
|
|
LONG lx = LONG((FLOAT)screenPt.x/ RECTWIDTH(&rcDeskt) * 0xFFFF);
|
|
LONG ly = LONG((FLOAT)screenPt.y/ RECTHEIGHT(&rcDeskt) * 0xFFFF);
|
|
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, lx, ly, 0, 0);
|
|
m_HitRegion = PRESIZE;
|
|
UpdateCursor(m_HitRegion);
|
|
|
|
m_bHandleEnter = TRUE;
|
|
break;
|
|
}
|
|
|
|
case ID_SYSTEMMENU_MINIMIZE:
|
|
case SC_MINIMIZE:
|
|
ShowSelfSite(SW_MINIMIZE);
|
|
break;
|
|
|
|
case ID_SYSTEMMENU_MAXIMIZE:
|
|
case SC_MAXIMIZE:
|
|
ShowSelfSite(SW_MAXIMIZE);
|
|
break;
|
|
|
|
case ID_SYSTEMMENU_CLOSE:
|
|
case SC_CLOSE:
|
|
OnClose(WM_CLOSE, wParam, lParam, bHandled);
|
|
break;
|
|
|
|
default:
|
|
bHandled = FALSE;
|
|
return ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
m_bSysMenuOn = FALSE;
|
|
return(lRet);
|
|
}/* end of function OnCommand */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnTimer */
|
|
/* Description: Handles the timer message. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnTimer(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
WPARAM wTimerID = wParam;
|
|
|
|
if(ID_EV_TIMER == wTimerID){
|
|
|
|
if(false == m_fUserActivity && false == m_fWaitingForActivity){
|
|
|
|
// If system menu is on, do not time out
|
|
if (!m_bSysMenuOn) {
|
|
|
|
// fire message that there is no activity going on
|
|
m_fWaitingForActivity = true;
|
|
Fire_ActivityDeclined();
|
|
}
|
|
}/* end of if statement */
|
|
|
|
m_fUserActivity = false; // reset the flag
|
|
}
|
|
else {
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
::KillTimer(m_hWnd, wTimerID);
|
|
}/* end of if statement */
|
|
|
|
Fire_Timeout(wTimerID);
|
|
}/* end of if statement */
|
|
|
|
bHandled = TRUE;
|
|
return(1);
|
|
}/* end of function OnTimer */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnCaptureChanged */
|
|
/* Description: Handles the on syscommand. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnCaptureChanged(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
ATLTRACE2(atlTraceWindowing, 4, TEXT("Received WM_CAPTURECHANGED MESSAGE \n"));
|
|
|
|
if(m_fHandleHelp){
|
|
|
|
HWND h;
|
|
if(SUCCEEDED(GetWindow(&h))){
|
|
|
|
POINT pt;
|
|
::GetCursorPos(&pt);
|
|
RECT rc;
|
|
::GetWindowRect(h, &rc);
|
|
|
|
if(!::PtInRect(&rc, pt)){
|
|
// we clicked somewhere outiside in our help mode
|
|
m_fHandleHelp = false; // otherwise we are going to get lbutton up and we will
|
|
// turn it off then
|
|
}/* end of if statement */
|
|
}
|
|
else {
|
|
|
|
m_fHandleHelp = false; // could not get the window, but better trun off
|
|
// the help mode
|
|
}/* end of if statement */
|
|
|
|
|
|
return(0);
|
|
}/* end of if statement */
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
HWND hwndNewCapture = (HWND) lParam;
|
|
if(m_hWnd != hwndNewCapture){
|
|
|
|
ResetCaptureFlags();
|
|
#if 0 // uncoment this if we get badly behaving controls
|
|
if(m_bMouseDown){
|
|
|
|
// we are not supposed to do that
|
|
// but if our child takes a focus away while we
|
|
// are resizigng we get in trouble
|
|
SetCapture(TRUE);
|
|
}/* end of if statement */
|
|
#endif
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return(0);
|
|
}/* end of function OnCaptureChanged */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnSetIcon */
|
|
/* Description: Set icon . */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnSetIcon(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
LRESULT lr = ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
|
|
|
|
return(lr);
|
|
}/* end of function OnSetIcon */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnInitDialog */
|
|
/* Description: Fires the help event. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
ATLASSERT(FALSE);
|
|
LRESULT lr = ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
|
|
|
|
return(lr);
|
|
}/* end of function OnInitDialog */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnHelp */
|
|
/* Description: Fires the help event. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
HELPINFO* pHpi = (LPHELPINFO) lParam;
|
|
bHandled = TRUE;
|
|
|
|
if(NULL == pHpi){
|
|
|
|
return 0;
|
|
}/* end of if statement */
|
|
|
|
// first check if we have fired help on message box
|
|
HWND hCntrlWnd = (HWND)pHpi->hItemHandle;
|
|
|
|
if((::GetWindowLong(hCntrlWnd, GWL_STYLE) & WS_DLGFRAME) == WS_DLGFRAME){
|
|
// we have a message box up
|
|
|
|
HWND hwndText;
|
|
|
|
hwndText = ::FindWindowEx(hCntrlWnd, NULL, TEXT("Static"), NULL);
|
|
|
|
if(hwndText){
|
|
|
|
TCHAR strWindowText[MAX_PATH];
|
|
::GetWindowText(hwndText, strWindowText, MAX_PATH);
|
|
|
|
//::DestroyWindow(hCntrlWnd);
|
|
|
|
BSTR strToolbarName;
|
|
|
|
if(SUCCEEDED(GetToolbarName(&strToolbarName))){
|
|
|
|
USES_CONVERSION;
|
|
Fire_OnHelp(strToolbarName, ::SysAllocString(T2OLE(strWindowText)));
|
|
}/* end of if statement */
|
|
}
|
|
else {
|
|
|
|
;//::DestroyWindow(hCntrlWnd);
|
|
}/* end of if statement */
|
|
|
|
return(TRUE);
|
|
}/* end of if statement */
|
|
|
|
// then check if a windowed control has fired help
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// iterate through all the contained controls
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
ATLASSERT(FALSE); // should not be null
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
if(pObj->IsInputEnabled() && !pObj->IsWindowless()){
|
|
|
|
HWND hwnd = NULL;
|
|
|
|
HRESULT hr = pObj->GetWindow(&hwnd);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
if(hwnd == hCntrlWnd){
|
|
|
|
Fire_OnHelp(::SysAllocString(pObj->GetID()));
|
|
//ResetFocusFlags();
|
|
return(TRUE);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
// now look into windowless control
|
|
POINT ptMouse = pHpi->MousePos;
|
|
|
|
m_fHandleHelp = false; // get our self out of the help mode in case we clicked
|
|
// on windowed control and we did not get notified about this
|
|
|
|
// convert the point to client coordinates
|
|
HWND h = NULL;
|
|
HRESULT hr = GetWindow(&h);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
ATLASSERT(FALSE);
|
|
return(0);
|
|
}/* end of if statement */
|
|
|
|
if(!::ScreenToClient(h, &ptMouse)){
|
|
|
|
ATLASSERT(FALSE);
|
|
return(0);
|
|
}/* end of if statement */
|
|
|
|
for(i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// iterate through all the contained controls
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
ATLASSERT(FALSE); // should not be null
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
|
|
// send the message to the control over which we are howering or on which we
|
|
// have clicked, check if we already are ready to send the message
|
|
// in that case do not bother with the rect interstec bussines
|
|
if(pObj->IsInputEnabled()){
|
|
|
|
CComPtr<IViewObjectEx> pViewObject;
|
|
HRESULT hr = pObj->GetViewObject(&pViewObject);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
ATLASSERT(FALSE); // should have a view
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
DWORD dwHitResult = HITRESULT_OUTSIDE;
|
|
|
|
RECT rcCntrl;
|
|
pObj->GetPos(&rcCntrl);
|
|
|
|
pViewObject->QueryHitPoint(DVASPECT_CONTENT, &rcCntrl, ptMouse, 0, &dwHitResult);
|
|
|
|
if(HITRESULT_HIT == dwHitResult){
|
|
|
|
Fire_OnHelp(::SysAllocString(pObj->GetID()));
|
|
return(TRUE);
|
|
}/* end of if statement */
|
|
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
// Get toolbar name
|
|
BSTR strToolbarName;
|
|
|
|
if(SUCCEEDED(GetToolbarName(&strToolbarName))){
|
|
|
|
Fire_OnHelp(strToolbarName);
|
|
}/* end of if statement */
|
|
|
|
return(TRUE);
|
|
}/* end of function OnHelp */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnSize */
|
|
/* Description: Handles the onsize message if we are self contained. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnSize(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
try {
|
|
|
|
if(false == m_fSelfHosted){
|
|
|
|
bHandled = FALSE;
|
|
return 0;
|
|
}/* end of if statement */
|
|
|
|
// Update the system menu accordingly
|
|
|
|
if (m_hMenu) {
|
|
HMENU hSubMenu = ::GetSubMenu(m_hMenu, 0);
|
|
|
|
if(hSubMenu){
|
|
MENUITEMINFO mInfo;
|
|
mInfo.cbSize = sizeof(MENUITEMINFO);
|
|
|
|
BOOL bRestored = (wParam == SIZE_RESTORED);
|
|
::GetMenuItemInfo(hSubMenu, ID_SYSTEMMENU_RESTORE, false, &mInfo);
|
|
mInfo.fMask = MIIM_STATE;
|
|
mInfo.fState = bRestored? MFS_GRAYED:MFS_ENABLED;
|
|
::SetMenuItemInfo(hSubMenu, ID_SYSTEMMENU_RESTORE, false, &mInfo);
|
|
|
|
BOOL bMaximized = (wParam == SIZE_MAXIMIZED);
|
|
::GetMenuItemInfo(hSubMenu, ID_SYSTEMMENU_MAXIMIZE, false, &mInfo);
|
|
mInfo.fMask = MIIM_STATE;
|
|
mInfo.fState = bMaximized? MFS_GRAYED:MFS_ENABLED;
|
|
::SetMenuItemInfo(hSubMenu, ID_SYSTEMMENU_MAXIMIZE, false, &mInfo);
|
|
|
|
BOOL bMinimized = (wParam == SIZE_MINIMIZED);
|
|
::GetMenuItemInfo(hSubMenu, ID_SYSTEMMENU_MINIMIZE, false, &mInfo);
|
|
mInfo.fMask = MIIM_STATE;
|
|
mInfo.fState = bMinimized? MFS_GRAYED:MFS_ENABLED;
|
|
::SetMenuItemInfo(hSubMenu, ID_SYSTEMMENU_MINIMIZE, false, &mInfo);
|
|
|
|
BOOL bMovable = !(bMaximized || bMinimized);
|
|
::GetMenuItemInfo(hSubMenu, ID_SYSTEMMENU_SIZE, false, &mInfo);
|
|
mInfo.fMask = MIIM_STATE;
|
|
mInfo.fState = bMovable? MFS_ENABLED:MFS_GRAYED;
|
|
::SetMenuItemInfo(hSubMenu, ID_SYSTEMMENU_SIZE, false, &mInfo);
|
|
::GetMenuItemInfo(hSubMenu, ID_SYSTEMMENU_MOVE, false, &mInfo);
|
|
mInfo.fMask = MIIM_STATE;
|
|
mInfo.fState = bMovable? MFS_ENABLED:MFS_GRAYED;
|
|
::SetMenuItemInfo(hSubMenu, ID_SYSTEMMENU_MOVE, false, &mInfo);
|
|
}
|
|
}
|
|
|
|
if (wParam == SIZE_MAXIMIZED) {
|
|
#ifndef _DEBUG
|
|
::SetWindowPos(m_hWnd, HWND_TOPMOST, 0, 0, 0, 0,
|
|
SWP_NOREDRAW|SWP_NOMOVE|SWP_NOSIZE);
|
|
#endif
|
|
}
|
|
|
|
else {
|
|
::SetWindowPos(m_hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
|
|
SWP_NOREDRAW|SWP_NOMOVE|SWP_NOSIZE);
|
|
}
|
|
|
|
LONG lWidth = LOWORD(lParam);
|
|
LONG lHeight = HIWORD(lParam);
|
|
|
|
Fire_OnResize(lWidth, lHeight, wParam);
|
|
|
|
if (m_pBackBitmap) {
|
|
InvalidateRgn();
|
|
if (::IsWindow(m_hWnd))
|
|
::UpdateWindow(m_hWnd);
|
|
}
|
|
|
|
bHandled = true;
|
|
|
|
}
|
|
catch(...){
|
|
}
|
|
|
|
return 0;
|
|
}/* end of function OnSize */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnSizing */
|
|
/* Description: Does not let us scale beyond the minimum size. If it */
|
|
/* tries to we fix up the rect on it. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnSizing(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
if(false == m_fSelfHosted){
|
|
|
|
bHandled = FALSE;
|
|
return 0;
|
|
}/* end of if statement */
|
|
|
|
RECT* lpRect = (LPRECT)lParam;
|
|
|
|
LONG lWidth = RECTWIDTH(lpRect);
|
|
LONG lHeight = RECTHEIGHT(lpRect);
|
|
|
|
// if we are going to be to small fix the rect
|
|
if(lWidth < m_lMinWidth){
|
|
|
|
lpRect->right = lpRect->left + m_lMinWidth;
|
|
}/* end of if statement */
|
|
|
|
if(lHeight < m_lMinHeight){
|
|
|
|
lpRect->bottom = lpRect->top + m_lMinHeight;
|
|
}/* end of if statement */
|
|
|
|
bHandled = true;
|
|
|
|
return 0;
|
|
}/* end of function OnSizing */
|
|
|
|
/*************************************************************************/
|
|
/* Function: Close */
|
|
/* Description: Just exposes the underlaying Close functionality to our */
|
|
/* custom interface. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::Close(){
|
|
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
::PostMessage(m_hWnd, WM_CLOSE, NULL, NULL);
|
|
|
|
return(S_OK);
|
|
//::DestroyWindow(m_hWnd);
|
|
}/* end of if statement */
|
|
|
|
return(Close(OLECLOSE_SAVEIFDIRTY));
|
|
}/* end of function Close */
|
|
|
|
/*************************************************************************/
|
|
/* Function: Close */
|
|
/* Description: Calls OLECLOSE the contained objects, then itself. */
|
|
/* The cleans up the containers and send WM_QUIT if we are self hosting. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::Close(DWORD dwSaveOption){
|
|
|
|
HRESULT hr = DestroyScriptEngine();
|
|
|
|
ATLASSERT(SUCCEEDED(hr));
|
|
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
|
|
// iterate through all the contained objects and call on the Close
|
|
CHostedObject* pObj = (*i);
|
|
|
|
CComPtr<IOleObject> pIOleObject;
|
|
HRESULT hrIOleObj = pObj->GetOleObject(&pIOleObject);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
if(GetUnknown() == pObj->GetUnknown()){
|
|
|
|
continue; // that is us we close our self later after the contained objects
|
|
}/* end of if statement */
|
|
|
|
pIOleObject->Close(dwSaveOption);
|
|
}/* end of for loop */
|
|
|
|
hr = IOleObjectImpl<CMFBar>::Close(dwSaveOption);
|
|
|
|
bool fSelfHosted = m_fSelfHosted; // cache up the variable, since we are going to
|
|
// wipe it out
|
|
|
|
Cleanup(); // delete all the objects
|
|
|
|
if(fSelfHosted){
|
|
|
|
::PostMessage(NULL, WM_QUIT, NULL, NULL); // tell our container to give up
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function Close */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ProcessMessages *
|
|
/* Description: Process the windows messages. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::ProcessMessages(){
|
|
|
|
HRESULT hr = ::WaitMessage() ? S_OK: S_FALSE;
|
|
|
|
return(hr);
|
|
}/* end of function ProcessMessages */
|
|
|
|
/*************************************************************************/
|
|
/* Function: AddFocusObject */
|
|
/* Description: Adds an object to the end of the focus array. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::AddFocusObject(BSTR strObjectID){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
CHostedObject* pObj;
|
|
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
m_cntFocus.insert(m_cntFocus.end(), pObj);
|
|
}
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
|
|
hr = E_UNEXPECTED;
|
|
}/* end of try statement */
|
|
|
|
return (hr);
|
|
}/* end of function AddFocusObject */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ResetFocusArray */
|
|
/* Description: Resets the focus array. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::ResetFocusArray(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
ResetFocusFlags();
|
|
|
|
// cleanup the focus array
|
|
for(CNTOBJ::iterator k = m_cntFocus.begin(); false == m_cntFocus.empty(); ){
|
|
|
|
k = m_cntFocus.erase(k);
|
|
}/* end of for loop */
|
|
}
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
|
|
hr = E_UNEXPECTED;
|
|
}/* end of try statement */
|
|
|
|
return (hr);
|
|
}/* end of function ResetFocusArray */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnSetFocus */
|
|
/* Description: Iterates through the container and sends the focus */
|
|
/* message to the control that thinks it has the focus. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnSetFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
bHandled = TRUE;
|
|
LONG lRes = 0;
|
|
|
|
if(m_cntObj.empty() == true){
|
|
|
|
return 0;
|
|
}/* end of if statement */
|
|
|
|
MoveFocus(TRUE, lRes);
|
|
|
|
return lRes;
|
|
}/* end of function OnSetFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnHelpEnd */
|
|
/* Description: Resets the help */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnHelpEnd(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
bHandled = TRUE;
|
|
LONG lRes = 0;
|
|
|
|
m_fHandleHelp = false;
|
|
|
|
return lRes;
|
|
}/* end of function OnHelpEnd */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnUserFocus */
|
|
/* Description: Iterates through the container and sends the focus */
|
|
/* message to the control that thinks it has the focus. In this case */
|
|
/* the control is specified by hwnd and that it is a windowed control. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnUserFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
bHandled = TRUE;
|
|
LONG lRes = 0;
|
|
if (!m_bHandleUserFocus) {
|
|
|
|
m_bHandleUserFocus = TRUE;
|
|
return lRes;
|
|
}
|
|
|
|
HRESULT hr = E_FAIL; // did not find the object
|
|
|
|
if(m_fHandleHelp){
|
|
|
|
ResetFocusFlags();
|
|
return(lRes);
|
|
}/* end of if statement */
|
|
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
HWND hwndCtrl = NULL;
|
|
hr = pObj->GetWindow(&hwndCtrl);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
if(hwndCtrl == (HWND) wParam){
|
|
|
|
SetClosestFocus(lRes, pObj);
|
|
|
|
//SetObjectFocus(pObj, TRUE, lRes);
|
|
return(lRes);
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
return lRes;
|
|
}/* end of function OnUserFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnKillFocus */
|
|
/* Description: Sends the kill focus message to the control that has */
|
|
/* Itterates through the container and removes the focus */
|
|
/* from the contained objects. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnKillFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled){
|
|
|
|
bHandled = TRUE;
|
|
LONG lRes = 0;
|
|
|
|
ResetFocusFlags(); // cleanup the focus flags
|
|
return lRes;
|
|
}/* end of function OnKillFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnMouseMessage */
|
|
/* Description: Handles the mouse messages, distrubutes to proper */
|
|
/* controls if needed. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnMouseMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
|
|
BOOL& bHandled){
|
|
|
|
LONG lRes = 0;
|
|
bHandled = FALSE; // indicated if we dispatched the message
|
|
|
|
if(m_lTimeout > 0){
|
|
|
|
//WM_MOUSEMOVE messages keep comming over even if we really do not move the mouse
|
|
|
|
bool bResetActivity = false;
|
|
if(WM_MOUSEMOVE == uMsg){
|
|
|
|
static WPARAM wParTmp = 0;
|
|
static LPARAM lParTmp = 0;
|
|
|
|
if(wParam != wParTmp || lParam != lParTmp){
|
|
|
|
bResetActivity = true;
|
|
}/* end of if statement */
|
|
|
|
if(wParam & MK_CONTROL ||
|
|
wParam & MK_CONTROL ||
|
|
wParam & MK_LBUTTON ||
|
|
wParam & MK_MBUTTON ||
|
|
wParam & MK_RBUTTON ||
|
|
wParam & MK_SHIFT ){
|
|
|
|
bResetActivity = true;
|
|
}/* end of if statement */
|
|
|
|
lParTmp = lParam;
|
|
wParTmp = wParam;
|
|
}
|
|
else {
|
|
|
|
bResetActivity = true;
|
|
}/* end of if statement */
|
|
|
|
if(bResetActivity){
|
|
|
|
m_fUserActivity = true;
|
|
|
|
if(m_fWaitingForActivity){
|
|
|
|
Fire_ActivityStarted();
|
|
m_fWaitingForActivity = false;
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
ATLTRACE2(atlTraceWindowing, 32, TEXT("R WM_ button message : "));
|
|
|
|
if(!m_bMouseDown && m_HitRegion!=PRESIZE && m_HitRegion!=PREMOVE){
|
|
|
|
CHostedObject* pMouseCaptureObj = NULL;
|
|
|
|
// send the message to the control(s) that have the capture
|
|
if(false == m_fHandleHelp && GetCapture() == S_OK){
|
|
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// iterate through all the contained controls
|
|
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
ATLASSERT(FALSE); // should not be null
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
// need to be able send message to the button with the capture
|
|
if(pObj->HasCapture()){
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("Sending WM_ buttons message to button %ls \n"), pObj->GetID());
|
|
HRESULT hr = SendMessageToCtl(pObj, uMsg, wParam, lParam, bHandled, lRes);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
|
|
|
|
if (WM_LBUTTONDOWN == uMsg) {
|
|
|
|
CComPtr<IViewObjectEx> pViewObject;
|
|
HRESULT hr = pObj->GetViewObject(&pViewObject);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
ATLASSERT(FALSE); // should have a view
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
DWORD dwHitResult = HITRESULT_OUTSIDE;
|
|
|
|
POINT ptMouse = { LOWORD(lParam), HIWORD(lParam) };
|
|
RECT rcCntrl;
|
|
pObj->GetPos(&rcCntrl);
|
|
|
|
pViewObject->QueryHitPoint(DVASPECT_CONTENT, &rcCntrl, ptMouse, 0, &dwHitResult);
|
|
|
|
if(HITRESULT_HIT == dwHitResult){
|
|
|
|
if (WM_LBUTTONDOWN == uMsg) {
|
|
|
|
LONG lRes;
|
|
//SetObjectFocus(pObj, TRUE, lRes);
|
|
SetClosestFocus(lRes, pObj);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
pMouseCaptureObj = pObj;
|
|
break; // send mouse message to only the one control that has capture
|
|
// then to the ones we hower over
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
}/* end of if statement */
|
|
|
|
// send the message to the control(s) that we are over, but not to the one
|
|
// that which had focus and we already send one
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// iterate through all the contained controls
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
ATLASSERT(FALSE); // should not be null
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
// need to be able send message to the button with the capture
|
|
|
|
// send the message to the control over which we are howering or on which we
|
|
// have clicked, check if we already are ready to send the message
|
|
// in that case do not bother with the rect interstec bussines
|
|
if(!bHandled && pObj->IsWindowless() && pObj->IsInputEnabled()){
|
|
|
|
CComPtr<IViewObjectEx> pViewObject;
|
|
HRESULT hr = pObj->GetViewObject(&pViewObject);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
ATLASSERT(FALSE); // should have a view
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
DWORD dwHitResult = HITRESULT_OUTSIDE;
|
|
|
|
POINT ptMouse = { LOWORD(lParam), HIWORD(lParam) };
|
|
RECT rcCntrl;
|
|
pObj->GetPos(&rcCntrl);
|
|
|
|
pViewObject->QueryHitPoint(DVASPECT_CONTENT, &rcCntrl, ptMouse, 0, &dwHitResult);
|
|
|
|
if(HITRESULT_HIT == dwHitResult){
|
|
|
|
// see if we are handling help, if so do not do anything else, but
|
|
// fire help with the control ID we are howering over
|
|
if(m_fHandleHelp){
|
|
|
|
if (WM_LBUTTONUP == uMsg) {
|
|
|
|
Fire_OnHelp(::SysAllocString(pObj->GetID()));
|
|
m_fHandleHelp = false;
|
|
}/* end of if statement */
|
|
|
|
bHandled = TRUE;
|
|
return(lRes);
|
|
}
|
|
else {
|
|
|
|
if(pMouseCaptureObj == pObj){
|
|
|
|
continue; // we already have send message to this control
|
|
// do not do it again
|
|
}/* end of if statememt */
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("Sending WM_ buttons message to button %ls \n"), pObj->GetID());
|
|
SendMessageToCtl(pObj, uMsg, wParam, lParam, bHandled, lRes);
|
|
|
|
if (WM_LBUTTONDOWN == uMsg) {
|
|
|
|
LONG lRes;
|
|
//SetObjectFocus(pObj, TRUE, lRes);
|
|
SetClosestFocus(lRes, pObj);
|
|
}/* end of if statement */
|
|
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
}/* end of if statement */
|
|
|
|
|
|
if(TRUE == bHandled){
|
|
// we send some messages to a control, so there is no need to handle container now
|
|
|
|
return(lRes);
|
|
}/* end of if statement */
|
|
|
|
// we are not over any control so we might be over container itself, so handle
|
|
// the mouse message appropriately
|
|
|
|
ATLTRACE2(atlTraceWindowing, 32, TEXT("Not forwarding the message to the controls\n"));
|
|
|
|
if(WM_LBUTTONDOWN == uMsg) {
|
|
Fire_OnMouseDown();
|
|
}
|
|
|
|
if(WM_LBUTTONUP == uMsg || WM_LBUTTONDBLCLK == uMsg){
|
|
|
|
// TODO: Fire the click only if we are on our window or bitmap
|
|
if(m_fHandleHelp){
|
|
BSTR strToolbarName;
|
|
|
|
if(SUCCEEDED(GetToolbarName(&strToolbarName))){
|
|
|
|
Fire_OnHelp(strToolbarName);
|
|
}/* end of if statement */
|
|
m_fHandleHelp = false;
|
|
}
|
|
else {
|
|
|
|
if(WM_LBUTTONUP == uMsg){
|
|
|
|
Fire_OnClick();
|
|
Fire_OnMouseUp();
|
|
}
|
|
else {
|
|
|
|
Fire_OnDblClick();
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
// handle the moving of the container window
|
|
if(m_fSelfHosted && !m_fHandleHelp){
|
|
|
|
if(WM_LBUTTONDOWN == uMsg){
|
|
OnButtonDown(uMsg, wParam, lParam, bHandled);
|
|
}/* end of if statement */
|
|
|
|
if(WM_MOUSEMOVE == uMsg){
|
|
OnMouseMove(uMsg, wParam, lParam, bHandled);
|
|
}/* end of if statement */
|
|
|
|
if(WM_LBUTTONUP == uMsg){
|
|
OnButtonUp(uMsg, wParam, lParam, bHandled);
|
|
}/* end of if statement */
|
|
|
|
// Right click on the title bar
|
|
if(WM_RBUTTONDOWN == uMsg) {
|
|
|
|
POINT ptMouse = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
|
|
if (ptMouse.y <= SYS_TITLEBAR_WIDTH) {
|
|
::ClientToScreen(m_hWnd, &ptMouse);
|
|
PopupSystemMenu(ptMouse.x, ptMouse.y);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return(lRes);
|
|
}/* end of function OnMouseMessage */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnSetCursor */
|
|
/* Description: Handles the WM_SETCURSOR messages, distrubutes to proper */
|
|
/* controls if needed. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnSetCursor(UINT uMsg, WPARAM wParam, LPARAM lParam,
|
|
BOOL& bHandled){
|
|
|
|
LONG lRes = 0;
|
|
|
|
if(!::IsWindow(m_hWnd)){
|
|
|
|
return lRes;
|
|
}/* end of if statement */
|
|
|
|
if (m_HitRegion == PRESIZE || m_HitRegion == PREMOVE) {
|
|
|
|
return lRes;
|
|
}
|
|
|
|
bHandled = FALSE;
|
|
|
|
if(m_cntObj.empty() == true){
|
|
|
|
return 0;
|
|
}/* end of if statement */
|
|
|
|
|
|
CHostedObject* pMouseCaptureObj = NULL;
|
|
|
|
// send the message to the control(s) that have the capture
|
|
if(false == m_fHandleHelp && GetCapture() == S_OK){
|
|
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// iterate through all the contained controls
|
|
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
ATLASSERT(FALSE); // should not be null
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
// need to be able send message to the button with the capture
|
|
if(pObj->HasCapture()){
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("Sending WM_SETCURSOR message to button %ls \n"), pObj->GetID());
|
|
HRESULT hr = SendMessageToCtl(pObj, uMsg, wParam, lParam, bHandled, lRes);
|
|
|
|
#if 0
|
|
if(SUCCEEDED(hr)){
|
|
|
|
return(lRes);
|
|
}/* end of if statement */
|
|
#endif
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
}/* end of if statement */
|
|
|
|
DWORD dwValue = ::GetMessagePos();
|
|
POINT ptMouse = {GET_X_LPARAM(dwValue), GET_Y_LPARAM(dwValue)};
|
|
::ScreenToClient(m_hWnd, &ptMouse);
|
|
|
|
// send the message to the control(s) that we are over, but not to the one
|
|
// that which had focus and we already send one
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// iterate through all the contained controls
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
ATLASSERT(FALSE); // should not be null
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
// need to be able send message to the button with the capture
|
|
|
|
// send the message to the control over which we are howering or on which we
|
|
// have clicked, check if we already are ready to send the message
|
|
// in that case do not bother with the rect interstec bussines
|
|
if(pObj->IsWindowless()){
|
|
|
|
CComPtr<IViewObjectEx> pViewObject;
|
|
HRESULT hr = pObj->GetViewObject(&pViewObject);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
ATLASSERT(FALSE); // should have a view
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
DWORD dwHitResult = HITRESULT_OUTSIDE;
|
|
|
|
RECT rcCntrl;
|
|
pObj->GetPos(&rcCntrl);
|
|
|
|
pViewObject->QueryHitPoint(DVASPECT_CONTENT, &rcCntrl, ptMouse, 0, &dwHitResult);
|
|
|
|
if(HITRESULT_HIT == dwHitResult){
|
|
|
|
// see if we are handling help, if so do not do anything else, but
|
|
// fire help with the control ID we are howering over
|
|
if(m_fHandleHelp){
|
|
|
|
bHandled = FALSE;
|
|
return(lRes);
|
|
}
|
|
else {
|
|
|
|
if(pMouseCaptureObj == pObj){
|
|
|
|
continue; // we already have send message to this control
|
|
// do not do it again
|
|
}/* end of if statememt */
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("Sending WM_SETCURSOR message to button %ls \n"), pObj->GetID());
|
|
SendMessageToCtl(pObj, uMsg, wParam, lParam, bHandled, lRes);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
|
|
return(lRes);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
return lRes;
|
|
}
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnKeyMessage */
|
|
/* Description: Distrubutes the keyboard messages properly. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnKeyMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
|
|
BOOL& bHandled){
|
|
|
|
m_fUserActivity = true;
|
|
|
|
static bool fHandleKeyUp = false; // when onther child window closes on top
|
|
// of us we get an UP message without down
|
|
// this should.. eat it up
|
|
|
|
if(uMsg == WM_KEYDOWN || uMsg == WM_SYSKEYDOWN){
|
|
|
|
fHandleKeyUp = true;
|
|
}/* end of if statement */
|
|
|
|
if(m_fWaitingForActivity){
|
|
|
|
Fire_ActivityStarted();
|
|
m_fWaitingForActivity = false;
|
|
}/* end of if statement */
|
|
|
|
|
|
if(uMsg == WM_KEYUP || uMsg == WM_SYSKEYUP){
|
|
|
|
if(!fHandleKeyUp){
|
|
|
|
fHandleKeyUp = false;
|
|
return 0;
|
|
}/* end of if statement */
|
|
|
|
fHandleKeyUp = false;
|
|
}/* end of if statement */
|
|
|
|
bHandled = FALSE;
|
|
LONG lRes = 0;
|
|
VARIANT_BOOL fEat = VARIANT_FALSE;
|
|
|
|
LONG lEnable = 1; // using long since the framework will not handle short
|
|
|
|
LONG lVirtKey = (LONG) wParam;
|
|
LONG lKeyData = (LONG) lParam;
|
|
|
|
m_fForceKey = false; // reset the flag, the change in the value would indicate
|
|
// that we have received call to force key during the event
|
|
// processing
|
|
|
|
// Handle keys for manual move and size
|
|
HandleMoveSizeKey(uMsg, wParam, lParam, bHandled);
|
|
if (bHandled)
|
|
return lRes;
|
|
|
|
if (!m_bHandleEnter && !m_bSysMenuOn) {
|
|
|
|
if(WM_KEYDOWN == uMsg)
|
|
Fire_OnKeyDown(lVirtKey, lKeyData);
|
|
|
|
else if (WM_KEYUP == uMsg)
|
|
Fire_OnKeyUp(lVirtKey, lKeyData);
|
|
|
|
ATLTRACE2(atlTraceWindowing, 4, TEXT("OnKeyMessage Fire_OnKey message\n"));
|
|
|
|
}/* end of if statement */
|
|
|
|
if(WM_SYSKEYDOWN == uMsg){
|
|
|
|
Fire_OnSysKeyDown(lVirtKey, lKeyData);
|
|
}/* end of if statement */
|
|
|
|
if(WM_SYSKEYUP == uMsg){
|
|
|
|
Fire_OnSysKeyUp(lVirtKey, lKeyData);
|
|
}/* end of if statement */
|
|
|
|
if(m_fForceKey){
|
|
|
|
fEat = m_fEat;
|
|
lVirtKey = m_lVirtKey;
|
|
lKeyData = m_lKeyData;
|
|
}/* end of if statement */
|
|
|
|
if(VARIANT_FALSE == fEat){
|
|
|
|
if(WM_KEYUP == uMsg ){
|
|
switch(lVirtKey){
|
|
|
|
case VK_TAB:
|
|
bool fForward = true;
|
|
|
|
if(::GetKeyState(VK_SHIFT) < 0){
|
|
|
|
fForward = false;
|
|
}/* end of if statement */
|
|
|
|
MoveFocus(fForward, lRes);
|
|
return(lRes);
|
|
}/* end of switch statement */
|
|
}/* end of if statement */
|
|
|
|
if (m_bHandleEnter || m_bSysMenuOn)
|
|
return lRes;
|
|
|
|
// iterates through the controls and send these key messages to the one
|
|
// with focus
|
|
CNTOBJ::iterator i;
|
|
for(i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// iterate through all the contained controls
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
ATLASSERT(FALSE);
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
if(pObj->HasFocus()){
|
|
|
|
// handle help
|
|
if(WM_KEYUP == uMsg && VK_F1 == lVirtKey){
|
|
|
|
Fire_OnHelp(::SysAllocString(pObj->GetID()));
|
|
}/* end of if statement */
|
|
|
|
HRESULT hr = SendMessageToCtl(pObj, uMsg, lVirtKey, lKeyData, bHandled, lRes, false);
|
|
ATLTRACE2(atlTraceWindowing, 4, TEXT("OnKeyMessage SendMessageToCtl\n"));
|
|
|
|
if(SUCCEEDED(hr)){
|
|
|
|
return(lRes);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
// handle help
|
|
if(WM_KEYUP == uMsg && VK_F1 == lVirtKey){
|
|
BSTR strToolbarName;
|
|
|
|
if(SUCCEEDED(GetToolbarName(&strToolbarName))){
|
|
|
|
USES_CONVERSION;
|
|
Fire_OnHelp(strToolbarName, NULL);
|
|
//m_fHandleHelp = false;
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return(lRes);
|
|
}/* end of function OnKeyMessage */
|
|
|
|
/*************************************************************/
|
|
/* Name: HandleMoveSizeKey
|
|
/* Description: Handle arrows for manual move and size
|
|
/*************************************************************/
|
|
LRESULT CMFBar::HandleMoveSizeKey(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
LONG lRes = 0;
|
|
bHandled = TRUE;
|
|
|
|
LONG lVirtKey = (LONG) wParam;
|
|
LONG lKeyData = (LONG) lParam;
|
|
|
|
POINT point = m_ptMouse;
|
|
|
|
// Get Window rc
|
|
RECT rc;
|
|
::GetClientRect(m_hWnd, &rc);
|
|
|
|
// Get Desktop rc
|
|
RECT rcDeskt;
|
|
::GetWindowRect(::GetDesktopWindow(), &rcDeskt);
|
|
|
|
ATLTRACE2(atlTraceWindowing, 4, TEXT("OnKeyMessage m_bHandleEnter %d\n"), m_bHandleEnter);
|
|
|
|
if (lVirtKey == VK_ESCAPE || lVirtKey == VK_SELECT || lVirtKey == VK_SPACE || lVirtKey == VK_RETURN) {
|
|
if (WM_KEYDOWN == uMsg) {
|
|
if (m_bHandleEnter) {
|
|
|
|
if (lVirtKey == VK_ESCAPE) {
|
|
::MoveWindow(m_hWnd, m_rcWndOld.left, m_rcWndOld.top, RECTWIDTH(&m_rcWndOld), RECTHEIGHT(&m_rcWndOld), TRUE);
|
|
}
|
|
|
|
point = m_ptMouseOld;
|
|
LONG lx = LONG((FLOAT)point.x/ RECTWIDTH(&rcDeskt) * 0xFFFF);
|
|
LONG ly = LONG((FLOAT)point.y/ RECTHEIGHT(&rcDeskt) * 0xFFFF);
|
|
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTUP, lx, ly, 0, 0);
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, lx, ly, 0, 0);
|
|
return lRes;
|
|
}
|
|
}
|
|
else if (WM_KEYUP == uMsg) {
|
|
if (m_bHandleEnter && !m_bMouseDown &&
|
|
m_HitRegion!=PRESIZE && m_HitRegion!=PREMOVE) {
|
|
m_bHandleEnter = FALSE;
|
|
return lRes;
|
|
}
|
|
} /* end of if statement */
|
|
} /* end of if statement */
|
|
|
|
if (WM_KEYDOWN == uMsg &&
|
|
(lVirtKey == VK_LEFT || lVirtKey == VK_RIGHT||
|
|
lVirtKey == VK_UP || lVirtKey == VK_DOWN)) {
|
|
|
|
POINT leftTop = {SYS_MOVE_SIZE, SYS_MOVE_SIZE};
|
|
POINT rightBottom = {rc.right-SYS_MOVE_SIZE, rc.bottom-SYS_MOVE_SIZE};
|
|
|
|
POINT scLeftTop = leftTop;
|
|
::ClientToScreen(m_hWnd, &scLeftTop);
|
|
POINT scRightBottom = rightBottom;
|
|
::ClientToScreen(m_hWnd, &scRightBottom);
|
|
|
|
LONG left = LONG((FLOAT)scLeftTop.x/ RECTWIDTH(&rcDeskt) * 0xFFFF);
|
|
LONG top = LONG((FLOAT)scLeftTop.y/ RECTHEIGHT(&rcDeskt) * 0xFFFF);
|
|
LONG right = LONG((FLOAT)scRightBottom.x/ RECTWIDTH(&rcDeskt) * 0xFFFF);
|
|
LONG bottom = LONG((FLOAT)scRightBottom.y/ RECTHEIGHT(&rcDeskt) * 0xFFFF);
|
|
|
|
if (m_HitRegion == PREMOVE) {
|
|
|
|
POINT point = {(rc.left+rc.right)/2, rc.top + SYS_TITLEBAR_WIDTH/2};
|
|
POINT screenPt = point;
|
|
::ClientToScreen(m_hWnd, &screenPt);
|
|
|
|
LONG lx = LONG((FLOAT)screenPt.x/ RECTWIDTH(&rcDeskt) * 0xFFFF);
|
|
LONG ly = LONG((FLOAT)screenPt.y/ RECTHEIGHT(&rcDeskt) * 0xFFFF);
|
|
|
|
m_HitRegion = NOHIT;
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, lx, ly, 0, 0);
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTDOWN, lx, ly, 0, 0);
|
|
return lRes;
|
|
}
|
|
|
|
else if (m_HitRegion == PRESIZE) {
|
|
|
|
m_HitRegion = NOHIT;
|
|
switch (lVirtKey) {
|
|
|
|
case VK_LEFT:
|
|
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, left, (top+bottom)/2, 0, 0);
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTDOWN, left, (top+bottom)/2, 0, 0);
|
|
break;
|
|
case VK_RIGHT:
|
|
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, right, (top+bottom)/2, 0, 0);
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTDOWN, right, (top+bottom)/2, 0, 0);
|
|
break;
|
|
case VK_UP:
|
|
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, (left+right)/2, top, 0, 0);
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTDOWN, (left+right)/2, top, 0, 0);
|
|
break;
|
|
case VK_DOWN:
|
|
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, (left+right)/2, bottom, 0, 0);
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTDOWN, (left+right)/2, bottom, 0, 0);
|
|
break;
|
|
|
|
} /* end of switch statement */
|
|
return lRes;
|
|
}
|
|
|
|
else if (m_bMouseDown) {
|
|
switch (lVirtKey) {
|
|
|
|
case VK_LEFT:
|
|
|
|
if (!(m_HitRegion&RIGHT || m_HitRegion&LEFT) && m_HitRegion!=NOHIT) {
|
|
m_HitRegion = (HitRegion) (m_HitRegion | LEFT);
|
|
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, left, m_HitRegion&BOTTOM?bottom:top, 0, 0);
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTDOWN, left, m_HitRegion&BOTTOM?bottom:top, 0, 0);
|
|
return lRes;
|
|
}
|
|
|
|
if (!(m_HitRegion&RIGHT && RECTWIDTH(&rc)-SYS_MOVE_SIZE<=m_lMinWidth))
|
|
point.x -= SYS_MOVE_SIZE;
|
|
break;
|
|
case VK_RIGHT:
|
|
|
|
if (!(m_HitRegion&RIGHT || m_HitRegion&LEFT) && m_HitRegion!=NOHIT) {
|
|
m_HitRegion = (HitRegion) (m_HitRegion | RIGHT);
|
|
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, right, m_HitRegion&BOTTOM?bottom:top, 0, 0);
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTDOWN, right, m_HitRegion&BOTTOM?bottom:top, 0, 0);
|
|
return lRes;
|
|
}
|
|
if (!(m_HitRegion&LEFT && RECTWIDTH(&rc)-SYS_MOVE_SIZE<=m_lMinWidth))
|
|
point.x += SYS_MOVE_SIZE;
|
|
break;
|
|
case VK_UP:
|
|
|
|
if (!(m_HitRegion&TOP || m_HitRegion&BOTTOM) && m_HitRegion!=NOHIT) {
|
|
m_HitRegion = (HitRegion) (m_HitRegion | TOP);
|
|
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, m_HitRegion&RIGHT?right:left, top, 0, 0);
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTDOWN, m_HitRegion&RIGHT?right:left, top, 0, 0);
|
|
return lRes;
|
|
}
|
|
|
|
if (!(m_HitRegion&BOTTOM && RECTHEIGHT(&rc)-SYS_MOVE_SIZE<=m_lMinHeight))
|
|
point.y -= SYS_MOVE_SIZE;
|
|
break;
|
|
case VK_DOWN:
|
|
|
|
if (!(m_HitRegion&TOP || m_HitRegion&BOTTOM) && m_HitRegion!=NOHIT) {
|
|
m_HitRegion = (HitRegion) (m_HitRegion | BOTTOM);
|
|
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, m_HitRegion&RIGHT?right:left, bottom, 0, 0);
|
|
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTDOWN, m_HitRegion&RIGHT?right:left, bottom, 0, 0);
|
|
return lRes;
|
|
}
|
|
|
|
if (!(m_HitRegion&TOP && RECTHEIGHT(&rc)-SYS_MOVE_SIZE<=m_lMinHeight))
|
|
point.y += SYS_MOVE_SIZE;
|
|
break;
|
|
|
|
} /* end of switch statement */
|
|
::SetCursorPos(point.x, point.y);
|
|
return lRes;
|
|
}/* end of if statement */
|
|
}
|
|
|
|
bHandled = FALSE;
|
|
return lRes;
|
|
} /*HandleMoveSizekey*/
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnDispChange */
|
|
/* Description: Forwards this message to all the controls. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnDispChange(UINT uMsg, WPARAM wParam, LPARAM lParam,
|
|
BOOL& bHandled){
|
|
|
|
LONG lRes =0;
|
|
|
|
long cBitsPerPixel = wParam;
|
|
long cxScreen = LOWORD(lParam);
|
|
long cyScreen = HIWORD(lParam);
|
|
if (NULL != m_pBackBitmap)
|
|
m_pBackBitmap->OnDispChange(cBitsPerPixel, cxScreen, cyScreen);
|
|
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
SendMessageToCtl(pObj, uMsg, wParam, lParam, bHandled, lRes, true, false);
|
|
|
|
}/* end of for loop */
|
|
|
|
return(lRes);
|
|
}/* end of function OnDispChange */
|
|
|
|
/*************************************************************************/
|
|
/* Function: AdvanceIterator */
|
|
/* Description: Helper inline function that helps to keep track which */
|
|
/* direction we are advancing. */
|
|
/*************************************************************************/
|
|
void AdvanceIterator(CNTOBJ::iterator& i, bool fForward){
|
|
|
|
if(fForward){
|
|
|
|
i++;
|
|
}
|
|
else {
|
|
|
|
i--;
|
|
}/* end of if statement */
|
|
}/* end of function AdvanceIterator */
|
|
|
|
/*************************************************************************/
|
|
/* Function: MoveFocus */
|
|
/* Descrition: Moves focus through the objects in forward or reverse */
|
|
/* direction. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::MoveFocus(bool fForward, LONG& lRes){
|
|
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(true == m_cntFocus.empty()){
|
|
|
|
return(S_FALSE);
|
|
}/* end of if statement */
|
|
|
|
// first remove the focus and remeber the object
|
|
CHostedObject* pLastFocusObject = NULL;
|
|
|
|
CNTOBJ::iterator i, iEnd;
|
|
|
|
if(fForward){
|
|
|
|
i = m_cntFocus.begin();
|
|
iEnd = m_cntFocus.end();
|
|
iEnd--;
|
|
}
|
|
else {
|
|
i = m_cntFocus.end();
|
|
i--;
|
|
iEnd = m_cntFocus.begin();
|
|
|
|
}/* end of if statement */
|
|
|
|
BOOL bFirst = TRUE;
|
|
|
|
do {
|
|
|
|
// do not advance if first time in the loop
|
|
if (!bFirst)
|
|
AdvanceIterator(i, fForward);
|
|
else
|
|
bFirst = FALSE;
|
|
|
|
// iterate through all the contained controls
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
ATLASSERT(FALSE);
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
if(pObj->HasFocus()){
|
|
|
|
LONG lRes;
|
|
SetObjectFocus(pObj, FALSE, lRes);
|
|
pLastFocusObject = pObj;
|
|
continue; // get to the next object
|
|
}/* end of if statement */
|
|
|
|
// try to set the focus to the next object
|
|
if(NULL != pLastFocusObject){
|
|
|
|
if(pObj->IsInputEnabled()){
|
|
|
|
LONG lRes = 0;
|
|
HRESULT hr = SetObjectFocus(pObj, TRUE, lRes);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
continue; // this is the container so skip it
|
|
}/* end of if statement */
|
|
|
|
if(-1 == lRes){
|
|
// did not want to handle focus, since the button is disabled
|
|
SetObjectFocus(pObj, FALSE, lRes);
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
} while (i != iEnd); /* end of do loop */
|
|
|
|
// OK lets try to set focus to somebody before
|
|
//CNTOBJ::iterator i;
|
|
if(fForward){
|
|
|
|
i = m_cntFocus.begin();
|
|
iEnd = m_cntFocus.end();
|
|
iEnd--;
|
|
}
|
|
else {
|
|
i = m_cntFocus.end();
|
|
i--;
|
|
iEnd = m_cntFocus.begin();
|
|
|
|
}/* end of if statement */
|
|
|
|
bFirst = TRUE;
|
|
|
|
do {
|
|
// do not advance if first time in the loop
|
|
if (!bFirst)
|
|
AdvanceIterator(i, fForward);
|
|
else
|
|
bFirst = FALSE;
|
|
|
|
// iterate through all the contained controls
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
ATLASSERT(FALSE);
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
if(pObj->IsInputEnabled()){
|
|
|
|
LONG lRes = 0;
|
|
HRESULT hr = SetObjectFocus(pObj, TRUE, lRes);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
continue; // this is the container so skip it
|
|
}/* end of if statement */
|
|
|
|
if(-1 == lRes){
|
|
// did not want to handle focus, since the button is disabled
|
|
SetObjectFocus(pObj, FALSE, lRes);
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
} while (i != iEnd); /* end of do loop */
|
|
|
|
//ATLASSERT(FALSE); // should not really hapen, to have all the objects disabled
|
|
return(hr);
|
|
}/* end of function MoveFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetClosestFocus */
|
|
/* Descrition: Sets the focus to the closes object to pObj if specified. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::SetClosestFocus(LONG& lRes, CHostedObject* pStartObj, bool fForward){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_cntFocus.empty()){
|
|
|
|
hr = S_FALSE;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
ResetFocusFlags();
|
|
|
|
// first remove the focus and remeber the object
|
|
bool fStartSettingFocus = false;
|
|
|
|
CNTOBJ::iterator i, iEnd;
|
|
|
|
if(fForward){
|
|
|
|
i = m_cntFocus.begin();
|
|
iEnd = m_cntFocus.end();
|
|
iEnd--;
|
|
}
|
|
else {
|
|
i = m_cntFocus.end();
|
|
i--;
|
|
iEnd = m_cntFocus.begin();
|
|
|
|
}/* end of if statement */
|
|
|
|
if(NULL == pStartObj){
|
|
|
|
pStartObj = (*i); // initialize our start object
|
|
}/* end of if statement */
|
|
|
|
BOOL bFirst = TRUE;
|
|
|
|
do {
|
|
// do not advance if first time in the loop
|
|
if (!bFirst)
|
|
AdvanceIterator(i, fForward);
|
|
else
|
|
bFirst = FALSE;
|
|
|
|
// iterate through all the contained controls
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
ATLASSERT(FALSE);
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
if(pObj == pStartObj){
|
|
|
|
fStartSettingFocus = true;
|
|
}/* end of if statement */
|
|
|
|
// try to set the focus to the next object
|
|
if(fStartSettingFocus ){
|
|
|
|
if(pObj->IsInputEnabled()){
|
|
|
|
LONG lRes = 0;
|
|
HRESULT hr = SetObjectFocus(pObj, TRUE, lRes);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
continue; // this is the container so skip it
|
|
}/* end of if statement */
|
|
|
|
if(-1 == lRes){
|
|
// did not want to handle focus, since the button is disabled
|
|
SetObjectFocus(pObj, FALSE, lRes);
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
} while (i != iEnd); /* end of do loop */
|
|
|
|
if(!fStartSettingFocus){
|
|
|
|
hr = S_FALSE;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
// OK lets try to set focus to somebody before
|
|
//CNTOBJ::iterator i;
|
|
if(fForward){
|
|
|
|
i = m_cntFocus.begin();
|
|
iEnd = m_cntFocus.end();
|
|
iEnd--;
|
|
}
|
|
else {
|
|
i = m_cntFocus.end();
|
|
i--;
|
|
iEnd = m_cntFocus.begin();
|
|
}/* end of if statement */
|
|
|
|
bFirst = TRUE;
|
|
|
|
do {
|
|
// do not advance if first time in the loop
|
|
if (!bFirst)
|
|
AdvanceIterator(i, fForward);
|
|
else
|
|
bFirst = FALSE;
|
|
|
|
// iterate through all the contained controls
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
ATLASSERT(FALSE);
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
if(pObj->IsInputEnabled()){
|
|
|
|
LONG lRes = 0;
|
|
HRESULT hr = SetObjectFocus(pObj, TRUE, lRes);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
continue; // this is the container so skip it
|
|
}/* end of if statement */
|
|
|
|
if(-1 == lRes){
|
|
// did not want to handle focus, since the button is disabled
|
|
SetObjectFocus(pObj, FALSE, lRes);
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
} while (i != iEnd); /* end of do loop */
|
|
|
|
ATLASSERT(FALSE); // should not really hapen, to have all the objects disabled
|
|
return(hr);
|
|
|
|
}/* end of function SetClosestFocus */
|
|
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnForwardMsg */
|
|
/* Description: Forwards the message to the active object. */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::OnForwardMsg(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/){
|
|
|
|
ATLTRACE2(atlTraceHosting, 2, TEXT("CMFBar::OnForwardMsg\n"));
|
|
|
|
ATLASSERT(lParam != 0);
|
|
LPMSG lpMsg = (LPMSG)lParam;
|
|
|
|
if(m_spActiveObject){
|
|
|
|
if(m_spActiveObject->TranslateAccelerator(lpMsg) == S_OK)
|
|
return 1;
|
|
}/* end of function OnForwardMessage */
|
|
return 0;
|
|
}/* end of function OnForwardMessage */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ReflectNotifications */
|
|
/* Description: Reflects the messages to the child windows */
|
|
/*************************************************************************/
|
|
LRESULT CMFBar::ReflectNotifications(UINT uMsg, WPARAM wParam, LPARAM lParam,
|
|
BOOL& bHandled){
|
|
HWND hWndChild = NULL;
|
|
|
|
switch(uMsg){
|
|
|
|
case WM_COMMAND:
|
|
if(lParam != NULL) // not from a menu
|
|
hWndChild = (HWND)lParam;
|
|
break;
|
|
case WM_NOTIFY:
|
|
hWndChild = ((LPNMHDR)lParam)->hwndFrom;
|
|
break;
|
|
case WM_PARENTNOTIFY:
|
|
switch(LOWORD(wParam))
|
|
{
|
|
case WM_CREATE:
|
|
case WM_DESTROY:
|
|
hWndChild = (HWND)lParam;
|
|
break;
|
|
default:
|
|
hWndChild = GetDlgItem(HIWORD(wParam));
|
|
break;
|
|
}
|
|
break;
|
|
case WM_DRAWITEM:
|
|
if(wParam) // not from a menu
|
|
hWndChild = ((LPDRAWITEMSTRUCT)lParam)->hwndItem;
|
|
break;
|
|
case WM_MEASUREITEM:
|
|
if(wParam) // not from a menu
|
|
hWndChild = GetDlgItem(((LPMEASUREITEMSTRUCT)lParam)->CtlID);
|
|
break;
|
|
case WM_COMPAREITEM:
|
|
if(wParam) // not from a menu
|
|
hWndChild = GetDlgItem(((LPCOMPAREITEMSTRUCT)lParam)->CtlID);
|
|
break;
|
|
case WM_DELETEITEM:
|
|
if(wParam) // not from a menu
|
|
hWndChild = GetDlgItem(((LPDELETEITEMSTRUCT)lParam)->CtlID);
|
|
break;
|
|
case WM_VKEYTOITEM:
|
|
case WM_CHARTOITEM:
|
|
case WM_HSCROLL:
|
|
case WM_VSCROLL:
|
|
hWndChild = (HWND)lParam;
|
|
break;
|
|
case WM_CTLCOLORBTN:
|
|
case WM_CTLCOLORDLG:
|
|
case WM_CTLCOLOREDIT:
|
|
case WM_CTLCOLORLISTBOX:
|
|
case WM_CTLCOLORMSGBOX:
|
|
case WM_CTLCOLORSCROLLBAR:
|
|
case WM_CTLCOLORSTATIC:
|
|
hWndChild = (HWND)lParam;
|
|
break;
|
|
default:
|
|
break;
|
|
}/* end of switch statement */
|
|
|
|
if(hWndChild == NULL){
|
|
|
|
bHandled = FALSE;
|
|
return 1;
|
|
}/* end of if statememnt */
|
|
|
|
ATLASSERT(::IsWindow(hWndChild));
|
|
return ::SendMessage(hWndChild, OCM__BASE + uMsg, wParam, lParam);
|
|
}/* end of function ReflectNotifications */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_Caption */
|
|
/* Description: Sets the caption to the window if present and handles */
|
|
/* the ambient property implementation. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::put_Caption(BSTR bstrCaption){
|
|
|
|
ATLTRACE2(atlTraceControls,2,_T("CStockPropImpl::put_Caption\n"));
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if (FireOnRequestEdit(DISPID_CAPTION) == S_FALSE){
|
|
|
|
return S_FALSE;
|
|
}/* end of if statement */
|
|
|
|
m_bstrCaption = bstrCaption;
|
|
m_bRequiresSave = TRUE;
|
|
FireOnChanged(DISPID_CAPTION);
|
|
FireViewChange();
|
|
SendOnDataChange(NULL);
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
#ifdef _UNICODE
|
|
::SetWindowText(m_hWnd, bstrCaption);
|
|
#else
|
|
USES_CONVERSION;
|
|
LPTSTR strTemp = OLE2T(bstrCaption);
|
|
if (strTemp != NULL)
|
|
{
|
|
::SetWindowText(m_hWnd, strTemp);
|
|
}
|
|
else
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
#endif
|
|
}/* end of if statement */
|
|
|
|
return hr;
|
|
}/* end of function put_Caption */
|
|
|
|
/*************************************************************************/
|
|
/* Function: BitsPerPixel */
|
|
/* Description: Gets the number of bits per pixel. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::BitsPerPixel(long *plBits){
|
|
|
|
HRESULT hr = S_OK;
|
|
try {
|
|
|
|
HWND hwnd = NULL;
|
|
|
|
hr = GetWindow(&hwnd);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
HDC hdc = ::GetWindowDC(hwnd);
|
|
|
|
if(NULL == hdc){
|
|
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
*plBits = ::GetDeviceCaps(hdc, BITSPIXEL);
|
|
|
|
::ReleaseDC(hwnd, hdc);
|
|
|
|
}
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
|
|
hr = E_UNEXPECTED;
|
|
}/* end of try statement */
|
|
|
|
return(hr);
|
|
}/* end of function BitsPerPixel */
|
|
|
|
// ##### BEGIN ACTIVEX SCRIPTING SUPPORT #####
|
|
/*************************************************************************/
|
|
/* IActiveScriptSite Interface Implementation */
|
|
/*************************************************************************/
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_CmdLine */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::get_CmdLine(BSTR *pVal){
|
|
|
|
if(NULL == pVal){
|
|
|
|
return(E_POINTER);
|
|
}/* end of if statement */
|
|
|
|
*pVal = m_strCmdLine.Copy();
|
|
return S_OK;
|
|
}/* end of function get_CmdLine */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_CmdLine */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::put_CmdLine(BSTR newVal){
|
|
|
|
m_strCmdLine = newVal;
|
|
return S_OK;
|
|
}/* end of function put_CmdLine */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetUserLCID */
|
|
/* Description: Gets the user default LCID */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::GetUserLCID(long *plcid){
|
|
|
|
*plcid = ::GetUserDefaultLCID();
|
|
return (S_OK);
|
|
}/* end of function GetUserLCID */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetLCID */
|
|
/* Description: Gets the user default LCID */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::GetLCID(LCID *plcid){
|
|
|
|
*plcid = ::GetUserDefaultLCID();
|
|
return (S_OK);
|
|
}/* end of function GetLCID */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetItemInfo */
|
|
/* Description: Returns IUnknown or TypeInfo of the contained (embedded) */
|
|
/* objects in the active script, in this case we return also a container,*/
|
|
/* since we can script it as well (but the script container is inserted */
|
|
/* in the list as well, so no special case for it. */
|
|
/* TODO: Might want to optimize and use hash table for faster compares. */
|
|
/* on the other hand it seems like a script engine calls this just once */
|
|
/* for an object an then reuses its internal reference. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::GetItemInfo(LPCOLESTR strObjectID, DWORD dwReturnMask,
|
|
IUnknown** ppunkItemOut, ITypeInfo** pptinfoOut){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if (dwReturnMask & SCRIPTINFO_ITYPEINFO){
|
|
|
|
if (!pptinfoOut){
|
|
|
|
return E_INVALIDARG;
|
|
}/* end of if statement */
|
|
|
|
*pptinfoOut = NULL;
|
|
}/* end of if statement */
|
|
|
|
if (dwReturnMask & SCRIPTINFO_IUNKNOWN){
|
|
|
|
if (!ppunkItemOut){
|
|
return E_INVALIDARG;
|
|
}/* end of if statement */
|
|
|
|
*ppunkItemOut = NULL;
|
|
}/* end of if statement */
|
|
|
|
CHostedObject* pObj;
|
|
|
|
if(SUCCEEDED(FindObject(const_cast<BSTR>(strObjectID), &pObj))){
|
|
|
|
if (dwReturnMask & SCRIPTINFO_ITYPEINFO){
|
|
|
|
hr = pObj->GetTypeInfo(0, ::GetUserDefaultLCID(), pptinfoOut);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
if (dwReturnMask & SCRIPTINFO_IUNKNOWN){
|
|
|
|
*ppunkItemOut = pObj->GetUnknown(); // does AddRef under the hood
|
|
(*ppunkItemOut)->AddRef();
|
|
}/* end of if statement */
|
|
|
|
return(hr); // found out item no need to dig around longer
|
|
}/* end of for loop */
|
|
|
|
return TYPE_E_ELEMENTNOTFOUND;
|
|
}/* end of function GetItemInfo */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetDocVersionString */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::GetDocVersionString(BSTR *pbstrVersion ){
|
|
|
|
return (E_NOTIMPL);
|
|
}/* end of function GetDocVersionString */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnScriptTerminate */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::OnScriptTerminate(const VARIANT *pvarResult,
|
|
const EXCEPINFO *pexcepinfo){
|
|
|
|
return (E_NOTIMPL);
|
|
}/* end of function OnScriptTerminate */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnStateChange */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::OnStateChange(SCRIPTSTATE ssScriptState){
|
|
|
|
return (E_NOTIMPL);
|
|
}/* end of function OnStateChange */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnScriptError */
|
|
/* Description: Display the script error in debug mode, skip it in */
|
|
/* release mode for now. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::OnScriptError(IActiveScriptError *pse){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
WCHAR szError[1024];
|
|
EXCEPINFO ei;
|
|
DWORD dwSrcContext;
|
|
ULONG ulLine;
|
|
LONG ichError;
|
|
BSTR bstrLine = NULL;
|
|
|
|
|
|
hr = pse->GetExceptionInfo(&ei);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = pse->GetSourcePosition(&dwSrcContext, &ulLine, &ichError);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = pse->GetSourceLineText(&bstrLine);
|
|
|
|
if (hr){
|
|
|
|
hr = S_OK; // Ignore this error, there may not be source available
|
|
}/* end of if statement */
|
|
|
|
if (!hr){
|
|
|
|
wsprintfW(szError, L"Source:'%s'\n Line:%d Description:%s\n",
|
|
ei.bstrSource, ulLine, ei.bstrDescription);
|
|
#ifdef _DEBUG
|
|
USES_CONVERSION;
|
|
//ATLTRACE(OLE2T(szError));
|
|
::MessageBeep((UINT)-1);
|
|
::MessageBoxW(::GetFocus(), szError, L"Error", MB_OK);
|
|
#endif
|
|
// TODO: Add real error handling for released version
|
|
}/* end of if statment */
|
|
|
|
if (bstrLine){
|
|
|
|
::SysFreeString(bstrLine);
|
|
}/* end of if statement */
|
|
|
|
#endif
|
|
return hr;
|
|
}/* end of function OnScriptError */
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
STDMETHODIMP CMFBar::OnEnterScript
|
|
(
|
|
void
|
|
)
|
|
{
|
|
// No need to do anything
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
STDMETHODIMP CMFBar::OnLeaveScript
|
|
(
|
|
void
|
|
)
|
|
{
|
|
// No need to do anything
|
|
return S_OK;
|
|
}
|
|
|
|
// ##### END ACTIVEX SCRIPTING SUPPORT #####
|
|
|
|
/*************************************************************************/
|
|
/* Function: About */
|
|
/* Description: Displayes about box. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::About(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
const INT ciMaxBuffSize = MAX_PATH; // enough for the text
|
|
TCHAR strBuffer[ciMaxBuffSize];
|
|
TCHAR strBufferAbout[ciMaxBuffSize];
|
|
|
|
if(!::LoadString(m_hRes, IDS_BAR_ABOUT, strBuffer, ciMaxBuffSize)){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(!::LoadString(m_hRes, IDS_ABOUT, strBufferAbout, ciMaxBuffSize)){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
::MessageBox(::GetFocus(), strBuffer, strBufferAbout, MB_OK);
|
|
|
|
return (hr);
|
|
}/* end of function About */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetObjectUnknown */
|
|
/* Description: Iterates throught the object collection, finds the */
|
|
/* object that has the specific ID then returns it IUnknown. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::GetObjectUnknown(BSTR strObjectID, IUnknown **ppUnk){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == strObjectID){
|
|
|
|
return E_POINTER;
|
|
}/* end of if statement */
|
|
|
|
if(NULL == ppUnk){
|
|
|
|
return E_POINTER;
|
|
}/* end of if statement */
|
|
|
|
*ppUnk = NULL;
|
|
|
|
CHostedObject* pObj;
|
|
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
*ppUnk = pObj->GetUnknown();
|
|
hr = S_OK;
|
|
|
|
if(*ppUnk == NULL){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
(*ppUnk)->AddRef(); // adds the reference, since we are giving out
|
|
|
|
return (hr);
|
|
}/* end of function GetObjectUnknown */
|
|
|
|
/*************************************************************************/
|
|
/* Function: InvalidateObjectRect */
|
|
/* Description: Invalidates the object. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::InvalidateObjectRect(BSTR strObjectID){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == strObjectID){
|
|
|
|
return E_POINTER;
|
|
}/* end of if sattement */
|
|
|
|
CHostedObject* pObj;
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
CContainerObject* pCnt;
|
|
hr = pObj->GetContainerObject(&pCnt);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = pCnt->InvalidateObjectRect();
|
|
|
|
return (hr);
|
|
}/* end of function InvalidateObjectRect */
|
|
|
|
/*************************************************************************/
|
|
/* Function: Invalidate */
|
|
/* Description: Invalidates the whole container, which in turns repaints */
|
|
/* all the controls. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::Invalidate(){
|
|
|
|
HRESULT hr = InvalidateRect(NULL, FALSE);
|
|
|
|
return (hr);
|
|
}/* end of function Invalidate */
|
|
|
|
/*************************************************************************/
|
|
/* Function: EnableObject */
|
|
/* Description: Goes trough the objects and enables or disables it */
|
|
/* depending on the flag. Invalidates the objects rect as well. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::EnableObject(BSTR strObjectID, VARIANT_BOOL fEnable){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == strObjectID){
|
|
|
|
return E_POINTER;
|
|
}/* end of if sattement */
|
|
|
|
CHostedObject* pObj;
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
bool fTmpEnable = VARIANT_FALSE == fEnable ? false: true;
|
|
|
|
CContainerObject* pCnt;
|
|
hr = pObj->GetContainerObject(&pCnt);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
if(pObj->GetUnknown() == GetUnknown()){
|
|
// special case when we are invalidating our self/ the self hosted container
|
|
if(fTmpEnable){
|
|
|
|
InvalidateRect(NULL, false);
|
|
}/* end of if statement */
|
|
pObj->SetActive(fTmpEnable);
|
|
hr = S_OK;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
}/* end of if statemenet */
|
|
|
|
if (pObj->IsActive() == fTmpEnable)
|
|
return S_OK;
|
|
|
|
pObj->SetActive(fTmpEnable);
|
|
|
|
if(false == fTmpEnable){
|
|
|
|
LONG lRes = 0;
|
|
if (pObj->HasFocus()) {
|
|
|
|
SetClosestFocus(lRes);
|
|
//MoveFocus(true, lRes);
|
|
//SetObjectFocus(pObj, FALSE, lRes);
|
|
}
|
|
|
|
if(pObj->HasCapture()){
|
|
|
|
pCnt->SetCapture(FALSE);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
// invalidate area where the object lives
|
|
if(pObj->IsWindowless()){
|
|
|
|
// invalidate the rect only if we are windowless control
|
|
// the windowed control shopuld be able
|
|
// to update itself depending on the SW_SHOW, HIDE messagess
|
|
hr = pCnt->InvalidateObjectRect();
|
|
}/* end of if statement */
|
|
|
|
return (hr);
|
|
}/* end of function EnableObject */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ObjectEnabled */
|
|
/* Description: Goes trough the objects and checks if the particular */
|
|
/* object is enabled or disabled. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::ObjectEnabled(BSTR strObjectID, VARIANT_BOOL *pfEnabled){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == pfEnabled){
|
|
|
|
hr = E_POINTER;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(NULL == strObjectID){
|
|
|
|
hr = E_POINTER;
|
|
return(hr);
|
|
}/* end of if sattement */
|
|
|
|
CHostedObject* pObj;
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
*pfEnabled = pObj->IsActive()? VARIANT_TRUE : VARIANT_FALSE;
|
|
|
|
return (hr);
|
|
}/* end of function ObjectEnabled */
|
|
|
|
/*************************************************************************/
|
|
/* Function: EnableObjectInput */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::EnableObjectInput(BSTR strObjectID, VARIANT_BOOL fEnable){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == strObjectID){
|
|
|
|
return E_POINTER;
|
|
}/* end of if sattement */
|
|
|
|
CHostedObject* pObj;
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
bool fTmpEnable = VARIANT_FALSE == fEnable ? false: true;
|
|
|
|
CContainerObject* pCnt;
|
|
hr = pObj->GetContainerObject(&pCnt);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
if(pObj->GetUnknown() == GetUnknown()){
|
|
// special case when we are invalidating our self/ the self hosted container
|
|
if(fTmpEnable){
|
|
|
|
InvalidateRect(NULL, false);
|
|
}/* end of if statement */
|
|
pObj->SetInputEnabled(fTmpEnable);
|
|
hr = S_OK;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(NULL == pCnt){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
}/* end of if statemenet */
|
|
|
|
if (pObj->IsInputEnabled() == fTmpEnable)
|
|
return S_OK;
|
|
|
|
pObj->SetInputEnabled(fTmpEnable);
|
|
|
|
if(false == fTmpEnable){
|
|
|
|
LONG lRes = 0;
|
|
SetClosestFocus(lRes);
|
|
//MoveFocus(true, lRes);
|
|
//SetObjectFocus(pObj, FALSE, lRes);
|
|
|
|
if(pObj->HasCapture()){
|
|
|
|
pCnt->SetCapture(FALSE);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
// invalidate area where the object lives
|
|
if(pObj->IsWindowless()){
|
|
|
|
// invalidate the rect only if we are windowless control
|
|
// the windowed control shopuld be able
|
|
// to update itself depending on the SW_SHOW, HIDE messagess
|
|
hr = pCnt->InvalidateObjectRect();
|
|
}/* end of if statement */
|
|
|
|
return (hr);
|
|
}/* end of function EnableObjectInput */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ObjectInputEnabled */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::ObjectInputEnabled(BSTR strObjectID, VARIANT_BOOL *pfEnabled){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == pfEnabled){
|
|
|
|
hr = E_POINTER;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(NULL == strObjectID){
|
|
|
|
hr = E_POINTER;
|
|
return(hr);
|
|
}/* end of if sattement */
|
|
|
|
CHostedObject* pObj;
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
*pfEnabled = pObj->IsInputEnabled()? VARIANT_TRUE : VARIANT_FALSE;
|
|
|
|
return (hr);
|
|
}/* end of function ObjectInputEnabled */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetCookie */
|
|
/* Description: Sets a cookie to object, so it can be retrived later. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::SetCookie(BSTR strObjectID, VARIANT vCookie){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == strObjectID){
|
|
|
|
return E_POINTER;
|
|
}/* end of if sattement */
|
|
|
|
CHostedObject* pObj;
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
pObj->SetCookie(vCookie);
|
|
|
|
return (hr);
|
|
}/* end of function SetCookie */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetCookie */
|
|
/* Description: Gets help ID associated with the object. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::GetCookie(BSTR strObjectID, VARIANT *pvCookie){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == pvCookie){
|
|
|
|
hr = E_POINTER;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(NULL == strObjectID){
|
|
|
|
hr = E_POINTER;
|
|
return(hr);
|
|
}/* end of if sattement */
|
|
|
|
CHostedObject* pObj;
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = pObj->GetCookie(pvCookie);
|
|
|
|
return (hr);
|
|
}/* end of function GetCookie */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ForceKey */
|
|
/* Description: Forces the in the eventa handling code. */
|
|
/* The fEat disables or enables default key handler. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::ForceKey(LONG lVirtKey, LONG lKeyData, VARIANT_BOOL fEat){
|
|
|
|
m_fForceKey = true; // set the flag for key handler routine
|
|
|
|
m_fEat = (fEat == VARIANT_FALSE ? VARIANT_FALSE : VARIANT_TRUE); // disable or enable this call
|
|
m_lVirtKey = lVirtKey; // put in data
|
|
m_lKeyData = lKeyData; // put in data
|
|
|
|
return S_OK;
|
|
}/* end of function ForceKey */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_ScriptLanguage */
|
|
/* Description: Gets current script language such as JScript, VBScript */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::get_ScriptLanguage(BSTR *pstrScriptLanguage){
|
|
|
|
if(NULL == pstrScriptLanguage){
|
|
|
|
return(E_POINTER);
|
|
}/* end of if statement */
|
|
|
|
*pstrScriptLanguage = m_strScriptLanguage.Copy();
|
|
return S_OK;
|
|
}/* end of function get_ScriptLanguage */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_ScriptLanguage */
|
|
/* Description: Gets current script language such as JScript, VBScript */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::put_ScriptLanguage(BSTR strScriptLanguage){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if (m_ps){
|
|
|
|
hr = E_FAIL; // Already created the script engine, so it
|
|
// will not take an effect untill we unload it
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
m_strScriptLanguage = strScriptLanguage;
|
|
|
|
return (hr);
|
|
}/* end of function put_ScriptLanguage */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_ScriptFile */
|
|
/* Description: Gets the current script file. */
|
|
/* By default we have empty string which means loading from Windows */
|
|
/* resources, which is not really a file. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::get_ScriptFile(BSTR *pstrScriptFile){
|
|
|
|
if(NULL == pstrScriptFile){
|
|
|
|
return(E_POINTER);
|
|
}/* end of if statement */
|
|
|
|
*pstrScriptFile = m_strScriptFile.Copy();
|
|
return S_OK;
|
|
}/* end of function get_ScriptFile */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_ScriptFile */
|
|
/* Description: Sets the script file. Only valid before the load and */
|
|
/* unload. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::put_ScriptFile(BSTR strScriptFile){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
if(VARIANT_TRUE == m_fAutoLoad){
|
|
|
|
hr = DestroyScriptEngine();
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
m_strScriptFile = strScriptFile;
|
|
|
|
hr = Load();
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
const INT ciMaxBuffSize = MAX_PATH; // enough for the text
|
|
TCHAR strBuffer[ciMaxBuffSize];
|
|
|
|
if(!::LoadString(m_hRes, IDS_MAIN_ENTRY, strBuffer, ciMaxBuffSize)){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
USES_CONVERSION;
|
|
hr = Run(T2OLE(strBuffer));
|
|
|
|
}
|
|
else {
|
|
|
|
// case when we are loading manually
|
|
|
|
|
|
if (m_ps){
|
|
|
|
hr = E_FAIL; // Already created the script engine, so it
|
|
// will not take an effect untill we unload it
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
m_strScriptFile = strScriptFile;
|
|
}/* end of if statement */
|
|
|
|
}/* end of try statement */
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return (hr);
|
|
}/* end of function put_ScriptFile */
|
|
|
|
/*************************************************************************/
|
|
/* IActiveScriptSiteWindow Interface Implementation */
|
|
/*************************************************************************/
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetWindow */
|
|
/* Description: Gets the window. If we are windowless we do not pass */
|
|
/* down the parent window, since that seems to confuse the control */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::GetWindow(HWND *phwndOut){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!phwndOut){
|
|
|
|
hr = E_INVALIDARG;
|
|
return (hr);
|
|
}/* end of if statement */
|
|
|
|
|
|
if(m_bWndLess){
|
|
if(!::IsWindow(m_hWnd)){
|
|
|
|
return(GetParentHWND(phwndOut));
|
|
}/* end of if statement */
|
|
}
|
|
else {
|
|
if(!::IsWindow(m_hWnd)){
|
|
|
|
*phwndOut = NULL;
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
*phwndOut = m_hWnd;
|
|
|
|
return(hr);
|
|
}/* end of function GetWindow */
|
|
|
|
/*************************************************************************/
|
|
/* Function: EnableModeless */
|
|
/* Description: Sets the window from which the UI elemnt can come out */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::EnableModeless(BOOL fModeless){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_hWnd == NULL){
|
|
|
|
hr = E_NOTIMPL;
|
|
return (hr);
|
|
}/* end of if statement */
|
|
|
|
::EnableWindow(m_hWnd, fModeless);
|
|
return(hr);
|
|
}/* end of function EnableModeless */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_MinWidth */
|
|
/* Description: Gets the minimum width beyond which we do not resize. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::get_MinWidth(long *pVal){
|
|
|
|
if(NULL == pVal){
|
|
|
|
return(E_POINTER);
|
|
}/* end of if statement */
|
|
|
|
*pVal = m_lMinWidth;
|
|
return S_OK;
|
|
}/* end of function get_MinWidth */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_MinWidth */
|
|
/* Description: Puts the minimum width beyond which we do not resize. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::put_MinWidth(long newVal){
|
|
|
|
m_lMinWidth = newVal;
|
|
return S_OK;
|
|
}/* end of function put_MinWidth */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_MinWidth */
|
|
/* Description: Gets the minimum height beyond which we do not resize. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::get_MinHeight(long *pVal){
|
|
|
|
if(NULL == pVal){
|
|
|
|
return(E_POINTER);
|
|
}/* end of if statement */
|
|
|
|
*pVal = m_lMinHeight;
|
|
return S_OK;
|
|
}/* end of function get_MinHeight */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_MinHeight */
|
|
/* Description: Sets the minimum height beyond which we do not resize. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::put_MinHeight(long newVal){
|
|
|
|
m_lMinHeight = newVal;
|
|
return S_OK;
|
|
}/* end of function put_MinHeight */
|
|
|
|
// ##### BEGIN ACTIVEX SCRIPTING SUPPORT #####
|
|
|
|
/*************************************************************************/
|
|
/* Function: CreateScriptEngine */
|
|
/* Description: Initializes the script engine. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::CreateScriptEngine(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifndef _UNICODE
|
|
USES_CONVERSION;
|
|
#endif
|
|
|
|
if (m_ps){
|
|
|
|
hr = S_FALSE; // Already created the script engine
|
|
return(hr); // so get out
|
|
}/* end of if statement */
|
|
|
|
/*************************************************************************/
|
|
/* add (this) the container as a scriptable object as well */
|
|
/* this is special case so we can call script on our self as well */
|
|
/*************************************************************************/
|
|
const INT ciMaxBuffSize = MAX_PATH; // should be enough for tlbr ID, keep ID small if can
|
|
TCHAR strBuffer[ciMaxBuffSize];
|
|
|
|
if(!::LoadString(m_hRes, IDS_ROOT_OBJECT, strBuffer, ciMaxBuffSize)){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
CComPtr<IUnknown> pUnk = GetUnknown();
|
|
CComQIPtr<IDispatch> pDisp (pUnk);
|
|
|
|
if(!pDisp){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
#ifdef _UNICODE
|
|
BSTR strObjectID = ::SysAllocString(strBuffer); // gets freed in the destructor of the holding object
|
|
#else
|
|
BSTR strObjectID = ::SysAllocString(T2OLE(strBuffer));
|
|
#endif
|
|
|
|
hr = AddObject(strObjectID, pDisp); // this one adds the object to the list as well
|
|
|
|
::SysFreeString(strObjectID); // free up the sys string, since we allocate it in the contructor for the object
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(!m_strScriptLanguage){
|
|
// load what script language we decided to support if not set explicitly by user
|
|
if(!::LoadString(m_hRes, IDS_SCRIPT_LANGUAGE, strBuffer, ciMaxBuffSize)){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
m_strScriptLanguage = strBuffer;
|
|
}/* end of if statement */
|
|
|
|
CLSID clsid;
|
|
|
|
hr = ::CLSIDFromProgID(m_strScriptLanguage, &clsid); // get the language
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return hr;
|
|
}/* end of if statement */
|
|
|
|
hr = m_ps.CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER);
|
|
// Create the ActiveX Scripting Engine
|
|
//hr = ::CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_IActiveScript, (void **)&m_ps);
|
|
if (FAILED(hr)){
|
|
|
|
//s_pszError = "Creating the ActiveX Scripting engine failed. Scripting engine is probably not correctly registered or CLSID incorrect.";
|
|
return (hr);
|
|
}/* end of if statement */
|
|
|
|
// Script Engine must support IActiveScriptParse for us to use it
|
|
hr = m_ps->QueryInterface(IID_IActiveScriptParse, (void**) &m_psp);
|
|
|
|
if (FAILED(hr)){
|
|
|
|
//s_pszError = "ActiveX Scripting engine does not support IActiveScriptParse";
|
|
return (hr);
|
|
}/* end of if statement */
|
|
|
|
hr = m_ps->SetScriptSite(this);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return hr;
|
|
}/* end of if statement */
|
|
|
|
// InitNew the object:
|
|
hr = m_psp->InitNew();
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return hr;
|
|
}/* end of if statement */
|
|
|
|
// Adding dynamically added items so they can be recognized by name
|
|
// and scripted via script language such as VBScript or JScript
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
|
|
// iterate throw the array and see if we find matching ID
|
|
CHostedObject* pObj = (*i);
|
|
|
|
hr = m_ps->AddNamedItem((pObj)->GetID(), SCRIPTITEM_ISVISIBLE | SCRIPTITEM_ISSOURCE);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr); // might want to modify this later to not exit if we get one bad object
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
// Special case adding the root object
|
|
if(!::LoadString(m_hRes, IDS_ROOT_OBJECT, strBuffer, ciMaxBuffSize)){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
#ifdef _UNICODE
|
|
hr = m_ps->AddNamedItem(strBuffer, SCRIPTITEM_ISVISIBLE | SCRIPTITEM_ISSOURCE);
|
|
#else
|
|
hr = m_ps->AddNamedItem(A2W(strBuffer), SCRIPTITEM_ISVISIBLE | SCRIPTITEM_ISSOURCE);
|
|
#endif
|
|
|
|
// Add up the events that we have saved in the event array
|
|
for(CNTEVNT::iterator j = m_cntEvnt.begin(); j!= m_cntEvnt.end(); j++){
|
|
|
|
EXCEPINFO ei;
|
|
::ZeroMemory(&ei, sizeof(EXCEPINFO));
|
|
|
|
BSTR strName;
|
|
CEventObject* pObj = (*j);
|
|
|
|
hr = m_psp->AddScriptlet(NULL, pObj->m_strEventCode, pObj->m_strObjectID, NULL, pObj->m_strEvent, NULL, 0, 0, 0, &strName, &ei);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
ATLTRACE(TEXT("Failed to add an event, might be using a different language or the object does not exists. \n"));
|
|
ATLASSERT(FALSE);
|
|
return(hr);
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
return (hr);
|
|
}/* end of function CreateScriptEngine */
|
|
|
|
/*************************************************************************/
|
|
/* Function: DestroyScriptEngine */
|
|
/* Description: Destroys the engine. Might be usefull when using one */
|
|
/* script to initialize the objects and the other script to run the */
|
|
/* objects. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::DestroyScriptEngine(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_ps){
|
|
|
|
hr = m_ps->SetScriptState(SCRIPTSTATE_DISCONNECTED);
|
|
}/* end of if statement */
|
|
|
|
// Release the language engine, since it may hold on to us
|
|
if (m_psp){
|
|
|
|
m_psp.Release();
|
|
}/* end of if statement */
|
|
|
|
if (m_ps){
|
|
|
|
//HRESULT hrTmp = m_ps->InterruptScriptThread(SCRIPTTHREADID_CURRENT, NULL, SCRIPTINTERRUPT_DEBUG);
|
|
//ATLASSERT(SUCCEEDED(hrTmp));
|
|
|
|
hr = m_ps->Close();
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
m_ps.Release();
|
|
}/* end of if statement */
|
|
|
|
return (hr);
|
|
}/* end of function DestroyScriptEngine */
|
|
|
|
/*************************************************************************/
|
|
/* Function: Load */
|
|
/* Description: Loads the script. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::Load(){
|
|
|
|
//#ifndef _UNICODE_SCRIPT_FILE
|
|
USES_CONVERSION;
|
|
//#endif
|
|
|
|
HRESULT hr = CreateScriptEngine();
|
|
|
|
if(FAILED(hr)){
|
|
|
|
ATLTRACE(TEXT("Failed to create a script engine.\n"));
|
|
ATLASSERT(FALSE);
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
// see if we can find this resource DLL in the script
|
|
// TCHAR* strType = TEXT("SCRIPT");
|
|
|
|
LPTSTR strTemp = OLE2T(m_strScriptFile);
|
|
|
|
if (NULL == strTemp)
|
|
{
|
|
hr = E_POINTER;
|
|
return hr;
|
|
}
|
|
|
|
HRSRC hrscScript = ::FindResource(m_hRes, strTemp, MAKEINTRESOURCE(23));
|
|
|
|
if(NULL != hrscScript){
|
|
|
|
/**********************************************************************/
|
|
/* load up the script from a resource */
|
|
/**********************************************************************/
|
|
|
|
if(NULL == hrscScript){
|
|
|
|
hr = HRESULT_FROM_WIN32(::GetLastError());
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
HGLOBAL hScript = ::LoadResource(m_hRes, hrscScript);
|
|
|
|
if(NULL == hScript){
|
|
|
|
hr = HRESULT_FROM_WIN32(::GetLastError());
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
DWORD dwSize = ::SizeofResource((HMODULE)m_hRes, hrscScript);
|
|
|
|
if(dwSize == 0){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
/*****************************************************************/
|
|
/* change this depending if the file was saved as Unicode or not */
|
|
/*****************************************************************/
|
|
#ifndef _UNICODE_SCRIPT_FILE
|
|
WCHAR* strCode = A2W((CHAR*)hScript);
|
|
//delete[] hScript; // free up the temp buffer
|
|
#else
|
|
// work around script engine bug which does not recognize termination string
|
|
BSTR strCode = ::SysAllocStringLen((WCHAR*)hScript+ 1,dwSize / (sizeof(WCHAR) /sizeof(BYTE)) - 1);
|
|
ATLASSERT(strCode[dwSize / (sizeof(WCHAR) /sizeof(BYTE)) - 1] == 0x0000);
|
|
//strCode ++; // skip the word that indicates the byte order
|
|
#endif
|
|
|
|
EXCEPINFO ei;
|
|
::ZeroMemory(&ei, sizeof(EXCEPINFO));
|
|
hr = m_psp->ParseScriptText(strCode, NULL, NULL, NULL, 0, 0, SCRIPTTEXT_ISEXPRESSION|SCRIPTTEXT_ISVISIBLE, NULL, &ei);
|
|
|
|
#ifdef _UNICODE_SCRIPT_FILE
|
|
::SysFreeString(strCode);
|
|
#endif
|
|
|
|
}
|
|
else {
|
|
/**********************************************************************/
|
|
/* load up the script from a file */
|
|
/**********************************************************************/
|
|
// Create File m_strScriptFile
|
|
HANDLE hFile = ::CreateFile(
|
|
OLE2T(m_strScriptFile), // pointer to name of the file
|
|
GENERIC_READ, // access (read-write) mode
|
|
FILE_SHARE_READ, // share mode
|
|
NULL, // pointer to security descriptor
|
|
OPEN_EXISTING, // how to create
|
|
FILE_ATTRIBUTE_NORMAL, // file attributes
|
|
NULL // handle to file with attributes to copy
|
|
);
|
|
|
|
if(hFile == INVALID_HANDLE_VALUE){
|
|
|
|
hr = HRESULT_FROM_WIN32(::GetLastError());
|
|
|
|
#if _DEBUG
|
|
|
|
TCHAR strBuffer[MAX_PATH + 25];
|
|
wsprintf(strBuffer, TEXT("Failed to open script file %s"), OLE2T(m_strScriptFile));
|
|
::MessageBox(::GetFocus(), strBuffer, TEXT("Error"), MB_OK);
|
|
#endif
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
DWORD dwBitsSize = GetFileSize(hFile,NULL);
|
|
|
|
if(0 == dwBitsSize){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr); // the file size should be definetly more then 0
|
|
}/* end of if statement */
|
|
|
|
BYTE* pbBuffer = new BYTE[dwBitsSize + sizeof(WCHAR)];
|
|
::ZeroMemory(pbBuffer, dwBitsSize + sizeof(WCHAR));
|
|
|
|
// load it up convert the text to UNICODE
|
|
DWORD dwBytesRead = 0;
|
|
|
|
if(!ReadFile(hFile, pbBuffer, dwBitsSize, &dwBytesRead, NULL)){
|
|
|
|
hr = HRESULT_FROM_WIN32(::GetLastError());
|
|
delete[] pbBuffer;
|
|
::CloseHandle(hFile); // close the file
|
|
return (hr);
|
|
}/* end of function ReadFile */
|
|
|
|
if(dwBitsSize != dwBytesRead){
|
|
|
|
ATLTRACE(TEXT("Implement reading loop"));
|
|
delete[] pbBuffer; // free up the temp buffer
|
|
::CloseHandle(hFile); // close the file
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
/*****************************************************************/
|
|
/* change this depending if the file was saved as Unicode or not */
|
|
/*****************************************************************/
|
|
#ifndef _UNICODE_TEST_SCRIPT_FILE
|
|
WCHAR* strCode = A2W((CHAR*)pbBuffer);
|
|
delete[] pbBuffer; // free up the temp buffer
|
|
#else
|
|
WCHAR* strCode = (WCHAR*)pbBuffer;
|
|
#endif
|
|
::CloseHandle(hFile); // close the file
|
|
|
|
EXCEPINFO ei;
|
|
::ZeroMemory(&ei, sizeof(EXCEPINFO));
|
|
|
|
#ifdef _UNICODE
|
|
hr = m_psp->ParseScriptText(strCode, NULL, NULL, NULL, 0, 0, SCRIPTTEXT_ISEXPRESSION|SCRIPTTEXT_ISVISIBLE, NULL, &ei);
|
|
#else
|
|
hr = m_psp->ParseScriptText(strCode, NULL, NULL, NULL, 0, 0, SCRIPTTEXT_ISEXPRESSION|SCRIPTTEXT_ISVISIBLE, NULL, &ei);
|
|
#endif
|
|
}/* end of if statement */
|
|
|
|
// take out the extra character at the begining of the unicode file just in case it is garbled by editor
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = m_ps->SetScriptState(/* SCRIPTSTATE_STARTED */ SCRIPTSTATE_CONNECTED);
|
|
|
|
return hr;
|
|
}/* end of function Load */
|
|
|
|
/*************************************************************************/
|
|
/* Function: AddScriptlet */
|
|
/* Description: Using this method you can add events for JScript and */
|
|
/* other languages that do not support event handlers internally. This */
|
|
/* method just add these to the array which does get initializied on load*/
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::AddScriptlet(BSTR strObjectID, BSTR strEvent, BSTR strEventCode){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
CEventObject* pObj = new CEventObject(strObjectID, strEvent, strEventCode);
|
|
|
|
if(NULL == pObj){
|
|
|
|
hr = E_OUTOFMEMORY;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
m_cntEvnt.insert(m_cntEvnt.end(), pObj);
|
|
|
|
return(hr);
|
|
}/* end of function AddScriptlet */
|
|
|
|
/*************************************************************************/
|
|
/* Function: HookScriptlet */
|
|
/* Description: Hooks the scrtiptlet for immidiate use, unlike the */
|
|
/* Add scriptlet which adds it, so it takes effect in the next Load. */
|
|
/* However, it also adds the callback to the array, so if needs to be */
|
|
/* loaded on the next load. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::HookScriptlet(BSTR strObjectID, BSTR strEvent, BSTR strEventCode){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
hr = AddScriptlet(strObjectID, strEvent, strEventCode);
|
|
|
|
if(!m_ps){
|
|
|
|
ATLTRACE(TEXT("No Script Engine!! No Run!!\n"));
|
|
ATLASSERT(FALSE);
|
|
throw(S_FALSE);
|
|
}/* end of if statement */
|
|
|
|
EXCEPINFO ei;
|
|
::ZeroMemory(&ei, sizeof(EXCEPINFO));
|
|
|
|
BSTR strName;
|
|
|
|
hr = m_ps->SetScriptState(SCRIPTSTATE_STARTED);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = m_psp->AddScriptlet(NULL, strEventCode, strObjectID, NULL, strEvent, NULL, 0, 0, 0, &strName, &ei);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = m_ps->SetScriptState(SCRIPTSTATE_CONNECTED);
|
|
|
|
}/* end of try statement */
|
|
catch(HRESULT hrTmp){
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return (hr);
|
|
}/* end of function HookScriptlet */
|
|
|
|
/*************************************************************************/
|
|
/* Function: Run */
|
|
/* Description: Runs the Script function. Right now I do not support */
|
|
/* TODO: parameters, but they can be added, by handling VARIANT. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::Run(BSTR strStatement){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(!m_ps){
|
|
|
|
ATLTRACE(TEXT("No Script Engine!! No Run!!\n"));
|
|
ATLASSERT(FALSE);
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
CComPtr<IDispatch> pDispatch;
|
|
|
|
hr = m_ps->GetScriptDispatch(NULL, &pDispatch);
|
|
|
|
if (FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
DISPID dispidMain;
|
|
|
|
LCID lcid = ::GetUserDefaultLCID();
|
|
hr = pDispatch->GetIDsOfNames(IID_NULL, &strStatement, 1, lcid, &dispidMain);
|
|
|
|
if (hr == ResultFromScode(DISP_E_UNKNOWNNAME))
|
|
hr = NOERROR;
|
|
else if (FAILED(hr))
|
|
hr = E_UNEXPECTED;
|
|
else{
|
|
|
|
UINT uArgErr;
|
|
DISPPARAMS params;
|
|
EXCEPINFO ei;
|
|
|
|
params.cArgs = 0;
|
|
params.cNamedArgs = 0;
|
|
params.rgvarg = NULL;
|
|
params.rgdispidNamedArgs = NULL;
|
|
|
|
hr = pDispatch->Invoke(dispidMain, IID_NULL, lcid, DISPATCH_METHOD,
|
|
¶ms,NULL, &ei, &uArgErr);
|
|
if (FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
}/* end of if statement */
|
|
|
|
#ifdef _DEBUG
|
|
ULONG ulcstmt = 0;
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
CComQIPtr<IActiveScriptStats> pstat(m_ps);
|
|
|
|
if (pstat){
|
|
ULONG luT;
|
|
if (FAILED(pstat->GetStat(SCRIPTSTAT_STATEMENT_COUNT, &luT, &ulcstmt)))
|
|
ulcstmt = 0;
|
|
}/* end of if statement */
|
|
|
|
ATLTRACE("Statments executed %d\n", ulcstmt);
|
|
#endif
|
|
|
|
return(hr);
|
|
}/* end of function Run */
|
|
|
|
/*************************************************************************/
|
|
/* Function: CreateObject */
|
|
/* Description: Creates a new ActiveX object that can be scripted. */
|
|
/* Puts the newly created object into container and activates it. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::CreateObject(BSTR strID, BSTR strProgID,
|
|
long lx, long ly, long lWidth, long lHeight,
|
|
BSTR strPropBag, VARIANT_BOOL fDisabled,
|
|
BSTR strScriptHook){
|
|
|
|
HRESULT hr;
|
|
CHostedObject *pObj = NULL; // an ActiveX object
|
|
|
|
try {
|
|
|
|
hr = FindObject(strID, &pObj);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
|
|
ATLTRACE(TEXT("Duplicate Object \n!"));
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
// create the object
|
|
hr = CHostedObject::CreateObject(strID, strProgID, strPropBag, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
ATLTRACE2(atlTraceHosting, 2, TEXT("Failed to Create Object %ls \n"), strID);
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
// initialize inPlaceObject
|
|
CComPtr<IUnknown> pObjectUnknown;
|
|
pObjectUnknown = pObj->GetUnknown();
|
|
|
|
// Get this container unknown
|
|
CComPtr<IUnknown> pContainerUnknown;
|
|
pContainerUnknown = GetUnknown();
|
|
|
|
if(!pContainerUnknown){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
// this is just a container that delegates pretty
|
|
// much all the methods to this container
|
|
// only purpose for its being is that we need to connection
|
|
// between the container and a specific object
|
|
// for SetCapture and SetFocus calls
|
|
|
|
CContainerObject* pContainerObj = new CContainerObject(pContainerUnknown, pObj);
|
|
pContainerUnknown.Release();
|
|
|
|
if(NULL == pContainerObj){
|
|
|
|
throw(E_OUTOFMEMORY);
|
|
}/* end of if statement */
|
|
|
|
pObj->SetContainerObject(pContainerObj);
|
|
|
|
CComPtr<IUnknown> pUnkContainerObj;
|
|
|
|
hr = pContainerObj->QueryInterface(IID_IUnknown, (void**)&pUnkContainerObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
hr = E_FAIL;
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
// insert it at the end of the list
|
|
// TODO: eventually check for duplicate IDs
|
|
m_cntObj.insert(m_cntObj.end(), pObj);
|
|
// add our self to the script engine, so we can hook up the events
|
|
HRESULT hrTmp = m_ps->AddNamedItem((pObj)->GetID(), SCRIPTITEM_ISVISIBLE | SCRIPTITEM_ISSOURCE);
|
|
|
|
if(FAILED(hrTmp)){
|
|
|
|
ATLTRACE(TEXT("Engine is not initilized yet, but that is what I guess we intended\n"));
|
|
ATLASSERT(FALSE);
|
|
}/* end of if statement */
|
|
|
|
CComPtr<IOleObject> pOleObject;
|
|
HRESULT hrOle = pObj->GetOleObject(&pOleObject);
|
|
|
|
if(SUCCEEDED(hrOle)){
|
|
|
|
DWORD dwMiscStatus;
|
|
pOleObject->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus);
|
|
|
|
// set the OLE site
|
|
CComPtr<IOleClientSite> spClientSite;
|
|
|
|
hr = pUnkContainerObj->QueryInterface(&spClientSite);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
if(dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST){
|
|
|
|
pOleObject->SetClientSite(spClientSite); // set the client site
|
|
}/* end of if statement */
|
|
|
|
// no property bag so try to initialze from stream
|
|
CComQIPtr<IPersistStreamInit, &IID_IPersistStreamInit> spPSI(pOleObject);
|
|
|
|
// TODO: Eventaully load up stream via CreateStreamOnHGlobal
|
|
|
|
if (spPSI)
|
|
spPSI->InitNew(); // create new stream
|
|
|
|
|
|
// see if want to use the IPropertyBag to initialize our properties
|
|
CComQIPtr<IPersistPropertyBag, &IID_IPersistPropertyBag> pBag(pObjectUnknown);
|
|
|
|
if (pBag) {
|
|
CComQIPtr<IPropertyBag, &IID_IPropertyBag> pSBag(pUnkContainerObj);
|
|
|
|
if(!pSBag){
|
|
|
|
ATLTRACE2(atlTraceHosting, 0, _T("Could not get IPropertyBag.\r\n"));
|
|
ATLASSERT(FALSE);
|
|
throw(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
HRESULT hrTmp = pBag->Load(pSBag, NULL);
|
|
|
|
if(SUCCEEDED(hrTmp)){
|
|
|
|
pBag->Save(pSBag, FALSE, TRUE);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
if(0 == (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST)){
|
|
|
|
pOleObject->SetClientSite(spClientSite); // set the client site
|
|
}/* end of if statement */
|
|
|
|
pObj->InitViewObject(); // cache view object
|
|
|
|
// hook up sink/notify for events
|
|
// via this call in which we have chance to hook them up
|
|
if(NULL != *strScriptHook){
|
|
|
|
HRESULT hrTmp = Run(strScriptHook);
|
|
|
|
if(FAILED(hrTmp)){
|
|
|
|
ATLTRACE(TEXT("Engine is not initilized yet, but that is what I guess we intended\n"));
|
|
ATLASSERT(FALSE);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
// Get the extents adjust them etc...
|
|
// TODO enhance this to handle generic size
|
|
RECT rcPos;
|
|
|
|
SIZEL sSize, shmSize;
|
|
sSize.cx = lWidth;
|
|
sSize.cy = lHeight;
|
|
AtlPixelToHiMetric(&sSize, &shmSize);
|
|
|
|
pOleObject->SetExtent(DVASPECT_CONTENT, &shmSize);
|
|
pOleObject->GetExtent(DVASPECT_CONTENT, &shmSize);
|
|
AtlHiMetricToPixel(&shmSize, &sSize);
|
|
|
|
// TODO: handle the moves on SetObjectRects
|
|
// right now we set offset once but this needs to be eventaully done
|
|
|
|
rcPos.left = lx; // use m_rcPos for the offsets these any time we get SetObjectRects call
|
|
rcPos.top = ly;
|
|
rcPos.right = rcPos.left + sSize.cx;
|
|
rcPos.bottom = rcPos.top + sSize.cy;
|
|
|
|
// TODO: we might want to wait till our rect is set
|
|
// and then let the script to go at it, that way we reduce the moves
|
|
// and possible flashes
|
|
pObj->SetRawPos(&rcPos); // remember our new position raw position
|
|
|
|
//pObj->SetOffset(&m_rcPos.left, &m_rcPos.top); // sets the pointers to the offset
|
|
|
|
//pObj->GetPos(&rcPos); // get the position back with adjusted rect
|
|
|
|
|
|
// IN_PLACE ACTIVATE
|
|
hrOle = pOleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, spClientSite, 0, m_hWnd, &rcPos);
|
|
|
|
if(VARIANT_FALSE != fDisabled){
|
|
|
|
pObj->SetActive(false);
|
|
}/* end of if statement */
|
|
|
|
}
|
|
else {
|
|
// use the liter interface when IOleObject is not available
|
|
CComQIPtr<IObjectWithSite> spSite(pObjectUnknown);
|
|
|
|
if(spSite){
|
|
|
|
spSite->SetSite(pUnkContainerObj);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
}/* end of try statement */
|
|
catch(HRESULT hrTmp){
|
|
hr = hrTmp;
|
|
// cleanup our variables just in case
|
|
if(NULL != pObj){
|
|
|
|
delete pObj;
|
|
}/* end of if statement */
|
|
}
|
|
catch(...){
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return (hr);
|
|
}/* end of function CreateObject */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ShowSelfSite */
|
|
/* Description: Show itself as an site for itself. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::ShowSelfSite(long nCmd)
|
|
{
|
|
if (::IsWindow(m_hWnd)) {
|
|
if (NULL != m_pBackBitmap)
|
|
m_pBackBitmap->DeleteMemDC();
|
|
|
|
#if 0
|
|
long extStyle = ::GetWindowLong(m_hWnd, GWL_EXSTYLE);
|
|
|
|
if (nCmd == SW_MAXIMIZE) {
|
|
extStyle |= WS_EX_TOPMOST;
|
|
}
|
|
else {
|
|
extStyle &= ~WS_EX_TOPMOST;
|
|
}
|
|
|
|
::SetWindowLong(m_hWnd, GWL_EXSTYLE, extStyle);
|
|
#endif
|
|
::ShowWindow(m_hWnd, nCmd);
|
|
|
|
InvalidateRgn();
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetupSelfSite */
|
|
/* Description: Sets itself as an site for itself. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::SetupSelfSite(long lx, long ly, long lWidth,
|
|
long lHeight, BSTR strPropBag,
|
|
VARIANT_BOOL fDisabled,
|
|
VARIANT_BOOL fHelpDisabled,
|
|
VARIANT_BOOL fWindowDisabled){
|
|
|
|
HRESULT hr;
|
|
CHostedObject *pObj = NULL; // an ActiveX object
|
|
|
|
try {
|
|
if(true == m_fSelfHosted){
|
|
// we are already hosting our self so do not try to do so again
|
|
throw(S_FALSE);
|
|
}/* end of if statement */
|
|
|
|
if(m_nReadyState == READYSTATE_COMPLETE){
|
|
|
|
throw(S_FALSE); //we are already hosted (most likely IE)
|
|
}/* end of if statement */
|
|
|
|
m_bWindowOnly = TRUE; // create self as a window
|
|
m_fSelfHosted = true; // we are trying to self host so send a QUIT message
|
|
|
|
CComPtr<IDispatch> pDisp;
|
|
hr = GetUnknown()->QueryInterface(&pDisp);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
const INT ciMaxBuffSize = MAX_PATH; // should be enough for tlbr ID, keep ID small if can
|
|
TCHAR strBuffer[ciMaxBuffSize];
|
|
|
|
if(!::LoadString(m_hRes, IDS_ROOT_OBJECT, strBuffer, ciMaxBuffSize)){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
#ifndef _UNICODE
|
|
USES_CONVERSION;
|
|
BSTR strObjectID = ::SysAllocString(T2W(strBuffer));
|
|
|
|
#else
|
|
BSTR strObjectID = ::SysAllocString(strBuffer);
|
|
#endif
|
|
|
|
hr = CHostedObject::AddObject(strObjectID, strPropBag, pDisp, &pObj);
|
|
// strPropBag gets allocated as well
|
|
::SysFreeString(strObjectID);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
// initialize inPlaceObject
|
|
CComPtr<IUnknown> pObjectUnknown;
|
|
pObjectUnknown = pObj->GetUnknown();
|
|
|
|
// Get this container unknown
|
|
CComPtr<IUnknown> pContainerUnknown;
|
|
pContainerUnknown = GetUnknown();
|
|
|
|
if(!pContainerUnknown){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
// this is just a container that delegates pretty
|
|
// much all the methods to this container
|
|
// only purpose for its being is that we need to connection
|
|
// between the container and a specific object
|
|
// for SetCapture and SetFocus calls
|
|
|
|
CContainerObject* pContainerObj = new CContainerObject(pContainerUnknown, pObj);
|
|
pContainerUnknown.Release();
|
|
|
|
if(NULL == pContainerObj){
|
|
|
|
throw(E_OUTOFMEMORY);
|
|
}/* end of if statement */
|
|
|
|
pObj->SetContainerObject(pContainerObj);
|
|
|
|
CComPtr<IUnknown> pUnkContainerObj;
|
|
|
|
hr = pContainerObj->QueryInterface(IID_IUnknown, (void**)&pUnkContainerObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
// DO NOT INSERT THIS OBJECT, SINCE IT IS OUR CONTAINER
|
|
// m_cntObj.insert(m_cntObj.end(), pObj);
|
|
|
|
CComPtr<IOleObject> pOleObject;
|
|
HRESULT hrOle = pObj->GetOleObject(&pOleObject);
|
|
|
|
if(FAILED(hrOle)){
|
|
|
|
throw(hrOle);
|
|
}/* end of if statement */
|
|
|
|
DWORD dwMiscStatus;
|
|
pOleObject->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus);
|
|
|
|
// set the OLE site
|
|
CComPtr<IOleClientSite> spClientSite;
|
|
|
|
hr = pUnkContainerObj->QueryInterface(&spClientSite);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
if(dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST){
|
|
|
|
pOleObject->SetClientSite(spClientSite); // set the client site
|
|
}/* end of if statement */
|
|
|
|
// no property bag so try to initialze from stream
|
|
CComQIPtr<IPersistStreamInit, &IID_IPersistStreamInit> spPSI(pOleObject);
|
|
|
|
// TODO: Eventaully load up stream via CreateStreamOnHGlobal
|
|
|
|
if (spPSI)
|
|
spPSI->InitNew(); // create new stream
|
|
|
|
// see if want to use the IPropertyBag to initialize our properties
|
|
CComQIPtr<IPersistPropertyBag, &IID_IPersistPropertyBag> pBag(pObjectUnknown);
|
|
|
|
if (pBag) {
|
|
CComQIPtr<IPropertyBag, &IID_IPropertyBag> pSBag(pUnkContainerObj);
|
|
|
|
if(!pSBag){
|
|
|
|
ATLTRACE2(atlTraceHosting, 0, _T("Could not get IPropertyBag.\r\n"));
|
|
ATLASSERT(FALSE);
|
|
throw(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
HRESULT hrTmp = pBag->Load(pSBag, NULL);
|
|
|
|
if(SUCCEEDED(hrTmp)){
|
|
|
|
pBag->Save(pSBag, FALSE, TRUE);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
if(0 == (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST)){
|
|
|
|
pOleObject->SetClientSite(spClientSite); // set the client site
|
|
}/* end of if statement */
|
|
|
|
pObj->InitViewObject(); // cache view object
|
|
|
|
// TODO: hook up sink/notify for events
|
|
|
|
// Get the extents adjust them etc...
|
|
// TODO enhance this to handle generic size
|
|
RECT rcPos;
|
|
|
|
SIZEL sSize, shmSize;
|
|
sSize.cx = lWidth;
|
|
sSize.cy = lHeight;
|
|
AtlPixelToHiMetric(&sSize, &shmSize);
|
|
|
|
pOleObject->SetExtent(DVASPECT_CONTENT, &shmSize);
|
|
pOleObject->GetExtent(DVASPECT_CONTENT, &shmSize);
|
|
AtlHiMetricToPixel(&shmSize, &sSize);
|
|
|
|
// TODO: handle the moves on SetObjectRects
|
|
// right now we set offset once but this needs to be eventaully done
|
|
|
|
rcPos.left = lx; // use m_rcPos for the offsets these any time we get SetObjectRects call
|
|
rcPos.top = ly;
|
|
rcPos.right = rcPos.left + sSize.cx;
|
|
rcPos.bottom = rcPos.top + sSize.cy;
|
|
|
|
RECT rcClientRect;
|
|
|
|
rcClientRect.left = 0; // use m_rcPos for the offsets these any time we get SetObjectRects call
|
|
rcClientRect.top = 0;
|
|
rcClientRect.right = sSize.cx;
|
|
rcClientRect.bottom = sSize.cy;
|
|
|
|
// TODO: we might want to wait till our rect is set
|
|
// and then let the script to go at it, that way we reduce the moves
|
|
// and possible flashes
|
|
|
|
pObj->SetRawPos(&rcPos); // remember our new position raw position
|
|
|
|
// adjust rects
|
|
// IN_PLACE ACTIVATE OUR SELF ACTIVATION VERSION
|
|
|
|
if (m_spClientSite == NULL)
|
|
return S_OK;
|
|
|
|
CComPtr<IOleInPlaceObject> pIPO;
|
|
ControlQueryInterface(IID_IOleInPlaceObject, (void**)&pIPO);
|
|
ATLASSERT(pIPO != NULL);
|
|
|
|
m_spClientSite->QueryInterface(IID_IOleInPlaceSiteEx, (void**)&m_spInPlaceSite);
|
|
if (m_spInPlaceSite)
|
|
m_bInPlaceSiteEx = TRUE;
|
|
else
|
|
hr = m_spClientSite->QueryInterface(IID_IOleInPlaceSite, (void**) &m_spInPlaceSite);
|
|
|
|
ATLASSERT(m_spInPlaceSite);
|
|
if (!m_spInPlaceSite)
|
|
throw(E_FAIL);
|
|
|
|
m_bNegotiatedWnd = TRUE;
|
|
|
|
if (!m_bInPlaceActive){
|
|
|
|
BOOL bNoRedraw = FALSE;
|
|
if (m_bInPlaceSiteEx)
|
|
m_spInPlaceSite->OnInPlaceActivateEx(&bNoRedraw, 0);
|
|
else
|
|
{
|
|
hr = m_spInPlaceSite->CanInPlaceActivate();
|
|
// CanInPlaceActivate returns S_FALSE or S_OK
|
|
if (FAILED(hr))
|
|
throw(hr);
|
|
if ( hr != S_OK )
|
|
{
|
|
// CanInPlaceActivate returned S_FALSE.
|
|
throw( E_FAIL );
|
|
}
|
|
m_spInPlaceSite->OnInPlaceActivate();
|
|
}
|
|
}/* end of if statement */
|
|
|
|
m_bInPlaceActive = TRUE;
|
|
|
|
// get location in the parent window,
|
|
// as well as some information about the parent
|
|
//
|
|
OLEINPLACEFRAMEINFO frameInfo;
|
|
|
|
CComPtr<IOleInPlaceFrame> spInPlaceFrame;
|
|
CComPtr<IOleInPlaceUIWindow> spInPlaceUIWindow;
|
|
frameInfo.cb = sizeof(OLEINPLACEFRAMEINFO);
|
|
|
|
if (!m_bWndLess){
|
|
|
|
DWORD dwStyle;
|
|
DWORD dwExStyle;
|
|
HWND hwndPar = NULL;
|
|
|
|
|
|
if(VARIANT_FALSE == fWindowDisabled){
|
|
// one with the frame
|
|
dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
|
|
dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
|
|
}
|
|
else {
|
|
// one without the frame
|
|
dwStyle = WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS |WS_SYSMENU| WS_MAXIMIZEBOX| WS_MINIMIZEBOX ;
|
|
//dwExStyle = WS_EX_TRANSPARENT; //| WS_EX_LTRREADING| WS_EX_WINDOWEDGE;
|
|
//dwExStyle = 0x00080000; //WS_EX_LAYERED = 0x00080000;
|
|
dwExStyle = WS_EX_APPWINDOW;
|
|
//hwndPar = ::GetDesktopWindow();
|
|
}/* end of if statement */
|
|
|
|
if(VARIANT_FALSE == fDisabled){
|
|
|
|
dwStyle |= WS_VISIBLE;
|
|
}/* end of if statement */
|
|
|
|
if(VARIANT_FALSE == fHelpDisabled){
|
|
|
|
dwStyle &= ~(WS_MINIMIZEBOX | WS_MAXIMIZEBOX); // take out the min max style
|
|
// help does not work with it
|
|
dwExStyle |= WS_EX_CONTEXTHELP;
|
|
}/* end of if statement */
|
|
|
|
#ifdef _UNICODE
|
|
HWND h = Create(hwndPar, rcPos, m_bstrCaption /* window name */, dwStyle, dwExStyle);
|
|
#else
|
|
USES_CONVERSION;
|
|
HWND h = Create(hwndPar, rcPos, OLE2T(m_bstrCaption) /* window name */, dwStyle, dwExStyle);
|
|
#endif
|
|
|
|
// used instead of
|
|
// HWND h = CreateControlWindow(hwndParent, rcPos);
|
|
ATLASSERT(h != NULL); // will assert if creation failed
|
|
ATLASSERT(h == m_hWndCD);
|
|
if(NULL == h){
|
|
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
if(VARIANT_TRUE == fWindowDisabled){
|
|
|
|
::SendMessage(h, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM) m_hIcon);
|
|
::SendMessage(h, WM_SETICON, (WPARAM)ICON_BIG, (LPARAM) m_hIcon);
|
|
}/* end of if statement */
|
|
|
|
}/* end of if statement */
|
|
|
|
if(VARIANT_FALSE != fDisabled){
|
|
|
|
pObj->SetActive(false);
|
|
}/* end of if statement */
|
|
|
|
if (m_hMenu) {
|
|
::DestroyMenu(m_hMenu);
|
|
m_hMenu = NULL;
|
|
}
|
|
|
|
// Create the system menu
|
|
m_hMenu = ::LoadMenu(_Module.GetModuleInstance(), MAKEINTRESOURCE(IDR_SYSMENU));
|
|
|
|
MENUINFO mInfo;
|
|
mInfo.cbSize = sizeof(MENUINFO);
|
|
#if(WINVER >= 0x0500)
|
|
::GetMenuInfo(::GetSubMenu(m_hMenu, 0), &mInfo);
|
|
#else
|
|
CallGetMenuInfo(::GetSubMenu(m_hMenu, 0), &mInfo);
|
|
#endif
|
|
|
|
mInfo.dwStyle = MNS_NOCHECK;
|
|
mInfo.fMask = MIM_STYLE;
|
|
#if(WINVER >= 0x0500)
|
|
::SetMenuInfo(::GetSubMenu(m_hMenu, 0), &mInfo);
|
|
#else
|
|
CallSetMenuInfo(::GetSubMenu(m_hMenu, 0), &mInfo);
|
|
#endif
|
|
|
|
#if(WINVER >= 0x0500)
|
|
MENUITEMINFO iInfo;
|
|
iInfo.cbSize = sizeof(MENUITEMINFO);
|
|
#else
|
|
MENUITEMINFOInternal iInfo;
|
|
iInfo.cbSize = sizeof(MENUITEMINFOInternal);
|
|
#endif
|
|
|
|
::GetMenuItemInfo(::GetSubMenu(m_hMenu, 0), ID_SYSTEMMENU_RESTORE, false, (LPMENUITEMINFO)&iInfo);
|
|
iInfo.hbmpItem = HBMMENU_POPUP_RESTORE;
|
|
iInfo.fMask = MIIM_BITMAP;
|
|
::SetMenuItemInfo(::GetSubMenu(m_hMenu, 0), ID_SYSTEMMENU_RESTORE, false, (LPCMENUITEMINFO)&iInfo);
|
|
|
|
::GetMenuItemInfo(::GetSubMenu(m_hMenu, 0), ID_SYSTEMMENU_MINIMIZE, false, (LPMENUITEMINFO)&iInfo);
|
|
iInfo.hbmpItem = HBMMENU_POPUP_MINIMIZE;
|
|
iInfo.fMask = MIIM_BITMAP;
|
|
::SetMenuItemInfo(::GetSubMenu(m_hMenu, 0), ID_SYSTEMMENU_MINIMIZE, false, (LPCMENUITEMINFO)&iInfo);
|
|
|
|
::GetMenuItemInfo(::GetSubMenu(m_hMenu, 0), ID_SYSTEMMENU_MAXIMIZE, false, (LPMENUITEMINFO)&iInfo);
|
|
iInfo.hbmpItem = HBMMENU_POPUP_MAXIMIZE;
|
|
iInfo.fMask = MIIM_BITMAP;
|
|
::SetMenuItemInfo(::GetSubMenu(m_hMenu, 0), ID_SYSTEMMENU_MAXIMIZE, false, (LPCMENUITEMINFO)&iInfo);
|
|
|
|
::GetMenuItemInfo(::GetSubMenu(m_hMenu, 0), ID_SYSTEMMENU_CLOSE, false, (LPMENUITEMINFO)&iInfo);
|
|
iInfo.hbmpItem = HBMMENU_POPUP_CLOSE;
|
|
iInfo.fMask = MIIM_BITMAP|MIIM_STATE;
|
|
iInfo.fState = MFS_DEFAULT;
|
|
::SetMenuItemInfo(::GetSubMenu(m_hMenu, 0), ID_SYSTEMMENU_CLOSE, false, (LPCMENUITEMINFO)&iInfo);
|
|
|
|
|
|
}/* end of try statement */
|
|
catch(HRESULT hrTmp){
|
|
hr = hrTmp;
|
|
m_fSelfHosted = false;
|
|
// cleanup our variables just in case
|
|
if(NULL != pObj){
|
|
|
|
delete pObj;
|
|
}/* end of if statement */
|
|
}
|
|
catch(...){
|
|
m_fSelfHosted = false;
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return (hr);
|
|
}/* end of function SetupSelfSite */
|
|
|
|
/*************************************************************************/
|
|
/* Function: AddObject */
|
|
/* Description: Adds a scriptable only object that was created somewhere */
|
|
/* else into our object container. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::AddObject(BSTR strObjectID, LPDISPATCH pDisp){
|
|
|
|
HRESULT hr;
|
|
CHostedObject *pObj = NULL; // an ActiveX object
|
|
|
|
try {
|
|
// add an object that was already created
|
|
// this object does not get the Active flag set which
|
|
// means we will not try to draw it and do other
|
|
// activities on it, such as we would do on the objects
|
|
// that are contained and have a site
|
|
hr = CHostedObject::AddObject(strObjectID, NULL, pDisp, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
// now add the object to the container
|
|
// insert it at the end of the list
|
|
// TODO: eventually check for duplicate IDs
|
|
m_cntObj.insert(m_cntObj.end(), pObj);
|
|
|
|
}/* end of try statement */
|
|
catch(HRESULT hrTmp){
|
|
hr = hrTmp;
|
|
// cleanup our variables just in case
|
|
if(NULL != pObj){
|
|
|
|
delete pObj;
|
|
}/* end of if statement */
|
|
}
|
|
catch(...){
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return (hr);
|
|
}/* end of function AddObject */
|
|
|
|
// ##### END ACTIVEX SCRIPTING SUPPORT #####
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetParentHWND */
|
|
/* Description: Gets the parent window HWND where we are operating. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::GetParentHWND(HWND* pWnd){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
*pWnd = NULL;
|
|
|
|
if(m_bWndLess){
|
|
|
|
CComPtr<IOleClientSite> pClientSite;
|
|
|
|
hr = GetClientSite(&pClientSite);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
CComQIPtr<IOleWindow> pOleWindow(pClientSite);
|
|
|
|
if(!pOleWindow){
|
|
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = pOleWindow->GetWindow(pWnd);
|
|
}
|
|
else {
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
*pWnd = ::GetParent(m_hWnd);
|
|
if(::IsWindow(*pWnd)){
|
|
|
|
hr = S_OK;
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function GetParentHWND */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetClientRect */
|
|
/* Description: Gets the client rect. If we are windowless we pass down */
|
|
/* the m_rcPos. */
|
|
/*************************************************************************/
|
|
BOOL CMFBar::GetClientRect(LPRECT lpRect) const{
|
|
|
|
BOOL bRet = TRUE;
|
|
|
|
if (!lpRect){
|
|
|
|
bRet = FALSE;
|
|
return (bRet);
|
|
}/* end of if statement */
|
|
|
|
if(m_bWndLess){
|
|
|
|
*lpRect = m_rcPos;
|
|
return(bRet);
|
|
}/* end of if statement */
|
|
|
|
ATLASSERT(::IsWindow(m_hWnd));
|
|
bRet = ::GetClientRect(m_hWnd, lpRect);
|
|
|
|
return(bRet);
|
|
}/* end of function GetClientRect */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetParent */
|
|
/* Description: Gets the parent window. If we are windowless we pass */
|
|
/* down the parent container window, which is really in a sense parent. */
|
|
/*************************************************************************/
|
|
HWND CMFBar::GetParent(){
|
|
|
|
HWND hwnd = NULL;
|
|
|
|
if(m_bWndLess){
|
|
|
|
GetParentHWND(&hwnd);
|
|
return(hwnd);
|
|
}/* end of if statement */
|
|
|
|
ATLASSERT(::IsWindow(m_hWnd));
|
|
return ::GetParent(m_hWnd);
|
|
}/* end of function GetParent */
|
|
|
|
/*************************************************************************/
|
|
/* Function: AdjustRects */
|
|
/* Description: calls all our contained objects and the adjusts their */
|
|
/* rects in the case we have moved, if we do not have any that is OK, */
|
|
/* since the offset is kept in m_rcPos and set whenever the objects */
|
|
/* get created. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::AdjustRects(const LPCRECT prcPos){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
//TODO: handle resizing
|
|
ATLTRACE2(atlTraceHosting, 2, TEXT("Resizing control prcPos->left = %d, prcPos.right = %d, prcPos.bottom =%d, prcPos.top = %d\n"),
|
|
prcPos->left, prcPos->right, prcPos->bottom, prcPos->top);
|
|
|
|
if(false == m_fSelfHosted){
|
|
|
|
Fire_OnResize(RECTWIDTH(prcPos), RECTHEIGHT(prcPos), SIZE_RESTORED);
|
|
}/* end of if statement */
|
|
|
|
#if 0
|
|
if(!m_bWndLess){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(m_cntObj.empty() == true){
|
|
|
|
hr = S_FALSE;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
CNTOBJ::iterator i;
|
|
for(i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
|
|
CHostedObject* pObj = (*i);
|
|
ATLASSERT(pObj);
|
|
|
|
if(m_fSelfHosted && (GetUnknown() == pObj->GetUnknown())){
|
|
|
|
continue; // that is us we close our self later after the contained objects
|
|
}/* end of if statement */
|
|
|
|
pObj->SetObjectRects(); // adjust the current offset if it needs to be so
|
|
}/* end of for loop */
|
|
#endif
|
|
return(hr);
|
|
}/* end of function AdjustRects */
|
|
|
|
/*************************************************************************/
|
|
/* IOleInPlaceSiteEx Implementation */
|
|
/*************************************************************************/
|
|
|
|
/*************************************************************************/
|
|
/* Function: CanWindowlessActivate */
|
|
/* Description: Return if we can windowless activate or not. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::CanWindowlessActivate(){
|
|
|
|
return m_bCanWindowlessActivate ? S_OK : S_FALSE;
|
|
}/* end of function CanWindowlessActivate */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetDC */
|
|
/* Description: Gets a DC to draw with. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::GetDC(LPCRECT pRect, DWORD grfFlags, HDC* phDC){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_bWndLess){
|
|
|
|
hr = m_spInPlaceSite->GetDC(pRect, grfFlags, phDC);
|
|
}
|
|
else {
|
|
if(NULL == m_hWnd){
|
|
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
*phDC = ::GetDC(m_hWnd);
|
|
}
|
|
else {
|
|
hr = E_UNEXPECTED;
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function GetDC */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ReleaseDC */
|
|
/* Description: Releases the DC */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::ReleaseDC(HDC hDC){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_bWndLess){
|
|
|
|
hr = m_spInPlaceSite->ReleaseDC(hDC);
|
|
}
|
|
else {
|
|
if(NULL == m_hWnd){
|
|
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
::ReleaseDC(m_hWnd, hDC);
|
|
}
|
|
else {
|
|
hr = E_UNEXPECTED;
|
|
}/* end of if statement */
|
|
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function ReleaseDC */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnDefWindowMessage */
|
|
/* Description: Sends on messages to the default window procedure. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::OnDefWindowMessage(UINT msg, WPARAM wParam,
|
|
LPARAM lParam, LRESULT* plResult){
|
|
|
|
*plResult = DefWindowProc(msg, wParam, lParam);
|
|
return S_OK;
|
|
}/* end of function OnDefWindowMessage */
|
|
|
|
/*************************************************************************/
|
|
/* Function: InvalidateRgn */
|
|
/* Description: Invalidates the whole rect in case we need to repaint it.*/
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::InvalidateRgn(HRGN hRGN, BOOL fErase){
|
|
|
|
HRESULT hr = S_OK;
|
|
#if 0
|
|
if (!hRGN) {
|
|
RECT rc;
|
|
GetClientRect(&rc);
|
|
hRGN = ::CreateRectRgn( rc.left, rc.top, rc.right, rc.bottom);
|
|
}
|
|
|
|
HRGN newRgn = ::CreateRectRgn(0, 0, 10, 10);
|
|
::CombineRgn(newRgn, hRGN, NULL, RGN_COPY) ;
|
|
|
|
CNTOBJ::iterator i;
|
|
for(i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
|
|
CHostedObject* pObj = (*i);
|
|
ATLASSERT(pObj);
|
|
|
|
if(m_fSelfHosted && (GetUnknown() == pObj->GetUnknown())){
|
|
|
|
continue; // that is us we close our self later after the contained objects
|
|
}/* end of if statement */
|
|
|
|
if (!pObj->IsWindowless() && pObj->IsActive()) {
|
|
LONG x1, y1, w, h;
|
|
GetObjectPosition(pObj->GetID(), &x1, &y1, &w, &h);
|
|
HRGN objRgn = ::CreateRectRgn( x1, y1, x1+w, y1+h );
|
|
::CombineRgn(newRgn, newRgn, objRgn, RGN_DIFF);
|
|
//ATLTRACE(TEXT("Excluding Rgn %d %d %d %d\n"), x1, y1, x1+w, y1+h);
|
|
}
|
|
}/* end of for loop */
|
|
|
|
hRGN = newRgn;
|
|
#endif
|
|
|
|
if(m_bWndLess){
|
|
|
|
hr = m_spInPlaceSite->InvalidateRgn(hRGN ,fErase);
|
|
}
|
|
else {
|
|
if(NULL == m_hWnd){
|
|
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
::InvalidateRgn(m_hWnd, hRGN, fErase); // see if we can get by by not erasing..
|
|
}
|
|
else {
|
|
hr = E_UNEXPECTED;
|
|
}/* end of if statement */
|
|
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function InvalidateRgn */
|
|
|
|
/*************************************************************************/
|
|
/* Function: InvalidateRect */
|
|
/* Description: Invalidates the rect, handles if we are windowless */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::InvalidateRect(LPCRECT pRect, BOOL fErase){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_bWndLess){
|
|
|
|
hr = m_spInPlaceSite->InvalidateRect(pRect, fErase);
|
|
}
|
|
else {
|
|
if(NULL == m_hWnd){
|
|
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
::InvalidateRect(m_hWnd, pRect, fErase);
|
|
}
|
|
else {
|
|
hr = E_UNEXPECTED;
|
|
}/* end of if statement */
|
|
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function InvalidateRect */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetCapture */
|
|
/* Description: Used to determine if we have a cupature or not */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::GetCapture(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_bWndLess){
|
|
|
|
hr = m_spInPlaceSite->GetCapture();
|
|
}
|
|
else {
|
|
if(NULL == m_hWnd){
|
|
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
hr = ::GetCapture() == m_hWnd ? S_OK : S_FALSE;
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function GetCapture */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetCapture */
|
|
/* Description: Used to set the capture for mouse events */
|
|
/* Only one container at the time can have a capture. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::SetCapture(BOOL fCapture){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
// whatever we we are doing we need to reset the capture flags on all the object
|
|
// after this call is finished the specific site will set appropriate flag
|
|
ResetCaptureFlags();
|
|
|
|
if(fCapture){
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("Setting Mouse Capture in the container \n"));
|
|
}
|
|
else {
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("Resetting Mouse Capture in the container\n"));
|
|
}/* end of if statement */
|
|
|
|
if(m_bWndLess){
|
|
|
|
if (fCapture){
|
|
|
|
hr = m_spInPlaceSite->SetCapture(TRUE);
|
|
}
|
|
else {
|
|
|
|
hr = m_spInPlaceSite->SetCapture(FALSE);
|
|
}/* end of if statement */
|
|
}
|
|
else {
|
|
if(NULL == m_hWnd){
|
|
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
if (fCapture){
|
|
// do not have a capture, so set it
|
|
ATLTRACE2(atlTraceWindowing, 4, TEXT("Setting caputure to our self (container) \n"));
|
|
::SetCapture(m_hWnd);
|
|
}
|
|
else{
|
|
// nobody more has a capture, so let it go
|
|
ATLTRACE2(atlTraceWindowing, 4, TEXT("Releasing caputure from our self (container) \n"));
|
|
::ReleaseCapture();
|
|
}/* end of if statement */
|
|
}
|
|
else {
|
|
hr = E_UNEXPECTED;
|
|
}/* end of if statement */
|
|
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function SetCapture */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ResetCaptureFlags */
|
|
/* Description: Resets the capture on contained objects. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::ResetCaptureFlags(){
|
|
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// iterate through all the contained objects and draw them
|
|
CHostedObject* pObj = (*i);
|
|
|
|
pObj->SetCapture(false);
|
|
}/* end of for function */
|
|
|
|
return(S_OK);
|
|
}/* end of function ResetCaptureFlags */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ResetFocusFlags */
|
|
/* Description: Resets the capture on contained objects. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::ResetFocusFlags(){
|
|
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// iterate through all the contained objects and draw them
|
|
CHostedObject* pObj = (*i);
|
|
if(pObj->HasFocus()){
|
|
|
|
LONG lRes;
|
|
SetObjectFocus(pObj, FALSE, lRes);
|
|
}/* end of if statement */
|
|
}/* end of for function */
|
|
|
|
return(S_OK);
|
|
}/* end of function ResetFocusFlags */
|
|
|
|
/*************************************************************************/
|
|
/* Function: EnumObjects */
|
|
/* Description: Returns IEnumUnknown */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::EnumObjects(DWORD /*grfFlags*/, IEnumUnknown** ppenum){
|
|
|
|
if (ppenum == NULL)
|
|
return E_POINTER;
|
|
|
|
*ppenum = NULL;
|
|
|
|
// TODO: handle flags
|
|
ATLASSERT(FALSE);
|
|
|
|
if(m_cntObj.empty() == true){
|
|
|
|
return E_FAIL;
|
|
}/* end of if statement */
|
|
|
|
typedef CComObject<CComEnum<IEnumUnknown, &IID_IEnumUnknown, IUnknown*, _CopyInterface<IUnknown> > > enumunk;
|
|
enumunk* p = NULL;
|
|
ATLTRY(p = new enumunk);
|
|
if(p == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
// create an array to which we put our *IUnknowns
|
|
INT iSize = m_cntObj.size();
|
|
IUnknown** pArray = new IUnknown* [iSize];
|
|
|
|
if(pArray == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
bool bFirstElement = true;
|
|
CNTOBJ::iterator i;
|
|
INT iCount = 0;
|
|
|
|
for(i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
// move the interfaces to the array
|
|
CHostedObject* pObj = (*i);
|
|
pArray[iCount] = pObj->GetUnknown();
|
|
|
|
pArray[iCount]->AddRef();
|
|
|
|
iCount++;
|
|
}/* end of for loop */
|
|
|
|
HRESULT hRes = p->Init(pArray, pArray + iSize, GetUnknown(), AtlFlagCopy);
|
|
if (SUCCEEDED(hRes))
|
|
hRes = p->QueryInterface(IID_IEnumUnknown, (void**)ppenum);
|
|
if (FAILED(hRes))
|
|
delete p;
|
|
|
|
delete[] pArray;
|
|
|
|
return hRes;
|
|
}/* end of function EnumObjects */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SendMessageToCtl */
|
|
/* Description: Forwards message to a control */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::SendMessageToCtl(CHostedObject* pObj,
|
|
UINT uMsg, WPARAM wParam, LPARAM lParam,
|
|
BOOL& bHandled, LONG& lRes, bool fWndwlsOnly, bool fActiveOnly){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(NULL == pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(fWndwlsOnly && (!pObj->IsWindowless())){
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("NOT SENDING message to control %ls !!!\n"), pObj->GetID());
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(fActiveOnly && (!pObj->IsInputEnabled())){
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("NOT SENDING message to control %ls !!!\n"), pObj->GetID());
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
CComPtr<IUnknown> pUnk = pObj->GetUnknown();
|
|
|
|
if(!pUnk){
|
|
|
|
ATLASSERT(FALSE); // should not be null
|
|
return(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
if(pUnk == GetUnknown()){
|
|
|
|
// do not send message to our self since we might endup in the never ending recusion
|
|
return(S_FALSE);
|
|
}/* end of if statement */
|
|
|
|
CComQIPtr<IOleInPlaceObjectWindowless> spInPlaceObjectWindowless(pUnk);
|
|
|
|
if(spInPlaceObjectWindowless){
|
|
|
|
// more then one control can have have a capture
|
|
LRESULT lResTemp;
|
|
spInPlaceObjectWindowless->OnWindowMessage(uMsg, wParam, lParam, &lResTemp);
|
|
lRes = (LONG) lResTemp;
|
|
bHandled = TRUE;
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function SendMessageToCtl */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetFocus */
|
|
/* Description: Determine if we have a focus or not. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::GetFocus(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(m_bWndLess){
|
|
|
|
hr = m_spInPlaceSite->GetFocus();
|
|
}
|
|
else {
|
|
if(NULL == m_hWnd){
|
|
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
hr = ::GetFocus() == m_hWnd ? S_OK : S_FALSE;
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function GetFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetFocus */
|
|
/* Description: Sets focus to the control */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::SetFocus(BOOL fFocus){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
// we reset the flags depending on WM_SET and WM_KILL focus messages
|
|
if(fFocus){
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("Setting Mouse Focus in the container \n"));
|
|
}
|
|
else {
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("Resetting Mouse Focus in the container\n"));
|
|
}/* end of if statement */
|
|
|
|
if(m_bWndLess){
|
|
|
|
if (fFocus){
|
|
|
|
hr = m_spInPlaceSite->SetFocus(TRUE);
|
|
}
|
|
else {
|
|
|
|
hr = m_spInPlaceSite->SetFocus(FALSE);
|
|
}/* end of if statement */
|
|
}
|
|
else {
|
|
if(NULL == m_hWnd){
|
|
|
|
hr = E_FAIL;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
if (fFocus){
|
|
|
|
::SetFocus(m_hWnd);
|
|
}
|
|
else {
|
|
|
|
// else could call ::SetFocus(NULL), but that does not seem like a good solution
|
|
// so instead reset the focus on contained conrols
|
|
// which is risky too, since some control could try to call SetFocus(false)
|
|
// when it does not have the focus, but that is handled in the caller
|
|
//ResetFocusFlags();
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
else {
|
|
hr = E_UNEXPECTED;
|
|
}/* end of if statement */
|
|
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function SetFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_ActivityTimeOut */
|
|
/* Description: Gets the currrent timout value. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::get_ActivityTimeout(long *plTimeout){
|
|
|
|
*plTimeout = m_lTimeout;
|
|
return(S_OK);
|
|
}/* end of function get_ActivityTimeOut */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_ActivityTimeOut */
|
|
/* Description: Creates a new timer if needed. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::put_ActivityTimeout(long lTimeout){
|
|
|
|
if(lTimeout < 0){
|
|
|
|
return(E_INVALIDARG);
|
|
}/* end of if statement */
|
|
|
|
if(!::IsWindow(m_hWnd)){
|
|
|
|
return(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
if(m_lTimeout != 0 || 0 == lTimeout ){
|
|
|
|
// kill it each time we set a new timer
|
|
::KillTimer(m_hWnd, ID_EV_TIMER);
|
|
}
|
|
else {
|
|
|
|
if(0 == ::SetTimer(m_hWnd, ID_EV_TIMER, lTimeout, NULL)){
|
|
|
|
return(E_FAIL);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
m_lTimeout = lTimeout;
|
|
m_fUserActivity = false;
|
|
m_fWaitingForActivity = false;
|
|
|
|
return(S_OK);
|
|
}/* end of function put_ActivityTimeOut */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetObjectExtent */
|
|
/* Description: Sets specific object witdth and height. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::SetObjectExtent(BSTR strObjectID, long lWidth, long lHeight){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == strObjectID){
|
|
|
|
hr = E_POINTER;
|
|
return(hr);
|
|
}/* end of if sattement */
|
|
|
|
bool bFirstElement = true;
|
|
CNTOBJ::iterator i;
|
|
for(i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(!_wcsicmp(pObj->GetID(), strObjectID)){
|
|
RECT rcOld;
|
|
hr = pObj->GetPos(&rcOld);
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
RECT rcNew;
|
|
rcNew.left = rcOld.left; rcNew.top = rcOld.top;
|
|
rcNew.right = rcNew.left + lWidth; rcNew.bottom = rcNew.top + lHeight;
|
|
|
|
if(::EqualRect(&rcOld, &rcNew)){
|
|
|
|
hr = S_FALSE; // no point to monkey around if the rects are the same
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
// Set the objects new position
|
|
hr = pObj->SetRawPos(&rcNew);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
// Set the objects new position
|
|
hr = pObj->SetRawPos(&rcNew);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(pObj->IsWindowless()){
|
|
|
|
hr = pObj->SetObjectRects();
|
|
}
|
|
else {
|
|
|
|
hr = pObj->SetObjectRects(&rcNew);
|
|
}/* end of if statement */
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
RECT rcUnion;
|
|
|
|
::UnionRect(&rcUnion, &rcOld, &rcNew);
|
|
|
|
if (pObj->IsWindowless())
|
|
hr = InvalidateRect(&rcUnion, FALSE);
|
|
|
|
break; // already have set the state and invalidated and bail out
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
return (hr);
|
|
}/* end of function SetObjectExtent */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetObjectPosition */
|
|
/* Description: Sets specific object position. Looks up object by object */
|
|
/* ID. Sets also extents. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::SetObjectPosition(BSTR strObjectID, long xPos,
|
|
long yPos, long lWidth, long lHeight){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == strObjectID){
|
|
|
|
hr = E_POINTER;
|
|
return(hr);
|
|
}/* end of if sattement */
|
|
|
|
RECT rcNew;
|
|
rcNew.left = xPos; rcNew.top = yPos;
|
|
rcNew.right = rcNew.left + lWidth; rcNew.bottom = rcNew.top + lHeight;
|
|
|
|
bool bFirstElement = true;
|
|
CNTOBJ::iterator i;
|
|
for(i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(!_wcsicmp(pObj->GetID(), strObjectID)){
|
|
RECT rcOld;
|
|
hr = pObj->GetPos(&rcOld);
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(::EqualRect(&rcOld, &rcNew)){
|
|
|
|
hr = S_FALSE; // no point to monkey around if the rects are the same
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
// Set the objects new position
|
|
hr = pObj->SetRawPos(&rcNew);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(pObj->IsWindowless()){
|
|
|
|
hr = pObj->SetObjectRects();
|
|
|
|
LPARAM lParam = MAKELPARAM(lWidth, lHeight);
|
|
WPARAM wParam = SIZE_RESTORED;
|
|
BOOL bHandled;
|
|
LONG lRes;
|
|
SendMessageToCtl(pObj, WM_SIZE, wParam, lParam, bHandled, lRes);
|
|
}
|
|
else {
|
|
|
|
hr = pObj->SetObjectRects(&rcNew);
|
|
}/* end of if statement */
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
RECT rcUnion;
|
|
|
|
::UnionRect(&rcUnion, &rcOld, &rcNew);
|
|
|
|
if (pObj->IsWindowless())
|
|
hr = InvalidateRect(&rcUnion, FALSE);
|
|
|
|
break; // already have set the state and invalidated and bail out
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
return (hr);
|
|
}/* end of function SetObjectPosition */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetObjectPosition */
|
|
/* Description: SetObjectPosition */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::GetObjectPosition(BSTR strObjectID, long* pxPos, long* pyPos, long* plWidth, long* plHeight){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == strObjectID){
|
|
|
|
hr = E_POINTER;
|
|
return(hr);
|
|
}/* end of if sattement */
|
|
|
|
if(NULL == pxPos || NULL == pyPos || NULL == plWidth || NULL == plHeight){
|
|
|
|
return(E_POINTER);
|
|
}/* end of if statement */
|
|
|
|
*pxPos = *pyPos = *plWidth = *plHeight = 0;
|
|
|
|
bool bFirstElement = true;
|
|
CNTOBJ::iterator i;
|
|
for(i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
|
|
if(!_wcsicmp((*i)->GetID(), strObjectID)){
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
// Set the objects new position
|
|
RECT rc;
|
|
hr = pObj->GetPos(&rc);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
|
|
*pxPos = rc.left; *pyPos = rc.top; *plWidth = RECTWIDTH(&rc); *plHeight = RECTHEIGHT(&rc);
|
|
}/* end of if statement */
|
|
|
|
break; // already have set the state and invalidated and bail out
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
return (hr);
|
|
}/* end function GetObjectPosition */
|
|
|
|
/*************************************************************************/
|
|
/* Function: WinHelp */
|
|
/* Description: Called by the script to execute specific help topic. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::WinHelp(BSTR strHelpFile, long lCommand, long dwData){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
HWND h = NULL;
|
|
|
|
hr = GetWindow(&h);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
USES_CONVERSION;
|
|
LPTSTR strTemp = OLE2T(strHelpFile);
|
|
if (strTemp != NULL)
|
|
{
|
|
BOOL bResult = ::WinHelp(h, strTemp, lCommand, dwData);
|
|
|
|
if(!bResult){
|
|
|
|
// failed so lets try to get some more meaningful result
|
|
hr = HRESULT_FROM_WIN32(::GetLastError());
|
|
}/* end of if statement */
|
|
}
|
|
else
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
|
|
}/* end of try statement */
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return (hr);
|
|
}/* end of function WinHelp */
|
|
|
|
static HWND (WINAPI *pfnHtmlHelp)(HWND , LPCTSTR , UINT , ULONG_PTR);
|
|
typedef HWND (WINAPI *PFNHTMLHELP)(HWND , LPCTSTR , UINT , ULONG_PTR);
|
|
|
|
/*************************************************************************/
|
|
/* Function: CallHtmlHelp */
|
|
/* Description: Dynamically load the HTML help. */
|
|
/*************************************************************************/
|
|
HWND CMFBar::CallHtmlHelp(HWND hwndCaller,LPCTSTR pszFile,UINT uCommand,ULONG_PTR dwData){
|
|
|
|
HWND hwnd = NULL; // return value
|
|
|
|
if(NULL == m_hinstHelpDll){
|
|
|
|
m_hinstHelpDll = ::LoadLibrary(TEXT("HHCTRL.OCX"));
|
|
}/* end of if statement */
|
|
|
|
if (m_hinstHelpDll){
|
|
|
|
#ifndef _UNICODE
|
|
pfnHtmlHelp = (PFNHTMLHELP)GetProcAddress(m_hinstHelpDll, "HtmlHelpA");
|
|
#else
|
|
pfnHtmlHelp = (PFNHTMLHELP)GetProcAddress(m_hinstHelpDll, "HtmlHelpW");
|
|
#endif
|
|
|
|
if (pfnHtmlHelp){
|
|
|
|
hwnd = pfnHtmlHelp(hwndCaller, pszFile, uCommand, dwData);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return (hwnd);
|
|
}/* end of function CallHtmlHelp */
|
|
|
|
/*************************************************************************/
|
|
/* Function: HTMLHelp */
|
|
/* Description: Called by the script to execute specific help topic. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::HTMLHelp(BSTR strHelpFile, long lCommand, VARIANT vData){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
HWND h = NULL;
|
|
|
|
hr = GetWindow(&h);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
USES_CONVERSION;
|
|
|
|
ULONG_PTR pData = NULL;
|
|
|
|
switch(vData.vt){
|
|
|
|
case VT_BSTR: { // This might be tricky since we have to convert to ansi if not un Unicode
|
|
|
|
#ifndef _UNICODE
|
|
USES_CONVERSION;
|
|
pData = (ULONG_PTR) OLE2T(vData.bstrVal);
|
|
#else
|
|
pData = (ULONG_PTR) vData.bstrVal;
|
|
#endif
|
|
}
|
|
break;
|
|
default: pData = vData.ulVal; // like VT_I4 just cast to the the type
|
|
}/* end of switch statement */
|
|
|
|
CComBSTR cstr = TEXT("hcp:");
|
|
|
|
if(cstr == strHelpFile){
|
|
|
|
// special case when we are creating process for TS
|
|
// per Bradley Serbus we do not build another function for this
|
|
TCHAR lpszCmdLine[MAX_PATH * 3];
|
|
|
|
if(MAX_PATH < GetWindowsDirectory(lpszCmdLine, MAX_PATH )){
|
|
|
|
// not enough size in max path
|
|
ATLASSERT(TRUE);
|
|
throw(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
_tcscat(lpszCmdLine, TEXT("\\pchealth\\helpctr\\binaries\\helpctr.exe"));
|
|
|
|
_tcscat(lpszCmdLine, TEXT(" -url hcp://help/"));
|
|
|
|
if(VT_BSTR != vData.vt){
|
|
|
|
throw(E_INVALIDARG);
|
|
}/* end of if statement */
|
|
|
|
TCHAR* strTS = OLE2T(vData.bstrVal);
|
|
|
|
if(NULL == strTS){
|
|
|
|
throw(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
_tcscat(lpszCmdLine, strTS);
|
|
|
|
// take the container out of the top-most mode
|
|
::SetWindowPos(m_hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
|
|
SWP_NOREDRAW|SWP_NOMOVE|SWP_NOSIZE);
|
|
|
|
#ifndef _UNICODE
|
|
if(WinExec(lpszCmdLine, SW_SHOW) <= 31){
|
|
#else
|
|
long cCharacters = wcslen(lpszCmdLine)+1;
|
|
long cbAnsi = cCharacters*2;
|
|
|
|
// Use of the OLE allocator is not required because the resultant
|
|
// ANSI string will never be passed to another COM component. You
|
|
// can use your own allocator.
|
|
LPSTR pszA = (LPSTR) CoTaskMemAlloc(cbAnsi);
|
|
|
|
if (NULL == pszA)
|
|
throw(E_OUTOFMEMORY);
|
|
|
|
if (0 == WideCharToMultiByte(CP_ACP, 0, lpszCmdLine, cCharacters, pszA, cbAnsi, NULL, NULL)) {
|
|
DWORD dwError = GetLastError();
|
|
CoTaskMemFree(pszA);
|
|
throw HRESULT_FROM_WIN32(dwError);
|
|
}
|
|
|
|
if(WinExec(pszA, SW_SHOW) <= 31){
|
|
CoTaskMemFree(pszA);
|
|
#endif
|
|
//if(!::CreateProcess(lpszCmdLine, NULL , NULL, NULL, FALSE, 0, NULL, NULL, NULL, NULL)){
|
|
|
|
ATLASSERT(FALSE);
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
#ifdef _UNICODE
|
|
CoTaskMemFree(pszA);
|
|
#endif
|
|
|
|
}
|
|
else {
|
|
|
|
// take the container out of the top-most mode
|
|
::SetWindowPos(m_hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
|
|
SWP_NOREDRAW|SWP_NOMOVE|SWP_NOSIZE);
|
|
m_bHandleUserFocus = FALSE;
|
|
|
|
HWND hWndNew = CallHtmlHelp(h, OLE2T(strHelpFile), lCommand, pData);
|
|
|
|
if(!::IsWindow(hWndNew)){
|
|
|
|
// failed so lets try to get some more meaningful result
|
|
hr = HRESULT_FROM_WIN32(::GetLastError());
|
|
}/* end of if statement */
|
|
|
|
}/* end of if statement */
|
|
|
|
}/* end of try statement */
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return (hr);
|
|
}/* end of function HTMLHelp */
|
|
|
|
/*************************************************************************/
|
|
/* Function: MessageBox */
|
|
/* Description: Displays the message box using specified parameters. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::MessageBox(BSTR strText, BSTR strCaption, long lType){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
USES_CONVERSION;
|
|
|
|
HWND hWnd = NULL;
|
|
HRESULT hr = GetWindow(&hWnd);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
ATLASSERT(FALSE);
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
LPTSTR strTemp1 = OLE2T(strText);
|
|
LPTSTR strTemp2 = OLE2T(strCaption);
|
|
if (strTemp1 != NULL && strTemp2 != NULL)
|
|
{
|
|
::MessageBox(hWnd, strTemp1, strTemp2, lType);
|
|
}
|
|
else
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
}
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
return S_OK;
|
|
}/* end of function MessageBox */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetToolbarName */
|
|
/* Description: Gets and allocates the toolbar name. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::GetToolbarName(BSTR* strToolbarName){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(NULL == strToolbarName){
|
|
|
|
hr = E_POINTER;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
const INT ciMaxBuffSize = MAX_PATH; // should be enough for tlbr ID, keep ID small if can
|
|
TCHAR strBuffer[ciMaxBuffSize];
|
|
|
|
if(!::LoadString(m_hRes, IDS_ROOT_OBJECT, strBuffer, ciMaxBuffSize)){
|
|
|
|
hr = E_FAIL;
|
|
return(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
#ifdef _UNICODE
|
|
*strToolbarName = ::SysAllocString(strBuffer);
|
|
#else
|
|
USES_CONVERSION;
|
|
*strToolbarName = ::SysAllocString(T2OLE(strBuffer));
|
|
#endif
|
|
|
|
return(hr);
|
|
}/* end of function GetToolbarName */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetPriority */
|
|
/* Description: Sets the thread priority. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::SetPriority(long lPriority){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
HANDLE hThread = ::GetCurrentThread();
|
|
|
|
if(!::SetThreadPriority(hThread, lPriority)){
|
|
|
|
hr = HRESULT_FROM_WIN32(::GetLastError());
|
|
throw (hr);
|
|
}/* end of if statement */
|
|
}
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return (hr);
|
|
}/* end of function SetPriority */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetPriorityClass */
|
|
/* Description: Sets the thread priority. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::SetPriorityClass(long lPriority){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
HANDLE hThread = ::GetCurrentThread();
|
|
|
|
if(!::SetPriorityClass(hThread, lPriority)){
|
|
|
|
hr = HRESULT_FROM_WIN32(::GetLastError());
|
|
throw (hr);
|
|
}/* end of if statement */
|
|
}
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return (hr);
|
|
}/* end of function SetPriorityClass */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_BackgroundImage */
|
|
/* Description: Gets the backround image. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::get_BackgroundImage(BSTR *pstrFilename){
|
|
|
|
*pstrFilename = m_bstrBackImageFilename.Copy();
|
|
return S_OK;
|
|
}/* end of function get_BackgroundImage */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_BackgroundImage */
|
|
/* Description: Attempts to load the background image. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::put_BackgroundImage(BSTR strFilename){
|
|
|
|
USES_CONVERSION;
|
|
HRESULT hr = S_OK;
|
|
|
|
if(NULL != m_pBackBitmap){
|
|
|
|
delete m_pBackBitmap;
|
|
}/* end of if statement */
|
|
|
|
m_pBackBitmap = new CBitmap;
|
|
|
|
//m_pBackBitmap->LoadPalette(true); // load the palette if available, since this
|
|
// is the palette we use for the rest
|
|
// of the contained objects
|
|
|
|
m_bstrBackImageFilename = strFilename;
|
|
|
|
TCHAR strBuffer[MAX_PATH] = TEXT("\0");
|
|
|
|
bool fGrayOut = false;
|
|
|
|
hr = m_pBackBitmap->PutImage(strFilename, m_hRes, FALSE, m_blitType, CUSTOM_CONTAINER);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
// we are updating image that is being used, refresh it
|
|
ATLTRACE2(atlTraceWindowing, 20, TEXT("Redrawing the image\n"));
|
|
InvalidateRgn(); // our helper function
|
|
|
|
return(hr);
|
|
}/* end of function put_BackgroundImage */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetReadyState */
|
|
/* Description: Sets ready state and fires event if it needs to be fired */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::SetReadyState(LONG lReadyState){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
bool bFireEvent = (lReadyState != m_nReadyState);
|
|
|
|
|
|
#ifdef _DEBUG
|
|
if(m_nFreezeEvents > 0){
|
|
|
|
::Sleep(10);
|
|
ATLTRACE("Container not expecting events at the moment");
|
|
}/* end of is statement */
|
|
|
|
#endif
|
|
|
|
if(bFireEvent){
|
|
|
|
put_ReadyState(lReadyState);
|
|
Fire_ReadyStateChange(lReadyState);
|
|
}
|
|
else {
|
|
// set the variable
|
|
m_nReadyState = lReadyState;
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function SetReadyState */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnPostVerbInPlaceActivate */
|
|
/* Description: Creates the in place active object. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::OnPostVerbInPlaceActivate(){
|
|
|
|
SetReadyState(READYSTATE_COMPLETE);
|
|
|
|
return(S_OK);
|
|
}/* end of function OnPostVerbInPlaceActivate */
|
|
|
|
/*************************************************************************/
|
|
/* Function: get_AutoLoad */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::get_AutoLoad(VARIANT_BOOL *pVal){
|
|
|
|
*pVal = m_fAutoLoad;
|
|
|
|
return S_OK;
|
|
}/* end of function get_AutoLoad */
|
|
|
|
/*************************************************************************/
|
|
/* Function: put_AutoLoad */
|
|
/* Description: Sets the flag to autolaod the engine after we set a */
|
|
/* script file or not. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::put_AutoLoad(VARIANT_BOOL newVal){
|
|
|
|
m_fAutoLoad = (VARIANT_FALSE == newVal ? VARIANT_FALSE : VARIANT_TRUE);
|
|
|
|
return S_OK;
|
|
}/* end of function put_AutoLoad */
|
|
|
|
/*************************************************************/
|
|
/* Name: SetRectRgn
|
|
/* Description: Set up a rectangular window update region
|
|
/*************************************************************/
|
|
STDMETHODIMP CMFBar::SetRectRgn(long x1, long y1, long x2, long y2)
|
|
{
|
|
HRGN hRgn = ::CreateRectRgn( x1, y1, x2, y2 );
|
|
::SetWindowRgn(m_hWnd, hRgn, TRUE);
|
|
return S_OK;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name: SetRoundRectRgn
|
|
/* Description: Set up a round corner window update region
|
|
/*************************************************************/
|
|
STDMETHODIMP CMFBar::SetRoundRectRgn(long x1, long y1, long x2, long y2, long width, long height){
|
|
|
|
HRGN hRgn = ::CreateRoundRectRgn(x1, y1, x2, y2, width, height);
|
|
::SetWindowRgn(m_hWnd, hRgn, TRUE);
|
|
return S_OK;
|
|
}/* end of function SetRoundRectRgn */
|
|
|
|
/*************************************************************/
|
|
/* Function: SetTimeout */
|
|
/* Description: Creates a timer and then calls events when */
|
|
/* timer proc gets called. */
|
|
/*************************************************************/
|
|
STDMETHODIMP CMFBar::SetTimeout(long lTimeout, long lId){
|
|
|
|
if(lTimeout < 0){
|
|
|
|
return(E_INVALIDARG);
|
|
}/* end of if statement */
|
|
|
|
if(!::IsWindow(m_hWnd)){
|
|
|
|
return(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
if(ID_EV_TIMER == lId){
|
|
|
|
return(E_INVALIDARG);
|
|
}/* end of if statement */
|
|
|
|
if(lTimeout == 0){
|
|
|
|
::KillTimer(m_hWnd, lId);
|
|
}
|
|
else{
|
|
|
|
if(0 != lTimeout){
|
|
|
|
if(0 == ::SetTimer(m_hWnd, lId, lTimeout, NULL)){
|
|
|
|
return(E_FAIL);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return S_OK;
|
|
}/* end of function SetTimeout */
|
|
|
|
/*************************************************************/
|
|
/* Function: Sleep */
|
|
/*************************************************************/
|
|
STDMETHODIMP CMFBar::Sleep(long lMiliseconds){
|
|
|
|
::Sleep(lMiliseconds);
|
|
|
|
return S_OK;
|
|
}/* end of function Sleep */
|
|
|
|
/*************************************************************/
|
|
/* Name: OnButtonDown
|
|
/* Description: Handles WM_MOUSEDOWN
|
|
/*************************************************************/
|
|
LRESULT CMFBar::OnButtonDown(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
m_ptMouse.x = GET_X_LPARAM(lParam);
|
|
m_ptMouse.y = GET_Y_LPARAM(lParam);
|
|
::ClientToScreen(m_hWnd, &m_ptMouse);
|
|
SetCapture(TRUE);
|
|
SetFocus(TRUE);
|
|
ATLTRACE(TEXT("Button down, starting to track\n"));
|
|
|
|
m_bMouseDown = true;
|
|
|
|
// Test for resize hit region
|
|
::GetWindowRect(m_hWnd, &m_rcWnd);
|
|
m_HitRegion = ResizeHitRegion(m_ptMouse);
|
|
UpdateCursor(m_HitRegion);
|
|
}/* end of if statement */
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name: OnButtonUp
|
|
/* Description: Handles WM_MOUSEUP
|
|
/*************************************************************/
|
|
LRESULT CMFBar::OnButtonUp(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
if(::IsWindow(m_hWnd)){
|
|
|
|
m_bMouseDown = false;
|
|
|
|
SetCapture(FALSE);
|
|
ATLTRACE(TEXT("Done tracking the window\n"));
|
|
m_HitRegion = ResizeHitRegion(m_ptMouse);
|
|
UpdateCursor(m_HitRegion);
|
|
|
|
}/* end of if statement */
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name: OnMouseMove
|
|
/* Description: Handles WM_MOUSEMOVE
|
|
/*************************************************************/
|
|
LRESULT CMFBar::OnMouseMove(UINT, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
|
|
if(::IsWindow(m_hWnd)){
|
|
::GetWindowRect(m_hWnd, &m_rcWnd);
|
|
|
|
POINT ptMouse;
|
|
ptMouse.x = GET_X_LPARAM(lParam);
|
|
ptMouse.y = GET_Y_LPARAM(lParam);
|
|
::ClientToScreen(m_hWnd, &ptMouse);
|
|
|
|
// Test for resize hit region
|
|
HitRegion hitRegion = ResizeHitRegion(ptMouse);
|
|
if (!m_bMouseDown && m_HitRegion!=PREMOVE && m_HitRegion!=PRESIZE)
|
|
UpdateCursor(hitRegion);
|
|
|
|
// No mouse movement, return
|
|
long xAdjustment = m_ptMouse.x - ptMouse.x;
|
|
long yAdjustment = m_ptMouse.y - ptMouse.y;
|
|
if (xAdjustment == 0 && yAdjustment == 0)
|
|
return 0;
|
|
|
|
m_ptMouse = ptMouse;
|
|
// ATLTRACE(TEXT("Mouse pos: %d %d\n"), m_ptMouse.x, m_ptMouse.y);
|
|
|
|
if (m_HitRegion!=NOHIT && m_bMouseDown) {
|
|
long resizeX = m_rcWnd.left;
|
|
long resizeY = m_rcWnd.top;
|
|
long resizeW = RECTWIDTH(&m_rcWnd);
|
|
long resizeH = RECTHEIGHT(&m_rcWnd);
|
|
HWND desktopWnd = ::GetDesktopWindow();
|
|
RECT desktopRC;
|
|
::GetWindowRect(desktopWnd, &desktopRC);
|
|
|
|
if (m_HitRegion & LEFT) {
|
|
ptMouse.x -= SYS_MOVE_SIZE;
|
|
resizeW = m_rcWnd.right-ptMouse.x;
|
|
if (resizeW >RECTWIDTH(&desktopRC)) {
|
|
resizeW = RECTWIDTH(&desktopRC);
|
|
}
|
|
else if (resizeW < m_lMinWidth) {
|
|
resizeW = m_lMinWidth;
|
|
}
|
|
resizeX = m_rcWnd.right-resizeW;
|
|
}
|
|
if (m_HitRegion & RIGHT) {
|
|
ptMouse.x += SYS_MOVE_SIZE;
|
|
resizeW = ptMouse.x-m_rcWnd.left;
|
|
if (resizeW >RECTWIDTH(&desktopRC)) {
|
|
resizeW = RECTWIDTH(&desktopRC);
|
|
}
|
|
else if (resizeW < m_lMinWidth) {
|
|
resizeW = m_lMinWidth;
|
|
}
|
|
}
|
|
if (m_HitRegion & TOP) {
|
|
ptMouse.y -= SYS_MOVE_SIZE;
|
|
resizeH = m_rcWnd.bottom-ptMouse.y;
|
|
if (resizeH >RECTHEIGHT(&desktopRC)) {
|
|
resizeH = RECTHEIGHT(&desktopRC);
|
|
}
|
|
else if (resizeH < m_lMinHeight) {
|
|
resizeH = m_lMinHeight;
|
|
}
|
|
resizeY = m_rcWnd.bottom - resizeH;
|
|
}
|
|
if (m_HitRegion & BOTTOM) {
|
|
ptMouse.y += SYS_MOVE_SIZE;
|
|
resizeH = ptMouse.y-m_rcWnd.top;
|
|
if (resizeH >RECTHEIGHT(&desktopRC)) {
|
|
resizeH = RECTHEIGHT(&desktopRC);
|
|
}
|
|
else if (resizeH < m_lMinHeight) {
|
|
resizeH = m_lMinHeight;
|
|
}
|
|
}
|
|
|
|
if (resizeW >= m_lMinWidth || resizeH >= m_lMinHeight) {
|
|
|
|
if(NULL != m_pBackBitmap){
|
|
|
|
m_pBackBitmap->DeleteMemDC();
|
|
}/* end of if statement */
|
|
|
|
::MoveWindow(m_hWnd, resizeX, resizeY, resizeW, resizeH, TRUE);
|
|
ATLTRACE2(atlTraceWindowing, 30, TEXT("Resize window to: %d %d %d %d\n"), resizeX, resizeY, resizeX+resizeW, resizeY+resizeH);
|
|
|
|
}
|
|
|
|
}/* end of if statement */
|
|
|
|
|
|
else if(m_bMouseDown){
|
|
long x = m_rcWnd.left;
|
|
long y = m_rcWnd.top;
|
|
long width = RECTWIDTH(&m_rcWnd);
|
|
long height = RECTHEIGHT(&m_rcWnd);
|
|
::MoveWindow(m_hWnd, x - xAdjustment, y - yAdjustment, width, height, TRUE);
|
|
ATLTRACE2(atlTraceWindowing, 32, TEXT("Moving the window\n"));
|
|
m_ptMouse = ptMouse;
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name: ResizeHitRegion */
|
|
/* Description: Test if mouse is in resize hit region */
|
|
/*************************************************************/
|
|
HitRegion CMFBar::ResizeHitRegion(POINT p){
|
|
|
|
// TODO: DO NOT HARDCODE THE REGION SIZES
|
|
int hitRegion = NOHIT;
|
|
if (abs(p.x-m_rcWnd.left)<=10) {
|
|
hitRegion |= LEFT;
|
|
}
|
|
else if (abs(p.x-m_rcWnd.right)<=10) {
|
|
hitRegion |= RIGHT;
|
|
}/* end of if statement */
|
|
|
|
if (abs(p.y-m_rcWnd.top)<=10) {
|
|
hitRegion |= TOP;
|
|
}
|
|
else if (abs(p.y-m_rcWnd.bottom)<=10) {
|
|
hitRegion |= BOTTOM;
|
|
}/* end of if statement */
|
|
|
|
return (HitRegion)hitRegion;
|
|
}/* end of function ResizeHitRegion */
|
|
|
|
/*************************************************************/
|
|
/* Name: UpdateCursor */
|
|
/* Description: Change cursor shape to move arrows */
|
|
/*************************************************************/
|
|
HRESULT CMFBar::UpdateCursor(HitRegion hitRegion){
|
|
|
|
if (m_hCursor)
|
|
::DestroyCursor(m_hCursor);
|
|
|
|
int iHitRegion = (int) hitRegion;
|
|
switch (iHitRegion) {
|
|
case PREMOVE:
|
|
case PRESIZE:
|
|
m_hCursor = ::LoadCursor(0, IDC_SIZEALL);
|
|
break;
|
|
case LEFT|NOHIT:
|
|
case RIGHT|NOHIT:
|
|
m_hCursor = ::LoadCursor(0, IDC_SIZEWE);
|
|
break;
|
|
case TOP|NOHIT:
|
|
case BOTTOM|NOHIT:
|
|
m_hCursor = ::LoadCursor(0, IDC_SIZENS);
|
|
break;
|
|
case LEFT|TOP|NOHIT:
|
|
case RIGHT|BOTTOM|NOHIT:
|
|
m_hCursor = ::LoadCursor(0, IDC_SIZENWSE);
|
|
break;
|
|
case RIGHT|TOP|NOHIT:
|
|
case LEFT|BOTTOM|NOHIT:
|
|
m_hCursor = ::LoadCursor(0, IDC_SIZENESW);
|
|
break;
|
|
default:
|
|
m_hCursor = ::LoadCursor(0, IDC_ARROW);
|
|
break;
|
|
|
|
}/* end of switch statement */
|
|
|
|
::SetCursor(m_hCursor);
|
|
|
|
return S_OK;
|
|
}/* end of function UpdateCursor */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetObjectFocus */
|
|
/* Description: Sets or resets focus to specific object. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::SetObjectFocus(BSTR strObjectID, VARIANT_BOOL fEnable){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
CHostedObject* pObj;
|
|
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statetement */
|
|
|
|
LONG lRes = 0;
|
|
|
|
hr = SetObjectFocus(pObj, VARIANT_FALSE == fEnable ? FALSE : TRUE, lRes);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statement */
|
|
|
|
if(-1 == lRes){
|
|
|
|
throw(E_FAIL); // the control did not take the focus since it is disabled
|
|
}/* end of if statement */
|
|
|
|
}/* end of try statement */
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return(hr);
|
|
}/* end of function SetObjectFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: HasObjectFocus */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CMFBar::HasObjectFocus(BSTR strObjectID, VARIANT_BOOL* pfEnable){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
CHostedObject* pObj;
|
|
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statetement */
|
|
|
|
*pfEnable = pObj->HasFocus() ? VARIANT_TRUE : VARIANT_FALSE;
|
|
|
|
}/* end of try statement */
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return(hr);
|
|
}/* end of function HasObjectFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetObjectFocus */
|
|
/* Description: Sets or resets focus to specific object. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::SetObjectFocus(CHostedObject* pObj, BOOL fSet, LONG& lRes){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
CContainerObject* pCnt;
|
|
hr = pObj->GetContainerObject(&pCnt);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
LONG lParam = 0;
|
|
BOOL bHandled = FALSE;
|
|
|
|
if(fSet){
|
|
|
|
ResetFocusFlags(); // reset old focus on other control
|
|
pCnt->SetFocus(TRUE);
|
|
SendMessageToCtl(pObj, WM_SETFOCUS, (WPARAM) m_hWnd, lParam, bHandled, lRes, false);
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("Sending WM_SETFOCUS to %ls \n"), pObj->GetID());
|
|
}
|
|
else {
|
|
|
|
pCnt->SetFocus(FALSE); // disable focus and caputure if we are disabeling the object
|
|
SendMessageToCtl(pObj, WM_KILLFOCUS, (WPARAM) m_hWnd, lParam, bHandled, lRes, false);
|
|
|
|
ATLTRACE2(atlTraceUser, 31, TEXT("Sending WM_KILLFOCUS to %ls \n"), pObj->GetID());
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function SetObjectFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: FindObject */
|
|
/* Description: Itterates the objects till it finds the one with matching*/
|
|
/* ID. */
|
|
/*************************************************************************/
|
|
HRESULT CMFBar::FindObject(BSTR strObjectID, CHostedObject** ppObj){
|
|
|
|
HRESULT hr = E_FAIL; // did not find the object
|
|
*ppObj = NULL;
|
|
|
|
for(CNTOBJ::iterator i = m_cntObj.begin(); i!= m_cntObj.end(); i++){
|
|
|
|
CHostedObject* pObj = (*i);
|
|
|
|
if(NULL == pObj){
|
|
|
|
continue;
|
|
}/* end of if statement */
|
|
|
|
if(!_wcsicmp(pObj->GetID(), strObjectID)){
|
|
|
|
*ppObj = pObj; // set the pointer and bail out
|
|
hr = S_OK;
|
|
break; // got the unknown get out
|
|
}/* end of if statement */
|
|
}/* end of for loop */
|
|
|
|
return(hr);
|
|
}/* end of function FindObject */
|
|
|
|
/*************************************************************/
|
|
/* Name: HasObjectCapture */
|
|
/* Description: Gives us status of capture on specific object*/
|
|
/*************************************************************/
|
|
STDMETHODIMP CMFBar::HasObjectCapture(BSTR strObjectID, VARIANT_BOOL *pfEnable){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
CHostedObject* pObj;
|
|
|
|
hr = FindObject(strObjectID, &pObj);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
throw(hr);
|
|
}/* end of if statetement */
|
|
|
|
*pfEnable = pObj->HasCapture() ? VARIANT_TRUE : VARIANT_FALSE;
|
|
|
|
}/* end of try statement */
|
|
catch(HRESULT hrTmp){
|
|
|
|
hr = hrTmp;
|
|
}
|
|
catch(...){
|
|
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return(hr);
|
|
}/* end of function HasObjectCapture */
|
|
|
|
/*************************************************************/
|
|
/* Name: PopupSystemMenu
|
|
/* Description:
|
|
/*************************************************************/
|
|
STDMETHODIMP CMFBar::PopupSystemMenu(long x, long y)
|
|
{
|
|
|
|
if (m_hMenu == NULL)
|
|
return S_FALSE;
|
|
|
|
RECT rc;
|
|
::GetWindowRect(m_hWnd, &rc);
|
|
|
|
m_bSysMenuOn = TRUE;
|
|
m_bHandleEnter = TRUE;
|
|
|
|
if (x < 0)
|
|
x = rc.left;
|
|
if (y < 0)
|
|
y = rc.top+SYS_TITLEBAR_WIDTH;
|
|
|
|
::TrackPopupMenu(::GetSubMenu(m_hMenu, 0), TPM_LEFTALIGN, x, y, 0, m_hWnd, 0);
|
|
|
|
m_bSysMenuOn = FALSE;
|
|
return S_OK;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name: GetRegistryDword
|
|
/* Description:
|
|
/*************************************************************/
|
|
BOOL GetRegistryDword(const TCHAR *pValueName, const TCHAR *pSubKey, DWORD* dwRet, DWORD dwDefault)
|
|
{
|
|
HKEY hKey;
|
|
LONG lRet;
|
|
*dwRet = dwDefault;
|
|
|
|
lRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, pSubKey, 0, KEY_QUERY_VALUE, &hKey);
|
|
if (lRet == ERROR_SUCCESS) {
|
|
|
|
DWORD dwType, dwLen;
|
|
dwLen = sizeof(DWORD);
|
|
|
|
lRet = RegQueryValueEx(hKey, pValueName, NULL, &dwType, (LPBYTE)dwRet, &dwLen);
|
|
if (ERROR_SUCCESS != lRet)
|
|
*dwRet = dwDefault;
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
return (lRet == ERROR_SUCCESS);
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name: SetRegistryDword
|
|
/* Description:
|
|
/*************************************************************/
|
|
BOOL SetRegistryDword(const TCHAR *pValueName, const TCHAR *pSubKey, DWORD dwRet)
|
|
{
|
|
HKEY hKey;
|
|
LONG lRet;
|
|
|
|
lRet = RegCreateKey(HKEY_LOCAL_MACHINE, pSubKey, &hKey);
|
|
if (lRet == ERROR_SUCCESS) {
|
|
|
|
lRet = RegSetValueEx(hKey, pValueName, NULL, REG_DWORD, (LPBYTE)&dwRet, sizeof(dwRet));
|
|
RegCloseKey(hKey);
|
|
}
|
|
return (lRet == ERROR_SUCCESS);
|
|
}
|
|
|
|
const TCHAR g_szLeft[] = TEXT("Left");
|
|
const TCHAR g_szTop[] = TEXT("Top");
|
|
const TCHAR g_szRight[] = TEXT("Right");
|
|
const TCHAR g_szBottom[] = TEXT("Bottom");
|
|
const TCHAR g_szFullScreen[] = TEXT("FullScreen");
|
|
const TCHAR g_szUserData[] = TEXT("UserData");
|
|
const TCHAR g_szKey[] = TEXT("Software\\Microsoft\\Multimedia\\MSMFCnt\\");
|
|
/*************************************************************/
|
|
/* Name: SaveSelfHostState
|
|
/* Description:
|
|
/*************************************************************/
|
|
STDMETHODIMP CMFBar::SaveSelfHostState(BSTR strAppName)
|
|
{
|
|
USES_CONVERSION;
|
|
TCHAR *szAppName = OLE2T(strAppName);
|
|
|
|
TCHAR szSubKey[MAX_PATH];
|
|
_stprintf(szSubKey, TEXT("%s%s"), g_szKey, szAppName);
|
|
|
|
if (m_fSelfHosted && ::IsWindow(m_hWnd)) {
|
|
|
|
WINDOWPLACEMENT wndPlacement;
|
|
wndPlacement.length = sizeof(WINDOWPLACEMENT);
|
|
::GetWindowPlacement(m_hWnd, &wndPlacement);
|
|
|
|
if (wndPlacement.showCmd == SW_SHOWMAXIMIZED) {
|
|
SetRegistryDword(g_szFullScreen, szSubKey, 1);
|
|
}
|
|
|
|
else {
|
|
SetRegistryDword(g_szFullScreen, szSubKey, 0);
|
|
}
|
|
|
|
SetRegistryDword(g_szLeft, szSubKey, wndPlacement.rcNormalPosition.left);
|
|
SetRegistryDword(g_szTop, szSubKey, wndPlacement.rcNormalPosition.top);
|
|
SetRegistryDword(g_szRight, szSubKey, wndPlacement.rcNormalPosition.right);
|
|
SetRegistryDword(g_szBottom, szSubKey, wndPlacement.rcNormalPosition.bottom);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name: RestoreSelfHostState
|
|
/* Description:
|
|
/*************************************************************/
|
|
STDMETHODIMP CMFBar::RestoreSelfHostState(BSTR strAppName)
|
|
{
|
|
USES_CONVERSION;
|
|
TCHAR *szAppName = OLE2T(strAppName);
|
|
|
|
TCHAR szSubKey[MAX_PATH];
|
|
_stprintf(szSubKey, TEXT("%s%s"), g_szKey, szAppName);
|
|
|
|
if (m_fSelfHosted && ::IsWindow(m_hWnd)) {
|
|
|
|
BOOL bFullScreen;
|
|
GetRegistryDword(g_szFullScreen, szSubKey, (DWORD*)&bFullScreen, 0);
|
|
|
|
UINT uFlags = SWP_NOZORDER;
|
|
if (bFullScreen)
|
|
uFlags |= SWP_HIDEWINDOW;
|
|
|
|
DWORD left, top, right, bottom;
|
|
if (
|
|
GetRegistryDword(g_szLeft, szSubKey, &left, 0) &&
|
|
GetRegistryDword(g_szTop, szSubKey, &top, 0) &&
|
|
GetRegistryDword(g_szRight, szSubKey, &right, 0) &&
|
|
GetRegistryDword(g_szBottom, szSubKey, &bottom, 0) ) {
|
|
if (0 == ::SetWindowPos(m_hWnd, 0, left, top, right-left, bottom-top, uFlags))
|
|
return E_FAIL;
|
|
}
|
|
|
|
else {
|
|
if (!bFullScreen)
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (bFullScreen) {
|
|
ShowSelfSite(SW_MAXIMIZE);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name:
|
|
/* Description:
|
|
/*************************************************************/
|
|
STDMETHODIMP CMFBar::SaveSelfHostUserData(BSTR strAppName, long lData)
|
|
{
|
|
USES_CONVERSION;
|
|
TCHAR *szAppName = OLE2T(strAppName);
|
|
|
|
TCHAR szSubKey[MAX_PATH];
|
|
_stprintf(szSubKey, TEXT("%s%s"), g_szKey, szAppName);
|
|
|
|
SetRegistryDword(g_szUserData, szSubKey, lData);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name:
|
|
/* Description:
|
|
/*************************************************************/
|
|
STDMETHODIMP CMFBar::GetSelfHostUserData(BSTR strAppName, long *lData)
|
|
{
|
|
USES_CONVERSION;
|
|
TCHAR *szAppName = OLE2T(strAppName);
|
|
|
|
TCHAR szSubKey[MAX_PATH];
|
|
_stprintf(szSubKey, TEXT("%s%s"), g_szKey, szAppName);
|
|
|
|
DWORD dwRet;
|
|
if (GetRegistryDword(g_szUserData, szSubKey, &dwRet, 0)) {
|
|
*lData = dwRet;
|
|
return S_OK;
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
/*************************************************************/
|
|
/* Name: get_DoubleClickTime
|
|
/* Description:
|
|
/*************************************************************/
|
|
STDMETHODIMP CMFBar::get_DoubleClickTime(long *pVal)
|
|
{
|
|
if (pVal == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*pVal = ::GetDoubleClickTime();
|
|
return S_OK;
|
|
}
|
|
|
|
/*************************************************************************/
|
|
/* End of file: MFBar.cpp */
|
|
/*************************************************************************/
|
|
|
|
|
|
|