Category

Development Platform
Home > SourceCode/Document > Windows Develop > View Code
bv_text.c
Package: win2ksrc.rar　[view]
Upload User: caisha3
Upload Date: 2013-09-21
Package Size: 208739k
Code Size: 11k
Category:

Windows Develop

Development Platform:

Visual C++

bv_text.c：Code Content
  1. /* File: C:WACKERTDLLBV_TEXT.C (Created: 11-Jan-1994)
  2.  * Created from:
  3.  * File: C:HA5Gha5gstxtproc.c (Created: 27-SEP-1991)
  4.  *
  5.  * Copyright 1994 by Hilgraeve Inc. -- Monroe, MI
  6.  * All rights reserved
  7.  *
  8.  * $Revision: 1 $
  9.  * $Date: 10/05/98 12:37p $
  10.  */
  12. // #define DEBUGSTR 1
  14. #define WE_DRAW_EDGE 1
  16. #include <windows.h>
  17. #include <tdllstdtyp.h>
  18. #include <tdllmc.h>
  19. #include <tdllassert.h>
  21. #include <termxfer_dlg.h>
  23. #include "bv_text.h"
  24. #include "bv_text.hh"
  26. /*
  27.  * This stuff can probably go away as soon as the two following styles are
  28.  * supported:
  29.  *
  30.  * SS_SUNKEN 0x00001000L
  31.  * SS_RAISED 0x00002000L
  32.  */
  34. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  35.  * FUNCTION:
  36.  * RegisterBeveledTextClass
  37.  *
  38.  * DESCRIPTION:
  39.  * Registers the VU Meter window class.  (No kidding!)
  40.  *
  41.  * PARAMETERS:
  42.  * Hinstance -- the instance handle
  43.  *
  44.  * RETURNS:
  45.  * Whatever RegisterClass returns.
  46.  */
  47. BOOL RegisterBeveledTextClass(HANDLE hInstance)
  48. {
  49. BOOL            bRetVal = TRUE;
  50. WNDCLASS        wndclass;
  52. if (bRetVal)
  53. {
  54. wndclass.style          = CS_HREDRAW | CS_VREDRAW;
  55. wndclass.lpfnWndProc    = BeveledTextWndProc;
  56. wndclass.cbClsExtra     = 0;
  57. wndclass.cbWndExtra     = sizeof(VOID FAR *);
  58. wndclass.hIcon          = NULL;
  59. wndclass.hInstance      = hInstance;
  60. wndclass.hCursor        = NULL;
  61. wndclass.hbrBackground  = (HBRUSH)GetStockObject(BLACK_BRUSH);
  62. wndclass.lpszMenuName   = NULL;
  63. wndclass.lpszClassName  = BV_TEXT_CLASS;
  65. bRetVal = RegisterClass(&wndclass);
  66. }
  68. return bRetVal;
  69. }
  72. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  73.  * FUNCTION: stxtDrawBeveledText
  74.  *
  75.  * DESCRIPTION:
  76.  *
  77.  * ARGUEMENTS:
  78.  *
  79.  * RETURNS:
  80.  *
  81.  */
  83. VOID stxtDrawBeveledText(
  84.  HDC hdc,
  85.  HFONT hNewFont,
  86.  LPRECT  lpRc,
  87.  USHORT  usWidth,
  88.  DWORD dwStyle,
  89.  ULONG FAR *pulColors,
  90.  LPTSTR pszText
  91. )
  92. {
  93. //ULONG  ulOldBkColor;
  94. //ULONG  ulOldTextColor;
  95. #if defined(WE_DRAW_EDGE)
  96. HBRUSH hBrush;
  97. #endif
  98. HFONT  hFont;
  99. //WORD  wFlags;
  100. WORD   wStyle;
  101. INT    nWidth;
  102. INT    nHeight;
  103. INT    nIndex;
  104. RECT   rcE;
  105. TEXTMETRIC tm;
  106. LPTSTR  lpstr;
  108. /*
  109.  * We redraw the edging completely, every time
  110.  */
  111. nHeight = (int)GetSystemMetrics(SM_CYBORDER) * (int)usWidth;
  112. nWidth = (int)GetSystemMetrics(SM_CXBORDER) * (int)usWidth;
  114. #if defined(WE_DRAW_EDGE)
  115. /* Draw the top edge */
  116. hBrush = CreateSolidBrush(pulColors[2]);
  117. for (nIndex = 0; nIndex < nHeight; nIndex += 1)
  118. {
  119. rcE = *lpRc;
  120. rcE.top = nIndex;
  121. rcE.bottom = nIndex + 1;
  122. rcE.right -= nIndex;
  123. FillRect(hdc, &rcE, hBrush);
  124. }
  125. /* Draw the left edge */
  126. for (nIndex = 0; nIndex < nWidth; nIndex += 1)
  127. {
  128. rcE = *lpRc;
  129. rcE.left = nIndex;
  130. rcE.right = nIndex + 1;
  131. rcE.bottom -= nIndex;
  132. FillRect(hdc, &rcE, hBrush);
  133. }
  134. DeleteObject(hBrush);
  135. /* Draw the bottom edge */
  136. hBrush = CreateSolidBrush(pulColors[3]);
  137. for (nIndex = 0; nIndex < nHeight; nIndex += 1)
  138. {
  139. rcE = *lpRc;
  140. rcE.top = rcE.bottom - nIndex - 1;
  141. rcE.bottom = rcE.bottom - nIndex;
  142. rcE.left += nIndex + 1;
  143. FillRect(hdc, &rcE, hBrush);
  144. }
  145. /* Draw the right edge */
  146. for (nIndex = 0; nIndex < nWidth; nIndex += 1)
  147. {
  148. rcE = *lpRc;
  149. rcE.left = rcE.right - nIndex - 1;
  150. rcE.right = rcE.right - nIndex;
  151. rcE.top += nIndex + 1;
  152. FillRect(hdc, &rcE, hBrush);
  153. }
  154. DeleteObject(hBrush);
  155. #else
  157. DrawEdge(hdc, lpRc,
  158.  EDGE_SUNKEN,
  159.  BF_SOFT | BF_RECT);
  161. #endif
  163. /*
  164.  * We redraw the text completely every time
  165.  */
  167. rcE = *lpRc;
  168. #if defined(WE_DRAW_EDGE)
  169. InflateRect(&rcE, -nWidth, -nHeight);
  170. #else
  171. InflateRect(&rcE, -2, -2);
  172. #endif
  174. /* -------------- Must have something to paint ------------- */
  176. if (pszText)
  177. lpstr = pszText;
  179. else
  180. lpstr = " ";
  182. /* -------------- Figure where to place it ------------- */
  184. nIndex = (int)lstrlen(lpstr);
  185. wStyle = (WORD)dwStyle;
  187. if (wStyle & SS_RIGHT)
  188. {
  189. SetTextAlign(hdc, TA_RIGHT);
  190. nWidth = rcE.right - (2 * nWidth);
  191. }
  193. else if (wStyle & SS_CENTER)
  194. {
  195. SetTextAlign(hdc, TA_CENTER);
  196. nWidth = ((rcE.right - rcE.left) / 2) + nWidth;
  197. }
  199. else
  200. {
  201. nWidth = 3 * nWidth;
  202. }
  205. SetBkColor(hdc, pulColors[0]);
  206. SetTextColor(hdc, pulColors[1]);
  208. if (hNewFont != (HFONT)0)
  209. hFont = SelectObject(hdc, hNewFont);
  211. GetTextMetrics(hdc, &tm);
  212. nHeight += ((rcE.bottom - rcE.top) - tm.tmHeight - 1) / 2;
  214. ExtTextOut(hdc, nWidth, nHeight, ETO_OPAQUE | ETO_CLIPPED, &rcE,
  215. lpstr, nIndex, (LPINT)0);
  217. if (hNewFont != (HFONT)0)
  218. SelectObject(hdc, hFont);
  219. }
  223. /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  224.  * FUNCTION: StaticTextWndProc
  225.  *
  226.  * DESCRIPTION:
  227.  *
  228.  * ARGUEMENTS:
  229.  *
  230.  * RETURNS:
  231.  *
  232.  */
  234. LONG CALLBACK BeveledTextWndProc(HWND hWnd,
  235.   UINT wMsg,
  236.   WPARAM wPar,
  237.   LPARAM lPar)
  238. {
  239. LPSTEXT psT;
  241. switch (wMsg)
  242. {
  243. case WM_CREATE:
  244. psT = (LPSTEXT)malloc(sizeof(STEXT));
  245. SetWindowLong(hWnd, 0, (LONG)psT);
  247. psT->ulCheck = STEXT_VALID;
  248. psT->pszText = NULL;
  249. psT->hFont  = (HFONT)0;
  250. psT->fpOwnerDraw = (STXT_OWNERDRAW)0;
  252. switch (GetWindowLong(hWnd, GWL_STYLE) & 0x0000FF00)
  253. {
  254. case 0:
  255. default:
  256. psT->cBackGround = GetSysColor(COLOR_BTNFACE);
  257. psT->cTextColor  = GetSysColor(COLOR_BTNTEXT);
  258. psT->cUpperEdge  = GetSysColor(COLOR_BTNSHADOW);
  259. psT->cLowerEdge = GetSysColor(COLOR_BTNHIGHLIGHT);
  261. break;
  263. case BVS_ALTCLR:
  264. // case 0x100:
  265. psT->cBackGround = 0x00000000;
  266. psT->cTextColor  = 0x0000FF00;
  267. psT->cUpperEdge  = GetSysColor(COLOR_BTNSHADOW);
  268. psT->cLowerEdge  = GetSysColor(COLOR_BTNHIGHLIGHT);
  270. break;
  271. }
  273. psT->usDepth  = STXT_DEF_DEPTH;
  275. break;
  277. case WM_DESTROY:
  278. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  280. if (STEXT_OK(psT))
  281. {
  282. if (psT->pszText != NULL)
  283. free(psT->pszText);
  285. if (psT->fpOwnerDraw)
  286. FreeProcInstance((FARPROC)psT->fpOwnerDraw);
  288. free(psT);
  289. }
  290. SetWindowLong(hWnd, 0, 0L);
  291. break;
  293. case WM_GETDLGCODE:
  294. /* Static controls don't want any of these */
  295. return DLGC_STATIC;
  297. case WM_GETTEXTLENGTH:
  298. {
  299. ULONG ulLength = 0;
  301. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  302. if (STEXT_OK(psT))
  303. {
  304. if (psT->pszText != NULL)
  305. ulLength = (ULONG)lstrlen(psT->pszText);
  306. }
  307. return ((LONG)ulLength);
  308. }
  310. case WM_GETTEXT:
  311. {
  312. WORD wLength = 0;
  314. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  315. if (STEXT_OK(psT))
  316. {
  317. if (psT->pszText != NULL)
  318. {
  319. wLength = (WORD)lstrlen(psT->pszText);
  320. if (wPar < wLength)
  321. wLength = wPar;
  322. memcpy((LPTSTR)lPar, psT->pszText, wLength);
  323. }
  324. }
  325. return ((LONG)wLength);
  326. }
  328. case WM_SETTEXT:
  329. {
  330. WORD wLength;
  331. LPTSTR pszStr;
  333. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  334. if (STEXT_OK(psT))
  335. {
  336. CHAR  ach[128];
  337. INT   i, len;
  338. SIZE  sz;
  339. RECT  rc;
  340. HDC   hDC;
  341. HFONT hFont;
  342. DWORD dwStyle;
  344. ach[0] = 0;
  345. if (psT->pszText != NULL)
  346. {
  347. lstrcpy(ach, psT->pszText);
  348. free(psT->pszText);
  349. }
  350. psT->pszText = NULL;
  352. pszStr = (LPTSTR)lPar;
  353. if (pszStr != NULL)
  354. {
  355. wLength = (WORD)lstrlen(pszStr);
  356. if (wLength > 0)
  357. {
  358. psT->pszText = (LPTSTR)malloc(wLength + 1);
  359. lstrcpy(psT->pszText, pszStr);
  361. dwStyle = (DWORD)GetWindowLong(hWnd, GWL_STYLE);
  362. GetClientRect(hWnd, &rc);
  364. // Microsoft defined SS_LEFT to be zero!  
  365. // So the only way I can test SS_LEFT is
  366. // to see if bit 1 is zero
  368. switch (dwStyle & 3)
  369. {
  370. default:
  371. break;
  373. case SS_LEFT:
  374. {
  375. // Invalidate only from the point where the
  376. // string has changed.
  378. for (i=0, len=lstrlen(ach) ; i < len  ; ++i)
  379. {
  380. if (ach[i] != *pszStr++)
  381. break;
  382. }
  384. ach[i] = '';
  386. hDC = GetDC(hWnd);
  387. hFont = (HFONT)SendMessage(hWnd, WM_GETFONT, 0, 0L);
  388. if (hFont)
  389. hFont = SelectObject(hDC, hFont);
  390. GetTextExtentPoint(hDC, ach, i, &sz);
  391. if (hFont)
  392. SelectObject(hDC, hFont);
  393. ReleaseDC(hWnd, hDC);
  395. rc.left += sz.cx;
  397. /*
  398.  * We fudge because the font isn't fixed pitch
  399.  */
  400. rc.left -= min(sz.cx, 8);
  401. }
  402. break;
  404. case SS_RIGHT:
  405. {
  406. // Invalidate to the longer of the two strings.
  408. hDC = GetDC(hWnd);
  409. hFont = (HFONT)SendMessage(hWnd, WM_GETFONT, 0, 0L);
  410. if (hFont)
  411. hFont = SelectObject(hDC, hFont);
  412. GetTextExtentPoint(hDC, pszStr, lstrlen(pszStr), &sz);
  413. len = sz.cx;
  414. GetTextExtentPoint(hDC, ach, lstrlen(ach), &sz);
  415. if (hFont)
  416. SelectObject(hDC, hFont);
  417. ReleaseDC(hWnd, hDC);
  419. // rc.left += max(0, rc.right - ((int)GetSystemMetrics(SM_CXBORDER) * (int)psT->usDepth) - max(len, sz.cx) - 1 - 8);
  420. }
  421. break;
  422. }
  424. InvalidateRect(hWnd, &rc, FALSE);
  425. }
  426. }
  427. }
  428. }
  429. break;
  431. case WM_PAINT:
  432. {
  433. RECT rcC;
  434. PAINTSTRUCT ps;
  436. BeginPaint(hWnd, &ps);
  438. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  439. if (STEXT_OK(psT))
  440. {
  441. GetClientRect(hWnd, &rcC);
  443. stxtDrawBeveledText(
  444. ps.hdc,
  445. psT->hFont,
  446. (LPRECT)&rcC,
  447. psT->usDepth,
  448. (DWORD)GetWindowLong(hWnd, GWL_STYLE),
  449. (ULONG FAR *)&psT->cBackGround,
  450. psT->pszText
  451. );
  453. if (psT->fpOwnerDraw)
  454. (*psT->fpOwnerDraw)(hWnd, ps.hdc);
  455. }
  457. EndPaint(hWnd, &ps);
  458. }
  459. break;
  461. case WM_STXT_SET_BK:
  462. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  463. if (STEXT_OK(psT))
  464. {
  465. psT->cBackGround = (ULONG)lPar;
  466. InvalidateRect(hWnd, NULL, FALSE);
  467. }
  468. break;
  470. case WM_STXT_SET_TXT:
  471. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  472. if (STEXT_OK(psT))
  473. {
  474. psT->cTextColor = (ULONG)lPar;
  475. InvalidateRect(hWnd, NULL, FALSE);
  476. }
  477. break;
  479. case WM_STXT_SET_UE:
  480. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  481. if (STEXT_OK(psT))
  482. {
  483. psT->cUpperEdge = (ULONG)lPar;
  484. InvalidateRect(hWnd, NULL, FALSE);
  485. }
  486. break;
  488. case WM_STXT_SET_LE:
  489. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  490. if (STEXT_OK(psT))
  491. {
  492. psT->cLowerEdge = (ULONG)lPar;
  493. InvalidateRect(hWnd, NULL, FALSE);
  494. }
  495. break;
  497. case WM_STXT_SET_DEPTH:
  498. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  499. if (STEXT_OK(psT))
  500. {
  501. if (wPar < 7)
  502. {
  503. psT->usDepth = wPar;
  504. InvalidateRect(hWnd, NULL, TRUE);
  505. }
  506. }
  507. break;
  509. case WM_STXT_OWNERDRAW:
  510. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  512. psT->fpOwnerDraw = (STXT_OWNERDRAW)lPar;
  513. break;
  515. case WM_SETFONT:
  516. psT = (LPSTEXT)GetWindowLong(hWnd, 0);
  518. if (STEXT_OK(psT))
  519. psT->hFont = (HFONT)wPar;
  521. return 0L;
  523. default:
  524. break;
  525. }
  527. return DefWindowProc(hWnd, wMsg, wPar, (LONG)lPar);
  528. }