Exemple #1
0
        protected override void LoadFromObject(VolumeDB.Volume volume)
        {
            //
            // form
            //
            ArchiveNo   = volume.ArchiveNo;
            Category    = volume.Category;
            Title       = volume.Title;
            Description = volume.Description;
            Keywords    = volume.Keywords;
            LoanedTo    = volume.LoanedTo;

            if (volume.LoanedDate != DateTime.MinValue)
            {
                dcLoanedDate.Date = volume.LoanedDate;
            }
            else
            {
                dcLoanedDate.Clear();
            }

            if (volume.ReturnDate != DateTime.MinValue)
            {
                dcReturnDate.Date = volume.ReturnDate;
            }
            else
            {
                dcReturnDate.Clear();
            }

            //
            // info labels
            //
            UpdateInfoLabels(volume.IsHashed, volume.Added);
        }
Exemple #2
0
        protected override void LoadFromObject(VolumeDB.Volume volume)
        {
            if (!(volume is AudioCdVolume))
            {
                throw new ArgumentException(string.Format("must be of type {0}",
                                                          typeof(AudioCdVolume)), "volume");
            }

            base.LoadFromObject(volume);

            AudioCdVolume avol = (AudioCdVolume)volume;

            UpdateInfoLabels(avol.Tracks, avol.Duration);
        }
        protected override void LoadFromObject(VolumeDB.Volume volume)
        {
            if (!(volume is FileSystemVolume))
            {
                throw new ArgumentException(string.Format("must be of type {0}",
                                                          typeof(FileSystemVolume)), "volume");
            }

            base.LoadFromObject(volume);

            FileSystemVolume fsvol = (FileSystemVolume)volume;

            UpdateInfoLabels(fsvol.Files, fsvol.Directories, fsvol.Size);
        }
Exemple #4
0
        protected override void SaveToObject(VolumeDB.Volume volume)
        {
            // save form
            volume.ArchiveNo   = ArchiveNo.Trim();
            volume.Category    = Category;
            volume.Title       = Title.Trim();
            volume.Description = Description;
            volume.Keywords    = Keywords.Trim();
            volume.LoanedTo    = LoanedTo.Trim();
            volume.LoanedDate  = LoanedDate;
            volume.ReturnDate  = ReturnDate;

            volume.UpdateChanges();
        }
Exemple #5
0
        public void FillRoot(Volume volume, VolumeDatabase db)
        {
            if (volume == null)
                throw new ArgumentNullException("volume");

            if (db == null)
                throw new ArgumentNullException("db");

            this.database = db;

            TreeModel model;
            VolumeType volType = volume.GetVolumeType();
            ResetView();

            switch (volType) {
                case VolumeType.FileSystemVolume:
                    InitView(volType, out model);

                    // load volume root
                    FileSystemVolume fsv = (FileSystemVolume)volume;
                    DirectoryVolumeItem item = fsv.GetRoot();

                    AppendDirRows((TreeStore)model, TreeIter.Zero, item);

                    Model = model;
                    /*ColumnsAutosize();*/
                    break;

                case VolumeType.AudioCdVolume:
                    InitView(volType, out model);

                    // load volume root
                    AudioCdVolume avol = (AudioCdVolume)volume;
                    AudioCdRootVolumeItem root = avol.GetRoot();

                    AudioTrackVolumeItem[] tracks = root.GetTracks();

                    ListStore store = (ListStore)model;
                    if (tracks.Length == 0) {
                        store.AppendValues(null, STR_EMPTY, STR_EMPTY, STR_EMPTY);
                    } else {
                        foreach (AudioTrackVolumeItem track in tracks) {
                            store.AppendValues(GetImage(track),
                                           track.Name,
                                           (track.Artist.Length == 0 ? S._("Unknown") : track.Artist),
                                           string.Format("{0:D2}:{1:D2}", track.Duration.Minutes, track.Duration.Seconds),
                                           track);
                        }
                    }

                    Model = model;
                    /*ColumnsAutosize();*/
                    break;
                default:
                    throw new NotImplementedException("Items view has not been implemented for this volumetype");
            }
        }
Exemple #6
0
 public NewVolumeAddedEventArgs(Volume volume)
     : base()
 {
     this.volume = volume;
 }
Exemple #7
0
        private Gdk.Pixbuf GetVolumeIcon(Volume v)
        {
            Gdk.Pixbuf icon;

            switch (v.DriveType) {
                case VolumeDriveType.CDRom:
                    icon = iconCache.GetIcon(Icons.Icon.Stock_Cdrom, ICON_SIZE);
                    break;
                case VolumeDriveType.Harddisk:
                    icon = iconCache.GetIcon(Icons.Icon.Stock_Harddisk, ICON_SIZE);
                    break;
                case VolumeDriveType.Ram:
                    icon = iconCache.GetIcon(Icons.Icon.Stock_Harddisk, ICON_SIZE); // FIXME : is there a more suitable icon?
                    break;
                case VolumeDriveType.Network:
                    icon = iconCache.GetIcon(Icons.Icon.Stock_Network, ICON_SIZE);
                    break;
                case VolumeDriveType.Removable:
                    icon = iconCache.GetIcon(Icons.Icon.DriveRemovableMedia, ICON_SIZE);
                    break;
                case VolumeDriveType.Unknown:
                    icon = iconCache.GetIcon(Icons.Icon.Stock_Harddisk, ICON_SIZE); // FIXME : is there a more suitable icon?
                    break;
               default:
                   throw new Exception("Invalid VolumeDriveType");
            }

            return icon;
        }
