Changeset 912


Ignore:
Timestamp:
4/28/2009 2:09:09 PM (5 years ago)
Author:
lowjoel
Message:

Don't nest public classes.

File:
1 edited

Legend:

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

    r903 r912  
    3333using Eraser.Util; 
    3434using System.Net.Cache; 
     35using System.Globalization; 
    3536 
    3637namespace Eraser 
     
    100101        /// <param name="sender">The object triggering this event/</param> 
    101102        /// <param name="e">Event argument.</param> 
    102         private void updateListDownloader_ProgressChanged(object sender, UpdateManager.ProgressEventArgs e) 
     103        private void updateListDownloader_ProgressChanged(object sender, ProgressEventArgs e) 
    103104        { 
    104105            if (InvokeRequired) 
     
    107108                    throw new OperationCanceledException(); 
    108109 
    109                 Invoke(new EventHandler<UpdateManager.ProgressEventArgs>( 
     110                Invoke(new EventHandler<ProgressEventArgs>( 
    110111                    updateListDownloader_ProgressChanged), sender, e); 
    111112                return; 
     
    132133            { 
    133134                if (!(e.Error is OperationCanceledException)) 
    134                     MessageBox.Show(this, e.Error.Message, S._("Eraser"), 
    135                         MessageBoxButtons.OK, MessageBoxIcon.Error); 
     135                    MessageBox.Show(this, e.Error.Message, S._("Eraser"), MessageBoxButtons.OK, 
     136                        MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 
     137                        RightToLeft == RightToLeft.Yes ? MessageBoxOptions.RtlReading :  0); 
    136138 
    137139                Close(); 
     
    143145 
    144146            //First list all available mirrors 
    145             Dictionary<string, UpdateManager.Mirror>.Enumerator iter = 
    146                 updates.Mirrors.GetEnumerator(); 
     147            Dictionary<string, Mirror>.Enumerator iter = updates.Mirrors.GetEnumerator(); 
    147148            while (iter.MoveNext()) 
    148149                updatesMirrorCmb.Items.Add(iter.Current.Value); 
     
    185186                updatesLv.Groups.Add(group); 
    186187 
    187                 foreach (UpdateManager.Update update in updates[key]) 
     188                foreach (UpdateInfo update in updates[key]) 
    188189                { 
    189190                    //Skip if this update won't work on our current architecture. 
     
    211212            { 
    212213                MessageBox.Show(this, S._("There are no new updates or plugins available for " + 
    213                     "Eraser."), S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Information); 
     214                    "Eraser."), S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Information, 
     215                    MessageBoxDefaultButton.Button1, 
     216                    RightToLeft == RightToLeft.Yes ? MessageBoxOptions.RtlReading : 0); 
    214217                Close(); 
    215218            } 
     
    247250            updatesPanel.Visible = false; 
    248251            downloadingPnl.Visible = true; 
    249             List<UpdateManager.Update> updatesToInstall = 
    250                 new List<UpdateManager.Update>(); 
     252            List<UpdateInfo> updatesToInstall = new List<UpdateInfo>(); 
    251253 
    252254            //Set the mirror 
    253             updates.SelectedMirror = (UpdateManager.Mirror) 
    254                 updatesMirrorCmb.SelectedItem; 
     255            updates.SelectedMirror = (Mirror)updatesMirrorCmb.SelectedItem; 
    255256 
    256257            //Collect the items that need to be installed 
     
    263264                    downloadingLv.Items.Add(item); 
    264265 
    265                     updatesToInstall.Add((UpdateManager.Update)item.Tag); 
     266                    updatesToInstall.Add((UpdateInfo)item.Tag); 
    266267                } 
    267268                else 
    268                     uiUpdates.Remove((UpdateManager.Update)item.Tag); 
     269                    uiUpdates.Remove((UpdateInfo)item.Tag); 
    269270 
    270271            //Then run the thread if there are updates. 
     
    285286            { 
    286287                updates.OnProgressEvent += downloader_ProgressChanged; 
    287                 object downloadedUpdates = updates.DownloadUpdates((List<UpdateManager.Update>)e.Argument); 
     288                object downloadedUpdates = updates.DownloadUpdates((List<UpdateInfo>)e.Argument); 
    288289                e.Result = downloadedUpdates; 
    289290            } 
     
    299300        /// <param name="sender">The object triggering this event/</param> 
    300301        /// <param name="e">Event argument.</param> 
    301         private void downloader_ProgressChanged(object sender, UpdateManager.ProgressEventArgs e) 
     302        private void downloader_ProgressChanged(object sender, ProgressEventArgs e) 
    302303        { 
    303304            if (InvokeRequired) 
     
    306307                    throw new OperationCanceledException(); 
    307308 
    308                 Invoke(new EventHandler<UpdateManager.ProgressEventArgs>(downloader_ProgressChanged), 
     309                Invoke(new EventHandler<ProgressEventArgs>(downloader_ProgressChanged), 
    309310                    sender, e); 
    310311                return; 
    311312            } 
    312313 
    313             UpdateData update = uiUpdates[(UpdateManager.Update)e.UserState]; 
    314  
    315             if (e is UpdateManager.ProgressErrorEventArgs) 
    316             { 
    317                 update.Error = ((UpdateManager.ProgressErrorEventArgs)e).Exception; 
     314            UpdateData update = uiUpdates[(UpdateInfo)e.UserState]; 
     315 
     316            if (e is ProgressErrorEventArgs) 
     317            { 
     318                update.Error = ((ProgressErrorEventArgs)e).Exception; 
    318319                update.LVItem.ImageIndex = 3; 
    319320                update.LVItem.SubItems[1].Text = S._("Error"); 
     
    358359                if (!(e.Error is OperationCanceledException)) 
    359360                    MessageBox.Show(this, e.Error.Message, S._("Eraser"), 
    360                         MessageBoxButtons.OK, MessageBoxIcon.Error); 
     361                        MessageBoxButtons.OK, MessageBoxIcon.Error, 
     362                        MessageBoxDefaultButton.Button1, 
     363                        RightToLeft == RightToLeft.Yes ? MessageBoxOptions.RtlReading : 0); 
    361364 
    362365                Close(); 
     
    372375                installingLv.Items.Add(item); 
    373376 
    374                 UpdateData update = uiUpdates[(UpdateManager.Update)item.Tag]; 
     377                UpdateData update = uiUpdates[(UpdateInfo)item.Tag]; 
    375378                if (update.Error == null) 
    376379                    item.SubItems[1].Text = string.Empty; 
     
    414417                    throw new OperationCanceledException(); 
    415418 
    416                 Invoke(new EventHandler<UpdateManager.ProgressEventArgs>(installer_ProgressChanged), 
     419                Invoke(new EventHandler<ProgressEventArgs>(installer_ProgressChanged), 
    417420                    sender, e); 
    418421                return; 
    419422            } 
    420423 
    421             UpdateData update = uiUpdates[(UpdateManager.Update)e.UserState]; 
    422             if (e is UpdateManager.ProgressErrorEventArgs) 
    423             { 
    424                 update.Error = ((UpdateManager.ProgressErrorEventArgs)e).Exception; 
     424            UpdateData update = uiUpdates[(UpdateInfo)e.UserState]; 
     425            if (e is ProgressErrorEventArgs) 
     426            { 
     427                update.Error = ((ProgressErrorEventArgs)e).Exception; 
    425428                update.LVItem.ImageIndex = 3; 
    426429                update.LVItem.SubItems[1].Text = S._("Error: {0}", update.Error.Message); 
     
    460463        /// Maps listview items to the UpdateManager.Update object. 
    461464        /// </summary> 
    462         Dictionary<UpdateManager.Update, UpdateData> uiUpdates = 
    463             new Dictionary<UpdateManager.Update, UpdateData>(); 
     465        Dictionary<UpdateInfo, UpdateData> uiUpdates = new Dictionary<UpdateInfo, UpdateData>(); 
    464466 
    465467        /// <summary> 
     
    475477            /// <param name="item">The ListViewItem used for the display of the 
    476478            /// update.</param> 
    477             public UpdateData(UpdateManager.Update update, ListViewItem item) 
     479            public UpdateData(UpdateInfo update, ListViewItem item) 
    478480            { 
    479481                Update = update; 
     
    485487            /// of the update. 
    486488            /// </summary> 
    487             public UpdateManager.Update Update; 
     489            public UpdateInfo Update; 
    488490 
    489491            /// <summary> 
     
    518520    public class UpdateManager 
    519521    { 
    520         /// <summary> 
    521         /// Represents a download mirror. 
    522         /// </summary> 
    523         public struct Mirror 
    524         { 
    525             public Mirror(string location, string link) 
    526                 : this() 
    527             { 
    528                 Location = location; 
    529                 Link = link; 
    530             } 
    531  
    532             /// <summary> 
    533             /// The location where the mirror is at. 
    534             /// </summary> 
    535             public string Location 
    536             { 
    537                 get; 
    538                 set; 
    539             } 
    540  
    541             /// <summary> 
    542             /// The URL prefix to utilise the mirror. 
    543             /// </summary> 
    544             public string Link 
    545             { 
    546                 get; 
    547                 set; 
    548             } 
    549  
    550             public override string ToString() 
    551             { 
    552                 return Location; 
    553             } 
    554         } 
    555  
    556         /// <summary> 
    557         /// Represents an update available on the server. 
    558         /// </summary> 
    559         public struct Update 
    560         { 
    561             public string Name; 
    562             public Version Version; 
    563             public string Publisher; 
    564             public string Architecture; 
    565             public long FileSize; 
    566             public string Link; 
    567         } 
    568  
    569         /// <summary> 
    570         /// Specialised progress event argument, containing message describing 
    571         /// current action, and overall progress percentage. 
    572         /// </summary> 
    573         public class ProgressEventArgs : ProgressChangedEventArgs 
    574         { 
    575             public ProgressEventArgs(float progressPercentage, float overallPercentage, 
    576                 object userState, string message) 
    577                 : base((int)(progressPercentage * 100), userState) 
    578             { 
    579                 this.progressPercentage = progressPercentage; 
    580                 this.overallProgressPercentage = overallPercentage; 
    581                 this.message = message; 
    582             } 
    583  
    584             /// <summary> 
    585             /// Gets the asynchronous task progress percentage. 
    586             /// </summary> 
    587             public new float ProgressPercentage 
    588             { 
    589                 get 
    590                 { 
    591                     return progressPercentage; 
    592                 } 
    593             } 
    594  
    595             /// <summary> 
    596             /// Gets the asynchronous task overall progress percentage. 
    597             /// </summary> 
    598             public float OverallProgressPercentage 
    599             { 
    600                 get 
    601                 { 
    602                     return overallProgressPercentage; 
    603                 } 
    604             } 
    605  
    606             /// <summary> 
    607             /// Gets the message associated with the current task. 
    608             /// </summary> 
    609             public string Message 
    610             { 
    611                 get 
    612                 { 
    613                     return message; 
    614                 } 
    615             } 
    616  
    617             float progressPercentage; 
    618             float overallProgressPercentage; 
    619             string message; 
    620         } 
    621  
    622         /// <summary> 
    623         /// Extends the ProgressEventArgs further by allowing for the inclusion of 
    624         /// an exception. 
    625         /// </summary> 
    626         public class ProgressErrorEventArgs : ProgressEventArgs 
    627         { 
    628             /// <summary> 
    629             /// Constructor. 
    630             /// </summary> 
    631             /// <param name="e">The base ProgressEventArgs object.</param> 
    632             /// <param name="ex">The exception</param> 
    633             public ProgressErrorEventArgs(ProgressEventArgs e, Exception ex) 
    634                 : base(e.ProgressPercentage, e.OverallProgressPercentage, e.UserState, e.Message) 
    635             { 
    636                 this.exception = ex; 
    637             } 
    638  
    639             /// <summary> 
    640             /// The exception associated with the progress event. 
    641             /// </summary> 
    642             public Exception Exception 
    643             { 
    644                 get 
    645                 { 
    646                     return exception; 
    647                 } 
    648             } 
    649  
    650             private Exception exception; 
    651         } 
    652  
    653522        /// <summary> 
    654523        /// Retrieves the update list from the server. 
     
    755624        /// <param name="rdr">The XML reader object representing the element and its children.</param> 
    756625        /// <returns>A list of updates in the category.</returns> 
    757         private static List<Update> ParseUpdateCategory(XmlReader rdr) 
    758         { 
    759             List<Update> result = new List<Update>(); 
     626        private static List<UpdateInfo> ParseUpdateCategory(XmlReader rdr) 
     627        { 
     628            List<UpdateInfo> result = new List<UpdateInfo>(); 
    760629            if (!rdr.ReadToDescendant("item")) 
    761630                return result; 
     
    767636                    continue; 
    768637 
    769                 Update update = new Update(); 
     638                UpdateInfo update = new UpdateInfo(); 
    770639                update.Name = rdr.GetAttribute("name"); 
    771640                update.Version = new Version(rdr.GetAttribute("version")); 
    772641                update.Publisher = rdr.GetAttribute("publisher"); 
    773642                update.Architecture = rdr.GetAttribute("architecture"); 
    774                 update.FileSize = Convert.ToInt64(rdr.GetAttribute("filesize")); 
     643                update.FileSize = Convert.ToInt64(rdr.GetAttribute("filesize"), 
     644                    CultureInfo.InvariantCulture); 
    775645                update.Link = rdr.ReadElementContentAsString(); 
    776646 
     
    787657        /// <param name="updates">The updates to retrieve and install.</param> 
    788658        /// <returns>An opaque object for use with InstallUpdates.</returns> 
    789         public object DownloadUpdates(ICollection<Update> downloadQueue) 
     659        public object DownloadUpdates(ICollection<UpdateInfo> downloadQueue) 
    790660        { 
    791661            //Create a folder to hold all our updates. 
    792662            DirectoryInfo tempDir = new DirectoryInfo(Path.GetTempPath()); 
    793             tempDir = tempDir.CreateSubdirectory("eraser" + Environment.TickCount.ToString()); 
     663            tempDir = tempDir.CreateSubdirectory("eraser" + Environment.TickCount.ToString( 
     664                CultureInfo.InvariantCulture)); 
    794665 
    795666            int currUpdate = 0; 
    796             Dictionary<string, Update> tempFilesMap = new Dictionary<string, Update>(); 
    797             foreach (Update update in downloadQueue) 
     667            Dictionary<string, UpdateInfo> tempFilesMap = new Dictionary<string, UpdateInfo>(); 
     668            foreach (UpdateInfo update in downloadQueue) 
    798669            { 
    799670                try 
     
    814685                        byte[] tempBuffer = new byte[16384]; 
    815686                        string tempFilePath = Path.Combine( 
    816                             tempDir.FullName, string.Format("{0}-{1}", ++currUpdate, 
    817                             Path.GetFileName(reqUri.GetComponents(UriComponents.Path, UriFormat.Unescaped)))); 
     687                            tempDir.FullName, string.Format(CultureInfo.InvariantCulture, "{0}-{1}", 
     688                            ++currUpdate, Path.GetFileName(reqUri.GetComponents(UriComponents.Path, 
     689                                UriFormat.Unescaped)))); 
    818690 
    819691                        using (Stream strm = resp.GetResponseStream()) 
     
    857729        public void InstallUpdates(object value) 
    858730        { 
    859             Dictionary<string, Update> tempFiles = (Dictionary<string, Update>)value; 
    860             Dictionary<string, Update>.KeyCollection files = tempFiles.Keys; 
     731            Dictionary<string, UpdateInfo> tempFiles = (Dictionary<string, UpdateInfo>)value; 
     732            Dictionary<string, UpdateInfo>.KeyCollection files = tempFiles.Keys; 
    861733            int currItem = 0; 
    862734 
     
    865737                foreach (string path in files) 
    866738                { 
    867                     Update item = tempFiles[path]; 
     739                    UpdateInfo item = tempFiles[path]; 
    868740                    float progress = (float)currItem++ / files.Count; 
    869741                    OnProgress(new ProgressEventArgs(0.0f, progress, 
     
    966838        /// Retrieves the categories available. 
    967839        /// </summary> 
    968         public Dictionary<string, List<Update>>.KeyCollection Categories 
     840        public Dictionary<string, List<UpdateInfo>>.KeyCollection Categories 
    969841        { 
    970842            get 
     
    977849        /// Retrieves all updates available. 
    978850        /// </summary> 
    979         public Dictionary<string, List<Update>> Updates 
     851        public Dictionary<string, List<UpdateInfo>> Updates 
    980852        { 
    981853            get 
     
    990862        /// <param name="key">The category to retrieve.</param> 
    991863        /// <returns>All updates in the given category.</returns> 
    992         public ICollection<Update> this[string key] 
     864        public ICollection<UpdateInfo> this[string key] 
    993865        { 
    994866            get 
     
    1012884        /// The list of updates downloaded. 
    1013885        /// </summary> 
    1014         private Dictionary<string, List<Update>> updates = 
    1015             new Dictionary<string, List<Update>>(); 
     886        private Dictionary<string, List<UpdateInfo>> updates = 
     887            new Dictionary<string, List<UpdateInfo>>(); 
     888    } 
     889 
     890    /// <summary> 
     891    /// Represents a download mirror. 
     892    /// </summary> 
     893    public struct Mirror 
     894    { 
     895        public Mirror(string location, string link) 
     896            : this() 
     897        { 
     898            Location = location; 
     899            Link = link; 
     900        } 
     901 
     902        /// <summary> 
     903        /// The location where the mirror is at. 
     904        /// </summary> 
     905        public string Location 
     906        { 
     907            get; 
     908            set; 
     909        } 
     910 
     911        /// <summary> 
     912        /// The URL prefix to utilise the mirror. 
     913        /// </summary> 
     914        public string Link 
     915        { 
     916            get; 
     917            set; 
     918        } 
     919 
     920        public override string ToString() 
     921        { 
     922            return Location; 
     923        } 
     924    } 
     925 
     926    /// <summary> 
     927    /// Represents an update available on the server. 
     928    /// </summary> 
     929    public struct UpdateInfo 
     930    { 
     931        public string Name { get; set; } 
     932        public Version Version { get; set; } 
     933        public string Publisher { get; set; } 
     934        public string Architecture { get; set; } 
     935        public long FileSize { get; set; } 
     936        public string Link { get; set; } 
     937    } 
     938 
     939    /// <summary> 
     940    /// Specialised progress event argument, containing message describing 
     941    /// current action, and overall progress percentage. 
     942    /// </summary> 
     943    public class ProgressEventArgs : ProgressChangedEventArgs 
     944    { 
     945        public ProgressEventArgs(float progressPercentage, float overallPercentage, 
     946            object userState, string message) 
     947            : base((int)(progressPercentage * 100), userState) 
     948        { 
     949            this.progressPercentage = progressPercentage; 
     950            this.overallProgressPercentage = overallPercentage; 
     951            this.message = message; 
     952        } 
     953 
     954        /// <summary> 
     955        /// Gets the asynchronous task progress percentage. 
     956        /// </summary> 
     957        public new float ProgressPercentage 
     958        { 
     959            get 
     960            { 
     961                return progressPercentage; 
     962            } 
     963        } 
     964 
     965        /// <summary> 
     966        /// Gets the asynchronous task overall progress percentage. 
     967        /// </summary> 
     968        public float OverallProgressPercentage 
     969        { 
     970            get 
     971            { 
     972                return overallProgressPercentage; 
     973            } 
     974        } 
     975 
     976        /// <summary> 
     977        /// Gets the message associated with the current task. 
     978        /// </summary> 
     979        public string Message 
     980        { 
     981            get 
     982            { 
     983                return message; 
     984            } 
     985        } 
     986 
     987        float progressPercentage; 
     988        float overallProgressPercentage; 
     989        string message; 
     990    } 
     991 
     992    /// <summary> 
     993    /// Extends the ProgressEventArgs further by allowing for the inclusion of 
     994    /// an exception. 
     995    /// </summary> 
     996    public class ProgressErrorEventArgs : ProgressEventArgs 
     997    { 
     998        /// <summary> 
     999        /// Constructor. 
     1000        /// </summary> 
     1001        /// <param name="e">The base ProgressEventArgs object.</param> 
     1002        /// <param name="ex">The exception</param> 
     1003        public ProgressErrorEventArgs(ProgressEventArgs e, Exception ex) 
     1004            : base(e.ProgressPercentage, e.OverallProgressPercentage, e.UserState, e.Message) 
     1005        { 
     1006            this.exception = ex; 
     1007        } 
     1008 
     1009        /// <summary> 
     1010        /// The exception associated with the progress event. 
     1011        /// </summary> 
     1012        public Exception Exception 
     1013        { 
     1014            get 
     1015            { 
     1016                return exception; 
     1017            } 
     1018        } 
     1019 
     1020        private Exception exception; 
    10161021    } 
    10171022} 
Note: See TracChangeset for help on using the changeset viewer.