Example #1
0
void CMenuButton::OnShowMenu()
{
	m_bRealMenuIsActive = true;

	// Begin CMFCMenuButton::OnShowMenu()
	if (m_hMenu == NULL || m_bMenuIsActive)
	{
		return;
	}

	CRect rectWindow;
	GetWindowRect(rectWindow);

	int x, y;

	if (m_bRightArrow)
	{
		x = rectWindow.right;
		y = rectWindow.top;
	}
	else
	{
		x = rectWindow.left;
		y = rectWindow.bottom;
	}

	if (m_bStayPressed)
	{
		m_bPushed = TRUE;
		m_bHighlighted = TRUE;
	}

	m_bMenuIsActive = TRUE;
	Invalidate();

	TPMPARAMS params;
	params.cbSize = sizeof(TPMPARAMS);
	params.rcExclude = rectWindow;
	m_nMenuResult = ::TrackPopupMenuEx(m_hMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_NONOTIFY | TPM_RETURNCMD | TPM_VERTICAL, x, y, GetSafeHwnd(), &params);

	CWnd* pParent = GetParent();

#ifdef _DEBUG
	if ((pParent->IsKindOf(RUNTIME_CLASS(CDialog))) && (!pParent->IsKindOf(RUNTIME_CLASS(CDialogEx))))
	{
		TRACE(_T("CMFCMenuButton parent is CDialog, should be CDialogEx for popup menu handling to work correctly.\n"));
	}
#endif

	if (m_nMenuResult != 0)
	{
		//-------------------------------------------------------
		// Trigger mouse up event(to button click notification):
		//-------------------------------------------------------
		if (pParent != NULL)
		{
			pParent->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), BN_CLICKED), (LPARAM)m_hWnd);
		}
	}

	m_bPushed = FALSE;
	m_bHighlighted = FALSE;
	m_bMenuIsActive = FALSE;

	Invalidate();
	UpdateWindow();

	if (m_bCaptured)
	{
		ReleaseCapture();
		m_bCaptured = FALSE;
	}
	// End CMFCMenuButton::OnShowMenu()

	m_bRealMenuIsActive = false;
}
Example #2
0
LRESULT CGameWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
	if (m_pGame)
		m_pGame->WndProc(GetSafeHwnd(), message, wParam, lParam);
	return __super::WindowProc(message, wParam, lParam);
}
//*****************************************************************************************
void CBCGPColorButton::OnDraw (CDC* pDC, const CRect& rect, UINT uiState)
{
	ASSERT_VALID (pDC);

	if (m_pPalette == NULL)
	{
		RebuildPalette (NULL);
	}

	CPalette* pCurPalette = pDC->SelectPalette (m_pPalette, FALSE);
	pDC->RealizePalette();

	CSize sizeArrow = CBCGPMenuImages::Size ();

	CRect rectColor = rect;
	rectColor.right -= sizeArrow.cx + nImageHorzMargin;

	CRect rectArrow = rect;
	rectArrow.left = rectColor.right;

	COLORREF color = m_Color;
	if (color == (COLORREF) -1)	// Automatic
	{
		//---------------------------
		// Draw automatic text label:
		//---------------------------
		color = m_ColorAutomatic;
		
		if (!m_strAutoColorText.IsEmpty ())
		{
			rectColor.right = rectColor.left + rectColor.Height ();

			CRect rectText = rect;
			rectText.left = rectColor.right;
			rectText.right = rectArrow.left;

			CFont* pOldFont = SelectFont (pDC);
			ASSERT(pOldFont != NULL);

			pDC->SetBkMode (TRANSPARENT);

			if (m_clrText == (COLORREF)-1)
			{
				if (m_bVisualManagerStyle && !m_bDontSkin)
				{
					pDC->SetTextColor (IsWindowEnabled() ? globalData.clrBarText : globalData.clrGrayedText);
				}
				else
				{
					pDC->SetTextColor (IsWindowEnabled() ? globalData.clrBtnText : globalData.clrGrayedText);
				}
			}
			else
			{
				pDC->SetTextColor (m_clrText);
			}

			UINT nFormat = DT_CENTER | DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS;

			if (m_bOnGlass)
			{
				CBCGPVisualManager::GetInstance ()->DrawTextOnGlass (pDC, 
					m_strAutoColorText, rectText, nFormat, 0);
			}
			else
			{
				pDC->DrawText (m_strAutoColorText, rectText, nFormat);
			}

			pDC->SelectObject (pOldFont);
		}
	}

	//----------------
	// Draw color box:
	//----------------
	rectColor.DeflateRect (2, 2);

	if (m_bOnGlass)
	{
		CBCGPDrawManager dm (*pDC);
		dm.DrawRect (rectColor, (COLORREF)-1, globalData.clrBtnDkShadow);
	}
	else
	{
		pDC->Draw3dRect (rectColor, globalData.clrBtnHilite, globalData.clrBtnHilite);
		rectColor.DeflateRect (1, 1);
		pDC->Draw3dRect (rectColor, globalData.clrBtnDkShadow, globalData.clrBtnDkShadow);
	}

	rectColor.DeflateRect (1, 1);

	if (color != (COLORREF)-1 && (uiState & ODS_DISABLED) == 0)
	{
		if (globalData.m_nBitsPerPixel == 8) // 256 colors
		{
			ASSERT_VALID (m_pPalette);
			color =  PALETTEINDEX (m_pPalette->GetNearestPaletteIndex (color));
		}

		if (m_bOnGlass)
		{
			CBCGPDrawManager dm (*pDC);
			dm.DrawRect (rectColor, color, (COLORREF)-1);
		}
		else
		{
			CBrush br (color);
			pDC->FillRect (rectColor, &br);
		}
	}

	//----------------------
	// Draw drop-down arrow:
	//----------------------
	CRect rectArrowWinXP = rectArrow;
	rectArrowWinXP.DeflateRect (2, 2);

	if (m_bVisualManagerStyle && !m_bDontSkin)
	{
		CBCGPDrawOnGlass dog (m_bOnGlass);

		BOOL bDisabled    = !IsWindowEnabled ();
		BOOL bFocused     = GetSafeHwnd () == ::GetFocus ();
		BOOL bHighlighted = IsHighlighted ();

		CBCGPToolbarComboBoxButton buttonDummy;
#ifndef _BCGSUITE_
		buttonDummy.m_bIsCtrl = TRUE;

		CBCGPVisualManager::GetInstance ()->OnDrawComboDropButton (
			pDC, rectArrowWinXP, bDisabled, FALSE,
			bHighlighted || bFocused,
			&buttonDummy);
#else
		CMFCVisualManager::GetInstance ()->OnDrawComboDropButton (
			pDC, rectArrowWinXP, bDisabled, FALSE,
			bHighlighted || bFocused,
			&buttonDummy);
#endif
	}
	else
	{
		if (!m_bWinXPTheme || !CBCGPVisualManager::GetInstance ()->DrawComboDropButtonWinXP (
										pDC, rectArrowWinXP,
										(uiState & ODS_DISABLED), m_bPushed,
										m_bHighlighted))
		{
			pDC->FillRect (rectArrow, &globalData.brBtnFace);

			CBCGPMenuImages::Draw (pDC, CBCGPMenuImages::IdArowDownLarge, rectArrow,
				(uiState & ODS_DISABLED) ? CBCGPMenuImages::ImageGray : CBCGPMenuImages::ImageBlack);

			pDC->Draw3dRect (rectArrow, globalData.clrBtnLight, globalData.clrBtnDkShadow);
			rectArrow.DeflateRect (1, 1);
			pDC->Draw3dRect (rectArrow, globalData.clrBtnHilite, globalData.clrBtnShadow);
		}
	}

	if (pCurPalette != NULL)
	{
		pDC->SelectPalette (pCurPalette, FALSE);
	}
}
Example #4
0
void CEpgTimerTaskDlg::OnTimer(UINT_PTR nIDEvent)
{
	// TODO: ここにメッセージ ハンドラー コードを追加するか、既定の処理を呼び出します。
	if( nIDEvent == RETRY_ADD_TRAY ){
		KillTimer(RETRY_ADD_TRAY);
		CString strBuff=L"";
/*		RESERVE_DATA Item;
		if( GetNextReserve(&Item) == TRUE ){
			wstring strTime;
			GetTimeString3(Item.StartTime, Item.dwDurationSec, strTime);

			strBuff += L"次の予約 ";
			strBuff += strTime.c_str();
			strBuff += L" ";
			strBuff += Item.strTitle.c_str();
		}else{
			strBuff += L"次の予約 なし";
		}*/
		HICON hSetIcon = m_hIconBlue;
		switch(m_dwSrvStatus){
			case 1:
				hSetIcon = m_hIconRed;
				break;
			case 2:
				hSetIcon = m_hIconGreen;
				break;
			default:
				break;
		}
		if( AddTaskBar( GetSafeHwnd(),
				WM_TRAY_PUSHICON,
				TRAYICON_ID,
				hSetIcon,
				strBuff ) == FALSE ){
					SetTimer(RETRY_ADD_TRAY, 5000, NULL);
		}
	}else if( nIDEvent == RETRY_CHG_TRAY ){
		KillTimer(RETRY_CHG_TRAY);
		CString strBuff=L"";
/*		RESERVE_DATA Item;
		if( GetNextReserve(&Item) == TRUE ){
			wstring strTime;
			GetTimeString3(Item.StartTime, Item.dwDurationSec, strTime);

			strBuff += L"次の予約 ";
			strBuff += strTime.c_str();
			strBuff += L" ";
			strBuff += Item.strTitle.c_str();
		}else{
			strBuff += L"次の予約 なし";
		}
*/
		HICON hSetIcon = m_hIconBlue;
		switch(m_dwSrvStatus){
			case 1:
				hSetIcon = m_hIconRed;
				break;
			case 2:
				hSetIcon = m_hIconGreen;
				break;
			default:
				break;
		}
		if( ChgTipsTaskBar( GetSafeHwnd(),
				TRAYICON_ID,
				hSetIcon,
				strBuff ) == FALSE ){
					SetTimer(RETRY_CHG_TRAY, 5000, NULL);
		}
	}
	CDialogEx::OnTimer(nIDEvent);
}
Example #5
0
void CCopyDlg::OnOK()
{
    if (::IsWindow(m_pLogDlg->GetSafeHwnd())&&(m_pLogDlg->IsWindowVisible()))
    {
        m_pLogDlg->SendMessage(WM_CLOSE);
        return;
    }
    m_bCancelled = true;
    // check if the status thread has already finished
    if ((m_pThread)&&(m_bThreadRunning))
    {
        WaitForSingleObject(m_pThread->m_hThread, 1000);
        if (m_bThreadRunning)
        {
            // we gave the thread a chance to quit. Since the thread didn't
            // listen to us we have to kill it.
            TerminateThread(m_pThread->m_hThread, (DWORD)-1);
            InterlockedExchange(&m_bThreadRunning, FALSE);
        }
    }

    CString id;
    GetDlgItemText(IDC_BUGID, id);
    CString sRevText;
    GetDlgItemText(IDC_COPYREVTEXT, sRevText);
    if (!m_ProjectProperties.CheckBugID(id))
    {
        ShowEditBalloon(IDC_BUGID, IDS_COMMITDLG_ONLYNUMBERS, IDS_ERR_ERROR, TTI_ERROR);
        return;
    }
    m_sLogMessage = m_cLogMessage.GetText();
    if ((m_ProjectProperties.bWarnIfNoIssue) && (id.IsEmpty() && !m_ProjectProperties.HasBugID(m_sLogMessage)))
    {
        CTaskDialog taskdlg(CString(MAKEINTRESOURCE(IDS_COMMITDLG_WARNNOISSUE_TASK1)),
                            CString(MAKEINTRESOURCE(IDS_COMMITDLG_WARNNOISSUE_TASK2)),
                            L"TortoiseSVN",
                            0,
                            TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
        taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_COMMITDLG_WARNNOISSUE_TASK3)));
        taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_COMMITDLG_WARNNOISSUE_TASK4)));
        taskdlg.SetCommonButtons(TDCBF_CANCEL_BUTTON);
        taskdlg.SetDefaultCommandControl(2);
        taskdlg.SetMainIcon(TD_WARNING_ICON);
        if (taskdlg.DoModal(m_hWnd) != 1)
            return;
    }
    UpdateData(TRUE);

    if (GetCheckedRadioButton(IDC_COPYHEAD, IDC_COPYREV) == IDC_COPYHEAD)
        m_CopyRev = SVNRev(SVNRev::REV_HEAD);
    else if (GetCheckedRadioButton(IDC_COPYHEAD, IDC_COPYREV) == IDC_COPYWC)
        m_CopyRev = SVNRev(SVNRev::REV_WC);
    else
        m_CopyRev = SVNRev(sRevText);

    if (!m_CopyRev.IsValid())
    {
        ShowEditBalloon(IDC_COPYREVTEXT, IDS_ERR_INVALIDREV, IDS_ERR_ERROR, TTI_ERROR);
        return;
    }

    CString combourl = m_URLCombo.GetWindowString();
    if (combourl.IsEmpty())
        combourl = m_URLCombo.GetString();

    if ((m_wcURL.CompareNoCase(combourl)==0)&&(m_CopyRev.IsHead()))
    {
        CString temp;
        temp.FormatMessage(IDS_ERR_COPYITSELF, (LPCTSTR)m_wcURL, (LPCTSTR)m_URLCombo.GetString());
        ::MessageBox(this->m_hWnd, temp, L"TortoiseSVN", MB_ICONERROR);
        return;
    }

    m_URLCombo.SaveHistory();
    m_URL = CPathUtils::CombineUrls(m_repoRoot, m_URLCombo.GetString());
    if (!CTSVNPath(m_URL).IsValidOnWindows())
    {
        CString sInfo;
        sInfo.Format(IDS_WARN_NOVALIDPATH_TASK1, (LPCTSTR)m_URL);
        CTaskDialog taskdlg(sInfo,
                            CString(MAKEINTRESOURCE(IDS_WARN_NOVALIDPATH_TASK2)),
                            L"TortoiseSVN",
                            0,
                            TDF_ENABLE_HYPERLINKS | TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
        taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_WARN_NOVALIDPATH_TASK3)));
        taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_WARN_NOVALIDPATH_TASK4)));
        taskdlg.SetCommonButtons(TDCBF_CANCEL_BUTTON);
        taskdlg.SetExpansionArea(CString(MAKEINTRESOURCE(IDS_WARN_NOVALIDPATH_TASK5)));
        taskdlg.SetDefaultCommandControl(2);
        taskdlg.SetMainIcon(TD_WARNING_ICON);
        if (taskdlg.DoModal(m_hWnd) != 1)
            return;
    }
    CStringUtils::WriteAsciiStringToClipboard(m_URL);

    // now let the bugtraq plugin check the commit message
    CComPtr<IBugTraqProvider2> pProvider2 = NULL;
    if (m_BugTraqProvider)
    {
        HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider2);
        if (SUCCEEDED(hr))
        {
            ATL::CComBSTR temp;
            ATL::CComBSTR sourceURL;
            sourceURL.Attach(m_wcURL.AllocSysString());
            ATL::CComBSTR parameters;
            parameters.Attach(m_bugtraq_association.GetParameters().AllocSysString());
            ATL::CComBSTR targetURL;
            targetURL.Attach(m_URL.AllocSysString());
            ATL::CComBSTR commitMessage;
            commitMessage.Attach(m_sLogMessage.AllocSysString());
            CBstrSafeVector pathList(1);
            pathList.PutElement(0, m_path.GetSVNPathString());

            hr = pProvider2->CheckCommit(GetSafeHwnd(), parameters, sourceURL, targetURL, pathList, commitMessage, &temp);
            if (FAILED(hr))
            {
                OnComError(hr);
            }
            else
            {
                CString sError = temp == 0 ? L"" : temp;
                if (!sError.IsEmpty())
                {
                    CAppUtils::ReportFailedHook(m_hWnd, sError);
                    return;
                }
            }
        }
    }

    CTSVNPathList checkedItems;
    checkedItems.AddPath(m_path);
    DWORD exitcode = 0;
    CString error;
    CHooks::Instance().SetProjectProperties(m_path, m_ProjectProperties);
    if (CHooks::Instance().CheckCommit(m_hWnd, checkedItems, m_sLogMessage, exitcode, error))
    {
        if (exitcode)
        {
            CString sErrorMsg;
            sErrorMsg.Format(IDS_HOOK_ERRORMSG, (LPCWSTR)error);

            CTaskDialog taskdlg(sErrorMsg,
                                CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK2)),
                                L"TortoiseSVN",
                                0,
                                TDF_ENABLE_HYPERLINKS | TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
            taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK3)));
            taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK4)));
            taskdlg.SetDefaultCommandControl(1);
            taskdlg.SetMainIcon(TD_ERROR_ICON);
            bool retry = (taskdlg.DoModal(GetSafeHwnd()) == 1);

            if (retry)
                return;
        }
    }

    if (!m_sLogMessage.IsEmpty())
    {
        m_History.AddEntry(m_sLogMessage);
        m_History.Save();
    }

    m_sBugID.Trim();
    if (!m_sBugID.IsEmpty())
    {
        m_sBugID.Replace(L", ", L",");
        m_sBugID.Replace(L" ,", L",");
        CString sBugID = m_ProjectProperties.sMessage;
        sBugID.Replace(L"%BUGID%", m_sBugID);
        if (m_ProjectProperties.bAppend)
            m_sLogMessage += L"\n" + sBugID + L"\n";
        else
            m_sLogMessage = sBugID + L"\n" + m_sLogMessage;
        UpdateData(FALSE);
    }
    CResizableStandAloneDialog::OnOK();
}
Example #6
0
void CCopyDlg::OnBnClickedBugtraqbutton()
{
    m_tooltips.Pop();   // hide the tooltips
    CString sMsg = m_cLogMessage.GetText();

    if (m_BugTraqProvider == NULL)
        return;

    ATL::CComBSTR parameters;
    parameters.Attach(m_bugtraq_association.GetParameters().AllocSysString());
    ATL::CComBSTR commonRoot;
    commonRoot.Attach(m_path.GetWinPathString().AllocSysString());
    CBstrSafeVector pathList(1);
    pathList.PutElement(0, m_path.GetSVNPathString());

    ATL::CComBSTR originalMessage;
    originalMessage.Attach(sMsg.AllocSysString());
    ATL::CComBSTR temp;
    m_revProps.clear();

    // first try the IBugTraqProvider2 interface
    CComPtr<IBugTraqProvider2> pProvider2 = NULL;
    HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider2);
    if (SUCCEEDED(hr))
    {
        ATL::CComBSTR repositoryRoot;
        repositoryRoot.Attach(m_wcURL.AllocSysString());
        ATL::CComBSTR bugIDOut;
        GetDlgItemText(IDC_BUGID, m_sBugID);
        ATL::CComBSTR bugID;
        bugID.Attach(m_sBugID.AllocSysString());
        CBstrSafeVector revPropNames;
        CBstrSafeVector revPropValues;
        if (FAILED(hr = pProvider2->GetCommitMessage2(GetSafeHwnd(), parameters, repositoryRoot, commonRoot, pathList, originalMessage, bugID, &bugIDOut, &revPropNames, &revPropValues, &temp)))
        {
            OnComError(hr);
        }
        else
        {
            if (bugIDOut)
            {
                m_sBugID = bugIDOut;
                SetDlgItemText(IDC_BUGID, m_sBugID);
            }
            m_cLogMessage.SetText((LPCTSTR)temp);
            BSTR HUGEP *pbRevNames;
            BSTR HUGEP *pbRevValues;

            HRESULT hr1 = SafeArrayAccessData(revPropNames, (void HUGEP**)&pbRevNames);
            if (SUCCEEDED(hr1))
            {
                HRESULT hr2 = SafeArrayAccessData(revPropValues, (void HUGEP**)&pbRevValues);
                if (SUCCEEDED(hr2))
                {
                    if (revPropNames->rgsabound->cElements == revPropValues->rgsabound->cElements)
                    {
                        for (ULONG i = 0; i < revPropNames->rgsabound->cElements; i++)
                        {
                            m_revProps[pbRevNames[i]] = pbRevValues[i];
                        }
                    }
                    SafeArrayUnaccessData(revPropValues);
                }
                SafeArrayUnaccessData(revPropNames);
            }
        }
    }
    else
    {
        // if IBugTraqProvider2 failed, try IBugTraqProvider
        CComPtr<IBugTraqProvider> pProvider = NULL;
        hr = m_BugTraqProvider.QueryInterface(&pProvider);
        if (FAILED(hr))
        {
            OnComError(hr);
            return;
        }

        if (FAILED(hr = pProvider->GetCommitMessage(GetSafeHwnd(), parameters, commonRoot, pathList, originalMessage, &temp)))
        {
            OnComError(hr);
        }
        else
            m_cLogMessage.SetText((LPCTSTR)temp);
    }
    m_sLogMessage = m_cLogMessage.GetText();
    if (!m_ProjectProperties.sMessage.IsEmpty())
    {
        CString sBugID = m_ProjectProperties.FindBugID(m_sLogMessage);
        if (!sBugID.IsEmpty())
        {
            SetDlgItemText(IDC_BUGID, sBugID);
        }
    }

    m_cLogMessage.SetFocus();
}
//*************************************************************************************
void CBCGPCaptionBar::OnMouseMove(UINT nFlags, CPoint point) 
{
	CBCGPControlBar::OnMouseMove(nFlags, point);

	BOOL bTrack = FALSE;

	if (m_uiBtnID != 0 && m_bBtnEnabled)
	{
		BOOL bIsBtnHighlighted = m_rectButton.PtInRect (point);

		if (m_bIsBtnHighlighted != bIsBtnHighlighted)
		{
			m_bIsBtnHighlighted = bIsBtnHighlighted;
			m_bIsBtnPressed = (nFlags & MK_LBUTTON) && m_bIsBtnHighlighted;

			InvalidateRect (m_rectButton);
			UpdateWindow ();

			bTrack = bIsBtnHighlighted;
		}
	}

	if (!m_rectClose.IsRectEmpty ())
	{
		BOOL bIsBtnHighlighted = m_rectClose.PtInRect (point);

		if (m_bIsCloseBtnHighlighted != bIsBtnHighlighted)
		{
			m_bIsCloseBtnHighlighted = bIsBtnHighlighted;
			m_bIsCloseBtnPressed = (nFlags & MK_LBUTTON) && m_bIsCloseBtnHighlighted;

			InvalidateRect (m_rectClose);
			UpdateWindow ();

			bTrack = bIsBtnHighlighted;
		}
	}

	int nHyperlinkHighlighted = HitTestHyperlink(point);
	if (m_nHyperlinkHighlighted != nHyperlinkHighlighted)
	{
		if (m_nHyperlinkHighlighted != -1)
		{
			InvalidateRect(&m_arHyperlinksRects[m_nHyperlinkHighlighted]);
		}

		m_nHyperlinkHighlighted = nHyperlinkHighlighted;

		if (m_nHyperlinkHighlighted != -1)
		{
			InvalidateRect(&m_arHyperlinksRects[m_nHyperlinkHighlighted]);
		}

		UpdateWindow();
		bTrack = TRUE;
	}

	if (!m_bTracked && bTrack)
	{
		m_bTracked = TRUE;
		
		TRACKMOUSEEVENT trackmouseevent;
		trackmouseevent.cbSize = sizeof(trackmouseevent);
		trackmouseevent.dwFlags = TME_LEAVE;
		trackmouseevent.hwndTrack = GetSafeHwnd();
		trackmouseevent.dwHoverTime = HOVER_DEFAULT;
		::BCGPTrackMouse (&trackmouseevent);	
	}
}
Example #8
0
BOOL CCopyDlg::OnInitDialog()
{
    CResizableStandAloneDialog::OnInitDialog();
    CAppUtils::MarkWindowAsUnpinnable(m_hWnd);

    ExtendFrameIntoClientArea(IDC_EXTGROUP);
    m_aeroControls.SubclassControl(this, IDC_DOSWITCH);
    m_aeroControls.SubclassControl(this, IDC_MAKEPARENTS);
    m_aeroControls.SubclassOkCancelHelp(this);
    m_bCancelled = false;

    DWORD exStyle = LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER | LVS_EX_CHECKBOXES;
    m_ExtList.SetExtendedStyle(exStyle);
    SetWindowTheme(m_ExtList.GetSafeHwnd(), L"Explorer", NULL);
    m_ExtList.ShowText(CString(MAKEINTRESOURCE(IDS_COPY_WAITFOREXTERNALS)));

    AdjustControlSize(IDC_COPYHEAD);
    AdjustControlSize(IDC_COPYREV);
    AdjustControlSize(IDC_COPYWC);
    AdjustControlSize(IDC_DOSWITCH);
    AdjustControlSize(IDC_MAKEPARENTS);

    CTSVNPath path(m_path);
    CString sWindowTitle;
    GetWindowText(sWindowTitle);
    CAppUtils::SetWindowTitle(m_hWnd, path.GetUIPathString(), sWindowTitle);

    m_History.SetMaxHistoryItems((LONG)CRegDWORD(L"Software\\TortoiseSVN\\MaxHistoryItems", 25));

    SetRevision(m_CopyRev);

    m_tooltips.AddTool(IDC_HISTORY, IDS_COMMITDLG_HISTORY_TT);

    if (SVN::PathIsURL(path))
    {
        DialogEnableWindow(IDC_COPYWC, FALSE);
        DialogEnableWindow(IDC_DOSWITCH, FALSE);
        SetDlgItemText(IDC_COPYSTARTLABEL, CString(MAKEINTRESOURCE(IDS_COPYDLG_FROMURL)));
    }

    SVN svn;
    CString sUUID;
    m_repoRoot = svn.GetRepositoryRootAndUUID(path, true, sUUID);
    m_repoRoot.TrimRight('/');
    m_wcURL = svn.GetURLFromPath(path);
    if (m_wcURL.IsEmpty() || (!path.IsUrl() && !path.Exists()))
    {
        CString Wrong_URL=path.GetSVNPathString();
        CString temp;
        temp.Format(IDS_ERR_NOURLOFFILE, (LPCTSTR)Wrong_URL);
        ::MessageBox(this->m_hWnd, temp, L"TortoiseSVN", MB_ICONERROR);
        this->EndDialog(IDCANCEL);      //exit
    }
    m_URLCombo.LoadHistory(L"Software\\TortoiseSVN\\History\\repoPaths\\"+sUUID, L"url");
    m_URLCombo.SetCurSel(0);
    CString relPath = m_wcURL.Mid(m_repoRoot.GetLength());
    if (!m_URL.IsEmpty())
    {
        // allow the use of urls relative to the repo root
        if (m_URL[0] != '^')
            relPath = m_URL.Mid(m_repoRoot.GetLength());
        else
            relPath = m_URL.Mid(1);
    }
    CTSVNPath r = CTSVNPath(relPath);
    relPath = r.GetUIPathString();
    relPath.Replace('\\', '/');
    m_URLCombo.AddString(relPath, 0);
    m_URLCombo.SelectString(-1, relPath);
    m_URL = m_wcURL;
    SetDlgItemText(IDC_DESTURL, CPathUtils::CombineUrls(m_repoRoot, relPath));
    SetDlgItemText(IDC_FROMURL, m_wcURL);

    CString reg;
    reg.Format(L"Software\\TortoiseSVN\\History\\commit%s", (LPCTSTR)sUUID);
    m_History.Load(reg, L"logmsgs");

    m_ProjectProperties.ReadProps(m_path);
    if (CRegDWORD(L"Software\\TortoiseSVN\\AlwaysWarnIfNoIssue", FALSE))
        m_ProjectProperties.bWarnIfNoIssue = TRUE;

    m_cLogMessage.Init(m_ProjectProperties);
    m_cLogMessage.SetFont((CString)CRegString(L"Software\\TortoiseSVN\\LogFontName", L"Courier New"), (DWORD)CRegDWORD(L"Software\\TortoiseSVN\\LogFontSize", 8));

    GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_HIDE);
    GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(FALSE);
    CBugTraqAssociations bugtraq_associations;
    bugtraq_associations.Load(m_ProjectProperties.GetProviderUUID(), m_ProjectProperties.sProviderParams);

    if (bugtraq_associations.FindProvider(CTSVNPathList(m_path), &m_bugtraq_association))
    {
        CComPtr<IBugTraqProvider> pProvider;
        HRESULT hr = pProvider.CoCreateInstance(m_bugtraq_association.GetProviderClass());
        if (SUCCEEDED(hr))
        {
            m_BugTraqProvider = pProvider;
            ATL::CComBSTR temp;
            ATL::CComBSTR parameters;
            parameters.Attach(m_bugtraq_association.GetParameters().AllocSysString());
            hr = pProvider->GetLinkText(GetSafeHwnd(), parameters, &temp);
            if (SUCCEEDED(hr))
            {
                SetDlgItemText(IDC_BUGTRAQBUTTON, temp == 0 ? L"" : temp);
                GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(TRUE);
                GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_SHOW);
            }
        }

        GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
    }
    if (m_ProjectProperties.sMessage.IsEmpty())
    {
        GetDlgItem(IDC_BUGID)->ShowWindow(SW_HIDE);
        GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_HIDE);
        GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
    }
    else
    {
        GetDlgItem(IDC_BUGID)->ShowWindow(SW_SHOW);
        GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_SHOW);
        if (!m_ProjectProperties.sLabel.IsEmpty())
            SetDlgItemText(IDC_BUGIDLABEL, m_ProjectProperties.sLabel);
        GetDlgItem(IDC_BUGID)->SetFocus();
    }

    if (!m_sLogMessage.IsEmpty())
        m_cLogMessage.SetText(m_sLogMessage);
    else
        m_cLogMessage.SetText(m_ProjectProperties.GetLogMsgTemplate(PROJECTPROPNAME_LOGTEMPLATEBRANCH));

    OnEnChangeLogmessage();

    m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKALL);
    m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKNONE);

    // line up all controls and adjust their sizes.
