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