home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Programmer's Library 1.3 / Microsoft-Programers-Library-v1.3.iso / sampcode / msj / msjv5_2 / clipbrd / viewer2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-03-01  |  12.2 KB  |  416 lines
  1. /*
  2.  * WINDOWS CLIPBOARD VIEWER - STATUS & CLIENT WINDOW SOURCE CODE
  3.  *
  4.  * LANGUAGE      : Microsoft C 5.1
  5.  * MODEL         : medium
  6.  * ENVIRONMENT   : Microsoft Windows 2.1 SDK
  7.  * STATUS        : operational
  8.  *
  9.  * Note that both the client and status windows save the current
  10.  * clipboard format and data handle.  In general this is NOT good
  11.  * programming practice.  In this situation we assume that we will
  12.  * always be notifed when ANY change occurs to the clipboard.
  13.  *
  14.  * 1.01 - Kevin P. Welch - add param to GetClipboardFmtName.
  15.  *
  16.  */
  17.  
  18. #define  NOCOMM
  19.  
  20. #include <windows.h>
  21. #include <string.h>
  22. #include <stdio.h>
  23.  
  24. #include "viewer.h"
  25.  
  26. /* client window properties */
  27. #define  CLIENT_FORMAT     MAKEINTRESOURCE(1)
  28. #define  CLIENT_MODULE     MAKEINTRESOURCE(2)
  29. #define  CLIENT_DISPINFO   MAKEINTRESOURCE(3)
  30.  
  31. /* status window properties */
  32. #define  STATUS_DATA       MAKEINTRESOURCE(1)
  33. #define  STATUS_FORMAT     MAKEINTRESOURCE(2)
  34. #define  STATUS_DISPFONT   MAKEINTRESOURCE(3)
  35.  
  36. /*
  37.  * StatusWndFn( hWnd, wMsg, wParam, lParam ) : LONG
  38.  *
  39.  *    hWnd       window handle
  40.  *    wMsg       message number
  41.  *    wParam     additional message information
  42.  *    lParam     additional message information
  43.  *
  44.  * This window function processes all the messages related to
  45.  * the status child window of the clipboard viewer.
  46.  *
  47.  */
  48.  
  49. LONG FAR PASCAL StatusWndFn( hWnd, wMsg, wParam, lParam )
  50.    HWND        hWnd;
  51.    WORD        wMsg;
  52.    WORD        wParam;
  53.    LONG        lParam;
  54. {
  55.    LONG        lResult;
  56.  
  57.    /* initialization */
  58.    lResult = FALSE;
  59.  
  60.    /* process each message */
  61.    switch( wMsg )
  62.       {
  63.  case WM_CREATE : /* window being created */
  64.    {
  65.      HDC         hDC;
  66.      LOGFONT     LogFont;
  67.      TEXTMETRIC  TextMetric;
  68.  
  69.      /* retrieve system font metrics */
  70.      hDC = GetDC( hWnd );
  71.      GetTextMetrics( hDC, &TextMetric );
  72.      ReleaseDC( hWnd, hDC );
  73.  
  74.      /* define display font */
  75.      LogFont.lfHeight = TextMetric.tmHeight;
  76.      LogFont.lfWidth = TextMetric.tmAveCharWidth;
  77.      LogFont.lfEscapement = 0;
  78.      LogFont.lfOrientation = 0;
  79.      LogFont.lfWeight = FW_MEDIUM;
  80.      LogFont.lfItalic = FALSE;
  81.      LogFont.lfUnderline = FALSE;
  82.      LogFont.lfStrikeOut = FALSE;
  83.      LogFont.lfCharSet = ANSI_CHARSET;
  84.      LogFont.lfOutPrecision = OUT_STROKE_PRECIS;
  85.      LogFont.lfClipPrecision = CLIP_STROKE_PRECIS;
  86.      LogFont.lfQuality = PROOF_QUALITY;
  87.      LogFont.lfPitchAndFamily = DEFAULT_PITCH|FF_MODERN;
  88.  
  89.      strcpy( LogFont.lfFaceName, "Helv" );
  90.  
  91.      /* define property lists */
  92.      SetProp( hWnd, STATUS_DATA, NULL );
  93.      SetProp( hWnd, STATUS_FORMAT, NULL );
  94.      SetProp( hWnd, STATUS_DISPFONT, CreateFontIndirect(&LogFont) );
  95.  
  96.    }
  97.    break;
  98.  case WM_UPDATE : /* update command from parent */
  99.  
  100.    /* update property lists */
  101.    SetProp( hWnd, STATUS_DATA, LOWORD(lParam) );
  102.    SetProp( hWnd, STATUS_FORMAT, wParam );
  103.  
  104.    /* force update of window */
  105.    InvalidateRect( hWnd, NULL, TRUE );
  106.  
  107.    break;
  108.  case WM_PAINT : /* paint window */
  109.    {
  110.      PAINTSTRUCT   Ps;
  111.      WORD          wCrntFmt;
  112.      HFONT         hOldFont;
  113.      RECT          rcClient;
  114.      HANDLE        hCrntData;
  115.      TEXTMETRIC    TextMetric;
  116.      char          szFmtSize[32];
  117.      char          szFmtName[80];
  118.      char          szFmtOwner[80];
  119.  
  120.      /* retrieve property list data */
  121.      hCrntData = GetProp( hWnd, STATUS_DATA );
  122.      wCrntFmt = GetProp( hWnd, STATUS_FORMAT );
  123.  
  124.      /* define clipboard format name */
  125.      GetClipboardFmtName(wCrntFmt,szFmtName,sizeof(szFmtName),TRUE);
  126.  
  127.      /* define clipboard format owner */
  128.      if ( wCrntFmt && GetClipboardOwner() ) {
  129.        GetModuleFileName(
  130.          GetClassWord( GetClipboardOwner(), GCW_HMODULE ),
  131.          szFmtSize,
  132.          sizeof(szFmtSize)
  133.        );
  134.        sprintf( szFmtOwner, "%s from %s", szFmtName,
  135.                 strrchr(szFmtSize,'\\')+1 );
  136.        strcpy( szFmtName, szFmtOwner );
  137.      }
  138.  
  139.      /* define clipboard format size */
  140.      switch( wCrntFmt )
  141.        {
  142.      case NULL : /* empty */
  143.        strcpy( szFmtSize, "0 bytes" );
  144.        break;
  145.      case CF_BITMAP : /* standard GDI bitmap */
  146.      case CF_DSPBITMAP : /* display bitmap */
  147.        {
  148.          BITMAP      bmStruct;
  149.  
  150.          /* retieve bitmap object */
  151.          if (GetObject(hCrntData,sizeof(BITMAP),(LPSTR)&bmStruct)==
  152.              sizeof(BITMAP) ) {
  153.            sprintf(
  154.              szFmtSize,
  155.              " - %u x %u%s",
  156.              bmStruct.bmWidth,
  157.              bmStruct.bmHeight,
  158.              ((bmStruct.bmPlanes==1)&&(bmStruct.bmBitsPixel==1)) ?
  159.               " - mono" : ""
  160.            );
  161.            strcat( szFmtName, szFmtSize );
  162.            sprintf(
  163.              szFmtSize,
  164.              "%ld bytes",
  165.              sizeof(BITMAP) + ((LONG)bmStruct.bmWidthBytes *
  166.                     bmStruct.bmPlanes * bmStruct.bmHeight)
  167.            );
  168.          } else
  169.            strcpy( szFmtSize, "(size unknown)" );
  170.  
  171.        }
  172.        break;
  173.      case CF_METAFILEPICT : /* standard GDI metafile */
  174.      case CF_DSPMETAFILEPICT : /* display metafile */
  175.        {
  176.          LPMETAFILEPICT    lpmfStruct;
  177.          char          szMapMode[32];
  178.  
  179.          /* retieve bitmap object */
  180.          lpmfStruct = (LPMETAFILEPICT)GlobalLock( hCrntData );
  181.          if ( lpmfStruct ) {
  182.            switch( lpmfStruct->mm )
  183.              {
  184.               case MM_TEXT :
  185.                 sprintf( szFmtSize, " - %u x %u - text",
  186.                          lpmfStruct->xExt, lpmfStruct->yExt );
  187.                 break;
  188.               case MM_LOMETRIC :
  189.                 sprintf( szFmtSize, " - %u x %u - low metric",
  190.                          lpmfStruct->xExt, lpmfStruct->yExt );
  191.                 break;
  192.               case MM_HIMETRIC :
  193.                 sprintf( szFmtSize, " - %u x %u - high metric",
  194.                          lpmfStruct->xExt, lpmfStruct->yExt );
  195.                 break;
  196.               case MM_LOENGLISH :
  197.                 sprintf( szFmtSize, " - %u x %u - low english",
  198.                          lpmfStruct->xExt, lpmfStruct->yExt );
  199.                 break;
  200.               case MM_HIENGLISH :
  201.                 sprintf( szFmtSize, " - %u x %u - high english",
  202.                          lpmfStruct->xExt, lpmfStruct->yExt );
  203.                 break;
  204.               case MM_TWIPS :
  205.                 sprintf( szFmtSize, " - %u x %u - twips",
  206.                          lpmfStruct->xExt, lpmfStruct->yExt );
  207.                 break;
  208.               case MM_ISOTROPIC :
  209.                 sprintf( szFmtSize, " - isotropic" );
  210.                 break;
  211.               case MM_ANISOTROPIC :
  212.                 sprintf( szFmtSize, " - anisotropic" );
  213.                 break;
  214.               default :
  215.                 strcpy( szMapMode, "" );
  216.                 break;
  217.            }
  218.            strcat( szFmtName, szFmtSize );
  219.            sprintf(
  220.              szFmtSize,
  221.              "%ld bytes",
  222.              GlobalSize(hCrntData)+GlobalSize(lpmfStruct->hMF)
  223.            );
  224.            UnlockData( hCrntData );
  225.          } else
  226.            strcpy( szFmtSize, "(size unknown)" );
  227.  
  228.        }
  229.        break;
  230.      case CF_TEXT : /* standard text */
  231.      case CF_SYLK : /* standard SYLK text */
  232.      case CF_DIF : /* standard DIF text */
  233.      case CF_TIFF : /* standard binary TIFF data */
  234.      case CF_OEMTEXT : /* standard OEM text */
  235.      case CF_OWNERDISPLAY : /* owner display */
  236.      case CF_DSPTEXT : /* display text */
  237.      default : /* something else */
  238.        sprintf( szFmtSize, "%ld bytes", GlobalSize(hCrntData) );
  239.        break;
  240.      }
  241.  
  242.      /* make sure entire window is updated */
  243.      InvalidateRect( hWnd, NULL, TRUE );
  244.  
  245.      /* start painting */
  246.      BeginPaint( hWnd, &Ps );
  247.      GetTextMetrics( Ps.hdc, &TextMetric );
  248.      hOldFont = SelectObject( Ps.hdc, GetProp(hWnd,
  249.                                               STATUS_DISPFONT) );
  250.  
  251.      /* retrieve & adjust client rectangle for drawing */
  252.      GetClientRect( hWnd, &rcClient );
  253.      rcClient.left += TextMetric.tmAveCharWidth;
  254.      rcClient.right -= TextMetric.tmAveCharWidth;
  255.  
  256.      /* update clipboard format name & size */
  257.      DrawText( Ps.hdc, szFmtName, -1, &rcClient,
  258.                DT_LEFT|DT_VCENTER|DT_SINGLELINE );
  259.      DrawText( Ps.hdc, szFmtSize, -1, &rcClient,
  260.                DT_RIGHT|DT_VCENTER|DT_SINGLELINE );
  261.  
  262.      /* end painting */
  263.      SelectObject( Ps.hdc, hOldFont );
  264.      EndPaint( hWnd, &Ps );
  265.  
  266.    }
  267.    break;
  268.  case WM_CLOSE : /* window being closed */
  269.  
  270.    /* delete display font */
  271.    DeleteObject( GetProp(hWnd,STATUS_DISPFONT) );
  272.  
  273.    /* remove property lists */
  274.    RemoveProp( hWnd, STATUS_DATA );
  275.    RemoveProp( hWnd, STATUS_FORMAT );
  276.    RemoveProp( hWnd, STATUS_DISPFONT );
  277.  
  278.    /* end it all */
  279.    DestroyWindow( hWnd );
  280.  
  281.    break;
  282.  default : /* send to default */
  283.       lResult = DefWindowProc( hWnd, wMsg, wParam, lParam );
  284.       break;
  285.    }
  286.  
  287.    /* return normal result */
  288.    return( lResult );
  289.  
  290. }
  291.  
  292. /*
  293.  * ClientWndFn( hWnd, wMsg, wParam, lParam ) : LONG
  294.  *
  295.  *    hWnd        window handle
  296.  *    wMsg       message number
  297.  *    wParam      additional message information
  298.  *    lParam      additional message information
  299.  *
  300.  * This window function processes all the messages related to
  301.  * the client area of the clipboard viewer.
  302.  *
  303.  */
  304.  
  305. LONG FAR PASCAL ClientWndFn( hWnd, wMsg, wParam, lParam )
  306.    HWND        hWnd;
  307.    WORD        wMsg;
  308.    WORD        wParam;
  309.    LONG        lParam;
  310. {
  311.  FARPROC   lpFn;
  312.  LONG        lResult;
  313.  
  314.    /* initialization */
  315.    lResult = FALSE;
  316.  
  317.    /* process each message */
  318.    switch( wMsg )
  319.       {
  320.  case WM_CREATE : /* window being created */
  321.  
  322.    /* define property lists */
  323.    SetProp( hWnd, CLIENT_FORMAT, NULL );
  324.    SetProp( hWnd, CLIENT_MODULE, NULL );
  325.    SetProp( hWnd, CLIENT_DISPINFO, NULL );
  326.  
  327.      break;
  328.  case WM_UPDATE : /* update command from parent */
  329.  
  330.    /* check if clipboard data present */
  331.    if (GetProp(hWnd,CLIENT_FORMAT) && GetProp(hWnd,CLIENT_MODULE)) {
  332.      lpFn=GetProcAddress(GetProp(hWnd,CLIENT_MODULE),LIB_DESTROY );
  333.      (*lpFn)( hWnd, GetProp(hWnd,CLIENT_DISPINFO) );
  334.    }
  335.  
  336.    /* update property lists */
  337.    SetProp( hWnd, CLIENT_FORMAT, wParam );
  338.    SetProp( hWnd, CLIENT_MODULE, HIWORD(lParam) );
  339.  
  340.    if ( wParam && HIWORD(lParam) ) {
  341.      lpFn = GetProcAddress( GetProp(hWnd,CLIENT_MODULE), LIB_CREATE);
  342.      SetProp( hWnd, CLIENT_DISPINFO, (*lpFn)(hWnd,LOWORD(lParam)) );
  343.    } else {
  344.      SetProp( hWnd, CLIENT_DISPINFO, NULL );
  345.      SetScrollPos( hWnd, SB_HORZ, 0, TRUE );
  346.      SetScrollPos( hWnd, SB_VERT, 0, TRUE );
  347.    }
  348.  
  349.    /* force update of window */
  350.    InvalidateRect( hWnd, NULL, TRUE );
  351.  
  352.    break;
  353.  case WM_SIZE : /* window being sized */
  354.  case WM_HSCROLL : /* horizontal scroll request */
  355.  case WM_VSCROLL : /* vertical scroll request */
  356.  case WM_PAINT : /* window being painted */
  357.  
  358.    /* determine if a responsible library function available */
  359.    if (GetProp(hWnd,CLIENT_FORMAT) && GetProp(hWnd,CLIENT_MODULE)) {
  360.  
  361.      LPSTR     lpszLibrary;
  362.  
  363.      /* determine which library is responsible */
  364.      switch( wMsg )
  365.        {
  366.      case WM_SIZE :
  367.        lpszLibrary = LIB_SIZE;
  368.        break;
  369.      case WM_HSCROLL :
  370.        lpszLibrary = LIB_HSCROLL;
  371.        break;
  372.      case WM_VSCROLL :
  373.        lpszLibrary = LIB_VSCROLL;
  374.        break;
  375.      case WM_PAINT :
  376.        lpszLibrary = LIB_PAINT;
  377.        break;
  378.      }
  379.  
  380.      /* call display library function */
  381.      lpFn = GetProcAddress(GetProp(hWnd,CLIENT_MODULE),lpszLibrary);
  382.      (*lpFn)( hWnd, GetProp(hWnd,CLIENT_DISPINFO), wParam, lParam );
  383.  
  384.    } else
  385.        lResult = DefWindowProc( hWnd, wMsg, wParam, lParam );
  386.  
  387.    break;
  388.  case WM_CLOSE : /* window being closed */
  389.  
  390.    /* pass to responsible destroy library function */
  391.    if (GetProp(hWnd,CLIENT_FORMAT) && GetProp(hWnd,CLIENT_MODULE)) {
  392.      lpFn = GetProcAddress(GetProp(hWnd,CLIENT_MODULE),LIB_DESTROY );
  393.      (*lpFn)( hWnd, GetProp(hWnd,CLIENT_DISPINFO) );
  394.    }
  395.  
  396.    /* remove properties */
  397.    RemoveProp( hWnd, CLIENT_FORMAT );
  398.    RemoveProp( hWnd, CLIENT_MODULE );
  399.    RemoveProp( hWnd, CLIENT_DISPINFO );
  400.  
  401.    /* end it all */
  402.    DestroyWindow( hWnd );
  403.  
  404.    break;
  405.  default : /* send to default */
  406.       lResult = DefWindowProc( hWnd, wMsg, wParam, lParam );
  407.       break;
  408.    }
  409.  
  410.    /* return normal result */
  411.    return( lResult );
  412.  
  413. }
  414.  
  415.  
  416.