Changeset 12336 for extensions/PiwigoLib/PiwigoWpf

Timestamp:

Oct 3, 2011, 5:09:51 PM (13 years ago)

Author:

bayral

Message:

rename category to Albums

Location:

extensions/PiwigoLib/PiwigoWpf

Files:

• App.xaml (modified) (1 diff)
• App.xaml.cs (modified) (1 diff)
• Command/PwgCmdConnect.cs (modified) (1 diff)
• Command/PwgCmdDisconnect.cs (modified) (2 diffs)
• Command/PwgCmdGetImageforAlbum.cs (added)
• Command/PwgCmdGetImageforCategory.cs (deleted)
• Command/PwgCmdGetImageforTag.cs (modified) (1 diff)
• Command/PwgCmdGetSubAlbumforAlbum.cs (added)
• Command/PwgCmdGetSubCategorieforCategory.cs (deleted)
• Command/PwgCmdProvider.cs (modified) (2 diffs)
• Command/PwgCmdSelectImageInAlbum.cs (added)
• Command/PwgCmdSelectImageInCategory.cs (deleted)
• DTO/Helper/PwgAlbumListWPFHelper.cs (added)
• DTO/Helper/PwgAlbumWPFHelper.cs (added)
• DTO/Helper/PwgCategoryListWPFHelper.cs (deleted)
• DTO/Helper/PwgCategoryWPFHelper.cs (deleted)
• DTO/Helper/PwgImageWPFHelper.cs (modified) (1 diff)
• DTO/Helper/PwgTagListWPFHelper.cs (modified) (1 diff)
• DTO/LocalPwgAlbum.cs (added)
• DTO/LocalPwgCategory.cs (deleted)
• DTO/LocalPwgImage.cs (modified) (1 diff)
• DTO/PwgAlbumListWPF.cs (added)
• DTO/PwgCategoryListWPF.cs (deleted)
• DTO/PwgCategoryWPF.cs (deleted)
• DTO/PwgImageWPF.cs (modified) (1 diff)
• DTO/PwgModelManager.cs (modified) (2 diffs)
• DTO/PwgTreeAlbumWPF.cs (added)
• MainWindow.xaml (modified) (4 diffs)
• MainWindow.xaml.cs (modified) (3 diffs)
• PiwigoWpf.csproj (modified) (3 diffs)
• Services/ImageCacheManager.cs (modified) (10 diffs)

extensions/PiwigoLib/PiwigoWpf/App.xaml

@@ -8 +8 @@
         <ObjectDataProvider x:Name="ImagesODP" x:Key="Images" ObjectType="{x:Type piwigo:PwgImageListWPF}"/> <!--IsAsynchronous="True"-->
         <ObjectDataProvider x:Name="SessionODP" x:Key="Session" ObjectType="{x:Type piwigo:PwgSessionWPF}" />
-        <ObjectDataProvider x:Name="CategoriesODP" x:Key="Categories" ObjectType="{x:Type piwigo:PwgRootCategoryListWPF}"/> <!--IsAsynchronous="True"-->
+        <ObjectDataProvider x:Name="AlbumsODP" x:Key="Albums" ObjectType="{x:Type piwigo:PwgRootAlbumListWPF}"/> <!--IsAsynchronous="True"-->
         <ObjectDataProvider x:Name="TagsODP" x:Key="Tags" ObjectType="{x:Type piwigo:PwgTagListWPF}"/>
         <!--IsAsynchronous="True"-->

extensions/PiwigoLib/PiwigoWpf/App.xaml.cs

@@ -22 +22 @@
              // Model object was created in the app.xaml, so we have to link to them
             PwgModelManager.Instance.Session = (PwgSessionWPF)(this.Resources["Session"] as ObjectDataProvider).Data;
