public VersionMini(VersionInfo vers, FTObjects ftobjects)
 {
     InitializeComponent();
     m_VersionInfo = vers;
     m_FTObjects = ftobjects;
     SetVersion();
 }

 public VersionLeaf(VersionInfo vers)
 {
     this.m_VersionInfo = vers;
     this.Visible = true;
     InitializeComponent();
     if (m_VersionInfo != null)
     {
         this.VersionLabelBig.Text = m_VersionInfo.versionName;
     }
     else
     {
         this.VersionLabelBig.Text = "Big Version";
     }
     if (m_VersionInfo != null && m_VersionInfo.userVersName != null)
     {
         StringBuilder bil = new StringBuilder();
         foreach (string name in m_VersionInfo.userVersName)
         {
             bil.Append(name + "\n");
         }
         this.VersionLabel.Text = bil.ToString();
     }
     else
     {
         this.VersionLabel.Text = "Small Version";
     }
 }

        private void WebClient_OnDownloadStringCompleted(object sender, DownloadStringCompletedEventArgs downloadStringCompletedEventArgs)
        {
            // Pega a referência do resultado            
            var result = downloadStringCompletedEventArgs.Result;
            // Deserializa o XML recebido do site
            latestVersion = SerializationHelper.ReadFromXml<VersionInfo>(result);
            // Libera o WebClient da memória
            ((WebClient)sender).Dispose();
            
            // Atualiza as configurações, informando a data da última checagem de atualização
            Properties.Settings.Default.LastTimeCheckedUpdate = DateTime.Now;
            Properties.Settings.Default.Save();

            // Atualiza as configurações
            Properties.Settings.Default.UpdateAvailable = UpdateAvailable;
            Properties.Settings.Default.Save();

            // Atualização disponível
            if (!UpdateAvailable) return;            

            // Define o local para salvar o arquivo
            downloadedFileName = downloadedFileDir + System.IO.Path.GetFileName(latestVersion.downloadURL);
            // Baixa atualização
            DownloadUpdate(latestVersion.downloadURL, downloadedFileName);
        }

        public ChangeLogEntry CreateEntry(VersionInfo version,string text)
        {
            ChangeLogEntry entry = new ChangeLogEntry();
            entry.Version = version;
            entry.Text = text;

            return entry;
        }

 public void removeVersion(VersionInfo version)
 {
     DataRow dat;
     VersionInfoFromDataRow.TryGetValue(version, out dat);
     if (dat != null)
     {
         this.Rows.Remove(dat);
         VersionInfoFromDataRow.Remove(version);
     }
 }

        public override void ExecuteVersioningStrategy(string currentVersion, string desiredVersion)
        {
            Logger.InfoFormat("No version history information found, creating history at version '{0}'..",
                desiredVersion);
            var version = new VersionInfo {Version = desiredVersion};
            CreateNewVersion(version);
            Logger.InfoFormat("Version '{0}' recorded.", desiredVersion);

            FromVersion = "0";
            ToVersion = version.Version;
        }

        public VersionFile GetVersionInfo(VersionInfo build)
        {
            if (!Configured())
                return null;
            if (!File.Exists(_repoDir + @"\xmls\Version_" + _platform + "_" + build.Build + ".xml"))
                return null;

            var fileinfo = new VersionFile();
            fileinfo.Load(_repoDir + @"\xmls\Version_" + _platform + "_" + build.Build + ".xml");
            return fileinfo;
        }

        public void addVersion(VersionInfo vers)
        {
            List<VersionBox> newC = mana.returnChangeAdd(vers);
            this.SuspendLayout();
            VersionLeaf vler;
            //Todo if there is a row add then everything must be redrawn
            //make that more clear bu setting a variable
            //then check that and redraw
            //if (mana.removeBox == null && newC == null)
            //{
            //    addAllFromMana();
            //}
            //else
            //{
            //    foreach (BoxLoc bo in mana.removeBox)
            //    {
            //        VersionBoxFromString.TryGetValue("row" + bo.row + "col" + bo.col, out vler);
            //        if (vler != null)
            //        {
            //            vler.Visible = false;
            //        }
            //    }
            //    this.tableLayoutPanel1.ColumnCount = mana.Col + 1;
            //    this.tableLayoutPanel1.RowCount = mana.Row + 1;
            //    foreach (VersionBox vb in newC)
            //    {
            //        VersionBoxFromString.TryGetValue("row" + vb.Row + "col" + vb.Col, out vler);
            //        if (vler != null)
            //        {
            //            vler.setVersionInfo(vb.m_version);
            //        }
            //        else
            //        {
            //            this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
            //            VersionLeaf leaf = new VersionLeaf(vb.m_version);
            //            leaf.setText("Col: " + vb.Col + " Row: " + vb.Row + " ColSpan: " + vb.ColSpan);
            //            leaf.Anchor = System.Windows.Forms.AnchorStyles.None;
            //            leaf.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            //            leaf.Location = new System.Drawing.Point(4, 4);
            //            leaf.Size = new System.Drawing.Size(150, 150);
            //            this.tableLayoutPanel1.Controls.Add(leaf, vb.Col, vb.Row);
            //            VersionBoxFromString["row" + vb.Row + "col" + vb.Col] = leaf;
            //            if (vb.ColSpan > 0)
            //            {
            //                this.tableLayoutPanel1.SetColumnSpan(leaf, vb.ColSpan);
            //            }
            //            this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle());
            //        }

            //    }
            //}
            //this.ResumeLayout(false);
            //this.PerformLayout();
        }

 public void setVersionInfo(VersionInfo vers)
 {
     this.m_VersionInfo = vers;
     this.VersionLabelBig.Text = vers.versionName;
     StringBuilder bil = new StringBuilder();
     foreach (string name in m_VersionInfo.userVersName)
     {
         bil.Append(name + "\n");
     }
     this.VersionLabel.Text = bil.ToString();
     this.Visible = true;
 }

		void CreateControlFromInfo ()
		{
			var lw = new LogWidget (info);
			
			widget = lw;
			info.Updated += OnInfoUpdated;
			lw.History = this.info.History;
			vinfo   = this.info.Item.VersionInfo;
		
			if (WorkbenchWindow != null)
				widget.SetToolbar (WorkbenchWindow.GetToolbar (this));
		}

		public override void Deserialize(GenericReader reader)
		{
			base.Deserialize(reader);

			int version = reader.GetVersion();

			switch (version)
			{
				case 0:
					Version = new VersionInfo(reader);
					break;
			}
		}

        public bool UpdateVersionDescription(VersionInfo build, string description)
        {
            if (!Configured())
                return false;
            if (!File.Exists(_repoDir + @"\xmls\Version_" + _platform + "_" + build.Build + ".xml"))
                return false;

            var fileinfo = new VersionFile();
            fileinfo.Load(_repoDir + @"\xmls\Version_" + _platform + "_" + build.Build + ".xml");
            fileinfo.Description = description;
            fileinfo.Save(_repoDir + @"\xmls\Version_" + _platform + "_" + build.Build + ".xml");

            return true;
        }

 public CalendarPanel(VersionInfo vers)
 {
     InitializeComponent();
     this.DateLabel.Text = vers.date.ToLongDateString();
     this.TimeLabel.Text = vers.date.ToLongTimeString();
     this.VersionsListBox.Items.Add(vers.versionName);
     if (vers.userVersName != null)
     {
         foreach (string v in vers.userVersName)
         {
             this.VersionsListBox.Items.Add(v);
         }
     }
 }

        public static VersionInfo Get()
        {
            if (versionInfo == null)
            {
                lock (lockObj)
                {
                    if (versionInfo == null)
                    {
                        versionInfo = get();
                    }
                }
            }

            return versionInfo;
        }

		void CreateControlFromInfo ()
		{
			this.vc = info.Item.Repository;
			this.filepath = info.Item.Path;
			var lw = new LogWidget (info);
			
			widget = lw;
			info.Updated += delegate {
				lw.History = this.info.History;
				vinfo   = this.info.VersionInfo;
			};
			lw.History = this.info.History;
			vinfo   = this.info.VersionInfo;
		
		}

			public DiffData (Repository vc, FilePath root, VersionInfo info, bool remote)
			{
				VersionInfo = info;
				Diff = new Lazy<DiffInfo> (() => {
					try {
						DiffInfo result = null;
						if (!remote)
							result = vc.GenerateDiff (root, info);
						return result ?? vc.PathDiff (root, new [] { info.LocalPath }, remote).FirstOrDefault ();
					} catch (Exception ex) {
						Exception = ex;
						return null;
					}
				});
			}

        public object Get(VersionInfo request)
        {
            var availableMigrations = Assembly.GetTypes()
                .Where(t => t.IsDefined(typeof(MigrationAttribute), true))
                .Select(t =>
                {
                    var m = (MigrationAttribute)t.GetCustomAttributes(typeof(MigrationAttribute), true).First();
                    return new VersionInfo 
                    { 
                        Description = m.Description ?? t.Name, 
                        Version = m.Version,
                        IsAvailable = true,
                    };
                })
                .ToList();

            using(var con = Database.OpenDbConnection())
            {
                List<VersionInfo> appliedMigrations;

                if (con.TableExists("VersionInfo"))
                {
                    appliedMigrations = con.Select<VersionInfo>();
                }
                else
                {
                    appliedMigrations = new List<VersionInfo>();
                }

                return new VersionInfoResponse
                {
                    Migrations = appliedMigrations
                        .Concat(availableMigrations)
                        .ToLookup(v => v.Version)
                        .Select(g => g.Aggregate((v1, v2) => new VersionInfo
                        {
                            Version = v1.Version,
                            Description = v1.Description ?? v2.Description,
                            AppliedOn = v1.AppliedOn ?? v2.AppliedOn,
                            IsAvailable = v1.IsAvailable || v2.IsAvailable,
                        }))
                        .OrderByDescending(v => v.Version)
                        .ToList(),
                    Info = appliedMigrations.Except(availableMigrations).Any() ? "Warning: Database has migrations applied that are not available in the current migration assembly.  Rollback may not be possible." : null,
                    Database = con.Database,
                };
            }            
        }

 public static void AddUserVersionButton_Click( VersionInfo VersionInfo, EventArgs e, Panel Caller)
 {
     if (VersionInfo != null)
     {
         Util.UserDebug("Add User Version Button Clicked " + VersionInfo.versionName);
         UserVersionForm uservers = new UserVersionForm(VersionInfo, m_FTObjects.AllUserVersions);
         DialogResult res = uservers.ShowDialog(Caller);
         if (res == DialogResult.OK)
         {
             UserVersVer ver = new UserVersVer();
             ver.uservers = uservers;
             ver.versionInfo = VersionInfo;
             new Thread(new ParameterizedThreadStart(HandleAddUser)).Start(ver);
         }
     }
 }

 public void SetVersionInfo(VersionInfo vi)
 {
     this.versionInfo = vi;
     string version = GameInfo.instance.version;
     if (vi.isMandatory == 1)
     {
         this.descTM.text = string.Format(Localization.Localize("NewVersionNoticeContent2"), version, vi.newVersionId);
         this.mandatoryObj.SetActive(true);
         this.optionObj.SetActive(false);
     }
     else
     {
         this.descTM.text = string.Format(Localization.Localize("NewVersionNoticeContent1"), version, vi.newVersionId);
         this.optionObj.SetActive(true);
         this.mandatoryObj.SetActive(false);
     }
     this.descTM.Commit();
 }

            public static bool TryParse(string value, out VersionInfo info)
            {
                if (value.Length > 1 && value.EndsWith("b"))
                {
                    value = value.Substring(0, value.Length - 1);
                }

                if (string.IsNullOrEmpty(value))
                {
                    info = default(VersionInfo);
                    return false;
                }
                
                string[] tokens = value.Split('.');
                if (tokens.Length != 3)
                {
                    info = default(VersionInfo);
                    return false;
                }
                
                int major;
                if (!int.TryParse(tokens[0], out major))
                {
                    info = default(VersionInfo);
                    return false;
                }
                
                int minor;
                if (!int.TryParse(tokens[1], out minor))
                {
                    info = default(VersionInfo);
                    return false;
                }
                
                int maintenance;
                if (!int.TryParse(tokens[2], out maintenance))
                {
                    info = default(VersionInfo);
                    return false;
                }
                
                info = new VersionInfo(major, minor, maintenance);
                return true;
            }