Example #1
0
void bring_to_top(GtkWidget *win){
#ifdef __WIN32__
	HWND hWnd;
	int nTargetID, nForegroundID;
	BOOL res;

	hWnd = GDK_WINDOW_HWND (win->window);

	/* From  http://techtips.belution.com/ja/vc/0012/ */
	nForegroundID = GetWindowThreadProcessId(GetForegroundWindow(), NULL);
	nTargetID = GetWindowThreadProcessId(hWnd, NULL );

	AttachThreadInput(nTargetID, nForegroundID, TRUE );

	// SPI_GETFOREGROUNDLOCKTIMEOUT will be undefined. Why ?
	/*
	SystemParametersInfo( SPI_GETFOREGROUNDLOCKTIMEOUT,0,&sp_time,0);
	SystemParametersInfo( SPI_SETFOREGROUNDLOCKTIMEOUT,0,(LPVOID)0,0);
	SetForegroundWindow(hWnd);
	SystemParametersInfo( SPI_SETFOREGROUNDLOCKTIMEOUT,0,sp_time,0);
	*/

	res = SetForegroundWindow(hWnd);

	AttachThreadInput(nTargetID, nForegroundID, FALSE);

	if(!res){
		SetFocus(hWnd);
	}
#else
	gdk_window_show(GTK_WIDGET(win)->window);
	gdk_window_focus(GTK_WIDGET(win)->window, gtk_get_current_event_time());

#endif
}
Example #2
0
// http://www.codeproject.com/Tips/76427/How-to-bring-window-to-top-with-SetForegroundWindo
void SetForegroundWindowInternal(HWND hWnd)
{
    SetWindowPos(hWnd,HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
    SetWindowPos(hWnd,HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
    SetWindowPos(hWnd,HWND_NOTOPMOST, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE);
    return;
    //relation time of SetForegroundWindow lock
    DWORD lockTimeOut = 0;
    HWND  hCurrWnd = GetForegroundWindow();
    DWORD dwThisTID = GetCurrentThreadId(),
        dwCurrTID = GetWindowThreadProcessId(hCurrWnd, 0);

    //we need to bypass some limitations from Microsoft :)
    if (dwThisTID != dwCurrTID)
    {
        AttachThreadInput(dwThisTID, dwCurrTID, TRUE);

        SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, &lockTimeOut, 0);
        SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, 0, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);

        AllowSetForegroundWindow(ASFW_ANY);
    }

    SetForegroundWindow(hWnd);

    if (dwThisTID != dwCurrTID)
    {
        SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, (PVOID)lockTimeOut, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
        AttachThreadInput(dwThisTID, dwCurrTID, FALSE);
    }
}
Example #3
0
	XBool activateGame(HWND h)
	{
		//方案1://不行
		//return BringWindowToTop(XEG.getHWND());
		//方案2://可以
		//typedef void (WINAPI *PROCSWITCHTOTHISWINDOW) (HWND, BOOL);
		//PROCSWITCHTOTHISWINDOW SwitchToThisWindow;
		//HMODULE hUser32 = GetModuleHandle("user32");
		//SwitchToThisWindow = ( PROCSWITCHTOTHISWINDOW)GetProcAddress(hUser32, "SwitchToThisWindow");  
		//if(SwitchToThisWindow == NULL) return false;
		////接下来只要用任何现存窗口的句柄调用这个函数即可,第二个参数指定如果窗口极小化,是否恢复其原状态。
		//SwitchToThisWindow(XEG.getHWND(), TRUE);
		//return true;
		//方案3://可行
		HWND hCurWnd = GetForegroundWindow();
		DWORD dwMyID = GetCurrentThreadId();
		DWORD dwCurID = GetWindowThreadProcessId(hCurWnd, NULL);
		AttachThreadInput(dwCurID, dwMyID, TRUE);
		SetForegroundWindow(h);
		AttachThreadInput(dwCurID, dwMyID, FALSE);
		return  true;
		//方法4://可行
		//ShowWindow(XEG.getHWND(),SW_SHOWNA);//简单的显示主窗口完事儿 
		//SetActiveWindow(XEG.getHWND());
		//SetForegroundWindow(XEG.getHWND());    
		////this->SetWindowPos(this,LOWORD(lParam),HIWORD(lParam),c.Width(),c.Height(),SWP_NOACTIVATE);
		//BringWindowToTop(XEG.getHWND());
		//return true;
	}