-            PwgModelManager.Instance.CategoryList = (PwgRootCategoryListWPF)(this.Resources["Categories"] as ObjectDataProvider).Data;
+            PwgModelManager.Instance.AlbumList = (PwgRootAlbumListWPF)(this.Resources["Albums"] as ObjectDataProvider).Data;
             PwgModelManager.Instance.ImageList = (PwgImageListWPF)(this.Resources["Images"] as ObjectDataProvider).Data;
             PwgModelManager.Instance.TagsList = (PwgTagListWPF)(this.Resources["Tags"] as ObjectDataProvider).Data;

extensions/PiwigoLib/PiwigoWpf/Command/PwgCmdConnect.cs

@@ -33 +33 @@
                 }
 
-                SendUiInfo("Retriving list of Category from server...");
+                SendUiInfo("Retriving list of Album from server...");
                 PwgSessionWPFHelper.AddPwgSessionInfoToPwgSessionWPF(sess, ref sesWPF);
 
-                PwgCategoryListWPFHelper.InitRootCategory();
+                PwgAlbumListWPFHelper.InitRootAlbum();
 
-                List<PwgCategory> lstCat = PwgServiceProvider.Instance.PwgCategoriesService.GetListOfCategory(null, null, null); //(PwgModelManager.Instance.Session.Status == PwgSessionStatusEnum.Guest)
-                PwgRootCategoryWPF aRootCatWPF = PwgModelManager.Instance.RootCategoryList;
+                List<PwgAlbum> lstCat = PwgServiceProvider.Instance.PwgAlbumsService.GetListOfAlbum(null, null, null); //(PwgModelManager.Instance.Session.Status == PwgSessionStatusEnum.Guest)
+                PwgRootAlbumWPF aRootCatWPF = PwgModelManager.Instance.RootAlbumList;
 
-                PwgCategoryListWPFHelper.ConvertPwgCategoryListToPwgRootCategoryWPF(lstCat, ref aRootCatWPF);
+                PwgAlbumListWPFHelper.ConvertPwgAlbumListToPwgRootAlbumWPF(lstCat, ref aRootCatWPF);
                 aRootCatWPF.IsExpanded = true;
 

extensions/PiwigoLib/PiwigoWpf/Command/PwgCmdDisconnect.cs

@@ -26 +26 @@
                 PwgSessionWPFHelper.AddPwgSessionInfoToPwgSessionWPF(sess, ref sesWPF);
 
-                SendUiInfo("Removing Image and Category ...");
+                SendUiInfo("Removing Image and Album ...");
                 if (PwgModelManager.Instance.ImageList != null)
                 {
@@ -32 +32 @@
                 }
 
-                if ((PwgModelManager.Instance.CategoryList != null)
-                    && (PwgModelManager.Instance.RootCategoryList != null))
+                if ((PwgModelManager.Instance.AlbumList != null)
+                    && (PwgModelManager.Instance.RootAlbumList != null))
                 {
-                    PwgModelManager.Instance.RootCategoryList.Childrens.Clear();
+                    PwgModelManager.Instance.RootAlbumList.Childrens.Clear();
                 }
 
-                if (PwgModelManager.Instance.CategoryList != null)
+                if (PwgModelManager.Instance.AlbumList != null)
                 {
-                    PwgModelManager.Instance.CategoryList.Clear();
+                    PwgModelManager.Instance.AlbumList.Clear();
                 }
 

extensions/PiwigoLib/PiwigoWpf/Command/PwgCmdGetImageforTag.cs

@@ -36 +36 @@
                     tagParam = (PwgTagWPF)parameter;
                     SendUiInfo("Setting up cache data...");
-                    ImageCacheManager.Instance.SetCurrentCategory("Tag-" + tagParam.Name);
+                    ImageCacheManager.Instance.SetCurrentAlbum("Tag-" + tagParam.Name);
 
                     SendUiInfo("Retriving images list from server...");

extensions/PiwigoLib/PiwigoWpf/Command/PwgCmdProvider.cs

@@ -21 +21 @@
                     objICom = PwgCmdDisconnect;
                     break;
-                case "PwgCmdGetImageforCategory":
-                    objICom = PwgCmdGetImageforCategory;
+                case "PwgCmdGetImageforAlbum":
+                    objICom = PwgCmdGetImageforAlbum;
                     break;
