C++ wxNewEventType函数代码示例

  OscapePrg::OscapePrg(wxWindow *parent) : wxProgress(parent) {
    evtLeave = wxNewEventType();
    idLeave = wxNewId();

    /* Connect to event handler that will make us close */
    Connect(wxID_ANY, evtLeave,
      (wxObjectEventFunction)(wxEventFunction)(wxCommandEventFunction)wxStaticCastEvent(LeaveEventFunction, &OscapePrg::Leave),
      NULL,
      this);

    evtProgress = wxNewEventType();
    idProgress = wxNewId();

    /* Connect to event handler that will make us close */
    Connect(wxID_ANY, evtProgress,
      (wxObjectEventFunction)(wxEventFunction)(wxCommandEventFunction)wxStaticCastEvent(ProgressEventFunction, &OscapePrg::Progress),
      NULL,
      this);

    tinit = time(NULL);
    paused = false;
    quit = false;
    prg = this;

    evt = CreateEvent(
      NULL,		  // default security attributes
      TRUE,		  // manual reset
      TRUE,		  // initially set
      NULL		  // unnamed mutex
      );

    end = CreateEvent(
      NULL,		  // default security attributes
      TRUE,		  // manual reset
      FALSE,		  // initially not set
      NULL		  // unnamed mutex
      );

    SetSize(600, 265);
  }

#include "refactorengine.h"
#include "cppwordscanner.h"
#include "entry.h"
#include "ctags_manager.h"
#include "fileextmanager.h"
#include <wx/progdlg.h>
#include <wx/sizer.h>
#include "progress_dialog.h"
#include "refactoring_storage.h"

const wxEventType wxEVT_REFACTORING_ENGINE_CACHE_INITIALIZING = wxNewEventType();

RefactoringEngine::RefactoringEngine()
{
}

RefactoringEngine::~RefactoringEngine()
{
}

RefactoringEngine* RefactoringEngine::Instance()
{
    static RefactoringEngine ms_instance;
    return &ms_instance;
}


