void DestroyInternalEditor() { if (m_InternalEditor != null) { // Do not destroy anything if we are just reloading assemblies or re-importing. bool shouldDestroyEverything = Unsupported.IsDestroyScriptableObject(this); if (shouldDestroyEverything) { DestroyImmediate(m_InternalEditor); } // On Destroy, look for instances id instead of target because they may already be null. for (var index = 0; index < m_PresetsInstanceIds.Count; index++) { var instanceId = m_PresetsInstanceIds[index]; if (--s_References[instanceId].count == 0) { if (shouldDestroyEverything) { if (s_References[instanceId].reference is Component) { var go = ((Component)s_References[instanceId].reference).gameObject; go.hideFlags = HideFlags.None; // make sure we remove the don't destroy flag before calling destroy DestroyImmediate(go); } else { DestroyImmediate(s_References[instanceId].reference); } } s_References.Remove(instanceId); } } } }
// internal override void OnHeaderIconGUI(Rect iconRect) // { // this.assetEditor.OnHeaderIconGUI(iconRect); // } // internal override SerializedObject GetSerializedObjectInternal() // { // if (this.m_SerializedObject == null) // { // this.m_SerializedObject = SerializedObject.LoadFromCache(base.GetInstanceID()); // } // if (this.m_SerializedObject == null) // { // this.m_SerializedObject = new SerializedObject(base.targets); // } // return this.m_SerializedObject; // } public virtual void OnDisable() { AssetImporter assetImporter = this.target as AssetImporter; if (Unsupported.IsDestroyScriptableObject(this) && this.m_MightHaveModified && assetImporter != null && !InternalEditorUtility.ignoreInspectorChanges && this.HasModified() && !this.AssetWasUpdated()) { string message = "Unapplied import settings for '" + assetImporter.assetPath + "'"; if (base.targets.Length > 1) { message = "Unapplied import settings for '" + base.targets.Length + "' files"; } if (EditorUtility.DisplayDialog("Unapplied import settings", message, "Apply", "Revert")) { this.Apply(); this.m_MightHaveModified = false; AssetImporterInspector.ImportAssets(this.GetAssetPaths()); } } /* * if (this.serializedObject != null && this.serializedObject.hasModifiedProperties) * { * this.serializedObject.Cache(base.GetInstanceID()); * this.serializedObject = null; * } */ }
public override void OnDisable() { if (Unsupported.IsDestroyScriptableObject(this)) { if (spriteAtlasAsset && HasModified()) { if (EditorUtility.DisplayDialog("Unapplied import settings", "Unapplied import settings for \'" + m_AssetPath + "\'", "Apply", "Revert")) { ApplyAndImportSpriteAtlas(); } else { ResetValues(); } } } base.OnDisable(); }
public virtual void OnDisable() { ////FIXME: The code below wreaks havoc with tabbed editors. Triggering a re-import will //// cause all active editors to be destroyed which, if we're part of a tabbed editor, //// will take down our parent while it is trying to switch editors. Also, we'll be //// doing all this while InspectorWindow.OnGUI() is still going through the active //// editors to draw them so we're killing them right under its nose. // When destroying the inspector check if we have any unapplied modifications // and apply them. AssetImporter importer = target as AssetImporter; if (Unsupported.IsDestroyScriptableObject(this) && m_MightHaveModified && importer != null && HasModified() && !AssetWasUpdated()) { string dialogText = string.Format(L10n.Tr("Unapplied import settings for \'{0}\'"), importer.assetPath); if (targets.Length > 1) { dialogText = string.Format(L10n.Tr("Unapplied import settings for \'{0}\' files"), targets.Length); } if (EditorUtility.DisplayDialog(L10n.Tr("Unapplied import settings"), dialogText, L10n.Tr("Apply"), L10n.Tr("Revert"))) { Apply(); m_MightHaveModified = false; ImportAssets(GetAssetPaths()); } } // Only cache SerializedObject if it has modified properties. // If we have multiple editors (e.g. a tabbed editor and its editor for the active tab) we don't // want the one that doesn't do anything with the SerializedObject to overwrite the cache. if (m_SerializedObject != null && m_SerializedObject.hasModifiedProperties) { m_SerializedObject.Cache(GetInstanceID()); m_SerializedObject = null; } }
public virtual void OnDisable() { AssetImporter assetImporter = base.target as AssetImporter; if (Unsupported.IsDestroyScriptableObject(this) && this.m_MightHaveModified && assetImporter != null && !InternalEditorUtility.ignoreInspectorChanges && this.HasModified() && !this.AssetWasUpdated()) { string message = string.Format(L10n.Tr("Unapplied import settings for '{0}'"), assetImporter.assetPath); if (base.targets.Length > 1) { message = string.Format(L10n.Tr("Unapplied import settings for '{0}' files"), base.targets.Length); } if (EditorUtility.DisplayDialog(L10n.Tr("Unapplied import settings"), message, L10n.Tr("Apply"), L10n.Tr("Revert"))) { this.Apply(); this.m_MightHaveModified = false; this.ImportAssets(this.GetAssetPaths()); } } if (this.m_SerializedObject != null && this.m_SerializedObject.hasModifiedProperties) { this.m_SerializedObject.Cache(base.GetInstanceID()); this.m_SerializedObject = null; } }
public virtual void OnDisable() { EditorApplication.wantsToQuit -= ApplicationWantsToQuit; AssemblyReloadEvents.afterAssemblyReload -= FixInspectorCache; AssetImporterEditorPostProcessAsset.OnAssetbundleNameChanged -= FixImporterAssetbundleName; if (!m_OnEnableCalled) { Debug.LogError($"{this.GetType().Name}.OnEnable must call base.OnEnable to avoid unexpected behaviour."); } // do not check on m_ApplyRevertGUICalled if OnEnable was never called // or we are closing before OnInspectorGUI have been called (which is the case in most of our EditorTests) if (m_OnEnableCalled && needsApplyRevert && !isInspectorDirty && !m_ApplyRevertGUICalled) { Debug.LogError($"{this.GetType().Name}.OnInspectorGUI must call ApplyRevertGUI to avoid unexpected behaviour."); } // When destroying the inspector check if we have any unapplied modifications // and apply them. if (Unsupported.IsDestroyScriptableObject(this)) { if (!CheckForApplyOnClose()) { // we need to force back the current tracker to our assetTargets if (!IsClosingInspector()) { if (m_HasInspectorBeenSeenLocked) { m_Inspector.SetObjectsLocked(new List <Object>(assetTargets)); } else { Selection.objects = assetTargets; } } else { var inspector = ScriptableObject.CreateInstance <InspectorWindow>(); if (m_HasInspectorBeenSeenLocked) { inspector.SetObjectsLocked(new List <Object>(assetTargets)); } else { Selection.objects = assetTargets; } inspector.Show(true); } if (s_UnreleasedInstances == null) { s_UnreleasedInstances = new List <int>(); } foreach (var t in m_TargetsInstanceID) { s_UnreleasedInstances.Add(t); } } else { foreach (var t in m_TargetsInstanceID) { ReleaseInspectorCopy(t); } } } m_OnEnableCalled = false; m_ApplyRevertGUICalled = false; }
// Called from a various number of places, like after an assembly reload or when the Editor gets created. internal sealed override void InternalSetTargets(Object[] t) { base.InternalSetTargets(t); if (m_CopySaved) // coming back from an assembly reload or asset re-import { if (extraDataType != null && m_ExtraDataTargets != null) // we need to recreate the user custom array { // just get back the data from customSerializedData array, it gets serialized and reconstructed properly m_ExtraDataTargets = extraDataSerializedObject.targetObjects; } ReloadTargets(AssetWasUpdated()); } else // newly created editor { var editors = Resources.FindObjectsOfTypeAll(this.GetType()).Cast <AssetImporterEditor>(); CheckExtraDataArray(); var loadedIds = new List <int>(t.Length); for (int i = 0; i < t.Length; ++i) { int instanceID = t[i].GetInstanceID(); loadedIds.Add(instanceID); var extraData = CreateOrReloadInspectorCopy(instanceID); if (m_ExtraDataTargets != null) { // we got the data from another instance if (extraData != null) { m_ExtraDataTargets[i] = extraData; } else { m_ExtraDataTargets[i] = ScriptableObject.CreateInstance(extraDataType); m_ExtraDataTargets[i].hideFlags = HideFlags.DontUnloadUnusedAsset | HideFlags.DontSaveInEditor; InitializeExtraDataInstance(m_ExtraDataTargets[i], i); SaveUserData(instanceID, m_ExtraDataTargets[i]); } } // proceed to an editor count check to make sure we have the proper number of instances saved. // If it is not the case, then a dispose was not done properly. int count = editors.Count(e => !Unsupported.IsDestroyScriptableObject(e) && e.targets.Contains(t[i])); if (s_UnreleasedInstances != null) { count += s_UnreleasedInstances.Count(id => id == instanceID); } var instances = GetInspectorCopyCount(instanceID); if (count != instances) { if (!CanEditorSurviveAssemblyReload()) { Debug.LogError($"The previous instance of {GetType()} was not un-loaded properly. The script has to be declared in a file with the same name."); } else { Debug.LogError($"The previous instance of {GetType()} has not been disposed correctly. Make sure you are calling base.OnDisable() in your AssetImporterEditor implementation."); } // Fix the cache count so it does not fail anymore. FixCacheCount(instanceID, count); } } // Clean-up previous instances now that we reloaded the copies if (s_UnreleasedInstances != null) { for (var index = s_UnreleasedInstances.Count - 1; index >= 0; index--) { var copy = s_UnreleasedInstances[index]; if (loadedIds.Contains(copy)) { ReleaseInspectorCopy(copy); s_UnreleasedInstances.RemoveAt(index); } } } m_TargetsInstanceID = loadedIds; m_CopySaved = true; } }