C++ wxIdleEventHandler函数代码示例

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;
  }
}

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 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 );
}