Unified Diff » Win32 & MFC

Block Windows Shut Down

Bob — Thu, 28 Jan 2010 18:51:27 +0000

It’s hard to describe just how much I HATE rebooting my computer. If I have to use a Windows computer for any extended period of time, then I always change update policies to disallow automatic reboots. In fact, I usually click the irritating “Remind me in ten minutes” button every ten minutes for three weeks before I finally allow Windows to restart (or until I stop the Automatic Updates service).

So you can imagine how annoyed I was to come into work twice this week to the blue Windows logon screen. Every time this happens it takes me twenty minutes to figure out what I was doing the day before, what I have to do today, and where I stopped with my work. And really what made this so much more painful was that it happened without any advanced warning.

And that’s what got me thinking: could I block restart requests? I researched the Windows shut down process online and then went to work on a prototype. From what I read, calling ExitWindowsEx sends WM_QUERYENDSESSION to all top-level windows. Applications that are not ready to shut down should return false. I figured the best strategy was to install a system-wide hook and filter the message.

Initially I attempted to capture WM_QUERYENDSESSION with the WH_GETMESSAGE hook and replace it with WM_NULL, but trial-and-error revealed that it’s sent through SendMessage and not posted to the window’s queue. This meant that I couldn’t filter out the message.

I switched to WH_CALLWNDPROC and was able to capture the message, but not actually modify it. Since my DLL is memory-mapped into the local process space, it seemed like the only way to filter the message was to create a new WindowProc function that handles WM_QUERYENDSESSION and always returns false. Then inside the hook procedure, I could intercept the message and call SetWindowLong to replace the window’s message procedure.

This demonstrates the basic concept:

LRESULT CALLBACK CallWndProc( int nCode, WPARAM wParam, LPARAM lParam )
{
  if( nCode == HC_ACTION ) {
      CWPSTRUCT *msg = (CWPSTRUCT*)lParam;
 
      /* hijack the window proc when we see a shut down message */
      if( msg->message == WM_QUERYENDSESSION )
          oldwndproc = SetWindowLong(msg->hwnd, GWL_WNDPROC, (DWORD)WindowProc);
  }
 
  return CallNextHookEx(g_callwndhk, nCode, wParam, lParam);
}
 
LRESULT CALLBACK WindowProc( HWND hWnd, UINT uiMessage, 
        WPARAM wParam, LPARAM lParam )
{
  /* intercept shut down messages */
  if( uiMessage == WM_QUERYENDSESSION )
      return 0;
 
  return DefWindowProc(hWnd, uiMessage, wParam, lParam);
}

When my little application starts, it calls SetProcessShutdownParameters with level 0×4FF to increase the chances of trapping the message first. I figured this was a good idea since I know its WindowProc function can be safely hijacked. Now when Windows sends WM_QUERYENDSESSION the response is always “NO!”. The added exclamation there is a call to AbortSystemShutdown, which is probably unnecessary but I do it just to be safe. Also, I added an alert message box to warn me when a reboot is triggered.

I’m sort of amazed this actually worked. Some day I’ll test it against InitiateSystemShutdown and ExitWindowsEx with EWX_FORCE to see how it holds up. Interestingly, Windows Vista/7 provides ShutdownBlockReasonCreate for seemingly outright blocking shut down attempts.

You can obtain the sources to this project here.

Remove Tabs From the Windows Taskbar

Bob — Sun, 07 Jun 2009 04:54:03 +0000

I’m very picky about my desktop environment. I like windows, toolbars, icons, etc. to be arranged in a certain way. Typically, I turn off annoying prompts and nag screens in Windows, and unhide “scary” advanced options in OS X. One hard-to-fix pet peeve is when applications put an icon in the notification area (near the clock) AND leave a tab in the taskbar. This wastes valuable taskbar real estate.

I use Spark on my workstation to connect to the company’s internal IM server. The application works alright, but the contacts window always appears in the taskbar. So I started to think about ways I could programmatically solve my problem.

