Пример #1
0
	virtual void OnClick(BOOL /*bKeyboard  = FALSE */, CPoint /*pt  = CPoint */)
	{
		if (GetKeyState(VK_LBUTTON) >= 0)
			return;

		m_bPressed = TRUE;

		CXTPRibbonScrollableBar* pScrollableBar = GetScrollableBar(m_pParent);

		pScrollableBar->OnGroupsScroll(m_bScrollLeft);

		int cmsTimer = GetDoubleClickTime() * 4 / 5;
		m_pParent->SetTimer(IDSYS_SCROLL, cmsTimer, NULL);
		BOOL bFirst = TRUE;

		m_pParent->SetCapture();

		while (::GetCapture() == m_pParent->GetSafeHwnd() && IsVisible())
		{
			MSG msg;

			if (!::GetMessage(&msg, NULL, 0, 0))
			{
				AfxPostQuitMessage((int)msg.wParam);
				break;
			}

			if (msg.message == WM_TIMER && msg.wParam == IDSYS_SCROLL)
			{
				pScrollableBar->OnGroupsScroll(m_bScrollLeft);

				if (bFirst)
				{
					cmsTimer = GetDoubleClickTime() / 10;
					m_pParent->SetTimer(IDSYS_SCROLL, cmsTimer, NULL);
				}
				bFirst = FALSE;
			}
			else if (msg.message == WM_LBUTTONUP)
			{
				break;
			}
			else
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}

		ReleaseCapture();
		m_pParent->KillTimer(IDSYS_SCROLL);

		m_bPressed = FALSE;
		if (!IsVisible()) m_bSelected = FALSE;
		RedrawParent(FALSE);
	}
