//重画消息
void CButtonBar::OnPaint()
{
CPaintDC dc(this);
//获取位置
CRect rcRect;
GetClientRect(&rcRect);
//加载资源
CImageHandle ImageHotHandle(&m_ImageHot);
CImageHandle ImageActiveHandle(&m_ImageActive);
CImageHandle ImageNormalHandle(&m_ImageNormal);
CImageHandle m_ImageBackGroundHandle(&m_ImageBackGround);
//建立缓冲
CDC BufferDC;
CBitmap BufferBmp;
BufferDC.CreateCompatibleDC(&dc);
BufferBmp.CreateCompatibleBitmap(&dc,rcRect.Width(),rcRect.Height());
BufferDC.SelectObject(&BufferBmp);
//绘画背景
CBrush BackBrush(TITLE_GROUND_COLOR);
CPen BorderPen(PS_SOLID,1,CSkinWndObject::m_SkinAttribute.m_crInsideBorder);
CPen * pOldPen=BufferDC.SelectObject(&BorderPen);
CBrush * pOldBrush=BufferDC.SelectObject(&BackBrush);
BufferDC.FillSolidRect(&rcRect,CSkinWndObject::m_SkinAttribute.m_crBackGround);
BufferDC.RoundRect(&rcRect,CPoint(10,10));
m_ImageBackGround.BitBlt(BufferDC,1,rcRect.Height()-m_ImageBackGround.GetHeight()-3);
BufferDC.SelectObject(pOldPen);
BufferDC.SelectObject(pOldBrush);
BackBrush.DeleteObject();
BorderPen.DeleteObject();
//绘画按钮
BufferDC.SetBkMode(TRANSPARENT);
BufferDC.SelectObject(&CSkinAttribute::m_DefaultFont);
//绘画按钮
CRect rcButton;
CSkinImage * pSkinImage=NULL;
for (INT_PTR i=0; i<m_OptionsItemPtr.GetCount(); i++)
{
LPCTSTR pszButtonText=m_OptionsItemPtr[i]->GetButtonText();
rcButton.SetRect(1,(int)(ITEM_HEIGHT*i+10+2*i),rcRect.Width(),(int)(ITEM_HEIGHT*(i+1)+10+2*i));
if (i==m_nActiveItem)
{
pSkinImage=&m_ImageActive;
BufferDC.SetTextColor(RGB(0,0,0));
}
else if (i==m_nHotItem)
{
pSkinImage=&m_ImageHot;
BufferDC.SetTextColor(RGB(0,0,0));
}
else
{
pSkinImage=&m_ImageNormal;
BufferDC.SetTextColor(RGB(0,0,0));
}
pSkinImage->BitBlt(BufferDC,rcButton.left,rcButton.top,ITEM_WIDTH,ITEM_HEIGHT,0,0,SRCCOPY);
BufferDC.DrawText(pszButtonText,lstrlen(pszButtonText),rcButton,DT_END_ELLIPSIS|DT_VCENTER|DT_CENTER|DT_SINGLELINE);
}
//绘画界面
dc.BitBlt(0,0,rcRect.Width(),rcRect.Height(),&BufferDC,0,0,SRCCOPY);
//清理资源
BufferDC.DeleteDC();
BufferBmp.DeleteObject();
return;
}
//重画函数
void CControlWnd::OnPaint()
{
CPaintDC dc(this);
//获取位置
CRect rcClient;
GetClientRect(&rcClient);
//创建缓冲
CDC BufferDC;
CBitmap BufferImage;
BufferDC.CreateCompatibleDC(&dc);
BufferImage.CreateCompatibleBitmap(&dc,rcClient.Width(),rcClient.Height());
BufferDC.SelectObject(&BufferImage);
//加载资源
CImageHandle HandleControlTop(&m_ImageControlTop);
CImageHandle HandleControlMid(&m_ImageControlMid);
CImageHandle HandleControlButtom(&m_ImageControlButtom);
CImageHandle HandleActionExplain(&m_ImageActionExplain);
//绘画背景
m_ImageControlTop.BitBlt(BufferDC,0,0);
for (int nImageYPos=m_ImageControlTop.GetHeight();nImageYPos<rcClient.Height();nImageYPos+=m_ImageControlMid.GetHeight())
{
m_ImageControlMid.BitBlt(BufferDC,0,nImageYPos);
}
m_ImageControlButtom.BitBlt(BufferDC,0,rcClient.Height()-m_ImageControlButtom.GetHeight());
//变量定义
int nYPos=5;
BYTE cbCurrentItem=0;
BYTE cbExcursion[3]={0,1,2};
BYTE cbItemKind[4]={WIK_LEFT,WIK_CENTER,WIK_RIGHT,WIK_PENG};
//绘画扑克
for (BYTE i=0;i<CountArray(cbItemKind);i++)
{
if ((m_cbActionMask&cbItemKind[i])!=0)
{
//绘画扑克
for (BYTE j=0;j<3;j++)
{
BYTE cbCardData=m_cbCenterCard;
if (i<CountArray(cbExcursion))
cbCardData=m_cbCenterCard+j-cbExcursion[i];
g_CardResource.m_ImageTableBottom.DrawCardItem(&BufferDC,cbCardData,j*26+12,nYPos+5);
}
//计算位置
int nXImagePos=0;
int nItemWidth=m_ImageActionExplain.GetWidth()/7;
if ((m_cbActionMask&cbItemKind[i])&WIK_PENG)
nXImagePos=nItemWidth;
//绘画标志
int nItemHeight=m_ImageActionExplain.GetHeight();
m_ImageActionExplain.BitBlt(BufferDC,126,nYPos+5,nItemWidth,nItemHeight,nXImagePos,0);
//绘画边框
if (cbCurrentItem==m_cbCurrentItem)
{
BufferDC.Draw3dRect(7,nYPos,rcClient.Width()-14,ITEM_HEIGHT,RGB(255,255,0),RGB(255,255,0));
}
//设置变量
++cbCurrentItem;
nYPos+=ITEM_HEIGHT;
}
}
//杠牌扑克
for (BYTE i=0;i<CountArray(m_cbGangCard);i++)
{
if (m_cbGangCard[i]!=0)
{
//绘画扑克
for (BYTE j=0;j<4;j++)
{
g_CardResource.m_ImageTableBottom.DrawCardItem(&BufferDC,m_cbGangCard[i],j*26+12,nYPos+5);
}
//绘画边框
if (cbCurrentItem==m_cbCurrentItem)
{
BufferDC.Draw3dRect(7,nYPos,rcClient.Width()-14,ITEM_HEIGHT,RGB(255,255,0),RGB(255,255,0));
}
//绘画标志
int nItemWidth=m_ImageActionExplain.GetWidth()/7;
int nItemHeight=m_ImageActionExplain.GetHeight();
m_ImageActionExplain.BitBlt(BufferDC,126,nYPos+5,nItemWidth,nItemHeight,nItemWidth*3,0);
//设置变量
cbCurrentItem++;
nYPos+=ITEM_HEIGHT;
}
else
break;
}
//绘画界面
dc.BitBlt(0,0,rcClient.Width(),rcClient.Height(),&BufferDC,0,0,SRCCOPY);
//清理资源
BufferDC.DeleteDC();
BufferImage.DeleteObject();
return;
}
/*
Attach()
Collega la toolbar al controllo.
UINT nID l'id del controllo
const CSize& sizeButton dimensione (in pixel) del bottone (+2 rispetto al bitmap)
const CSize& sizeBitmap dimensione (in pixel) del bitmap usato per il bottone (-2 rispetto al bottone)
*/
BOOL CToolBarCtrlEx::Attach(const CSize& sizeButton,const CSize& sizeBitmap,UINT nID/*=(UINT)-1L*/,UINT nIDCold/*=(UINT)-1L*/,UINT nIDHot/*=(UINT)-1L*/)
{
BOOL bAttached = FALSE;
if(m_pToolBarButtonsList)
{
int nButtonsCount = m_pToolBarButtonsList->Count();
if(nButtonsCount > 0)
{
m_pTbArray = new TBBUTTON[nButtonsCount];
if(m_pTbArray)
{
TOOLBARBUTTON* t;
char szResourceString[32];
int nOfs = 0;
int n;
memset(m_szToolBarTextStrings,'\0',sizeof(m_szToolBarTextStrings));
for(int i = 0; i < nButtonsCount; i++)
{
if((t = (TOOLBARBUTTON*)m_pToolBarButtonsList->GetAt(i))!=(TOOLBARBUTTON*)NULL)
{
memcpy((void*)&m_pTbArray[i],(void*)&t->button,sizeof(TBBUTTON));
if(t->text!=0L)
{
if((n = ::LoadString(NULL,t->text,szResourceString,sizeof(szResourceString)-1))!=0)
{
if(nOfs+n < sizeof(m_szToolBarTextStrings)-2)
{
memcpy(m_szToolBarTextStrings+nOfs,szResourceString,n);
nOfs += n+1;
}
}
}
}
else
memset((void*)&m_pTbArray[i],'\0',sizeof(TBBUTTON));
}
if(nIDCold!=(UINT)-1L && nIDHot!=(UINT)-1L)
{
CImageList imageList;
CBitmap bitmap;
// lista immagini standard
bitmap.LoadBitmap(nIDCold);
imageList.Create(sizeBitmap.cx,sizeBitmap.cy,ILC_COLORDDB|ILC_MASK,nButtonsCount,1);
imageList.Add(&bitmap,RGB(255,0,255));
this->SendMessage(TB_SETIMAGELIST,0,(LPARAM)imageList.m_hImageList);
imageList.Detach();
bitmap.Detach();
// lista immagini 'hot'
bitmap.LoadBitmap(nIDHot);
imageList.Create(sizeBitmap.cx,sizeBitmap.cy,ILC_COLORDDB|ILC_MASK,nButtonsCount,1);
imageList.Add(&bitmap,RGB(255,0,255));
this->SendMessage(TB_SETHOTIMAGELIST,0,(LPARAM)imageList.m_hImageList);
imageList.Detach();
bitmap.Detach();
bAttached = TRUE;
}
else if(nID!=(UINT)-1L)
{
CToolBarCtrl::SetBitmapSize(sizeButton);
CToolBarCtrl::SetBitmapSize(sizeBitmap);
CToolBarCtrl::AddBitmap(nButtonsCount,nID);
bAttached = TRUE;
}
if(bAttached)
{
if(m_szToolBarTextStrings[0]!='\0')
CToolBarCtrl::AddStrings(m_szToolBarTextStrings);
CToolBarCtrl::AddButtons(nButtonsCount,m_pTbArray);
CToolBarCtrl::AutoSize();
}
}
}
}
return(bAttached);
}
void CTreeOptionsCtrlEx::OnCreateImageList()
{
CDC* pDCScreen = GetDC();
if (pDCScreen)
{
const int iBmpWidth = 16;
const int iBmpHeight = 17;
const int iBitmaps = 13;
CBitmap bmpControls;
if (bmpControls.CreateCompatibleBitmap(pDCScreen, iBmpWidth*iBitmaps, iBmpHeight))
{
if (m_ilTree.Create(iBmpWidth, iBmpHeight, m_uImageListColorFlags | ILC_MASK, 0, 1))
{
CDC dcMem;
if (dcMem.CreateCompatibleDC(pDCScreen))
{
HTHEME hTheme = (g_xpStyle.IsThemeActive() && g_xpStyle.IsAppThemed()) ? g_xpStyle.OpenThemeData(NULL, L"BUTTON") : NULL;
CBitmap* pOldBmp = dcMem.SelectObject(&bmpControls);
dcMem.FillSolidRect(0, 0, iBmpWidth*iBitmaps, iBmpHeight, GetSysColor(COLOR_WINDOW));
//int iCtrlWidth = iBmpWidth - 2;
//int iCtrlHeight = iBmpHeight - 2;
int iCtrlWidth = 16 - 3;
int iCtrlHeight = 16 - 3;
int iCtrlLeft = (iBmpWidth - iCtrlWidth) / 2;
int iCtrlTop = (iBmpHeight - iCtrlHeight) / 2;
// checkbox
CRect rcBmp(0, 0, 0+iBmpWidth, 0+iBmpHeight);
CRect rcCtrl(iCtrlLeft, iCtrlTop, iCtrlLeft+iCtrlWidth, iCtrlTop+iCtrlHeight);
if (hTheme){
g_xpStyle.DrawThemeBackground(hTheme, dcMem, BP_CHECKBOX, CBS_UNCHECKEDNORMAL, &rcCtrl, NULL);
g_xpStyle.DrawThemeEdge(hTheme, dcMem, BP_CHECKBOX, CBS_UNCHECKEDNORMAL, &rcCtrl, 0, 0, NULL);
}
else
dcMem.DrawFrameControl(&rcCtrl, DFC_BUTTON, DFCS_BUTTONCHECK | DFCS_FLAT);
// checkbox checked
rcCtrl.MoveToX(iCtrlLeft+iBmpWidth*1);
if (hTheme){
g_xpStyle.DrawThemeBackground(hTheme, dcMem, BP_CHECKBOX, CBS_CHECKEDNORMAL, &rcCtrl, NULL);
g_xpStyle.DrawThemeEdge(hTheme, dcMem, BP_CHECKBOX, CBS_CHECKEDNORMAL, &rcCtrl, 0, 0, NULL);
}
else
dcMem.DrawFrameControl(&rcCtrl, DFC_BUTTON, DFCS_BUTTONCHECK | DFCS_CHECKED | DFCS_FLAT);
// radio
rcCtrl.MoveToX(iCtrlLeft+iBmpWidth*2);
if (hTheme){
g_xpStyle.DrawThemeBackground(hTheme, dcMem, BP_RADIOBUTTON, RBS_UNCHECKEDNORMAL, &rcCtrl, NULL);
g_xpStyle.DrawThemeEdge(hTheme, dcMem, BP_CHECKBOX, RBS_UNCHECKEDNORMAL, &rcCtrl, 0, 0, NULL);
} else
dcMem.DrawFrameControl(&rcCtrl, DFC_BUTTON, DFCS_BUTTONRADIO | DFCS_FLAT);
// radio checked
rcCtrl.MoveToX(iCtrlLeft+iBmpWidth*3);
if (hTheme){
g_xpStyle.DrawThemeBackground(hTheme, dcMem, BP_RADIOBUTTON, RBS_CHECKEDNORMAL, &rcCtrl, NULL);
g_xpStyle.DrawThemeEdge(hTheme, dcMem, BP_CHECKBOX, RBS_CHECKEDNORMAL, &rcCtrl, 0, 0, NULL);
} else
dcMem.DrawFrameControl(&rcCtrl, DFC_BUTTON, DFCS_BUTTONRADIO | DFCS_CHECKED | DFCS_FLAT);
// checkbox disabled
rcCtrl.MoveToX(iCtrlLeft+iBmpWidth*4);
if (hTheme){
g_xpStyle.DrawThemeBackground(hTheme, dcMem, BP_CHECKBOX, CBS_UNCHECKEDDISABLED, &rcCtrl, NULL);
g_xpStyle.DrawThemeEdge(hTheme, dcMem, BP_CHECKBOX, CBS_UNCHECKEDDISABLED, &rcCtrl, 0, 0, NULL);
} else
dcMem.DrawFrameControl(&rcCtrl, DFC_BUTTON, DFCS_BUTTONCHECK | DFCS_INACTIVE | DFCS_FLAT);
// checkbox checked disabled
rcCtrl.MoveToX(iCtrlLeft+iBmpWidth*5);
if (hTheme){
g_xpStyle.DrawThemeBackground(hTheme, dcMem, BP_CHECKBOX, CBS_CHECKEDDISABLED, &rcCtrl, NULL);
g_xpStyle.DrawThemeEdge(hTheme, dcMem, BP_CHECKBOX, CBS_CHECKEDDISABLED, &rcCtrl, 0, 0, NULL);
} else
dcMem.DrawFrameControl(&rcCtrl, DFC_BUTTON, DFCS_BUTTONCHECK | DFCS_CHECKED | DFCS_INACTIVE | DFCS_FLAT);
// radio disabled
rcCtrl.MoveToX(iCtrlLeft+iBmpWidth*6);
if (hTheme){
g_xpStyle.DrawThemeBackground(hTheme, dcMem, BP_RADIOBUTTON, RBS_UNCHECKEDDISABLED, &rcCtrl, NULL);
g_xpStyle.DrawThemeEdge(hTheme, dcMem, BP_CHECKBOX, RBS_UNCHECKEDDISABLED, &rcCtrl, 0, 0, NULL);
} else
dcMem.DrawFrameControl(&rcCtrl, DFC_BUTTON, DFCS_BUTTONRADIO | DFCS_INACTIVE | DFCS_FLAT);
// radio checked disabled
rcCtrl.MoveToX(iCtrlLeft+iBmpWidth*7);
if (hTheme){
g_xpStyle.DrawThemeBackground(hTheme, dcMem, BP_RADIOBUTTON, RBS_CHECKEDDISABLED, &rcCtrl, NULL);
g_xpStyle.DrawThemeEdge(hTheme, dcMem, BP_CHECKBOX, RBS_CHECKEDDISABLED, &rcCtrl, 0, 0, NULL);
} else
dcMem.DrawFrameControl(&rcCtrl, DFC_BUTTON, DFCS_BUTTONRADIO | DFCS_CHECKED | DFCS_INACTIVE | DFCS_FLAT);
// checkbox checked tri-state
rcCtrl.MoveToX(iCtrlLeft+iBmpWidth*8);
if (hTheme){
g_xpStyle.DrawThemeBackground(hTheme, dcMem, BP_CHECKBOX, CBS_MIXEDNORMAL, &rcCtrl, NULL);
g_xpStyle.DrawThemeEdge(hTheme, dcMem, BP_CHECKBOX, CBS_MIXEDNORMAL, &rcCtrl, 0, 0, NULL);
} else
dcMem.DrawFrameControl(&rcCtrl, DFC_BUTTON, DFCS_BUTTON3STATE | DFCS_CHECKED | DFCS_FLAT);
// checkbox checked tri-state disabled
rcCtrl.MoveToX(iCtrlLeft+iBmpWidth*9);
if (hTheme){
g_xpStyle.DrawThemeBackground(hTheme, dcMem, BP_CHECKBOX, CBS_MIXEDDISABLED, &rcCtrl, NULL);
g_xpStyle.DrawThemeEdge(hTheme, dcMem, BP_CHECKBOX, CBS_MIXEDDISABLED, &rcCtrl, 0, 0, NULL);
} else
dcMem.DrawFrameControl(&rcCtrl, DFC_BUTTON, DFCS_BUTTON3STATE | DFCS_CHECKED | DFCS_INACTIVE | DFCS_FLAT);
ASSERT( TREEOPTSCTRLIMG_EDIT == 11 );
rcBmp.MoveToX(iBmpWidth*11);
rcCtrl.MoveToX(iCtrlLeft+iBmpWidth*11);
CFont font;
font.CreatePointFont(10, _T("Courier"));
CFont* pOldFont = dcMem.SelectObject(&font);
dcMem.TextOut(rcCtrl.left+2, rcCtrl.top, _T("I"));
dcMem.SelectObject(pOldFont);
CRect rcEdge(rcBmp);
rcEdge.top += 1;
rcEdge.bottom -= 1;
dcMem.DrawEdge(&rcEdge, EDGE_ETCHED, BF_RECT);
if (hTheme){
g_xpStyle.CloseThemeData(hTheme);
hTheme = NULL;
}
hTheme = (g_xpStyle.IsThemeActive() && g_xpStyle.IsAppThemed()) ? g_xpStyle.OpenThemeData(NULL, L"COMBOBOX") : NULL;
rcCtrl.MoveToX(iCtrlLeft+iBmpWidth*12);
if (hTheme){
g_xpStyle.DrawThemeBackground(hTheme, dcMem, CP_DROPDOWNBUTTON, CBXS_NORMAL, &rcCtrl, NULL);
g_xpStyle.DrawThemeEdge(hTheme, dcMem, CP_DROPDOWNBUTTON, CBXS_NORMAL, &rcCtrl, 0, 0, NULL);
} else
dcMem.DrawFrameControl(&rcCtrl, DFC_SCROLL, DFCS_SCROLLCOMBOBOX | DFCS_FLAT);
dcMem.SelectObject(pOldBmp);
m_ilTree.Add(&bmpControls, RGB(255,0,255));
if (hTheme)
g_xpStyle.CloseThemeData(hTheme);
}
}
}
ReleaseDC(pDCScreen);
}
}
void CSkinListBox::DrawItem( LPDRAWITEMSTRUCT lpDrawItemStruct )
{
//没有节点就不用继续执行了
if( GetCount()==0 ) return;
//变量定义
CRect rcItem=lpDrawItemStruct->rcItem;
CDC * pDCControl=CDC::FromHandle(lpDrawItemStruct->hDC);
//创建缓冲
CDC BufferDC;
CBitmap ImageBuffer;
BufferDC.CreateCompatibleDC(pDCControl);
ImageBuffer.CreateCompatibleBitmap(pDCControl,rcItem.Width(),rcItem.Height());
//设置环境
BufferDC.SelectObject(&ImageBuffer);
BufferDC.SelectObject(GetCtrlFont());
//获取字符
CString strString;
GetText(lpDrawItemStruct->itemID,strString);
//计算位置
CRect rcString;
rcString.SetRect(4,0,rcItem.Width()-8,rcItem.Height());
//颜色定义
COLORREF crTextColor=((lpDrawItemStruct->itemState&ODS_SELECTED)!=0)?m_colSelectText:m_colNormalText;
//绘画背景
BufferDC.FillSolidRect(0,0,rcItem.Width(),rcItem.Height(),m_colBack);
//节点选中
if ( (lpDrawItemStruct->itemState&ODS_SELECTED) != 0 )
{
if ( m_pSelectImg!= NULL && !m_pSelectImg->IsNull() )
{
m_pSelectImg->Draw(&BufferDC,CRect(0,0,rcItem.Width(),rcItem.Height()));
}
}
//节点高亮
else if ( m_nHovenItem == lpDrawItemStruct->itemID )
{
if ( m_pBackImgH!= NULL && !m_pBackImgH->IsNull() )
{
m_pBackImgH->Draw(&BufferDC,CRect(0,0,rcItem.Width(),rcItem.Height()));
}
}
//绘画字符
BufferDC.SetBkMode(TRANSPARENT);
BufferDC.SetTextColor(crTextColor);
BufferDC.DrawText(strString,&rcString,DT_VCENTER|DT_SINGLELINE);
//绘画界面
pDCControl->BitBlt(rcItem.left,rcItem.top,rcItem.Width(),rcItem.Height(),&BufferDC,0,0,SRCCOPY);
//清理资源
BufferDC.DeleteDC();
ImageBuffer.DeleteObject();
}
CSmfReadMap::CSmfReadMap(std::string mapname)
: file(mapname)
{
PrintLoadMsg("Opening map file");
ConfigureAnisotropy();
usePBO = !!configHandler->Get("UsePBO", 1);
for(int a=0;a<1024;++a){
for(int b=0;b<3;++b){
float c=max(mapInfo->water.minColor[b],mapInfo->water.baseColor[b]-mapInfo->water.absorb[b]*a);
waterHeightColors[a*4+b]=(unsigned char)(c*210);
}
waterHeightColors[a*4+3]=1;
}
const SMFHeader& header = file.GetHeader();
width=header.mapx;
height=header.mapy;
gs->mapx=header.mapx;
gs->mapy=header.mapy;
gs->mapSquares = gs->mapx*gs->mapy;
gs->hmapx=gs->mapx/2;
gs->hmapy=gs->mapy/2;
gs->pwr2mapx=next_power_of_2(gs->mapx);
gs->pwr2mapy=next_power_of_2(gs->mapy);
// logOutput.Print("%i %i",gs->mapx,gs->mapy);
float3::maxxpos=gs->mapx*SQUARE_SIZE-1;
float3::maxzpos=gs->mapy*SQUARE_SIZE-1;
heightmap=new float[(gs->mapx+1)*(gs->mapy+1)];
const CMapInfo::smf_t& smf = mapInfo->smf;
const float minH = smf.minHeightOverride ? smf.minHeight : header.minHeight;
const float maxH = smf.maxHeightOverride ? smf.maxHeight : header.maxHeight;
const float base = minH;
const float mod = (maxH - minH) / 65536.0f;
file.ReadHeightmap(heightmap, base, mod);
CReadMap::Initialize();
for (unsigned int a = 0; a < mapname.size(); ++a) {
mapChecksum += mapname[a];
mapChecksum *= mapname[a];
}
PrintLoadMsg("Loading detail textures");
detailTexName = mapInfo->smf.detailTexName;
CBitmap bm;
if (!bm.Load(detailTexName)) {
throw content_error("Could not load detail texture from file " + detailTexName);
}
glGenTextures(1, &detailTex);
glBindTexture(GL_TEXTURE_2D, detailTex);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
glBuildMipmaps(GL_TEXTURE_2D, GL_RGBA8, bm.xsize, bm.ysize, GL_RGBA, GL_UNSIGNED_BYTE, bm.mem);
if (anisotropy != 0.0f) {
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
}
PrintLoadMsg("Creating overhead texture");
unsigned char* buf=new unsigned char[MINIMAP_SIZE];
file.ReadMinimap(buf);
glGenTextures(1, &minimapTex);
glBindTexture(GL_TEXTURE_2D, minimapTex);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf);
int offset=0;
for (unsigned int i = 0; i < MINIMAP_NUM_MIPMAP; i++) {
int mipsize = 1024>>i;
int size = ((mipsize+3)/4)*((mipsize+3)/4)*8;
glCompressedTexImage2DARB(GL_TEXTURE_2D, i, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, mipsize, mipsize, 0, size, buf + offset);
offset += size;
}
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, MINIMAP_NUM_MIPMAP-1 );
delete[] buf;
PrintLoadMsg("Creating ground shading");
unsigned char* bufZero = new unsigned char[gs->pwr2mapx * gs->pwr2mapy * 4];
memset(bufZero, 0, gs->pwr2mapx * gs->pwr2mapy * 4);
glGenTextures(1, &shadowTex);
glBindTexture(GL_TEXTURE_2D, shadowTex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, gs->pwr2mapx, gs->pwr2mapy, 0, GL_RGBA, GL_UNSIGNED_BYTE, bufZero);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
if (anisotropy != 0.0f) {
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
}
delete[] bufZero;
HeightmapUpdated(0, gs->mapx, 0, gs->mapy);
groundDrawer=new CBFGroundDrawer(this);
file.ReadFeatureInfo ();
}
void CBCGPHeaderCtrl::OnDrawItem (CDC* pDC, int iItem, CRect rect, BOOL bIsPressed,
BOOL bIsHighlighted)
{
ASSERT_VALID (this);
ASSERT_VALID (pDC);
const int nTextMargin = 5;
//-------------
// Draw border:
//-------------
CBCGPVisualManager::GetInstance ()->OnDrawHeaderCtrlBorder (this, pDC,
rect, bIsPressed, bIsHighlighted);
if (iItem < 0)
{
return;
}
int nSortVal = 0;
if (m_mapColumnsStatus.Lookup (iItem, nSortVal) &&
nSortVal != 0)
{
//-----------------
// Draw sort arrow:
//-----------------
CRect rectArrow = rect;
rectArrow.DeflateRect (5, 5);
rectArrow.left = rectArrow.right - rectArrow.Height ();
if (bIsPressed)
{
rectArrow.right++;
rectArrow.bottom++;
}
rect.right = rectArrow.left - 1;
int dy2 = (int) (.134 * rectArrow.Width ());
rectArrow.DeflateRect (0, dy2);
m_bAscending = nSortVal > 0;
OnDrawSortArrow (pDC, rectArrow);
}
HD_ITEM hdItem;
memset (&hdItem, 0, sizeof (hdItem));
hdItem.mask = HDI_FORMAT | HDI_BITMAP | HDI_TEXT | HDI_IMAGE;
TCHAR szText [256];
hdItem.pszText = szText;
hdItem.cchTextMax = 255;
if (!GetItem (iItem, &hdItem))
{
return;
}
//-----------------------
// Draw bitmap and image:
//-----------------------
if ((hdItem.fmt & HDF_IMAGE) && hdItem.iImage >= 0)
{
// By Max Khiszinsky:
//---------------------------------------
// The column has a image from imagelist:
//---------------------------------------
CImageList* pImageList = GetImageList ();
if (pImageList != NULL)
{
int cx = 0;
int cy = 0;
VERIFY (::ImageList_GetIconSize (*pImageList, &cx, &cy));
CPoint pt = rect.TopLeft ();
pt.x ++;
pt.y = (rect.top + rect.bottom - cy) / 2;
VERIFY (pImageList->Draw (pDC, hdItem.iImage, pt, ILD_NORMAL));
rect.left += cx;
}
}
if ((hdItem.fmt & (HDF_BITMAP | HDF_BITMAP_ON_RIGHT)) && hdItem.hbm != NULL)
{
CBitmap* pBmp = CBitmap::FromHandle (hdItem.hbm);
ASSERT_VALID (pBmp);
BITMAP bmp;
pBmp->GetBitmap (&bmp);
CRect rectBitmap = rect;
if (hdItem.fmt & HDF_BITMAP_ON_RIGHT)
{
rectBitmap.right--;
rect.right = rectBitmap.left = rectBitmap.right - bmp.bmWidth;
}
else
{
rectBitmap.left++;
rect.left = rectBitmap.right = rectBitmap.left + bmp.bmWidth;
}
rectBitmap.top += max (0, (rectBitmap.Height () - bmp.bmHeight) / 2);
rectBitmap.bottom = rectBitmap.top + bmp.bmHeight;
pDC->DrawState (rectBitmap.TopLeft (), rectBitmap.Size (), pBmp, DSS_NORMAL);
}
//-----------
// Draw text:
//-----------
if (hdItem.fmt & HDF_STRING)
{
COLORREF clrText = CBCGPVisualManager::GetInstance ()->GetHeaderCtrlTextColor (this, bIsPressed, bIsHighlighted);
COLORREF clrTextOld = (COLORREF)-1;
if (clrText != (COLORREF)-1)
{
clrTextOld = pDC->SetTextColor (clrText);
}
CRect rectLabel = rect;
rectLabel.DeflateRect (nTextMargin, 0);
CString strLabel = hdItem.pszText;
UINT uiTextFlags = DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS | DT_NOPREFIX;
if (hdItem.fmt & HDF_CENTER)
{
uiTextFlags |= DT_CENTER;
}
else if (hdItem.fmt & HDF_RIGHT)
{
uiTextFlags |= DT_RIGHT;
}
pDC->DrawText (strLabel, rectLabel, uiTextFlags);
if (clrText != (COLORREF)-1)
{
pDC->SetTextColor (clrTextOld);
}
}
}
void CDisplayView::drawofl(void)
{
CFrame *parentframe = getParent();
if(!parentframe) return;
CDrawContext *srccon;
long dsplw,dsplh;
#if 1 // quantise near-grey to grey for transparent-draw
// could be removed if q'ed bitmap is compiled to resource
if(stConverted==false)
{
stConverted = true;
srccon = new CDrawContext(parentframe,0);
COffscreenContext *charcon;
CColor pcl;
int w,h;
for(int nf=0; nf<kNumFtTypes; nf++)
{
dsplw = stFonts[nf].font->getWidth();
dsplh = stFonts[nf].font->getHeight();
charcon = new COffscreenContext(srccon,stFonts[nf].font,true);
CPoint cp = CPoint(0,0);
CRect cr = CRect(0,0, dsplw,dsplh);
stFonts[nf].font->draw(charcon, cr, cp );
for(w=0; w<dsplw; w++)
{
for(h=0; h<dsplh; h++)
{
#define RNG 14
pcl = charcon->getPoint(CPoint(w,h));
if( pcl.red==128 && pcl.green==128 && pcl.blue==128 ) continue;
if(pcl.red<(128-RNG) || pcl.red>128+RNG) continue;
if(pcl.green<(128-RNG) || pcl.green>128+RNG) continue;
if(pcl.blue<(128-RNG) || pcl.blue>128+RNG) continue;
pcl.red=pcl.green=pcl.blue = 128;
charcon->drawPoint(CPoint(w,h), pcl);
}
}
delete charcon;
}
delete srccon;
}
#endif
#if 0 // 0=PixelDrawing, else transparent drawing
COffscreenContext *charcon;
CPoint cp;
CRect cr;
char c;
dsplw = mDsplBmp->getWidth();
dsplh = mDsplBmp->getHeight();
CBitmap *bgnd = parentframe->getBackground();
// get fresh background image
cp = CPoint(size.left+mXAlign,size.top+mYAlign);
cr = CRect(0,0,dsplw,dsplh);
srccon = new CDrawContext(parentframe,0);
COffscreenContext *dspcon = new COffscreenContext(srccon,mDsplBmp,true);
bgnd->draw(dspcon, cr, cp);
// get fresh font image
cp = CPoint(0,0);
cr = CRect(0,0, mFontBmp->getWidth(),mFontBmp->getHeight());
charcon = new COffscreenContext(parentframe,mFontBmp->getWidth(),mFontBmp->getHeight());
CColor scl,dcl;
mFontBmp->draw(charcon, cr, cp );
for(int i=0; i<mCharsfit && (c = mText[i]); i++)
{
int h,w,wd = i*mPaintWidth;
int ws = (c - 33) * mCharWidth; // left position in font
if(ws < 0)
{
continue;
}
for(w=0,ws+=mCharOfs; w<(mCharWidth-mCharOfs); w++,ws++,wd++)
{
for(h=0; h<dsplh; h++)
{
scl = charcon->getPoint(CPoint(ws,h));
if( scl.red==128 && scl.green==128 && scl.blue==128 ) continue;
dcl = dspcon->getPoint(CPoint(wd,h));
dcl.red = stClip[scl.red + (scl.red>>1) + dcl.red];
dcl.green = stClip[scl.green + (scl.green>>1) + dcl.green];
dcl.blue = stClip[scl.blue + (scl.blue>>1) + dcl.blue];
dspcon->drawPoint(CPoint(wd,h), dcl);
}
}
}
delete srccon;
delete dspcon;
delete charcon;
#else
CPoint cp;
CRect cr;
char c;
dsplw = mDsplBmp->getWidth();
dsplh = mDsplBmp->getHeight();
// get fresh background image
CBitmap *bgnd = parentframe->getBackground();
cp = CPoint(size.left+mXAlign,size.top+mYAlign);
cr = CRect(0,0,dsplw,dsplh);
srccon = new CDrawContext(parentframe,0);
COffscreenContext *dspcon = new COffscreenContext(srccon,mDsplBmp,true);
bgnd->draw(dspcon, cr, cp);
for(int i=0; i<mCharsfit && (c = mText[i]); i++)
{
int ws = (c - 33) * mCharWidth; // left position in font
if(ws < 0)
{
continue;
}
CPoint dp = CPoint(ws+mCharOfs,0);
CRect dr = CRect(i*mPaintWidth,0, i*mPaintWidth+mCharWidth,dsplh);
mFontBmp->drawTransparent(dspcon, dr, dp);
}
delete srccon;
delete dspcon;
#endif
m1stSight = false;
setDirty(true);
}
void CSm3ReadMap::Initialize (const char *mapname)
{
try {
string lmsg = "Loading " + string(mapname);
PrintLoadMsg(lmsg.c_str());
GLint tu;
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &tu);
renderer = SAFE_NEW terrain::Terrain;
renderer->config.cacheTextures=false;
renderer->config.forceFallbackTexturing = !!configHandler.GetInt("SM3ForceFallbackTex", 0);
if (!renderer->config.forceFallbackTexturing && GLEW_ARB_fragment_shader && GLEW_ARB_shading_language_100) {
renderer->config.useBumpMaps = true;
renderer->config.anisotropicFiltering = 0.0f;
}
renderer->config.useStaticShadow = false;
renderer->config.terrainNormalMaps = false;
renderer->config.normalMapLevel = 3;
if (shadowHandler->drawShadows)
renderer->config.useShadowMaps = true;
if (!mapInfo->sm3.minimap.empty()) {
CBitmap bmp;
if(bmp.Load(mapInfo->sm3.minimap))
minimapTexture=bmp.CreateTexture(true);
}
/* int numStages=atoi(mapDefParser.SGetValueDef("0", "map\\terrain\\numtexturestages").c_str());
int maxStages=configHandler.GetInt("SM3MaxTextureStages", 10);
if (numStages > maxStages) {
renderer->config.cacheTextures = true;
renderer->config.cacheTextureSize = 256;
// renderer->config.detailMod
}
*/
Sm3LoadCB loadcb;
terrain::LightingInfo lightInfo;
lightInfo.ambient = mapInfo->light.groundAmbientColor;
terrain::StaticLight light;
light.color = mapInfo->light.groundSunColor;
light.directional = false;
light.position = mapInfo->light.sunDir *1000000;
lightInfo.staticLights.push_back (light);
renderer->Load (GetMapDefParser(), &lightInfo, &loadcb);
height = width = renderer->GetHeightmapWidth ()-1;
// Set global map info
gs->mapx=width;
gs->mapy=height;
gs->mapSquares = width*height;
gs->hmapx=width/2;
gs->hmapy=height/2;
gs->pwr2mapx=next_power_of_2(width);
gs->pwr2mapy=next_power_of_2(height);
float3::maxxpos=width*SQUARE_SIZE-1;
float3::maxzpos=height*SQUARE_SIZE-1;
CReadMap::Initialize();
const TdfParser& mapDefParser = GetMapDefParser();
if (mapDefParser.SectionExist("map\\featuretypes")) {
int numTypes = atoi(mapDefParser.SGetValueDef("0", "map\\featuretypes\\numtypes").c_str());
for (int a=0;a<numTypes;a++) {
char loc[100];
SNPRINTF(loc, 100, "map\\featuretypes\\type%d", a);
featureTypes.push_back (SAFE_NEW std::string(mapDefParser.SGetValueDef("TreeType0", loc)));
}
}
LoadFeatureData();
groundDrawer = SAFE_NEW CSm3GroundDrawer (this);
}
catch(content_error& e)
{
ErrorMessageBox(e.what(), "Error:", MBF_OK);
}
}
void CIMMain::OnPaint()
{
CPaintDC dc(this);
// Create a memory DC compatible with the paint DC
CDC memDC;
memDC.CreateCompatibleDC(&dc);
CRect rcClip, rcClient;
dc.GetClipBox( &rcClip );
GetClientRect(&rcClient);
// Select a compatible bitmap into the memory DC
CBitmap bitmap;
bitmap.CreateCompatibleBitmap( &dc, rcClient.Width(), rcClient.Height() );
memDC.SelectObject( &bitmap );
//dc.SetBkMode(TRANSPARENT);
// Set clip region to be same as that in paint DC
CRgn rgn;
rgn.CreateRectRgnIndirect( &rcClip );
memDC.SelectClipRgn(&rgn);
rgn.DeleteObject();
// First let the control do its default drawing.
CWnd::DefWindowProc(WM_PAINT, (WPARAM)memDC.m_hDC, 0);
HTREEITEM hItem = GetFirstVisibleItem();
int iItemCount = GetVisibleCount() + 1;
while(hItem && iItemCount--)
{
CRect rect;
// Do not meddle with selected items or drop highlighted items
UINT selflag = TVIS_DROPHILITED | TVIS_SELECTED;
Color_Font cf;
if ((GetItemState(hItem, selflag) & selflag)
&& ::GetFocus() == m_hWnd)
;
else if (m_mapColorFont.Lookup(hItem, cf))
{
CFont *pFontDC;
CFont fontDC;
LOGFONT logfont;
if(cf.logfont.lfFaceName[0] != '\0 ')
logfont = cf.logfont;
else {
// No font specified, so use window font
CFont *pFont = GetFont();
pFont-> GetLogFont( &logfont );
}
if(GetItemBold(hItem))
logfont.lfWeight = 700;
fontDC.CreateFontIndirect(&logfont);
pFontDC = memDC.SelectObject(&fontDC );
if(cf.color != (COLORREF) - 1)
memDC.SetTextColor(cf.color);
else
memDC.SetTextColor(GetSysColor(COLOR_WINDOWTEXT));
CString sItem = GetItemText(hItem);
GetItemRect(hItem, &rect, TRUE);
//memDC.SetBkColor( GetSysColor(COLOR_WINDOW ));
memDC.SetBkMode(TRANSPARENT);
memDC.TextOut(rect.left + 2, rect.top + 5, sItem);
memDC.SelectObject(pFontDC);
}
hItem = GetNextVisibleItem(hItem);
}
dc.BitBlt(rcClip.left, rcClip.top, rcClip.Width(), rcClip.Height(), &memDC,
rcClip.left, rcClip.top, SRCCOPY);
memDC.DeleteDC();
}
BOOL CDrawMandelbrotDlg::Draw()
{
CRect rect;
GetWindowRect(&rect);
int width = rect.Width();
int height = rect.Height();
m_top = m_bottom + (m_right - m_left) * height / width;
CClientDC dc(this);
CDC memDC;
memDC.CreateCompatibleDC(&dc);
CBitmap bmp;
bmp.CreateCompatibleBitmap(&dc, width, height);
memDC.SelectObject(&bmp);
BITMAPINFO bmpInfo;
bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmpInfo.bmiHeader.biWidth = width;
bmpInfo.bmiHeader.biHeight = -height;
bmpInfo.bmiHeader.biPlanes = 1;
bmpInfo.bmiHeader.biBitCount = 24;
bmpInfo.bmiHeader.biCompression = BI_RGB;
bmpInfo.bmiHeader.biSizeImage = 0;
bmpInfo.bmiHeader.biXPelsPerMeter = 3000;
bmpInfo.bmiHeader.biYPelsPerMeter = 3000;
bmpInfo.bmiHeader.biClrUsed = 0;
bmpInfo.bmiHeader.biClrImportant = 0;
long bytesPerLine = (bmpInfo.bmiHeader.biWidth * 3 + 3) / 4 * 4;
long bufferSize = bytesPerLine * height;
BYTE *buffer = new BYTE[bufferSize];
memset(buffer, 0, bufferSize);
int maxLoop = 1500;
double w = m_right - m_left;
double h = m_top - m_bottom;
int iTmp = -1;
int index = -1;
#pragma omp parallel for
for (int i = 0; i < width; ++i)
{
for (int j = 0; j < height; ++j)
{
ComplexNum z;
ComplexNum c;
double dTmp;
int loopCount = 0;
c.real = w * (i + 1) / width + m_left;
c.imag = h * (j + 1) / height + m_bottom;
do
{
dTmp = z.real * z.real - z.imag * z.imag + c.real;
z.imag = 2 * z.real * z.imag + c.imag;
z.real = dTmp;
++loopCount;
} while((z.real * z.real + z.imag * z.imag) < 4 && loopCount < maxLoop);
if (loopCount != maxLoop)
{
int iTmp = loopCount % 255;
index = j * bytesPerLine + i * 3;
buffer[index] = iTmp;
buffer[index + 1] = iTmp * 5;
buffer[index + 2] = iTmp * 10;
}
}
}
SetDIBits(dc.m_hDC, bmp, 0, height, buffer, &bmpInfo, DIB_RGB_COLORS);
delete []buffer;
dc.BitBlt(0, 0, bmpInfo.bmiHeader.biWidth, height, &memDC, 0, 0, SRCCOPY);
return true;
}
void CIMTree::OnPaint()
{
CPaintDC dc(this); // device context for painting
CRect rcClip, rcClient;
dc.GetClipBox( &rcClip );
GetClientRect(&rcClient);
// Create a compatible memory DC
CDC memDC;
memDC.CreateCompatibleDC( &dc );
// Select a compatible bitmap into the memory DC
CBitmap bitmap, bmpImage;
bitmap.CreateCompatibleBitmap( &dc, rcClient.Width(), rcClient.Height() );
CBitmap *OldBitmap = memDC.SelectObject( &bitmap );
// First let the control do its default drawing.
CTreeCtrl::DefWindowProc( WM_PAINT, (WPARAM)memDC.m_hDC, 0 );
/*
// create the font
CFont *pFontDC;
CFont fontDC, boldFontDC;
LOGFONT logfont;
CFont *pFont = GetFont();
pFont->GetLogFont( &logfont );
fontDC.CreateFontIndirect( &logfont ); //普通字体
pFontDC = memDC.SelectObject( &fontDC );
logfont.lfWeight = 700;
boldFontDC.CreateFontIndirect( &logfont ); //粗体字
// and now let's get to the painting itself
HTREEITEM hItem = GetFirstVisibleItem();
int n = GetVisibleCount();
hItem = GetFirstVisibleItem();
n = GetVisibleCount();
while(hItem!=NULL && n>=0)
{
CRect rect;
CRect m_labelRect;
UINT selflag = TVIS_SELECTED ; // |TVIS_DROPHILITED;
CString ItemText = GetItemText(hItem);
GetItemRect( hItem, &m_labelRect, TRUE ); //文字
GetItemRect( hItem, &rect, FALSE );
if ( !(GetItemState( hItem, selflag ) & selflag )) //选中状态
{
memDC.SetBkMode(TRANSPARENT);
memDC.SetTextColor(::GetSysColor (COLOR_WINDOWTEXT ));
DrawItemText(&memDC,ItemText,m_labelRect,LVCFMT_LEFT);
}
else
{
COLORREF m_highlightColor = ::GetSysColor (COLOR_HIGHLIGHT);
CBrush brush(m_highlightColor);
memDC.FillRect (m_labelRect, &brush);
// draw a dotted focus rectangle
memDC.DrawFocusRect (m_labelRect);
memDC.SetBkColor(m_highlightColor);
memDC.SetTextColor(::GetSysColor (COLOR_HIGHLIGHTTEXT));
memDC.SelectObject( &boldFontDC );
DrawItemText(&memDC,ItemText,m_labelRect,LVCFMT_LEFT);
memDC.SelectObject( &pFontDC );
}
hItem = GetNextVisibleItem( hItem );
n--;
}
memDC.SelectObject( pFontDC );
*/
// Draw bitmap in the background if one has been set
if( m_bitmap.m_hObject != NULL )
{
// Now create a mask
CDC maskDC;
maskDC.CreateCompatibleDC(&dc);
CBitmap maskBitmap;
// Create monochrome bitmap for the mask
maskBitmap.CreateBitmap( rcClient.Width(), rcClient.Height(),
1, 1, NULL );
CBitmap *OldMask = maskDC.SelectObject( &maskBitmap );
memDC.SetBkColor( ::GetSysColor( COLOR_WINDOW ) );
// Create the mask from the memory DC
maskDC.BitBlt( 0, 0,
rcClient.Width(), rcClient.Height(),
&memDC,
rcClient.left, rcClient.top,
SRCCOPY );
CDC tempDC;
tempDC.CreateCompatibleDC(&dc);
CBitmap *Oldtemp = tempDC.SelectObject( &m_bitmap );
CDC imageDC;
CBitmap bmpImage;
imageDC.CreateCompatibleDC( &dc );
bmpImage.CreateCompatibleBitmap( &dc, rcClient.Width(),
rcClient.Height() );
CBitmap *OldImage = imageDC.SelectObject( &bmpImage );
if( dc.GetDeviceCaps(RASTERCAPS) & RC_PALETTE && m_pal.m_hObject != NULL )
{
dc.SelectPalette( &m_pal, FALSE );
dc.RealizePalette();
imageDC.SelectPalette( &m_pal, FALSE );
}
// Get x and y offset
CRect rcRoot;
GetItemRect( GetRootItem(), rcRoot, FALSE );
rcRoot.left = -GetScrollPos( SB_HORZ );
imageDC.FillSolidRect(CRect(0,0,rcClient.right,rcClient.bottom),BgColor);
if( m_bBgStretch )
{
imageDC.SetStretchBltMode(COLORONCOLOR);
imageDC.StretchBlt(
0,0,rcClient.right,rcClient.bottom,
&tempDC,
0,0,m_cxBitmap,m_cyBitmap,
SRCCOPY
);
}
else
{
imageDC.BitBlt(
rcClient.right-m_cxBitmap,rcClient.bottom-m_cyBitmap,
m_cxBitmap,m_cyBitmap,
&tempDC,
0, 0,
SRCCOPY );
/*
// Draw bitmap in tiled manner to imageDC
for( int i = rcRoot.left; i < rcClient.right; i += m_cxBitmap )
for( int j = rcRoot.top; j < rcClient.bottom; j += m_cyBitmap )
{
imageDC.BitBlt( i, j, m_cxBitmap, m_cyBitmap,
&tempDC,0, 0, SRCCOPY );
}
*/
}
// Set the background in memDC to black. Using SRCPAINT with black and any other
// color results in the other color, thus making black the transparent color
memDC.SetBkColor(RGB(0,0,0));
memDC.SetTextColor(RGB(255,255,255));
memDC.BitBlt( rcClip.left, rcClip.top,
rcClip.Width(), rcClip.Height(),
&maskDC,
rcClip.left, rcClip.top,
SRCAND);
// Set the foreground to black. See comment above.
imageDC.SetBkColor(RGB(255,255,255));
imageDC.SetTextColor(RGB(0,0,0));
imageDC.BitBlt( rcClip.left, rcClip.top,
rcClip.Width(), rcClip.Height(),
&maskDC,
rcClip.left, rcClip.top,
SRCAND);
// Combine the foreground with the background
imageDC.BitBlt( rcClip.left, rcClip.top,
rcClip.Width(), rcClip.Height(),
&memDC,
rcClip.left, rcClip.top,
SRCPAINT);
// Draw the final image to the screen
dc.BitBlt( rcClip.left, rcClip.top,
rcClip.Width(), rcClip.Height(),
&imageDC,
rcClip.left, rcClip.top, SRCCOPY );
//释放对象
maskDC.SelectObject(OldMask);
imageDC.SelectObject(OldImage);
tempDC.SelectObject(Oldtemp);
maskBitmap.DeleteObject();
bmpImage.DeleteObject();
maskDC.DeleteDC();
imageDC.DeleteDC();
tempDC.DeleteDC();
}
else
{
dc.BitBlt( rcClip.left, rcClip.top,
rcClip.Width(),
rcClip.Height(),
&memDC,
rcClip.left, rcClip.top, SRCCOPY );
}
memDC.SelectObject(OldBitmap);
bitmap.DeleteObject();
memDC.DeleteDC();
}
void CSkinVerticleScrollbar::Draw()
{
CClientDC dc(this);
CRect clientRect;
GetClientRect(&clientRect);
CMyMemDC memDC(&dc, &clientRect);
memDC.FillSolidRect(&clientRect, RGB(74,82,107));
CDC bitmapDC;
bitmapDC.CreateCompatibleDC(&dc);
CBitmap bitmap;
bitmap.LoadBitmap(IDB_VERTICLE_SCROLLBAR_TOP);
CBitmap* pOldBitmap = bitmapDC.SelectObject(&bitmap);
memDC.BitBlt(clientRect.left,clientRect.top,20,17,&bitmapDC,0,0,SRCCOPY);
bitmapDC.SelectObject(pOldBitmap);
bitmap.DeleteObject();
pOldBitmap = NULL;
bitmap.LoadBitmap(IDB_VERTICLE_SCROLLBAR_UPARROW);
pOldBitmap = bitmapDC.SelectObject(&bitmap);
memDC.BitBlt(clientRect.left,clientRect.top+17,20,19,&bitmapDC,0,0,SRCCOPY);
bitmapDC.SelectObject(pOldBitmap);
bitmap.DeleteObject();
pOldBitmap = NULL;
//draw the background (span)
bitmap.LoadBitmap(IDB_VERTICLE_SCROLLBAR_SPAN);
pOldBitmap = bitmapDC.SelectObject(&bitmap);
int nHeight = clientRect.Height() - 37;
memDC.StretchBlt(clientRect.left, clientRect.top+37, 20,nHeight,&bitmapDC, 0,0, 20, 1, SRCCOPY);
bitmapDC.SelectObject(pOldBitmap);
bitmap.DeleteObject();
pOldBitmap = NULL;
//draw the down arrow of the scrollbar
bitmap.LoadBitmap(IDB_VERTICLE_SCROLLBAR_DOWNARROW);
pOldBitmap = bitmapDC.SelectObject(&bitmap);
memDC.BitBlt(clientRect.left,nHeight,20,16,&bitmapDC,0,0,SRCCOPY);
bitmapDC.SelectObject(pOldBitmap);
bitmap.DeleteObject();
pOldBitmap = NULL;
//draw the down arrow of the scrollbar
bitmap.LoadBitmap(IDB_VERTICLE_SCROLLBAR_BOTTOM);
pOldBitmap = bitmapDC.SelectObject(&bitmap);
memDC.BitBlt(clientRect.left+1,nHeight+26,20,22,&bitmapDC,0,0,SRCCOPY);
bitmapDC.SelectObject(pOldBitmap);
bitmap.DeleteObject();
pOldBitmap = NULL;
//If there is nothing to scroll then don't
//show the thumb control otherwise show it
if(pList->GetScrollLimit(SB_VERT) != 0)
{
//draw the thumb control
bitmap.LoadBitmap(IDB_VERTICLE_SCROLLBAR_THUMB);
pOldBitmap = bitmapDC.SelectObject(&bitmap);
memDC.BitBlt(clientRect.left,clientRect.top+nThumbTop,20,26,&bitmapDC,0,0,SRCCOPY);
bitmapDC.SelectObject(pOldBitmap);
bitmap.DeleteObject();
pOldBitmap = NULL;
}
}
void CViewSockTrackerImage::OnDraw(CDC* pDC)
{
CDocument* pDoc = GetDocument();
// 這邊畫 圖片
/////////////////////////////////////////////////////////////////////
CRect RectImage;
GetClientRect( &RectImage );
if(m_pBitmap != NULL && csInfomation == "" )
{
CBitmap bmp;
if(bmp.Attach(m_pBitmap))
{
CString csW = _T("");
BITMAP bmpInfo;
bmp.GetBitmap(&bmpInfo);
CDC dcMemory;
dcMemory.CreateCompatibleDC(pDC);
dcMemory.SelectObject(&bmp);
pDC->SetStretchBltMode(HALFTONE);
pDC->StretchBlt(RectImage.left,RectImage.top,RectImage.Width(),RectImage.Height(),&dcMemory,0,0,
bmpInfo.bmWidth,bmpInfo.bmHeight,SRCCOPY);
bmp.Detach();
//
m_w = bmpInfo.bmWidth;
m_h = bmpInfo.bmHeight;
}
}
//
// 這邊畫 Pattern ROI
/////////////////////////////////////////////////////////////////////
if(m_pBitmap != NULL && csInfomation == "" )
{
CRect rect;
COLORREF color = RGB(255, 255, 0);
m_AlignRectTracker.SetRectColor( color );
m_AlignRectTracker.GetTrueRect(&rect);
if( m_bLoadRect )
{
m_bLoadRect = false;
m_AlignRectTracker.m_rect = m_LoadRect;
m_AlignRectTracker.Draw( pDC, m_LoadRect );
}
else
m_AlignRectTracker.Draw( pDC );
}
/////////////////////////////////////////////////////////////////////
if( csInfomation != "" )
{
CRect RectText;
GetClientRect( &RectText );
int x = 0;
int y = 0;
x = 20;
y = RectText.Height() / 2;
pDC->TextOut( x, y, csInfomation );
pDC->TextOut( x, y + 15 , "Image is lost" );
csInfomation = "";
}
//
m_pBitmap = NULL;
}
LRESULT CEXMLDocumentStyleSheetsView::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
CBitmap bmIcons;
bmIcons.LoadBitmap(MAKEINTRESOURCE(IDB_CSSSTYLESHEETS));
m_icons.Create(16, 16, ILC_COLOR8 | ILC_MASK, 1, 5);
m_icons.Add(bmIcons, RGB(255, 255, 255));
IUnknown* p;
CRect rc(0,0,0,0);
m_axtreeCtl.Create(m_hWnd, rc, NULL, WS_CHILD | WS_VISIBLE);
m_axtreeCtl.AttachControl(m_treeCtl, &p);
IDispEventImpl<4, CEXMLDocumentStyleSheetsView, &DIID__IUITreeControlEvents, &LIBID_UILib, 1, 0>::DispEventAdvise(m_treeCtl);
m_treeCtl->put_hImageList((long)(HIMAGELIST)m_icons);
CComPtr<IEXMLDocument> document;
m_viewGroup->get_eXMLDocument(&document);
CComPtr<ILDOMDocument> domdocument;
document->get_DOMDocument(&domdocument);
PopulateStyleSheetElements(NULL, domdocument);
#if 0
if (m_styleSheetList)
{
ASSERT(m_viewGroup);
CComPtr<IEXMLDocument> eDocument;
m_viewGroup->get_eXMLDocument(&eDocument);
CComPtr<ILDOMDocument> domDocument;
eDocument->get_DOMDocument(&domDocument);
// CComPtr<ILDOMElement> documentElement;
// domDocument->get_documentElement(&documentElement);
PopulateStyleSheetElements(NULL, domDocument);
/*
PopulateStyleSheets(NULL, m_styleSheetList);
*/
{
CComQIPtr<ILDOMEventTarget> eventTarget = domDocument;
eventTarget->addEventListener(L"DOMNodeInserted", (ILDOMEventListener*)this, VARIANT_TRUE);
eventTarget->addEventListener(L"DOMNodeRemovedFromDocument", (ILDOMEventListener*)this, VARIANT_TRUE);
}
IDispEventImpl<1, CEXMLDocumentStyleSheetsView, &DIID__IEXMLViewGroupEvents, &LIBID_LXMLEDITORLib, 1, 0>::DispEventAdvise(m_viewGroup->GetUnknown());
}
else if (m_styleSheet)
{
CComPtr<ILCSSRuleList> ruleList;
m_styleSheet->get_cssRules(&ruleList);
PopulateRules(NULL, ruleList);
}
#endif
// CComQIPtr<IUIActiveManager> uiActiveManager = m_app;
// uiActiveManager->AddEventHandler(this);
return 0;
}
void CDConsoleDlg::AddImage(CImageList& imageList, UINT id)
{
CBitmap bm;
bm.LoadBitmap(id);
imageList.Add(&bm, RGB(0, 0, 0));
}
BOOL CFileUploaderDialog::OnInitDialog (void)
{
CDialog::OnInitDialog ();
// Initialize FlickrClient
o_FlickrClient.SetPhotoSetInfo (&map_PhotoSetInfoByName);
// Add Items to the System Menu
CMenu* pSysMenu = GetSystemMenu (FALSE);
if (pSysMenu != NULL)
{
pSysMenu->AppendMenu (MF_SEPARATOR);
pSysMenu->AppendMenu (MF_STRING, IDM_SETTINGS, _T("&Settings ..."));
}
// Set System Icons
SetIcon (hico_FlickrPal16, FALSE);
SetIcon (hico_FlickrPal32, TRUE);
// Create Wait Animation
CRect oWaitAnimationRect;
GetDlgItem (IDC_WAIT_ANIMATION_RECT)->GetWindowRect (oWaitAnimationRect);
ScreenToClient (oWaitAnimationRect);
m_WaitAnimation.Create (NULL,
_T("WaitAnimation"),
WS_CHILD,
oWaitAnimationRect,
this,
IDC_WAIT_ANIMATION_RECT);
// Create Username Ctrl
CRect oUsernameTextRect;
GetDlgItem (IDC_USERNAME_RECT)->GetWindowRect (oUsernameTextRect);
ScreenToClient (oUsernameTextRect);
m_UsenameText.Create (NULL,
_T("UsernameText"),
WS_CHILD,
oUsernameTextRect,
this,
IDC_USERNAME_RECT);
m_UsenameText.Init (RGB (0, 200, 0));
// Create User Photos URL
CRect oUserPhotosURLRect;
GetDlgItem (IDC_USER_PHOTOS_URL_RECT)->GetWindowRect (oUserPhotosURLRect);
ScreenToClient (oUserPhotosURLRect);
m_UserPhotosURLCtrl.Create (NULL,
_T("UserPhotosURL"),
WS_CHILD,
oUserPhotosURLRect,
this,
IDC_USER_PHOTOS_URL_RECT);
// Create User Profile URL
CRect oUserProfileURLRect;
GetDlgItem (IDC_USER_PROFILE_URL_RECT)->GetWindowRect (oUserProfileURLRect);
ScreenToClient (oUserProfileURLRect);
m_UserProfileURLCtrl.Create (NULL,
_T("UserProfileURL"),
WS_CHILD,
oUserProfileURLRect,
this,
IDC_USER_PROFILE_URL_RECT);
// Create Available Quota Ctrl
CRect oAvailableQuotaRect;
GetDlgItem (IDC_AVAILABLE_QUOTA_RECT)->GetWindowRect (oAvailableQuotaRect);
ScreenToClient (oAvailableQuotaRect);
m_AvailableQuotaText.Create (NULL,
_T("AvailableQuotaText"),
WS_CHILD,
oAvailableQuotaRect,
this,
IDC_AVAILABLE_QUOTA_RECT);
m_AvailableQuotaText.Init (RGB (0, 100, 50), true);
// Create Image Thumbnail List View
CRect rect;
CWnd* pListCtrlRef = GetDlgItem (IDC_IMAGE_THUMBNAIL_LC_REF);
pListCtrlRef->GetWindowRect (rect);
ScreenToClient (rect);
m_ImageListCtrl.Create (WS_CHILD | WS_VSCROLL | LVS_ICON | WS_VISIBLE | LVS_SINGLESEL, rect, this, IDC_IMAGE_THUMBNAIL_LC_REF);
// Show Thumbnails
m_ImageListCtrl.ShowImageThumbnails (lst_FileName);
// Store Image Data
int iItemIndex = 0;
while (lst_FileName.empty () == false)
{
CString sFileName = lst_FileName.front ();
CImageDetails* pImageDetails = new CImageDetails;
// Set File Name
pImageDetails->s_FileName = sFileName;
// Set File Name as the Title
CString sTitle = sFileName.Right (sFileName.GetLength() - sFileName.ReverseFind ('\\') - 1); // With the extension
pImageDetails->s_Title = sTitle.Left (sTitle.Find ('.')); // Without the extension
// Set File Size
pImageDetails->s_FileSize = GetFileSize (sFileName);
map_ImageDetailsByItemIndex.insert (make_pair (iItemIndex++, pImageDetails));
lst_FileName.pop_front ();
}
// Initialize Only Me Radio Button
m_OnlyMeRadioButton.SetEnable (true);
m_OnlyMeRadioButton.SetFamilyCheckBox (&m_FamilyCheckBox);
m_OnlyMeRadioButton.SetFriendsCheckBox (&m_FriendsCheckBox);
// Initialize Anyone Radio Button
m_AnyoneRadioButton.SetEnable (false);
m_AnyoneRadioButton.SetFamilyCheckBox (&m_FamilyCheckBox);
m_AnyoneRadioButton.SetFriendsCheckBox (&m_FriendsCheckBox);
// Initialize Sets Lists
m_SetsImageList.Create (16, 16, ILC_COLOR32 | ILC_MASK, 0, 4);
CBitmap bmListItem; // Existing Item
bmListItem.LoadBitmap (IDB_BITMAP_SET_LIST_ITEM);
m_SetsImageList.Add (&bmListItem, RGB(0, 0, 0));
CBitmap bmListItemNew; // New Item
bmListItemNew.LoadBitmap (IDB_BITMAP_SET_LIST_ITEM_NEW);
m_SetsImageList.Add (&bmListItemNew, RGB(0, 0, 0));
m_AvailableSetsListCtrl.SetImageList (&m_SetsImageList, LVSIL_SMALL);
m_AvailableSetsListCtrl.InsertColumn (0, _T(""), 0, 150);
m_AvailableSetsListCtrl.SetButton ((CButton*)GetDlgItem (IDC_BUTTON_ADD_SET));
m_AvailableSetsListCtrl.SetPhotoSetInfo (&map_PhotoSetInfoByName);
m_SelectedSetsListCtrl.SetImageList (&m_SetsImageList, LVSIL_SMALL);
m_SelectedSetsListCtrl.InsertColumn (0, _T(""), 0, 150);
m_SelectedSetsListCtrl.SetButton ((CButton*)GetDlgItem (IDC_BUTTON_REMOVE_SET));
// Initialize Animate Control
TCHAR zWindowsDirectory [MAX_PATH];
GetWindowsDirectory (zWindowsDirectory, MAX_PATH);
CString sAnimationFileName = zWindowsDirectory;
if (sAnimationFileName[sAnimationFileName.GetLength () - 1] != '\\')
sAnimationFileName+= '\\';
sAnimationFileName+= "upload.avi";
m_AnimateCtrl.Open (sAnimationFileName);
// Show Offline Message
ShowOfflineMessage ();
// Set Default Values
m_OnlyMeRadioButton.SetCheck (TRUE);
m_SafetyLevelCombo.SetCurSel (0);
m_HiddenCombo.SetCurSel (0);
m_ContentTypeCombo.SetCurSel (0);
// Disable Image Controls by Default
EnableImageControls (FALSE);
// Show Initial Help Message
ShowHelpText ();
// Create User Profile Restore Timer
SetTimer (TID_USER_PROFILE_RESTORE, 10, NULL);
return TRUE;
}
CMiniMap::CMiniMap()
: CInputReceiver(BACK),
fullProxy(false),
proxyMode(false),
selecting(false),
maxspect(false),
maximized(false),
minimized(false),
mouseLook(false),
mouseMove(false),
mouseResize(false),
slaveDrawMode(false),
showButtons(false),
useIcons(true)
{
lastWindowSizeX = globalRendering->viewSizeX;
lastWindowSizeY = globalRendering->viewSizeY;
if (globalRendering->dualScreenMode) {
width = globalRendering->viewSizeX;
height = globalRendering->viewSizeY;
xpos = (globalRendering->viewSizeX - globalRendering->viewPosX);
ypos = 0;
}
else {
const std::string geo = configHandler->GetString("MiniMapGeometry");
ParseGeometry(geo);
}
fullProxy = configHandler->GetBool("MiniMapFullProxy");
buttonSize = configHandler->GetInt("MiniMapButtonSize");
unitBaseSize = configHandler->GetFloat("MiniMapUnitSize");
unitExponent = configHandler->GetFloat("MiniMapUnitExp");
cursorScale = configHandler->GetFloat("MiniMapCursorScale");
useIcons = configHandler->GetBool("MiniMapIcons");
drawCommands = configHandler->GetInt("MiniMapDrawCommands");
drawProjectiles = configHandler->GetBool("MiniMapDrawProjectiles");
simpleColors = configHandler->GetBool("SimpleMiniMapColors");
myColor[0] = (unsigned char)(0.2f * 255);
myColor[1] = (unsigned char)(0.9f * 255);
myColor[2] = (unsigned char)(0.2f * 255);
myColor[3] = (unsigned char)(1.0f * 255);
allyColor[0] = (unsigned char)(0.3f * 255);
allyColor[1] = (unsigned char)(0.3f * 255);
allyColor[2] = (unsigned char)(0.9f * 255);
allyColor[3] = (unsigned char)(1.0f * 255);
enemyColor[0] = (unsigned char)(0.9f * 255);
enemyColor[1] = (unsigned char)(0.2f * 255);
enemyColor[2] = (unsigned char)(0.2f * 255);
enemyColor[3] = (unsigned char)(1.0f * 255);
UpdateGeometry();
circleLists = glGenLists(circleListsCount);
for (int cl = 0; cl < circleListsCount; cl++) {
glNewList(circleLists + cl, GL_COMPILE);
glBegin(GL_LINE_LOOP);
const int divs = (1 << (cl + 3));
for (int d = 0; d < divs; d++) {
const float rads = float(2.0 * PI) * float(d) / float(divs);
glVertex3f(math::sin(rads), 0.0f, math::cos(rads));
}
glEnd();
glEndList();
}
// setup the buttons' texture and texture coordinates
buttonsTexture = 0;
CBitmap bitmap;
bool unfiltered = false;
if (bitmap.Load("bitmaps/minimapbuttons.png")) {
if ((bitmap.ysize == buttonSize) && (bitmap.xsize == (buttonSize * 4))) {
unfiltered = true;
}
glGenTextures(1, &buttonsTexture);
glBindTexture(GL_TEXTURE_2D, buttonsTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
bitmap.xsize, bitmap.ysize, 0,
GL_RGBA, GL_UNSIGNED_BYTE, bitmap.mem);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
if (unfiltered) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
} else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
glBindTexture(GL_TEXTURE_2D, 0);
}
const float xshift = unfiltered ? 0.0f : (0.5f / bitmap.xsize);
const float yshift = unfiltered ? 0.0f : (0.5f / bitmap.ysize);
moveBox.xminTx = 0.50f + xshift;
moveBox.xmaxTx = 0.75f - xshift;
resizeBox.xminTx = 0.75f + xshift;
resizeBox.xmaxTx = 1.00f - xshift;
minimizeBox.xminTx = 0.00f + xshift;
minimizeBox.xmaxTx = 0.25f - xshift;
maximizeBox.xminTx = 0.25f + xshift;
maximizeBox.xmaxTx = 0.50f - xshift;
moveBox.yminTx = 1.00f - yshift;
resizeBox.yminTx = 1.00f - yshift;
minimizeBox.yminTx = 1.00f - yshift;
maximizeBox.yminTx = 1.00f - yshift;
moveBox.ymaxTx = 0.00f + yshift;
resizeBox.ymaxTx = 0.00f + yshift;
minimizeBox.ymaxTx = 0.00f + yshift;
maximizeBox.ymaxTx = 0.00f + yshift;
}
void CMenuItem::DrawHotKeyString (int bIsCurrent, int bTiny, int bCreateTextBms, int nDepth)
{
CBitmap *bmP = m_bmText [bIsCurrent];
if (!*m_text)
return;
if (m_color)
fontManager.SetColorRGBi (m_color, 1, 0, 0);
else
SetColor (bIsCurrent, bTiny);
if (bCreateTextBms && FAST_MENUS &&
(bmP || (bmP = CreateStringBitmap (m_text, MENU_KEY (m_nKey, - 1), gameData.menu.keyColor, nTabs, m_bCentered, m_w, 0)))) {
bmP->Render (CCanvas::Current (), m_x, m_y, bmP->Width (), bmP->Height (), 0, 0, bmP->Width (), bmP->Height (), 1, 0);
m_bmText [bIsCurrent] = bmP;
}
else {
int w, h, aw, l, i,
x = m_x,
y = m_y;
char *t, *ps = m_text, s [MENU_MAX_TEXTLEN], ch = 0, ch2;
if ((t = strchr (ps, '\n'))) {
strncpy (s, ps, sizeof (s));
SetText (s);
fontManager.Current ()->StringSize (s, w, h, aw);
do {
if ((t = strchr (m_text, '\n')))
*t = '\0';
DrawHotKeyString (0, bTiny, 0, nDepth + 1);
if (!t)
break;
SetText (t + 1);
m_y += h / 2;
m_x = m_xSave;
nTabIndex = -1;
} while (*(m_text));
}
else if ((t = strchr (ps, '\t'))) {
strncpy (s, ps, sizeof (s));
SetText (s);
fontManager.Current ()->StringSize (s, w, h, aw);
do {
if ((t = strchr (m_text, '\t')))
*t = '\0';
DrawHotKeyString (0, bTiny, 0, nDepth + 1);
if (!t)
break;
SetText (t + 1);
nTabIndex++;
} while (*(m_text));
nTabIndex = -1;
SetText (ps);
m_y = y;
}
else {
l = (int) strlen (m_text);
if (bIsCurrent || !m_nKey)
i = l;
else {
ch = MENU_KEY (m_nKey, *ps);
for (i = 0; ps [i]; i++)
if (ps [i] == ch)
break;
}
strncpy (s, ps, sizeof (s));
s [i] = '\0';
fontManager.Current ()->StringSize (s, w, h, aw);
if (nTabIndex >= 0) {
x += LHX (nTabs [nTabIndex]);
if (!gameStates.multi.bSurfingNet)
x += m_w - w;
}
//m_x = x + w;
if (i) {
GrString (x, y, s, NULL);
#if DBG
//GrUpdate (0);
#endif
}
if (i < l) { // print the hotkey
x += w;
s [i] = ch;
ch2 = s [++i];
s [i] = '\0';
SetColor (1, bTiny);
GrString (x, y, s + i - 1, NULL);
#if DBG
//GrUpdate (0);
#endif
SetColor (0, bTiny);
if (i < l) { // print text following the hotkey
fontManager.Current ()->StringSize (s + i - 1, w, h, aw);
x += w;
s [i] = ch2;
GrString (x, y, s + i, NULL);
}
}
}
}
}
void CUnitDefHandler::ParseTAUnit(std::string file, int id)
{
CSunParser sunparser;
sunparser.LoadFile(file);
UnitDef& ud=unitDefs[id];
ud.name = sunparser.SGetValueMSG("UNITINFO\\UnitName");
ud.humanName = sunparser.SGetValueMSG("UNITINFO\\name");
sunparser.GetDef(ud.extractsMetal, "0", "UNITINFO\\ExtractsMetal");
sunparser.GetDef(ud.windGenerator, "0", "UNITINFO\\WindGenerator");
sunparser.GetDef(ud.tidalGenerator, "0", "UNITINFO\\TidalGenerator");
ud.health=atof(sunparser.SGetValueDef("0", "UNITINFO\\MaxDamage").c_str());
ud.metalUpkeep=atof(sunparser.SGetValueDef("0", "UNITINFO\\MetalUse").c_str());
ud.energyUpkeep=atof(sunparser.SGetValueDef("0", "UNITINFO\\EnergyUse").c_str());
ud.metalMake=atof(sunparser.SGetValueDef("0", "UNITINFO\\MetalMake").c_str());
ud.makesMetal=atof(sunparser.SGetValueDef("0", "UNITINFO\\MakesMetal").c_str());
ud.energyMake=atof(sunparser.SGetValueDef("0", "UNITINFO\\EnergyMake").c_str());
ud.metalStorage=atof(sunparser.SGetValueDef("0", "UNITINFO\\MetalStorage").c_str());
ud.energyStorage=atof(sunparser.SGetValueDef("0", "UNITINFO\\EnergyStorage").c_str());
ud.isMetalMaker=(ud.makesMetal>=1 && ud.energyUpkeep>ud.makesMetal*40);
ud.controlRadius=32;
ud.losHeight=20;
ud.metalCost=atof(sunparser.SGetValueDef("0", "UNITINFO\\BuildCostMetal").c_str());
if(ud.metalCost<1) //avoid some nasty divide by 0 etc
ud.metalCost=1;
ud.mass=atof(sunparser.SGetValueDef("0", "UNITINFO\\Mass").c_str());
if(ud.mass<=0)
ud.mass=ud.metalCost;
ud.energyCost=atof(sunparser.SGetValueDef("0", "UNITINFO\\BuildCostEnergy").c_str());
ud.buildTime=atof(sunparser.SGetValueDef("0", "UNITINFO\\BuildTime").c_str());
if(ud.buildTime<1) //avoid some nasty divide by 0 etc
ud.buildTime=1;
ud.aihint=id; //fix
ud.losRadius=atof(sunparser.SGetValueDef("0", "UNITINFO\\SightDistance").c_str());
ud.airLosRadius=atof(sunparser.SGetValueDef("0", "UNITINFO\\SightDistance").c_str())*1.5;
ud.tooltip=sunparser.SGetValueDef(ud.name,"UNITINFO\\Description");
ud.moveType=0;
sunparser.GetDef(ud.canfly, "0", "UNITINFO\\canfly");
sunparser.GetDef(ud.canmove, "0", "UNITINFO\\canmove");
sunparser.GetDef(ud.builder, "0", "UNITINFO\\Builder");
sunparser.GetDef(ud.upright, "0", "UNITINFO\\Upright");
sunparser.GetDef(ud.onoffable, "0", "UNITINFO\\onoffable");
sunparser.GetDef(ud.maxSlope, "0", "UNITINFO\\MaxSlope");
ud.maxHeightDif=40*tan(ud.maxSlope*(PI/180));
ud.maxSlope = cos(ud.maxSlope*(PI/180));
sunparser.GetDef(ud.minWaterDepth, "-10e6", "UNITINFO\\MinWaterDepth");
sunparser.GetDef(ud.maxWaterDepth, "10e6", "UNITINFO\\MaxWaterDepth");
std::string value;
ud.floater = sunparser.SGetValue(value, "UNITINFO\\Waterline");
sunparser.GetDef(ud.waterline, "0", "UNITINFO\\Waterline");
if(ud.waterline>8 && ud.canmove)
ud.waterline+=5; //make subs travel at somewhat larger depths to reduce vulnerability to surface weapons
sunparser.GetDef(ud.selfDCountdown, "5", "UNITINFO\\selfdestructcountdown");
ud.speed=atof(sunparser.SGetValueDef("0", "UNITINFO\\MaxVelocity").c_str())*30;
ud.maxAcc=atof(sunparser.SGetValueDef("0.5", "UNITINFO\\acceleration").c_str());
ud.maxDec=atof(sunparser.SGetValueDef("0.5", "UNITINFO\\BrakeRate").c_str())*0.1;
ud.turnRate=atof(sunparser.SGetValueDef("0", "UNITINFO\\TurnRate").c_str());
ud.buildSpeed=atof(sunparser.SGetValueDef("0", "UNITINFO\\WorkerTime").c_str());
ud.buildDistance=atof(sunparser.SGetValueDef("64", "UNITINFO\\Builddistance").c_str());
ud.buildDistance=max(128,ud.buildDistance);
ud.armoredMultiple=atof(sunparser.SGetValueDef("1", "UNITINFO\\DamageModifier").c_str());
ud.armorType=damageArrayHandler->GetTypeFromName(ud.name);
// info->AddLine("unit %s has armor %i",ud.name.c_str(),ud.armorType);
ud.radarRadius=atoi(sunparser.SGetValueDef("0", "UNITINFO\\RadarDistance").c_str());
ud.sonarRadius=atoi(sunparser.SGetValueDef("0", "UNITINFO\\SonarDistance").c_str());
ud.jammerRadius=atoi(sunparser.SGetValueDef("0", "UNITINFO\\RadarDistanceJam").c_str());
ud.sonarJamRadius=atoi(sunparser.SGetValueDef("0", "UNITINFO\\SonarDistanceJam").c_str());
ud.stealth=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\Stealth").c_str());
ud.targfac=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\istargetingupgrade").c_str());
ud.isFeature=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\IsFeature").c_str());
ud.canResurrect=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\canResurrect").c_str());
ud.canCapture=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\canCapture").c_str());
ud.hideDamage=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\HideDamage").c_str());
ud.isCommander=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\commander").c_str());
ud.cloakCost=atof(sunparser.SGetValueDef("-1", "UNITINFO\\CloakCost").c_str());
ud.cloakCostMoving=atof(sunparser.SGetValueDef("-1", "UNITINFO\\CloakCostMoving").c_str());
if(ud.cloakCostMoving<0)
ud.cloakCostMoving=ud.cloakCost;
if(ud.cloakCost>=0)
ud.canCloak=true;
else
ud.canCloak=false;
ud.startCloaked=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\init_cloaked").c_str());
ud.decloakDistance=atof(sunparser.SGetValueDef("-1", "UNITINFO\\mincloakdistance").c_str());
ud.highTrajectoryType=atoi(sunparser.SGetValueDef("0", "UNITINFO\\HighTrajectory").c_str());
ud.canKamikaze=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\kamikaze").c_str());
ud.kamikazeDist=atof(sunparser.SGetValueDef("-25", "UNITINFO\\kamikazedistance").c_str())+25; //we count 3d distance while ta count 2d distance so increase slightly
sunparser.GetDef(ud.canfly, "0", "UNITINFO\\canfly");
sunparser.GetDef(ud.canmove, "0", "UNITINFO\\canmove");
sunparser.GetDef(ud.canhover, "0", "UNITINFO\\canhover");
if(sunparser.SGetValue(value, "UNITINFO\\floater"))
sunparser.GetDef(ud.floater, "0", "UNITINFO\\floater");
sunparser.GetDef(ud.builder, "0", "UNITINFO\\Builder");
if(ud.builder && !ud.buildSpeed) //core anti is flagged as builder for some reason
ud.builder=false;
ud.wantedHeight=atof(sunparser.SGetValueDef("0", "UNITINFO\\cruisealt").c_str())*1.5;
ud.hoverAttack = !!atoi(sunparser.SGetValueDef("0", "UNITINFO\\hoverattack").c_str());
sunparser.GetDef(ud.transportSize, "0", "UNITINFO\\transportsize");
sunparser.GetDef(ud.transportCapacity, "0", "UNITINFO\\transportcapacity");
ud.isAirBase=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\isAirBase").c_str());
ud.stunnedCargo=!ud.isAirBase;
ud.loadingRadius=220;
sunparser.GetDef(ud.transportMass, "100000", "UNITINFO\\TransportMass");
sunparser.GetDef(ud.wingDrag, "0.07", "UNITINFO\\WingDrag"); //drag caused by wings
sunparser.GetDef(ud.wingAngle, "0.08", "UNITINFO\\WingAngle"); //angle between front and the wing plane
sunparser.GetDef(ud.drag, "0.005", "UNITINFO\\Drag"); //how fast the aircraft loses speed (see also below)
sunparser.GetDef(ud.frontToSpeed, "0.1", "UNITINFO\\frontToSpeed"); //fudge factor for lining up speed and front of plane
sunparser.GetDef(ud.speedToFront, "0.07", "UNITINFO\\speedToFront");//fudge factor for lining up speed and front of plane
sunparser.GetDef(ud.myGravity, "0.4", "UNITINFO\\myGravity"); //planes are slower than real airplanes so lower gravity to compensate
sunparser.GetDef(ud.maxBank, "0.8", "UNITINFO\\maxBank"); //max roll
sunparser.GetDef(ud.maxPitch, "0.45", "UNITINFO\\maxPitch"); //max pitch this plane tries to keep
sunparser.GetDef(ud.turnRadius, "500", "UNITINFO\\turnRadius"); //hint to the ai about how large turn radius this plane needs
sunparser.GetDef(ud.maxAileron, "0.015", "UNITINFO\\maxAileron"); //turn speed around roll axis
sunparser.GetDef(ud.maxElevator, "0.01", "UNITINFO\\maxElevator"); //turn speed around pitch axis
sunparser.GetDef(ud.maxRudder, "0.004", "UNITINFO\\maxRudder"); //turn speed around yaw axis
ud.categoryString=sunparser.SGetValueDef("", "UNITINFO\\Category");
ud.category=CCategoryHandler::Instance()->GetCategories(sunparser.SGetValueDef("", "UNITINFO\\Category"));
ud.noChaseCategory=CCategoryHandler::Instance()->GetCategories(sunparser.SGetValueDef("", "UNITINFO\\NoChaseCategory"));
// info->AddLine("Unit %s has cat %i",ud.humanName.c_str(),ud.category);
for(int a=0;a<16;++a){
char c[50];
sprintf(c,"%i",a+1);
string name;
sunparser.GetDef(name, "", std::string("UNITINFO\\")+"weapon"+c);
WeaponDef *wd = weaponDefHandler->GetWeapon(name);
if(!wd){
if(a>2) //allow empty weapons among the first 3
break;
else
continue;
}
while(ud.weapons.size()<a){
if(!weaponDefHandler->GetWeapon("NOWEAPON")) {
info->AddLine("Error: Spring requires a NOWEAPON weapon type to be present as a placeholder for missing weapons");
break;
} else
ud.weapons.push_back(UnitDef::UnitDefWeapon("NOWEAPON",weaponDefHandler->GetWeapon("NOWEAPON"),0,float3(0,0,1),-1,0,0));
}
string badTarget;
sunparser.GetDef(badTarget, "", std::string("UNITINFO\\") + "badTargetCategory"+c);
unsigned int btc=CCategoryHandler::Instance()->GetCategories(badTarget);
if(a<3){
switch(a){
case 0:
sunparser.GetDef(badTarget, "", std::string("UNITINFO\\") + "wpri_badTargetCategory");
break;
case 1:
sunparser.GetDef(badTarget, "", std::string("UNITINFO\\") + "wsec_badTargetCategory");
break;
case 2:
sunparser.GetDef(badTarget, "", std::string("UNITINFO\\") + "wspe_badTargetCategory");
break;
}
btc|=CCategoryHandler::Instance()->GetCategories(badTarget);
}
string onlyTarget;
sunparser.GetDef(onlyTarget, "", std::string("UNITINFO\\") + "onlyTargetCategory"+c);
unsigned int otc;
if(!onlyTarget.empty())
otc=CCategoryHandler::Instance()->GetCategories(onlyTarget);
else
otc=0xffffffff;
unsigned int slaveTo=atoi(sunparser.SGetValueDef("0", string("UNITINFO\\WeaponSlaveTo")+c).c_str());
float3 mainDir=sunparser.GetFloat3(float3(1,0,0),string("UNITINFO\\WeaponMainDir")+c);
mainDir.Normalize();
float angleDif=cos(atof(sunparser.SGetValueDef("360", string("UNITINFO\\MaxAngleDif")+c).c_str())*PI/360);
ud.weapons.push_back(UnitDef::UnitDefWeapon(name,wd,slaveTo,mainDir,angleDif,btc,otc));
}
sunparser.GetDef(ud.canDGun, "0", "UNITINFO\\candgun");
string TEDClass=sunparser.SGetValueDef("0", "UNITINFO\\TEDClass").c_str();
ud.TEDClassString=TEDClass;
if(ud.extractsMetal) {
ud.extractRange = readmap->extractorRadius;
ud.type = "MetalExtractor";
}
else if(ud.transportCapacity)
{
ud.type = "Transport";
}
else if(ud.builder)
{
if(TEDClass!="PLANT")
ud.type = "Builder";
else
ud.type = "Factory";
}
else if(ud.canfly && !ud.hoverAttack)
{
if(!ud.weapons.empty() && ud.weapons[0].def!=0 && (ud.weapons[0].def->type=="AircraftBomb" || ud.weapons[0].def->type=="TorpedoLauncher")){
ud.type = "Bomber";
if(ud.turnRadius==500) //only reset it if user hasnt set it explicitly
ud.turnRadius=800; //hint to the ai about how large turn radius this plane needs
} else {
ud.type = "Fighter";
}
sunparser.GetDef(ud.maxAcc, "0.065", "UNITINFO\\maxAcc"); //engine power
}
else if(ud.canmove)
{
ud.type = "GroundUnit";
}
else
{
ud.type = "Building";
}
ud.movedata=0;
if(ud.canmove && !ud.canfly && ud.type!="Factory"){
string moveclass=sunparser.SGetValueDef("", "UNITINFO\\MovementClass");
ud.movedata=moveinfo->GetMoveDataFromName(moveclass);
if(ud.movedata->moveType==MoveData::Hover_Move || ud.movedata->moveType==MoveData::Ship_Move){
ud.upright=true;
}
if(ud.canhover){
if(ud.movedata->moveType!=MoveData::Hover_Move){
info->AddLine("Inconsistant move data hover %i %s %s",ud.movedata->pathType,ud.humanName.c_str(),moveclass.c_str());
}
} else if(ud.floater){
if(ud.movedata->moveType!=MoveData::Ship_Move){
info->AddLine("Inconsistant move data ship %i %s %s",ud.movedata->pathType,ud.humanName.c_str(),moveclass.c_str());
}
} else {
if(ud.movedata->moveType!=MoveData::Ground_Move){
info->AddLine("Inconsistant move data ground %i %s %s",ud.movedata->pathType,ud.humanName.c_str(),moveclass.c_str());
}
}
// info->AddLine("%s uses movetype %i",ud.humanName.c_str(),ud.movedata->pathType);
}
if(ud.maxAcc!=0 && ud.speed!=0)
ud.drag=1.0/(ud.speed/GAME_SPEED*1.1/ud.maxAcc)-ud.wingAngle*ud.wingAngle*ud.wingDrag; //meant to set the drag such that the maxspeed becomes what it should be
std::string objectname;
sunparser.GetDef(objectname, "", "UNITINFO\\Objectname");
ud.model.modelpath = "objects3d\\" + objectname + ".3do";
ud.model.modelname = objectname;
sunparser.GetDef(ud.wreckName, "", "UNITINFO\\Corpse");
sunparser.GetDef(ud.deathExplosion, "", "UNITINFO\\ExplodeAs");
sunparser.GetDef(ud.selfDExplosion, "", "UNITINFO\\SelfDestructAs");
string buildpic;
sunparser.GetDef(buildpic, "", "UNITINFO\\BuildPic");
if(buildpic.empty())
{
//try pcx first and then bmp if no pcx exist
CFileHandler bfile("unitpics\\" + ud.name + ".pcx");
if(bfile.FileExists())
{
CBitmap bitmap("unitpics\\" + ud.name + ".pcx");
ud.unitimage = bitmap.CreateTexture(false);
}
else
{
CFileHandler bfile("unitpics\\" + ud.name + ".bmp");
if(bfile.FileExists()){
CBitmap bitmap("unitpics\\" + ud.name + ".bmp");
ud.unitimage = bitmap.CreateTexture(false);
} else {
CBitmap bitmap;
ud.unitimage = bitmap.CreateTexture(false);
}
}
}
else
{
CBitmap bitmap("unitpics\\" + buildpic);
ud.unitimage = bitmap.CreateTexture(false);
}
ud.power = (ud.metalCost + ud.energyCost/60.0f);
sunparser.GetDef(ud.activateWhenBuilt, "0", "UNITINFO\\ActivateWhenBuilt");
ud.xsize=atoi(sunparser.SGetValueDef("1", "UNITINFO\\FootprintX").c_str())*2;//ta has only half our res so multiply size with 2
ud.ysize=atoi(sunparser.SGetValueDef("1", "UNITINFO\\FootprintZ").c_str())*2;
ud.needGeo=false;
if(ud.type=="Building" || ud.type=="Factory"){
CreateYardMap(&ud, sunparser.SGetValueDef("c", "UNITINFO\\YardMap"));
} else {
ud.yardmap = 0;
}
ud.leaveTracks=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\LeaveTracks").c_str());
ud.trackWidth=atof(sunparser.SGetValueDef("32", "UNITINFO\\TrackWidth").c_str());
ud.trackOffset=atof(sunparser.SGetValueDef("0", "UNITINFO\\TrackOffset").c_str());
ud.trackStrength=atof(sunparser.SGetValueDef("0", "UNITINFO\\TrackStrength").c_str());
ud.trackStretch=atof(sunparser.SGetValueDef("1", "UNITINFO\\TrackStretch").c_str());
if(ud.leaveTracks && groundDecals)
ud.trackType=groundDecals->GetTrackType(sunparser.SGetValueDef("StdTank", "UNITINFO\\TrackType"));
ud.canDropFlare=!!atoi(sunparser.SGetValueDef("0", "UNITINFO\\CanDropFlare").c_str());
ud.flareReloadTime=atof(sunparser.SGetValueDef("5", "UNITINFO\\FlareReload").c_str());
ud.flareEfficieny=atof(sunparser.SGetValueDef("0.5", "UNITINFO\\FlareEfficiency").c_str());
ud.flareDelay=atof(sunparser.SGetValueDef("0.3", "UNITINFO\\FlareDelay").c_str());
ud.flareDropVector=sunparser.GetFloat3(ZeroVector,"UNITINFO\\FlareDropVector");
ud.flareTime=atof(sunparser.SGetValueDef("3", "UNITINFO\\FlareTime").c_str())*30;
ud.flareSalvoSize=atoi(sunparser.SGetValueDef("4", "UNITINFO\\FlareSalvoSize").c_str());
ud.flareSalvoDelay=atof(sunparser.SGetValueDef("0.1", "UNITINFO\\FlareSalvoDelay").c_str())*30;
ud.smoothAnim = !!atoi(sunparser.SGetValueDef("0", "UNITINFO\\SmoothAnim").c_str());
LoadSound(sunparser, ud.sounds.ok, "ok1");
LoadSound(sunparser, ud.sounds.select, "select1");
LoadSound(sunparser, ud.sounds.arrived, "arrived1");
LoadSound(sunparser, ud.sounds.build, "build");
LoadSound(sunparser, ud.sounds.activate, "activate");
LoadSound(sunparser, ud.sounds.deactivate, "deactivate");
LoadSound(sunparser, ud.sounds.cant, "cant");
LoadSound(sunparser, ud.sounds.underattack, "underattack");
}
///////////////////////////////////////////////////////////////////////////////
// Name: SetLed
// Description: This method will draw the LED to the specified DC.
//
// Entry:
// CDC *pDC - DC to draw to
//
// int iLedColor - Where color is defined by:
// LED_COLOR_RED
// LED_COLOR_GREEN
// LED_COLOR_YELLOW
// LED_COLOR_BLUE
//
// int iMode - where mode is defined by:
// LED_ON
// LED_OFF
// LED_DISABLED
//
// int iShape - where shape is defined by:
// LED_ROUND
// LED_SQUARE
///////////////////////////////////////////////////////////////////////////////
void CLed::DrawLed(CDC *pDC,int nLEDColor, int nMode, int nShape)
{
CRect rect;
GetClientRect(&rect);
//
// Center led within an oversized window
//
if(rect.Width() >= LED_SIZE && rect.Height() >= LED_SIZE)
{
int nWidth = rect.Width();
int nHeight = rect.Height();
rect.left += (nWidth - LED_SIZE)/2;
rect.right -= (nWidth - LED_SIZE)/2;
rect.top += (nHeight - LED_SIZE)/2;
rect.bottom -= (nHeight - LED_SIZE)/2;
}
//
// Prepare temporary DCs and bitmaps
//
CBitmap TransBitmap;
TransBitmap.CreateBitmap(LED_SIZE,LED_SIZE,1,1,NULL);
CBitmap bitmapTemp;
CBitmap* pBitmap = &m_LedBitmap;
CDC srcDC;
CDC dcMask;
CDC TempDC;
TempDC.CreateCompatibleDC(pDC);
srcDC.CreateCompatibleDC(pDC);
dcMask.CreateCompatibleDC(pDC);
CBitmap* pOldBitmap = srcDC.SelectObject(pBitmap);
CBitmap* pOldMaskbitmap = dcMask.SelectObject(&TransBitmap);
bitmapTemp.CreateCompatibleBitmap(pDC,LED_SIZE,LED_SIZE);
//
// Work with tempDC and bitmapTemp to reduce flickering
//
CBitmap *pOldBitmapTemp = TempDC.SelectObject(&bitmapTemp);
TempDC.BitBlt(0, 0, LED_SIZE, LED_SIZE, pDC, rect.left, rect.top, SRCCOPY);
//
// Create mask
//
COLORREF OldBkColor = srcDC.SetBkColor(RGB(255,0,255));
dcMask.BitBlt(0, 0, LED_SIZE, LED_SIZE,&srcDC, nMode*LED_SIZE, nLEDColor+nShape, SRCCOPY);
TempDC.SetBkColor(OldBkColor);
//
// Using the IDB_LEDS bitmap, index into the bitmap for the appropriate
// LED. By using the mask color (RGB(255,0,255)) a mask has been created
// so the bitmap will appear transparent.
//
TempDC.BitBlt(0, 0, LED_SIZE, LED_SIZE, &srcDC, nMode*LED_SIZE, nLEDColor+nShape, SRCINVERT);
TempDC.BitBlt(0, 0, LED_SIZE, LED_SIZE,&dcMask, 0, 0, SRCAND);
TempDC.BitBlt(0, 0, LED_SIZE, LED_SIZE, &srcDC, nMode*LED_SIZE, nLEDColor+nShape, SRCINVERT);
//
// Since the actual minipulation is done to tempDC so there is minimal
// flicker, it is now time to draw the result to the screen.
//
pDC->BitBlt(rect.left, rect.top, LED_SIZE, LED_SIZE, &TempDC, 0, 0, SRCCOPY);
//
// House cleaning
//
srcDC.SelectObject(pOldBitmap);
dcMask.SelectObject(pOldMaskbitmap);
TempDC.SelectObject(pOldBitmapTemp);
VERIFY(srcDC.DeleteDC());
VERIFY(dcMask.DeleteDC());
VERIFY(TempDC.DeleteDC());
VERIFY(TransBitmap.DeleteObject());
VERIFY(bitmapTemp.DeleteObject());
}
void AFX_GLOBAL_DATA::UpdateSysColors()
{
m_bIsBlackHighContrast = ::GetSysColor(COLOR_3DLIGHT) == RGB(255, 255, 255) && ::GetSysColor(COLOR_3DFACE) == RGB(0, 0, 0);
m_bIsWhiteHighContrast = ::GetSysColor(COLOR_3DDKSHADOW) == RGB(0, 0, 0) && ::GetSysColor(COLOR_3DFACE) == RGB(255, 255, 255);
CWindowDC dc(NULL);
m_nBitsPerPixel = dc.GetDeviceCaps(BITSPIXEL);
clrBarFace = clrBtnFace = ::GetSysColor(COLOR_BTNFACE);
clrBarShadow = clrBtnShadow = ::GetSysColor(COLOR_BTNSHADOW);
clrBarDkShadow = clrBtnDkShadow = ::GetSysColor(COLOR_3DDKSHADOW);
clrBarLight = clrBtnLight = ::GetSysColor(COLOR_3DLIGHT);
clrBarHilite = clrBtnHilite = ::GetSysColor(COLOR_BTNHIGHLIGHT);
clrBarText = clrBtnText = ::GetSysColor(COLOR_BTNTEXT);
clrGrayedText = ::GetSysColor(COLOR_GRAYTEXT);
clrWindowFrame = ::GetSysColor(COLOR_WINDOWFRAME);
clrHilite = ::GetSysColor(COLOR_HIGHLIGHT);
clrTextHilite = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
clrBarWindow = clrWindow = ::GetSysColor(COLOR_WINDOW);
clrWindowText = ::GetSysColor(COLOR_WINDOWTEXT);
clrCaptionText = ::GetSysColor(COLOR_CAPTIONTEXT);
clrMenuText = ::GetSysColor(COLOR_MENUTEXT);
clrActiveCaption = ::GetSysColor(COLOR_ACTIVECAPTION);
clrInactiveCaption = ::GetSysColor(COLOR_INACTIVECAPTION);
clrActiveCaptionGradient = ::GetSysColor(COLOR_GRADIENTACTIVECAPTION);
clrInactiveCaptionGradient = ::GetSysColor(COLOR_GRADIENTINACTIVECAPTION);
clrActiveBorder = ::GetSysColor(COLOR_ACTIVEBORDER);
clrInactiveBorder = ::GetSysColor(COLOR_INACTIVEBORDER);
clrInactiveCaptionText = ::GetSysColor(COLOR_INACTIVECAPTIONTEXT);
if (m_bIsBlackHighContrast)
{
clrHotLinkNormalText = clrWindowText;
clrHotLinkHoveredText = clrWindowText;
clrHotLinkVisitedText = clrWindowText;
}
else
{
clrHotLinkNormalText = ::GetSysColor(COLOR_HOTLIGHT);
clrHotLinkHoveredText = RGB(0, 0, 255); // Bright blue
clrHotLinkVisitedText = RGB(128, 0, 128); // Violet
}
hbrBtnShadow = ::GetSysColorBrush(COLOR_BTNSHADOW);
ENSURE(hbrBtnShadow != NULL);
hbrBtnHilite = ::GetSysColorBrush(COLOR_BTNHIGHLIGHT);
ENSURE(hbrBtnHilite != NULL);
hbrWindow = ::GetSysColorBrush(COLOR_WINDOW);
ENSURE(hbrWindow != NULL);
brBtnFace.DeleteObject();
brBtnFace.CreateSolidBrush(clrBtnFace);
brBarFace.DeleteObject();
brBarFace.CreateSolidBrush(clrBarFace);
brActiveCaption.DeleteObject();
brActiveCaption.CreateSolidBrush(clrActiveCaption);
brInactiveCaption.DeleteObject();
brInactiveCaption.CreateSolidBrush(clrInactiveCaption);
brHilite.DeleteObject();
brHilite.CreateSolidBrush(clrHilite);
brBlack.DeleteObject();
brBlack.CreateSolidBrush(clrBtnDkShadow);
brWindow.DeleteObject();
brWindow.CreateSolidBrush(clrWindow);
penHilite.DeleteObject();
penHilite.CreatePen(PS_SOLID, 1, afxGlobalData.clrHilite);
penBarFace.DeleteObject();
penBarFace.CreatePen(PS_SOLID, 1, afxGlobalData.clrBarFace);
penBarShadow.DeleteObject();
penBarShadow.CreatePen(PS_SOLID, 1, afxGlobalData.clrBarShadow);
if (brLight.GetSafeHandle())
{
brLight.DeleteObject();
}
if (m_nBitsPerPixel > 8)
{
COLORREF clrLight = RGB(GetRValue(clrBtnFace) +((GetRValue(clrBtnHilite) - GetRValue(clrBtnFace)) / 2 ),
GetGValue(clrBtnFace) +((GetGValue(clrBtnHilite) - GetGValue(clrBtnFace)) / 2),
GetBValue(clrBtnFace) +((GetBValue(clrBtnHilite) - GetBValue(clrBtnFace)) / 2));
brLight.CreateSolidBrush(clrLight);
}
else
{
HBITMAP hbmGray = CreateDitherBitmap(dc.GetSafeHdc());
ENSURE(hbmGray != NULL);
CBitmap bmp;
bmp.Attach(hbmGray);
brLight.CreatePatternBrush(&bmp);
}
// CMenuImages::CleanUp();
// CDockingManager::m_bSDParamsModified = TRUE;
}
void ColorPicker::OnPaint()
{
// Setup a backbuffer:
CPaintDC dcPaint(this);
CDC dc;
dc.CreateCompatibleDC(&dcPaint);
CRect rectClient;
GetClientRect(rectClient);
CBitmap bitmap;
bitmap.CreateCompatibleBitmap(&dcPaint, rectClient.Width(), rectClient.Height());
CBitmap *oldBitmap = dc.SelectObject(&bitmap);
// Fill background first
CBrush bgBrush(GetSysColor(COLOR_BTNFACE));
dc.FillRect(&rectClient, &bgBrush);
// Draw a border:
dc.Draw3dRect
(
0,
0,
rectClient.Width(),
rectClient.Height(),
RGB(0, 0, 0),
RGB(0, 0, 0)
);
if (hueBarDirty_)
generateHueBar();
if (alphaBarDirty_ || (!alphaSelection_ && slGraphDirty_))
generateAlphaBar();
if (slGraphDirty_)
generatePicker();
if (slPickerDirty_)
setPicker(false);
dc.BitBlt
(
slGraphRect_.left,
slGraphRect_.top,
slGraphRect_.Width(),
slGraphRect_.Height(),
pickerDC_,
0,
0,
SRCCOPY
);
dc.BitBlt
(
hueBarRect_.left,
hueBarRect_.top,
hueBarRect_.Width(),
hueBarRect_.Height(),
hueBarDC_,
0,
0,
SRCCOPY
);
dc.BitBlt
(
alphaBarRect_.left,
alphaBarRect_.top,
alphaBarRect_.Width(),
alphaBarRect_.Height(),
alphaBarDC_,
0,
0,
SRCCOPY
);
// Draw sl picker:
CSize sz(6, 6);
drawCrossAt
(
slPickerPosition_,
dc,
sz
);
// Draw hue indicator:
sz.cx = hueBarRect_.Width();
sz.cy = 6;
CPoint
pt
(
slGraphRect_.Width() + c_spacer_ + hueBarRect_.Width()/2 + c_borderSpace_,
(int)(currentHue_*hueBarRect_.Height()) + c_borderSpace_
);
drawCrossAt(pt, dc, sz);
if (alphaSelection_)
{
// Draw alpha indicator:
sz.cx = 6;
sz.cy = alphaBarRect_.Height();
pt =
CPoint
(
(int)(currentAlpha_ * alphaBarRect_.Width()) + c_borderSpace_,
(int)(slGraphRect_.Height() + c_spacer_ + alphaBarRect_.Height()/2) + c_borderSpace_
);
drawCrossAt(pt, dc, sz);
}
// Draw the backbuffer:
dcPaint.BitBlt
(
rectClient.left,
rectClient.top,
rectClient.Width(),
rectClient.Height(),
&dc,
0,
0,
SRCCOPY
);
dc.SelectObject(oldBitmap);
dc.DeleteDC();
bitmap.DeleteObject();
}
void CTipDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
if( cxIcon == 16 && cyIcon == 16 )
{
dc.DrawIcon( x, y, theApp.hMainIconSmall );
}
else
{
dc.DrawIcon( x, y, theApp.hMainIconBig );
}
return;
}
CPaintDC dc(this); // device context for painting
// Get paint area for the big static control
CWnd* pStatic = GetDlgItem(IDC_FRAME_INTERNAL);
CRect rect;
pStatic->GetWindowRect(&rect);
ScreenToClient(&rect);
// Paint the background white.
CBrush brush;
brush.CreateStockObject(WHITE_BRUSH);
dc.FillRect(rect, &brush);
// Load bitmap and get dimensions of the bitmap
CBitmap bmp;
bmp.LoadBitmap(IDB_LIGHTBULB);
BITMAP bmpInfo;
ZeroMemory( &bmpInfo, sizeof(bmpInfo) );
bmp.GetBitmap(&bmpInfo);
// Draw bitmap in top corner and validate only top portion of window
CDC dcTmp;
dcTmp.CreateCompatibleDC(&dc);
dcTmp.SelectObject(&bmp);
rect.bottom = bmpInfo.bmHeight + rect.top;
dc.BitBlt(rect.left, rect.top, rect.Width(), rect.Height(),
&dcTmp, 0, 0, SRCCOPY);
// Draw out "Did you know..." message next to the bitmap
CString strMessage;
strMessage = LocLoadString(IDS_TIPS_DIDYOUKNOW);
rect.left += bmpInfo.bmWidth;
dc.SetBkMode( TRANSPARENT );
dc.DrawText(strMessage, rect, DT_VCENTER | DT_SINGLELINE);
// Do not call CDialog::OnPaint() for painting messages
}