#define LINKSPACING 9
    RECT rc = AdjustControlSize(IDC_SELECTLABEL);
    rc.right -= 15; // AdjustControlSize() adds 20 pixels for the checkbox/radio button bitmap, but this is a label...
    rc = AdjustStaticSize(IDC_CHECKALL, rc, LINKSPACING);
    rc = AdjustStaticSize(IDC_CHECKNONE, rc, LINKSPACING);

    CAppUtils::SetAccProperty(m_cLogMessage.GetSafeHwnd(), PROPID_ACC_ROLE, ROLE_SYSTEM_TEXT);
    CAppUtils::SetAccProperty(m_cLogMessage.GetSafeHwnd(), PROPID_ACC_HELP, CString(MAKEINTRESOURCE(IDS_INPUT_ENTERLOG)));
    CAppUtils::SetAccProperty(m_cLogMessage.GetSafeHwnd(), PROPID_ACC_KEYBOARDSHORTCUT, L"Alt+"+CString(CAppUtils::FindAcceleratorKey(this, IDC_INVISIBLE)));

    CAppUtils::SetAccProperty(GetDlgItem(IDC_CHECKALL)->GetSafeHwnd(), PROPID_ACC_ROLE, ROLE_SYSTEM_LINK);
    CAppUtils::SetAccProperty(GetDlgItem(IDC_CHECKNONE)->GetSafeHwnd(), PROPID_ACC_ROLE, ROLE_SYSTEM_LINK);

    CAppUtils::SetAccProperty(m_URLCombo.GetSafeHwnd(), PROPID_ACC_KEYBOARDSHORTCUT, L"Alt+"+CString(CAppUtils::FindAcceleratorKey(this, IDC_TOURLLABEL)));
    CAppUtils::SetAccProperty(GetDlgItem(IDC_FROMURL)->GetSafeHwnd(), PROPID_ACC_KEYBOARDSHORTCUT, L"Alt+"+CString(CAppUtils::FindAcceleratorKey(this, IDC_COPYSTARTLABEL)));
    CAppUtils::SetAccProperty(GetDlgItem(IDC_DESTURL)->GetSafeHwnd(), PROPID_ACC_KEYBOARDSHORTCUT, L"Alt+"+CString(CAppUtils::FindAcceleratorKey(this, IDC_DESTLABEL)));

    AddAnchor(IDC_REPOGROUP, TOP_LEFT, TOP_RIGHT);
    AddAnchor(IDC_COPYSTARTLABEL, TOP_LEFT, TOP_RIGHT);
    AddAnchor(IDC_FROMURL, TOP_LEFT, TOP_RIGHT);
    AddAnchor(IDC_TOURLLABEL, TOP_LEFT);
    AddAnchor(IDC_URLCOMBO, TOP_LEFT, TOP_RIGHT);
    AddAnchor(IDC_BROWSE, TOP_RIGHT);
    AddAnchor(IDC_DESTLABEL, TOP_LEFT, TOP_RIGHT);
    AddAnchor(IDC_DESTURL, TOP_LEFT, TOP_RIGHT);
    AddAnchor(IDC_MSGGROUP, TOP_LEFT, MIDDLE_RIGHT);
    AddAnchor(IDC_HISTORY, TOP_LEFT);
    AddAnchor(IDC_BUGTRAQBUTTON, TOP_LEFT);
    AddAnchor(IDC_BUGIDLABEL, TOP_RIGHT);
    AddAnchor(IDC_BUGID, TOP_RIGHT);
    AddAnchor(IDC_INVISIBLE, TOP_RIGHT);
    AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, MIDDLE_RIGHT);
    AddAnchor(IDC_FROMGROUP, MIDDLE_LEFT, MIDDLE_RIGHT);
    AddAnchor(IDC_COPYHEAD, MIDDLE_LEFT);
    AddAnchor(IDC_COPYREV, MIDDLE_LEFT);
    AddAnchor(IDC_COPYREVTEXT, MIDDLE_RIGHT);
    AddAnchor(IDC_BROWSEFROM, MIDDLE_RIGHT);
    AddAnchor(IDC_COPYWC, MIDDLE_LEFT);
    AddAnchor(IDC_EXTGROUP, MIDDLE_LEFT, BOTTOM_RIGHT);
    AddAnchor(IDC_SELECTLABEL, MIDDLE_LEFT);
    AddAnchor(IDC_CHECKALL, MIDDLE_LEFT);
    AddAnchor(IDC_CHECKNONE, MIDDLE_LEFT);
    AddAnchor(IDC_EXTERNALSLIST, MIDDLE_LEFT, BOTTOM_RIGHT);
    AddAnchor(IDC_DOSWITCH, BOTTOM_LEFT);
    AddAnchor(IDC_MAKEPARENTS, BOTTOM_LEFT);
    AddAnchor(IDOK, BOTTOM_RIGHT);
    AddAnchor(IDCANCEL, BOTTOM_RIGHT);
    AddAnchor(IDHELP, BOTTOM_RIGHT);

    if ((m_pParentWnd==NULL)&&(GetExplorerHWND()))
        CenterWindow(CWnd::FromHandle(GetExplorerHWND()));
    EnableSaveRestore(L"CopyDlg");

    m_bSettingChanged = false;
    if (!m_path.IsUrl())
    {
        // start a thread to obtain the highest revision number of the working copy
        // without blocking the dialog
        if ((m_pThread = AfxBeginThread(FindRevThreadEntry, this))==NULL)
        {
            OnCantStartThread();
        }
    }

    return TRUE;
}
Example #9
0
// Handle scroll bar call from the edit control
void SourceWindow::OnEditSetScrollInfo(NMHDR* pNotifyStruct, LRESULT* result)
{
  SCNXSetScrollInfo* ssi = (SCNXSetScrollInfo*)pNotifyStruct;
  ssi->nPos = ::SetScrollInfo(GetSafeHwnd(),ssi->nBar,(LPCSCROLLINFO)ssi->lpsi,ssi->bRedraw);
  *result = 1;
}
void COptionTreeItemEdit::DrawAttribute(CDC *pDC, const RECT &rcRect)
{
	// If we don't have focus, text is drawn.
	if (m_bFocus == TRUE)
	{
		return;
	}

	// Make sure options aren't NULL
	if (m_otOption == NULL)
	{
		return;
	}

	// Make sure there is a window
	if (!IsWindow(GetSafeHwnd()))
	{
		return;
	}

	// Set window position
	if (IsWindow(GetSafeHwnd()))
	{
		MoveWindow(m_rcAttribute.left, m_rcAttribute.top, m_rcAttribute.Width(), m_rcAttribute.Height());
	}

	// Declare variables
	HGDIOBJ hOld;
	COLORREF crOld;
	int nOldBack;
	CRect rcText;
	CString strText, strWindowText;
	COLORREF crOldBack;

	// Get window text
	GetWindowText(strWindowText);

	// Make text
	// -- Password
	if (GetOption(OT_EDIT_PASSWORD) == TRUE)
	{
		strText = "";
		for (int i = 0; i < strWindowText.GetLength(); i++)
		{
			strText += _T("*");
		}
	}
	// -- No password
	else
	{
		strText = strWindowText;
	}

	// Select font
	hOld = pDC->SelectObject(m_otOption->GetNormalFont());
	
	// Set text color
	if (IsReadOnly() == TRUE || m_otOption->IsWindowEnabled() == FALSE)
	{
		crOld = pDC->SetTextColor(GetSysColor(COLOR_GRAYTEXT));
	}
	else
	{
		crOld = pDC->SetTextColor(GetTextColor());
	}

	// Set background mode
	nOldBack = pDC->SetBkMode(TRANSPARENT);

	// Set background color
	crOldBack = pDC->SetBkColor(GetBackgroundColor());	

	// Get rectangle
	rcText = rcRect;

	// Draw text
	// -- Single line
	if (GetOption(OT_EDIT_MULTILINE) == FALSE)
	{
		pDC->DrawText(strText, rcText, DT_SINGLELINE | DT_VCENTER);
	}
	// -- Mutliline
	else
	{
		pDC->DrawText(strText, rcText, DT_TOP);
	}

	// Restore GDI ojects
	pDC->SelectObject(hOld);
	pDC->SetTextColor(crOld);
	pDC->SetBkMode(nOldBack);
	pDC->SetBkColor(crOldBack);
}
BOOL COptionTreeItemEdit::CreateEditItem(DWORD dwOptions, DWORD dwAddStyle)
{
	// Declare variables
	DWORD dwStyle = WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL;
	BOOL bRet = FALSE;


	// Make sure options is not NULL
	if (m_otOption == NULL)
	{
		return FALSE;
	}

	// Create edit control
	if (!IsWindow(GetSafeHwnd()))
	{
		// -- Create edit style
		// -- -- Multiline
		if (dwOptions & OT_EDIT_MULTILINE)
		{
			dwStyle |= ES_MULTILINE;
		}
		// -- -- Password
		if (dwOptions & OT_EDIT_PASSWORD)
		{
			dwStyle |= ES_PASSWORD;
		}
		// -- -- Numeical
		if (dwOptions & OT_EDIT_NUMERICAL)
		{
			dwStyle |= ES_NUMBER;
		}
		// -- -- Additional style
		if (dwAddStyle != 0)
		{
			dwStyle |= dwAddStyle;
		}

		// -- Create the edit view
		bRet = Create(dwStyle, m_rcAttribute, m_otOption->GetCtrlParent(), GetCtrlID());

		// -- Setup edit
		if (bRet == TRUE)
		{
			// -- -- Set font
			SetFont(m_otOption->GetNormalFont(), TRUE);

			// -- -- Modify style
			ModifyStyleEx(0, WS_EX_CLIENTEDGE, SWP_FRAMECHANGED);

			// -- -- Save options
			m_dwOptions = dwOptions;

			// -- -- Set selection
			SetSel(0, 0);

			// -- -- Set multiline
			if (GetOption(OT_EDIT_MULTILINE) == TRUE)
			{
				SetItemHeight(OT_EDIT_MLHEIGHT);
			}

			// -- -- Set window position
			MoveWindow(m_rcAttribute.left, m_rcAttribute.top, m_rcAttribute.Width(), m_rcAttribute.Height());

			// -- -- Hide window
			ShowWindow(SW_HIDE);
		}
	}

	return bRet;
}
void SmartListCtrl::setStyle( ViewStyle style )
{
	style_ = style;
	static CImageList dummyImgList;
	static const int IMGLIST_FORMAT = ILC_COLOR24|ILC_MASK;

	thumbnailManager_->resetPendingRequests( this );

	if ( !dummyImgList.GetSafeHandle() )
	{
		dummyImgList.Create( 1, 1, IMGLIST_FORMAT, 0, 0 );
		dummyImgList.SetBkColor( GetBkColor() );
	}

	// delete previous image list
	SetImageList( &dummyImgList, LVSIL_NORMAL );
	SetImageList( &dummyImgList, LVSIL_SMALL );
	SetImageList( &dummyImgList, LVSIL_STATE );

	CImageList* imgListPtr = 0;
	// set thumbnail size according to list style
	DWORD wstyle = GetWindowLong( GetSafeHwnd(), GWL_STYLE );
	// hack: have to force change the list view style so tooltip cache resets.
	SetWindowLong( GetSafeHwnd(), GWL_STYLE, (wstyle & ~LVS_TYPEMASK) | LVS_REPORT );
	wstyle = GetWindowLong( GetSafeHwnd(), GWL_STYLE );
	if ( style_ == BIGICONS )
	{
		SetWindowLong( GetSafeHwnd(), GWL_STYLE, (wstyle & ~LVS_TYPEMASK) | LVS_ICON );
		listViewIcons_ = true;
		thumbWidthCur_ = thumbWidth_;
		thumbHeightCur_ = thumbHeight_;
		listCache_ = &listCacheBig_;
		listCache_->setMaxItems( maxItems_ );
		imgListPtr = &imgListBig_;
	}
	else if ( style_ == SMALLICONS )
	{
		SetWindowLong( GetSafeHwnd(), GWL_STYLE, (wstyle & ~LVS_TYPEMASK) | LVS_LIST );
		listViewIcons_ = true;
		thumbWidthCur_ = thumbWidthSmall_;
		thumbHeightCur_ = thumbHeightSmall_;
		// Since small icons take less space, up the max cache items (by 16 if
		// big thumbs are 64x64 and small thumbs are 16x16, for example) to
		// take advantage of the same memory space.
		int memoryMultiplier =
			( thumbWidth_ * thumbHeight_ ) /
			( thumbWidthSmall_ * thumbHeightSmall_ );
		listCache_ = &listCacheSmall_;
		listCache_->setMaxItems( maxItems_ * memoryMultiplier );
		imgListPtr = &imgListSmall_;
	}
	else
	{
		SetWindowLong( GetSafeHwnd(), GWL_STYLE, (wstyle & ~LVS_TYPEMASK) | LVS_LIST );
		listViewIcons_ = false;
		thumbWidthCur_ = 0;
		thumbHeightCur_ = 0;
		imgListPtr = &dummyImgList;
	}

	// create image list if the style requires it
	if ( style_ != LIST )
	{
		if ( !imgListPtr->GetSafeHandle() )
		{
			imgListPtr->Create( thumbWidthCur_, thumbHeightCur_, IMGLIST_FORMAT, 0, 32 );
			imgListPtr->SetBkColor( GetBkColor() );
			imgListPtr->Add( AfxGetApp()->LoadIcon( IDI_UALFILE ) );
			// clear cache
			listCache_->init( imgListPtr, 1 );
		}
	}

	// set the image list
	if ( style_ == BIGICONS )
		SetImageList( imgListPtr, LVSIL_NORMAL );
	else if ( style_ == SMALLICONS )
		SetImageList( imgListPtr, LVSIL_SMALL );

	// clear and start
	SetItemCount( 0 );
	if ( provider_ )
		SetTimer( SMARTLIST_LOADTIMER_ID, SMARTLIST_LOADTIMER_MSEC, 0 );
}
Example #13
0
BOOL CWinMenu::DrawMenuItems(HDC hDC, LPRECT pRect)
{
	if ( hDC == NULL || pRect == NULL ) return FALSE;

	BOOL bFirst = m_bFirstDraw;
	m_bFirstDraw = FALSE;

	CText		text;
	long		x = pRect->left + 4;
	long		y = pRect->top + 4;
	long		w = pRect->right - pRect->left - 8;

	long		bx = x;
	long		by = y;

	// Set colors
	COLORREF rgbMenu, rgbMenuText, rgbSel, rgbSelText;

	if ( m_bSystemColors )
	{	rgbMenu = GetSysColor( COLOR_MENU );
		rgbMenuText = GetSysColor( COLOR_MENUTEXT );
		rgbSel = GetSysColor( COLOR_HIGHLIGHT );
		rgbSelText = GetSysColor( COLOR_HIGHLIGHTTEXT );
	} // end if
	else
	{	rgbMenu = m_rgbMenu;
		rgbMenuText = m_rgbMenuText;
		rgbSel = m_rgbSel;
		rgbSelText = m_rgbSelText;
	} // end else


	COLORREF	rgbLightPen = ScaleColor( rgbMenu, 100 );
	COLORREF	rgbDarkPen = ScaleColor( rgbMenu, -150 );

	COLORREF	rgbBck = rgbMenu;
	COLORREF	rgbBckLt = ScaleColor( rgbBck, 40 );
	COLORREF	rgbBckDk = ScaleColor( rgbBck, -40 );
	COLORREF	rgbSelLt = ScaleColor( rgbSel, 80 );
	COLORREF	rgbSelDk = ScaleColor( rgbSel, -120 );
	COLORREF	rgbSelTextLt = ScaleColor( rgbSelText, 80 );
	COLORREF	rgbSelTextDk = ScaleColor( rgbSelText, -150 );
	COLORREF	rgbBumpLt = ScaleColor( rgbBck, 120 );
	COLORREF	rgbBumpDk = ScaleColor( rgbBck, -120 );

	COLORREF	rgbText = rgbMenuText;
	COLORREF	rgbTextLt = ScaleColor( rgbBck, 100 );
	COLORREF	rgbTextDk = ScaleColor( rgbBck, -100 );

	if ( GetColorAvg( rgbSel ) > 128 )
	{	COLORREF swap = rgbSelTextLt;
		rgbSelTextLt = rgbSelTextDk; rgbSelTextDk = swap;
	} // end if


	// What font does the user want for menu's?
	NONCLIENTMETRICS info;
	info.cbSize = sizeof(info);			
	SystemParametersInfo( SPI_GETNONCLIENTMETRICS, sizeof( info ), &info, 0 );

	// Check for empty menu	
	if ( m_mitems.Size() == 0 )
	{
		COLORREF rgbEmptyLt = ScaleColor( rgbBck, 120 );
		COLORREF rgbEmptyDk = ScaleColor( rgbBck, -120 );

		if ( GetColorAvg( rgbBck ) < 128 ) 
		{	COLORREF swap = rgbEmptyLt;
			rgbEmptyLt = rgbEmptyDk; rgbEmptyDk = swap;
		} // end if

		RECT t;
		CopyRect( &t, pRect );

		text.SetWeight( FW_BOLD );
		text.SetFont( &info.lfMenuFont );
		text.SetFlags( DT_SINGLELINE | DT_CENTER | DT_VCENTER );

		// Make text look recessed
		OffsetRect( &t, -1, -1 );
		text.SetColor( rgbEmptyDk );
		text.DrawText( hDC, EMPTY_STR, &t );

		OffsetRect( &t, 1, 1 );
		text.SetColor( rgbEmptyLt );
		text.DrawText( hDC, EMPTY_STR, &t );

	} // end if
	
	
	// This kinda bites, but we need to know how far to offset the text
	BOOL islots = 0;
	LPMITEMINFO	pmi = NULL;
	while(	islots < 2 && ( pmi = (LPMITEMINFO)m_mitems.GetNext( pmi ) ) != NULL )
	{
		// Do we need both icon slots?
		if ( pmi->icon != NULL && pmi->b != NULL ) islots = 2;

		// Do we have one islot already?
		else if ( islots < 1 )
		{
			if ( pmi->icon != NULL ) islots = 1;
			
			else if ( pmi->b != NULL && m_hCheck == NULL && m_hUncheck == NULL )
				islots = 1;
		} // end else if

	} // end while

	
	// The icon size
	long iconsize = m_th - 4;

	// Draw each item
	pmi = NULL;
	while(	( pmi = (LPMITEMINFO)m_mitems.GetNext( pmi ) ) != NULL &&
			x < pRect->right && y < pRect->bottom )
	{
		// Set base coords
		bx = x; by = y;

		if ( *pmi->name != NULL )
		{
			POINT	pt;
			GetCursorPos( &pt );
			ScreenToClient( &pt );

			// Is this item being selected?
			BOOL bSelected = FALSE;
			RECT hl;
			hl.left = pRect->left + 3;
			hl.right = pRect->right - 4;
			hl.top = by;
			hl.bottom = by + m_th;
//			if (	pt.x > hl.left && pt.x < hl.right &&
//					pt.y > hl.top && pt.y < hl.bottom )

			// Add for toolbar
			if ( pmi->toolbar != NULL && pmi->toolbar->GetNumButtons() )
				hl.left += pmi->toolbar->GetWidth();


			if ( pmi == m_itemover )
			{
				bSelected = TRUE;
//				HPEN whitepen = CreatePen( PS_SOLID, 1, RGB( 255, 255, 255 ) );
//				HPEN dkgraypen = CreatePen( PS_SOLID, 1, RGB( 50, 50, 50 ) );
				HPEN whitepen = CreatePen( PS_SOLID, 1, rgbLightPen );
				HPEN dkgraypen = CreatePen( PS_SOLID, 1, rgbDarkPen );
				HPEN oldpen = (HPEN)SelectObject( hDC, whitepen );

				// Draw white line
				MoveToEx( hDC, hl.right, hl.top, NULL );
				LineTo( hDC, hl.right, hl.bottom  );
				LineTo( hDC, hl.left, hl.bottom  );

				// Draw dark gray line
				SelectObject( hDC, dkgraypen );
				MoveToEx( hDC, hl.right, hl.top, NULL );
				LineTo( hDC, hl.left, hl.top  );
				LineTo( hDC, hl.left, hl.bottom  );

				SelectObject( hDC, oldpen );
				DeleteObject( whitepen );
				DeleteObject( dkgraypen );

//				InflateRect( &hl, -1, -1 );
				hl.left += 1;
				hl.top += 1;

//				GradientFill( hDC, &hl, RGB( 170, 170, 190 ), RGB( 110, 110, 110 ) );
				CGrDC::VertGradientFill( hDC, &hl, rgbSelLt, rgbSelDk );
/*				HBRUSH brush = CreateSolidBrush( RGB( 120, 120, 120 ) );
				FillRect( hDC, &hl, brush );
				DeleteObject( brush );
*/

			} // end if

			// Draw toolbar
			if ( pmi->toolbar != NULL && pmi->toolbar->GetNumButtons() )
			{	pmi->toolbar->SetHeight( m_th );

				RECT tbar;
				SetRect( &tbar, bx, by, bx + pmi->toolbar->GetWidth(), 
									by + pmi->toolbar->GetHeight() );

				if ( bFirst ) pmi->toolbar->CreateToolTips( GetSafeHwnd(), &tbar );
				pmi->toolbar->SetMessageTarget( GetSafeHwnd(), WM_MENUCMD );
				pmi->toolbar->Draw( GetSafeHwnd(), hDC, &tbar );
			
				bx += pmi->toolbar->GetWidth();
			} // end if

			RECT t;

			// Calc text box
			t.left = bx + 4;
			t.left += islots * iconsize;
			t.right = pRect->right;
			t.top = by;
			t.bottom = by + m_th;

			// Draw Check
			if ( pmi->b != NULL )
			{
				RECT icon;
				SetRect( &icon, bx + 2, by + 2, bx + 2 + iconsize, by + 2 + iconsize );

				if ( *pmi->b != FALSE )
				{
					if ( bSelected && m_hHotCheck != NULL )
						CGrDC::DrawIcon( hDC, &icon, m_hHotCheck );
//						DrawIconEx( hDC, bx + 2, by + 2, m_hHotCheck, iconsize, iconsize, 0, 0, DI_NORMAL );

					else if ( m_hCheck != NULL )
						CGrDC::DrawIcon( hDC, &icon, m_hCheck );
//						DrawIconEx( hDC, bx + 2, by + 2, m_hCheck, iconsize, iconsize, 0, 0, DI_NORMAL );
				} // end if
				else 
				{
					if ( bSelected && m_hHotUncheck != NULL )
						CGrDC::DrawIcon( hDC, &icon, m_hHotUncheck );
//						DrawIconEx( hDC, bx + 2, by + 2, m_hHotUncheck, iconsize, iconsize, 0, 0, DI_NORMAL );

					else if ( m_hUncheck != NULL )
						CGrDC::DrawIcon( hDC, &icon, m_hUncheck );
//						DrawIconEx( hDC, bx + 2, by + 2, m_hUncheck, iconsize, iconsize, 0, 0, DI_NORMAL );
				} // end else
			} // end if

			// Draw icon
			if ( pmi->icon != NULL ) 
			{
				long xoff = 2;
				xoff += iconsize * ( islots - 1 ) + 1;


//				DrawIconEx( hDC, x + xoff, y + 2, pmi->icon,
//							16, 16, 0, 0, DI_NORMAL );

				DrawIconEx( hDC, bx + xoff, by + 2, pmi->icon,
							iconsize, iconsize, 0, 0, DI_NORMAL );



			} // end if

			// Setup the text object
			text.SetFlags( DT_SINGLELINE | DT_VCENTER );

			if ( bSelected )
			{
				text.SetWeight( FW_BOLD );
				text.SetFont( &info.lfMenuFont );
	
				// Make text look recessed
				OffsetRect( &t, -1, -1 );
//				text.SetColor( RGB( 0, 0, 0 ) );
				text.SetColor( rgbSelTextDk );
				text.DrawText( hDC, pmi->name, &t );

				OffsetRect( &t, 1, 1 );
				text.SetColor( rgbSelTextLt );
			} // end if
			else
			{
//				text.SetItalic( FALSE );
				text.SetWeight( FW_BOLD );
				text.SetFont( &info.lfMenuFont );
//				text.SetFont( TFONTSIZE, TFONTTYPE );
//				text.SetColor( RGB( 0, 50, 128 ) );
				text.SetColor( rgbText );
			} // end else
//			else text.SetColor( rgbText );
//			text.SetColor( RGB( 0, 50, 128 ) );
			text.DrawText( hDC, pmi->name, &t );

			// Draw sub menu indicator
			if ( pmi->submenu != NULL )
			{
				// Do we have a tick mark icon?
				if ( m_hTick != NULL )
				{
					RECT ic;
					SetRect( &ic, t.right - 18, t.top + 5, t.right - 8, t.bottom - 7 );

					// Colorize tick icon
					HICON hMono = NULL;
					if ( !pmi->submenu->IsEmpty() ) 
						hMono = CGrDC::CreateMonoChromeIcon( m_hTick, GetSysColor( COLOR_ACTIVECAPTION ) );
					else hMono = CGrDC::CreateMonoChromeIcon( m_hTick, GetSysColor( COLOR_INACTIVECAPTION ) );
//						hMono = CGrDC::CreateMonoChromeIcon( m_hTick, rgbSel );
//					else hMono = CGrDC::CreateMonoChromeIcon( m_hTick, rgbBck );

					// Draw the icon
					if ( hMono != NULL )
					{	
						CGrDC::DrawIcon( hDC, &ic, hMono );
						DestroyIcon( hMono );
					} // end if

				} // end if
				else
				{
					HPEN whitepen = CreatePen( PS_SOLID, 1, rgbLightPen );
					HPEN dkgraypen = CreatePen( PS_SOLID, 1, ScaleColor( rgbBck, -10 ) );
					HPEN blackpen = CreatePen( PS_SOLID, 1, ScaleColor( rgbBck, -40 ) );
					HPEN oldpen = (HPEN)SelectObject( hDC, whitepen );				
					HBRUSH mbrush;
					if ( !pmi->submenu->IsEmpty() ) mbrush = CreateSolidBrush( rgbBck );
					else mbrush = CreateSolidBrush( ScaleColor( rgbBck, -80 ) );
					HBRUSH oldbrush = (HBRUSH)SelectObject( hDC, mbrush );

					POINT	pts[ 3 ];

					pts[ 0 ].x = t.right - 14;
					pts[ 0 ].y = t.top + 5;
					pts[ 1 ].x = t.right - 14;
					pts[ 1 ].y = t.bottom - 7;
					pts[ 2 ].x = t.right - 8;
					pts[ 2 ].y = t.top + ( ( t.bottom - t.top ) / 2 );

					// Draw the shape
					Polygon( hDC, pts, sizeof( pts ) / sizeof( POINT ) );

					// Draw border
					MoveToEx( hDC, pts[ 0 ].x, pts[ 0 ].y, NULL );
					LineTo( hDC, pts[ 1 ].x, pts[ 1 ].y );
					SelectObject( hDC, blackpen );
					LineTo( hDC, pts[ 2 ].x, pts[ 2 ].y );
					SelectObject( hDC, dkgraypen );
					LineTo( hDC, pts[ 0 ].x, pts[ 0 ].y ); 


					// Release drawing objects
					SelectObject( hDC, oldpen );
					DeleteObject( whitepen );
					DeleteObject( dkgraypen );
					DeleteObject( blackpen );
					SelectObject( hDC, oldbrush );
					DeleteObject( mbrush );

				} // end if

			} // end if

			// Next menu item position
			y += m_th;
		} // end if

		else // separator
		{
//			HPEN whitepen = CreatePen( PS_SOLID, 1, RGB( 255, 255, 255 ) );
//			HPEN dkgraypen = CreatePen( PS_SOLID, 1, RGB( 50, 50, 50 ) );
			HPEN whitepen = CreatePen( PS_SOLID, 1, rgbBumpLt );
			HPEN dkgraypen = CreatePen( PS_SOLID, 1, rgbBumpDk );
			HPEN oldpen = (HPEN)SelectObject( hDC, whitepen );

			// Draw white line
			MoveToEx( hDC, bx + 2, by + 2, NULL );
			LineTo( hDC, ( pRect->right - pRect->left ) - 2, by + 2 );

			// Draw dark gray line
			SelectObject( hDC, dkgraypen );
			MoveToEx( hDC, bx + 2, by + 3, NULL );
			LineTo( hDC, ( pRect->right - pRect->left ) - 2, by + 3 );

			SelectObject( hDC, oldpen );
			DeleteObject( whitepen );
			DeleteObject( dkgraypen );

			y += 6;

		} // end else

	} // end while

	return TRUE;
}
Example #14
0
void CStartupDlg::OnOK() 
{
	m_btnOK.EnableWindow( FALSE );
	m_btnOffline.EnableWindow( FALSE );

	UpdateData( );

	m_ctrlProgress.ShowWindow( SW_SHOW );

	int nSel = m_comboServer.GetCurSel();
	if( CB_ERR == nSel )
	{
		AfxMessageBox( AfxModuleLoadString(IDS_SELECTSRV_NOSELECTED) );
		m_btnOK.EnableWindow( TRUE );
		if( !m_bDisableOffline )
			m_btnOffline.EnableWindow( TRUE );
		m_ctrlProgress.ShowWindow( SW_HIDE );
		return;
	}

	int i = m_comboServer.GetItemData(nSel);
	CQuoteServerArray & aServers = AfxGetQSProfile().GetQuoteServers();
	if( i >= 0 && i < aServers.GetSize() )
	{
		AfxGetQSProfile().SetCurrentServer(i);
		CQuoteServer & qs = aServers.ElementAt(i);

		// Save
		qs.m_strUser = m_strUser;
		qs.m_strPasswd = m_strPasswd;
		qs.m_bSavePasswd = m_bSavePasswd;
		if( !qs.m_bSavePasswd )
			qs.m_strPasswd.Empty();

		// Load
		m_strAddress = qs.m_strAddress;
		m_nPort = qs.m_nPort;
	}
	AfxGetQSProfile().StoreProfile();

	m_staticInfo.SetWindowText( AfxModuleLoadString(IDS_STARTUP_CONNECTSERVER) );

	AfxBeginThread( RefreshServers, NULL, THREAD_PRIORITY_NORMAL);

	if( !AfxGetStkReceiver().NetEngineBeginWorking( m_strAddress, m_nPort, m_strUser, m_strPasswd ) )
	{
		m_staticInfo.SetWindowText( AfxModuleLoadString(IDS_STARTUP_CONNECTFAILED) );
		m_btnOK.EnableWindow( TRUE );
		if( !m_bDisableOffline )
			m_btnOffline.EnableWindow( TRUE );
		m_ctrlProgress.ShowWindow( SW_HIDE );
		return;
	}

	m_staticInfo.SetWindowText( AfxModuleLoadString(IDS_STARTUP_LOADPROGRAM) );
	ASSERT( m_pfnLoadProgram );
	if( AfxGetStkReceiver().m_bFirst && m_pfnLoadProgram &&
		!m_pfnLoadProgram( GetSafeHwnd(), 0, STKLIB_MAX_PROGRESS ) )
	{
		CDialog::OnCancel();
		return;
	}

	AfxGetStkReceiver().m_bFirst = FALSE;

	CDialog::OnOK();
}
Example #15
0
// Show 		 - Show the titletip if needed
// rectTitle	 - The rectangle within which the original 
//				    title is constrained - in client coordinates
// lpszTitleText - The text to be displayed
// xoffset		 - Number of pixel that the text is offset from
//				   left border of the cell
void Printing::CPntTitleTip::Show(CRect rectTitle, LPCTSTR lpszTitleText, int xoffset /*=0*/,
                     LPRECT lpHoverRect /*=NULL*/,
                     const LOGFONT* lpLogFont /*=NULL*/,
                     COLORREF crTextClr /* CLR_DEFAULT */,
                     COLORREF crBackClr /* CLR_DEFAULT */)
{
    if (!IsWindow(m_hWnd))
        Create(m_pParentWnd);

	ASSERT( ::IsWindow( GetSafeHwnd() ) );

    if (rectTitle.IsRectEmpty())
        return;

	// If titletip is already displayed, don't do anything.
	if( IsWindowVisible() ) 
		return;

    m_rectHover = (lpHoverRect != NULL)? lpHoverRect : rectTitle;
    m_rectHover.right++; m_rectHover.bottom++;

	m_pParentWnd->ClientToScreen( m_rectHover );
    ScreenToClient( m_rectHover );

	// Do not display the titletip is app does not have focus
	if( GetFocus() == NULL )
		return;

	// Define the rectangle outside which the titletip will be hidden.
	// We add a buffer of one pixel around the rectangle
	m_rectTitle.top    = -1;
	m_rectTitle.left   = -xoffset-1;
	m_rectTitle.right  = rectTitle.Width()-xoffset;
	m_rectTitle.bottom = rectTitle.Height()+1;

	// Determine the width of the text
	m_pParentWnd->ClientToScreen( rectTitle );

	CClientDC dc(this);
	CString strTitle = _T("");
    strTitle += _T(" ");
    strTitle += lpszTitleText; 
    strTitle += _T(" ");

	CFont font, *pOldFont = NULL;
    if (lpLogFont)
    {
        font.CreateFontIndirect(lpLogFont);
	    pOldFont = dc.SelectObject( &font );
    }
    else
    {
        // use same font as ctrl
	    pOldFont = dc.SelectObject( m_pParentWnd->GetFont() );
    }

	CSize size = dc.GetTextExtent( strTitle );

    TEXTMETRIC tm;
    dc.GetTextMetrics(&tm);
    size.cx += tm.tmOverhang;

	CRect rectDisplay = rectTitle;
	rectDisplay.left += xoffset;
	rectDisplay.right = rectDisplay.left + size.cx + xoffset;
    
    // Do not display if the text fits within available space
    if ( rectDisplay.right > rectTitle.right-xoffset )
    {
		// Show the titletip
        SetWindowPos( &wndTop, rectDisplay.left, rectDisplay.top, 
            rectDisplay.Width(), rectDisplay.Height(), 
            SWP_SHOWWINDOW|SWP_NOACTIVATE );
        
        // FNA - handle colors correctly
        if (crBackClr != CLR_DEFAULT)
        {
		    CBrush backBrush(crBackClr);
		    CBrush* pOldBrush = dc.SelectObject(&backBrush);
		    CRect rect;
		    dc.GetClipBox(&rect);     // Erase the area needed 

		    dc.PatBlt(rect.left, rect.top, rect.Width(), rect.Height(),  PATCOPY);
		    dc.SelectObject(pOldBrush);
	    }
        // Set color
        if (crTextClr != CLR_DEFAULT)//FNA
            dc.SetTextColor(crTextClr);//FA

        dc.SetBkMode( TRANSPARENT );
        dc.TextOut( 0, 0, strTitle );
        SetCapture();
    }
    
    dc.SelectObject( pOldFont );
}
/* #FN#
   Called when the user clicks the OK button */
