예제 #1
0
        /// <summary>
        /// Get an Int from the registry
        /// </summary>
        public static int GetInteger(this RegistryKey registryKey, string subKeyPath, int defaultValue)
        {
            // Check the arguments for null
            if (registryKey == null)
            {
                // this should not happen
                TracePrint.PrintStackTrace(1);
                // throw new ArgumentNullException(nameof(registryKey));
                return(defaultValue);
            }

            object value = registryKey.GetValue(subKeyPath);

            if (value == null)
            {
                return(defaultValue);
            }

            if (value is Int32)
            {
                return((int)value);
            }

            if (value is string)
            {
                return(Int32.Parse((string)value));
            }

            throw new NotSupportedException(String.Format("Registry key {0}\\{1} has unhandled type {2}.", registryKey.Name, subKeyPath, value.GetType().FullName));
        }
예제 #2
0
        /// <summary>
        /// Given size units in normal pixels, translate them into device independent pixels (the out parameters)
        /// </summary>
        /// <param name="widthInPixels"></param>
        /// <param name="heightInPixels"></param>
        /// <param name="widthInDeviceIndependentPixels"></param>
        /// <param name="heightInDeviceIndependentPixels"></param>
        public static void TransformPixelsToDeviceIndependentPixels(int widthInPixels,
                                                                    int heightInPixels,
                                                                    out double widthInDeviceIndependentPixels,
                                                                    out double heightInDeviceIndependentPixels)
        {
            IntPtr hDc = GetDC(IntPtr.Zero);

            if (hDc != IntPtr.Zero)
            {
                int dpiX = GetDeviceCaps(hDc, LOGPIXELSX);
                int dpiY = GetDeviceCaps(hDc, LOGPIXELSY);

                _ = ReleaseDC(IntPtr.Zero, hDc);

                widthInDeviceIndependentPixels  = 96 * widthInPixels / (double)dpiX;
                heightInDeviceIndependentPixels = 96 * heightInPixels / (double)dpiY;
            }
            else
            {
                // This is very unlikely.
                // As a workaround, we just return the original pixel size. While this may not be the correct size (depending on the actual dpi),
                // it will not crash the program and at least maintains the correct aspect ration
                widthInDeviceIndependentPixels  = widthInPixels;
                heightInDeviceIndependentPixels = heightInPixels;
                TracePrint.PrintMessage("In TransformPixelsToDeviceIndependentPixels: Failed to get DC.");
            }
        }
예제 #3
0
        /// <summary>
        /// Get an Int from the registry
        /// </summary>
        public static int GetInteger(this RegistryKey registryKey, string subKeyPath, int defaultValue)
        {
            // Check the arguments for null
            if (registryKey == null)
            {
                // this should not happen
                TracePrint.PrintStackTrace(1);
                // throw new ArgumentNullException(nameof(registryKey));
                return(defaultValue);
            }

            object value = registryKey.GetValue(subKeyPath);

            if (value == null)
            {
                return(defaultValue);
            }

            if (value is Int32)
            {
                return((int)value);
            }

            if (value is string @string)
            {
                return(Int32.Parse(@string));
            }
            return(defaultValue);
        }
예제 #4
0
        private static void GetAllImageAndVideoFilesInFolderAndSubfolders(string rootFolderPath, List <FileInfo> fileInfoList, int recursionLevel)
        {
            // Check the arguments for null
            if (fileInfoList == null)
            {
                // this should not happen
                TracePrint.PrintStackTrace(1);
                // Not show what happens if we return with a null fileInfoList, but its worth a shot
                // throw new ArgumentNullException(nameof(control));
                return;
            }

            int nextRecursionLevel = recursionLevel + 1;

            if (!Directory.Exists(rootFolderPath))
            {
                return;
            }

            DirectoryInfo directoryInfo = new DirectoryInfo(rootFolderPath);

            foreach (string extension in new List <string>()
            {
                Constant.File.JpgFileExtension, Constant.File.AviFileExtension, Constant.File.Mp4FileExtension, Constant.File.ASFFileExtension
            })
            {
                // GetFiles has a 'bug', where it can match an extension even if there are more letters after the extension.
                // That is, if we are looking for *.jpg, it will not only return *.jpg files, but files such as *.jpgXXX
                fileInfoList.AddRange(directoryInfo.GetFiles("*" + extension));
            }

            // Recursively descend subfolders
            DirectoryInfo dirInfo = new DirectoryInfo(rootFolderPath);

            DirectoryInfo[] subDirs = dirInfo.GetDirectories();
            foreach (DirectoryInfo subDir in subDirs)
            {
                // Skip the following folders
                if (subDir.Name == Constant.File.BackupFolder || subDir.Name == Constant.File.DeletedFilesFolder || subDir.Name == Constant.File.VideoThumbnailFolderName)
                {
                    continue;
                }
                GetAllImageAndVideoFilesInFolderAndSubfolders(subDir.FullName, fileInfoList, nextRecursionLevel);
            }

            if (recursionLevel == 0)
            {
                // After all recursion is complete, do the following (but only on the initial recursion level)
                // Because of that bug, we need to check for, and remove, any files that don't exactly match the desired extension
                // At the same time, we also remove MacOSX hidden files, if any
                FilesRemoveAllButImagesAndVideos(fileInfoList);
                if (fileInfoList.Count != 0)
                {
                    fileInfoList.OrderBy(file => file.FullName).ToList();
                }
            }
        }
