// --------------------------------------------------------------------------
// CNSmlDmAOAdapter::FetchLeafObjectSizeL
// Fetches leaf object size.
// -------------------------------------------------------------------------
void CNSmlDmAOAdapter::FetchLeafObjectSizeL( const TDesC8& aURI,
const TDesC8& aLUID,
const TDesC8& /* aType */,
TInt aResultsRef,
TInt aStatusRef )
{
LOGSTRING( "CNSmlDmAOAdapter::FetchLeafObjectSizeL: Start" );
LOGSTRING3( "\tFetchLeafObjectSizeL \tURI: %S, \tLUID: %S,",
&aURI, &aLUID );
CSmlDmAOCommandElement* cmd =
CSmlDmAOCommandElement::NewLC( ETrue,
aStatusRef,
aResultsRef,
CNSmlDmAOAdapter::EGetSizeCmd,
LastURISeg( aURI ),
KNullDesC8);
TInt luid( KDefaultLuid );
if ( aLUID.Length() > 0 )
{
luid = DesToIntL( aLUID );
}
iSettingStore->ExecuteCmdL( *cmd, luid );
LOGSTRING2( "\tCmd executed with status: %d ",
cmd->Status() );
// if executed get status
if ( cmd->Executed() )
{
Callback().SetStatusL( aStatusRef, cmd->Status() );
// if successful get results
if ( cmd->Status() == CSmlDmAdapter::EOk )
{
LOGSTRING2( "\tCmd executed with result: %S ",
cmd->Data() );
CBufBase* result = CBufFlat::NewL( cmd->Data()->Size() );
CleanupStack::PushL( result );
result->InsertL( 0, *cmd->Data() );
Callback().SetResultsL( aResultsRef, *result, KNullDesC8 );
CleanupStack::PopAndDestroy( result );
}
}
else
{
// failed to execute command
Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError );
}
CleanupStack::PopAndDestroy( cmd );
LOGSTRING( "CNSmlDmAOAdapter::FetchLeafObjectSizeL: End" );
}
CChooseProfileDlg(CCtrlButton &_btn, PROFILEMANAGERDATA *_pd) :
CDlgBase(g_hInst, IDD_PROFILE_SELECTION),
m_btnOk(_btn),
m_pd(_pd),
m_profileList(this, IDC_PROFILELIST)
{
m_profileList.OnItemChanged = Callback(this, &CChooseProfileDlg::list_OnItemChanged);
m_profileList.OnKeyDown = Callback(this, &CChooseProfileDlg::list_OnKeyDown);
m_profileList.OnGetInfoTip = Callback(this, &CChooseProfileDlg::list_OnGetTip);
m_profileList.OnDoubleClick = Callback(this, &CChooseProfileDlg::list_OnDblClick);
}
CVkOptionFeedsForm::CVkOptionFeedsForm(CVkProto *proto):
CVkDlgBase(proto, IDD_OPT_FEEDS, false),
m_cbNewsEnabled(this, IDC_NEWS_ENBL),
m_edtNewsInterval(this, IDC_ED_INT_NEWS),
m_spNewsInterval(this, IDC_SPIN_INT_NEWS),
m_cbNotificationsEnabled(this, IDC_NOTIF_ENBL),
m_edtNotificationsInterval(this, IDC_ED_INT_NOTIF),
m_spNotificationsInterval(this, IDC_SPIN_INT_NOTIF),
m_cbNotificationsMarkAsViewed(this, IDC_NOTIF_MARK_VIEWED),
m_cbSpecialContactAlwaysEnabled(this, IDC_SPEC_CONT_ENBL),
m_cbNewsAutoClearHistory(this, IDC_NEWSAUTOCLEAR),
m_cbNewsFilterPosts(this, IDC_F_POSTS),
m_cbNewsFilterPhotos(this, IDC_F_PHOTOS),
m_cbNewsFilterTags(this, IDC_F_TAGS),
m_cbNewsFilterWallPhotos(this, IDC_F_WALLPHOTOS),
m_cbNewsSourceFriends(this, IDC_S_FRIENDS),
m_cbNewsSourceGroups(this, IDC_S_GROUPS),
m_cbNewsSourcePages(this, IDC_S_PAGES),
m_cbNewsSourceFollowing(this, IDC_S_FOLLOWING),
m_cbNewsSourceIncludeBanned(this, IDC_S_BANNED),
m_cbNewsSourceNoReposts(this, IDC_S_NOREPOSTES),
m_cbNotificationFilterComments(this, IDC_N_COMMENTS),
m_cbNotificationFilterLikes(this, IDC_N_LIKES),
m_cbNotificationFilterReposts(this, IDC_N_REPOSTS),
m_cbNotificationFilterMentions(this, IDC_N_MENTIONS),
m_cbNotificationFilterInvites(this, IDC_N_INVITES)
{
CreateLink(m_cbNewsEnabled, m_proto->m_vkOptions.bNewsEnabled);
CreateLink(m_edtNewsInterval, m_proto->m_vkOptions.iNewsInterval);
CreateLink(m_cbNotificationsEnabled, m_proto->m_vkOptions.bNotificationsEnabled);
CreateLink(m_edtNotificationsInterval, m_proto->m_vkOptions.iNotificationsInterval);
CreateLink(m_cbNotificationsMarkAsViewed, m_proto->m_vkOptions.bNotificationsMarkAsViewed);
CreateLink(m_cbSpecialContactAlwaysEnabled, m_proto->m_vkOptions.bSpecialContactAlwaysEnabled);
CreateLink(m_cbNewsAutoClearHistory, m_proto->m_vkOptions.bNewsAutoClearHistory);
CreateLink(m_cbNewsFilterPosts, m_proto->m_vkOptions.bNewsFilterPosts);
CreateLink(m_cbNewsFilterPhotos, m_proto->m_vkOptions.bNewsFilterPhotos);
CreateLink(m_cbNewsFilterTags, m_proto->m_vkOptions.bNewsFilterTags);
CreateLink(m_cbNewsFilterWallPhotos, m_proto->m_vkOptions.bNewsFilterWallPhotos);
CreateLink(m_cbNewsSourceFriends, m_proto->m_vkOptions.bNewsSourceFriends);
CreateLink(m_cbNewsSourceGroups, m_proto->m_vkOptions.bNewsSourceGroups);
CreateLink(m_cbNewsSourcePages, m_proto->m_vkOptions.bNewsSourcePages);
CreateLink(m_cbNewsSourceFollowing, m_proto->m_vkOptions.bNewsSourceFollowing);
CreateLink(m_cbNewsSourceIncludeBanned, m_proto->m_vkOptions.bNewsSourceIncludeBanned);
CreateLink(m_cbNewsSourceNoReposts, m_proto->m_vkOptions.bNewsSourceNoReposts);
CreateLink(m_cbNotificationFilterComments, m_proto->m_vkOptions.bNotificationFilterComments);
CreateLink(m_cbNotificationFilterLikes, m_proto->m_vkOptions.bNotificationFilterLikes);
CreateLink(m_cbNotificationFilterReposts, m_proto->m_vkOptions.bNotificationFilterReposts);
CreateLink(m_cbNotificationFilterMentions, m_proto->m_vkOptions.bNotificationFilterMentions);
CreateLink(m_cbNotificationFilterInvites, m_proto->m_vkOptions.bNotificationFilterInvites);
m_cbNewsEnabled.OnChange = Callback(this, &CVkOptionFeedsForm::On_cbNewsEnabledChange);
m_cbNotificationsEnabled.OnChange = Callback(this, &CVkOptionFeedsForm::On_cbNotificationsEnabledChange);
}
CInviteDialog(WhatsAppProto *pThis) :
CProtoDlgBase<WhatsAppProto>(pThis, IDD_GROUPCHAT_INVITE, false),
m_clc(this, IDC_CLIST),
m_entry(this, IDC_NEWJID),
m_btnOk(this, IDOK)
{
m_btnOk.OnClick = Callback(this, &CInviteDialog::btnOk_OnClick);
m_clc.OnNewContact =
m_clc.OnListRebuilt = Callback(this, &CInviteDialog::FilterList);
m_clc.OnOptionsChanged = Callback(this, &CInviteDialog::ResetListOptions);
}
CFacebookGuardDialog::CFacebookGuardDialog(FacebookProto *proto, const char *fb_dtsg)
: CFacebookDlgBase(proto, IDD_GUARD, false),
m_ok(this, IDOK),
m_sms(this, IDC_SEND_SMS),
m_text(this, IDC_TEXT),
m_fb_dtsg(fb_dtsg)
{
memset(m_code, 0, sizeof(m_code));
m_ok.OnClick = Callback(this, &CFacebookGuardDialog::OnOk);
m_sms.OnClick = Callback(this, &CFacebookGuardDialog::OnSms);
}
CJabberDlgBookmarks::CJabberDlgBookmarks(CJabberProto *proto) :
CSuper(proto, IDD_BOOKMARKS, NULL),
m_btnAdd(this, IDC_ADD, SKINICON_OTHER_ADDCONTACT, LPGEN("Add")),
m_btnEdit(this, IDC_EDIT, SKINICON_OTHER_RENAME, LPGEN("Edit")),
m_btnRemove(this, IDC_REMOVE, SKINICON_OTHER_DELETE, LPGEN("Remove")),
m_lvBookmarks(this, IDC_BM_LIST, true, true)
{
m_lvBookmarks.OnItemActivate = Callback(this, &CJabberDlgBookmarks::lvBookmarks_OnDoubleClick);
m_btnAdd.OnClick = Callback(this, &CJabberDlgBookmarks::btnAdd_OnClick);
m_btnEdit.OnClick = Callback(this, &CJabberDlgBookmarks::btnEdit_OnClick);
m_btnRemove.OnClick = Callback(this, &CJabberDlgBookmarks::btnRemove_OnClick);
}
CVkCaptchaForm::CVkCaptchaForm(CVkProto *proto, CAPTCHA_FORM_PARAMS *param) :
CVkDlgBase(proto, IDD_CAPTCHAFORM, false),
m_instruction(this, IDC_INSTRUCTION),
m_edtValue(this, IDC_VALUE),
m_btnOpenInBrowser(this, IDOPENBROWSER),
m_btnOk(this, IDOK),
m_param(param)
{
m_btnOpenInBrowser.OnClick = Callback(this, &CVkCaptchaForm::On_btnOpenInBrowser_Click);
m_btnOk.OnClick = Callback(this, &CVkCaptchaForm::On_btnOk_Click);
m_edtValue.OnChange = Callback(this, &CVkCaptchaForm::On_edtValue_Change);
}
CVkWallPostForm::CVkWallPostForm(CVkProto *proto, WALLPOST_FORM_PARAMS *param) :
CVkDlgBase(proto, IDD_WALLPOST, false),
m_edtMsg(this, IDC_ED_MSG),
m_edtUrl(this, IDC_ED_URL),
m_cbOnlyForFriends(this, IDC_ONLY_FRIENDS),
m_btnShare(this, IDOK),
m_param(param)
{
m_btnShare.OnClick = Callback(this, &CVkWallPostForm::On_btnShare_Click);
m_edtMsg.OnChange = Callback(this, &CVkWallPostForm::On_edtValue_Change);
m_edtUrl.OnChange = Callback(this, &CVkWallPostForm::On_edtValue_Change);
}
// ------------------------------------------------------------------------
// CNSmlDmAOAdapter::ChildURIListL
// Fetches child nodes of a node. these may be either all VENDORCONFIG
// nodes or leaf nodes under a VENDORCONFIG node.
// ------------------------------------------------------------------------
void CNSmlDmAOAdapter::ChildURIListL( const TDesC8& aURI,
const TDesC8& aLUID,
const CArrayFix<TSmlDmMappingInfo>&
/*aPreviousURISegmentList*/,
TInt aResultsRef,
TInt aStatusRef )
{
LOGSTRING( "CNSmlDmAOAdapter::ChildURIListL: Start" );
LOGSTRING3( "\tChildURIListL URI: %S, LUID: %S ",
&aURI, &aLUID );
CBufBase* resultList = CBufFlat::NewL( KSmlMaxURISegLen );
CleanupStack::PushL( resultList );
// get all leaf nodes below VENDORCONFIG node
if ( !aURI.Compare( KNSmlDmAOAdapterAO ) )
{
CSmlDmAOCommandElement* cmd =
CSmlDmAOCommandElement::NewLC( EFalse,
aStatusRef,
aResultsRef,
CNSmlDmAOAdapter::EGetCmd,
KNullDesC8,
KNullDesC8 );
TInt luid( KDefaultLuid );
if ( aLUID.Length() > 0 )
{
luid = DesToIntL( aLUID );
}
iSettingStore->ExecuteCmdL( *cmd, luid );
LOGSTRING2( "\tCmd executed with status: %d ",
cmd->Status() );
Callback().SetStatusL( aStatusRef, cmd->Status() );
if( cmd->Status() == CSmlDmAdapter::EOk )
{
resultList->InsertL( 0, *cmd->Data() );
Callback().SetResultsL( aResultsRef,
*resultList,
KNullDesC8 );
}
CleanupStack::PopAndDestroy( cmd );
}
CleanupStack::PopAndDestroy( resultList );
LOGSTRING( "CNSmlDmAOAdapter::ChildURIListL: End" );
}
void Replace(uint32_t index, T entry)
{
if (index < Size())
{
Callback(Buffer_Remove, BufferImpl<T>::at(index));
BufferImpl<T>::at(index) = entry;
Callback(Buffer_Add, entry);
}
else
{
Add(entry);
}
}
CLuaOptions::CLuaOptions(int idDialog)
: CDlgBase(g_hInstance, idDialog),
m_popupOnError(this, IDC_POPUPONERROR),
m_popupOnObsolete(this, IDC_POPUPONOBSOLETE),
isScriptListInit(false), m_scripts(this, IDC_SCRIPTS),
m_reload(this, IDC_RELOAD)
{
CreateLink(m_popupOnError, "PopupOnError", DBVT_BYTE, 1);
CreateLink(m_popupOnObsolete, "PopupOnObsolete", DBVT_BYTE, 1);
m_scripts.OnClick = Callback(this, &CLuaOptions::OnScriptListClick);
m_reload.OnClick = Callback(this, &CLuaOptions::OnReload);
}
auto Accept(ConnectionWrapper *Connection, CallbackFunctor &&Callback)
{
// Accept on streamed socket.
if (Connection->Type == eConnection::STREAMED)
{
sockaddr ClientInfo;
int ClientLength = 0;
void *Socket = (void *)accept((SOCKET)Connection->Handle.Streamed.Socket, &ClientInfo, &ClientLength);
return Callback(Socket, &ClientInfo, ClientLength);
}
return Callback(nullptr, nullptr, 0);
}
bool
CamerasChild::RecvFrameSizeChange(const CaptureEngine& capEngine,
const int& capId,
const int& w, const int& h)
{
LOG((__PRETTY_FUNCTION__));
MutexAutoLock lock(mCallbackMutex);
if (Callback(capEngine, capId)) {
Callback(capEngine, capId)->FrameSizeChange(w, h, 0);
} else {
LOG(("Frame size change with dead callback"));
}
return true;
}
void InputManager::HandleEvent(sf::Event e) {
// check for resize event and recreate view
if(e.Type == sf::Event::Resized) {
Root::get_mutable_instance().ResetView();
}
// check for keyboard event
if(e.Type == sf::Event::KeyPressed or e.Type == sf::Event::KeyReleased) {
for(auto i = mKeyBindings.begin(); i != mKeyBindings.end(); ++i) {
if(i->Key == e.Key.Code or i->UseAnyKey) {
if((i->EventType == KEY_PRESSED and e.Type == sf::Event::KeyPressed) or
(i->EventType == KEY_RELEASED and e.Type == sf::Event::KeyReleased))
i->Callback();
}
}
}
// check for mouse event
if(e.Type == sf::Event::MouseButtonPressed or
e.Type == sf::Event::MouseButtonReleased or
e.Type == sf::Event::MouseMoved or
e.Type == sf::Event::MouseWheelMoved) {
for(auto i = mMouseBindings.begin(); i != mMouseBindings.end(); ++i) {
if((i->EventType == BUTTON_PRESSED and
e.Type == sf::Event::MouseButtonPressed)
and i->Button == e.MouseButton.Button) {
MouseEventArgs a;
a.SetScreenPixel(Vector2D(e.MouseButton.X, e.MouseButton.Y));
i->Callback(a);
} else if((i->EventType == BUTTON_RELEASED and
e.Type == sf::Event::MouseButtonReleased) and
i->Button == e.MouseButton.Button) {
MouseEventArgs a;
a.SetScreenPixel(Vector2D(e.MouseButton.X, e.MouseButton.Y));
i->Callback(a);
} else if(i->EventType == MOUSE_MOVED and
e.Type == sf::Event::MouseMoved) {
MouseEventArgs a;
a.SetScreenPixel(Vector2D(e.MouseMove.X, e.MouseMove.Y));
i->Callback(a);
} else if(i->EventType == WHEEL_MOVED and
e.Type == sf::Event::MouseWheelMoved) {
MouseEventArgs a;
a.WheelDelta = e.MouseWheel.Delta;
i->Callback(a);
}
}
}
}
void CUICustomEdit::Register_callbacks()
{
ec().assign_callback( DIK_ESCAPE, text_editor::ks_free, Callback( this, &CUICustomEdit::press_escape ) );
ec().assign_callback( DIK_RETURN, text_editor::ks_free, Callback( this, &CUICustomEdit::press_commit ) );
ec().assign_callback( DIK_NUMPADENTER, text_editor::ks_free, Callback( this, &CUICustomEdit::press_commit ) );
ec().assign_callback( DIK_GRAVE, text_editor::ks_free, Callback( this, &CUICustomEdit::nothing ) );
// ec().assign_callback( DIK_TAB, text_editor::ks_free, Callback( this, &CConsole::Find_cmd ) );
// ec().assign_callback( DIK_TAB, text_editor::ks_Shift, Callback( this, &CConsole::Find_cmd_back ) );
// ec().assign_callback( DIK_UP, text_editor::ks_free, Callback( this, &CConsole::Prev_cmd ) );
// ec().assign_callback( DIK_DOWN, text_editor::ks_free, Callback( this, &CConsole::Next_cmd ) );
// ec().assign_callback( DIK_TAB, text_editor::ks_Alt, Callback( this, &CConsole::GamePause ) );
}
LightNode::LightNode(const IEntityClassPtr& eclass) :
EntityNode(eclass),
_light(_entity,
*this,
Callback(boost::bind(&scene::Node::transformChanged, this)),
Callback(boost::bind(&scene::Node::boundsChanged, this)),
Callback(boost::bind(&LightNode::lightChanged, this))),
_lightCenterInstance(_light.getDoom3Radius().m_centerTransformed, boost::bind(&LightNode::selectedChangedComponent, this, _1)),
_lightTargetInstance(_light.targetTransformed(), boost::bind(&LightNode::selectedChangedComponent, this, _1)),
_lightRightInstance(_light.rightTransformed(), _light.targetTransformed(), boost::bind(&LightNode::selectedChangedComponent, this, _1)),
_lightUpInstance(_light.upTransformed(), _light.targetTransformed(), boost::bind(&LightNode::selectedChangedComponent, this, _1)),
_lightStartInstance(_light.startTransformed(), boost::bind(&LightNode::selectedChangedComponent, this, _1)),
_lightEndInstance(_light.endTransformed(), boost::bind(&LightNode::selectedChangedComponent, this, _1)),
m_dragPlanes(boost::bind(&LightNode::selectedChangedComponent, this, _1))
{}
void ForwardType::Fire(py::list argumentsList) {
for(std::list<ForwardFunction>::iterator it = Functions.begin();
it != Functions.end(); it++) {
ForwardFunction fwdFunction = *it;
PyThreadState *oldThreadState = PyThreadState_Get();
PyThreadState_Swap(fwdFunction.ThreadState);
py::object returnValue = py::object(true);
try {
py::object returnValue = fwdFunction.PythonFunction(*py::tuple(argumentsList));
}
catch(const py::error_already_set &) {
PyErr_Print();
}
PyThreadState_Swap(oldThreadState);
if(!Callback(returnValue)) {
PyThreadState_Swap(oldThreadState);
return;
}
}
}
CAddContactDlg(ADDCONTACTSTRUCT *acs) :
CDlgBase(g_hInst, IDD_ADDCONTACT),
m_chkAdded(this, IDC_ADDED),
m_chkAuth(this, IDC_AUTH),
m_chkOpen(this, IDC_OPEN_WINDOW),
m_btnOk(this, IDOK),
m_group(this, IDC_GROUP),
m_authReq(this, IDC_AUTHREQ),
m_myHandle(this, IDC_MYHANDLE)
{
m_chkAuth.OnChange = Callback(this, &CAddContactDlg::OnAuthClicked);
m_chkOpen.OnChange = Callback(this, &CAddContactDlg::OnOpenClicked);
m_btnOk.OnClick = Callback(this, &CAddContactDlg::OnOk);
m_acs = *acs;
}
bool cConnection::Read(void)
{
char temp[8193];
int size;
size = Socket->recv(temp, sizeof(temp)-1);
if (size >= 0)
{
Buffer.Add(temp, size);
temp[size] = 0;
}
if (Buffer.Get() && strstr(Buffer.Get(), "\r\n\r\n"))
{ // found the blank line
temp[0] = 0;
Buffer.Add(temp, 1);
Reading = false;
Buffer.FreeBeforeNextAdd();
if (Callback)
{
Callback(this);
}
return ReadCallback();
}
return false;
}
void cvar_t::ForceSet (const char *val)
{
if (m_Flags & CVAR_LATCH &&
!(m_Flags & CVAR_SERVERINFO && baseapp != server) &&
!(m_Flags & CVAR_CLIENTINFO && baseapp != client))
{
m_Flags |= CVAR_MODIFIED;
if(val)
m_LatchedString = val;
else
m_LatchedString = "";
}
else
{
m_Flags |= CVAR_MODIFIED;
if(val)
m_String = val;
else
m_String = "";
m_Value = atof (val);
if (m_Flags & CVAR_USERINFO)
D_UserInfoChanged (this);
if (m_Flags & CVAR_SERVERINFO)
D_SendServerInfoChange (this, val);
if (m_UseCallback)
Callback ();
}
m_Flags &= ~CVAR_ISDEFAULT;
}
static Callback from_function_e(UserData userdata) {
return Callback(
[=](Args && ... args) -> R {
return function_caller_e<UserData, Function>(std::forward<Args>(args)..., userdata);
}
);
}
SoundHandle::~SoundHandle()
{
if(hasCallback == true)
{
Callback();
}
/*
* i was running into a bug because i didnt do the isvalid / NULL
* checks ..
* sources get removed even if you dont do RemoveSource
* but it will not dereference them! ..
*/
if(sndstream != NULL)
{
SoundSystemManager::GetSingleton().GetSoundSystem()->RemoveStream(sndstream);
}
if(sndsource != NULL)
{
SoundSystemManager::GetSingleton().GetSoundSystem()->RemoveSource(sndsource);
}
if(delayActive)
{
SoundSystemManager::GetSingleton().eventTimer->RemoveTimerEvent(this);
}
}
CJabberDlgGcJoin::CJabberDlgGcJoin(CJabberProto *proto, TCHAR *jid) :
CSuper(proto, IDD_GROUPCHAT_JOIN, NULL),
btnOk(this, IDOK),
m_jid(mir_tstrdup(jid))
{
btnOk.OnClick = Callback(this, &CJabberDlgGcJoin::OnBtnOk);
}
uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length
#if !defined(NO_STREAM_CALLBACKS)
, uint8_t (* const Callback)(void)
#endif
)
{
uint8_t* DataStream = (uint8_t*)(Buffer + Length - 1);
uint8_t ErrorCode;
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
while (Length--)
{
if (!(Endpoint_ReadWriteAllowed()))
{
Endpoint_ClearCurrentBank();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return ENDPOINT_RWSTREAM_ERROR_CallbackAborted;
#endif
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
}
*(DataStream--) = Endpoint_Read_Byte();
}
return ENDPOINT_RWSTREAM_ERROR_NoError;
}
/** The constructor
*
* Create a new MessageBox with an empty message.
*
* \param vTitle The title of the message box
* \param vGui The GUI object
* \param sid The skin identifier
*
*/
RainbruRPG::OgreGui::RbMessageBox::
RbMessageBox( const String& vTitle, GUI* vGui, OgreGuiSkinID sid):
Dialog(Vector4(10, 10, 300, 100), vTitle, vGui, sid),
message(""),
title(vTitle),
width(300),
height(100),
caption(NULL),
btnOk(NULL)
{
// Center the dialog
unsigned int rwWidth, rwHeight, posX, posY;
rwWidth=GameEngine::getSingleton().getRenderWindow()->getWidth();
rwHeight=GameEngine::getSingleton().getRenderWindow()->getHeight();
posX=(rwWidth/2)-(width/2);
posY=(rwHeight/2)-(height/2);
LOGI(_("Centering the Dialog"));
move(posY, posY);
// Adds default widgets
Vector4 labDim=Vector4(2, 24, width-20, 30);
caption=new Label( labDim, "Unset", this );
addWidget(caption);
Vector4 btnDim=Vector4( (width/2)-50, height-30, 100, 24 );
btnOk=new PushButton (btnDim, "OK", Callback(this), this);
addWidget(btnOk);
}
static Callback from_method_e(C * instance, UserData userdata) {
return Callback(
[=](Args && ... args) -> R {
return method_caller_e<C, UserData, CMethod>(instance, std::forward<Args>(args)..., userdata);
}
);
}
uint8_t Pipe_Write_Stream_LE(const void* Data, uint16_t Length
#if !defined(NO_STREAM_CALLBACKS)
, uint8_t (* const Callback)(void)
#endif
)
{
uint8_t* DataStream = (uint8_t*)Data;
uint8_t ErrorCode;
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
while (Length--)
{
if (!(Pipe_ReadWriteAllowed()))
{
Pipe_ClearCurrentBank();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return PIPE_RWSTREAM_ERROR_CallbackAborted;
#endif
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
}
Pipe_Write_Byte(*(DataStream++));
}
return PIPE_RWSTREAM_ERROR_NoError;
}
static Callback from_method(C * instance) {
return Callback(
[=](Args && ... args) -> R {
return method_caller<C, CMethod>(instance, std::forward<Args>(args)...);
}
);
}
Widget& Widget::operator= (const Widget& right)
{
// Make sure it is not the same widget
if (this != &right)
{
this->sf::Drawable::operator=(right);
this->Transformable::operator=(right);
this->CallbackManager::operator=(right);
m_Enabled = right.m_Enabled;
m_Visible = right.m_Visible;
m_Loaded = right.m_Loaded;
m_WidgetPhase = right.m_WidgetPhase;
m_Parent = right.m_Parent;
m_Opacity = right.m_Opacity;
m_MouseHover = false;
m_MouseDown = false;
m_Focused = false;
m_AllowFocus = right.m_AllowFocus;
m_AnimatedWidget = right.m_AnimatedWidget;
m_DraggableWidget = right.m_DraggableWidget;
m_ContainerWidget = right.m_ContainerWidget;
m_Callback = Callback();
m_Callback.widget = nullptr;
m_Callback.widgetType = right.m_Callback.widgetType;
m_Callback.id = right.m_Callback.id;
}
return *this;
}
int CSNMPMessage::ResendMessage()
{
if (m_received)
{
// Don't bother to resend if we already have the response
SetSendTime();
return SNMP_CLASS_SUCCESS;
}
if (m_target->get_retry() <= 0)
{
// This message has timed out
Callback(SNMP_CLASS_TIMEOUT); // perform callback with the error
return SNMP_CLASS_TIMEOUT;
}
m_target->set_retry(m_target->get_retry() - 1);
SetSendTime();
int status = send_snmp_request(m_socket, m_rawPdu, m_rawPduLen, *m_address);
if (status != 0)
return SNMP_CLASS_TL_FAILED;
return SNMP_CLASS_SUCCESS;
}
