Example #1
0
LOCAL void Meter_OnDraw(HWND hWindow, HDC hDC, LPRECT lpRect, BOOL fHighlight)
/***********************************************************************/
{
    RECT	rSrcArea, rDstArea, rControlArea;
    POINT	ptDst;
    PDIB	pdibSrc, pdibDst, pdibSrc2, pdibTmp;
    UINT	id;
    LPOFFSCREEN lpOffScreen;
    LPSCENE lpScene;
    HDC		hWinGDC;
    HPALETTE hLoadPal;

    lpScene = CScene::GetScene( GetParent(hWindow) );
    if (!lpScene)
        return;

    LPMETERCONTINFO lpInfo;
    if (!(lpInfo = (LPMETERCONTINFO)GetWindowLong(hWindow, GWL_DATAPTR) ))
        return;

    rSrcArea = * lpRect;
    rDstArea = * lpRect;
    rControlArea = * lpRect;

    lpOffScreen = lpScene->GetOffScreen();
    if (lpOffScreen)
    {
        MapWindowPoints(hWindow, GetParent(hWindow), (LPPOINT)& rDstArea, 2);
        if (!(pdibSrc = lpOffScreen->GetReadOnlyDIB() ) )
            return;
        if (!(pdibDst = lpOffScreen->GetWritableDIB() ) )
            return;
        hWinGDC = lpOffScreen->GetDC();
        hLoadPal = GetApp()->m_hPal;
    }
    else
    {
        return;
    }

    RECT	rClient;
    GetClientRect(hWindow, & rClient);
    MapWindowPoints(hWindow, GetParent(hWindow), (LPPOINT)& rClient, 2 );

    // Get the control style
    DWORD dwStyle = GetWindowStyle(hWindow);
    BOOL bVert = (dwStyle & MC_VERT) ? TRUE : FALSE ;

    // Get the control id
    if (!(id = GetWindowWord(hWindow, GWW_ICONID) ) )
        id = GET_WINDOW_ID(hWindow);

    // Refresh the background,
    // compressed DIBs must use GDI copying (lose transparency ability)
    if (pdibSrc->GetCompression() == BI_RLE8 ||
            pdibDst->GetCompression() == BI_RLE8)
    {
        pdibSrc->DCBlt(hWinGDC,
                       rDstArea.left, rDstArea.top,
                       rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
                       rDstArea.left, rDstArea.top,
                       rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top );
    }
    else
    {
        pdibSrc->DibBlt(pdibDst,
                        rDstArea.left, rDstArea.top,
                        rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
                        rDstArea.left, rDstArea.top,
                        rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
                        NO /*bTransparent*/ );
    }

    // Load the resource
    if (pdibSrc = CDib::LoadDibFromResource(GetWindowInstance(hWindow),
                                            MAKEINTRESOURCE(id), hLoadPal, (dwStyle & BS_MASK) != 0) )
    {
        if (pdibSrc2 = CDib::LoadDibFromResource(GetWindowInstance(hWindow),
                       MAKEINTRESOURCE(id + 1), hLoadPal, (dwStyle & BS_MASK) != 0) )
        {
            int iBitmapWidth = pdibSrc->GetWidth();
            int iBitmapHeight = pdibSrc->GetHeight();

            rSrcArea.left = 0;
            rSrcArea.top = 0;
            rSrcArea.right = rSrcArea.left + iBitmapWidth;
            rSrcArea.bottom = rSrcArea.top + iBitmapHeight;
            rDstArea = rClient;
            rDstArea.right = rDstArea.left + iBitmapWidth;
            rDstArea.bottom = rDstArea.top + iBitmapHeight;

            // Get the position width
            int iPosWidth;
            if (bVert)
            {
                iPosWidth = (int)( (float)iBitmapHeight *
                                   ((float)lpInfo->lPosition / ((float)lpInfo->Max - (float)lpInfo->Min)));
                iPosWidth = iBitmapHeight - iPosWidth;
            }
            else
            {
                iPosWidth = (int)( (float)iBitmapWidth *
                                   ((float)lpInfo->lPosition / ((float)lpInfo->Max - (float)lpInfo->Min)));
            }
            // compressed DIBs must use GDI copying (lose transparency ability)
            if (pdibSrc->GetCompression() == BI_RLE8 ||
                    pdibDst->GetCompression() == BI_RLE8 )
            {
                pdibSrc->DCBlt(hWinGDC,
                               rDstArea.left, rDstArea.top,
                               rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
                               rSrcArea.left, rSrcArea.top,
                               rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top);
            }
            else
            {
                RGBTRIPLE rgb;
                LPRGBTRIPLE lpRGB = NULL;
                if (dwStyle & BS_MASK)
                {
                    STRING szColor;
                    GetWindowText(hWindow, szColor, sizeof(szColor));
                    AsciiRGB(szColor, & rgb);
                    if (fHighlight)
                    {
                        // this relies on the fact that AsciiRGB replaces commas
                        // with NULL terminators
                        LPTSTR lp = szColor + lstrlen(szColor) + 1; // passed red
                        lp += lstrlen(lp) + 1; // passed green
                        lp += lstrlen(lp) + 1; // passed blue to higlight color
                        AsciiRGB(lp, & rgb);
                    }
                    lpRGB = & rgb;
                }
                // Render the first bitmap
                pdibTmp = pdibSrc;
                pdibTmp->DibBlt(pdibDst,
                                rDstArea.left, rDstArea.top,
                                rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
                                rSrcArea.left, rSrcArea.top,
                                rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top,
                                FALSE /*bTransparent*/, lpRGB);
            }

            // Adjust the source and dest rect's and render the 2nd bitmap

            if (bVert)
            {
                //rDstArea.top = rDstArea.top;// iPosWidth;
                rDstArea.bottom = rDstArea.top + iPosWidth;
                //rSrcArea.top = rSrcArea.bottom - iPosWidth;
                rSrcArea.bottom = iPosWidth;
            }
            else
            {
                rDstArea.right = rDstArea.left + iPosWidth;
                rSrcArea.right = rSrcArea.left + iPosWidth;
            }
            // compressed DIBs must use GDI copying (lose transparency ability)
            if (pdibSrc->GetCompression() == BI_RLE8 ||
                    pdibDst->GetCompression() == BI_RLE8 )
            {
                pdibSrc->DCBlt(hWinGDC,
                               rDstArea.left, rDstArea.top,
                               rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
                               rSrcArea.left, rSrcArea.top,
                               rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top);
            }
            else
            {
                RGBTRIPLE rgb;
                LPRGBTRIPLE lpRGB = NULL;
                if (dwStyle & BS_MASK)
                {
                    STRING szColor;
                    GetWindowText(hWindow, szColor, sizeof(szColor));
                    AsciiRGB(szColor, & rgb);
                    if (fHighlight)
                    {
                        // this relies on the fact that AsciiRGB replaces commas
                        // with NULL terminators
                        LPTSTR lp = szColor + lstrlen(szColor) + 1; // passed red
                        lp += lstrlen(lp) + 1; // passed green
                        lp += lstrlen(lp) + 1; // passed blue to higlight color
                        AsciiRGB(lp, & rgb);
                    }
                    lpRGB = & rgb;
                }
                // Render the first bitmap
                pdibTmp = pdibSrc2;
                pdibTmp->DibBlt(pdibDst,
                                rDstArea.left, rDstArea.top,
                                rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
                                rSrcArea.left, rSrcArea.top,
                                rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top,
                                FALSE /*bTransparent*/, lpRGB);

            }
        }
        delete pdibSrc;
        delete pdibSrc2;
    }

    ptDst.x = rControlArea.left;
    ptDst.y = rControlArea.top;
    if (lpOffScreen)
    {
        lpOffScreen->DrawRect(hDC, & rClient, & ptDst);
    }
}
Example #2
0
DWORD __far __pascal WndData( HWND hWnd, WNDDATAMSG Msg, DWORD dwParam, void __far * fpDataBuffer )
{
  RECT __far * fpRect;
  FPWNDDATA fpWndData;
  HWNDDATA hWndData;
  DWORD dwReturn;
  
  switch( Msg )
  {
    /******************* CHILDWNDDATA structure messages.  *******************/


    /* Am I painting the window currently. */
    case WDM_SETAMPAINTING: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->ChildWndData.bAmPainting = ( BOOL ) dwParam;
      GlobalUnlock( hWndData );
      
      return 0;
    }

    case WDM_GETAMPAINTING: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->ChildWndData.bAmPainting;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /*  The screen position of a hotspot. */
    case WDM_SETHOTSPOTPOS: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpRect = ( RECT __far * ) fpDataBuffer;
      fpWndData->ChildWndData.HotSpotPosRec = *fpRect;
      GlobalUnlock( hWndData );
      
      return 0;
    }

    case WDM_GETHOTSPOTPOS: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpRect = ( RECT __far * ) fpDataBuffer;
      *fpRect = fpWndData->ChildWndData.HotSpotPosRec;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /*  The display data for window. */
    case WDM_SETDISPLAYINFO: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->ChildWndData.hDisplayInfo = ( HGLOBAL ) dwParam;
      GlobalUnlock( hWndData );
      
      return 0;
    }

    case WDM_GETDISPLAYINFO: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->ChildWndData.hDisplayInfo;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Handle to the window that keeps the data. */
    case WDM_SETDATAHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->ChildWndData.hDataWnd = ( HWND ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETDATAHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->ChildWndData.hDataWnd;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Handle of the window's parent window. */
    case WDM_SETPARENTHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->ChildWndData.hParentWnd = ( HWND ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETPARENTHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->ChildWndData.hParentWnd;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Handle to the non-scrollable topic window. */
    case WDM_SETNOSCROLLHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->ChildWndData.hNoScrollWnd = ( HWND ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETNOSCROLLHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->ChildWndData.hNoScrollWnd;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Position of window in client area. */
    case WDM_SETCLIENTPOS: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpRect = ( RECT __far * ) fpDataBuffer;
      fpWndData->ChildWndData.ClientPosRect = *fpRect;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETCLIENTPOS: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpRect = ( RECT __far * ) fpDataBuffer;
      *fpRect = fpWndData->ChildWndData.ClientPosRect;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /******************* MAINWNDDATA structure messages.  *******************/
    
    /* Handle to accelerator support system. */
    case WDM_SETACCELSYS: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.hAccelSys = ( HACCELSYS ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETACCELSYS: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.hAccelSys;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Handle to the window that keeps the data. */
    case WDM_SETMAINDATAHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.hDataWnd = ( HWND ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETMAINDATAHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.hDataWnd;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Is the Search dialog already being displayed. */
    case WDM_SETSEARCHDLGDISPLAYED: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.bSearchDlgDisplayed = ( BOOL ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETSEARCHDLGDISPLAYED: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.bSearchDlgDisplayed;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Topic data for main topic window. */
    case WDM_SETMAINTOPICDATA: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.hTopicData = ( HTOPICDATA ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETMAINTOPICDATA: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.hTopicData;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Active secondary window list. */
    case WDM_SETSECWNDDATA: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.hSecWndList = ( HGLOBAL ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETSECWNDDATA: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.hSecWndList;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Handle to the "Back" button data. */
    case WDM_SETBACKDATA: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.hBackBtnData = ( HGLOBAL ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETBACKDATA: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.hBackBtnData;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Browse next topic offset. */
    case WDM_SETBROWSENEXTDATA: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.dwNextTopicCharOffset = ( long int ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETBROWSENEXTDATA: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = ( long int ) fpWndData->MainWndData.dwNextTopicCharOffset;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Browse prev. topic offset. */
    case WDM_SETBROWSEPREVDATA: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.dwPrevTopicCharOffset = ( long int ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETBROWSEPREVDATA: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = ( long int ) fpWndData->MainWndData.dwPrevTopicCharOffset;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /* Help file/topic information buffer. */
    case WDM_SETFILEBUFFER: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.hHelpFileBuffer = ( HGLOBAL ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETFILEBUFFER: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.hHelpFileBuffer;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }

    /* History window's HWND. */
    case WDM_SETHISTORYHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.hHistoryWnd = ( HWND ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETHISTORYHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.hHistoryWnd;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /*  Main topic window's HWND. */
    case WDM_SETMAINTOPICHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.hTopicWnd = ( HWND ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETMAINTOPICHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.hTopicWnd;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }

    /*  Button bar window's HWND. */
    case WDM_SETBUTTONBARHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.hButtonBarWnd = ( HWND ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETBUTTONBARHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.hButtonBarWnd;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /*  Window to notify when quitting. */
    case WDM_SETQUITHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.hQuitWnd = ( HWND ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETQUITHWND: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.hQuitWnd;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }


    /*  Macro engine instance handle. */
    case WDM_SETMACROENGINE: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      fpWndData->MainWndData.hMacroEngine = ( HMACROENGINE ) dwParam;
      GlobalUnlock( hWndData );
      return 0;
    }
    case WDM_GETMACROENGINE: 
    {
      hWndData = (HWNDDATA) GetWindowWord( hWnd, 0 );
      fpWndData = ( FPWNDDATA ) GlobalLock( hWndData );
      dwReturn = (DWORD) fpWndData->MainWndData.hMacroEngine;
      GlobalUnlock( hWndData );
      return( dwReturn );
    }
  }
  
  /* If message doesn't return a value - return 0. */
  return 0;
}
Example #3
0
File: cns.c Project: Akasurde/krb5
/*
 * Function: Main routine called on program invocation.
 *
 * Parameters:
 *	hinstance - the current instance
 *
 *	hprevinstance - previous instance if one exists or NULL.
 *
 *	cmdline - the command line string passed by Windows.
 *
 *	ncmdshow - show flag to indicate wheather to come up minimized
 *		or not.
 *
 * Returns: TRUE if initialized sucessfully, false otherwise.
 */
int PASCAL
WinMain(HINSTANCE hinst, HINSTANCE hprevinstance, LPSTR cmdline, int ncmdshow)
{
  DLGPROC dlgproc;
  HWND hwnd;
  HACCEL haccel;
  MSG msg;
  char *p;
  char buf[MAX_K_NAME_SZ + 9];
  char name[MAX_K_NAME_SZ];

  strcpy(buf, cmdline);
  action = LOGIN_AND_RUN;
  name[0] = 0;
  p = strtok(buf, " ,");

  while (p != NULL) {
    if (_stricmp(p, "/exit") == 0)
      action = LOGIN_AND_EXIT;
    else if (_stricmp(p, "/minimize") == 0)
      action = LOGIN_AND_MINIMIZE;
    else
      strcpy(name, p);

    p = strtok(NULL, " ,");
  }

  dlgncmdshow = ncmdshow;
  hinstance = hinst;

#ifndef _WIN32
  /*
   * If a previous instance of this application exits, bring it
   * to the front and exit.
   *
   * This code is not compiled for WIN32, since hprevinstance will always
   * be NULL.
   */
  if (hprevinstance != NULL) {
    hwnd = FindWindow(KWIN_DIALOG_CLASS, NULL);

    if (IsWindow(hwnd) && IsWindowVisible(hwnd)) {
      if (GetWindowWord(hwnd, GWW_HINSTANCE) == hprevinstance) {
	if (name[0])
	  SendMessage(hwnd, WM_KWIN_SETNAME, 0, (LONG)name);

	ShowWindow(hwnd, ncmdshow);
	SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
		     SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE);

	return FALSE;
      }
    }
  }

  if (hprevinstance == NULL)
#endif /* _WIN32 */

  if (!init_application(hinstance))
      return FALSE;

  if (!init_instance(hinstance, ncmdshow))
    return FALSE;

#ifdef _WIN32
  dlgproc = kwin_dlg_proc;
#else
  dlgproc = (FARPROC)MakeProcInstance(kwin_dlg_proc, hinstance);
  assert(dlgproc != NULL);

  if (dlgproc == NULL)
    return 1;
#endif

  hwnd = CreateDialogParam(hinstance, MAKEINTRESOURCE(ID_KWIN),
			   HWND_DESKTOP, dlgproc, (LONG)name);
  assert(hwnd != NULL);

  if (hwnd == NULL)
    return 1;
  haccel = LoadAccelerators(hinstance, MAKEINTRESOURCE(IDA_KWIN));
  assert(hwnd != NULL);

  while (GetMessage(&msg, NULL, 0, 0)) {
    if (!TranslateAccelerator(hwnd, haccel, &msg) &&
	!IsDialogMessage(hwnd, &msg)) {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
  }

  DestroyWindow(hwnd);

#ifndef _WIN32
  FreeProcInstance((FARPROC)dlgproc);
#endif

  cns_save_registry();

  return 0;
}
Example #4
0
LOCAL void Story_OnDraw(HWND hWindow, HDC hDC, LPRECT lpRect, BOOL fHighlight)
/***********************************************************************/
{
	BOOL bHasFocus, bSelected, bDown;
	DWORD dwStyle;
	RECT rSrcArea, rDstArea;
	POINT ptDst;
	PDIB pdibSrc, pdibDst, pDib;
	LPOFFSCREEN lpOffScreen;
	PTOON pToon;
	LPSCENE lpScene;
	PSTORY pStory;
	RGBQUAD rgbQuad[256];
	BITMAPINFOHEADER bmi;
	LPTR lp;
	HDC hWinGDC;
	HPALETTE hWinGPal = NULL, hDisplayPal = NULL, hOldPal;

	if (IsRectEmpty(lpRect))
		return;
	pStory = GetStory(hWindow);
	if (!pStory)
		return;
	if (!pStory->m_pDib)
		return;
	lpScene = CScene::GetScene(GetParent(hWindow));
	if (!lpScene)
		return;

	rSrcArea = *lpRect;
	rDstArea = *lpRect;
	bSelected = GetWindowWord(hWindow, GWW_STATE );
	dwStyle = GetWindowLong( hWindow, GWL_STYLE );
	bHasFocus = ( GetFocus() == hWindow );
	bDown = ( bSelected || (bTrack && bInRect && bHasFocus) );

	lpOffScreen = lpScene->GetOffScreen();
	if (lpOffScreen)
	{
		MapWindowPoints( hWindow, GetParent(hWindow), (LPPOINT)&rDstArea, 2 );
 		if ( !(pdibSrc = lpOffScreen->GetReadOnlyDIB()) )
			return;
		if ( !(pdibDst = lpOffScreen->GetWritableDIB()) )
			return;
		hWinGDC = lpOffScreen->GetDC();
		hWinGPal = hDisplayPal = GetApp()->m_hPal;
	}
	else
	{
		// fix
		HWND hToon = FindClassDescendent(GetParent(hWindow), "toon");
		if (!hToon)
			return;
		pToon = GetToon(hToon);
		if (!pToon)
			return;
		MapWindowPoints( hWindow, pToon->GetWindow(), (LPPOINT)&rDstArea, 2 );
		pdibSrc = pToon->GetStageDib();
		lp = ToonGetDIBPointer(pToon->GetToonHandle(), &bmi);
		ToonGetColors(pToon->GetToonHandle(), 0, 256, rgbQuad);
		bmi.biClrUsed = 256;
		pdibDst = new CDib(&bmi, rgbQuad, lp);
		if (!pdibDst)
			return;
		hWinGDC = ToonDC(pToon->GetToonHandle());
		// to make sure we don't change the system palette
		hDisplayPal = CopySystemPalette();
		// to match WinG dib
		hWinGPal = CreateCustomPalette(rgbQuad, 256);
	}

	if (!pStory->m_fMappedToPalette && ((dwStyle & BS_MASK) == 0))
	{
		pStory->m_pDib->MapToPalette(hWinGPal);
		pStory->m_fMappedToPalette = TRUE;
	}


	// Copy source dib so we can twiddle its bits
	pDib = new CDib();
	if (!pDib)
	{
		if (!lpOffScreen && hDisplayPal)
			DeleteObject(hDisplayPal);
		if (!lpOffScreen && hWinGPal)
			DeleteObject(hWinGPal);
		return;
	}
	if (!pDib->Create(pStory->m_pDib->GetBitCount(),
						lpRect->right-lpRect->left,
						lpRect->bottom-lpRect->top))
	{
		delete pDib;
		if (!lpOffScreen && hDisplayPal)
			DeleteObject(hDisplayPal);
		if (!lpOffScreen && hWinGPal)
			DeleteObject(hWinGPal);
		return;
	}
	pDib->CopyColorTable(pStory->m_pDib);
	// draw in source bitmap
	pStory->m_pDib->DibBlt( pDib,
					0, 0,
				 	rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top,
				 	rSrcArea.left, rSrcArea.top,
				 	rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top,
				 	NO /*bTransparent*/ );
	
	if ( pdibSrc->GetCompression() == BI_RLE8 ||
		 pdibDst->GetCompression() == BI_RLE8)
	{ // compressed DIBs must use GDI copying (lose transparency ability)
		pdibSrc->DCBlt( hWinGDC,
						rDstArea.left, rDstArea.top,
					 	rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
						rDstArea.left, rDstArea.top,
					 	rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top );
	}
	else
	{
		pdibSrc->DibBlt( pdibDst,
						rDstArea.left, rDstArea.top,
					 	rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
					 	rDstArea.left, rDstArea.top,
					 	rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
					 	NO /*bTransparent*/ );
	}

	if ( pDib->GetCompression() == BI_RLE8 ||
		 pdibDst->GetCompression() == BI_RLE8 )
	{ // compressed DIBs must use GDI copying (lose transparency ability)
		pDib->DCBlt( hWinGDC,
					rDstArea.left, rDstArea.top,
					rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
					rSrcArea.left, rSrcArea.top,
					rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top );
	}
	else
	{
		RGBTRIPLE rgb;
		LPRGBTRIPLE lpRGB = NULL;
		if (dwStyle & BS_MASK)
		{
			STRING szColor;
			GetWindowText(hWindow, szColor, sizeof(szColor));
			AsciiRGB( szColor, &rgb );
			if (fHighlight)
			{
				// this relies on the fact that AsciiRGB replaces commas
				// with NULL terminators
				LPTSTR lp = szColor + lstrlen(szColor) + 1; // passed red
				lp += lstrlen(lp) + 1; // passed green
				lp += lstrlen(lp) + 1; // passed blue to higlight color
				AsciiRGB(lp, &rgb);
				rgb.rgbtRed = rgb.rgbtGreen = 0; rgb.rgbtBlue = 255;
			}
			else
				rgb.rgbtRed = rgb.rgbtGreen = rgb.rgbtBlue = 0;
			lpRGB = &rgb;
		}
		else
		{
			BYTE bTrans = *pStory->m_pDib->GetXY(0, 0);
			LPTR lpColor = pStory->m_pDib->GetXY(1, 0);
			LPTR lpHighlight = pStory->m_pDib->GetXY(2, 0); 
			BYTE bColor = *lpColor;
			BYTE bHighlight = *lpHighlight;
			// if highlight color is the transparent color then
			// we are hiding and showing highlighted area
			// if not, then we are changing the color of highlighted area
			if (bHighlight == bTrans)
			{
				// we need to strip off highlight info if we are not
				// highlighted
				if (!fHighlight && (bColor != bTrans))
				{
					HPTR hp = pDib->GetPtr();
					DWORD dwSize = pDib->GetSizeImage();
					while (dwSize)
					{
						if (*hp != bColor)
							*hp = bTrans;
						++hp;
						--dwSize;
					}
				}
			}
			else
			{
				// we need to change the color if we are highlighted
				if (fHighlight && (bColor != bHighlight) && (bColor != bTrans))
				{
					HPTR hp = pDib->GetPtr();
					DWORD dwSize = pDib->GetSizeImage();
					while (dwSize)
					{
						if (*hp == bColor)
							*hp = bHighlight;
						++hp;
						--dwSize;
					}
				}
			}
		}
		pDib->DibBlt( pdibDst,
					rDstArea.left, rDstArea.top,
					rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
					0, 0,
					rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top,
					YES/*bTransparent*/, lpRGB, NULL, hWinGPal );
	}
	delete pDib;

	ptDst.x = rSrcArea.left;
	ptDst.y = rSrcArea.top;
	if (lpOffScreen)
	{
		lpOffScreen->DrawRect( hDC, &rDstArea, &ptDst );
	}
	else
	{
		//if (hDisplayPal)
		//{
		//	hOldPal = SelectPalette(hDC, hDisplayPal, FALSE);
		//	RealizePalette(hDC);
		//}
		//pdibDst->DCBlt( hDC,
		//	ptDst.x, ptDst.y,
		//	rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
		//	rDstArea.left, rDstArea.top,
		//	rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top );
		WinGStretchBlt( hDC,
			ptDst.x, ptDst.y,
			rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
			hWinGDC,
			rDstArea.left, rDstArea.top,
			rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top );
		//if (hDisplayPal)
	    //{
		//	SelectPalette(hDC, hOldPal, TRUE);
	   	//	DeleteObject(hDisplayPal);
		//}
		if (hWinGPal)
			DeleteObject(hWinGPal);
	}
}
Example #5
0
LRESULT WINAPI
DefDlgProc(HWND hDlg, UINT iMessage, WPARAM wParam, LPARAM lParam)
{
    DLGPROC	f;
    LRESULT	rc;
    HBRUSH	hBrush;
    HFONT   hFont;
    RECT rcClient;
    HWND hWndChild, hWndFocus;
    DWORD dwStyle;
    WORD wTmp;
    HCLASS32 hDialog32;

    APISTR((LF_APICALL,"DefDlgProc(HWND=%x,UINT=%x,WPARAM=%x,LPARAM=%lx)\n",
            hDlg,iMessage,wParam,lParam));

    if (!IsWindow(hDlg)) {
        APISTR((LF_APIFAIL,"DefDlgProc: returns LRESULT 0\n"));
        return 0L;
    }

    if (iMessage == WM_CONVERT) {
        if (!lpDialogBinToNat) {
            hDialog32 = FindClass(TWIN_DIALOGCLASS,(HINSTANCE)0);
            lpDialogBinToNat = (WNDPROC)GetClassHandleLong(
                                   hDialog32,GCL_BINTONAT);
        }
        if (lpDialogBinToNat) {
            rc = lpDialogBinToNat(hDlg,iMessage,wParam,lParam);
            APISTR((LF_APIRET,"DefDlgProc: returns LRESULT %x\n",rc));
            return rc;
        } else {
            APISTR((LF_APIFAIL,"DefDlgProc: returns LRESULT 0\n"));
            return (LRESULT)0;
        }
    }

    if ( (f = (DLGPROC) GetWindowLong(hDlg,DWL_DLGPROC)) ) {
        rc = CallWindowProc(
#ifdef	STRICT
                 (WNDPROC)f,
#else
                 (FARPROC)f,
#endif
                 hDlg,iMessage,wParam,lParam);
    }
    else  rc = 0L;

    if (!IsWindow(hDlg)) {	/* dialog has been destroyed in the callback */
        APISTR((LF_APIRET,"DefDlgProc: returns LRESULT %x\n",rc));
        return rc;
    }

    if(LOWORD(rc) == 0) {
        switch(iMessage) {
        case WM_ERASEBKGND:
            GetClientRect(hDlg, &rcClient);
            hBrush = (HBRUSH)SendMessage(hDlg,
                                         GET_WM_CTLCOLOR_MSG(CTLCOLOR_DLG),
                                         GET_WM_CTLCOLOR_MPS(
                                             (HDC)wParam,hDlg,CTLCOLOR_DLG));
            FillRect((HDC)wParam,&rcClient,hBrush);
            APISTR((LF_APIRET,"DefDlgProc: returns LRESULT 1\n"));
            return (LRESULT)1;

        case WM_SHOWWINDOW:
            /* if we are hiding, save the focus */
            if (!wParam)
                SaveDlgFocus(hDlg);
            rc =  DefWindowProc(hDlg,iMessage,wParam,lParam);
            APISTR((LF_APIRET,"DefDlgProc: returns LRESULT %x\n",rc));
            return rc;

        case WM_SYSCOMMAND:
            if ((wParam & 0xfff0) == SC_MINIMIZE)
                SaveDlgFocus(hDlg);

            rc = DefWindowProc(hDlg,iMessage,wParam,lParam);
            APISTR((LF_APIRET,"DefDlgProc: returns LRESULT %x\n",rc));
            return rc;

        case WM_ACTIVATE:
            if GET_WM_ACTIVATE_STATE(wParam,lParam)
                RestoreDlgFocus(hDlg);
            else
                SaveDlgFocus(hDlg);
            break;

        case WM_SETFOCUS:
            if (!RestoreDlgFocus(hDlg))
                DlgSetFocus(GetFirstDlgTabItem(hDlg));
            break;

        case WM_CLOSE:
            hWndChild = GetDlgItem(hDlg, IDCANCEL);
            if (hWndChild) {
                dwStyle = GetWindowLong(hDlg,GWL_STYLE);
                if (dwStyle & WS_DISABLED) {
                    MessageBeep(0);
                } else
                    PostMessage(hDlg,WM_COMMAND,
                                GET_WM_COMMAND_MPS(IDCANCEL,
                                                   hWndChild,BN_CLICKED));
            }
            break;

        case WM_NCDESTROY:
            SetWindowWord(hDlg,DWW_STATUS,1);
            if ((hFont = (HFONT)GetWindowWord(hDlg, DWW_HFONT))) {
                DeleteObject(hFont);
                SetWindowWord(hDlg,DWW_HFONT,0);
            }
            DefWindowProc(hDlg,iMessage,wParam,lParam);
            break;

        case DM_SETDEFID:
            SetWindowWord(hDlg,DWW_DEFID,wParam);
            APISTR((LF_APIRET,"DefDlgProc: returns LRESULT 1\n"));
            return (LRESULT)1;

        case DM_GETDEFID:
            wTmp = GetWindowWord(hDlg,DWW_DEFID);
            if (wTmp) {
                rc = MAKELRESULT(wTmp, DC_HASDEFID);
                APISTR((LF_APIRET,"DefDlgProc: returns LRESULT %x\n",rc));
                return rc;
            } else {
                APISTR((LF_APIRET,"DefDlgProc: returns LRESULT 0\n"));
                return (LRESULT)0;
            }

        case WM_NEXTDLGCTL:
            hWndFocus = GetFocus();
            if (LOWORD(lParam)) {
                if (!hWndFocus)
                    hWndFocus = hDlg;
                hWndChild = (HWND)wParam;
            }
            else {
                if (!hWndFocus) {
                    /* set to the first tab item */
                    hWndChild = GetFirstDlgTabItem(hDlg);
                    hWndFocus = hDlg;
                }
                else {
                    if (!IsChild(hDlg,hWndFocus))
                        return (LRESULT)1;
                    hWndChild = GetNextDlgTabItem(hDlg,
                                                  hWndFocus,(BOOL)wParam);
                }
            }

            DlgSetFocus(hWndChild);
            CheckDefPushButton(hDlg,hWndFocus,hWndChild);

            APISTR((LF_APIRET,"DefDlgProc: returns LRESULT 1\n"));
            return (LRESULT)1;

        case WM_GETFONT:
            rc = (LRESULT)GetWindowWord(hDlg,DWW_HFONT);
            APISTR((LF_APIRET,"DefDlgProc: returns LRESULT %x\n",rc));
            return rc;

        case WM_SETFONT:
            SetWindowWord(hDlg,DWW_HFONT,(HFONT)wParam);
            if (LOWORD(lParam))
                InvalidateRect(hDlg,NULL,TRUE);
            APISTR((LF_APIRET,"DefDlgProc: returns LRESULT %x\n",0));
            return 0L;

        case WM_VKEYTOITEM:
        case WM_COMPAREITEM:
        case WM_CHARTOITEM:
        case WM_INITDIALOG:
            break;

        case WM_MOUSEACTIVATE:

            rc = (LRESULT)MA_ACTIVATE;
            if ((int)(short)LOWORD(lParam) == HTCAPTION)
                rc = (LRESULT)MA_NOACTIVATE;
            APISTR((LF_APIRET,"DefDlgProc: returns LRESULT %x\n",rc));
            return rc;

#ifdef	TWIN32
        case WM_CTLCOLORMSGBOX:
        case WM_CTLCOLORBTN:
        case WM_CTLCOLORDLG:
        case WM_CTLCOLORSTATIC:
            rc =  GetStockObject(LTGRAY_BRUSH);
            APISTR((LF_APIRET,"DefDlgProc: returns LRESULT %x\n",rc));
            return rc;
#endif
        default:
            rc = DefWindowProc(hDlg,iMessage,wParam,lParam);
            APISTR((LF_APIRET,"DefDlgProc: returns LRESULT %x\n",rc));
            return rc;
        }
    }
Example #6
0
//***********************************************************************
void CJungleScene::HandlePuzzle1Buttons( HWND hWnd, ITEMID id )
//***********************************************************************
{
	int iSndID = GetWindowWord( GetDlgItem(hWnd, id), GWW_ICONID );
	if ( !iSndID )
		iSndID = id;

	// Get the current shot info from the video
	LPVIDEO lpVideo = (LPVIDEO)GetWindowLong( GetDlgItem(hWnd, IDC_VIDEO_GAME), GWL_DATAPTR );
	if ( !lpVideo)
		return;
	LPSHOT lpShot =  &lpVideo->lpAllShots [lpVideo->lCurrentShot - 1];
	if (!lpShot)
		return;

	// Extract the shot number
	int iShotNum = (int)(lpShot->lFlags & A_VALUE_BITS);
	// How many items in the list?
	int nItems = sizeof(m_PuzzleInfo) / sizeof(VRECOINFO);
	// Get the index of the item matching the shot
	for ( int idx = 0; idx < nItems; idx++ )
	{
		if ( iShotNum == m_PuzzleInfo[idx].iShotNum )
			break;
	}

	if ( idx == nItems )
		return; // Couldn't find the shot in the list

	int iNxtSyllable = m_PuzzleInfo[idx].iSyllables[nMatches];
	int iNumSyllables = m_PuzzleInfo[idx].sNumSyllables;

	// Does the button match the next syllable?
	if (iSndID == iNxtSyllable)
	{
//		int iState = GetWindowWord( GetDlgItem(hWnd, id), GWW_STATE );
//		SendMessage( GetDlgItem(hWnd, id), SM_SETSTATE, !iState, 0L);
		SendMessage( GetDlgItem(hWnd, id), SM_SETSTATE, 1, 0L);

		// Give them instinct points
		ChangeInstinctMeter (hWnd, GOOD_RESPONSE);
		// Set progress meter
		nMatches++;
		long lProgress = (METER_MAX * nMatches) / (long)iNumSyllables;
		SendMessage( GetDlgItem(hWnd, IDC_PUZ_PROGRESS), SM_SETPOSITION, 0, lProgress );
		// Is this the last syllable?
		if (nMatches >= iNumSyllables)
		{
			// Delay so the progress meter is shown
			Delay( 1500 );
			// Simulate an EVENT_DOWN (good response) to the video control
			FORWARD_WM_KEYDOWN (GetDlgItem(hWnd, IDC_VIDEO_GAME), VK_DOWN,
				0/*cRepeat*/, 0/*flags*/, SendMessage);
		}
		return;
	}

	// It is not a match

	// Take instinct points away
	ChangeInstinctMeter (hWnd, BAD_RESPONSE);

//	// Simulate a wrong button pressed
//	FORWARD_WM_KEYDOWN (GetDlgItem(hWnd, IDC_VIDEO_GAME), VK_UP,
//		0/*cRepeat*/, 0/*flags*/, SendMessage);
}
Example #7
0
/****************************************************************************
 *                                                                          *
 *  FUNCTION   : DdeCallback()                                              *
 *                                                                          *
 *  PURPOSE    : This handles all callbacks from the DDEML.  This handles   *
 *               updating of the associated conversation and any special    *
 *               testing cases such as blocking callbacks etc.              *
 *                                                                          *
 *               For the most part, clients only handle advise data and     *
 *               asynchronous transaction completion here.                  *
 *                                                                          *
 *  RETURNS    : Results vary depending on transaction type.                *
 *                                                                          *
 ****************************************************************************/
HDDEDATA EXPENTRY DdeCallback(
WORD wType,
WORD wFmt,
HCONV hConv,
HSZ hsz1,
HSZ hsz2,
HDDEDATA hData,
DWORD lData1,
DWORD lData2)
{
    HWND hwnd;
    CONVINFO ci;
    XACT *pxact;

    if (hConv) {
        /*
         * update conversation status if it changed.
         */
        MYCONVINFO *pmci;
        
        ci.cb = sizeof(CONVINFO);
	if (!DdeQueryConvInfo(hConv,(DWORD) QID_SYNC, &ci) || (!IsWindow((HWND)ci.hUser))) {
            /*
             * This conversation does not yet have a corresponding MDI window
             * or is disconnected.
             */
            return 0;
        }
        if (pmci = (MYCONVINFO *)GetWindowWord((HWND)ci.hUser, 0)) {
            if (pmci->ci.wStatus != ci.wStatus ||
                    pmci->ci.wConvst != ci.wConvst ||
                    pmci->ci.wLastError != ci.wLastError) {
                /*
                 * Things have changed, updated the conversation window.
                 */
                InvalidateRect((HWND)ci.hUser, NULL, TRUE);
            }
            if (ci.wConvst & ST_INLIST) {
                /*
                 * update the associated list window (if any) as well.
                 */
                if (hwnd = FindListWindow(ci.hConvList))
                    InvalidateRect(hwnd, NULL, TRUE);
            }
        }
    }

    /*
     * handle special block on next callback option here.  This demonstrates
     * the CBR_BLOCK feature.
     */
    if (fBlockNextCB && !(wType & XTYPF_NOBLOCK)) {
        fBlockNextCB = FALSE;
        return(CBR_BLOCK);
    }

    /*
     * handle special termination here.  This demonstrates that at any time
     * a client can drop a conversation.
     */
    if (fTermNextCB && hConv && wType != XTYP_DISCONNECT) {
        fTermNextCB = FALSE;
        MyDisconnect(hConv);
        return(0);
    }

    /*
     * Now we begin sort out what to do.
     */
    switch (wType) {
    case XTYP_REGISTER:
    case XTYP_UNREGISTER:
        /*
         * This is where the client would insert code to keep track of
         * what servers are available.  This could cause the initiation
         * of some conversations.
         */
        break;

    case XTYP_DISCONNECT:
        if (fAutoReconnect) {
            /*
             * attempt a reconnection
             */
            if (hConv = DdeReconnect(hConv)) {
                AddConv(ci.hszServiceReq, ci.hszTopic, hConv, FALSE);
                return 0;
            }
        }
        
        /*
         * update conv window to show its new state.
         */
        SendMessage((HWND)ci.hUser, UM_DISCONNECTED, 0, 0);
        return 0;
        break;

    case XTYP_ADVDATA:
        /*
         * data from an active advise loop (from a server)
         */
        Delay(wDelay);
        hwnd = FindAdviseChild((HWND)ci.hUser, hsz2, wFmt);
        if (!IsWindow(hwnd)) {
            PSTR pszItem, pszFmt;
            /*
             * AdviseStart window is gone, make a new one.
             */
            pxact = (XACT *)MyAlloc(sizeof(XACT));
            pxact->wType = wType;
            pxact->hConv = hConv;
            pxact->wFmt = wFmt;
            pxact->hszItem = hsz2;
            DdeKeepStringHandle(idInst, hsz2);
            
            pszItem = GetHSZName(hsz2);
            pszFmt = GetFormatName(wFmt);
            
            hwnd = CreateInfoCtrl(NULL, 
                    (int)SendMessage((HWND)ci.hUser, UM_GETNEXTCHILDX, 0, 0L),
                    (int)SendMessage((HWND)ci.hUser, UM_GETNEXTCHILDY, 0, 0L),
                    200, 100,
                    (HWND)ci.hUser, hInst,
                    Type2String(wType, 0), (LPSTR)pszItem, NULL,
                    NULL, (LPSTR)pszFmt, NULL,
                    ICSTY_SHOWFOCUS, 0, (DWORD)(LPSTR)pxact);
                    
            MyFree(pszFmt);
            MyFree(pszItem);

            if (!IsWindow(hwnd))
                return(DDE_FNOTPROCESSED); 
        }
        if (!hData) {
            /*
             * XTYPF_NODATA case - request the info. (we do this synchronously
             * for simplicity)
             */
            hData = DdeClientTransaction(NULL, 0L, hConv, hsz2, wFmt,
                    XTYP_REQUEST, DefTimeout, NULL);
        }
        if (hData) {
            PSTR pData;
            /*
             * Show incomming data on corresponding transaction window.
             */
            pData = GetTextData(hData);
            SendMessage(hwnd, ICM_SETSTRING, ICSID_CENTER, (DWORD)(LPSTR)pData);
            MyFree(pData);
            DdeFreeDataHandle(hData);
        }
        SendMessage(hwnd, ICM_SETSTRING, ICSID_LL, (DWORD)(LPSTR)"Advised");
        return(DDE_FACK);
        break;
        
    case XTYP_XACT_COMPLETE:
        /*
         * An asynchronous transaction has completed.  Show the results.
         *
         * ...unless the XOPT_BLOCKRESULT is chosen.
         */
        
        ci.cb = sizeof(CONVINFO);
        if (DdeQueryConvInfo(hConv, lData1, &ci) &&
                IsWindow((HWND)ci.hUser) && 
                (pxact = (XACT *)GetWindowWord((HWND)ci.hUser, GWW_WUSER))) {
                
            if (pxact->fsOptions & XOPT_BLOCKRESULT) {
                pxact->fsOptions &= ~XOPT_BLOCKRESULT;
                return(CBR_BLOCK);
            }
            
            pxact->Result = lData2;
            pxact->ret = hData;
            CompleteTransaction((HWND)ci.hUser, pxact);
        }
        break;
    }
}
Example #8
0
/*
 * StartUpDriver - the main message handling loop
 */
long __export FAR PASCAL StartUpDriver( HWND hwnd, UINT message,
                                WPARAM wparam, LPARAM lparam )
{
    FARPROC     farproc;
    HWND        tmpw;
    int         len;
    char        data[_MAX_PATH];
    char        tmp[80 + _MAX_PATH];
    HINSTANCE   inst;

    switch( message ) {
    case WM_DESTROY:
        PostQuitMessage( 0 );
        break;

    case WM_COMMAND:
        switch( wparam ) {
        case MSG_ABOUT:
            inst = (HINSTANCE)GetWindowWord( hwnd, GWW_HINSTANCE );
            farproc = MakeProcInstance( (FARPROC)About2, inst );
            DialogBox( inst, ResName( "AboutBox" ), hwnd, (DLGPROC)farproc );
            FreeProcInstance( farproc );
            SetFocus( editChild );
            break;

        case PUSH_GETFILES_ID:
        case MSG_GETFILES:
            data[0] = 0;
            if( getFile( data ) ) {
                GetWindowText( editChild, tmp, sizeof( tmp ) );
                strcat( tmp, data );
                SetWindowText( editChild, tmp );
            }
            SetFocus( editChild );
            break;

        case PUSH_OK_ID:
        case SELECT_ID:
            len = GetWindowTextLength( editChild ) + 1;
            if( len > _MAX_PATH )
                len = _MAX_PATH;
            GetWindowText( editChild, dataPtr, len );
            canContinue = TRUE;
            tmpw = GetParent( editChild );
            SetWindowLong( editChild, GWL_WNDPROC, (LONG) oldClassProc );
            /* fall through, like exit was picked */

        case MSG_EXIT:
            DestroyWindow( mainWindow );
            PostQuitMessage( 0 );
            break;

        } /* switch */
        break;

    default:
        return( DefWindowProc(hwnd,message,wparam,lparam) );

    } /* switch */
    return( 0L );

} /* StartUpDriver */
Example #9
0
/****************************************************************************
 *                                                                          *
 * Function: HypCtrlWndProc                                                 *
 *                                                                          *
 * Purpose : Process Hyperlink control messages.                            *
 *                                                                          *
 * History : Date      Reason                                               *
 *           00/00/00  Created                                              *
 *                                                                          *
 ****************************************************************************/
static LRESULT CALLBACK HypCtrlWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg){
		case WM_LBUTTONUP: {
			HYPCTRL* pHcWnd = (HYPCTRL*) GetWindowLong(hWnd, WND_HYPSTRUCT);

			if (pHcWnd->bPlaySound) PlayNavigatingSound();
		
			if (pHcWnd->cbFn != NULL) {
				// call user function (callback)
				pHcWnd->cbFn(pHcWnd->cbID);
			} else {
				// jump to link
				ShellExecute(NULL, _T("open"), pHcWnd->szLink, NULL, NULL, SW_SHOW);
			}
			return FALSE;
		}
		case WM_PAINT: {
			PAINTSTRUCT ps;
			HDC hdc;
			RECT rect;

			HYPCTRL* pHcWnd     = (HYPCTRL*) GetWindowLong(hWnd, WND_HYPSTRUCT);
			BOOL bIsOverControl = (BOOL) GetWindowWord(hWnd, WND_ISHOVER);

			rect.left	= (LONG) GetWindowLong(hWnd, WND_LEFT);
			rect.top	= (LONG) GetWindowLong(hWnd, WND_TOP);
			rect.right	= (LONG) GetWindowLong(hWnd, WND_RIGHT);
			rect.bottom	= (LONG) GetWindowLong(hWnd, WND_BOTTOM);

			hdc = BeginPaint(hWnd, &ps);

			if (bIsOverControl) {
				// draws hover state
     		    SetBkColor(hdc, (COLORREF) pHcWnd->bgcHover);
				SelectObject(hdc, (HFONT) GetWindowLong(hWnd, WND_FONTH));
				SetTextColor(hdc, pHcWnd->fgcHover);
			} else {
				// draws normal state
       		    SetBkColor(hdc, (COLORREF) pHcWnd->bgcNormal);
				SelectObject(hdc, (HFONT) GetWindowLong(hWnd, WND_FONTN));
				SetTextColor(hdc, pHcWnd->fgcNormal);
			}
			// draw the text
			DrawText(hdc, pHcWnd->szText, -1, &rect, pHcWnd->dtStyle);
            
			EndPaint(hWnd, &ps);
			return FALSE;
		}
		case WM_CAPTURECHANGED:
			SetWindowWord(hWnd, WND_ISHOVER, (WORD) FALSE);
			InvalidateRect(hWnd, NULL, TRUE);
			return FALSE;
		case WM_MOUSEMOVE: {
			RECT rect;

			rect.left	= (LONG) GetWindowLong(hWnd, WND_LEFT);
			rect.top	= (LONG) GetWindowLong(hWnd, WND_TOP);
			rect.right	= (LONG) GetWindowLong(hWnd, WND_RIGHT);
			rect.bottom	= (LONG) GetWindowLong(hWnd, WND_BOTTOM);
			
			// check if mouse is over control
			if ((BOOL) GetWindowWord(hWnd, WND_ISHOVER)) {
				POINT ptMousePos;
				DWORD dwMousePos;

				dwMousePos = GetMessagePos();

				ptMousePos.x = LOWORD(dwMousePos);
				ptMousePos.y = HIWORD(dwMousePos);

				ScreenToClient(hWnd, &ptMousePos);

				if (!(BOOL) PtInRect(&rect, ptMousePos)) {
					SetWindowWord(hWnd, WND_ISHOVER, (WORD) FALSE);
					InvalidateRect(hWnd, &rect, TRUE);
				   	ReleaseCapture();
				}
			} else {
				SetWindowWord(hWnd, WND_ISHOVER, (WORD) TRUE);
				InvalidateRect(hWnd, &rect, TRUE);
				SetCapture(hWnd);
			}
			return FALSE;
		}
		case WM_CLOSE: {
			HYPCTRL* pHcWnd = (HYPCTRL*) GetWindowLong(hWnd, WND_HYPSTRUCT);
			HFONT hFontTemp;

			// clean up
			if (pHcWnd->szLink) GlobalFreePtr(pHcWnd->szLink);
			if (pHcWnd->szText) GlobalFreePtr(pHcWnd->szText);
			if (pHcWnd->szTooltip) GlobalFreePtr(pHcWnd->szTooltip);
			if (pHcWnd->cbFn) GlobalFreePtr(pHcWnd->cbFn);
			
			hFontTemp = (HFONT) GetWindowLong(hWnd, WND_FONTN);
			if (hFontTemp) DeleteObject(hFontTemp);

			hFontTemp = (HFONT) GetWindowLong(hWnd, WND_FONTH);
			if (hFontTemp) DeleteObject(hFontTemp);

			if (pHcWnd) GlobalFreePtr(pHcWnd);
			DestroyWindow(hWnd);
			return FALSE;
		}
	}
	return DefWindowProc(hWnd, msg, wParam, lParam);
}
Example #10
0
LOCAL void Slider_Paint (HWND hWindow, HDC hDC, LPRECT lpRect, BOOL fHighlight)
/***********************************************************************/
{
	BOOL	bHasFocus, bSelected, bDown;
	DWORD	dwStyle;
	RECT	rSrcArea, rDstArea;
	POINT	ptDst;
	UINT	id;
	PDIB	pdibSrc, pdibDst;
	HDC		hWinGDC;

	LPHSLIDERINFO lpInfo;
	if (! (lpInfo = (LPHSLIDERINFO)GetWindowLong (hWindow, GWL_DATAPTR) ) )
		return;

	rSrcArea = *lpRect;
	rDstArea = *lpRect;
	MapWindowPoints (hWindow, GetParent(hWindow), (LPPOINT)& rDstArea, 2 );

	LPSCENE lpScene = CScene::GetScene (GetParent (hWindow) );
	if (! lpScene)
		return;

	if ( !lpScene->GetDIBs( &pdibSrc, &pdibDst, &hWinGDC ) )
		return;
	if ( !pdibSrc || !pdibDst || !hWinGDC )
		return;

	bSelected = GetWindowWord (hWindow, GWW_STATE);
	dwStyle = GetWindowStyle(hWindow);
	bHasFocus = (GetFocus () == hWindow);
	bDown = ( bSelected || (lpInfo->bTrack && lpInfo->bInRect && bHasFocus) );

	// Repair the dirty bitmap with the clean bitmap
	if ( pdibSrc->GetCompression() == BI_RLE8 ||
		 pdibDst->GetCompression() == BI_RLE8)
	{ // compressed DIBs must use GDI copying (lose transparency ability)
		pdibSrc->DCBlt( hWinGDC,
						rDstArea.left, rDstArea.top,
						rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
						rDstArea.left, rDstArea.top,
						rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top );
	}
	else
	{
		pdibSrc->DibBlt( pdibDst,
						rDstArea.left, rDstArea.top,
						rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
						rDstArea.left, rDstArea.top,
						rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
						NO /*bTransparent*/ );
	}

	// Draw the slider background
	RECT rSlider = lpInfo->rSlider;
	RECT rInner = lpInfo->rSlider;
	rInner.top = lpInfo->iCenter - (lpInfo->iTrackWidth / 2);
	rInner.bottom = lpInfo->iCenter + (lpInfo->iTrackWidth / 2);
	MapWindowPoints (hWindow, GetParent(hWindow), (LPPOINT)& rSlider, 2);
	MapWindowPoints (hWindow, GetParent(hWindow), (LPPOINT)& rInner, 2);

	// Turn off tick painting because using background bitmap
	#ifdef UNUSED
	HBRUSH hBrush = CreateSolidBrush (lpInfo->rgbBackgnd);
	HBRUSH hBrush2 = (HBRUSH)GetStockObject (BLACK_BRUSH);

	FillRect (hWinGDC, & rSlider, hBrush);
	FillRect (hWinGDC, & rInner, hBrush2);
	DeleteObject (hBrush);
	#endif

	RECT	rClient;
	GetClientRect (hWindow, & rClient);
	MapWindowPoints (hWindow, GetParent(hWindow), (LPPOINT)& rClient, 2 );

	// Turn off tick painting because using background bitmap
	#ifdef UNUSED
	// Draw a chiselled border
	RECT	rBorder = rClient;
	InflateRect (& rBorder, 1, 1);
	int cxButton = rBorder.right - rBorder.left;
	int cyButton = rBorder.bottom - rBorder.top;			   
	HPEN hLitePen = CreatePen (PS_SOLID, 1, RGB (255, 255, 255));
	HPEN hDarkPen = CreatePen (PS_SOLID, 1, RGB (128, 128, 128));
	HPEN hOldPen = (HPEN)SelectObject (hWinGDC, hLitePen);

	MoveToEx (hWinGDC, rBorder.left, rBorder.bottom - 1, NULL);
	LineTo (hWinGDC, rBorder.left, rBorder.top);
	LineTo (hWinGDC, rBorder.right - 1, rBorder.top);
	
	MoveToEx (hWinGDC, rBorder.left + 1, rBorder.bottom - 2, NULL);
	LineTo (hWinGDC, rBorder.left + 1, rBorder.top + 1);
	LineTo (hWinGDC, rBorder.right - 2, rBorder.top + 1);
	
	SelectObject (hWinGDC, hDarkPen);
	MoveToEx (hWinGDC, rBorder.right - 1, rBorder.top, NULL);
	LineTo (hWinGDC, rBorder.right - 1, rBorder.bottom - 1);
	LineTo (hWinGDC, rBorder.left, rBorder.bottom - 1);
	
	MoveToEx (hWinGDC, rBorder.right - 2, rBorder.top + 1, NULL);
	LineTo (hWinGDC, rBorder.right - 2, rBorder.bottom - 2);
	LineTo (hWinGDC, rBorder.left + 1, rBorder.bottom - 2);

	SelectObject (hWinGDC, hOldPen);
	DeleteObject (hLitePen);
	DeleteObject (hDarkPen);

	// If tick-marks are wanted
	if (lpInfo->iTicks)
	{
		int pw = 2; // pen width
		HPEN hTickPen = CreatePen (PS_SOLID, pw, lpInfo->rgbBackgnd);
		hOldPen = (HPEN)SelectObject (hWinGDC, hTickPen);

		int iBmpWidth = lpInfo->rBitmap.right - lpInfo->rBitmap.left;
		int wx = rClient.right - rClient.left - iBmpWidth;
		int dx = wx / lpInfo->iTicks;
		wx = wx - (dx * lpInfo->iTicks) - pw;
		int x = rClient.left + (iBmpWidth + wx + pw) / 2; // wx is now the excess
		int y1 = rClient.top + 2;
		int y2 = y1 + 10;
		for (int idx = 0; idx <= lpInfo->iTicks ; idx++)
		{
			MoveToEx (hWinGDC, x, y1, NULL);
			LineTo (hWinGDC, x, y2);
			x += dx;
		}
		SelectObject (hWinGDC, hOldPen);
		DeleteObject (hTickPen);
	}
	#endif

	rSrcArea = lpInfo->rBitmap;
	rDstArea = lpInfo->rBitmap;
	MapWindowPoints (hWindow, GetParent(hWindow), (LPPOINT)& rDstArea, 2 );

	// Get the control ID to load the bitmap resource
	if (! (id = GetWindowWord (hWindow, GWW_ICONID) ) )
		id = GET_WINDOW_ID (hWindow);

	if (pdibSrc = CDib::LoadDibFromResource (GetWindowInstance (hWindow),
		MAKEINTRESOURCE(id), GetApp()->m_hPal, (dwStyle & BS_MASK) != 0 ))
	{ // Load the resource
		if ( pdibSrc->GetCompression() == BI_RLE8 ||
			 pdibDst->GetCompression() == BI_RLE8 )
		{ // compressed DIBs must use GDI copying (lose transparency ability)
			pdibSrc->DCBlt( hWinGDC,
						rDstArea.left, rDstArea.top,
						rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
						rSrcArea.left, rSrcArea.top,
						rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top );
		}
		else
		{
			RGBTRIPLE rgb;
			LPRGBTRIPLE lpRGB = NULL;
			if (dwStyle & BS_MASK)
			{
				STRING szColor;
				GetWindowText(hWindow, szColor, sizeof(szColor));
				AsciiRGB( szColor, &rgb );
				lpRGB = &rgb;
			}
			if (dwStyle & BS_HIGHLIGHT)
			{
				// Get the transparency color
				BYTE bTrans = *pdibSrc->GetXY(0, 0);

				// Get the color to replace
				LPTR lpColor = pdibSrc->GetXY(1, 0);
				BYTE bColor = *lpColor;
				*lpColor = bTrans;

				// Get the hightlight color
				LPTR lpHighlight = pdibSrc->GetXY(2, 0); 
				BYTE bHighlight = *lpHighlight;
				*lpHighlight = bTrans;

				// Replace the pixels in the DIB
				if (bDown && (bColor != bHighlight))
				{
					HPTR hp = pdibSrc->GetPtr();
					DWORD dwSize = pdibSrc->GetSizeImage();
					while ( dwSize-- )
					{
						if (*hp == bColor)
							*hp = bHighlight;
						++hp;
					}
				}
			}

			// Set slider position if needed
			if (lpInfo->Position)
			{
				int iBmpWidth = lpInfo->rBitmap.right - lpInfo->rBitmap.left;
				int iWidth = rClient.right - rClient.left - iBmpWidth;
				int x = (int)(((long)(lpInfo->Position - lpInfo->Min) * iWidth) / (lpInfo->Max - lpInfo->Min));
				rDstArea.left += x;
				if (rDstArea.left < rClient.left)
					rDstArea.left = rClient.left;
				else
				if (rDstArea.left + iBmpWidth > rClient.right)
					rDstArea.left = rClient.right - iBmpWidth;
				rDstArea.right = rDstArea.left + iBmpWidth;
			}

			pdibSrc->DibBlt( pdibDst,
						rDstArea.left, rDstArea.top,
						rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
						rSrcArea.left, rSrcArea.top,
						rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top,
						(dwStyle & BS_TRANSPARENT) != 0 /*bTransparent*/, lpRGB );
		}
		delete pdibSrc;
	}

	ptDst.x = rSrcArea.left;
	ptDst.y = rSrcArea.top;
	if (lpScene)
		lpScene->Paint( hDC, &rClient, &ptDst );
}