void InputHandler::Clear()
{
InputHandler * ih = Get();
while (!ih->Binds.empty())
Unregister(ih->Binds.front()->Key, true, true);
}
wxClassInfo::~wxClassInfo()
{
// remove this object from the linked list of all class infos: if we don't
// do it, loading/unloading a DLL containing static wxClassInfo objects is
// not going to work
if ( this == sm_first )
{
sm_first = m_next;
}
else
{
wxClassInfo *info = sm_first;
while (info)
{
if ( info->m_next == this )
{
info->m_next = m_next;
break;
}
info = info->m_next;
}
}
Unregister();
}
//
// GPWindow::~GPWindow
//
// Destruct the window. This calls Unregister().
//
GPWindow::~GPWindow() {
Unregister();
if (savemessage) {
delete savemessage;
}
delete savePanel;
}
void UJavascriptAssetTypeActions::Refresh()
{
if (bRegistered)
{
Unregister();
Register();
}
}
void UJavascriptAssetEditorToolkit::Refresh()
{
if (bRegistered)
{
Unregister();
Register();
}
}
CPipeState_Listening::~CPipeState_Listening()
{
Unregister();
#ifdef _WIN32
m_Event.Destroy();
#endif
}
void GlobalShortcuts::ReloadSettings() {
// The actual shortcuts have been set in our actions for us by the config
// dialog already - we just need to reread the gnome settings.
use_gnome_ = settings_.value("use_gnome", true).toBool();
Unregister();
Register();
}
TaskQueue *TaskQueue::TaskQueueList::TakeFirst(int list_index_) {
t_assert(!Empty(list_index_));
auto queue = lists_[list_index_];
Unregister(queue);
// log_msgs.push_back("Unregistered from list in TakeFirst");
return queue;
}
VuCollection::~VuCollection(){
if (registered){
Unregister();
}
if (mutex_){
VuxDestroyMutex(mutex_);
}
}
void USpawnMovementComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) {
CurrentCountDown = FMath::Clamp(CurrentCountDown, 0.0f, TimeCount) - DeltaTime;
if (CurrentCountDown < DeltaTime && detachElements.Num() > counter) {
CurrentCountDown = TimeCount;
Unregister(detachElements[counter]);
++counter;
}
}
CPipeState_Connecting::~CPipeState_Connecting()
{
if(m_Socket)
Unregister();
#ifdef _WIN32
m_Event.Destroy();
#endif
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
intf_sys_t *p_sys;
p_intf->p_sys = p_sys = calloc( 1, sizeof(*p_sys) );
if( !p_sys )
return VLC_ENOMEM;
char *psz_display = var_CreateGetNonEmptyString( p_intf, "x11-display" );
int i_screen_default;
p_sys->p_connection = xcb_connect( psz_display, &i_screen_default );
free( psz_display );
if( !p_sys->p_connection )
goto error;
/* Get the root windows of the default screen */
const xcb_setup_t* xcbsetup = xcb_get_setup( p_sys->p_connection );
if( !xcbsetup )
goto error;
xcb_screen_iterator_t iter = xcb_setup_roots_iterator( xcbsetup );
for( int i = 0; i < i_screen_default; i++ )
{
if( !iter.rem )
break;
xcb_screen_next( &iter );
}
if( !iter.rem )
goto error;
p_sys->root = iter.data->root;
/* */
p_sys->p_symbols = xcb_key_symbols_alloc( p_sys->p_connection ); // FIXME
if( !p_sys->p_symbols )
goto error;
Mapping( p_intf );
Register( p_intf );
if( vlc_clone( &p_sys->thread, Thread, p_intf, VLC_THREAD_PRIORITY_LOW ) )
{
Unregister( p_intf );
free( p_sys->p_map );
goto error;
}
return VLC_SUCCESS;
error:
if( p_sys->p_symbols )
xcb_key_symbols_free( p_sys->p_symbols );
if( p_sys->p_connection )
xcb_disconnect( p_sys->p_connection );
free( p_sys );
return VLC_EGENERIC;
}
void GOrgueMidiListener::Register(GOrgueMidi* midi)
{
Unregister();
if (midi)
{
m_midi = midi;
m_midi->Register(this);
}
}
void UJavascriptAssetEditorToolkit::Refresh()
{
#if WITH_EDITOR
if (bRegistered)
{
Unregister();
Register();
}
#endif
}
TargetSettingsWin::~TargetSettingsWin()
{
//delete all views
fCurrentSettingsView->RemoveSelf(); //first remove current view
delete fGeneralSettingsView;
delete fCompilerSettingsView;
delete fLinkerSettingsView;
delete fIncludeSettingsView;
Unregister();
}
void
_XawImUnregister(Widget inwidg)
{
XawVendorShellExtPart *ve;
VendorShellWidget vw;
if ((vw = SearchVendorShell(inwidg)) == NULL) return;
if ((ve = GetExtPart(vw)) != NULL) {
Unregister(inwidg, ve);
}
}
void CHotKey::SetKey( DWORD key, bool bSave )
{
if(m_Key == key)
{
return;
}
if(m_bIsRegistered)
Unregister();
m_Key = key;
if(bSave)
SaveKey();
}
pfConsoleCmd::~pfConsoleCmd()
{
int i;
for( i = 0; i < fSigLabels.GetCount(); i++ )
{
delete [] fSigLabels[ i ];
}
Unregister();
fSignature.Reset();
fSigLabels.Reset();
}
/*****************************************************************************
* Close:
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
intf_sys_t *p_sys = p_intf->p_sys;
vlc_cancel( p_sys->thread );
vlc_join( p_sys->thread, NULL );
Unregister( p_intf );
free( p_sys->p_map );
xcb_key_symbols_free( p_sys->p_symbols );
xcb_disconnect( p_sys->p_connection );
free( p_sys );
}
// ----------------------------------------------------------------------------
// * ~GuidoCarbonControl
// ----------------------------------------------------------------------------
GuidoCarbonControl::~GuidoCarbonControl()
{
std::vector<GuidoCarbonControl *>::iterator elt;
for( elt = sControlList.begin(); elt != sControlList.end(); ++ elt )
{
if( *elt == this )
{
sControlList.erase( elt );
break;
}
}
if( sControlList.size() == 0 )
Unregister();
}
void CPlayerPlugin_InteractiveEntityMonitor::HandleEvent( EPlayerPlugInEvent theEvent, void * data )
{
switch(theEvent)
{
case EPE_Die:
{
EnableHighlighting(false);
break;
}
case EPE_Spawn:
{
EnableHighlighting(true);
m_timeUntilRefresh = -1.f;
break;
}
case EPE_InteractiveEntityRegister:
{
Register((IEntity*)data, 0);
break;
}
case EPE_InteractiveEntityRegisterShoot:
{
Register((IEntity*)data, EIES_ShootToInteract);
break;
}
case EPE_InteractiveEntityUnregister:
{
Unregister((IEntity*)data);
break;
}
case EPE_InteractiveEntitySetEnabled:
{
bool enable = *(bool*)data;
if(enable && !m_bEnabled)
{
EnableHighlighting(true);
m_timeUntilRefresh = -1.f;
}
else if(!enable && m_bEnabled)
{
EnableHighlighting(false);
}
break;
}
}
CPlayerPlugin::HandleEvent(theEvent, data);
}
void
Network::remove_stream(
NetStream *s
)
{
// notify observers. (Do this before deleting the stream)
notify_net(Network_obs::remove_str, s);
int i=0;
while (i<nStreams_ && streams_[i] != s) ++i;
if (i < nStreams_) {
Unregister(s);
streams_[i] = streams_[--nStreams_];
delete s;
}
}
void emModel::Free()
{
RefCount--;
if (RefCount<=0) {
delete this;
}
else if (RefCount==1 && IsCommon()) {
if (MinCommonLifetime==0) {
Unregister();
}
else if (((int)MinCommonLifetime)>0) {
TimeOfDeath=Context.SharedTiming->SecsCounter+MinCommonLifetime;
Context.DoGCOnModels=true;
}
}
}
bool VirtualBoxBridge::deleteVM(IMachine *m)
{
uint32_t medias_size;
IMedium ** medias;
nsresult rc;
NS_CHECK_AND_DEBUG_ERROR(m, Unregister(CleanupMode::Full, &medias_size, &medias), rc);
if(NS_FAILED(rc))
return false;
std::cout << "medias_size: " << medias_size << std::endl;
bool succeeded = true;
for(int i = 0; i < medias_size; i++)
{
nsXPIDLString media_name;
nsXPIDLString media_location;
medias[i]->GetName(getter_Copies(media_name));
medias[i]->GetLocation(getter_Copies(media_location));
std::cout << "Deleting media " << returnQStringValue(media_name).toStdString()
<< " (" << returnQStringValue(media_location).toStdString() << ")" << std::endl;
IProgress *progress;
int32_t resultCode;
medias[i]->DeleteStorage(&progress);
progress->WaitForCompletion(-1);
progress->GetResultCode(&resultCode);
if(resultCode != 0)
{
succeeded= false;
std::cerr << "Error while deleting media " << returnQStringValue(media_name).toStdString()
<< " (" << returnQStringValue(media_location).toStdString() << ")" << std::endl;
}
if(resultCode == 0)
{
QFile media_file(returnQStringValue(media_location));
if(media_file.exists())
media_file.remove();
}
}
return succeeded;
}
void InputHandler::Register(int key, int modifiers, int down, float downDur, int up, float upDur)
{
Unregister(key, down != 0, up != 0);
InputHandler * ih = Get();
InputBind * bind = new InputBind();
bind->Key = key;
bind->Modifiers = modifiers;
bind->ProfileUp = up;
bind->ProfileDurationUp = upDur;
bind->ProfileDown = down;
bind->ProfileDurationDown = downDur;
bind->IsDown = IsKeyDown(key, modifiers);
ih->Binds.push_back(bind);
}
void Player::SkipCinematic
(
Event *ev
)
{
if( level.cinematic && ( level.RegisterSize( STRING_SKIP ) ) )
{
ScriptThreadLabel skiplabel;
G_ClearFade();
Unregister( STRING_SKIP );
// reset the roll on our view just in case
v_angle.z = 0;
SetViewAngles( v_angle );
}
}
int ProcessArgs(nsIComponentRegistrar* registrar, int argc, char *argv[])
{
int i = 1;
nsresult res;
while (i < argc) {
if (argv[i][0] == '-') {
int j;
for (j = 1; argv[i][j] != '\0'; j++) {
switch (argv[i][j]) {
case 'u':
gUnreg = true;
break;
default:
cerr << "Unknown option '" << argv[i][j] << "'\n";
}
}
i++;
} else {
if (gUnreg) {
res = Unregister(argv[i]);
if (NS_SUCCEEDED(res)) {
cout << "Successfully unregistered: " << argv[i] << "\n";
} else {
cerr << "Unregister failed (";
print_err(res);
cerr << "): " << argv[i] << "\n";
}
} else {
res = Register(registrar, argv[i]);
if (NS_SUCCEEDED(res)) {
cout << "Successfully registered: " << argv[i] << "\n";
} else {
cerr << "Register failed (";
print_err(res);
cerr << "): " << argv[i] << "\n";
}
}
i++;
}
}
return 0;
}
BOOL CSessionNotify::Register(HWND hWnd)
{
ASSERT(m_hWTSAPI == NULL); Unregister();
m_hWTSAPI = AU_LoadLibrary(_T("Wtsapi32.dll"));
if(m_hWTSAPI == NULL) return TRUE; // We're running on Win9x/Win2000?
m_hTarget = hWnd;
m_lpWTSRegisterSessionNotification = (LPWTSREGISTERSESSIONNOTIFICATION)GetProcAddress(m_hWTSAPI,
"WTSRegisterSessionNotification");
m_lpWTSUnRegisterSessionNotification = (LPWTSUNREGISTERSESSIONNOTIFICATION)GetProcAddress(m_hWTSAPI,
"WTSUnRegisterSessionNotification");
if(m_lpWTSRegisterSessionNotification != NULL)
return m_lpWTSRegisterSessionNotification(hWnd, 0); // 0 = NOTIFY_FOR_THIS_SESSION
return TRUE;
}
LuaReference &LuaReference::operator=( const LuaReference &cpy )
{
if( this == &cpy )
return *this;
Unregister();
if( cpy.m_iReference == LUA_NOREF )
m_iReference = LUA_NOREF;
else
{
/* Make a new reference. */
Lua *L = LUA->Get();
lua_rawgeti( L, LUA_REGISTRYINDEX, cpy.m_iReference );
m_iReference = luaL_ref( L, LUA_REGISTRYINDEX );
LUA->Release( L );
}
return *this;
}
Register(const char* name, const char* organization, const char* code)
{
LONG r = 0;
int i = 0;
r = ERROR_SUCCESS;
RegKeyValues[3][1] = name;
RegKeyValues[4][1] = organization;
RegKeyValues[5][1] = code;
for (i = 0; r == ERROR_SUCCESS && i < RegKeyValuesNum; i++)
r = RegSetValue(HKEY_CLASSES_ROOT,
RegKeyValues[i][0],
REG_SZ,
RegKeyValues[i][1],
lstrlen(RegKeyValues[i][1]));
if (r != ERROR_SUCCESS)
Unregister();
return (r == ERROR_SUCCESS) ? true : false;
}