예제 #5
0
 // Checks the length of the backup path
 public static bool IsBackupPathLengthTooLong(string str)
 {
     // Check the arguments for null
     if (str == null)
     {
         // this should not happen
         TracePrint.PrintStackTrace(1);
         return(false);
     }
     return(str.Length + Constant.File.MaxAdditionalLengthOfBackupFiles > Constant.File.MaxPathLength);
 }
예제 #6
0
        /// <summary>
        /// Populate folderPaths with all the folders and subfolders (from the root folder) that contains at least one video or image file
        /// If prefixPath is provided, it is stripped from the beginning of the matching folder paths, otherwise the full path is returned
        /// </summary>
        /// <param name="folderRoot"></param>
        /// <param name="folderPaths"></param>
        public static void GetAllFoldersContainingAnImageOrVideo(string folderRoot, List <string> folderPaths, string prefixPath)
        {
            // Check the arguments for null
            if (folderPaths == null || folderRoot == null)
            {
                // this should not happen
                TracePrint.PrintStackTrace(1);
                // throw new ArgumentNullException(nameof(folderPaths));
                // Not sure what happens if we have a null folderPaths, but we may as well try it.
                return;
            }

            if (!Directory.Exists(folderRoot))
            {
                return;
            }
            // Add a folder only if it contains one of the desired extensions
            if (CheckFolderForAtLeastOneImageOrVideoFiles(folderRoot) == true)
            {
                if (String.IsNullOrEmpty(prefixPath) == false)
                {
                    int index = folderRoot.Length > prefixPath.Length + 1 ? prefixPath.Length + 1 : prefixPath.Length;
                    folderPaths.Add(folderRoot.Substring(index));
                }
                else
                {
                    folderPaths.Add(folderRoot);
                }
            }

            DirectoryInfo[] subDirs;
            // Recursively descend subfolders, collecting directory info on the way
            // Note that while folders without images are also collected, these will eventually be skipped when it is later scanned for images to load
            try
            {
                DirectoryInfo dirInfo = new DirectoryInfo(folderRoot);
                subDirs = dirInfo.GetDirectories();
            }
            catch
            {
                // It may fail if there is a permissions issue
                return;
            }
            foreach (DirectoryInfo subDir in subDirs)
            {
                // Skip the following folders
                if (subDir.Name == Constant.File.BackupFolder || subDir.Name == Constant.File.DeletedFilesFolder || subDir.Name == Constant.File.VideoThumbnailFolderName)
                {
                    continue;
                }
                GetAllFoldersContainingAnImageOrVideo(subDir.FullName, folderPaths, prefixPath);
            }
        }
예제 #7
0
        /// <summary>
        /// Returns true only if every character in the string is a letter or a digit
        /// </summary>
        public static bool IsLetterOrDigit(string str)
        {
            // Check the arguments for null
            if (str == null)
            {
                // this should not happen
                TracePrint.PrintStackTrace(1);
                return(false);
            }

            foreach (char c in str)
            {
                if (!Char.IsLetterOrDigit(c))
                {
                    return(false);
                }
            }
            return(true);
        }
예제 #8
0
        /// <summary>
        /// Returns true only if every character in the string is a digit
        /// </summary>
        public static bool IsDigits(string value)
        {
            // Check the arguments for null
            if (value == null)
            {
                // this should not happen
                TracePrint.PrintStackTrace(1);
                // throw new ArgumentNullException(nameof(value));
                return(false);
            }

            foreach (char character in value)
            {
                if (!Char.IsDigit(character))
                {
                    return(false);
                }
            }
            return(true);
        }
        public static Dictionary <string, ImageMetadata> LoadMetadata(string filePath)
        {
            Dictionary <string, ImageMetadata> metadataDictionary = new Dictionary <string, ImageMetadata>();

            try
            {
                foreach (Directory metadataDirectory in ImageMetadataReader.ReadMetadata(filePath))
                {
                    // TraceDebug.PrintMessage(String.Format("metadataDirectory is: {0}", metadataDirectory.Name));
                    foreach (Tag metadataTag in metadataDirectory.Tags)
                    {
                        ImageMetadata metadata = new ImageMetadata(metadataTag.DirectoryName, metadataTag.Name, metadataTag.Description);

                        // Check if the metadata name is already in the dictionary.
                        // If so, just skip it as its not clear what else to do with it
                        // Note that Quicktime mp4s appear to have multiple directories called Quicktime Track Headers.
                        // Exiftool seems to handle this properly but MetadataDetector generates duplicates.
                        // So only the first Quicktime track header is added to the dictionary.
                        if (!metadataDictionary.ContainsKey(metadata.Key))
                        {
                            metadataDictionary.Add(metadata.Key, metadata);
                        }
                        else
                        {
                            TracePrint.PrintMessage(String.Format("ImageMetadata Dictionary: Duplicate metadata key: {0}:{1} (Note that Quicktime may have multiple Track Headers)", metadataDirectory.Name, metadata.Key));
                        }
                    }
                }
            }
            catch
            {
                // Likely a corrupt file, Just return the empty dictionary
                metadataDictionary.Clear();
            }
            return(metadataDictionary);
        }