Пример #2
0
CTitleTip::CTitleTip()
{
	// Register the window class if it has not already been registered.
	WNDCLASS wndcls;
	HINSTANCE hInst = AfxGetInstanceHandle();
	if(!(::GetClassInfo(hInst, TITLETIP_CLASSNAME, &wndcls)))
	{
		// otherwise we need to register a new class
		wndcls.style			= CS_SAVEBITS;
		wndcls.lpfnWndProc		= ::DefWindowProc;
		wndcls.cbClsExtra		= wndcls.cbWndExtra = 0;
		wndcls.hInstance		= hInst;
		wndcls.hIcon			= NULL;
		wndcls.hCursor			= LoadCursor( hInst, IDC_ARROW );
		wndcls.hbrBackground	= (HBRUSH)(COLOR_INFOBK +1);
		wndcls.lpszMenuName		= NULL;
		wndcls.lpszClassName	= TITLETIP_CLASSNAME;

		if (!AfxRegisterClass(&wndcls))
			AfxThrowResourceException();
	}

    m_dwLastLButtonDown = ULONG_MAX;
    m_dwDblClickMsecs   = GetDoubleClickTime();
    m_bCreated          = FALSE;
    m_pParentWnd        = NULL;
}
Пример #3
0
/////////////////////////////////////////////////////////////////////////////
// ZTitleTip
//
ZTitleTip::ZTitleTip( zLONG lHoverDelay )
{
#ifdef DEBUG_ALL
   TraceLineI( "ZTitleTip::ctor Delay: ", lHoverDelay );
#endif

   // Register the window class if it has not already been registered.
   WNDCLASS wndcls;
   HINSTANCE hInst = AfxGetInstanceHandle( );

   if ( ::GetClassInfo( hInst, ZTITLETIP_CLASSNAME, &wndcls ) == 0 )
   {
      // Otherwise we need to register a new class.
      wndcls.style         = CS_SAVEBITS;
      wndcls.lpfnWndProc   = ::DefWindowProc;
      wndcls.cbClsExtra    = wndcls.cbWndExtra = 0;
      wndcls.hInstance     = hInst;
      wndcls.hIcon         = 0;
      wndcls.hCursor       = LoadCursor( hInst, IDC_ARROW );
      wndcls.hbrBackground = (HBRUSH)(COLOR_INFOBK + 1);
      wndcls.lpszMenuName  = 0;
      wndcls.lpszClassName = ZTITLETIP_CLASSNAME;
      if ( AfxRegisterClass( &wndcls ) == 0 )
         AfxThrowResourceException( );
   }

   m_dwLastLButtonDown  = ULONG_MAX;
   m_ulDblClickInterval = GetDoubleClickTime( );
   m_bCreated           = FALSE;
   m_pParentWnd         = 0;
   m_lHoverDelay        = lHoverDelay;
}
Пример #4
0
void
win_mouse_click(mouse_button b, LPARAM lp)
{
  static mouse_button last_button;
  static uint last_time, count;
  static pos last_click_pos;

  win_show_mouse();
  if (tab_bar_click(lp)) return;

  mod_keys mods = get_mods();
  pos p = get_mouse_pos(lp);

  uint t = GetMessageTime();
  if (b != last_button ||
      p.x != last_click_pos.x || p.y != last_click_pos.y ||
      t - last_time > GetDoubleClickTime() || ++count > 3)
    count = 1;
  term_mouse_click(win_active_terminal(), b, mods, p, count);
  last_pos = (pos){INT_MIN, INT_MIN};
  last_click_pos = p;
  last_time = t;
  last_button = b;
  if (alt_state > ALT_NONE)
    alt_state = ALT_CANCELLED;
}
Пример #5
0
// MDI client subclassing
LRESULT CALLBACK EXPORT CallBack(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  LPOLDGLOBALS lp=FindGlobal(hWnd);

  if (!lp)
    return 0L;

  switch (message)
    {
    case WM_LBUTTONDOWN:
      {
      DWORD dwThisLBUTTONDOWNTime;
      dwThisLBUTTONDOWNTime=GetMessageTime();
      if ( (dwThisLBUTTONDOWNTime-dwLastLBUTTONDOWNTime<=(DWORD)GetDoubleClickTime()))
        {
        dwLastLBUTTONDOWNTime=0;
        BoxSelectWindow(lp);
        return 0;
        }
      else
        dwLastLBUTTONDOWNTime=dwThisLBUTTONDOWNTime;
      }
    }
  return CallWindowProc(lp->lpfnOldFarProc,hWnd,message,wParam,lParam);
}
// CodeReview I've duplicated this 'cache' trick for system settings
// because they're unlikely to change and calling into the OS for values
// repeatedly is just silly to begin with.  [6/29/2007 justind]
U32 Win32CursorController::getDoubleClickTime()
{
    static S32 sPlatWinDoubleClicktime = -1;
    if( sPlatWinDoubleClicktime == -1 )
        sPlatWinDoubleClicktime = GetDoubleClickTime();
    return sPlatWinDoubleClicktime;
}
QVariant QWindowsIntegration::styleHint(QPlatformIntegration::StyleHint hint) const
{
    switch (hint) {
    case QPlatformIntegration::CursorFlashTime:
        if (const unsigned timeMS = GetCaretBlinkTime())
            return QVariant(int(timeMS));
        break;
#ifdef SPI_GETKEYBOARDSPEED
    case KeyboardAutoRepeatRate:
        return QVariant(keyBoardAutoRepeatRateMS());
#endif
    case QPlatformIntegration::StartDragTime:
    case QPlatformIntegration::StartDragDistance:
    case QPlatformIntegration::KeyboardInputInterval:
    case QPlatformIntegration::ShowIsFullScreen:
    case QPlatformIntegration::PasswordMaskDelay:
    case QPlatformIntegration::StartDragVelocity:
        break; // Not implemented
    case QPlatformIntegration::FontSmoothingGamma:
        return QVariant(QWindowsFontDatabase::fontSmoothingGamma());
    case QPlatformIntegration::MouseDoubleClickInterval:
        if (const int ms = GetDoubleClickTime())
            return QVariant(ms);
        break;
    case QPlatformIntegration::UseRtlExtensions:
        return QVariant(d->m_context.useRTLExtensions());
    }
    return QPlatformIntegration::styleHint(hint);
}
Пример #8
0
void
win_mouse_click(mouse_button b, LPARAM lp)
{
  static mouse_button last_button;
  static uint last_time, count;
  static pos last_click_pos;

  win_show_mouse();
  mod_keys mods = get_mods();
  pos p = get_mouse_pos(lp);

  uint t = GetMessageTime();
  if (b != last_button ||
      p.x != last_click_pos.x || p.y != last_click_pos.y ||
      t - last_time > GetDoubleClickTime() || ++count > 3)
    count = 1;

  SetFocus(wnd);  // in case focus was in search bar
  term_mouse_click(b, mods, p, count);
  last_pos = (pos){INT_MIN, INT_MIN};
  last_click_pos = p;
  last_time = t;
  last_button = b;
  if (alt_state > ALT_NONE)
    alt_state = ALT_CANCELLED;
}
Пример #9
0
int
mousewheel_scroll(HWND win, int delta, int page, BOOL is_vertical)
{
    /* We accumulate the wheel_delta until there is enough to scroll for
     * at least a single line. This improves the feel for strange values
     * of SPI_GETWHEELSCROLLLINES and for some mouses. */
    static HWND last_win = NULL;
    static DWORD last_time[2] = { 0, 0 };   /* horizontal, vertical */
    static int accum_delta[2] = { 0, 0 };   /* horizontal, vertical */

    DWORD now;
    UINT param;
    int dir = (is_vertical ? 1 : 0); /* index into accum_delta[], last_time[] */
    UINT lines_per_WHEEL_DELTA;
    int lines;

    now = GetTickCount();

    if(page < 1)
        page = 1;

    /* Ask the system for scroll speed. */
    param = (is_vertical ? SPI_GETWHEELSCROLLLINES : SPI_GETWHEELSCROLLCHARS);
    if(MC_ERR(!SystemParametersInfo(param, 0, &lines_per_WHEEL_DELTA, 0)))
        lines_per_WHEEL_DELTA = 3;

    /* But never scroll more then complete page. */
    if(lines_per_WHEEL_DELTA == WHEEL_PAGESCROLL  ||  lines_per_WHEEL_DELTA >= page)
        lines_per_WHEEL_DELTA = page;

    mc_mutex_lock(&mousewheel_mutex);

    /* Reset the accumulated value(s) when switching to another window, when
     * changing scrolling direction, or when the wheel was not used for some
     * time. */
    if(win != last_win) {
        last_win = win;
        accum_delta[0] = 0;
        accum_delta[1] = 0;
    } else if((now - last_time[dir] > GetDoubleClickTime() * 2)  ||
              ((delta > 0) == (accum_delta[dir] < 0))) {
        accum_delta[dir] = 0;
    }

    /* Compute lines to scroll. */
    if(lines_per_WHEEL_DELTA > 0) {
        accum_delta[dir] += delta;
        lines = (accum_delta[dir] * (int)lines_per_WHEEL_DELTA) / WHEEL_DELTA;
        accum_delta[dir] -= (lines * WHEEL_DELTA) / (int)lines_per_WHEEL_DELTA;
    } else {
        /* lines_per_WHEEL_DELTA == 0 --> We just don't scroll at all. */
        lines = 0;
        accum_delta[dir] = 0;
    }
    last_time[dir] = now;

    mc_mutex_unlock(&mousewheel_mutex);
    return (is_vertical ? -lines : lines);
}
Пример #10
0
//--------------------------------------------------------------------------
void WindowsMouse::_Init() noexcept
{
    VeCursorPtr spDefault = VE_NEW VeCursor();
    VeCursor::Data* pkData = GetCursorData(spDefault);
    pkData->m_pvDriverdata = LoadCursor(nullptr, IDC_ARROW);
    SetDefaultCursor(pkData);
    SetDoubleClickTime(GetDoubleClickTime());
}
Пример #11
0
static pos
translate_pos(int x, int y)
{
  return (pos){
    .x = floorf((x - PADDING) / (float)font_width ),
    .y = floorf((y - PADDING) / (float)font_height), 
  };
}

