archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
2 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/shell/osshell/accesory/eudcedit/eudclist.cpp

1710 lines
43 KiB
Raw Blame History

/**************************************************/
/* */
/* */
/* EUDC Character List ( Japan, China, Korea) */
/* */
/* */
/* Copyright (c) 1997-1999 Microsoft Corporation. */
/**************************************************/
#include "stdafx.h"
#include "eudcedit.h"
#include "eudclist.h"
#include "util.h"
#define STRSAFE_LIB
#include <strsafe.h>
#ifdef BUILD_ON_WINNT
#include "extfunc.h"
#endif // BUILD_ON_WINNT
/* Matrics of Characterlist */
#define NUM_CHAR 16 // Row of matrics
#define NUM_LINE 6 // Line of matrics
#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif
IMPLEMENT_DYNCREATE( CEudcList, CEdit)
BEGIN_MESSAGE_MAP( CEudcList, CEdit)
//{{AFX_MSG_MAP( CEudcList)
ON_WM_PAINT()
ON_WM_VSCROLL()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONDBLCLK()
ON_WM_SETCURSOR()
ON_WM_KEYDOWN()
ON_WM_SETFOCUS()
ON_WM_KILLFOCUS()
ON_WM_RBUTTONUP()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
#ifdef BUILD_ON_WINNT
static CRect rcColumnHead[NUM_CHAR];
#endif //BUILD_ON_WINNT
static CRect rcEditChar[NUM_LINE][NUM_CHAR];
static CRect rcEditCode[NUM_LINE];
static BYTE ViewCode[NUM_LINE];
static BOOL bHasGlyph;
#define EUDCCODEBASE ((unsigned short)0xe000)
/****************************************/
/* */
/* Default Constructor */
/* */
/****************************************/
CEudcList::CEudcList()
{
// Initialize parameter( Japan, China and Korea)
SetInitEUDCCodeRange( CountryInfo.CurrentRange);
FocusFlag = FALSE;
}
/****************************************/
/* */
/* Set coderange of EUDC */
/* */
/****************************************/
void
CEudcList::SetInitEUDCCodeRange(
int nIndex)
{
if ( (nIndex >= ARRAYLEN(CountryInfo.sRange)) || (nIndex >= ARRAYLEN(CountryInfo.eRange)))
{
return;
}
m_Index = nIndex;
EUDC_SCode = CountryInfo.sRange[m_Index];
EUDC_ECode = CountryInfo.eRange[m_Index];
EUDC_EView =(CountryInfo.eRange[m_Index] & 0xfff0) -(0x10*(NUM_LINE-1));
if( SelectEUDC.m_Code[0] != '\0'){
SelectCode = (WORD)Mytcstol(SelectEUDC.m_Code, (TCHAR **)0, 16);
EUDC_SView = (WORD)Mytcstol(SelectEUDC.m_Code, (TCHAR **)0, 16);
EUDC_SView &= 0xfff0;
if( EUDC_EView <= EUDC_SView)
EUDC_SView = EUDC_EView;
}else{
EUDC_SView = CountryInfo.sRange[m_Index] & 0xfff0;
SelectCode = EUDC_SCode;
}
#ifdef BUILD_ON_WINNT
//In case of CHS, each range will have a different trail byte range
//after user selects a new range, we have to correct them with
//sOrigTralByte and eOrigTralByte and form new trail byte range.
if (CountryInfo.LangID == EUDC_CHS && !CountryInfo.bUnicodeMode)
CorrectTrailByteRange(m_Index);
#endif // BUILD_ON_WINNT
LButtonPt.x = LButtonPt.y = 0;
ScrlBarPos = (short)GetBarPosition( EUDC_SView);
this->SetScrollPos( SB_VERT, ScrlBarPos, TRUE);
}
/****************************************/
/* */
/* Set coderange of EUDC */
/* */
/****************************************/
void
CEudcList::SetEUDCCodeRange(
int nIndex)
{
if ( (nIndex >= ARRAYLEN(CountryInfo.sRange)) || (nIndex >= ARRAYLEN(CountryInfo.eRange)))
{
return;
}
m_Index = nIndex;
EUDC_SView = CountryInfo.sRange[m_Index] & 0xfff0;
EUDC_EView =(CountryInfo.eRange[m_Index] & 0xfff0) -(0x10*(NUM_LINE-1));
EUDC_SCode = CountryInfo.sRange[m_Index];
EUDC_ECode = CountryInfo.eRange[m_Index];
#ifdef BUILD_ON_WINNT
//In case of CHS, each range will have a different trail byte range
//after user selects a new range, we have to correct them with
//sOrigTralByte and eOrigTralByte and form new trail byte range.
if (CountryInfo.LangID == EUDC_CHS && !CountryInfo.bUnicodeMode)
CorrectTrailByteRange(m_Index);
#endif // BUILD_ON_WINNT
SelectCode = (WORD)EUDC_SCode;
LButtonPt.x = LButtonPt.y = 0;
ScrlBarPos = (short)0;
this->SetScrollPos( SB_VERT, ScrlBarPos, TRUE);
}
/****************************************/
/* */
/* Destructor */
/* */
/****************************************/
CEudcList::~CEudcList()
{
SysFFont.DeleteObject();
EUDCFont.DeleteObject();
}
/****************************************/
/* */
/* Correct it if code is illegal */
/* */
/****************************************/
WORD
CEudcList::CorrectEUDCCode(
WORD Code,
BOOL UporDown)
{
COUNTRYINFO Info;
WORD wCode;
BYTE LByte, HByte;
int TralPos = 0;
LByte = LOBYTE( Code);
HByte = HIBYTE( Code);
Info = CountryInfo;
//decide code falls in which trail byte range
for( int i = 0; i < Info.nTralByte; i++){
if( LByte >= (Info.sTralByte[i] & 0xf0) &&
LByte <= (Info.eTralByte[i] & 0xf0)){
goto RET;
}else if( LByte < (Info.sTralByte[i] & 0xf0)){
TralPos = i;
break;
}else TralPos = i+1;
}
#ifdef BUILD_ON_WINNT
// If we are going up on the code range, make the code in the first
// first line of next valid trailbyte. Otherwise make the code in
// the last line the preivous valid range.
if( UporDown){
if( TralPos == Info.nTralByte){
TralPos =0;
HByte += 0x1;
}
LByte = Info.sTralByte[TralPos] & 0xf0;
}else{
if( TralPos ==0 ){
HByte -= 0x1;
TralPos = Info.nTralByte;
}
LByte = Info.eTralByte[TralPos-1] & 0xf0;
}
#else
if( UporDown)
if( TralPos == Info.nTralByte){
LByte = (Info.sTralByte[0] & 0xf0);
HByte += 0x1;
}else LByte = (Info.sTralByte[TralPos] & 0xf0);
else{
if( !TralPos){
LByte = (Info.eTralByte[Info.nTralByte-1] & 0xf0);
HByte -= 0x1;
}else LByte = (Info.eTralByte[TralPos-1] & 0xf0);
}
#endif // BUILD_ON_WINNT
RET:
wCode = MAKEWORD( LByte, HByte);
return wCode;
}
/****************************************/
/* */
/* Get position of scrollbar */
/* */
/****************************************/
#ifdef BUILD_ON_WINNT
int
CEudcList::GetBarPosition(
WORD Code)
{
COUNTRYINFO Info;
WORD NumPage=0, NumCode=0;
BYTE Space[MAX_LEADBYTES];
int TotalSpace=0,TralPos=0;
int Err;
BOOL ValidCode=FALSE;
Info = CountryInfo;
NumPage = HIBYTE( Code) - HIBYTE( EUDC_SCode);
// Calculate each code space block for each trail byte range
// and decide how many of each we count.
/* space before first trailbyte range */
Space[0] = ( Info.sTralByte[0] & 0xf0);
for( int i = 1; i < Info.nTralByte; i++){
Space[i] = (( Info.sTralByte[i] & 0xf0)
- ( Info.eTralByte[i-1] & 0xf0) - 0x10);
}
/* space after last trailbyte range */
Space[i] = (0xff - Info.eTralByte[Info.nTralByte-1]) & 0xf0;
for (i = 0; i < Info.nTralByte; i++)
if( LOBYTE( Code) >= (Info.sTralByte[i] & 0xf0) &&
LOBYTE( Code) <= (Info.eTralByte[i] & 0xff)){
ValidCode=TRUE; //within our trail byte range.
TralPos=i;
break;
}
if (!ValidCode)
return(0); //not within our trail byte range.
for (i = 0; i < Info.nTralByte; i++){
if (Info.sTralByte[TralPos] > LOBYTE( EUDC_SCode )){
if((Info.sTralByte[i]) > LOBYTE(EUDC_SCode) && i <= TralPos)
TotalSpace += Space[i] * (NumPage + 1);
else
TotalSpace += Space[i] * NumPage ;
}else{
if((Info.sTralByte[i] & 0xf0) < LOBYTE(EUDC_SCode) && i > TralPos)
TotalSpace += Space[i] * (NumPage - 1);
else
TotalSpace += Space[i] * NumPage ;
}
}
TotalSpace += Space[i] * NumPage;
Err = EUDC_SCode & 0x000f;
NumCode = Code - EUDC_SCode - TotalSpace + Err;
return( NumCode /NUM_CHAR);
}
#else
int
CEudcList::GetBarPosition(
WORD Code)
{
COUNTRYINFO Info;
WORD NumPage, NumCode;
BYTE Space[MAX_LEADBYTES];
int LoSpace, HiSpace;
int Err;
Info = CountryInfo;
NumPage = HIBYTE( Code) - HIBYTE( EUDC_SCode);
Space[0] = ( Info.sTralByte[0] & 0xf0);
Space[1] = 0x00;
for( int i = 1; i < Info.nTralByte; i++){
Space[i] = (( Info.sTralByte[i] & 0xf0)
- ( Info.eTralByte[i-1] & 0xf0) - 0x10);
}
for( i = 0; i < Info.nTralByte; i++){
if( LOBYTE( Code) >= (Info.sTralByte[i] & 0xf0) &&
LOBYTE( Code) <= (Info.eTralByte[i] & 0xff)){
if( LOBYTE( EUDC_SCode) > Info.sTralByte[0]){
LoSpace = ( Space[0] * NumPage);
HiSpace = ( Space[1] * (i + NumPage - 1));
}else{
LoSpace = ( Space[0] * NumPage);
HiSpace = ( Space[1] * (i + NumPage));
}
Err = EUDC_SCode & 0x000f;
NumCode = Code - EUDC_SCode - LoSpace - HiSpace + Err;
break;
}
}
return( NumCode /NUM_CHAR);
}
#endif // BUILD_ON_WINNT
/****************************************/
/* */
/* Calculate bar pos from code */
/* */
/****************************************/
WORD
CEudcList::GetCodeScrPos(
int Pos)
{
WORD i;
WORD Code = 0;
WORD NumLine = 0;
WORD PNumLine = 0;
if( !Pos)
return( EUDC_SCode & 0xfff0);
#ifdef BUILD_ON_WINNT
// we dont't need to go through each char, instead we can examine each
// line to make this faster
for( i = EUDC_SCode; i <= EUDC_ECode; i+= NUM_CHAR){
#else
for( i = EUDC_SCode; i <= EUDC_ECode; ++i){
#endif // BUILD_ON_WINNT
NumLine = (WORD)GetBarPosition( i);
if( NumLine >= Pos){
NumLine = PNumLine;
break;
}
PNumLine = NumLine;
}
Code = i;
Pos -= NumLine;
Code &= 0xfff0;
return Code;
}
#define FIX_SPACE 6
#define LINEWIDTH 4
/****************************************/
/* */
/* Calcurate character size */
/* */
/****************************************/
void
CEudcList::CalcCharSize()
{
TCHAR Dummy[] = TEXT("FA40");
int Sx;
int OldMode;
CClientDC dc( this);
this->GetClientRect( &EditListRect);
OldMode = dc.SetMapMode( MM_TEXT);
CFont *OldFont = dc.SelectObject( &SysFFont);
GetTextExtentPoint32( dc.GetSafeHdc(), Dummy, 4, &FixSize);
FixSize.cx += FIX_SPACE;
dc.SelectObject( OldFont);
CharSize.cy = ( EditListRect.Height()
- (NUM_LINE-1)*LINEWIDTH - 2) / NUM_LINE;
CharSize.cx = ( EditListRect.Width()
- FixSize.cx - 2 - (NUM_CHAR*LINEWIDTH)) / NUM_CHAR;
for( int i = 0; i < NUM_LINE; i++){
rcEditCode[i].left = 1;
rcEditCode[i].top = 1 + i*( CharSize.cy + LINEWIDTH);
rcEditCode[i].right = rcEditCode[i].left + FixSize.cx;
rcEditCode[i].bottom = rcEditCode[i].top + CharSize.cy;
Sx = rcEditCode[i].right + LINEWIDTH;
for( int j = 0; j < NUM_CHAR; j++){
rcEditChar[i][j].left = Sx +j*(CharSize.cx+LINEWIDTH);
rcEditChar[i][j].top = rcEditCode[i].top;
rcEditChar[i][j].right = rcEditChar[i][j].left
+ CharSize.cx;
rcEditChar[i][j].bottom = rcEditChar[i][j].top
+ CharSize.cy;
}
}
#ifdef BUILD_ON_WINNT
for( int j = 0; j < NUM_CHAR; j++){
rcColumnHead[j].left = Sx +j*(CharSize.cx+LINEWIDTH);
rcColumnHead[j].top = 1;
rcColumnHead[j].right = rcColumnHead[j].left + CharSize.cx;
rcColumnHead[j].bottom = 1 + FixSize.cy;
}
#endif //BUILD_ON_WINNT
dc.SetMapMode( MM_TEXT);
}
/****************************************/
/* */
/* MESSAGE "WM_PAINT" */
/* */
/****************************************/
void
CEudcList::OnPaint()
{
register int i, j, k;
WORD Code;
CFont *OldFont;
BYTE Glyph[800];
BOOL bGlyph = FALSE;
HRESULT hresult;
CPaintDC dc( this);
int BottomCode = GetBarPosition((WORD)EUDC_EView);
SetScrollRange( SB_VERT, 0, BottomCode, FALSE);
this->SetScrollPos( SB_VERT, ScrlBarPos, TRUE);
Code = EUDC_SView;
int OldMapMode = dc.SetMapMode( MM_TEXT);
dc.SetViewportOrg( 0, 0);
OldFont = dc.SelectObject( &SysFFont);
//
// access *.euf to set bits in the array (800 * 8 = 6400)
// to indicate a char has a glyph
//
bGlyph = GetGlyph(SelectEUDC.m_File, Glyph);
for( i = 0; i < NUM_LINE; i++){
BYTE CodeArray[10];
int xOffset, yOffset;
// Check character code
dc.SelectObject( &SysFFont);
Code = CorrectEUDCCode( Code, TRUE);
//*STRSAFE* wsprintf((LPTSTR)CodeArray, TEXT("%04X"), Code);
hresult = StringCbPrintf((LPTSTR)CodeArray , sizeof(CodeArray), TEXT("%04X"), Code);
if (!SUCCEEDED(hresult))
{
return ;
}
dc.SetBkColor( COLOR_FACE);
dc.SetTextColor(GetSysColor(COLOR_WINDOWTEXT)); // COLOR_BLACK);
if( rcEditChar[i][0].Height() > FixSize.cy){
yOffset = ( rcEditChar[i][0].Height() - FixSize.cy) /2;
}else yOffset = 0;
ExtTextOut( dc.GetSafeHdc(), rcEditCode[i].left,
rcEditCode[i].top + yOffset,
ETO_OPAQUE, &rcEditCode[i],
(LPCTSTR)CodeArray, 4, NULL);
dc.SelectObject( &EUDCFont);
for( j = 0; j < NUM_CHAR; j++,Code++){
BYTE sOffset;
CSize cSize;
BOOL flg;
int wLength;
//
// see if the character has a glyph
//
bHasGlyph = TRUE;
if(bGlyph == TRUE)
{
WORD wIndex;
if (CountryInfo.bUnicodeMode)
wIndex = Code - EUDCCODEBASE;
else
{
CHAR pchar[3];
WCHAR wpchar[2];
pchar[0] = HIBYTE(Code);
pchar[1] = LOBYTE(Code);
pchar[2] = 0;
MultiByteToWideChar(CP_ACP, 0, pchar, 2, wpchar, 1);
wIndex = wpchar[0] - EUDCCODEBASE;
}
if((Glyph[wIndex>>3] & (0x80>>(wIndex%8))) == 0)
bHasGlyph = FALSE;
}
//fix for FontIsLinked
else
bHasGlyph = FALSE;
//
flg = FALSE;
sOffset = LOBYTE( Code);
for( k = 0; k < CountryInfo.nTralByte; k++){
if( sOffset >= CountryInfo.sTralByte[k] &&
sOffset <= CountryInfo.eTralByte[k]){
flg = TRUE;
}
}
if((Code < CountryInfo.sRange[cRange])
||(Code > CountryInfo.eRange[cRange]))
flg = FALSE;
if( !flg) continue;
if (CountryInfo.bUnicodeMode){
CodeArray[1] = HIBYTE(Code);
CodeArray[0] = LOBYTE(Code);
wLength = 1;
}
else{
CodeArray[0] = HIBYTE(Code);
CodeArray[1] = LOBYTE(Code);
wLength = 2;
}
CodeArray[2] = (BYTE)'\0';
BOOL PtIn;
if(( rcEditChar[i][j].PtInRect( LButtonPt) ||
SelectCode == Code) && wLength != 0){
TCHAR CodeNum[10];
// If character is selected by left clickking ,
// Put it on dialog.
PtIn = TRUE;
SelectCode = Code;
dc.SetBkColor(COLOR_FACE);
dc.SetTextColor(GetSysColor(COLOR_WINDOWTEXT)); // COLOR_BLACK);
//*STRSAFE* wsprintf(CodeNum, TEXT("%04X"),Code);
hresult = StringCchPrintf(CodeNum , ARRAYLEN(CodeNum), TEXT("%04X"),Code);
if (!SUCCEEDED(hresult))
{
return ;
}
GetParent()->SetDlgItemText(IDC_CODECUST,CodeNum);
if (CountryInfo.bUnicodeMode)
{
//*STRSAFE* lstrcpyW((WCHAR *)ViewCode, (WCHAR *)CodeArray);
hresult = StringCbCopyW((WCHAR *)ViewCode, sizeof(ViewCode), (WCHAR *)CodeArray);
if (!SUCCEEDED(hresult))
{
return ;
}
}
else
{
//*STRSAFE* lstrcpyA((CHAR *)ViewCode, (CHAR *)CodeArray);
hresult = StringCbCopyA((CHAR *)ViewCode, sizeof(ViewCode), (CHAR *)CodeArray);
if (!SUCCEEDED(hresult))
{
return ;
}
}
GetParent()->SendMessage( WM_VIEWUPDATE, 0, 0);
}else{
PtIn = FALSE;
dc.SetBkColor( COLOR_FACE);
dc.SetTextColor( GetSysColor(COLOR_WINDOWTEXT)); //COLOR_BLACK);
}
if (CountryInfo.bUnicodeMode)
GetTextExtentPoint32W( dc.GetSafeHdc(), (LPCWSTR)CodeArray, wLength, &cSize);
else
GetTextExtentPoint32A( dc.GetSafeHdc(), (LPCSTR)CodeArray, wLength, &cSize);
if( rcEditChar[i][j].Width() > cSize.cx){
xOffset = rcEditChar[i][j].Width() - cSize.cx;
xOffset /= 2;
}else xOffset = 0;
if( rcEditChar[i][j].Height() > cSize.cy){
yOffset = rcEditChar[i][j].Height() - cSize.cy;
yOffset /= 2;
}else yOffset = 0;
if(bHasGlyph == TRUE)
{
if (CountryInfo.bUnicodeMode)
{
#ifdef UNICODE
ExtTextOutW(dc.GetSafeHdc(),rcEditChar[i][j].left + xOffset,
rcEditChar[i][j].top + yOffset, ETO_OPAQUE,
&rcEditChar[i][j], (LPCWSTR)CodeArray, wLength, NULL);
#else
CHAR ViewTmp[2];
wLength = WideCharToMultiByte(CP_ACP, 0, (LPWSTR) CodeArray, 1, ViewTmp, 2, NULL, NULL);
ExtTextOutA(dc.GetSafeHdc(),rcEditChar[i][j].left + xOffset,
rcEditChar[i][j].top + yOffset, ETO_OPAQUE,
&rcEditChar[i][j], (LPCSTR)ViewTmp, wLength, NULL);
#endif
}
else
{
ExtTextOutA(dc.GetSafeHdc(), rcEditChar[i][j].left + xOffset,
rcEditChar[i][j].top + yOffset, ETO_OPAQUE,
&rcEditChar[i][j], (LPCSTR)CodeArray,
wLength, NULL);
}
}
DrawConcave( &dc, rcEditChar[i][j], PtIn);
}
}
dc.SetMapMode( OldMapMode);
dc.SelectObject( OldFont);
LButtonPt.x = LButtonPt.y = 0;
}
/****************************************/
/* */
/* MESSAGE "WM_VSCROLL" */
/* */
/****************************************/
void
CEudcList::OnVScroll(
UINT nSBCode,
UINT nPos,
CScrollBar* pScrollBar)
{
int MoveScr;
BOOL ThumbTrkFlag;
BOOL ThumbPosFlag;
MoveScr = 0;
ThumbTrkFlag = FALSE;
ThumbPosFlag = FALSE;
BarRange = GetBarPosition((WORD)EUDC_EView);
SetScrollRange( SB_VERT, 0, BarRange, FALSE);
switch( nSBCode)
{
case SB_LINEDOWN:
if(( EUDC_SView + NUM_CHAR) <= EUDC_EView){
MoveScr = 0 - (CharSize.cy + LINEWIDTH);
EUDC_SView += NUM_CHAR;
EUDC_SView = CorrectEUDCCode(EUDC_SView,TRUE);
ScrlBarPos = (short)GetBarPosition( EUDC_SView);
}
break;
case SB_LINEUP:
if(( EUDC_SView - NUM_CHAR) >= ( EUDC_SCode & 0xfff0)){
MoveScr = CharSize.cy + LINEWIDTH;
EUDC_SView -= NUM_CHAR;
EUDC_SView = CorrectEUDCCode(EUDC_SView,FALSE);
ScrlBarPos = (short)GetBarPosition( EUDC_SView);
}
break;
case SB_PAGEDOWN:
if(( EUDC_SView + NUM_CHAR*NUM_LINE) <= EUDC_EView){
MoveScr = ( 0-(CharSize.cy+LINEWIDTH))*NUM_LINE;
ScrlBarPos = (short)GetBarPosition( EUDC_SView);
ScrlBarPos += NUM_LINE;
EUDC_SView = GetCodeScrPos( ScrlBarPos);
}else{
MoveScr = ( 0-(CharSize.cy+LINEWIDTH))*NUM_LINE;
EUDC_SView = EUDC_EView;
ScrlBarPos = (short)GetBarPosition( EUDC_SView);
}
break;
case SB_PAGEUP:
if(( EUDC_SView - NUM_CHAR*NUM_LINE)
>= ( EUDC_SCode & 0xfff0)){
MoveScr = (CharSize.cy + LINEWIDTH)*NUM_LINE;
ScrlBarPos = (short)GetBarPosition( EUDC_SView);
ScrlBarPos -= NUM_LINE;
EUDC_SView = GetCodeScrPos( ScrlBarPos);
}else{
MoveScr = (CharSize.cy + LINEWIDTH)*NUM_LINE;
EUDC_SView = (EUDC_SCode & 0xfff0);
ScrlBarPos = (short)GetBarPosition( EUDC_SView);
}
break;
case SB_TOP:
EUDC_SView = ( EUDC_SCode & 0xfff0);
ScrlBarPos = 0;
break;
case SB_BOTTOM:
EUDC_SView = EUDC_EView;
ScrlBarPos = (short)BarRange;
break;
case SB_THUMBPOSITION:
ThumbPosFlag = TRUE;
ScrlBarPos = (short)nPos;
EUDC_SView = GetCodeScrPos( nPos);
break;
case SB_THUMBTRACK:
ThumbTrkFlag = TRUE;
break;
default:
break;
}
if( abs( MoveScr) < (CharSize.cy + LINEWIDTH)*NUM_LINE &&
abs( MoveScr) > 0 && !ThumbTrkFlag){
CRect ScrllRect;
CRect ClintRect;
GetClientRect( &ClintRect);
ScrllRect.CopyRect( &ClintRect);
if( MoveScr < 0){
ClintRect.top = 0 - MoveScr;
this->ScrollWindow( 0, MoveScr, &ClintRect, NULL);
ScrllRect.top = ( 0 - MoveScr)*(NUM_LINE-1);
}else{
ClintRect.top = LINEWIDTH;
ClintRect.bottom = MoveScr*(NUM_LINE - 1);
this->ScrollWindow( 0, MoveScr, &ClintRect, NULL);
ScrllRect.top = 0;
ScrllRect.bottom = ScrllRect.top + MoveScr;
}
this->InvalidateRect( &ScrllRect, FALSE);
}else if(!ThumbTrkFlag && ( MoveScr || ThumbPosFlag)){
this->Invalidate( TRUE);
}
this->SetScrollPos( SB_VERT, ScrlBarPos, TRUE);
}
/****************************************/
/* */
/* MESSAGE "WM_LBUTTONDOWN" */
/* */
/****************************************/
void
CEudcList::OnLButtonDown(
UINT nFlags,
CPoint point)
{
CRect test;
BOOL PtIn;
unsigned int i, j;
PtIn = FALSE;
this->SetFocus();
for( i = 0; i < NUM_LINE; i++){
for( j = 0; j < NUM_CHAR; j++){
if( rcEditChar[i][j].PtInRect( point)){
if( IsCorrectChar( i, j))
PtIn = TRUE;
break;
}
}
}
if( !PtIn){
MessageBeep((UINT)-1);
return;
}
LButtonPt = point;
SearchSelectPosition();
SelectCode = 0;
for( i = 0; i < NUM_LINE; i++){
for( j = 0; j < NUM_CHAR; j++){
if( rcEditChar[i][j].PtInRect( LButtonPt)){
test.SetRect( rcEditChar[i][j].left - 2,
rcEditChar[i][j].top - 2,
rcEditChar[i][j].right + 2,
rcEditChar[i][j].bottom + 2);
this->InvalidateRect( &test, FALSE);
break;
}
}
}
this->UpdateWindow();
}
/****************************************/
/* */
/* MESSAGE "WM_LBUTTONDBLCLK" */
/* */
/****************************************/
void
CEudcList::OnLButtonDblClk(
UINT nFlags,
CPoint point)
{
BOOL PtIn;
unsigned int i, j;
LButtonPt = point;
this->Invalidate( FALSE);
this->UpdateWindow();
PtIn = FALSE;
this->SetFocus();
for( i = 0; i < NUM_LINE; i++){
for( j = 0; j < NUM_CHAR; j++){
if( rcEditChar[i][j].PtInRect( point)){
if( IsCorrectChar( i, j))
PtIn = TRUE;
break;
}
}
}
if( !PtIn){
MessageBeep((UINT)-1);
return;
}else{
GetParent()->PostMessage( WM_COMMAND, IDOK, 0L);
}
}
/****************************************/
/* */
/* MESSAGE "WM_SETCURSOR" */
/* */
/****************************************/
BOOL
CEudcList::OnSetCursor(
CWnd* pWnd,
UINT nHitTest,
UINT message)
{
::SetCursor( AfxGetApp()->LoadStandardCursor(IDC_ARROW));
return TRUE;
}
/****************************************/
/* */
/* Draw ConcaveRectangle */
/* */
/****************************************/
void
CEudcList::DrawConcave(
CDC *dc,
CRect rect,
BOOL PtIn)
{
CBrush ConBrush, *OldBrush;
CRect Rt, Rf;
if (!dc)
{
return;
}
Rt.SetRect( rect.left-1, rect.top-1, rect.right+1, rect.bottom+1);
Rf.CopyRect( &rect);
if( !PtIn){
ConBrush.CreateSolidBrush( COLOR_HLIGHT);
OldBrush = dc->SelectObject( &ConBrush);
dc->PatBlt( Rt.left, Rt.top, Rt.Width(), 1, PATCOPY);
dc->PatBlt( Rt.left, Rt.top, 1, Rt.Height(), PATCOPY);
dc->SelectObject( OldBrush);
ConBrush.DeleteObject();
ConBrush.CreateSolidBrush( COLOR_SHADOW);
OldBrush = dc->SelectObject( &ConBrush);
dc->PatBlt( Rt.left, Rt.bottom, Rt.Width(), 1, PATCOPY);
dc->PatBlt( Rt.right, Rt.top, 1, Rt.Height()+1, PATCOPY);
dc->SelectObject( OldBrush);
ConBrush.DeleteObject();
if( FocusFlag){
CBrush fBrush;
CPen fPen, *OldPen;
fBrush.CreateStockObject( NULL_BRUSH);
fPen.CreatePen( PS_SOLID, 1, COLOR_FACE);
OldBrush = dc->SelectObject( &fBrush);
OldPen = dc->SelectObject( &fPen);
dc->Rectangle( &Rf);
dc->SelectObject( OldBrush);
dc->SelectObject( OldPen);
fBrush.DeleteObject();
fPen.DeleteObject();
}
}else{
ConBrush.CreateSolidBrush( COLOR_SHADOW);
OldBrush = dc->SelectObject( &ConBrush);
dc->PatBlt( Rt.left, Rt.top, Rt.Width(), 1, PATCOPY);
dc->PatBlt( Rt.left, Rt.top, 1, Rt.Height(), PATCOPY);
dc->SelectObject( OldBrush);
ConBrush.DeleteObject();
ConBrush.CreateSolidBrush( COLOR_HLIGHT);
OldBrush = dc->SelectObject( &ConBrush);
dc->PatBlt( Rt.left, Rt.bottom, Rt.Width(), 1, PATCOPY);
dc->PatBlt( Rt.right, Rt.top, 1, Rt.Height()+1, PATCOPY);
dc->SelectObject( OldBrush);
ConBrush.DeleteObject();
if( FocusFlag){
CBrush fBrush;
CPen fPen, *OldPen;
fBrush.CreateStockObject( NULL_BRUSH);
fPen.CreatePen( PS_SOLID, 1, COLOR_SHADOW);
OldBrush = dc->SelectObject( &fBrush);
OldPen = dc->SelectObject( &fPen);
dc->Rectangle( &Rf);
dc->SelectObject( OldBrush);
dc->SelectObject( OldPen);
fBrush.DeleteObject();
fPen.DeleteObject();
}
}
}
/****************************************/
/* */
/* MESSAGE "WM_KEYDOWN" */
/* */
/****************************************/
void
CEudcList::OnKeyDown(
UINT nChar,
UINT nRepCnt,
UINT nFlags)
{
int sPos;
int ePos;
#ifdef BUILD_ON_WINNT
int i;
WORD TmpCode;
#endif // BUILD_ON_WINNT
if( nChar == VK_DOWN || nChar == VK_UP ||
nChar == VK_RIGHT || nChar == VK_LEFT){
sPos = GetBarPosition( EUDC_SView);
ePos = GetBarPosition( SelectCode);
if( ePos - sPos >= NUM_LINE || ePos < sPos){
EUDC_SView = SelectCode & 0xfff0;
ScrlBarPos = (short)GetBarPosition( EUDC_SView);
this->Invalidate(FALSE);
this->UpdateWindow();
}
switch( nChar){
case VK_DOWN:
if( SelectCode + NUM_CHAR > EUDC_ECode)
break;
#ifdef BUILD_ON_WINNT
TmpCode = SelectCode + NUM_CHAR;
TmpCode = CorrectEUDCCodeKey( TmpCode, NUM_CHAR, TRUE);
sPos = GetBarPosition( EUDC_SView);
ePos = GetBarPosition( TmpCode);
for (i=0;i <= ePos - sPos - NUM_LINE; i++){
#else
if( ePos - sPos >= NUM_LINE - 1){
#endif // BUILD_ON_WINNT
this->SendMessage( WM_VSCROLL, SB_LINEDOWN, 0);
}
SearchSelectPosition();
SelectCode += NUM_CHAR;
SelectCode = CorrectEUDCCodeKey( SelectCode,
NUM_CHAR, TRUE);
SearchSelectPosition();
this->UpdateWindow();
break;
case VK_UP:
if( SelectCode - NUM_CHAR < EUDC_SCode)
break;
#ifdef BUILD_ON_WINNT
TmpCode = SelectCode - NUM_CHAR;
TmpCode = CorrectEUDCCodeKey( TmpCode, NUM_CHAR, FALSE);
sPos = GetBarPosition( EUDC_SView);
ePos = GetBarPosition( TmpCode);
for ( i=0; i < sPos - ePos; i++){
#else
if( SelectCode - NUM_CHAR < EUDC_SView){
#endif // BUILD_ON_WINNT
this->SendMessage( WM_VSCROLL, SB_LINEUP, 0);
}
SearchSelectPosition();
SelectCode -= NUM_CHAR;
SelectCode = CorrectEUDCCodeKey( SelectCode,
NUM_CHAR, FALSE);
SearchSelectPosition();
this->UpdateWindow();
break;
case VK_LEFT:
if( SelectCode - 1 < EUDC_SCode)
break;
#ifdef BUILD_ON_WINNT
TmpCode = SelectCode - 1;
TmpCode = CorrectEUDCCodeKey( TmpCode, 1, FALSE);
sPos = GetBarPosition( EUDC_SView);
ePos = GetBarPosition( TmpCode);
if( ePos < sPos){
#else
if( SelectCode - 1 < EUDC_SView){
#endif // BUILD_ON_WINNT
this->SendMessage( WM_VSCROLL, SB_LINEUP, 0);
}
SearchSelectPosition();
SelectCode--;
SelectCode = CorrectEUDCCodeKey( SelectCode, 1, FALSE);
SearchSelectPosition();
this->UpdateWindow();
break;
case VK_RIGHT:
#ifdef BUILD_ON_WINNT
// Move to above...
#else
WORD TmpCode;
#endif // BUILD_ON_WINNT
if( SelectCode + 1 > EUDC_ECode)
break;
TmpCode = SelectCode + 1;
TmpCode = CorrectEUDCCodeKey( TmpCode, 1, TRUE);
sPos = GetBarPosition( EUDC_SView);
ePos = GetBarPosition( TmpCode);
if( ePos - sPos >= NUM_LINE){
this->SendMessage( WM_VSCROLL, SB_LINEDOWN, 0);
}
SearchSelectPosition();
SelectCode++;
SelectCode = CorrectEUDCCodeKey( SelectCode, 1, TRUE);
SearchSelectPosition();
this->UpdateWindow();
break;
}
}else CEdit::OnKeyDown(nChar, nRepCnt, nFlags);
}
/****************************************/
/* */
/* MESSAGE "WM_SETFOCUS" */
/* */
/****************************************/
void
CEudcList::OnSetFocus(
CWnd* pOldWnd)
{
CEdit::OnSetFocus(pOldWnd);
FocusFlag = TRUE;
SearchSelectPosition();
this->UpdateWindow();
::HideCaret( NULL);
// DestroyCaret();
}
/****************************************/
/* */
/* Search select posistion */
/* */
/****************************************/
void
CEudcList::SearchSelectPosition()
{
CRect test;
int sViewPt, sCodePt;
unsigned int i, j;
sViewPt = GetBarPosition( EUDC_SView);
sCodePt = GetBarPosition( SelectCode);
#ifdef BUILD_ON_WINNT
// the new view does not contain previsouly selected char,
// we don't need to redraw the concave.
if (sCodePt < sViewPt || sCodePt > sViewPt+NUM_LINE)
return;
#endif
i = (unsigned int)(sCodePt - sViewPt);
j = (unsigned int)(SelectCode & 0x000f);
test.SetRect( rcEditChar[i][j].left - 2,
rcEditChar[i][j].top - 2,
rcEditChar[i][j].right + 2,
rcEditChar[i][j].bottom + 2);
this->InvalidateRect( &test, FALSE);
}
/****************************************/
/* */
/* Correct it if code is illegal */
/* */
/****************************************/
#ifdef BUILD_ON_WINNT
WORD
CEudcList::CorrectEUDCCodeKey(
WORD Code,
int MovePt,
BOOL UporDown)
{
COUNTRYINFO Info;
WORD wCode;
BYTE LByte, HByte, Tmp0;
int TralPos = 0;
LByte = LOBYTE( Code);
HByte = HIBYTE( Code);
Info = CountryInfo;
for( int i = 0; i < Info.nTralByte; i++){
if( LByte >= Info.sTralByte[i] && LByte <= Info.eTralByte[i]){
goto RET;
}else if( LByte < Info.sTralByte[i]){
/* decide which range of starting trailbyte we are less than */
TralPos = i;
break;
}else TralPos = i+1;
}
if( UporDown){ //code increasing
if( TralPos == Info.nTralByte){ //greater than last eTrailByte
HByte += 0x1; //same as less than next sTraiByte
TralPos=0;
}
if( MovePt < NUM_CHAR){ //
LByte = Info.sTralByte[TralPos];
}else{
Tmp0 = LByte & 0x0f;
LByte = Info.sTralByte[TralPos] & 0xf0;
LByte |= Tmp0;
if (LByte < Info.sTralByte[TralPos])
LByte += NUM_CHAR;
}
}else{
if( TralPos == 0){ //greater than last eTrailByte
TralPos = Info.nTralByte;
HByte -= 0x1;
}
if( MovePt < NUM_CHAR){
LByte = Info.eTralByte[TralPos-1];
}else{
Tmp0 = LByte & 0x0f;
LByte = Info.eTralByte[TralPos-1] & 0xf0;
LByte |= Tmp0;
if (LByte > Info.eTralByte[TralPos-1])
LByte -= NUM_CHAR;
}
}
RET:
wCode = MAKEWORD( LByte, HByte);
return wCode;
}
#else
WORD
CEudcList::CorrectEUDCCodeKey(
WORD Code,
int MovePt,
BOOL UporDown)
{
COUNTRYINFO Info;
WORD wCode;
BYTE LByte, HByte;
int TralPos = 0;
LByte = LOBYTE( Code);
HByte = HIBYTE( Code);
Info = CountryInfo;
for( int i = 0; i < Info.nTralByte; i++){
if( LByte >= Info.sTralByte[i] && LByte <= Info.eTralByte[i]){
goto RET;
}else if( LByte < Info.sTralByte[i]){
TralPos = i;
break;
}else TralPos = i+1;
}
if( UporDown)
if( TralPos == Info.nTralByte){
if( MovePt < NUM_CHAR){
LByte = Info.sTralByte[0];
HByte += 0x1;
}else{
LByte = Info.eTralByte[Info.nTralByte - 1];
}
}else if( MovePt < NUM_CHAR){
LByte = Info.sTralByte[TralPos];
}else{
if( TralPos){
BYTE Tmp1;
BYTE Tmp2;
Tmp1 = Info.eTralByte[TralPos-1] & 0xf0;
Tmp2 = LByte & 0xf0;
if( Tmp1 == Tmp2){
LByte = Info.eTralByte[TralPos-1];
}else{
Tmp1 = LByte & 0x0f;
LByte = Info.sTralByte[TralPos] & 0xf0;
LByte |= Tmp1;
}
}else{
LByte += (Info.sTralByte[0] & 0xf0);
}
}
else{
if( !TralPos){
if( MovePt < NUM_CHAR){
LByte = Info.eTralByte[Info.nTralByte - 1];
HByte -= 0x1;
}else{
BYTE Tmp;
Tmp = LByte & 0x0f;
LByte = Info.eTralByte[Info.nTralByte - 1]&0xf0;
LByte |= Tmp;
HByte -= 0x1;
if( LByte > Info.eTralByte[Info.nTralByte-1]){
LByte = Info.eTralByte[Info.nTralByte-1];
}
}
}else{
BYTE Tmp;
Tmp = LByte & 0x0f;
LByte = Info.eTralByte[TralPos-1] & 0xf0;
LByte |= Tmp;
if( LByte > Info.eTralByte[TralPos-1])
LByte = Info.eTralByte[TralPos-1];
}
}
RET:
wCode = MAKEWORD( LByte, HByte);
return wCode;
}
#endif // BUILD_ON_WINNT
/****************************************/
/* */
/* Whether correct or not? */
/* */
/****************************************/
BOOL
CEudcList::IsCorrectChar(
UINT i,
UINT j)
{
int sViewPt;
WORD wCode;
BYTE sOffset;
BOOL flg;
flg = FALSE;
BarRange = GetBarPosition((WORD)EUDC_EView);
sViewPt = GetBarPosition( EUDC_SView);
wCode = GetCodeScrPos( sViewPt + i);
wCode |= j;
sOffset = LOBYTE( wCode);
for( int k = 0; k < CountryInfo.nTralByte; k++){
if( sOffset >= CountryInfo.sTralByte[k] &&
sOffset <= CountryInfo.eTralByte[k]){
flg = TRUE;
}
}
return flg;
}
/****************************************/
/* */
/* MESSAGE "WM_KILLFOCUS" */
/* */
/****************************************/
void
CEudcList::OnKillFocus(
CWnd* pNewWnd)
{
FocusFlag = FALSE;
SearchSelectPosition();
this->UpdateWindow();
CEdit::OnKillFocus( pNewWnd);
::HideCaret( NULL);
}
/****************************************/
/* */
/* MESSAGE "WM_RBUTTONUP" */
/* */
/****************************************/
void
CEudcList::OnRButtonUp(
UINT nFlags,
CPoint point)
{
GetParent()->SendMessage( WM_CONTEXTMENU, (WPARAM)this->GetSafeHwnd(), 0);
}
BEGIN_MESSAGE_MAP( CViewEdit, CEdit)
//{{AFX_MSG_MAP( CViewEdit)
ON_WM_PAINT()
ON_WM_SETCURSOR()
ON_WM_SETFOCUS()
ON_WM_KILLFOCUS()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONDBLCLK()
ON_WM_RBUTTONUP()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/****************************************/
/* */
/* Default Constructor */
/* */
/****************************************/
CViewEdit::CViewEdit()
{
}
/****************************************/
/* */
/* Destructor */
/* */
/****************************************/
CViewEdit::~CViewEdit()
{
//fix for 261529
EUDCFont.DeleteObject();
}
/****************************************/
/* */
/* MESSAGE "WM_PAINT" */
/* */
/****************************************/
void
CViewEdit::OnPaint()
{
LOGFONT LogFont;
CFont ViewFont, *OldFont;
CSize cSize;
CRect ViewRect;
int xOffset, yOffset;
CPaintDC dc( this);
GetClientRect( &ViewRect);
DrawConcave( &dc, ViewRect);
if(bHasGlyph == FALSE) return;
memset( &LogFont, 0, sizeof( LogFont));
//fix for 261529
EUDCFont.GetLogFont(&LogFont);
if( ViewRect.Width() >= ViewRect.Height())
LogFont.lfHeight = ViewRect.Height() - 10;
else LogFont.lfHeight = ViewRect.Width() - 10;
if( !ViewFont.CreateFontIndirect( &LogFont))
return;
OldFont = dc.SelectObject( &ViewFont);
#ifdef BUILD_ON_WINNT
if (CountryInfo.bUnicodeMode)
GetTextExtentPoint32W(dc.GetSafeHdc(), (LPCWSTR)ViewCode, 1, &cSize);
else
#endif //BUILD_ON_WINNT
GetTextExtentPoint32A(dc.GetSafeHdc(), (LPCSTR)ViewCode, 2, &cSize);
if( ViewRect.Width() > cSize.cx){
xOffset = ViewRect.Width() - cSize.cx;
xOffset /= 2;
}else xOffset = 0;
if( ViewRect.Height() > cSize.cy){
yOffset = ViewRect.Height() - cSize.cy;
yOffset /= 2;
}else yOffset = 0;
dc.SetBkColor( COLOR_FACE);
dc.SetTextColor(GetSysColor(COLOR_WINDOWTEXT)); // COLOR_BLACK);
if (CountryInfo.bUnicodeMode)
{
#ifdef UNICODE
ExtTextOutW(dc.GetSafeHdc(), xOffset, yOffset, ETO_OPAQUE,
&ViewRect, (LPCWSTR)ViewCode, 1, NULL);
#else
CHAR ViewTmp[2];
WideCharToMultiByte(CP_ACP, 0, (LPWSTR) ViewCode, 1, ViewTmp, 2, NULL, NULL);
ExtTextOutA(dc.GetSafeHdc(), xOffset, yOffset, ETO_OPAQUE,
&ViewRect, (LPCSTR)ViewTmp, 2, NULL);
#endif
}
else
{
ExtTextOutA(dc.GetSafeHdc(), xOffset, yOffset, ETO_OPAQUE,
&ViewRect, (LPCSTR)ViewCode, 2, NULL);
}
dc.SelectObject( OldFont);
ViewFont.DeleteObject();
}
/****************************************/
/* */
/* Draw Concave Rect */
/* */
/****************************************/
void
CViewEdit::DrawConcave(
CDC *dc,
CRect rect)
{
CBrush ConBrush, *OldBrush;
CRect Rt;
if (!dc)
{
return;
}
Rt.SetRect( rect.left-1, rect.top-1, rect.right, rect.bottom);
ConBrush.CreateSolidBrush(COLOR_FACE);
OldBrush = dc->SelectObject( &ConBrush);
dc->PatBlt( Rt.left, Rt.top, Rt.right, Rt.bottom, PATCOPY);
dc->SelectObject( OldBrush);
ConBrush.DeleteObject();
ConBrush.CreateSolidBrush( COLOR_HLIGHT);
OldBrush = dc->SelectObject( &ConBrush);
dc->PatBlt( Rt.left, Rt.top, Rt.Width(), 1, PATCOPY);
dc->PatBlt( Rt.left, Rt.top, 1, Rt.Height(), PATCOPY);
dc->SelectObject( OldBrush);
ConBrush.DeleteObject();
ConBrush.CreateSolidBrush( COLOR_SHADOW);
OldBrush = dc->SelectObject( &ConBrush);
dc->PatBlt( Rt.left, Rt.bottom, Rt.Width(), 1, PATCOPY);
dc->PatBlt( Rt.right, Rt.top, 1, Rt.Height()+1, PATCOPY);
dc->SelectObject( OldBrush);
ConBrush.DeleteObject();
}
BEGIN_MESSAGE_MAP( CCustomListFrame, CStatic)
//{{AFX_MSG_MAP( CCustomListFrame)
ON_WM_PAINT()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/****************************************/
/* */
/* Default Constructor */
/* */
/****************************************/
CCustomListFrame::CCustomListFrame()
{
}
/****************************************/
/* */
/* Destructor */
/* */
/****************************************/
CCustomListFrame::~CCustomListFrame()
{
}
/****************************************/
/* */
/* MESSAGE "WM_PAINT" */
/* */
/****************************************/
void
CCustomListFrame::OnPaint()
{
CRect FrameRect;
CPaintDC dc( this);
this->GetClientRect( &FrameRect);
this->DrawConcave( &dc, FrameRect);
}
/****************************************/
/* */
/* Draw Concave Rect */
/* */
/****************************************/
void
CCustomListFrame::DrawConcave(
CDC *dc,
CRect rect)
{
CBrush ConBrush, *OldBrush;
CRect Rt;
if (!dc)
{
return;
}
Rt.SetRect( rect.left-1, rect.top-1, rect.right, rect.bottom);
ConBrush.CreateSolidBrush( COLOR_HLIGHT);
OldBrush = dc->SelectObject( &ConBrush);
dc->PatBlt( Rt.left, Rt.top, Rt.Width(), 1, PATCOPY);
dc->PatBlt( Rt.left, Rt.top, 1, Rt.Height(), PATCOPY);
dc->SelectObject( OldBrush);
ConBrush.DeleteObject();
ConBrush.CreateSolidBrush( COLOR_SHADOW);
OldBrush = dc->SelectObject( &ConBrush);
dc->PatBlt( Rt.left, Rt.bottom, Rt.Width(), 1, PATCOPY);
dc->PatBlt( Rt.right, Rt.top, 1, Rt.Height()+1, PATCOPY);
dc->SelectObject( OldBrush);
ConBrush.DeleteObject();
}
BEGIN_MESSAGE_MAP( CCustomInfoFrame, CStatic)
//{{AFX_MSG_MAP( CCustomInfoFrame)
ON_WM_PAINT()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/****************************************/
/* */
/* Default Constructor */
/* */
/****************************************/
CCustomInfoFrame::CCustomInfoFrame()
{
}
/****************************************/
/* */
/* Destructor */
/* */
/****************************************/
CCustomInfoFrame::~CCustomInfoFrame()
{
}
/****************************************/
/* */
/* MESSAGE "WM_PAINT" */
/* */
/****************************************/
void
CCustomInfoFrame::OnPaint()
{
CRect FrameRect;
CPaintDC dc( this);
this->GetClientRect( &FrameRect);
this->DrawConcave( &dc, FrameRect);
}
/****************************************/
/* */
/* Draw Concave Rect */
/* */
/****************************************/
void
CCustomInfoFrame::DrawConcave(
CDC *dc,
CRect rect)
{
CBrush ConBrush, *OldBrush;
CRect Rt;
if (!dc)
{
return;
}
Rt.SetRect( rect.left-1, rect.top-1, rect.right, rect.bottom);
ConBrush.CreateSolidBrush( COLOR_SHADOW);
OldBrush = dc->SelectObject( &ConBrush);
dc->PatBlt( Rt.left, Rt.top, Rt.Width(), 1, PATCOPY);
dc->PatBlt( Rt.left, Rt.top, 1, Rt.Height(), PATCOPY);
dc->SelectObject( OldBrush);
ConBrush.DeleteObject();
ConBrush.CreateSolidBrush( COLOR_HLIGHT);
OldBrush = dc->SelectObject( &ConBrush);
dc->PatBlt( Rt.left, Rt.bottom, Rt.Width(), 1, PATCOPY);
dc->PatBlt( Rt.right, Rt.top, 1, Rt.Height()+1, PATCOPY);
dc->SelectObject( OldBrush);
ConBrush.DeleteObject();
}
BOOL CViewEdit::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
{
::SetCursor( AfxGetApp()->LoadStandardCursor(IDC_ARROW));
return TRUE;
}
void CViewEdit::OnSetFocus(CWnd* pOldWnd)
{
CEdit::OnSetFocus(pOldWnd);
::HideCaret( NULL);
}
void CViewEdit::OnKillFocus(CWnd* pNewWnd)
{
CEdit::OnKillFocus(pNewWnd);
::HideCaret( NULL);
}
void CViewEdit::OnLButtonDown(UINT nFlags, CPoint point)
{
}
void CViewEdit::OnLButtonDblClk(UINT nFlags, CPoint point)
{
}
void CViewEdit::OnRButtonUp(UINT nFlags, CPoint point)
{
GetParent()->SendMessage( WM_CONTEXTMENU, (WPARAM)this->GetSafeHwnd(), 0);
}
#ifdef BUILD_ON_WINNT
BEGIN_MESSAGE_MAP( CColumnHeading, CWnd)
//{{AFX_MSG_MAP( CColumnHeading)
ON_WM_PAINT()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/****************************************/
/* */
/* Default Constructor */
/* */
/****************************************/
CColumnHeading::CColumnHeading()
{
}
/****************************************/
/* */
/* Destructor */
/* */
/****************************************/
CColumnHeading::~CColumnHeading()
{
SysFFont.DeleteObject();
}
/****************************************/
/* */
/* MESSAGE "WM_PAINT" */
/* */
/****************************************/
void
CColumnHeading::OnPaint()
{
// column heading support
CPaintDC dc( this);
TCHAR ColumnHead[2];
CSize cSize;
int j,xOffset;
HRESULT hresult;
dc.SetMapMode( MM_TEXT);
dc.SelectObject( &SysFFont);
dc.SetBkColor( COLOR_FACE);
dc.SetTextColor(GetSysColor(COLOR_WINDOWTEXT)); // COLOR_BLACK);
for( j = 0; j < NUM_CHAR; j++){
//*STRSAFE* wsprintf(ColumnHead, TEXT("%X"), j);
hresult = StringCchPrintf(ColumnHead , ARRAYLEN(ColumnHead), TEXT("%X"), j);
if (!SUCCEEDED(hresult))
{
return ;
}
GetTextExtentPoint32(dc.GetSafeHdc(),
ColumnHead, 1, &cSize);
if( rcColumnHead[j].Width() > cSize.cx){
xOffset = rcColumnHead[j].Width() - cSize.cx;
xOffset /= 2;
}else
xOffset= 0;
dc.ExtTextOut( rcColumnHead[j].left + xOffset,
rcColumnHead[j].top,
ETO_OPAQUE, &rcColumnHead[j],
ColumnHead, 1, NULL);
}
}
#endif //BUILD_ON_WINNT