C / C++ / MFC

POINT pt;
BITMAP Bitmap;
HANDLE hBitmap = 0;
HDC hBitmapMemoryDC = 0;
RECT ClientRect;
HBITMAP hOffScreenBitmap = 0;
HDC hOffScreenMemoryDC = 0;


LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;
    HDC hdc;

    switch (message)
    {
    case WM_CREATE:
        hBitmap = ::LoadImage(hInst, MAKEINTRESOURCE(IDB_BITMAP1), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);
        ::GetObject(hBitmap, sizeof(Bitmap), &Bitmap);
        hBitmapMemoryDC = ::CreateCompatibleDC(0);
        ::SelectObject(hBitmapMemoryDC, hBitmap);
        break;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        // blt the bitmap to the offscreen buffer
        ::StretchBlt(hOffScreenMemoryDC, 0, 0, ClientRect.right, ClientRect.bottom, hBitmapMemoryDC, 0, 0, Bitmap.bmWidth, Bitmap.bmHeight, SRCCOPY);
        // draw crosshairs on the offscreen buffer
        ::MoveToEx(hOffScreenMemoryDC, pt.x , 0 , NULL); 
        ::LineTo(hOffScreenMemoryDC, pt.x, ClientRect.bottom); 
        ::MoveToEx(hOffScreenMemoryDC, 0, pt.y, NULL); 
        ::LineTo(hOffScreenMemoryDC, ClientRect.right, pt.y); 
        // blt the offscreen buffer to the screen
        ::BitBlt(hdc, 0, 0, ClientRect.right, ClientRect.bottom, hOffScreenMemoryDC, 0, 0, SRCCOPY);
        EndPaint(hWnd, &ps);
        break;
    case WM_MOUSEMOVE:
        pt.x = LOWORD(lParam);
        pt.y = HIWORD(lParam);
        ::InvalidateRect(hWnd,NULL,FALSE); // changed to FALSE since we draw the entire client area
        ::UpdateWindow(hWnd);
        break;	
    case WM_ERASEBKGND:
        // We draw the background in WM_PAINT - don't do it here!
        return 1;
    case WM_SIZE:
        ClientRect.left = 0;
        ClientRect.top = 0;
        ClientRect.right = LOWORD(lParam);
        ClientRect.bottom = HIWORD(lParam);
        // (Re)Create the offscreen buffer
        if (hOffScreenBitmap != 0)
            ::DeleteObject(hOffScreenBitmap);
        if (hOffScreenMemoryDC != 0)
            ::DeleteDC(hOffScreenMemoryDC);
        hdc = ::GetDC(hWnd);
        hOffScreenMemoryDC = ::CreateCompatibleDC(hdc);
        hOffScreenBitmap = ::CreateCompatibleBitmap(hdc, ClientRect.right, ClientRect.bottom);
        ::SelectObject(hOffScreenMemoryDC, hOffScreenBitmap);
        ::ReleaseDC(hWnd, hdc);
        break;
    case WM_DESTROY:
        if (hBitmap != 0)
            ::DeleteObject(hBitmap);
        if (hBitmapMemoryDC != 0)
            ::DeleteDC(hBitmapMemoryDC);
        if (hOffScreenBitmap != 0)
            ::DeleteObject(hOffScreenBitmap);
        if (hOffScreenMemoryDC != 0)
            ::DeleteDC(hOffScreenMemoryDC);
         PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

Mark Salsbery
Microsoft MVP - Visual C++

modified on Thursday, May 26, 2011 8:30 PM

Berlus wrote:

void operator(MyStruct& ms)

Berlus wrote:

I need help in converting these two function into one function (since basicaly it is the same code).

using std;
struct MyStruct {
   int a;     // just an example
   double b;  // just an example
   //...
};
// this implements the streaming operator for all classes derived from std::ostream
ostream& operator<<(ostream& output, MyStruct& ms) {
    output << "    a: " << ms.a << endl;
    output << "    b: " << ms.b << endl;
    return output;
}

int main () {
   MyStruct ms;
   ms.a = 3;
   ms.b = 3.1415926;
   ofstream myfile("test.txt");
   myfile << ms; // writes to file
   cout << ms; // writes to console
}

#include <iostream>
#include <fstream>
using namespace std;


struct MyStruct
{
	ostream& operator<<(ostream& output) {
		output << "    a: " << a << endl;
		output << "    b: " << b << endl;
		return output;
	}

	int a;
	double b;
};

int main(void)
{
  MyStruct ms;
  ms.a = 5;
  ms.b = 4.2;

  cout << ms;

  // Write to a file without changing methods in MyStruct
  ofstream  my_file("me.txt");
  my_file << ms;
  
  return 0;
}

struct MyStruct {
   int a;
   MyStruct(int value) : a(value) {} // conversion constructor, for implicit casting of int to MyStruct
   MyStruct operator-(const MyStruct& op2) {
      return (a-op2.a);
   }
};

struct MyStruct {
   int a;
   MyStruct(int value) : a(vlaue) {}
};
MyStruct operator-(const MyStruct& op1, const MyStruct& op2) {
   return op1.a - op2.a;
}

Richard MacCutchan wrote:

Show the contents of your URL so people can see if it is valid.

• what you are trying to achieve
• what your code is doing
• what are the actual values of any variables that the code is using
• what results you are seeing

BOOL FindTrayProcess( DWORD& pid );
void PrintError( TCHAR* msg );

int _tmain(int argc, _TCHAR* argv[])
{
	DWORD pid;
	HANDLE hTray;
	TCHAR szPath[MAX_PATH+1] = TEXT("C:\\Program Files\\Windows Media Bonus Pack for Windows XP\\PowerToys\\mpxptray.exe"); // Used for (re)starting it
	STARTUPINFO si;
	PROCESS_INFORMATION pi;

	// Find the tray process, and kill it
	if (FindTrayProcess( pid ))
	{
		if (INVALID_HANDLE_VALUE == (hTray = OpenProcess( PROCESS_TERMINATE, FALSE, pid )))
		{
			PrintError(TEXT("OpenProcess"));
		}
		else
		{
			if ( ! TerminateProcess( hTray, 0 ) )
				PrintError(TEXT("TerminateProcess"));
			CloseHandle(hTray);
		}
	}

	// (Re)start the tray process
	
	memset( (void*)&si, 0, sizeof(STARTUPINFO) );
	si.cb = sizeof(STARTUPINFO);
	memset( (void*)&pi, 0, sizeof(PROCESS_INFORMATION) );

	if ( ! CreateProcess( szPath, NULL, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi ))
	{
		DWORD ErrCode = GetLastError();
		PrintError(TEXT("CreateProcess"));
		return ErrCode;
	}

	CloseHandle( pi.hThread );
	CloseHandle( pi.hProcess );

	return 0;
}

BOOL FindTrayProcess( DWORD& pid )
{
	HANDLE hProcessSnap;
	PROCESSENTRY32 pe32;

	// Take a snapshot of all processes in the system.
	hProcessSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
	if( hProcessSnap == INVALID_HANDLE_VALUE )
	{
		PrintError( TEXT("CreateToolhelp32Snapshot") );
		return( FALSE );
	}

	// Set the size of the structure before using it.
	pe32.dwSize = sizeof( PROCESSENTRY32 );

	// Retrieve information about the first process,
	// and exit if unsuccessful
	if( !Process32First( hProcessSnap, &pe32 ) )
	{
		PrintError( TEXT("Process32First") ); // show cause of failure
		CloseHandle( hProcessSnap );          // clean the snapshot object
		return( FALSE );
	}

	// Now walk the snapshot of processes, and
	// display information about each process in turn
	do
	{
		if (_tcsicmp( pe32.szExeFile, TEXT("mpxptray.exe") ) == 0 )
		{
			pid = pe32.th32ProcessID;
			CloseHandle( hProcessSnap );
			return( TRUE );
		}
	} while( Process32Next( hProcessSnap, &pe32 ) );

	CloseHandle( hProcessSnap );
	return( FALSE );
}

void PrintError( TCHAR* msg )
{
	DWORD eNum;
	TCHAR sysMsg[256];
	TCHAR* p;

	eNum = GetLastError( );
	FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
		 NULL, eNum,
		 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
		 sysMsg, 256, NULL );

	// Trim the end of the line and terminate it with a null
	p = sysMsg;
	while( ( *p > 31 ) || ( *p == 9 ) )
	++p;
	do { *p-- = 0; } while( ( p >= sysMsg ) &&
						  ( ( *p == '.' ) || ( *p < 33 ) ) );

	// Display the message
	_tprintf( TEXT("\n  WARNING: %s failed with error %d (%s)"), msg, eNum, sysMsg );
}