Changeset 918


Ignore:
Timestamp:
04/29/09 08:09:16 (5 years ago)
Author:
lowjoel
Message:

Rewritten the Toolbar and UpdateManager? code to factor out all list management functions to a collection class. Fixes warning CA1002.

Location:
branches/eraser6/Eraser
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/eraser6/Eraser/ToolBar.cs

    r910 r918  
    4040 
    4141            //Initialize the toolbar item list 
    42             items = new List<ToolBarItem>(); 
     42            Items = new ToolbarItemCollection(this); 
    4343 
    4444            //Hook mouse move events to show the currently selected item 
     
    6262            //See if the click was on any item's arrow. 
    6363            Rectangle mouse_rect = new Rectangle(e.Location, new Size(1, 1)); 
    64             foreach (ToolBarItem i in items) 
     64            foreach (ToolBarItem i in Items) 
    6565            { 
    6666                if (i.Menu != null && mouse_rect.IntersectsWith(i.MenuRect)) 
     
    9595            int x = 0; 
    9696 
    97             foreach (ToolBarItem i in items) 
     97            foreach (ToolBarItem i in Items) 
    9898            { 
    9999                { 
     
    172172        /// Stores the items in the Tool Bar. 
    173173        /// </summary> 
    174         private List<ToolBarItem> items; 
    175  
    176         /// <summary> 
    177         /// Accesses or modifies the items in the tool bar. 
    178         /// </summary> 
    179         /// <param name="index">Index of item.</param> 
    180         /// <returns>ToolBarItem describing the item at index i.</returns> 
    181         public ToolBarItem this[int index] 
    182         { 
    183             get 
    184             { 
    185                 return items[index]; 
    186             } 
    187  
    188             set 
    189             { 
    190                 items[index] = value; 
    191                 Redraw(); 
    192             } 
    193         } 
    194  
    195         public ICollection<ToolBarItem> Items 
    196         { 
    197             get { return items; } 
     174        public ToolbarItemCollection Items 
     175        { 
     176            get; 
     177            set; 
    198178        } 
    199179    } 
     
    204184        /// Tool bar item text. 
    205185        /// </summary> 
    206         [Description("Tool bar item text")] 
     186        [Description("Toolbar item text")] 
    207187        public string Text 
    208188        { 
    209189            get { return text; } 
    210             set { text = value; } 
     190            set 
     191            { 
     192                text = value; 
     193                if (Window != null) 
     194                    Window.Redraw(); 
     195            } 
    211196        } 
    212197 
     
    218203        { 
    219204            get { return bitmap; } 
    220             set { bitmap = value; } 
     205            set 
     206            { 
     207                bitmap = value; 
     208                if (Window != null) 
     209                    Window.Redraw(); 
     210            } 
    221211        } 
    222212 
     
    227217        { 
    228218            get { return menu; } 
    229             set { menu = value; } 
     219            set 
     220            { 
     221                menu = value; 
     222                if (Window != null) 
     223                    Window.Redraw(); 
     224            } 
    230225        } 
    231226 
     
    250245 
    251246        /// <summary> 
     247        /// The owning window of this item. 
     248        /// </summary> 
     249        internal ToolBar Window; 
     250 
     251        /// <summary> 
    252252        /// Stores the rectangle of this item. 
    253253        /// </summary> 
    254         internal Rectangle Rectangle = new Rectangle(); 
     254        internal Rectangle Rectangle; 
    255255 
    256256        /// <summary> 
     
    269269        internal Rectangle MenuRect; 
    270270    } 
     271 
     272    public class ToolbarItemCollection : ICollection<ToolBarItem>, IList<ToolBarItem>, 
     273        IEnumerable<ToolBarItem> 
     274    { 
     275        /// <summary> 
     276        /// Constructor. 
     277        /// </summary> 
     278        /// <param name="win">The owning toolbar window.</param> 
     279        internal ToolbarItemCollection(ToolBar win) 
     280        { 
     281            window = win; 
     282        } 
     283 
     284        #region ICollection<ToolBarItem> Members 
     285        public void Add(ToolBarItem item) 
     286        { 
     287            if (item.Window != null) 
     288                throw new ArgumentException("The item being added already is owned by " + 
     289                    "another ToolBar control. Remove the item from the other control " + 
     290                    "before inserting it into this one."); 
     291 
     292            item.Window = window; 
     293            list.Add(item); 
     294            window.Redraw(); 
     295        } 
     296 
     297        public void Clear() 
     298        { 
     299            foreach (ToolBarItem item in list) 
     300                item.Window = null; 
     301            list.Clear(); 
     302            window.Redraw(); 
     303        } 
     304 
     305        public bool Contains(ToolBarItem item) 
     306        { 
     307            return list.Contains(item); 
     308        } 
     309 
     310        public void CopyTo(ToolBarItem[] array, int arrayIndex) 
     311        { 
     312            list.CopyTo(array, arrayIndex); 
     313        } 
     314 
     315        public int Count 
     316        { 
     317            get { return list.Count; } 
     318        } 
     319 
     320        public bool IsReadOnly 
     321        { 
     322            get { return false; } 
     323        } 
     324 
     325        public bool Remove(ToolBarItem item) 
     326        { 
     327            item.Window = null; 
     328            bool result = list.Remove(item); 
     329            window.Redraw(); 
     330            return result; 
     331        } 
     332        #endregion 
     333 
     334        #region IEnumerable<ToolBarItem> Members 
     335        public IEnumerator<ToolBarItem> GetEnumerator() 
     336        { 
     337            return list.GetEnumerator(); 
     338        } 
     339        #endregion 
     340 
     341        #region IEnumerable Members 
     342        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
     343        { 
     344            return list.GetEnumerator(); 
     345        } 
     346        #endregion 
     347 
     348        #region IList<ToolBarItem> Members 
     349        public int IndexOf(ToolBarItem item) 
     350        { 
     351            return list.IndexOf(item); 
     352        } 
     353 
     354        public void Insert(int index, ToolBarItem item) 
     355        { 
     356            throw new NotImplementedException(); 
     357        } 
     358 
     359        public void RemoveAt(int index) 
     360        { 
     361            throw new NotImplementedException(); 
     362        } 
     363 
     364        public ToolBarItem this[int index] 
     365        { 
     366            get 
     367            { 
     368                throw new NotImplementedException(); 
     369            } 
     370            set 
     371            { 
     372                throw new NotImplementedException(); 
     373            } 
     374        } 
     375        #endregion 
     376 
     377        /// <summary> 
     378        /// The window owning the items in this list. 
     379        /// </summary> 
     380        private ToolBar window; 
     381 
     382        /// <summary> 
     383        /// The list storing the toolbar items. 
     384        /// </summary> 
     385        private List<ToolBarItem> list = new List<ToolBarItem>(); 
     386    } 
    271387} 
  • branches/eraser6/Eraser/UpdateForm.cs

    r912 r918  
    4545        { 
    4646            InitializeComponent(); 
    47  
    48             updates = new UpdateManager(); 
    4947            updateListDownloader.RunWorkerAsync(); 
    5048        } 
     
    186184                updatesLv.Groups.Add(group); 
    187185 
    188                 foreach (UpdateInfo update in updates[key]) 
     186                foreach (UpdateInfo update in updates.Updates[key]) 
    189187                { 
    190188                    //Skip if this update won't work on our current architecture. 
     
    458456        /// The Update manager instance used by this form. 
    459457        /// </summary> 
    460         UpdateManager updates; 
     458        UpdateManager updates = new UpdateManager(); 
    461459 
    462460        /// <summary> 
     
    521519    { 
    522520        /// <summary> 
     521        /// Constructor. 
     522        /// </summary> 
     523        public UpdateManager() 
     524        { 
     525            Updates = new UpdateCategoriesDictionary(); 
     526        } 
     527 
     528        /// <summary> 
    523529        /// Retrieves the update list from the server. 
    524530        /// </summary> 
     
    564570        { 
    565571            //Move the XmlReader to the root node 
    566             updates.Clear(); 
     572            Updates.Clear(); 
    567573            mirrors.Clear(); 
    568574            XmlReader rdr = XmlReader.Create(strm); 
     
    587593                    } 
    588594                    else 
    589                         updates.Add(categories.Name, ParseUpdateCategory(categories.ReadSubtree())); 
     595                        Updates.Add(categories.Name, ParseUpdateCategory(categories.ReadSubtree())); 
    590596                } 
    591597 
     
    624630        /// <param name="rdr">The XML reader object representing the element and its children.</param> 
    625631        /// <returns>A list of updates in the category.</returns> 
    626         private static List<UpdateInfo> ParseUpdateCategory(XmlReader rdr) 
    627         { 
    628             List<UpdateInfo> result = new List<UpdateInfo>(); 
     632        private static UpdateList ParseUpdateCategory(XmlReader rdr) 
     633        { 
     634            UpdateList result = new UpdateList(); 
    629635            if (!rdr.ReadToDescendant("item")) 
    630636                return result; 
     
    727733        } 
    728734 
     735        /// <summary> 
     736        /// Installs all updates downloaded. 
     737        /// </summary> 
     738        /// <param name="value">The value returned from a call to 
     739        /// <see cref="DownloadUpdates"/>.</param> 
    729740        public void InstallUpdates(object value) 
    730741        { 
     
    778789        /// Called when the progress of the operation changes. 
    779790        /// </summary> 
    780         public EventHandler<ProgressEventArgs> OnProgressEvent 
    781         { 
    782             get { return onProgressEvent; } 
    783             set { onProgressEvent = value; } 
    784         } 
    785         private EventHandler<ProgressEventArgs> onProgressEvent; 
     791        public EventHandler<ProgressEventArgs> OnProgressEvent { get; set; } 
    786792 
    787793        /// <summary> 
     
    838844        /// Retrieves the categories available. 
    839845        /// </summary> 
    840         public Dictionary<string, List<UpdateInfo>>.KeyCollection Categories 
     846        public ICollection<string> Categories 
    841847        { 
    842848            get 
    843849            { 
    844                 return updates.Keys; 
     850                return Updates.Keys; 
    845851            } 
    846852        } 
     
    849855        /// Retrieves all updates available. 
    850856        /// </summary> 
    851         public Dictionary<string, List<UpdateInfo>> Updates 
    852         { 
    853             get 
    854             { 
    855                 return updates; 
    856             } 
    857         } 
    858  
    859         /// <summary> 
    860         /// Retrieves the updates in the given category. 
    861         /// </summary> 
    862         /// <param name="key">The category to retrieve.</param> 
    863         /// <returns>All updates in the given category.</returns> 
    864         public ICollection<UpdateInfo> this[string key] 
    865         { 
    866             get 
    867             { 
    868                 return updates[key]; 
    869             } 
    870         } 
     857        public UpdateCategoriesDictionary Updates { get; set; } 
    871858 
    872859        /// <summary> 
     
    880867        /// </summary> 
    881868        private Mirror selectedMirror; 
    882  
    883         /// <summary> 
    884         /// The list of updates downloaded. 
    885         /// </summary> 
    886         private Dictionary<string, List<UpdateInfo>> updates = 
    887             new Dictionary<string, List<UpdateInfo>>(); 
     869    } 
     870 
     871    /// <summary> 
     872    /// Manages a list of categories, mapping categories to a list of updates. 
     873    /// </summary> 
     874    public class UpdateCategoriesDictionary : IDictionary<string, UpdateList>, 
     875        ICollection<KeyValuePair<string, UpdateList>>, 
     876        IEnumerable<KeyValuePair<string, UpdateList>> 
     877    { 
     878        #region IDictionary<string,UpdateList> Members 
     879        public void Add(string key, UpdateList value) 
     880        { 
     881            dictionary.Add(key, value); 
     882        } 
     883 
     884        public bool ContainsKey(string key) 
     885        { 
     886            return dictionary.ContainsKey(key); 
     887        } 
     888 
     889        public ICollection<string> Keys 
     890        { 
     891            get { return dictionary.Keys; } 
     892        } 
     893 
     894        public bool Remove(string key) 
     895        { 
     896            return dictionary.Remove(key); 
     897        } 
     898 
     899        public bool TryGetValue(string key, out UpdateList value) 
     900        { 
     901            return dictionary.TryGetValue(key, out value); 
     902        } 
     903 
     904        public ICollection<UpdateList> Values 
     905        { 
     906            get { return dictionary.Values; } 
     907        } 
     908 
     909        public UpdateList this[string key] 
     910        { 
     911            get 
     912            { 
     913                return dictionary[key]; 
     914            } 
     915            set 
     916            { 
     917                dictionary[key] = value; 
     918            } 
     919        } 
     920        #endregion 
     921 
     922        #region ICollection<KeyValuePair<string,UpdateList>> Members 
     923        public void Add(KeyValuePair<string, UpdateList> item) 
     924        { 
     925            dictionary.Add(item.Key, item.Value); 
     926        } 
     927 
     928        public void Clear() 
     929        { 
     930            dictionary.Clear(); 
     931        } 
     932 
     933        public bool Contains(KeyValuePair<string, UpdateList> item) 
     934        { 
     935            return dictionary.ContainsKey(item.Key) && dictionary[item.Key] == item.Value; 
     936        } 
     937 
     938        public void CopyTo(KeyValuePair<string, UpdateList>[] array, int arrayIndex) 
     939        { 
     940            throw new NotImplementedException(); 
     941        } 
     942 
     943        public int Count 
     944        { 
     945            get { return dictionary.Count; } 
     946        } 
     947 
     948        public bool IsReadOnly 
     949        { 
     950            get { return true; } 
     951        } 
     952 
     953        public bool Remove(KeyValuePair<string, UpdateList> item) 
     954        { 
     955            return dictionary.Remove(item.Key); 
     956        } 
     957        #endregion 
     958 
     959        #region IEnumerable<KeyValuePair<string,UpdateList>> Members 
     960        public IEnumerator<KeyValuePair<string, UpdateList>> GetEnumerator() 
     961        { 
     962            throw new NotImplementedException(); 
     963        } 
     964        #endregion 
     965 
     966        #region IEnumerable Members 
     967        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
     968        { 
     969            throw new NotImplementedException(); 
     970        } 
     971        #endregion 
     972 
     973        /// <summary> 
     974        /// The store for the current object. 
     975        /// </summary> 
     976        private Dictionary<string, UpdateList> dictionary = 
     977            new Dictionary<string, UpdateList>(); 
     978    } 
     979 
     980    /// <summary> 
     981    /// Manages a category, containing a list of updates. 
     982    /// </summary> 
     983    public class UpdateList : IList<UpdateInfo>, ICollection<UpdateInfo>, 
     984        IEnumerable<UpdateInfo> 
     985    { 
     986        #region IList<UpdateInfo> Members 
     987        public int IndexOf(UpdateInfo item) 
     988        { 
     989            return list.IndexOf(item); 
     990        } 
     991 
     992        public void Insert(int index, UpdateInfo item) 
     993        { 
     994            list.Insert(index, item); 
     995        } 
     996 
     997        public void RemoveAt(int index) 
     998        { 
     999            list.RemoveAt(index); 
     1000        } 
     1001 
     1002        public UpdateInfo this[int index] 
     1003        { 
     1004            get 
     1005            { 
     1006                return list[index]; 
     1007            } 
     1008            set 
     1009            { 
     1010                list[index] = value; 
     1011            } 
     1012        } 
     1013        #endregion 
     1014 
     1015        #region ICollection<UpdateInfo> Members 
     1016        public void Add(UpdateInfo item) 
     1017        { 
     1018            list.Add(item); 
     1019        } 
     1020 
     1021        public void Clear() 
     1022        { 
     1023            list.Clear(); 
     1024        } 
     1025 
     1026        public bool Contains(UpdateInfo item) 
     1027        { 
     1028            return list.Contains(item); 
     1029        } 
     1030 
     1031        public void CopyTo(UpdateInfo[] array, int arrayIndex) 
     1032        { 
     1033            list.CopyTo(array, arrayIndex); 
     1034        } 
     1035 
     1036        public int Count 
     1037        { 
     1038            get { return list.Count; } 
     1039        } 
     1040 
     1041        public bool IsReadOnly 
     1042        { 
     1043            get { return true; } 
     1044        } 
     1045 
     1046        public bool Remove(UpdateInfo item) 
     1047        { 
     1048            return list.Remove(item); 
     1049        } 
     1050        #endregion 
     1051 
     1052        #region IEnumerable<UpdateInfo> Members 
     1053        public IEnumerator<UpdateInfo> GetEnumerator() 
     1054        { 
     1055            return list.GetEnumerator(); 
     1056        } 
     1057        #endregion 
     1058 
     1059        #region IEnumerable Members 
     1060        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
     1061        { 
     1062            return list.GetEnumerator(); 
     1063        } 
     1064        #endregion 
     1065 
     1066        /// <summary> 
     1067        /// The store for this object. 
     1068        /// </summary> 
     1069        private List<UpdateInfo> list = new List<UpdateInfo>(); 
    8881070    } 
    8891071 
     
    9031085        /// The location where the mirror is at. 
    9041086        /// </summary> 
    905         public string Location 
    906         { 
    907             get; 
    908             set; 
    909         } 
     1087        public string Location { get; set; } 
    9101088 
    9111089        /// <summary> 
    9121090        /// The URL prefix to utilise the mirror. 
    9131091        /// </summary> 
    914         public string Link 
    915         { 
    916             get; 
    917             set; 
    918         } 
     1092        public string Link { get; set; } 
    9191093 
    9201094        public override string ToString() 
Note: See TracChangeset for help on using the changeset viewer.