I could set the WS_EX_TOOLWINDOW style on the window, but that would alter the window’s appearance. What I really wanted was a way to tell Windows to remove the tab. A quick search on Google turned up the answer: use COM to create an instance of ITaskbarList. The interface has the function ITaskbarList::DeleteTab() which takes a window handle. Perfect!

Now I just needed to get the window’s handle. FindWindow() would have worked, but that meant hard-coding my username into the program. I felt a more elegant solution was to enumerate all of the windows, and look for the one with the right class and title prefix.

Since the tab would reappear every time I brought the contact list window to the foreground, I ended up wrapping my fix with a loop and a timer. Here’s the finished product:

/* NoSpark.cpp - Hides the Spark contacts window tab in the taskbar */
 
#include 
#include 
 
BOOL CALLBACK EnumWindowsProc(HWND, LPARAM);
 
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow )
{
	HANDLE htmr = CreateWaitableTimer(NULL, TRUE, L"CheckSpark");
	LARGE_INTEGER lidt;
	ITaskbarList* ptl;
 
	__int64 qwdt = -60 * 10000000; // 1 minute
	lidt.LowPart = (DWORD) (qwdt & 0xFFFFFFFF);
	lidt.HighPart = (LONG) (qwdt >> 32);
 
	while( TRUE ) {
		SetWaitableTimer(htmr, &lidt, 0, NULL, NULL, FALSE);
		WaitForSingleObject(htmr, INFINITE);
 
		HWND hsparkwnd = 0;
		EnumWindows(&EnumWindowsProc, (LPARAM) &hsparkwnd);
		if( hsparkwnd == 0 ) continue;
 
		CoInitialize(NULL);
		HRESULT ret = CoCreateInstance(
			CLSID_TaskbarList, 
			NULL, 
			CLSCTX_SERVER, 
			IID_ITaskbarList, 
			(LPVOID*) &ptl
		);
 
		if( ret == S_OK )
			ptl->DeleteTab(hsparkwnd);
 
		ptl->Release();
		CoUninitialize();
	}
 
	return 0;
}
 
BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
	int tmpsz = 16;
	LPWSTR lptmp = (LPWSTR) malloc(sizeof(WCHAR) * tmpsz);
 
	RtlZeroMemory(lptmp, tmpsz);
	GetClassName(hwnd, lptmp, tmpsz);
 
	if( wcscmp(lptmp, L"SunAwtFrame") != 0 ) {
		free(lptmp);
		return TRUE;
	}
 
	RtlZeroMemory(lptmp, tmpsz);
	GetWindowText(hwnd, lptmp, tmpsz);
 
	if( wcscmp(lptmp, L"Spark -") > 0 ) {
		*((HWND*) lParam) = hwnd;
		free(lptmp);
		return FALSE;
	}
 
	free(lptmp);
	return TRUE;
}

To compile this program, create a new, empty Visual C++ project. Create a new cpp file and drop the code above inside. If you get compile errors about converting wchar_t* to const char* then change your character set from Multibyte to Unicode in the project properties.

Dipping Duck

Bob — Wed, 13 May 2009 03:53:04 +0000

So I was trying to read a document on my computer at work today, while making notes on a piece of paper. But every five minutes the screensaver would activate, causing me to stop writing, type my password, and find my place in the document again. Needless to say it was quite annoying.

Now you might be wondering why I don’t just change the screensaver time-out or turn off the requirement for a password. Well even though I’m a local administrator, there is a domain-wide GPO that prevents me from doing so. (Yes I know I can edit the registry, but that setting doesn’t survive a GP refresh.) I understand the reason for the policy, but five minutes seems a bit too short.

I wanted to fix this problem AND keep my job at the same time. Alice’s “dipping duck” inspired me to write a simple program to simulate mouse movement.

