void BattleListFilter::OnChangeMap ( wxCommandEvent& event )
{
if ( m_filter_map_edit == NULL ) return;
if ( m_filter_map_expression == NULL )
m_filter_map_expression = new wxRegEx(m_filter_map_edit->GetValue(), wxRE_ICASE);
else
m_filter_map_expression->Compile(m_filter_map_edit->GetValue(), wxRE_ICASE);
OnChange(event);
}
void GUI_TextField::DeleteCurrChar(void)
{
if (cursorpos < buffer_index) {
char *bkup = strdup(buffer);
strncpy(buffer + cursorpos, bkup + cursorpos + 1, buffer_index - cursorpos);
buffer[--buffer_index] = '\0';
free(bkup);
OnChange();
SetChanged(1);
}
}
bool CAccessControlListGroup::AddACL ( CAccessControlList* pACL )
{
if ( !IsACLPresent ( pACL ) )
{
m_ACLs.push_back ( pACL );
OnChange ();
return true;
}
return false;
}
void frmReport::OnBrowseStylesheet(wxCommandEvent &ev)
{
if (rbHtml->GetValue())
{
wxString def = txtHtmlStylesheet->GetValue();
if (!wxFile::Exists(def))
def.Empty();
#ifdef __WXMSW__
wxFileDialog file(this, _("Select stylesheet filename"), wxGetHomeDir(), def, _("HTML Stylesheet files (*.css)|*.css|All files (*.*)|*.*"), wxFD_OPEN);
#else
wxFileDialog file(this, _("Select stylesheet filename"), wxGetHomeDir(), def, _("HTML Stylesheet files (*.css)|*.css|All files (*)|*"), wxFD_OPEN);
#endif
if (file.ShowModal() == wxID_OK)
{
txtHtmlStylesheet->SetValue(file.GetPath());
OnChange(ev);
}
}
else
{
wxString def = txtXmlStylesheet->GetValue();
if (!wxFile::Exists(def))
def.Empty();
#ifdef __WXMSW__
wxFileDialog file(this, _("Select stylesheet filename"), wxGetHomeDir(), def, _("XML Stylesheet files (*.xsl)|*.xsl|All files (*.*)|*.*"), wxFD_OPEN);
#else
wxFileDialog file(this, _("Select stylesheet filename"), wxGetHomeDir(), def, _("XML Stylesheet files (*.xsl)|*.xsl|All files (*)|*"), wxFD_OPEN);
#endif
if (file.ShowModal() == wxID_OK)
{
txtXmlStylesheet->SetValue(file.GetPath());
OnChange(ev);
}
}
}
void frmRestore::OnChangeSchema(wxCommandEvent &ev)
{
if (chkOnlySchema->GetValue())
{
chkOnlyData->SetValue(false);
chkOnlyData->Disable();
}
else
chkOnlyData->Enable();
OnChange(ev);
}
void dlgLanguage::OnChangeName(wxCommandEvent &ev)
{
if (connection->BackendMinimumVersion(8, 1) && !language)
{
bool useTemplate = (cbName->FindString(cbName->wxComboBox::GetValue()) >= 0);
chkTrusted->Enable(!useTemplate);
cbHandler->Enable(!useTemplate);
cbInline->Enable(!useTemplate && connection->BackendMinimumVersion(9, 0));
cbValidator->Enable(!useTemplate);
}
OnChange(ev);
}
void CAccessControlListManager::DeleteACL ( class CAccessControlList* pACL )
{
assert ( pACL );
// Remove its dependencies among the groups
RemoveACLDependencies ( pACL );
// Delete the class and remove it from the list
delete pACL;
m_ACLs.remove ( pACL );
OnChange ();
}
CAccessControlList::~CAccessControlList ( void )
{
CIdArray::PushUniqueId ( this, EIdClass::ACL, m_uiScriptID );
list < CAccessControlListRight* > ::iterator iter = m_Rights.begin ();
for ( ; iter != m_Rights.end (); iter++ )
{
delete *iter;
}
m_Rights.clear ();
OnChange ();
}
CAccessControlListGroup::~CAccessControlListGroup ( void )
{
CIdArray::PushUniqueId ( this, EIdClass::ACL_GROUP, m_uiScriptID );
ObjectList::iterator iter = m_Objects.begin ();
for ( ; iter != m_Objects.end (); iter++ )
{
delete *iter;
}
m_Objects.clear ();
m_ObjectsById.clear ();
OnChange ();
}
CAccessControlListRight* CAccessControlList::AddRight ( const char* szRightName, CAccessControlListRight::ERightType eRightType, bool bAccess )
{
CAccessControlListRight* pRight = GetRight ( szRightName, eRightType );
if ( !pRight )
{
pRight = new CAccessControlListRight ( szRightName, eRightType, bAccess, m_pACLManager );
m_Rights.push_back ( pRight );
OnChange ();
}
return pRight;
}
void CAccessControlListManager::ClearACLs ( void )
{
// Return true if it exists
list < CAccessControlList* > ::iterator iter = m_ACLs.begin ();
for ( ; iter != m_ACLs.end (); iter++ )
{
delete *iter;
}
// Clear the list
m_ACLs.clear ();
OnChange ();
}
void CAccessControlListManager::ClearGroups ( void )
{
// Delete all the ACLs
list < CAccessControlListGroup* > ::iterator iter = m_Groups.begin ();
for ( ; iter != m_Groups.end (); iter++ )
{
delete *iter;
}
// Clear the list
m_Groups.clear ();
OnChange ();
}
//---------------------------------------------------------------------------
void __fastcall TConfiguration::Changed()
{
if (FUpdating == 0)
{
if (OnChange)
{
OnChange(this);
}
}
else
{
FChanged = true;
}
}
void FindContoursSidebar::OnChooseAuto( wxCommandEvent& event )
{
if (autoThresh->GetValue())
{
thresh1->Disable();
thresh2->Disable();
}
else
{
thresh1->Enable();
thresh2->Enable();
}
OnChange();
}
void GUI_TextField::Backspace(void)
{
if (buffer_index > 0 && cursorpos > 0) {
if (cursorpos < buffer_index) {
char *bkup = strdup(buffer);
strncpy(buffer + cursorpos - 1, bkup + cursorpos, buffer_index - cursorpos);
free(bkup);
}
buffer[--buffer_index] = '\0';
SetCursorPos(cursorpos - 1);
OnChange();
SetChanged(1);
}
}
CAccessControlList* CAccessControlListManager::AddACL ( const char* szACLName )
{
// Grab the ACL with that name. Only add it if we don't already have it
CAccessControlList* pACL = GetACL ( szACLName );
if ( !pACL )
{
// Create it and put it back in our list
pACL = new CAccessControlList ( szACLName, this );
m_ACLs.push_back ( pACL );
OnChange ();
}
return pACL;
}
CAccessControlListGroup* CAccessControlListManager::AddGroup ( const char* szGroupName )
{
// Grab the group with that name already. Only add it if it doesn't exist already
CAccessControlListGroup* pGroup = GetGroup ( szGroupName );
if ( !pGroup )
{
// Create it and put it back in our list
pGroup = new CAccessControlListGroup ( szGroupName );
m_Groups.push_back ( pGroup );
OnChange ();
}
return pGroup;
}
void CParmGlobal::SetValue(tint32 iValueNew, tbool bCallOnChange)
{
if (iValueNew < miMinValue) {
iValueNew = miMinValue;
}
if (iValueNew > miMaxValue) {
iValueNew = miMaxValue;
}
miValue = iValueNew;
if (bCallOnChange) {
OnChange();
}
}
void Store::ShadowFile(StringSection<ResChar> filename)
{
auto record = GetRetainedFileRecord(filename);
record->_state._status = DependentFileState::Status::Shadowed;
// propagate change messages...
// (duplicating processing from RegisterFileDependency)
ResChar directoryName[MaxPath];
FileNameSplitter<ResChar> splitter(filename);
SplitPath<ResChar>(splitter.DriveAndPath()).Simplify().Rebuild(directoryName);
FakeFileChange(StringSection<ResChar>(directoryName), splitter.FileAndExtension());
record->OnChange();
}
void dlgDatabase::OnChangeRestr(wxCommandEvent &ev)
{
if (txtSchemaRestr->GetValue().IsEmpty())
schemaRestrictionOk = true;
else
{
wxString sql = wxT("EXPLAIN SELECT 1 FROM pg_namespace\n")
wxT("WHERE nspname IN (") + txtSchemaRestr->GetValue() + wxT(")");
wxLogNull nix;
wxString result = connection->ExecuteScalar(sql);
schemaRestrictionOk = !result.IsEmpty();
}
OnChange(ev);
}
/*----------------------------------------------------------------------------------------------
Display TsString in the control
(may be explicitly called when created by ATL, because in this case TssEdit::Create() will
not be called)
----------------------------------------------------------------------------------------------*/
void TssEdit::PostCreate(ITsString * ptss)
{
AssertPtrN(ptss);
if (ptss)
{
int cch;
ITsStringPtr qtss = ptss;
CheckHr(qtss->get_Length(&cch));
// Treat as inserting all the characters, since the cache previously had nothing.
CheckHr(m_qcda->PropChanged(NULL, kpctNotifyAll, khvoString, ktagString, 0, cch, 0));
OnUpdate();
::UpdateWindow(m_hwnd);
OnChange();
}
}
void frmBackup::OnChangePlain(wxCommandEvent &ev)
{
bool isPlain = (rbxFormat->GetSelection() == 2);
chkBlobs->Enable(canBlob && !isPlain);
chkOnlyData->Enable(isPlain && !chkOnlySchema->GetValue());
if (isPlain)
isPlain = !chkOnlyData->GetValue();
chkOnlySchema->Enable(isPlain);
chkNoOwner->Enable(isPlain);
chkDropDb->Enable(isPlain);
chkCreateDb->Enable(isPlain);
chkDisableTrigger->Enable(chkOnlyData->GetValue());
wxCommandEvent nullEvent;
OnChange(nullEvent);
}
CAccessControlListGroupObject* CAccessControlListGroup::AddObject ( const char* szObjectName, CAccessControlListGroupObject::EObjectType eObjectType )
{
unsigned int uiHash = CAccessControlListGroupObject::GenerateHashId ( szObjectName, eObjectType );
ObjectMap::const_iterator iter = m_ObjectsById.find ( uiHash );
if ( iter != m_ObjectsById.end() )
{
return iter->second;
}
CAccessControlListGroupObject* pObject = new CAccessControlListGroupObject ( szObjectName, eObjectType );
m_Objects.push_back ( pObject );
m_ObjectsById.insert ( ObjectMap::value_type ( pObject->GetObjectHashId(), pObject ) );
OnChange ();
return pObject;
}
/*----------------------------------------------------------------------------------------------
Trap a character so that we can call the OnUpdate and OnChange methods.
----------------------------------------------------------------------------------------------*/
void TssEdit::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
SuperClass::OnChar(nChar, nRepCnt, nFlags);
IVwSelectionPtr qvwsel;
AssertPtr(m_qrootb);
CheckHr(m_qrootb->get_Selection(&qvwsel));
if (qvwsel)
{
ComBool fOk;
CheckHr(qvwsel->Commit(&fOk));
}
OnUpdate();
::UpdateWindow(m_hwnd);
OnChange();
}
void COleClientItem::OnActivate()
{
ASSERT_VALID(this);
// it is necessary to lock the object when it is in-place
// (without this, a link to an embedding may disconnect unexpectedly)
if (!m_bLocked)
{
OleLockRunning(m_lpObject, TRUE, FALSE);
m_bLocked = TRUE;
}
// notify the item of the state change
if (m_nItemState != activeState)
{
OnChange(OLE_CHANGED_STATE, (DWORD)activeState);
m_nItemState = activeState;
}
}
void dlgHbaConfig::OnAddValue(wxCommandEvent &ev)
{
if (databaseAdding)
{
cbDatabase->SetSelection(-1);
cbDatabase->SetValue(database);
cbDatabase->SetInsertionPointEnd();
databaseAdding = false;
}
if (userAdding)
{
cbUser->SetSelection(-1);
cbUser->SetValue(user);
cbUser->SetInsertionPointEnd();
userAdding = false;
}
OnChange(ev);
}
bool CAccessControlListGroup::RemoveObject ( const char* szObjectName, CAccessControlListGroupObject::EObjectType eObjectType )
{
unsigned int uiHash = CAccessControlListGroupObject::GenerateHashId ( szObjectName, eObjectType );
// Try to find a match and delete it
ObjectMap::iterator iter = m_ObjectsById.find ( uiHash );
if ( iter != m_ObjectsById.end() )
{
// Delete, remove from list and return true
delete ( iter->second );
m_Objects.remove ( iter->second );
m_ObjectsById.erase( iter );
OnChange ();
return true;
}
return false;
}
bool CAccessControlList::RemoveRight ( const char* szRightName, CAccessControlListRight::ERightType eRightType )
{
unsigned int uiHash = HashString ( szRightName );
list < CAccessControlListRight* > ::iterator iter = m_Rights.begin ();
for ( ; iter != m_Rights.end (); iter++ )
{
CAccessControlListRight* pACLRight = *iter;
if ( pACLRight->GetRightNameHash () == uiHash && eRightType == pACLRight->GetRightType ()
&& SStringX ( szRightName ) == pACLRight->GetRightName () )
{
m_Rights.remove ( pACLRight );
delete pACLRight;
OnChange ();
return true;
}
}
return false;
}
void frmRestore::OnSelectFilename(wxCommandEvent &ev)
{
wxString FilenameOnly;
wxFileName::SplitPath(txtFilename->GetValue(), NULL, NULL, &FilenameOnly, NULL);
#ifdef __WXMSW__
wxFileDialog file(this, _("Select backup filename"), ::wxPathOnly(txtFilename->GetValue()), FilenameOnly,
_("Backup files (*.backup)|*.backup|All files (*.*)|*.*"));
#else
wxFileDialog file(this, _("Select backup filename"), ::wxPathOnly(txtFilename->GetValue()), FilenameOnly,
_("Backup files (*.backup)|*.backup|All files (*)|*"));
#endif
if (file.ShowModal() == wxID_OK)
{
txtFilename->SetValue(file.GetPath());
OnChange(ev);
}
}
void frmBackupGlobals::OnSelectFilename(wxCommandEvent &ev)
{
wxString title, prompt, FilenameOnly;
title = _("Select output file");
#ifdef __WXMSW__
prompt = _("Query files (*.sql)|*.sql|All files (*.*)|*.*");
#else
prompt = _("Query files (*.sql)|*.sql|All files (*)|*");
#endif
wxFileName::SplitPath(txtFilename->GetValue(), NULL, NULL, &FilenameOnly, NULL);
wxFileDialog file(this, title, ::wxPathOnly(txtFilename->GetValue()), FilenameOnly, prompt, wxFD_SAVE);
if (file.ShowModal() == wxID_OK)
{
txtFilename->SetValue(file.GetPath());
OnChange(ev);
}
}