Exemple #8
0
        private string GetVolumeDescription(Volume v)
        {
            // common volume info
            string title;
            string category;

             	if (string.IsNullOrEmpty(v.Title)) {
                Gdk.Color a = Parent.Style.Base(Gtk.StateType.Normal);
                Gdk.Color b = Parent.Style.Text(Gtk.StateType.Normal);
                Gdk.Color c = Util.ColorBlend(a, b);

                double gdk_max = (double)ushort.MaxValue;
                string col = string.Format("#{0:X2}{1:X2}{2:X2}",
                                       (int)(255 * (c.Red / gdk_max)),
                                       (int)(255 * (c.Green / gdk_max)),
                                       (int)(255 * (c.Blue / gdk_max)));

                title = string.Format("<span foreground=\"{0}\">{1}</span>", col, Util.Escape(STR_UNNAMED));

            } else if (!string.IsNullOrEmpty(v.LoanedTo)) {
                title = string.Format("<span foreground=\"red\">{0}</span>", Util.Escape(v.Title));
            } else {
                title = Util.Escape(v.Title);
            }

            if (string.IsNullOrEmpty(v.ArchiveNo)) {
                title = string.Format("<b>{0}</b>", title);
            } else {
                title = string.Format("<b>{0}</b> <small>({1})</small>",
                                  title,
                                  Util.Escape(v.ArchiveNo));
            }

            if (string.IsNullOrEmpty(v.Category))
                category = "-";
            else if (!VolumeEditor.categories.TryGetTranslatedString(v.Category, out category))
                category = v.Category;

            // specific volume info
            // only show important info, otherwise its too cluttered, too high!
            string strFormat = "{0}\n<span size=\"medium\"><i>{1}</i> {2}\n{3} / {4} {5}</span>";
            string desc;

            switch (v.GetVolumeType()) {
                case VolumeType.FileSystemVolume:
                    FileSystemVolume fsv = (FileSystemVolume)v;

                    desc = string.Format(strFormat,
                                     title,
                                     Util.Escape(STR_CATEGORY),
                                     Util.Escape(category),
                                     Util.GetSizeStr(fsv.Size),
                                     fsv.Files.ToString(),
                                     Util.Escape(STR_FILES));
                    break;
            case VolumeType.AudioCdVolume:
                    AudioCdVolume avol = (AudioCdVolume)v;

                    desc = string.Format(strFormat,
                                     title,
                                     Util.Escape(STR_CATEGORY),
                                     Util.Escape(category),
                                     avol.Duration,
                                     avol.Tracks.ToString(),
                                     Util.Escape(STR_TRACKS));
                    break;
                default:
                    throw new NotImplementedException("Description not implemented for this VolumeType");
            }

            return desc;
        }
Exemple #9
0
 private void AddVolume(ListStore store, Volume v)
 {
     store.AppendValues(GetVolumeIcon(v), GetVolumeDescription(v), v);
 }
Exemple #10
0
 public void UpdateVolume(TreeIter iter, Volume volume)
 {
     //Model.SetValue(iter, 0, GetVolumeIcon(volume);
     Model.SetValue(iter, 1, GetVolumeDescription(volume));
 }
Exemple #11
0
        public void Fill(Volume[] volumes)
        {
            if (volumes == null)
                throw new ArgumentNullException("volumes");

            Clear();

            ListStore store = (ListStore)Model;

            foreach (Volume v in volumes)
                AddVolume(store, v);

            // cluumns may still have the old width after clear()
            // so reset it
            ColumnsAutosize();
        }
Exemple #12
0
 public void AddVolume(Volume v)
 {
     AddVolume((ListStore)this.Model, v);
 }