void RefactoringEngine::Clear()
{
    m_possibleCandidates.clear();
    m_candidates.clear();

#endif            // __WXMSW__

void OCP_DataStreamInput_Thread::Parse_And_Send_Posn(const char *buf)
{
    if( m_pMessageTarget ) {
        OCPN_DataStreamEvent Nevent(wxEVT_OCPN_DATASTREAM, 0);
        Nevent.SetNMEAString( buf );
        Nevent.SetStream( m_launcher );

        m_pMessageTarget->AddPendingEvent(Nevent);
    }

    return;
}

const wxEventType wxEVT_OCPN_THREADMSG = wxNewEventType();

void OCP_DataStreamInput_Thread::ThreadMessage(const wxString &msg)
{
    //    Signal the main program thread
    OCPN_ThreadMessageEvent event(wxEVT_OCPN_THREADMSG, 0);
    event.SetSString( std::string(msg.mb_str()));
    if( gFrame )
        gFrame->GetEventHandler()->AddPendingEvent(event);
}

bool OCP_DataStreamInput_Thread::SetOutMsg(const wxString &msg)
{
    //  Assume that the caller already owns the mutex
    wxCriticalSectionLocker locker( m_outCritical );
    

    One quirk is that the top-level implementation object (m_top) always
    keeps a pointer to the implementation object where a new child is needed.
    (m_add_child_target).  This is so that when a new uesr view is added
    to the hierarchy, AddChild() is able to reparent the new user view to
    the correct implementation object's leaf.

*/

#include "wx/dcmemory.h"
#include "wx/dcscreen.h"
#include "wx/layout.h"
#include "wx/scrolbar.h"
#include "wx/settings.h"


const wxEventType wxEVT_DYNAMIC_SASH_SPLIT = wxNewEventType();
const wxEventType wxEVT_DYNAMIC_SASH_UNIFY = wxNewEventType();
const wxEventType wxEVT_DYNAMIC_SASH_REPARENT = wxNewEventType();

enum DynamicSashRegion
{
    DSR_NONE,
    DSR_VERTICAL_TAB,
    DSR_HORIZONTAL_TAB,
    DSR_CORNER,
    DSR_LEFT_EDGE,
    DSR_TOP_EDGE,
    DSR_RIGHT_EDGE,
    DSR_BOTTOM_EDGE
};

// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//////////////////////////////////////////////////////////////////////
// $URL: http://svn.rebarp.se/svn/RME/trunk/source/updater.hpp $
// $Id: updater.hpp 310 2010-02-26 18:03:48Z admin $

#include "main.h"

#ifdef _USE_UPDATER_

#include <wx/url.h>

#include "json.h"

#include "updater.h"

const wxEventType EVT_UPDATE_CHECK_FINISHED = wxNewEventType();

UpdateChecker::UpdateChecker()
{
	////
}

UpdateChecker::~UpdateChecker()
{
	////
}

void UpdateChecker::connect(wxEvtHandler* receiver)
{
	wxString address = wxT("http://www.remeresmapeditor.com/update.php");
	address << wxT("?os=") << 

#include <wx/tokenzr.h>
#include <wx/valgen.h>
#include "project/Assets.h"
#include "Triumph.h"

// these macros will expand a pre-processor define into code
// these are needed to expand the update host which
// are given as aa pre-processor define by the premake script
#define T4P_STR_EXPAND(s) #s
#define T4P_STR(s) T4P_STR_EXPAND(s)

static int ID_VERSION_FEATURE_TIMER = wxNewId();
static int ID_VERSION_DIALOG_TIMER = wxNewId();
static int ID_EVENT_VERSION_UPDATES = wxNewId();
static int ID_EVENT_VERSION_UPDATES_ON_DIALOG = wxNewId();
static wxEventType EVENT_VERSION_CHECK = wxNewEventType();


t4p::VersionUpdateViewClass::VersionUpdateViewClass(t4p::VersionUpdateFeatureClass& feature)
    : FeatureViewClass()
    , Feature(feature)
    , Timer(this, ID_VERSION_FEATURE_TIMER) {
}

void t4p::VersionUpdateViewClass::AddHelpMenuItems(wxMenu* helpMenu) {
    helpMenu->Append(t4p::MENU_VERSION_UPDATE, _("Check for updates"),
                     _("Check for new version of Triumph"), wxITEM_NORMAL);
}

void t4p::VersionUpdateViewClass::AddPreferenceWindow(wxBookCtrlBase* parent) {
    VersionUpdatePreferencesPanelClass* panel = new t4p::VersionUpdatePreferencesPanelClass(

 * File:    imgthread.cpp
 * Authors: Björn Petersen
 * Purpose: Silverjuke image thread'n'cache
 *
 ******************************************************************************/


#include <sjbase/base.h>
#include <sjtools/imgthread.h>
#include <sjtools/console.h>

#include <wx/listimpl.cpp> // sic!
WX_DEFINE_LIST(SjImgThreadObjList);


const wxEventType wxEVT_IMAGE_THERE = wxNewEventType();


/*******************************************************************************
 * SjImgThread - Thread Entry Point
 ******************************************************************************/


void* SjImgThread::Entry()
{
	int                         getFirst = -1;
	SjImgThreadObjList::Node*   node;
	SjImgThreadObj*             obj = NULL;
	bool                        objOk;
	long                        imagesThisRound;

	}
}

int DataViewCtrlHeaderMenu::CountVisibleColumns()
{

	int totalVisibleColumnsCount = 0;
	int totalColumnsCount = parentDataView->GetColumnCount();

	for (int i = 0; i < totalColumnsCount; ++i) {
		wxDataViewColumn* column = parentDataView->GetColumn(i);
		if (!column->IsHidden()) {
			totalVisibleColumnsCount++;
		}
	}

	return totalVisibleColumnsCount;
}

void DataViewCtrlHeaderMenu::OnShowColumns(wxCommandEvent&)
{
	wxCommandEvent newEvent;

	newEvent.SetEventType(SHOW_ALL_COLUMNS_EVT);

	parentDataView->GetEventHandler()->ProcessEvent(newEvent);
}

wxEventType DataViewCtrlHeaderMenu::HIDE_COLUMN_EVT = wxNewEventType();
wxEventType DataViewCtrlHeaderMenu::SHOW_ALL_COLUMNS_EVT = wxNewEventType();

 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial
 * portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 * LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "CommonIncludes.h"
#include "EncFSMPErrorLog.h"

const wxEventType errorLogEventType = wxNewEventType();

enum
{
	ID_NEW_ERROR_LOG_ENTRY = 3000
};

EncFSMPErrorLog::EncFSMPErrorLog(wxWindow* parent)
	: EncFSMPErrorLogBase(parent), isWindowShown_(false),
	showErrorLogOnErr_(true), mutex_()
{
}

EncFSMPErrorLog::~EncFSMPErrorLog()
{
}

#include "cc_box_tip_window.h"
#include <wx/bitmap.h>
#include <wx/dcmemory.h>
#include "ieditor.h"
#include <wx/settings.h>
#include <wx/dcbuffer.h>
#include "bitmap_loader.h"
#include <wx/tokenzr.h>
#include <wx/spinctrl.h>
#include "Markup.h"
#include "event_notifier.h"
#include "editor_config.h"
#include <wx/stc/stc.h>
#include "file_logger.h"

const wxEventType wxEVT_TIP_BTN_CLICKED_UP   = wxNewEventType();
const wxEventType wxEVT_TIP_BTN_CLICKED_DOWN = wxNewEventType();

CCBoxTipWindow::CCBoxTipWindow(wxWindow* parent, const wxString& tip)
    : wxPopupWindow(parent)
    , m_tip(tip)
{
    while ( m_tip.Replace("\n\n", "\n") ) {}
    DoInitialize(m_tip, 1, true);
}

CCBoxTipWindow::CCBoxTipWindow(wxWindow* parent, const wxString &tip, size_t numOfTips, bool simpleTip)
    : wxPopupWindow(parent)
    , m_tip(tip)
{
    while ( m_tip.Replace("\n\n", "\n") ) {}

#ifdef __WXMSW__
    wxFSVolume::CancelSearch();
#endif
}

wxString t4p::VolumeListActionClass::GetLabel() const {
    return wxT("Volume List");
}

t4p::VolumeListEventClass::VolumeListEventClass(int id,
        const std::vector<wxString>& localVolumes)
    : wxEvent(id, t4p::EVENT_ACTION_VOLUME_LIST)
    , LocalVolumes() {
    t4p::DeepCopy(LocalVolumes, localVolumes);
}

wxEvent* t4p::VolumeListEventClass::Clone() const {
    return new t4p::VolumeListEventClass(GetId(), LocalVolumes);
}

const wxEventType t4p::EVENT_ACTION_VOLUME_LIST = wxNewEventType();

BEGIN_EVENT_TABLE(t4p::FileWatcherFeatureClass, t4p::FeatureClass)
    EVT_COMMAND(wxID_ANY, t4p::EVENT_APP_READY, t4p::FileWatcherFeatureClass::OnAppReady)
    EVT_COMMAND(wxID_ANY, t4p::EVENT_APP_EXIT, t4p::FileWatcherFeatureClass::OnAppExit)
    EVT_TIMER(ID_FILE_MODIFIED_CHECK, t4p::FileWatcherFeatureClass::OnTimer)
    EVT_FSWATCHER(wxID_ANY, t4p::FileWatcherFeatureClass::OnFsWatcher)
    EVT_COMMAND(wxID_ANY, t4p::EVENT_APP_PREFERENCES_SAVED, t4p::FileWatcherFeatureClass::OnPreferencesSaved)
    EVT_ACTION_VOLUME_LIST(wxID_ANY, t4p::FileWatcherFeatureClass::OnVolumeListComplete)
END_EVENT_TABLE()

    // return FALSE so other process in our group are allowed to process this event
    return FALSE;
}
#endif

#include <sys/types.h>
#include <signal.h>

#if 0
#    define DBG_LOG 1
static wxFFile gfp(wxT("debugger.log"), wxT("w+"));
#else
#    define DBG_LOG 0
#endif

const wxEventType wxEVT_GDB_STOP_DEBUGGER     = wxNewEventType();

//Using the running image of child Thread 46912568064384 (LWP 7051).
static wxRegEx reInfoProgram1( wxT( "\\(LWP[ \t]([0-9]+)\\)" ) );
//Using the running image of child process 10011.
static wxRegEx reInfoProgram2( wxT( "child process ([0-9]+)" ) );
//Using the running image of child thread 4124.0x117c
static wxRegEx reInfoProgram3( wxT( "Using the running image of child thread ([0-9]+)" ) );

#ifdef __WXMSW__
static wxRegEx reConnectionRefused( wxT( "[0-9a-zA-Z/\\\\-\\_]*:[0-9]+: No connection could be made because the target machine actively refused it." ) );
#else
static wxRegEx reConnectionRefused( wxT( "[0-9a-zA-Z/\\\\-\\_]*:[0-9]+: Connection refused." ) );
#endif
DebuggerInfo GetDebuggerInfo()
{

// wxWindows headers
#include <wx/wx.h>

// PostgreSQL headers
#include <libpq-fe.h>

// App headers
#include "db/pgSet.h"
#include "db/pgConn.h"
#include "db/pgQueryThread.h"
#include "db/pgQueryResultEvent.h"
#include "utils/pgDefs.h"
#include "utils/sysLogger.h"

const wxEventType PGQueryResultEvent = wxNewEventType();

// default notice processor for the pgQueryThread
// we do assume that the argument passed will be always the
// object of pgQueryThread
void pgNoticeProcessor(void *_arg, const char *_message)
{
	wxString str(_message, wxConvUTF8);

	wxLogNotice(wxT("%s"), str.Trim().c_str());
	if (_arg)
	{
		((pgQueryThread *)_arg)->AppendMessage(str);
	}
}

}

CodeBlocksLogEvent::CodeBlocksLogEvent(wxEventType commandType, wxWindow* window_in, const wxString& title_in, wxBitmap *icon_in)
    : wxEvent(wxID_ANY, commandType),
    logger(nullptr), logIndex(-1), icon(icon_in), title(title_in), window(window_in)
{
}

CodeBlocksLogEvent::CodeBlocksLogEvent(const CodeBlocksLogEvent& rhs)
    : wxEvent(wxID_ANY, rhs.GetEventType()), logger(rhs.logger), logIndex(rhs.logIndex), icon(rhs.icon), title(rhs.title), window(rhs.window)
{
}


// app events
const wxEventType cbEVT_APP_STARTUP_DONE = wxNewEventType();
const wxEventType cbEVT_APP_START_SHUTDOWN = wxNewEventType();
const wxEventType cbEVT_APP_ACTIVATED = wxNewEventType();
const wxEventType cbEVT_APP_DEACTIVATED = wxNewEventType();
// plugin events
const wxEventType cbEVT_PLUGIN_ATTACHED = wxNewEventType();
const wxEventType cbEVT_PLUGIN_RELEASED = wxNewEventType();
const wxEventType cbEVT_PLUGIN_INSTALLED = wxNewEventType();
const wxEventType cbEVT_PLUGIN_UNINSTALLED = wxNewEventType();
const wxEventType cbEVT_PLUGIN_LOADING_COMPLETE = wxNewEventType();
// editor events
const wxEventType cbEVT_EDITOR_CLOSE = wxNewEventType();
const wxEventType cbEVT_EDITOR_OPEN = wxNewEventType();
const wxEventType cbEVT_EDITOR_SWITCHED = wxNewEventType();
const wxEventType cbEVT_EDITOR_ACTIVATED = wxNewEventType();
const wxEventType cbEVT_EDITOR_DEACTIVATED = wxNewEventType();

#include "bf/item_reference_edit.hpp"
#include "bf/set_edit.hpp"
#include "bf/wx_facilities.hpp"
#include "bf/any_animation_edit.hpp"
#include "bf/font_edit.hpp"
#include "bf/sample_edit.hpp"
#include "bf/sprite_edit.hpp"

#include "bf/call_by_field_type.hpp"

#include <list>
#include <claw/assert.hpp>

/*----------------------------------------------------------------------------*/
const wxEventType
bf::delete_item_field_event::delete_field_event_type = wxNewEventType();

/*----------------------------------------------------------------------------*/
/**
 * \brief Constructor.
 * \param field_name The name of the cleared field.
 * \param t The type of the event.
 * \param id The id of the window that generates the event.
 */
bf::delete_item_field_event::delete_item_field_event
( const std::string& field_name, wxEventType t, wxWindowID id )
  : wxNotifyEvent(t, id), m_field_name(field_name)
{

} // delete_item_field_event::delete_item_field_event()