/*************************************************************************
* RegisterShellHook [SHELL.102]
*/
BOOL WINAPI RegisterShellHook16(HWND16 hWnd, UINT16 uAction)
{
TRACE("%04x [%u]\n", hWnd, uAction );
switch( uAction )
{
case 2: /* register hWnd as a shell window */
if( !SHELL_hHook )
{
SHELL_hHook = SetWindowsHookExA( WH_SHELL, SHELL_HookProc,
GetModuleHandleA("shell32.dll"), 0 );
if ( SHELL_hHook )
{
uMsgWndCreated = RegisterWindowMessageA( lpstrMsgWndCreated );
uMsgWndDestroyed = RegisterWindowMessageA( lpstrMsgWndDestroyed );
uMsgShellActivate = RegisterWindowMessageA( lpstrMsgShellActivate );
}
else
WARN("-- unable to install ShellHookProc()!\n");
}
if ( SHELL_hHook )
return ((SHELL_hWnd = HWND_32(hWnd)) != 0);
break;
default:
WARN("-- unknown code %i\n", uAction );
SHELL_hWnd = 0; /* just in case */
}
return FALSE;
}
/***********************************************************************
* COMDLG32_FR_CheckPartial [internal]
* Check various fault conditions in the supplied parameters that
* cause an extended error to be reported.
* RETURNS
* TRUE: Success
* FALSE: Failure
*/
static BOOL COMDLG32_FR_CheckPartial(
const FINDREPLACEA *pfr, /* [in] Find structure */
BOOL Replace /* [in] True if called as replace */
) {
if(!pfr)
{
COMDLG32_SetCommDlgExtendedError(CDERR_GENERALCODES);
return FALSE;
}
if(pfr->lStructSize != sizeof(FINDREPLACEA))
{
COMDLG32_SetCommDlgExtendedError(CDERR_STRUCTSIZE);
return FALSE;
}
if(!IsWindow(pfr->hwndOwner))
{
COMDLG32_SetCommDlgExtendedError(CDERR_DIALOGFAILURE);
return FALSE;
}
if((pfr->wFindWhatLen < 1 || !pfr->lpstrFindWhat)
||(Replace && (pfr->wReplaceWithLen < 1 || !pfr->lpstrReplaceWith)))
{
COMDLG32_SetCommDlgExtendedError(FRERR_BUFFERLENGTHZERO);
return FALSE;
}
if((FindReplaceMessage = RegisterWindowMessageA(FINDMSGSTRINGA)) == 0)
{
COMDLG32_SetCommDlgExtendedError(CDERR_REGISTERMSGFAIL);
return FALSE;
}
if((HelpMessage = RegisterWindowMessageA(HELPMSGSTRINGA)) == 0)
{
COMDLG32_SetCommDlgExtendedError(CDERR_REGISTERMSGFAIL);
return FALSE;
}
if((pfr->Flags & FR_ENABLEHOOK) && !pfr->lpfnHook)
{
COMDLG32_SetCommDlgExtendedError(CDERR_NOHOOK);
return FALSE;
}
if((pfr->Flags & (FR_ENABLETEMPLATE | FR_ENABLETEMPLATEHANDLE)) && !pfr->hInstance)
{
COMDLG32_SetCommDlgExtendedError(CDERR_NOHINSTANCE);
return FALSE;
}
if((pfr->Flags & FR_ENABLETEMPLATE) && !pfr->lpTemplateName)
{
COMDLG32_SetCommDlgExtendedError(CDERR_NOTEMPLATE);
return FALSE;
}
return TRUE;
}
/*************************************************************************
* RegisterShellHook [SHELL.102]
*/
BOOL WINAPI RegisterShellHook16(HWND16 hWnd, UINT16 uAction)
{
TRACE("%04x [%u]\n", hWnd, uAction );
switch( uAction )
{
case 2: /* register hWnd as a shell window */
if( !SHELL_hHook )
{
HMODULE16 hShell = GetModuleHandle16( "SHELL" );
HOOKPROC16 hookProc = (HOOKPROC16)GetProcAddress16( hShell, (LPCSTR)103 );
SHELL_hHook = SetWindowsHookEx16( WH_SHELL, hookProc, hShell, 0 );
if ( SHELL_hHook )
{
uMsgWndCreated = RegisterWindowMessageA( lpstrMsgWndCreated );
uMsgWndDestroyed = RegisterWindowMessageA( lpstrMsgWndDestroyed );
uMsgShellActivate = RegisterWindowMessageA( lpstrMsgShellActivate );
}
else
WARN("-- unable to install ShellHookProc()!\n");
}
if ( SHELL_hHook )
return ((SHELL_hWnd = hWnd) != 0);
break;
default:
WARN("-- unknown code %i\n", uAction );
SHELL_hWnd = 0; /* just in case */
}
return FALSE;
}
MainApp::MainApp (int &argc, char **argv)
: QtSingleApplication (argc, argv)
{
#ifdef Q_WS_WIN32
uidDiscover = RegisterWindowMessageA ("SkypeControlAPIDiscover");
uidAttach = RegisterWindowMessageA ("SkypeControlAPIAttach");
hSkypeWindow = NULL;
#endif
}//MainApp::MainApp
void WinConsole::CreateTrayIcon()
{
m_taskbarCreatedMessage = RegisterWindowMessageA("TaskbarCreated") ;
char className[] = "NZBGet tray window";
WNDCLASSEX wnd;
memset(&wnd, 0, sizeof(wnd));
wnd.hInstance = m_instance;
wnd.lpszClassName = className;
wnd.lpfnWndProc = TrayWndProcStat;
wnd.style = 0;
wnd.cbSize = sizeof(WNDCLASSEX);
RegisterClassEx(&wnd);
m_trayWindow = CreateWindowEx(0, className, "NZBGet", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT, nullptr, nullptr, m_instance, nullptr);
m_iconData = new NOTIFYICONDATA;
memset(m_iconData, 0, sizeof(NOTIFYICONDATA));
m_iconData->cbSize = sizeof(NOTIFYICONDATA);
m_iconData->hWnd = m_trayWindow;
m_iconData->uID = 100;
m_iconData->uCallbackMessage = UM_TRAYICON;
m_iconData->hIcon = m_workingIcon;
strncpy(m_iconData->szTip, "NZBGet", sizeof(m_iconData->szTip));
m_iconData->uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
}
void InitMain()
{
bInitMain=TRUE;
//Get 16x16 icon
hMainSmallIcon=(HICON)CopyImage((HANDLE)hMainIcon, IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_COPYFROMRESOURCE);
//Register unique message
if (!nMinimizeToTrayMessage)
nMinimizeToTrayMessage=RegisterWindowMessageA("MinimizeToTray");
//Popup menu
if (!hMenuList)
{
if (hMenuList=CreatePopupMenu())
{
AppendMenuWide(hMenuList, MF_STRING, IDC_ITEM_RESTORE, GetLangStringW(wLangModule, STRID_MENU_RESTORE));
AppendMenuWide(hMenuList, MF_SEPARATOR, (UINT)-1, NULL);
AppendMenuWide(hMenuList, MF_STRING, IDC_ITEM_EXIT, GetLangStringW(wLangModule, STRID_MENU_EXIT));
}
}
//SubClass
NewMainProcData=NULL;
SendMessage(hMainWnd, AKD_SETMAINPROC, (WPARAM)NewEditParentProc, (LPARAM)&NewMainProcData);
if (nMDI == WMD_MDI)
{
NewFrameProcData=NULL;
SendMessage(hMainWnd, AKD_SETFRAMEPROC, (WPARAM)NewEditParentProc, (LPARAM)&NewFrameProcData);
}
}
WinDockPlugin::WinDockPlugin(unsigned base, Buffer *config)
: Plugin(base), EventReceiver(DefaultPriority - 1)
{
dock = this;
load_data(winDockData, &data, config);
CmdAutoHide = registerType();
Command cmd;
cmd->id = CmdAutoHide;
cmd->text = I18N_NOOP("AutoHide");
cmd->menu_id = MenuMain;
cmd->menu_grp = 0x7001;
cmd->flags = COMMAND_CHECK_STATE;
m_bInit = false;
m_autoHide = new QTimer(this);
connect(m_autoHide, SIGNAL(timeout()), this, SLOT(slotAutoHide()));
Event eCmd(EventCommandCreate, cmd);
eCmd.process();
WM_APPBAR = RegisterWindowMessageA("AppBarNotify");
init();
}
/***********************************************************************
* User32InitializeImmEntryTable
*/
BOOL WINAPI User32InitializeImmEntryTable(DWORD magic)
{
static const WCHAR imm32_dllW[] = {'i','m','m','3','2','.','d','l','l',0};
HMODULE imm32 = GetModuleHandleW(imm32_dllW);
TRACE("(%x)\n", magic);
if (!imm32 || magic != IMM_INIT_MAGIC)
return FALSE;
if (imm_get_ui_window)
return TRUE;
WM_MSIME_SERVICE = RegisterWindowMessageA("MSIMEService");
WM_MSIME_RECONVERTOPTIONS = RegisterWindowMessageA("MSIMEReconvertOptions");
WM_MSIME_MOUSE = RegisterWindowMessageA("MSIMEMouseOperation");
WM_MSIME_RECONVERTREQUEST = RegisterWindowMessageA("MSIMEReconvertRequest");
WM_MSIME_RECONVERT = RegisterWindowMessageA("MSIMEReconvert");
WM_MSIME_QUERYPOSITION = RegisterWindowMessageA("MSIMEQueryPosition");
WM_MSIME_DOCUMENTFEED = RegisterWindowMessageA("MSIMEDocumentFeed");
/* this part is not compatible with native imm32.dll */
imm_get_ui_window = (void*)GetProcAddress(imm32, "__wine_get_ui_window");
if (!imm_get_ui_window)
FIXME("native imm32.dll not supported\n");
return TRUE;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
PSTR pCmdLine, int nCmdShow)
{
MSG msg;
WNDCLASSW wc;
TCHAR szFileName[MAX_PATH];
GetModuleFileName(NULL, szFileName, MAX_PATH);
KillProcessByNameExcludingMyself(PathFindFileName(szFileName));
_msgDiscover = RegisterWindowMessageA("SkypeControlAPIDiscover");
_msgDiscoverTest = RegisterWindowMessageA("SkypeControlAPIDiscoverTest");
_msgAttach = RegisterWindowMessageA("SkypeControlAPIAttach");
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.lpszClassName = L"papi_proxy";
wc.hInstance = hInstance;
wc.hbrBackground = GetSysColorBrush(COLOR_3DFACE);
wc.lpszMenuName = NULL;
wc.lpfnWndProc = WndProc;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
RegisterClassW(&wc);
_hwnd = CreateWindowW(wc.lpszClassName, L"Public API Proxy",
WS_DLGFRAME | WS_SYSMENU | WS_MINIMIZEBOX,
WND_POS_X, WND_POS_Y, WND_WIDTH, WND_HEIGHT,
NULL, NULL, hInstance, NULL);
ShowWindow(_hwnd, nCmdShow);
UpdateWindow(_hwnd);
SkypeAttach(_hwnd);
while(GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return (int) msg.wParam;
}
static BOOL WINAPI register_classes( INIT_ONCE *once, void *param, void **context )
{
WNDCLASSW wndClass;
ZeroMemory(&wndClass, sizeof(WNDCLASSW));
wndClass.style = CS_GLOBALCLASS | CS_IME | CS_HREDRAW | CS_VREDRAW;
wndClass.lpfnWndProc = IME_WindowProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 2 * sizeof(LONG_PTR);
wndClass.hInstance = x11drv_module;
wndClass.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
wndClass.hIcon = LoadIconW(NULL, (LPWSTR)IDI_APPLICATION);
wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW +1);
wndClass.lpszMenuName = 0;
wndClass.lpszClassName = UI_CLASS_NAME;
RegisterClassW(&wndClass);
WM_MSIME_SERVICE = RegisterWindowMessageA("MSIMEService");
WM_MSIME_RECONVERTOPTIONS = RegisterWindowMessageA("MSIMEReconvertOptions");
WM_MSIME_MOUSE = RegisterWindowMessageA("MSIMEMouseOperation");
WM_MSIME_RECONVERTREQUEST = RegisterWindowMessageA("MSIMEReconvertRequest");
WM_MSIME_RECONVERT = RegisterWindowMessageA("MSIMEReconvert");
WM_MSIME_QUERYPOSITION = RegisterWindowMessageA("MSIMEQueryPosition");
WM_MSIME_DOCUMENTFEED = RegisterWindowMessageA("MSIMEDocumentFeed");
return TRUE;
}
//
// Setup the EventFilter
//
void FaceApp::SetupEventFilter( FaceTrackNoIR *window ) {
mainWindow = window;
msgID_FTClient = RegisterWindowMessageA ( FT_PROGRAMID );
qDebug() << "FaceApp::SetupEventFilter says: Message ID =" << msgID_FTClient;
msgID_FTIR_Register = RegisterWindowMessageA ( FTIR_REGISTER_PROGRAMHANDLE );
msgID_FTIR_UnRegister = RegisterWindowMessageA ( FTIR_UNREGISTER_PROGRAMHANDLE );
////if ( RegisterHotKey( window->winId(), 777, MOD_WIN, VK_HOME ) ) {
//// qDebug() << "FaceApp::SetupEventFilter says: RegisterHotKey HOME =" << VK_HOME;
////}
////if ( RegisterHotKey( window->winId(), 778, MOD_WIN, VK_END ) ) {
//// qDebug() << "FaceApp::SetupEventFilter says: RegisterHotKey END =" << VK_END;
////}
////
////QAbstractEventDispatcher *evtdis = QAbstractEventDispatcher::instance();
////if (evtdis != NULL) {
//// qDebug() << "FaceApp::SetupEventFilter says: EventDispatcher found!";
////}
}
/************************************************************************
* FD31_AllocPrivate [internal]
* allocate a private object to hold 32 bits Unicode
* structure that will be used throughtout the calls, while
* keeping available the original structures and a few variables
* On entry : type = dialog procedure type (16,32A,32W)
* dlgType = dialog type (open or save)
*/
PFD31_DATA FD31_AllocPrivate(LPARAM lParam, UINT dlgType,
PFD31_CALLBACKS callbacks, DWORD data)
{
PFD31_DATA lfs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FD31_DATA));
TRACE("alloc private buf %p\n", lfs);
if (!lfs) return NULL;
lfs->hook = FALSE;
lfs->lParam = lParam;
lfs->open = (dlgType == OPEN_DIALOG);
lfs->callbacks = callbacks;
if (! lfs->callbacks->Init(lParam, lfs, data))
{
FD31_DestroyPrivate(lfs);
return NULL;
}
lfs->lbselchstring = RegisterWindowMessageA(LBSELCHSTRINGA);
lfs->fileokstring = RegisterWindowMessageA(FILEOKSTRINGA);
return lfs;
}
bool InitGlobalData(PHVNC lpServer)
{
bool ret_val=false;
do
{
lpServer->hGlobalVNCMapping=CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,sizeof(GLOBAL_VNC_DATA),lpServer->Names.szGlobalMappingName);
lpServer->lpGlobalVNCData=(GLOBAL_VNC_DATA *)MapViewOfFile(lpServer->hGlobalVNCMapping,FILE_MAP_ALL_ACCESS,0,0,0);
if ((!lpServer->lpGlobalVNCData) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->lpGlobalVNCData->dwVNCMessage=RegisterWindowMessageA(lpServer->DeskInfo.szDeskName);
if (!lpServer->lpGlobalVNCData->dwVNCMessage)
break;
lpServer->EventsInfo.hInputMutex=CreateMutex(NULL,false,lpServer->Names.szInputMutex);
if ((!lpServer->EventsInfo.hInputMutex) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hPaintMutex=CreateMutex(NULL,false,NULL);
if (!lpServer->EventsInfo.hPaintMutex)
break;
lpServer->EventsInfo.hSharedMemMutex=CreateMutex(NULL,false,lpServer->Names.szSharedMemMutex);
if ((!lpServer->EventsInfo.hSharedMemMutex) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hSendThreadMessageMutex=CreateMutex(NULL,false,lpServer->Names.szSendThreadMessageMutex);
if ((!lpServer->EventsInfo.hSendThreadMessageMutex) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hSendThreadMessageEvent=CreateEvent(NULL,true,false,lpServer->Names.szSendThreadMessageEvent);
if ((!lpServer->EventsInfo.hSendThreadMessageEvent) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hVNCKillEvent=CreateEvent(NULL,true,false,lpServer->Names.szVNCKillEventName);
if ((!lpServer->EventsInfo.hVNCKillEvent) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hClipboardUpdatedEvent=CreateEvent(NULL,false,false,lpServer->Names.szClipboardUpdatedEvent);
if ((!lpServer->EventsInfo.hClipboardUpdatedEvent) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
if ((GetWindowsDirectoryA(lpServer->Names.szShell,sizeof(lpServer->Names.szShell))) || (GetEnvironmentVariableA("windir",lpServer->Names.szShell,sizeof(lpServer->Names.szShell))))
lstrcatA(lpServer->Names.szShell,"\\explorer.exe");
else
break;
ret_val=true;
}
while (false);
return ret_val;
}
/* DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDS */
TW_UINT16 SANE_EnableDSUserInterface (pTW_IDENTITY pOrigin,
TW_MEMREF pData)
{
TW_UINT16 twRC = TWRC_SUCCESS;
pTW_USERINTERFACE pUserInterface = (pTW_USERINTERFACE) pData;
TRACE ("DG_CONTROL/DAT_USERINTERFACE/MSG_ENABLEDS\n");
if (activeDS.currentState != 4)
{
twRC = TWRC_FAILURE;
activeDS.twCC = TWCC_SEQERROR;
WARN("sequence error %d\n", activeDS.currentState);
}
else
{
activeDS.hwndOwner = pUserInterface->hParent;
if (! activeDS.windowMessage)
activeDS.windowMessage = RegisterWindowMessageA("SANE.DS ACTIVITY MESSAGE");
if (pUserInterface->ShowUI)
{
BOOL rc;
activeDS.currentState = 5; /* Transitions to state 5 */
rc = DoScannerUI();
pUserInterface->ModalUI = TRUE;
if (!rc)
{
if (activeDS.windowMessage)
PostMessageA(activeDS.hwndOwner, activeDS.windowMessage, MSG_CLOSEDSREQ, 0);
}
#ifdef SONAME_LIBSANE
else
{
psane_get_parameters (activeDS.deviceHandle, &activeDS.sane_param);
activeDS.sane_param_valid = TRUE;
}
#endif
}
else
{
/* no UI will be displayed, so source is ready to transfer data */
activeDS.currentState = 6; /* Transitions to state 6 directly */
if (activeDS.windowMessage)
PostMessageA(activeDS.hwndOwner, activeDS.windowMessage, MSG_XFERREADY, 0);
}
twRC = TWRC_SUCCESS;
activeDS.twCC = TWCC_SUCCESS;
}
return twRC;
}
void Entry(void)
{
HANDLE hMutex;
int result=1;
Options options;
g_controlMsg=RegisterWindowMessageA(CONTROL_MESSAGE_NAME);
ZeroFill(&options,sizeof options);
ProcessCommandLine(&options);
#ifdef _DEBUG
options.showWindow=TRUE;
#endif
hMutex=OpenMutexA(MUTEX_ALL_ACCESS,FALSE,MUTEX_NAME);
if(hMutex)
{
// Already running.
ApplyOptions(&options);
}
else
{
if(options.nextLayout||options.prevLayout)
{
// Don't do anything.
}
else
{
hMutex=CreateMutexA(0,FALSE,MUTEX_NAME);
if(!RunHelpers())
result=1;
else
{
result=Main(&options);
ReleaseMutex(hMutex);
hMutex=NULL;
}
PostMessage(HWND_BROADCAST,g_controlMsg,CONTROL_QUIT,0);
}
}
LocalFree(options.pLayoutToSet);
options.pLayoutToSet=NULL;
ExitProcess(result);
}
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, INT nCmdShow)
{
HANDLE hMutex;
HWND hDlg;
MSG msg;
if ((hMutex = OpenMutex(MUTEX_ALL_ACCESS, TRUE, MUTEX_NAME)) == NULL) {
CreateMutex(NULL, TRUE, MUTEX_NAME);
} else {
ReleaseMutex(hMutex);
return EXIT_SUCCESS;
}
InitCommonControls();
WorkerLoadResources(hInstance);
Worker.dwKeyTime = 0;
Worker.isInvisible = TRUE;
WM_TASKBARCREATED = RegisterWindowMessageA("TaskbarCreated");
if ((hDlg = CreateDialogParam(hInstance, MAKEINTRESOURCE(IDD_MAIN), 0, DlgProc, 0)) == NULL) {
WorkerError(App.Strings.errWinCreat);
return EXIT_FAILURE;
}
if ((App.notifyIconData = WorkerNotifyIconData(hInstance, hDlg)) == NULL) {
WorkerError(App.Strings.errNoMem);
return EXIT_FAILURE;
}
ShowWindow(hDlg, nCmdShow);
SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, hInstance, 0);
while (GetMessage(&msg, NULL, 0, 0) > 0) {
if (!IsDialogMessage(hDlg, &msg)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
if (!IsWindowVisible(hDlg)) {
Shell_NotifyIcon(NIM_DELETE, App.notifyIconData);
}
HeapFree(GetProcessHeap(), 0, App.notifyIconData);
return (INT) msg.wParam;
}
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR args, int iCmdShow )
{
TCHAR className[] = TEXT( "tray icon class" );
WM_TASKBARCREATED = RegisterWindowMessageA("TaskbarCreated") ;
WNDCLASSEX wnd = { 0 };
wnd.hInstance = hInstance;
wnd.lpszClassName = className;
wnd.lpfnWndProc = WndProc;
wnd.style = CS_HREDRAW | CS_VREDRAW ;
wnd.cbSize = sizeof (WNDCLASSEX);
wnd.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wnd.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
wnd.hCursor = LoadCursor (NULL, IDC_ARROW);
wnd.hbrBackground = (HBRUSH)COLOR_APPWORKSPACE ;
if (!RegisterClassEx(&wnd))
{
FatalAppExit( 0, TEXT("Couldn't register window class!") );
}
g_hwnd = CreateWindowEx(0, className, TEXT( "Using the system tray" ), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 400, 400, NULL, NULL, hInstance, NULL);
InitNotifyIconData();
Shell_NotifyIcon(NIM_ADD, &g_notifyIconData);
ZeroMQContext::init();
Exit exit;
MSG msg ;
while (!quit)
{
PeekMessage(&msg, 0, 0, 0, PM_REMOVE);
exit.receive_input();
TranslateMessage(&msg);
DispatchMessage(&msg);
}
Shell_NotifyIcon(NIM_DELETE, &g_notifyIconData);
return msg.wParam;
}
int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPTSTR lpCmdLine,
_In_ int nCmdShow)
{
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
// TODO: Place code here.
MSG msg;
HACCEL hAccelTable;
TCHAR className[] = TEXT("tray icon");
WM_TASKBARCREATED = RegisterWindowMessageA("CreatedTaskBar");
// Initialize global strings
hInst = hInstance; // Store instance handle in our global variable
// Initialize global strings
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(hInstance, IDC_PROGTASKBAR, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance);
// Perform application initialization:
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_PROGTASKBAR));
// Main message loop:
while (GetMessage(&msg, NULL, 0, 0))
{
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
if (!IsWindowVisible(g_hwnd))
Shell_NotifyIcon(NIM_DELETE, &g_notifyIconData);
return (int) msg.wParam;
}
QSystemTrayIconSys::QSystemTrayIconSys(QSystemTrayIcon *object)
: hIcon(0), q(object)
{
currentShellVersion = detectShellVersion();
notifyIconSizeA = FIELD_OFFSET(NOTIFYICONDATAA, szTip[64]); // NOTIFYICONDATAA_V1_SIZE
notifyIconSizeW = FIELD_OFFSET(NOTIFYICONDATAW, szTip[64]); // NOTIFYICONDATAW_V1_SIZE;
maxTipLength = 64;
#if NOTIFYICON_VERSION >= 3
if (currentShellVersion >=5) {
notifyIconSizeA = FIELD_OFFSET(NOTIFYICONDATAA, guidItem); // NOTIFYICONDATAA_V2_SIZE
notifyIconSizeW = FIELD_OFFSET(NOTIFYICONDATAW, guidItem); // NOTIFYICONDATAW_V2_SIZE;
maxTipLength = 128;
}
#endif
// For restoring the tray icon after explorer crashes
if (!MYWM_TASKBARCREATED) {
MYWM_TASKBARCREATED = QT_WA_INLINE(RegisterWindowMessageW(L"TaskbarCreated"),RegisterWindowMessageA("TaskbarCreated"));
}
}
BOOL FInitFile(
HANDLE hins)
{
bMouse = GetSystemMetrics(SM_MOUSEPRESENT);
wWinVer = 0x0A0A;
//
// Initialize these to reality.
//
#if DPMICDROMCHECK
wCDROMIndex = InitCDROMIndex((LPWORD)&wNumCDROMDrives);
#endif
//
// special WOW messages
//
msgWOWLFCHANGE = RegisterWindowMessageA((LPSTR)szmsgWOWLFCHANGE);
msgWOWDIRCHANGE = RegisterWindowMessageA((LPSTR)szmsgWOWDIRCHANGE);
msgWOWCHOOSEFONT_GETLOGFONT = RegisterWindowMessageA((LPSTR)szmsgWOWCHOOSEFONT_GETLOGFONT);
msgLBCHANGEA = RegisterWindowMessageA((LPSTR)szmsgLBCHANGEA);
msgSHAREVIOLATIONA = RegisterWindowMessageA((LPSTR)szmsgSHAREVIOLATIONA);
msgFILEOKA = RegisterWindowMessageA((LPSTR)szmsgFILEOKA);
msgCOLOROKA = RegisterWindowMessageA((LPSTR)szmsgCOLOROKA);
msgSETRGBA = RegisterWindowMessageA((LPSTR)szmsgSETRGBA);
msgLBCHANGEW = RegisterWindowMessageW((LPWSTR)szmsgLBCHANGEW);
msgSHAREVIOLATIONW = RegisterWindowMessageW((LPWSTR)szmsgSHAREVIOLATIONW);
msgFILEOKW = RegisterWindowMessageW((LPWSTR)szmsgFILEOKW);
msgCOLOROKW = RegisterWindowMessageW((LPWSTR)szmsgCOLOROKW);
msgSETRGBW = RegisterWindowMessageW((LPWSTR)szmsgSETRGBW);
g_cfCIDA = RegisterClipboardFormat(szShellIDList);
return (TRUE);
}
/***********************************************************************
* PRINTDLG_WMInitDialog [internal]
*/
static LRESULT PRINTDLG_WMInitDialog16(HWND hDlg, WPARAM wParam, PRINT_PTRA16* ptr16)
{
PRINT_PTRA *PrintStructures = &ptr16->print32;
LPPRINTDLG16 lppd = ptr16->lpPrintDlg16;
DEVNAMES *pdn;
DEVMODEA *pdm;
char *name = NULL;
UINT comboID = (lppd->Flags & PD_PRINTSETUP) ? cmb1 : cmb4;
/* load Collate ICONs */
PrintStructures->hCollateIcon =
LoadIconA(COMDLG32_hInstance, "PD32_COLLATE");
PrintStructures->hNoCollateIcon =
LoadIconA(COMDLG32_hInstance, "PD32_NOCOLLATE");
if(PrintStructures->hCollateIcon == 0 ||
PrintStructures->hNoCollateIcon == 0) {
ERR("no icon in resourcefile\n");
COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
EndDialog(hDlg, FALSE);
}
/* load Paper Orientation ICON */
/* FIXME: not implemented yet */
/*
* if lppd->Flags PD_SHOWHELP is specified, a HELPMESGSTRING message
* must be registered and the Help button must be shown.
*/
if (lppd->Flags & PD_SHOWHELP) {
if((PrintStructures->HelpMessageID =
RegisterWindowMessageA(HELPMSGSTRINGA)) == 0) {
COMDLG32_SetCommDlgExtendedError(CDERR_REGISTERMSGFAIL);
return FALSE;
}
} else
PrintStructures->HelpMessageID = 0;
if (!(lppd->Flags & PD_PRINTSETUP)) {
/* We have a print quality combo box. What shall we do? */
if (GetDlgItem(hDlg,cmb1)) {
char buf [20];
FIXME("Print quality only displaying currently.\n");
pdm = GlobalLock16(lppd->hDevMode);
if(pdm) {
switch (pdm->u1.s1.dmPrintQuality) {
case DMRES_HIGH :
strcpy(buf,"High");
break;
case DMRES_MEDIUM :
strcpy(buf,"Medium");
break;
case DMRES_LOW :
strcpy(buf,"Low");
break;
case DMRES_DRAFT :
strcpy(buf,"Draft");
break;
case 0 :
strcpy(buf,"Default");
break;
default :
sprintf(buf,"%ddpi",pdm->u1.s1.dmPrintQuality);
break;
}
GlobalUnlock16(lppd->hDevMode);
} else
strcpy(buf,"Default");
SendDlgItemMessageA(hDlg,cmb1,CB_ADDSTRING,0,(LPARAM)buf);
SendDlgItemMessageA(hDlg,cmb1,CB_SETCURSEL,0,0);
EnableWindow(GetDlgItem(hDlg,cmb1),FALSE);
}
}
/* FIXME: I allow more freedom than either Win95 or WinNT,
* which do not agree to what errors should be thrown or not
* in case nToPage or nFromPage is out-of-range.
*/
if (lppd->nMaxPage < lppd->nMinPage)
lppd->nMaxPage = lppd->nMinPage;
if (lppd->nMinPage == lppd->nMaxPage)
lppd->Flags |= PD_NOPAGENUMS;
if (lppd->nToPage < lppd->nMinPage)
lppd->nToPage = lppd->nMinPage;
if (lppd->nToPage > lppd->nMaxPage)
lppd->nToPage = lppd->nMaxPage;
if (lppd->nFromPage < lppd->nMinPage)
lppd->nFromPage = lppd->nMinPage;
if (lppd->nFromPage > lppd->nMaxPage)
lppd->nFromPage = lppd->nMaxPage;
/* If the printer combo box is in the dialog, fill it */
if (GetDlgItem(hDlg,comboID)) {
/* Fill Combobox
*/
pdn = GlobalLock16(lppd->hDevNames);
pdm = GlobalLock16(lppd->hDevMode);
if(pdn)
name = (char*)pdn + pdn->wDeviceOffset;
else if(pdm)
name = (char*)pdm->dmDeviceName;
PRINTDLG_SetUpPrinterListComboA(hDlg, comboID, name);
if(pdm) GlobalUnlock16(lppd->hDevMode);
if(pdn) GlobalUnlock16(lppd->hDevNames);
/* Now find selected printer and update rest of dlg */
name = HeapAlloc(GetProcessHeap(),0,256);
if (GetDlgItemTextA(hDlg, comboID, name, 255))
PRINTDLG_ChangePrinterA(hDlg, name, PrintStructures);
} else {
/* else just use default printer */
char name[200];
DWORD dwBufLen = sizeof(name);
BOOL ret = GetDefaultPrinterA(name, &dwBufLen);
if (ret)
PRINTDLG_ChangePrinterA(hDlg, name, PrintStructures);
else
FIXME("No default printer found, expect problems!\n");
}
HeapFree(GetProcessHeap(),0,name);
return TRUE;
}
static INT_PTR CALLBACK FormatChooseDlgProc(HWND hWnd, UINT msg,
WPARAM wParam, LPARAM lParam)
{
TRACE("hwnd=%p msg=%i 0x%08lx 0x%08lx\n", hWnd, msg, wParam, lParam );
switch (msg) {
case WM_INITDIALOG:
afc = (PACMFORMATCHOOSEA)lParam;
MSACM_FillFormatTags(hWnd);
MSACM_FillFormat(hWnd);
if ((afc->fdwStyle & ~(ACMFORMATCHOOSE_STYLEF_CONTEXTHELP|
ACMFORMATCHOOSE_STYLEF_SHOWHELP)) != 0)
FIXME("Unsupported style %08x\n", ((PACMFORMATCHOOSEA)lParam)->fdwStyle);
if (!(afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP))
ShowWindow(GetDlgItem(hWnd, IDD_ACMFORMATCHOOSE_BTN_HELP), SW_HIDE);
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK:
EndDialog(hWnd, MSACM_GetWFX(hWnd, afc));
return TRUE;
case IDCANCEL:
EndDialog(hWnd, ACMERR_CANCELED);
return TRUE;
case IDD_ACMFORMATCHOOSE_CMB_FORMATTAG:
switch (HIWORD(wParam)) {
case CBN_SELCHANGE:
MSACM_FillFormat(hWnd);
break;
default:
TRACE("Dropped dlgNotif (fmtTag): 0x%08x 0x%08lx\n",
HIWORD(wParam), lParam);
break;
}
break;
case IDD_ACMFORMATCHOOSE_BTN_HELP:
if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP)
SendMessageA(afc->hwndOwner,
RegisterWindowMessageA(ACMHELPMSGSTRINGA), 0L, 0L);
break;
default:
TRACE("Dropped dlgCmd: ctl=%d ntf=0x%04x 0x%08lx\n",
LOWORD(wParam), HIWORD(wParam), lParam);
break;
}
break;
case WM_CONTEXTMENU:
if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
SendMessageA(afc->hwndOwner,
RegisterWindowMessageA(ACMHELPMSGCONTEXTMENUA),
wParam, lParam);
break;
#if defined(WM_CONTEXTHELP)
case WM_CONTEXTHELP:
if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
SendMessageA(afc->hwndOwner,
RegisterWindowMessageA(ACMHELPMSGCONTEXTHELPA),
wParam, lParam);
break;
#endif
default:
TRACE("Dropped dlgMsg: hwnd=%p msg=%i 0x%08lx 0x%08lx\n",
hWnd, msg, wParam, lParam );
break;
}
return FALSE;
}
BOOL WINAPI DllMain(HMODULE hmod, DWORD dwReason, LPVOID lpvReserved)
{
_OSVERSIONINFOA osversioninfo;
if(dwReason == DLL_PROCESS_DETACH) // We are unloading
{
FreeFontCache();
DestroyFormatCaches();
ReleaseTypeInfoPtrs();
UninitKinsokuClassify();
if(fOleInitialized)
OleUninitialize();
if(hinstRE)
{
UnregisterClassA(szClassREA, hinstRE);
#ifdef RICHED32_BUILD
UnregisterClassA(szClassRE10A, hinstRE);
#endif
UnregisterClass(wszClassREW, hinstRE);
}
DeleteCriticalSection(&g_CriticalSection);
}
else if(dwReason == DLL_PROCESS_ATTACH) // We have just loaded
{
InitializeCriticalSection(&g_CriticalSection);
if( FAILED(OleInitialize(NULL)) )
{
return FALSE;
}
else
{
fOleInitialized = TRUE;
}
//NB!! Do not allocate memory before OLE is initialized.
InitUnicodeWrappers(); // Init UNICODE wrappers for Chicago
GetSysParms(); // Define screen/window parms
RegisterFETCs(); // Register new clipboard formats
CreateFormatCaches(); // Create global format caches
InitNLSProcTable(); // Get National Language Support Functions.
if ( !InitKinsokuClassify() ) // Init tables for classifying Unicode chars.
return FALSE;
// Magellan Mouse.
gWM_MouseRoller = RegisterWindowMessageA(MSH_MOUSEWHEEL);
hinstRE = hmod;
osversioninfo.dwOSVersionInfoSize = sizeof(_OSVERSIONINFOA);
GetVersionExA(&osversioninfo);
dwPlatformId = osversioninfo.dwPlatformId;
dwMajorVersion = osversioninfo.dwMajorVersion;
if(osversioninfo.dwMajorVersion >= VERS4)
{
icr3DDarkShadow = COLOR_3DDKSHADOW;
}
if(!RichFRegisterClass())
{
#ifdef DEBUG
OutputDebugStringA("Could not register RICHED20 class.\r\n");
#endif // DEBUG
//return FALSE;
}
InitFontCache();
}
return TRUE;
}
LONG_PTR CALLBACK HotkeyHandlerDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static POINT ptLast;
static int iMousedown;
if (msg == WM_TASKBARCREATED) {
CreateSystrayIcon(FALSE);
if (nen_options.bTraySupport)
CreateSystrayIcon(TRUE);
return 0;
}
switch (msg) {
case WM_CREATE:
int i;
for(i = 0; i < safe_sizeof(_hotkeydescs); i++) {
_hotkeydescs[i].cbSize = sizeof(HOTKEYDESC);
CallService(MS_HOTKEY_REGISTER, 0, (LPARAM)&_hotkeydescs[i]);
}
WM_TASKBARCREATED = RegisterWindowMessageA("TaskbarCreated");
ShowWindow(hwndDlg, SW_HIDE);
hSvcHotkeyProcessor = CreateServiceFunction(MS_TABMSG_HOTKEYPROCESS, HotkeyProcessor);
SetTimer(hwndDlg, TIMERID_SENDLATER, TIMEOUT_SENDLATER, NULL);
break;
case WM_HOTKEY: {
CLISTEVENT *cli = 0;
cli = (CLISTEVENT *)CallService(MS_CLIST_GETEVENT, (WPARAM)INVALID_HANDLE_VALUE, (LPARAM)0);
if (cli != NULL) {
if (strncmp(cli->pszService, "SRMsg/TypingMessage", strlen(cli->pszService))) {
CallService(cli->pszService, 0, (LPARAM)cli);
break;
}
}
if (wParam == 0xc001)
SendMessage(hwndDlg, DM_TRAYICONNOTIFY, 101, WM_MBUTTONDOWN);
break;
}
/*
* handle the popup menus (session list, favorites, recents...
* just draw some icons, nothing more :)
*/
case WM_MEASUREITEM: {
LPMEASUREITEMSTRUCT lpmi = (LPMEASUREITEMSTRUCT) lParam;
lpmi->itemHeight = 0;
lpmi->itemWidth = 6;
return TRUE;
}
case WM_DRAWITEM: {
LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT) lParam;
struct TWindowData *dat = 0;
if (dis->CtlType == ODT_MENU && (dis->hwndItem == (HWND)PluginConfig.g_hMenuFavorites || dis->hwndItem == (HWND)PluginConfig.g_hMenuRecent)) {
HICON hIcon = (HICON)dis->itemData;
DrawMenuItem(dis, hIcon, 0);
return TRUE;
} else if (dis->CtlType == ODT_MENU) {
HWND hWnd = M->FindWindow((HANDLE)dis->itemID);
DWORD idle = 0;
if (hWnd == NULL) {
SESSION_INFO *si = SM_FindSessionByHCONTACT((HANDLE)dis->itemID);
hWnd = si ? si->hWnd : 0;
}
if (hWnd)
dat = (struct TWindowData *)GetWindowLongPtr(hWnd, GWLP_USERDATA);
if (dis->itemData >= 0) {
HICON hIcon;
BOOL fNeedFree = FALSE;
if (dis->itemData > 0)
hIcon = dis->itemData & 0x10000000 ? hIcons[ICON_HIGHLIGHT] : PluginConfig.g_IconMsgEvent;
else if (dat != NULL) {
hIcon = MY_GetContactIcon(dat);
idle = dat->idle;
} else
hIcon = PluginConfig.g_iconContainer;
DrawMenuItem(dis, hIcon, idle);
if (fNeedFree)
DestroyIcon(hIcon);
return TRUE;
}
}
}
break;
case DM_TRAYICONNOTIFY: {
int iSelection;
if (wParam == 100 || wParam == 101) {
switch (lParam) {
case WM_LBUTTONUP: {
POINT pt;
GetCursorPos(&pt);
if (wParam == 100)
SetForegroundWindow(hwndDlg);
if (GetMenuItemCount(PluginConfig.g_hMenuTrayUnread) > 0) {
iSelection = TrackPopupMenu(PluginConfig.g_hMenuTrayUnread, TPM_RETURNCMD, pt.x, pt.y, 0, hwndDlg, NULL);
HandleMenuEntryFromhContact(iSelection);
} else
TrackPopupMenu(GetSubMenu(PluginConfig.g_hMenuContext, 8), TPM_RETURNCMD, pt.x, pt.y, 0, hwndDlg, NULL);
if (wParam == 100)
PostMessage(hwndDlg, WM_NULL, 0, 0);
break;
}
case WM_MBUTTONDOWN: {
MENUITEMINFOA mii = {0};
int i, iCount = GetMenuItemCount(PluginConfig.g_hMenuTrayUnread);
if (wParam == 100)
SetForegroundWindow(hwndDlg);
if (iCount > 0) {
UINT uid = 0;
mii.fMask = MIIM_DATA;
mii.cbSize = sizeof(mii);
i = iCount - 1;
do {
GetMenuItemInfoA(PluginConfig.g_hMenuTrayUnread, i, TRUE, &mii);
if (mii.dwItemData > 0) {
uid = GetMenuItemID(PluginConfig.g_hMenuTrayUnread, i);
HandleMenuEntryFromhContact(uid);
break;
}
} while (--i >= 0);
if (uid == 0 && pLastActiveContainer != NULL) { // no session found, restore last active container
if (IsIconic(pLastActiveContainer->hwnd) || !IsWindowVisible(pLastActiveContainer->hwnd)) {
SendMessage(pLastActiveContainer->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
SetForegroundWindow(pLastActiveContainer->hwnd);
} else {
if(PluginConfig.m_HideOnClose)
ShowWindow(pLastActiveContainer->hwnd, SW_HIDE);
else
SendMessage(pLastActiveContainer->hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0);
}
}
}
if (wParam == 100)
PostMessage(hwndDlg, WM_NULL, 0, 0);
break;
}
case WM_RBUTTONUP: {
HMENU submenu = PluginConfig.g_hMenuTrayContext;
POINT pt;
if (wParam == 100)
SetForegroundWindow(hwndDlg);
GetCursorPos(&pt);
CheckMenuItem(submenu, ID_TRAYCONTEXT_DISABLEALLPOPUPS, MF_BYCOMMAND | (nen_options.iDisable ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(submenu, ID_TRAYCONTEXT_DON40223, MF_BYCOMMAND | (nen_options.iNoSounds ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(submenu, ID_TRAYCONTEXT_DON, MF_BYCOMMAND | (nen_options.iNoAutoPopup ? MF_CHECKED : MF_UNCHECKED));
EnableMenuItem(submenu, ID_TRAYCONTEXT_HIDEALLMESSAGECONTAINERS, MF_BYCOMMAND | (nen_options.bTraySupport) ? MF_ENABLED : MF_GRAYED);
CheckMenuItem(submenu, ID_TRAYCONTEXT_SHOWTHETRAYICON, MF_BYCOMMAND | (nen_options.bTraySupport ? MF_CHECKED : MF_UNCHECKED));
iSelection = TrackPopupMenu(submenu, TPM_RETURNCMD, pt.x, pt.y, 0, hwndDlg, NULL);
if (iSelection) {
MENUITEMINFO mii = {0};
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA | MIIM_ID;
GetMenuItemInfo(submenu, (UINT_PTR)iSelection, FALSE, &mii);
if (mii.dwItemData != 0) { // this must be an itm of the fav or recent menu
HandleMenuEntryFromhContact(iSelection);
} else {
switch (iSelection) {
case ID_TRAYCONTEXT_SHOWTHETRAYICON:
nen_options.bTraySupport = !nen_options.bTraySupport;
CreateSystrayIcon(nen_options.bTraySupport ? TRUE : FALSE);
break;
case ID_TRAYCONTEXT_DISABLEALLPOPUPS:
nen_options.iDisable ^= 1;
break;
case ID_TRAYCONTEXT_DON40223:
nen_options.iNoSounds ^= 1;
break;
case ID_TRAYCONTEXT_DON:
nen_options.iNoAutoPopup ^= 1;
break;
case ID_TRAYCONTEXT_HIDEALLMESSAGECONTAINERS: {
struct TContainerData *pContainer = pFirstContainer;
while (pContainer) {
ShowWindow(pContainer->hwnd, SW_HIDE);
pContainer = pContainer->pNextContainer;
}
break;
}
case ID_TRAYCONTEXT_RESTOREALLMESSAGECONTAINERS: {
struct TContainerData *pContainer = pFirstContainer;
while (pContainer) {
ShowWindow(pContainer->hwnd, SW_SHOW);
pContainer = pContainer->pNextContainer;
}
break;
}
case ID_TRAYCONTEXT_BE: {
struct TContainerData *pContainer = pFirstContainer;
nen_options.iDisable = 1;
nen_options.iNoSounds = 1;
nen_options.iNoAutoPopup = 1;
while (pContainer) {
SendMessage(pContainer->hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 1);
pContainer = pContainer->pNextContainer;
}
break;
}
}
}
}
if (wParam == 100)
PostMessage(hwndDlg, WM_NULL, 0, 0);
break;
}
default:
break;
}
}
break;
}
/*
* handle an event from the popup module (mostly window activation). Since popups may run in different threads, the message
* is posted to our invisible hotkey handler which does always run within the main thread.
* wParam is the hContact
* lParam the event handle
*/
case DM_HANDLECLISTEVENT: {
CLISTEVENT *cle = (CLISTEVENT *)CallService(MS_CLIST_GETEVENT, wParam, 0);
/*
* if lParam == NULL, don't consider clist events, just open the message tab
*/
if(lParam == 0) {
HandleMenuEntryFromhContact((int)wParam);
break;
}
/*
* first try, if the clist returned an event...
*/
if (cle) {
if (ServiceExists(cle->pszService)) {
CallService(cle->pszService, (WPARAM)NULL, (LPARAM)cle);
CallService(MS_CLIST_REMOVEEVENT, (WPARAM)cle->hContact, (LPARAM)cle->hDbEvent);
}
} else { // still, we got that message posted.. the event may be waiting in tabSRMMs tray...
HandleMenuEntryFromhContact((int)wParam);
}
break;
}
case DM_DOCREATETAB: {
HWND hWnd = M->FindWindow((HANDLE)lParam);
if (hWnd && IsWindow(hWnd)) {
struct TContainerData *pContainer = 0;
SendMessage(hWnd, DM_QUERYCONTAINER, 0, (LPARAM)&pContainer);
if (pContainer) {
int iTabs = TabCtrl_GetItemCount(GetDlgItem(pContainer->hwnd, IDC_MSGTABS));
if (iTabs == 1)
SendMessage(pContainer->hwnd, WM_CLOSE, 0, 1);
else
SendMessage(hWnd, WM_CLOSE, 0, 1);
CreateNewTabForContact((struct TContainerData *)wParam, (HANDLE)lParam, 0, NULL, TRUE, TRUE, FALSE, 0);
}
}
break;
}
case DM_DOCREATETAB_CHAT: {
SESSION_INFO *si = SM_FindSessionByHWND((HWND)lParam);
if (si && IsWindow(si->hWnd)) {
struct TContainerData *pContainer = 0;
SendMessage(si->hWnd, DM_QUERYCONTAINER, 0, (LPARAM)&pContainer);
if (pContainer) {
int iTabs = TabCtrl_GetItemCount(GetDlgItem(pContainer->hwnd, 1159));
if (iTabs == 1)
SendMessage(pContainer->hwnd, WM_CLOSE, 0, 1);
else
SendMessage(si->hWnd, WM_CLOSE, 0, 1);
si->hWnd = CreateNewRoom((struct TContainerData *)wParam, si, TRUE, 0, 0);
}
}
break;
}
case DM_SENDMESSAGECOMMANDW:
SendMessageCommand_W(wParam, lParam);
if (lParam)
free((void *)lParam);
return(0);
case DM_SENDMESSAGECOMMAND:
SendMessageCommand(wParam, lParam);
if (lParam)
free((void *)lParam);
return(0);
/*
* sent from the popup to "dismiss" the event. we should do this in the main thread
*/
case DM_REMOVECLISTEVENT:
CallService(MS_CLIST_REMOVEEVENT, wParam, lParam);
CallService(MS_DB_EVENT_MARKREAD, wParam, lParam);
return(0);
case DM_SETLOCALE: {
HKL hkl = (HKL)lParam;
HANDLE hContact = (HANDLE)wParam;
HWND hWnd = M->FindWindow(hContact);
if(hWnd) {
TWindowData *dat = (TWindowData *)GetWindowLongPtr(hWnd, GWLP_USERDATA);
if(dat) {
DBVARIANT dbv;
if(hkl) {
dat->hkl = hkl;
PostMessage(dat->hwnd, DM_SETLOCALE, 0, 0);
}
if(0 == M->GetTString(hContact, SRMSGMOD_T, "locale", &dbv)) {
GetLocaleID(dat, dbv.ptszVal);
DBFreeVariant(&dbv);
UpdateReadChars(dat);
}
}
}
return(0);
}
/*
* react to changes in the desktop composition state
* (enable/disable DWM, change to a non-aero visual style
* or classic Windows theme
*/
case WM_DWMCOMPOSITIONCHANGED: {
bool fNewAero = M->getAeroState(); // refresh dwm state
SendMessage(hwndDlg, WM_THEMECHANGED, 0, 0);
TContainerData *pContainer = pFirstContainer;
while (pContainer) {
if(fNewAero)
SetAeroMargins(pContainer);
else {
MARGINS m = {0};
if(M->m_pfnDwmExtendFrameIntoClientArea)
M->m_pfnDwmExtendFrameIntoClientArea(pContainer->hwnd, &m);
}
if(pContainer->SideBar->isActive())
RedrawWindow(GetDlgItem(pContainer->hwnd, 5000), NULL, NULL, RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW); // the container for the sidebar buttons
RedrawWindow(pContainer->hwnd, NULL, NULL, RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW|RDW_ALLCHILDREN);
pContainer = pContainer->pNextContainer;
}
M->BroadcastMessage(WM_DWMCOMPOSITIONCHANGED, 0, 0);
break;
}
/*
* this message is fired when the user changes desktop color
* settings (Desktop->personalize)
* the handler reconfigures the aero-related skin images for
* tabs and buttons to match the new desktop color theme.
*/
case WM_DWMCOLORIZATIONCOLORCHANGED: {
M->getAeroState();
Skin->setupAeroSkins();
CSkin::initAeroEffect();
break;
}
/*
* user has changed the visual style or switched to/from
* classic Windows theme
*/
case WM_THEMECHANGED: {
struct TContainerData *pContainer = pFirstContainer;
M->getAeroState();
Skin->setupTabCloseBitmap();
CSkin::initAeroEffect();
PluginConfig.m_ncm.cbSize = sizeof(NONCLIENTMETRICS);
SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &PluginConfig.m_ncm, 0);
FreeTabConfig();
ReloadTabConfig();
while (pContainer) {
SendMessage(GetDlgItem(pContainer->hwnd, IDC_MSGTABS), EM_THEMECHANGED, 0, 0);
BroadCastContainer(pContainer, EM_THEMECHANGED, 0, 0);
pContainer = pContainer->pNextContainer;
}
break;
}
case DM_SPLITSENDACK: {
ACKDATA ack = {0};
struct SendJob *job = sendQueue->getJobByIndex((int)wParam);
ack.hContact = job->hOwner;
ack.hProcess = job->hSendId;
ack.type = ACKTYPE_MESSAGE;
ack.result = ACKRESULT_SUCCESS;
if (job->hOwner && job->iAcksNeeded && job->hOwner && job->iStatus == SendQueue::SQ_INPROGRESS) {
if (IsWindow(job->hwndOwner))
::SendMessage(job->hwndOwner, HM_EVENTSENT, (WPARAM)MAKELONG(wParam, 0), (LPARAM)&ack);
else
sendQueue->ackMessage(0, (WPARAM)MAKELONG(wParam, 0), (LPARAM)&ack);
}
return 0;
}
case DM_LOGSTATUSCHANGE:
CGlobals::logStatusChange(wParam, reinterpret_cast<CContactCache *>(lParam));
return(0);
case DM_MUCFLASHWORKER: {
FLASH_PARAMS *p = reinterpret_cast<FLASH_PARAMS*>(lParam);
if(1 == wParam) {
CallService(MS_CLIST_CONTACTDOUBLECLICKED, (WPARAM)p->hContact, 1);
p->bActiveTab = TRUE;
p->bInactive = FALSE;
p->bMustAutoswitch = p->bMustFlash = FALSE;
}
if(2 == wParam) {
p->bActiveTab = TRUE;
p->bInactive = FALSE;
p->bMustAutoswitch = p->bMustFlash = FALSE;
SendMessage(p->hWnd, DM_ACTIVATEME, 0, 0);
}
DoFlashAndSoundWorker(p);
return(0);
}
case WM_POWERBROADCAST:
case WM_DISPLAYCHANGE: {
struct TContainerData *pContainer = pFirstContainer;
while (pContainer) {
if (CSkin::m_skinEnabled) { // invalidate cached background DCs for skinned containers
pContainer->oldDCSize.cx = pContainer->oldDCSize.cy = 0;
SelectObject(pContainer->cachedDC, pContainer->oldHBM);
DeleteObject(pContainer->cachedHBM);
DeleteDC(pContainer->cachedDC);
pContainer->cachedDC = 0;
RedrawWindow(pContainer->hwnd, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME);
}
pContainer = pContainer->pNextContainer;
}
break;
}
case WM_ACTIVATE:
if (LOWORD(wParam) != WA_ACTIVE)
SetWindowPos(hwndDlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
return 0;
case WM_CLOSE:
return 0;
case WM_TIMER:
if(wParam == TIMERID_SENDLATER) {
/*
* send heartbeat to each open container (to manage autoclose
* feature)
*/
TContainerData *pContainer = pFirstContainer;
/*
* send heartbeat to each container, they use this to update
* dynamic content (i.e. local time in the info panel).
*/
while(pContainer) {
SendMessage(pContainer->hwnd, WM_TIMER, TIMERID_HEARTBEAT, 0);
pContainer = pContainer->pNextContainer;
}
/*
* process send later contacts and jobs, if enough time has elapsed
*/
if(sendLater->isAvail() && !sendLater->isInteractive() && (time(0) - sendLater->lastProcessed()) > CSendLater::SENDLATER_PROCESS_INTERVAL) {
sendLater->setLastProcessed(time(0));
/*
* check the list of contacts that may have new send later jobs
* (added on user's request)
*/
sendLater->processContacts();
/*
* start processing the job list
*/
if(!sendLater->isJobListEmpty()) {
KillTimer(hwndDlg, wParam);
sendLater->startJobListProcess();
SetTimer(hwndDlg, TIMERID_SENDLATER_TICK, TIMEOUT_SENDLATER_TICK, 0);
}
}
}
/*
* process one entry per tick (default: 200ms)
* TODO better timings, possibly slow down when many jobs are in the
* queue.
*/
else if(wParam == TIMERID_SENDLATER_TICK) {
if(!sendLater->haveJobs()) {
KillTimer(hwndDlg, wParam);
SetTimer(hwndDlg, TIMERID_SENDLATER, TIMEOUT_SENDLATER, 0);
sendLater->qMgrUpdate(true);
}
else
sendLater->processCurrentJob();
}
break;
case WM_DESTROY: {
KillTimer(hwndDlg, TIMERID_SENDLATER_TICK);
KillTimer(hwndDlg, TIMERID_SENDLATER);
DestroyServiceFunction(hSvcHotkeyProcessor);
break;
}
}
return(DefWindowProc(hwndDlg, msg, wParam, lParam));
}
Boolean MCScreenDC::handle(real8 sleep, Boolean dispatch, Boolean anyevent,
Boolean &abort, Boolean &reset)
{
MSG msg, tmsg;
stateinfo oldinfo = *curinfo;
curinfo->abort = curinfo->reset = False;
curinfo->dispatch = dispatch;
curinfo->handled = False;
curinfo->keysym = 0;
curinfo->live = True;
if (mousewheel == 0)
mousewheel = RegisterWindowMessageA(MSH_MOUSEWHEEL);
if (dispatch && pendingevents != NULL
|| PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)
|| sleep != 0
&& MsgWaitForMultipleObjects(1, &g_notify_wakeup, False,
(DWORD)(sleep * 1000.0), QS_ALLINPUT)
!= WAIT_TIMEOUT && PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
{
if (dispatch && pendingevents != NULL)
{
curinfo->live = False;
MCEventnode *tptr = (MCEventnode *)pendingevents->remove
(pendingevents);
MCmodifierstate = tptr->modifier;
MCeventtime = tptr->time;
curinfo->keysym = tptr->keysym;
MCWindowProc(tptr->hwnd, tptr->msg, tptr->wParam, tptr->lParam);
delete tptr;
}
else
{
Boolean dodispatch = True;
if (dodispatch)
{
curinfo->live = True;
MCeventtime = msg.time;
if (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN
|| msg.message == WM_KEYUP || msg.message == WM_SYSKEYUP)
curinfo->keysym = getkeysym(msg.wParam, msg.lParam);
TranslateMessage(&msg);
bool t_char_found;
if ((MCruntimebehaviour & RTB_ACCURATE_UNICODE_INPUT) != 0)
t_char_found = PeekMessageW(&tmsg, NULL, WM_CHAR, WM_CHAR, PM_REMOVE) ||
PeekMessageW(&tmsg, NULL, WM_SYSCHAR, WM_SYSCHAR, PM_REMOVE);
else
t_char_found = PeekMessageA(&tmsg, NULL, WM_CHAR, WM_CHAR, PM_REMOVE) ||
PeekMessageA(&tmsg, NULL, WM_SYSCHAR, WM_SYSCHAR, PM_REMOVE);
if (t_char_found)
{
_Drawable _dw;
Drawable dw = &_dw;
dw->type = DC_WINDOW;
dw->handle.window = (MCSysWindowHandle)msg.hwnd;
if (MCdispatcher->findstackd(dw) == NULL)
{
if ((MCruntimebehaviour & RTB_ACCURATE_UNICODE_INPUT) != 0)
DispatchMessageW(&msg);
else
DispatchMessageA(&msg);
}
memcpy(&msg, &tmsg, sizeof(MSG));
}
if ((MCruntimebehaviour & RTB_ACCURATE_UNICODE_INPUT) != 0)
DispatchMessageW(&msg);
else
DispatchMessageA(&msg);
}
}
}
if (MCrecording)
MCtemplateplayer->handlerecord();
abort = curinfo->abort;
reset = curinfo->reset;
Boolean handled = curinfo->handled;
*curinfo = oldinfo;
return handled;
}
/***********************************************************************
* CC_WMInitDialog16 [internal]
*/
static LONG CC_WMInitDialog16( HWND hDlg, WPARAM wParam, LPARAM lParam )
{
int i, res;
int r, g, b;
HWND hwnd;
RECT rect;
POINT point;
LCCPRIV lpp;
CHOOSECOLORW *ch32;
CHOOSECOLOR16 *ch16 = (CHOOSECOLOR16 *) lParam;
TRACE("WM_INITDIALOG lParam=%08lX\n", lParam);
lpp = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct CCPRIVATE) );
if (ch16->lStructSize != sizeof(CHOOSECOLOR16) )
{
HeapFree(GetProcessHeap(), 0, lpp);
EndDialog (hDlg, 0) ;
return FALSE;
}
ch32 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CHOOSECOLORW) );
lpp->lpcc = ch32;
lpp->lpcc16 = ch16;
ch32->lStructSize = sizeof(CHOOSECOLORW);
ch32->hwndOwner = HWND_32(ch16->hwndOwner);
/* Should be an HINSTANCE but MS made a typo */
ch32->hInstance = HWND_32(ch16->hInstance);
ch32->lpCustColors = MapSL(ch16->lpCustColors);
ch32->lpfnHook = (LPCCHOOKPROC) ch16->lpfnHook; /* only used as flag */
ch32->Flags = ch16->Flags;
SetWindowLongPtrW(hDlg, DWLP_USER, (LONG_PTR)lpp);
if (!(lpp->lpcc->Flags & CC_SHOWHELP))
ShowWindow( GetDlgItem(hDlg,0x40e), SW_HIDE);
lpp->msetrgb = RegisterWindowMessageA(SETRGBSTRINGA);
#if 0
cpos = MAKELONG(5,7); /* init */
if (lpp->lpcc->Flags & CC_RGBINIT)
{
for (i = 0; i < 6; i++)
for (j = 0; j < 8; j++)
if (predefcolors[i][j] == lpp->lpcc->rgbResult)
{
cpos = MAKELONG(i,j);
goto found;
}
}
found:
/* FIXME: Draw_a_focus_rect & set_init_values */
#endif
GetWindowRect(hDlg, &lpp->fullsize);
if (lpp->lpcc->Flags & CC_FULLOPEN || lpp->lpcc->Flags & CC_PREVENTFULLOPEN)
{
hwnd = GetDlgItem(hDlg, 0x2cf);
EnableWindow(hwnd, FALSE);
}
if (!(lpp->lpcc->Flags & CC_FULLOPEN ) || lpp->lpcc->Flags & CC_PREVENTFULLOPEN)
{
rect = lpp->fullsize;
res = rect.bottom - rect.top;
hwnd = GetDlgItem(hDlg, 0x2c6); /* cut at left border */
point.x = point.y = 0;
ClientToScreen(hwnd, &point);
ScreenToClient(hDlg,&point);
GetClientRect(hDlg, &rect);
point.x += GetSystemMetrics(SM_CXDLGFRAME);
SetWindowPos(hDlg, 0, 0, 0, point.x, res, SWP_NOMOVE|SWP_NOZORDER);
for (i = 0x2bf; i < 0x2c5; i++)
ShowWindow( GetDlgItem(hDlg, i), SW_HIDE);
for (i = 0x2d3; i < 0x2d9; i++)
ShowWindow( GetDlgItem(hDlg, i), SW_HIDE);
ShowWindow( GetDlgItem(hDlg, 0x2c9), SW_HIDE);
ShowWindow( GetDlgItem(hDlg, 0x2c8), SW_HIDE);
ShowWindow( GetDlgItem(hDlg, 0x2c6), SW_HIDE);
ShowWindow( GetDlgItem(hDlg, 0x2c5), SW_HIDE);
ShowWindow( GetDlgItem(hDlg, 1090 ), SW_HIDE);
}
else
CC_SwitchToFullSize(hDlg, lpp->lpcc->rgbResult, NULL);
res = TRUE;
for (i = 0x2bf; i < 0x2c5; i++)
SendMessageA( GetDlgItem(hDlg, i), EM_LIMITTEXT, 3, 0); /* max 3 digits: xyz */
if (CC_HookCallChk(lpp->lpcc))
{
res = CallWindowProc16( (WNDPROC16)lpp->lpcc16->lpfnHook,
HWND_16(hDlg), WM_INITDIALOG, wParam, lParam);
}
/* Set the initial values of the color chooser dialog */
r = GetRValue(lpp->lpcc->rgbResult);
g = GetGValue(lpp->lpcc->rgbResult);
b = GetBValue(lpp->lpcc->rgbResult);
CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
lpp->h = CC_RGBtoHSL('H', r, g, b);
lpp->s = CC_RGBtoHSL('S', r, g, b);
lpp->l = CC_RGBtoHSL('L', r, g, b);
/* Doing it the long way because CC_EditSetRGB/HSL doesn't seem to work */
SetDlgItemInt(hDlg, 703, lpp->h, TRUE);
SetDlgItemInt(hDlg, 704, lpp->s, TRUE);
SetDlgItemInt(hDlg, 705, lpp->l, TRUE);
SetDlgItemInt(hDlg, 706, r, TRUE);
SetDlgItemInt(hDlg, 707, g, TRUE);
SetDlgItemInt(hDlg, 708, b, TRUE);
CC_PaintCross(hDlg, lpp->h, lpp->s);
CC_PaintTriangle(hDlg, lpp->l);
return res;
}
/***********************************************************************
* CC_WMCommand16 [internal]
*/
static LRESULT CC_WMCommand16( HWND hDlg, WPARAM wParam, LPARAM lParam, WORD notifyCode, HWND hwndCtl )
{
int r, g, b, i, xx;
UINT cokmsg;
HDC hdc;
COLORREF *cr;
LCCPRIV lpp = (LCCPRIV)GetWindowLongPtrW(hDlg, DWLP_USER);
TRACE("CC_WMCommand wParam=%lx lParam=%lx\n", wParam, lParam);
switch (wParam)
{
case 0x2c2: /* edit notify RGB */
case 0x2c3:
case 0x2c4:
if (notifyCode == EN_UPDATE && !lpp->updating)
{
i = CC_CheckDigitsInEdit(hwndCtl, 255);
r = GetRValue(lpp->lpcc->rgbResult);
g = GetGValue(lpp->lpcc->rgbResult);
b= GetBValue(lpp->lpcc->rgbResult);
xx = 0;
switch (wParam)
{
case 0x2c2: if ((xx = (i != r))) r = i; break;
case 0x2c3: if ((xx = (i != g))) g = i; break;
case 0x2c4: if ((xx = (i != b))) b = i; break;
}
if (xx) /* something has changed */
{
lpp->lpcc->rgbResult = RGB(r, g, b);
CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
lpp->h = CC_RGBtoHSL('H', r, g, b);
lpp->s = CC_RGBtoHSL('S', r, g, b);
lpp->l = CC_RGBtoHSL('L', r, g, b);
CC_EditSetHSL(hDlg, lpp->h, lpp->s, lpp->l);
CC_PaintCross(hDlg, lpp->h, lpp->s);
CC_PaintTriangle(hDlg, lpp->l);
}
}
break;
case 0x2bf: /* edit notify HSL */
case 0x2c0:
case 0x2c1:
if (notifyCode == EN_UPDATE && !lpp->updating)
{
i = CC_CheckDigitsInEdit(hwndCtl , wParam == 0x2bf ? 239:240);
xx = 0;
switch (wParam)
{
case 0x2bf: if ((xx = ( i != lpp->h))) lpp->h = i; break;
case 0x2c0: if ((xx = ( i != lpp->s))) lpp->s = i; break;
case 0x2c1: if ((xx = ( i != lpp->l))) lpp->l = i; break;
}
if (xx) /* something has changed */
{
r = CC_HSLtoRGB('R', lpp->h, lpp->s, lpp->l);
g = CC_HSLtoRGB('G', lpp->h, lpp->s, lpp->l);
b = CC_HSLtoRGB('B', lpp->h, lpp->s, lpp->l);
lpp->lpcc->rgbResult = RGB(r, g, b);
CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
CC_EditSetRGB(hDlg, lpp->lpcc->rgbResult);
CC_PaintCross(hDlg, lpp->h, lpp->s);
CC_PaintTriangle(hDlg, lpp->l);
}
}
break;
case 0x2cf:
CC_SwitchToFullSize(hDlg, lpp->lpcc->rgbResult, &lpp->fullsize);
SetFocus( GetDlgItem(hDlg, 0x2bf));
break;
case 0x2c8: /* add colors ... column by column */
cr = lpp->lpcc->lpCustColors;
cr[(lpp->nextuserdef % 2) * 8 + lpp->nextuserdef / 2] = lpp->lpcc->rgbResult;
if (++lpp->nextuserdef == 16)
lpp->nextuserdef = 0;
CC_PaintUserColorArray(hDlg, 2, 8, lpp->lpcc->lpCustColors);
break;
case 0x2c9: /* resulting color */
hdc = GetDC(hDlg);
lpp->lpcc->rgbResult = GetNearestColor(hdc, lpp->lpcc->rgbResult);
ReleaseDC(hDlg, hdc);
CC_EditSetRGB(hDlg, lpp->lpcc->rgbResult);
CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
r = GetRValue(lpp->lpcc->rgbResult);
g = GetGValue(lpp->lpcc->rgbResult);
b = GetBValue(lpp->lpcc->rgbResult);
lpp->h = CC_RGBtoHSL('H', r, g, b);
lpp->s = CC_RGBtoHSL('S', r, g, b);
lpp->l = CC_RGBtoHSL('L', r, g, b);
CC_EditSetHSL(hDlg, lpp->h, lpp->s, lpp->l);
CC_PaintCross(hDlg, lpp->h, lpp->s);
CC_PaintTriangle(hDlg, lpp->l);
break;
case 0x40e: /* Help! */ /* The Beatles, 1965 ;-) */
i = RegisterWindowMessageA(HELPMSGSTRINGA);
if (lpp->lpcc16)
{
if (lpp->lpcc->hwndOwner)
SendMessageA(lpp->lpcc->hwndOwner, i, 0, (LPARAM)lpp->lpcc16);
if ( CC_HookCallChk(lpp->lpcc))
CallWindowProc16( (WNDPROC16) lpp->lpcc16->lpfnHook,
HWND_16(hDlg), WM_COMMAND, psh15,
(LPARAM)lpp->lpcc16);
}
break;
case IDOK :
cokmsg = RegisterWindowMessageA(COLOROKSTRINGA);
if (lpp->lpcc16)
{
if (lpp->lpcc->hwndOwner)
if (SendMessageA(lpp->lpcc->hwndOwner, cokmsg, 0, (LPARAM)lpp->lpcc16))
break; /* do NOT close */
}
if (lpp->lpcc16)
{
BYTE *ptr = MapSL(lpp->lpcc16->lpCustColors);
memcpy(ptr, lpp->lpcc->lpCustColors, sizeof(COLORREF)*16);
lpp->lpcc16->rgbResult = lpp->lpcc->rgbResult;
}
EndDialog(hDlg, 1) ;
return TRUE ;
case IDCANCEL :
EndDialog(hDlg, 0) ;
return TRUE ;
}
return FALSE;
}
int main( int argc, char *argv[] )
{
QApplication::setColorSpec( QApplication::ManyColor );
DesignerApplication a( argc, argv );
DesignerApplication::setOverrideCursor( Qt::WaitCursor );
bool creatPid = FALSE;
if ( a.argc() > 1 ) {
QString arg1 = a.argv()[ 1 ];
if ( arg1 == "-client" ) {
QFile pf( QDir::homeDirPath() + "/.designerpid" );
if ( pf.exists() && pf.open( IO_ReadOnly ) ) {
QString pidStr;
pf.readLine( pidStr, pf.size() );
QFile f( QDir::homeDirPath() + "/.designerargs" );
f.open( IO_WriteOnly );
QTextStream ts( &f );
for ( int i = 1; i < a.argc(); ++i )
ts << a.argv()[ i ] << " ";
ts << endl;
f.close();
#if defined(Q_OS_UNIX)
if ( kill( pidStr.toInt(), SIGUSR1 ) == -1 )
creatPid = TRUE;
else
return 0;
#elif defined(Q_OS_WIN32)
if ( !GetProcessVersion( pidStr.toUInt() ) ) {
creatPid = TRUE;
} else {
if ( a.winVersion() & Qt::WV_NT_based )
SendMessage( HWND_BROADCAST, RegisterWindowMessage((TCHAR*)"QT_DESIGNER_OPEN_FILE"), 0, 0 );
else
SendMessage( HWND_BROADCAST, RegisterWindowMessageA("QT_DESIGNER_OPEN_FILE"), 0, 0 );
return 0;
}
#endif
} else {
creatPid = TRUE;
}
} else if(arg1 == "-debug_stderr") {
extern bool debugToStderr; //outputwindow.cpp
debugToStderr = TRUE;
}
}
if ( creatPid ) {
QFile pf( QDir::homeDirPath() + "/.designerpid" );
pf.open( IO_WriteOnly );
QTextStream ts( &pf );
#if defined(Q_OS_UNIX)
signal( SIGUSR1, signalHandler );
#endif
ts << getpid() << endl;
pf.close();
signal( SIGABRT, exitHandler );
signal( SIGFPE, exitHandler );
signal( SIGILL, exitHandler );
signal( SIGINT, exitHandler );
signal( SIGSEGV, exitHandler );
signal( SIGTERM, exitHandler );
}
extern void qInitImages_designercore();
qInitImages_designercore();
QSettings config;
QString keybase = DesignerApplication::settingsKey();
config.insertSearchPath( QSettings::Windows, "/Trolltech" );
QStringList pluginPaths = config.readListEntry( keybase + "PluginPaths" );
if (pluginPaths.count())
QApplication::setLibraryPaths(pluginPaths);
QSplashScreen *splash = a.showSplash();
MainWindow *mw = new MainWindow( creatPid );
a.setMainWidget( mw );
#if defined(QT_NON_COMMERCIAL)
mw->setCaption( "Qt Designer by Trolltech for non-commercial use" );
#else
mw->setCaption( "Qt Designer by Trolltech" );
#endif
if ( config.readBoolEntry( keybase + "Geometries/MainwindowMaximized", FALSE ) ) {
int x = config.readNumEntry( keybase + "Geometries/MainwindowX", 0 );
int y = config.readNumEntry( keybase + "Geometries/MainwindowY", 0 );
mw->move( x, y );
mw->showMaximized();
} else {
mw->show();
}
if ( splash )
splash->finish( mw );
delete splash;
QApplication::restoreOverrideCursor();
for ( int i = 1; i < a.argc(); ++i ) {
QString arg = a.argv()[ i ];
if ( arg[0] != '-' )
mw->fileOpen( "", "", arg );
}
return a.exec();
}
int WINAPI WinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow
)
{
SECURITY_ATTRIBUTES sa;
sa.bInheritHandle = true;
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = NULL;
if (!IsWow64())
return 1;
if (!CString(lpCmdLine).IsEmpty())
pidToAttach = atoi(lpCmdLine);
HMODULE hKernel32 = LoadLibrary("KERNEL32.DLL");
pfnLoadLibrary = (LPTHREAD_START_ROUTINE)GetProcAddress(hKernel32, ("LoadLibraryA"));
char *pDataRemote = 0;
DWORD numBytes = 0;
HANDLE fledgeProcess = NULL;
int numTries = 30;
while (numTries)
{
EnumWindows(FindFledge, pidToAttach);
if (fledgeWindow != NULL)
break;
Sleep(1000);
numTries--;
}
if (fledgeWindow == NULL)
return 1;
GetWindowThreadProcessId(fledgeWindow, &pidToAttach);
fledgeProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pidToAttach);
CStringA curDir;
GetCurrentDirectoryA(MAX_PATH, curDir.GetBuffer(MAX_PATH + 1));
CString param = curDir.GetBuffer();
param.Append("\\");
param.Append(HOOK_DLLNAME);
pDataRemote = (char*) VirtualAllocEx(fledgeProcess, 0, param.GetAllocLength(), MEM_COMMIT, PAGE_READWRITE);
if (pDataRemote == NULL)
return 1;
if (!WriteProcessMemory(fledgeProcess, pDataRemote, param.GetBuffer(), param.GetAllocLength(), &numBytes))
return 1;
DWORD threadID;
HANDLE fledgeThread = CreateRemoteThread(fledgeProcess, NULL, 0, (LPTHREAD_START_ROUTINE) pfnLoadLibrary, pDataRemote, 0, &threadID);
CStringA eventName;
eventName.Format("%s%d", "Global\\FledgeHook", pidToAttach);
HANDLE hEvent = CreateEventA(NULL, false, false, eventName);
WaitForSingleObject(hEvent, INFINITE);
DWORD WM_FLEDGEHOOKDATA = RegisterWindowMessageA("FledgeHookDataEvent");
PostThreadMessageA(threadID, WM_FLEDGEHOOKDATA, 0, (LPARAM)fledgeWindow);
curDir.ReleaseBuffer();
param.ReleaseBuffer();
CloseHandle(fledgeProcess);
return 0;
}
int WINAPI WinMain(HINSTANCE hThisInstance,
HINSTANCE hPrevInstance,
LPSTR lpszArgument,
int nCmdShow)
{
/* This is the handle for our window */
MSG messages; /* Here messages to the application are saved */
WNDCLASSEX wincl; /* Data structure for the windowclass */
WM_TASKBAR = RegisterWindowMessageA("TaskbarCreated");
/* The Window structure */
wincl.hInstance = hThisInstance;
wincl.lpszClassName = szClassName;
wincl.lpfnWndProc = WindowProcedure; /* This function is called by windows */
wincl.style = CS_DBLCLKS; /* Catch double-clicks */
wincl.cbSize = sizeof(WNDCLASSEX);
/* Use default icon and mouse-pointer */
wincl.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(ICO1));
wincl.hIconSm = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(ICO1));
wincl.hCursor = LoadCursor(NULL, IDC_ARROW);
wincl.lpszMenuName = NULL; /* No menu */
wincl.cbClsExtra = 0; /* No extra bytes after the window class */
wincl.cbWndExtra = 0; /* structure or the window instance */
wincl.hbrBackground = (HBRUSH)(CreateSolidBrush(RGB(255, 255, 255)));
/* Register the window class, and if it fails quit the program */
if (!RegisterClassEx(&wincl))
return 503;
/* The class is registered, let's create the program*/
Hwnd = CreateWindowEx(
0, /* Extended possibilites for variation */
szClassName, /* Classname */
szClassName, /* Title Text */
0, /* default window */
0, /* Windows decides the position */
0, /* where the window ends up on the screen */
0, /* The programs width */
0, /* and height in pixels */
HWND_MESSAGE, /* The window is a child-window to desktop */
NULL, /* No menu */
NULL, /* Program Instance handler */
NULL /* No Window Creation data */
);
/*Initialize the NOTIFYICONDATA structure only once*/
InitNotifyIconData();
/* Make the window visible on the screen */
ShowWindow(Hwnd, nCmdShow);
// store address of hook proc
HOOKPROC lpfnHookProc = &LowLevelKeyboardProc;
// try to set hook
KBHook = SetWindowsHookEx(WH_KEYBOARD_LL, lpfnHookProc, GetModuleHandle(NULL), 0);
// if hook was not installed, get the last error code, and string and
// show them both in a messagebox()
if (KBHook == NULL)
{
char lpBuffer[50];
char* errorString = GetLastErrorString();
strcat_s(lpBuffer, errorString);
MessageBox(HWND_DESKTOP, lpBuffer, "keyboard hook could not be installed!", MB_OK);
}
/* Run the message loop. It will run until GetMessage() returns 0 */
while (GetMessage(&messages, NULL, 0, 0))
{
/* Translate virtual-key messages into character messages */
TranslateMessage(&messages);
/* Send message to WindowProcedure */
DispatchMessage(&messages);
}
// if there is a valid hook procedure, uninstall it
if (KBHook)
{
// if unhookwindowshookex fails, show the last error as a string
if (!UnhookWindowsHookEx(KBHook))
{
char* errorString = GetLastErrorString();
MessageBox(HWND_DESKTOP, errorString, "Last Error", MB_OK);
}
}
return messages.wParam;
}
