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

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 FindContoursSidebar::OnChooseAuto( wxCommandEvent& event )
{
    if (autoThresh->GetValue())
    {
        thresh1->Disable();
        thresh2->Disable();
    }
    else
    {
        thresh1->Enable();
        thresh2->Enable();
    }
    OnChange();
}

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