开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
trackwnd.c
资源名称：xtractor.zip　[点击查看]
上传用户：xmgzy123
上传日期：2007-01-07
资源大小：373k
文件大小：35k
源码类别：

SCSI/ASPI

开发平台：

WINDOWS

trackwnd.c：源码内容
  1. /*
  2.  * trackwnd.c - Copyright (C) 1999,2000 Jay A. Key
  3.  *
  4.  * Implementation of the TrackWnd window class.  TrackWnd is intended to
  5.  * be a child window of the main application window, and supports the 
  6.  * displaying, editing and selectind of CD audio tracks.  Includes a header
  7.  * control for changing the width of the items displayed on screen.
  8.  *
  9.  **********************************************************************
  10.  *
  11.  * This program is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2 of the License, or
  14.  * (at your option) any later version.
  15.  *
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with this program; if not, write to the Free Software
  23.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  24.  *
  25.  */
  26. #include <windows.h>
  27. #include <commctrl.h>
  28. #include <string.h>
  30. #include "resources.h"
  31. #include "trackwnd.h"
  32. #include "globals.h"
  33. #include "statusbar.h"
  35. typedef struct
  36. {
  37.   int iNum;
  38.   int iMax;
  39.   int iTextHeight;
  40.   int vw, vh;
  41.   int dx, dy;              // scroll bar offsets into virtual window
  42.   int iHeaderHeight;
  43.   int hx[5];               // header x offsets
  44.   int hw[5];               // header widths
  45.   int iFound;
  46.   HWND hHeader;
  47.   BOOL bVScroll, bHScroll;
  48.   HPEN hBrownPen, hBlackPen;
  49.   int iSelected;
  50.   ADDTRACK *tracks;
  51. } TRACKWNDEXTRA, *LPTRACKWNDEXTRA;
  54. LRESULT CALLBACK TrackWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  55. void doTrackWndPaint( HWND hWnd, LPTRACKWNDEXTRA lpe );
  56. void RecalcWindow( HWND hWnd, LPTRACKWNDEXTRA lpe );
  57. void DeleteTrack( HWND hWnd, int iTrack, LPTRACKWNDEXTRA lpe );
  58. void HandleVScroll( HWND, int, int, LPTRACKWNDEXTRA );
  59. void HandleHScroll( HWND, int, int, LPTRACKWNDEXTRA );
  60. void ComputeHeaderPos( HWND hHdr, HWND hParent );
  61. HWND createHeader( HWND hWnd, HINSTANCE hInst );
  62. char *notifyString( UINT code );
  63. BOOL handleHeaderNotify( HWND hWnd, LPARAM lParam, LPTRACKWNDEXTRA lpe );
  64. BOOL HandleLMouseDown( HWND hWnd, LPTRACKWNDEXTRA lpe, LPARAM lParam );
  65. BOOL HandleRMouseDown( HWND hWnd, LPTRACKWNDEXTRA lpe, LPARAM lParam );
  66. int CheckBoxHit( LPTRACKWNDEXTRA lpe, LPARAM lParam );
  67. BOOL HandleCheckTrack( HWND hWnd, LPTRACKWNDEXTRA lpe, int trackNo, BOOL bChecked );
  68. BOOL HandleInvertCheck( HWND hWnd, LPTRACKWNDEXTRA lpe, int trackNo );
  69. int doContextMenu( HWND hWnd, LPARAM lParam );
  70. BOOL RenameSelectedTrack( HWND hWnd, LPTRACKWNDEXTRA lpe );
  71. LRESULT processFindFirst( LPTRACKWNDEXTRA lpe, LPADDTRACK lpAddTrack );
  72. LRESULT processFindNext( LPTRACKWNDEXTRA lpe, LPADDTRACK lpAddTrack );
  73. void convertuMsg( UINT uMsg, char * s );
  74. void logWindowsProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  75. LRESULT CALLBACK EditSubclassWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  76. LRESULT CALLBACK FooWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  77. void SetTrackWndText( HWND hWnd );
  78. LRESULT numChecked( LPTRACKWNDEXTRA lpe );
  79. int doTrackContextMenu( HWND hParent, HWND hChild, LPARAM lParam );
  80. BOOL setTrackStatus( LPTRACKWNDEXTRA lpe, int idx, LPCSTR s );
  83. static char szTrackWndClass[] = "akripTrackWnd";
  84. //static char szFooClass[] = "fooclass";
  85. //static ADDTRACK tmpAddTrack;
  86. HWND hHeader;
  87. static int iCtlId = 10000;
  88. static BOOL bInEditTrack = FALSE;
  89. static HWND hEdit = NULL;
  91. int InitTrackWnd( HINSTANCE hInst )
  92. {
  93.   WNDCLASSEX wc;
  94.   LOGBRUSH lb;
  95.   HBRUSH hBrush;
  97.   ZeroMemory( &lb, sizeof(lb) );
  98.   lb.lbStyle = BS_SOLID;
  99.   lb.lbColor = RGB( 240, 255, 220 );
  100.   lb.lbHatch = 0;
  101.   hBrush = CreateBrushIndirect( &lb );
  103.   ZeroMemory( &wc, sizeof(wc) );
  104.   wc.cbSize          = sizeof(wc);
  105.   wc.style           = CS_HREDRAW | CS_VREDRAW;
  106.   wc.lpfnWndProc     = (WNDPROC)TrackWndProc;
  107.   wc.hInstance       = hInst;
  108.   wc.hCursor         = LoadCursor( NULL, IDC_ARROW );
  109.   wc.hbrBackground   = hBrush;
  110.   wc.lpszClassName   = szTrackWndClass;
  112.   if ( !RegisterClassEx( &wc ) )
  113.     return 0;
  115. #if 0
  116.   ZeroMemory( &wc, sizeof(wc) );
  117.   wc.cbSize          = sizeof(wc);
  118.   wc.style           = CS_HREDRAW | CS_VREDRAW;
  119.   wc.lpfnWndProc     = (WNDPROC)FooWndProc;
  120.   wc.hInstance       = hInst;
  121.   wc.hCursor         = LoadCursor( NULL, IDC_ARROW );
  122.   wc.hbrBackground   = hBrush;
  123.   wc.lpszClassName   = szFooClass;
  125.   if ( !RegisterClassEx( &wc ) )
  126.     return 0;
  127. #endif
  129.   return -1;
  130. }
  133. LRESULT CALLBACK TrackWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  134. {
  135.   LPTRACKWNDEXTRA lpe;
  136.   RECT rc;
  138.   logWindowsProc( hWnd, uMsg, wParam, lParam );
  140.   lpe = (LPTRACKWNDEXTRA)GetWindowLong( hWnd, GWL_USERDATA);
  141.   if ( !lpe && ( uMsg != WM_CREATE ) )
  142.     return DefWindowProc( hWnd, uMsg, wParam, lParam );
  144.   switch( uMsg )
  145.     {
  146.     case WM_COMMAND:
  147.       switch( HIWORD(wParam) )
  148.         {
  149.         case EN_SETFOCUS: break;
  150.         case EN_KILLFOCUS: break;
  151.         }
  152.       break;
  154.     case WM_CONTEXTMENU:
  155.       doTrackContextMenu( GetParent(hWnd), hWnd, lParam );
  156.       break;
  158.     case WM_SETFOCUS:
  159.       //OutputDebugString( "TrackWnd gaining focus" );
  160.       break;
  162.     case WM_KILLFOCUS:
  163.       //OutputDebugString( "TrackWnd losing focus" );
  164.       break;
  166.     case WM_NOTIFY:
  167.       if ( wParam == IDM_HEADER )
  168.         return handleHeaderNotify( hWnd, lParam, lpe );
  169.       break;
  171.     case WM_DESTROY:
  172.       lpe = (LPTRACKWNDEXTRA)GetWindowLong( hWnd, GWL_USERDATA );
  173.       if ( lpe )
  174.         {
  175.           if ( lpe->tracks )
  176.             GlobalFree( (HGLOBAL)lpe->tracks );
  177.           if ( lpe->hBrownPen )
  178.             DeleteObject( lpe->hBrownPen );
  179.           if ( lpe->hBlackPen )
  180.             DeleteObject( lpe->hBlackPen );
  181.           GlobalFree( lpe );
  182.         }
  183.       return DefWindowProc( hWnd, uMsg, wParam, lParam );
  185.     case WM_CREATE:
  186.       lpe = (LPTRACKWNDEXTRA)GlobalAlloc( GPTR, sizeof(TRACKWNDEXTRA) );
  187.       lpe->tracks = (LPADDTRACK)GlobalAlloc( GPTR, sizeof(ADDTRACK)*100 );
  188.       lpe->iNum = 0;
  189.       lpe->iMax = 100;
  190.       lpe->hBrownPen = CreatePen( PS_SOLID, 1, 0x00003384 );
  191.       lpe->hBlackPen = CreatePen( PS_SOLID, 1, 0x00000000 );
  192.       lpe->iSelected = -1;
  193.       lpe->iFound = -1;
  194.       SetWindowLong( hWnd, GWL_USERDATA, (LONG)lpe );
  195.       UpdateStatusBar();
  196.       break;
  198.     case WM_PAINT:
  199.       doTrackWndPaint( hWnd, lpe );
  200.       break;
  202.     case WM_VSCROLL:
  203.       HandleVScroll( hWnd, (int)LOWORD(wParam), (int)HIWORD(wParam), lpe );
  204.       RecalcWindow( hWnd, lpe );
  205.       GetClientRect( hWnd, &rc );
  206.       rc.top += (lpe->iHeaderHeight+1);
  207.       InvalidateRect( hWnd, &rc, TRUE );
  208.       UpdateWindow( hWnd );
  209.       break;
  211.     case WM_HSCROLL:
  212.       HandleHScroll( hWnd, (int)LOWORD(wParam), (int)HIWORD(wParam), lpe );
  213.       RecalcWindow( hWnd, lpe );
  214.       GetClientRect( hWnd, &rc );
  215.       rc.top += (lpe->iHeaderHeight+1);
  216.       InvalidateRect( hWnd, &rc, TRUE );
  217.       UpdateWindow( hWnd );
  218.       break;
  220.     case WM_SIZE:
  221.       RecalcWindow( hWnd, lpe );
  222.       break;
  224.     case WM_ADDTRACK:
  225.       if ( lpe->iNum >= lpe->iMax )
  226.         break;
  227.       memcpy( &(lpe->tracks[lpe->iNum]), (void *)lParam, sizeof(ADDTRACK) );
  228.       lpe->iNum++;
  229.       RecalcWindow( hWnd, lpe );
  230.       GetClientRect( hWnd, &rc );
  231.       rc.top += (lpe->iHeaderHeight+1);
  232.       InvalidateRect( hWnd, &rc, TRUE );
  233.       UpdateWindow( hWnd );
  234.       UpdateStatusBar();
  235.       break;
  237.     case WM_CHECKTRACK:
  238.       if ( HandleCheckTrack( hWnd, lpe, (int)wParam, (BOOL)lParam ) )
  239.         {
  240.           GetClientRect( hWnd, &rc );
  241.           rc.top += (lpe->iHeaderHeight+1);
  242.           InvalidateRect( hWnd, &rc, TRUE );
  243.           UpdateWindow( hWnd );
  244.         }
  245.       UpdateStatusBar();
  246.       break;
  248.     case WM_INVERTCHECK:
  249.       if ( HandleInvertCheck( hWnd, lpe, (int)wParam ) )
  250.         {
  251.           GetClientRect( hWnd, &rc );
  252.           rc.top += (lpe->iHeaderHeight+1);
  253.           InvalidateRect( hWnd, &rc, TRUE );
  254.           UpdateWindow( hWnd );
  255.         }
  256.       UpdateStatusBar();
  257.       break;
  259.     case WM_DELTRACK:
  260.       DeleteTrack( hWnd, (int)wParam, lpe );
  261.       RecalcWindow( hWnd, lpe );
  262.       GetClientRect( hWnd, &rc );
  263.       rc.top += (lpe->iHeaderHeight+1);
  264.       InvalidateRect( hWnd, &rc, TRUE );
  265.       UpdateWindow( hWnd );
  266.       UpdateStatusBar();
  267.       break;
  269.     case WM_SELTRACK:
  270.       if ( lpe->iSelected != (int)wParam )
  271.         {
  272.           lpe->iSelected = (int)wParam;
  273.           GetClientRect( hWnd, &rc );
  274.           rc.top += (lpe->iHeaderHeight+1);
  275.           InvalidateRect( hWnd, &rc, TRUE );
  276.           UpdateWindow( hWnd );
  277.         }
  278.       break;
  280.     case WM_MOUSEMOVE:
  281.       // grrr... it's an evil hack, but I need for the MouseCapture to 
  282.       // remain with the edit control.  When the user selects text with the
  283.       // mouse, the edit control automatically captures the mouse (even if
  284.       // it already has the mouse captured.  Then it releases it, but not
  285.       // until after the WM_*BUTTONUP message.  Until I write a custom
  286.       // edit control, I'll have to use this workaround.
  287.       if ( bInEditTrack && hEdit )
  288.         SetCapture( hEdit );
  289.       break;
  291.     case WM_LBUTTONDOWN:
  292.       if ( HandleLMouseDown( hWnd, lpe, lParam ) )
  293.         {
  294.           GetClientRect( hWnd, &rc );
  295.           rc.top += (lpe->iHeaderHeight+1);
  296.           InvalidateRect( hWnd, &rc, TRUE );
  297.           UpdateWindow( hWnd );
  298.         }
  299.       break;
  301.     case WM_RBUTTONDOWN:
  302.       if ( HandleRMouseDown( hWnd, lpe, lParam ) )
  303.         {
  304.           GetClientRect( hWnd, &rc );
  305.           rc.top += (lpe->iHeaderHeight+1);
  306.           InvalidateRect( hWnd, &rc, TRUE );
  307.           UpdateWindow( hWnd );
  308.         }
  309.       break;
  311.     case WM_RENSELTRACK:
  312.       if ( RenameSelectedTrack( hWnd, lpe ) )
  313.         {
  314.           GetClientRect( hWnd, &rc );
  315.           rc.top += (lpe->iHeaderHeight+1);
  316.           InvalidateRect( hWnd, &rc, TRUE );
  317.           UpdateWindow( hWnd );
  318.         }
  319.       break;
  321.     // copies the first checked track found into (LPADDTRACK)lParam .
  322.     // Returns index of the track, or -1 if no track found
  323.     case WM_FINDFIRSTTRACK:
  324.       return processFindFirst( lpe, (LPADDTRACK)lParam );
  325.       break;
  327.     // returns NULL if no more tracks are selected, otherwise LPADDTRACK
  328.     case WM_FINDNEXTTRACK:
  329.       return processFindNext( lpe, (LPADDTRACK)lParam );
  330.       break;
  332.     case WM_SETSELTEXT:
  333.       lstrcpy( lpe->tracks[lpe->iSelected].name, (char *)lParam );
  334.       GetClientRect( hWnd, &rc );
  335.       rc.top += (lpe->iHeaderHeight+1);
  336.       InvalidateRect( hWnd, &rc, TRUE );
  337.       UpdateWindow( hWnd );
  338.       break;
  340.     case WM_SETTRACKTEXT:
  341.       if ( (int)wParam < lpe->iNum )
  342.         {
  343.           lstrcpyn( lpe->tracks[wParam].name, (char *)lParam, MAX_PATH );
  344.           lpe->tracks[wParam].name[MAX_PATH] = '';
  345.           GetClientRect( hWnd, &rc );
  346.           rc.top += (lpe->iHeaderHeight+1);
  347.           InvalidateRect( hWnd, &rc, TRUE );
  348.           UpdateWindow( hWnd );
  349.         }
  350.       break;
  352.     case WM_SETTRACKSTATUS:
  353.       if ( setTrackStatus( lpe, (int)wParam, (LPCSTR)lParam ) )
  354.         {
  355.           GetClientRect( hWnd, &rc );
  356.           rc.top += (lpe->iHeaderHeight+1);
  357.           InvalidateRect( hWnd, &rc, TRUE );
  358.           UpdateWindow( hWnd );
  359.         }
  360.       break;
  362.     case WM_NUMCHECKED:
  363.       return numChecked( lpe );
  365.     case WM_NUMTRACKS:
  366.       return (LRESULT)lpe->iNum;
  368.     case WM_GETTRACK:
  369.       if ( lParam )
  370.         {
  371.           memcpy( (BYTE *)lParam, (BYTE *)&lpe->tracks[wParam], sizeof(ADDTRACK) );
  372.           return (LRESULT)lParam;
  373.         }
  374.       break;
  376.     case WM_CAPTURECHANGED:
  377.       //OutputDebugString( "TrackWndProc: WM_CAPTURECHANGED" );
  378.       break;
  380.     default:
  381.       return DefWindowProc( hWnd, uMsg, wParam, lParam );
  382.     }
  384.   return 0L;
  385. }
  388. HWND createTrackWnd( HWND hParent, HINSTANCE hInst, int idCtrl, LPRECT lprc )
  389. {
  390.   LPTRACKWNDEXTRA lpe;
  391.   HWND hRet;
  392.   HDC hDC;
  393.   SIZE s;
  394.   RECT rc;
  396.   hRet = CreateWindowEx( 0, szTrackWndClass, "A Bogus Name",
  397.                          WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL,
  398.                          lprc->left, lprc->top,
  399.                          lprc->right - lprc->left, lprc->bottom - lprc->top,
  400.                          hParent, (HMENU)idCtrl, hInst, NULL );
  403.   /*
  404.    * compute text height
  405.    */
  406.   lpe = (LPTRACKWNDEXTRA)GetWindowLong( hRet, GWL_USERDATA );
  407.   hDC = GetWindowDC( hRet );
  408.   GetTextExtentPoint32( hDC, "ABCDEFGHIJKLMNOPQRSTUVWYXZabcdefghijklmnopqrstuvwxyz", 52, &s );
  409.   lpe->iTextHeight = s.cy;
  410.   ReleaseDC( hRet, hDC );
  412.   lpe->hHeader = createHeader( hRet, hInst );
  413.   GetClientRect( lpe->hHeader, &rc );
  414.   lpe->iHeaderHeight = rc.bottom - rc.top + 1;
  416.   return hRet;
  417. }
  421. void doTrackWndPaint( HWND hWnd, LPTRACKWNDEXTRA lpe )
  422. {
  423.   PAINTSTRUCT p;
  424.   HDC hDC;
  425.   RECT rc;
  426.   int i;
  427.   int oldBkMode;
  428.   int hw[5];            // width of header items
  429.   int hx[5];            // x offset of header items
  430.   DWORD len;
  431.   //char buf[32];
  432.   POINT pts[5];
  433.   HPEN hOldPen;
  434.   COLORREF oldBkColor, oldTextColor;
  435.   char buf[81];
  437.   GetClientRect( hWnd, &rc );
  438.   hDC = BeginPaint( hWnd, &p );
  440.   /*
  441.    * compute the offsets for each header section
  442.    */
  443.   ZeroMemory( hw, sizeof(int[5]) );
  444.   ZeroMemory( hx, sizeof(int[5]) );
  445.   for( i = 0; i < 4; i++ )
  446.     {
  447.       HD_ITEM hi;
  448.       ZeroMemory( &hi, sizeof(hi) );
  449.       hi.mask = HDI_WIDTH;
  450.       SendMessage( lpe->hHeader, HDM_GETITEM, i, (LPARAM)&hi );
  451.       hw[i] = hi.cxy;
  452.       hx[i+1] = hx[i] + hw[i];
  453.     }
  455.   oldBkMode = SetBkMode( hDC, TRANSPARENT );
  457.   for( i = 0; i < lpe->iNum; i++ )
  458.     {
  459.       // compute rectangle for track title
  460.       rc.left = hx[1] + 5 - lpe->dx;
  461.       rc.right = rc.left + hw[1] - 10;
  462.       rc.top = 6 + (lpe->iHeaderHeight + i*(lpe->iTextHeight+4) ) - lpe->dy;
  463.       rc.bottom = rc.top + 16;
  465.       if ( i == lpe->iSelected )
  466.         {
  467.           SetBkMode( hDC, OPAQUE );
  468.           oldBkColor = SetBkColor( hDC, RGB(20,20,140) );
  469.           oldTextColor = SetTextColor( hDC, oldBkColor );
  470.         }
  471.       DrawText( hDC, lpe->tracks[i].name, lstrlen( lpe->tracks[i].name ), &rc, DT_VCENTER );
  472.       if ( i == lpe->iSelected )
  473.         {
  474.           SetBkMode( hDC, TRANSPARENT );
  475.           SetBkColor( hDC, oldBkColor );
  476.           SetTextColor( hDC, oldTextColor );
  477.         }
  479.       // compute rectangle for status text
  480.       rc.left = hx[3] + 5 - lpe->dx;
  481.       rc.right = rc.left + hw[3] - 10;
  482.       DrawText( hDC, lpe->tracks[i].status, lstrlen( lpe->tracks[i].status ),
  483.                 &rc, DT_VCENTER );
  485.       rc.left = hx[2] + 5 - lpe->dx;
  486.       rc.right = rc.left + hw[2] - 10;
  488.       len = lpe->tracks[i].len / 75;
  489.       wsprintf( buf, "%02d:%02d", len / 60, len % 60 );
  490.       DrawText( hDC, buf, lstrlen( buf ), &rc, DT_VCENTER );
  492.       // draw check box
  493.       pts[0].x = pts[3].x = pts[4].x = ((hx[1]+1)/2 - 4) - lpe->dx;
  494.       pts[1].x = pts[2].x = pts[0].x + 8;
  495.       pts[0].y = pts[1].y = pts[4].y = rc.top + 5;
  496.       pts[2].y = pts[3].y = rc.top + 13;
  497.       hOldPen = SelectObject( hDC, lpe->hBrownPen );
  498.       Polyline( hDC, pts, 5 );
  500.       if ( lpe->tracks[i].bChecked )
  501.         {
  502.           SelectObject( hDC, lpe->hBlackPen );
  503.           pts[0].x += 2;
  504.           pts[0].y += 3;
  505.           pts[1].x = pts[0].x + 2;
  506.           pts[1].y = pts[0].y + 3;
  507.           pts[2].x = pts[1].x + 7;
  508.           pts[2].y = pts[1].y - 7;
  509.           Polyline( hDC, pts, 3 );
  511.           pts[0].x += 1;
  512.           pts[1].x = pts[0].x + 2;
  513.           pts[1].y = pts[0].y + 3;
  514.           pts[2].x = pts[1].x + 7;
  515.           pts[2].y = pts[1].y - 7;
  516.           Polyline( hDC, pts, 3 );
  517.         }
  518.       SelectObject( hDC, hOldPen );
  519.     }
  521.   SetBkMode( hDC, oldBkMode );
  523.   EndPaint( hWnd, &p );
  524. }
  527. HFONT CreateTrackWndFont( HDC hDC )
  528. {
  529.   LOGFONT lf;
  531.   ZeroMemory( &lf, sizeof(lf) );
  532.   lf.lfHeight = -MulDiv( 12, GetDeviceCaps( hDC, LOGPIXELSY), 72 );
  533.   lf.lfCharSet = DEFAULT_CHARSET;
  534.   lf.lfOutPrecision = OUT_TT_PRECIS;
  535.   lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
  536.   lf.lfQuality = DEFAULT_QUALITY;
  537.   lf.lfPitchAndFamily = FF_MODERN | DEFAULT_PITCH;
  538.   strcpy( lf.lfFaceName, "Courier New" );
  540.   return CreateFontIndirect( &lf );
  541. }
  544. void RecalcWindow( HWND hWnd, LPTRACKWNDEXTRA lpe )
  545. {
  546.   RECT rc;
  547.   SCROLLINFO si;
  548.   int i;
  550.   /*
  551.    * compute the offsets for each header section, used for mouse hit testing
  552.    * The paint code will recompute on a per paint basis
  553.    */
  554.   ZeroMemory( lpe->hw, sizeof(int[5]) );
  555.   ZeroMemory( lpe->hx, sizeof(int[5]) );
  556.   for( i = 0; i < 3; i++ )
  557.     {
  558.       HD_ITEM hi;
  559.       ZeroMemory( &hi, sizeof(hi) );
  560.       hi.mask = HDI_WIDTH;
  561.       SendMessage( lpe->hHeader, HDM_GETITEM, i, (LPARAM)&hi );
  562.       lpe->hw[i] = hi.cxy;
  563.       lpe->hx[i+1] = lpe->hx[i] + lpe->hw[i];
  564.     }
  566.   GetClientRect( hWnd, &rc );
  567.   lpe->vh = lpe->iNum * (lpe->iTextHeight + 4) + lpe->iHeaderHeight + 5;
  569.   ZeroMemory( &si, sizeof(si) );
  570.   si.cbSize = sizeof(si);
  571.   si.fMask  = SIF_PAGE | SIF_RANGE;
  572.   si.nMin   = 0;
  573.   si.nMax   = lpe->vh;
  574.   si.nPage  = rc.bottom;
  575.   si.nPos   = lpe->dy;
  577. #if 0
  578.   if ( !lpe->bVScroll )
  579. #endif
  580.     si.fMask |= SIF_POS;
  582.   SetScrollInfo( hWnd, SB_VERT, &si, TRUE );
  584.   if ( lpe->bVScroll && ( lpe->vh < rc.bottom ) )
  585.     lpe->bVScroll = FALSE;
  586.   else if ( !lpe->bVScroll && ( lpe->vh > rc.bottom ) )
  587.     lpe->bVScroll = TRUE;
  589.   if ( lpe->bVScroll == FALSE )
  590.     lpe->dy = 0;
  592.   ZeroMemory( &si, sizeof(si) );
  593.   si.cbSize = sizeof(si);
  594.   si.fMask  = SIF_PAGE | SIF_RANGE;
  595.   si.nMin   = 0;
  596.   si.nMax   = lpe->vw;
  597.   si.nPage  = rc.right;
  598.   si.nPos   = lpe->dx;
  600.   if ( !lpe->bHScroll )
  601.     si.fMask |= SIF_POS;
  603.   SetScrollInfo( hWnd, SB_HORZ, &si, TRUE );
  605.   if ( lpe->bHScroll && ( lpe->vw < rc.right ) )
  606.     lpe->bHScroll = FALSE;
  607.   else if ( !lpe->bHScroll && ( lpe->vw > rc.right ) )
  608.     lpe->bHScroll = TRUE;
  610.   if ( lpe->bHScroll == FALSE )
  611.     lpe->dx = 0;
  613.   ComputeHeaderPos( lpe->hHeader, hWnd );
  614. }
  617. void DeleteTrack( HWND hWnd, int iTrack, LPTRACKWNDEXTRA lpe )
  618. {
  619.   int i;
  621.   hWnd = hWnd;
  622.   if ( iTrack == (int)ALLTRACKS )
  623.     {
  624.       lpe->iSelected = -1;
  625.       lpe->iNum = 0;
  626.       return;
  627.     }
  629.   if ( iTrack > lpe->iNum )
  630.     return;
  632.   lpe->iSelected = -1;
  633.   for( i = iTrack; i < lpe->iNum; i++ )
  634.     {
  635.       lpe->tracks[i] = lpe->tracks[i+1];
  636.     }
  637.   lpe->iNum--;
  638. }
  641. void HandleHScroll( HWND hWnd, int nScrollCode, int nPos, LPTRACKWNDEXTRA lpe )
  642. {
  643.   hWnd = hWnd; nScrollCode = nScrollCode; nPos = nPos; lpe = lpe;
  644. }
  646. void HandleVScroll( HWND hWnd, int nScrollCode, int nPos, LPTRACKWNDEXTRA lpe )
  647. {
  648.   RECT rc;
  649.   SCROLLINFO si;
  651.   GetClientRect( hWnd, &rc );
  653.   si.cbSize   = sizeof(si);
  654.   si.fMask    = SIF_ALL;
  655.   GetScrollInfo( hWnd, SB_VERT, &si );
  657.   // one line of text takes up lpe->iTextHeight + 4 units
  658.   switch( nScrollCode )
  659.     {
  660.     case SB_BOTTOM: break;
  661.     case SB_ENDSCROLL: break;
  662.     case SB_LINEDOWN:
  663.       lpe->dy = min( lpe->dy + lpe->iTextHeight + 4, 
  664.                      lpe->vh - (rc.bottom-1) );
  665.       break;
  667.     case SB_LINEUP:
  668.       lpe->dy = max( 0, lpe->dy - (lpe->iTextHeight+4) );
  669.       break;
  671.     case SB_PAGEDOWN:
  672.       lpe->dy = min( lpe->dy + rc.bottom, lpe->vh - (rc.bottom-1) );
  673.       break;
  675.     case SB_PAGEUP:
  676.       lpe->dy = max( 0, lpe->dy - rc.bottom );
  677.       break;
  679.     case SB_THUMBPOSITION:
  680.       lpe->dy = nPos;
  681.       break;
  683.     case SB_THUMBTRACK:
  684.       lpe->dy = nPos;
  685.       break;
  687.     case SB_TOP: break;
  688.       break;
  690.     default: 
  691.       //OutputDebugString( "Unknown scroll-bar message" );
  692.       break;
  693.     }
  694. }
  699. HWND createHeader( HWND hWnd, HINSTANCE hInst )
  700. {
  701.   HD_ITEM hdi;
  702.   HWND hRet;
  704.   hRet = CreateWindowEx( 0L, WC_HEADER, "",
  705.                          WS_CHILD | WS_BORDER | HDS_HORZ,
  706.                          0, 0, 0, 0,
  707.                          hWnd, (HMENU)IDM_HEADER, hInst, NULL );
  708.   if ( !hRet )
  709.     return NULL;
  711.   ComputeHeaderPos( hRet, hWnd );
  713.   hdi.mask    = HDI_FORMAT | HDI_WIDTH;
  714.   hdi.cxy     = 30;
  715.   hdi.fmt     = HDF_LEFT | HDF_STRING;
  716.   SendMessage( hRet, HDM_INSERTITEM, 9999, (LPARAM)&hdi );
  718.   hdi.mask    = HDI_TEXT | HDI_FORMAT | HDI_WIDTH;
  719.   hdi.pszText = "Title";
  720.   hdi.cxy     = 200;
  721.   hdi.cchTextMax = lstrlen( hdi.pszText );
  722.   hdi.fmt     = HDF_LEFT | HDF_STRING;
  723.   SendMessage( hRet, HDM_INSERTITEM, 9999, (LPARAM)&hdi );
  725.   hdi.mask    = HDI_TEXT | HDI_FORMAT | HDI_WIDTH;
  726.   hdi.pszText = "Time";
  727.   hdi.cxy     = 70;
  728.   hdi.cchTextMax = lstrlen( hdi.pszText );
  729.   hdi.fmt     = HDF_LEFT | HDF_STRING;
  730.   SendMessage( hRet, HDM_INSERTITEM, 9999, (LPARAM)&hdi );
  732.   hdi.mask    = HDI_TEXT | HDI_FORMAT | HDI_WIDTH;
  733.   hdi.pszText = "Status";
  734.   hdi.cxy     = 200;
  735.   hdi.cchTextMax = lstrlen( hdi.pszText );
  736.   hdi.fmt     = HDF_LEFT | HDF_STRING;
  737.   SendMessage( hRet, HDM_INSERTITEM, 9999, (LPARAM)&hdi );
  739.   return hRet;
  740. }
  744. void ComputeHeaderPos( HWND hHdr, HWND hParent )
  745. {
  746.   WINDOWPOS wp;
  747.   HD_LAYOUT hdl;
  748.   RECT rc;
  750.   GetClientRect( hParent, &rc );
  751.   hdl.prc = &rc;
  752.   hdl.pwpos = &wp;
  753.   SendMessage( hHdr, HDM_LAYOUT, 0, (LPARAM)&hdl );
  754.   SetWindowPos( hHdr, wp.hwndInsertAfter, wp.x, wp.y, wp.cx, wp.cy,
  755.                 wp.flags | SWP_SHOWWINDOW );
  756. }
  759. BOOL handleHeaderNotify( HWND hWnd, LPARAM lParam, LPTRACKWNDEXTRA lpe )
  760. {
  761.   HD_NOTIFY *lphd = (HD_NOTIFY *)lParam;
  762.   LPNMHDR lpnm = (LPNMHDR)lParam;
  764. #if 0
  765.   if ( lpnm->code <= HDN_FIRST && lpnm->code >= HDN_LAST )
  766.     {
  767.       wsprintf( buf, "Header notify[%04X:%d:%d]: %s", lphd->hdr.hwndFrom, lphd->iItem,lphd->iButton,  notifyString( lphd->hdr.code ) );
  768.     }
  769.   else
  770.     wsprintf( buf, "Header notify[%04X]: %s", lphd->hdr.hwndFrom,  notifyString( lphd->hdr.code ) );
  772.   OutputDebugString( buf );
  773. #endif
  775.   switch( lpnm->code )
  776.     {
  777.     case HDN_ITEMCHANGED:
  778.       RecalcWindow( hWnd, lpe );
  779.       InvalidateRect( hWnd, NULL, TRUE );
  780.       UpdateWindow( hWnd );
  781.       break;
  783.     case HDN_BEGINTRACK:
  784.       SetFocus( hWnd );
  785.       // prevent the first header from changing
  786.       if ( lphd->iItem == 0 )
  787.         return TRUE;
  788.       break;
  789.     }
  791.   return FALSE;
  792. }
  795. #ifndef NM_CUSTOMDRAW
  796. #define NM_CUSTOMDRAW     (NM_FIRST-12)
  797. #endif
  799. #ifndef NM_RELEASEDCAPTURE
  800. #define NM_RELEASEDCAPTURE   (NM_FIRST-16)
  801. #endif
  803. char *notifyString( UINT code )
  804. {
  805.   static char buf[60];
  806.   switch( code )
  807.     {
  808.     case NM_CUSTOMDRAW: return "NM_CUSTOMDRAW";
  809.     case NM_CLICK: return "NM_CLICK";
  810.     case NM_DBLCLK: return "NM_DBLCLK";
  811.     case NM_KILLFOCUS: return "NM_KILLFOCUS";
  812.     case NM_OUTOFMEMORY: return "NM_OUTOFMEMORY";
  813.     case NM_RCLICK: return "NM_RCLICK";
  814.     case NM_RDBLCLK: return "NM_RDBLCLK";
  815.     case NM_RETURN: return "NM_RETURN";
  816.     case NM_SETFOCUS: return "NM_SETFOCUS";
  817.     case NM_RELEASEDCAPTURE: return "NM_RELEASEDCAPTURE";
  818.     case HDN_BEGINTRACK: return "HDN_BEGINTRACK";
  819.     case HDN_DIVIDERDBLCLICK: return "NM_DIVIDERDBLCLICK";
  820.     case HDN_ENDTRACK: return "HDN_ENDTRACK";
  821.     case HDN_ITEMCHANGED: return "HDN_ITEMCHANGED";
  822.     case HDN_ITEMCHANGING: return "HDN_ITEMCHANGING";
  823.     case HDN_ITEMCLICK: return "HDN_ITEMCLICK";
  824.     case HDN_ITEMDBLCLICK: return "HDN_ITEMDBLCLICK";
  825.     case HDN_TRACK: return "HDN_TRACK";
  826.     default: wsprintf( buf, "unknown %04X (%d)", code, code ); return buf;
  827.     }
  828. }
  830. /*
  831.  * determines if a mouse click (in window coordinates) was on a check box.
  832.  * If so, returns the index of the track.  If not, returns -1
  833.  */
  834. int CheckBoxHit( LPTRACKWNDEXTRA lpe, LPARAM lParam )
  835. {
  836.   int i, x, y;
  837.   int mx, my;
  839.   mx = (int)LOWORD(lParam) + lpe->dx;
  840.   my = (int)HIWORD(lParam) + lpe->dy;
  842.   for( i = 0; i < lpe->iNum; i++ )
  843.     {
  844.       x = (lpe->hx[1] + 1) / 2 - 4;   // left side x value
  845.       y = 11 + lpe->iHeaderHeight + i*(lpe->iTextHeight + 4);
  846.       if ( (mx >= x) && (mx <= (x+8)) && (my >= y) && (my <= (y+8)) )
  847.         return i;
  848.     }
  850.   return -1;
  851. }
  854. /*
  855.  * Determines if a mouse click was on a track name on the screen.  lParam
  856.  * is expected to be in client coordinates, as sent with the WM_LBUTTONDOWN,
  857.  * etc. messages.  Returns the index of the track hit, or -1 if not on a
  858.  * track name
  859.  */
  860. int TrackNameHit( LPTRACKWNDEXTRA lpe, LPARAM lParam )
  861. {
  862.   int i, x, y;
  863.   int mx, my;
  864.   RECT rc;
  866.   // if it's within the header, return -1 (no track hit)
  867.   if ( ((int)HIWORD(lParam)) <= lpe->iHeaderHeight )
  868.     return -1;
  870.   mx = (int)LOWORD(lParam) + lpe->dx;
  871.   my = (int)HIWORD(lParam) + lpe->dy;
  874.   for( i = 0; i < lpe->iNum; i++ )
  875.     {
  876.       x = lpe->hx[1] + 1;
  877.       y = 6 + lpe->iHeaderHeight + i*(lpe->iTextHeight + 4);
  879.       rc.left = x;
  880.       rc.right = x + lpe->hw[1];
  881.       rc.top = y;
  882.       rc.bottom = y + lpe->iTextHeight;
  884.       if ( (mx >= rc.left) && (mx <= rc.right) && (my >= rc.top) &&
  885.            (my <= rc.bottom) )
  886.         return i;
  887.     }
  889.   return -1;
  890. }
  892. /*
  893.  * returns TRUE if the mouse click was on either a check box or a track name,
  894.  * and will require a repaint
  895.  */
  896. BOOL HandleLMouseDown( HWND hWnd, LPTRACKWNDEXTRA lpe, LPARAM lParam )
  897. {
  898.   int i;
  900.   SetFocus( hWnd );
  902.   // determine if the click was on a check box
  903.   i = CheckBoxHit( lpe, lParam );
  904.   if ( i != -1 )
  905.     {
  906.       lpe->tracks[i].bChecked = !lpe->tracks[i].bChecked;
  907.       UpdateStatusBar();
  908.       return TRUE;
  909.     }
  911.   i = TrackNameHit( lpe, lParam );
  912.   if ( i != -1 )
  913.     {
  914.       lpe->iSelected = i;
  915.       return TRUE;
  916.     }
  918.   return FALSE;
  919. }
  921. /*
  922.  * returns TRUE if the mouse click was on either a check box or a track name,
  923.  * and will require a repaint
  924.  */
  925. BOOL HandleRMouseDown( HWND hWnd, LPTRACKWNDEXTRA lpe, LPARAM lParam )
  926. {
  927.   int i;
  929.   SetFocus( hWnd );
  931.   // did we hit a track name?
  932.   i = TrackNameHit( lpe, lParam );
  933.   if ( i != -1 )
  934.     {
  935.       lpe->iSelected = i;
  936.       return TRUE;
  937.     }
  939.   return FALSE;
  940. }
  943. /*
  944.  * if trackNo == -1, then check/uncheck all
  945.  */
  946. BOOL HandleCheckTrack( HWND hWnd, LPTRACKWNDEXTRA lpe, int trackNo, BOOL bChecked )
  947. {
  948.   int i;
  950.   hWnd = hWnd;
  951.   if ( trackNo == (int)ALLTRACKS )
  952.     {
  953.       for( i = 0; i < lpe->iNum; i++ )
  954.         lpe->tracks[i].bChecked = bChecked;
  955.       return TRUE;
  956.     }
  958.   if ( trackNo < 0 || trackNo >= lpe->iNum )
  959.     return FALSE;
  961.   lpe->tracks[trackNo].bChecked = bChecked;
  963.   return TRUE;
  964. }
  966. /*
  967.  * if trackNo == -1, then check/uncheck all
  968.  */
  969. BOOL HandleInvertCheck( HWND hWnd, LPTRACKWNDEXTRA lpe, int trackNo )
  970. {
  971.   int i;
  973.   hWnd = hWnd;
  974.   if ( trackNo == (int)ALLTRACKS )
  975.     {
  976.       for( i = 0; i < lpe->iNum; i++ )
  977.         lpe->tracks[i].bChecked = !lpe->tracks[i].bChecked;
  978.       return TRUE;
  979.     }
  981.   if ( trackNo < 0 || trackNo >= lpe->iNum )
  982.     return FALSE;
  984.   lpe->tracks[trackNo].bChecked = !lpe->tracks[trackNo].bChecked;
  986.   return TRUE;
  987. }
  990. int doTrackContextMenu( HWND hParent, HWND hChild, LPARAM lParam )
  991. {
  992.   HMENU hMenu, hPopup;
  993.   LPTRACKWNDEXTRA lpe;
  994.   int i;
  995.   POINT p;
  996.   LPARAM lp2;
  998.   p.x = (LONG)LOWORD(lParam);
  999.   p.y = (LONG)HIWORD(lParam);
  1000.   ScreenToClient( hChild, &p );
  1001.   lp2 = MAKELPARAM( p.x, p.y );
  1003.   lpe = (LPTRACKWNDEXTRA)GetWindowLong( hChild, GWL_USERDATA);
  1005.   if ( p.y < lpe->iHeaderHeight )
  1006.     return 0;
  1008.   // if it hit a track name, then we need to pop up the track context menu
  1009.   // otherwise, we need a generic context menu
  1010.   i = TrackNameHit( lpe, lp2 );
  1011.   if ( i != -1 )
  1012.     {
  1013.       hMenu = LoadMenu( ghInstance, "trackPopupMenu" );
  1014.       if ( !hMenu )
  1015.         return 0;
  1017.       hPopup = GetSubMenu( hMenu, 0 );
  1018.       TrackPopupMenu( hPopup, TPM_LEFTALIGN | TPM_RIGHTBUTTON,
  1019.                       LOWORD(lParam), HIWORD(lParam), 0, hParent, NULL );
  1020.     }
  1021.   else
  1022.     {
  1023.       hMenu = LoadMenu( ghInstance, "genericPopupMenu" );
  1024.       if ( !hMenu )
  1025.         return 0;
  1027.       // pop up a more generic menu
  1028.       hPopup = GetSubMenu( hMenu, 0 );
  1029.       TrackPopupMenu( hPopup, TPM_LEFTALIGN | TPM_RIGHTBUTTON,
  1030.                       LOWORD(lParam), HIWORD(lParam), 0, hParent, NULL );
  1031.     }
  1033.   DestroyMenu( hMenu );
  1035.   return 1;
  1036. }
  1040. /*
  1041.  * Pops up a sub-classed single-line edit on top of track title.  Must ensure
  1042.  * that the selected track is visible.  Captures mouse input to catch when
  1043.  * user clicks elsewhere, and saves the text.
  1044.  */
  1045. BOOL RenameSelectedTrack( HWND hWnd, LPTRACKWNDEXTRA lpe )
  1046. {
  1047.   int hw[5];            // width of header items
  1048.   int hx[5];            // x offset of header items
  1049.   int i;
  1050.   RECT rc;
  1051.   //HWND hEdit;
  1053.   if ( bInEditTrack )
  1054.     return FALSE;
  1056.   bInEditTrack = TRUE;
  1058.   if ( (lpe->iSelected < 0) || (lpe->iSelected >= lpe->iNum) )
  1059.     return FALSE;
  1061.   /*
  1062.    * compute the offsets for each header section
  1063.    */
  1064.   ZeroMemory( hw, sizeof(int[5]) );
  1065.   ZeroMemory( hx, sizeof(int[5]) );
  1066.   for( i = 0; i < 3; i++ )
  1067.     {
  1068.       HD_ITEM hi;
  1069.       ZeroMemory( &hi, sizeof(hi) );
  1070.       hi.mask = HDI_WIDTH;
  1071.       SendMessage( lpe->hHeader, HDM_GETITEM, i, (LPARAM)&hi );
  1072.       hw[i] = hi.cxy;
  1073.       hx[i+1] = hx[i] + hw[i];
  1074.     }
  1076.   i = lpe->iSelected;
  1077.   rc.left = hx[1] + 5 - lpe->dx;
  1078.   rc.right = rc.left + hw[1] - 10;
  1079.   rc.top = 4 + (lpe->iHeaderHeight + i*(lpe->iTextHeight+4) ) - lpe->dy;
  1080.   rc.bottom = rc.top + 20;
  1082.   hEdit = CreateWindowEx( 0L, "EDIT", lpe->tracks[lpe->iSelected].name,
  1083.                           WS_BORDER | WS_CHILD | WS_VISIBLE
  1084.                           | ES_AUTOHSCROLL | ES_LEFT,
  1085.                           rc.left, rc.top,
  1086.                           rc.right - rc.left, rc.bottom - rc.top,
  1087.                           hWnd, (HMENU)++iCtlId, ghInstance, NULL );
  1089.   // Save old window proc
  1090.   SetWindowLong( hEdit, GWL_USERDATA, GetWindowLong( hEdit, GWL_WNDPROC ) );
  1091.   // Set new window proc
  1092.   SetWindowLong( hEdit, GWL_WNDPROC, (LONG)EditSubclassWndProc );
  1094.   SetFocus( hEdit );
  1095.   SendMessage( hEdit, EM_SETLIMITTEXT, (WPARAM)(MAX_PATH+1), 0L );
  1096.   SendMessage( hEdit, EM_SETSEL, 0, -1L );
  1097.   //SendMessage( hEdit, WM_STARTMOUSECAPTURE, 0, 0L );
  1099.   SetCapture( hEdit );
  1101.   return TRUE;
  1102. }
  1105. LRESULT processFindFirst( LPTRACKWNDEXTRA lpe, LPADDTRACK lpAddTrack )
  1106. {
  1107.   int i;
  1109.   if ( lpAddTrack == NULL )
  1110.     return -1L;
  1112.   for( i = 0; i < lpe->iNum; i++ )
  1113.     {
  1114.       if ( lpe->tracks[i].bChecked )
  1115.         {
  1116.           *lpAddTrack = lpe->tracks[i];
  1117.           lpe->iFound = i;
  1118.           return i;
  1119.         }
  1120.     }
  1122.   return -1L;
  1123. }
  1126. LRESULT processFindNext( LPTRACKWNDEXTRA lpe, LPADDTRACK lpAddTrack )
  1127. {
  1128.   int i;
  1130.   if ( lpAddTrack == NULL )
  1131.     return -1L;
  1133.   for( i = lpe->iFound + 1; i < lpe->iNum; i++ )
  1134.     {
  1135.       if ( lpe->tracks[i].bChecked )
  1136.         {
  1137.           *lpAddTrack = lpe->tracks[i];
  1138.           lpe->iFound = i;
  1139.           return i;
  1140.         }
  1141.     }
  1143.   return -1L;
  1144. }
  1147. BOOL setTrackStatus( LPTRACKWNDEXTRA lpe, int idx, LPCSTR s )
  1148. {
  1149.   if ( !lpe || !s )
  1150.     return FALSE;
  1152.   lstrcpyn( lpe->tracks[idx].status, s, 61 );
  1153.   return TRUE;
  1154. }
  1157. #ifndef WM_MOUSEHOVER
  1158. #define WM_MOUSEHOVER 0x2A1
  1159. #endif
  1160. #ifndef WM_MOUSELEAVE
  1161. #define WM_MOUSELEAVE 0x2A3
  1162. #endif
  1163. void logWindowsProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  1164. {
  1165. #if 0
  1166.   char szMsg[40];
  1167.   static UINT filtered[] = {
  1168.     WM_MOUSEMOVE, WM_MOUSEHOVER, WM_MOUSELEAVE, WM_SETCURSOR, WM_NCHITTEST, 0
  1169.   };
  1170.   int i;
  1172.   hWnd = hWnd, wParam = wParam; lParam = lParam;
  1174.   for( i = 0; filtered[i]; i++ )
  1175.     if ( uMsg == filtered[i] )
  1176.       return;
  1177.   
  1178.   convertuMsg( uMsg, szMsg );
  1179. #else
  1180.   hWnd = hWnd; uMsg = uMsg; wParam = wParam; lParam = lParam;
  1181. #endif
  1182. }
  1185. void convertuMsg( UINT uMsg, char * s )
  1186. {
  1187.   switch( uMsg )
  1188.     {
  1189.     case WM_COMMAND: lstrcpy( s, "WM_COMMAND" ); break;
  1190.     case WM_INITDIALOG: lstrcpy( s, "WM_INITDIALOG" ); break;
  1191.     default:
  1192.       wsprintf( s, "%d", uMsg );
  1193.       break;
  1194.     }
  1195. }
  1197. LRESULT CALLBACK EditSubclassWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  1198. {
  1199.   WNDPROC lpfnWndProc;
  1200.   int x, y;
  1201.   RECT rc;
  1203.   lpfnWndProc = (WNDPROC)GetWindowLong( hWnd, GWL_USERDATA );
  1205. #if 0
  1206.   switch( uMsg )
  1207.     {
  1208.     case EM_CANUNDO: OutputDebugString( "EM_CANUNDO" ); break;
  1209.     case EM_CHARFROMPOS: OutputDebugString( "EM_CHARFROMPOS" ); break;
  1210.     case EM_EMPTYUNDOBUFFER: OutputDebugString( "EM_EMPTYUNDOBUFFER" ); break;
  1211.     case EM_GETFIRSTVISIBLELINE: OutputDebugString( "EM_GETFIRSTVISIBLELINE" ); break;
  1212.     case EM_GETLIMITTEXT: OutputDebugString( "EM_GETLIMITTEXT" ); break;
  1213.     case EM_GETLINE: OutputDebugString( "EM_GETLINE" ); break;
  1214.     case EM_GETMARGINS: OutputDebugString( "EM_GETMARGINS" ); break;
  1215.     case EM_GETMODIFY: OutputDebugString( "EM_GETMODIFY" ); break;
  1216.     case EM_GETRECT: OutputDebugString( "EM_GETRECT" ); break;
  1217.     case EM_GETSEL: OutputDebugString( "EM_GETSEL" ); break;
  1218.     case EM_LINELENGTH: OutputDebugString( "EM_LINELENGTH" ); break;
  1219.     case EM_POSFROMCHAR: OutputDebugString( "EM_POSFROMCHAR" ); break;
  1220.     case EM_REPLACESEL: OutputDebugString( "EM_REPLACESEL" ); break;
  1221.     case EM_SETLIMITTEXT: OutputDebugString( "EM_SETLIMITTEXT" ); break;
  1222.     case EM_SETMARGINS: OutputDebugString( "EM_SETMARGINS" ); break;
  1223.     case EM_SETMODIFY: OutputDebugString( "EM_SETMODIFY" ); break;
  1224.     case EM_SETREADONLY: OutputDebugString( "EM_SETREADONLY" ); break;
  1225.     case EM_SETSEL: OutputDebugString( "EM_SETSEL" ); break;
  1226.     case EM_UNDO: OutputDebugString( "EM_UNDO" ); break;
  1227.     case WM_COMMAND:
  1228.       switch( HIWORD(wParam) )
  1229.         {
  1230.         case EN_SETFOCUS: OutputDebugString( "EN_SETFOCUS: edit control" ); break;
  1231.         case EN_KILLFOCUS: OutputDebugString( "EN_KILLFOCUS: edit control" ); break;
  1232.         case EN_CHANGE: OutputDebugString( "EN_CHANGE" ); break;
  1233.         case EN_ERRSPACE: OutputDebugString( "EN_ERRSPACE" ); break;
  1234.         case EN_MAXTEXT: OutputDebugString( "EN_MAXTEXT" ); break;
  1235.         case EN_UPDATE: OutputDebugString( "EN_UPDATE" ); break;
  1236.         }
  1237.       break;
  1238.     }
  1239. #endif
  1241.   switch( uMsg )
  1242.     {
  1243.     case WM_LBUTTONDOWN:
  1244.     case WM_RBUTTONDOWN:
  1245.       GetClientRect( hWnd, &rc );
  1246.       x = (int)LOWORD( lParam );
  1247.       y = (int)HIWORD( lParam );
  1248.       if ( (x < 0) || ( y < 0) || (x > rc.right) || (y > rc.bottom) )
  1249.         {
  1250.           POINT p;
  1252.           SetTrackWndText( hWnd );
  1253.           ReleaseCapture();
  1254.           bInEditTrack = FALSE;
  1255.           p.x = x; p.y = y; MapWindowPoints( hWnd, GetParent(hWnd ), &p, 1 );
  1256.           SendMessage( GetParent(hWnd), uMsg, wParam,
  1257.                        (LPARAM)MAKELONG( p.x, p.y ) );
  1258.           DestroyWindow( hWnd );
  1259.           return 0L;
  1260.         }
  1261.       break;
  1263.     case WM_LBUTTONUP:
  1264.       break;
  1266.     case WM_KEYDOWN:
  1267.       if ( (int)wParam == 27 ) // escape key
  1268.         {
  1269.           //SetTrackWndText( hWnd );
  1270.   bInEditTrack = FALSE;
  1271.           DestroyWindow( hWnd );
  1272.           return 0L;
  1273.         }
  1274.       break;
  1276.     case WM_CAPTURECHANGED:
  1277.       break;
  1278.     }
  1280.   return CallWindowProc( lpfnWndProc, hWnd, uMsg, wParam, lParam );
  1281. }
  1284. void SetTrackWndText( HWND hWnd )
  1285. {
  1286.   char buf[MAX_PATH+1];
  1288.   ZeroMemory( buf, MAX_PATH+1 );
  1289.   SendMessage( hWnd, WM_GETTEXT, MAX_PATH+1, (LPARAM)buf );
  1290.   SendMessage( GetParent( hWnd ), WM_SETSELTEXT, 0, (LPARAM)buf );
  1291. }
  1294. LRESULT CALLBACK FooWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  1295. {
  1296.   return DefWindowProc( hWnd, uMsg, wParam, lParam );
  1297. }
  1300. LRESULT numChecked( LPTRACKWNDEXTRA lpe )
  1301. {
  1302.   int i;
  1303.   LRESULT retVal = 0;
  1305.   for( i = 0; lpe && (i < lpe->iNum); i++ )
  1306.     if ( lpe->tracks[i].bChecked )
  1307.       retVal++;
  1309.   return retVal;
  1310. }