SetWindowPos() leaves an artefact on resize - c

Question

Hi, please help me. This is a c/c++ project.
OBJECTIVE:
To create an OSD to show master volume that fades after a couple seconds.
CURRENT IMPLEMENTATION:
Much of the code is a collage, the fragments of which are pulled from libusbk examples and forums. The highlights of the code are:
Create a WS_POPUP window using CreateWindowEx - 129
Use ShowWindow during initialization of the window - 168
When the volume is changed, function SetOSDWidth (172) is called, which starts a timer, calls ShowWindow and calls SetWindowPos with the new width, determined by the new volume.
In the secondary(?) loop pluggedin() (277), the time elapsed since the last SetOSDWidth call is checked - if it's long enough, ShowWindow is called with the parameter SW_HIDE.
That's it!
IMMEDIATE RESULTS:
It works just as expected!
THE BUG - RESULTS AFTER SOME TIME:
When the bar is resized to a smaller width, it leaves behind a black artefact. It also does not extend wider than the width it was when it was hidden - rather, it weirdly gets smaller in the horizontal axis. In debug mode of VSExpress2010, the bug almost never shows up, but when running the debug .exe or release .exe on its own, it happens. And once it happens, EVEN RESTARTING (end process in taskmgr then double click executable) the .exe does not fix it.
This link leads to an image which illustrates the problem -
http://i.stack.imgur.com/DmrrN.jpg
THINGS I'VE TRIED
All kinds of window styes and other parameters in CreateWindowEx and ShowWindow. Mixing up the order. Trying with and without UpdateWindow. Too much reading in forums - time to write! :)
THE CODE
There are three files here.
U7VolumeDial.c containing WinMain
Volume.h containing definitions to call cpp from c
Volume.cpp containing functions for controlling volume
1)
//##############################
//January 2014
//ASUS U7 Volume Dial Workaround
//We define the vendor and product IDs
#define U7VID 0x1043
#define U7PID 0x857C
//Some definitions for the pipe
#define EP_ADDRESS 0x84
#define MAX_TRANSFER_SIZE 16
#define MAX_PENDING_TRANSFERS 32
#define MAX_PENDING_IO 3
//A whole bunch of includes
#include <Windows.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <time.h>
//USB Library
#include "libusbk.h"
//Audio Code
#include "Volume.h"
//To process kill signal
#include <signal.h>
//GLOBALS
const char g_szClassName[] = "VolumeOSD";
BOOL timetodie=0;
int savencmdshow;
DWORD pluggedin();
DWORD notpluggedin();
//USB Handles
KUSB_DRIVER_API Usb;
KLST_HANDLE deviceList = NULL;
KLST_DEVINFO_HANDLE deviceInfo = NULL;
KUSB_HANDLE usbHandle = NULL;
KSTM_HANDLE streamHandle = NULL;
//USB Variables
DWORD errorCode = ERROR_SUCCESS;
DWORD transferLength = 0;
BOOL success;
UCHAR myBuffer[MAX_TRANSFER_SIZE * MAX_PENDING_IO];
UINT count = 0;
BOOL intheslot=0;
//Window Variables
WNDCLASSEX wc;
HWND hwnd;
MSG Msg;
//Timer Variables
clock_t start;
double timeout=5;
//Window Callback Function
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg)
{
case WM_CLOSE:
DestroyWindow(hwnd);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return 0;
}
//Hotplug Callback Function
VOID KUSB_API OnHotPlug(
KHOT_HANDLE Handle,
KLST_DEVINFO_HANDLE DeviceInfo,
KLST_SYNC_FLAG NotificationType)
{
UNREFERENCED_PARAMETER(Handle);
if (NotificationType == KLST_SYNC_FLAG_ADDED)
{
printf("KHOTPLUG - ASUS U7 is ACTIVE\n");
// system("pause");
intheslot=1;
}
else
{
printf("KHOTPLUG - ASUS U7 is DISCONNECTED\n");
//system("pause");
intheslot=0;
}
}
//Creating the OSD
DWORD InitializeOSD(HINSTANCE hInstance, int nCmdShow)
{
//Step 1: Registering the Window Class
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = 0;//LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_HIGHLIGHT+1);
wc.lpszMenuName = NULL;
wc.lpszClassName = g_szClassName;
wc.hIconSm = 0;//LoadIcon(NULL, IDI_APPLICATION);
if(!RegisterClassEx(&wc))
{
MessageBox(NULL, "Window Registration Failed!", "Error!",
MB_ICONEXCLAMATION | MB_OK);
return 0;
}
// Step 2: Creating the Window
hwnd = CreateWindowEx(
WS_EX_TOPMOST|WS_EX_LAYERED|WS_EX_NOACTIVATE,
g_szClassName,
"Volume",
WS_POPUP,
0,
0,
1280, 10,
NULL, NULL, hInstance, NULL);
#define transparencykey RGB(80,80,80)
#define opacity 254
SetLayeredWindowAttributes(
hwnd,
RGB(80,80,80),
opacity,
LWA_ALPHA);
// SetWindowLong(hwnd, GWL_STYLE, 0);
/* SetWindowPos(
hwnd,
HWND_TOPMOST,
0,
0,
700,
10,
SWP_NOSENDCHANGING);*/
if(hwnd == NULL)
{
MessageBox(NULL, "Window Creation Failed!", "Error!",
MB_ICONEXCLAMATION | MB_OK);
return 0;
}
ShowWindow(hwnd, nCmdShow);
// UpdateWindow(hwnd);
}
DWORD SetOSDWidth(int width)
{
if (((clock()-start)/(double) CLOCKS_PER_SEC)<timeout)
{
start=clock();
}
else
{
ShowWindow(hwnd, savencmdshow);
//UpdateWindow(hwnd);
start=clock();
}
SetWindowPos(
hwnd,
HWND_TOPMOST,
0,
0,
width,
10,
SWP_NOSENDCHANGING|SW_SHOWNOACTIVATE);
//UpdateWindow(hwnd);
return 0;
}
//Signal Callback Function
void signal_callback_handler(int signum)
{
timetodie=1;
SetOSDWidth(1280);
exit(signum);
}
//main routine
//DWORD __cdecl main(int argc, char* argv[])
int WINAPI WinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
DWORD errorCode = ERROR_SUCCESS;
KHOT_HANDLE hotHandle = NULL;
KHOT_PARAMS hotParams;
savencmdshow=nCmdShow;
InitializeOSD(hInstance,nCmdShow);
memset(&hotParams, 0, sizeof(hotParams));
hotParams.OnHotPlug = OnHotPlug;
hotParams.Flags |= KHOT_FLAG_PLUG_ALL_ON_INIT;
strcpy(hotParams.PatternMatch.DeviceInterfaceGUID, "*");
printf("Initialize a HotK device notification event monitor..\n");
printf("Looking for 'DeviceInterfaceGUID's matching the pattern'%s'..\n", hotParams.PatternMatch.DeviceInterfaceGUID);
if (!HotK_Init(&hotHandle, &hotParams))
{
errorCode = GetLastError();
printf("HotK_Init failed. ErrorCode: %08Xh\n", errorCode);
//system("pause");
goto DoneHot;
}
printf("HotK monitor initialized successfully!\n");
//printf("Press 'q' to exit...\n\n");
//Register signal handler
// signal(SIGINT, signal_callback_handler);
// signal(3, signal_callback_handler);
// signal(SIGTERM, signal_callback_handler);
//Infinite Loop
for(;;)
{
if (intheslot==1)
{
pluggedin();
}
Sleep(100);
if (timetodie==1)
{
goto outtheinfinite;
}
}
outtheinfinite:
if (!HotK_Free(hotHandle))
{
errorCode = GetLastError();
printf("HotK_Free failed. ErrorCode: %08Xh\n", errorCode);
goto DoneHot;
}
printf("HotK monitor closed successfully!\n");
DoneHot:
return errorCode;
}
DWORD pluggedin()
{
// int loop;
// int bigloop;
InitVolumeControl();
//Register signal handler
//signal(SIGINT, signal_callback_handler);
//signal(SIGTERM, signal_callback_handler);
//USB Stuff
//Create a LstK object
if (!LstK_Init(&deviceList, KLST_FLAG_NONE))
{
errorCode = GetLastError();
printf("An error occured getting the device list. errorCode=%08Xh\n", errorCode);
//system("pause");
return errorCode;
}
//Get the number of devices
LstK_Count(deviceList, &count);
if (!count)
{
printf("No devices connected.\n");
// Always free the device list if LstK_Init returns TRUE
LstK_Free(deviceList);
//system("pause");
return ERROR_DEVICE_NOT_CONNECTED;
}
//Find ASUS U7
if (LstK_FindByVidPid(deviceList, U7VID, U7PID, &deviceInfo))
{
printf("LstK_FindByVidPid: ASUS U7 is connected.\n\n");
printf("Bus Number %u\n",deviceInfo->BusNumber);
printf("ClassGUID %s\n",deviceInfo->ClassGUID);
printf("InstanceID %s\n",deviceInfo->Common.InstanceID);
printf("VendorID 0x%04X\n",deviceInfo->Common.Vid);
printf("ProductID 0x%04X\n",deviceInfo->Common.Pid);
printf("CompositeInterface %u\n",deviceInfo->Common.MI);
printf("Connected %u\n",deviceInfo->Connected);
printf("Device Address %u\n",deviceInfo->DeviceAddress);
printf("DeviceDesc %s\n",deviceInfo->DeviceDesc);
printf("DeviceID %s\n",deviceInfo->DeviceID);
printf("DeviveInterfaceGUID %s\n",deviceInfo->DeviceInterfaceGUID);
printf("Device Path\n%s\n",deviceInfo->DevicePath);
printf("DriverID %u\n",deviceInfo->DriverID);
printf("LUsb0FilterIndex %u\n",deviceInfo->LUsb0FilterIndex);
printf("Manufacturer %s\n",deviceInfo->Mfg);
printf("SerialNumber %s\n",deviceInfo->SerialNumber);
printf("Service %s\n",deviceInfo->Service);
printf("SymbolicLink\n%s\n",deviceInfo->SymbolicLink);
printf("SyncFlags %08Xh\n",deviceInfo->SyncFlags);
}
else
{
printf("ASUS U7 not found.\n");
//system("pause");
}
//
if (deviceInfo)
{
BOOL success = LibK_SetContext(deviceInfo, KLIB_HANDLE_TYPE_LSTINFOK, 1);
if (success)
{
UINT_PTR myValue = LibK_GetContext(deviceInfo, KLIB_HANDLE_TYPE_LSTINFOK);
printf("\nMyContextValue = %u\n", myValue);
}
}
//Load API
LibK_LoadDriverAPI(&Usb, deviceInfo->DriverID);
//Initialize the device to create physical usb handle
if (!Usb.Init(&usbHandle, deviceInfo))
{
errorCode = GetLastError();
printf("Usb.Init failed. ErrorCode: %08Xh\n", errorCode);
//system("pause");
return errorCode;
}
printf("\nASUS U7 libusb filter API opened successfully!\n");
//Initialize stream handle
success = StmK_Init(
&streamHandle,
usbHandle,
EP_ADDRESS,
MAX_TRANSFER_SIZE,
MAX_PENDING_TRANSFERS,
MAX_PENDING_IO,
NULL,
KSTM_FLAG_NONE);
if (!success)
{
errorCode = GetLastError();
printf("StmK_Init failed. ErrorCode: %08Xh\n", errorCode);
//system("pause");
return errorCode;
}
printf("\nStream Handler Initialized\n");
//Start the stream
success = StmK_Start(streamHandle);
if (!success)
{
errorCode = GetLastError();
printf("StmK_Start failed. ErrorCode: %08Xh\n", errorCode);
//system("pause");
return errorCode;
}
printf("\n[Start Stream] successful!\n");
while(_kbhit()) _getch();
do
{
ULONG length;
if (((clock()-start)/(double) CLOCKS_PER_SEC)>timeout)
{
ShowWindow(hwnd, SW_HIDE);
}
if (intheslot==0)
{
//Stop the stream
success = StmK_Stop(streamHandle, 0);
if (!success)
{
errorCode = GetLastError();
printf("StmK_Stop failed. ErrorCode: %08Xh\n", errorCode);
goto Done;
}
printf("[Stop Stream] successful!\n");
goto Done;
}
success = StmK_Read(streamHandle, myBuffer, 0, sizeof(myBuffer), &length);
if (success)
{
//printf("%u%",length);
if (myBuffer[0]==0x01)
{VolumeUp();}
if ((length>16)&&(myBuffer[15]==0x01))
{VolumeUp();}
if ((length>32)&&(myBuffer[31]==0x01))
{VolumeUp();}
if (myBuffer[0]==0x02)
{VolumeDown();}
if ((length>16)&&(myBuffer[15]==0x02))
{VolumeDown();}
if ((length>32)&&(myBuffer[31]==0x02))
{VolumeDown();}
// for (bigloop=0;bigloop<4;bigloop+=1)
// {
// for (loop=0;loop<16;loop+=1)
// {
// printf("%02X ",myBuffer[bigloop*16+loop]);
// }
// printf("\n");
// }
// printf("\n\n");
}
else
{
if (timetodie==1)
{
goto Done;
}
Sleep(20);
// If the return result is ERROR_NO_MORE_ITEMS then there is no more data
// to read. Other errors indicate a problem.
//if (GetLastError() != ERROR_NO_MORE_ITEMS)
//{
// break;
//}
//else
//{
// ..Emulate some work..
// Sleep(20);
//}
}
}
while(!_kbhit());
Done:
// Destroy the OSD
DestroyWindow(hwnd);
printf("Maybe I killed the OSD, maybe not");
// Free the stream handle.
if (streamHandle)
{
StmK_Free(streamHandle);
printf("Stream Handle Freed\n");
}
// Free the usb handle.
UsbK_Free(usbHandle);
printf("USB Handle Freed\n");
// Free the device list.
LstK_Free(deviceList);
printf("USB Device Enumeration Handle Freed\n");
DeInitVolumeControl();
printf("\n\n");
//system("pause");
return errorCode;
}'
2) Phew - thanks, don't want to miss anything - here's the header for the cpp stuff
#ifdef __cplusplus
//HRESULT hr;
//IMMDeviceEnumerator *DeviceEnumerator;
//IMMDevice *DefaultDevice;
//IAudioEndpointVolume *EndpointVolume;
extern "C" void InitVolumeControl();
extern "C" void VolumeUp();
extern "C" void VolumeDown();
extern "C" void DeInitVolumeControl();
#endif
#ifndef __cplusplus
void InitVolumeControl();
void VolumeUp();
void VolumeDown();
void DeInitVolumeControl();
#endif
3) And finally the cpp volume control
#define _WIN32_WINNT 0x0601
#define WINVER 0x0601
#include <stdio.h>
#include "Volume.h"
#include <mmdeviceapi.h>
#include <endpointvolume.h>
#include <math.h>
//Audio Handles/Pointers
HRESULT hr = NULL;
IMMDeviceEnumerator *DeviceEnumerator = NULL;
IMMDevice *DefaultDevice = NULL;
IAudioEndpointVolume *EndpointVolume = NULL;
float VolumeLevel = 0;
int NewOSDWidth;
extern "C" DWORD SetOSDWidth(int width);
void InitVolumeControl()
{
//Audio Stuff
//Initialize COM
CoInitialize(NULL);
//Initialize Device Enumerator
hr = CoCreateInstance( __uuidof(MMDeviceEnumerator),
NULL,
CLSCTX_INPROC_SERVER,
__uuidof(IMMDeviceEnumerator),
(LPVOID *)&DeviceEnumerator );
//Find Default Audio Device
hr = DeviceEnumerator->GetDefaultAudioEndpoint(eRender,eConsole,&DefaultDevice);
//Find Endpoint Volume
hr = DefaultDevice->Activate( __uuidof(IAudioEndpointVolume),
CLSCTX_INPROC_SERVER,
NULL,
(LPVOID *)&EndpointVolume);
EndpointVolume->GetMasterVolumeLevelScalar(&VolumeLevel);
NewOSDWidth=floorf(VolumeLevel*1280);
SetOSDWidth(NewOSDWidth);
}
void VolumeUp()
{
if(EndpointVolume->VolumeStepUp(NULL))
{
printf("Endpoint Volume Error - Reinitialising");
EndpointVolume->Release();
DefaultDevice->Release();
hr = DeviceEnumerator->GetDefaultAudioEndpoint(eRender,eConsole,&DefaultDevice);
hr = DefaultDevice->Activate( __uuidof(IAudioEndpointVolume),
CLSCTX_INPROC_SERVER,
NULL,
(LPVOID *)&EndpointVolume);
EndpointVolume->VolumeStepUp(NULL);
}
EndpointVolume->GetMasterVolumeLevelScalar(&VolumeLevel);
NewOSDWidth=floor(VolumeLevel*1280);
SetOSDWidth(NewOSDWidth);
}
void VolumeDown()
{
if(EndpointVolume->VolumeStepDown(NULL))
{
printf("Endpoint Volume Error - Reinitialising");
EndpointVolume->Release();
DefaultDevice->Release();
hr = DeviceEnumerator->GetDefaultAudioEndpoint(eRender,eConsole,&DefaultDevice);
hr = DefaultDevice->Activate( __uuidof(IAudioEndpointVolume),
CLSCTX_INPROC_SERVER,
NULL,
(LPVOID *)&EndpointVolume);
EndpointVolume->VolumeStepDown(NULL);
}
EndpointVolume->GetMasterVolumeLevelScalar(&VolumeLevel);
NewOSDWidth=floor(VolumeLevel*1280);
SetOSDWidth(NewOSDWidth);
}
void DeInitVolumeControl()
{
DeviceEnumerator->Release();
DeviceEnumerator=NULL;
printf("AUDIO Device Enumerator Released\n");
DefaultDevice->Release();
DefaultDevice=NULL;
printf("AUDIO Device Released\n");
EndpointVolume->Release();
EndpointVolume=NULL;
printf("Endpoint Volume Released\n");
CoUninitialize();
printf("COM Objects Released\n");
}
Any input would be greatly appreciated. As an aside, if you've waded through that stuff above, you'll notice that it's to do with the external soundcard sold by ASUS, the XONAR U7 - after buying it and installing in Win7-64, the volume dial wasn't functional. I got hold of the main dudes and they told me, without explanation, to send it to a repair centre...? A quick look using a USB monitor showed output when the dial was turned - so either a driver problem, or firmware not sending HID like it should be? Repair centre... pffft, something smells.