static pos
get_mouse_pos(LPARAM lp)
{
  return translate_pos(GET_X_LPARAM(lp), GET_Y_LPARAM(lp));  
}

static mouse_button clicked_button;
static pos last_pos;

void
win_mouse_click(mouse_button b, LPARAM lp)
{
  static mouse_button last_button;
  static uint last_time, count;
  static pos last_click_pos;

  win_show_mouse();
  mod_keys mods = get_mods();
  pos p = get_mouse_pos(lp);
  
  if (clicked_button) {
    term_mouse_release(b, mods, p);
    clicked_button = 0;
  }
  
  uint t = GetMessageTime();
  if (b != last_button ||
      p.x != last_click_pos.x || p.y != last_click_pos.y ||
      t - last_time > GetDoubleClickTime() || ++count > 3)
    count = 1;
  term_mouse_click(b, mods, p, count);
  last_pos = last_click_pos = p;
  last_time = t;
  clicked_button = last_button = b;
  if (alt_state > ALT_NONE)
    alt_state = ALT_CANCELLED;
}

void
win_mouse_release(mouse_button b, LPARAM lp)
{
  win_show_mouse();
  if (b == clicked_button) {
    term_mouse_release(b, get_mods(), get_mouse_pos(lp));
    clicked_button = 0;
    ReleaseCapture();
  }
}  
 // static
 bool NativeTextfieldWin::IsDoubleClick(const POINT& origin,
     const POINT& current, DWORD elapsed_time)
 {
     // The CXDOUBLECLK and CYDOUBLECLK system metrics describe the width and
     // height of a rectangle around the origin position, inside of which clicks
     // within the double click time are considered double clicks.
     return (elapsed_time<=GetDoubleClickTime()) &&
         (abs(current.x-origin.x)<=(GetSystemMetrics(SM_CXDOUBLECLK)/2)) &&
         (abs(current.y-origin.y)<=(GetSystemMetrics(SM_CYDOUBLECLK)/2));
 }