#include 
 
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow )
{
    HANDLE htmr = CreateWaitableTimer(NULL, TRUE, L"CheckIdle");
    LARGE_INTEGER lidt;
    LASTINPUTINFO lii;
 
    __int64 qwdt = -30 * 10000000; // 30 seconds
    lidt.LowPart = (DWORD) (qwdt & 0xFFFFFFFF);
    lidt.HighPart = (LONG) (qwdt >> 32);
 
    while( TRUE ) {
        SetWaitableTimer(htmr, &lidt, 0, NULL, NULL, FALSE);
        WaitForSingleObject(htmr, INFINITE);
 
        RtlZeroMemory(&lii, sizeof(LASTINPUTINFO));
        lii.cbSize = sizeof(LASTINPUTINFO);
        BOOL ret = GetLastInputInfo(&lii);
 
        int threshold = 3 * 60; // 3 minutes
        int idletime = ret ? (GetTickCount() - lii.dwTime) / 1000 : 0;
 
        BOOL scrnsvr = FALSE;
        SystemParametersInfo(SPI_GETSCREENSAVERRUNNING, 0, &scrnsvr, 0);
 
        if( idletime > threshold && !scrnsvr ) {
            MOUSEINPUT mi;
            RtlZeroMemory(&mi, sizeof(MOUSEINPUT));
            mi.dwFlags = MOUSEEVENTF_MOVE;
            mi.dx = 1;
            mi.dy = 1;
 
            INPUT in;
            in.type = INPUT_MOUSE;
            in.mi = mi;
 
            SendInput(1, &in, sizeof(in));
        }
    }
 
    return 0;
}

Every thirty seconds the program checks to see if the computer is idle. After three minutes of inactivity (and if the screensaver isn’t running), it moves the mouse cursor one pixel down and to the right. If I lock the workstation or manually activate the screensaver, the program won’t do anything. To compile this program, create a new empty C++ Win32 application project. Add a new cpp file, drop in the code above, and hit “Build Solution”.

Now the screensaver won’t be a nuisance when I’m trying to read. I just have to make sure to hit Win-L before I leave my desk!

Custom Draw ListView with Double Buffering

Bob — Sat, 31 May 2008 04:33:19 +0000

For one of my pet projects, I needed to add a graphic to certain ListView rows. I considered owner-drawing the control, but that seemed messy. What I really wanted was a way to draw on top of whatever Windows painted. I couldn’t find a nifty .NET way to do this, so remembering a technique from the MFC days, I decided to custom draw the ListView. This would let me inject my own drawing code and let Windows handle the rest. Perfect!

I had originally implemented the ListView using a control style to eliminate the annoying flicker every time the list was repainted. Once I started custom drawing the control, I saw odd artifacts in the ListView’s client area when I scrolled or moved the mouse. If I turned off double buffering, it worked fine.

I studied the custom draw process looking for my mistake, but I couldn’t find any. I even used the .NET Reflector to look at Microsoft’s implementation. The message I’m filtering has a handle to the control’s back-buffer. So it seemed like I should just be able to draw directly into that. But no matter what I did, it produced the same artifacts.

After about three days of banging my head, I managed to make it work by drawing into my own buffer and then using BitBlt() to copy my image to the control’s buffer. I also had to set the double buffer style with a window message rather than using the built-in property, although admittedly, I’m not sure why.

I like visual aids, so here’s a code snippet from my project. I changed names and removed a bunch of unnecessary lines for easier reading.

#include "stdafx.h"
#include "MyListViewControl.h"
 
using namespace MyListViewControl;
using namespace System::Drawing;
using namespace System::Windows::Forms;
 
MyListViewControl::MyListViewControl() { }
 
