Frame::Frame( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxFrame( parent, id, title, pos, size, style )
{
this->SetSizeHints( wxDefaultSize, wxDefaultSize );
wxBoxSizer* bSizerTop;
bSizerTop = new wxBoxSizer( wxVERTICAL );
m_splitterVert = new wxSplitterWindow( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSP_3D );
m_splitterVert->SetSashGravity( 1 );
m_splitterVert->Connect( wxEVT_IDLE, wxIdleEventHandler( Frame::m_splitterVertOnIdle ), NULL, this );
m_panelLeft = new wxPanel( m_splitterVert, wxID_ANY, wxDefaultPosition, wxSize( -1,-1 ), wxDOUBLE_BORDER|wxTAB_TRAVERSAL );
wxBoxSizer* bSizerLeft;
bSizerLeft = new wxBoxSizer( wxHORIZONTAL );
m_splitterHoriz = new wxSplitterWindow( m_panelLeft, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSP_3D|wxDOUBLE_BORDER );
m_splitterHoriz->SetSashGravity( 1 );
m_splitterHoriz->Connect( wxEVT_IDLE, wxIdleEventHandler( Frame::m_splitterHorizOnIdle ), NULL, this );
m_panelMain = new EdViewPanel( m_splitterHoriz, wxID_ANY, wxDefaultPosition, wxSize( -1,-1 ), wxDOUBLE_BORDER|wxTAB_TRAVERSAL );
m_panelBottom = new wxPanel( m_splitterHoriz, wxID_ANY, wxDefaultPosition, wxSize( -1,100 ), wxDOUBLE_BORDER|wxTAB_TRAVERSAL );
m_splitterHoriz->SplitHorizontally( m_panelMain, m_panelBottom, 559 );
bSizerLeft->Add( m_splitterHoriz, 1, wxEXPAND, 0 );
m_panelLeft->SetSizer( bSizerLeft );
m_panelLeft->Layout();
bSizerLeft->Fit( m_panelLeft );
m_panelRight = new wxPanel( m_splitterVert, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );
wxBoxSizer* bSizerRight;
bSizerRight = new wxBoxSizer( wxVERTICAL );
m_notebook = new wxNotebook( m_panelRight, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0 );
bSizerRight->Add( m_notebook, 1, wxEXPAND | wxALL, 5 );
m_panelRight->SetSizer( bSizerRight );
m_panelRight->Layout();
bSizerRight->Fit( m_panelRight );
m_splitterVert->SplitVertically( m_panelLeft, m_panelRight, -300 );
bSizerTop->Add( m_splitterVert, 1, wxALIGN_BOTTOM|wxEXPAND, 5 );
this->SetSizer( bSizerTop );
this->Layout();
m_statusBar = this->CreateStatusBar( 1, wxST_SIZEGRIP, wxID_ANY );
m_menubar = new wxMenuBar( 0 );
m_menuFile = new wxMenu();
m_menubar->Append( m_menuFile, wxT("File") );
this->SetMenuBar( m_menubar );
m_toolBar = this->CreateToolBar( wxTB_HORIZONTAL, wxID_ANY );
m_toolBar->Realize();
this->Centre( wxBOTH );
// Connect Events
this->Connect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( Frame::OnClose ) );
this->Connect( wxEVT_IDLE, wxIdleEventHandler( Frame::OnIdle ) );
}
void EvtHandlerTestCase::BuiltinConnect()
{
handler.Connect(wxEVT_IDLE, wxIdleEventHandler(MyHandler::OnIdle));
handler.Disconnect(wxEVT_IDLE, wxIdleEventHandler(MyHandler::OnIdle));
handler.Connect(wxEVT_IDLE, wxIdleEventHandler(MyHandler::OnIdle), NULL, &handler);
handler.Disconnect(wxEVT_IDLE, wxIdleEventHandler(MyHandler::OnIdle), NULL, &handler);
// using casts like this is even uglier than using wxIdleEventHandler but
// it should still continue to work for compatibility
handler.Connect(wxEVT_IDLE, (wxObjectEventFunction)(wxEventFunction)&MyHandler::OnIdle);
handler.Disconnect(wxEVT_IDLE, (wxObjectEventFunction)(wxEventFunction)&MyHandler::OnIdle);
#ifdef wxHAS_EVENT_BIND
handler.Bind(wxEVT_IDLE, GlobalOnIdle);
handler.Unbind(wxEVT_IDLE, GlobalOnIdle);
IdleFunctor f;
handler.Bind(wxEVT_IDLE, f);
handler.Unbind(wxEVT_IDLE, f);
handler.Bind(wxEVT_IDLE, &MyHandler::OnIdle, &handler);
handler.Unbind(wxEVT_IDLE, &MyHandler::OnIdle, &handler);
handler.Bind(wxEVT_IDLE, &MyHandler::StaticOnIdle);
handler.Unbind(wxEVT_IDLE, &MyHandler::StaticOnIdle);
#endif // wxHAS_EVENT_BIND
}
void MyApp::activateRenderLoop(bool on) {
if (on && !render_loop_on) {
Connect(wxID_ANY, wxEVT_IDLE, wxIdleEventHandler(MyApp::OnIdle));
render_loop_on = true;
}
else if (!on && render_loop_on) {
Disconnect(wxEVT_IDLE, wxIdleEventHandler(MyApp::OnIdle));
render_loop_on = false;
}
}
void EvtHandlerTestCase::AutoDisconnect()
{
wxEvtHandler source;
{
MyHandler sink;
source.Connect(wxEVT_IDLE, wxIdleEventHandler(MyHandler::OnIdle), NULL, &sink);
// mismatched event type, so nothing should be disconnected
CPPUNIT_ASSERT(!source.Disconnect(wxEVT_THREAD, wxIdleEventHandler(MyHandler::OnIdle), NULL, &sink));
}
// destruction of sink should have automatically disconnected it, so
// there should be nothing to disconnect anymore
CPPUNIT_ASSERT(!source.Disconnect(wxID_ANY, wxEVT_IDLE));
}
Frame::~Frame()
{
// Disconnect Events
this->Disconnect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( Frame::OnClose ) );
this->Disconnect( wxEVT_IDLE, wxIdleEventHandler( Frame::OnIdle ) );
}
MainWindow::MainWindow(const wxString& title, const wxSize& size, long flags)
: wxFrame(NULL, -1, title, wxDefaultPosition, size, flags)
{
wxMenuBar *menuBar = new wxMenuBar;
wxMenu *menuFile = new wxMenu();
menuFile->Append(ID_Open, _("&Open..."));
menuFile->Append(ID_About, _("&About..."));
menuFile->AppendSeparator();
menuFile->Append(ID_Quit, _("E&xit"));
menuBar->Append(menuFile, _("&File"));
wxMenu *menuDebug = new wxMenu();
menuDebug->Append(ID_MemoryView, _("&MemoryView"));
menuBar->Append(menuDebug, _("&Debug"));
SetMenuBar( menuBar );
mach = NULL;
Connect( wxID_ANY, wxEVT_IDLE, wxIdleEventHandler(MainWindow::OnIdle) );
running = true;
//CreateStatusBar();
//SetStatusText( _("Welcome to wxWidgets!") );
}
void IRCChannelPage::createLayout()
{
wxBoxSizer* mainSizer;
mainSizer = new wxBoxSizer( wxHORIZONTAL );
m_splitter = new wxSplitterWindow( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSP_3D );
m_splitter->Connect( wxEVT_IDLE, wxIdleEventHandler( IRCChannelPage::m_splitterOnIdle ), NULL, this );
wxPanel* eventsPanel;
eventsPanel = new wxPanel( m_splitter, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );
wxBoxSizer* eventsSizer;
eventsSizer = new wxBoxSizer( wxVERTICAL );
m_eventsCtrl = new IRCTextCtrl( eventsPanel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY|wxVSCROLL|wxHSCROLL|wxNO_BORDER|wxWANTS_CHARS );
eventsSizer->Add( m_eventsCtrl, 1, wxEXPAND | wxALL, 0 );
eventsPanel->SetSizer( eventsSizer );
eventsPanel->Layout();
eventsSizer->Fit( eventsPanel );
wxPanel* usersPanel;
usersPanel = new wxPanel( m_splitter, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );
wxBoxSizer* usersSizer;
usersSizer = new wxBoxSizer( wxVERTICAL );
m_usersCtrl = new wxListCtrl( usersPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_SINGLE_SEL );
usersSizer->Add( m_usersCtrl, 1, wxALL|wxEXPAND, 0 );
usersPanel->SetSizer( usersSizer );
usersPanel->Layout();
usersSizer->Fit( usersPanel );
m_splitter->SplitVertically( eventsPanel, usersPanel, 0 );
mainSizer->Add( m_splitter, 1, wxEXPAND, 0 );
this->SetSizer( mainSizer );
this->Layout();
}
void SpectraMainFrame::ConnectEventHandlers(void)
{
Connect(
wxID_EXIT,
wxEVT_COMMAND_MENU_SELECTED,
wxCommandEventHandler(SpectraMainFrame::DoClose)
);
Connect(
wxID_OPEN,
wxEVT_COMMAND_MENU_SELECTED,
wxCommandEventHandler(SpectraMainFrame::DoOpenDocument)
);
Connect(
SpectraMainFrameID_GenerateDoc,
wxEVT_COMMAND_MENU_SELECTED,
wxCommandEventHandler(SpectraMainFrame::DoGenerateDocument)
);
Connect(
wxID_ABOUT,
wxEVT_COMMAND_MENU_SELECTED,
wxCommandEventHandler(SpectraMainFrame::DoShowAboutDialog)
);
Connect(
wxEVT_CLOSE_WINDOW,
wxCloseEventHandler(SpectraMainFrame::OnClose)
);
SetExtraStyle(wxWS_EX_PROCESS_IDLE);
wxIdleEvent::SetMode(wxIDLE_PROCESS_SPECIFIED);
Connect(
wxEVT_IDLE,
wxIdleEventHandler(SpectraMainFrame::OnIdle)
);
}
MainFrameBaseClass::~MainFrameBaseClass()
{
this->Disconnect(wxEVT_IDLE, wxIdleEventHandler(MainFrameBaseClass::OnIdle), NULL, this);
this->Disconnect(wxID_CLEAR, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler(MainFrameBaseClass::OnClearView), NULL, this);
this->Disconnect(wxID_CLEAR, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(MainFrameBaseClass::OnClearViewUI), NULL, this);
this->Disconnect(ID_KILL_INFIRIOR, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler(MainFrameBaseClass::OnTerminateInfirior), NULL, this);
this->Disconnect(ID_KILL_INFIRIOR, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(MainFrameBaseClass::OnSignalInferiorUI), NULL, this);
this->Disconnect(ID_KILL_INFIRIOR, wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, wxAuiToolBarEventHandler(MainFrameBaseClass::OnSignalinferior), NULL, this);
this->Disconnect(ID_SETTINGS, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler(MainFrameBaseClass::OnSettings), NULL, this);
this->Disconnect(wxID_SAVE, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler(MainFrameBaseClass::OnSaveContent), NULL, this);
this->Disconnect(wxID_SAVE, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(MainFrameBaseClass::OnSaveContentUI), NULL, this);
m_stc->Disconnect(wxEVT_KEY_DOWN, wxKeyEventHandler(MainFrameBaseClass::OnKeyDown), NULL, this);
m_stc->Disconnect(wxEVT_STC_UPDATEUI, wxStyledTextEventHandler(MainFrameBaseClass::OnStcUpdateUI), NULL, this);
this->Disconnect(m_menuItem7->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MainFrameBaseClass::OnExit), NULL, this);
this->Disconnect(m_menuItem9->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MainFrameBaseClass::OnAbout), NULL, this);
m_timerMarker->Disconnect(wxEVT_TIMER, wxTimerEventHandler(MainFrameBaseClass::OnAddMarker), NULL, this);
std::map<int, wxMenu*>::iterator menuIter = m_dropdownMenus.begin();
for( ; menuIter != m_dropdownMenus.end(); ++menuIter ) {
wxDELETE( menuIter->second );
}
m_dropdownMenus.clear();
m_timerMarker->Stop();
wxDELETE( m_timerMarker );
this->Disconnect(wxID_ANY, wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN, wxAuiToolBarEventHandler(MainFrameBaseClass::ShowAuiToolMenu), NULL, this);
}
/*****************************************************
**
** EphemView --- Constructor
**
******************************************************/
EphemView::EphemView( wxWindow *parent, ChildWindow *frame )
: BasicView( parent, frame, VIEW_EPHEM, true )
{
int dummy;
DateTimeFormatter::get()->calculateDateIntegers( MDate::getCurrentJD(), dummy, month, year );
expert = new EphemExpert( props );
lastmonth = month;
dasaId = D_VIMSOTTARI;
planets = 1;
mode = config->viewprefs->ephemMode;
circleType = config->viewprefs->ephemCircleType;
swidget = (SheetWidget*)NULL;
twidget = (TextWidget*)NULL;
isLocaltime = config->viewprefs->ephemTimezone;
expert->prepareMonth( month, year, isLocaltime );
setDirty();
initToolItems();
initClientView();
Connect( wxEVT_IDLE, wxIdleEventHandler( EphemView::OnIdle ));
Connect( CMD_NOW, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( EphemView::OnNow ));
}
ZoomNavigator::ZoomNavigator(IManager* manager)
: IPlugin(manager)
, mgr(manager)
, zoompane(NULL)
, m_topWindow(NULL)
, m_text(NULL)
, m_markerFirstLine(wxNOT_FOUND)
, m_markerLastLine(wxNOT_FOUND)
, m_enabled(false)
, m_lastLine(wxNOT_FOUND)
, m_startupCompleted(false)
{
m_config = new clConfig("zoom-navigator.conf");
m_longName = _("Zoom Navigator");
m_shortName = wxT("ZoomNavigator");
m_topWindow = m_mgr->GetTheApp();
m_topWindow->Connect(wxEVT_IDLE, wxIdleEventHandler(ZoomNavigator::OnIdle), NULL, this);
EventNotifier::Get()->Connect(wxEVT_INIT_DONE, wxCommandEventHandler(ZoomNavigator::OnInitDone), NULL, this);
EventNotifier::Get()->Connect(wxEVT_FILE_SAVED, clCommandEventHandler(ZoomNavigator::OnFileSaved), NULL, this);
EventNotifier::Get()->Connect(
wxEVT_ZN_SETTINGS_UPDATED, wxCommandEventHandler(ZoomNavigator::OnSettingsChanged), NULL, this);
m_topWindow->Connect(XRCID("zn_settings"),
wxEVT_COMMAND_MENU_SELECTED,
wxCommandEventHandler(ZoomNavigator::OnSettings),
NULL,
this);
EventNotifier::Get()->Bind(wxEVT_SHOW_WORKSPACE_TAB, &ZoomNavigator::OnToggleTab, this);
DoInitialize();
}
ProcessOutput::ProcessOutput( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )
{
this->SetSizeHints( wxDefaultSize, wxDefaultSize );
wxBoxSizer* bSizer5;
bSizer5 = new wxBoxSizer( wxVERTICAL );
m_logoutput = new wxListBox( this, wxID_ANY, wxDefaultPosition, wxSize( 700,300 ), 0, NULL, wxLB_ALWAYS_SB|wxLB_HSCROLL|wxALWAYS_SHOW_SB );
m_logoutput->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 76, 90, 90, false, wxEmptyString ) );
bSizer5->Add( m_logoutput, 1, wxALL|wxEXPAND, 5 );
m_cancel_process = new wxButton( this, wxID_ANY, _("&Terminate updater"), wxDefaultPosition, wxDefaultSize, 0 );
bSizer5->Add( m_cancel_process, 0, wxALL|wxALIGN_CENTER_HORIZONTAL, 5 );
this->SetSizer( bSizer5 );
this->Layout();
bSizer5->Fit( this );
this->Centre( wxBOTH );
// Connect Events
this->Connect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( ProcessOutput::ProcessOutputOnClose ) );
this->Connect( wxEVT_IDLE, wxIdleEventHandler( ProcessOutput::ProcessOutputOnIdle ) );
this->Connect( wxEVT_INIT_DIALOG, wxInitDialogEventHandler( ProcessOutput::ProcessOutputOnInitDialog ) );
m_cancel_process->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( ProcessOutput::m_cancel_processOnButtonClick ), NULL, this );
}
MyDllApp::MyDllApp()
{
// Keep the wx "main" thread running even without windows. This greatly
// simplifies threads handling, because we don't have to correctly
// implement wx-thread restarting.
//
// Note that this only works if you don't explicitly call ExitMainLoop(),
// except in reaction to wx_dll_cleanup()'s message. wx_dll_cleanup()
// relies on the availability of wxApp instance and if the event loop
// terminated, wxEntry() would return and wxApp instance would be
// destroyed.
//
// Also note that this is efficient, because if there are no windows, the
// thread will sleep waiting for a new event. We could safe some memory
// by shutting the thread down when it's no longer needed, though.
SetExitOnFrameDelete(false);
Connect(wxEVT_IDLE, wxIdleEventHandler(MyDllApp::OnIdle));
Connect(CMD_SHOW_WINDOW,
wxEVT_THREAD,
wxThreadEventHandler(MyDllApp::OnShowWindow));
Connect(CMD_TERMINATE,
wxEVT_THREAD,
wxThreadEventHandler(MyDllApp::OnTerminate));
}
void CscopePlugin::OnAttach()
{
// do whatever initialization you need for your plugin
// NOTE: after this function, the inherited member variable
// m_IsAttached will be TRUE...
// You should check for it in other functions, because if it
// is FALSE, it means that the application did *not* "load"
// (see: does not need) this plugin...
m_view = new CscopeView(m_cfg);
//Creates log image
// wxString prefix = ConfigManager::GetDataFolder() + _T("/images/16x16/");
// wxBitmap * bmp = new wxBitmap(cbLoadBitmap(prefix + _T("cscope.png"), wxBITMAP_TYPE_PNG));
CodeBlocksLogEvent evt(cbEVT_ADD_LOG_WINDOW, m_view, _T("Cscope")/*, bmp*/);
Manager::Get()->ProcessEvent(evt);
// Connect(idOnFindSymbol, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(CscopePlugin::OnFind), NULL, (wxEvtHandler*)this);
// Connect(idOnFindSymbol, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(CscopePlugin::OnCscopeUI), NULL, (wxEvtHandler*)this);
// Connect(idOnFindGlobalDefinition, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(CscopePlugin::OnFind), NULL, (wxEvtHandler*)this);
// Connect(idOnFindGlobalDefinition, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(CscopePlugin::OnCscopeUI), NULL, (wxEvtHandler*)this);
Connect(idOnFindFunctionsCalledByThisFuncion, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(CscopePlugin::OnFind), NULL, (wxEvtHandler*)this);
Connect(idOnFindFunctionsCalledByThisFuncion, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(CscopePlugin::OnCscopeUI), NULL, (wxEvtHandler*)this);
Connect(idOnFindFunctionsCallingThisFunction, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(CscopePlugin::OnFind), NULL, (wxEvtHandler*)this);
Connect(idOnFindFunctionsCallingThisFunction, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(CscopePlugin::OnCscopeUI), NULL, (wxEvtHandler*)this);
Connect(wxEVT_END_PROCESS, wxProcessEventHandler(CscopePlugin::OnCscopeReturned), NULL, this);
Connect(wxEVT_IDLE, wxIdleEventHandler(CscopePlugin::OnIdle), NULL, this);
Connect(wxEVT_CSCOPE_THREAD_DONE, wxCommandEventHandler(CscopePlugin::OnParserThreadEnded), NULL, this);
}
CDialogProxyRefreshBase::~CDialogProxyRefreshBase()
{
// Disconnect Events
this->Disconnect( wxEVT_IDLE, wxIdleEventHandler( CDialogProxyRefreshBase::OnIdle ) );
m_btnRefresh->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( CDialogProxyRefreshBase::OnBtnRefreshClick ), NULL, this );
}
bool sQ1App::OnInit()
{
sq1::InitVariables();
// open CAN channel:
if (!sq1::OpenCAN())
return false;
sq1::DriveReset();
sq1::DriveInit();
wxInitAllImageHandlers();
int width = 285;
int height = 540;
MainFrame *pFrame = new MainFrame(wxT("sQ1 Control Panel"), width, height);
wxCmdLineParser parser(argc, argv);
OnInitCmdLine(parser);
parser.Parse();
OnCmdLineParsed(parser);
pFrame->Show(true);
SetTopWindow(pFrame);
Connect( wxID_ANY, wxEVT_IDLE, wxIdleEventHandler(sQ1App::OnIdle) );
return true;
};
void CodeFormatterDlg::OnSplitterIdle(wxIdleEvent& e)
{
long sashPosition(wxNOT_FOUND);
if(EditorConfigST::Get()->GetLongValue(wxT("CodeFormatterDlgSashPos"), sashPosition)) {
m_splitterSettingsPreview->SetSashPosition(sashPosition);
}
m_splitterSettingsPreview->Disconnect( wxEVT_IDLE, wxIdleEventHandler( CodeFormatterDlg::OnSplitterIdle), NULL, this );
}
void DispLoading::onIdle(wxIdleEvent& event)
{
#ifdef WIN32
if (!m_imgAnimation->IsPlaying())
m_imgAnimation->Play();
#endif
Disconnect( wxEVT_IDLE, wxIdleEventHandler( DispLoading::onIdle ) );
}
EventHandler() :
eg(EventGenerator::Get()), m_loop(0), m_count(0), m_watcher(0)
{
m_loop = new wxEventLoop();
Connect(wxEVT_IDLE, wxIdleEventHandler(EventHandler::OnIdle));
Connect(wxEVT_FSWATCHER, wxFileSystemWatcherEventHandler(
EventHandler::OnFileSystemEvent));
}
/*************************************************//**
*
* TextView --- Constructor
*
******************************************************/
TextView::TextView( wxWindow *parent, ChildWindow *frame, const VIEW_ID &viewId, const bool &showToolbar )
: BasicView( parent, frame, viewId, showToolbar )
{
twidget = new TextWidget( this, props );
widget = twidget;
updateView = true;
Connect( wxEVT_IDLE, wxIdleEventHandler( TextView::OnIdle ));
}
ProcessOutput::~ProcessOutput()
{
// Disconnect Events
this->Disconnect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( ProcessOutput::ProcessOutputOnClose ) );
this->Disconnect( wxEVT_IDLE, wxIdleEventHandler( ProcessOutput::ProcessOutputOnIdle ) );
this->Disconnect( wxEVT_INIT_DIALOG, wxInitDialogEventHandler( ProcessOutput::ProcessOutputOnInitDialog ) );
m_cancel_process->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( ProcessOutput::m_cancel_processOnButtonClick ), NULL, this );
}
BaseFrame::~BaseFrame()
{
// Disconnect Events
this->Disconnect( wxEVT_IDLE, wxIdleEventHandler( BaseFrame::OnIdle ) );
m_propertyPlanet->Disconnect( wxEVT_PG_CHANGED, wxPropertyGridEventHandler( BaseFrame::OnPropertyChanged ), NULL, this );
m_mgr.UnInit();
}
ExampleFrame(
wxApp& app,
wxWindow* parent,
const wxString& title,
ExampleInfoDisplay* info_disp,
wxGLContext* context)
: wxFrame(parent, wxID_ANY, title, wxDefaultPosition, wxDefaultSize)
, info_display(info_disp)
, main_panel(
new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize))
, gl_canvas(
new ExampleGLCanvas((wxEvtHandler*)this, (wxWindow*)main_panel))
, gl_context(context)
, frame_no(0)
, fps_frame_no(0)
, fps_time(0.0)
, prim_count(0.0)
, idle_call_count(0) {
assert(info_display);
assert(gl_canvas);
assert(gl_context);
wxBoxSizer* main_sizer = new wxBoxSizer(wxVERTICAL);
main_panel->SetClientSize(800, 600);
main_sizer->Add(main_panel, 1, wxEXPAND);
wxStatusBar* status_bar = new wxStatusBar(this);
main_sizer->Add(status_bar, 0, wxEXPAND);
wxBoxSizer* gl_sizer = new wxBoxSizer(wxVERTICAL);
gl_sizer->Add(gl_canvas, 1, wxEXPAND);
main_panel->SetSizer(gl_sizer);
SetSize(
main_panel->GetSize().GetWidth(),
main_panel->GetSize().GetHeight() +
status_bar->GetSize().GetHeight());
SetSizer(main_sizer);
Layout();
Show();
gl_context->SetCurrent(*gl_canvas);
// TODO: this won't work very well in "UNICODE" builds
oglplus::ExampleParams params(app.argc, (char**)app.argv);
example = oglplus::makeExample(params);
os_clock.reset();
HandleResize();
Connect(wxEVT_CLOSE_WINDOW, wxCloseEventHandler(ExampleFrame::OnClose));
Connect(wxEVT_MOTION, wxMouseEventHandler(ExampleFrame::OnMouseEvent));
Connect(wxEVT_SIZE, wxSizeEventHandler(ExampleFrame::OnResize));
SetExtraStyle(wxWS_EX_PROCESS_IDLE);
wxIdleEvent::SetMode(wxIDLE_PROCESS_SPECIFIED);
Connect(wxEVT_IDLE, wxIdleEventHandler(ExampleFrame::OnIdle));
}
CDialogWlanTestBase::~CDialogWlanTestBase()
{
// Disconnect Events
this->Disconnect( wxEVT_IDLE, wxIdleEventHandler( CDialogWlanTestBase::OnIdle ) );
this->Disconnect( wxEVT_INIT_DIALOG, wxInitDialogEventHandler( CDialogWlanTestBase::OnInitDialog ) );
m_radioBox_TCPUDP->Disconnect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( CDialogWlanTestBase::TCPUDPOnRadioBox ), NULL, this );
m_notebook->Disconnect( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, wxNotebookEventHandler( CDialogWlanTestBase::OnNotebookPageChanged ), NULL, this );
}
CDialogIperfBase::~CDialogIperfBase()
{
// Disconnect Events
this->Disconnect( wxEVT_IDLE, wxIdleEventHandler( CDialogIperfBase::OnIdle ) );
this->Disconnect( wxEVT_INIT_DIALOG, wxInitDialogEventHandler( CDialogIperfBase::OnInitDialog ) );
m_buttonCreate->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( CDialogIperfBase::OnBtnCreateClick ), NULL, this );
m_buttonKill->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( CDialogIperfBase::OnBtnKillClick ), NULL, this );
}
EventHandler(int types = wxFSW_EVENT_ALL) :
eg(EventGenerator::Get()), m_loop(0), m_count(0), m_watcher(0),
m_eventTypes(types)
{
m_loop = new wxEventLoop();
Connect(wxEVT_IDLE, wxIdleEventHandler(EventHandler::OnIdle));
Connect(wxEVT_FSWATCHER, wxFileSystemWatcherEventHandler(
EventHandler::OnFileSystemEvent));
}
wxProgress::~wxProgress()
{
// Disconnect Events
this->Disconnect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( wxProgress::AbortProgress ) );
this->Disconnect( wxEVT_IDLE, wxIdleEventHandler( wxProgress::IdleProgress ) );
BOPause->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxProgress::PauseProgress ), NULL, this );
BOAbort->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxProgress::AbortProgress ), NULL, this );
}
CVideoControlSoft::CVideoControlSoft(wxWindow* parent, wxWindowID id, CWindowMain * windowMain, IVideoInterface * eventPlayer)
: CWindowOpenGLMain("CVideoControl",parent, id)
{
renderBitmapOpenGL = new Regards::Video::CRenderBitmapInterfaceOpenGL(this);
printf("CVideoControl initialisation \n");
#ifdef WIN32
renderBitmapOpenGL->Init(this);
#endif
#ifndef __APPLE__
int argc = 1;
char* argv[1] ={wxString((wxTheApp->argv)[0]).char_str()};
glutInit(&argc, argv);
#endif
widthVideo = 0;
heightVideo = 0;
subtilteUpdate = false;
threadVideo = nullptr;
volumeStart = 64;
old_width = 0;
old_height = 0;
pause = false;
config = nullptr;
angle = 0;
flipV = false;
newVideo = true;
flipH = false;
videoEnd = false;
exit = false;
quitWindow = false;
videoStart = false;
videoRenderStart = false;
pictureSubtitle = nullptr;
video_aspect_ratio = 0.0;
config = CParamInit::getInstance();
Connect(wxEVT_PAINT, wxPaintEventHandler(CVideoControlSoft::OnPaint));
Connect(wxEVT_SIZE, wxSizeEventHandler(CVideoControlSoft::OnSize));
Connect(EVENT_ENDVIDEOTHREAD, wxCommandEventHandler(CVideoControlSoft::EndVideoThread));
Connect(EVENT_VIDEOSTART, wxCommandEventHandler(CVideoControlSoft::VideoStart));
Connect(wxEVT_IDLE, wxIdleEventHandler(CVideoControlSoft::OnIdle));
Connect(EVENT_VIDEOROTATION, wxCommandEventHandler(CVideoControlSoft::VideoRotation));
Connect(wxEVENT_VIDEOREFRESH, wxCommandEventHandler(CVideoControlSoft::OnRefresh));
fpsTimer = new wxTimer(this, TIMER_FPS);
Connect(wxEVT_RIGHT_DOWN, wxMouseEventHandler(CVideoControlSoft::OnRButtonDown));
Connect(TIMER_FPS, wxEVT_TIMER, wxTimerEventHandler(CVideoControlSoft::OnShowFPS), nullptr, this);
pause = false;
videoEnd = true;
this->windowMain = windowMain;
this->eventPlayer = eventPlayer;
openCLEngine = nullptr;
openclContext = nullptr;
openclEffectYUV = nullptr;
}
CDialogIperfBase::CDialogIperfBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )
{
this->SetSizeHints( wxDefaultSize, wxDefaultSize );
wxBoxSizer* bSizer2;
bSizer2 = new wxBoxSizer( wxVERTICAL );
wxBoxSizer* bSizer3;
bSizer3 = new wxBoxSizer( wxHORIZONTAL );
wxBoxSizer* bSizer8;
bSizer8 = new wxBoxSizer( wxVERTICAL );
wxBoxSizer* bSizer312;
bSizer312 = new wxBoxSizer( wxHORIZONTAL );
m_staticText22 = new wxStaticText( this, wxID_ANY, wxT("CMDS:"), wxDefaultPosition, wxDefaultSize, 0 );
m_staticText22->Wrap( -1 );
bSizer312->Add( m_staticText22, 0, wxALL, 8 );
m_textCtrlCmds = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize( 250,-1 ), 0 );
bSizer312->Add( m_textCtrlCmds, 0, wxALL, 5 );
bSizer8->Add( bSizer312, 1, wxEXPAND, 5 );
bSizer3->Add( bSizer8, 1, wxEXPAND, 5 );
wxBoxSizer* bSizer4;
bSizer4 = new wxBoxSizer( wxHORIZONTAL );
m_buttonCreate = new wxButton( this, wxID_ANY, wxT("Create"), wxDefaultPosition, wxDefaultSize, 0 );
m_buttonCreate->SetDefault();
bSizer4->Add( m_buttonCreate, 0, wxALIGN_CENTER|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxALL|wxEXPAND|wxRIGHT, 5 );
m_buttonKill = new wxButton( this, wxID_ANY, wxT("Kill"), wxDefaultPosition, wxDefaultSize, 0 );
m_buttonKill->SetDefault();
bSizer4->Add( m_buttonKill, 0, wxALL, 5 );
bSizer3->Add( bSizer4, 1, wxALIGN_RIGHT|wxALL|wxEXPAND, 5 );
bSizer2->Add( bSizer3, 0, wxALL|wxEXPAND, 5 );
m_textCtrlInfo = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE|wxTE_WORDWRAP );
bSizer2->Add( m_textCtrlInfo, 1, wxALL|wxEXPAND, 5 );
this->SetSizer( bSizer2 );
this->Layout();
this->Centre( wxBOTH );
// Connect Events
this->Connect( wxEVT_IDLE, wxIdleEventHandler( CDialogIperfBase::OnIdle ) );
this->Connect( wxEVT_INIT_DIALOG, wxInitDialogEventHandler( CDialogIperfBase::OnInitDialog ) );
m_buttonCreate->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( CDialogIperfBase::OnBtnCreateClick ), NULL, this );
m_buttonKill->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( CDialogIperfBase::OnBtnKillClick ), NULL, this );
}
MainFrame_Base::~MainFrame_Base()
{
// Disconnect Events
this->Disconnect( wxEVT_IDLE, wxIdleEventHandler( MainFrame_Base::onIdle ) );
start_button->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( MainFrame_Base::onStart ), NULL, this );
dof_checkBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( MainFrame_Base::onDofCheckBox ), NULL, this );
this->Disconnect( wxID_ANY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( MainFrame_Base::onOpenMenu ) );
this->Disconnect( wxID_ANY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( MainFrame_Base::onSaveImageMenu ) );
this->Disconnect( wxID_ANY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( MainFrame_Base::onAboutMenu ) );
}