void HideFlyout(HWND hwndMainWindow, HWND hwndFlyout)
{
    DestroyWindow(hwndFlyout);

    // immediately after hiding the flyout we don't want to allow showing it again, which will allow clicking
    // on the icon to hide the flyout. If we didn't have this code, clicking on the icon when the flyout is open
    // would cause the focus change (from flyout to the taskbar), which would trigger hiding the flyout
    // (see the WM_ACTIVATE handler). Since the flyout would then be hidden on click, it would be shown again instead
    // of hiding.
    SetTimer(hwndMainWindow, HIDEFLYOUT_TIMER_ID, GetDoubleClickTime(), NULL);
}
Пример #14
0
// Left button
void CMouse::InternalOnLButtonDown(UINT nFlags, const CPoint& point)
{
    GetWnd().SetFocus();
    m_bLeftDown = false;
    SetCursor(nFlags, point);
    if (MVRDown(nFlags, point)) {
        return;
    }
    bool bIsOnFS = IsOnFullscreenWindow();
    if ((!m_bD3DFS || !bIsOnFS) && (abs(GetMessageTime() - m_popupMenuUninitTime) < 2)) {
        return;
    }
    if (m_pMainFrame->GetLoadState() == MLS::LOADED && m_pMainFrame->GetPlaybackMode() == PM_DVD &&
            (m_pMainFrame->IsD3DFullScreenMode() ^ m_bD3DFS) == 0 &&
            (m_pMainFrame->m_pDVDC->ActivateAtPosition(GetVideoPoint(point)) == S_OK)) {
        return;
    }
    if (m_bD3DFS && bIsOnFS && m_pMainFrame->m_OSD.OnLButtonDown(nFlags, point)) {
        return;
    }
    m_bLeftDown = true;
    bool bDouble = false;
    if (m_bLeftDoubleStarted &&
            GetMessageTime() - m_leftDoubleStartTime < (int)GetDoubleClickTime() &&
            CMouse::PointEqualsImprecise(m_leftDoubleStartPoint, point)) {
        m_bLeftDoubleStarted = false;
        bDouble = true;
    } else {
        m_bLeftDoubleStarted = true;
        m_leftDoubleStartTime = GetMessageTime();
        m_leftDoubleStartPoint = point;
    }
    auto onButton = [&]() {
        GetWnd().SetCapture();
        bool ret = false;
        if (bIsOnFS || !m_pMainFrame->IsCaptionHidden()) {
            ret = OnButton(wmcmd::LDOWN, point, bIsOnFS);
        }
        if (bDouble) {
            ret = OnButton(wmcmd::LDBLCLK, point, bIsOnFS) || ret;
        }
        if (!ret) {
            ReleaseCapture();
        }
        return ret;
    };
    m_drag = (!onButton() && !bIsOnFS) ? Drag::BEGIN_DRAG : Drag::NO_DRAG;
    if (m_drag == Drag::BEGIN_DRAG) {
        GetWnd().SetCapture();
        m_beginDragPoint = point;
        GetWnd().ClientToScreen(&m_beginDragPoint);
    }
}
Пример #15
0
void aui_Region::InitCommon(void)
{
#ifdef __AUI_USE_DIRECTX__
	m_doubleClickTimeOut    = GetDoubleClickTime();
#else
	m_doubleClickTimeOut    = 375;
#endif

	m_editGrabPoint.x       = -1;
	m_editGrabPoint.y       = -1;

    memset(&m_mouseState, 0, sizeof(m_mouseState));
}
Пример #16
0
void CTreeCtrlEx::OnLButtonDown( UINT nFlags, CPoint point )
{

	UINT nHitFlags = 0;
	HTREEITEM hClickedItem = HitTest( point, &nHitFlags );

	// Must invoke label editing explicitly. The base class OnLButtonDown would normally
	// do this, but we can't call it here because of the multiple selection...
	if( !( nFlags&( MK_CONTROL|MK_SHIFT ) ) && ( GetStyle() & TVS_EDITLABELS ) && ( nHitFlags & TVHT_ONITEMLABEL ) )
		if ( hClickedItem == GetSelectedItem() )
		{
			// Clear multple selection before label editing
			ClearSelection();
			SelectItem( hClickedItem );

			// Invoke label editing
			m_bEditLabelPending = TRUE;
			m_idTimer = SetTimer(TCEX_EDITLABEL, GetDoubleClickTime(), NULL);

			return;
		}

	m_bEditLabelPending = FALSE;

	if( nHitFlags & TVHT_ONITEM )
	{
		SetFocus();

		m_hClickedItem = hClickedItem;

		// Is the clicked item already selected ?
		BOOL bIsClickedItemSelected = GetItemState( hClickedItem, TVIS_SELECTED ) & TVIS_SELECTED;

		if ( bIsClickedItemSelected )
		{
			// Maybe user wants to drag/drop multiple items!
			// So, wait until OnLButtonUp() to do the selection stuff. 
			m_bSelectPending=TRUE;
		}
		else
		{
			SelectMultiple( hClickedItem, nFlags, point );
			m_bSelectPending=FALSE;
		}

		m_ptClick=point;
	}
	else
		CTreeCtrl::OnLButtonDown( nFlags, point );
}
Пример #17
0
    UIContext::UIContext(const Vector2& screenSize) :
        m_screenSize(screenSize)
    {
#if defined(WIN32)
        doubleClickTime = std::chrono::milliseconds(GetDoubleClickTime());
#endif
        pContentManager = oContentManager;
        m_pDownControls[0] = nullptr;
        m_pDownControls[1] = nullptr;
        m_pDownControls[2] = nullptr;
        m_pLastDownControls[0] = nullptr;
        m_pLastDownControls[1] = nullptr;
        m_pLastDownControls[2] = nullptr;
    }
