C / C++ / MFC

namespace MyNamespace
{
class MyObject
{
  int m_i;
public:
  MyObject (int i) :m_i (i + 1) { cout << "MyObject constructor i=" << i << endl; }
  MyObject (const MyObject&) = delete; //these objects cannot be copied
  int get_i () const { return m_i; }
};
}


struct MyStruct
{
  MyStruct (const MyNamespace::MyObject& r) //tell compiler how to build a MyStruct
    : myObject (r.get_i ()) //cannot copy myObject so I just make a new one
    { cout << "MyStruct constructor" << endl; }

  MyNamespace::MyObject  myObject;
};

static MyStruct s_myStruct { MyNamespace::MyObject (5) };
//created a MyObject, then created a second one and finally finished construction of myStruct

// this probably won't run on a microcontroller...
int main ()
{
  cout << s_myStruct.myObject.get_i () << endl;
}

MyObject constructor i=5
MyObject constructor i=6
MyStruct constructor
7

// Test to see if I can draw the bitmap on the screen.
// Pass the pDC and a bougus x and y coordinate for testing purposes.
drawImage(pDC, 100, 100);

BigSteve-O wrote:

drawImage(pDC, 100, 100);

BigSteve-O wrote:

It looks like loadBitmap returns NULL. I have no idea as to why though.

Quote:

If the bitmap identified by lpszResourceName does not exist or if there is insufficient memory to load the bitmap, the function returns 0.

void CMyChessTestView::OnDraw(CDC* pDC)
{
	CMyChessTestDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	if (!pDoc)
		return;

	// TODO: add draw code for native data here
	// Draw the empty board....
	drawImage(pDC, 100, 100);
	drawEmptyBoard(pDC);
}

void CMyChessTestView::drawImage(CDC* pDC, int x, int y)
{

	// load IDB_BITMAP1 from our resources
	CBitmap bmp;
	if (bmp.LoadBitmap(IDB_LADYPIC))
	{
		// Get the size of the bitmap
		BITMAP bmpInfo;
		bmp.GetBitmap(&bmpInfo);

		// Create an in-memory DC compatible with the
		// display DC we're using to paint
		CDC dcMemory;
		
		dcMemory.CreateCompatibleDC(pDC);

		// Select the bitmap into the in-memory DC
		CBitmap *pOldBitmap = dcMemory.SelectObject(&bmp);

		// Find a centerpoint for the bitmap in the client area
		CRect rect;
		GetClientRect(&rect);
		int nX = rect.left + (rect.Width() - bmpInfo.bmWidth) / 2;
		int nY = rect.top + (rect.Height() - bmpInfo.bmHeight) / 2;

		// Copy the bits from the in-memory DC into the on-
		// screen DC to actually do the painting. Use the centerpoint
		// we computed for the target offset.
		pDC->BitBlt(nX, nY, bmpInfo.bmWidth, bmpInfo.bmHeight, &dcMemory,
			0, 0, SRCCOPY);

		dcMemory.SelectObject(pOldBitmap);
	}
	else
	{
		TRACE0("ERROR: Where's IDB_LADYPIC?\n");
	}
}

void CMyChessTestView::drawEmptyBoard(CDC* pDC)
{
	CMyChessTestDoc* pBC = GetDocument();
	ASSERT_VALID(pBC);
	if (!pBC)
		return;
	//drawImage(pDC, 80, 80);
	pDC->SetMapMode(MM_LOENGLISH);
	pDC->SetWindowExt(800, 800);
	//pDC->SetViewportOrg(testrec.Width(), testrec.Height());

	for (int i = 0; i < 8; i++)
	{
		for (int j = 0; j < 8; j++)
		{
			COLORREF color = pBC->getSquare(i, j);
			CBrush brush(color);
			int x1 = (j * 70) + 35;
			int y1 = (i * -70) - 35;
			int x2 = x1 + 70;
			int y2 = y1 - 70;
			CRect rect(x1, y1, x2, y2);
			pDC->FillRect(rect, &brush);
			//pDC->Rectangle(rect);
		}
	}
	// Now draw the borders
	for (int x = 35; x <= 595; x += 70)
	{
		pDC->MoveTo(x, -35);
		pDC->LineTo(x, -595);
	}
	for (int y = -35; y >= -595; y -= 70)
	{
		pDC->MoveTo(35, y);
		pDC->LineTo(595, y);
	}

BigSteve-O wrote:

if I draw the board first, the pieces will not show up, and that by drawing the piece first and then the board, all shows up.

//..
drawEmptyBoard(&dc);
drawImage(&dc, 105, -105); // note the negative y
//..

/*..*/::drawImage(CDC* pDC, int x, int y)
{
	CBitmap bmp;
	if (bmp.LoadBitmap(IDB_LADYPIC))
	{
		BITMAP bmpInfo;
		bmp.GetBitmap(&bmpInfo);

		CDC dcMemory;

		dcMemory.CreateCompatibleDC(pDC);
		dcMemory.SetMapMode(pDC->GetMapMode()); // as weird as it looks, the map mode is not the same, after CreateCompatibleDC

		// Select the bitmap into the in-memory DC
		CBitmap* pOldBitmap = dcMemory.SelectObject(&bmp);

		pDC->StretchBlt(x, y, bmpInfo.bmWidth, bmpInfo.bmHeight, &dcMemory,0, 0, bmpInfo.bmWidth, -bmpInfo.bmHeight, SRCCOPY); // note the negative height of the bitmap

		dcMemory.SelectObject(pOldBitmap);
	}
}