Gui_DisplayFrame(Gui_ProcessorHandler& processor_hand,sigc::signal<void,bool,double> signal_show_decor,sigc::signal<void,bool> signal_show_mask): m_display(processor_hand){ DEV_INFOS("building graphical display frame"); this->add(m_display); signal_show_decor.connect( sigc::mem_fun(this,&Gui_DisplayFrame::on_show_deco)); signal_show_mask.connect( sigc::mem_fun(this,&Gui_DisplayFrame::on_show_mask)); }
void Interactive::loop() { if (rl_bind_keyseq("`", &context_switch) != 0) { std::cout << "BINDING FAILED" << std::endl; } rl_callback_handler_install(m_prompt.c_str(), &Interactive::gotCommand); rl_completion_entry_function = &completion_generator; CmdLine.connect(sigc::mem_fun(this, &Interactive::runCommand)); ContextSwitch.connect(sigc::mem_fun(this, &Interactive::switchContext)); while (select() == 0); std::cout << std::endl << std::flush; rl_callback_handler_remove(); }
void Admintest::test_customMonitorOperation_monitorin() { // Check that Dispatching in not yet connected assert(m_server->m_world.Dispatching.slots().begin() == m_server->m_world.Dispatching.slots().end()); // Set it up so it is already monitoring m_account->m_monitorConnection = null_signal.connect(sigc::mem_fun(this, &Admintest::null_method)); ASSERT_TRUE(m_account->m_monitorConnection.connected()); Atlas::Objects::Operation::Monitor op; OpVector res; Root arg; op->setArgs1(arg); m_account->customMonitorOperation(op, res); ASSERT_TRUE(m_account->m_monitorConnection.connected()); // Check that Dispatching in not been connected assert(m_server->m_world.Dispatching.slots().begin() == m_server->m_world.Dispatching.slots().end()); }
void on_limits_changed() { magnet::gtk::forceNumericEntry(_minValue); try { _min = boost::lexical_cast<GLfloat>(_minValue.get_text()); } catch(...) {} magnet::gtk::forceNumericEntry(_maxValue); try { _max = boost::lexical_cast<GLfloat>(_maxValue.get_text()); } catch(...) {} _signal_changed.emit(); }
ObjectManager::ObjectManager( Mode mode, RakNet::RakNetGUID ownGUID, RakNet::RakNetGUID serverGUID, sigc::signal<void>& rUpdateSignal, sigc::signal<void>& rLateUpdateSignal, ObjectTemplateManager& rObjectTemplateManager, RakNet::ReplicaManager3& rReplicaManager, RakNet::NetworkIDManager& rNetworkIDManager, RakNet::RPC3& rRPC3, bool offlineMode /*= false*/ ): mMode( mode ), mOfflineMode( offlineMode ), mOwnGUID( ownGUID ), mServerGUID( serverGUID ), mUpdateSignal( rUpdateSignal ), mObjectTemplateManager( rObjectTemplateManager ), mReplicaManager( rReplicaManager ), mNetworkIDManager( rNetworkIDManager ), mRPC3( rRPC3 ) { mUpdateConnection = rUpdateSignal.connect( sigc::mem_fun( this, &ObjectManager::update ) ); mUpdateConnection.block( true ); rLateUpdateSignal.connect( sigc::mem_fun( this, &ObjectManager::lateUpdate ) ); }
/** * Respond to the text box changing. * * This function responds to the box changing by grabbing the value * from the text box and putting it in the parameter. */ void ParamComboBoxEntry::changed (void) { Glib::ustring data = this->get_active_text(); _pref->set(data.c_str(), _doc, _node); if (_changeSignal != NULL) { _changeSignal->emit(); } }
/** \brief A function to respond to the value_changed signal from the adjustment. This function just grabs the value from the adjustment and writes it to the parameter. Very simple, but yet beautiful. */ void ParamFloatAdjustment::val_changed (void) { //std::cout << "Value Changed to: " << this->get_value() << std::endl; _pref->set(this->get_value(), _doc, _node); if (_changeSignal != NULL) { _changeSignal->emit(); } return; }
/** \brief Respond to the selected radiobutton changing This function responds to the radiobutton selection changing by grabbing the value from the text box and putting it in the parameter. */ void ParamRadioButtonWdg::changed (void) { if (this->get_active()) { Glib::ustring data = this->get_label(); _pref->set(data.c_str(), _doc, _node); } if (_changeSignal != NULL) { _changeSignal->emit(); } }
ClientConnection::ClientConnection( sigc::signal<void>& rUpdateSignal ): mRakPeer( *RakNet::RakPeerInterface::GetInstance() ) { LOGI << "Initializing client connection"; rUpdateSignal.connect( sigc::mem_fun( this, &ClientConnection::update ) ); mRPC3.SetNetworkIDManager( &mNetworkIDManager ); mReplicaManager.SetNetworkIDManager( &mNetworkIDManager ); mRakPeer.AttachPlugin( &mRPC3 ); mRakPeer.AttachPlugin( &mReplicaManager ); // Initialize plugin manager mPluginManager = new ClientPluginManager( SERVER, rUpdateSignal, mRakPeer, mReplicaManager, mNetworkIDManager, mRPC3 ); mReplicaManager.setPluginManager( *mPluginManager ); // Initialize user manager mSessionManager.reset( new SessionManager( mUserManager, *mPluginManager, rUpdateSignal ) ); // Initialize permission manager PermissionManager& permissionManager = mPluginManager->createPlugin<PermissionManager>(); permissionManager.setSessionManager( *mSessionManager.get() ); // Connect to plugin change signal to set the object manager when it's created. mPluginChangeConnection = mPluginManager->connect( sigc::mem_fun( this, &ClientConnection::pluginChange ) ); // Load all other plugins and set configuration for them. Copy vector to set to remove // duplicates and fix the load order. std::set<ClientServerPluginTypeEnum> plugins; std::copy( msSettings.mPlugins.begin(), msSettings.mPlugins.end(), std::inserter( plugins, plugins.end() ) ); for( std::set<ClientServerPluginTypeEnum>::iterator i = plugins.begin(); i!= plugins.end(); ++i ) { ClientServerPlugin& plugin = mPluginManager->createPlugin( *i ); LOGI << "Loading client-server plugin: " << plugin.getTypeName(); Globals::mConfig->registerObject( plugin ); } // Load user settings after loading all plugins (PermissionManager), so default permissions get // overridden. Globals::mConfig->registerObject( mUserManager ); Globals::mClient = this; Globals::mLua->object( "ClientConnection" ) = this; }
Gui_ResultFrame::Gui_ResultFrame(Gui_ProcessorHandler& processor_hand, sigc::signal<void,bool>& signal_set_to_NA, ResultMap& result_map): m_result_map(result_map), m_processor_hand(processor_hand), m_result_display(m_signal_update_result_map, m_result_map), m_result_detail(m_signal_update_result_map,m_signal_select_object,m_signal_toggle_object, m_result_map), m_user_filter(m_processor_hand) { DEV_INFOS("RESUlt frame"); this->pack1(m_result_display); this->pack2(m_result_detail); processor_hand.signal_state().connect( sigc::mem_fun(*this,&Gui_ResultFrame::on_processor_idle)); signal_set_to_NA.connect( sigc::mem_fun(*this,&Gui_ResultFrame::on_set_current_to_NA)); m_signal_toggle_object.connect( sigc::mem_fun(m_user_filter,&Gui_UserFilterSetter::on_toggle_object)); // signal_set_to_NA.connect( sigc::mem_fun(m_result_display,&Gui_ResultListDisplay::on_setToNA)); DEV_INFOS("RESUlt frame OK"); }
void ControlManagerImpl::setControlSize(int size, bool force) { if ((size < 1) || (size > 7)) { g_warning("Illegal logical size set: %d", size); } else if (force || (size != _size)) { _size = size; for (std::vector<SPCanvasItem *>::iterator it = _itemList.begin(); it != _itemList.end(); ++it) { if (*it) { updateItem(*it); } } _sizeChangedSignal.emit(); } }
void OnAxisPick(SDL_JoyAxisEvent *e) { if (e->value > -32767/3 && e->value < 32767/3) return; m_keyUpConnection.disconnect(); Gui::Screen::RemoveBaseWidget(m_infoTooltip); delete m_infoTooltip; m_infoTooltip = 0; m_axisBinding.joystick = e->which; m_axisBinding.axis = e->axis; m_axisBinding.direction = (e->value < 0 ? KeyBindings::NEGATIVE : KeyBindings::POSITIVE); onChange.emit(m_axisBinding); m_keyLabel->SetText(m_axisBinding.Description()); ResizeRequest(); }
void Admintest::test_opDispatched() { Link_sent_called = false; m_account->m_monitorConnection = null_signal.connect(sigc::mem_fun(this, &Admintest::null_method)); ASSERT_TRUE(m_account->m_monitorConnection.connected()); Operation op; m_account->opDispatched(op); // The account is connected, so calling this should not affect the signal ASSERT_TRUE(m_account->m_monitorConnection.connected()); // The operation should have been sent here ASSERT_TRUE(Link_sent_called); }
namespace Eris { static LogLevel _logLevel = DEFAULT_LOG; sigc::signal<void, LogLevel, const std::string&> Logged; void setLogLevel(LogLevel lvl) { _logLevel = lvl; } LogLevel getLogLevel() { return _logLevel; } void doLog(LogLevel lvl, const std::string& msg) { if (lvl <= _logLevel) Logged.emit(lvl, msg); } std::ostream& operator<<(std::ostream& os, const Atlas::Objects::Root& obj) { std::stringstream s; Atlas::Codecs::Bach debugCodec(s, s, *(Atlas::Bridge*)0); Atlas::Objects::ObjectsEncoder debugEncoder(debugCodec); debugEncoder.streamObjectsMessage(obj); return os << s.str(); } std::ostream& operator<<(std::ostream& os, const Atlas::Message::Element& msg) { std::stringstream s; Atlas::Codecs::Bach debugCodec(s, s, *(Atlas::Bridge*)0); Atlas::Message::Encoder debugEncoder(debugCodec); debugEncoder.streamMessageElement(msg.asMap()); return os << s.str(); } } // of namespace
void Admintest::test_opDispatched_unconnected_monitored() { m_account->m_connection = 0; Link_sent_called = false; m_account->m_monitorConnection = null_signal.connect(sigc::mem_fun(this, &Admintest::null_method)); ASSERT_TRUE(m_account->m_monitorConnection.connected()); Operation op; m_account->opDispatched(op); // The account is unconnected, so calling opDispatched should not // cause the signal to get cut off ASSERT_TRUE(!m_account->m_monitorConnection.connected()); // The operation should not have been sent here ASSERT_TRUE(!Link_sent_called); }
void OnClickCancel() { onClickCancel.emit(); }
AfterTerrainUpdateListener(sigc::signal<void, const std::vector<WFMath::AxisBox<2>>&, const std::set<TerrainPage*>&>& event) { event.connect(sigc::mem_fun(*this, &AfterTerrainUpdateListener::eventListener)); }
WorldSizeChangedListener(sigc::signal<void>& event) { event.connect(sigc::mem_fun(*this, &WorldSizeChangedListener::eventListener)); }
static int context_switch(int a, int b) { ContextSwitch.emit(a, b); return 0; }
template<class... Args> XBT_ALWAYS_INLINE R operator()(Args&&... args) const { return sig_.emit(std::forward<Args>(args)...); }
void disconnect_all_slots() { sig_.clear(); }
void on_combobox_changed() { ::Gtk::TreeModel::iterator iter = _comboBox.get_active(); if (iter) _mode = ((*iter)[m_Columns.m_col_id]); _signal_changed.emit(); }
sigc::connection ControlManagerImpl::connectCtrlSizeChanged(const sigc::slot<void> &slot) { return _sizeChangedSignal.connect(slot); }
void Transmitter::run(void) { sleep(2); m_slot.emit(m_origin); // Emit the signal }
void doLog(LogLevel lvl, const std::string& msg) { if (lvl <= _logLevel) Logged.emit(lvl, msg); }
void Close() { onChange.emit(m_binding); m_keyLabel->SetText(m_binding.Description()); ResizeRequest(); }
template<class U> XBT_ALWAYS_INLINE void connect(U&& slot) { sig_.connect(std::forward<U>(slot)); }
void Interactive::gotCommand(char * cmd) { CmdLine.emit(cmd); }
EntityMoveInstance::EntityMoveInstance(EmberEntity& entity, MovementAdapter& moveAdapter, sigc::signal<void>& eventFinishedMoving, sigc::signal<void>& eventCancelledMoving) : EntityObserverBase(entity, true), mMoveAdapter(moveAdapter) { eventCancelledMoving.connect(sigc::mem_fun(*this, &EntityObserverBase::deleteOurselves)); eventFinishedMoving.connect(sigc::mem_fun(*this, &EntityObserverBase::deleteOurselves)); }
template<class Res, class... Args> XBT_ALWAYS_INLINE void connect(Res(*slot)(Args...)) { sig_.connect(sigc::ptr_fun(slot)); }