Example #4
0
static DWORD set_foreground(HWND hwnd)
{
    HWND hwnd_fore;
    DWORD set_id, fore_id, ret;
    char win_text[1024];

    hwnd_fore = GetForegroundWindow();
    GetWindowTextA(hwnd_fore, win_text, 1024);
    set_id = GetWindowThreadProcessId(hwnd, NULL);
    fore_id = GetWindowThreadProcessId(hwnd_fore, NULL);
    trace("\"%s\" %p %08x hwnd %p %08x\n", win_text, hwnd_fore, fore_id, hwnd, set_id);
    ret = AttachThreadInput(set_id, fore_id, TRUE);
    trace("AttachThreadInput returned %08x\n", ret);
    ret = ShowWindow(hwnd, SW_SHOWNORMAL);
    trace("ShowWindow returned %08x\n", ret);
    ret = SetWindowPos(hwnd, HWND_TOPMOST, 0,0,0,0, SWP_NOSIZE|SWP_NOMOVE);
    trace("set topmost returned %08x\n", ret);
    ret = SetWindowPos(hwnd, HWND_NOTOPMOST, 0,0,0,0, SWP_NOSIZE|SWP_NOMOVE);
    trace("set notopmost returned %08x\n", ret);
    ret = SetForegroundWindow(hwnd);
    trace("SetForegroundWindow returned %08x\n", ret);
    Sleep(250);
    AttachThreadInput(set_id, fore_id, FALSE);
    return ret;
}
Example #5
0
bool raiseWindow(QWidget *w, unsigned)
#endif
{
    Event e(EventRaiseWindow, w);
    if (e.process())
        return false;
#ifdef USE_KDE
    /* info.currentDesktop is 0 when iconified :(
    also onAllDesktops is 0 when Objekt isn't
    shown already */
    KWin::Info info = KWin::info(w->winId());
    if ((!info.onAllDesktops) || (desk == 0)) {
        if (desk == 0) desk = KWin::currentDesktop();
        KWin::setOnDesktop(w->winId(), desk);
    }
#endif
    w->show();
    w->showNormal();
    w->setActiveWindow();
    w->raise();
#ifdef USE_KDE
    KWin::setActiveWindow(w->winId());
#endif
#ifdef WIN32
    AttachThreadInput(GetWindowThreadProcessId(GetForegroundWindow(),NULL), GetCurrentThreadId(), TRUE);
    SetForegroundWindow(w->winId());
    SetFocus(w->winId());
    AttachThreadInput(GetWindowThreadProcessId(GetForegroundWindow(),NULL), GetCurrentThreadId(), FALSE);
#endif
    return true;
}
Example #6
0
void DoFocus(BOOL bUseCurrent,HWND hwndFocus)
{
	HWND hwndEdit;
	char WinClass[256];
	DWORD OtherAppThreadID;
	DWORD OtherAppProcessID;
	DWORD TrayThreadID;

	if(bUseCurrent)
	{
		TrayThreadID=GetCurrentThreadId();
		hwndEdit=hwndFocus; 
		GetClassName(hwndEdit,WinClass,255);

		OtherAppThreadID = GetWindowThreadProcessId( hwndEdit, 
			&OtherAppProcessID);

		AttachThreadInput( TrayThreadID, OtherAppThreadID, TRUE );

		// We can key off WinClass if something else
		// needs to be done 

		SetFocus(hwndEdit);

		AttachThreadInput( TrayThreadID, OtherAppThreadID, FALSE );
	}
}
Example #7
0
BOOL SetForegroundWindowInternal(HWND hWnd) {
	BOOL ret = false;
	if (!IsWindow(hWnd)) return ret;

	//relation time of SetForegroundWindow lock
	DWORD lockTimeOut = 0;
	HWND  hCurrWnd = GetForegroundWindow();
	DWORD dwThisTID = GetCurrentThreadId(),
	dwCurrTID = GetWindowThreadProcessId(hCurrWnd, 0);

	//we need to bypass some limitations from Microsoft :)
	if (dwThisTID != dwCurrTID)
	{
		AttachThreadInput(dwThisTID, dwCurrTID, TRUE);

		SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, &lockTimeOut, 0);
		SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, 0, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);

		AllowSetForegroundWindow(ASFW_ANY);
	}

	ret = SetForegroundWindow(hWnd);

	if (dwThisTID != dwCurrTID)
	{
		SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, (PVOID)lockTimeOut, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
		AttachThreadInput(dwThisTID, dwCurrTID, FALSE);
	}

	return ret;
}
Example #8
0
void WaitForReleaseVkKeys(DWORD dwThreadCurrent, DWORD dwThreadTarget, DWORD dwTimeout)
{
  DWORD dwStart=GetTickCount();
  BYTE lpKeyState[256];
  int i;

  Loop:
  if (dwTimeout == INFINITE || GetTickCount() - dwStart < dwTimeout)
  {
    AttachThreadInput(dwThreadCurrent, dwThreadTarget, FALSE);

    if (AttachThreadInput(dwThreadCurrent, dwThreadTarget, TRUE))
    {
      Sleep(0);

      if (GetKeyboardState(lpKeyState))
      {
        for (i=0; i < 256; ++i)
        {
          if (lpKeyState[i] & 0x80)
            goto Loop;
        }
      }
    }
  }
}
Example #9
0
//------------------------------------------------------------------------------
// 
//------------------------------------------------------------------------------
COMMONEXPORT BOOL _SetForegroundWindowEx ( HWND hWnd )
{
	if (hWnd == NULL)
		return FALSE;
	
	// determine current foreground window
	HWND hWndForeground = ::GetForegroundWindow ();

	if (hWndForeground == NULL)
		return ::SetForegroundWindow (hWnd);

	// check whether it is able to pump messages to avoid deadlocks
	DWORD dwResult = 0;

    if  ( SendMessageTimeout ( hWndForeground, WM_NULL, 0, 0, SMTO_NORMAL, 1000, &dwResult ) == 0 )
		return FALSE;

	int iTID = ::GetWindowThreadProcessId ( hWnd, 0 );
	int iForegroundTID  = ::GetWindowThreadProcessId ( hWndForeground, 0 );
	
	AttachThreadInput (iTID, iForegroundTID, TRUE);
	
	::SetForegroundWindow (hWnd);
	
	AttachThreadInput (iTID, iForegroundTID, FALSE);

    return TRUE;
}
Example #10
0
HRESULT CSysProgressDlg::ShowModeless(HWND hWndParent, BOOL immediately)
{
	EnsureValid();
	m_hWndProgDlg = nullptr;
	if (!IsValid())
		return E_FAIL;
	m_hWndParent = hWndParent;
	auto winId = GetWindowThreadProcessId(m_hWndParent, 0);
	auto threadId = GetCurrentThreadId();
	if (winId != threadId)
		AttachThreadInput(winId, threadId, TRUE);
	m_hWndFocus = GetFocus();
	if (winId != threadId)
		AttachThreadInput(winId, threadId, FALSE);
	HRESULT hr = m_pIDlg->StartProgressDialog(hWndParent, nullptr, m_dwDlgFlags, nullptr);
	if(FAILED(hr))
		return hr;

	ATL::CComPtr<IOleWindow> pOleWindow;
	HRESULT hr2 = m_pIDlg.QueryInterface(&pOleWindow);
	if(SUCCEEDED(hr2))
	{
		hr2 = pOleWindow->GetWindow(&m_hWndProgDlg);
		if(SUCCEEDED(hr2))
		{
			if (immediately)
				ShowWindow(m_hWndProgDlg, SW_SHOW);
		}
	}
	m_isVisible = true;
	return hr;
}
void
bringToFront()
{
#if defined(Q_WS_X11)
    {
        qDebug() << Q_FUNC_INFO;

        QWidget* widget = tomahawkWindow();
        if ( !widget )
            return;

        widget->show();
        widget->activateWindow();
        widget->raise();

        WId wid = widget->winId();
        NETWM::init();

        XEvent e;
        e.xclient.type = ClientMessage;
        e.xclient.message_type = NETWM::NET_ACTIVE_WINDOW;
        e.xclient.display = QX11Info::display();
        e.xclient.window = wid;
        e.xclient.format = 32;
        e.xclient.data.l[0] = 2;
        e.xclient.data.l[1] = QX11Info::appTime();
        e.xclient.data.l[2] = 0;
        e.xclient.data.l[3] = 0l;
        e.xclient.data.l[4] = 0l;

        XSendEvent( QX11Info::display(), RootWindow( QX11Info::display(), DefaultScreen( QX11Info::display() ) ), False, SubstructureRedirectMask | SubstructureNotifyMask, &e );
    }
#elif defined(Q_WS_WIN)
    {
        qDebug() << Q_FUNC_INFO;

        QWidget* widget = tomahawkWindow();
        if ( !widget )
            return;

        widget->show();
        widget->activateWindow();
        widget->raise();

        WId wid = widget->winId();

        HWND hwndActiveWin = GetForegroundWindow();
        int  idActive      = GetWindowThreadProcessId(hwndActiveWin, NULL);
        if ( AttachThreadInput(GetCurrentThreadId(), idActive, TRUE) )
        {
            SetForegroundWindow( wid );
            SetFocus( wid );
            AttachThreadInput(GetCurrentThreadId(), idActive, FALSE);
        }
    }
#endif
}
Example #12
0
/*------------------------------------------------
  set keyboard focus to the main window forcedly
--------------------------------------------------*/
void SetFocusTClockMain(HWND hwnd)
{
	DWORD pid, curthread, mythread;
	
	curthread = GetWindowThreadProcessId(GetForegroundWindow(), &pid);
	mythread = GetCurrentThreadId();
	AttachThreadInput(mythread, curthread, TRUE);
	SetForegroundWindow(hwnd);
	SetFocus(hwnd);
	AttachThreadInput(mythread, curthread, FALSE);
}
Example #13
0
HRESULT VegasFSRender::writeData(ISfProgress* progress) {
  BOOL useAudio = (m_pIAudioStream &&
                   m_pTemplate->pAudioTemplate &&
                   m_pTemplate->pAudioTemplate->cNumAStreams);
  BOOL useVideo = (m_pIVideoStream &&
                   m_pTemplate->pVideoTemplate &&
                   m_pTemplate->pVideoTemplate->cNumVStreams);

  if (!useVideo)
    return SF_E_NOVIDEO;

  HWND activewnd = GetForegroundWindow();
  DWORD threadid = GetWindowThreadProcessId(activewnd, NULL);
  AttachThreadInput(GetCurrentThreadId(), threadid, TRUE);

  ZeroMemory(&FfpHeader, NUMBYTES(FfpHeader));

  LPTSTR pszFileName;
#ifdef UNICODE
  pszFileName = m_szFileName;
#else
  TCHAR szFileName[MAX_PATH];
  SfMBFromWC(szFileName, m_szFileName, MAX_PATH);
  pszFileName = szFileName;
#endif
  HRESULT hr = S_OK;

  hr = m_pIVideoStream->GetFrameCount(&FfpHeader.Video.cfTotal);
  hr = m_pIVideoStream->GetFrameRate(&FfpHeader.Video.dFPS);
  FfpHeader.Video.ntLength = SfVideo_FramesToTime(
      FfpHeader.Video.cfTotal, FfpHeader.Video.dFPS);
  FfpHeader.Video.bih = *m_pTemplate->pVideoTemplate->pbihCodec;
  FfpHeader.Video.cbFrameSize = FSDibImageBytes(&FfpHeader.Video.bih);
  if (useAudio) {
    hr = m_pIAudioStream->GetSampleCount(&FfpHeader.Audio.ccTotal);
    FfpHeader.Audio.wfx = m_pTemplate->pAudioTemplate->wfx;
    hr = m_pIAudioStream->GetStreamLength(&FfpHeader.Audio.ntLength);
    FfpHeader.Audio.ntLength = SfAudio_CellsToTime(FfpHeader.Audio.ccTotal,
        FfpHeader.Audio.wfx.nSamplesPerSec);
  }

  Init(!!useAudio, FfpHeader.Audio.wfx.nSamplesPerSec,
      FfpHeader.Audio.wfx.wBitsPerSample, FfpHeader.Audio.wfx.nChannels,
      (DWORD)FfpHeader.Video.cfTotal, FfpHeader.Video.dFPS,
      FfpHeader.Video.bih.biWidth, FfpHeader.Video.bih.biHeight, activewnd, pszFileName);
  hr = S_OK;
  if (!Run())
    hr = SF_E_CANCEL;

  EnableWindow(activewnd, TRUE);
  SetForegroundWindow(activewnd);
  AttachThreadInput(GetCurrentThreadId(), threadid, FALSE);
  return hr;
}
void fsSetForegroundWindow (HWND hWnd)
{
	HWND hFor = GetForegroundWindow ();
	int iMyTID = GetCurrentThreadId ();
	int iCurrTID = GetWindowThreadProcessId (hFor, NULL);

	AttachThreadInput (iMyTID, iCurrTID, TRUE);

	SetForegroundWindow (hWnd);

	AttachThreadInput (iMyTID, iCurrTID, FALSE);
}
Example #15
0
   void handle_task_timer(void) {
	   KillTimer(m_hwnd, TASK_RISE_TIMER);
	   if (NULL == task_over) return;

	   DWORD ThreadID1 = GetWindowThreadProcessId(GetForegroundWindow(), NULL);
	   DWORD ThreadID2 = GetCurrentThreadId();
	   if (ThreadID1 != ThreadID2) {
		   AttachThreadInput(ThreadID1, ThreadID2, TRUE);
		   SetForegroundWindow(m_hwnd);
		   AttachThreadInput(ThreadID1, ThreadID2, FALSE);
	   }
	   PostMessage(GetBBWnd(), BB_BRINGTOFRONT, 0, (LPARAM)task_over);
   }
