internal override void FromCofigFavorite(IFavorite destination, FavoriteConfigurationElement source)
 {
     this.SSH1 = source.SSH1;
     this.AuthMethod = source.AuthMethod;
     this.CertificateKey = source.KeyTag;
     this.SSHKeyFile = source.SSHKeyFile;
 }

 internal override void ToConfigFavorite(IFavorite source, FavoriteConfigurationElement destination)
 {
     destination.SSH1 = this.SSH1;
     destination.AuthMethod = this.AuthMethod;
     destination.KeyTag = this.CertificateKey;
     destination.SSHKeyFile = this.SSHKeyFile;
 }

        public static Size GetSize(Connection connection, IFavorite favorite)
        {
            int height = favorite.Display.Height;
            int width = favorite.Display.Width;

            switch (favorite.Display.DesktopSize)
            {
                case DesktopSize.x640:
                    return new Size(640, 480);
                case DesktopSize.x800:
                    return new Size(800, 600);
                case DesktopSize.x1024:
                    return new Size(1024, 768);
                case DesktopSize.x1152:
                    return new Size(1152, 864);
                case DesktopSize.x1280:
                    return new Size(1280, 1024);
                case DesktopSize.FullScreen:
                    width = Screen.FromControl(connection).Bounds.Width - 13;
                    height = Screen.FromControl(connection).Bounds.Height - 1;
                    return GetMaxAvailableSize(width, height);
                case DesktopSize.FitToWindow:
                case DesktopSize.AutoScale:
                    width = connection.Parent.Width;
                    height = connection.Parent.Height;
                    return GetMaxAvailableSize(width, height);
                default:
                    return new Size(width, height);
            }
        }

 public void LoadFrom(IFavorite favorite)
 {
     this.FillDisplayControls(favorite);
     var rdpOptions = favorite.ProtocolProperties as RdpOptions;
     if (rdpOptions != null)
         this.FillRdpDisplayControls(rdpOptions);
 }

 internal void LoadFrom(IFavorite favorite)
 {
     foreach (var protocolControl in this.Controls.OfType<IProtocolOptionsControl>())
     {
         protocolControl.LoadFrom(favorite);
     }
 }

 public NewTerminalForm(IPersistence persistence, IFavorite favorite)
     : this()
 {
     this.persistence = persistence;
     this.InitializeFavoritePropertiesControl();
     this.Init(favorite, String.Empty);
 }

 public void SaveTo(IFavorite favorite)
 {
     this.FillFavoriteDisplayOptions(favorite);
     var rdpOptions = favorite.ProtocolProperties as RdpOptions;
     if (rdpOptions != null)
         this.FillFavoriteRdpDisplayOptions(rdpOptions);
 }

        public void CheckForTerminalServer(IFavorite favorite)
        {
            if (favorite.Protocol == ConnectionManager.RDP)
                ThreadPool.QueueUserWorkItem(new WaitCallback(this.CheckForTS), favorite);

            this.IsTerminalServer = false;
        }

 private void FillDisplayControls(IFavorite favorite)
 {
     this.cmbResolution.SelectedIndex = (Int32)favorite.Display.DesktopSize;
     this.cmbColors.SelectedIndex = (Int32)favorite.Display.Colors;
     this.widthUpDown.Value = favorite.Display.Width;
     this.heightUpDown.Value = favorite.Display.Height;
 }

        /// <summary>
        /// Creates deep copy of provided favorite in persistence including its toolbar button and groups memebership.
        /// The copy is already added to the persistence.
        /// Returns newly created favorite copy if operation was successfull; otherwise null.
        /// </summary>
        internal IFavorite Copy(IFavorite favorite)
        {
            if (favorite == null)
                return null;

            return this.CopyUsingPrompt(favorite);
        }

 internal static ValidationStates Validate(IFavorite favorite)
 {
     List<ValidationState> results = ValidateObject(favorite);
     var executeResults = ValidateObject(favorite.ExecuteBeforeConnect);
     results.AddRange(executeResults);
     return new ValidationStates(results);
 }

 public void LoadFrom(IFavorite favorite)
 {
     this.chkExecuteBeforeConnect.Checked = favorite.ExecuteBeforeConnect.Execute;
     this.txtCommand.Text = favorite.ExecuteBeforeConnect.Command;
     this.txtArguments.Text = favorite.ExecuteBeforeConnect.CommandArguments;
     this.txtInitialDirectory.Text = favorite.ExecuteBeforeConnect.InitialDirectory;
     this.chkWaitForExit.Checked = favorite.ExecuteBeforeConnect.WaitForExit;
 }

 private static void ConvertDisplay(IFavorite result, FavoriteConfigurationElement sourceFavorite)
 {
     IDisplayOptions display = result.Display;
     display.Colors = sourceFavorite.Colors;
     display.DesktopSize = sourceFavorite.DesktopSize;
     display.Width = sourceFavorite.DesktopSizeWidth;
     display.Height = sourceFavorite.DesktopSizeHeight;
 }

        private IFavorite CopyUsingPrompt(IFavorite favorite)
        {
            InputBoxResult result = this.copyPrompt();
            if (result.ReturnCode == DialogResult.OK && !string.IsNullOrEmpty(result.Text))
                return this.CopySelectedFavorite(favorite, result.Text);

            return null;
        }

 private static void ConvertDisplay(FavoriteConfigurationElement result, IFavorite sourceFavorite)
 {
     IDisplayOptions display = sourceFavorite.Display;
     result.Colors = display.Colors;
     result.DesktopSize = display.DesktopSize;
     result.DesktopSizeWidth = display.Width;
     result.DesktopSizeHeight = display.Height;
 }

 internal static void AddFavoriteIntoGroups(IPersistence persistence, IFavorite toPerisist, IEnumerable<string> validGroupNames)
 {
     foreach (string groupName in validGroupNames)
     {
         IGroup group = FavoritesFactory.GetOrAddNewGroup(persistence, groupName);
         group.AddFavorite(toPerisist);
     }
 }

 public void Add(IFavorite favorite)
 {
     if (AddToCache(favorite))
     {
         this.dispatcher.ReportFavoriteAdded(favorite);
         this.persistence.SaveImmediatelyIfRequested();
     }
 }

 internal static void UpdateFavoriteUrl(IFavorite destination, string newAbsoluteUrl)
 {
     var webOptions = destination.ProtocolProperties as WebOptions;
     if (webOptions != null)
     {
         webOptions.UpdateMyFavoriteUrl(destination, newAbsoluteUrl);
     }
 }

        public void SaveTo(IFavorite favorite)
        {
            var rdpOptions = favorite.ProtocolProperties as RdpOptions;
            if (rdpOptions == null)
                return;

            FillFavoriteTSgatewayOptions(rdpOptions);
        }

        public void LoadFrom(IFavorite favorite)
        {
            var rdpOptions = favorite.ProtocolProperties as RdpOptions;
            if (rdpOptions == null)
                return;

            FillTsGatewayControls(rdpOptions);
        }