Пример #18
0
void CIWinSyncDlg::HideFlyout()
{
	m_pFlyoutDialog->ShowWindow(SW_HIDE);
	m_pFlyoutDialog->DestroyWindow();
	delete(m_pFlyoutDialog);
	m_pFlyoutDialog = NULL;
   
    // immediately after hiding the flyout we don't want to allow showing it again, which will allow clicking
    // on the icon to hide the flyout. If we didn't have this code, clicking on the icon when the flyout is open
    // would cause the focus change (from flyout to the taskbar), which would trigger hiding the flyout
    // (see the WM_ACTIVATE handler). Since the flyout would then be hidden on click, it would be shown again instead
    // of hiding.
    SetTimer(HIDEFLYOUT_TIMER_ID, GetDoubleClickTime(), NULL);
}
Пример #19
0
LRESULT msg_handler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static UINT taskbarRestartMsg; /* static here means value is kept across multiple calls to this func */

    switch(msg) {
    case WM_CREATE:
        taskbarRestartMsg = RegisterWindowMessage("TaskbarCreated");
        break;

    case WM_TIMER:
#if 0
        KillTimer(hWnd, timerID);
        call_caml_systray_clicked(SYSTRAY_LBUTTONCLK);
#endif
        break;

    case WM_DESTROY:
        break;

    case WM_TRAYMESSAGE:
#if 0
        switch (lParam) {
        case WM_RBUTTONUP:
            call_caml_systray_clicked(SYSTRAY_RBUTTONCLK);
            break;

        case WM_LBUTTONDBLCLK:
            KillTimer(hWnd, timerID);
            call_caml_systray_clicked(SYSTRAY_LBUTTONDBLCLK);
            break;

        case WM_LBUTTONDOWN:
            SetTimer(hWnd, timerID, GetDoubleClickTime(), NULL);
            break;

        }
#endif
    default:
        if (msg == taskbarRestartMsg) {
            /* explorer crashed and left us hanging...
               This will put the systray icon back in it's place, when it restarts */
            Shell_NotifyIcon(NIM_ADD,&nid);
        }
        break;

    }/* end switch */

    return DefWindowProc(hWnd, msg, wParam, lParam);

}
Пример #20
0
VOID CXElement::On_CXMsg_MouseEnter( CXMsg_MouseEnter& arg )
{
	CString toolTip;
	if (XSUCCEEDED(GetToolTip(toolTip)))
	{
		CXMsg_GetRealWnd msg;
		_SendXMsg(msg);
		if (!msg.wnd)
		{
			return;
		}
		HWND hWnd = 0;
		msg.wnd->GetHWnd(hWnd);
		if (!m_toolTip.IsWindow())
		{
			m_toolTip.Create(hWnd, NULL, NULL, TTS_ALWAYSTIP | TTS_NOPREFIX,WS_EX_TOPMOST);
			if (!m_toolTip.IsWindow())
			{
				WTF;
			}
			m_toolTip.SetWindowLongPtr(GWLP_USERDATA,(LONG_PTR)hWnd);

			CSize size;
			GetSize(size);
			m_toolTip.SetMaxTipWidth(260);
			m_toolTip.AddTool(hWnd,_T(""));
			m_toolTip.SetDelayTime( TTDT_AUTOPOP, static_cast<int>(GetDoubleClickTime() * 10) ) ;
			m_toolTip.SetDelayTime( TTDT_RESHOW, static_cast<int>(GetDoubleClickTime() * 10) ) ;
			m_toolTip.Activate(TRUE);
		}
		MSG mouseMsg = { hWnd, WM_MOUSEMOVE, 0, MAKELONG (arg.pt.x,arg.pt.y)};
		m_toolTip.RelayEvent(&mouseMsg);

		m_toolTip.UpdateTipText((LPCTSTR)toolTip,hWnd);
	}
	arg.msgHandled = TRUE;
}
Пример #21
0
static void SDLCALL
SDL_MouseDoubleClickTimeChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
{
    SDL_Mouse *mouse = (SDL_Mouse *)userdata;

    if (hint && *hint) {
        mouse->double_click_time = SDL_atoi(hint);
    } else {
#ifdef __WIN32__
        mouse->double_click_time = GetDoubleClickTime();
#else
        mouse->double_click_time = 500;
#endif
    }
}
Пример #22
0
void GetSysParms(void)
{
	TRACEBEGIN(TRCSUBSYSHOST, TRCSCOPEINTERN, "GetSysParms");

	crAuto		= GetSysColor(COLOR_WINDOWTEXT);
	cxBorder	= GetSystemMetrics(SM_CXBORDER);	// Unsizable window border
	cyBorder	= GetSystemMetrics(SM_CYBORDER);	//  widths
	cxHScroll	= GetSystemMetrics(SM_CXHSCROLL);	// Scrollbar-arrow bitmap 
	cxVScroll	= GetSystemMetrics(SM_CXVSCROLL);	//  dimensions
	cyHScroll	= GetSystemMetrics(SM_CYHSCROLL);	//
	cyVScroll	= GetSystemMetrics(SM_CYVSCROLL);	//
	cxDoubleClk	= GetSystemMetrics(SM_CXDOUBLECLK);
	cyDoubleClk	= GetSystemMetrics(SM_CYDOUBLECLK);
	DCT			= GetDoubleClickTime();
    
    // Get system metrics (do this only once)
    // CF - Ideally we should not need these stupid metrics

    HWND hwnd = GetDesktopWindow();
    HDC hdc = ::GetDC(hwnd);
    HFONT hfontOld;
    TEXTMETRIC tm;

	xPerInchScreenDC = GetDeviceCaps(hdc, LOGPIXELSX); 
	yPerInchScreenDC = GetDeviceCaps(hdc, LOGPIXELSY);
	int cPalette = GetDeviceCaps(hdc, SIZEPALETTE);

	// 256 colors is where we seem to need to use the palette.
	if (256 == cPalette)
	{
		fUsePalette = TRUE;
	}

	// calculate a himetric selection bar for the window's host.
	dxSelBar = DXtoHimetricX(dxSelBarDefaultSize, xPerInchScreenDC);

    hfontOld = (HFONT)SelectObject(hdc, GetStockObject(SYSTEM_FONT));
    if(hfontOld)
    {
		GetTextMetrics(hdc, &tm);
		CDisplay::_xWidthSys = (INT) tm.tmAveCharWidth;
		CDisplay::_yHeightSys = (INT) tm.tmHeight;

		SelectObject(hdc, hfontOld);
    }

    ::ReleaseDC(hwnd, hdc);		
}
Пример #23
0
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

	MSG msg;

	szTitle = GString(IDS_APP_TITLE);
	szWindowClass = GString(IDC_LAUNCHBROWSER);
	OptionsKeyName = Format(TEXT("Software\\%s"), szTitle.c_str());
	
	// if it's running already, pop the options dialog
	HWND existingWindow = FindWindow(szWindowClass.c_str(), szTitle.c_str());
	if(existingWindow != NULL)
	{
		SendNotifyMessage(existingWindow, WM_COMMAND, ID_FILE_OPTIONS, 0);
		return FALSE;
	}

	RegisterWindowClass(hInstance);

	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}

	Browser::ScanRegistryForBrowsers();
	SearchEngine::InitSearchEngines();

	MouseDoubleClickTime = GetDoubleClickTime() / 1000.0;

	hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, fnKeyboardHook, hInstance, 0);

	if(LoadOptionsFromRegistry() == FALSE)
	{
		PostMessage(hMainWindow, WMU_POP_OPTIONS_DIALOG, 0, 0);
	}

	// Main message loop:
	while (GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return (int) msg.wParam;
}
Пример #24
0
void Console::onLBtnDown(HWND hWnd, int x, int y, const COORD &pos)
{
	static DWORD	prev_time = 0;
	static int	prevX = -100;
	static int	prevY = -100;

	{
		/* calc click count */
		DWORD now_time = GetTickCount();
		DWORD stime;
		if(prev_time > now_time)
			stime = now_time + ~prev_time+1;
		else
			stime = now_time - prev_time;
		if(stime <= GetDoubleClickTime()) {
			int sx = (prevX > x) ? prevX-x : x-prevX;
			int sy = (prevY > y) ? prevY-y : y-prevY;
			if(sx <= GetSystemMetrics(SM_CXDOUBLECLK) &&
			   sy <= GetSystemMetrics(SM_CYDOUBLECLK)) {
				if(++gSelectMode > 2)
					gSelectMode = 0;
			}
			else {
				gSelectMode = 0;
			}
		}
		else {
			gSelectMode = 0;
		}
		prev_time = now_time;
		prevX = x;
		prevY = y;
	}

	if(!gScreen)
		return;

	SetCapture(hWnd);

	gSelectPos.X = pos.X;
	gSelectPos.Y = pos.Y;
	gSelectRect.Left = gSelectRect.Right = pos.X;
	gSelectRect.Top  = gSelectRect.Bottom = pos.Y;

	__select_expand();
	InvalidateRect(hWnd, NULL, FALSE);
}
Пример #25
0
	/*static*/
	bool Win32TrayItem::MessageHandler(
		HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
	{
		if (message == trayClickedMessage)
		{
			UINT button = (UINT) lParam;
			int id = LOWORD(wParam);
			bool handled = false;

			for (size_t i = 0; i < trayItems.size(); i++)
			{
				AutoPtr<Win32TrayItem> item = trayItems[i];

				item->is_double_clicked = false;
				if(item->GetId() == id && button == WM_LBUTTONDBLCLK)
				{
					item->is_double_clicked = true;
					KillTimer(hWnd, 100);
					item->HandleDoubleLeftClick();
					handled = true;
				}
				if (item->GetId() == id && button == WM_LBUTTONDOWN)
				{
					SetTimer(hWnd, 100, GetDoubleClickTime(), (TIMERPROC)DoubleClickTimerProc); 
					handled = true;
				}
				else if (item->GetId() == id && button == WM_RBUTTONDOWN)
				{
					item->HandleRightClick();
					handled = true;
				}
			}
			return handled;
		}
		else if (message == WM_MENUCOMMAND)
		{
			HMENU nativeMenu = (HMENU) lParam;
			UINT position = (UINT) wParam;
			return Win32MenuItem::HandleClickEvent(nativeMenu, position);
		}
		else
		{
			// Not handled;
			return false;
		}
	}
Пример #26
0
///initialize GLUT
bool init_glut()
{
  static int argc = 1;
  static const char* argv[1] = { "x" };

  //prepare GLUT environment
  if (!glut_initialized) {
    glutInit(&argc, (char**) argv);
    glut_initialized = true;
  }
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_ACCUM);
  glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);

  //obtain other parameters
