Esempio n. 1
0
            public FeedbackRowTuple(string sampleFileName, string currentDate, string newDate, string numFilesWithThatDate, ImageRow imageRow, AmbiguousDateRange ambiguousDateRange)
            {
                // Properties that will be displayed in the data grid
                this.Select               = false;
                this.SampleFileName       = sampleFileName;
                this.CurrentDate          = currentDate;
                this.NewDate              = newDate;
                this.NumFilesWithThatDate = numFilesWithThatDate;

                this.ImageRow           = imageRow;
                this.AmbiguousDateRange = ambiguousDateRange;
            }
Esempio n. 2
0
 public UpdateInfo(ImageRow row)
     : base(row)
 {
 }
Esempio n. 3
0
 public WsReference(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 4
0
 public ImageRowElement(ImageRow imageRow) : this()
 {
     ImageRow = imageRow;
 }
        private void DeleteCurrentImageOnly()
        {
            // The single file to delete
            ImageRow imageRow = this.filesToDelete[0];

            // Show  the deleted file name and image in the interface
            this.ShowSingleFileView();
            this.maxPathLength = 70;
            string filePath = Path.Combine(imageRow.RelativePath, imageRow.File);

            if (string.IsNullOrEmpty(filePath) == false)
            {
                filePath = filePath.Length <= this.maxPathLength ? filePath : "..." + filePath.Substring(filePath.Length - this.maxPathLength, this.maxPathLength);
            }

            this.SingleImageViewer.Source  = imageRow.LoadBitmap(this.fileDatabase.FolderPath, Constant.ImageValues.PreviewWidth480, out _);
            this.SingleFilePanel.ToolTip   = Path.Combine(imageRow.RelativePath, imageRow.File);
            this.SingleImageViewer.ToolTip = Path.Combine(imageRow.RelativePath, imageRow.File);
            this.SingleFileNameRun.Text    = filePath;

            // Populate the information pane
            string imageOrVideo = this.filesToDelete[0].IsVideo ? "video" : "image";

            if (this.deleteImage == true)
            {
                this.Message.Title  = String.Format("Delete the current {0}", imageOrVideo);
                this.Message.What   = String.Format("Deletes the current {0} if it exists", imageOrVideo);
                this.Message.Result = String.Format("\u2022 The deleted {0} will be backed up in a sub-folder named {1}.{2}", imageOrVideo, Constant.File.DeletedFilesFolder, Environment.NewLine);
                this.Message.Hint   = String.Format("\u2022 Restore the deleted {0} by manually moving it ", imageOrVideo);
                if (this.deleteImage == true && this.deleteData == false)
                {
                    // Case 1: Delete the current image, but not its data.

                    this.Message.Title  += " but not its data.";
                    this.Message.What   += String.Format("{0}The data entered for the {1} IS NOT deleted.", Environment.NewLine, imageOrVideo);
                    this.Message.Result += String.Format("\u2022 A placeholder {0} will be shown when you try to view a deleted {0}.", imageOrVideo);
                    this.Message.Hint   += "back to its original location." + Environment.NewLine;
                }
                else if (this.deleteImage == true && this.deleteData == true)
                {
                    // Case 2: Delete the current image and its data
                    this.Message.Title  += " and its data";
                    this.Message.What   += String.Format("{0}The data entered for the {1} IS deleted as well.", Environment.NewLine, imageOrVideo);
                    this.Message.Result += String.Format("\u2022 However, the data associated with that {0} will be permanently deleted.", imageOrVideo);
                    this.Message.Hint   += "to a new sub-folder." + Environment.NewLine + "  Then add that sub-folder back to the image set." + Environment.NewLine;
                }
                this.Message.Hint += String.Format("\u2022 See Options|Preferences to manage how files in {0} are permanently deleted.", Constant.File.DeletedFilesFolder);
            }
            else
            {
                // Case: Delete the data only, leaving the image intact
                this.FileLabel.Text           = "Affected file:";
                this.ConfirmCheckBoxText.Text = "Click to confirm deletion of data for the selected file";
                this.Message.Title            = String.Format("Delete only the current {0}'s data", imageOrVideo);
                this.Message.What             = String.Format("Deletes the data associated with the current {0}, but leaves the {0} intact", imageOrVideo);
                this.Message.Result           = String.Format("\u2022 This data record will be removed.{0}", Environment.NewLine);
                this.Message.Result          += String.Format("\u2022 The {0} is still intact, but it will not be displayed in Timelapse {1}", imageOrVideo, Environment.NewLine);
                this.Message.Result          += String.Format("   unless a duplicate record exists.", imageOrVideo);
                this.Message.Hint             = "Deleting only the data is useful for removing a previously-created duplicate record of a file.";
            }
        }
Esempio n. 6
0
 public ChartOfAccounts(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 7
0
 public Report(ImageRow imageRow)
     : base(imageRow)
 {
 }
 public ChartOfCharacteristicTypes(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 9
0
        // Populate the database with the metadata for the selected note field
        private async Task <ObservableCollection <KeyValuePair <string, string> > > PopulateAsync(bool?metadataExtractorRBIsChecked)
        {
            // This list will hold key / value pairs that will be bound to the datagrid feedback,
            // which is the way to make those pairs appear in the data grid during background worker progress updates
            ObservableCollection <KeyValuePair <string, string> > keyValueList = new ObservableCollection <KeyValuePair <string, string> >();

            return(await Task.Run(() =>
            {
                // For each row in the database, get the image filename and try to extract the chosen metadata value.
                // If we can't decide if we want to leave the data field alone or to clear it depending on the state of the isClearIfNoMetadata (set via the checkbox)
                // Report progress as needed.
                // This tuple list will hold the id, key and value that we will want to update in the database
                string dataLabelToUpdate = this.dataLabelByLabel[this.dataFieldLabel];
                List <ColumnTuplesWithWhere> imagesToUpdate = new List <ColumnTuplesWithWhere>();
                TimeZoneInfo imageSetTimeZone = this.fileDatabase.ImageSet.GetSystemTimeZone();
                int percentDone = 0;

                double totalImages = this.fileDatabase.CountAllCurrentlySelectedFiles;
                Dictionary <string, ImageMetadata> metadata = new Dictionary <string, ImageMetadata>();
                for (int imageIndex = 0; imageIndex < totalImages; ++imageIndex)
                {
                    // Provide feedback if the operation was cancelled during the database update
                    if (Token.IsCancellationRequested == true)
                    {
                        keyValueList.Clear();
                        keyValueList.Add(new KeyValuePair <string, string>("Cancelled", "No changes were made"));
                        return keyValueList;
                    }

                    ImageRow image = this.fileDatabase.FileTable[imageIndex];
                    if (metadataExtractorRBIsChecked == true)
                    {   // MetadataExtractor specific code
                        metadata = ImageMetadataDictionary.LoadMetadata(image.GetFilePath(this.fileDatabase.FolderPath));
                    }
                    else
                    {
                        // ExifTool specific code - note that we transform results into the same dictionary structure used by the MetadataExtractor
                        string[] tags = { this.metadataFieldName };
                        metadata.Clear();
                        Dictionary <string, string> exifData = this.exifTool.FetchExifFrom(image.GetFilePath(this.fileDatabase.FolderPath), tags);
                        if (exifData.ContainsKey(tags[0]))
                        {
                            metadata.Add(tags[0], new Timelapse.Util.ImageMetadata(String.Empty, tags[0], exifData[tags[0]]));
                        }
                    }

                    if (this.ReadyToRefresh())
                    {
                        percentDone = Convert.ToInt32(imageIndex / totalImages * 100.0);
                        this.Progress.Report(new ProgressBarArguments(percentDone, String.Format("{0}/{1} images. Processing {2}", imageIndex, totalImages, image.File), true, false));
                        Thread.Sleep(Constant.ThrottleValues.RenderingBackoffTime);  // Allows the UI thread to update every now and then
                    }

                    if (metadata.ContainsKey(this.metadataFieldName) == false)
                    {
                        if (this.clearIfNoMetadata)
                        {
                            // Clear the data field if there is no metadata...
                            if (dataLabelToUpdate == Constant.DatabaseColumn.DateTime)
                            {
                                image.SetDateTimeOffsetFromFileInfo(this.fileDatabase.FolderPath);
                                imagesToUpdate.Add(image.GetDateTimeColumnTuples());
                                keyValueList.Add(new KeyValuePair <string, string>(image.File, "No metadata found - date/time reread from file"));
                            }
                            else
                            {
                                List <ColumnTuple> clearField = new List <ColumnTuple>()
                                {
                                    new ColumnTuple(this.dataLabelByLabel[this.dataFieldLabel], String.Empty)
                                };
                                imagesToUpdate.Add(new ColumnTuplesWithWhere(clearField, image.ID));
                                keyValueList.Add(new KeyValuePair <string, string>(image.File, "No metadata found - data field is cleared"));
                            }
                        }
                        else
                        {
                            keyValueList.Add(new KeyValuePair <string, string>(image.File, "No metadata found - data field remains unaltered"));
                        }

                        continue;
                    }

                    string metadataValue = metadata[this.metadataFieldName].Value;
                    ColumnTuplesWithWhere imageUpdate;
                    if (dataLabelToUpdate == Constant.DatabaseColumn.DateTime)
                    {
                        if (DateTimeHandler.TryParseMetadataDateTaken(metadataValue, imageSetTimeZone, out DateTimeOffset metadataDateTime))
                        {
                            image.SetDateTimeOffset(metadataDateTime);
                            imageUpdate = image.GetDateTimeColumnTuples();
                            keyValueList.Add(new KeyValuePair <string, string>(image.File, metadataValue));
                        }
                        else
                        {
                            keyValueList.Add(new KeyValuePair <string, string>(image.File, String.Format("'{0}' - data field remains unaltered - not a valid date/time.", metadataValue)));
                            continue;
                        }
                    }
                    else
                    {
                        imageUpdate = new ColumnTuplesWithWhere(new List <ColumnTuple>()
                        {
                            new ColumnTuple(dataLabelToUpdate, metadataValue)
                        }, image.ID);
                        keyValueList.Add(new KeyValuePair <string, string>(image.File, metadataValue));
                    }
                    imagesToUpdate.Add(imageUpdate);
                }
                this.IsAnyDataUpdated = true;
                this.Progress.Report(new ProgressBarArguments(100, String.Format("Writing metadata for {0} files. Please wait...", totalImages), false, true));
                Thread.Sleep(Constant.ThrottleValues.RenderingBackoffTime);  // Allows the UI thread to update every now and then
                this.fileDatabase.UpdateFiles(imagesToUpdate);
                return keyValueList;
            }, this.Token).ConfigureAwait(true));
        }
Esempio n. 10
0
 public ExchangePlan(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 11
0
 public Role(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 12
0
 public CommonModule(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 13
0
 public Enum(ImageRow row)
     : base(row)
 {
 }
Esempio n. 14
0
 public static ImageColumn <T> Column <T>(this ImageRow <T> row, int col)
     where T : struct, IEquatable <T>
 {
     return(row.Image.Column(col));
 }
Esempio n. 15
0
 public Versions(ImageRow row)
     : base(row)
 {
 }
Esempio n. 16
0
 public static ImageColumn <T>[] Columns <T>(this ImageRow <T> row)
     where T : struct, IEquatable <T>
 {
     return(row.Image.Columns());
 }
 public ImageRowChangeEvent(ImageRow row, global::System.Data.DataRowAction action)
 {
     this.eventRow    = row;
     this.eventAction = action;
 }
Esempio n. 18
0
        public void Show(bool isVisible, int maxNumberImagesToDisplay)
        {
            ImageRow currentImageRow = timelapseWindow?.DataHandler?.ImageCache?.Current;
            TimeSpan timeThreshold   = timelapseWindow.State.EpisodeTimeThreshold;

            if (isVisible == false || currentImageRow == null || FileDatabase == null)
            {
                // Hide the popup if asked or if basic data isn't available, including deleting the children
                this.IsOpen = false;
                this.Child  = null;
                return;
            }

            // Images or placeholders will be contained in a horizontal stack panel, which in turn is the popup's child
            StackPanel sp = new StackPanel
            {
                Orientation = Orientation.Horizontal
            };

            this.Child = sp;

            double width = 0;  // Used to calculate the placement offset of the popup relative to the placement target
            double height;

            // Add a visual marker to show the position of the label in the image list
            Label label = EpisodePopup.CreateLabel("^", this.ImageHeight);

            label.VerticalAlignment = VerticalAlignment.Top;
            width += label.Width;
            height = label.Height;
            sp.Children.Add(label);

            int       margin = 2;
            FileTable fileTable; // To hold the results of the database selection as a table of ImageRows

            // We will only consider images whose relative path is the same as the current file
            string relativePath = currentImageRow.RelativePath;

            // Calculate the lower and upper extent of the range of dates we should examine
            // The maximum date range we need to consider would be the current date plus/minus the (time threshold * the number of images we could display),
            // While this could produce more hits than we need, it should give us a relatively short table of possible candidates
            DateTime lowerDateTime  = currentImageRow.DateTime - TimeSpan.FromTicks(timeThreshold.Ticks * maxNumberImagesToDisplay);
            DateTime upperDateTime  = currentImageRow.DateTime + TimeSpan.FromTicks(timeThreshold.Ticks * maxNumberImagesToDisplay);
            string   slowerDateTime = DateTimeHandler.ToStringDatabaseDateTime(lowerDateTime);
            string   supperDateTime = DateTimeHandler.ToStringDatabaseDateTime(upperDateTime);

            // Get a table of files (sorted by datetime) with that relative path which falls between the lower and upper date range
            DataTable dt = this.FileDatabase.GetIDandDateWithRelativePathAndBetweenDates(relativePath, slowerDateTime, supperDateTime);

            // Find the current image in that table by its ID
            int rowWithCurrentImageRowID = -1;
            int availableRows            = dt.Rows.Count;

            for (int i = 0; i < availableRows; i++)
            {
                if (Convert.ToInt64(dt.Rows[i][0]) == currentImageRow.ID)
                {
                    rowWithCurrentImageRowID = i;
                    break;
                }
            }

            // From that current image, alternate between going to the previous/next row.
            // If the date difference between alternating successive images is less than the time threshold,
            // display it.
            int      goBackwardsRow        = rowWithCurrentImageRowID - 1;
            int      goForwardsRow         = rowWithCurrentImageRowID + 1;
            int      imagesLeftToDisplay   = maxNumberImagesToDisplay;
            DateTime lastBackwardsDateTime = currentImageRow.DateTime;
            DateTime lastForwardsDateTime  = currentImageRow.DateTime;

            while (true && (goBackwardsRow >= 0 || goForwardsRow < availableRows))
            {
                // Abort when there is no more work to do
                if (imagesLeftToDisplay <= 0)
                {
                    break;
                }

                // Start on the left
                if (goBackwardsRow >= 0)
                {
                    // Add a popup image to the left of the caret
                    using (fileTable = this.FileDatabase.SelectFileInDataTableById(dt.Rows[goBackwardsRow][0].ToString()))
                    {
                        if (fileTable.Any())
                        {
                            if ((lastBackwardsDateTime - fileTable[0].DateTime).Duration() <= timeThreshold)
                            {
                                Image image = EpisodePopup.CreateImage(fileTable[0], margin, this.ImageHeight);
                                width += image.Source.Width;
                                height = Math.Max(height, image.Source.Height);

                                // Create a canvas containing the image and bounding boxes (if detections are on)
                                sp.Children.Insert(0, CreateCanvasWithBoundingBoxesAndImage(image, height, margin, fileTable[0].ID));
                                imagesLeftToDisplay--;
                                lastBackwardsDateTime = fileTable[0].DateTime;
                            }
                            else
                            {
                                // Stop searching backwards
                                goBackwardsRow = -1;
                            }
                        }
                    }
                    goBackwardsRow--;
                }

                // Now try to add a popup image to the right if we still have some more  images left to display
                if (goForwardsRow < availableRows && imagesLeftToDisplay > 0)
                {
                    using (fileTable = this.FileDatabase.SelectFileInDataTableById(dt.Rows[goForwardsRow][0].ToString()))
                    {
                        if (fileTable.Any())
                        {
                            if ((lastForwardsDateTime - fileTable[0].DateTime).Duration() <= timeThreshold)
                            {
                                Image image = EpisodePopup.CreateImage(fileTable[0], margin, this.ImageHeight);
                                width += image.Source.Width;
                                height = Math.Max(height, image.Source.Height);

                                // Create a canvas containing the image and bounding box
                                sp.Children.Add(CreateCanvasWithBoundingBoxesAndImage(image, height, margin, fileTable[0].ID));
                                imagesLeftToDisplay--;
                                lastBackwardsDateTime = fileTable[0].DateTime;
                            }
                            else
                            {
                                // Stop searching forwards
                                goForwardsRow = availableRows;
                            }
                        }
                    }
                    goForwardsRow++;
                }
            }

            label.Height = Math.Max(label.Height, height); // So it extends to the top of the popup
            // Position and open the popup so it appears horizontallhy centered just above the cursor
            this.HorizontalOffset = this.markableCanvas.ActualWidth / 2.0 - width / 2.0;
            this.VerticalOffset   = -height - 2 * margin;
            this.IsOpen           = true;

            // Cleanup
            dt.Dispose();
        }
Esempio n. 19
0
 public SharedAttribute(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 20
0
 public Configuration(ImageRow row)
     : base(row)
 {
 }
Esempio n. 21
0
 public Catalog(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 22
0
 public Subsystem(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 23
0
        // Returns:
        // - the list of files whose dates have changed
        // - a collection of feedback information for each file whose dates were changed, each row detailing the file name and how the dates were changed
        // - the number of missing Files, if any
        private List <ImageRow> GetImageRowsWithChangedDates(IProgress <ProgressBarArguments> progress, int count, TimeZoneInfo imageSetTimeZone, ObservableCollection <DateTimeFeedbackTuple> feedbackRows, out int missingFiles)
        {
            List <ImageRow> filesToAdjust = new List <ImageRow>();

            missingFiles = 0;
            for (int fileIndex = 0; fileIndex < count; ++fileIndex)
            {
                if (Token.IsCancellationRequested)
                {
                    // A cancel was requested. Clear all pending changes and abort
                    feedbackRows.Clear();
                    break;
                }

                // We will store the various times here
                ImageRow       file             = this.fileDatabase.FileTable[fileIndex];
                DateTimeOffset originalDateTime = file.DateTimeIncorporatingOffset;
                string         feedbackMessage  = string.Empty;

                try
                {
                    // Get the image (if its there), get the new dates/times, and add it to the list of images to be updated
                    // Note that if the image can't be created, we will just to the catch.
                    bool usingMetadataTimestamp = true;
                    if (file.FileExists(this.fileDatabase.FolderPath) == false)
                    {
                        // The file does not exist. Generate a feedback message
                        missingFiles++;
                    }
                    else
                    {
                        // Read the date from the file, and check to see if its different from the recorded date
                        DateTimeAdjustmentEnum dateTimeAdjustment = file.TryReadDateTimeOriginalFromMetadata(this.fileDatabase.FolderPath, imageSetTimeZone);
                        if (dateTimeAdjustment == DateTimeAdjustmentEnum.MetadataNotUsed)
                        {
                            // We couldn't read the metadata, so get a candidate date/time from the file info instead
                            file.SetDateTimeOffsetFromFileInfo(this.fileDatabase.FolderPath);
                            usingMetadataTimestamp = false;
                        }
                        DateTimeOffset rescannedDateTime = file.DateTimeIncorporatingOffset;
                        bool           sameDate          = rescannedDateTime.Date == originalDateTime.Date;
                        bool           sameTime          = rescannedDateTime.TimeOfDay == originalDateTime.TimeOfDay;
                        bool           sameUTCOffset     = rescannedDateTime.Offset == originalDateTime.Offset;

                        if (!(sameDate && sameTime && sameUTCOffset))
                        {
                            // Date has been updated - add it to the queue of files to be processed, and generate a feedback message.
                            filesToAdjust.Add(file);
                            feedbackMessage  = "\x2713"; // Checkmark
                            feedbackMessage += DateTimeHandler.ToStringDisplayDateTime(originalDateTime) + " \x2192 " + DateTimeHandler.ToStringDisplayDateTime(rescannedDateTime);
                            feedbackMessage += usingMetadataTimestamp ? " (read from metadata)" : " (read from file)";
                            feedbackRows.Add(new DateTimeFeedbackTuple(file.File, feedbackMessage));
                        }
                    }
                }
                catch (Exception exception)
                {
                    // This shouldn't happen, but just in case.
                    TracePrint.PrintMessage(string.Format("Unexpected exception processing '{0}' in DateTimeReread. {1}", file.File, exception.ToString()));
                    feedbackMessage += string.Format("\x2716 skipping: {0}", exception.Message);
                    feedbackRows.Add(new DateTimeFeedbackTuple(file.File, feedbackMessage));
                    break;
                }

                // Update the progress bar every time interval to indicate what file we are working on
                TimeSpan intervalFromLastRefresh = DateTime.Now - this.lastRefreshDateTime;
                if (intervalFromLastRefresh > Constant.ThrottleValues.ProgressBarRefreshInterval)
                {
                    int percentDone = Convert.ToInt32(fileIndex / Convert.ToDouble(count) * 100.0);
                    progress.Report(new ProgressBarArguments(percentDone, String.Format("Pass 1: Checking dates for {0} / {1} files", fileIndex, count), true, false));
                    Thread.Sleep(Constant.ThrottleValues.RenderingBackoffTime);
                    this.lastRefreshDateTime = DateTime.Now;
                }
            }
            return(filesToAdjust);
        }
Esempio n. 24
0
 public FunctionalOption(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 25
0
 public DocumentJournal(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 26
0
        // Menu selections for propagating or copying the current value of this control to all images

        // Copy the last non-empty value in this control preceding this file up to the current image
        protected virtual void MenuItemPropagateFromLastValue_Click(object sender, RoutedEventArgs e)
        {
            // Check the arguments for null
            ThrowIf.IsNullArgument(sender, nameof(sender));

            // Get the chosen data entry control
            DataEntryControl control = (DataEntryControl)((MenuItem)sender).Tag;

            if (control == null)
            {
                return;
            }

            bool     checkForZero    = control is DataEntryCounter;
            bool     isFlag          = control is DataEntryFlag;
            int      indexToCopyFrom = -1;
            ImageRow valueSource     = null;
            string   valueToCopy     = checkForZero ? "0" : String.Empty;

            // Search for the row with some value in it, starting from the previous row
            int currentRowIndex = (this.ThumbnailGrid.IsVisible == false) ? this.ImageCache.CurrentRow : this.ThumbnailGrid.GetSelected()[0];

            for (int previousIndex = currentRowIndex - 1; previousIndex >= 0; previousIndex--)
            {
                ImageRow file = this.FileDatabase.FileTable[previousIndex];
                if (file == null)
                {
                    continue;
                }
                valueToCopy = file.GetValueDatabaseString(control.DataLabel);
                if (valueToCopy == null)
                {
                    continue;
                }
                valueToCopy = valueToCopy.Trim();
                if (valueToCopy.Length > 0)
                {
                    if ((checkForZero && !valueToCopy.Equals("0")) ||                                                       // Skip over non-zero values for counters
                        (isFlag && !valueToCopy.Equals(Constant.BooleanValue.False, StringComparison.OrdinalIgnoreCase)) || // Skip over false values for flags
                        (!checkForZero && !isFlag))
                    {
                        indexToCopyFrom = previousIndex;    // We found a non-empty value
                        valueSource     = file;
                        break;
                    }
                }
            }

            string newContent = valueToCopy;

            if (indexToCopyFrom < 0)
            {
                // Display a dialog box saying there is nothing to propagate.
                // Note that this should never be displayed, as the menu shouldn't be highlit if there is nothing to propagate
                // But just in case...
                Dialogs.DataEntryNothingToPropagateDialog(Application.Current.MainWindow);
                return;
            }

            // Display the appropriate dialog box that explains what will happen. Arguments indicate what is to be propagated and how many files will be affected
            int filesAffected = currentRowIndex - indexToCopyFrom;

            if (Dialogs.DataEntryConfirmPropagateFromLastValueDialog(Application.Current.MainWindow, valueToCopy, filesAffected) != true)
            {
                return; // operation cancelled
                // newContent = this.FileDatabase.FileTable[currentRowIndex].GetValueDisplayString(control.DataLabel); // No change, so return the current value
            }

            // Update the affected files. Note that we start on the row after the one with a value in it to the current row.
            Mouse.OverrideCursor = Cursors.Wait;
            this.FileDatabase.UpdateFiles(valueSource, control.DataLabel, indexToCopyFrom + 1, currentRowIndex);
            control.SetContentAndTooltip(newContent);
            Mouse.OverrideCursor = null;
        }
Esempio n. 27
0
 public CommonForm(ImageRow imageRow)
     : base(imageRow)
 {
 }
Esempio n. 28
0
        // Add a row to the tuple, which in turn will update the grid.
        public void AddFeedbackRow(string sampleFileName, string currentDate, string newDate, string numFilesWithThatDate, ImageRow imageRow, AmbiguousDateRange ambiguousDateRange)
        {
            FeedbackRowTuple row = new FeedbackRowTuple(sampleFileName, currentDate, newDate, numFilesWithThatDate, imageRow, ambiguousDateRange);

            this.feedbackRows.Add(row);
        }
Esempio n. 29
0
 public Sequence(ImageRow imageRow)
     : base(imageRow)
 {
 }