-                case "PwgCmdGetSubCategorieforCategory":
-                    objICom = PwgCmdGetSubCategorieforCategory;
+                case "PwgCmdGetSubAlbumforAlbum":
+                    objICom = PwgCmdGetSubAlbumforAlbum;
                     break;
                 case "PwgCmdGetImageforTag":
@@ -63 +63 @@
         }
 
-        public static AsyncCommand _pwgCmdGetImageforCategory;
-        public static AsyncCommand PwgCmdGetImageforCategory
+        public static AsyncCommand _pwgCmdGetImageforAlbum;
+        public static AsyncCommand PwgCmdGetImageforAlbum
         {
             get
             {
-                if (_pwgCmdGetImageforCategory == null)
+                if (_pwgCmdGetImageforAlbum == null)
                 {
-                    _pwgCmdGetImageforCategory = new PwgCmdGetImageforCategory();
+                    _pwgCmdGetImageforAlbum = new PwgCmdGetImageforAlbum();
                 }
-                return _pwgCmdGetImageforCategory;
+                return _pwgCmdGetImageforAlbum;
             }
         }
 
-        public static AsyncCommand _pwgCmdGetSubCategorieforCategory;
-        public static AsyncCommand PwgCmdGetSubCategorieforCategory
+        public static AsyncCommand _pwgCmdGetSubAlbumforAlbum;
+        public static AsyncCommand PwgCmdGetSubAlbumforAlbum
         {
             get
             {
-                if (_pwgCmdGetSubCategorieforCategory == null)
+                if (_pwgCmdGetSubAlbumforAlbum == null)
                 {
-                    _pwgCmdGetSubCategorieforCategory = new PwgCmdGetSubCategorieforCategory();
+                    _pwgCmdGetSubAlbumforAlbum = new PwgCmdGetSubAlbumforAlbum();
                 }
-                return _pwgCmdGetSubCategorieforCategory;
+                return _pwgCmdGetSubAlbumforAlbum;
             }
         }

extensions/PiwigoLib/PiwigoWpf/DTO/Helper/PwgImageWPFHelper.cs

@@ -28 +28 @@
                 aPwgImageWPF.Width = aPwgImage.Width;
 
-                if (aPwgImageWPF.Categories == null)
+                if (aPwgImageWPF.Albums == null)
                 {
-                    aPwgImageWPF.Categories = new System.Collections.ObjectModel.ObservableCollection<PwgCategoryWPF>();
+                    aPwgImageWPF.Albums = new System.Collections.ObjectModel.ObservableCollection<PwgAlbumWPF>();
                 }
                 else
                 {
-                    aPwgImageWPF.Categories.Clear();
+                    aPwgImageWPF.Albums.Clear();
                 }
 
-                foreach (PwgCategoryWPF c in aPwgImageWPF.Categories)
+                foreach (PwgAlbumWPF c in aPwgImageWPF.Albums)
                 {
-                    aPwgImageWPF.Categories.Add(c);
+                    aPwgImageWPF.Albums.Add(c);
                 }
 

extensions/PiwigoLib/PiwigoWpf/DTO/Helper/PwgTagListWPFHelper.cs

