internal void LoadImage(dfAtlas atlas, string source)
 {
     dfAtlas.ItemInfo item = atlas[source];
     if (item == null)
     {
         throw new InvalidOperationException(string.Concat("Sprite does not exist in atlas: ", source));
     }
     this.Atlas = atlas;
     this.Source = source;
     this.Size = item.sizeInPixels;
     this.Baseline = (int)this.Size.y;
 }

    private string buildItemTooltip( dfAtlas.ItemInfo sprite )
    {
        if( sprite == null )
            return "";

        var width = (int)sprite.sizeInPixels.x;
        var height = (int)sprite.sizeInPixels.y;

        return string.Format(
            "Atlas: {3}  Sprite: {0}  Size: {1}x{2}",
            sprite.name,
            width,
            height,
            atlas.name
        );
    }

    public static void Show( string title, dfAtlas atlas, string sprite, SelectionCallback callback )
    {
        if( atlas == null )
            throw new Exception( "No Texture Atlas was specified" );

        // Detect whether the user has deleted the textures after adding them to the Atlas
        if( atlas.Texture == null )
            throw new Exception( "The Texture Atlas does not have a texture or the texture was deleted" );

        var dialog = ScriptableWizard.DisplayWizard<dfSpriteSelectionDialog>( title );
        dialog.atlas = atlas;
        dialog.selectedSprite = sprite;
        dialog.minSize = new Vector2( 300, 200 );
        dialog.callback = callback;
        dialog.selectionShown = string.IsNullOrEmpty( sprite );
        dialog.ShowAuxWindow();
    }

 public void RemoveSprite( dfAtlas atlas, string spriteName )
 {
     selectedTextures.Clear();
     atlas[ spriteName ].deleted = true;
     rebuildAtlas( atlas );
 }

    private static void ShowAtlasActions( dfAtlas atlas )
    {
        dfEditorUtil.DrawSeparator();

        EditorGUILayout.BeginHorizontal();
        {

            if( GUILayout.Button( "Rebuild" ) )
            {
                rebuildAtlas( atlas );
            }

            if( GUILayout.Button( "Refresh Views" ) )
            {
                dfGUIManager.RefreshAll( true );
            }

        }
        EditorGUILayout.EndHorizontal();
    }

    private void drawSprite( Rect rect, dfAtlas.ItemInfo sprite )
    {
        var size = sprite.sizeInPixels;
        var destRect = rect;

        if( destRect.width < size.x || destRect.height < size.y )
        {

            var newHeight = size.y * rect.width / size.x;
            if( newHeight <= rect.height )
                destRect.height = newHeight;
            else
                destRect.width = size.x * rect.height / size.y;

        }
        else
        {
            destRect.width = size.x;
            destRect.height = size.y;
        }

        if( destRect.width < rect.width ) destRect.x = rect.x + ( rect.width - destRect.width ) * 0.5f;
        if( destRect.height < rect.height ) destRect.y = rect.y + ( rect.height - destRect.height ) * 0.5f;

        GUI.DrawTextureWithTexCoords( destRect, atlas.Material.mainTexture, sprite.region, true );
    }

    private dfMarkupBox createImageBox( dfAtlas atlas, string source, dfMarkupStyle style )
    {
        if( source.ToLowerInvariant().StartsWith( "http://" ) )
        {
            return null;
        }
        else if( atlas != null && atlas[ source ] != null )
        {

            var spriteBox = new dfMarkupBoxSprite( this, dfMarkupDisplayType.inline, style );
            spriteBox.LoadImage( atlas, source );

            return spriteBox;

        }
        else
        {
            var texture = dfMarkupImageCache.Load( source );
            if( texture != null )
            {

                var textureBox = new dfMarkupBoxTexture( this, dfMarkupDisplayType.inline, style );
                textureBox.LoadTexture( texture );

                return textureBox;

            }
        }

        return null;
    }

    internal static void Reimport( dfAtlas atlas )
    {
        var textureFilePath = AssetDatabase.GUIDToAssetPath( atlas.imageFileGUID );
        if( !File.Exists( textureFilePath ) )
        {
            Debug.LogError( string.Format( "The image file for atlas {0} could not be found", atlas.name ), atlas );
            return;
        }

        var dataFilePath = AssetDatabase.GUIDToAssetPath( atlas.dataFileGUID );
        if( !File.Exists( dataFilePath ) )
        {
            Debug.LogError( string.Format( "The data file for atlas {0} could not be found", atlas.name ), atlas );
            return;
        }

        var dataFile = AssetDatabase.LoadAssetAtPath( dataFilePath, typeof( TextAsset ) ) as TextAsset;
        if( dataFile == null )
        {
            Debug.LogError( string.Format( "Faile to open the data file for the {0} atlas", atlas.name ), atlas );
            return;
        }

        var textureFile = AssetDatabase.LoadAssetAtPath( textureFilePath, typeof( Texture2D ) ) as Texture2D;
        if( textureFile == null )
        {
            Debug.LogError( string.Format( "Faile to open the image file for the {0} atlas", atlas.name ), atlas );
            return;
        }

        dfTextureAtlasInspector.setAtlasTextureSettings( textureFilePath, false );

        var uvx = 1f / textureFile.width;
        var uvy = 1f / textureFile.height;

        var newSprites = new List<dfAtlas.ItemInfo>();
        var oldSprites = atlas.Items;

        var data = JSON.JsonDecode( dataFile.text ) as DICT;
        var frames = data[ "frames" ] as DICT;
        foreach( var key in frames.Keys )
        {

            var itemData = frames[ key ] as DICT;

            var spriteName = Path.GetFileNameWithoutExtension( key );

            var isRotated = (bool)itemData[ "rotated" ];
            if( isRotated )
            {
                Debug.LogError( string.Format( "Sprite '{0}' is rotated. Rotated sprites are not yet supported", spriteName ) );
                continue;
            }

            var frameRect = extractUVRect( itemData[ "frame" ] as DICT, textureFile );
            var spriteSize = new Vector2( frameRect.width / uvx, frameRect.height / uvy );

            var sprite = new dfAtlas.ItemInfo()
            {
                name = spriteName,
                border = new RectOffset(),
                deleted = false,
                region = frameRect,
                rotated = false,
                sizeInPixels = spriteSize
            };
            newSprites.Add( sprite );

            for( int i = 0; i < oldSprites.Count; i++ )
            {
                var old = oldSprites[ i ];
                if( string.Equals( old.name, spriteName, StringComparison.OrdinalIgnoreCase ) )
                {
                    sprite.border = old.border;
                    break;
                }
            }

        }

        newSprites.Sort();
        atlas.Items.Clear();
        atlas.Items.AddRange( newSprites );

        var prefabPath = AssetDatabase.GetAssetPath( atlas );
        var go = atlas.gameObject;

        #region Delay execution of object selection to work around a Unity issue

        // Declared with null value to eliminate "uninitialized variable"
        // compiler error in lambda below.
        EditorApplication.CallbackFunction callback = null;

        callback = () =>
        {
            EditorUtility.FocusProjectWindow();
            go = AssetDatabase.LoadMainAssetAtPath( prefabPath ) as GameObject;
            Selection.objects = new UnityEngine.Object[] { go };
            EditorGUIUtility.PingObject( go );
            Debug.Log( "Texture Atlas prefab re-imported at " + prefabPath, go );
//.........这里部分代码省略.........

    private void EditAtlasOptions( dfAtlas atlas )
    {
        if( atlas.generator == dfAtlas.TextureAtlasGenerator.Internal )
        {

                using( dfEditorUtil.BeginGroup( "Global Options" ) )
                {

                    var packingMethodConfig = (dfTexturePacker.dfTexturePackingMethod)EditorPrefs.GetInt( "DaikonForge.AtlasPackingMethod", (int)dfTexturePacker.dfTexturePackingMethod.RectBestAreaFit );
                    var packingMethod = (dfTexturePacker.dfTexturePackingMethod)EditorGUILayout.EnumPopup( "Packing Method", packingMethodConfig );
                    if( packingMethod != packingMethodConfig )
                    {
                        EditorPrefs.SetInt( "DaikonForge.AtlasPackingMethod", (int)packingMethod );
                    }

                    var sizes = new string[] { "256", "512", "1024", "2048", "4096" };
                        var defaultIndex = Mathf.Max( 0, getIndex( sizes, dfTextureAtlasInspector.MaxAtlasSize.ToString() ) );
                        var selectedIndex = EditorGUILayout.Popup( "Max Size", defaultIndex, sizes );
                        dfTextureAtlasInspector.MaxAtlasSize = int.Parse( sizes[ selectedIndex ] );

                    var paddingConfig = EditorPrefs.GetInt( "DaikonForge.AtlasDefaultPadding", 2 );
                    var padding = Mathf.Max( 0, EditorGUILayout.IntField( "Padding", paddingConfig ) );
                    {
                        if( padding != paddingConfig )
                        {
                            EditorPrefs.SetInt( "DaikonForge.AtlasDefaultPadding", padding );
                        }
                    }

                    ForceSquare = EditorGUILayout.Toggle( "Force square", ForceSquare );

                    var extrudeSpritesConfig = EditorPrefs.GetBool( "DaikonForge.AtlasExtrudeSprites", false );
                    var extrudeSprites = EditorGUILayout.Toggle( "Extrude Edges", extrudeSpritesConfig );
                    {
                        if( extrudeSprites != extrudeSpritesConfig )
                        {
                            EditorPrefs.SetBool( "DaikonForge.AtlasExtrudeSprites", extrudeSprites );
                        }
                    }

                }

        }
        else if( atlas.generator == dfAtlas.TextureAtlasGenerator.TexturePacker )
        {

            using( dfEditorUtil.BeginGroup( "Imported Texture Atlas" ) )
            {

                var dataFilePath = AssetDatabase.GUIDToAssetPath( atlas.dataFileGUID );
                var dataFile = AssetDatabase.LoadAssetAtPath( dataFilePath, typeof( TextAsset ) ) as TextAsset;
                EditorGUILayout.ObjectField( "Image File", atlas.Texture, typeof( Texture2D ), false );
                EditorGUILayout.ObjectField( "Data File", dataFile, typeof( TextAsset ), false );

            }

        }

        using( dfEditorUtil.BeginGroup( "Atlas Options" ) )
        {
            EditAtlasReplacement( atlas );
        }
    }

    private static void ShowAtlasActions( dfAtlas atlas )
    {
        dfEditorUtil.DrawSeparator();

        EditorGUILayout.BeginHorizontal();
        {

            if( atlas.generator == dfAtlas.TextureAtlasGenerator.TexturePacker )
            {
                if( GUILayout.Button( "Reimport" ) )
                {
                    dfTexturePackerImporter.Reimport( atlas );
                }
            }
            else if( GUILayout.Button( "Rebuild" ) )
            {
                rebuildAtlas( atlas );
            }

            if( GUILayout.Button( "Refresh Views" ) )
            {
                dfGUIManager.RefreshAll( true );
            }

        }
        EditorGUILayout.EndHorizontal();
    }

    private static Texture2D getTexture( dfAtlas atlas, string sprite )
    {
        var spriteInfo = atlas[ sprite ];
        if( spriteInfo == null )
            return null;

        var guid = atlas[ sprite ].textureGUID;
        if( string.IsNullOrEmpty( guid ) )
            return null;

        var path = AssetDatabase.GUIDToAssetPath( guid );
        if( string.IsNullOrEmpty( path ) )
            return null;

        return AssetDatabase.LoadAssetAtPath( path, typeof( Texture2D ) ) as Texture2D;
    }

    private static void DrawSprite( Rect rect, dfAtlas atlas, string sprite )
    {
        var spriteInfo = atlas[ sprite ];
        var size = spriteInfo.sizeInPixels;
        var destRect = rect;

        if( destRect.width < size.x || destRect.height < size.y )
        {

            var newHeight = size.y * rect.width / size.x;
            if( newHeight <= rect.height )
                destRect.height = newHeight;
            else
                destRect.width = size.x * rect.height / size.y;

        }
        else
        {
            destRect.width = size.x;
            destRect.height = size.y;
        }

        if( destRect.width < rect.width ) destRect.x = rect.x + ( rect.width - destRect.width ) * 0.5f;
        if( destRect.height < rect.height ) destRect.y = rect.y + ( rect.height - destRect.height ) * 0.5f;

        dfEditorUtil.DrawSprite( destRect, atlas, sprite );
    }

    protected internal static void SelectFontDefinition( string label, dfAtlas atlas, dfGUIManager view, string propertyName, bool colorizeIfMissing, int labelWidth )
    {
        var savedColor = GUI.color;
        var showDialog = false;

        try
        {

            GUI.enabled = ( atlas != null );

            var value = (dfFontBase)getValue( view, propertyName );

            if( value == null && colorizeIfMissing )
                GUI.color = EditorGUIUtility.isProSkin ? Color.yellow : Color.red;

            dfPrefabSelectionDialog.FilterCallback filterCallback = delegate( GameObject item )
            {

                if( atlas == null )
                    return false;

                var font = item.GetComponent<dfFontBase>();
                if( font == null )
                    return false;

                if( font is dfFont )
                {
                    var bitmappedFont = (dfFont)font;
                    if( bitmappedFont.Atlas == null || !dfAtlas.Equals( bitmappedFont.Atlas, atlas ) )
                        return false;
                }

                return true;

            };

            dfPrefabSelectionDialog.SelectionCallback selectionCallback = delegate( GameObject item )
            {
                var font = ( item == null ) ? null : item.GetComponent<dfFontBase>();
                dfEditorUtil.MarkUndo( view, "Change Font" );
                setValue( view, propertyName, font );
            };

            EditorGUILayout.BeginHorizontal();
            {

                EditorGUILayout.LabelField( label, "", GUILayout.Width( labelWidth ) );

                var displayText = value == null ? "[none]" : value.name;
                GUILayout.Label( displayText, "TextField" );

                var evt = Event.current;
                if( evt != null )
                {
                    Rect textRect = GUILayoutUtility.GetLastRect();
                    if( evt.type == EventType.mouseDown && evt.clickCount == 2 )
                    {
                        if( textRect.Contains( evt.mousePosition ) )
                        {
                            if( GUI.enabled && value != null )
                            {
                                Selection.activeObject = value;
                                EditorGUIUtility.PingObject( value );
                            }
                        }
                    }
                    else if( evt.type == EventType.DragUpdated || evt.type == EventType.DragPerform )
                    {
                        if( textRect.Contains( evt.mousePosition ) )
                        {

                            var draggedObject = DragAndDrop.objectReferences.First() as GameObject;
                            var draggedFont =
                                ( draggedObject != null )
                                ? draggedObject.GetComponent<dfFontBase>()
                                : null;

                            DragAndDrop.visualMode =
                                ( draggedFont != null )
                                ? DragAndDropVisualMode.Copy
                                : DragAndDropVisualMode.None;

                            if( evt.type == EventType.DragPerform )
                            {
                                selectionCallback( draggedObject );
                            }

                            evt.Use();

                        }
                    }
                }

                if( GUI.enabled && GUILayout.Button( new GUIContent( " ", "Edit Font" ), "IN ObjectField", GUILayout.Width( 14 ) ) )
                {
                    showDialog = true;
                }

            }
            EditorGUILayout.EndHorizontal();
//.........这里部分代码省略.........

 private dfMarkupBox createImageBox(dfAtlas atlas, string source, dfMarkupStyle style)
 {
     if (source.ToLowerInvariant().StartsWith("http://"))
     {
         return null;
     }
     if (atlas != null && atlas[source] != null)
     {
         dfMarkupBoxSprite _dfMarkupBoxSprite = new dfMarkupBoxSprite(this, dfMarkupDisplayType.inline, style);
         _dfMarkupBoxSprite.LoadImage(atlas, source);
         return _dfMarkupBoxSprite;
     }
     Texture texture = dfMarkupImageCache.Load(source);
     if (texture == null)
     {
         return null;
     }
     dfMarkupBoxTexture _dfMarkupBoxTexture = new dfMarkupBoxTexture(this, dfMarkupDisplayType.inline, style);
     _dfMarkupBoxTexture.LoadTexture(texture);
     return _dfMarkupBoxTexture;
 }

    private static Texture2D getTexture( dfAtlas atlas, string sprite )
    {
        var guid = atlas[ sprite ].textureGUID;
        var path = AssetDatabase.GUIDToAssetPath( guid );

        return AssetDatabase.LoadAssetAtPath( path, typeof( Texture2D ) ) as Texture2D;
    }

 internal static void DrawSprite( Rect rect, dfAtlas atlas, string sprite )
 {
     var spriteInfo = atlas[ sprite ];
     GUI.DrawTextureWithTexCoords( rect, atlas.Material.mainTexture, spriteInfo.region, true );
 }

    internal static bool rebuildAtlas( dfAtlas atlas )
    {
        try
        {

            EditorUtility.DisplayProgressBar( "Rebuilding Texture Atlas", "Processing changes to the texture atlas...", 0 );

            var sprites = atlas.Items
                .Where( i => i != null && !i.deleted )
                .Select( i => new { source = i, texture = getTexture( i.textureGUID ) } )
                .Where( i => i.texture != null )
                .OrderByDescending( i => i.texture.width * i.texture.height )
                .ToList();

            var textures = sprites.Select( i => i.texture ).ToList();

            var oldAtlasTexture = atlas.Material.mainTexture;
            var texturePath = AssetDatabase.GetAssetPath( oldAtlasTexture );

            var padding = EditorPrefs.GetInt( "DaikonForge.AtlasDefaultPadding", 2 );

            var newAtlasTexture = new Texture2D( 0, 0, TextureFormat.RGBA32, false );
            var newRects = newAtlasTexture.PackTextures2( textures.ToArray(), padding, dfTextureAtlasInspector.MaxAtlasSize, dfTextureAtlasInspector.ForceSquare );

            byte[] bytes = newAtlasTexture.EncodeToPNG();
            System.IO.File.WriteAllBytes( texturePath, bytes );
            bytes = null;
            DestroyImmediate( newAtlasTexture );

            setAtlasTextureSettings( texturePath, false );

            // Fix up the new sprite locations
            for( int i = 0; i < sprites.Count; i++ )
            {
                sprites[ i ].source.region = newRects[ i ];
                sprites[ i ].source.sizeInPixels = new Vector2( textures[ i ].width, textures[ i ].height );
                sprites[ i ].source.texture = null;
            }

            // Remove any deleted sprites
            atlas.Items.RemoveAll( i => i.deleted );

            // Re-sort the Items collection
            atlas.Items.Sort();
            atlas.RebuildIndexes();

            EditorUtility.SetDirty( atlas );
            EditorUtility.SetDirty( atlas.Material );

            dfGUIManager.RefreshAll( true );

            return true;

        }
        catch( Exception err )
        {

            Debug.LogError( err.ToString(), atlas );
            EditorUtility.DisplayDialog( "Error Rebuilding Texture Atlas", err.Message, "OK" );

            return false;

        }
        finally
        {
            EditorUtility.ClearProgressBar();
        }
    }

    private static void previewAtlasTexture( dfAtlas atlas, Rect rect )
    {
        if( atlas == null )
            return;

        var texture = atlas.Texture;
        if( texture == null )
            return;

        var size = new Vector2( texture.width, texture.height );

        var destRect = rect;

        if( destRect.width < size.x || destRect.height < size.y )
        {

            var newHeight = size.y * rect.width / size.x;
            if( newHeight <= rect.height )
                destRect.height = newHeight;
            else
                destRect.width = size.x * rect.height / size.y;

        }
        else
        {
            destRect.width = size.x;
            destRect.height = size.y;
        }

        if( destRect.width < rect.width ) destRect.x = rect.x + ( rect.width - destRect.width ) * 0.5f;
        if( destRect.height < rect.height ) destRect.y = rect.y + ( rect.height - destRect.height ) * 0.5f;

        GUI.DrawTexture( destRect, texture );
    }

        internal void LoadImage( dfAtlas atlas, string source )
        {

        var spriteInfo = atlas[ source ];
        if( spriteInfo == null )
            throw new InvalidOperationException( "Sprite does not exist in atlas: " + source );

        this.Atlas = atlas;
        this.Source = source;

        this.Size = spriteInfo.sizeInPixels;
        this.Baseline = (int)Size.y;

        }

    private void addSelectedTextures( dfAtlas atlas )
    {
        var textures = DragAndDrop.objectReferences.Where( x => x is Texture2D ).Cast<Texture2D>().ToList();
        var notReadable = textures.Where( x => !isReadable( x ) ).OrderBy( x => x.name ).Select( x => x.name ).ToArray();
        var readable = textures.Where( x => isReadable( x ) ).OrderBy( x => x.name ).ToArray();

        if( !AddTexture( atlas, readable ) )
        {
            return;
        }

        var message = string.Format( "{0} texture(s) added.", readable.Length );
        if( notReadable.Length > 0 )
        {
            message += "\nThe following textures were not set to Read/Write and could not be added:\n\n\t";
            message += string.Join( "\n\t", notReadable );
        }

        EditorUtility.DisplayDialog( "Add Sprites", message, "OK" );

        SelectedSprite = ( readable.Length > 0 ) ? readable.First().name : "";
    }