void updatePreset()
        {
            PresetMetadata preset = new PresetMetadata();

            preset.Id                    = selectedPreset.Id;
            preset.Name                  = Name;
            preset.Rating                = Rating;
            preset.IsRatingEnabled       = RatingEnabled;
            preset.Title                 = Title;
            preset.IsTitleEnabled        = TitleEnabled;
            preset.Author                = Author;
            preset.IsAuthorEnabled       = AuthorEnabled;
            preset.Description           = Description;
            preset.IsDescriptionEnabled  = DescriptionEnabled;
            preset.Copyright             = Copyright;
            preset.IsCopyrightEnabled    = CopyrightEnabled;
            preset.CreationDate          = Creation;
            preset.IsCreationDateEnabled = CreationEnabled;

            using (PresetMetadataDbCommands presetMetaDataCommands = new PresetMetadataDbCommands())
            {
                try
                {
                    PresetMetadata result = presetMetaDataCommands.update(preset);
                    MetadataPresets.Remove(SelectedPreset);
                    CollectionsSort.insertIntoSortedCollection <PresetMetadata>(MetadataPresets, result);

                    clear();
                }
                catch (Exception e)
                {
                    Logger.Log.Error("Error updating presetMetadata", e);
                }
            }
        }
        private void refreshDirectory_Click(object sender, RoutedEventArgs e)
        {
            Location selectedNode = treeView.SelectedItem as Location;

            if (selectedNode == null)
            {
                return;
            }

            Location parent = selectedNode.Parent as Location;
            Location newNode;
            string   fullName = selectedNode.FullName;

            parent.Children.Remove(selectedNode);

            if (selectedNode is DriveLocation)
            {
                newNode = new DriveLocation(new DriveInfo(fullName), infoGatherTask, MediaFileWatcher.Instance.MediaFileState);
            }
            else
            {
                newNode = new DirectoryLocation(new DirectoryInfo(fullName), infoGatherTask, MediaFileWatcher.Instance.MediaFileState);
            }

            CollectionsSort.insertIntoSortedCollection(parent.Children, newNode);
            infoGatherTask.addLocation(newNode);
            newNode.IsExpanded    = selectedNode.IsExpanded;
            treeView.SelectedItem = newNode;
        }
        private void createDirectory_Click(object sender, RoutedEventArgs e)
        {
            Location selectedNode = treeView.SelectedItem as Location;

            if (selectedNode == null)
            {
                return;
            }

            try
            {
                String newFolder = FileUtils.getUniqueDirectoryName(selectedNode.FullName);

                selectedNode.IsExpanded = true;

                DirectoryInfo newFolderInfo = System.IO.Directory.CreateDirectory(newFolder);

                DirectoryLocation child = new DirectoryLocation(newFolderInfo, infoGatherTask, MediaFileWatcher.Instance.MediaFileState);

                CollectionsSort.insertIntoSortedCollection(selectedNode.Children, child);
                infoGatherTask.addLocation(child);

                //treeView.SelectedItem = child;
                //treeView.ScrollIntoView(child);
            }
            catch (Exception ex)
            {
                Logger.Log.Error("Error creating directory", ex);
                MessageBox.Show("Error creating directory\n\n" + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
        int insertSorted_WLock(SelectableMediaItem selectableItem)
        {
            int newIndex = CollectionsSort.insertIntoSortedCollection <SelectableMediaItem>(MediaCollectionView, selectableItem, SortFunc, 0, sortedItemEnd);

            sortedItemEnd++;

            return(newIndex);
        }
Example #5
0
        private void addFavoritesButton_Click(object sender, RoutedEventArgs e)
        {
            if (String.IsNullOrEmpty(Location) || String.IsNullOrWhiteSpace(Location))
            {
                return;
            }

            if (!FavoriteLocations.Contains(Location))
            {
                CollectionsSort.insertIntoSortedCollection(FavoriteLocations, Location);
            }
        }
Example #6
0
        private void propertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName.Equals("Text"))
            {
                SharpTreeNode parent = Parent;

                if (Parent != null && Parent.Children.Count > 1)
                {
                    parent.Children.Remove(this);
                    CollectionsSort.insertIntoSortedCollection(parent.Children, this);
                }
            }
        }
        private void addTag(string tagName)
        {
            if (String.IsNullOrEmpty(tagName) || String.IsNullOrWhiteSpace(tagName))
            {
                return;
            }

            tagName = tagName.Trim();

            addTagAutoCompleteBox.Text = "";

            // add linked tags

            using (TagDbCommands tc = new TagDbCommands(null))
            {
                Tag tag = tc.getTagByName(tagName);

                if (tag != null)
                {
                    if (AddLinkedTags)
                    {
                        foreach (Tag childTag in tag.ChildTags)
                        {
                            if (!Tags.Contains(childTag))
                            {
                                Tags.Add(childTag);
                            }
                        }
                    }
                }
                else
                {
                    if (AcceptOnlyExistingTags)
                    {
                        return;
                    }

                    tag      = new Tag();
                    tag.Name = tagName;
                }

                if (!Tags.Contains(tag))
                {
                    CollectionsSort.insertIntoSortedCollection <Tag>(Tags, tag);
                }
            }
        }
        protected void add_WLock(IEnumerable <MediaItem> items)
        {
            // Use a fast(er) path if we are just adding a batch of items to a empty list
            // instead of firing off a whole bunch of itemchanged events
            if (this.MediaCollectionView.Count == 0 && items.Count() > 1)
            {
                List <SelectableMediaItem> addedItems = new List <SelectableMediaItem>();

                foreach (MediaItem item in items)
                {
                    SelectableMediaItem selectableItem = new SelectableMediaItem(item);

                    if (Filter(selectableItem))
                    {
                        selectableItem.SelectionChanged += selectableItem_SelectionChanged;

                        if (selectableItem.Item.Metadata != null)
                        {
                            CollectionsSort.insertIntoSortedCollection(addedItems, selectableItem, sortFunc, 0, sortedItemEnd);
                            sortedItemEnd++;
                        }
                        else
                        {
                            addedItems.Add(selectableItem);
                        }
                    }
                }

                MediaCollectionView.AddRange(addedItems);

                QueueNrItemsInStateChangedEvent(new MediaStateCollectionViewChangedEventArgs(MediaStateChangedAction.Add, addedItems));
                // this is incorrect
                //sortedItemEnd = Media.Count;
            }
            else
            {
                foreach (MediaItem item in items)
                {
                    add_WLock(item);
                }
            }
        }