@@ -9 +9 @@
     public static class PwgTagListWPFHelper
     {
-        public static void AddPwgTagToList(PwgTag aPwgCategory,
-                                           ref PwgTagListWPF aPwgCategoryListWPF)
+        public static void AddPwgTagToList(PwgTag aPwgAlbum,
+                                           ref PwgTagListWPF aPwgAlbumListWPF)
         {
-            if (aPwgCategory != null)
+            if (aPwgAlbum != null)
             {
-                if (aPwgCategoryListWPF == null)
+                if (aPwgAlbumListWPF == null)
                 {
-                    aPwgCategoryListWPF = new PwgTagListWPF();
+                    aPwgAlbumListWPF = new PwgTagListWPF();
                 }
 
                 PwgTagWPF pwgTag = new PwgTagWPF();
-                PwgTagWPFHelper.ConvertPwgTagToPwgTagWPF(aPwgCategory, ref pwgTag);
+                PwgTagWPFHelper.ConvertPwgTagToPwgTagWPF(aPwgAlbum, ref pwgTag);
 
-                aPwgCategoryListWPF.Add(pwgTag);
+                aPwgAlbumListWPF.Add(pwgTag);
             }
         }

extensions/PiwigoLib/PiwigoWpf/DTO/LocalPwgImage.cs

@@ -14 +14 @@
     {
         //FileInfo highResFile, FileInfo lowResFile, FileInfo thumbFile, String imageName, String imageAuthor, DateTime creationDate,
-        //    String authorComment, List<String> lstCategories, List<String> lstTags, PwgConfidentLevelEnum? confidentLevel
+        //    String authorComment, List<String> lstAlbums, List<String> lstTags, PwgConfidentLevelEnum? confidentLevel
 
         private Int32 _id;

extensions/PiwigoLib/PiwigoWpf/DTO/PwgImageWPF.cs

@@ -112 +112 @@
         }
 
-        //public List<PwgCategoryWPF> Categories { get; set; }
-        private ObservableCollection<PwgCategoryWPF> _categories;
-        public ObservableCollection<PwgCategoryWPF> Categories
+        //public List<PwgAlbumWPF> Albums { get; set; }
+        private ObservableCollection<PwgAlbumWPF> _Albums;
+        public ObservableCollection<PwgAlbumWPF> Albums
         {
-            set { _categories = value; OnPropertyChanged("Categories"); }
-            get { return _categories; }
+            set { _Albums = value; OnPropertyChanged("Albums"); }
+            get { return _Albums; }
         }
         public event PropertyChangedEventHandler PropertyChanged;

extensions/PiwigoLib/PiwigoWpf/DTO/PwgModelManager.cs

@@ -67 +67 @@
             }
 
-            private PwgRootCategoryListWPF _categoryList = new PwgRootCategoryListWPF();
-            public PwgRootCategoryListWPF CategoryList
+            private PwgRootAlbumListWPF _AlbumList = new PwgRootAlbumListWPF();
+            public PwgRootAlbumListWPF AlbumList
             {
-                set { _categoryList = value; OnPropertyChanged("CategoryList"); }
-                get { return _categoryList; }
+                set { _AlbumList = value; OnPropertyChanged("AlbumList"); }
+                get { return _AlbumList; }
             }
 
-            private PwgRootCategoryWPF _rootCategoryList;
-            public PwgRootCategoryWPF RootCategoryList
+            private PwgRootAlbumWPF _rootAlbumList;
+            public PwgRootAlbumWPF RootAlbumList
             {
-                set { _rootCategoryList = value; OnPropertyChanged("RootCategoryList"); }
-                get { return _rootCategoryList; }
+                set { _rootAlbumList = value; OnPropertyChanged("RootAlbumList"); }
+                get { return _rootAlbumList; }
             }
 
@@ -96 +96 @@
             }
 
-            private LocalPwgCategoryListWPF _localCategoryToImport;
-            public LocalPwgCategoryListWPF LocalCategoryToImport
+            private LocalPwgAlbumListWPF _localAlbumToImport;
+            public LocalPwgAlbumListWPF LocalAlbumToImport
             {
-                set { _localCategoryToImport = value; OnPropertyChanged("LocalCategoryToImport"); }
-                get { return _localCategoryToImport; }
+                set { _localAlbumToImport = value; OnPropertyChanged("LocalAlbumToImport"); }
+                get { return _localAlbumToImport; }
             }
             

extensions/PiwigoLib/PiwigoWpf/MainWindow.xaml

@@ -142 +142 @@
                 Grid.Row="1"  
                 MinWidth="180" >
