void wxRibbonGallery::OnMouseUp(wxMouseEvent& evt)
{
if(m_mouse_active_rect != NULL)
{
wxPoint pos = evt.GetPosition();
if(m_active_item)
{
if(m_art && m_art->GetFlags() & wxRIBBON_BAR_FLOW_VERTICAL)
pos.x += m_scroll_amount;
else
pos.y += m_scroll_amount;
}
if(m_mouse_active_rect->Contains(pos))
{
if(m_mouse_active_rect == &m_scroll_up_button_rect)
{
m_up_button_state = wxRIBBON_GALLERY_BUTTON_HOVERED;
ScrollLines(-1);
}
else if(m_mouse_active_rect == &m_scroll_down_button_rect)
{
m_down_button_state = wxRIBBON_GALLERY_BUTTON_HOVERED;
ScrollLines(1);
}
else if(m_mouse_active_rect == &m_extension_button_rect)
{
m_extension_button_state = wxRIBBON_GALLERY_BUTTON_HOVERED;
wxCommandEvent notification(wxEVT_BUTTON,
GetId());
notification.SetEventObject(this);
ProcessWindowEvent(notification);
}
else if(m_active_item != NULL)
{
if(m_selected_item != m_active_item)
{
m_selected_item = m_active_item;
wxRibbonGalleryEvent notification(
wxEVT_RIBBONGALLERY_SELECTED, GetId());
notification.SetEventObject(this);
notification.SetGallery(this);
notification.SetGalleryItem(m_selected_item);
ProcessWindowEvent(notification);
}
wxRibbonGalleryEvent notification(
wxEVT_RIBBONGALLERY_CLICKED, GetId());
notification.SetEventObject(this);
notification.SetGallery(this);
notification.SetGalleryItem(m_selected_item);
ProcessWindowEvent(notification);
}
}
m_mouse_active_rect = NULL;
m_active_item = NULL;
Refresh(false);
}
}
void wxRibbonButtonBar::UpdateWindowUI(long flags)
{
wxWindowBase::UpdateWindowUI(flags);
// don't waste time updating state of tools in a hidden toolbar
if ( !IsShown() )
return;
size_t btn_count = m_buttons.size();
bool rerealize = false;
for ( size_t btn_i = 0; btn_i < btn_count; ++btn_i )
{
wxRibbonButtonBarButtonBase& btn = *m_buttons.Item(btn_i);
int id = btn.id;
wxUpdateUIEvent event(id);
event.SetEventObject(this);
if ( ProcessWindowEvent(event) )
{
if ( event.GetSetEnabled() )
EnableButton(id, event.GetEnabled());
if ( event.GetSetChecked() )
ToggleButton(id, event.GetChecked());
if ( event.GetSetText() )
{
btn.label = event.GetText();
rerealize = true;
}
}
}
if ( rerealize )
Realize();
}
// Handle event from scrollbars
void wxWindowQt::QtOnScrollBarEvent( wxScrollEvent& event )
{
wxEventType windowEventType = 0;
// Map the scroll bar event to the corresponding scroll window event:
wxEventType scrollBarEventType = event.GetEventType();
if ( scrollBarEventType == wxEVT_SCROLL_TOP )
windowEventType = wxEVT_SCROLLWIN_TOP;
else if ( scrollBarEventType == wxEVT_SCROLL_BOTTOM )
windowEventType = wxEVT_SCROLLWIN_BOTTOM;
else if ( scrollBarEventType == wxEVT_SCROLL_PAGEUP )
windowEventType = wxEVT_SCROLLWIN_PAGEUP;
else if ( scrollBarEventType == wxEVT_SCROLL_PAGEDOWN )
windowEventType = wxEVT_SCROLLWIN_PAGEDOWN;
else if ( scrollBarEventType == wxEVT_SCROLL_LINEUP )
windowEventType = wxEVT_SCROLLWIN_LINEUP;
else if ( scrollBarEventType == wxEVT_SCROLL_LINEDOWN )
windowEventType = wxEVT_SCROLLWIN_LINEDOWN;
else if ( scrollBarEventType == wxEVT_SCROLL_THUMBTRACK )
windowEventType = wxEVT_SCROLLWIN_THUMBTRACK;
else if ( scrollBarEventType == wxEVT_SCROLL_THUMBRELEASE )
windowEventType = wxEVT_SCROLLWIN_THUMBRELEASE;
if ( windowEventType != 0 )
{
wxScrollWinEvent e( windowEventType, event.GetPosition(), event.GetOrientation() );
ProcessWindowEvent( e );
}
}
void OnMouseClick(wxMouseEvent&)
{
wxCommandEvent event(EVT_SUGGESTION_SELECTED);
event.SetEventObject(this);
event.SetString(m_value.text);
ProcessWindowEvent(event);
}
void CTimeBarFrame::RClickOnFrame(int nFrameIndex)
{
wxCommandEvent itemContainerRClickEvent(TIMTBAR_ITEMCONTAINERRCLICK_EVENT, GetId());
itemContainerRClickEvent.SetInt(nFrameIndex);
itemContainerRClickEvent.SetEventObject(this);
ProcessWindowEvent(itemContainerRClickEvent);
}
void wxRibbonToolBar::UpdateWindowUI(long flags)
{
wxWindowBase::UpdateWindowUI(flags);
// don't waste time updating state of tools in a hidden toolbar
if ( !IsShown() )
return;
size_t group_count = m_groups.GetCount();
size_t g, t;
for(g = 0; g < group_count; ++g)
{
wxRibbonToolBarToolGroup* group = m_groups.Item(g);
size_t tool_count = group->tools.GetCount();
for(t = 0; t < tool_count; ++t)
{
wxRibbonToolBarToolBase* tool = group->tools.Item(t);
int id = tool->id;
wxUpdateUIEvent event(id);
event.SetEventObject(this);
if ( ProcessWindowEvent(event) )
{
if ( event.GetSetEnabled() )
EnableTool(id, event.GetEnabled());
if ( event.GetSetChecked() )
ToggleTool(id, event.GetChecked());
}
}
}
}
/* CTextureCanvas::onMouseEvent
* Called when and mouse event is generated (movement/clicking/etc)
*******************************************************************/
void CTextureCanvas::onMouseEvent(wxMouseEvent& e)
{
bool refresh = false;
// MOUSE MOVEMENT
if (e.Moving() || e.Dragging())
{
dragging = false;
// Pan if middle button is down
if (e.MiddleIsDown())
{
offset = offset + point2_t(e.GetPosition().x - mouse_prev.x, e.GetPosition().y - mouse_prev.y);
refresh = true;
dragging = true;
}
else if (e.LeftIsDown())
dragging = true;
// Check if patch hilight changes
point2_t pos = screenToTexPosition(e.GetX(), e.GetY());
int patch = patchAt(pos.x, pos.y);
if (hilight_patch != patch)
{
hilight_patch = patch;
refresh = true;
}
}
// LEFT BUTTON UP
else if (e.LeftUp())
{
// If we were dragging, generate end drag event
if (dragging)
{
dragging = false;
updateTexturePreview();
refresh = true;
wxCommandEvent evt(EVT_DRAG_END, GetId());
evt.SetInt(wxMOUSE_BTN_LEFT);
ProcessWindowEvent(evt);
}
}
// LEAVING
if (e.Leaving())
{
// Set no hilighted patch
hilight_patch = -1;
refresh = true;
}
// Refresh is needed
if (refresh)
Refresh();
// Update 'previous' mouse coordinates
mouse_prev.set(e.GetPosition().x, e.GetPosition().y);
}
void
wxTreeListCtrl::OnItemToggled(wxTreeListItem item, wxCheckBoxState stateOld)
{
wxTreeListEvent event(wxEVT_COMMAND_TREELIST_ITEM_CHECKED, this, item);
event.SetOldCheckedState(stateOld);
ProcessWindowEvent(event);
}
void SToolBar::onButtonClick(wxCommandEvent& e)
{
// See SToolBarGroup::onButtonClicked
wxCommandEvent ev(wxEVT_STOOLBAR_BUTTON_CLICKED, GetId());
ev.SetEventObject(this);
ev.SetString(e.GetString());
ProcessWindowEvent(ev);
}
void wxRibbonGallery::OnMouseMove(wxMouseEvent& evt)
{
bool refresh = false;
wxPoint pos = evt.GetPosition();
if(TestButtonHover(m_scroll_up_button_rect, pos, &m_up_button_state))
refresh = true;
if(TestButtonHover(m_scroll_down_button_rect, pos, &m_down_button_state))
refresh = true;
if(TestButtonHover(m_extension_button_rect, pos, &m_extension_button_state))
refresh = true;
wxRibbonGalleryItem *hovered_item = NULL;
wxRibbonGalleryItem *active_item = NULL;
if(m_client_rect.Contains(pos))
{
if(m_art && m_art->GetFlags() & wxRIBBON_BAR_FLOW_VERTICAL)
pos.x += m_scroll_amount;
else
pos.y += m_scroll_amount;
size_t item_count = m_items.Count();
size_t item_i;
for(item_i = 0; item_i < item_count; ++item_i)
{
wxRibbonGalleryItem *item = m_items.Item(item_i);
if(!item->IsVisible())
continue;
if(item->GetPosition().Contains(pos))
{
if(m_mouse_active_rect == &item->GetPosition())
active_item = item;
hovered_item = item;
break;
}
}
}
if(active_item != m_active_item)
{
m_active_item = active_item;
refresh = true;
}
if(hovered_item != m_hovered_item)
{
m_hovered_item = hovered_item;
wxRibbonGalleryEvent notification(
wxEVT_RIBBONGALLERY_HOVER_CHANGED, GetId());
notification.SetEventObject(this);
notification.SetGallery(this);
notification.SetGalleryItem(hovered_item);
ProcessWindowEvent(notification);
refresh = true;
}
if(refresh)
Refresh(false);
}
void SToolBarGroup::onButtonClicked(wxCommandEvent& e)
{
// No idea why the event doesn't propagate as it's supposed to,
// shouldn't need to do this
wxCommandEvent ev(wxEVT_STOOLBAR_BUTTON_CLICKED, GetId());
ev.SetEventObject(this);
ev.SetString(e.GetString());
ProcessWindowEvent(ev);
}
void wxRibbonBar::DoMouseButtonCommon(wxMouseEvent& evt, wxEventType tab_event_type)
{
wxRibbonPageTabInfo *tab = HitTestTabs(evt.GetPosition());
if(tab)
{
wxRibbonBarEvent notification(tab_event_type, GetId(), tab->page);
notification.SetEventObject(this);
ProcessWindowEvent(notification);
}
}
void CTimeBarFrame::OnTreeItemEndDrag(wxTreeEvent& event)
{
wxTreeItemId draggingItemId = m_pItemTreeCtrl->GetSelection();
wxTreeItemId targetItemId = event.GetItem();
BEATS_ASSERT(draggingItemId.IsOk() && targetItemId.IsOk());
if (draggingItemId != targetItemId && !IsParentOfItem(draggingItemId, targetItemId))
{
m_pEndDragData = static_cast<CTimeBarFrameData*>(m_pItemTreeCtrl->GetItemData(event.GetItem()));
wxCommandEvent dragEvent(TIMTBAR_DRAGITEMEND_EVENT, GetId());
dragEvent.SetEventObject(this);
ProcessWindowEvent(dragEvent);
}
}
void wxRibbonButtonBar::OnMouseUp(wxMouseEvent& evt)
{
wxPoint cursor(evt.GetPosition());
if(m_active_button)
{
wxRibbonButtonBarButtonSizeInfo& size =
m_active_button->base->sizes[m_active_button->size];
wxRect btn_rect;
btn_rect.SetTopLeft(m_layout_offset + m_active_button->position);
btn_rect.SetSize(size.size);
if(btn_rect.Contains(cursor))
{
int id = m_active_button->base->id;
cursor -= btn_rect.GetTopLeft();
wxEventType event_type;
do
{
if(size.normal_region.Contains(cursor))
event_type = wxEVT_COMMAND_RIBBONBUTTON_CLICKED;
else if(size.dropdown_region.Contains(cursor))
event_type = wxEVT_COMMAND_RIBBONBUTTON_DROPDOWN_CLICKED;
else
break;
wxRibbonButtonBarEvent notification(event_type, id);
if(m_active_button->base->kind == wxRIBBON_BUTTON_TOGGLE)
{
m_active_button->base->state ^=
wxRIBBON_BUTTONBAR_BUTTON_TOGGLED;
notification.SetInt(m_active_button->base->state &
wxRIBBON_BUTTONBAR_BUTTON_TOGGLED);
}
notification.SetEventObject(this);
notification.SetBar(this);
notification.SetButton(m_active_button->base);
m_lock_active_state = true;
ProcessWindowEvent(notification);
m_lock_active_state = false;
wxStaticCast(m_parent, wxRibbonPanel)->HideIfExpanded();
} while(false);
if(m_active_button) // may have been NULLed by event handler
{
m_active_button->base->state &= ~wxRIBBON_BUTTONBAR_BUTTON_ACTIVE_MASK;
m_active_button = NULL;
}
Refresh(false);
}
}
}
void wxTreeListCtrl::SendItemEvent(wxEventType evt, wxDataViewEvent& eventDV)
{
wxTreeListEvent eventTL(evt, this, m_model->FromDVI(eventDV.GetItem()));
if ( !ProcessWindowEvent(eventTL) )
{
eventDV.Skip();
return;
}
if ( !eventTL.IsAllowed() )
{
eventDV.Veto();
}
}
void wxTreeListCtrl::SendColumnEvent(wxEventType evt, wxDataViewEvent& eventDV)
{
wxTreeListEvent eventTL(evt, this, wxTreeListItem());
eventTL.SetColumn(eventDV.GetColumn());
if ( !ProcessWindowEvent(eventTL) )
{
eventDV.Skip();
return;
}
if ( !eventTL.IsAllowed() )
{
eventDV.Veto();
}
}
void CTimeBarFrame::OnTreeItemStartDrag(wxTreeEvent& event)
{
m_pBeginDragData = static_cast<CTimeBarFrameData*>(m_pItemTreeCtrl->GetItemData(event.GetItem()));
BEATS_ASSERT(m_pBeginDragData != NULL)
if (m_pBeginDragData->GetId() != m_pItemTreeCtrl->GetRootItem())
{
m_pItemTreeCtrl->SelectItem(event.GetItem());
if (m_bEnableDrag)
{
wxCommandEvent dragEvent(TIMTBAR_DRAGITEMBEGIN_EVENT, GetId());
dragEvent.SetEventObject(this);
ProcessWindowEvent(dragEvent);
event.Allow();
}
}
}
void MyFrame::OnColourGalleryButton(wxCommandEvent& evt)
{
wxRibbonGallery *gallery = wxDynamicCast(evt.GetEventObject(), wxRibbonGallery);
if(gallery == NULL)
return;
m_ribbon->DismissExpandedPanel();
if(gallery->GetSelection())
m_colour_data.SetColour(GetGalleryColour(gallery, gallery->GetSelection(), NULL));
wxColourDialog dlg(this, &m_colour_data);
if(dlg.ShowModal() == wxID_OK)
{
m_colour_data = dlg.GetColourData();
wxColour clr = m_colour_data.GetColour();
// Try to find colour in gallery
wxRibbonGalleryItem *item = NULL;
for(unsigned int i = 0; i < gallery->GetCount(); ++i)
{
item = gallery->GetItem(i);
if(GetGalleryColour(gallery, item, NULL) == clr)
break;
else
item = NULL;
}
// Colour not in gallery - add it
if(item == NULL)
{
item = AddColourToGallery(gallery,
clr.GetAsString(wxC2S_HTML_SYNTAX), m_bitmap_creation_dc,
&clr);
gallery->Realise();
}
// Set selection
gallery->EnsureVisible(item);
gallery->SetSelection(item);
// Send an event to respond to the selection change
wxRibbonGalleryEvent dummy(wxEVT_RIBBONGALLERY_SELECTED, gallery->GetId());
dummy.SetEventObject(gallery);
dummy.SetGallery(gallery);
dummy.SetGalleryItem(item);
ProcessWindowEvent(dummy);
}
}
void BatchProcessDialog::OnCancel(wxCommandEvent & WXUNUSED(event))
{
#if !defined(__WXMAC__)
// It is possible that we could just do EndModal()
// here even on Linux. However, we know the alternative way of
// closing works, if we are hidden, so we hide and then do that.
Hide();
// Under Linux an EndModal() here potentially crashes (Bug #1221).
// But sending a close message instead is OK.
wxCloseEvent Evt;
Evt.SetId( wxID_CANCEL );
Evt.SetEventObject( this);
ProcessWindowEvent( Evt );
#else
EndModal(wxID_CANCEL);
#endif
}
void CTimeBarFrame::SetCursorPos(int pos, bool bRefresh, bool bSendEvent)
{
int nPos = pos < 0 ? 0 : pos;
if (m_nCursorPos != nPos)
{
m_nCursorPos = nPos;
if (bRefresh)
{
m_pFrameContainer->Refresh(false);
m_pScalebar->Refresh(false);
}
if (bSendEvent)
{
wxCommandEvent cursorChangeEvent(TIMTBAR_CURSORCHANGE_EVENT, GetId());
cursorChangeEvent.SetInt(nPos);
cursorChangeEvent.SetEventObject(this);
ProcessWindowEvent(cursorChangeEvent);
}
}
}
void wxRibbonGallery::OnMouseLeave(wxMouseEvent& WXUNUSED(evt))
{
m_hovered = false;
m_active_item = NULL;
if(m_up_button_state != wxRIBBON_GALLERY_BUTTON_DISABLED)
m_up_button_state = wxRIBBON_GALLERY_BUTTON_NORMAL;
if(m_down_button_state != wxRIBBON_GALLERY_BUTTON_DISABLED)
m_down_button_state = wxRIBBON_GALLERY_BUTTON_NORMAL;
if(m_extension_button_state != wxRIBBON_GALLERY_BUTTON_DISABLED)
m_extension_button_state = wxRIBBON_GALLERY_BUTTON_NORMAL;
if(m_hovered_item != NULL)
{
m_hovered_item = NULL;
wxRibbonGalleryEvent notification(
wxEVT_RIBBONGALLERY_HOVER_CHANGED, GetId());
notification.SetEventObject(this);
notification.SetGallery(this);
ProcessWindowEvent(notification);
}
Refresh(false);
}
void TileSetPanel::OnLeftButtonPressed(wxMouseEvent& event)
{
if (!m_tileset || m_tileset->IsDirty())
return;
wxPoint mousePos = CalcUnscrolledPosition(event.GetPosition());
//Select the tile
int selectedCol, selectedRow;
GetTileAt(mousePos, selectedCol, selectedRow);
if (selectedCol >= m_tileset->GetColumnsCount() || selectedRow >= m_tileset->GetRowsCount())
return;
m_selectedCol = selectedCol;
m_selectedRow = selectedRow;
//Send the event
TileSelectionEvent newEvent(TILE_SELECTION_CHANGED, GetId(), m_tileset->GetTileIDFromCell(m_selectedCol, m_selectedRow));
newEvent.SetEventObject(this);
ProcessWindowEvent(newEvent);
Refresh();
}
// ----------------------------------------------------------------------------
// ArchiveEntryList::setDir
//
// Opens the given directory (if it exists)
// ----------------------------------------------------------------------------
bool ArchiveEntryList::setDir(ArchiveTreeNode* dir)
{
// If it doesn't exist, do nothing
if (!dir)
return false;
// Set current dir
current_dir = dir;
// Clear current selection
clearSelection();
// Update filter
applyFilter();
// Update list
updateList();
// Fire event
wxCommandEvent evt(EVT_AEL_DIR_CHANGED, GetId());
ProcessWindowEvent(evt);
return true;
}
void
DirectFB_PumpEventsWindow(_THIS)
{
SDL_DFB_DEVICEDATA(_this);
DFB_WindowData *p;
DFBInputEvent ievt;
for (p = devdata->firstwin; p != NULL; p = p->next) {
DFBWindowEvent evt;
SDL_Window *w = p->sdl_window;
while (p->eventbuffer->GetEvent(p->eventbuffer,
DFB_EVENT(&evt)) == DFB_OK) {
if (!DirectFB_WM_ProcessEvent(_this, w, &evt))
ProcessWindowEvent(_this, p, w->flags, &evt);
}
}
/* Now get relative events in case we need them */
while (devdata->events->GetEvent(devdata->events,
DFB_EVENT(&ievt)) == DFB_OK) {
ProcessInputEvent(_this, &ievt);
}
}
void SDLApplication::HandleEvent (SDL_Event* event) {
switch (event->type) {
case SDL_USEREVENT:
currentUpdate = SDL_GetTicks ();
applicationEvent.type = UPDATE;
applicationEvent.deltaTime = currentUpdate - lastUpdate;
lastUpdate = currentUpdate;
nextUpdate += framePeriod;
while (nextUpdate <= currentUpdate) {
nextUpdate += framePeriod;
}
ApplicationEvent::Dispatch (&applicationEvent);
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_APP_WILLENTERBACKGROUND:
windowEvent.type = WINDOW_DEACTIVATE;
WindowEvent::Dispatch (&windowEvent);
break;
case SDL_APP_WILLENTERFOREGROUND:
windowEvent.type = WINDOW_ACTIVATE;
WindowEvent::Dispatch (&windowEvent);
break;
case SDL_CONTROLLERAXISMOTION:
case SDL_CONTROLLERBUTTONDOWN:
case SDL_CONTROLLERBUTTONUP:
case SDL_CONTROLLERDEVICEADDED:
case SDL_CONTROLLERDEVICEREMOVED:
ProcessGamepadEvent (event);
break;
case SDL_DROPFILE:
ProcessDropEvent (event);
break;
case SDL_FINGERMOTION:
case SDL_FINGERDOWN:
case SDL_FINGERUP:
#ifndef HX_MACOS
ProcessTouchEvent (event);
#endif
break;
case SDL_JOYAXISMOTION:
if (SDLJoystick::IsAccelerometer (event->jaxis.which)) {
ProcessSensorEvent (event);
} else {
ProcessJoystickEvent (event);
}
break;
case SDL_JOYBALLMOTION:
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
case SDL_JOYHATMOTION:
case SDL_JOYDEVICEADDED:
case SDL_JOYDEVICEREMOVED:
ProcessJoystickEvent (event);
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
ProcessKeyEvent (event);
break;
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEWHEEL:
ProcessMouseEvent (event);
break;
case SDL_TEXTINPUT:
case SDL_TEXTEDITING:
ProcessTextEvent (event);
break;
case SDL_WINDOWEVENT:
switch (event->window.event) {
case SDL_WINDOWEVENT_ENTER:
case SDL_WINDOWEVENT_LEAVE:
case SDL_WINDOWEVENT_SHOWN:
case SDL_WINDOWEVENT_HIDDEN:
case SDL_WINDOWEVENT_FOCUS_GAINED:
case SDL_WINDOWEVENT_FOCUS_LOST:
case SDL_WINDOWEVENT_MINIMIZED:
case SDL_WINDOWEVENT_MOVED:
case SDL_WINDOWEVENT_RESTORED:
ProcessWindowEvent (event);
break;
case SDL_WINDOWEVENT_EXPOSED:
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
ProcessWindowEvent (event);
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_WINDOWEVENT_CLOSE:
ProcessWindowEvent (event);
break;
}
break;
case SDL_QUIT:
active = false;
break;
}
}
void CTimeBarFrame::OnMinusBtnClicked(wxCommandEvent& /*event*/)
{
wxCommandEvent minusButtonClickEvent(TIMTBAR_MINUSBUTTONCLICK_EVENT, GetId());
minusButtonClickEvent.SetEventObject(this);
ProcessWindowEvent(minusButtonClickEvent);
}
void SDLApplication::HandleEvent (SDL_Event* event) {
switch (event->type) {
case SDL_USEREVENT:
currentUpdate = SDL_GetTicks ();
updateEvent.deltaTime = currentUpdate - lastUpdate;
lastUpdate = currentUpdate;
while (nextUpdate <= currentUpdate) {
nextUpdate += framePeriod;
}
UpdateEvent::Dispatch (&updateEvent);
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_APP_WILLENTERBACKGROUND:
windowEvent.type = WINDOW_DEACTIVATE;
WindowEvent::Dispatch (&windowEvent);
break;
case SDL_APP_WILLENTERFOREGROUND:
windowEvent.type = WINDOW_ACTIVATE;
WindowEvent::Dispatch (&windowEvent);
break;
case SDL_CONTROLLERAXISMOTION:
case SDL_CONTROLLERBUTTONDOWN:
case SDL_CONTROLLERBUTTONUP:
case SDL_CONTROLLERDEVICEADDED:
case SDL_CONTROLLERDEVICEREMOVED:
ProcessGamepadEvent (event);
break;
case SDL_FINGERMOTION:
case SDL_FINGERDOWN:
case SDL_FINGERUP:
ProcessTouchEvent (event);
break;
case SDL_JOYAXISMOTION:
case SDL_JOYBALLMOTION:
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
case SDL_JOYHATMOTION:
case SDL_JOYDEVICEADDED:
case SDL_JOYDEVICEREMOVED:
//joy
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
ProcessKeyEvent (event);
break;
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEWHEEL:
ProcessMouseEvent (event);
break;
case SDL_TEXTINPUT:
case SDL_TEXTEDITING:
ProcessTextEvent (event);
break;
case SDL_WINDOWEVENT:
switch (event->window.event) {
case SDL_WINDOWEVENT_ENTER:
case SDL_WINDOWEVENT_LEAVE:
case SDL_WINDOWEVENT_SHOWN:
case SDL_WINDOWEVENT_HIDDEN:
case SDL_WINDOWEVENT_FOCUS_GAINED:
case SDL_WINDOWEVENT_FOCUS_LOST:
case SDL_WINDOWEVENT_MINIMIZED:
case SDL_WINDOWEVENT_MOVED:
case SDL_WINDOWEVENT_RESTORED:
ProcessWindowEvent (event);
break;
case SDL_WINDOWEVENT_EXPOSED:
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
ProcessWindowEvent (event);
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_WINDOWEVENT_CLOSE:
ProcessWindowEvent (event);
active = false;
break;
}
break;
case SDL_QUIT:
//quit
active = false;
break;
}
}
void BatchProcessDialog::OnApplyToProject(wxCommandEvent & WXUNUSED(event))
{
long item = mChains->GetNextItem(-1,
wxLIST_NEXT_ALL,
wxLIST_STATE_SELECTED);
if (item == -1) {
wxMessageBox(_("No chain selected"));
return;
}
wxString name = mChains->GetItemText(item);
wxDialog * pD = safenew wxDialog(this, wxID_ANY, GetTitle());
pD->SetName(pD->GetTitle());
ShuttleGui S(pD, eIsCreating);
S.StartHorizontalLay(wxCENTER, false);
{
S.StartStatic(wxT(""), false); // deliberately not translated (!)
{
S.SetBorder(20);
S.AddFixedText(wxString::Format(_("Applying '%s' to current project"),
name.c_str()));
}
S.EndStatic();
}
S.EndHorizontalLay();
pD->Layout();
pD->Fit();
pD->CenterOnScreen();
pD->Move(-1, 0);
pD->Show();
// The Hide() on the next line seems to tickle a bug in wx3,
// giving rise to our Bug #1221. The problem is that on Linux
// the 'Hide' converts us from a Modal into a regular dialog,
// as far as closing is concerned. On Linux we can't close with
// EndModal() anymore after this.
Hide();
gPrefs->Write(wxT("/Batch/ActiveChain"), name);
gPrefs->Flush();
mBatchCommands.ReadChain(name);
// The disabler must get deleted before the EndModal() call. Otherwise,
// the menus on OSX will remain disabled.
bool success;
{
wxWindowDisabler wd(pD);
success = mBatchCommands.ApplyChain();
}
if (!success) {
Show();
return;
}
#if !defined(__WXMAC__)
// Under Linux an EndModal() here crashes (Bug #1221).
// But sending a close message instead is OK.
wxCloseEvent Evt;
Evt.SetId( wxID_OK );
Evt.SetEventObject( this);
ProcessWindowEvent( Evt );
#else
EndModal(wxID_OK);
#endif
// Raise myself again, and the parent window with me
Show();
}
void BatchProcessDialog::OnApplyToFiles(wxCommandEvent & WXUNUSED(event))
{
long item = mChains->GetNextItem(-1,
wxLIST_NEXT_ALL,
wxLIST_STATE_SELECTED);
if (item == -1) {
wxMessageBox(_("No chain selected"));
return;
}
wxString name = mChains->GetItemText(item);
gPrefs->Write(wxT("/Batch/ActiveChain"), name);
gPrefs->Flush();
AudacityProject *project = GetActiveProject();
if (!project->GetIsEmpty()) {
wxMessageBox(_("Please save and close the current project first."));
return;
}
wxString path = gPrefs->Read(wxT("/DefaultOpenPath"), ::wxGetCwd());
wxString prompt = _("Select file(s) for batch processing...");
FormatList l;
wxString filter;
wxString all;
Importer::Get().GetSupportedImportFormats(&l);
for (const auto &format : l) {
const Format *f = &format;
wxString newfilter = f->formatName + wxT("|");
for (size_t i = 0; i < f->formatExtensions.size(); i++) {
if (!newfilter.Contains(wxT("*.") + f->formatExtensions[i] + wxT(";")))
newfilter += wxT("*.") + f->formatExtensions[i] + wxT(";");
if (!all.Contains(wxT("*.") + f->formatExtensions[i] + wxT(";")))
all += wxT("*.") + f->formatExtensions[i] + wxT(";");
}
newfilter.RemoveLast(1);
filter += newfilter;
filter += wxT("|");
}
all.RemoveLast(1);
filter.RemoveLast(1);
wxString mask = _("All files|*|All supported files|") +
all + wxT("|") +
filter;
wxString type = gPrefs->Read(wxT("/DefaultOpenType"),mask.BeforeFirst(wxT('|')));
// Convert the type to the filter index
int index = mask.First(type + wxT("|"));
if (index == wxNOT_FOUND) {
index = 0;
}
else {
index = mask.Left(index).Freq(wxT('|')) / 2;
if (index < 0) {
index = 0;
}
}
FileDialog dlog(this,
prompt,
path,
wxT(""),
mask,
wxFD_OPEN | wxFD_MULTIPLE | wxRESIZE_BORDER);
dlog.SetFilterIndex(index);
if (dlog.ShowModal() != wxID_OK) {
return;
}
wxArrayString files;
dlog.GetPaths(files);
files.Sort();
wxDialog * pD = safenew wxDialog(this, wxID_ANY, GetTitle());
pD->SetName(pD->GetTitle());
ShuttleGui S(pD, eIsCreating);
S.StartVerticalLay(false);
{
S.StartStatic(_("Applying..."), 1);
{
wxImageList *imageList = new wxImageList(9, 16);
imageList->Add(wxIcon(empty9x16_xpm));
imageList->Add(wxIcon(arrow_xpm));
S.SetStyle(wxSUNKEN_BORDER | wxLC_REPORT | wxLC_HRULES | wxLC_VRULES |
wxLC_SINGLE_SEL);
mList = S.Id(CommandsListID).AddListControlReportMode();
mList->AssignImageList(imageList, wxIMAGE_LIST_SMALL);
mList->InsertColumn(0, _("File"), wxLIST_FORMAT_LEFT);
}
S.EndStatic();
S.StartHorizontalLay(wxCENTER, false);
{
S.Id(wxID_CANCEL).AddButton(_("&Cancel"));
}
S.EndHorizontalLay();
}
S.EndVerticalLay();
int i;
for (i = 0; i < (int)files.GetCount(); i++ ) {
mList->InsertItem(i, files[i], i == 0);
}
// Set the column size for the files list.
mList->SetColumnWidth(0, wxLIST_AUTOSIZE);
int width = mList->GetColumnWidth(0);
wxSize sz = mList->GetClientSize();
if (width > sz.GetWidth() && width < 500) {
sz.SetWidth(width);
mList->SetInitialSize(sz);
}
pD->Layout();
pD->Fit();
pD->SetSizeHints(pD->GetSize());
pD->CenterOnScreen();
pD->Move(-1, 0);
pD->Show();
Hide();
mBatchCommands.ReadChain(name);
for (i = 0; i < (int)files.GetCount(); i++) {
wxWindowDisabler wd(pD);
if (i > 0) {
//Clear the arrow in previous item.
mList->SetItemImage(i - 1, 0, 0);
}
mList->SetItemImage(i, 1, 1);
mList->EnsureVisible(i);
project->Import(files[i]);
project->OnSelectAll();
if (!mBatchCommands.ApplyChain()) {
break;
}
if (!pD->IsShown() || mAbort) {
break;
}
UndoManager *um = project->GetUndoManager();
um->ClearStates();
project->OnSelectAll();
project->OnRemoveTracks();
}
project->OnRemoveTracks();
// Under Linux an EndModal() here crashes (Bug #1221).
// But sending a close message instead is OK.
#if !defined(__WXMAC__)
wxCloseEvent Evt;
Evt.SetId( wxID_OK );
Evt.SetEventObject( this);
ProcessWindowEvent( Evt );
#else
EndModal(wxID_OK);
#endif
// Raise myself again, and the parent window with me
Show();
}
void wxRibbonBar::OnMouseLeftDown(wxMouseEvent& evt)
{
wxRibbonPageTabInfo *tab = HitTestTabs(evt.GetPosition());
SetFocus();
if ( tab )
{
if ( m_ribbon_state == wxRIBBON_BAR_MINIMIZED )
{
ShowPanels();
m_ribbon_state = wxRIBBON_BAR_EXPANDED;
}
else if ( (tab == &m_pages.Item(m_current_page)) && (m_ribbon_state == wxRIBBON_BAR_EXPANDED) )
{
HidePanels();
m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
}
}
else
{
if ( m_ribbon_state == wxRIBBON_BAR_EXPANDED )
{
HidePanels();
m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
}
}
if(tab && tab != &m_pages.Item(m_current_page))
{
wxRibbonBarEvent query(wxEVT_RIBBONBAR_PAGE_CHANGING, GetId(), tab->page);
query.SetEventObject(this);
ProcessWindowEvent(query);
if(query.IsAllowed())
{
SetActivePage(query.GetPage());
wxRibbonBarEvent notification(wxEVT_RIBBONBAR_PAGE_CHANGED, GetId(), m_pages.Item(m_current_page).page);
notification.SetEventObject(this);
ProcessWindowEvent(notification);
}
}
else if(tab == NULL)
{
if(m_tab_scroll_left_button_rect.Contains(evt.GetPosition()))
{
m_tab_scroll_left_button_state |= wxRIBBON_SCROLL_BTN_ACTIVE | wxRIBBON_SCROLL_BTN_HOVERED;
RefreshTabBar();
}
else if(m_tab_scroll_right_button_rect.Contains(evt.GetPosition()))
{
m_tab_scroll_right_button_state |= wxRIBBON_SCROLL_BTN_ACTIVE | wxRIBBON_SCROLL_BTN_HOVERED;
RefreshTabBar();
}
}
wxPoint position = evt.GetPosition();
if(position.x >= 0 && position.y >= 0)
{
wxSize size = GetSize();
if(position.x < size.GetWidth() && position.y < size.GetHeight())
{
if(m_toggle_button_rect.Contains(position))
{
bool pshown = ArePanelsShown();
ShowPanels(!pshown);
if ( pshown )
m_ribbon_state = wxRIBBON_BAR_MINIMIZED;
else
m_ribbon_state = wxRIBBON_BAR_PINNED;
wxRibbonBarEvent event(wxEVT_RIBBONBAR_TOGGLED, GetId());
event.SetEventObject(this);
ProcessWindowEvent(event);
}
if ( m_help_button_rect.Contains(position) )
{
wxRibbonBarEvent event(wxEVT_RIBBONBAR_HELP_CLICK, GetId());
event.SetEventObject(this);
ProcessWindowEvent(event);
}
}
}
}