Example #16
0
void UIScreenCaptureMgr::forceForgroundWindow(__in HWND hWnd)
{
    HWND hForegroundWnd = ::GetForegroundWindow();
    DWORD dwPid = GetWindowThreadProcessId(hForegroundWnd, NULL);
    if (!AttachThreadInput(dwPid, GetCurrentThreadId(), TRUE)
        || !::SetForegroundWindow(hWnd) 
        || !::BringWindowToTop(hWnd))
    {
        return;
    }

    SwitchToThisWindow(hWnd, TRUE);
    AttachThreadInput(dwPid, GetCurrentThreadId(), FALSE);
}
Example #17
0
void SetForegroundWindowEx(HWND hWnd)
{
        // Attach foreground window thread to our thread
	const DWORD foreGroundID = GetWindowThreadProcessId(GetForegroundWindow(), NULL);
	const DWORD currentID = GetCurrentThreadId();

	AttachThreadInput(foreGroundID, currentID, TRUE);
	// Do our stuff here 
	HWND lastActivePopupWnd = GetLastActivePopup(hWnd);
	SetForegroundWindow(lastActivePopupWnd);

	// Detach the attached thread
	AttachThreadInput(foreGroundID, currentID, FALSE);
}
Example #18
0
BOOL WindowUtil_setFocus(HWND hwnd) {
	BOOL ret;

	// Attach foreground window thread
	AttachThreadInput(GetWindowThreadProcessId(GetForegroundWindow(), NULL), GetCurrentThreadId(), TRUE);

	ret = SetForegroundWindow(hwnd);
	SetFocus(hwnd);

	// Detach the attached thread
	AttachThreadInput(GetWindowThreadProcessId(GetForegroundWindow(), NULL), GetCurrentThreadId(), FALSE);

	return ret;
}
Example #19
0
void BringWindowToTop(HWND hwnd ,DWORD type)
{
	DWORD dwFGThreadId, dwFGProcessId,dwThisThreadId;
	HWND hwndForeground = ::GetForegroundWindow();
	dwFGThreadId = GetWindowThreadProcessId(hwndForeground, &dwFGProcessId);
	dwThisThreadId = GetCurrentThreadId();
	AttachThreadInput(dwThisThreadId, dwFGThreadId,TRUE);
	if(type != NULL)
	{
		::ShowWindow(hwnd,type);
	}
	::SetForegroundWindow(hwnd);
	::BringWindowToTop(hwnd);
	AttachThreadInput(dwThisThreadId, dwFGThreadId,FALSE);
}
// 最前面に来るメッセージボックスを表示する
int CCustomBindStatusCallBack::_ActiveMessageBox(const CString& strText, UINT uType)
{
	// 最前面プロセスのスレッドIDを取得する 
	int foregroundID = ::GetWindowThreadProcessId( ::GetForegroundWindow(), NULL); 
	// 最前面アプリケーションの入力処理機構に接続する 
	AttachThreadInput( ::GetCurrentThreadId(), foregroundID, TRUE); 
	// 最前面ウィンドウを変更する 
	::SetForegroundWindow(m_hWndDLing);

	int nReturn = MessageBox(m_hWndDLing, strText, NULL, uType);
	// 接続を解除する
	AttachThreadInput( ::GetCurrentThreadId(), foregroundID, FALSE);

	return nReturn;
}
Example #21
0
/*------------------------------------------------
  WM_EXITMENULOOP message
--------------------------------------------------*/
void OnExitMenuLoop(HWND hwnd)
{
	HWND hwndBar;
	DWORD pid, clockthread, mythread;
	
	hwndBar = GetTaskbarWindow();
	if(hwndBar)
	{
		clockthread = GetWindowThreadProcessId(hwndBar, &pid);
		mythread = GetCurrentThreadId();
		AttachThreadInput(clockthread, mythread, TRUE);
		SetFocus(hwndBar);
		AttachThreadInput(clockthread, mythread, FALSE);
	}
}
Example #22
0
void __stdcall SetForegroundWindowForce(HWND hWnd)
{
 HWND hForeground;
 DWORD id, foreground_id;
 hForeground = GetForegroundWindow();
 if (hForeground == hWnd) return;
 foreground_id = GetWindowThreadProcessId(hForeground, NULL);
 id = GetWindowThreadProcessId(hWnd, NULL);
 if (AttachThreadInput(id, foreground_id, TRUE))
 {
  SetForegroundWindow(hWnd);
  BringWindowToTop(hWnd);
  AttachThreadInput(id, foreground_id, FALSE);
 }
}
Example #23
0
//http://www.shloemi.com/2012/09/solved-setforegroundwindow-win32-api-not-always-works/
void MirandaUtils::ForceForegroundWindow(HWND hWnd)
{
	DWORD foreThread = GetWindowThreadProcessId(GetForegroundWindow(), NULL);
	DWORD appThread = GetCurrentThreadId();

	if (foreThread != appThread) {
		AttachThreadInput(foreThread, appThread, true);
		BringWindowToTop(hWnd);
		ShowWindow(hWnd, SW_SHOW);
		AttachThreadInput(foreThread, appThread, false);
	} else {
		BringWindowToTop(hWnd);
		ShowWindow(hWnd, SW_SHOW);
	}
}
Example #24
0
WINBOOL SetForegroundWindowEx(HWND hWnd)
{
    //Attach foreground window thread to our thread
    const DWORD ForeGroundID = GetWindowThreadProcessId(::GetForegroundWindow(), NULL);
    const DWORD CurrentID   = GetCurrentThreadId();
    WINBOOL retval;

    AttachThreadInput(ForeGroundID, CurrentID, TRUE);
    //Do our stuff here
    HWND hLastActivePopupWnd = GetLastActivePopup(hWnd);
    retval = SetForegroundWindow(hLastActivePopupWnd);

    //Detach the attached thread
    AttachThreadInput(ForeGroundID, CurrentID, FALSE);
    return retval;
}// End SetForegroundWindowEx
Example #25
0
static
bool
attachThreadToForeground()
{
    // only attach threads if using low level hooks.  a low level hook
    // runs in the thread that installed the hook but we have to make
    // changes that require being attached to the target thread (which
    // should be the foreground window).  a regular hook runs in the
    // thread that just removed the event from its queue so we're
    // already in the right thread.
    if (g_hookThread != 0) {
        HWND window    = GetForegroundWindow();
        DWORD threadID = GetWindowThreadProcessId(window, NULL);
        // skip if no change
        if (g_attachedThread != threadID) {
            // detach from previous thread
            detachThread();

            // attach to new thread
            if (threadID != 0 && threadID != g_hookThread) {
                AttachThreadInput(g_hookThread, threadID, TRUE);
                g_attachedThread = threadID;
            }
            return true;
        }
    }
    return false;
}
Example #26
0
void muiWindow::BringWindowToForeground()
{
	// Windows 98 and later very much restricts what SetForegroundWindow() does - in most cases it just flashes the taskbar.
	// Here we will force it to actually brind the window to the foreground & get the keyboard focus
	HWND hwndForegroundWindow = GetForegroundWindow();
	DWORD dwForegroundThreadId = GetWindowThreadProcessId(hwndForegroundWindow, NULL); 
	DWORD dwThisThreadId = GetWindowThreadProcessId(hwnd, NULL); 

	bool bAttachedToFgThread = (dwThisThreadId != dwForegroundThreadId) && AttachThreadInput(dwThisThreadId, dwForegroundThreadId, TRUE);
	
	SetForegroundWindow(hwnd); 
	//BringWindowToTop(hwnd);
	SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOREDRAW);
    
	if (bAttachedToFgThread) AttachThreadInput(dwThisThreadId, dwForegroundThreadId, FALSE); 
}
Example #27
0
void CSysProgressDlg::Stop()
{
	if ((m_isVisible)&&(IsValid()))
	{
		m_pIDlg->StopProgressDialog();
		// Sometimes the progress dialog sticks around after stopping it,
		// until the mouse pointer is moved over it or some other triggers.
		// We hide the window here immediately.
		if (m_hWndProgDlg)
		{
			// The progress dialog is handled on a separate thread, which means
			// even calling StopProgressDialog() will not stop it immediately.
			// Even destroying the progress window is not enough.
			// Which can cause problems with modality: if we stop the progress
			// dialog and immediately show e.g. a messagebox over the same
			// window the progress dialog has as its parent, then the messagebox
			// is modal first (deactivates the parent), but then a little bit
			// later the progress dialog finally closes properly, and by doing that
			// re-enables its parent window.
			// Which leads to the parent window being enabled even though
			// the modal messagebox is shown over the parent window.
			// This situation can even lead to the messagebox appearing *behind*
			// the parent window (race condition)
			// 
			// So, to really ensure that the progress dialog is fully stopped
			// and destroyed, we have to attach to its UI thread and handle
			// all messages until there are no more messages: that's when
			// the progress dialog is really gone.
			AttachThreadInput(GetWindowThreadProcessId(m_hWndProgDlg, 0), GetCurrentThreadId(), TRUE);
			// StartProgressDialog creates a new thread to host the progress window.
			// When the window receives WM_DESTROY message StopProgressDialog() wrongly
			// attempts to re-enable the parent in the calling thread (our thread),
			// after the progress window is destroyed and the progress thread has died.
			// When the progress window dies, the system tries to assign a new foreground window.
			// It cannot assign to hwndParent because StartProgressDialog (w/PROGDLG_MODAL) disabled the parent window.
			// So the system hands the foreground activation to the next process that wants it in the
			// system foreground queue. Thus we lose our right to recapture the foreground window.
			// To fix this problem, we enable the parent window and set to focus to it here, after
			// we've attached to the window thread.
			ShowWindow(m_hWndProgDlg, SW_HIDE);
			EnableWindow(m_hWndParent, TRUE);
			if (m_hWndFocus)
				SetFocus(m_hWndFocus);
			else
				SetFocus(m_hWndParent);
			auto start = GetTickCount64();
			while (::IsWindow(m_hWndProgDlg) && ((GetTickCount64() - start) < 3000))
			{
				MSG msg = { 0 };
				while (PeekMessage(&msg, m_hWndProgDlg, 0, 0, PM_REMOVE))
				{
				}
			}
		}
		m_isVisible = false;
		m_pIDlg.Release();

		m_hWndProgDlg = nullptr;
	}
}
Example #28
0
void BrowsePushed(LPRUNDLG_DATA lprd)
{
    HWND hDlg = lprd->hDlg;
    TCHAR szText[MAX_PATH];

    // Get out of the "synchronized input queues" state
    if (lprd->dwThreadId)
    {
        AttachThreadInput(GetCurrentThreadId(), lprd->dwThreadId, FALSE);
        lprd->dwThreadId = 0;
    }

    GetDlgItemText(hDlg, IDD_COMMAND, szText, ARRAYSIZE(szText));
    PathUnquoteSpaces(szText);

    if (GetFileNameFromBrowse(hDlg, szText, ARRAYSIZE(szText), lprd->lpszWorkingDir,
            MAKEINTRESOURCE(IDS_EXE), MAKEINTRESOURCE(IDS_PROGRAMSFILTER),
            MAKEINTRESOURCE(IDS_BROWSE)))
    {
        PathQuoteSpaces(szText);
        SetDlgItemText(hDlg, IDD_COMMAND, szText);
        EnableOKButton(hDlg, szText);
        // place the focus on OK
        // SetFocus(GetDlgItem(hDlg, IDOK));
        SendMessage(hDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hDlg, IDOK), TRUE);
    }
}
Example #29
0
BOOL install_util::ForeGroundInstallWindow()
{
  HWND hWnd= FindWindow(_T("#32770"), INSTALL_TITLE);
  if(NULL == hWnd)
    return FALSE;
  HWND hForeWnd =  GetForegroundWindow(); 
  DWORD dwCurID =  GetCurrentThreadId(); 
  DWORD dwForeID =  GetWindowThreadProcessId(hForeWnd, NULL); 
  AttachThreadInput(dwCurID, dwForeID, TRUE); 
  ShowWindow( hWnd, SW_SHOWNORMAL ); 
  SetWindowPos( hWnd, HWND_TOPMOST, 0,0,0,0, SWP_NOSIZE|SWP_NOMOVE ); 
  SetWindowPos( hWnd, HWND_NOTOPMOST, 0,0,0,0, SWP_NOSIZE|SWP_NOMOVE ); 
  SetForegroundWindow( hWnd ); 
  AttachThreadInput(dwCurID, dwForeID, FALSE);
  return TRUE;
}
Example #30
0
//---------------------------------------------------------------------------
// Puts up the standard file.run dialog.
// REVIEW UNDONE This should use a RUNDLG structure for all the various
// options instead of just passing them as parameters, a ptr to the struct
// would be passed to the dialog via the lParam.
int WINAPI RunFileDlg(HWND hwndParent, HICON hIcon, LPCTSTR lpszWorkingDir, LPCTSTR lpszTitle,
        LPCTSTR lpszPrompt, DWORD dwFlags)
{
    RUNDLG_DATA rd;

    rd.hIcon = hIcon;
    rd.lpszWorkingDir = lpszWorkingDir;
    rd.lpszTitle = lpszTitle;
    rd.lpszPrompt = lpszPrompt;
    rd.dwFlags = dwFlags;
    rd.hEventReady = 0;
    rd.dwThreadId = 0;

    // We do this so we can get type-ahead when we're running on a
    // seperate thread. The parent thread needs to block to give us time
    // to do the attach and then get some messages out of the queue hence
    // the event.
    if (hwndParent)
    {
        // HACK The parent signals it's waiting for the dialog to grab type-ahead
        // by sticking it's threadId in a property on the parent.
        rd.dwThreadId = (DWORD)GetProp(hwndParent, c_szWaitingThreadID);
        if (rd.dwThreadId)
        {
            // DebugMsg(DM_TRACE, "s.rfd: Attaching input to %x.", idThread);
            AttachThreadInput(GetCurrentThreadId(), rd.dwThreadId, TRUE);
            // NB Hack.
            rd.hEventReady = OpenEvent(EVENT_ALL_ACCESS, TRUE, c_szRunDlgReady);
        }
    }

    return DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_RUN), hwndParent,
        RunDlgProc, (LPARAM)(LPRUNDLG_DATA)&rd);
}