Driver::Driver(Operator* defaultOp)
: _isBlocked(false)
, _defaultOp(defaultOp)
, _activeOp(0)
{
assert(_defaultOp);
AddEventHandler(ev_op_setOperator, this, &Driver::Event_SetOperator);
AddEventHandler(ev_w_rebuildAll, this, &Driver::Event_RebuildAll);
}
short bMainThread :: Start() // Program execution starts here
{
// attach error handler
AppErrorHandler defaultHandler("errdemo", CtAll, NULL);
AddEventHandler(&defaultHandler);
// Create the application facility
bFacility *fac = new bFacility(FAC_ERRDEMO, "App", FAC_APPMSGFILE);
fac->SetHelpFilename(FAC_APPHELPFILE, FAC_APPHELPOFFSET);
ThisApp->AddFacility(fac);
// ...and the IO library facility
fac = new bFacility(FAC_IO, "I/O Library", FAC_IOMSGFILE);
fac->SetHelpFilename(FAC_IOHELPFILE, FAC_IOHELPOFFSET);
ThisApp->AddFacility(fac);
// create help manager
wHelpManager help("errdemo.hlp");
help.SetHelpWindowTitle("Help for Error Demo");
help.SetHelpTable(MainHelpTable);
AppWindow w; // Contstruct the top level frame window
Exec(); // Go to the message loop.
return 0;
}
ENT_GeometryOutln::ENT_GeometryOutln(ENT_Geometry& subject) : _subject(subject) {
InitOutline();
AddEventHandler(ev_geom_vertexScaleChanged, this, &ENT_GeometryOutln::Event_VertexScaleChanged);
AddEventHandler(ev_geom_edgeScaleChanged, this, &ENT_GeometryOutln::Event_EdgeScaleChanged);
AddEventHandler(ev_geom_edgeTintChanged, this, &ENT_GeometryOutln::Event_EdgeTintChanged);
AddEventHandler(ev_geom_edgeShadingChanged, this, &ENT_GeometryOutln::Event_EdgeShadingChanged);
AddEventHandler(ev_geom_renderModeChanged, this, &ENT_GeometryOutln::Event_RenderModeChanged);
AddEventHandler(ev_geom_showVertexLabels, this, &ENT_GeometryOutln::Event_ShowVertexLabels);
AddEventHandler(ev_geom_xrayVertexLabels, this, &ENT_GeometryOutln::Event_XrayVertexLabels);
AddEventHandler(ev_geom_setVertexLabelSize, this, &ENT_GeometryOutln::Event_SetVertexLabelSize);
AddEventHandler(ev_ent_setPosition, this, &ENT_GeometryOutln::Event_SetPosition);
}
void UserInterface::Init() {
AddEventHandler(ev_w_editModeChanged, this, &UserInterface::Event_EditModeChanged);
// order matters
_outliner = GEN::MakePtr(new UI::Outliner());
_operatorPanel = GEN::MakePtr(new UI::OperatorPanel());
_penOptions = GEN::MakePtr(new UI::PenOptions());
_mainWindow = GEN::MakePtr(new UI::MainWindow());
_uiThreadID = SYS::Thread::CallerID();
}
void XtAddRawEventHandler(
Widget widget,
EventMask eventMask,
_XtBoolean other,
XtEventHandler proc,
XtPointer closure)
{
WIDGET_TO_APPCON(widget);
LOCK_APP(app);
AddEventHandler(widget, (XtPointer) &eventMask, 0, FALSE, other,
proc, closure, XtListTail, FALSE, TRUE);
UNLOCK_APP(app);
}
void XtInsertEventHandler(
Widget widget,
EventMask eventMask,
_XtBoolean other,
XtEventHandler proc,
XtPointer closure,
XtListPosition position)
{
WIDGET_TO_APPCON(widget);
LOCK_APP(app);
AddEventHandler(widget, (XtPointer) &eventMask, 0, FALSE, other,
proc, closure, position, TRUE, FALSE);
UNLOCK_APP(app);
}
void XtInsertEventTypeHandler(
Widget widget,
int type,
XtPointer select_data,
XtEventHandler proc,
XtPointer closure,
XtListPosition position)
{
WIDGET_TO_APPCON(widget);
LOCK_APP(app);
AddEventHandler(widget, select_data, type, TRUE, FALSE,
proc, closure, position, TRUE, FALSE);
UNLOCK_APP(app);
}
int LWF::AddEventHandler(string eventName, EventHandler eventHandler)
{
int eventId = SearchEventId(eventName);
int id;
if (eventId >= 0 && eventId < (int)data->events.size()) {
id = AddEventHandler(eventId, eventHandler);
} else {
GenericEventHandlerDictionary::iterator it =
m_genericEventHandlerDictionary.find(eventName);
if (it == m_genericEventHandlerDictionary.end()) {
m_genericEventHandlerDictionary[eventName] = EventHandlerList();
it = m_genericEventHandlerDictionary.find(eventName);
}
id = GetEventOffset();
it->second.push_back(make_pair(id, eventHandler));
}
return id;
}
// ---------------------------------------------------------------------------
// CPeninputServerObserver::CPeninputServerObserver
// Constructor. Adds the active object to the active scheduler
// and issues a request for server notification.
// ---------------------------------------------------------------------------
//
CPeninputServerObserver::CPeninputServerObserver(
RPeninputServerImpl* aPeninputServer,
TThreadId aSrvThreadId)
:CActive( EPriorityHigh ),
iPeninputServer( aPeninputServer ),
iSrvThreadId(aSrvThreadId),
iServerExit(EFalse)
{
__ASSERT_ALWAYS( !IsActive(), User::Panic( KPeninputServerName,
KErrObserverAlreadyActive ) );
//__ASSERT_DEBUG(aHandler, User::Panic( KPeninputServerName,
// KErrObserverNoHandler ));
AddEventHandler(this); //set own as the dummy handler
/*if(aPrevObserver)
{
iHandler = aPrevObserver->iHandler;
iUiActivationHandler = aPrevObserver->iUiActivationHandler;
}*/
// issue asynchronous request and set this object active
CActiveScheduler::Add( this );
}
Ptr<IEventHandler> EventInfoImpl::Attach(const Value& thisObject, Ptr<IValueFunctionProxy> handler)
{
if(thisObject.IsNull())
{
throw ArgumentNullException(L"thisObject", this);
}
else if(!thisObject.CanConvertTo(ownerTypeDescriptor, Value::RawPtr))
{
throw ArgumentTypeMismtatchException(L"thisObject", ownerTypeDescriptor, Value::RawPtr, thisObject);
}
DescriptableObject* rawThisObject=thisObject.GetRawPtr();
if(rawThisObject)
{
Ptr<EventHandlerImpl> eventHandler=new EventHandlerImpl(this, rawThisObject, handler);
AddEventHandler(rawThisObject, eventHandler);
AttachInternal(rawThisObject, eventHandler.Obj());
return eventHandler;
}
else
{
return 0;
}
}
int Movie::SetEventHandler(string eventName, MovieEventHandler eventHandler)
{
ClearEventHandler(eventName);
return AddEventHandler(eventName, eventHandler);
}
int LWF::SetEventHandler(int eventId, EventHandler eventHandler)
{
ClearEventHandler(eventId);
return AddEventHandler(eventId, eventHandler);
}
int Button::SetEventHandler(string eventName, ButtonEventHandler eventHandler)
{
ClearEventHandler(eventName);
return AddEventHandler(eventName, eventHandler);
}
bool ff::EntityDomain::AddEventHandler(hash_t eventId, IEntityEventHandler *handler)
{
return AddEventHandler(GetEventEntry(eventId), INVALID_ENTITY, handler);
}
bool ff::EntityDomain::AddEventHandler(hash_t eventId, Entity entity, IEntityEventHandler *handler)
{
return AddEventHandler(GetEventEntry(eventId), entity, handler);
}
D3_Delaunay::D3_Delaunay() {
AddEventHandler(EV::def_D3_Delaunay_Action, this, &D3_Delaunay::Event_Action);
}
Variant DynamicObject::m_AddEventHandler(int numargs, Variant args[])
{
AddEventHandler(args[0], args[1]);
return VARNULL;
}
Delaunay3D::Delaunay3D() {
AddEventHandler(ev_setScale, this, &Delaunay3D::Event_SetScale);
}