예제 #10
0
        /// <summary>
        ///  Select the rows with the given IDs, discover its rowIndexes, and then scroll the topmost row into view
        ///  This method is provided with a list of tuples, each containing
        /// - a File ID,
        /// - a possible row index into the data table containing that File ID
        /// </summary>
        public static void SelectAndScrollIntoView(this DataGrid dataGrid, List <Tuple <long, int> > idRowIndexes)
        {
            // We want to select (highlight) each row in the data table matching those IDs.
            // Typically, the file record identified by the ID will be found in the datagrid row specified by RowIndex,
            // which will occur *unless* the the user has resorted the datagrid by clicking a column header
            // For efficiency, we check each tuple to see if the ID provided matches the ID in the row specified by rowIndex. If so,
            // we can quickly highlight those rows.  Otherwise we need to search the datagrid for each ID

            // Check the arguments for null
            if (dataGrid == null || idRowIndexes == null)
            {
                // this should not happen
                TracePrint.PrintStackTrace(1);
                // throw new ArgumentNullException(nameof(idRowIndexes) + " or " nameof(dataGrid));
                // Not sure what the consequences of this empty return is, but ...
                return;
            }

            // If there are no selections, just unselect everything
            if (idRowIndexes.Count.Equals(0))
            {
                dataGrid.UnselectAll();
                return;
            }

            int         topmostRowIndex = int.MaxValue; // Keeps track of the topmost row index, as this is the one we will want to scroll too
            DataRowView currentRow;                     // The current row being examined
            List <int>  rowIndexesToSelect = new List <int>();
            long        currentID;
            int         currentRowIndexThatMayContainID;

            foreach (Tuple <long, int> idRowIndex in idRowIndexes)
            {
                currentID = (int)idRowIndex.Item1;
                currentRowIndexThatMayContainID = idRowIndex.Item2;

                // Get the row indicated by rowIndex (after first checking that such a row exists)
                if (dataGrid.Items.Count < currentRowIndexThatMayContainID)
                {
                    // System.Diagnostics.Debug.Print("row index " + currentRowIndexThatMayContainID + " is not in array sized " + dataGrid.Items.Count);
                    return;
                }
                currentRow = dataGrid.Items[currentRowIndexThatMayContainID] as DataRowView;

                if ((long)currentRow.Row.ItemArray[0] == currentID)
                {
                    // The ID is in the row indicated by rowIndex. Add that rowIndex as one of the rows we should select
                    rowIndexesToSelect.Add(currentRowIndexThatMayContainID);
                    if (topmostRowIndex > currentRowIndexThatMayContainID)
                    {
                        topmostRowIndex = currentRowIndexThatMayContainID;
                    }
                }
                else
                {
                    // The ID is not in the row indicated by rowIndex. Search the datagrid for that ID, and then add it as one of the rows we should select
                    bool idFound            = false;
                    int  dataGridItemsCount = dataGrid.Items.Count;
                    for (int index = 0; index < dataGridItemsCount; index++)
                    {
                        currentRow = dataGrid.Items[index] as DataRowView;
                        if ((long)currentRow.Row.ItemArray[0] == currentID)
                        {
                            idFound = true;
                            rowIndexesToSelect.Add(index);
                            if (topmostRowIndex > index)
                            {
                                topmostRowIndex = index;
                            }
                            break;
                        }
                    }
                    if (idFound == false)
                    {
                        // The id should always be found. But just in case  we ignore IDS that aren't found
                        // System.Diagnostics.Debug.Print("could not find ID: " + currentID + " in array sized " + dataGrid.Items.Count);
                    }
                }
            }

            // Select the items (which highlights those rows)
            bool indexIncreasing = topmostRowIndex > dataGrid.SelectedIndex;

            SelectRowByIndexes(dataGrid, rowIndexesToSelect);

            // Depending on our selection direction, we scroll to expose the previous or next 2 rows to ensure they are visible beyond the selected row);
            int scrollIndex = indexIncreasing ? Math.Min(topmostRowIndex + 3, dataGrid.Items.Count - 1) : Math.Max(topmostRowIndex - 3, 0);

            dataGrid.ScrollIntoView(dataGrid.Items[scrollIndex]);
        }