mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
706 lines
26 KiB
706 lines
26 KiB
|
|
/*************************************************
|
|
* movelst.c *
|
|
* *
|
|
* Copyright (C) 1995-1999 Microsoft Inc. *
|
|
* *
|
|
*************************************************/
|
|
|
|
#include <windows.h> // required for all Windows applications
|
|
#include <windowsx.h>
|
|
#include <stdlib.h>
|
|
#include <memory.h>
|
|
#include <tchar.h>
|
|
#include <htmlhelp.h>
|
|
#include "rc.h"
|
|
#include "movelst.h"
|
|
#include "lctool.h"
|
|
|
|
#define HELPNAME _TEXT("LCTOOL.CHM")
|
|
//Bug #19911
|
|
//#define SEQHELPKEY _TEXT("§ïÅܦrµü¶¶§Ç")
|
|
|
|
#define ID_TIMER 100
|
|
#define LINE_WIDTH 1
|
|
|
|
// style flags for the DrawIndicator() function
|
|
#define DI_TOPERASED 0x0001 // erasing a line drawn on the top of the list
|
|
#define DI_BOTTOMERASED 0x0002 // erasing a line drawn on the bottom of the list
|
|
#define DI_ERASEICON 0x0004 // erasing the icon
|
|
|
|
static UINT idTimer; // the id for the timer used in scrolling the list
|
|
static HFONT hFont; // a new font for the list box
|
|
static HCURSOR hCurDrag; // a cursor to indicate dragging
|
|
static int nHtItem; // the height of an individual item in the list box
|
|
static BOOL bNoIntegralHeight; // does the list box have the LBS_NOINTEGRALHEIGHT style flag
|
|
|
|
static HWND ghDlg; // handle to the main window
|
|
static HWND ghList; // handle to the list box
|
|
static HBRUSH ghBrush; // handle to the brush with the color of the windows background
|
|
static UINT iCurrentAddr;
|
|
|
|
void DrawIndicator(HDC hDC, int nYpos, int nWidth, WORD wFlags);
|
|
WNDPROC lpfnOldListProc, LstProc;
|
|
BOOL lcRemoveDup( TCHAR *szBuf );
|
|
void lcOrgEditWindow();
|
|
|
|
BOOL lcDisp2Seq(
|
|
HWND hDlg,
|
|
UINT iAddr,
|
|
TCHAR *szDispBuf)
|
|
{
|
|
UINT i,j,len;
|
|
#ifdef UNICODE
|
|
TCHAR szPhrase[SEGMENT_SIZE * 2];
|
|
#else
|
|
UCHAR szPhrase[SEGMENT_SIZE * 2];
|
|
#endif
|
|
int nRet;
|
|
|
|
// remove duplicate phrase
|
|
if(lcRemoveDup(szDispBuf) && iAddr < MAX_LINE){
|
|
SendMessage(hwndPhrase[iAddr],WM_SETTEXT,0,
|
|
(LPARAM)(LPCTSTR)szDispBuf);
|
|
}
|
|
|
|
len=lstrlen(szDispBuf)+1;
|
|
if((szDispBuf[len-1] == _TEXT(' ')) && (len > 1)) {
|
|
szDispBuf[len-1]=0;
|
|
len--;
|
|
}
|
|
if(len >= MAX_CHAR_NUM) { //tang must fix
|
|
szDispBuf[MAX_CHAR_NUM-1]=0;
|
|
#ifndef UNICODE
|
|
if(is_DBCS_1st(szDispBuf, MAX_CHAR_NUM-2))
|
|
szDispBuf[MAX_CHAR_NUM-2]=' ';
|
|
#endif
|
|
len=MAX_CHAR_NUM;
|
|
}
|
|
|
|
i = 0;
|
|
j = 0;
|
|
for(;;) {
|
|
if (i == len - 1) {
|
|
if (i - j + 1 > 0) {
|
|
lstrcpyn(szPhrase, &szDispBuf[j], i - j + 1);
|
|
SendDlgItemMessage(hDlg,IDD_SOURCELIST,
|
|
LB_ADDSTRING,
|
|
0,
|
|
(LPARAM)(LPSTR)szPhrase);
|
|
}
|
|
break;
|
|
}
|
|
if (szDispBuf[i] == ' ') {
|
|
lstrcpyn(szPhrase, &szDispBuf[j], i - j + 1);
|
|
nRet = (int)SendDlgItemMessage(hDlg,
|
|
IDD_SOURCELIST,
|
|
LB_ADDSTRING,
|
|
0,
|
|
(LPARAM)(LPSTR)szPhrase);
|
|
j = i + 1;
|
|
}
|
|
i++;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL lcSeq2Disp(
|
|
HWND hDlg,
|
|
UINT iAddr,
|
|
TCHAR *szDispBuf)
|
|
{
|
|
WORD nCount;
|
|
TCHAR szPhrase[SEGMENT_SIZE * 2];
|
|
int nRet;
|
|
WORD i;
|
|
|
|
nCount = (int)SendDlgItemMessage(hDlg,IDD_SOURCELIST, LB_GETCOUNT,
|
|
0, 0);
|
|
if (nCount == LB_ERR)
|
|
return FALSE;
|
|
|
|
*szDispBuf = 0;
|
|
for(i = 0; i < nCount; i++) {
|
|
nRet = (int)SendDlgItemMessage(hDlg,
|
|
IDD_SOURCELIST,
|
|
LB_GETTEXT,
|
|
(WPARAM)i,
|
|
(LPARAM)(LPSTR)szPhrase);
|
|
if (nRet == LB_ERR)
|
|
return FALSE;
|
|
|
|
lstrcat(szDispBuf, szPhrase);
|
|
lstrcat(szDispBuf, _TEXT(" "));
|
|
}
|
|
|
|
SendMessage(hwndPhrase[iAddr],WM_SETTEXT,0,
|
|
(LPARAM)(LPCTSTR)szDispBuf);
|
|
SendMessage(hwndPhrase[iAddr], EM_SETMODIFY, TRUE, 0);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void lcChangeSequence(
|
|
HWND hwnd)
|
|
{
|
|
int is_OK;
|
|
BOOL is_WORD;
|
|
|
|
iCurrentAddr=lcGetEditFocus(GetFocus(), &is_WORD);
|
|
is_OK=(INT)DialogBox(hInst,
|
|
_TEXT("SEQDIALOG"),
|
|
hwndMain,
|
|
(DLGPROC)ActualDlgProc);
|
|
|
|
if (is_WORD)
|
|
SetFocus(hwndWord[iCurrentAddr]);
|
|
else
|
|
SetFocus(hwndPhrase[iCurrentAddr]);
|
|
|
|
if (is_OK) {
|
|
bSaveFile = TRUE;
|
|
lcSaveEditText(iDisp_Top, 0);
|
|
lcOrgEditWindow();
|
|
}
|
|
}
|
|
|
|
LRESULT CALLBACK ClassDlgProc(HWND hDlg, UINT message, WPARAM wParam , LPARAM lParam)
|
|
{
|
|
|
|
return DefDlgProc(hDlg, message, wParam, lParam);
|
|
|
|
}
|
|
|
|
LRESULT CALLBACK ActualDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
TCHAR szStr[MAX_CHAR_NUM];
|
|
BOOL bRet;
|
|
|
|
switch (message)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
LOGFONT lf;
|
|
HMENU hSysMenu; // handle to the system menu
|
|
HDC hdc; // a dc to find out the number of pixels per logcal inch
|
|
LOGBRUSH lb;
|
|
|
|
lb.lbStyle = BS_SOLID;
|
|
lb.lbColor = GetSysColor(COLOR_WINDOW);
|
|
lb.lbHatch = 0;
|
|
|
|
ghBrush = CreateBrushIndirect(&lb);
|
|
|
|
hSysMenu = GetSystemMenu(hDlg, FALSE);
|
|
// disable the "maximize" option in the system menu
|
|
EnableMenuItem(hSysMenu, 4, MF_GRAYED|MF_DISABLED|MF_BYPOSITION);
|
|
// disable the "size" option of the system menu
|
|
EnableMenuItem(hSysMenu, 2, MF_GRAYED|MF_DISABLED|MF_BYPOSITION);
|
|
|
|
SendMessage(hwndPhrase[iCurrentAddr], WM_GETTEXT, MAX_CHAR_NUM-1, (LPARAM)szStr);
|
|
lcDisp2Seq(hDlg, iCurrentAddr, szStr);
|
|
|
|
ghList = GetDlgItem(hDlg, IDD_SOURCELIST);
|
|
LstProc = MakeProcInstance(NewListProc,hInst);
|
|
lpfnOldListProc = (WNDPROC)SetWindowLongPtr(ghList,
|
|
GWLP_WNDPROC,
|
|
(LONG_PTR)LstProc);
|
|
|
|
// check to see if it has integral height
|
|
bNoIntegralHeight = FALSE;
|
|
hdc = GetDC(hDlg);
|
|
memset(&lf, 0, sizeof(lf));
|
|
lf.lfHeight = -MulDiv(9, 96, 72);
|
|
lstrcpy(lf.lfFaceName, _TEXT("MS Sans Serif"));
|
|
hFont = CreateFontIndirect(&lf);
|
|
ReleaseDC(hDlg, hdc);
|
|
SendMessage(ghList, WM_SETFONT, (WPARAM)hFont, (LPARAM)FALSE);
|
|
// the drag cursor
|
|
hCurDrag = LoadCursor(hInst, _TEXT("IDC_DRAG"));
|
|
|
|
return FALSE; // didn't set the focus
|
|
}
|
|
break;
|
|
case WM_COMMAND:
|
|
switch (wParam)
|
|
{
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, FALSE);
|
|
break;
|
|
case IDOK:
|
|
bRet = lcSeq2Disp(hDlg, iCurrentAddr, szStr);
|
|
EndDialog(hDlg, bRet);
|
|
break;
|
|
case ID_HELP:
|
|
LoadString(hInst, IDS_CHANGEWORDORDER, szStr, sizeof(szStr)/sizeof(TCHAR));
|
|
// WinHelp(hDlg, HELPNAME, HELP_PARTIALKEY, (DWORD)szStr);
|
|
HtmlHelp(hDlg, HELPNAME, HH_DISPLAY_TOPIC, 0L);
|
|
break;
|
|
}
|
|
return TRUE;
|
|
|
|
case WM_DESTROY: // clean up
|
|
{
|
|
DeleteObject(ghBrush);
|
|
DeleteObject(hFont);
|
|
DestroyCursor(hCurDrag);
|
|
}
|
|
break;
|
|
default:
|
|
return FALSE; // we didn't do anyting
|
|
} // end switch message
|
|
return TRUE; // we did the processing
|
|
|
|
}
|
|
|
|
LRESULT CALLBACK NewListProc(HWND hwndList,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
|
|
static BOOL bTracking = FALSE;
|
|
static BOOL bDrag = FALSE;
|
|
static HCURSOR hCursorOld = NULL;
|
|
|
|
|
|
|
|
switch (message)
|
|
{
|
|
case WM_CANCELMODE:
|
|
// WM_CANCELMODE is sent to the window that has captured the mouse before
|
|
// a message box or modal dialog is displayed. If we were dragging the item
|
|
// cancel the drag.
|
|
bTracking = FALSE;
|
|
ReleaseCapture();
|
|
if (bDrag)
|
|
SetCursor(hCursorOld);
|
|
break;
|
|
case WM_LBUTTONDOWN:
|
|
{
|
|
|
|
// Was the list box item dragged into the destination?
|
|
BOOL bDragSuccess = FALSE;
|
|
MSG msg;
|
|
POINTS pts;
|
|
POINTS points;
|
|
POINT pt;
|
|
POINT point;
|
|
|
|
RECT rectIsDrag; // Rectangle to determine if dragging has started.
|
|
int nOldPos;
|
|
|
|
int nOldY = -1; // the last place that we drew on
|
|
HDC hdc; // dc to draw on
|
|
div_t divt; // get remainder a quotient with "div"
|
|
int nCount;
|
|
div_t divVis;
|
|
// space for scroll bar - starts off at 1 so we don't overwrite the border
|
|
int dxScroll = 1;
|
|
RECT rect;
|
|
int nVisible; // the number of items visible
|
|
int idTimer; // id for the timer
|
|
int nNewPos; // the new position
|
|
int nTopIndex; // the top index
|
|
|
|
|
|
|
|
|
|
GetWindowRect(hwndList, &rect);
|
|
|
|
// Pass the WM_LBUTTONDOWN to the list box window procedure. Then
|
|
// fake a WM_LBUTTONUP so that we can track the drag.
|
|
CallWindowProc(lpfnOldListProc, hwndList, message, wParam, lParam);
|
|
|
|
// the number of items in the list box
|
|
nCount = (int)SendMessage(hwndList, LB_GETCOUNT,0,0L);
|
|
if (nCount == 0 ) // don't do anything to and empty list box
|
|
return 0;
|
|
// fake the WM_LBUTTONUP
|
|
CallWindowProc(lpfnOldListProc, hwndList, WM_LBUTTONUP, wParam, lParam);
|
|
// get a dc to draw on
|
|
hdc = GetDC(hwndList);
|
|
|
|
// the height of each item
|
|
nHtItem = (int)SendMessage(hwndList, LB_GETITEMHEIGHT,0,0L);
|
|
// the current item
|
|
nOldPos = (int)SendMessage(hwndList, LB_GETCURSEL,0,0L);
|
|
|
|
divVis = div((rect.bottom - rect.top), nHtItem);
|
|
// the number of visible items
|
|
nVisible = divVis.quot;
|
|
// some items are invisible - there must be scroll bars - we don't want
|
|
// to draw on them
|
|
if (nVisible < nCount)
|
|
dxScroll = GetSystemMetrics(SM_CXVSCROLL) + 1;
|
|
|
|
idTimer = 0;
|
|
idTimer = (UINT)SetTimer(hwndList, ID_TIMER,100,NULL);
|
|
|
|
|
|
// Create a tiny rectangle to determine if item was dragged or merely clicked on.
|
|
// If the user moves outside this rectangle we assume that the dragging has
|
|
// started.
|
|
points = MAKEPOINTS(lParam);
|
|
point.x = points.x; point.y = points.y;
|
|
SetRect(&rectIsDrag, point.x, point.y - nHtItem / 2,
|
|
point.x, point.y + nHtItem / 2);
|
|
|
|
|
|
bTracking = TRUE;
|
|
SetCapture(hwndList);
|
|
|
|
|
|
// Drag loop
|
|
while (bTracking)
|
|
{
|
|
// Retrieve mouse, keyboard, and timer messages. We retrieve keyboard
|
|
// messages so that the system queue is not filled by keyboard messages
|
|
// during the drag (This can happen if the user madly types while dragging!)
|
|
// If none of these messages are available we wait. Both PeekMessage()
|
|
// and Waitmessage() will yield to other apps.
|
|
|
|
while (!PeekMessage(&msg, NULL, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE)
|
|
&& !PeekMessage(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)
|
|
&& !PeekMessage(&msg, NULL, WM_TIMER, WM_TIMER, PM_REMOVE))
|
|
WaitMessage();
|
|
switch(msg.message)
|
|
{
|
|
case WM_MOUSEMOVE:
|
|
{
|
|
pts = MAKEPOINTS(msg.lParam);
|
|
pt.x = pts.x; pt.y = pts.y;
|
|
if (!bDrag)
|
|
{
|
|
// Check if the user has moved out of the Drag rect.
|
|
// in the vertical direction. This indicates that
|
|
// the drag has started.
|
|
if ( (pt.y > rectIsDrag.bottom) ||
|
|
(pt.y < rectIsDrag.top)) // !PtInRect(&rectIsDrag,pt))
|
|
{
|
|
hCursorOld = SetCursor(hCurDrag);
|
|
bDrag = TRUE; // Drag has started
|
|
|
|
}
|
|
}
|
|
|
|
|
|
if (bDrag)
|
|
{
|
|
|
|
SetCursor(hCurDrag);
|
|
// if we are above or below the list box, then we are scrolling it, and
|
|
// we shouldn't be drawing here
|
|
ClientToScreen(hwndList, &pt);
|
|
if ((pt.y >= rect.top) && (pt.y <= rect.bottom))
|
|
{
|
|
// convert the point back to client coordinates
|
|
ScreenToClient(hwndList, &pt);
|
|
divt = div(pt.y,nHtItem);
|
|
|
|
// if we are half way to the item
|
|
// AND it is a new item
|
|
// AND we are not past the end of the list..
|
|
if ( divt.rem < nHtItem / 2 &&
|
|
(nOldY != nHtItem * divt.quot) &&
|
|
(divt.quot < nCount + 1))
|
|
{
|
|
|
|
if (nOldY != -1)
|
|
{
|
|
// erase the old one
|
|
DrawIndicator(hdc, nOldY,(rect.right - rect.left) - dxScroll, DI_ERASEICON);
|
|
}
|
|
|
|
nOldY = nHtItem * divt.quot;
|
|
DrawIndicator(hdc, nOldY,(rect.right - rect.left) - dxScroll, 0);
|
|
|
|
}
|
|
} // end if in the list box window
|
|
|
|
} // end if bDrag
|
|
|
|
}
|
|
break;
|
|
case WM_TIMER:
|
|
{
|
|
POINT pt;
|
|
GetCursorPos(&pt);
|
|
nTopIndex = (int)SendMessage(hwndList, LB_GETTOPINDEX,0,0L);;
|
|
if (pt.y < rect.top) // scroll up
|
|
{
|
|
|
|
if (nTopIndex > 0)
|
|
{
|
|
|
|
nTopIndex--;
|
|
SendMessage(hwndList, LB_SETTOPINDEX, nTopIndex,0L);
|
|
// when you scroll up, the line always stays on the top index
|
|
// erase the one we've moved down
|
|
DrawIndicator(hdc, nHtItem,(rect.right - rect.left) - dxScroll, DI_TOPERASED|DI_ERASEICON);
|
|
// draw the new one
|
|
DrawIndicator(hdc, 0,(rect.right - rect.left) - dxScroll, 0);
|
|
// the new one was drawn at y = 0
|
|
nOldY = 0;
|
|
|
|
}
|
|
|
|
}
|
|
else if (pt.y > rect.bottom) // scroll down
|
|
{
|
|
// if the number of visible items (ie seen in the list box)
|
|
// plus the number above the list is less than the total number
|
|
// of items, then we need to scroll down
|
|
if (nVisible + nTopIndex < nCount)
|
|
{
|
|
|
|
if (nOldY - nTopIndex != nVisible)
|
|
{
|
|
// if them move below the list REALLY REALLY FAST, then
|
|
// the last line will not be on the bottom - so we want to reset the last
|
|
// line to be the bottom
|
|
|
|
// erase the old line
|
|
DrawIndicator(hdc, nOldY,(rect.right - rect.left) - dxScroll, DI_ERASEICON);
|
|
// reset the index
|
|
divt.quot = nVisible;
|
|
nOldY = divt.quot * nHtItem;
|
|
// draw the new line
|
|
DrawIndicator(hdc, nOldY,(rect.right - rect.left) - dxScroll, 0);
|
|
|
|
|
|
}
|
|
// scroll up
|
|
nTopIndex++;
|
|
SendMessage(hwndList, LB_SETTOPINDEX, nTopIndex,0L);
|
|
|
|
// erase the line that has moved up..
|
|
DrawIndicator(hdc, nOldY - nHtItem,(rect.right - rect.left) - dxScroll, DI_BOTTOMERASED|DI_ERASEICON);
|
|
// draw the new one
|
|
DrawIndicator(hdc, nOldY,(rect.right - rect.left) - dxScroll, 0);
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
case WM_LBUTTONUP:
|
|
// End of Drag
|
|
|
|
nTopIndex = (int)SendMessage(hwndList, LB_GETTOPINDEX, 0, 0L);
|
|
if (bDrag)
|
|
{
|
|
// get rid of any line we've drawn - the position of the line
|
|
// divided by the height of the itme is where our new index
|
|
// is going to be
|
|
DrawIndicator(hdc, nOldY,(rect.right - rect.left) - dxScroll, DI_ERASEICON);
|
|
|
|
nNewPos = (nOldY / nHtItem) + nTopIndex;
|
|
// the old position can't equal the new one
|
|
if (nNewPos != nOldPos)
|
|
bDragSuccess = TRUE;
|
|
}
|
|
bTracking = FALSE;
|
|
break;
|
|
default:
|
|
// Process the keyboard messages
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
break;
|
|
}
|
|
}// end while bTracking
|
|
|
|
ReleaseCapture();
|
|
if (bDrag)
|
|
{
|
|
SetCursor(hCursorOld);
|
|
// move the item
|
|
if (bDragSuccess)
|
|
{
|
|
int nIndex;
|
|
char s[256];
|
|
|
|
|
|
// we need to store the top index, because deleting and adding a new
|
|
// string will change it, and we want to be able to see the item that
|
|
// we have moved
|
|
nTopIndex = (int)SendMessage(hwndList, LB_GETTOPINDEX,0,0L);
|
|
// stop most of the blinking..
|
|
SendMessage(hwndList, WM_SETREDRAW, FALSE,0L);
|
|
// get the text of the item - limited to 256 chars!
|
|
SendMessage(hwndList, LB_GETTEXT, nOldPos, (LPARAM)(LPSTR)s);
|
|
|
|
/*------------------------------------------------------------------------
|
|
| strategy: given ABCD and moving to BCAD do the following:
|
|
|
|
|
| 1. delete A -- giving BCD
|
|
| 2. insert A -- giving BCAD
|
|
| 3. hilite A
|
|
| 4. set the top index so A is visible
|
|
-------------------------------------------------------------------------*/
|
|
// delete the original string
|
|
SendMessage(hwndList, LB_DELETESTRING, nOldPos, 0L);
|
|
|
|
// if we've moved DOWN the list subtract one from the new index
|
|
// (because we've deleted a string but if we are moving UP the list,
|
|
// we don't subtract anything (the deleted item is below the new item,
|
|
// so our new index hasn't changed
|
|
|
|
if (nNewPos > nOldPos)
|
|
nNewPos--;
|
|
// put it in the new pos
|
|
nIndex = (int)SendMessage(hwndList,
|
|
LB_INSERTSTRING,
|
|
nNewPos,
|
|
(LPARAM)(LPSTR)s);
|
|
|
|
SendMessage(hwndList, LB_SETCURSEL, nIndex, 0L);
|
|
SendMessage(hwndList, LB_SETTOPINDEX, nTopIndex,0L);
|
|
SendMessage(hwndList, WM_SETREDRAW, TRUE,0L);
|
|
|
|
} // end if bDragSuccess
|
|
} // end if bDrag
|
|
bDrag = FALSE;
|
|
ReleaseDC(hwndList, hdc);
|
|
KillTimer(hwndList, idTimer);
|
|
}
|
|
break;
|
|
default:
|
|
return CallWindowProc(lpfnOldListProc, hwndList, message, wParam, lParam);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CALLBACK AboutDlgProc (HWND hDlg, UINT message,
|
|
WPARAM wParam, LPARAM lParam)
|
|
{
|
|
|
|
switch (message)
|
|
{
|
|
case WM_INITDIALOG:
|
|
return (TRUE);
|
|
case WM_COMMAND:
|
|
if (wParam == IDOK)
|
|
{
|
|
EndDialog(hDlg, TRUE);
|
|
return (TRUE);
|
|
}
|
|
break;
|
|
}
|
|
return (FALSE);
|
|
|
|
}
|
|
|
|
void DrawIndicator(HDC hDC, int nYpos, int nWidth, WORD wFlags)
|
|
{
|
|
|
|
// draw a horizontal line
|
|
int nTop, nHeight;
|
|
HICON hIcon;
|
|
HRGN hClipRgn; // the clipping region
|
|
RECT rect;
|
|
|
|
// we don't want the clip anything when we are drawing
|
|
// the icon outside the list box
|
|
SelectClipRgn(hDC, NULL);
|
|
if (wFlags & DI_ERASEICON)
|
|
{
|
|
rect.left = -33;
|
|
rect.right = -1;
|
|
rect.top = nYpos -16;
|
|
rect.bottom = nYpos + 16;
|
|
// ghBrush is created in WM_INITDIALOG
|
|
FillRect(hDC, &rect, ghBrush);
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
hIcon = LoadIcon(hInst, _TEXT("IDI_ARROW"));
|
|
if (hIcon)
|
|
{
|
|
DrawIcon(hDC,-33,nYpos - 16,hIcon);
|
|
DestroyIcon(hIcon);
|
|
}
|
|
}
|
|
|
|
|
|
// create a clipping region for drawing the lines in the list box
|
|
GetWindowRect(ghList, &rect);
|
|
hClipRgn = CreateRectRgn(0,0, rect.right - rect.left, rect.bottom - rect.top);
|
|
if ( hClipRgn )
|
|
{
|
|
SelectClipRgn(hDC, hClipRgn);
|
|
// we can delete it emmdiately because SelectClipRgn makes a COPY of the region
|
|
DeleteObject(hClipRgn);
|
|
}
|
|
|
|
|
|
/****************************************************
|
|
|
|
erasing something drawn on top
|
|
the top is drawn like
|
|
|
|
______ |_____|
|
|
| | instead of | |
|
|
|
|
so we want to NOT draw the two vertical lines
|
|
above the horzontal
|
|
|
|
*****************************************************/
|
|
// if (nYpos = 0) wFlags |= DI_TOPERASED;
|
|
if (wFlags & DI_TOPERASED)
|
|
{
|
|
nTop = nYpos;
|
|
nHeight = nHtItem / 4;
|
|
}
|
|
/****************************************************
|
|
|
|
erasing something originally drawn on the bottom
|
|
|
|
if the list box is NOT LBS_NOINTEGRALHEIGHT, then
|
|
the botton line will be on the border of the list
|
|
box, so we don't want to draw the horizontal line at
|
|
all, ie we draw
|
|
|
|
| | |_____|
|
|
instead of | |
|
|
|
|
|
|
*****************************************************/
|
|
else if (wFlags & DI_BOTTOMERASED && !bNoIntegralHeight)
|
|
{
|
|
nTop = nYpos - nHtItem / 4;
|
|
nHeight = nHtItem / 4;
|
|
}
|
|
|
|
else
|
|
{
|
|
nTop = nYpos - nHtItem / 4;
|
|
nHeight = nHtItem / 2;
|
|
}
|
|
|
|
if (!(wFlags & DI_BOTTOMERASED && !bNoIntegralHeight)) // see above comment
|
|
{
|
|
PatBlt(hDC,
|
|
LINE_WIDTH,
|
|
nYpos,
|
|
nWidth - 2 * LINE_WIDTH,
|
|
LINE_WIDTH,
|
|
PATINVERT);
|
|
}
|
|
PatBlt(hDC,
|
|
0,
|
|
nTop,
|
|
LINE_WIDTH,
|
|
nHeight ,
|
|
PATINVERT);
|
|
|
|
PatBlt(hDC,
|
|
nWidth - LINE_WIDTH,
|
|
nTop,
|
|
LINE_WIDTH,
|
|
nHeight,
|
|
PATINVERT);
|
|
}
|