Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/nw/convert/nwconv/columnlb.c

2987 lines
108 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
// ==================================================================================================
// COPYRIGHT 1992,1993 MICROSOFT CORP ALL RIGHTS RESERVED
// ==================================================================================================
//
// - Custom control to display Columns/Titles above a list box
//
// TERMINOLOGY:
// PHYSICAL COLUMNS: The index of the original columns in their original order
// VIRtUAL COLUMNS: The index of the column as the display is currently showing it based on
// the current order.
//
// History:
// -------
// RickD 04/10/92 created TitleListBox
// Tom Laird-McConnell 12/30/92 Ported to Win32, added to BH project
// Tom Laird-McConnell 05/01/93 gutted titlelist and used as base for complete rewrite as ColumnLB
// Tom Laird-McConnell 08/18/93 Added tabbed-delimited string support
// Arth 03/24/94 Added Unicode support
// ==================================================================================================
#define STRICT 1
#include "switches.h"
#include <windows.h>
#include <windowsx.h>
#include <string.h>
#include <stdlib.h>
// #include <dprintf.h>
#include "columnlb.h"
#include "vlist.h"
#include "utils.h"
#include "debug.h"
#include "mem.h"
//#define DEBUG_HSCROLL 1
#define WHITESPACE 8
#define IDL_COLUMNLISTBOX (CLB_BASE + 1)
#define IDL_COLUMNTITLELISTBOX (CLB_BASE + 2)
#define LB16_ADDSTRING (WM_USER+1)
#define LB16_INSERTSTRING (WM_USER+2)
typedef struct _COLRECORD
{
DWORD itemData;
LPTSTR pString[];
} COLRECORD;
typedef COLRECORD *LPCOLRECORD;
// -------------------------------------------------------------------------------------
//
// window procs
//
LRESULT CALLBACK ColumnLBClass_ListBoxWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK ColumnLBClass_WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
//
// system message handlers
//
BOOL ColumnLBClass_OnNCCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct);
void ColumnLBClass_OnNCDestroy(HWND hwnd);
void ColumnLBClass_OnDestroy(HWND hwnd);
void ColumnLBClass_OnPaint(HWND hwnd);
void ColumnLBClass_OnSize(HWND hwnd, UINT state, int cx, int cy);
void ColumnLBClass_OnSetFont(HWND hwnd, HFONT hfont, BOOL fRedraw);
LRESULT ColumnLBClass_OnHScroll(HWND hwnd, HWND hwndCtl, UINT code, int pos);
void ColumnLBClass_OnDrawItem(HWND hwnd, const DRAWITEMSTRUCT * lpDrawItem);
void ColumnLBClass_OnMeasureItem(HWND hwnd, LPMEASUREITEMSTRUCT lpMeasureItem);
void ColumnLBClass_OnDeleteItem(HWND hwnd, const DELETEITEMSTRUCT *lpDeleteItem);
int ColumnLBClass_OnCharToItem(HWND hwnd, UINT ch, HWND hwndListbox, int iCaret);
//
// WM_USER message handlers
//
BYTE ColumnLBClass_OnNumberCols(HWND hwnd, BYTE NewNumberCols, BOOL fSetColumns);
int ColumnLBClass_OnColWidth(HWND hwnd, BYTE Column, int NewWidth, BOOL fSetWidth);
LPTSTR ColumnLBClass_OnColTitle(HWND hwnd, BYTE Column, LPTSTR lpTitle, BOOL fSetTitle);
BYTE ColumnLBClass_OnSortCol(HWND hwnd, BYTE NewSortCol, BOOL fSetSortCol);
LPBYTE ColumnLBClass_OnColOrder(HWND hwnd, LPBYTE NewColOrder, BOOL fSetOrder);
LPINT ColumnLBClass_OnColOffsets(HWND hwnd, LPINT NewOffsetTable, BOOL fSetOffsets);
LRESULT ColumnLBClass_OnAutoWidth(HWND hwnd, BYTE ColumnToCompute);
//
// mouse movement messages
//
void ColumnLBClass_OnMouseMove(HWND hwnd, int x, int y, UINT keyFlags);
void ColumnLBClass_OnLButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
void ColumnLBClass_OnLButtonUp(HWND hwnd, int x, int y, UINT keyFlags);
void ColumnLBClass_OnRButtonDown (HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
// helper functions
int ColumnLBClass_ComputeOffsets(HWND hwnd);
// -------------------------------------------------------------------------------------
//
// Locals
//
BOOL fWIN32s; // flag for whether win32s (instead of win32/NT)
// -----------------------------------------------------------------
//
// ColumnLBClass_Register()
//
// This function is used to register the Column LB class with the system
//
// HISTORY:
// Tom Laird-McConnell 4/17/93 Created
//
// -----------------------------------------------------------------
BOOL ColumnLBClass_Register(HINSTANCE hInstance)
{
WNDCLASS WndClass;
fWIN32s = ((DWORD)GetVersion() & 0x80000000) ? TRUE : FALSE;
//
// Create the COLUMNLISTBOX class
//
WndClass.style = CS_PARENTDC | CS_DBLCLKS; // CS_GLOBALCLASS;
WndClass.lpfnWndProc = ColumnLBClass_WndProc;
WndClass.cbClsExtra = 0;
WndClass.cbWndExtra = sizeof(LPCOLUMNLBSTRUCT); // we store a pointer as instance data
WndClass.hInstance = hInstance;
WndClass.hIcon = 0;
WndClass.hCursor = LoadCursor(0, IDC_ARROW);
WndClass.hbrBackground = 0;
WndClass.lpszMenuName = 0;
WndClass.lpszClassName = COLUMNLBCLASS_CLASSNAME;
/* Register the normal title list box control */
return RegisterClass((LPWNDCLASS)&WndClass);
}
// -----------------------------------------------------------------
//
// ColumnVLBClass_Register()
//
// This function is used to register the Column VLIST LB class with the system
//
// HISTORY:
// Tom Laird-McConnell 4/17/93 Created
//
// -----------------------------------------------------------------
BOOL ColumnVLBClass_Register(HINSTANCE hInstance)
{
WNDCLASS WndClass;
fWIN32s = ((DWORD)GetVersion() & 0x80000000) ? TRUE : FALSE;
//
// Create the COLUMNVLISTBOX class
//
WndClass.style = CS_PARENTDC | CS_DBLCLKS; // CS_GLOBALCLASS;
WndClass.lpfnWndProc = ColumnLBClass_WndProc;
WndClass.cbClsExtra = 0;
WndClass.cbWndExtra = sizeof(LPCOLUMNLBSTRUCT); // we store a pointer as instance data
WndClass.hInstance = hInstance;
WndClass.hIcon = 0;
WndClass.hCursor = LoadCursor(0, IDC_ARROW);
WndClass.hbrBackground = 0;
WndClass.lpszMenuName = 0;
WndClass.lpszClassName = COLUMNVLBCLASS_CLASSNAME; // NOTE: this is a different name
/* Register the new control */
return(RegisterClass((LPWNDCLASS)&WndClass));
}
// -----------------------------------------------------------------
//
// ColumnLBClass_Unregister()
//
// This function is used to deregister the Column LB class with the system
//
// HISTORY:
// Tom Laird-McConnell 4/17/93 Created
//
// -----------------------------------------------------------------
BOOL ColumnLBClass_Unregister(HINSTANCE hInstance)
{
return(UnregisterClass(COLUMNLBCLASS_CLASSNAME, hInstance));
}
// -----------------------------------------------------------------
//
// ColumnVLBClass_Unregister()
//
// This function is used to deregister the Column VLIST LB class with the system
//
// HISTORY:
// Tom Laird-McConnell 4/17/93 Created
//
// -----------------------------------------------------------------
BOOL ColumnVLBClass_Unregister(HINSTANCE hInstance)
{
return(UnregisterClass(COLUMNVLBCLASS_CLASSNAME, hInstance));
}
// -----------------------------------------------------------------
// ColumnLBClass_ListBoxWndProc
//
// Window proc used in sub-classing the internal listbox to catch
// internal scroll events to keep title in sync with it...
//
// HISTORY:
// Tom Laird-McConnell 4/17/93 Created
//
// -----------------------------------------------------------------
LRESULT CALLBACK ColumnLBClass_ListBoxWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
DWORD result;
LPCOLUMNLBSTRUCT lpColumnLB;
// Everthing goes to normal listbox for processing
lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(GetParent(hwnd), (DWORD)0);
// preprocessing
switch (msg)
{
case WM_HSCROLL:
// do title hscroll first..
result = SendMessage(lpColumnLB->hwndTitleList, WM_HSCROLL, wParam, lParam);
break;
case WM_SETFOCUS:
lpColumnLB->fHasFocus = TRUE;
//dprintf ("SetFocus to ColumnLB\n");
break;
case WM_KILLFOCUS:
lpColumnLB->fHasFocus = FALSE;
//dprintf ("KillFocus to ColumnLB\n");
break;
}
//
// call the original listbox window proc
//
result = CallWindowProc((WNDPROC)(lpColumnLB->OldListboxProc), hwnd, msg, (WPARAM) wParam, (LPARAM)lParam);
//
// or if our parent has CLBS_NOTIFYLMOUSE style, then foward LMOUSE buttons
// or if our parent has CLBS_NOTIFYRMOUSE style, then foward RMOUSE buttons
//
switch (msg)
{
case WM_HSCROLL:
//
// if it is a Horizontal scrolls, then we foward to our parent so title can be moved
// in sync with listbox....
//
SendMessage(GetParent(hwnd), CLB_HSCROLL, wParam, lParam );
break;
case VLB_RESETCONTENT:
case LB_RESETCONTENT:
//
// if it is a LB_RESETCONTENT, or VLB_RESETCONTENT, then reset x position
//
SendMessage(GetParent(hwnd), CLB_HSCROLL, (WPARAM)SB_TOP, (LPARAM)NULL);
break;
case WM_LBUTTONDOWN :
case WM_LBUTTONUP :
case WM_LBUTTONDBLCLK :
//
// forward message to parent
//
if (GetWindowLong(GetParent(hwnd), GWL_EXSTYLE) & CLBS_NOTIFYLMOUSE)
SendMessage(GetParent(hwnd), msg, wParam, lParam);
break;
case WM_RBUTTONDOWN :
// case WM_RBUTTONUP :
case WM_RBUTTONDBLCLK :
//
// forward message to parent
//
// if (GetWindowLong(GetParent(hwnd), GWL_EXSTYLE) & CLBS_NOTIFYRMOUSE)
SendMessage(GetParent(hwnd), msg, wParam, lParam);
break;
default:
break;
}
return(result);
}
// -----------------------------------------------------------------
// ColumnLBClass_TitleListBoxWndProc
//
// Window proc used in sub-classing the internal Title listbox to catch
// internal mouse click events...
//
// HISTORY:
// Tom Laird-McConnell 4/17/93 Created
//
// -----------------------------------------------------------------
LRESULT CALLBACK ColumnLBClass_TitleListBoxWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
DWORD result;
LPCOLUMNLBSTRUCT lpColumnLB;
// Everthing goes to normal listbox for processing
lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(GetParent(hwnd), (DWORD)0);
//
// call the original listbox window proc
//
result = CallWindowProc((WNDPROC)(lpColumnLB->OldTitleListboxProc) , hwnd, msg, (WPARAM) wParam, (LPARAM)lParam);
//
// foward LMOUSE buttons, foward RMOUSE buttons
//
switch (msg)
{
#ifdef DEBUG_HSCROLL
case WM_HSCROLL:
dprintf(TEXT("ColumnLBClass_TitleListBoxProc: CallWindowProc(OldListboxProc) returned %ld to hwnd=%lx, wParam=%u, lParam=%u\n"), hwnd, wParam, lParam);
break;
#endif
case WM_MOUSEMOVE:
case WM_LBUTTONDOWN :
case WM_LBUTTONUP :
case WM_LBUTTONDBLCLK :
case WM_RBUTTONDOWN :
case WM_RBUTTONUP :
case WM_RBUTTONDBLCLK :
SendMessage(GetParent(hwnd), msg, wParam, lParam);
break;
case WM_SETFOCUS:
// we don't ever want the focus, so give it back to the parent...
SendMessage(GetParent(hwnd), msg, wParam, lParam);
break;
case WM_SIZE:
// we need to reset our idea of what our current scroll position is...
break;
}
return(result);
}
// -----------------------------------------------------------------
// ColumnLBClass_WndProc
//
// Main window proc for handling messages for both the ColumnLB and
// ColumnVLB classes...
//
// HISTORY:
// Tom Laird-McConnell 4/17/93 Created
//
// -----------------------------------------------------------------
LRESULT CALLBACK ColumnLBClass_WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0);
LPCOLRECORD lpRecord;
int result;
//
// check for ListBox message coming from application
// and forward them onto the listbox itself...
//
if ( ((fWIN32s == TRUE) && (msg >= WM_USER && msg < (WM_USER + LB_MSGMAX - LB_ADDSTRING + 1)) ) || // WIN32s version BUGBUG
((fWIN32s == FALSE) && (msg >= LB_ADDSTRING && msg < LB_MSGMAX)) || // NT version BUGBUG
((msg >= VLB_TOVLIST_MSGMIN) && (msg <= VLB_TOVLIST_MSGMAX)) // vlb sepcific APP->VLIST messages should be fowarded...
)
{
//
// OWNERDRAW parent, so just send it to the hwnd list child
//
return(SendMessage(lpColumnLB->hwndList, msg, wParam, lParam));
}
//
// check to see if message is a TO APPLCATION message from the child listbox
// which should be forwarded to application parent window
//
if ((msg >= VLB_TOAPP_MSGMIN) && (msg <= VLB_TOAPP_MSGMAX))
return(SendMessage(GetParent(hwnd), msg, wParam, lParam)); // forward to parent...
//
// since it's not a message passing through, then process this message
// as our own...
//
switch (msg)
{
HANDLE_MSG(hwnd, WM_NCCREATE, ColumnLBClass_OnNCCreate);
HANDLE_MSG(hwnd, WM_NCDESTROY, ColumnLBClass_OnNCDestroy);
HANDLE_MSG(hwnd, WM_DESTROY, ColumnLBClass_OnDestroy);
HANDLE_MSG(hwnd, WM_PAINT, ColumnLBClass_OnPaint);
HANDLE_MSG(hwnd, WM_SIZE, ColumnLBClass_OnSize);
HANDLE_MSG(hwnd, WM_DRAWITEM, ColumnLBClass_OnDrawItem);
HANDLE_MSG(hwnd, WM_MEASUREITEM, ColumnLBClass_OnMeasureItem);
HANDLE_MSG(hwnd, WM_DELETEITEM, ColumnLBClass_OnDeleteItem);
HANDLE_MSG(hwnd, WM_LBUTTONDOWN, ColumnLBClass_OnLButtonDown);
HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK, ColumnLBClass_OnLButtonDown);
HANDLE_MSG(hwnd, WM_LBUTTONUP, ColumnLBClass_OnLButtonUp);
HANDLE_MSG(hwnd, WM_MOUSEMOVE, ColumnLBClass_OnMouseMove);
case WM_RBUTTONDOWN:
// figure out what item we are on and tell our parent.
HANDLE_WM_RBUTTONDOWN ( hwnd, wParam, lParam, ColumnLBClass_OnRButtonDown );
break;
case WM_CREATE:
{
LPCREATESTRUCT lpCreate = (LPCREATESTRUCT) lParam;
ColumnLBClass_OnSize(hwnd, SIZE_RESTORED, lpCreate->cx, lpCreate->cy);
}
break;
// -------------------------------------------------------------------
// put System messages here which explicitly need to be passed to LISTBOX
//
case WM_SETFONT:
HANDLE_WM_SETFONT(hwnd, wParam, lParam, ColumnLBClass_OnSetFont);
break;
// put the focus on the list box if we get it
case WM_SETFOCUS:
lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0);
SetFocus(lpColumnLB->hwndList);
break;
case SBM_SETPOS :
case SBM_SETRANGE :
case SBM_SETRANGEREDRAW :
//
// need to foward SBM messages to both listboxes...
//
SendMessage(lpColumnLB->hwndTitleList, msg, wParam, lParam);
return(SendMessage(lpColumnLB->hwndList, msg, wParam, lParam));
case SBM_GETPOS :
case SBM_GETRANGE :
case SBM_ENABLE_ARROWS :
return(SendMessage(lpColumnLB->hwndList, msg, wParam, lParam));
// ------------------------------------------------------------------------------
//
// LB_XXXXXXX Messages (disguised as CLB_XXXXXX messages)
// to pass on to child listbox, if the parent didn't want us to
// be owner draw, then we implement ownerddraw default behavior ourself
//
// ------------------------------------------------------------------------------
case CLB_ADDSTRING:
case CLB_INSERTSTRING:
//
// if the parent is NOT handling OWNERDRAW, then we need to handle
//
if ( ! (lpColumnLB->Style & (LBS_OWNERDRAWFIXED | VLBS_OWNERDRAWFIXED)) )
{
LPTSTR lpColStart,lpTab;
LPTSTR lpStringBuffer;
int i;
lpRecord = (LPCOLRECORD)GlobalAllocPtr(GPTR, sizeof(COLRECORD) + sizeof(LPTSTR) * lpColumnLB->nColumns);
lpStringBuffer = (LPTSTR) GlobalAllocPtr(GPTR, (lstrlen((LPTSTR)lParam) * sizeof(TCHAR)) + sizeof(TCHAR));
if ((lpRecord) && (lpStringBuffer))
{
// now parse the tab-deliminated string and put into each pointer
lstrcpy(lpStringBuffer, (LPTSTR)lParam);
lpColStart = lpStringBuffer;
lpTab = lstrchr(lpStringBuffer, TEXT('\t'));
// fill in pointer table
for (i=0; i < lpColumnLB->nColumns; i++)
{
if (lpTab)
*lpTab = '\0';
else
{
// there was an error, not enough tabs!
GlobalFreePtr(lpRecord);
GlobalFreePtr(lpStringBuffer);
return(LB_ERR);
}
// store this pointer.
lpRecord->pString[i] = lpColStart;
// advance to next column text
lpColStart = lpTab + 1;
lpTab = lstrchr(lpColStart, TEXT('\t'));
}
lpRecord->itemData = 0;
// and now pass on our new lpRecord as the item being added to the listbox
return(SendMessage(lpColumnLB->hwndList, msg - CLB_BASE, wParam, (LPARAM)lpRecord));
}
else // an error has occured, free up any memory and return failure
{
if (lpStringBuffer)
GlobalFreePtr(lpStringBuffer);
if (lpRecord)
GlobalFreePtr(lpRecord);
return(LB_ERR);
}
}
else
//
// Parent is owner draw, so send it to the hwnd list child,
// but translate the message first to real LB_ message
//
return(SendMessage(lpColumnLB->hwndList, msg - CLB_BASE, wParam, lParam));
// and we also need to check for LB_GETTEXT to make it look like a string
case CLB_GETTEXT:
//
// if the parent is NOT handling OWNERDRAW, then we need to handle
//
if ( ! (lpColumnLB->Style & (LBS_OWNERDRAWFIXED | VLBS_OWNERDRAWFIXED)) )
{
LPTSTR p = (LPTSTR)lParam;
DWORD Length = 0;
DWORD x;
int i;
*p = '\0';
// and now pass on to get the text...
lpRecord = (LPCOLRECORD)SendMessage(lpColumnLB->hwndList, LB_GETITEMDATA, wParam, 0);
if (lpRecord == (LPCOLRECORD)LB_ERR)
return(LB_ERR);
for (i=0; i < lpColumnLB->nColumns ; i++ )
{
lstrcpy(p, lpRecord->pString[lpColumnLB->ColumnOrderTable[i]]);
lstrcat(p, TEXT("\t"));
x = lstrlen(p);
Length += x + sizeof(TCHAR);
p += x;
}
return(Length);
}
else
//
// Parent is owner draw, so send it to the hwnd list child,
// but translate the message first to real LB_ message
//
return(SendMessage(lpColumnLB->hwndList, msg - CLB_BASE, wParam, lParam));
case CLB_GETTEXTPTRS:
if ( ! (lpColumnLB->Style & (LBS_OWNERDRAWFIXED | VLBS_OWNERDRAWFIXED)) )
{
lpRecord = (LPCOLRECORD)SendMessage(lpColumnLB->hwndList, LB_GETITEMDATA, wParam, 0);
if (lpRecord == (LPCOLRECORD)LB_ERR)
return(LB_ERR);
return (LRESULT)lpRecord->pString;
}
else
return (LRESULT)NULL;
// we need to handle LB_GETTEXTLEN to return full tabbed length...
case CLB_GETTEXTLEN:
//
// if the parent is NOT handling OWNERDRAW, then we need to handle
//
if ( ! (lpColumnLB->Style & (LBS_OWNERDRAWFIXED | VLBS_OWNERDRAWFIXED)) )
{
LPTSTR p = (LPTSTR)lParam;
DWORD Length = 0;
int i;
// and now pass on to get the text...
lpRecord = (LPCOLRECORD)SendMessage(lpColumnLB->hwndList, LB_GETITEMDATA, wParam, 0);
if (lpRecord == (LPCOLRECORD)LB_ERR)
return(LB_ERR);
for (i=0; i < lpColumnLB->nColumns ; i++ )
{
Length += lstrlen(lpRecord->pString[lpColumnLB->ColumnOrderTable[i]]) + sizeof(TCHAR);
}
return(Length);
}
else
//
// Parent is owner draw, so send it to the hwnd list child,
// but translate the message first to real LB_ message
//
return(SendMessage(lpColumnLB->hwndList, msg - CLB_BASE, wParam, lParam));
case CLB_GETITEMDATA:
//
// if the parent is NOT handling OWNERDRAW, then we need to handle
//
if ( ! (lpColumnLB->Style & (LBS_OWNERDRAWFIXED | VLBS_OWNERDRAWFIXED)) )
{
lpRecord = (LPCOLRECORD)SendMessage(lpColumnLB->hwndList, LB_GETITEMDATA, wParam, 0);
if (lpRecord != (LPCOLRECORD)LB_ERR)
return(lpRecord->itemData);
else
return(LB_ERR);
}
else
//
// Parent is owner draw, so send it to the hwnd list child,
// but translate the message first to real LB_ message
//
return(SendMessage(lpColumnLB->hwndList, msg - CLB_BASE, wParam, lParam));
case CLB_SETITEMDATA:
//
// if the parent is NOT handling OWNERDRAW, then we need to handle
//
if ( ! (lpColumnLB->Style & (LBS_OWNERDRAWFIXED | VLBS_OWNERDRAWFIXED)) )
{
lpRecord = (LPCOLRECORD)SendMessage(lpColumnLB->hwndList, LB_GETITEMDATA, wParam, 0);
if (lpRecord != (LPCOLRECORD)LB_ERR)
return(lpRecord->itemData = lParam);
else
return(LB_ERR);
}
else
//
// Parent is owner draw, so send it to the hwnd list child,
// but translate the message first to real LB_ message
//
return(SendMessage(lpColumnLB->hwndList, msg - CLB_BASE, wParam, lParam));
//
// if it is a HORIZONTAL exntent message, then we need to massage...
//
case CLB_SETHORIZONTALEXTENT :
//
// send the message to the title listbox as well
//
SendMessage(lpColumnLB->hwndTitleList, LB_SETHORIZONTALEXTENT, wParam, lParam);
//
// pass it on to the child listbox, using VLB_SETHOR if appropriate...
//
return(SendMessage(lpColumnLB->hwndList,
(lpColumnLB->fUseVlist) ? VLB_SETHORIZONTALEXTENT : LB_SETHORIZONTALEXTENT,
wParam, lParam));
//
// we need to massage the GETITEMRECT to handle the incorrect rect returned due to titlelistbox.
//
case CLB_GETITEMRECT:
{
int retcode;
int height;
LPRECT lpRect = (LPRECT)lParam;
//
// send it to the hwnd list child, but translate the message first to real LB_ message
//
retcode = SendMessage(lpColumnLB->hwndList, msg - CLB_BASE, wParam, lParam);
height = lpRect->bottom-lpRect->top;
lpRect->top = lpRect->bottom + 1;
lpRect->bottom = lpRect->top + height;
return(retcode);
}
break;
case CLB_DELETESTRING :
case CLB_SELITEMRANGEEX :
case CLB_RESETCONTENT :
case CLB_SETSEL :
case CLB_SETCURSEL :
case CLB_GETSEL :
case CLB_GETCURSEL :
case CLB_GETCOUNT :
case CLB_SELECTSTRING :
case CLB_DIR :
case CLB_GETTOPINDEX :
case CLB_FINDSTRING :
case CLB_GETSELCOUNT :
case CLB_GETSELITEMS :
case CLB_SETTABSTOPS :
case CLB_GETHORIZONTALEXTENT :
case CLB_SETCOLUMNWIDTH :
case CLB_ADDFILE :
case CLB_SETTOPINDEX :
case CLB_SELITEMRANGE :
case CLB_SETANCHORINDEX :
case CLB_GETANCHORINDEX :
case CLB_SETCARETINDEX :
case CLB_GETCARETINDEX :
case CLB_SETITEMHEIGHT :
case CLB_GETITEMHEIGHT :
case CLB_FINDSTRINGEXACT :
case CLB_SETLOCALE :
case CLB_GETLOCALE :
case CLB_SETCOUNT :
//
// Simply send it to the hwnd list child, but translate the message first to real LB_ message
//
return(SendMessage(lpColumnLB->hwndList, msg - CLB_BASE, wParam, lParam));
// -------------------------------------------------------------------
// put messages here which explicitly need to be passed to our PARENT
//
case WM_COMMAND:
/* if this is a notification message from our child translate */
/* it to look like it is from us and pass on to our parent */
if (LOWORD(wParam) == IDL_COLUMNLISTBOX)
return(SendMessage( GetParent(hwnd),
msg,
MAKELONG( GetDlgCtrlID(hwnd) ,HIWORD(wParam)),
(LPARAM)hwnd )); // make it look like we were the ones sending the message...
else
return(SendMessage(GetParent(hwnd), msg, wParam, (LPARAM)hwnd));
case WM_VKEYTOITEM:
// pass on to our parent but using our hwnd...
if (lpColumnLB->Style & (LBS_WANTKEYBOARDINPUT | VLBS_WANTKEYBOARDINPUT) )
return(SendMessage(GetParent(hwnd), msg, wParam, (LPARAM)hwnd));
else
return(-1); // perform default action...
case WM_CHARTOITEM:
if (lpColumnLB->Style & (LBS_WANTKEYBOARDINPUT | VLBS_WANTKEYBOARDINPUT) )
if ((result = SendMessage(GetParent(hwnd), msg, wParam, (LPARAM)hwnd)) != -1)
return(result);
return HANDLE_WM_CHARTOITEM(hwnd, wParam, lParam, ColumnLBClass_OnCharToItem);
case WM_COMPAREITEM:
{
LPCOMPAREITEMSTRUCT lpCompareItem = (LPCOMPAREITEMSTRUCT)lParam;
int result;
if ((lpColumnLB->Style & LBS_OWNERDRAWFIXED) ||
(lpColumnLB->Style & VLBS_OWNERDRAWFIXED))
{
//
// substitute our values in the COMPAREITEMSTRUCT...
//
lpCompareItem->CtlID = GetDlgCtrlID(hwnd);
lpCompareItem->hwndItem = hwnd;
//
// then pass to our parent as our WM_COMPAREITEM, with the current physcial sort column as wParam
//
result = (int)SendMessage(GetParent(hwnd), WM_COMPAREITEM, (WPARAM)lpColumnLB->SortColumn, (LPARAM)lpCompareItem);
return(result);
}
else
{
LPTSTR lpString1;
LPTSTR lpString2;
LPCOLRECORD lpColRecord1;
LPCOLRECORD lpColRecord2;
// handle ourselves assuming item data is pointer to array of LPTSTR's
lpColRecord1 = (LPCOLRECORD)lpCompareItem->itemData1;
lpColRecord2 = (LPCOLRECORD)lpCompareItem->itemData2;
lpString1 = lpColRecord1->pString[lpColumnLB->SortColumn];
lpString2 = lpColRecord2->pString[lpColumnLB->SortColumn];
if (lpString1 && lpString2)
return(lstrcmpi(lpString1, lpString2));
else
return(0);
}
}
break;
// ---------------------------------------------------------
// handle our own messages
// ---------------------------------------------------------
//
// NUMBER COLUMNS
//
case CLB_GETNUMBERCOLS : // get the number of columns (ret=NumCols)
return ColumnLBClass_OnNumberCols(hwnd, 0, FALSE);
case CLB_SETNUMBERCOLS : // set the number of columns (wparam=NumCols)
return ColumnLBClass_OnNumberCols(hwnd, (BYTE)wParam, TRUE);
// ----------------------------------------------------------------
// Following messages use physical column numbers
// ----------------------------------------------------------------
//
// COLUMN WIDTH
//
case CLB_GETCOLWIDTH : // get a column width (wParm=Physical Column ret=ColWidth in LU's)
return ColumnLBClass_OnColWidth(hwnd, (BYTE)wParam, (int)0, FALSE);
case CLB_SETCOLWIDTH : // set a column width (wParm=Physical Column lParam=Width)
return ColumnLBClass_OnColWidth(hwnd, (BYTE)wParam, (int)lParam, TRUE);
case CLB_AUTOWIDTH : // auto-matically set column widths using titles... (wParam = Physical Column to auto width)
return ColumnLBClass_OnAutoWidth(hwnd, (BYTE)wParam);
//
// COLUMN TITLE
//
case CLB_GETCOLTITLE : // get a column's title (wParm=Physical Column, ret=Title)
return (LRESULT)ColumnLBClass_OnColTitle(hwnd, (BYTE)wParam, (LPTSTR)NULL, FALSE);
case CLB_SETCOLTITLE : // set a column's title (wParm=Physical Col, lParm=Title)
return (LRESULT)ColumnLBClass_OnColTitle(hwnd, (BYTE)wParam, (LPTSTR)lParam, TRUE);
case CLB_GETROWCOLTEXT:
//
// if the parent is NOT handling OWNERDRAW, then we need to handle
//
if ( ! (lpColumnLB->Style & (LBS_OWNERDRAWFIXED | VLBS_OWNERDRAWFIXED)) )
{
INT WhichCol = (INT)(wParam);
INT WhichRow = (INT)(lParam);
// and now pass on to get the text...
lpRecord = (LPCOLRECORD)SendMessage(lpColumnLB->hwndList, LB_GETITEMDATA, WhichRow, 0);
if (lpRecord == (LPCOLRECORD)LB_ERR)
return((LRESULT)NULL);
return (LRESULT)lpRecord->pString[WhichCol];
}
return((LRESULT)NULL); // owner draw, the owner has to figure this out themselves
//
// SORT COLUMN
//
case CLB_GETSORTCOL : // get the physical sort column (ret=Physical Col)
return (LRESULT)ColumnLBClass_OnSortCol(hwnd, 0, FALSE);
case CLB_SETSORTCOL : // set the physical sort column (wParm=Physical Col)
return (LRESULT)ColumnLBClass_OnSortCol(hwnd, (BYTE)wParam, TRUE);
//
// COLUMN ORDER
//
case CLB_GETCOLORDER : // get the virtual order of physical columns (ret = LPDWORD order table)
return (LRESULT)ColumnLBClass_OnColOrder(hwnd, (LPBYTE)0, FALSE);
case CLB_SETCOLORDER : // get the virtual order of physical columns (wParam = LPDWORD order table)
return (LRESULT)ColumnLBClass_OnColOrder(hwnd, (LPBYTE)lParam, TRUE);
case CLB_CHECKFOCUS: // does the listbox have the focus?
// if (lpColumnLB->fUseVlist) // then we have to ask vlist the info
// return
// else
return lpColumnLB->fHasFocus;
// ----------------------------------------------------------------
// Following messages use virtual column numbers
// ----------------------------------------------------------------
//
// COLUMN OFFSETS
//
case CLB_GETCOLOFFSETS : // gets the incremental virtual col offsets (ret=LPDWORD)
return (LRESULT)ColumnLBClass_OnColOffsets(hwnd, (LPINT)wParam, FALSE);
// case CLB_SETCOLOFFSETS : // gets the incremental virtual col offsets (ret=LPDWORD)
// return (LRESULT)ColumnLBClass_OnColOffsets(hwnd, (LPDWORD)wParam, TRUE);
// =================================================================
// INTERNAL
//
case CLB_HSCROLL : // a hscroll event (INTERNAL)
return ColumnLBClass_OnHScroll(hwnd, (HWND)(lParam), (int)LOWORD(wParam), (int)HIWORD(wParam));
//
// GET FOCUS
//
case CLB_GETFOCUS : // get the handle for the window of CLB with the key focus
if ( lpColumnLB->fUseVlist )
// we must ask the column list box below us for the information.
return SendMessage ( lpColumnLB->hwndList, VLB_GETFOCUSHWND, 0,0 );
return (LRESULT) lpColumnLB->hwndList;
default:
return(DefWindowProc(hwnd, msg, wParam, lParam));
}
return(TRUE);
}
// ------------------------------------------------------------------
// ColumnLBClass_OnNCCreate()
//
// Handles WM_NCCCREATE message
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
BOOL ColumnLBClass_OnNCCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
{
LPCOLUMNLBSTRUCT lpColumnLB;
HWND hwndList;
HWND hwndTitleList;
BOOL fUseVlist;
HDC hdc;
TEXTMETRIC tm;
RECT rect;
WORD ncxBorder;
WORD ncyBorder;
WORD yTitle;
ncxBorder = GetSystemMetrics(SM_CXBORDER);
ncyBorder = GetSystemMetrics(SM_CYBORDER);
//
// if the classname is for ColumnVLB class, then they want the Column Virtual list box...
//
if (lstrcmpi(lpCreateStruct->lpszClass, COLUMNVLBCLASS_CLASSNAME) == 0)
fUseVlist = TRUE;
else
fUseVlist = FALSE;
hdc = GetDC(hwnd);
GetTextMetrics(hdc, &tm);
ReleaseDC(hwnd, hdc);
yTitle = tm.tmHeight + 2*ncyBorder;
GetClientRect(hwnd, &rect);
//
// create the title list box window...
//
hwndTitleList = CreateWindow( (LPTSTR) TEXT("LISTBOX"),
(LPTSTR) TEXT(""),
(lpCreateStruct->style & ~WS_BORDER) |
LBS_NOINTEGRALHEIGHT |
LBS_OWNERDRAWFIXED |
WS_VISIBLE |
WS_CHILD,
ncxBorder,
ncyBorder,
lpCreateStruct->cx - (2*ncxBorder) - GetSystemMetrics(SM_CXVSCROLL),
yTitle,
hwnd,
(HMENU)IDL_COLUMNTITLELISTBOX,
lpCreateStruct->hInstance,
NULL);
if (fUseVlist == TRUE)
//
// create a Vlist window...
//
hwndList = CreateWindow((LPTSTR)VLIST_CLASSNAME,
(LPTSTR) TEXT(""),
(lpCreateStruct->style & ~(WS_BORDER | VLBS_HASSTRINGS)) | // NOTE: This can _never_ be hasstrings
VLBS_NOTIFY |
VLBS_USETABSTOPS |
VLBS_NOINTEGRALHEIGHT |
VLBS_OWNERDRAWFIXED | // we always force this as either we will owner draw, or our parent will
WS_HSCROLL |
WS_VSCROLL |
VLBS_DISABLENOSCROLL |
WS_VISIBLE |
WS_CHILD,
ncxBorder,
yTitle + ncyBorder,
lpCreateStruct->cx - ncxBorder, // -(2*ncxBorder)
lpCreateStruct->cy - yTitle - ncyBorder,
hwnd,
(HMENU)IDL_COLUMNLISTBOX,
lpCreateStruct->hInstance,
NULL);
else
//
// create a list box window...
//
#ifdef H_SCROLL
hwndList = CreateWindow((LPTSTR) TEXT("LISTBOX"),
(LPTSTR) TEXT(""),
(lpCreateStruct->style & ~(WS_BORDER | LBS_HASSTRINGS)) | // NOTE: This can _never_ be hasstrings
LBS_NOTIFY |
LBS_USETABSTOPS |
LBS_NOINTEGRALHEIGHT |
LBS_OWNERDRAWFIXED | // we always force this as either we will owner draw, or our parent will
WS_HSCROLL |
WS_VSCROLL |
LBS_DISABLENOSCROLL |
WS_VISIBLE |
WS_CHILD,
ncxBorder,
yTitle + ncyBorder,
lpCreateStruct->cx - ncxBorder, // -(2*ncxBorder)
lpCreateStruct->cy - yTitle - ncyBorder,
hwnd,
(HMENU)IDL_COLUMNLISTBOX,
lpCreateStruct->hInstance,
NULL);
#else
hwndList = CreateWindow((LPTSTR) TEXT("LISTBOX"),
(LPTSTR) TEXT(""),
(lpCreateStruct->style & ~(WS_BORDER | LBS_HASSTRINGS)) | // NOTE: This can _never_ be hasstrings
LBS_NOTIFY |
LBS_USETABSTOPS |
LBS_NOINTEGRALHEIGHT |
LBS_OWNERDRAWFIXED | // we always force this as either we will owner draw, or our parent will
WS_VSCROLL |
LBS_DISABLENOSCROLL |
WS_VISIBLE |
WS_CHILD,
ncxBorder,
yTitle + ncyBorder,
lpCreateStruct->cx - ncxBorder, // -(2*ncxBorder)
lpCreateStruct->cy - yTitle - ncyBorder,
hwnd,
(HMENU)IDL_COLUMNLISTBOX,
lpCreateStruct->hInstance,
NULL);
#endif
//
// if we succeeded...
//
if (hwndList)
{
//
// create a ColumnLB struct to keep track of all of the pertinent instance
// info for this instance of a ColumnLB window
//
lpColumnLB = (LPCOLUMNLBSTRUCT)GlobalAllocPtr(GPTR, sizeof(COLUMNLBSTRUCT));
if (lpColumnLB)
{
BYTE i;
//
// store it in the window data for this window
//
SetWindowLong(hwnd, 0, (DWORD)lpColumnLB);
memset(lpColumnLB, '\0', sizeof(COLUMNLBSTRUCT));
//
// fill in pertinent info
//
lpColumnLB->Style = lpCreateStruct->style;
lpColumnLB->hInstance = (HINSTANCE)GetWindowLong(hwnd, GWL_HINSTANCE);
lpColumnLB->fUseVlist = fUseVlist;
lpColumnLB->fSorting = FALSE;
lpColumnLB->fMouseState = 0;
lpColumnLB->hwndList = hwndList;
lpColumnLB->OldListboxProc = (FARPROC)GetWindowLong(hwndList, GWL_WNDPROC);
lpColumnLB->NewListboxProc = MakeProcInstance((FARPROC)ColumnLBClass_ListBoxWndProc, hInst);
lpColumnLB->hwndTitleList = hwndTitleList;
lpColumnLB->OldTitleListboxProc = (FARPROC)GetWindowLong(hwndTitleList, GWL_WNDPROC);
lpColumnLB->NewTitleListboxProc = MakeProcInstance((FARPROC)ColumnLBClass_TitleListBoxWndProc, hInst);
lpColumnLB->nColumns=1;
lpColumnLB->yTitle = yTitle;
//
// init sort order
//
for (i=0; i < MAX_COLUMNS ; i++ )
lpColumnLB->ColumnOrderTable[i] = i;
//
// sub-class the listbox window by substituting our window proc for the
// normal one...
//
SetWindowLong(hwndList, GWL_WNDPROC,(DWORD)lpColumnLB->NewListboxProc);
//
// sub-class the title listbox window by substituting our window proc for the
// normal one...
//
SetWindowLong(hwndTitleList, GWL_WNDPROC,(DWORD)lpColumnLB->NewTitleListboxProc);
//
// add the lpColumnLB struct as the only item in the title listbox
//
ListBox_AddString(lpColumnLB->hwndTitleList, (DWORD)lpColumnLB);
//
// pass this on to the default window proc
//
return(FORWARD_WM_NCCREATE(hwnd, lpCreateStruct, DefWindowProc));
}
else
{
return(FALSE);
}
}
else
return(FALSE);
}
// ------------------------------------------------------------------
// ColumnLBClass_OnDestroy()
//
// Handles WM_DESTROY message
//
// HISTORY:
// Tom Laird-McConnell 7/18/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnDestroy(HWND hwnd)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0);
DestroyWindow(lpColumnLB->hwndTitleList);
DestroyWindow(lpColumnLB->hwndList);
}
// ------------------------------------------------------------------
// ColumnLBClass_OnNCDestroy()
//
// Handles WM_NCDESTROY
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnNCDestroy(HWND hwnd)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0);
FreeProcInstance(lpColumnLB->NewListboxProc);
GlobalFreePtr(lpColumnLB);
}
// ------------------------------------------------------------------
// ColumnLBClass_OnPaint()
//
// Handles WM_PAINT message, draws column titles as appropriate...
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnPaint(HWND hwnd)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0);
PAINTSTRUCT ps;
HBRUSH hFrameBrush, hGreyBrush;
RECT rect;
HDC hdc;
int ncxBorder = GetSystemMetrics(SM_CXBORDER);
int ncyBorder = GetSystemMetrics(SM_CYBORDER);
BeginPaint(hwnd, (LPPAINTSTRUCT)&ps);
// Draw border around title and listbox
GetClientRect(hwnd, (LPRECT)&rect);
hdc = ps.hdc;
hFrameBrush = CreateSolidBrush(GetSysColor(COLOR_WINDOWFRAME));
FrameRect(hdc, (LPRECT)&rect, hFrameBrush);
// make bottom the height of a HSCROLL bar
// make left side the width of a VSCROLL bar
rect.top += ncyBorder;
rect.right -= ncxBorder;
rect.left = rect.right - GetSystemMetrics(SM_CXVSCROLL);
rect.bottom = lpColumnLB->yTitle+ncyBorder;
hGreyBrush = CreateSolidBrush(GetSysColor(COLOR_SCROLLBAR));
FillRect(hdc, &rect, hGreyBrush);
rect.right = rect.left+1;
FillRect(hdc, &rect, hFrameBrush);
// destroy brushes...
DeleteBrush(hFrameBrush);
DeleteBrush(hGreyBrush);
EndPaint(hwnd, (LPPAINTSTRUCT)&ps);
}
// ------------------------------------------------------------------
// ColumnLBClass_OnSize()
//
// Handles WM_SIZE message
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnSize(HWND hwnd, UINT state, int cx, int cy)
{
WORD ncxBorder;
WORD ncyBorder;
RECT rect;
DWORD cxExtent;
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0);
if (lpColumnLB->hwndList != (HWND)NULL)
{
ncxBorder = GetSystemMetrics(SM_CXBORDER);
ncyBorder = GetSystemMetrics(SM_CYBORDER);
// position title listbox at top
MoveWindow(lpColumnLB->hwndTitleList,
ncxBorder,
ncyBorder,
cx-(2*ncxBorder) - GetSystemMetrics(SM_CXVSCROLL),
lpColumnLB->yTitle,
TRUE);
// position list box below title listbox
MoveWindow(lpColumnLB->hwndList,
ncxBorder,
lpColumnLB->yTitle + ncyBorder,
cx - ncxBorder, // -(2*ncxBorder)
cy-lpColumnLB->yTitle - ncyBorder,
TRUE);
cxExtent = ColumnLBClass_ComputeOffsets(hwnd);
GetClientRect(hwnd, &rect);
//
// if the new extent is smaller then the space available, move the position
//
if ((DWORD)rect.right > cxExtent)
{
// #ifdef DEBUG
// dprintf(TEXT("Reset HSCROLL pos to far left\n"));
// #endif
// move position to far left
SendMessage(lpColumnLB->hwndList,
(lpColumnLB->fUseVlist) ? VLB_HSCROLL : WM_HSCROLL,
MAKEWPARAM(SB_TOP, 0), 0);
// do the same for the title list
SendMessage(lpColumnLB->hwndTitleList,
WM_HSCROLL, MAKEWPARAM(SB_TOP, 0), 0);
}
InvalidateRect(lpColumnLB->hwndList, NULL, TRUE);
InvalidateRect(lpColumnLB->hwndTitleList, NULL, TRUE);
}
InvalidateRect(lpColumnLB->hwndTitleList, 0, TRUE);
InvalidateRect(lpColumnLB->hwndList, 0, TRUE);
}
// ------------------------------------------------------------------
// ColumnLBClass_OnSetFont()
//
// Handles WM_SETFONT message
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnSetFont(HWND hwnd, HFONT hFont, BOOL fRedraw)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0);
HDC hdc;
TEXTMETRIC tm;
RECT rect;
lpColumnLB->hFont = hFont;
hdc = GetDC(hwnd);
SelectFont(hdc, (HFONT)hFont);
GetTextMetrics(hdc, &tm);
//
// forward on to listbox window
//
if (lpColumnLB->hwndList != (HWND)NULL)
FORWARD_WM_SETFONT(lpColumnLB->hwndList, hFont, fRedraw, SendMessage);
if (lpColumnLB->hwndTitleList != (HWND)NULL)
FORWARD_WM_SETFONT(lpColumnLB->hwndTitleList, hFont, fRedraw, SendMessage);
//
// store text height...
//
lpColumnLB->yTitle = tm.tmHeight + 2*GetSystemMetrics(SM_CYBORDER);
//
// change height appropriately
//
ListBox_SetItemHeight(lpColumnLB->hwndTitleList, 0, lpColumnLB->yTitle);
SendMessage(lpColumnLB->hwndList,
(lpColumnLB->fUseVlist) ? VLB_SETITEMHEIGHT : LB_SETITEMHEIGHT,
0,
tm.tmHeight);
//
// since we changed the font size, forze a WM_SIZE to recalc the size of the window
//
GetClientRect(hwnd, &rect);
ColumnLBClass_OnSize(hwnd, SIZE_RESTORED, rect.right-rect.left, rect.bottom-rect.top);
ReleaseDC(hwnd, hdc);
}
// ------------------------------------------------------------------
// ColumnLBClass_OnHScroll()
//
//
// Handles OnHScroll messages to keep title bar in ssync with listbox...
//
// HISTORY:
// Tom Laird-McConnell 5/1/93 Created
// ------------------------------------------------------------------
LRESULT ColumnLBClass_OnHScroll(HWND hwnd, HWND hwndCtl, UINT code, int pos)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0);
long lPos;
WORD nPos;
RECT rect;
int cxExtent;
switch (code)
{
case SB_THUMBPOSITION:
case SB_THUMBTRACK:
nPos = pos;
break;
case SB_LINEUP:
case SB_LINEDOWN:
case SB_PAGEUP:
case SB_PAGEDOWN:
case SB_TOP:
case SB_BOTTOM:
case SB_ENDSCROLL:
if (lpColumnLB->fUseVlist)
nPos = (WORD)SendMessage(lpColumnLB->hwndList, VLB_GETSCROLLPOS, 0, 0);
else
nPos = GetScrollPos((hwndCtl) ? hwndCtl : lpColumnLB->hwndList, SB_HORZ);
// nPos = GetScrollPos(lpColumnLB->hwndList, SB_HORZ);
break;
default:
return(TRUE);
}
GetClientRect(lpColumnLB->hwndList, (LPRECT)&rect);
//... if it is a VLIST, then there is an error in the client calculation when it has VSCROLL bars, so
// we need to adjust ourselves by width of VSCROLL bar...
if (lpColumnLB->fUseVlist)
rect.right -= GetSystemMetrics(SM_CXVSCROLL);
cxExtent = (DWORD)SendMessage(lpColumnLB->hwndList,
(lpColumnLB->fUseVlist) ? VLB_GETHORIZONTALEXTENT : LB_GETHORIZONTALEXTENT, 0, 0L);
if (cxExtent >= rect.right)
{
// then the listbox size is > then client's display size
// so we need to calculate how much is not on the client display
cxExtent -= rect.right;
}
else
// else set the amount left over to 0 to nullify (technical term) the
// effects of this calculation...
cxExtent = 0;
lPos = -(((LONG)nPos*(LONG)cxExtent)/100);
if (lPos > 0)
lpColumnLB->xPos = 0;
else
if (lPos < -cxExtent)
lpColumnLB->xPos = -cxExtent;
else
lpColumnLB->xPos = (int)lPos;
}
// ------------------------------------------------------------------
// ColumnLBClass_OnMeasureItem()
//
//
// Handles telling the parent how to draw each column accordingly...
//
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnMeasureItem(HWND hwnd, LPMEASUREITEMSTRUCT lpMeasureItem)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
TEXTMETRIC tm;
HDC hdc;
if (lpMeasureItem->CtlID == IDL_COLUMNTITLELISTBOX)
{
if (lpColumnLB)
lpMeasureItem->itemHeight = lpColumnLB->yTitle;
else
{
hdc = GetDC(hwnd);
GetTextMetrics(hdc, &tm);
ReleaseDC(hwnd, hdc);
lpMeasureItem->itemHeight = tm.tmHeight;
}
}
else
//
// it should be passed to parent
//
FORWARD_WM_MEASUREITEM(GetParent(hwnd), lpMeasureItem, SendMessage);
}
// ------------------------------------------------------------------
// ColumnLBClass_OnDeleteItem()
//
//
// Handles deleting items if necessary...
//
//
// HISTORY:
// Tom Laird-McConnell 08/18/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnDeleteItem(HWND hwnd, const DELETEITEMSTRUCT *lpDeleteItem)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
LPCOLRECORD lpRecord;
// don't actually do the delete if we are sorting...
if (lpColumnLB->fSorting == TRUE)
return;
if (lpDeleteItem->CtlID == IDL_COLUMNLISTBOX)
{
// if the style is that the owner is handling the owner draw stuff
// then we need to pass to the parent ELSE free our memory...
if ((lpColumnLB) && (lpColumnLB->Style & LBS_OWNERDRAWFIXED))
//
// it should be passed to parent
//
FORWARD_WM_DELETEITEM(GetParent(hwnd), lpDeleteItem, SendMessage);
else
// this is our item data, so we need to free it
if (lpDeleteItem->itemData)
{
lpRecord = (LPCOLRECORD)lpDeleteItem->itemData;
// NOTE that the first pointer is actually the string buffer...
if (lpRecord->pString[0])
GlobalFreePtr(lpRecord->pString[0]);
GlobalFreePtr(lpRecord);
}
}
}
// ------------------------------------------------------------------
// ColumnLBClass_OnDrawItem()
//
//
// Handles telling the parent to draw each column accordingly...
//
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnDrawItem(HWND hwnd, const DRAWITEMSTRUCT * lpDrawItem)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
HWND hwndParent = GetParent(hwnd);
BYTE i;
BYTE PhysCol;
CLBDRAWITEMSTRUCT CLBDrawItemStruct;
RECT rect;
int ncxBorder = GetSystemMetrics(SM_CXBORDER);
int ncyBorder = GetSystemMetrics(SM_CYBORDER);
HPEN hFramePen;
HPEN hShadowPen;
HPEN hHighlightPen;
HPEN hOldPen;
HBRUSH hBackgroundBrush;
DWORD Col;
DWORD cyChar;
TEXTMETRIC tm;
BYTE PhysColumn;
RECT ClientRect;
GetClientRect(lpDrawItem->hwndItem, &ClientRect);
//
// figure out which window sent us the DrawItem
//
switch (lpDrawItem->CtlID)
{
//
// handle drawing the title listbox
//
case IDL_COLUMNTITLELISTBOX:
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0);
if (lpDrawItem->itemAction == ODA_DRAWENTIRE)
{
GetTextMetrics(lpDrawItem->hDC, &tm);
cyChar = tm.tmHeight;
//
// create all of our pens for our drawing
//
hHighlightPen = CreatePen(PS_SOLID, ncyBorder, GetSysColor(COLOR_BTNHIGHLIGHT));
hShadowPen = CreatePen(PS_SOLID, ncyBorder, GetSysColor(COLOR_BTNSHADOW));
hFramePen = CreatePen(PS_SOLID, ncyBorder, GetSysColor(COLOR_WINDOWFRAME));
hBackgroundBrush = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
//
// get the window rect we are going to work with
//
CopyRect(&rect, &lpDrawItem->rcItem);
FillRect(lpDrawItem->hDC, &rect, hBackgroundBrush);
//
// Draw frame color line below title section of property window
//
hOldPen = SelectObject(lpDrawItem->hDC, hFramePen);
MoveToEx(lpDrawItem->hDC, rect.left, rect.bottom, NULL);
LineTo(lpDrawItem->hDC, rect.right, rect.bottom);
//
// we start at the current left
//
rect.top += 2*ncyBorder;
SetTextColor(lpDrawItem->hDC, GetSysColor(COLOR_BTNTEXT));
SetBkColor(lpDrawItem->hDC, GetSysColor(COLOR_BTNFACE));
SetBkMode(lpDrawItem->hDC, TRANSPARENT);
for (Col=0; Col < lpColumnLB->nColumns; Col++)
{
//
// get the index number of the current column
//
PhysColumn = lpColumnLB->ColumnOrderTable[Col];
//
// adjust right side to be left side plus width of current column
//
rect.right = rect.left + lpColumnLB->ColumnInfoTable[PhysColumn].Width;
//
// if the button is dpressed, then draw it that way
//
if (lpColumnLB->ColumnInfoTable[PhysColumn].fDepressed)
{
//
// pick the shadow pen and draw the top-left depressed
//
SelectObject(lpDrawItem->hDC, hShadowPen);
MoveToEx(lpDrawItem->hDC, rect.left, rect.bottom, NULL);
LineTo(lpDrawItem->hDC, rect.left, rect.top-2*ncyBorder); // bottom-left --> top-left
LineTo(lpDrawItem->hDC, rect.right, rect.top-2*ncyBorder); // top-left --> top-right
//
// pick the Frame pen and draw the Column seperater
//
SelectObject(lpDrawItem->hDC, hFramePen);
MoveToEx(lpDrawItem->hDC, rect.right+ncxBorder, rect.top-2*ncyBorder, NULL);
LineTo(lpDrawItem->hDC, rect.right+ncxBorder, rect.bottom); // bottom-left --> top-left
//
// move the cursor for whitespace to draw text
//
rect.left += WHITESPACE/2;
// draw the title of the column in the current slot
DrawText(lpDrawItem->hDC,
lpColumnLB->ColumnInfoTable[PhysColumn].lpTitle,
-1,
(LPRECT)&rect,
DT_SINGLELINE | DT_LEFT | DT_TOP);
rect.left -= WHITESPACE/2; // restore the left position...
}
else
{
// it is not depressed, draw it normal
//
// pick the white pen and draw the top-left highlight
//
SelectObject(lpDrawItem->hDC, hHighlightPen);
MoveToEx(lpDrawItem->hDC, rect.left, rect.bottom-ncyBorder, NULL);
LineTo(lpDrawItem->hDC, rect.left, rect.top-2*ncyBorder); // bottom-left --> top-left
LineTo(lpDrawItem->hDC, rect.right, rect.top-2*ncyBorder); // top-left --> top-right
//
// pick the shadow pen and draw the bottom-right dark shadow
//
SelectObject(lpDrawItem->hDC, hShadowPen);
LineTo(lpDrawItem->hDC, rect.right, rect.bottom-ncyBorder); // top-right --> bottom-right
LineTo(lpDrawItem->hDC, rect.left, rect.bottom-ncyBorder); // bottom-right --> bottom-left
//
// pick the Frame pen and draw the Column seperater
//
SelectObject(lpDrawItem->hDC, hFramePen);
MoveToEx(lpDrawItem->hDC, rect.right+ncxBorder, rect.top-2*ncyBorder, NULL);
LineTo(lpDrawItem->hDC, rect.right+ncxBorder, rect.bottom); // bottom-left --> top-left
//
// move the cursor for whitespace to draw text
//
rect.left += WHITESPACE/4;
rect.top -= ncyBorder;
// draw the title of the column in the current slot
DrawText(lpDrawItem->hDC,
lpColumnLB->ColumnInfoTable[PhysColumn].lpTitle,
-1,
(LPRECT)&rect,
DT_SINGLELINE | DT_LEFT | DT_TOP);
rect.top += ncyBorder;
}
//
// adjust the left side of the rect for the width of this column
//
rect.left = rect.right+2*ncxBorder;
}
// select the original brush
SelectObject(lpDrawItem->hDC, hOldPen);
// delete my pens
DeletePen(hFramePen);
DeletePen(hHighlightPen);
DeletePen(hShadowPen);
DeleteBrush(hBackgroundBrush);
}
}
break;
//
// handle sending CLB_DRAWITEM MESSAGES to parent
//
case IDL_COLUMNLISTBOX:
{
//
// make a copy of the drawitem portion of the struct
//
memcpy(&CLBDrawItemStruct.DrawItemStruct, lpDrawItem, sizeof(DRAWITEMSTRUCT));
//
// fake parent window into thinking our id is the listbox
//
CLBDrawItemStruct.DrawItemStruct.CtlID = GetDlgCtrlID(hwnd);
CLBDrawItemStruct.lpColOrder = lpColumnLB->ColumnOrderTable;
CLBDrawItemStruct.nColumns = lpColumnLB->nColumns;
CopyRect(&rect, &lpDrawItem->rcItem);
//
// move the cursor for whitespace to draw text
//
rect.left += WHITESPACE/4;
//
// tell the parent to draw each physical column in the appropriate rectangle
//
for (i=0; i < lpColumnLB->nColumns ;i++ )
{
//
// get physical column number
//
PhysCol = lpColumnLB->ColumnOrderTable[i];
//
// massage the rect's right to be the left plus the width of the column
//
rect.right = rect.left + lpColumnLB->ColumnInfoTable[PhysCol].Width - WHITESPACE/4;
//
// copy it
//
CopyRect(&CLBDrawItemStruct.rect[i], &rect);
//
// massage the rect's left to be the right + 1
//
rect.left = rect.right + WHITESPACE/4 + 2*ncxBorder ;
}
if ((lpColumnLB->Style & LBS_OWNERDRAWFIXED) ||
(lpColumnLB->Style & VLBS_OWNERDRAWFIXED) )
//
// send a draw message with the physical column order list
// to the parent as they want to draw it
//
SendMessage(hwndParent, CLBN_DRAWITEM, (WPARAM)0, (WPARAM)&CLBDrawItemStruct);
else
{
//
// we want to draw it ourselves...
// NOTE: This assumes that we are LBS_HASSTRINGS and NOT LBS_OWNERDRAWFIXED
//
switch(lpDrawItem->itemAction)
{
case ODA_FOCUS:
DrawFocusRect(lpDrawItem->hDC,(LPRECT)&(lpDrawItem->rcItem));
break;
case ODA_DRAWENTIRE:
case ODA_SELECT:
// only if we have data...
if (lpDrawItem->itemData)
{
LPCOLRECORD lpColRecord = (LPCOLRECORD)lpDrawItem->itemData;
if ((lpColRecord == NULL) ||
(lpColRecord == (LPCOLRECORD)LB_ERR))
break; // bogus data
// Are we highlighted? (highlit?)
if (lpDrawItem->itemState & ODS_SELECTED)
{
hBackgroundBrush = CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
SetBkColor(lpDrawItem->hDC, GetSysColor(COLOR_HIGHLIGHT));
SetTextColor(lpDrawItem->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
}
else
{
hBackgroundBrush = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
SetBkColor(lpDrawItem->hDC, GetSysColor(COLOR_WINDOW));
SetTextColor(lpDrawItem->hDC, GetSysColor(COLOR_WINDOWTEXT));
}
// FillRect(lpDrawItem->hDC,(LPRECT)&(lpDrawItem->rcItem), hBackgroundBrush);
//
// either way, draw column borders now...
//
hFramePen = CreatePen(PS_SOLID, ncyBorder, GetSysColor(COLOR_WINDOWFRAME));
hOldPen = SelectObject(lpDrawItem->hDC, hFramePen);
//
// now draw each column in the approved order...
//
for (i=0; i < CLBDrawItemStruct.nColumns ; i++)
{
//
// draw line of text...
//
ExtTextOut( lpDrawItem->hDC,
CLBDrawItemStruct.rect[i].left,
CLBDrawItemStruct.rect[i].top,
ETO_CLIPPED | ETO_OPAQUE,
&CLBDrawItemStruct.rect[i],
lpColRecord->pString[CLBDrawItemStruct.lpColOrder[i]], // pointer to string
lstrlen(lpColRecord->pString[CLBDrawItemStruct.lpColOrder[i]]), // length
(LPINT)NULL);
// draw column seperator
ColumnLB_DrawColumnBorder( lpDrawItem->hDC, &CLBDrawItemStruct.rect[i], ClientRect.bottom, hBackgroundBrush);
}
// restore old pen
SelectObject(lpDrawItem->hDC, hOldPen);
// destroy pen
DeletePen(hFramePen);
DeleteBrush(hBackgroundBrush);
}
break;
} // end of switch on drawitem action
}
}
break;
}
}
// ------------------------------------------------------------------
// ColumnLBClass_OnCharToItem()
//
// Handles converting keystrokes to items
//
// HISTORY:
// Tom Laird-McConnell 10/18/93 Created
// ------------------------------------------------------------------
int ColumnLBClass_OnCharToItem(HWND hwnd, UINT ch, HWND hwndListbox, int iCaret)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0);
LPCOLRECORD lpColRecord;
int nCount;
int nCurSel;
int nNewSel;
TCHAR cKey;
TCHAR cLBText;
if (hwndListbox != lpColumnLB->hwndTitleList)
{
RECT ClientRect;
GetClientRect(hwnd, &ClientRect);
//
// if the parent is NOT ownerdraw, then we are doing it ourselves, and
// so need to translate the WM_CHAR --> the correct item based on the
// current sort column...
//
if (! (lpColumnLB->Style & (LBS_OWNERDRAWFIXED | VLBS_OWNERDRAWFIXED)) )
{
nCurSel = ListBox_GetCurSel(lpColumnLB->hwndList);
if (IsCharAlphaNumeric((TCHAR)ch))
{
nNewSel = nCurSel + 1;
nCount = ListBox_GetCount(lpColumnLB->hwndList);
cKey = toupper( (TCHAR)ch );
// loop thru items starting with the one just after
// the current selection, until we are too far along,
// then wrap around to the beginning and
// keep going until we hit our original selection.
for (; nNewSel != nCurSel ; nNewSel++ )
{
// make sure that we do't try to compare at location -1
if( nNewSel == -1)
continue;
lpColRecord = (LPCOLRECORD)ListBox_GetItemData(lpColumnLB->hwndList, nNewSel);
// if this comes back as LB_ERR then we are off the end of the list
if( lpColRecord == (LPCOLRECORD)LB_ERR )
{
nNewSel = -1; // increment will move to 0
continue;
}
cLBText = toupper( *lpColRecord->pString[
lpColumnLB->ColumnOrderTable[
lpColumnLB->SortColumn ]] );
if ( cLBText == cKey )
{
// we found it ...
// change the current selection
if( lpColumnLB->Style & LBS_MULTIPLESEL )
{
// multiple selection LB, just move fuzzy rect
ListBox_SetCaretIndex(lpColumnLB->hwndList, nNewSel);
// BUGBUG change of caret does not have a notification?
}
else
{
// single sel LB, change the sel
ListBox_SetCurSel(lpColumnLB->hwndList, nNewSel);
// notify our parent if we need to
if( lpColumnLB->Style & LBS_NOTIFY )
{
SendMessage( GetParent( hwnd ),
WM_COMMAND,
MAKEWPARAM( GetDlgCtrlID( hwnd), LBN_SELCHANGE),
(LPARAM)hwnd); // NOTE: substitute ourselves
// as the source of the message
}
}
return(-1); // we handled it...
}
else if (nNewSel == nCount-1)
{
// we have gone beyond it
// or are at the end of the list...
// we need to wrap to the beginning
// (this will get incremented above prior to use)
nNewSel = -1;
continue;
}
}
// we did not find our target
return(nCurSel);
}
else
// not an alphanumeric, just return the current selection
return(nCurSel);
}
else
//
// pass on to parent as a WM_CHARTOITEM, but with the HIWORD(wParam) == SORT COLUMN
//
return(SendMessage( GetParent(hwnd),
CLBN_CHARTOITEM,
MAKEWPARAM(ch, lpColumnLB->SortColumn),
(LPARAM)hwnd));
}
}
// ------------------------------------------------------------------
// ColumnLBClass_OnNumberCols()
//
// case CLB_GETNUMBERCOLS : // get the number of columns (ret=NumCols)
// case CLB_SETNUMBERCOLS : // set the number of columns (wparam=NumCols)
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
BYTE ColumnLBClass_OnNumberCols(HWND hwnd, BYTE NewNumberCols, BOOL fSetColumns)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
//
// if we are modifying it
//
if (fSetColumns)
{
//
// if the value is a new value
//
if (lpColumnLB->nColumns != NewNumberCols)
{
lpColumnLB->nColumns = NewNumberCols;
// force a redraw of the entire columnlb...
InvalidateRect(hwnd, NULL, TRUE);
}
}
return lpColumnLB->nColumns;
}
// ------------------------------------------------------------------
// ColumnLBClass_OnColWidth()
//
// case CLB_GETCOLWIDTH : // get a column width (wParm=Physical Column ret=ColWidth in DU's)
// case CLB_SETCOLWIDTH : // set a column width (wParm=Physical Column lParam=Width)
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
int ColumnLBClass_OnColWidth(HWND hwnd, BYTE Column, int NewWidth, BOOL fSetWidth)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
int cxExtent;
RECT rect;
//
// if we are modifying it
//
if (fSetWidth)
{
//
// if the value is a new value
//
if (lpColumnLB->ColumnInfoTable[Column].Width != NewWidth)
{
lpColumnLB->ColumnInfoTable[Column].Width = NewWidth;
cxExtent = ColumnLBClass_ComputeOffsets(hwnd);
GetClientRect(hwnd, &rect);
//
// send the message to the title listbox as well
//
SendMessage(lpColumnLB->hwndTitleList, LB_SETHORIZONTALEXTENT, cxExtent, 0L);
//
// pass it on to the child listbox, using VLB_SETHOR if appropriate...
//
SendMessage(lpColumnLB->hwndList,
(lpColumnLB->fUseVlist) ? VLB_SETHORIZONTALEXTENT : LB_SETHORIZONTALEXTENT, cxExtent, 0L);
//
// if the new extent is smaller then the space available, move the position
//
if (rect.right > cxExtent)
{
// #ifdef DEBUG
// dprintf(TEXT("Reset HSCROLL pos to far left\n"));
// #endif
// move position to far left
SendMessage(lpColumnLB->hwndList,
(lpColumnLB->fUseVlist) ? VLB_HSCROLL : WM_HSCROLL,
MAKEWPARAM(SB_TOP, 0), 0);
// do the same for the title list
SendMessage(lpColumnLB->hwndTitleList,
WM_HSCROLL, MAKEWPARAM(SB_TOP, 0), 0);
}
InvalidateRect(lpColumnLB->hwndList, NULL, TRUE);
InvalidateRect(lpColumnLB->hwndTitleList, NULL, TRUE);
}
}
return (DWORD)lpColumnLB->ColumnInfoTable[Column].Width;
}
// ------------------------------------------------------------------
// ColumnLBClass_OnColTitle()
//
// case CLB_GETCOLTITLE : // get a column's title (wParm=Physical Column, ret=Title)
// case CLB_SETCOLTITLE : // set a column's title (wParm=Physical Col, lParm=Title)
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
LPTSTR ColumnLBClass_OnColTitle(HWND hwnd, BYTE Column, LPTSTR lpTitle, BOOL fSetTitle)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
//
// if we are modifying it
//
if (fSetTitle)
{
//
// if the value is a new value
//
if (lpColumnLB->ColumnInfoTable[Column].lpTitle != lpTitle)
{
//
// BUGBUG, is there more to do here?
//
lpColumnLB->ColumnInfoTable[Column].lpTitle = lpTitle;
//
// invalidate the title
//
InvalidateRect(lpColumnLB->hwndTitleList, NULL, TRUE);
}
}
return (LPTSTR)lpColumnLB->ColumnInfoTable[Column].lpTitle;
}
// ------------------------------------------------------------------
// ColumnLBClass_OnSortCol()
//
// case CLB_GETSORTCOL : // get the sort column (ret=Physical Col)
// case CLB_SETSORTCOL : // set the sort column (wParm=Physical Col)
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
BYTE ColumnLBClass_OnSortCol(HWND hwnd, BYTE NewSortCol, BOOL fSetSortCol)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
DWORD nCount;
LPDWORD lpListboxContents;
DWORD i;
int nCurSel;
DWORD ItemData;
HCURSOR hCursor;
//
// if we are modifying it
//
if (fSetSortCol)
{
hCursor = SetCursor(LoadCursor(0, IDC_WAIT));
// set new sort value
lpColumnLB->SortColumn = NewSortCol;
// need to resort listbox
nCount = ListBox_GetCount(lpColumnLB->hwndList);
// need to get current select
nCurSel = ListBox_GetCurSel(lpColumnLB->hwndList);
// and it's item data
ItemData = ListBox_GetItemData(lpColumnLB->hwndList, nCurSel);
SetWindowRedraw(lpColumnLB->hwndList, FALSE);
//
// allocate space for the listbox contents
//
lpListboxContents = (LPDWORD) GlobalAllocPtr(GPTR, sizeof(DWORD) * nCount);
//
// retrieve all of the data values
//
for (i=0; i<nCount; i++)
lpListboxContents[i] = ListBox_GetItemData(lpColumnLB->hwndList, i);
//
// reset the listbox contents
//
lpColumnLB->fSorting = TRUE; // disable deleting while sorting...
SendMessage(lpColumnLB->hwndList, LB_RESETCONTENT, 0, 0);
lpColumnLB->fSorting = FALSE; // reenable it...
//
// now re-add all of the items, with the new sort column
//
for (i=0; i<nCount ; i++ )
{
nCurSel = ListBox_AddString(lpColumnLB->hwndList, lpListboxContents[i]);
}
// reselect selected item...
for (i=0; i < nCount ; i++)
{
if (ItemData == (DWORD)ListBox_GetItemData(lpColumnLB->hwndList, i))
// then select it
ListBox_SetCurSel(lpColumnLB->hwndList, i);
}
GlobalFreePtr(lpListboxContents);
SetWindowRedraw(lpColumnLB->hwndList, TRUE);
InvalidateRect(lpColumnLB->hwndList, NULL, TRUE);
SetCursor(hCursor);
}
return lpColumnLB->SortColumn;
}
// ------------------------------------------------------------------
// ColumnLBClass_OnColOrder()
//
// case CLB_GETCOLORDER : // get the virtual order of the physical columns (ret=LPDWORD order table)
// case CLB_SETCOLORDER : // set the virtual order of the physical columns (ret=LPDWORD order table, wParamn=LPDWORD new order)
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
LPBYTE ColumnLBClass_OnColOrder(HWND hwnd, LPBYTE NewColOrder, BOOL fSetOrder)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
//
// if we are modifying it
//
if (fSetOrder)
{
//
// copy the new order over the old order
//
memcpy(lpColumnLB->ColumnOrderTable, NewColOrder, lpColumnLB->nColumns);
ColumnLBClass_ComputeOffsets(hwnd);
//
// cause listbox to be redrawn
//
InvalidateRect(lpColumnLB->hwndTitleList, NULL, TRUE);
InvalidateRect(lpColumnLB->hwndList, NULL, TRUE);
}
return lpColumnLB->ColumnOrderTable;
}
// ------------------------------------------------------------------
// ColumnLBClass_OnColOffsets()
//
// case CLB_GETCOLOFFSETS : // gets the incremental col offsets (ret=LPDWORD)
// case CLB_SETCOLOFFSETS : // sets the incremental col offsets (wParam = LPDWORD)
//
// HISTORY:
// Tom Laird-McConnell 4/18/93 Created
// ------------------------------------------------------------------
LPINT ColumnLBClass_OnColOffsets(HWND hwnd, LPINT NewOffsetTable, BOOL fSetOffsets)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
//
// if we are modifying it
//
// if (fSetOffsets)
// {
// for (i=0; i < lpColumnLB->nColumns ; i++ )
// {
// lpColumnLB->ColumnOffsetTable[i] = NewOffsetTable[i];
// }
// }
return (lpColumnLB->ColumnOffsetTable);
}
// ------------------------------------------------------------------
// ColumnLBClass_OnAutoWidths()
//
//
// Handles CLB_AUTOWIDTHS messages to calculate the width of each field, and
// to calculate the offsets automatically... (if column is -1 , then all columns)
// ColumnToCompute is in Physical Columns
//
// returns: The horiztonal extent of all of the columns...
//
// HISTORY:
// Tom Laird-McConnell 5/1/93 Created
// ------------------------------------------------------------------
LRESULT ColumnLBClass_OnAutoWidth(HWND hwnd, BYTE ColumnToCompute)
{
HDC hdc;
BYTE nColumn;
LONG cxExtent;
SIZE Size;
TEXTMETRIC tm;
LPCOLUMNINFO lpColumnInfo, lpPrevColumnInfo;
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0);
HFONT hOldFont;
DWORD OldStyle, NewStyle;
hdc = GetDC(hwnd);
GetTextMetrics(hdc, &tm);
hOldFont = SelectFont(hdc, lpColumnLB->hFont);
lpPrevColumnInfo = NULL;
//
// based on column order, compute the widths and offsets of each column
// NOTE: nColumn is the physical column
//
lpColumnInfo = lpColumnLB->ColumnInfoTable;
cxExtent = 0;
for (nColumn=0; nColumn < lpColumnLB->nColumns; nColumn++, lpColumnInfo++)
{
// bail out if column title is not there...
if ((lpColumnInfo->lpTitle == NULL) ||
(lpColumnInfo->lpTitle[0] == '\0'))
continue; // try next column
//
// only if it is a column we are supposed to change
//
if ((ColumnToCompute == (BYTE)-1) ||
(nColumn == ColumnToCompute))
{
GetTextExtentPoint( hdc,
(LPTSTR)lpColumnInfo->lpTitle,
lstrlen(lpColumnInfo->lpTitle),
&Size);
//
// the width is the text extent of the string plus some whitespace
//
lpColumnInfo->Width = (WHITESPACE/2) + Size.cx;
}
}
SelectFont(hdc, hOldFont);
ReleaseDC(hwnd, hdc);
//
// now adjust the offsets to show new values
//
cxExtent = ColumnLBClass_ComputeOffsets(hwnd);
if (lpColumnLB->fUseVlist)
OldStyle = SendMessage(lpColumnLB->hwndList, VLB_GETLISTBOXSTYLE, 0L, 0L);
else
OldStyle = GetWindowLong(lpColumnLB->hwndList, GWL_STYLE);
//
// send the message to the title listbox as well
//
SendMessage(lpColumnLB->hwndTitleList, LB_SETHORIZONTALEXTENT, cxExtent, 0L);
SendMessage(lpColumnLB->hwndList,
(lpColumnLB->fUseVlist) ? VLB_SETHORIZONTALEXTENT : LB_SETHORIZONTALEXTENT, cxExtent, 0L);
if (lpColumnLB->fUseVlist)
NewStyle = SendMessage(lpColumnLB->hwndList, VLB_GETLISTBOXSTYLE, 0L, 0L);
else
NewStyle = GetWindowLong(lpColumnLB->hwndList, GWL_STYLE);
//
// if the horizontal scroll bar is gone, then reset hscroll position
//
if ((NewStyle & WS_HSCROLL) !=
(OldStyle & WS_HSCROLL))
{
// move position to far left
SendMessage(lpColumnLB->hwndList,
(lpColumnLB->fUseVlist) ? VLB_HSCROLL : WM_HSCROLL,
MAKEWPARAM(SB_TOP, 0), 0);
}
InvalidateRect(lpColumnLB->hwndList, NULL, TRUE);
InvalidateRect(lpColumnLB->hwndTitleList, NULL, TRUE);
return(cxExtent);
}
// ------------------------------------------------------------------
// ColumnLBClass_ComputeOffsets()
//
// returns text extent...
//
// HISTORY:
// Tom Laird-McConnell 5/3/93 Created
// ------------------------------------------------------------------
int ColumnLBClass_ComputeOffsets(HWND hwnd)
{
BYTE i;
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
LPINT lpOffset;
LPBYTE lpOrder;
LPCOLUMNINFO lpColumnInfo;
BYTE PhysColumn;
int ncxBorder = GetSystemMetrics(SM_CXBORDER);
//
// recalc the offsets table using the current virtual order
//
lpOffset = lpColumnLB->ColumnOffsetTable;
lpOrder = lpColumnLB->ColumnOrderTable;
lpColumnInfo = lpColumnLB->ColumnInfoTable;
//
// first offset is always 0
//
lpOffset[0] = 0;
for (i=1; i < lpColumnLB->nColumns + 1 ; i++ )
{
PhysColumn = lpOrder[i-1];
//
// this offset is the previous offset plus the previous width
//
lpOffset[i] = lpOffset[i-1] + lpColumnInfo[PhysColumn].Width + 2 * ncxBorder;
}
//
// last offset is also new text extent...
return(lpOffset[lpColumnLB->nColumns]);
}
// ------------------------------------------------------------------
// ColumnLBClass_OnLButtonDown()
//
// Handles WM_LBUTTONDOWN and WM_LBUTTONDBLCLK messages from the client
// area above the listbox
//
//
// HISTORY:
// Tom Laird-McConnell 5/3/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnLButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
BYTE i;
int AdjustedX = x - lpColumnLB->xPos;
HCURSOR hCursor;
BYTE PhysColumn;
BYTE VirtColumn;
RECT rect;
POINT point;
point.x = x;
point.y = y;
GetClientRect(lpColumnLB->hwndTitleList, &rect);
// only if this is a right mouse button from
if (PtInRect(&rect, point))
{
//
// if this is a down-click, and it is on a column border, then go into resize mode
//
for(i=1; i < lpColumnLB->nColumns+1; i++)
{
//
// check to see if this is a column offset
//
if ((AdjustedX > lpColumnLB->ColumnOffsetTable[i]-4) &&
(AdjustedX < lpColumnLB->ColumnOffsetTable[i]+4))
{
VirtColumn = i-1;
PhysColumn = lpColumnLB->ColumnOrderTable[VirtColumn];
//
// x is the right-side of the column i-1
//
lpColumnLB->fMouseState = MOUSE_COLUMNRESIZE;
lpColumnLB->xPrevPos = 0;
lpColumnLB->ColClickStart = VirtColumn; // virtual column
SetCapture(hwnd);
hCursor = LoadCursor(lpColumnLB->hInstance, TEXT("SizebarHCursor"));
SetCursor(hCursor);
return;
}
#ifdef DRAG
else
//
// if this is a down-click, and it is on a column title,
//
if ((AdjustedX > lpColumnLB->ColumnOffsetTable[i-1]) &&
(AdjustedX < lpColumnLB->ColumnOffsetTable[i]))
{
//
// whether it is a double-or single click, we need to draw down button state
//
VirtColumn = i-1;
PhysColumn = lpColumnLB->ColumnOrderTable[VirtColumn];
lpColumnLB->ColumnInfoTable[PhysColumn].fDepressed = TRUE;
GetClientRect(lpColumnLB->hwndTitleList, &rect);
rect.left = lpColumnLB->ColumnOffsetTable[VirtColumn] + lpColumnLB->xPos;
rect.right = lpColumnLB->ColumnOffsetTable[VirtColumn+1] + lpColumnLB->xPos;
//
// if this is a double-click, AND we are in sort mode then handle this as a sort request on the
// column double-clicked on
//
if (fDoubleClick)
{
if (GetWindowLong(hwnd, GWL_STYLE) & LBS_SORT)
{
//
// then default to doing a sort
//
SendMessage(hwnd, CLB_SETSORTCOL, (WPARAM)PhysColumn, (LPARAM)0);
}
else
{
//
// tell parent that the user double-clicked on PhysColumn
//
SendMessage(GetParent(hwnd), CLBN_TITLEDBLCLK, (WPARAM)GetDlgCtrlID(hwnd), (LPARAM) PhysColumn);
}
//
// we are done with double-click, so redraw window
//
lpColumnLB->ColumnInfoTable[PhysColumn].fDepressed = FALSE;
InvalidateRect(lpColumnLB->hwndTitleList, &rect, FALSE);
return;
}
else
{
// then go into single click mode/or column drag mode
//
// then x, y is in column i-1
//
lpColumnLB->fMouseState = MOUSE_COLUMNCLICK;
lpColumnLB->ColClickStart = VirtColumn;
CopyRect(&lpColumnLB->ColClickRect, &rect);
// lpColumnLB->ColClickRect.left += (lpColumnLB->ColClickRect.right - lpColumnLB->ColClickRect.left)/3;
// lpColumnLB->ColClickRect.right -= (lpColumnLB->ColClickRect.right - lpColumnLB->ColClickRect.left)/3;
SetCapture(hwnd);
InvalidateRect(lpColumnLB->hwndTitleList, &rect, FALSE);
GetWindowRect(lpColumnLB->hwndTitleList, &rect);
ClipCursor(&rect);
return;
}
}
#endif
}
}
}
// ------------------------------------------------------------------
// ColumnLBClass_OnMouseMove()
//
// Handles Mouse movement messages from the client
// area above the listbox
//
//
// HISTORY:
// Tom Laird-McConnell 5/3/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnMouseMove(HWND hwnd, int x, int y, UINT keyFlags)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
RECT rect;
HDC hdc;
BYTE i;
int AdjustedX = x - lpColumnLB->xPos;
POINT Point;
HCURSOR hCursor;
switch (lpColumnLB->fMouseState)
{
case 0 : // not in mouse mode at all, so just track changing cursor when over column border
for(i=1; i < lpColumnLB->nColumns + 1; i++)
{
//
// check to see if this is a column offset
//
if ((AdjustedX > lpColumnLB->ColumnOffsetTable[i]-4) &&
(AdjustedX < lpColumnLB->ColumnOffsetTable[i]+4))
{
//
// it is, so set the cursor and return
//
hCursor = LoadCursor(lpColumnLB->hInstance, TEXT("SizebarHCursor"));
SetCursor(hCursor);
return;
}
}
SetCursor(LoadCursor(0,IDC_ARROW));
break;
case MOUSE_COLUMNRESIZE:
GetClientRect(hwnd, &rect);
//
// as long as we haven't moved past the previous column, and we haven't moved out of the rect
//
if (AdjustedX < lpColumnLB->ColumnOffsetTable[lpColumnLB->ColClickStart]+8)
{
x += (lpColumnLB->ColumnOffsetTable[lpColumnLB->ColClickStart]+8)-AdjustedX;
AdjustedX = lpColumnLB->ColumnOffsetTable[lpColumnLB->ColClickStart]+8;
}
if (x < rect.right)
{
hdc = GetDC(hwnd);
// un invert previous postion
if (lpColumnLB->xPrevPos)
{
rect.left = lpColumnLB->xPrevPos;
rect.right = rect.left+1;
InvertRect(hdc, &rect);
}
lpColumnLB->xPrevPos = x;
// invert new position
rect.left = x;
rect.right = rect.left+1;
InvertRect(hdc, &rect);
ReleaseDC(hwnd, hdc);
}
break;
case MOUSE_COLUMNDRAG:
//
// if this is a column drag, we track the messages until the mouse has moved
// back INTO the original column rectangle, if it does this, then we switchback to
// COLUMNCLICK mode, until they let go, or move back out
//
Point.x = x;
Point.y = y;
GetClientRect(lpColumnLB->hwndTitleList, &rect);
// if it is on far RIGHT generate WM_HSCROLL right message
if (x >= rect.right-2)
{
SendMessage(lpColumnLB->hwndList, (lpColumnLB->fUseVlist) ? VLB_HSCROLL : WM_HSCROLL, MAKEWPARAM(SB_LINEDOWN, 0), (LPARAM)NULL);
return;
}
// if it is on far RIGHT generate WM_HSCROLL left message
if (x <= rect.left+2)
{
SendMessage(lpColumnLB->hwndList, (lpColumnLB->fUseVlist) ? VLB_HSCROLL : WM_HSCROLL, MAKEWPARAM(SB_LINEUP, 0), (LPARAM)NULL);
return;
}
// rect.right -= lpColumnLB->xPos;
//
// //
// // it if is out of the title area, or if it is in the original column
// //
// if ((PtInRect(&lpColumnLB->ColClickRect, Point) == TRUE) || // original column
// (PtInRect(&rect, Point) == FALSE) ) // title area
// {
// //
// // then it has moved back into the original column, switch to
// //COLUMNCLICK mode
// //
// lpColumnLB->fMouseState = MOUSE_COLUMNCLICK;
//
// SetCursor(LoadCursor(0, IDC_ARROW));
// return;
// }
break;
case MOUSE_COLUMNCLICK:
//
// if this is a column click, we track the messages until the mouse has moved
// outside of the original column rectangle, if it does this, then we switch to
// COLUMNDRAG mode, until they let go, or until they move back to the original
// column.
//
Point.x = x;
Point.y = y;
GetClientRect(lpColumnLB->hwndTitleList, &rect);
rect.right -= lpColumnLB->xPos;
//
// if it is outside of the original column, and inside title area, then swtich to
// DRAG mode
//
if ((PtInRect(&lpColumnLB->ColClickRect, Point) == FALSE) && //
(PtInRect(&rect, Point) == TRUE) ) // title area
{
//
// then it has moved outside of the column, switch to
//COLUMNDRAG mode
//
lpColumnLB->fMouseState = MOUSE_COLUMNDRAG;
hCursor = LoadCursor(lpColumnLB->hInstance, TEXT("ColDragCursor"));
SetCursor(hCursor);
}
break;
}
}
// ------------------------------------------------------------------
// ColumnLBClass_OnLButtonUp()
//
// Handles WM_LBUTTONUp messages from the client
// area above the listbox
//
//
// HISTORY:
// Tom Laird-McConnell 5/3/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnLButtonUp(HWND hwnd, int x, int y, UINT keyFlags)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
BYTE PhysColumn = lpColumnLB->ColumnOrderTable[lpColumnLB->ColClickStart];
BYTE PhysSourceColumn;
int AdjustedX = x - lpColumnLB->xPos;
POINT Point;
BYTE NewOrderTable[MAX_COLUMNS];
LPBYTE lpNewOrderTable = NewOrderTable;
LPBYTE lpOrderTable = lpColumnLB->ColumnOrderTable;
BYTE CurrentCol;
BYTE DestCol;
BYTE SourceCol;
TCHAR Direction;
BYTE i;
HDC hdc;
RECT rect;
SetCursor(LoadCursor(0, IDC_ARROW)); // go back to arrow
switch (lpColumnLB->fMouseState)
{
case MOUSE_COLUMNRESIZE:
//
// if we were in resize column mode, then resize the column to the left of the border
//
ReleaseCapture();
ClipCursor(NULL);
lpColumnLB->fMouseState = 0;
// clean up line
GetClientRect(hwnd, &rect);
hdc = GetDC(hwnd);
// massage the value to make sure it's in the right range...
if (AdjustedX < lpColumnLB->ColumnOffsetTable[lpColumnLB->ColClickStart]+8)
AdjustedX = lpColumnLB->ColumnOffsetTable[lpColumnLB->ColClickStart]+8;
// un invert previous postion
if (lpColumnLB->xPrevPos)
{
rect.left = lpColumnLB->xPrevPos;
rect.right = rect.left+1;
InvertRect(hdc, &rect);
}
ReleaseDC(hwnd, hdc);
//
// set the physical column width to be the current x position - the current virtual column offset
//
SendMessage(hwnd,
CLB_SETCOLWIDTH,
(WPARAM)PhysColumn,
(LPARAM)AdjustedX - lpColumnLB->ColumnOffsetTable[lpColumnLB->ColClickStart]);
break;
case MOUSE_COLUMNDRAG:
lpColumnLB->fMouseState = 0;
ReleaseCapture();
ClipCursor(NULL);
lpColumnLB->ColumnInfoTable[PhysColumn].fDepressed = FALSE;
//
// we need to figure out what column we ended up on
//
for(i=1; i < lpColumnLB->nColumns+1; i++)
{
//
// if it fits in this columns area, then this is the destination column
//
if ((AdjustedX > lpColumnLB->ColumnOffsetTable[i-1]) &&
(AdjustedX < lpColumnLB->ColumnOffsetTable[i]))
{
//
// make duplicate of the table
//
memcpy(NewOrderTable, lpOrderTable, sizeof(BYTE)*lpColumnLB->nColumns);
//
// i-1 is the destination column! (virtual)
//
SourceCol = lpColumnLB->ColClickStart; // virtual
DestCol = i-1; // virtual
PhysSourceColumn = lpColumnLB->ColumnOrderTable[SourceCol]; // physical
Direction = (SourceCol > DestCol) ? -1 : 1;
CurrentCol = SourceCol;
while (CurrentCol != DestCol)
{
NewOrderTable[CurrentCol] = NewOrderTable[CurrentCol + Direction];
CurrentCol += Direction;
}
//
// ok, it's equal to destination, so let's put the source Physical value into the destination
//
NewOrderTable[CurrentCol] = PhysSourceColumn;
//
// ok, so now set the order to the new order
//
SendMessage(hwnd, CLB_SETCOLORDER, (WPARAM)0, (LPARAM)NewOrderTable);
}
}
GetClientRect(lpColumnLB->hwndTitleList, &rect);
rect.left = lpColumnLB->ColumnOffsetTable[lpColumnLB->ColClickStart] + lpColumnLB->xPos;
rect.right = lpColumnLB->ColumnOffsetTable[lpColumnLB->ColClickStart+1] + lpColumnLB->xPos;
InvalidateRect(lpColumnLB->hwndTitleList, &rect, FALSE);
break;
case MOUSE_COLUMNCLICK:
//
// if this is a column click, we track the messages until the mouse has moved
//
lpColumnLB->fMouseState = 0;
ReleaseCapture();
ClipCursor(NULL);
lpColumnLB->ColumnInfoTable[PhysColumn].fDepressed = FALSE;
GetClientRect(lpColumnLB->hwndTitleList, &rect);
rect.left = lpColumnLB->ColumnOffsetTable[lpColumnLB->ColClickStart] + lpColumnLB->xPos;
rect.right = lpColumnLB->ColumnOffsetTable[lpColumnLB->ColClickStart+1] + lpColumnLB->xPos;
InvalidateRect(lpColumnLB->hwndTitleList, &rect, FALSE);
//
// now send a CLBN_SINGLECLICK message to the parent, only if the mousebutton was let up in the original
// column
//
Point.x = AdjustedX;
Point.y = y;
if (PtInRect(&lpColumnLB->ColClickRect, Point) == TRUE)
SendMessage(GetParent(hwnd), CLBN_TITLESINGLECLK, (WPARAM)GetDlgCtrlID(hwnd), (LPARAM)PhysColumn);
return;
}
}
// ------------------------------------------------------------------
// ColumnLBClass_OnRButtonDown()
//
// Handles WM_RBUTTON_DOWN messages
// alg:
//
// figure out where we are
// determine listbox item
// find height of rows
// translate mouse Y into a row number
// are we VLIST?
// Yes, Get TopIndex
// are we Owner Draw?
// Yes
// Send message to VLIST to get the data for row number
// No
// item number + TopIndex is the info the parent needs.
// No
// item number is the info the parent needs
// determine column
// calc which column taking into account scrolling
// send message to parent with info
// The parent will receive the column in wParam and the item in lParam. lParam
// needs to be the item because it might be the owner draw data.
//
//
//
// HISTORY:
// Steve Hiskey 10/19/93 Created
// ------------------------------------------------------------------
void ColumnLBClass_OnRButtonDown (HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
{
LPCOLUMNLBSTRUCT lpColumnLB = (LPCOLUMNLBSTRUCT)GetWindowLong(hwnd, 0L);
// get the item height here and not when the OnFont message is
// processed. ?? we get different/wrong results otherwise.
int ItemHeight = (int)ListBox_GetItemHeight(hwnd,1);
int Item = y / ItemHeight;
BYTE i;
int AdjustedX = x - lpColumnLB->xPos;
BYTE VirtColumn;
DWORD TopIndex;
CLBRBUTTONSTRUCT RButtonStruct;
BOOL GotOne = FALSE;
BOOL fTemp;
RButtonStruct.x = x;
RButtonStruct.y = y + lpColumnLB->yTitle;
RButtonStruct.hwndChild = hwnd;
//
// we already have the item (non VList), figure out which column
//
for(i=1; i < lpColumnLB->nColumns+1; i++)
{
if ((AdjustedX > lpColumnLB->ColumnOffsetTable[i-1]) &&
(AdjustedX < lpColumnLB->ColumnOffsetTable[i]))
{
//
// we have our column. Get the Physical Column. The parent of this column
// list box know what columns are interesting... and how the physical columns
// map to the virtual columns.
//
VirtColumn = i-1;
RButtonStruct.PhysColumn = lpColumnLB->ColumnOrderTable[VirtColumn];
GotOne = TRUE;
break;
}
}
if ( !GotOne)
return;
// are we VLIST?
if ( lpColumnLB->fUseVlist )
{
DWORD Style;
// are we owner draw? If so, then we don't care about TopIndex, we just want
// the instance data
Style = (DWORD)SendMessage(lpColumnLB->hwndList, VLB_GETVLISTSTYLE, 0, 0L);
if ( Style && VLBS_USEDATAVALUES )
{
// we are use data values. This means that we must ask the VList for the
// data and this is the data is the identifier of the row. ie, the data the
// VList stores is the structure needed to identify and display the line.
RButtonStruct.Index = ListBox_GetItemData(lpColumnLB->hwndList, Item );
}
else
{
// we are a normal vlist box. Get the top index and add our offset
// from top of listbox to it.
TopIndex = (DWORD)SendMessage(lpColumnLB->hwndList, LB_GETTOPINDEX, 0, 0L);
RButtonStruct.Index = TopIndex + Item;
}
}
else
{
// we are a normal list box. We need to know what item we are looking at.
// ask the listbox for the top index.
TopIndex = (DWORD)SendMessage(lpColumnLB->hwndList, LB_GETTOPINDEX, 0, 0L);
RButtonStruct.Index = TopIndex + Item;
}
// if they have hit rButton, we should set the focus to this item (lButton)... since
// WE are providing the CLB_SETCURSEL, we must tell the parent... some weird rule about
// if the user does a set cur sel, then the parent is notified, but if the parent does
// the set cur sel, the parent is not notified... since we are neither the parent or the
// user, we have to do both.
// if VLIST, we need to send just the item, top TopIndex + Item...
if ( lpColumnLB->fUseVlist )
fTemp = ListBox_SetCurSel(lpColumnLB->hwndList, Item);
else
fTemp = ListBox_SetCurSel(lpColumnLB->hwndList, RButtonStruct.Index);
if ( fTemp )
SendMessage(GetParent(hwnd), WM_COMMAND,
GetDlgCtrlID( lpColumnLB->hwndList),
MAKELPARAM(lpColumnLB->hwndList, LBN_SELCHANGE));
// we are ready to send which column and which row to the parent.
SendMessage ( GetParent (hwnd), CLBN_RBUTTONDOWN, (WORD)0, (LONG) &RButtonStruct );
}
// ------------------------------------------------------------------
// ColumnLBClass_DrawColumnBorder()
//
//
// HISTORY:
// Tom Laird-McConnell 3/15/94 created
// ------------------------------------------------------------------
void ColumnLB_DrawColumnBorder(HDC hDC, RECT *lpRect, int Bottom, HBRUSH hBackgroundBrush)
{
int ncxBorder = GetSystemMetrics(SM_CXBORDER);
RECT rect;
CopyRect(&rect, lpRect);
// fill in left side of rect
rect.right = rect.left;
rect.left -= (WHITESPACE/4);
FillRect(hDC, &rect, hBackgroundBrush);
// fill in right side of rect
rect.left = lpRect->right;
rect.right = lpRect->right + ncxBorder;
FillRect(hDC, &rect, hBackgroundBrush);
// draw the line itself
MoveToEx( hDC, rect.right, rect.top, NULL);
LineTo( hDC, rect.right, Bottom);
}
Reference in New Issue Copy Permalink