Exemple #13
0
        public VolumeScanner(VolumeDatabase db, DriveInfo drive)
        {
            this.scanCompleted = false;
            this.database = db;
            this.newVolume = null;

            infoIcon	= RenderIcon(Icons.Icon.Stock_DialogInfo,	   ICON_SIZE);
            warningIcon = RenderIcon(Icons.Icon.Stock_DialogWarning,   ICON_SIZE);
            errorIcon	= RenderIcon(Icons.Icon.Stock_DialogError,	   ICON_SIZE);

            mdps = null;

            if (App.Settings.ScannerExtractMetaData &&
                (VolumeProber.ProbeVolume(drive) == VolumeProber.VolumeProbeResult.Filesystem)) {

                mdps = new MetadataProvider[] {
                    new TagLibMetadataProvider(),
                    new ArchiveMetadataProvider()
                };
            }

            // setup scanner options
            ScannerOptions[] opts = new ScannerOptions[2] {

                new FilesystemScannerOptions() {
                    BufferSize			= App.Settings.ScannerBufferSize,
                    ComputeHashs		= App.Settings.ScannerComputeHashs,
                    DiscardSymLinks		= App.Settings.ScannerDiscardSymLinks,
                    GenerateThumbnails	= App.Settings.ScannerGenerateThumbnails,
                    MetadataProviders	= mdps,
                    DbDataPath			= PathUtil.GetDbDataPath(database)
                },

                new AudioCdScannerOptions() {
                    EnableMusicBrainz = App.Settings.ScannerEnableMusicBrainz
                }
            };

            scanner = VolumeProber.GetScannerForVolume(drive, database, opts);

            // scanner eventhandlers
            scanner.BeforeScanItem	  += scanner_BeforeScanItem;
            scanner.ScannerWarning	  += scanner_ScannerWarning;
            scanner.Error			  += scanner_Error;
            scanner.ScanCompleted	  += scanner_ScanCompleted;

            /* volumedatabase event handlers */
            database.BeginWriteAccess	+= database_BeginWriteAccess;
            database.EndWriteAccess		+= database_EndWriteAccess;

            // must be called _after_ scanner instanciation
            // (requires scanner.VolumeInfo.GetVolumeType())
            BuildGui();
            InitTreeView();

            scannerLog = new StringBuilder();
            timer = new StatusUpdateTimer(this);

            try {
                /* NOTE: make sure the timer will be removed properly later,
                 * or it keeps running, even if this window has been closed. */
                timer.Install();

                string tmp;
                // e.g. GIO network 'drives' do not have a devicefile
                if (string.IsNullOrEmpty(drive.Device))
                    tmp = S._("Scanning started.");
                else
                    tmp = string.Format(S._("Scanning of drive '{0}' started."), drive.Device);

                UpdateLog(LogIcon.Info, tmp);

                switch (scanner.VolumeInfo.GetVolumeType()) {
                    case VolumeType.FileSystemVolume:
                        UpdateLog(LogIcon.Info, string.Format(S._("Options: generate thumbs: {0}, extract metadata: {1}, discard symlinks: {2}, hashing: {3}."),
                                                              BoolToStr(App.Settings.ScannerGenerateThumbnails),
                                                              BoolToStr(App.Settings.ScannerExtractMetaData),
                                                              BoolToStr(App.Settings.ScannerDiscardSymLinks),
                                                              BoolToStr(App.Settings.ScannerComputeHashs)));
                        break;
                    case VolumeType.AudioCdVolume:
                        UpdateLog(LogIcon.Info, string.Format(S._("Options: MusicBrainz enabled: {0}"),
                                                          BoolToStr(App.Settings.ScannerEnableMusicBrainz)));
                        break;
                    default:
                        throw new NotImplementedException(string.Format("Missing options output for scannertyp {0}", scanner.GetType()));
                }

                if (scanner.VolumeInfo.GetVolumeType() == VolumeType.FileSystemVolume) {
                    // copy already known volume data into the editor
                    volEditor.ArchiveNo = scanner.VolumeInfo.ArchiveNo;
                    volEditor.Title = scanner.VolumeInfo.Title;
                } else {
                    // other volumetypes have no useful data yet (e.g. AudioCD data may be queried from musicbrainz.org),
                    // so disable the editor and re-enable it and fill in the data when scanning has been completed.
                    volEditor.Sensitive = false;
                }

                // start scanning on a new thread and return immediately
                scanner.RunAsync();
            } catch {
                timer.Remove();
                throw;
            }
        }
Exemple #14
0
        private void scanner_ScanCompleted(object sender, ScanCompletedEventArgs e)
        {
            Application.Invoke(delegate {
                if (e.Error != null) {
                    UpdateLog(LogIcon.Error, string.Format(S._("Scanning failed. Reason: an unhandled exception occured ({0})."), e.Error.Message));
                } else if (e.Cancelled) {
                    UpdateLog(LogIcon.Error, S._("Scanning aborted."));
                } else {
                    UpdateLog(LogIcon.Info, S._("Scanning completed successfully."));
                    newVolume = e.Volume;

                    // the volume editor may have been disabled in the ctor
                    // for some volume types (e.g. AudioCD volumes)
                    if (!volEditor.Sensitive) {
                        volEditor.Load(newVolume);
                        volEditor.Sensitive = true;
                    }
                }

                if (!btnAbort.Sensitive) /* possibly disabled in AbortScan() */
                    btnAbort.Sensitive = true;

                btnAbort.Label = Stock.Close;
                scanCompleted = true;
            });

            /* remove timeout handler (installed in ctor) */
            timer.Remove();
        }
Exemple #15
0
 protected virtual void OnNewVolumeAdded(Volume volume)
 {
     if (NewVolumeAdded != null)
         NewVolumeAdded(this, new NewVolumeAddedEventArgs(volume));
 }