-            <TabItem Header="Categories">
-            <TreeView Name="listViewCategory"  
-                DataContext="{Binding Source={StaticResource Categories}}" 
-                ItemsSource="{Binding}"  MouseDoubleClick="listViewCategory_MouseDoubleClick"
-                HorizontalAlignment="Left" PreviewMouseDown="listViewCategory_PreviewMouseDown">
+            <TabItem Header="Albums">
+            <TreeView Name="listViewAlbum"  
+                DataContext="{Binding Source={StaticResource Albums}}" 
+                ItemsSource="{Binding}"  MouseDoubleClick="listViewAlbum_MouseDoubleClick"
+                HorizontalAlignment="Left" PreviewMouseDown="listViewAlbum_PreviewMouseDown">
                 <TreeView.ItemContainerStyle>
                     <!-- 
@@ -188 +188 @@
                 <TreeView.Resources>
                     <HierarchicalDataTemplate 
-                    DataType="{x:Type pwgdto:PwgTreeCategoryWPF}" 
+                    DataType="{x:Type pwgdto:PwgTreeAlbumWPF}" 
                     ItemsSource="{Binding Childrens}"
                     >
@@ -200 +200 @@
                     </HierarchicalDataTemplate>
                     <HierarchicalDataTemplate 
-                DataType="{x:Type pwgdto:PwgCategoryWPF}" 
+                DataType="{x:Type pwgdto:PwgAlbumWPF}" 
                 ItemsSource="{Binding Childrens}"
                 >
@@ -213 +213 @@
                                     <TextBlock Text="{Binding Path=ImagesCount}"/>
                                     <TextBlock Text=" images inside"/>
-                                    <TextBlock Text="{Binding Path=SubCategoriesCount}"/>
-                                    <TextBlock Text=" categories inside"/>
+                                    <TextBlock Text="{Binding Path=SubAlbumsCount}"/>
+                                    <TextBlock Text=" Albums inside"/>
                                 </UniformGrid>
                             </StackPanel.ToolTip>

extensions/PiwigoLib/PiwigoWpf/MainWindow.xaml.cs

@@ -30 +30 @@
         }
 
-        private void listViewCategory_MouseDoubleClick(object sender, MouseButtonEventArgs e)
+        private void listViewAlbum_MouseDoubleClick(object sender, MouseButtonEventArgs e)
         {
-            AppHelper.ExecuteCommand<PwgCmdGetImageforCategory>(listViewCategory.SelectedValue);
+            AppHelper.ExecuteCommand<PwgCmdGetImageforAlbum>(listViewAlbum.SelectedValue);
         }
 
         private void listViewImage_SelectionChanged(object sender, SelectionChangedEventArgs e)
         {
-            if (PwgCmdSelectImageInCategory.Command.CanExecute(sender))
+            if (PwgCmdSelectImageInAlbum.Command.CanExecute(sender))
             {
-                PwgCmdSelectImageInCategory.Command.Execute(sender);
+                PwgCmdSelectImageInAlbum.Command.Execute(sender);
             }
         }
 
