// // arcdlg.cpp: Autoreconnect dialog box // modeless dialog box for autoreconnection status // // Copyright Microsoft Corportation 2001 // (nadima) // #include "adcg.h" #define TRC_GROUP TRC_GROUP_UI #define TRC_FILE "arcdlg.cpp" #include #include "arcdlg.h" #include "axresrc.h" #define TRANSPARENT_MASK_COLOR RGB(105, 139, 228) #ifdef OS_WINCE #define RGB_TOPBAND RGB(0, 52, 156) #define RGB_MIDBAND RGB(49,101,206) #endif // // Runtime debug flags instrumentation for 611316 // #define ARCDLG_DEBUG_DESTROYCALLED 0x0001 #define ARCDLG_DEBUG_WMDESTROYCALLED 0x0002 #define ARCDLG_DEBUG_WMDESTROYSUCCEED 0x0004 #define ARCDLG_DEBUG_SETNULLINSTPTR 0x0008 DWORD g_dwArcDlgDebug = 0; #define ARC_DBG_SETINFO(x) g_dwArcDlgDebug |= x; LPTSTR FormatMessageVArgs(LPCTSTR pcszFormat, ...) { LPTSTR pszOutput; va_list argList; va_start(argList, pcszFormat); if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING, pcszFormat, 0, 0, reinterpret_cast(&pszOutput), 0, &argList) == 0) { pszOutput = NULL; } va_end(argList); return(pszOutput); } /////////////////////////////////////////////////////////////////////////////// // // ARC UI base class // CAutoReconnectUI::CAutoReconnectUI( HWND hwndOwner, HINSTANCE hInst, CUI* pUi) : _hwndOwner(hwndOwner), _hInstance(hInst), _hwnd(NULL), _pUi(pUi) { DC_BEGIN_FN("CAutoReconnectUI"); #ifndef OS_WINCE _hGDI = LoadLibrary(_T("gdi32.dll")); if (_hGDI) { _pfnSetLayout = (PFNGDI_SETLAYOUT)GetProcAddress(_hGDI, "SetLayout"); if (!_pfnSetLayout) { TRC_ERR((TB,_T("GetProcAddress 'SetLayout' failed: 0x%x"), GetLastError())); } } #else _hGDI = NULL; _pfnSetLayout = NULL; #endif DC_END_FN(); } CAutoReconnectUI::~CAutoReconnectUI() { DC_BEGIN_FN("CAutoReconnectUI"); #ifndef OS_WINCE if (_hGDI) { _pfnSetLayout = NULL; FreeLibrary(_hGDI); _hGDI = NULL; } #endif DC_END_FN(); } // // PaintBitmap // // Params: hdcDestination = HDC to paint into. // prcDestination = RECT in HDC to paint into. // hbmSource = HBITMAP to paint. // prcSource = RECT from HBITMAP to paint from. // // Returns: // // Purpose: Wraps blitting a bitmap. // // Modified from version in shell code // VOID CAutoReconnectUI::PaintBitmap( HDC hdcDestination, const RECT* prcDestination, HBITMAP hbmSource, const RECT *prcSource ) { HDC hdcBitmap; DC_BEGIN_FN("PaintBitmap"); hdcBitmap = CreateCompatibleDC(NULL); if (hdcBitmap != NULL) { BOOL fEqualWidthAndHeight; INT iWidthSource, iHeightSource; INT iWidthDestination, iHeightDestination; INT iStretchBltMode; #ifndef OS_WINCE DWORD dwLayout; #endif HBITMAP hbmSelected; RECT rcSource; BITMAP bitmap; if (prcSource == NULL) { if (GetObject(hbmSource, sizeof(bitmap), &bitmap) == 0) { bitmap.bmWidth = prcDestination->right - prcDestination->left; bitmap.bmHeight = prcDestination->bottom - prcDestination->top; } SetRect(&rcSource, 0, 0, bitmap.bmWidth, bitmap.bmHeight); prcSource = &rcSource; } hbmSelected = static_cast(SelectObject(hdcBitmap, hbmSource)); iWidthSource = prcSource->right - prcSource->left; iHeightSource = prcSource->bottom - prcSource->top; iWidthDestination = prcDestination->right - prcDestination->left; iHeightDestination = prcDestination->bottom - prcDestination->top; fEqualWidthAndHeight = (iWidthSource == iWidthDestination) && (iHeightSource == iHeightDestination); if (!fEqualWidthAndHeight) { #ifndef OS_WINCE iStretchBltMode = SetStretchBltMode(hdcDestination, HALFTONE); #endif } else { iStretchBltMode = 0; } #ifndef OS_WINCE if (_pfnSetLayout) { dwLayout = _pfnSetLayout(hdcDestination, LAYOUT_BITMAPORIENTATIONPRESERVED); } #endif if (!StretchBlt(hdcDestination, prcDestination->left, prcDestination->top, iWidthDestination, iHeightDestination, hdcBitmap, prcSource->left, prcSource->top, iWidthSource, iHeightSource, SRCCOPY)) { TRC_ERR((TB,_T("Blt failed"))); } #ifndef OS_WINCE if (_pfnSetLayout) { _pfnSetLayout(hdcDestination, dwLayout); } if (!fEqualWidthAndHeight) { (int)SetStretchBltMode(hdcDestination, iStretchBltMode); } #endif (HGDIOBJ)SelectObject(hdcBitmap, hbmSelected); DeleteDC(hdcBitmap); } DC_END_FN(); } VOID CAutoReconnectUI::CenterWindow( HWND hwndCenterOn, INT xRatio, INT yRatio ) { RECT childRect; RECT parentRect; DCINT xPos; DCINT yPos; LONG desktopX = GetSystemMetrics(SM_CXSCREEN); LONG desktopY = GetSystemMetrics(SM_CYSCREEN); BOOL center = TRUE; DC_BEGIN_FN("CenterWindowOnParent"); TRC_ASSERT(_hwnd, (TB, _T("_hwnd is NULL...was it set in WM_INITDIALOG?\n"))); if (!_hwnd) { TRC_ALT((TB, _T("Window doesn't exist"))); DC_QUIT; } if (!xRatio) { xRatio = 2; } if (!yRatio) { yRatio = 2; } GetClientRect(hwndCenterOn, &parentRect); GetWindowRect(_hwnd, &childRect); // // Calculate the top left - centered in the parent window. // xPos = ( (parentRect.right + parentRect.left) - (childRect.right - childRect.left)) / xRatio; yPos = ( (parentRect.bottom + parentRect.top) - (childRect.bottom - childRect.top)) / yRatio; // // Constrain to the desktop // if (xPos < 0) { xPos = 0; } else if (xPos > (desktopX - (childRect.right - childRect.left))) { xPos = desktopX - (childRect.right - childRect.left); } if (yPos < 0) { yPos = 0; } else if (yPos > (desktopY - (childRect.bottom - childRect.top))) { yPos = desktopY - (childRect.bottom - childRect.top); } TRC_DBG((TB, _T("Set dialog position to %u %u"), xPos, yPos)); SetWindowPos(_hwnd, NULL, xPos, yPos, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE); DC_EXIT_POINT: DC_END_FN(); return; } // CenterWindowOnParent #ifndef ARC_MINIMAL_UI /////////////////////////////////////////////////////////////////////////////// // // ARC UI - Rich UI - dialog with status text and progress band // CAutoReconnectDlg::CAutoReconnectDlg(HWND hwndOwner, HINSTANCE hInst, CUI* pUi) : CAutoReconnectUI(hwndOwner, hInst, pUi), _fInitialized(FALSE), _hfntTitle(NULL), _pProgBand(NULL), _hPalette(NULL) { #ifndef OS_WINCE BOOL fUse8BitDepth = FALSE; #else BOOL fUse8BitDepth = TRUE; #endif LOGFONT logFont; #ifndef OS_WINCE HDC hdcScreen; char szPixelSize[10]; #else WCHAR szPixelSize[10]; #endif BITMAP bitmap; INT logPixelsY = 100; DC_BEGIN_FN("CAutoReconnectDlg"); _nArcTimerID = 0; _elapsedArcTime = 0; _fContinueReconAttempts = TRUE; #ifndef OS_WINCE // // Get color depth // hdcScreen = GetDC(NULL); if (hdcScreen) { fUse8BitDepth = (GetDeviceCaps(hdcScreen, BITSPIXEL) <= 8); logPixelsY = GetDeviceCaps(hdcScreen, LOGPIXELSY); ReleaseDC(NULL, hdcScreen); hdcScreen = NULL; } #endif // // Load bitmaps // _hbmBackground = (HBITMAP)LoadImage( _hInstance, MAKEINTRESOURCE(fUse8BitDepth ? IDB_ARC_BACKGROUND8 :IDB_ARC_BACKGROUND24), IMAGE_BITMAP, 0, 0, #ifndef OS_WINCE LR_CREATEDIBSECTION); #else 0); #endif if ((_hbmBackground != NULL) && (GetObject(_hbmBackground, sizeof(bitmap), &bitmap) >= sizeof(bitmap))) { SetRect(&_rcBackground, 0, 0, bitmap.bmWidth, bitmap.bmHeight); } _hbmFlag = (HBITMAP)LoadImage( _hInstance, MAKEINTRESOURCE(fUse8BitDepth ? IDB_ARC_WINFLAG8 :IDB_ARC_WINFLAG24), IMAGE_BITMAP, 0, 0, #ifndef OS_WINCE LR_CREATEDIBSECTION); #else 0); #endif if ((_hbmFlag != NULL) && (GetObject(_hbmFlag, sizeof(bitmap), &bitmap) >= sizeof(bitmap))) { SetRect(&_rcFlag, 0, 0, bitmap.bmWidth, bitmap.bmHeight); } #ifndef OS_WINCE _hbmDisconImg = (HBITMAP)LoadImage( _hInstance, MAKEINTRESOURCE(fUse8BitDepth ? IDB_ARC_DISCON8 :IDB_ARC_DISCON24), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION); if ((_hbmDisconImg != NULL) && (GetObject(_hbmDisconImg, sizeof(bitmap), &bitmap) >= sizeof(bitmap))) { SetRect(&_rcDisconImg, 0, 0, bitmap.bmWidth, bitmap.bmHeight); } _hPalette = CUT::UT_GetPaletteForBitmap(NULL, _hbmBackground); #endif // // Create fonts. Load the font name and size from resources. // ZeroMemory(&logFont, sizeof(logFont)); #ifndef OS_WINCE if (LoadStringA(_hInstance, IDS_ARC_TITLE_FACESIZE, szPixelSize, sizeof(szPixelSize)) != 0) #else if (LoadString(_hInstance, IDS_ARC_TITLE_FACESIZE, szPixelSize, sizeof(szPixelSize)/sizeof(WCHAR)) != 0) #endif { #ifndef OS_WINCE logFont.lfHeight = -MulDiv(atoi(szPixelSize), logPixelsY, 72); #else logFont.lfHeight = -(_wtoi(szPixelSize)/logPixelsY*72); #endif if (LoadString(_hInstance, IDS_ARC_TITLE_FACENAME, logFont.lfFaceName, LF_FACESIZE) != 0) { logFont.lfWeight = FW_BOLD; logFont.lfQuality = DEFAULT_QUALITY; _hfntTitle = CreateFontIndirect(&logFont); } } _szConnectAttemptStringTmpl[0] = NULL; if (!LoadString(_hInstance, IDS_ARC_CONATTEMPTS, _szConnectAttemptStringTmpl, sizeof(_szConnectAttemptStringTmpl)/sizeof(TCHAR)) != 0) { TRC_ERR((TB,_T("Failed to load IDS_ARC_CONATTEMPTS"))); } _lastDiscReason = NL_DISCONNECT_LOCAL; #ifdef OS_WINCE _hbrTopBand = CreateSolidBrush(RGB_TOPBAND); _hbrMidBand = CreateSolidBrush(RGB_MIDBAND); #endif _fInitialized = (_hbmBackground && _hbmFlag && _hfntTitle && _pUi && _szConnectAttemptStringTmpl[0]); if (!_fInitialized) { TRC_ERR((TB,_T("Failed to properly init arc dlg"))); } DC_END_FN(); } CAutoReconnectDlg::~CAutoReconnectDlg() { if (_hbmBackground) { DeleteObject(_hbmBackground); _hbmBackground = NULL; } if (_hbmFlag) { DeleteObject(_hbmFlag); _hbmFlag = NULL; } #ifndef OS_WINCE if (_hbmDisconImg) { DeleteObject(_hbmDisconImg); _hbmDisconImg = NULL; } #endif if (_hfntTitle) { DeleteObject(_hfntTitle); _hfntTitle = NULL; } if (_hPalette) { DeleteObject(_hPalette); _hPalette = NULL; } if (_pProgBand) { delete _pProgBand; _pProgBand = NULL; } #ifdef OS_WINCE if (_hbrTopBand) { DeleteObject(_hbrTopBand); _hbrTopBand = NULL; } if (_hbrMidBand) { DeleteObject(_hbrMidBand); _hbrMidBand = NULL; } #endif } HWND CAutoReconnectDlg::StartModeless() { LONG_PTR dwStyle; DC_BEGIN_FN("StartModeless"); if (!_fInitialized) { TRC_ERR((TB,_T("failing startmodeless fInitialized is FALSE"))); return NULL; } _hwnd = CreateDialogParam(_hInstance, MAKEINTRESOURCE(IDD_ARCDLG), _hwndOwner, StaticDialogBoxProc, (LPARAM)this); if (_hwnd) { // // Make the dialog a child of the parent // dwStyle = GetWindowLongPtr(_hwnd, GWL_STYLE); dwStyle &= ~WS_POPUP; dwStyle |= WS_CHILD; SetParent(_hwnd, _hwndOwner); SetWindowLongPtr(_hwnd, GWL_STYLE, dwStyle); } else { TRC_ERR((TB,_T("CreateDialog failed: 0x%x"), GetLastError())); } DC_END_FN(); return _hwnd; } BOOL CAutoReconnectDlg::ShowTopMost() { BOOL rc = FALSE; DC_BEGIN_FN("ShowTopMost"); if (!_hwnd) { DC_QUIT; } ShowWindow(_hwnd, SW_SHOWNORMAL); // // Bring the window to the TOP of the Z order // SetWindowPos( _hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE ); rc = TRUE; DC_EXIT_POINT: DC_END_FN(); return rc; } VOID CAutoReconnectDlg::OnParentSizePosChange() { DC_BEGIN_FN("OnParentSizePosChange"); // // Reposition the dialog to 1/2 down the middle // of the owner window // if (_hwnd && _hwndOwner) { CenterWindow(_hwndOwner, 2, 2); } DC_END_FN(); } // // Handler for WM_ERASEBKGND (See platform sdk docs) // VOID CAutoReconnectDlg::OnEraseBkgnd( HWND hwnd, HDC hdc ) { RECT rc; HPALETTE hPaletteOld = NULL; DC_BEGIN_FN("OnEraseBkgnd"); TRC_ASSERT(_hbmBackground, (TB,_T("_hbmBackground is NULL"))); if (GetClientRect(hwnd, &rc)) { hPaletteOld = SelectPalette(hdc, _hPalette, FALSE); RealizePalette(hdc); PaintBitmap(hdc, &rc, _hbmBackground, &_rcBackground); SelectPalette(hdc, hPaletteOld, FALSE); RealizePalette(hdc); } DC_END_FN(); } // // Handler for WM_PRINTCLIENT // VOID CAutoReconnectDlg::OnPrintClient( HWND hwnd, HDC hdcPrint, DWORD dwOptions) { DC_BEGIN_FN("OnPrintClient"); #ifndef OS_WINCE if ((dwOptions & (PRF_ERASEBKGND | PRF_CLIENT)) != 0) { OnEraseBkgnd(hwnd, hdcPrint); } #endif DC_END_FN(); } #ifndef OS_WINCE void xDrawTransparentBitmap(HDC hdc, HBITMAP hBitmap, short xStart, short yStart, COLORREF cTransparentColor) { BITMAP bm; COLORREF cColor; HBITMAP bmAndBack, bmAndObject, bmAndMem, bmSave; HBITMAP bmBackOld, bmObjectOld, bmMemOld, bmSaveOld; HDC hdcMem, hdcBack, hdcObject, hdcTemp, hdcSave; POINT ptSize; hdcTemp = CreateCompatibleDC(hdc); SelectObject(hdcTemp, hBitmap); // Select the bitmap GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm); ptSize.x = bm.bmWidth; // Get width of bitmap ptSize.y = bm.bmHeight; // Get height of bitmap DPtoLP(hdcTemp, &ptSize, 1); // Convert from device // to logical points // Create some DCs to hold temporary data. hdcBack = CreateCompatibleDC(hdc); hdcObject = CreateCompatibleDC(hdc); hdcMem = CreateCompatibleDC(hdc); hdcSave = CreateCompatibleDC(hdc); // Create a bitmap for each DC. DCs are required for a number of // GDI functions. // Monochrome DC bmAndBack = CreateBitmap(ptSize.x, ptSize.y, 1, 1, NULL); // Monochrome DC bmAndObject = CreateBitmap(ptSize.x, ptSize.y, 1, 1, NULL); bmAndMem = CreateCompatibleBitmap(hdc, ptSize.x, ptSize.y); bmSave = CreateCompatibleBitmap(hdc, ptSize.x, ptSize.y); // Each DC must select a bitmap object to store pixel data. bmBackOld = (HBITMAP)SelectObject(hdcBack, bmAndBack); bmObjectOld = (HBITMAP)SelectObject(hdcObject, bmAndObject); bmMemOld = (HBITMAP)SelectObject(hdcMem, bmAndMem); bmSaveOld = (HBITMAP)SelectObject(hdcSave, bmSave); // Set proper mapping mode. SetMapMode(hdcTemp, GetMapMode(hdc)); // Save the bitmap sent here, because it will be overwritten. BitBlt(hdcSave, 0, 0, ptSize.x, ptSize.y, hdcTemp, 0, 0, SRCCOPY); // Set the background color of the source DC to the color. // contained in the parts of the bitmap that should be transparent cColor = SetBkColor(hdcTemp, cTransparentColor); // Create the object mask for the bitmap by performing a BitBlt // from the source bitmap to a monochrome bitmap. BitBlt(hdcObject, 0, 0, ptSize.x, ptSize.y, hdcTemp, 0, 0, SRCCOPY); // Set the background color of the source DC back to the original // color. SetBkColor(hdcTemp, cColor); // Create the inverse of the object mask. BitBlt(hdcBack, 0, 0, ptSize.x, ptSize.y, hdcObject, 0, 0, NOTSRCCOPY); // Copy the background of the main DC to the destination. BitBlt(hdcMem, 0, 0, ptSize.x, ptSize.y, hdc, xStart, yStart, SRCCOPY); // Mask out the places where the bitmap will be placed. BitBlt(hdcMem, 0, 0, ptSize.x, ptSize.y, hdcObject, 0, 0, SRCAND); // Mask out the transparent colored pixels on the bitmap. BitBlt(hdcTemp, 0, 0, ptSize.x, ptSize.y, hdcBack, 0, 0, SRCAND); // XOR the bitmap with the background on the destination DC. BitBlt(hdcMem, 0, 0, ptSize.x, ptSize.y, hdcTemp, 0, 0, SRCPAINT); // Copy the destination to the screen. BitBlt(hdc, xStart, yStart, ptSize.x, ptSize.y, hdcMem, 0, 0, SRCCOPY); // Place the original bitmap back into the bitmap sent here. BitBlt(hdcTemp, 0, 0, ptSize.x, ptSize.y, hdcSave, 0, 0, SRCCOPY); // Delete the memory bitmaps. DeleteObject(SelectObject(hdcBack, bmBackOld)); DeleteObject(SelectObject(hdcObject, bmObjectOld)); DeleteObject(SelectObject(hdcMem, bmMemOld)); DeleteObject(SelectObject(hdcSave, bmSaveOld)); // Delete the memory DCs. DeleteDC(hdcMem); DeleteDC(hdcBack); DeleteDC(hdcObject); DeleteDC(hdcSave); DeleteDC(hdcTemp); } // // Handler for WM_DRAWITEM (see platform sdk) // Handles owner draw items // // VOID CAutoReconnectDlg::OnDrawItem( HWND hwnd, const DRAWITEMSTRUCT *pDIS ) { DC_BEGIN_FN("OnDrawItem"); HPALETTE hPaletteOld = NULL; HFONT hfntSelected; int iBkMode; COLORREF colorText; RECT rc; SIZE size; TCHAR szText[256]; hPaletteOld = SelectPalette(pDIS->hDC, _hPalette, FALSE); (UINT)RealizePalette(pDIS->hDC); switch (pDIS->CtlID) { case IDC_TITLE_ARCING: { // Draw the title of the dialog "AutoReconecting". hfntSelected = static_cast(SelectObject(pDIS->hDC, _hfntTitle)); colorText = SetTextColor(pDIS->hDC, 0x00FFFFFF); iBkMode = SetBkMode(pDIS->hDC, TRANSPARENT); (int)GetWindowText(GetDlgItem(hwnd, pDIS->CtlID), szText, sizeof(szText)/sizeof(szText[0])); GetTextExtentPoint(pDIS->hDC, szText, lstrlen(szText), &size); CopyRect(&rc, &pDIS->rcItem); InflateRect(&rc, 0, -((rc.bottom - rc.top - size.cy) / 2)); DrawText(pDIS->hDC, szText, -1, &rc, 0); SetBkMode(pDIS->hDC, iBkMode); SetTextColor(pDIS->hDC, colorText); SelectObject(pDIS->hDC, hfntSelected); } break; case IDC_TITLE_FLAG: { BITMAP bitmap; GetClientRect(pDIS->hwndItem, &rc); if (GetObject(_hbmFlag, sizeof(bitmap), &bitmap) != 0) { rc.left += ((rc.right - rc.left) - bitmap.bmWidth) / 2; rc.right = rc.left + bitmap.bmWidth; rc.top += ((rc.bottom - rc.top) - bitmap.bmHeight) / 2; rc.bottom = rc.top + bitmap.bmHeight; } PaintBitmap(pDIS->hDC, &rc, _hbmFlag, &_rcFlag); } break; case IDC_ARC_STATIC_DISCBMP: { xDrawTransparentBitmap(pDIS->hDC, _hbmDisconImg, 0, 0, TRANSPARENT_MASK_COLOR); } break; } (HGDIOBJ)SelectPalette(pDIS->hDC, hPaletteOld, FALSE); (UINT)RealizePalette(pDIS->hDC); DC_END_FN(); } #endif // // StaticDialogBoxProc // Params: see platform sdk for wndproc // // Delegates work to appropriate instance // // INT_PTR CALLBACK CAutoReconnectDlg::StaticDialogBoxProc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) { // // Delegate to appropriate instance // (only works for single instance dialogs) // DC_BEGIN_FN("StaticDialogBoxProc"); DCINT retVal = 0; CAutoReconnectDlg* pDlg; if(WM_INITDIALOG != uMsg) { // // Need to retreive the instance pointer from the window class // pDlg = (CAutoReconnectDlg*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); } else { // // WM_INITDIALOG need to grab and set instance pointer // // // lParam contains this pointer (passed in DialogBoxParam) // pDlg = (CAutoReconnectDlg*) lParam; TRC_ASSERT(pDlg,(TB,_T("Got null instance pointer (lParam) in WM_INITDIALOG"))); if(!pDlg) { DC_QUIT; } // // Store the dialog pointer in the windowclass // SetLastError(0); if(!SetWindowLongPtr( hwndDlg, GWLP_USERDATA, (LONG_PTR)pDlg)) { if(GetLastError()) { TRC_ERR((TB,_T("SetWindowLongPtr failed 0x%x"), GetLastError())); DC_QUIT; } } } if (pDlg) { retVal = pDlg->DialogBoxProc(hwndDlg, uMsg, wParam, lParam); } DC_EXIT_POINT: DC_END_FN(); return retVal; } // // Name: DialogBoxProc // // Purpose: Handles AutoReconnect dialog box proc // // Returns: TRUE if message dealt with // FALSE otherwise // // Params: See windows documentation // // INT_PTR CALLBACK CAutoReconnectDlg::DialogBoxProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { INT_PTR rc = FALSE; DC_BEGIN_FN("DialogBoxProc"); switch (uMsg) { case WM_INITDIALOG: { // // Center // _hwnd = hwndDlg; CenterWindow(_hwndOwner, 2, 2); UpdateConnectionAttempts(0, 0); // // The band is positioned a fixed ratio of the way // down the height of this dialog to match up with the // background image // RECT cliRect; LONG nBandPos = 0; GetClientRect(hwndDlg, &cliRect); nBandPos = (INT)((cliRect.bottom - cliRect.top) * 42.0/193.0); _pProgBand = new CProgressBand(hwndDlg, _hInstance, nBandPos, IDB_ARC_BAND24, IDB_ARC_BAND8, NULL); if (_pProgBand) { if (!_pProgBand->Initialize()) { TRC_ERR((TB,_T("Progress band failed to init"))); delete _pProgBand; _pProgBand = NULL; } } // // Subclass the cancel button to do the correct key handling // this is important because the message loop is driven by // the container application so we can't just rely on it // calling IsDialogMessage(). In other words we need to manually // handle the appropriate keymapping code. // #ifndef OS_WINCE if (!SetWindowSubclass(GetDlgItem(hwndDlg, IDCANCEL), CancelBtnSubclassProc, IDCANCEL, reinterpret_cast(this))) { TRC_ERR((TB,_T("SetWindowSubclass failed: 0x%x"), GetLastError())); } #else _lOldCancelProc = (WNDPROC )SetWindowLong(GetDlgItem(hwndDlg, IDCANCEL), GWL_WNDPROC, (LONG )CancelBtnSubclassProc); SetWindowLong(GetDlgItem(hwndDlg, IDCANCEL), GWL_USERDATA, reinterpret_cast(this)); #endif // // Set the focus on the cancel button // and make it the default button // SendMessage(hwndDlg, DM_SETDEFID, IDCANCEL, 0); //SetFocus(GetDlgItem(hwndDlg, IDCANCEL)); SetFocus(hwndDlg); if (_pProgBand) { _pProgBand->StartSpinning(); } rc = 1; } break; case WM_COMMAND: { switch(DC_GET_WM_COMMAND_ID(wParam)) { case IDCANCEL: { TRC_NRM((TB,_T("AutoReconnect cancel was pressed"))); if (_pProgBand) { _pProgBand->StopSpinning(); } _pUi->UI_UserInitiatedDisconnect(_lastDiscReason); // // Disable the cancel button and set the cancel flag. // This will take effect on the next autoreconnection // notification. // EnableWindow(GetDlgItem(hwndDlg, IDCANCEL), FALSE); _fContinueReconAttempts = FALSE; } break; } } break; //WM_COMMAND case WM_DESTROY: { ARC_DBG_SETINFO(ARCDLG_DEBUG_WMDESTROYCALLED); #ifndef OS_WINCE RemoveWindowSubclass(GetDlgItem(hwndDlg, IDCANCEL), CancelBtnSubclassProc, IDCANCEL); #else SetWindowLong(GetDlgItem(hwndDlg, IDCANCEL), GWL_WNDPROC, (LONG )_lOldCancelProc); #endif // // Clear the instance data to prevent further processing // after the dialog is deleted // SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)NULL); } break; #ifndef OS_WINCE case WM_DRAWITEM: { OnDrawItem(hwndDlg, (DRAWITEMSTRUCT*)(lParam)); } break; #endif case WM_TIMER: { if (_pProgBand) { _pProgBand->OnTimer((INT)wParam); } } break; case WM_ERASEBKGND: { OnEraseBkgnd(hwndDlg, (HDC)wParam); if (_pProgBand) { _pProgBand->OnEraseParentBackground((HDC)wParam); } rc = 1; } break; case WM_CTLCOLORDLG: { SetBkMode((HDC)wParam, TRANSPARENT); rc = (INT_PTR)GetStockObject(NULL_BRUSH); } break; case WM_CTLCOLORSTATIC: { SetTextColor((HDC)wParam, RGB(255,255,255)); SetBkMode((HDC)wParam, TRANSPARENT); #ifndef OS_WINCE rc = (INT_PTR)GetStockObject(NULL_BRUSH); #else LONG lId = GetWindowLong((HWND)lParam, GWL_ID); rc = (INT_PTR)((lId == IDC_TITLE_ARCING) ? _hbrTopBand : _hbrMidBand); #endif } break; #ifndef OS_WINCE case WM_PRINTCLIENT: { OnPrintClient(hwndDlg, (HDC)wParam, (DWORD)lParam); rc = 1; } break; #endif default: { rc = 0; } break; } DC_END_FN(); return(rc); } /* DialogBoxProc */ VOID CAutoReconnectDlg::UpdateConnectionAttempts( ULONG conAttempts, ULONG maxConAttempts) { LPTSTR szFormattedString = NULL; HWND hwndStatic; DC_BEGIN_FN("UpdateConnectionAttempts"); hwndStatic = GetDlgItem(GetHwnd(), IDC_ARC_STATIC_INFO); szFormattedString = FormatMessageVArgs( _szConnectAttemptStringTmpl, conAttempts, maxConAttempts ); if (szFormattedString) { SetDlgItemText(GetHwnd(), IDC_ARC_STATIC_INFO, szFormattedString); LocalFree(szFormattedString); // // Invalidate the static control to trigger a repaint // if (hwndStatic) { RECT rc; if (GetWindowRect(hwndStatic, &rc)) { MapWindowPoints(HWND_DESKTOP, GetHwnd(), (LPPOINT)&rc,sizeof(RECT)/sizeof(POINT)); InvalidateRect(GetHwnd(), &rc, TRUE); UpdateWindow(GetHwnd()); } } } DC_END_FN(); } // // Called to notify us that we got disconnected // this means the last connection attempt failed // // Params: // discReason - disconnect major reason code // attemptCount - attempt count so far // pfContinueArc - [OUT] set to FALSE to stop ARC // VOID CAutoReconnectDlg::OnNotifyAutoReconnecting( UINT discReason, ULONG attemptCount, ULONG maxAttemptCount, BOOL* pfContinueArc ) { DC_BEGIN_FN("OnNotifyDisconnected"); _lastDiscReason = discReason; if (_fContinueReconAttempts) { _connectionAttempts = attemptCount; UpdateConnectionAttempts(attemptCount, maxAttemptCount); } else { TRC_NRM((TB,_T("Stopping arc - _fContinueReconAttempts is FALSE"))); } *pfContinueArc = _fContinueReconAttempts; DC_END_FN(); } // // Called to notify us that we have connected // VOID CAutoReconnectDlg::OnNotifyConnected() { DC_BEGIN_FN("OnNotifyConnected"); _fContinueReconAttempts = FALSE; DC_END_FN(); } // // Destory // Called to kill and cleanup the dialog // // BOOL CAutoReconnectDlg::Destroy() { DC_BEGIN_FN("Destroy"); ARC_DBG_SETINFO(ARCDLG_DEBUG_DESTROYCALLED); if (!DestroyWindow(_hwnd)) { TRC_ERR((TB,_T("DestroyWindow failed: 0x%x"), GetLastError())); } else { ARC_DBG_SETINFO(ARCDLG_DEBUG_WMDESTROYSUCCEED); } // // Clear the instance data to prevent further processing // after the dialog is deleted // ARC_DBG_SETINFO(ARCDLG_DEBUG_SETNULLINSTPTR); SetWindowLongPtr(_hwnd, GWLP_USERDATA, (LONG_PTR)NULL); DC_END_FN(); return TRUE; } #ifndef OS_WINCE LRESULT CALLBACK CAutoReconnectDlg::CancelBtnSubclassProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uiID, DWORD_PTR dwRefData ) #else LRESULT CALLBACK CAutoReconnectDlg::CancelBtnSubclassProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) #endif { LRESULT rc = 0; CAutoReconnectDlg* pThis = NULL; DC_BEGIN_FN("CancelBtnSubclassProc"); #ifndef OS_WINCE pThis = reinterpret_cast(dwRefData); #else pThis = reinterpret_cast(GetWindowLong(hwnd, GWL_USERDATA)); #endif TRC_ASSERT(pThis, (TB,_T("pThis == NULL"))); switch (uMsg) { case WM_KEYUP: { // // Hitting 'Esc' or 'Return' on the Cancel button // are the same as pressing it // if (VK_ESCAPE == wParam || VK_RETURN == wParam) { SendMessage(hwnd, BM_CLICK, NULL, NULL); } } // // Intentional fallthru // default: { #ifndef OS_WINCE rc = DefSubclassProc(hwnd, uMsg, wParam, lParam); #else rc = CallWindowProc(pThis->_lOldCancelProc, hwnd, uMsg, wParam, lParam); #endif } break; } DC_END_FN(); return rc; } #else // ARC_MINIMAL_UI #include "res_inc.c" CAutoReconnectPlainUI::CAutoReconnectPlainUI(HWND hwndOwner, HINSTANCE hInst, CUI* pUi) : CAutoReconnectUI(hwndOwner, hInst, pUi), _fInitialized(FALSE), _hPalette(NULL), _fIsUiVisible(FALSE) { #ifndef OS_WINCE BOOL fUse8BitDepth = FALSE; #else BOOL fUse8BitDepth = TRUE; #endif LOGFONT logFont; #ifndef OS_WINCE HDC hdcScreen; #else #endif BITMAP bitmap; INT logPixelsY = 100; DC_BEGIN_FN("CAutoReconnectPlainUI"); _nFlashingTimer = 0; _fContinueReconAttempts = TRUE; #ifndef OS_WINCE // // Get color depth // hdcScreen = GetDC(NULL); if (hdcScreen) { fUse8BitDepth = (GetDeviceCaps(hdcScreen, BITSPIXEL) <= 8); logPixelsY = GetDeviceCaps(hdcScreen, LOGPIXELSY); // // Load bitmaps // LPBYTE pBitmapBits = fUse8BitDepth ? (LPBYTE)g_DisconImage8Bits : (LPBYTE)g_DisconImageBits; ULONG cbBitmapLen = fUse8BitDepth ? g_cbDisconImage8Bits : g_cbDisconImageBits; _hbmDisconImg = (HBITMAP)LoadImageFromMemory( hdcScreen, (LPBYTE)pBitmapBits, cbBitmapLen ); if ((_hbmDisconImg != NULL) && (GetObject(_hbmDisconImg, sizeof(bitmap), &bitmap) >= sizeof(bitmap))) { SetRect(&_rcDisconImg, 0, 0, bitmap.bmWidth, bitmap.bmHeight); _hPalette = CUT::UT_GetPaletteForBitmap(NULL, _hbmDisconImg); } ReleaseDC(NULL, hdcScreen); hdcScreen = NULL; } #endif _fInitialized = (_hbmDisconImg && _pUi); if (!_fInitialized) { TRC_ERR((TB,_T("Failed to properly init arc dlg"))); } DC_END_FN(); } CAutoReconnectPlainUI::~CAutoReconnectPlainUI() { #ifndef OS_WINCE if (_hbmDisconImg) { DeleteObject(_hbmDisconImg); _hbmDisconImg = NULL; } #endif if (_hPalette) { DeleteObject(_hPalette); _hPalette = NULL; } } #define ARC_PLAIN_WNDCLASS _T("ARCICON") HWND CAutoReconnectPlainUI::StartModeless() { LONG_PTR dwStyle; WNDCLASS tmpWndClass; WNDCLASS plainArcWndClass; ATOM registerClassRc; DC_BEGIN_FN("StartModeless"); if (!_fInitialized) { TRC_ERR((TB,_T("failing startmodeless fInitialized is FALSE"))); return NULL; } // // Create a window to host the UI // // // Register the class for the Main Window // if (!GetClassInfo(_hInstance, ARC_PLAIN_WNDCLASS, &tmpWndClass)) { TRC_NRM((TB, _T("Register Main Window class"))); plainArcWndClass.style = CS_DBLCLKS; plainArcWndClass.lpfnWndProc = StaticPlainArcWndProc; plainArcWndClass.cbClsExtra = 0; plainArcWndClass.cbWndExtra = sizeof(void*); //store 'this' pointer plainArcWndClass.hInstance = _hInstance; plainArcWndClass.hIcon = NULL; plainArcWndClass.hCursor = LoadCursor(NULL, IDC_ARROW); plainArcWndClass.hbrBackground = (HBRUSH) GetStockObject(HOLLOW_BRUSH); plainArcWndClass.lpszMenuName = NULL; plainArcWndClass.lpszClassName = ARC_PLAIN_WNDCLASS; registerClassRc = RegisterClass (&plainArcWndClass); if (registerClassRc == 0) { TRC_ERR((TB,_T("RegisterClass failed: 0x%x"), GetLastError())); DC_QUIT; } } _hwnd = CreateWindow(ARC_PLAIN_WNDCLASS, NULL, WS_CHILD | WS_CLIPSIBLINGS, 0, 0, _rcDisconImg.right - _rcDisconImg.left, _rcDisconImg.bottom - _rcDisconImg.top, _hwndOwner, NULL, _hInstance, this ); if (_hwnd) { // // Move window to the parent's top-right and then show the window // MoveToParentTopRight(); ShowTopMost(); _fIsUiVisible = TRUE; } else { TRC_ERR((TB,_T("CreateWindow failed: 0x%x"), GetLastError())); } DC_EXIT_POINT: DC_END_FN(); return _hwnd; } BOOL CAutoReconnectPlainUI::ShowTopMost() { BOOL rc = FALSE; DC_BEGIN_FN("ShowTopMost"); if (!_hwnd) { DC_QUIT; } ShowWindow(_hwnd, SW_SHOWNORMAL); // // Bring the window to the TOP of the Z order // SetWindowPos( _hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE ); rc = TRUE; DC_EXIT_POINT: DC_END_FN(); return rc; } // // Position offset from the edge // #define ICON_POSITION_OFFSET 20 VOID CAutoReconnectPlainUI::MoveToParentTopRight() { RECT rcParent; INT xPos, yPos; DC_BEGIN_FN("OnParentSizePosChange"); // // Reposition the dialog to the top right // of the owner window // if (_hwnd && _hwndOwner) { // // Position the window in the top-right of the parent // GetClientRect(_hwndOwner, &rcParent); xPos = rcParent.right - ICON_POSITION_OFFSET - (_rcDisconImg.right - _rcDisconImg.left); yPos = rcParent.top + ICON_POSITION_OFFSET; SetWindowPos(_hwnd, NULL, xPos, yPos, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE); } DC_END_FN(); } VOID CAutoReconnectPlainUI::OnParentSizePosChange() { MoveToParentTopRight(); } // // Handler for WM_ERASEBKGND (See platform sdk docs) // VOID CAutoReconnectPlainUI::OnEraseBkgnd( HWND hwnd, HDC hdc ) { RECT rc; HPALETTE hPaletteOld = NULL; DC_BEGIN_FN("OnEraseBkgnd"); TRC_ASSERT(_hbmDisconImg, (TB,_T("_hbmBackground is NULL"))); if (GetClientRect(hwnd, &rc)) { hPaletteOld = SelectPalette(hdc, _hPalette, FALSE); RealizePalette(hdc); PaintBitmap(hdc, &rc, _hbmDisconImg, &_rcDisconImg); SelectPalette(hdc, hPaletteOld, FALSE); RealizePalette(hdc); } DC_END_FN(); } // // Handler for WM_PRINTCLIENT // VOID CAutoReconnectPlainUI::OnPrintClient( HWND hwnd, HDC hdcPrint, DWORD dwOptions) { DC_BEGIN_FN("OnPrintClient"); #ifndef OS_WINCE if ((dwOptions & (PRF_ERASEBKGND | PRF_CLIENT)) != 0) { OnEraseBkgnd(hwnd, hdcPrint); } #endif DC_END_FN(); } // // StaticPlainArcWndProc // Params: see platform sdk for wndproc // // Delegates work to appropriate instance // // LRESULT CALLBACK CAutoReconnectPlainUI::StaticPlainArcWndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) { INT retVal = 0; CAutoReconnectPlainUI* pUI; DC_BEGIN_FN("StaticPlainArcWndProc"); pUI = (CAutoReconnectPlainUI*)GetWindowLongPtr(hwnd, GWLP_USERDATA); if(WM_CREATE == uMsg) { //pull out the this pointer and stuff it in the window class LPCREATESTRUCT lpcs = (LPCREATESTRUCT) lParam; pUI = (CAutoReconnectPlainUI*)lpcs->lpCreateParams; SetWindowLongPtr( hwnd, GWLP_USERDATA, (LONG_PTR)pUI); } // // Delegate the message to the appropriate instance // if(pUI) { return pUI->WndProc(hwnd, uMsg, wParam, lParam); } else { return DefWindowProc(hwnd, uMsg, wParam, lParam); } DC_EXIT_POINT: DC_END_FN(); return retVal; } #define ARC_PLAIN_UI_TIMERID 1 #define ARC_ANIM_TIME 400 // // Name: WndProc // // Purpose: Handles AutoReconnect dialog box proc // // Returns: TRUE if message dealt with // FALSE otherwise // // Params: See windows documentation // // LRESULT CALLBACK CAutoReconnectPlainUI::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { INT_PTR rc = FALSE; DC_BEGIN_FN("DialogBoxProc"); switch (uMsg) { case WM_CREATE: { _nFlashingTimer = SetTimer(hwnd, ARC_PLAIN_UI_TIMERID, ARC_ANIM_TIME, NULL ); if (_nFlashingTimer) { SetFocus(hwnd); } else { TRC_ERR((TB,_T("SetTimer failed - 0x%x"), GetLastError())); rc = -1; } } break; case WM_DESTROY: { if (_nFlashingTimer) { KillTimer(hwnd, _nFlashingTimer); _nFlashingTimer = 0; } SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)NULL); } break; case WM_TIMER: { // // DO animation stuff // OnAnimFlashTimer(); } break; case WM_ERASEBKGND: { OnEraseBkgnd(hwnd, (HDC)wParam); rc = 1; } break; case WM_KEYUP: { if (VK_ESCAPE == wParam) { TRC_NRM((TB,_T("ARC ESC pressed, disconnect"))); _pUi->UI_UserInitiatedDisconnect(_lastDiscReason); _fContinueReconAttempts = FALSE; } } break; case WM_SETFOCUS: { TRC_NRM((TB,_T("Setfocus to arc"))); } break; case WM_KILLFOCUS: { TRC_NRM((TB,_T("killfocus to arc: 0x%x 0x%x"), wParam, lParam)); } break; #ifndef OS_WINCE case WM_PRINTCLIENT: { OnPrintClient(hwnd, (HDC)wParam, (DWORD)lParam); rc = 1; } break; #endif default: { return DefWindowProc( hwnd, uMsg, wParam, lParam); } break; } DC_END_FN(); return(rc); } /* DialogBoxProc */ VOID CAutoReconnectPlainUI::OnAnimFlashTimer() { // // Toggle UI hide state // _fIsUiVisible = !_fIsUiVisible; ShowWindow(_hwnd, _fIsUiVisible ? SW_SHOWNORMAL : SW_HIDE); } // // Called to notify us that we got disconnected // this means the last connection attempt failed // // Params: // discReason - disconnect major reason code // attemptCount - attempt count so far // pfContinueArc - [OUT] set to FALSE to stop ARC // VOID CAutoReconnectPlainUI::OnNotifyAutoReconnecting( UINT discReason, ULONG attemptCount, ULONG maxAttemptCount, BOOL* pfContinueArc ) { DC_BEGIN_FN("OnNotifyDisconnected"); _lastDiscReason = discReason; if (!_fContinueReconAttempts) { TRC_NRM((TB,_T("Stopping arc - _fContinueReconAttempts is FALSE"))); } *pfContinueArc = _fContinueReconAttempts; DC_END_FN(); } // // Called to notify us that we have connected // VOID CAutoReconnectPlainUI::OnNotifyConnected() { DC_BEGIN_FN("OnNotifyConnected"); _fContinueReconAttempts = FALSE; DC_END_FN(); } // // Destory // Called to kill and cleanup the dialog // // BOOL CAutoReconnectPlainUI::Destroy() { DC_BEGIN_FN("Destroy"); if (!DestroyWindow(_hwnd)) { TRC_ERR((TB,_T("DestroyWindow failed: 0x%x"), GetLastError())); } DC_END_FN(); return TRUE; } // // Load a bitmap from memory // // Params: // pbBitmapBits - pointer to bitmap bits (e.g. can pass in file mapping // to a BMP file). // // cbLen - length of pbBitmapBits // // Returns: // HBITMAP - handle to the bitmap // HBITMAP CAutoReconnectPlainUI::LoadImageFromMemory( HDC hdc, LPBYTE pbBitmapBits, ULONG cbLen ) { HRESULT hr; HBITMAP hbmp = NULL; LPBITMAPINFO pbmi = NULL; ULONG cbBmiLen = 0; PBYTE pBitmapBits = NULL; ULONG cbBitmapBits = 0; hr = LoadImageBits( pbBitmapBits, cbLen, &pbmi, &cbBmiLen, &pBitmapBits, &cbBitmapBits ); if (SUCCEEDED(hr)) { hbmp = CreateDIBitmap(hdc, &pbmi->bmiHeader, CBM_INIT, pBitmapBits, pbmi, DIB_RGB_COLORS ); delete pBitmapBits; delete pbmi; } return hbmp; } #define BMP_24_BITSPERPIXEL 24 #define BMP_16_BITSPERPIXEL 16 #define BMP_32_BITSPERPIXEL 32 // // Worker function for image load, caller frees outparam bits // HRESULT CAutoReconnectPlainUI::LoadImageBits( LPBYTE pbBitmapBits, ULONG cbLen, LPBITMAPINFO* ppBitmapInfo, PULONG pcbBitmapInfo, LPBYTE* ppBits, PULONG pcbBits ) { HRESULT hr = ResultFromScode(S_OK); BITMAPFILEHEADER bmfh; BITMAPCOREHEADER *pbch; BITMAPINFOHEADER bih; LPBYTE pbStart; ULONG cbi = 0; ULONG cbData; LPBITMAPINFO pbi = NULL; LPBYTE pbData = NULL; DWORD dwSizeOfHeader; // // Record the starting position // pbStart = pbBitmapBits; // // First validate the buffer for size // if (cbLen < sizeof(BITMAPFILEHEADER)) { return(ResultFromScode(E_FAIL)); } // // Now get the bitmap file header // memcpy(&bmfh, pbBitmapBits, sizeof(BITMAPFILEHEADER)); // // Validate the header // if (!(bmfh.bfType == 0x4d42) && (bmfh.bfOffBits <= cbLen)) { return E_FAIL; } // // Get the next 4 bytes which will represent the size of the // next structure and allow us to determine the type // if (SUCCEEDED(hr)) { pbBitmapBits += sizeof(BITMAPFILEHEADER); memcpy(&dwSizeOfHeader, pbBitmapBits, sizeof(DWORD)); if (dwSizeOfHeader == sizeof(BITMAPCOREHEADER)) { pbch = (BITMAPCOREHEADER *)pbBitmapBits; memset(&bih, 0, sizeof(BITMAPINFOHEADER)); bih.biSize = sizeof(BITMAPINFOHEADER); bih.biWidth = pbch->bcWidth; bih.biHeight = pbch->bcHeight; bih.biPlanes = pbch->bcPlanes; bih.biBitCount = pbch->bcBitCount; pbBitmapBits += sizeof(BITMAPCOREHEADER); } else if (dwSizeOfHeader == sizeof(BITMAPINFOHEADER)) { memcpy(&bih, pbBitmapBits, sizeof(BITMAPINFOHEADER)); pbBitmapBits += sizeof(BITMAPINFOHEADER); } else { hr = ResultFromScode(E_FAIL); } } // // Check if biClrUsed is set since we do not handle that // case at this time // if (SUCCEEDED(hr)) { if (bih.biClrUsed != 0) { hr = ResultFromScode(E_FAIL); } } // // Now we need to calculate the size of the BITMAPINFO we need // to allocate including any palette information // if (SUCCEEDED(hr)) { // // First the size of the header // cbi = sizeof(BITMAPINFOHEADER); // // Now the palette // if (bih.biBitCount == BMP_24_BITSPERPIXEL) { // // Just add on the 1 RGBQUAD for the structure but // there is no palette // cbi += sizeof(RGBQUAD); } else if ((bih.biBitCount == BMP_16_BITSPERPIXEL) || (bih.biBitCount == BMP_32_BITSPERPIXEL)) { // // Add on the 3 DWORD masks which are used to // get the colors out of the data // cbi += (3 * sizeof(DWORD)); } else { // // Anything else we just use the bit count to calculate // the number of entries // cbi += ((1 << bih.biBitCount) * sizeof(RGBQUAD)); } // // Now allocate the BITMAPINFO // pbi = (LPBITMAPINFO) new BYTE [cbi]; if (pbi == NULL) { hr = ResultFromScode(E_OUTOFMEMORY); } } // // Fill in the BITMAPINFO data structure and get the bits // if (SUCCEEDED(hr)) { // // First copy the header data // memcpy(&(pbi->bmiHeader), &bih, sizeof(BITMAPINFOHEADER)); // // Now the palette data // if (bih.biBitCount == BMP_24_BITSPERPIXEL) { // // No palette data to copy // } else if ((bih.biBitCount == BMP_16_BITSPERPIXEL) || (bih.biBitCount == BMP_32_BITSPERPIXEL)) { // // Copy the 3 DWORD masks // memcpy(&(pbi->bmiColors), pbBitmapBits, 3*sizeof(DWORD)); } else { // // If we were a BITMAPCOREHEADER type then we have our // palette data in the form of RGBTRIPLEs so we must // explicitly copy each. Otherwise we can just memcpy // the RGBQUADs // if (dwSizeOfHeader == sizeof(BITMAPCOREHEADER)) { ULONG cPalEntry = (1 << bih.biBitCount); ULONG cCount; RGBTRIPLE *argbt = (RGBTRIPLE *)pbBitmapBits; for (cCount = 0; cCount < cPalEntry; cCount++) { pbi->bmiColors[cCount].rgbRed = argbt[cCount].rgbtRed; pbi->bmiColors[cCount].rgbGreen = argbt[cCount].rgbtGreen; pbi->bmiColors[cCount].rgbBlue = argbt[cCount].rgbtBlue; pbi->bmiColors[cCount].rgbReserved = 0; } } else { ULONG cbPalette = (1 << bih.biBitCount) * sizeof(RGBQUAD); memcpy(&(pbi->bmiColors), pbBitmapBits, cbPalette); } } // // Now find out where the bits are // pbBitmapBits = pbStart + bmfh.bfOffBits; // // Get the size to copy // cbData = cbLen - bmfh.bfOffBits; // // Allocate the buffer to hold the bits // pbData = new BYTE [cbData]; if (pbData == NULL) { hr = ResultFromScode(E_OUTOFMEMORY); } if (SUCCEEDED(hr)) { memcpy(pbData, pbBitmapBits, cbData); } } // // If everything succeeded record the data // if (SUCCEEDED(hr)) { // // Record the info // *pcbBitmapInfo = cbi; *ppBitmapInfo = pbi; // // Record the data // *ppBits = pbData; *pcbBits = cbData; } else { // // Cleanup // delete pbi; delete pbData; } return(hr); } #endif // ARC_MINIMAL_UI