Click here to Skip to main content
15,885,680 members
Articles / Desktop Programming / WPF

C.B.R.

Rate me:
Please Sign up or sign in to vote.
4.96/5 (52 votes)
22 Oct 2012GPL329 min read 124.2K   1.8K   132  
Comic and electronic publication reader with library management, extended file conversion, and devices support.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CBR.Core.Helpers;
using CBR.Core.Services;
using System.Windows.Input;
using CBR.Core.Models;
using System.Collections.ObjectModel;

namespace CBR.ViewModels
{
	class OptionsViewModel : ViewModelBase
	{
		#region ----------------PROPERTIES----------------

        public int ImageCacheCount
		{
			get
			{
                return WorkspaceService.Instance.Settings.ImageCacheCount;
			}
			set
			{
                WorkspaceService.Instance.Settings.ImageCacheCount = value;
			}
		}

        public int ImageCacheDuration
        {
            get
            {
                return WorkspaceService.Instance.Settings.ImageCacheDuration;
            }
            set
            {
                WorkspaceService.Instance.Settings.ImageCacheDuration = value;
            }
        }

        public int AutoFitMode
        {
            get
            {
                return WorkspaceService.Instance.Settings.AutoFitMode;
            }
            set
            {
                if( value != -1 )
                    WorkspaceService.Instance.Settings.AutoFitMode = value;
            }
        }

        public double MagnifierScaleFactor
        {
            get
            {
                return WorkspaceService.Instance.Settings.MagnifierScaleFactor;
            }
            set
            {
                WorkspaceService.Instance.Settings.MagnifierScaleFactor = value;
            }
        }

        public double MagnifierSize
        {
            get
            {
                return WorkspaceService.Instance.Settings.MagnifierSize;
            }
            set
            {
                WorkspaceService.Instance.Settings.MagnifierSize = value;
            }
        }

        public int MaxRecentFile
        {
            get
            {
                return WorkspaceService.Instance.Settings.MaxRecentFile;
            }
            set
            {
                WorkspaceService.Instance.Settings.MaxRecentFile = value;
            }
        }

        public ObservableCollection<string> Dynamics
        {
            get { return new ObservableCollection<string>( WorkspaceService.Instance.Settings.Dynamics ); }
        }

		#endregion

        #region save command
        private ICommand saveSettingsCommand;
        public ICommand SaveSettingsCommand
        {
            get
            {
                if (saveSettingsCommand == null)
                    saveSettingsCommand = new DelegateCommand(SaveSetting, delegate() { return true; });
                return saveSettingsCommand;
            }
        }

        void SaveSetting()
        {
            try
            {
                Properties.Settings.Default.CatalogSetting = WorkspaceService.Instance.Settings;
                Properties.Settings.Default.Save();

                Mediator.Instance.NotifyColleagues(ViewModelMessages.SettingsChanged, WorkspaceService.Instance.Settings);
            }
            catch (Exception err)
            {
                ExceptionHelper.Manage("OptionsViewModel:SaveSetting", err);
            }
        }
        #endregion

        #region reset command
        private ICommand resetSettingsCommand;
        public ICommand ResetSettingsCommand
        {
            get
            {
                if (resetSettingsCommand == null)
                    resetSettingsCommand = new DelegateCommand(ResetSetting, delegate() { return true; });
                return resetSettingsCommand;
            }
        }

        void ResetSetting()
        {
            try
            {
                WorkspaceService.Instance.Settings = new WorkspaceInfo();
                Properties.Settings.Default.CatalogSetting = WorkspaceService.Instance.Settings;
                Properties.Settings.Default.Save();

                Mediator.Instance.NotifyColleagues(ViewModelMessages.SettingsChanged, WorkspaceService.Instance.Settings);
            }
            catch (Exception err)
            {
                ExceptionHelper.Manage("OptionsViewModel:ResetSetting", err);
            }
        }
        #endregion

        #region add command
        private ICommand addPropertyCommand;
        public ICommand AddPropertyCommand
        {
            get
            {
                if (addPropertyCommand == null)
                    addPropertyCommand = new DelegateCommand<string>(AddProperty, delegate(string param) { return !string.IsNullOrEmpty(param); });
                return addPropertyCommand;
            }
        }

        void AddProperty(string param)
        {
            try
            {
                if (WorkspaceService.Instance.Settings.Dynamics.Contains(param as string))
                    return;
                else
                {
                    WorkspaceService.Instance.Settings.Dynamics.Add(param as string);

                    Properties.Settings.Default.CatalogSetting = WorkspaceService.Instance.Settings;
                    Properties.Settings.Default.Save();
                }

                RaisePropertyChanged("Dynamics");
                Mediator.Instance.NotifyColleagues(ViewModelMessages.SettingsChanged, WorkspaceService.Instance.Settings);
            }
            catch (Exception err)
            {
                ExceptionHelper.Manage("OptionsViewModel:AddProperty", err);
            }
        }
        #endregion

        #region delete command
        private ICommand deletePropertyCommand;
        public ICommand DeletePropertyCommand
        {
            get
            {
                if (deletePropertyCommand == null)
                    deletePropertyCommand = new DelegateCommand<string>(DeleteProperty, delegate(string param) { return !string.IsNullOrEmpty(param); });
                return deletePropertyCommand;
            }
        }

        void DeleteProperty(string param)
        {
            try
            {
                if (WorkspaceService.Instance.Settings.Dynamics.Contains(param as string))
                {
                    WorkspaceService.Instance.Settings.Dynamics.Remove(param as string);

                    Properties.Settings.Default.CatalogSetting = WorkspaceService.Instance.Settings;
                    Properties.Settings.Default.Save();
                }

                RaisePropertyChanged("Dynamics");
                Mediator.Instance.NotifyColleagues(ViewModelMessages.SettingsChanged, WorkspaceService.Instance.Settings);
            }
            catch (Exception err)
            {
                ExceptionHelper.Manage("OptionsViewModel:DeleteProperty", err);
            }
        }
        #endregion
	}
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The GNU General Public License (GPLv3)


Written By
Architect
France France
WPF and MVVM fan, I practice C # in all its forms from the beginning of the NET Framework without mentioning C ++ / MFC and other software packages such as databases, ASP, WCF, Web & Windows services, Application, and now Core and UWP.
In my wasted hours, I am guilty of having fathered C.B.R. and its cousins C.B.R. for WinRT and UWP on the Windows store.
But apart from that, I am a great handyman ... the house, a rocket stove to heat the jacuzzi and the last one: a wood oven for pizza, bread, and everything that goes inside

https://guillaumewaser.wordpress.com/
https://fouretcompagnie.wordpress.com/

Comments and Discussions