You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2019 lines
52 KiB
2019 lines
52 KiB
//#--------------------------------------------------------------
|
|
//
|
|
// File: mainwindow.cpp
|
|
//
|
|
// Synopsis: This file holds the implementation of the
|
|
// CMainWindow class
|
|
//
|
|
// History: 11/10/2000 serdarun Created
|
|
//
|
|
// Copyright (C) 1999-2000 Microsoft Corporation
|
|
// All rights reserved.
|
|
//
|
|
//#--------------------------------------------------------------
|
|
|
|
|
|
#include "stdafx.h"
|
|
#include "mainwindow.h"
|
|
|
|
|
|
//
|
|
// PROGID of the Localization Manager
|
|
//
|
|
const WCHAR LOCALIZATION_MANAGER [] = L"ServerAppliance.LocalizationManager";
|
|
|
|
const WCHAR szMainPage[] = L"\\localui_main.htm";
|
|
|
|
const WCHAR szLocalUIDir[] = L"\\ServerAppliance\\localui";
|
|
|
|
//
|
|
// startup registrypages
|
|
//
|
|
const WCHAR szLocalUI_StartPage[] = L"\\localui_startup_start.htm";
|
|
|
|
const WCHAR szLocalUI_ShutdownPage[] = L"\\localui_startup_shutdown.htm";
|
|
|
|
const WCHAR szLocalUI_UpdatePage[] = L"\\localui_startup_update.htm";
|
|
|
|
const WCHAR szLocalUI_ReadyPage[] = L"\\localui_startup_ready.htm";
|
|
|
|
//
|
|
// WBEM namespace to connection to
|
|
//
|
|
const WCHAR DEFAULT_NAMESPACE[] = L"\\\\.\\ROOT\\CIMV2";
|
|
|
|
//
|
|
// Query Language to use for WBEM
|
|
//
|
|
const WCHAR QUERY_LANGUAGE [] = L"WQL";
|
|
|
|
//
|
|
// WBEM query which specifies the type of events we are interested
|
|
// in
|
|
//
|
|
const WCHAR QUERY_STRING [] = L"select * from Microsoft_SA_AlertEvent";
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: startworkerroutine
|
|
//
|
|
// Synopsis: This is thread method for starting keypad reading
|
|
//
|
|
// Arguments: PVOID - pointer to main window class object
|
|
//
|
|
// Returns: DWORD - success/failure
|
|
//
|
|
// History: serdarun Created 11/10/2000
|
|
//
|
|
// Called By: Init method of CMainWindow
|
|
//
|
|
//----------------------------------------------------------------
|
|
DWORD WINAPI startworkerroutine (
|
|
/*[in]*/ PVOID pArg
|
|
)
|
|
{
|
|
((CMainWindow*)pArg)->KeypadReader();
|
|
|
|
return 0;
|
|
} // end of startworkerroutine method
|
|
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: Invoke
|
|
//
|
|
// Synopsis: This is the Invoke method of famous IDispatch interface
|
|
//
|
|
// Arguments: See MSDN for detailed description
|
|
//
|
|
// Returns: HRESULT - success/failure
|
|
//
|
|
// History: serdarun Created 11/10/2000
|
|
//
|
|
// Called By: WebBrowser control created by main window to notify events
|
|
//
|
|
//----------------------------------------------------------------
|
|
STDMETHODIMP CWebBrowserEventSink::Invoke(DISPID dispid, REFIID riid, LCID lcid,
|
|
WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult,
|
|
EXCEPINFO* pexcepinfo, UINT* puArgErr)
|
|
{
|
|
//
|
|
//return immediately if we don't have a valid window pointer
|
|
//
|
|
if (NULL == m_pMainWindow)
|
|
return S_OK;
|
|
|
|
switch (dispid)
|
|
{
|
|
//
|
|
//Occurs when a document has reached the READYSTATE_COMPLETE state
|
|
//
|
|
case DISPID_DOCUMENTCOMPLETE:
|
|
if ( (pdispparams->cArgs == 2)
|
|
&& (pdispparams->rgvarg[0].vt == (VT_VARIANT | VT_BYREF))
|
|
&& (pdispparams->rgvarg[1].vt == VT_DISPATCH) && m_bMainControl )
|
|
m_pMainWindow->PageLoaded(pdispparams->rgvarg[1].pdispVal, pdispparams->rgvarg[0].pvarVal);
|
|
else
|
|
m_pMainWindow->RegistryPageLoaded(pdispparams->rgvarg[1].pdispVal, pdispparams->rgvarg[0].pvarVal);
|
|
break;
|
|
//
|
|
//Occurs before a navigation in the given WebBrowser
|
|
//
|
|
case DISPID_BEFORENAVIGATE2:
|
|
if (m_bMainControl)
|
|
m_pMainWindow->LoadingNewPage();
|
|
break;
|
|
//
|
|
//Not interested in rest of the events
|
|
//
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return S_OK;
|
|
} // end of CWebBrowserEventSink::Invoke method
|
|
|
|
|
|
//
|
|
// constructor
|
|
//
|
|
CMainWindow::CMainWindow() :
|
|
m_hWorkerThread(INVALID_HANDLE_VALUE),
|
|
m_lDispWidth(0),
|
|
m_lDispHeight(0),
|
|
m_dwMainCookie(0),
|
|
m_dwSecondCookie(0),
|
|
m_bPageReady(FALSE),
|
|
m_pSAKeypadController(NULL),
|
|
m_pMainWebBrowser(NULL),
|
|
m_pMainWebBrowserUnk(NULL),
|
|
m_pMainInPlaceAO(NULL),
|
|
m_pMainOleObject(NULL),
|
|
m_pMainViewObject(NULL),
|
|
m_pMainWebBrowserEventSink(NULL),
|
|
m_pSecondWebBrowser(NULL),
|
|
m_pSecondWebBrowserUnk(NULL),
|
|
m_pSecondWebBrowserEventSink(NULL),
|
|
m_pLocInfo(NULL),
|
|
m_pLangChange(NULL),
|
|
m_RegBitmapState(BITMAP_STARTING),
|
|
m_pSAWbemSink(NULL),
|
|
m_pWbemServices(NULL),
|
|
m_pSAConsumer(NULL),
|
|
m_dwLEDMessageCode(1),
|
|
m_bInTaskorMainPage(FALSE),
|
|
m_pSaDisplay(NULL),
|
|
m_unintptrMainTimer(0),
|
|
m_unintptrSecondTimer(0),
|
|
m_bSecondIECreated(FALSE)
|
|
{
|
|
} // end of constructor
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: OnSaKeyMessage
|
|
//
|
|
// Synopsis: Message handler for wm_SaKeyMessage generated by
|
|
// keypad reader. It converts these messages to real
|
|
// WM_KEYDOWN messages and sends to IE control
|
|
//
|
|
// Arguments: windows message arguments
|
|
// WPARAM contains the key id
|
|
//
|
|
// Returns: LRESULT - success/failure
|
|
//
|
|
// History: serdarun Created 11/10/2000
|
|
//
|
|
//----------------------------------------------------------------
|
|
LRESULT CMainWindow::OnSaKeyMessage(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
LONG lMessage;
|
|
BOOL fShiftKey;
|
|
HRESULT hr;
|
|
BYTE aKeyboardState[300];
|
|
int iKey = wParam;
|
|
|
|
|
|
if (m_pSAKeypadController)
|
|
{
|
|
hr = m_pSAKeypadController->GetKey(iKey,&lMessage,&fShiftKey);
|
|
}
|
|
else
|
|
{
|
|
SATraceString ("CMainWindow::OnSaKeyMessage, don't have a valid keypad pointer...");
|
|
return 0;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("CMainWindow::OnSaKeyMessage failed on m_pSAKeypadController->GetKey");
|
|
return 0;
|
|
}
|
|
|
|
//if key is disabled
|
|
if (lMessage == 0)
|
|
return 0;
|
|
|
|
if (lMessage == -1)
|
|
{
|
|
m_pMainWebBrowser->GoBack();
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// get the current keyboard state
|
|
//
|
|
if (GetKeyboardState(aKeyboardState) == 0)
|
|
{
|
|
SATraceFailure("CMainWindow::OnSaKeyMessage failed on GetKeyboardState",GetLastError());
|
|
return 0;
|
|
}
|
|
|
|
if (fShiftKey)
|
|
aKeyboardState[VK_SHIFT] = 0xFF;
|
|
else
|
|
aKeyboardState[VK_SHIFT] = 0x00;
|
|
|
|
//
|
|
// set the new state with the shift key
|
|
//
|
|
if (SetKeyboardState(aKeyboardState) == 0)
|
|
{
|
|
SATraceFailure("CMainWindow::OnSaKeyMessage failed on SetKeyboardState",GetLastError());
|
|
return 0;
|
|
}
|
|
|
|
HWND hwnd = ::GetFocus();
|
|
HWND hwndTmp = m_hwndWebBrowser;
|
|
|
|
while (hwnd && hwndTmp)
|
|
{
|
|
if (hwnd == hwndTmp)
|
|
break;
|
|
hwndTmp = ::GetWindow(hwndTmp,GW_CHILD);
|
|
}
|
|
::PostMessage(hwndTmp,WM_KEYDOWN,lMessage,1);
|
|
|
|
|
|
return 0;
|
|
|
|
} // end of CMainWindow::OnSaKeyMessage
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: OnSaLocMessage
|
|
//
|
|
// Synopsis: Message handler for wm_SaLocMessage generated by
|
|
// keypad reader. It means Loc Id for the box has been
|
|
// changed
|
|
//
|
|
// Arguments: windows message arguments
|
|
//
|
|
// Returns: LRESULT - success/failure
|
|
//
|
|
// History: serdarun Created 11/28/2000
|
|
//
|
|
//----------------------------------------------------------------
|
|
LRESULT CMainWindow::OnSaLocMessage(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
//
|
|
// Initialize the state to the first page
|
|
//
|
|
m_RegBitmapState = BITMAP_STARTING;
|
|
|
|
CComBSTR bstrBootingPage = m_szLocalUIDir.c_str();
|
|
bstrBootingPage.Append(szLocalUI_StartPage);
|
|
//
|
|
// Second browser start the sequence
|
|
//
|
|
if (m_pSecondWebBrowser)
|
|
{
|
|
m_pSecondWebBrowser->Navigate(bstrBootingPage.Detach(),0,0,0,0);
|
|
}
|
|
|
|
//
|
|
// Main browser might refresh, talk to mkarki and kevinz
|
|
//
|
|
|
|
return 0;
|
|
} // end of CMainWindow::OnSaLocMessage
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: OnSaLEDMessage
|
|
//
|
|
// Synopsis: Message handler for wm_SaLEDMessage generated by
|
|
// sa cinsumer component.
|
|
//
|
|
// Arguments: windows message arguments
|
|
// WPARAM contains the LED code
|
|
//
|
|
// Returns: LRESULT - success/failure
|
|
//
|
|
// History: serdarun Created 11/10/2000
|
|
//
|
|
//----------------------------------------------------------------
|
|
LRESULT CMainWindow::OnSaLEDMessage(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
|
|
m_dwLEDMessageCode = wParam;
|
|
return 0;
|
|
|
|
} // end of CMainWindow::OnSaLEDMessage
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: OnSaAlertMessage
|
|
//
|
|
// Synopsis: Message handler for OnSaAlertMessage generated by
|
|
// sa consumer component.
|
|
//
|
|
// Arguments: windows message arguments
|
|
//
|
|
// Returns: LRESULT - success/failure
|
|
//
|
|
// History: serdarun Created 11/10/2000
|
|
//
|
|
//----------------------------------------------------------------
|
|
LRESULT CMainWindow::OnSaAlertMessage(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
|
|
//
|
|
// if we are not in tasks or main page, ignore alerts
|
|
//
|
|
if (!m_bInTaskorMainPage)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
SATraceString ("CMainWindow::OnSaAlertMessage, notifying the html page");
|
|
//
|
|
// send the special key press to the client
|
|
//
|
|
HWND hwnd = ::GetFocus();
|
|
HWND hwndTmp = m_hwndWebBrowser;
|
|
|
|
while (hwnd && hwndTmp)
|
|
{
|
|
if (hwnd == hwndTmp)
|
|
break;
|
|
hwndTmp = ::GetWindow(hwndTmp,GW_CHILD);
|
|
}
|
|
|
|
//
|
|
// Send a F24 key press to the html page, used for alerts
|
|
//
|
|
::PostMessage(hwndTmp,WM_KEYDOWN,VK_F24,1);
|
|
return 0;
|
|
|
|
} // end of CMainWindow::OnSaAlertMessage
|
|
|
|
|
|
LRESULT CMainWindow::OnTimer(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
|
|
//
|
|
// if it is a timer for registry page, print the page and go to the next page
|
|
//
|
|
if (wParam == m_unintptrSecondTimer)
|
|
{
|
|
KillTimer(m_unintptrSecondTimer);
|
|
PrintRegistryPage();
|
|
return 0;
|
|
}
|
|
|
|
|
|
if (m_bPageReady)
|
|
GetBitmap();
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CMainWindow::OnFocus(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
if (m_pMainOleObject)
|
|
m_pMainOleObject->DoVerb(OLEIVERB_UIACTIVATE,0,0,0,0,0);
|
|
return 0;
|
|
}
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: CreateMainIEControl
|
|
//
|
|
// Synopsis: Creates the main IE control and registers
|
|
// in the event sink
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: HRESULT - success/failure
|
|
//
|
|
// History: serdarun Created 11/10/2000
|
|
//
|
|
// Called By: CMainWindow::OnCreate method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT CMainWindow::CreateMainIEControl()
|
|
{
|
|
SATraceString ("Entering CMainWindow::CreateMainIEControl ...");
|
|
HRESULT hr = E_FAIL;
|
|
|
|
//
|
|
// Create the main IE control
|
|
//
|
|
m_hwndWebBrowser = ::CreateWindow(_T("AtlAxWin"), m_szMainPage.c_str(),
|
|
WS_CHILD|WS_VISIBLE, 0, 0, m_lDispWidth, m_lDispHeight, m_hWnd, NULL,
|
|
::GetModuleHandle(NULL), NULL);
|
|
|
|
if (NULL == m_hwndWebBrowser)
|
|
{
|
|
SATraceString ("CreateWindow for main IE control failed");
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Get a pointer to the control
|
|
//
|
|
AtlAxGetControl(m_hwndWebBrowser, &m_pMainWebBrowserUnk);
|
|
|
|
if (m_pMainWebBrowserUnk == NULL)
|
|
{
|
|
SATraceString ("Getting a pointer to the main control failed");
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// QI for the IWebBrowser2 interface
|
|
//
|
|
hr = m_pMainWebBrowserUnk->QueryInterface(IID_IWebBrowser2, (void**)&m_pMainWebBrowser);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("QI for IWebBrowser2 interface failed");
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// QI for the IOleInPlaceActiveObject interface
|
|
//
|
|
hr = m_pMainWebBrowserUnk->QueryInterface(IID_IOleInPlaceActiveObject, (void**)&m_pMainInPlaceAO);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("QI for IOleInPlaceActiveObject interface failed");
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// QI for the IOleObject interface
|
|
//
|
|
hr = m_pMainWebBrowserUnk->QueryInterface(IID_IOleObject, (void**)&m_pMainOleObject);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("QI for IOleObject interface failed");
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// QI for the IViewObject2 interface
|
|
//
|
|
hr = m_pMainWebBrowser->QueryInterface(IID_IViewObject2, (void**)&m_pMainViewObject);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("QI for IViewObject2 interface failed");
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Create the sink object for the events
|
|
//
|
|
hr = CComObject<CWebBrowserEventSink>::CreateInstance(&m_pMainWebBrowserEventSink);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("CreateInstance for sink object failed");
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Store the main window pointer for callbacks
|
|
//
|
|
m_pMainWebBrowserEventSink->m_pMainWindow = this;
|
|
|
|
//
|
|
// Register in the event sink of the main IE control
|
|
//
|
|
hr = AtlAdvise(m_pMainWebBrowserUnk, m_pMainWebBrowserEventSink->GetUnknown(), DIID_DWebBrowserEvents2, &m_dwMainCookie);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("AtlAdvise for main IE control failed");
|
|
return hr;
|
|
}
|
|
|
|
return S_OK;
|
|
} // end of CMainWindow::CreateMainIEControl
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: CreateSecondIEControl
|
|
//
|
|
// Synopsis: Creates the second IE control and registers
|
|
// in the event sink
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: HRESULT - success/failure
|
|
//
|
|
// History: serdarun Created 11/10/2000
|
|
//
|
|
// Called By: CMainWindow::OnCreate method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT CMainWindow::CreateSecondIEControl()
|
|
{
|
|
SATraceString ("Entering CMainWindow::CreateSecondIEControl ...");
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
wstring szStartUpPage;
|
|
|
|
szStartUpPage.assign(m_szLocalUIDir);
|
|
szStartUpPage.append(szLocalUI_StartPage);
|
|
//
|
|
// Create the main IE control
|
|
//
|
|
HWND m_hwndSecondWebBrowser = ::CreateWindow(_T("AtlAxWin"), szStartUpPage.c_str(),
|
|
WS_CHILD|WS_VISIBLE, 0, m_lDispHeight, m_lDispWidth, m_lDispHeight, m_hWnd, NULL,
|
|
::GetModuleHandle(NULL), NULL);
|
|
|
|
if (NULL == m_hwndSecondWebBrowser)
|
|
{
|
|
SATraceString ("CreateWindow for second IE control failed");
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Get a pointer to the control
|
|
//
|
|
AtlAxGetControl(m_hwndSecondWebBrowser, &m_pSecondWebBrowserUnk);
|
|
|
|
if (m_pSecondWebBrowserUnk == NULL)
|
|
{
|
|
SATraceString ("Getting a pointer to the main control failed");
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// QI for the IWebBrowser2 interface
|
|
//
|
|
hr = m_pSecondWebBrowserUnk->QueryInterface(IID_IWebBrowser2, (void**)&m_pSecondWebBrowser);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("QI for IWebBrowser2 interface failed");
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Create the sink object for the events
|
|
//
|
|
hr = CComObject<CWebBrowserEventSink>::CreateInstance(&m_pSecondWebBrowserEventSink);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("CreateInstance for sink object failed");
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Store the main window pointer for callbacks
|
|
//
|
|
m_pSecondWebBrowserEventSink->m_pMainWindow = this;
|
|
|
|
m_pSecondWebBrowserEventSink->m_bMainControl = FALSE;
|
|
|
|
//
|
|
// Register in the event sink of the main IE control
|
|
//
|
|
hr = AtlAdvise(m_pSecondWebBrowserUnk, m_pSecondWebBrowserEventSink->GetUnknown(), DIID_DWebBrowserEvents2, &m_dwSecondCookie);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("AtlAdvise for second IE control failed");
|
|
return hr;
|
|
}
|
|
|
|
return S_OK;
|
|
|
|
} // end of CMainWindow::CreateSecondIEControl
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: OnCreate
|
|
//
|
|
// Synopsis: Creates the IE controls
|
|
//
|
|
// Arguments: windows message arguments
|
|
//
|
|
// Returns: LRESULT - success(0)/failure(-1)
|
|
//
|
|
// History: serdarun Created 11/10/2000
|
|
//
|
|
//----------------------------------------------------------------
|
|
LRESULT CMainWindow::OnCreate(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
HRESULT hr;
|
|
|
|
SATraceString ("Entering CMainWindow::OnCreate...");
|
|
|
|
//
|
|
// Create main IE control
|
|
//
|
|
hr = CreateMainIEControl();
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("CreateMainIEControl failed");
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// Create the memory DC used for rendering
|
|
//
|
|
m_HdcMem = ::CreateCompatibleDC(NULL);
|
|
|
|
if (NULL == m_HdcMem)
|
|
{
|
|
SATraceFailure (
|
|
"CMainWindow::OnCreate failed on CreateCompatibleDC(NULL):",
|
|
GetLastError ());
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// Create the monochrome bitmap
|
|
//
|
|
m_hBitmap = CreateBitmap(m_lDispWidth, m_lDispHeight,1,1,0);
|
|
|
|
if (NULL == m_HdcMem)
|
|
{
|
|
SATraceFailure (
|
|
"CMainWindow::OnCreate failed on CreateBitmap:",
|
|
GetLastError ());
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// Select bitmap into DC
|
|
//
|
|
SelectObject(m_HdcMem, m_hBitmap);
|
|
|
|
|
|
//
|
|
// Set the timer
|
|
//
|
|
m_unintptrMainTimer = ::SetTimer(m_hWnd,1,250,0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: ShutDown
|
|
//
|
|
// Synopsis: Clean up all the resources
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none(just logs the problem)
|
|
//
|
|
// History: serdarun Created 11/20/2000
|
|
//
|
|
// Called By: CMainWindow::OnDestroy method
|
|
//
|
|
//----------------------------------------------------------------
|
|
void CMainWindow::ShutDown()
|
|
{
|
|
|
|
BOOL bStatus = FALSE;
|
|
HRESULT hr;
|
|
|
|
SATraceString ("Entering CMainWindow::ShutDown method ...");
|
|
|
|
|
|
if (INVALID_HANDLE_VALUE != m_hWorkerThread)
|
|
{
|
|
//
|
|
// cleanup thread handle
|
|
//
|
|
::CloseHandle (m_hWorkerThread);
|
|
m_hWorkerThread = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
//
|
|
// delete Memory DC
|
|
//
|
|
if (m_HdcMem)
|
|
{
|
|
::DeleteDC (m_HdcMem);
|
|
m_HdcMem = NULL;
|
|
}
|
|
|
|
|
|
//
|
|
// release the localization manager
|
|
//
|
|
if (m_pLocInfo)
|
|
{
|
|
m_pLocInfo->Release ();
|
|
m_pLocInfo = NULL;
|
|
}
|
|
|
|
//
|
|
// do the reverse sequence of initialization
|
|
//
|
|
if (m_pLangChange)
|
|
{
|
|
m_pLangChange->ClearCallback ();
|
|
m_pLangChange->Release();
|
|
m_pLangChange= NULL;
|
|
}
|
|
|
|
//
|
|
// Unadvise event sinks for IE controls
|
|
//
|
|
if (m_dwMainCookie != 0)
|
|
AtlUnadvise(m_pMainWebBrowserUnk, DIID_DWebBrowserEvents2, m_dwMainCookie);
|
|
|
|
if (m_dwSecondCookie != 0)
|
|
AtlUnadvise(m_pSecondWebBrowserUnk, DIID_DWebBrowserEvents2, m_dwSecondCookie);
|
|
|
|
if ((m_pWbemServices) && (m_pSAWbemSink))
|
|
{
|
|
//
|
|
// cancel reception of events
|
|
//
|
|
hr = m_pWbemServices->CancelAsyncCall (m_pSAWbemSink);
|
|
if (FAILED (hr))
|
|
{
|
|
SATracePrintf ("CMainWindow::Shutdown failed on-CancelAsyncCall failed with error:%x:",hr);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// release all of the smart pointers
|
|
//
|
|
m_pMainWebBrowser = NULL;
|
|
|
|
m_pMainWebBrowserUnk = NULL;
|
|
|
|
m_pMainWebBrowserEventSink = NULL;
|
|
|
|
m_pMainInPlaceAO = NULL;
|
|
|
|
m_pMainOleObject = NULL;
|
|
|
|
m_pMainViewObject = NULL;
|
|
|
|
m_pSAKeypadController = NULL;
|
|
|
|
m_pSecondWebBrowser = NULL;
|
|
|
|
m_pSecondWebBrowserUnk = NULL;
|
|
|
|
m_pSecondWebBrowserEventSink = NULL;
|
|
|
|
m_pWbemServices = NULL;
|
|
|
|
m_pSAWbemSink = NULL;
|
|
|
|
m_pSaDisplay = NULL;
|
|
|
|
if (m_pSAConsumer)
|
|
{
|
|
m_pSAConsumer->Release();
|
|
m_pSAConsumer= NULL;
|
|
}
|
|
return;
|
|
|
|
} // end of CMainWindow::ShutDown method
|
|
|
|
|
|
LRESULT CMainWindow::OnDestroy(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
{
|
|
HRESULT hr;
|
|
|
|
KillTimer(m_unintptrMainTimer);
|
|
|
|
ShutDown();
|
|
|
|
PostThreadMessage(id, WM_QUIT, 0, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: LoadingNewPage
|
|
//
|
|
// Synopsis: It is called before a new page is loaded by web control
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none(just logs the problem)
|
|
//
|
|
// History: serdarun Created 11/20/2000
|
|
//
|
|
// Called By: CWebBrowserEventSink::Invoke method
|
|
//
|
|
//----------------------------------------------------------------
|
|
void CMainWindow::LoadingNewPage()
|
|
{
|
|
|
|
SATraceString ("Entering CMainWindow::LoadingNewPage method");
|
|
|
|
//
|
|
// Set ready flad to FALSE, we won't print any bitmaps until page is ready
|
|
//
|
|
m_bPageReady = FALSE;
|
|
m_bInTaskorMainPage = FALSE;
|
|
|
|
//
|
|
// Load the default key messages for the new page
|
|
//
|
|
HRESULT hr;
|
|
|
|
if (m_pSAKeypadController)
|
|
{
|
|
hr = m_pSAKeypadController->LoadDefaults();
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("Setting default key messages failed");
|
|
}
|
|
}
|
|
return;
|
|
} // end of CMainWindow::LoadingNewPage method
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: PageLoaded
|
|
//
|
|
// Synopsis: It is called after a new page is loaded by web control
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none(just logs the problem)
|
|
//
|
|
// History: serdarun Created 11/20/2000
|
|
//
|
|
// Called By: CWebBrowserEventSink::Invoke method
|
|
//
|
|
//----------------------------------------------------------------
|
|
void CMainWindow::PageLoaded(IDispatch* pdisp, VARIANT* purl)
|
|
{
|
|
|
|
SATraceString ("Entering CMainWindow::PageLoaded method");
|
|
|
|
BSTR bstrLocation;
|
|
HRESULT hr;
|
|
|
|
if (m_bSecondIECreated == FALSE)
|
|
{
|
|
hr = CreateSecondIEControl();
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("CreateSecondIEControl failed");
|
|
}
|
|
|
|
m_bSecondIECreated = TRUE;
|
|
}
|
|
|
|
if (m_pMainWebBrowser)
|
|
{
|
|
if (SUCCEEDED(m_pMainWebBrowser->get_LocationName(&bstrLocation)))
|
|
{
|
|
if ( ( 0 == _wcsicmp (L"localui_main", bstrLocation ) ) ||
|
|
( 0 == _wcsicmp (L"localui_tasks", bstrLocation ) ) )
|
|
{
|
|
m_bInTaskorMainPage = TRUE;
|
|
}
|
|
else
|
|
{
|
|
m_bInTaskorMainPage = FALSE;
|
|
}
|
|
|
|
SysFreeString(bstrLocation);
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Inplace activate the web control
|
|
//
|
|
if (m_pMainOleObject)
|
|
{
|
|
m_pMainOleObject->DoVerb(OLEIVERB_UIACTIVATE,0,0,0,0,0);
|
|
}
|
|
|
|
//
|
|
// begin printing new bitmaps
|
|
//
|
|
m_bPageReady = TRUE;
|
|
|
|
return;
|
|
} // end of CMainWindow::PageLoaded method
|
|
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: RegistryPageLoaded
|
|
//
|
|
// Synopsis: It is called after a new page is loaded by secondary
|
|
// web control
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none(just logs the problem)
|
|
//
|
|
// History: serdarun Created 11/25/2000
|
|
//
|
|
// Called By: CWebBrowserEventSink::Invoke method
|
|
//
|
|
//----------------------------------------------------------------
|
|
void CMainWindow::RegistryPageLoaded(IDispatch* pdisp, VARIANT* purl)
|
|
{
|
|
|
|
m_unintptrSecondTimer = ::SetTimer(m_hWnd,2,3000,0);
|
|
|
|
}// end of CMainWindow::RegistryPageLoaded method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: PrintRegistryPage
|
|
//
|
|
// Synopsis: It is called after a new page is loaded by secondary
|
|
// web control
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none(just logs the problem)
|
|
//
|
|
// History: serdarun Created 11/25/2000
|
|
//
|
|
// Called By: OnTimer method
|
|
//
|
|
//----------------------------------------------------------------
|
|
void CMainWindow::PrintRegistryPage()
|
|
{
|
|
CComPtr<IViewObject2> pViewObject;
|
|
HRESULT hr;
|
|
BYTE DispBitmap [SA_DISPLAY_MAX_BITMAP_IN_BYTES];
|
|
RECTL rcBounds = { 0, 0, m_lDispWidth, m_lDispHeight };
|
|
BYTE BitMapInfoBuffer[sizeof(BITMAPINFO)+sizeof(RGBQUAD)];
|
|
BITMAPINFO * pBitMapInfo = (BITMAPINFO*)BitMapInfoBuffer;
|
|
BOOL bStatus;
|
|
HKEY hOpenKey = NULL;
|
|
LONG lMessageId;
|
|
|
|
SATraceString ("Entering CMainWindow::PrintRegistryPage method");
|
|
|
|
//
|
|
// Make sure we have a valid pointer to draw
|
|
//
|
|
|
|
if (!m_pSecondWebBrowser)
|
|
{
|
|
SATraceString ("m_pSecondWebBrowser is NULL in CMainWindow::PrintRegistryPage method");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Get the drawing interface pointer
|
|
//
|
|
hr = m_pSecondWebBrowser->QueryInterface(IID_IViewObject2,(void**)&pViewObject);
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("CMainWindow::PrintRegistryPage method failed on QI for IViewObject");
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// Draw on the memory DC
|
|
//
|
|
hr = pViewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, NULL, m_HdcMem, &rcBounds, NULL, NULL, 0);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
|
|
SATraceString ("CMainWindow::PrintRegistryPage failed on Draw method");
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// Initialize the bitmap info structure
|
|
//
|
|
pBitMapInfo->bmiHeader.biSize = sizeof (BitMapInfoBuffer);
|
|
pBitMapInfo->bmiHeader.biBitCount = 0;
|
|
|
|
|
|
|
|
//
|
|
// call to fill up the BITMAPINFO structure
|
|
//
|
|
bStatus = ::GetDIBits (
|
|
m_HdcMem,
|
|
(HBITMAP)m_hBitmap,
|
|
0,
|
|
0,
|
|
NULL,
|
|
pBitMapInfo,
|
|
DIB_RGB_COLORS
|
|
);
|
|
|
|
if (FALSE == bStatus)
|
|
{
|
|
SATraceFailure (
|
|
"CMainWindow::PrintRegistryPage failed on GetDIBits:",
|
|
GetLastError()
|
|
);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
::memset (DispBitmap, 0, SA_DISPLAY_MAX_BITMAP_IN_BYTES);
|
|
|
|
|
|
//
|
|
// get the bitmap into a buffer now
|
|
//
|
|
bStatus = ::GetDIBits (
|
|
m_HdcMem,
|
|
(HBITMAP)m_hBitmap,
|
|
0,
|
|
m_lDispHeight,
|
|
(PVOID)DispBitmap,
|
|
pBitMapInfo,
|
|
DIB_RGB_COLORS
|
|
);
|
|
|
|
|
|
if (FALSE == bStatus)
|
|
{
|
|
SATraceFailure (
|
|
"CMainWindow::PrintRegistryPage failed on GetDIBits:",
|
|
GetLastError()
|
|
);
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < SA_DISPLAY_MAX_BITMAP_IN_BYTES; i++)
|
|
{
|
|
DispBitmap[i] = ~DispBitmap[i];
|
|
}
|
|
|
|
if (m_RegBitmapState == BITMAP_STARTING)
|
|
{
|
|
lMessageId = SA_DISPLAY_STARTING;
|
|
m_RegBitmapState = BITMAP_CHECKDISK;
|
|
}
|
|
else if (m_RegBitmapState == BITMAP_CHECKDISK)
|
|
{
|
|
lMessageId = SA_DISPLAY_CHECK_DISK;
|
|
m_RegBitmapState = BITMAP_READY;
|
|
}
|
|
else if (m_RegBitmapState == BITMAP_READY)
|
|
{
|
|
lMessageId = SA_DISPLAY_READY;
|
|
m_RegBitmapState = BITMAP_SHUTDOWN;
|
|
}
|
|
else if (m_RegBitmapState == BITMAP_SHUTDOWN)
|
|
{
|
|
lMessageId = SA_DISPLAY_SHUTTING_DOWN;
|
|
m_RegBitmapState = BITMAP_UPDATE;
|
|
}
|
|
else if (m_RegBitmapState == BITMAP_UPDATE)
|
|
{
|
|
lMessageId = SA_DISPLAY_ADD_START_TASKS;
|
|
m_RegBitmapState = BITMAP_STARTING;
|
|
}
|
|
|
|
//
|
|
// call display helper to store the bitmap in the registry
|
|
//
|
|
hr = m_pSaDisplay->StoreBitmap(
|
|
lMessageId,
|
|
m_lDispWidth,
|
|
m_lDispHeight,
|
|
DispBitmap
|
|
);
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf (
|
|
"CMainWindow::PrintRegistryPage failed on StoreBitmap %x",
|
|
hr
|
|
);
|
|
}
|
|
|
|
CComBSTR bstrStatePage;
|
|
bstrStatePage = m_szLocalUIDir.c_str();
|
|
|
|
|
|
//
|
|
// append "ShutDown" to URL
|
|
//
|
|
if (m_RegBitmapState == BITMAP_SHUTDOWN)
|
|
{
|
|
bstrStatePage.Append(szLocalUI_ShutdownPage);
|
|
}
|
|
else if (m_RegBitmapState == BITMAP_CHECKDISK)
|
|
{
|
|
bstrStatePage.Append(szLocalUI_UpdatePage);
|
|
}
|
|
else if (m_RegBitmapState == BITMAP_UPDATE)
|
|
{
|
|
bstrStatePage.Append(szLocalUI_UpdatePage);
|
|
}
|
|
else if (m_RegBitmapState == BITMAP_READY)
|
|
{
|
|
bstrStatePage.Append(szLocalUI_ReadyPage);
|
|
}
|
|
|
|
//
|
|
// go to the next page if sequence is not completed
|
|
//
|
|
if (m_RegBitmapState != BITMAP_STARTING)
|
|
{
|
|
m_pSecondWebBrowser->Navigate(bstrStatePage.Detach(),0,0,0,0);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// tell the driver to pick up the new bitmaps
|
|
//
|
|
hr = m_pSaDisplay->ReloadRegistryBitmaps();
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf (
|
|
"CMainWindow::PrintRegistryPage failed on ReloadRegistryBitmaps %x",
|
|
hr
|
|
);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
return;
|
|
} // end of CMainWindow::PrintRegistryPage method
|
|
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: ConstructUrlStrings
|
|
//
|
|
// Synopsis: creates full path for main page
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none(just logs the problem)
|
|
//
|
|
// History: serdarun Created 02/06/2001
|
|
//
|
|
// Called By: CMainWindow::Initialize method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT CMainWindow::ConstructUrlStrings()
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
|
|
WCHAR szSystemDir[MAX_PATH];
|
|
|
|
//
|
|
// Get system32 directory
|
|
//
|
|
if (GetSystemDirectory(szSystemDir,MAX_PATH) == 0)
|
|
{
|
|
SATraceFailure (
|
|
"CMainWindow::ConstructUrlStrings, failed on GetSystemDirectory",
|
|
GetLastError()
|
|
);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// localui dir = system directory + "ServerAppliance\localui"
|
|
//
|
|
m_szLocalUIDir.assign(szSystemDir);
|
|
m_szLocalUIDir.append(szLocalUIDir);
|
|
|
|
//
|
|
// construct local ui main page
|
|
//
|
|
m_szMainPage.assign(m_szLocalUIDir);
|
|
m_szMainPage.append(szMainPage);
|
|
|
|
|
|
SATracePrintf ("ConstructUrlStrings Main Page:%ws",m_szMainPage.c_str());
|
|
SATracePrintf ("ConstructUrlStrings LocalUI directory:%ws",m_szLocalUIDir.c_str());
|
|
|
|
return hr;
|
|
}
|
|
// end of CMainWindow::ConstructUrlStrings method
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: CorrectTheFocus
|
|
//
|
|
// Synopsis: Sets focus to the first active element in the page
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none(just logs the problem)
|
|
//
|
|
// History: serdarun Created 11/20/2000
|
|
//
|
|
// Called By: CMainWindow::CorrectTheFocus method
|
|
//
|
|
//----------------------------------------------------------------
|
|
void CMainWindow::CorrectTheFocus()
|
|
{
|
|
|
|
CComPtr<IDispatch> pDisp;
|
|
CComPtr<IHTMLDocument2> pHTMLDocument;
|
|
CComPtr<IHTMLElement> pHTMLElement;
|
|
CComBSTR bstrTagName;
|
|
HRESULT hr;
|
|
|
|
USES_CONVERSION;
|
|
|
|
//
|
|
// If browser pointer is not valid, return
|
|
//
|
|
if (m_pMainWebBrowser == NULL)
|
|
return;
|
|
|
|
//
|
|
// Get the current document from browser
|
|
//
|
|
hr = m_pMainWebBrowser->get_Document(&pDisp);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("CMainWindow::CorrectTheFocus failed on get_Document");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Get the document interface
|
|
//
|
|
hr = pDisp->QueryInterface(IID_IHTMLDocument2,(void**)&pHTMLDocument);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("CMainWindow::CorrectTheFocus failed on QueryInterface for IHTMLDocument");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Get the active element
|
|
//
|
|
if ( FAILED( pHTMLDocument->get_activeElement(&pHTMLElement) ) )
|
|
{
|
|
SATraceString ("CMainWindow::CorrectTheFocus failed on get_activeElement");
|
|
return;
|
|
}
|
|
//
|
|
// There is no active element, send a tab message
|
|
//
|
|
else if (pHTMLElement == NULL)
|
|
{
|
|
PostThreadMessage(GetCurrentThreadId(),WM_KEYDOWN,(WPARAM)VK_TAB,(LPARAM)1);
|
|
}
|
|
//
|
|
// If body is the active element, also send a tab message
|
|
// We want something else to have the focus
|
|
//
|
|
else
|
|
{
|
|
hr = pHTMLElement->get_tagName(&bstrTagName);
|
|
m_bActiveXFocus = FALSE;
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("CMainWindow::CorrectTheFocus failed on get_tagName");
|
|
return;
|
|
}
|
|
//
|
|
// Check if the tag is body
|
|
//
|
|
//else if (_wcsicmp(W2T(bstrTagName),_T("body")) == 0)
|
|
// PostThreadMessage(GetCurrentThreadId(),WM_KEYDOWN,(WPARAM)VK_TAB,(LPARAM)1);
|
|
else if (_wcsicmp(W2T(bstrTagName),_T("object")) == 0)
|
|
m_bActiveXFocus = TRUE;
|
|
}
|
|
|
|
} // end of CMainWindow::CorrectTheFocus
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: GetBitmap
|
|
//
|
|
// Synopsis: Gets the bitmap from IE control and writes to LCD
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none(just logs the problem)
|
|
//
|
|
// History: serdarun Created 11/20/2000
|
|
//
|
|
// Called By: CMainWindow::OnTimer method
|
|
//
|
|
//----------------------------------------------------------------
|
|
void CMainWindow::GetBitmap()
|
|
{
|
|
|
|
HRESULT hr;
|
|
RECTL rcBounds = { 0, 0, m_lDispWidth, m_lDispHeight };
|
|
BOOL bStatus;
|
|
BYTE DisplayBitmap[SA_DISPLAY_MAX_BITMAP_IN_BYTES];
|
|
BYTE BitMapInfoBuffer[sizeof(BITMAPINFO)+sizeof(RGBQUAD)];
|
|
|
|
::memset ((PVOID)BitMapInfoBuffer, 0, sizeof(BitMapInfoBuffer));
|
|
|
|
BITMAPINFO * pBitMapInfo = (BITMAPINFO*)BitMapInfoBuffer;
|
|
|
|
//SATraceString ("Entering CMainWindow::GetBitmap method");
|
|
|
|
|
|
//
|
|
// Make sure there is an active element
|
|
//
|
|
CorrectTheFocus();
|
|
|
|
//
|
|
// If IViewObject2 interface is NULL, we cannot get the bitmap
|
|
//
|
|
if (m_pMainViewObject == NULL)
|
|
return;
|
|
|
|
//
|
|
// Draw on the memory DC
|
|
//
|
|
hr = m_pMainViewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, NULL, m_HdcMem, &rcBounds, NULL, NULL, 0);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
|
|
SATraceString ("CMainWindow::GetBitmap failed on Draw method");
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// Initialize the bitmap info structure
|
|
//
|
|
pBitMapInfo->bmiHeader.biSize = sizeof(BitMapInfoBuffer);
|
|
pBitMapInfo->bmiHeader.biBitCount = 0;
|
|
|
|
//
|
|
// Initialize the display buffer
|
|
//
|
|
::memset ((PVOID)DisplayBitmap, 0, SA_DISPLAY_MAX_BITMAP_IN_BYTES);
|
|
|
|
|
|
//
|
|
// call to fill up the BITMAPINFO structure
|
|
//
|
|
bStatus = ::GetDIBits (
|
|
m_HdcMem,
|
|
(HBITMAP)m_hBitmap,
|
|
0,
|
|
0,
|
|
NULL,
|
|
pBitMapInfo,
|
|
DIB_RGB_COLORS
|
|
);
|
|
|
|
if (FALSE == bStatus)
|
|
{
|
|
SATraceFailure (
|
|
"CMainWindow::GetBitmap failed on GetDIBits:",
|
|
GetLastError()
|
|
);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// get the bitmap into a buffer now
|
|
//
|
|
bStatus = ::GetDIBits (
|
|
m_HdcMem,
|
|
(HBITMAP)m_hBitmap,
|
|
0,
|
|
m_lDispHeight,
|
|
(PVOID)(DisplayBitmap),
|
|
pBitMapInfo,
|
|
DIB_RGB_COLORS
|
|
);
|
|
|
|
if (FALSE == bStatus)
|
|
{
|
|
SATraceFailure (
|
|
"CMainWindow::GetBitmap failed on GetDIBits:",
|
|
GetLastError()
|
|
);
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < SA_DISPLAY_MAX_BITMAP_IN_BYTES; i++)
|
|
{
|
|
DisplayBitmap[i] = ~DisplayBitmap[i];
|
|
}
|
|
|
|
|
|
hr = m_pSaDisplay->ShowMessage(
|
|
m_dwLEDMessageCode,
|
|
m_lDispWidth,
|
|
m_lDispHeight,
|
|
(DisplayBitmap)
|
|
);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf (
|
|
"CMainWindow::GetBitmap failed on ShowMessage: %x",
|
|
hr
|
|
);
|
|
}
|
|
|
|
return;
|
|
} // end of CMainWindow::GetBitmap
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: Initialize
|
|
//
|
|
// Synopsis: This is method for initializing the drivers and
|
|
// creating the main window for the service
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: HRESULT - success/failure
|
|
//
|
|
// History: serdarun Created 11/20/2000
|
|
//
|
|
// Called By; Run method of the service
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT CMainWindow::Initialize()
|
|
{
|
|
|
|
SATraceString ("Entering CMainWindow::Initialize method");
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!AtlAxWinInit())
|
|
{
|
|
SATraceString ("CMainWindow::Initialize, AtlAxWinInit failed...");
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
//
|
|
// Construct the URL strings
|
|
//
|
|
ConstructUrlStrings();
|
|
|
|
//
|
|
//Create the keypad component
|
|
//
|
|
|
|
CComPtr<IClassFactory> pCF;
|
|
|
|
hr = CoGetClassObject(CLSID_SAKeypadController,CLSCTX_INPROC_SERVER,0,IID_IClassFactory,(void**)&pCF);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf ("Initialize couldn't get class object for keypad controller:%x",hr);
|
|
return hr;
|
|
}
|
|
|
|
hr = pCF->CreateInstance(NULL,IID_ISAKeypadController,(void**)&m_pSAKeypadController);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf ("Initialize couldn't create keypad controller:%x",hr);
|
|
return hr;
|
|
}
|
|
else
|
|
{
|
|
m_pSAKeypadController->LoadDefaults();
|
|
}
|
|
|
|
|
|
//
|
|
// initialize connection to display helper component
|
|
//
|
|
hr = InitDisplayComponent();
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
//
|
|
// initialize consumer component
|
|
//
|
|
hr = InitWMIConsumer();
|
|
if (FAILED(hr))
|
|
{
|
|
|
|
SATraceString ("CMainWindow::Initialize method failed on initializing WMI consumer");
|
|
//we can continue without consumer
|
|
//return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
RECT rcMain = { 0, 0, m_lDispWidth+8, 2*m_lDispHeight+27 };
|
|
|
|
HWND hwnd = Create(
|
|
NULL, //parent window
|
|
rcMain, //coordinates
|
|
L"Main Window",
|
|
WS_OVERLAPPEDWINDOW);
|
|
|
|
if (NULL == hwnd)
|
|
{
|
|
SATraceString ("CMainWindow::Initialize method failed creating the main window");
|
|
ShutDown();
|
|
return E_FAIL;
|
|
|
|
}
|
|
|
|
//
|
|
// set the service window
|
|
//
|
|
m_pSAConsumer->SetServiceWindow(hwnd);
|
|
|
|
//
|
|
// following operations all depend on keypad driver
|
|
//
|
|
if (TRUE)
|
|
{
|
|
//
|
|
// initialize connection to localization manager
|
|
//
|
|
hr = InitLanguageCallback();
|
|
if (FAILED(hr))
|
|
{
|
|
//
|
|
// we can continue without loc manager
|
|
//
|
|
SATraceString ("CMainWindow::Initialize failed on InitLanguageCallback method..");
|
|
|
|
//return hr;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// spawn the worker thread now
|
|
//
|
|
DWORD dwThreadID = 0;
|
|
|
|
m_hWorkerThread = ::CreateThread (
|
|
NULL, //security
|
|
0, //stack size
|
|
startworkerroutine,
|
|
(PVOID)this,
|
|
0, //init flag
|
|
&dwThreadID
|
|
);
|
|
|
|
|
|
if (INVALID_HANDLE_VALUE == m_hWorkerThread)
|
|
{
|
|
SATraceFailure (
|
|
"CMainWindow::Initialize failed on CreateThread:",
|
|
GetLastError ()
|
|
);
|
|
// we can continue without the reader thread
|
|
}
|
|
}
|
|
|
|
SATraceString ("CMainWindow::Initialize completed successfully...");
|
|
|
|
hr = S_OK;
|
|
|
|
return hr;
|
|
|
|
} // end of CMainWindow::Initialize method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: InitLanguageCallback
|
|
//
|
|
// Synopsis: This is CMainWindow private method for
|
|
// initializing the localization manager the
|
|
// callback function from CLangChange class
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: HRESULT - success/failure
|
|
//
|
|
// History: serdarun Created 11/21/2000
|
|
//
|
|
// Called By: CMainWindow::InitLanguageCallback method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT
|
|
CMainWindow::InitLanguageCallback(
|
|
VOID
|
|
)
|
|
{
|
|
|
|
SATraceString("Entering CMainWindow::InitLanguageCallback....");
|
|
|
|
CLSID clsidLocMgr;
|
|
HRESULT hr;
|
|
IUnknown *pLangChangeUnk = NULL;
|
|
|
|
//
|
|
// initialize the localization manager
|
|
//
|
|
hr = ::CLSIDFromProgID (LOCALIZATION_MANAGER,&clsidLocMgr);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf ("Display Adapter unable to get CLSID for Loc Mgr:%x",hr);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// create the Localization Manager COM object
|
|
//
|
|
hr = ::CoCreateInstance (
|
|
clsidLocMgr,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
__uuidof (ISALocInfo),
|
|
(PVOID*) &m_pLocInfo
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
SATracePrintf ("Display Adapter unable to create Loc Mgr:%x",hr);
|
|
m_pLocInfo = NULL;
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// create object that supports ILangChange interface
|
|
//
|
|
m_pLangChange = new CLangChange;
|
|
|
|
m_pLangChange->AddRef();
|
|
|
|
if (m_pLangChange)
|
|
{
|
|
//
|
|
// Get the IUnkown pointer from m_pLangChange
|
|
//
|
|
hr = m_pLangChange->QueryInterface(IID_IUnknown, (void **)&pLangChangeUnk);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf("Query(IUnknown) failed %X",hr);
|
|
|
|
delete m_pLangChange;
|
|
|
|
m_pLangChange = NULL;
|
|
|
|
return hr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SATraceString("new CLangChange failed");
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
//
|
|
// Set Language change call back interface
|
|
//
|
|
hr = m_pLocInfo->SetLangChangeCallBack(pLangChangeUnk);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
//
|
|
// for now, ignore if can't set lang change
|
|
// call back
|
|
//
|
|
SATracePrintf("SetLangChangeCallBack failed %X",hr);
|
|
|
|
pLangChangeUnk->Release();
|
|
|
|
pLangChangeUnk = NULL;
|
|
|
|
return hr;
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
m_pLangChange->OnLangChangeCallback (m_hWnd);
|
|
|
|
pLangChangeUnk->Release();
|
|
|
|
pLangChangeUnk = NULL;
|
|
}
|
|
|
|
|
|
return S_OK;
|
|
|
|
} // end of CMainWindow::InitLanguageCallback method
|
|
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: KeypadReader
|
|
//
|
|
// Synopsis: This is CMainWindow private method in which
|
|
// the worker thread executes
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: VOID
|
|
//
|
|
// History: serdarun Created 11/22/2000
|
|
//
|
|
//----------------------------------------------------------------
|
|
void CMainWindow::KeypadReader()
|
|
{
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
CoInitialize(NULL);
|
|
|
|
SAKEY sakey;
|
|
|
|
CComPtr<ISaKeypad> pSaKeypad;
|
|
|
|
|
|
SATraceString("CMainWindow::KeypadReader....");
|
|
|
|
//
|
|
// create the display helper component
|
|
//
|
|
hr = CoCreateInstance(
|
|
CLSID_SaKeypad,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_ISaKeypad,
|
|
(void**)&pSaKeypad
|
|
);
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf("CMainWindow::KeypadReader failed on CoCreateInstance, %d",hr);
|
|
return;
|
|
}
|
|
|
|
hr = pSaKeypad->get_Key(&sakey);
|
|
while (SUCCEEDED(hr))
|
|
{
|
|
SATracePrintf("KeypadReader received a key press, %d",sakey);
|
|
|
|
if ( (sakey >= SAKEY_UP) && (sakey <= SAKEY_RETURN))
|
|
{
|
|
PostMessage(wm_SaKeyMessage,(WPARAM)(sakey-1),(LPARAM)0);
|
|
}
|
|
else
|
|
{
|
|
SATracePrintf("CMainWindow::KeypadReader received unknown key, %d",sakey);
|
|
}
|
|
|
|
hr = pSaKeypad->get_Key(&sakey);
|
|
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf("CMainWindow::KeypadReader failed on get_Key, %d",hr);
|
|
}
|
|
return;
|
|
|
|
|
|
|
|
SATraceFunction("Leaving CMainWindow::KeypadReader....");
|
|
return;
|
|
} // end of CMainWindow::KeypadReader
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: InitDisplayComponent
|
|
//
|
|
// Synopsis: This is CMainWindow private method for
|
|
// initializing the local display adapter
|
|
// connection to the display driver
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: HRESULT - success/failure
|
|
//
|
|
// History: serdarun Created 11/21/2000
|
|
//
|
|
// Called By: CMainWindow::Initialize method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT
|
|
CMainWindow::InitDisplayComponent(
|
|
VOID
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
SATraceString("CMainWindow::InitDisplayComponent....");
|
|
do
|
|
{
|
|
|
|
//
|
|
// create the display helper component
|
|
//
|
|
hr = CoCreateInstance(
|
|
CLSID_SaDisplay,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_ISaDisplay,
|
|
(void**)&m_pSaDisplay
|
|
);
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf("CMainWindow::InitDisplayComponent failed on CoCreateInstance, %d",hr);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// get the dimensions for the lcd
|
|
//
|
|
hr = m_pSaDisplay->get_DisplayWidth(&m_lDispWidth);
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf("CMainWindow::InitDisplayComponent failed on get_DisplayWidth, %d",hr);
|
|
break;
|
|
}
|
|
|
|
hr = m_pSaDisplay->get_DisplayHeight(&m_lDispHeight);
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf("CMainWindow::InitDisplayComponent failed on get_DisplayHeight, %d",hr);
|
|
break;
|
|
}
|
|
|
|
}
|
|
while (false);
|
|
|
|
return (S_OK);
|
|
|
|
} // end of CMainWindow::InitDisplayComponent method
|
|
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: InitWMIConsumer
|
|
//
|
|
// Synopsis: This is CMainWindow private method for
|
|
// registering the alert consumer
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: HRESULT - success/failure
|
|
//
|
|
//
|
|
// History: serdarun Created 12/10/2000
|
|
//
|
|
// Called By: CMainWindow::Initialize method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT CMainWindow::InitWMIConsumer()
|
|
{
|
|
|
|
SATraceString("CMainWindow::InitWMIConsumer....");
|
|
|
|
HRESULT hr = S_OK;
|
|
CComPtr <IWbemLocator> pWbemLocator;
|
|
|
|
|
|
m_pSAConsumer = new CSAConsumer();
|
|
|
|
if (!m_pSAConsumer)
|
|
{
|
|
SATraceString("CMainWindow::InitWMIConsumer failed on memory allocation");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
m_pSAConsumer->AddRef();
|
|
|
|
//
|
|
// get IWbemObjectSink interface
|
|
//
|
|
hr = m_pSAConsumer->QueryInterface(IID_IWbemObjectSink,(LPVOID*)&m_pSAWbemSink);
|
|
if (FAILED(hr))
|
|
{
|
|
SATracePrintf ("InitWMIConsumer couldn't get IWbemObjectSink interface:%x",hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// create the WBEM locator object
|
|
//
|
|
hr = ::CoCreateInstance (
|
|
__uuidof (WbemLocator),
|
|
0, //aggregation pointer
|
|
CLSCTX_INPROC_SERVER,
|
|
__uuidof (IWbemLocator),
|
|
(PVOID*) &pWbemLocator
|
|
);
|
|
|
|
if (SUCCEEDED (hr) && (pWbemLocator.p))
|
|
{
|
|
|
|
|
|
CComBSTR strNetworkRes (DEFAULT_NAMESPACE);
|
|
|
|
//
|
|
// connect to WMI
|
|
//
|
|
hr = pWbemLocator->ConnectServer (
|
|
strNetworkRes,
|
|
NULL, //user-name
|
|
NULL, //password
|
|
NULL, //current-locale
|
|
0, //reserved
|
|
NULL, //authority
|
|
NULL, //context
|
|
&m_pWbemServices
|
|
);
|
|
if (SUCCEEDED (hr))
|
|
{
|
|
CComBSTR strQueryLang (QUERY_LANGUAGE);
|
|
CComBSTR strQueryString (QUERY_STRING);
|
|
|
|
//
|
|
// set up the consumer object as the event sync
|
|
// for the object type we are interested in
|
|
//
|
|
hr = m_pWbemServices->ExecNotificationQueryAsync (
|
|
strQueryLang,
|
|
strQueryString,
|
|
0, //no-status
|
|
NULL, //status
|
|
(IWbemObjectSink*)(m_pSAWbemSink)
|
|
);
|
|
if (SUCCEEDED (hr))
|
|
{
|
|
SATraceString ("Consumer component successfully registered...");
|
|
return hr;
|
|
}
|
|
|
|
SATracePrintf ("Consumer component didn't register sink with WMI:%x",hr);
|
|
|
|
}
|
|
else
|
|
{
|
|
SATracePrintf ("Consumer component failed in connect to WMI:%x",hr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SATracePrintf ("Consumer component failed on Creating the WBEM Locator:%x",hr);
|
|
}
|
|
|
|
|
|
return (hr);
|
|
|
|
} // end of CMainWindow::InitWMIConsumer method
|