bool MyListViewControl::CustomDraw( Message% m )
{
	System::Drawing::Rectangle^ mprc;
	System::String^ cchQueueIndex;
	ListViewItem^ mpItem;
	LPNMCUSTOMDRAW lpnmcd;
	Graphics^ mpgfx;
	HDC hmemdc;
	RECT sOrderRect;
	RECT sStopRect;
	Brush^ mpbgbr;
	Brush^ mpfgbr;
	int nOrderLen;
	int nOrderOffset;
	int nRightEdge;
	int nRectWidth;
	int nItem;
 
	// Grab the custom draw info
	lpnmcd = (LPNMCUSTOMDRAW) m.LParam.ToPointer();
 
	// Figure out which drawing stage we're in
	switch( lpnmcd->dwDrawStage )
	{	
 
	// Control Pre-paint
	case( CDDS_PREPAINT ):
 
		// Request to be notified during item draw
		__super::WndProc( m );
		m.Result = (System::IntPtr) CDRF_NOTIFYITEMDRAW;
		return true;
 
 
	// List Item Pre-paint
	case( CDDS_ITEMPREPAINT ):
 
		// Request to be notified after item draw
		__super::WndProc( m );
		m.Result = (System::IntPtr) CDRF_NOTIFYPOSTPAINT;
		return true;
 
 
	// List Item Post-paint
	case( CDDS_ITEMPOSTPAINT ):
 
		__super::WndProc( m );
 
		// Get the current item
		nItem = static_cast&lt;int&gt;( lpnmcd->dwItemSpec );
		mpItem = (ListViewItem^) this->Items[nItem];		
 
		// Get the device context and item bounds
		mpgfx = this->CreateGraphics();
		mprc = this->GetItemRect( nItem, ItemBoundsPortion::Label );
 
		// *** Your custom drawing code here ***
 
		// Copy the bubble to the screen DC
		hmemdc = reinterpret_cast&lt;HDC&gt;( static_cast&lt;void*&gt;(mpgfx->GetHdc()) );
		BitBlt( 
			lpnmcd->hdc, 
			sOrderRect.left, 
			mprc->Y, 
			nRectWidth, 
			mprc->Height, 
			hmemdc, 
			sOrderRect.left, 
			mprc->Y, 
			SRCCOPY );
		mpgfx->ReleaseHdc( (System::IntPtr) hmemdc );
 
		// Let Windows redraw the border
		m.Result = (System::IntPtr) CDRF_DODEFAULT;
		return true;
	}
 
	return false;
}
 
void MyListViewControl::WndProc( Message% m )
{
	LPNMHDR lpnmhdr;
 
	switch( m.Msg )
	{
 
	// Reflected Notifications
	case( OCM_NOTIFY ):
 
		// Get the notification
		lpnmhdr = (LPNMHDR) m.LParam.ToPointer();
		if( lpnmhdr == NULL ) break;
 
		// We want custom draw messages
		if( lpnmhdr->code == NM_CUSTOMDRAW  
			&& lpnmhdr->hwndFrom == this->Handle.ToPointer() )
		{
			if( this->CustomDraw(m) ) return;
		}
 
		break;
 
	}
 
	__super::WndProc( m );
}

And here’s the header file with the double buffering message call:

#pragma once
 
namespace MyListView
{
	public ref class MyListView : 
		public System::Windows::Forms::ListView
	{
 
	private:
		bool CustomDraw( System::Windows::Forms::Message% m );
 
	public:
		virtual property bool DoubleBuffered
		{
			bool get() override
			{
				LRESULT lStyles = ::SendMessage( 
					(HWND) this->Handle.ToPointer(), 
					LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0 );
				return (lStyles & LVS_EX_DOUBLEBUFFER) != 0;
			}
 
			void set( bool fValue ) override
			{
				// I tried using the DoubleBuffered property, but I
				// get artifacts. So, let's do this the MFC way...
				::SendMessage( 
					(HWND) this->Handle.ToPointer(), 
					LVM_SETEXTENDEDLISTVIEWSTYLE, 
					LVS_EX_DOUBLEBUFFER, 
					LVS_EX_DOUBLEBUFFER );
			}
		}
 
	protected:
		virtual void WndProc( System::Windows::Forms::Message% m ) override;
 
	public:
		MyListViewControl();
 
	};
}

I spend days searching online and couldn’t find anyone who talked about custom drawing a .NET ListView with double buffering. I hope somebody will find this useful.