#ifdef WIN32
  double_click_delay_ms = GetDoubleClickTime();
#endif

  return true;
}
Пример #27
0
QVariant QWindowsIntegration::styleHint(QPlatformIntegration::StyleHint hint) const
{
    switch (hint) {
    case QPlatformIntegration::CursorFlashTime:
        if (const unsigned timeMS = GetCaretBlinkTime())
            return QVariant(int(timeMS) * 2);
        break;
#ifdef SPI_GETKEYBOARDSPEED
    case KeyboardAutoRepeatRate:
        return QVariant(keyBoardAutoRepeatRateMS());
#endif
    case QPlatformIntegration::StartDragTime:
    case QPlatformIntegration::StartDragDistance:
    case QPlatformIntegration::KeyboardInputInterval:
    case QPlatformIntegration::ShowIsFullScreen:
    case QPlatformIntegration::PasswordMaskDelay:
    case QPlatformIntegration::StartDragVelocity:
        break; // Not implemented
    case QPlatformIntegration::FontSmoothingGamma:
        return QVariant(QWindowsFontDatabase::fontSmoothingGamma());
    case QPlatformIntegration::MouseDoubleClickInterval:
        if (const int ms = GetDoubleClickTime())
            return QVariant(ms);
        break;
    case QPlatformIntegration::UseRtlExtensions:
        return QVariant(d->m_context.useRTLExtensions());
    case QPlatformIntegration::SynthesizeMouseFromTouchEvents:
#ifdef Q_OS_WINCE
        // We do not want Qt to synthesize mouse events as Windows also does that.
       return false;
#else // Q_OS_WINCE
       return QVariant(bool(d->m_options & DontPassOsMouseEventsSynthesizedFromTouch));
#endif // !Q_OS_WINCE
    default:
        break;
    }
    return QPlatformIntegration::styleHint(hint);
}
Пример #28
0
void
HippoCanvas::startTrackingHover()
{
    if (tooltip_->isShowing())
        return;

    // request a WM_MOUSEHOVER message; also resets the 
    // hover timer if we've already asked for this message.
    TRACKMOUSEEVENT tme;
    tme.cbSize = sizeof(tme);
    tme.dwFlags = TME_HOVER;
    tme.hwndTrack = window_;
    // The default Windows tooltip delay is defined to be the 
    // double click time. We don't currently support 
    // it, but if we had a shorter delay when moving 
    // along a toolbar, that is defined as 1/5 double click 
    // time, and tooltips pop down by default after 10x double
    // click time. See docs for TTM_SETDELAYTIME for this.
    tme.dwHoverTime = GetDoubleClickTime();
    if (TrackMouseEvent(&tme) == 0) {
        g_warning("Failed to request mouse hover events");
    }
}
//----------------------------------------------------------------------------------------------
//	wmNotify
//----------------------------------------------------------------------------------------------
VOID CStatusAreaIcon::wmNotify(
	 WPARAM	wParam
	,LPARAM	lParam )
{
	switch( wParam )
	{
		case STATUS_AREA_ICON_ID:
			switch( lParam )
			{
				case WM_LBUTTONDOWN:
					//	タイマーでポップアップ メニュー(左)を表示する
					SetTimer( Wnd, LEFT_CLICK_TIMER, GetDoubleClickTime(), NULL );
					break;

				case WM_LBUTTONDBLCLK:
					//	左クリック用タイマーを停止する
					KillTimer( Wnd, LEFT_CLICK_TIMER );
					//	プロパティ シートを開く
					if( PropertySheet->IsOpened() == FALSE )
					{
						PropertySheet->Open();
					}
					break;

				case WM_RBUTTONUP:
					//	ポップアップ メニュー(右)を表示する
					ShowRightPopupMenu();
					break;
			}
			break;

		case UPDATE_SETTING:
			//	レジストリから設定を読み込む
			Setting->LoadRegistry();
			break;
	}
}
Пример #30
0
BOOL CResizablePage::PreTranslateMessage(MSG* pMsg) 
{
    if  ( ::IsWindow ( m_pTitleTip->GetSafeHwnd () ) )
    {
        m_pTitleTip->PreTranslateMessage ( pMsg );
    }
	
	if (pMsg->message == WM_MOUSEMOVE && m_pTooltipMap!=NULL)
	{
		CPoint point ( GET_X_LPARAM(pMsg->lParam), GET_Y_LPARAM(pMsg->lParam) );
		::ClientToScreen (pMsg->hwnd, &point);
		ScreenToClient(&point);

	    HWND hWndChild = ::ChildWindowFromPoint ( GetSafeHwnd (), point );
    
		if  ( ::IsWindow(hWndChild) && m_ptMouseClientPos != point)
		{
			HWND2STRING_MAP::iterator i = m_pTooltipMap->m_TooltipMap.find(hWndChild);
			if ( i != m_pTooltipMap->m_TooltipMap.end() )
			{
				if (TOOLTIP_TIMER_ID)
					KillTimer(TOOLTIP_TIMER_ID);

				TOOLTIP_TIMER_ID = SetTimer (17, GetDoubleClickTime (), NULL);
				TRACE("SetTimer(TOOLTIP_TIMER_ID)\n");
				
				m_ptMouseClientPos = point;
				m_hwndChild = hWndChild;
				m_szTooltipNext = i->second;

			}
		}
	}
	
	return CPropertyPage::PreTranslateMessage(pMsg);
}