sitetext.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:12k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #ifndef _WINDOWS
  36. #error This is the Windows platform specific implementation.
  37. #endif
  38. //#define XXXBHG_TRACE_CODE
  39. #include "hxcom.h"
  40. #include "hxtypes.h"
  41. #include "hxwintyp.h"
  42. #ifdef _WIN32
  43. #include <vfw.h>
  44. #else
  45. #include <windows.h>
  46. #include <drawdib.h>
  47. #endif /* _WIN32 */
  48. #include "chxxtype.h"
  49. #include "hxmap.h"
  50. #include "carray.h"
  51. #include "hxslist.h"
  52. #include "hxevent.h"
  53. #include "ihxpckts.h"
  54. #include "hxwin.h"
  55. #include "hxengin.h"
  56. #include "hxcodec.h"
  57. #include "hxalloc.h"
  58. #include "diballoc.h"
  59. #include "hxvctrl.h"
  60. #include "hxvsurf.h"
  61. #include "surface.h"
  62. #include "vidosurf.h"
  63. #ifdef _WIN32
  64. //#include "fullsurf.h"
  65. //#include "ddraw.h" // needed by windraw.h
  66. //#include "windraw.h" // needed by wdsurf.h
  67. //#include "wdsurf.h"
  68. #endif /* _WIN32 */
  69. #include "hxsite2.h"
  70. #include "sitetext.h"
  71. #include "chxpckts.h"
  72. #include "hxtick.h"
  73. #include "hxprefs.h"
  74. #include "dbgtimer.h" // for blit time debugging
  75. #include "hxheap.h"
  76. #ifdef _DEBUG
  77. #undef HX_THIS_FILE
  78. static const char HX_THIS_FILE[] = __FILE__;
  79. #endif
  80. UINT32 CHXSiteStatusText::zm_nInstanceCount = 0;
  81. CHXMapPtrToPtr CHXSiteStatusText::zm_StatusWindowMap;
  82. /************************************************************************
  83.  *  Class:
  84.  *    CHXSiteStatusText this class draws the status text information.
  85.  */
  86. CHXSiteStatusText::CHXSiteStatusText() 
  87.    :   m_hWnd(NULL)
  88.    , m_parentWindow(NULL)
  89.    , m_hBitMap(NULL)
  90.    , m_backgroundBrush(0x00008000)
  91.    , m_textColor(0x0000FF00)
  92. {
  93.    memset(&m_rect, 0, sizeof(RECT));
  94. }
  95. CHXSiteStatusText::~CHXSiteStatusText() 
  96. {
  97.    if (m_hBitMap)
  98.    {
  99.       DeleteObject(m_hBitMap);
  100.    }
  101. }
  102. LRESULT HXEXPORT CHXSiteStatusTextProc
  103. (
  104.    HWND hWnd,
  105.    UINT message,
  106.    WPARAM uParam,
  107.    LPARAM lParam
  108.    )
  109. {
  110. #ifdef XXX_TRACE_CODE
  111.    if (message == WM_SIZE || message == WM_MOVE || message == WM_WINDOWPOSCHANGED)
  112.    {
  113.       OutputDebugString("NEW ONE!!! sizeingn");
  114.    }
  115. #endif
  116.    CHXSiteStatusText* pStatusWnd = NULL; 
  117.    if (CHXSiteStatusText::zm_StatusWindowMap.Lookup((void*)hWnd,(void*&)pStatusWnd))
  118.    {
  119.       if (pStatusWnd)
  120.       {
  121.          return pStatusWnd->HandleEvent(hWnd,message,uParam,lParam);
  122.       }
  123.    }
  124.    return (DefWindowProc(hWnd, message, uParam, lParam));
  125. }
  126. void
  127. CHXSiteStatusText::RegisterClass()
  128. {
  129.    if (0 == zm_nInstanceCount)
  130.    {
  131.       WNDCLASS wndClass;
  132.       ATOM result;
  133.       wndClass.style = 0; 
  134.       wndClass.lpfnWndProc = CHXSiteStatusTextProc; 
  135.       wndClass.cbClsExtra = 0; 
  136.       wndClass.cbWndExtra = 0; 
  137.       wndClass.hInstance = GetInstance();
  138.       wndClass.hIcon = NULL; 
  139.       wndClass.hCursor = NULL; 
  140.       wndClass.hbrBackground = NULL;
  141.       wndClass.lpszMenuName = NULL; 
  142.       wndClass.lpszClassName = "CHXSiteStatusText"; 
  143.       result = ::RegisterClass(&wndClass);
  144.       HX_ASSERT(result);
  145.    }
  146.    zm_nInstanceCount++;
  147. }
  148. void
  149. CHXSiteStatusText::UnRegisterClass()
  150. {
  151.    HX_ASSERT(zm_nInstanceCount > 0);
  152.     
  153.    if (zm_nInstanceCount > 0)
  154.    {
  155.       zm_nInstanceCount--;
  156.    }
  157.    if (0 == zm_nInstanceCount)
  158.    {
  159.       BOOL result = ::UnregisterClass("CHXSiteStatusText",GetInstance());
  160.       HX_ASSERT(result);
  161.    }
  162. }
  163. void
  164. CHXSiteStatusText::SetStatusText(const char* pText)
  165. {
  166.    if (!pText)
  167.    {
  168.       m_StatusText ="";
  169.    }
  170.    else
  171.    {
  172.       m_StatusText = pText;
  173.    }
  174.    if (m_StatusText.GetLength())
  175.    {
  176.       if (m_hWnd)
  177.       {
  178.          Show();
  179.          InvalidateRect(m_hWnd,NULL,TRUE);
  180.          UpdateWindow(m_hWnd);
  181.       }
  182.    }
  183.    else
  184.    {
  185.       Hide();
  186.    }
  187. }
  188. LRESULT 
  189. CHXSiteStatusText::HandleEvent
  190. (
  191.    HWND hWnd,
  192.    UINT message,
  193.    WPARAM uParam,
  194.    LPARAM lParam
  195.    )
  196. {
  197.    if (WM_PAINT == message)
  198.    {
  199.       PAINTSTRUCT ps;
  200.       HDC hDC = ::BeginPaint(hWnd,&ps);
  201.       // we are going to be writing to a memory DC so that the
  202.       // text does not blink. So 1st we have to set up the DC
  203.       RECT rect;
  204.       ::GetWindowRect(hWnd, &rect);
  205.       HDC hMemDC = CreateCompatibleDC(hDC);
  206.       if ( (rect.left - rect.right != m_rect.left - m_rect.right) 
  207.            || (rect.top - rect.bottom != m_rect.top - m_rect.bottom)
  208.            || !m_hBitMap)
  209.       {
  210.          if (m_hBitMap)
  211.          {
  212.             DeleteObject(m_hBitMap);
  213.          }
  214.          // this is a SLOW function we should avoid it like the plague.
  215.          m_hBitMap = CreateCompatibleBitmap(hDC, rect.right - rect.left, rect.bottom -  rect.top);
  216.          // copy the contents
  217.          memcpy(&m_rect, &rect, sizeof(RECT)); /* Flawfinder: ignore */
  218.       }
  219.       RECT boundsRect;
  220.       boundsRect.left     = 0;
  221.       boundsRect.right    = rect.right - rect.left;
  222.       boundsRect.top     = 0;
  223.       boundsRect.bottom   = rect.bottom - rect.top;
  224.       HBITMAP hOldBitMap = (HBITMAP) SelectObject(hMemDC, m_hBitMap);
  225.       // Now we will do the drawing
  226.       // create the approperiate tools
  227.       HBRUSH hStatusBrush = CreateSolidBrush(m_backgroundBrush);
  228.       HPEN hNullPen = CreatePen(PS_NULL,0,0);
  229.       HBRUSH hOldBrush = (HBRUSH)SelectObject(hMemDC, hStatusBrush);
  230.       HPEN hOldPen = (HPEN)SelectObject(hMemDC, hNullPen);
  231.       // draw the rectangle
  232.       Rectangle(hMemDC,boundsRect.left,boundsRect.top,boundsRect.right+1,boundsRect.bottom+1);
  233.       // Now we have to draw the text 
  234.       int nOldMode = SetBkMode(hMemDC,TRANSPARENT);
  235.       SetTextColor(hMemDC, m_textColor);
  236.       // Get the text extents ... if we go beyond the size of the window 
  237.       // then we should left justify the text and maybe add elipises (sp?).
  238.       SIZE textSize; 
  239.       GetTextExtentPoint(hMemDC, (const char*)m_StatusText, m_StatusText.GetLength(), &textSize);
  240.       if (textSize.cx > (boundsRect.right - boundsRect.left))
  241.       {
  242.          // we will loop to find out where to put the elipise
  243.          for (int i = 1; i <= m_StatusText.GetLength(); i++)
  244.          {
  245.             GetTextExtentPoint(hMemDC, (const char*)m_StatusText, i, &textSize);
  246.             if (textSize.cx > (boundsRect.right - boundsRect.left))
  247.             {
  248.                CHXString tempString;
  249.                for(int j = i - 1; j > 0 ; j--)
  250.                {
  251.                   tempString = m_StatusText.Left(j);
  252.                   tempString = tempString + "...";
  253.                   GetTextExtentPoint(hMemDC, (const char*)tempString, tempString.GetLength(), &textSize);
  254.                   if (textSize.cx > (boundsRect.right - boundsRect.left))
  255.                   {
  256.                      continue;
  257.                   }
  258.                   DrawText(hMemDC, tempString, tempString.GetLength(),&boundsRect, DT_LEFT | DT_SINGLELINE | DT_VCENTER);
  259.                   break;
  260.                }
  261.             }
  262.          }
  263.       }
  264.       else
  265.       {
  266.          DrawText(hMemDC, m_StatusText, m_StatusText.GetLength(),&boundsRect, DT_CENTER | DT_SINGLELINE | DT_VCENTER);
  267.       }
  268.       SetBkMode(hMemDC,nOldMode);
  269.     
  270.       // finally Blt the bitmap back on to the window. 
  271.       BitBlt(hDC, 0, 0, boundsRect.right , boundsRect.bottom, hMemDC, 0, 0, SRCCOPY);
  272.       // cleapup
  273.       SelectObject(hMemDC,hOldBrush);
  274.       SelectObject(hMemDC,hOldPen);
  275.       SelectObject(hMemDC, hOldBitMap);
  276.       DeleteObject(hStatusBrush);
  277.       DeleteObject(hNullPen);
  278.       DeleteDC(hMemDC);
  279.       // finished
  280.       ::EndPaint(hWnd,&ps);
  281.       return 0;
  282.    }
  283.    return (DefWindowProc(hWnd, message, uParam, lParam));
  284. }
  285. /************************************************************************
  286.  *  Function:
  287.  *    GetInstance
  288.  */
  289. HINSTANCE
  290. CHXSiteStatusText::GetInstance()
  291. {
  292. #ifndef _WIN32
  293.    return (HINSTANCE)GetCurrentTask(); // 16bit version
  294. #else
  295.    return NULL;     // NULL works for 32 bit.
  296. #endif
  297. }
  298. HX_RESULT CHXSiteStatusText::Create(void* ParentWindow)
  299. {
  300.    /*
  301.     * Make sure the window class is registered.
  302.     */
  303.    RegisterClass();
  304.    m_hWnd = CreateWindow( "CHXSiteStatusText",
  305.                           "", 
  306.                           WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD, 
  307.                           0,0,0,0,
  308.                           (HWND)ParentWindow,
  309.                           NULL,
  310.                           GetInstance(),
  311.                           NULL);
  312.    m_parentWindow  = (HWND) ParentWindow;
  313.    if (!m_hWnd)
  314.       return HXR_FAIL;
  315.    zm_StatusWindowMap.SetAt((void*)m_hWnd, (void*)this);
  316.    if (m_StatusText.GetLength())
  317.    {
  318.       Show();
  319.       InvalidateRect(m_hWnd,NULL,TRUE);
  320.       UpdateWindow(m_hWnd);
  321.    }
  322.    ParentChangedSize();
  323.    return HXR_OK;
  324. }
  325. HX_RESULT CHXSiteStatusText::Destroy()
  326. {
  327.    if (m_hWnd)
  328.    {
  329.       BOOL bDidDestroy = DestroyWindow(m_hWnd);
  330. #ifdef _DEBUGGING_DESTROY_WINDOWS     
  331.       HX_ASSERT(bDidDestroy);
  332. #endif
  333.       m_hWnd = 0;
  334.       UnRegisterClass();
  335.       zm_StatusWindowMap.RemoveKey((void*)m_hWnd);
  336.       return HXR_OK;
  337.    }
  338.    return HXR_FAIL;
  339. }
  340. HX_RESULT CHXSiteStatusText::Show()
  341. {
  342.    if (m_hWnd)
  343.    {
  344.       ShowWindowAsync(m_hWnd, SW_SHOW);
  345.       return HXR_OK;
  346.    }
  347.    return HXR_FAIL;
  348. }
  349. HX_RESULT CHXSiteStatusText::Hide()
  350. {
  351.    if (m_hWnd)
  352.    {
  353.       ShowWindowAsync(m_hWnd, SW_HIDE);
  354.       return HXR_OK;
  355.    }
  356.    return HXR_FAIL;
  357. }
  358. HX_RESULT CHXSiteStatusText::ParentChangedSize()
  359. {
  360.    if (!m_hWnd)
  361.       return HXR_FAIL;
  362.    // since our parent changed size we must also change size
  363.    RECT rect;
  364.    ::GetWindowRect(m_parentWindow, &rect);
  365.    // figure out the size of the text
  366.    HDC hdc = ::GetDC(m_hWnd);
  367.    TEXTMETRIC tm;
  368.    ::GetTextMetrics(hdc, &tm);
  369.    LONG nStatusTextHeight = tm.tmHeight;
  370.    ::ReleaseDC(m_hWnd, hdc);
  371.    m_rect.left     = 0;
  372.    m_rect.right    = rect.right - rect.left;
  373.    m_rect.top     = rect.bottom - rect.top - (LONG) ((double) nStatusTextHeight * 1.2);
  374.    m_rect.bottom   = rect.bottom - rect.top;
  375.    BOOL retVal = ::SetWindowPos(   m_hWnd, 
  376.                                    HWND_TOP, 
  377.                                    m_rect.left, 
  378.                                    m_rect.top, 
  379.                                    m_rect.right, 
  380.                                    m_rect.bottom - m_rect.top, 
  381.                                    0 );
  382.    // destroy the bitmap since we changed sizes; the bitmap will be
  383.    // generated again on the next paint
  384.    if (m_hBitMap)
  385.    {
  386.       DeleteObject(m_hBitMap);
  387.       m_hBitMap = NULL;
  388.    }
  389.    return HXR_OK;
  390. }