void SListBoxEx::OnKeyDown( TCHAR nChar, UINT nRepCnt, UINT nFlags )
{
int nNewSelItem = -1;
SWindow *pOwner = GetOwner();
if (pOwner && (nChar == VK_ESCAPE))
{
pOwner->SSendMessage(WM_KEYDOWN, nChar, MAKELONG(nFlags, nRepCnt));
return;
}
if (nChar == VK_DOWN && m_iSelItem < GetItemCount() - 1)
nNewSelItem = m_iSelItem+1;
else if (nChar == VK_UP && m_iSelItem > 0)
nNewSelItem = m_iSelItem-1;
else if (pOwner && nChar == VK_RETURN)
nNewSelItem = m_iSelItem;
else if(nChar == VK_PRIOR)
{
OnScroll(TRUE,SB_PAGEUP,0);
}else if(nChar == VK_NEXT)
{
OnScroll(TRUE,SB_PAGEDOWN,0);
}
if(nNewSelItem!=-1)
{
EnsureVisible(nNewSelItem);
NotifySelChange(m_iSelItem,nNewSelItem);
}
}
void TBLayout::SetOverflowScroll(int overflow_scroll)
{
overflow_scroll = MIN(overflow_scroll, m_overflow);
overflow_scroll = MAX(overflow_scroll, 0);
if (overflow_scroll == m_overflow_scroll)
return;
m_overflow_scroll = overflow_scroll;
Invalidate();
if (m_axis == AXIS_X)
OnScroll(m_overflow_scroll, 0);
else
OnScroll(0, m_overflow_scroll);
}
void IScrollMathModel::ScrollBy(Point2F movement)
{
mCurrentWindow.Origin += movement;
OnRestrictScroll();
OnScroll();
}
void CXTPControlScrollBar::DoScroll(int cmd, int pos)
{
m_bInScroll = TRUE;
CWnd* pParent = GetParent()->GetOwnerSite();
NMXTPSCROLL nmScroll;
nmScroll.hdr.code = XTP_SBN_SCROLL;
nmScroll.hdr.idFrom = GetID();
nmScroll.hdr.hwndFrom = GetParent()->GetSafeHwnd();
nmScroll.pSender = this;
nmScroll.nPos = pos;
nmScroll.nSBCode = cmd;
LRESULT lResult = 0;
AFX_NOTIFY notify;
notify.pResult = &lResult;
notify.pNMHDR = (NMHDR*)&nmScroll.hdr;
pParent->OnCmdMsg(GetID(), MAKELONG(XTP_SBN_SCROLL, WM_NOTIFY), ¬ify, NULL);
m_bInScroll = FALSE;
if (*notify.pResult)
return;
OnScroll(cmd, pos);
}
BOOL SListBox::SetTopIndex(int nIndex)
{
if (nIndex < 0 || nIndex >= GetCount())
return FALSE;
OnScroll(TRUE,SB_THUMBPOSITION, nIndex*m_nItemHei);
return TRUE;
}
void CScrollView::OnVScroll( UINT nSBCode, UINT nPos, CScrollBar *pScrollBar )
/****************************************************************************/
{
if( pScrollBar == NULL || !pScrollBar->SendChildNotifyLastMsg() ) {
if( pScrollBar == GetScrollBarCtrl( SB_VERT ) ) {
OnScroll( MAKEWORD( 0xFF, nSBCode ), nPos );
} else {
Default();
}
}
}
void CScrollWnd::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
if (pScrollBar != NULL && pScrollBar->SendChildNotifyLastMsg())
return; // eat it
// ignore scroll bar msgs from other controls
if (pScrollBar != GetScrollBarCtrl(SB_VERT))
return;
OnScroll(MAKEWORD(-1, nSBCode), nPos);
}
void CXTPPropertyPage::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
if (pScrollBar != NULL && pScrollBar->SendChildNotifyLastMsg())
return; // eat it
// ignore scroll bar msgs from other controls
if (pScrollBar != GetScrollBarCtrl(SB_HORZ))
return;
OnScroll(MAKEWORD(nSBCode, -1), nPos);
}
void CXDialog::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default
if (pScrollBar != NULL && pScrollBar->SendChildNotifyLastMsg())
return; // eat it
// ignore scroll bar msgs from other controls
if (pScrollBar != GetScrollBarCtrl(SB_HORZ))
return;
OnScroll(MAKEWORD(nSBCode, -1), nPos);
//CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
}
void AudacityProject::FinishAutoScroll()
{
// Set a flag so we don't have to generate two update events
mAutoScrolling = true;
// Call our Scroll method which updates our ViewInfo variables
// to reflect the positions of the scrollbars
wxScrollEvent *dummy = new wxScrollEvent();
OnScroll(*dummy);
delete dummy;
mAutoScrolling = false;
}
void SListBoxEx::EnsureVisible( int iItem )
{
if(iItem<0 || iItem>=GetItemCount()) return;
int iFirstVisible=(m_ptOrigin.y + m_nItemHei -1) / m_nItemHei;
CRect rcClient;
GetClientRect(&rcClient);
int nVisibleItems=rcClient.Height()/m_nItemHei;
if(iItem<iFirstVisible || iItem> iFirstVisible+nVisibleItems-1)
{
int nOffset=GetScrollPos(TRUE);
if(iItem<iFirstVisible) nOffset=(iItem-iFirstVisible)*m_nItemHei;
else nOffset=(iItem - iFirstVisible-nVisibleItems +1)*m_nItemHei;
nOffset-=nOffset%m_nItemHei;//让当前行刚好显示
OnScroll(TRUE,SB_THUMBPOSITION,nOffset + GetScrollPos(TRUE));
}
}
void SkeinWindow::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
if (pScrollBar != NULL && pScrollBar->SendChildNotifyLastMsg())
return;
if (pScrollBar == NULL)
{
if ((nSBCode == SB_THUMBPOSITION) || (nSBCode == SB_THUMBTRACK))
{
SCROLLINFO scroll;
::ZeroMemory(&scroll,sizeof scroll);
scroll.cbSize = sizeof scroll;
GetScrollInfo(SB_HORZ,&scroll);
nPos = scroll.nTrackPos;
}
OnScroll(MAKEWORD(nSBCode,0xFF),nPos);
}
}
void CDuiListBox::EnsureVisible(int nIndex)
{
if(nIndex < 0 || nIndex >= GetCount()) return;
CRect rcClient;
GetClient(&rcClient);
int iFirstVisible = (m_ptOrigin.y + m_nItemHei -1) / m_nItemHei;
int nVisibleItems = rcClient.Height() / m_nItemHei;
if(nIndex < iFirstVisible || nIndex > iFirstVisible+nVisibleItems-1)
{
int nOffset = GetScrollPos(TRUE);
if(nIndex < iFirstVisible) nOffset = (nIndex-iFirstVisible)*m_nItemHei;
else nOffset=(nIndex - iFirstVisible-nVisibleItems +1)*m_nItemHei;
nOffset-=nOffset%m_nItemHei;//让当前行刚好显示
OnScroll(TRUE,SB_THUMBPOSITION,nOffset + GetScrollPos(TRUE));
}
}
void PlacesOverlayVScrollBar::StartScrollAnimation(ScrollDir dir, int stop)
{
if (animation_.CurrentState() == nux::animation::Animation::State::Stopped)
{
SetupAnimation(0, stop, SCROLL_ANIMATION);
tweening_connection_ = animation_.updated.connect([this, dir] (int const& update) {
OnScroll(dir, update - delta_update_);
delta_update_ = update;
CheckIfThumbIsInsideSlider();
UpdateConnectorPosition();
QueueDraw();
});
animation_.Start();
}
}
FX_BOOL CFWL_ScrollBarImp::DoScroll(FX_DWORD dwCode, FX_FLOAT fPos) {
switch (dwCode) {
case FWL_SCBCODE_Min:
case FWL_SCBCODE_Max:
case FWL_SCBCODE_PageBackward:
case FWL_SCBCODE_PageForward:
case FWL_SCBCODE_StepBackward:
break;
case FWL_SCBCODE_StepForward:
break;
case FWL_SCBCODE_Pos:
case FWL_SCBCODE_TrackPos:
case FWL_SCBCODE_EndScroll:
break;
default: { return FALSE; }
}
return OnScroll(dwCode, fPos);
}
void AudacityProject::TP_ScrollWindow(double scrollto)
{
int pos = (int) (scrollto * mViewInfo.zoom)
/ mViewInfo.scrollStep;
int max = mHsbar->GetRange() - mHsbar->GetThumbSize();
if (pos > max)
pos = max;
else if (pos < 0)
pos = 0;
mHsbar->SetThumbPosition(pos);
// Call our Scroll method which updates our ViewInfo variables
// to reflect the positions of the scrollbars
wxScrollEvent *dummy = new wxScrollEvent();
OnScroll(*dummy);
delete dummy;
}
/*----------------------------------------------------------------------
* Class: AmayaScrollBar
* Method: OnScrollDown
* Description:
-----------------------------------------------------------------------*/
void AmayaScrollBar::OnScrollDown( wxScrollEvent& event )
{
Document doc;
View view;
FrameToView (m_ParentFrameID, &doc, &view);
if (event.GetOrientation() == wxVERTICAL)
{
TtcPageDown (doc, view);
/* this flag is necessary because 2 events occure when up/down button
is pressed (it's an optimisation)
this hack works because OnLineDown is called before OnScroll,
but becareful the events orders could change in future wxWidgets
releases or can be platform specific
*/
m_IgnoreNextScrollEvent = TRUE;
}
else if (event.GetOrientation() == wxVERTICAL)
OnScroll (event);
}
bool TBScrollContainer::OnEvent(const TBWidgetEvent &ev)
{
if (ev.type == EVENT_TYPE_CHANGED && (ev.target == &m_scrollbar_x || ev.target == &m_scrollbar_y))
{
Invalidate();
OnScroll(m_scrollbar_x.GetValue(), m_scrollbar_y.GetValue());
return true;
}
else if (ev.type == EVENT_TYPE_WHEEL && ev.modifierkeys == TB_MODIFIER_NONE)
{
double old_val = m_scrollbar_y.GetValueDouble();
m_scrollbar_y.SetValueDouble(old_val + ev.delta_y * TBSystem::GetPixelsPerLine());
return m_scrollbar_y.GetValueDouble() != old_val;
}
else if (ev.type == EVENT_TYPE_KEY_DOWN)
{
if (ev.special_key == TB_KEY_LEFT && m_scrollbar_x.CanScrollNegative())
ScrollBySmooth(-TBSystem::GetPixelsPerLine(), 0);
else if (ev.special_key == TB_KEY_RIGHT && m_scrollbar_x.CanScrollPositive())
ScrollBySmooth(TBSystem::GetPixelsPerLine(), 0);
else if (ev.special_key == TB_KEY_UP && m_scrollbar_y.CanScrollNegative())
ScrollBySmooth(0, -TBSystem::GetPixelsPerLine());
else if (ev.special_key == TB_KEY_DOWN && m_scrollbar_y.CanScrollPositive())
ScrollBySmooth(0, TBSystem::GetPixelsPerLine());
else if (ev.special_key == TB_KEY_PAGE_UP && m_scrollbar_y.CanScrollNegative())
ScrollBySmooth(0, -GetPaddingRect().h);
else if (ev.special_key == TB_KEY_PAGE_DOWN && m_scrollbar_y.CanScrollPositive())
ScrollBySmooth(0, GetPaddingRect().h);
else if (ev.special_key == TB_KEY_HOME)
ScrollToSmooth(m_scrollbar_x.GetValue(), 0);
else if (ev.special_key == TB_KEY_END)
ScrollToSmooth(m_scrollbar_x.GetValue(), (int)m_scrollbar_y.GetMaxValue());
else
return false;
return true;
}
return false;
}
/// <summary>
/// Handle windows messages for a class instance
/// </summary>
/// <param name="hWnd">Window message is for</param>
/// <param name="uMsg">Message</param>
/// <param name="wParam">Message data</param>
/// <param name="lParam">Additional message data</param>
LRESULT CameraSettingsViewer::DialogProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_INITDIALOG:
NuiViewer::SetIcon(hWnd);
break;
case WM_COMMAND:
OnCommand(LOWORD(wParam));
break;
// If the titlebar X is clicked, hide the dialog
case WM_CLOSE:
HideView();
break;
case WM_HSCROLL:
OnScroll(GetDlgCtrlID((HWND)lParam));
break;
}
return FALSE;
}
void CDuiItemBox::PageUp()
{
OnScroll(TRUE,SB_PAGEUP,0);
}
// ****************************************************************************
//
// Function Name: RWindowView::OnVScroll( )
//
// Description: Called to do vertical scrolling
//
// Returns: Nothing
//
// Exceptions: None
//
// ****************************************************************************
//
void RWindowView::OnVScroll( UINT nSBCode, int nPos )
{
YIntDimension scrollAmount = OnScroll( m_pVerticalScrollBar, nSBCode, nPos );
ScrollWindow( RRealSize( 0, scrollAmount ) );
}
// ****************************************************************************
//
// Function Name: RWindowView::OnHScroll( )
//
// Description: Called to do horizontal scrolling
//
// Returns: Nothing
//
// Exceptions: None
//
// ****************************************************************************
//
void RWindowView::OnHScroll( UINT nSBCode, int nPos )
{
YIntDimension scrollAmount = OnScroll( m_pHorizontalScrollBar, nSBCode, nPos );
ScrollWindow( RRealSize( scrollAmount, 0 ) );
}
static LRESULT WINAPI MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_CREATE:
{
TEXTMETRICW tm;
HDC hDC = GetDC(hWnd);
/*
* Note that the method with GetObjectW just returns
* the original parameters with which the font was created.
*/
if (GetTextMetricsW(hDC, &tm))
{
Globals.CharWidth = tm.tmMaxCharWidth; // tm.tmAveCharWidth;
Globals.CharHeight = tm.tmHeight + tm.tmExternalLeading;
}
ReleaseDC(hWnd, hDC);
Globals.hMenu = GetMenu(hWnd);
Globals.hWndNext = SetClipboardViewer(hWnd);
// For now, the Help dialog item is disabled because of lacking of HTML support
EnableMenuItem(Globals.hMenu, CMD_HELP, MF_BYCOMMAND | MF_GRAYED);
UpdateLinesToScroll(&Scrollstate);
UpdateDisplayMenu();
SetDisplayFormat(0);
DragAcceptFiles(hWnd, TRUE);
break;
}
case WM_CLOSE:
{
DestroyWindow(hWnd);
break;
}
case WM_DESTROY:
{
ChangeClipboardChain(hWnd, Globals.hWndNext);
if (Globals.uDisplayFormat == CF_OWNERDISPLAY)
{
HGLOBAL hglb;
PRECT prc;
hglb = GlobalAlloc(GMEM_MOVEABLE, sizeof(*prc));
if (hglb)
{
prc = GlobalLock(hglb);
SetRectEmpty(prc);
GlobalUnlock(hglb);
SendClipboardOwnerMessage(TRUE, WM_SIZECLIPBOARD,
(WPARAM)hWnd, (LPARAM)hglb);
GlobalFree(hglb);
}
}
PostQuitMessage(0);
break;
}
case WM_PAINT:
{
OnPaint(hWnd, wParam, lParam);
break;
}
case WM_KEYDOWN:
{
OnKeyScroll(hWnd, wParam, lParam, &Scrollstate);
break;
}
case WM_MOUSEWHEEL:
case WM_MOUSEHWHEEL:
{
OnMouseScroll(hWnd, uMsg, wParam, lParam, &Scrollstate);
break;
}
case WM_HSCROLL:
{
// NOTE: Windows uses an offset of 16 pixels
OnScroll(hWnd, SB_HORZ, wParam, 5, &Scrollstate);
break;
}
case WM_VSCROLL:
{
// NOTE: Windows uses an offset of 16 pixels
OnScroll(hWnd, SB_VERT, wParam, 5, &Scrollstate);
break;
}
case WM_SIZE:
{
RECT rc;
if (Globals.uDisplayFormat == CF_OWNERDISPLAY)
{
HGLOBAL hglb;
PRECT prc;
hglb = GlobalAlloc(GMEM_MOVEABLE, sizeof(*prc));
if (hglb)
{
prc = GlobalLock(hglb);
if (wParam == SIZE_MINIMIZED)
SetRectEmpty(prc);
else
GetClientRect(hWnd, prc);
GlobalUnlock(hglb);
SendClipboardOwnerMessage(TRUE, WM_SIZECLIPBOARD,
(WPARAM)hWnd, (LPARAM)hglb);
GlobalFree(hglb);
}
break;
}
GetClipboardDataDimensions(Globals.uDisplayFormat, &rc);
UpdateWindowScrollState(hWnd, rc.right, rc.bottom, &Scrollstate);
// NOTE: There still are little problems drawing
// the background when displaying clipboard text.
if (!IsClipboardFormatSupported(Globals.uDisplayFormat) ||
Globals.uDisplayFormat == CF_DSPTEXT ||
Globals.uDisplayFormat == CF_TEXT ||
Globals.uDisplayFormat == CF_OEMTEXT ||
Globals.uDisplayFormat == CF_UNICODETEXT)
{
InvalidateRect(Globals.hMainWnd, NULL, TRUE);
}
else
{
InvalidateRect(Globals.hMainWnd, NULL, FALSE);
}
break;
}
case WM_CHANGECBCHAIN:
{
/* Transmit through the clipboard viewer chain */
if ((HWND)wParam == Globals.hWndNext)
{
Globals.hWndNext = (HWND)lParam;
}
else if (Globals.hWndNext != NULL)
{
SendMessageW(Globals.hWndNext, uMsg, wParam, lParam);
}
break;
}
case WM_DESTROYCLIPBOARD:
break;
case WM_RENDERALLFORMATS:
{
/*
* When the user has cleared the clipboard via the DELETE command,
* we (clipboard viewer) become the clipboard owner. When we are
* subsequently closed, this message is then sent to us so that
* we get a chance to render everything we can. Since we don't have
* anything to render, just empty the clipboard.
*/
DeleteClipboardContent();
break;
}
case WM_RENDERFORMAT:
// TODO!
break;
case WM_DRAWCLIPBOARD:
{
UpdateDisplayMenu();
SetDisplayFormat(0);
/* Pass the message to the next window in clipboard viewer chain */
SendMessageW(Globals.hWndNext, uMsg, wParam, lParam);
break;
}
case WM_COMMAND:
{
if ((LOWORD(wParam) > CMD_AUTOMATIC))
{
SetDisplayFormat(LOWORD(wParam) - CMD_AUTOMATIC);
}
else
{
OnCommand(hWnd, uMsg, wParam, lParam);
}
break;
}
case WM_INITMENUPOPUP:
{
InitMenuPopup((HMENU)wParam, lParam);
break;
}
case WM_DROPFILES:
{
LoadClipboardFromDrop((HDROP)wParam);
break;
}
case WM_PALETTECHANGED:
{
/* Ignore if this comes from ourselves */
if ((HWND)wParam == hWnd)
break;
/* Fall back to WM_QUERYNEWPALETTE */
}
case WM_QUERYNEWPALETTE:
{
BOOL Success;
HDC hDC;
if (!OpenClipboard(Globals.hMainWnd))
return FALSE;
hDC = GetDC(hWnd);
if (!hDC)
{
CloseClipboard();
return FALSE;
}
Success = RealizeClipboardPalette(hDC);
ReleaseDC(hWnd, hDC);
CloseClipboard();
if (Success)
{
InvalidateRect(hWnd, NULL, TRUE);
UpdateWindow(hWnd);
return TRUE;
}
return FALSE;
}
case WM_SYSCOLORCHANGE:
{
SetDisplayFormat(Globals.uDisplayFormat);
break;
}
case WM_SETTINGCHANGE:
{
if (wParam == SPI_SETWHEELSCROLLLINES)
{
UpdateLinesToScroll(&Scrollstate);
}
break;
}
default:
{
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
}
return 0;
}
BOOL CGraphListCtrl::OnMouseWheel( UINT nFlags, short zDelta, CPoint pt )
{
OnScroll(nFlags, zDelta);
return TRUE;
}
void CScrView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
OnScroll(MAKEWORD(nSBCode, -1), nPos);
}
void IScrollMathModel::ScrollTo(Point2F offset)
{
mCurrentWindow.Origin = mInitialOffset + offset;
OnRestrictScroll();
OnScroll();
}
void CScrView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
OnScroll(MAKEWORD(-1, nSBCode), nPos);
}
void CDuiItemBox::PageDown()
{
OnScroll(TRUE,SB_PAGEDOWN,0);
}
bool TBEditField::OnEvent(const TBWidgetEvent &ev)
{
if (ev.type == EVENT_TYPE_CHANGED && ev.target == &m_scrollbar_x)
{
m_style_edit.SetScrollPos(m_scrollbar_x.GetValue(), m_style_edit.scroll_y);
OnScroll(m_scrollbar_x.GetValue(), m_style_edit.scroll_y);
return true;
}
else if (ev.type == EVENT_TYPE_CHANGED && ev.target == &m_scrollbar_y)
{
m_style_edit.SetScrollPos(m_style_edit.scroll_x, m_scrollbar_y.GetValue());
OnScroll(m_style_edit.scroll_x, m_scrollbar_y.GetValue());
return true;
}
else if (ev.type == EVENT_TYPE_WHEEL && ev.modifierkeys == TB_MODIFIER_NONE)
{
int old_val = m_scrollbar_y.GetValue();
m_scrollbar_y.SetValue(old_val + ev.delta_y * TBSystem::GetPixelsPerLine());
return m_scrollbar_y.GetValue() != old_val;
}
else if (ev.type == EVENT_TYPE_POINTER_DOWN && ev.target == this)
{
TBRect padding_rect = GetPaddingRect();
if (m_style_edit.MouseDown(
TBPoint(ev.target_x - padding_rect.x, ev.target_y - padding_rect.y),
1, ev.count, TB_MODIFIER_NONE, ev.touch))
{
// Post a message to start selection scroll
PostMessageDelayed(TBIDC("selscroll"), nullptr, SELECTION_SCROLL_DELAY);
return true;
}
}
else if (ev.type == EVENT_TYPE_POINTER_MOVE && ev.target == this)
{
TBRect padding_rect = GetPaddingRect();
return m_style_edit.MouseMove(TBPoint(ev.target_x - padding_rect.x, ev.target_y - padding_rect.y));
}
else if (ev.type == EVENT_TYPE_POINTER_UP && ev.target == this)
{
TBRect padding_rect = GetPaddingRect();
return m_style_edit.MouseUp(TBPoint(ev.target_x - padding_rect.x, ev.target_y - padding_rect.y),
1, TB_MODIFIER_NONE, ev.touch);
}
else if (ev.type == EVENT_TYPE_KEY_DOWN)
{
return m_style_edit.KeyDown(ev.key, ev.special_key, ev.modifierkeys);
}
else if (ev.type == EVENT_TYPE_KEY_UP)
{
return true;
}
else if ((ev.type == EVENT_TYPE_CLICK && ev.target->GetID() == TBIDC("popupmenu")) ||
(ev.type == EVENT_TYPE_SHORTCUT))
{
if (ev.ref_id == TBIDC("cut") && !m_style_edit.packed.read_only)
m_style_edit.Cut();
else if (ev.ref_id == TBIDC("copy"))
m_style_edit.Copy();
else if (ev.ref_id == TBIDC("paste") && !m_style_edit.packed.read_only)
m_style_edit.Paste();
else if (ev.ref_id == TBIDC("delete") && !m_style_edit.packed.read_only)
m_style_edit.Delete();
else if (ev.ref_id == TBIDC("undo") && !m_style_edit.packed.read_only)
m_style_edit.Undo();
else if (ev.ref_id == TBIDC("redo") && !m_style_edit.packed.read_only)
m_style_edit.Redo();
else if (ev.ref_id == TBIDC("selectall"))
m_style_edit.selection.SelectAll();
else
return false;
return true;
}
else if (ev.type == EVENT_TYPE_CONTEXT_MENU && ev.target == this)
{
TBPoint pos_in_root(ev.target_x, ev.target_y);
ev.target->ConvertToRoot(pos_in_root.x, pos_in_root.y);
if (TBMenuWindow *menu = new TBMenuWindow(ev.target, TBIDC("popupmenu")))
{
TBGenericStringItemSource *source = menu->GetList()->GetDefaultSource();
source->AddItem(new TBGenericStringItem(g_tb_lng->GetString(TBIDC("cut")), TBIDC("cut")));
source->AddItem(new TBGenericStringItem(g_tb_lng->GetString(TBIDC("copy")), TBIDC("copy")));
source->AddItem(new TBGenericStringItem(g_tb_lng->GetString(TBIDC("paste")), TBIDC("paste")));
source->AddItem(new TBGenericStringItem(g_tb_lng->GetString(TBIDC("delete")), TBIDC("delete")));
source->AddItem(new TBGenericStringItem("-"));
source->AddItem(new TBGenericStringItem(g_tb_lng->GetString(TBIDC("selectall")), TBIDC("selectall")));
menu->Show(source, TBPopupAlignment(pos_in_root), -1);
}
return true;
}
return false;
}
void isColorPickerDlg::bSliderScroll(wxScrollEvent& event) { OnScroll(bSlider, bText); }