void
/* #AS#
   Nothing */
CKeyboardDlg::
OnOK() 
{
	/* There is a problem with messages routing when the dialog is
	   closed with Enter/Alt-O key. KILLFOCUS message arrives
       to late and we have to invoke KillFocus handlers in OnOK
       method by ourselves. That's why we use this member. */
	m_bExitPass = TRUE;

	/* Unfortunately, edit controls do not lose the focus before
	   handling this when the user uses accelerators */
	ReceiveFocused();

	if( m_nArrowsMode != g_Input.Key.nArrowsMode )
	{
		g_Input.Key.nArrowsMode = m_nArrowsMode;
		WriteRegDWORD( NULL, REG_ARROWS_MODE, g_Input.Key.nArrowsMode );

		Input_SetArrowKeys( g_Input.Key.nArrowsMode );
	}
	/* Always reload the selected template */
	if( !PrepareTemplate( m_szTemplateFile, m_szTemplateDesc ) )
	{
		if( _IsFlagSet( m_ulInputState, IS_KEY_USE_TEMPLATE ) )
		{
			_ClrFlag( m_ulInputState, IS_KEY_USE_TEMPLATE );
			DisplayMessage( GetSafeHwnd(), IDS_ERROR_NO_KEYTEMP, 0, MB_ICONEXCLAMATION | MB_OK, m_szTemplateFile );
		}
	}
	else
		/* Fill the template table */
		CopyMemory( g_Input.Key.anKBTable, s_anKBTable, KEYBOARD_TABLE_SIZE * sizeof(int) );

	if( _stricmp( g_szTemplateDesc, m_szTemplateDesc ) != 0 )
		strcpy( g_szTemplateDesc, m_szTemplateDesc );

	/* Windows NT doesn't like empty strings in Registry */
	if( *m_szTemplateFile == '\0' )
		strcpy( m_szTemplateFile, DEFAULT_A8K );

	if( _stricmp( g_szTemplateFile, m_szTemplateFile ) != 0 )
	{
		strcpy( g_szTemplateFile, m_szTemplateFile );
		WriteRegString( NULL, REG_FILE_TEMPLATE, g_szTemplateFile );
	}
	/* Check the miscellanous states */
	if( m_ulInputState != g_Input.ulState )
	{
		if( g_Input.ulState & IS_CAPTURE_CTRLESC ^
			m_ulInputState & IS_CAPTURE_CTRLESC )
		{
			Input_EnableEscCapture( _IsFlagSet( m_ulInputState, IS_CAPTURE_CTRLESC ) );
		}
		g_Input.ulState = m_ulInputState;
		WriteRegDWORD( NULL, REG_INPUT_STATE, g_Input.ulState);
	}
	CCommonDlg::OnOK();

} /* #OF# CKeyboardDlg::OnOK */
Example #17
0
void CFileDiffDlg::OnContextMenu(CWnd* pWnd, CPoint point)
{
	if ((pWnd==0)||(pWnd != &m_cFileList))
		return;
	if (m_cFileList.GetSelectedCount() == 0)
		return;
	// if the context menu is invoked through the keyboard, we have to use
	// a calculated position on where to anchor the menu on
	if ((point.x == -1) && (point.y == -1))
	{
		CRect rect;
		m_cFileList.GetItemRect(m_cFileList.GetSelectionMark(), &rect, LVIR_LABEL);
		m_cFileList.ClientToScreen(&rect);
		point = rect.CenterPoint();
	}
	CIconMenu popup;
	if (popup.CreatePopupMenu())
	{
		int firstEntry = -1;
		POSITION firstPos = m_cFileList.GetFirstSelectedItemPosition();
		if (firstPos)
			firstEntry = m_cFileList.GetNextSelectedItem(firstPos);

		CString menuText;
		popup.AppendMenuIcon(ID_COMPARE, IDS_LOG_POPUP_COMPARETWO, IDI_DIFF);
		popup.AppendMenuIcon(ID_GNUDIFFCOMPARE, IDS_LOG_POPUP_GNUDIFF, IDI_DIFF);
		popup.AppendMenu(MF_SEPARATOR, NULL);
		if (!m_bIsBare)
		{
			menuText.Format(IDS_FILEDIFF_POPREVERTTOREV, (LPCTSTR)m_rev1.m_CommitHash.ToString().Left(g_Git.GetShortHASHLength()));
			popup.AppendMenuIcon(ID_REVERT1, menuText, IDI_REVERT);
			menuText.Format(IDS_FILEDIFF_POPREVERTTOREV, (LPCTSTR)m_rev2.m_CommitHash.ToString().Left(g_Git.GetShortHASHLength()));
			popup.AppendMenuIcon(ID_REVERT2, menuText, IDI_REVERT);
			popup.AppendMenu(MF_SEPARATOR, NULL);
		}
		popup.AppendMenuIcon(ID_LOG, IDS_FILEDIFF_LOG, IDI_LOG);
		if (firstEntry >= 0 && !m_arFilteredList[firstEntry]->IsDirectory())
		{
			if (!m_bIsBare)
			{
				popup.AppendMenuIcon(ID_BLAME, IDS_FILEDIFF_POPBLAME, IDI_BLAME);
				popup.AppendMenu(MF_SEPARATOR, NULL);
			}
			popup.AppendMenuIcon(ID_EXPORT, IDS_FILEDIFF_POPEXPORT, IDI_EXPORT);
		}
		else if (firstEntry >= 0)
			popup.AppendMenuIcon(ID_LOGSUBMODULE, IDS_MENULOGSUBMODULE, IDI_LOG);
		popup.AppendMenu(MF_SEPARATOR, NULL);
		popup.AppendMenuIcon(ID_SAVEAS, IDS_FILEDIFF_POPSAVELIST, IDI_SAVEAS);
		popup.AppendMenuIcon(ID_CLIPBOARD_PATH, IDS_STATUSLIST_CONTEXT_COPY, IDI_COPYCLIP);
		popup.AppendMenuIcon(ID_CLIPBOARD_ALL, IDS_STATUSLIST_CONTEXT_COPYEXT, IDI_COPYCLIP);

		int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
		m_bCancelled = false;
		switch (cmd)
		{
		case ID_COMPARE:
			{
				POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
				while (pos)
				{
					int index = m_cFileList.GetNextSelectedItem(pos);
					DoDiff(index, false);
				}
			}
			break;
		case ID_GNUDIFFCOMPARE:
			{
				POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
				while (pos)
				{
					CTGitPath *fd2 = m_arFilteredList[m_cFileList.GetNextSelectedItem(pos)];
					CTGitPath *fd1 = fd2;
					if (fd2->m_Action & CTGitPath::LOGACTIONS_REPLACED)
						fd1 = new CTGitPath(fd2->GetGitOldPathString());
					CAppUtils::StartShowUnifiedDiff(m_hWnd, *fd2, m_rev2.m_CommitHash.ToString(), *fd1, m_rev1.m_CommitHash.ToString());
					if (fd1 != fd2)
						delete fd1;
				}
			}
			break;
		case ID_REVERT1:
			RevertSelectedItemToVersion(m_rev1.m_CommitHash.ToString());
			break;
		case ID_REVERT2:
			RevertSelectedItemToVersion(m_rev2.m_CommitHash.ToString());
			break;
		case ID_BLAME:
			{
				POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
				while (pos)
				{
					int index = m_cFileList.GetNextSelectedItem(pos);
					CAppUtils::LaunchTortoiseBlame(m_arFilteredList[index]->GetWinPathString(), m_rev1.m_CommitHash.ToString());
				}
			}
			break;
		case ID_LOG:
		case ID_LOGSUBMODULE:
			{
				POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
				while (pos)
				{
					int index = m_cFileList.GetNextSelectedItem(pos);
					CString sCmd = _T("/command:log");
					if (sCmd == ID_LOGSUBMODULE)
						sCmd += _T(" /submodule");
					sCmd += _T(" /path:\"") + m_arFilteredList[index]->GetWinPathString() + _T("\" ");
					sCmd += _T(" /endrev:") + m_rev1.m_CommitHash.ToString();
					CAppUtils::RunTortoiseGitProc(sCmd);
				}
			}
			break;
		case ID_SAVEAS:
			{
				if (m_cFileList.GetSelectedCount() > 0)
				{
					CString temp;
					CTGitPath savePath;
					CString pathSave;
					if (!CAppUtils::FileOpenSave(pathSave, NULL, IDS_REPOBROWSE_SAVEAS, IDS_TEXTFILEFILTER, false, m_hWnd, _T(".txt")))
					{
						break;
					}
					savePath = CTGitPath(pathSave);

					// now open the selected file for writing
					try
					{
						CStdioFile file(savePath.GetWinPathString(), CFile::typeBinary | CFile::modeReadWrite | CFile::modeCreate);
						if (m_path1.IsEmpty() && m_path2.IsEmpty())
							temp.Format(IDS_FILEDIFF_CHANGEDLISTINTROROOT, (LPCTSTR)m_rev1.m_CommitHash.ToString(), (LPCTSTR)m_rev2.m_CommitHash.ToString());
						else
							temp.Format(IDS_FILEDIFF_CHANGEDLISTINTRO, (LPCTSTR)m_path1.GetGitPathString(), (LPCTSTR)m_rev1.m_CommitHash.ToString(), (LPCTSTR)m_path2.GetGitPathString(), (LPCTSTR)m_rev2.m_CommitHash.ToString());
						file.WriteString(temp + _T("\r\n"));
						POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
						while (pos)
						{
							int index = m_cFileList.GetNextSelectedItem(pos);
							CTGitPath* fd = m_arFilteredList[index];
							file.WriteString(fd->GetGitPathString());
							file.WriteString(_T("\r\n"));
						}
						file.Close();
					}
					catch (CFileException* pE)
					{
						pE->ReportError();
					}
				}
			}
			break;
		case ID_CLIPBOARD_PATH:
			{
				CopySelectionToClipboard();
			}
			break;

		case ID_CLIPBOARD_ALL:
			{
				CopySelectionToClipboard(TRUE);
			}
			break;
		case ID_EXPORT:
			{
				// export all changed files to a folder
				CBrowseFolder browseFolder;
				browseFolder.m_style = BIF_EDITBOX | BIF_NEWDIALOGSTYLE | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
				if (browseFolder.Show(GetSafeHwnd(), m_strExportDir) == CBrowseFolder::OK)
				{
					POSITION pos = m_cFileList.GetFirstSelectedItemPosition();
					while (pos)
					{
						int index = m_cFileList.GetNextSelectedItem(pos);
						CTGitPath* fd = m_arFilteredList[index];
						// we cannot export directories or folders
						if (fd->m_Action == CTGitPath::LOGACTIONS_DELETED || fd->IsDirectory())
							continue;
						CAppUtils::CreateMultipleDirectory(m_strExportDir + _T("\\") + fd->GetContainingDirectory().GetWinPathString());
						CString filename = m_strExportDir + _T("\\") + fd->GetWinPathString();
						if(m_rev1.m_CommitHash.ToString() == GIT_REV_ZERO)
						{
							if(!CopyFile(g_Git.CombinePath(fd), filename, false))
							{
								MessageBox(CFormatMessageWrapper(), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
								return;
							}
						}
						else
						{
							if(g_Git.GetOneFile(m_rev1.m_CommitHash, *fd, filename))
							{
								CString out;
								out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, (LPCTSTR)fd->GetGitPathString(), (LPCTSTR)m_rev1.m_CommitHash.ToString(), (LPCTSTR)filename);
								if (CMessageBox::Show(nullptr, g_Git.GetGitLastErr(out, CGit::GIT_CMD_GETONEFILE), _T("TortoiseGit"), 2, IDI_WARNING, CString(MAKEINTRESOURCE(IDS_IGNOREBUTTON)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON))) == 2)
									return;
							}
						}
					}
				}
			}

			break;

		}
	}
}
Example #18
0
BOOL CWallChangerDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	if (!::g_pWallChangerDlg)
		g_pWallChangerDlg = this;
	if (!::g_pWallEnablePicList)
		::g_pWallEnablePicList = new CWallEnablePicList;
	if (!::g_pWallThreadFindPic)
		::g_pWallThreadFindPic = new CWallThreadFindPic;
	::g_pWallThreadFindPic->SetMsgWnd(m_hWnd);

	srand((UINT)time(NULL));
	pTheTray->InsertMenu(0, MF_STRING | MF_BYPOSITION, IDS_TRAY_MOVEPIC		, CResString(IDS_TRAY_MOVEPIC));
	pTheTray->InsertMenu(0, MF_STRING | MF_BYPOSITION, IDS_TRAY_DELNOWPIC	, CResString(IDS_TRAY_DELNOWPIC));
	pTheTray->InsertMenu(0, MF_STRING | MF_BYPOSITION, IDS_TRAY_RANDPIC		, CResString(IDS_TRAY_RANDPIC), true);
	pTheAppEndDlg->SignWnd(GetSafeHwnd(), 6);

	m_cIni.SetPathName(theApp.m_sAppDir + _T("WallChanger.ini"));
	if (!::g_pWallConf)
		::g_pWallConf = new CWallConf;
	::g_pWallConf->Init(&m_cIni);

	m_sTempFilePath = CTempFilePath(NULL, NULL, _T(".jpg"));
	GetDlgItem(IDC_WALL_STATIC_WAITTIME)	->SetWindowText(CResString(IDS_WALL_STATIC_WAITTIME));
	GetDlgItem(IDC_WALL_STATIC_PICTOTALNUM)	->SetWindowText(CResString(IDS_WALL_STATIC_PICTOTALNUM));
	GetDlgItem(IDC_WALL_BTN_RANDPIC)		->SetWindowText(CResString(IDS_WALL_BTN_RANDPIC));
	GetDlgItem(IDC_WALL_BTN_DELPIC)			->SetWindowText(CResString(IDS_WALL_BTN_DELPIC));
	GetDlgItem(IDC_WALL_BTN_MOVEPIC)		->SetWindowText(CResString(IDS_WALL_BTN_MOVEPIC));
	GetDlgItem(IDC_WALL_BTN_ADDCLASS)		->SetWindowText(CResString(IDS_WALL_BTN_ADDCLASS));
	m_btn_EnableToolTip.SetWindowText(CResString(::g_pWallConf->m_General_bEnableTip ? IDS_ALL_BTN_DISABLETIP : IDS_ALL_BTN_ENABLETIP));
	((CComboBox *)GetDlgItem(IDC_WALL_COMBO_IMAGELOADERROR))->AddString(CResString(IDS_WALL_COMBOX_ASKUSER));
	((CComboBox *)GetDlgItem(IDC_WALL_COMBO_IMAGELOADERROR))->AddString(CResString(IDS_WALL_COMBOX_ASKDELETE));
	((CComboBox *)GetDlgItem(IDC_WALL_COMBO_IMAGELOADERROR))->AddString(CResString(IDS_WALL_COMBOX_DELETE));
	((CComboBox *)GetDlgItem(IDC_WALL_COMBO_IMAGELOADERROR))->AddString(CResString(IDS_WALL_COMBOX_EXPLORE));
	((CComboBox *)GetDlgItem(IDC_WALL_COMBO_IMAGELOADERROR))->AddString(CResString(IDS_WALL_COMBOX_NULL));

	m_iTestOfflineCount = TESTOFFLINECOUNT;
	SetTimer(KDT_OFFLINECOUNT, 1000, NULL);

	m_comboxImageLoadError.SetCurSel(m_comboxImageLoadError.FindString(-1, ::g_pWallConf->m_General_sComboxMsg));

	GetDlgItem(IDC_WALL_CHECK_SHOWDIRLOADERROR)->SetWindowText(CResString(IDS_WALL_CHECK_SHOWDIRLOADERROR));
	m_bShowDirLoadError = ::g_pWallConf->m_General_bShowDirLoadError;
	if (m_bShowDirLoadError)
		m_checkShowLoadDirError.SetCheck(BST_CHECKED);
	else
		m_checkShowLoadDirError.SetCheck(BST_UNCHECKED);

	CString sBuf;
	sBuf.Format(_T("%d"), (UINT)::g_pWallConf->m_General_uWaitTime);
	m_editWaitTime.SetWindowText(sBuf);
	m_staticTime.SetWindowText(sBuf);

	CRect rcWin;
	m_listDirPath.Init(&m_cIni, _T(""), &m_bShowDirLoadError);
	m_listDirPath.ShowWindow(SW_SHOW);
	m_listDirPath.GetClientRect(rcWin);
	m_listClass.Init(&m_cIni, rcWin, &m_bShowDirLoadError);

	SetHistoryNum(::g_pWallConf->m_General_uPicPathHistory);
	EnableToolTips(::g_pWallConf->m_General_bEnableTip);

	m_bInit = true;
	return TRUE;  // return TRUE unless you set the focus to a control
	// EXCEPTION: OCX ÄÝ©Ê­¶À³¶Ç¦^ FALSE
}
//****************************************************************************
void CBCGPDialogBar::UpdateScrollBars()
{
#ifndef _BCGSUITE_
    if(GetSafeHwnd() == NULL || m_scrollSize == CSize(0, 0))
    {
        return;
    }

	if (m_bUpdateScroll)
	{
		return;
	}

	m_bUpdateScroll = TRUE;

	CRect rectClient;
	GetClientRect(rectClient);
	CSize sizeClient(rectClient.Size());

	CSize sizeRange (m_scrollSize - sizeClient);

	CPoint ptScroll (m_scrollPos);
	ASSERT(ptScroll.x >= 0 && ptScroll.y >= 0);

	int nScrollButtonSize = GetScrollButtonSize();

	BOOL bNeedH = sizeRange.cx > 0;
	if (!bNeedH)
	{
		ptScroll.x = 0;
		sizeRange.cx = 0;
	}
	else
	{
		if (ScrollHorzAvailable (TRUE) && ScrollHorzAvailable (FALSE))
		{
			sizeRange.cx -= nScrollButtonSize;
		}
	}

	BOOL bNeedV = sizeRange.cy > 0;
	if (!bNeedV)
	{
		ptScroll.y = 0;
		sizeRange.cy = 0;
	}
	else
	{
		if (ScrollVertAvailable (TRUE) && ScrollVertAvailable (FALSE))
		{
			sizeRange.cy -= nScrollButtonSize;
		}
	}

	if (sizeRange.cx > 0 && ptScroll.x >= sizeRange.cx)
	{
		ptScroll.x = sizeRange.cx;
	}
	if (sizeRange.cy > 0 && ptScroll.y >= sizeRange.cy)
	{
		ptScroll.y = sizeRange.cy;
	}

	if (sizeRange.cx <= nScrollButtonSize)
	{
		sizeRange.cx = 0;
	}

	if (sizeRange.cy <= nScrollButtonSize)
	{
		sizeRange.cy = 0;
	}

	m_scrollRange = sizeRange;

	ScrollClient(CSize(m_scrollPos.x - ptScroll.x, m_scrollPos.y - ptScroll.y));

	CalcScrollButtons ();

	m_bUpdateScroll = FALSE;
#endif
}
Example #20
0
void CSplashWnd::SafeHide()
{
	if (GetSafeHwnd()) {
		ShowWindow(SW_HIDE);
	}
}
Example #21
0
// 计算列表项大小
void CPopupList::SetItemPoint()
{
	int nItemCount =  m_vecItem.size();

	// 判断是否有Desc字段,如果都没有的话,则显示的列表一律用相同高度的
	BOOL bHaveDesc = FALSE;
	m_bSingleLine = TRUE;
	for (int i = 0; i < nItemCount; i++)
	{
		EditListItem &editListItem = m_vecItem.at(i);
		if(!editListItem.strDesc.IsEmpty())
		{
			bHaveDesc = TRUE;
			m_bSingleLine = FALSE;
			break;
		}
	}

	int nHeight = 4;
	nHeight += 24 * nItemCount;
	if(bHaveDesc)
	{
		if(0 == nItemCount) nHeight += 40;
		if(nItemCount >= 1) nHeight += 20;
		if(nItemCount >= 2) nHeight += 9;
		if(nItemCount >= 2) nHeight += 9;
	}

	int nStratTop = 2;
	for (int i = 0; i < nItemCount; i++)
	{
		EditListItem &editListItem = m_vecItem.at(i);
		editListItem.rcItem.left = 2;
		editListItem.rcItem.right = m_nWidth - 2;
		if((i - 1 == m_nHoverItem) && (m_nHoverItem != -1) || (i + 1 == m_nHoverItem))
		{
			editListItem.rcItem.top = nStratTop;
			editListItem.rcItem.bottom = nStratTop + (bHaveDesc ? 33 : 24);
			nStratTop += (bHaveDesc ? 33 : 24);
		}
		else if(i == m_nHoverItem)
		{
			editListItem.rcItem.top = nStratTop;
			editListItem.rcItem.bottom = nStratTop + (bHaveDesc ? 44 : 24);
			nStratTop += (bHaveDesc ? 44 : 24);

			int nLeft = editListItem.rcItem.right - m_sizeClose.cx - 7;
			int nTop = editListItem.rcItem.top + ((bHaveDesc ? 44 : 24) - m_sizeClose.cy) / 2 + 1;

			m_rcClose.SetRect(nLeft, nTop, nLeft + m_sizeClose.cx, nTop + m_sizeClose.cy);
		}
		else
		{
			editListItem.rcItem.top = nStratTop;
			editListItem.rcItem.bottom = nStratTop + 24;
			nStratTop += 24;
		}
	}
	
	if(IsWindow(GetSafeHwnd()))
	{
		SetWindowPos(NULL, 0, 0, m_nWidth, nHeight, SWP_NOMOVE);
	}
}
Example #22
0
//***************************************************************************************
void CBCGPShellList::OnContextMenu(CWnd* /*pWnd*/, CPoint point) 
{
	ASSERT_VALID (this);
	ASSERT_VALID (g_pShellManager);
	ASSERT (g_pShellManager->m_pBCGMalloc != NULL);

	if (m_pContextMenu2 != NULL)
	{
		return;
	}

	if (!m_bContextMenu)
	{
		Default ();
		return;
	}

	if (m_psfCurFolder == NULL)
	{
		return;
	}

	UINT	nSelItems = GetSelectedCount ();
	int		nClickedItem = -1;

	if (point.x == -1 && point.y == -1)
	{
		//--------------------------------------------------------
		// Keyboard, show menu for the currently selected item(s):
		//--------------------------------------------------------
		if (nSelItems == 0)
		{
			return;
		}

		int nCurItem = -1;
		int nLastSelItem = -1;

		for (UINT i = 0; i < nSelItems; i++)
		{
			nCurItem = GetNextItem (nCurItem, LVNI_SELECTED);
			nLastSelItem = nCurItem;
		}

		CRect rectItem;
		if (GetItemRect (nLastSelItem, rectItem, LVIR_BOUNDS))
		{
			point.x = rectItem.left;
			point.y = rectItem.bottom + 1;

			ClientToScreen (&point);
		}
	}
	else
	{
		//--------------------------
		// Clicked on specifed item:
		//--------------------------
		LVHITTESTINFO lvhti;
		lvhti.pt = point;
		ScreenToClient(&lvhti.pt);
		
		lvhti.flags = LVHT_NOWHERE;
		
		HitTest (&lvhti);
		
		if ((lvhti.flags & LVHT_ONITEM) == 0)
		{
			//-----------------------------------
			// Click ouside of items, do nothing
			//-----------------------------------
			return;
		}

		nClickedItem = lvhti.iItem;
	}

	LPITEMIDLIST* pPidls = (LPITEMIDLIST*) 
						g_pShellManager->m_pBCGMalloc->Alloc (sizeof(LPITEMIDLIST) * nSelItems);
	ASSERT (pPidls != NULL);

	//------------------------
	// Get the selected items:
	//------------------------
	LVITEM lvItem;
	ZeroMemory(&lvItem, sizeof(lvItem));
	lvItem.mask = LVIF_PARAM;

	LPBCGCBITEMINFO pClickedInfo = (LPBCGCBITEMINFO)lvItem.lParam;

	if (nClickedItem >= 0)
	{
		//-------------------------------------------
		// Put the item clicked on first in the list:
		//-------------------------------------------
		lvItem.iItem = nClickedItem;

		if (GetItem (&lvItem))
		{
			pClickedInfo = (LPBCGCBITEMINFO)lvItem.lParam;
			pPidls [0] = pClickedInfo->pidlRel;
		}
	}
	
	int nCurItem = -1;
	for (UINT i = nClickedItem >= 0 ? 1 : 0; i < nSelItems; i++)
	{
		nCurItem = GetNextItem (nCurItem, LVNI_SELECTED);
		if (nCurItem != nClickedItem)
		{
			lvItem.iItem = nCurItem;

			if (GetItem (&lvItem))
			{
				LPBCGCBITEMINFO pInfo = (LPBCGCBITEMINFO)lvItem.lParam;
				pPidls [i] = pInfo->pidlRel;

				if (pClickedInfo == NULL)
				{
					pClickedInfo = pInfo;
				}
			}
		}
		else
		{
			i--;
		}
	}
	
	if (pPidls [0] == NULL)
	{
		g_pShellManager->m_pBCGMalloc->Free (pPidls);
		return;
	}

	IContextMenu* pcm;
	HRESULT hr = m_psfCurFolder->GetUIObjectOf (GetSafeHwnd (),
		nSelItems, 
		(LPCITEMIDLIST*)pPidls, 
		IID_IContextMenu, 
		NULL, 
		(LPVOID*)&pcm);
	
	if (SUCCEEDED (hr))
	{
		hr = pcm->QueryInterface (IID_IContextMenu2, (LPVOID*)&m_pContextMenu2);

		if (SUCCEEDED (hr))
		{
			HMENU hPopup = CreatePopupMenu ();
			if (hPopup != NULL)
			{
				hr = m_pContextMenu2->QueryContextMenu(hPopup, 0, 1, 0x7fff, CMF_NORMAL | CMF_EXPLORE);
				
				if (SUCCEEDED(hr))
				{
					UINT idCmd = TrackPopupMenu (hPopup,
							TPM_LEFTALIGN | TPM_RETURNCMD | TPM_RIGHTBUTTON, 
							point.x,
							point.y,
							0,
							GetSafeHwnd (),
							NULL);

					if (idCmd != 0)
					{
						BOOL bIsFolder = FALSE;

						if (nSelItems == 1 &&
							idCmd == ::GetMenuDefaultItem (hPopup, FALSE, 0))
						{
							//-----------------------------------------------------
							// If specified element is a folder, try to display it:
							//-----------------------------------------------------
							ULONG ulAttrs = SFGAO_FOLDER;
							m_psfCurFolder->GetAttributesOf (1, 
								(const struct _ITEMIDLIST **) &pClickedInfo->pidlRel, &ulAttrs);

							if (ulAttrs & SFGAO_FOLDER)
							{
								bIsFolder = TRUE;
								DisplayFolder (pClickedInfo);
							}
						}

						if (!bIsFolder)
						{
							CMINVOKECOMMANDINFO cmi;
							cmi.cbSize = sizeof(CMINVOKECOMMANDINFO);
							cmi.fMask = 0;
							cmi.hwnd = GetParent ()->GetSafeHwnd ();
							cmi.lpVerb = (LPCSTR)(INT_PTR)(idCmd - 1);
							cmi.lpParameters = NULL;
							cmi.lpDirectory = NULL;
							cmi.nShow = SW_SHOWNORMAL;
							cmi.dwHotKey = 0;
							cmi.hIcon = NULL;

							hr = pcm->InvokeCommand (&cmi);

							if (SUCCEEDED (hr) && GetParent () != NULL)
							{
								GetParent ()->SendMessage (BCGPM_ON_AFTER_SHELL_COMMAND,
									(WPARAM) idCmd);
							}
						}
					}
				}
			}

			if (m_pContextMenu2 != NULL)
			{
				m_pContextMenu2->Release();
				m_pContextMenu2 = NULL;
			}
		}
		
		pcm->Release();
	}
	
	g_pShellManager->m_pBCGMalloc->Free (pPidls);
}
CTracksInfo& CCWArrangePage::GetTracksInfo()
{
	if (!::IsWindow (GetSafeHwnd ()))
		return *m_pTracks;

	// create new tracks info
	if (m_pTracks == NULL)
		m_pTracks = new CTracksInfo ();

	// Build tracks info
	CString s;
	GetDlgItemText (IDC_RICHEDIT_TITLE, s);

	/*
	 * TODO: RTF should be merged [ mmc, 11.03.04 ]
	 *
	CString strRTFTitle;
	for (int i = 0; i < NUM_RENDER_TYPES; i++)
	{
		strRTFTitle = m_pTracks->GetRTFTitle ((RenderType) i);
		if (!strRTFTitle.IsEmpty ())
		{
			strRTFTitle.Replace (m_pTracks->GetTitle (), s);
			m_pTracks->SetRTFTitle (strRTFTitle, (RenderType) i);
		}
	}*/

	s.Replace ("\r\n", " · ");
	m_pTracks->SetTitle (s);

//	for (int i = 0; i < NUM_RENDER_TYPES; i++)
//		m_pTracks->SetRTFTitle ("" /*m_EditTitle.GetRTF ()*/, (RenderType) i);

	//m_pTracks->ApplyStyleToRTFTitles (?);

//	GetDlgItemText (IDC_EDIT_TITLE2, s);
//	m_pTracks->SetSubtitle (s);

	if (m_pTracks->IsManuallyEditable ())
	{
		// remove existing tracks
		int n = m_pTracks->GetNumTracks ();
		for (int i = 0; i < n; i++)
			m_pTracks->Remove (0);

		// add tracks from list control
		LVITEM lvItem;
		int m, nIdx = 1;
		for (int i = 0; i < m_List.GetItemCount (); i++)
		{
			lvItem.iItem = i;
			lvItem.iSubItem = 0;
			lvItem.mask = LVIF_IMAGE;
			m_List.GetItem (&lvItem);

			if (lvItem.iImage == 0)
				m = -1;
			else
				m = nIdx++;

			m_pTracks->Add (new CTrack (m,
				m_List.GetItemText (i, 1),
				m_List.GetItemText (i, 2),
				m_List.GetItemText (i, 3)));
		}
	}
	else
		for (int i = 0; i < m_pTracks->GetNumTracks (); i++)
			m_pTracks->SetTrackTexts (i + 1/*m_List.GetItemData (i)*/,
				m_List.GetItemText (i, 2),
				m_List.GetItemText (i, 3));

	return *m_pTracks;
}
Example #24
0
void CKillGamesDlg::OnClose() 
{
	::ShowWindow(GetSafeHwnd(),SW_MINIMIZE);
}
Example #25
0
//***************************************************************************************
void CBCGPShellList::DoDefault (int iItem)
{
	LVITEM lvItem;
	
	ZeroMemory(&lvItem, sizeof(lvItem));
	lvItem.mask = LVIF_PARAM;
	lvItem.iItem = iItem;
	
	if (!GetItem (&lvItem))
	{
		return;
	}

	LPBCGCBITEMINFO	pInfo = (LPBCGCBITEMINFO) lvItem.lParam;
	if (pInfo == NULL || pInfo->pParentFolder == NULL || pInfo->pidlRel == NULL)
	{
		ASSERT (FALSE);
		return;
	}

	IShellFolder *psfFolder = pInfo->pParentFolder;
	if (psfFolder == NULL)
	{
		SHGetDesktopFolder (&psfFolder);
	}
	else
	{
		psfFolder->AddRef ();
	}
	
	if (psfFolder == NULL)
	{
		return;
	}

	//-----------------------------------------------------
	// If specified element is a folder, try to display it:
	//-----------------------------------------------------
	ULONG ulAttrs = SFGAO_FOLDER;
	psfFolder->GetAttributesOf (1, 
		(const struct _ITEMIDLIST **) &pInfo->pidlRel, &ulAttrs);

	if (ulAttrs & SFGAO_FOLDER)
	{
		DisplayFolder (pInfo);
	}
	else
	{
		//-------------------------------
		// Invoke a default menu command:
		//-------------------------------
		IContextMenu *pcm;
		HRESULT hr = psfFolder->GetUIObjectOf (GetSafeHwnd (),
			1, 
			(LPCITEMIDLIST*)&pInfo->pidlRel, 
			IID_IContextMenu, 
			NULL, 
			(LPVOID*)&pcm);
		
		if (SUCCEEDED (hr))
		{
			HMENU hPopup = CreatePopupMenu ();

			if (hPopup != NULL)
			{
				hr = pcm->QueryContextMenu (hPopup, 0, 1, 0x7fff, 
											CMF_DEFAULTONLY | CMF_EXPLORE);
				
				if (SUCCEEDED (hr))
				{
					UINT idCmd = ::GetMenuDefaultItem (hPopup, FALSE, 0);
					if (idCmd != 0 && idCmd != (UINT)-1)
					{
						CMINVOKECOMMANDINFO cmi;
						cmi.cbSize = sizeof (CMINVOKECOMMANDINFO);
						cmi.fMask = 0;
						cmi.hwnd = GetParent()->GetSafeHwnd ();
						cmi.lpVerb = (LPCSTR)(INT_PTR)(idCmd - 1);
						cmi.lpParameters = NULL;
						cmi.lpDirectory = NULL;
						cmi.nShow = SW_SHOWNORMAL;
						cmi.dwHotKey = 0;
						cmi.hIcon = NULL;

						hr = pcm->InvokeCommand (&cmi);

						if (SUCCEEDED (hr) && GetParent () != NULL)
						{
							GetParent ()->SendMessage (BCGPM_ON_AFTER_SHELL_COMMAND,
								(WPARAM) idCmd);
						}
					}
				}
			}
			
			pcm->Release ();
		}
	}
	
	psfFolder->Release ();
}
void CListCtrlComboBox::ShowEdit(int nItem,int nSubItem) {
    if (nItem < 0 || nSubItem < 0) return;
    if (m_pParentList == NULL) return ;
    CListCtrl *pCtrl = m_pParentList;
    CRect rect;
    m_pParentList = pCtrl;
//	m_pParentList->GetSubItemRect(nItem,nIndex,LVIR_LABEL,rcCtrl);

    // 列可见
    CHeaderCtrl* pHeader = (CHeaderCtrl*)pCtrl->GetDlgItem(0);
    int nColumnCount = pHeader->GetItemCount();
    if( nSubItem >= nColumnCount || pCtrl->GetColumnWidth(nSubItem) < 5 )
        return ;

    // 列偏移
    int offset = 0;
    for( int i = 0; i < nSubItem; i++ )
        offset += pCtrl->GetColumnWidth( i );

    pCtrl->GetItemRect( nItem, &rect, LVIR_BOUNDS );
    rect.top -= 2;
    if (rect.top < 0) rect.top = 0;
    // 滚动列,便于操作
    CRect rcClient;
    CSize size;
    pCtrl->GetClientRect( &rcClient );
//	if( offset + rect.left < 0 || offset + rect.left > rcClient.right )
    if( offset + rect.left < 0 ) {
        size.cx = offset + rect.left;
        size.cy = 0;
        pCtrl->Scroll( size );
        rect.left -= size.cx;
    } else if(offset + rect.left > rcClient.right ) {
        size.cx = offset + rect.left;
        size.cy = 0;
        pCtrl->Scroll( size );
        rect.left -= size.cx;
    }
    // 获取列的对齐方式
    LV_COLUMN lvcol;
    lvcol.mask = LVCF_FMT;
    pCtrl->GetColumn( nSubItem, &lvcol );
    DWORD dwStyle;
    if((lvcol.fmt&LVCFMT_JUSTIFYMASK) == LVCFMT_LEFT)
        dwStyle = ES_LEFT;
    else if((lvcol.fmt&LVCFMT_JUSTIFYMASK) == LVCFMT_RIGHT)
        dwStyle = ES_RIGHT;
    else dwStyle = ES_CENTER;

    rect.left += offset + 1;
    if (nSubItem > 0)
        rect.right = rect.left + pCtrl->GetColumnWidth( nSubItem );
    else
        rect.right = rect.left + pCtrl->GetColumnWidth( nSubItem );

    if( rect.right > rcClient.right)
        rect.right = rcClient.right;

    rect.bottom = rect.top + 12 * rect.Height();

    CString strItem = pCtrl->GetItemText(nItem,nSubItem);
    pCtrl->ClientToScreen(rect);
    GetParent()->ScreenToClient(rect);
    MoveWindow(rect);
//	SetWindowPos(NULL, rect.left,rect.top,rect.Width(),rect.Height(), SWP_SHOWWINDOW);
//	pCtrl->ClientToScreen(rcClient);
//	GetParent()->ScreenToClient(rcClient);
//	pCtrl->SetWindowPos(this, rcClient.left,rcClient.top,rcClient.Width(),rcClient.Height(), SWP_SHOWWINDOW);
    ShowWindow(SW_SHOW);
    SetWindowText(strItem);
    ::SetFocus(GetSafeHwnd());
    SetItemHeight(-1,13);
//设置对应选项
    int nIndex =  FindStringExact(0, strItem);
    if (nIndex < 0) nIndex = 0;
    SetCurSel(nIndex);
    m_nCurrentItem = nItem;
    m_nCurrentSubItem = nSubItem;
}
Example #27
0
BOOL CSubtitleDlDlg::OnInitDialog()
{
    __super::OnInitDialog();

    m_status.Create(WS_CHILD | WS_VISIBLE | CCS_BOTTOM, CRect(0, 0, 0, 0), this, IDC_STATUSBAR);

    int n, curPos = 0;
    CArray<int> columnWidth;

    CString strColumnWidth = AfxGetApp()->GetProfileString(IDS_R_DLG_SUBTITLEDL, IDS_RS_DLG_SUBTITLEDL_COLWIDTH, _T(""));
    CString token = strColumnWidth.Tokenize(_T(","), curPos);
    while (!token.IsEmpty()) {
        if (_stscanf_s(token, L"%i", &n) == 1) {
            columnWidth.Add(n);
            token = strColumnWidth.Tokenize(_T(","), curPos);
        } else {
            throw 1;
        }
    }

    m_list.SetExtendedStyle(m_list.GetExtendedStyle()
                            | LVS_EX_DOUBLEBUFFER | LVS_EX_FULLROWSELECT
                            | LVS_EX_CHECKBOXES   | LVS_EX_LABELTIP);

    if (columnWidth.GetCount() != 5) {
        // default sizes
        columnWidth.RemoveAll();
        columnWidth.Add(290);
        columnWidth.Add(70);
        columnWidth.Add(50);
        columnWidth.Add(50);
        columnWidth.Add(270);
    }

    m_list.InsertColumn(COL_FILENAME, ResStr(IDS_SUBDL_DLG_FILENAME_COL), LVCFMT_LEFT, columnWidth[0]);
    m_list.InsertColumn(COL_LANGUAGE, ResStr(IDS_SUBDL_DLG_LANGUAGE_COL), LVCFMT_CENTER, columnWidth[1]);
    m_list.InsertColumn(COL_FORMAT, ResStr(IDS_SUBDL_DLG_FORMAT_COL), LVCFMT_CENTER, columnWidth[2]);
    m_list.InsertColumn(COL_DISC, ResStr(IDS_SUBDL_DLG_DISC_COL), LVCFMT_CENTER, columnWidth[3]);
    m_list.InsertColumn(COL_TITLES, ResStr(IDS_SUBDL_DLG_TITLES_COL), LVCFMT_LEFT, columnWidth[4]);

    AddAnchor(IDC_LIST1, TOP_LEFT, BOTTOM_RIGHT);
    AddAnchor(IDC_CHECK1, BOTTOM_LEFT);
    AddAnchor(IDOK, BOTTOM_RIGHT);
    AddAnchor(IDC_STATUSBAR, BOTTOM_LEFT, BOTTOM_RIGHT);

    const CSize s(420, 200);
    SetMinTrackSize(s);
    EnableSaveRestore(IDS_R_DLG_SUBTITLEDL);

    // set language sorting order
    const CAppSettings& settings = AfxGetAppSettings();
    CString order = settings.strSubtitlesLanguageOrder;
    // fill language->position map
    int listPos = 0;
    int tPos = 0;
    CString langCode = order.Tokenize(_T(",; "), tPos);
    while (tPos != -1) {
        CString langName = LangCodeToName(CStringA(langCode));
        if (!langName.IsEmpty()) {
            int pos;
            if (!defps.m_langPos.Lookup(langName, pos)) {
                defps.m_langPos[langName] = listPos++;
            }
        }
        langCode = order.Tokenize(_T(",; "), tPos);
    }

    // start new worker thread to download the list of subtitles
    m_pTA = DEBUG_NEW THREADSTRUCT;
    m_pTA->url = m_url;
    m_pTA->hWND = GetSafeHwnd();

    SetStatus(ResStr(IDS_SUBDL_DLG_DOWNLOADING));
    AfxBeginThread(RunThread, static_cast<LPVOID>(m_pTA));

    return TRUE;
}
Example #28
0
void CWinMenu::OnMouseMove(UINT nFlags, CPoint point) 
{
	LPMITEMINFO	item = GetMenuItem( &point );

	BOOL bRedraw = FALSE;

	// Redraw window if needed by toolbar
	if (	item != NULL && item->toolbar != NULL && 
			item->toolbar->OnMouseMove( nFlags, &point ) )
		bRedraw = TRUE;

	if ( ( nFlags & MK_LBUTTON ) == 0 )
	{	

		if ( item != m_itemover )
		{
			// Clear mouse over
			if ( m_itemover != NULL && m_itemover->toolbar != NULL )
				m_itemover->toolbar->ClearMouseOver();

			// Save new item
			m_itemover = item;

			// Popup sub menu if needed
			NewSubMenu( item );

			// Redraw our window
			bRedraw = TRUE;

		} // end if

	} // end if

	else
	{
		RECT c;
		GetWindowRect( &c );

		if ( !PtInRect( &c, point ) )
		{
			HWND last = m_hDropWnd;

			POINT pt;
			pt.x = point.x;
			pt.y = point.y;
			ClientToScreen( &pt );

			// Which window was choosen
			HWND hParent = ::WindowFromPoint( pt );
			if ( m_bAllowChildren )
			{
				if ( hParent != NULL )
				{
					// Check for child windows
					::ScreenToClient( hParent, &pt );
					HWND hChild = ::ChildWindowFromPoint( hParent, pt );
					
					// Which window to use
					if ( hChild != NULL ) m_hDropWnd = hChild;
					else m_hDropWnd = hParent;
						
				} // end if
			} // end if
			else
			{
				// Get topmost window
				while ( hParent != NULL )
				{
					m_hDropWnd = hParent;
					hParent = ::GetParent( hParent );
				} // end while

			} // end else

			// Border window
			if ( last != m_hDropWnd ) 
			{
				// Undo our mess
				RedrawLastWindow();

				if ( m_hDropWnd != GetSafeHwnd() && ::IsWindow( m_hDropWnd ) )
				{
					HDC hDC = ::GetWindowDC( m_hDropWnd );

					if ( hDC != NULL )
					{
						// Save last window we screwed up
						m_hLastWnd = m_hDropWnd;

						RECT rect;
						::GetWindowRect( m_hDropWnd, &rect );
						OffsetRect( &rect, -rect.left, -rect.top );

						HBRUSH oldbrush = (HBRUSH)SelectObject( hDC, GetStockObject( NULL_BRUSH ) );
						HPEN red = CreatePen( PS_DASH, 2, RGB( 255, 0, 0 ) );
						HPEN white = CreatePen( PS_DASH, 2, RGB( 80, 80, 80 ) );
						HPEN blue = CreatePen( PS_DASH, 2, RGB( 0, 0, 255 ) );
						HPEN oldpen = (HPEN)SelectObject( hDC, red );

						// Draw the rectangle
//						Rectangle( hDC, rect.left, rect.top, rect.right, rect.bottom );

						InflateRect( &rect, -2, -2 );
						SelectObject( hDC, red );
						Rectangle( hDC, rect.left, rect.top, rect.right, rect.bottom );

						InflateRect( &rect, -2, -2 );
						SelectObject( hDC, blue );
						Rectangle( hDC, rect.left, rect.top, rect.right, rect.bottom );

						// Restore the DC
						SelectObject( hDC, oldpen );
						SelectObject( hDC, oldbrush );
						DeleteObject( red );
						DeleteObject( white );
						DeleteObject( blue );
						::ReleaseDC( m_hDropWnd, hDC );
					} // end if
				} // end if
			} // end if

		} // end if

	} // end else if
	
	// Redraw window if needed
	if ( bRedraw ) RedrawWindow();

	CWnd::OnMouseMove(nFlags, point);
}
Example #29
0
BOOL Printing::CPntTitleTip::PreTranslateMessage(MSG* pMsg) 
{
    // Used to qualify WM_LBUTTONDOWN messages as double-clicks
    DWORD dwTick=0;
    BOOL bDoubleClick=FALSE;

    CWnd *pWnd;
	int hittest;
	switch (pMsg->message)
	{
	case WM_LBUTTONDOWN:
       // Get tick count since last LButtonDown
        dwTick = GetTickCount();
        bDoubleClick = ((dwTick - m_dwLastLButtonDown) <= m_dwDblClickMsecs);
        m_dwLastLButtonDown = dwTick;
        // NOTE: DO NOT ADD break; STATEMENT HERE! Let code fall through

	case WM_RBUTTONDOWN:
	case WM_MBUTTONDOWN:
		{
		POINTS pts = MAKEPOINTS( pMsg->lParam );
		POINT  point;
		point.x = pts.x;
		point.y = pts.y;

		ClientToScreen( &point );
        Hide();

		pWnd = WindowFromPoint( point );
		if (!pWnd)
			return CWnd::PreTranslateMessage(pMsg);

		if( pWnd->GetSafeHwnd() == GetSafeHwnd()) 
			pWnd = m_pParentWnd;

		hittest = (int)pWnd->SendMessage(WM_NCHITTEST,0,MAKELONG(point.x,point.y));

		if (hittest == HTCLIENT) 
		{
			pWnd->ScreenToClient( &point );
			pMsg->lParam = MAKELONG(point.x,point.y);
		}
		else 
		{
			switch (pMsg->message) {
			case WM_LBUTTONDOWN: 
				pMsg->message = WM_NCLBUTTONDOWN;
				break;
			case WM_RBUTTONDOWN: 
				pMsg->message = WM_NCRBUTTONDOWN;
				break;
			case WM_MBUTTONDOWN: 
				pMsg->message = WM_NCMBUTTONDOWN;
				break;
			}
			pMsg->wParam = hittest;
			pMsg->lParam = MAKELONG(point.x,point.y);
		}


        // If this is the 2nd WM_LBUTTONDOWN in x milliseconds,
        // post a WM_LBUTTONDBLCLK message instead of a single click.
        pWnd->PostMessage(  bDoubleClick ? WM_LBUTTONDBLCLK : pMsg->message,
                            pMsg->wParam,
                            pMsg->lParam);
		return TRUE;
		}
		
	case WM_KEYDOWN:
	case WM_SYSKEYDOWN:
        Hide();
		m_pParentWnd->PostMessage( pMsg->message, pMsg->wParam, pMsg->lParam );
		return TRUE;
	}

	if( GetFocus() == NULL )
	{
        Hide();
		return TRUE;
	}

	return CWnd::PreTranslateMessage(pMsg);
}
Example #30
-1
void CWinMenu::UnselectMenu()
{	m_itemover = NULL;
	if ( !::IsWindow( GetSafeHwnd() ) ) return;	
	KillSubMenus();
	RedrawWindow();
}