-        private void listViewCategory_PreviewMouseDown(object sender, MouseButtonEventArgs e)
+        private void listViewAlbum_PreviewMouseDown(object sender, MouseButtonEventArgs e)
         {
             e.Handled = false;
@@ -53 +53 @@
             if (dep != null)
             {
-                if (((TreeViewItem)dep).DataContext is PwgCategoryWPF)
+                if (((TreeViewItem)dep).DataContext is PwgAlbumWPF)
                 {
-                    PwgCategoryWPF aCat = (PwgCategoryWPF)((TreeViewItem)dep).DataContext;
+                    PwgAlbumWPF aCat = (PwgAlbumWPF)((TreeViewItem)dep).DataContext;
 
                     if ((e.ChangedButton == MouseButton.Left) && (e.ClickCount == 1))
@@ -62 +62 @@
                         if (aCat.Childrens == null)
                         {
-                            AppHelper.ExecuteCommand<PwgCmdGetSubCategorieforCategory>(aCat);
+                            AppHelper.ExecuteCommand<PwgCmdGetSubAlbumforAlbum>(aCat);
                         }
                     }

extensions/PiwigoLib/PiwigoWpf/PiwigoWpf.csproj

@@ -76 +76 @@
     </ApplicationDefinition>
     <Compile Include="Command\PwgCmdGetImageforTag.cs" />
-    <Compile Include="Command\PwgCmdGetSubCategorieforCategory.cs" />
-    <Compile Include="Command\PwgCmdSelectImageInCategory.cs" />
+    <Compile Include="Command\PwgCmdGetSubAlbumforAlbum.cs" />
+    <Compile Include="Command\PwgCmdSelectImageInAlbum.cs" />
     <Compile Include="Command\DelegateCommand.cs" />
     <Compile Include="Command\PwgCmdDeleteTrace.cs" />
     <Compile Include="Command\PwgCmdDisconnect.cs" />
     <Compile Include="Command\PwgCmdEventsConsumer.cs" />
-    <Compile Include="Command\PwgCmdGetImageforCategory.cs" />
+    <Compile Include="Command\PwgCmdGetImageforAlbum.cs" />
     <Compile Include="Command\PwgCmdProvider.cs" />
     <Compile Include="Command\PwgCmdConnect.cs" />
@@ -91 +91 @@
     <Compile Include="DTO\Helper\PwgImageListWPFHelper.cs" />
     <Compile Include="DTO\Helper\PwgImageWPFHelper.cs" />
-    <Compile Include="DTO\Helper\PwgCategoryWPFHelper.cs" />
-    <Compile Include="DTO\Helper\PwgCategoryListWPFHelper.cs" />
+    <Compile Include="DTO\Helper\PwgAlbumWPFHelper.cs" />
+    <Compile Include="DTO\Helper\PwgAlbumListWPFHelper.cs" />
     <Compile Include="DTO\Helper\PwgSessionWPFHelper.cs" />
-    <Compile Include="DTO\LocalPwgCategory.cs" />
+    <Compile Include="DTO\LocalPwgAlbum.cs" />
     <Compile Include="DTO\LocalPwgImage.cs" />
     <Compile Include="DTO\PwgModelManager.cs" />
@@ -117 +117 @@
     <Compile Include="DTO\PwgTagListWPF.cs" />
     <Compile Include="DTO\PwgImageListWPF.cs" />
-    <Compile Include="DTO\PwgCategoryListWPF.cs" />
-    <Compile Include="DTO\PwgCategoryWPF.cs" />
+    <Compile Include="DTO\PwgAlbumListWPF.cs" />
+    <Compile Include="DTO\PwgTreeAlbumWPF.cs" />
     <Compile Include="DTO\PwgImageWPF.cs" />
     <Compile Include="DTO\PwgSessionWPF.cs" />

extensions/PiwigoLib/PiwigoWpf/Services/ImageCacheManager.cs

@@ -64 +64 @@
             #region DTO
             // local DTO
-            internal class CategoryDictionnaryItem
+            internal class AlbumDictionnaryItem
             {
                 internal DirectoryInfo BasePath;
-                internal String CategorieId;
+                internal String AlbumId;
             };
 
-            internal class CategoryDictionnary : SortedDictionary<String, CategoryDictionnaryItem> { };
+            internal class AlbumDictionnary : SortedDictionary<String, AlbumDictionnaryItem> { };
 
             internal class ServerDictionnaryItem
             {
                 internal DirectoryInfo BasePath;
-                internal CategoryDictionnary Categories;
+                internal AlbumDictionnary Albums;
                 internal Uri ServeurUrl;
             };
@@ -86 +86 @@
             internal ServerDictionnary _aServerDictionnary;
             internal ServerDictionnaryItem _currentServer;
-            internal CategoryDictionnaryItem _currentCategory;
+            internal AlbumDictionnaryItem _currentAlbum;
 
             #endregion DTO
@@ -100 +100 @@
             }
             
-            static private String BuildCategoryDirCache(ServerDictionnaryItem server, String CatgeoryId)
-            {
-                String CategoryDirCache = String.Empty;
+            static private String BuildAlbumDirCache(ServerDictionnaryItem server, String CatgeoryId)
+            {
+                String AlbumDirCache = String.Empty;
                 if (server != null)
                 {
-                    CategoryDirCache = Path.Combine(server.BasePath.FullName, CatgeoryId.Replace("/", "_")); 
+                    AlbumDirCache = Path.Combine(server.BasePath.FullName, CatgeoryId.Replace("/", "_")); 
                 }
                 else
                 {
-                    throw new ApplicationException ("Current server not set before using category");
-                }
-
-                return CategoryDirCache;
+                    throw new ApplicationException ("Current server not set before using Album");
+                }
+
+                return AlbumDirCache;
             }
 
@@ -147 +147 @@
             public void UnsetCurrentServer()
             { 
-                _currentCategory = null;
+                _currentAlbum = null;
                 _currentServer = null;
             }
@@ -171 +171 @@
                         server.ServeurUrl = new Uri(serveurUri);
                         server.BasePath = new DirectoryInfo(currentserverDir);
-                        server.Categories = new CategoryDictionnary();
+                        server.Albums = new AlbumDictionnary();
                         _aServerDictionnary.Add(serveurUri, server);
                         _currentServer = server;
@@ -180 +180 @@
                         //Create it
                         Directory.CreateDirectory(currentserverDir);
-                        _currentServer.Categories.Clear();
-                    }
-                }
-            }
-
-            public void SetCurrentCategory(String CategorieId)
+                        _currentServer.Albums.Clear();
+                    }
+                }
+            }
+
+            public void SetCurrentAlbum(String AlbumId)
             {
                 if (_currentServer != null)
@@ -191 +191 @@
                     lock (_lock)
                     {
-                        String currentsCategoryDir = BuildCategoryDirCache(_currentServer, CategorieId);
-                        if (_currentServer.Categories.ContainsKey(CategorieId))
-                        {
-                            _currentCategory = _currentServer.Categories[CategorieId];
+                        String currentsAlbumDir = BuildAlbumDirCache(_currentServer, AlbumId);
+                        if (_currentServer.Albums.ContainsKey(AlbumId))
+                        {
+                            _currentAlbum = _currentServer.Albums[AlbumId];
                         }
                         else
                         {
-                            CategoryDictionnaryItem category = new CategoryDictionnaryItem();
-                            category.BasePath = new DirectoryInfo(currentsCategoryDir);
-                            category.CategorieId = CategorieId;
-                            _currentServer.Categories.Add(CategorieId, category);
-                            _currentCategory = category;
-                        }
-
-                        if (!Directory.Exists(currentsCategoryDir))
+                            AlbumDictionnaryItem Album = new AlbumDictionnaryItem();
+                            Album.BasePath = new DirectoryInfo(currentsAlbumDir);
+                            Album.AlbumId = AlbumId;
+                            _currentServer.Albums.Add(AlbumId, Album);
+                            _currentAlbum = Album;
+                        }
+
+                        if (!Directory.Exists(currentsAlbumDir))
                         {
                             //Create it
-                            Directory.CreateDirectory(currentsCategoryDir);
+                            Directory.CreateDirectory(currentsAlbumDir);
                         }
                     }
@@ -214 +214 @@
                 else
                 {
-                    throw new ApplicationException("Current server not set before using category");
+                    throw new ApplicationException("Current server not set before using Album");
                 }
             }
@@ -226 +226 @@
                     }
 
-                    if (_currentCategory != null)
-                    {
-                        String localDir = Path.Combine(_currentCategory.BasePath.FullName, strImageType);
+                    if (_currentAlbum != null)
+                    {
+                        String localDir = Path.Combine(_currentAlbum.BasePath.FullName, strImageType);
                         if (!Directory.Exists(localDir))
                         {
@@ -277 +277 @@
                     else
                     {
-                        throw new ApplicationException("Current category not set before using image cache.");
+                        throw new ApplicationException("Current Album not set before using image cache.");
                     }
                 }