public LocationTreeNode( LocationTreeFolder parent, ISource source, string name, int image, int selectedImage )
 {
     m_Parent = parent;
     m_Source = source;
     m_Name = name;
     m_Image = image;
     m_SelectedImage = selectedImage;
 }
 public bool IsRootOf( LocationTreeFolder folder )
 {
     for ( LocationTreeFolder parent = folder; parent != null; parent = parent.Parent )
     {
         if ( ReferenceEquals( parent, this ) )
         {
             return true;
         }
     }
     return false;
 }
 public int GetDistanceTo( LocationTreeFolder folder )
 {
     int distance = 0;
     for ( LocationTreeFolder parent = folder; parent != null; parent = parent.Parent, ++distance )
     {
         if ( ReferenceEquals( parent, this ) )
         {
             return distance;
         }
     }
     return -1;
 }
        public FileLocationTree( ILocationManager locationManager, string defaultPath )
        {
            m_Locations = locationManager;

            m_Images = new ImageList( );
            m_FolderImage = AddImage( Windows.Properties.Resources.Folder, true );
            m_FolderOpenImage = AddImage( Windows.Properties.Resources.FolderOpen, true );

            string[] driveNames = Environment.GetLogicalDrives( );
            m_Drives = new Folder[ driveNames.Length ];

            for ( int driveIndex = 0; driveIndex < driveNames.Length; ++driveIndex )
            {
                string driveName = driveNames[ driveIndex ];
                m_Drives[ driveIndex ] = new Folder( null, this, driveName );
            }

            m_Properties = new LocationProperty[]
                {
                    m_NameProperty,
                    m_SizeProperty,
                    m_TypeProperty,
                    m_ModifiedProperty,
                    m_CreatedProperty
                };

            m_DefaultFolder = m_Drives[ 0 ];
            try
            {
                OpenFolder( defaultPath, out m_DefaultFolder );
                return;
            }
            catch ( Exception ex )
            {
                AssetsLog.Exception( ex, "Failed to open default folder \"{0}\"", defaultPath );
            }
        }
 public Folder( LocationTreeFolder parent, FileLocationTree tree, string path )
     : base(parent, Locations.NewLocation( path ), tree.GetFolderIcon( false ), tree.GetFolderIcon( true ))
 {
     m_Context = tree;
 }
        public void OpenFolder( string path, out LocationTreeFolder folder )
        {
            string[] pathParts = path.Split( new char[] { '/', '\\' } );

            folder = FindDriveFolder( pathParts[ 0 ] );

            for ( int partIndex = 1; partIndex < pathParts.Length; ++partIndex )
            {
                if ( string.IsNullOrEmpty( pathParts[ partIndex ] ) )
                {
                    continue;
                }

                LocationTreeFolder nextFolder = folder.FindFolder( pathParts[ partIndex ] );
                if ( nextFolder == null )
                {
                    throw new ArgumentException( string.Format( "Path \"{0}\" is invalid - \"{1}\" does not exist in \"{2}\"", path, pathParts[ partIndex ], pathParts[ partIndex - 1 ] ), "path" );
                }
                folder = nextFolder;
            }
        }
 public LocationTreeNode( LocationTreeFolder parent, ISource source, int image, int selectedImage )
     : this(parent, source, GetSourceName( source ), image, selectedImage)
 {
 }
 public LocationTreeItem( LocationTreeFolder parent, ISource source, int image, int selectedImage )
     : base(parent, source, image, selectedImage)
 {
 }
 public LocationTreeFolder( LocationTreeFolder parent, ISource source, string name, int image, int selectedImage )
     : base(parent, source, name, image, selectedImage)
 {
 }
        private void ShowCurrentFolder( LocationTreeFolder currentFolder )
        {
            IEnumerable< LocationTreeFolder > folders;
            IEnumerable< LocationTreeItem > items;
            try
            {
                folders = currentFolder.Folders;
                items = currentFolder.Items;
            }
            catch ( Exception ex )
            {
                MessageBox.Show( ex.Message );
                return;
            }

            currentFolderView.Items.Clear( );
            foreach ( LocationTreeFolder folder in folders )
            {
                ListViewItem listItem = currentFolderView.Items.Add( folder.Name, folder.Image );
                listItem.Tag = folder;

                AddListItemProperties( listItem, folder, m_Locations.Properties );
            }
            foreach ( LocationTreeItem item in items )
            {
                if ( ( m_Filter == null ) || ( m_Filter.Match( item ) ) )
                {
                    ListViewItem listItem = currentFolderView.Items.Add( item.Name, item.Image );
                    listItem.Tag = item;

                    AddListItemProperties( listItem, item, m_Locations.Properties );
                }
            }

            foldersComboBox.Items.Clear( );
            foreach ( LocationTreeFolder rootFolder in m_Locations.Roots )
            {
                int distance = rootFolder.GetDistanceTo( currentFolder );
                if ( distance >= 0 )
                {
                    AddPathToRoot( foldersComboBox, currentFolder, distance );
                }
                else
                {
                    foldersComboBox.Items.Add( NewFolderComboItem( 0, rootFolder ) );
                }
            }
            m_CurrentFolder = currentFolder;

            upButton.Enabled = ( m_CurrentFolder.Parent != null );
        }
        private void LocationTreeBrowser_Load( object sender, EventArgs e )
        {
            foreach ( LocationProperty property in m_Locations.Properties )
            {
                ColumnHeader header = currentFolderView.Columns.Add( property.Name, property.DefaultSize, HorizontalAlignment.Left );
                header.Tag = new ItemComparer( property );
            }

            m_CurrentFolder = m_Locations.DefaultFolder;

            StringBuilder filter = new StringBuilder( );
            foreach ( IAssetLoader loader in AssetManager.Instance.Loaders )
            {
                filter.Append( loader.Name );
                filter.Append( ' ' );

                StringBuilder extensions = new StringBuilder( );
                foreach ( string extension in loader.Extensions )
                {
                    if ( extensions.Length > 0 )
                    {
                        extensions.Append( ';' );
                    }
                    extensions.Append( "*." );
                    extensions.Append( extension );
                }
                filter.AppendFormat( "({0})|{0}|", extensions );
            }

            filter.Append( "All Files (*.*)|*.*" );

            Filter = filter.ToString( );
        }
        private void AddPathToRoot( ComboBox combo, LocationTreeFolder folder, int distance )
        {
            int addAt = combo.Items.Count;

            combo.Items.Insert( addAt, NewFolderComboItem( distance--, folder ) );

            combo.SelectedIndexChanged -= foldersComboBox_SelectedIndexChanged;
            combo.SelectedIndex = addAt;
            combo.SelectedIndexChanged += foldersComboBox_SelectedIndexChanged;

            if ( folder.Parent != null )
            {
                for ( folder = folder.Parent; folder != null; folder = folder.Parent )
                {
                    combo.Items.Insert( addAt, NewFolderComboItem( distance--, folder ) );
                }
            }
        }
        public void EnterFolder( LocationTreeFolder folder )
        {
            if ( m_CurrentFolder != folder )
            {
                m_FolderStack.Add( m_CurrentFolder );
                ShowCurrentFolder( folder );

                backButton.Enabled = true;
            }
        }