public DlgPopulateFieldWithMetadata(DBData db_data, string file_name, string folder_path)
 {
     this.fileName = file_name;
     this.folderPath = folder_path;
     this.dbData = db_data;
     InitializeComponent();
 }
        public DlgDateTimeChangeCorrection(DBData db_data)
        {
            InitializeComponent();
            bool result;
            this.dbData = db_data;

            // Get the original date and display it
            this.dbData.GetIdOfCurrentRow();
            this.lblOriginalDate.Content = dbData.IDGetDate(out result) + " " + dbData.IDGetTime(out result);

            // Get the image filename and display it
            this.lblImageName.Content = dbData.IDGetFile(out result);

            // Display the image. While we should be on a valid image (our assumption), we can still show a missing or corrupted image if needed
            string path = System.IO.Path.Combine(dbData.FolderPath, dbData.IDGetFile(out result));
            BitmapFrame bmap;
            try
            {
                bmap = BitmapFrame.Create(new Uri(path), BitmapCreateOptions.None, BitmapCacheOption.None);
            }
            catch
            {
                if (! File.Exists  (path))
                    bmap = BitmapFrame.Create(new Uri("pack://application:,,/Resources/missing.jpg"));
                else
                    bmap = BitmapFrame.Create(new Uri("pack://application:,,/Resources/corrupted.jpg"));
            }
            this.imgDateImage.Source = bmap;
        }
        int originalDarkPixelThreshold = 0; // Default value

        #endregion Fields

        #region Constructors

        public DlgOptionsDarkImagesThreshold(DBData db_data, int dark_pixel_threshold, double dark_pixel_ratio)
        {
            InitializeComponent();

            this.dbData = db_data;
            this.originalDarkPixelThreshold = dark_pixel_threshold;
            this.originalDarkPixelRatio = dark_pixel_ratio;

            this.darkPixelThreshold = dark_pixel_threshold;
            this.darkPixelRatio = dark_pixel_ratio;
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Export all the database data associated with the filtered view to the CSV file indicated in the file path so that spreadsheet applications (like Excel) can display it.
        /// </summary>
        /// <param name="db"></param>
        /// <param name="filepath"></param>
        public static void ExportDataAsCSV(DBData db, string filepath)
        {
            TextWriter tw = new StreamWriter(filepath, false);
            try
            {
                // Write the header as defined by the data labels in the template file
                // If the data label is an empty string, we use the label instead.
                string header = "";
                string label;
                string datalabel;
                List<string> datalabels = new List<string>();
                for (int i = 0; i < db.templateTable.Rows.Count; i++)
                {
                    label = (string)db.templateTable.Rows[i][Constants.LABEL];
                    datalabel = (string)db.templateTable.Rows[i][Constants.DATALABEL];
                    header += addColumn(getLabel(label, datalabel));

                    // get a list of datalabels so we can add columns in the order that matches the current template table order
                    if (Constants.ID != datalabel) datalabels.Add(datalabel);
                }
                tw.WriteLine(header);
                // For each row in the data table, write out the columns in the same order as the
                // data labels in the template file
                for (int i = 0; i < db.dataTable.Rows.Count; i++)
                {
                    string row = "";
                    foreach (string dataLabel in datalabels)
                    {
                        row += addColumn((string)db.dataTable.Rows[i][dataLabel]);
                    }
                    tw.WriteLine(row);
                }
            }
            catch
            {
                // Can't write the spreadsheet file
                DlgMessageBox dlgMB = new DlgMessageBox();
                dlgMB.IconType = MessageBoxImage.Error;
                dlgMB.ButtonType = MessageBoxButton.OK;

                dlgMB.MessageTitle = "Can't write the spreadsheet file.";
                dlgMB.MessageProblem = "The following file can't be written: " + filepath + ".";
                dlgMB.MessageReason = "You may already have it open in Excel or another  application.";
                dlgMB.MessageSolution = "If the file is open in another application, close it and try again.";
                dlgMB.ShowDialog();
            }
            tw.Close();
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Create a CustomFilter, where we build a list of potential search term expressions based on the controls found in the sorted template table
        /// The search term will be used only if its 'UseForSearching' field is true
        /// </summary>
        /// <param name="db_data"></param>
        public CustomFilter(DBData db_data)
        {
            dbData = db_data;
            LogicalOperator = LogicalOperators.Or; // We default the search operation to this logical operation
            SearchTermList = new Dictionary<int, SearchTerm>();

            DataTable sortedTemplateTable = dbData.TemplateGetSortedByControls();

            // Initialize the filter to reflect the desired controls in the template (in sorted order)
            int row_count = 1; // We start at 1 as there is already a header row
            for (int i = 0; i < sortedTemplateTable.Rows.Count; i++)
            {
                // Get the values for each control
                DataRow row = sortedTemplateTable.Rows[i];
                string type = row[Constants.TYPE].ToString();

                // We only handle certain types, e.g., we don't give the user the opportunity to search over file names / folders / date / time
                if (type == Constants.NOTE || type == Constants.COUNTER || type == Constants.FIXEDCHOICE || type == Constants.IMAGEQUALITY || type == Constants.FLAG)
                {
                    // Create a new search expression for each row, where each row specifies a particular control and how it can be searched
                    string default_value = "";
                    string expression = CH_EQUALS;
                    bool is_use_for_searching = false;
                    if (type == Constants.COUNTER)
                    {
                        default_value = "0";
                        expression = CH_GREATER_THAN;  // Makes more sense that people will test for > as the default rather than counters
                    }
                    else if (type == Constants.FLAG)
                    {
                        default_value = "false";
                    }

                    // Create a new search term and add it to the list
                    SearchTerm st = new SearchTerm();
                    st.UseForSearching = is_use_for_searching;
                    st.Type = type;
                    st.Label = (string) row[Constants.LABEL];
                    st.DataLabel = (string) row[Constants.DATALABEL];
                    st.Expression = expression;
                    st.Value = default_value;
                    st.List = (string)row[Constants.LIST];
                    this.SearchTermList.Add(row_count, st);
                    row_count++;
                }
            }
        }
Ejemplo n.º 6
0
        private bool isCorrupted; // whether that image was corrupted or not

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Ask the user if he/she wants to delete the given image indicated by the index.
        /// Other parameters indicate various specifics of that image that we will use to display and delete it
        /// </summary>
        /// <param name="currentImageIndex"></param>
        /// <param name="imageFilename"></param>
        /// <param name="imageFolderPath"></param>
        /// <param name="isCorrupted"></param>
        public DlgDeleteImage(DBData db_data, string imageFilename, string imageFolderPath, bool isCorrupted, bool delete_data)
        {
            InitializeComponent();

            // Set the local variables to the passed in parameters
            this.imageFilename = imageFilename;
            this.imageFolderPath = imageFolderPath;
            this.deleteData = delete_data;
            this.dbData = db_data;

            if (this.deleteData == true)
            {
                this.textMain.Text = "Delete the current image file and its data: " + this.imageFilename; // put the file name in the title
                this.TBDeleteImageAndData1.Visibility = Visibility.Visible;
                this.TBDeleteImageOnly1.Visibility = Visibility.Collapsed;
                this.TBDeleteImageOnly2.Visibility = Visibility.Collapsed;
                this.TBDeleteImageOnly3.Visibility = Visibility.Collapsed;
                this.LblImageOnly.Visibility = Visibility.Hidden;
                this.deletedImage.Visibility = Visibility.Hidden;
                this.chkboxConfirm.Visibility = Visibility.Visible;
                this.OkButton.IsEnabled = false;            }
            else
            {
               this.textMain.Text = "Delete the current image file: " + this.imageFilename; // put the file name in the title
               this.TBDeleteImageAndData1.Visibility = Visibility.Collapsed;
               this.TBDeleteImageOnly1.Visibility = Visibility.Visible;
               this.TBDeleteImageOnly2.Visibility = Visibility.Visible;
               this.TBDeleteImageOnly3.Visibility = Visibility.Visible;
               this.LblImageOnly.Visibility = Visibility.Visible;
               this.deletedImage.Visibility = Visibility.Visible;

               this.chkboxConfirm.Visibility = Visibility.Hidden;
               this.OkButton.IsEnabled = true;
            }
            this.isCorrupted = isCorrupted;
            this.deleteData = delete_data;
            this.showOriginalImage();
            this.showDeletedImage();
        }
        // Create the interface
        public DlgDateCorrection(DBData db_data)
        {
            InitializeComponent();
            this.dbData = db_data;
            bool result;
            // Get the original date and display it
            this.lblOriginalDate.Content = dbData.IDGetDate(out result) + " " + dbData.IDGetTime(out result);

            // Get the image filename and display it
            this.lblImageName.Content = dbData.IDGetFile(out result);

            // Display the image. While we should be on a valid image (our assumption), we can still show a missing or corrupted image if needed
            string path = System.IO.Path.Combine(dbData.FolderPath, dbData.IDGetFile(out result));
            BitmapFrame bmap;
            try
            {
                bmap = BitmapFrame.Create(new Uri(path), BitmapCreateOptions.None, BitmapCacheOption.None);
            }
            catch
            {
                if (! File.Exists  (path))
                    bmap = BitmapFrame.Create(new Uri("pack://application:,,/Resources/missing.jpg"));
                else
                    bmap = BitmapFrame.Create(new Uri("pack://application:,,/Resources/corrupted.jpg"));
            }
            this.imgDateImage.Source = bmap;

            // Try to put the original date / time into the corrected date field. If we can't, leave it as it is (i.e., as dd-mmm-yyyy hh:mm am).
            string format = "dd-MMM-yyyy hh:mm tt";
            CultureInfo provider = CultureInfo.InvariantCulture;
            string sDate = this.lblOriginalDate.Content.ToString();
            try
            {
                DateTime.ParseExact(sDate, format, provider);
                this.tbNewDate.Text = this.lblOriginalDate.Content.ToString();
            }
            catch { };
        }
Ejemplo n.º 8
0
 public Propagate(DBData dbData)
 {
     this.dbData = dbData;  // We need a reference to the database if we are going to update it.
 }
Ejemplo n.º 9
0
 /// <summary>Constructor </summary>
 /// <param name="db"></param>
 public DlgDataView(DBData dbData)
 {
     InitializeComponent();
     this.dbData = dbData;
     RefreshDataTable ();
 }
Ejemplo n.º 10
0
        public void GenerateControls(DBData dbData)
        {
            const string EXAMPLE_DATE = "28-Dec-2014";
            const string EXAMPLE_TIME = "04:00 PM";

            string key = ""; // Construct a key

            Propagate = new Propagate(dbData);
            //this.ControlGrid.Inlines.Clear();
            //this.WP.Children.Clear();

            DataTable sortedTemplateTable = dbData.TemplateGetSortedByControls();
            for (int i = 0; i < sortedTemplateTable.Rows.Count; i++)
            {
                // Get the values for each control
                DataRow row = sortedTemplateTable.Rows[i];
                string type = row[Constants.TYPE].ToString();
                string defaultValue = row[Constants.DEFAULT].ToString();
                string label = row[Constants.LABEL].ToString();
                string tooltip = row[Constants.TOOLTIP].ToString();
                string width = row[Constants.TXTBOXWIDTH].ToString();
                int    iwidth = (width == "") ? 0 : Convert.ToInt32(width);
                string visiblity = row[Constants.VISIBLE].ToString();
                bool   bvisiblity = ("true" == visiblity.ToLower ()) ? true : false;
                string copyable = row[Constants.COPYABLE].ToString();
                bool   bcopyable = ("true" == copyable.ToLower ()) ? true : false;
                string list = row[Constants.LIST].ToString();
                int id = Convert.ToInt32 (row[Constants.ID].ToString ()); // TODO Need to use this ID to pass between controls and data

                // Get the key
                key = (string) row[Constants.DATALABEL];
                if (type == Constants.DATE && defaultValue == "")
                {
                    defaultValue = EXAMPLE_DATE;
                }
                else if (type == Constants.TIME && defaultValue == "")
                {
                    defaultValue = EXAMPLE_TIME;
                }

                if (type == Constants.FILE || type == Constants.FOLDER || type == Constants.DATE || type == Constants.TIME || type == Constants.NOTE)
                {
                    bool createContextMenu = (type == Constants.FILE) ? false : true;
                    MyNote myNote = new MyNote(this, createContextMenu);
                    myNote.Key = key;
                    myNote.Label = label;
                    myNote.DataLabel = key; // TODO we probably don't need a datalabel and a key any more as its redundant. Should just keep the DataLabel as its the key
                    myNote.Tooltip = tooltip;
                    myNote.Width = iwidth;
                    myNote.Visible = bvisiblity;
                    myNote.Content = defaultValue;
                    myNote.ReadOnly = (type == Constants.FOLDER || type == Constants.FILE) ? true : false; // File and Folder Notes are read only i.e., non-editable by the user
                    myNote.Copyable = bcopyable;
                    this.ControlGrid.Inlines.Add(myNote.Container);
                    //this.WP.Children.Add(myNote.Container);
                    this.ControlFromDataLabel.Add(key, myNote);
                }
                else if (type == Constants.FLAG || type == Constants.DELETEFLAG)
                {
                    MyFlag myFlag = new MyFlag(this, true);
                    myFlag.Key = key;
                    myFlag.Label = label;
                    myFlag.DataLabel = key; // TODO we probably don't need a datalabel and a key any more as its redundant. Should just keep the DataLabel as its the key
                    myFlag.Tooltip = tooltip;
                    myFlag.Width = iwidth;
                    myFlag.Visible = bvisiblity;
                    myFlag.Content = defaultValue;
                    myFlag.ReadOnly = false; // Flags are editable by the user
                    myFlag.Copyable = bcopyable;
                    //this.WP.Children.Add(myFlag.Container);
                    this.ControlGrid.Inlines.Add(myFlag.Container);
                    this.ControlFromDataLabel.Add(key, myFlag);
                }
                else if (type == Constants.COUNTER)
                {
                    MyCounter myCounter = new MyCounter(this, true);
                    myCounter.Key = key;
                    myCounter.Label = label;
                    myCounter.DataLabel = key; // TODO we probably don't need a datalabel and a key any more as its redundant. Should just keep the DataLabel as its the key
                    myCounter.Tooltip = tooltip;
                    myCounter.Width = iwidth;
                    myCounter.Visible = bvisiblity;
                    myCounter.Content = defaultValue;
                    myCounter.ReadOnly = false; // Couonters are editable by the user
                    myCounter.Copyable = bcopyable;
                    this.ControlGrid.Inlines.Add(myCounter.Container);
                    //this.WP.Children.Add(myCounter.Container);
                    this.ControlFromDataLabel.Add(key, myCounter);
                }
                else if (type == Constants.FIXEDCHOICE || type == Constants.IMAGEQUALITY)
                {
                    MyFixedChoice myFixedChoice = new MyFixedChoice(this, true, list);
                    myFixedChoice.Key = key;
                    myFixedChoice.Label = label;
                    myFixedChoice.DataLabel = key; // TODO we probably don't need a datalabel and a key any more as its redundant. Should just keep the DataLabel as its the key
                    myFixedChoice.Tooltip = tooltip;
                    myFixedChoice.Width = iwidth;
                    myFixedChoice.Visible = bvisiblity;
                    myFixedChoice.Content = defaultValue;
                    myFixedChoice.ReadOnly = false; // Fixed choices are editable (by selecting a menu) by the user
                    myFixedChoice.Copyable = bcopyable;
                    this.ControlGrid.Inlines.Add(myFixedChoice.Container);
                    //this.WP.Children.Add(myFixedChoice.Container);
                    this.ControlFromDataLabel.Add(key, myFixedChoice);
                }
            }
            //var panel = this.ButtonLocation.Parent as Panel;
            //panel.Children.Remove(this.ButtonLocation);
            //this.ControlGrid.Inlines.Add(this.ButtonLocation);
        }
Ejemplo n.º 11
0
        public List<MyCounter> MyCountersList = new List<MyCounter>(); // list of all our counter controls

        #endregion Fields

        #region Constructors

        public Controls(DBData dbData)
        {
            InitializeComponent();
            WP = new WrapPanel ();
        }
Ejemplo n.º 12
0
        private string imageFolderPath; // the full folder path where that image is located

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Ask the user if he/she wants to delete the given image indicated by the index.
        /// Other parameters indicate various specifics of that image that we will use to display and delete it
        /// </summary>
        /// <param name="currentImageIndex"></param>
        /// <param name="imageFilename"></param>
        /// <param name="imageFolderPath"></param>
        /// <param name="isCorrupted"></param>
        public DlgDeleteImages(DBData db_data, DataTable deletedTable, string imageFolderPath, bool delete_data)
        {
            InitializeComponent();
            Mouse.OverrideCursor = Cursors.Wait;
            this.deletedTable = deletedTable;
            this.imageFolderPath = imageFolderPath;
            this.deleteData = delete_data;
            this.dbData = db_data;

            string fname= "";
            string path="";
            BitmapImage image;
            System.Windows.Controls.Image imagectl;
            Label label;

            if (this.deleteData)
            {
                this.sp_DeleteAll.Visibility = Visibility.Visible;
                this.sp_DeleteImages.Visibility = Visibility.Collapsed;
                this.OkButton.IsEnabled = false;
                this.chkboxConfirm.Visibility= Visibility.Visible;
            }
            else
            {
                this.sp_DeleteAll.Visibility = Visibility.Collapsed;
                this.sp_DeleteImages.Visibility = Visibility.Visible;
                this.OkButton.IsEnabled = true;
                this.chkboxConfirm.Visibility = Visibility.Collapsed;
            }
            this.GridGallery.RowDefinitions.Clear();

            // Set the local variables to the passed in parameters
            int col = 0;
            int row = 0;

            GridLength gridlength200 = new GridLength(1, GridUnitType.Auto);
            GridLength gridlength20 = new GridLength(1, GridUnitType.Auto);
            for (int i = 0; i < deletedTable.Rows.Count; i++ )
            {
                fname = (string) deletedTable.Rows[i][Constants.FILE];

                label = new Label();
                label.Content = fname;
                label.Height = 25;
                label.VerticalAlignment = VerticalAlignment.Top;

                path = System.IO.Path.Combine(this.imageFolderPath, fname);

                if (Constants.IMAGEQUALITY_CORRUPTED == (string)deletedTable.Rows[i][Constants.IMAGEQUALITY])
                    image = this.getImage(path, "corrupted");
                else if (File.Exists(path))
                    image = this.getImage(path, "ok");
                else
                    image = this.getImage(path, "missing");

                imagectl = new System.Windows.Controls.Image() ;
                imagectl.Source = image;

                if (col == 0)
                {
                    this.GridGallery.RowDefinitions.Add(new RowDefinition() { Height = gridlength20 });
                    this.GridGallery.RowDefinitions.Add(new RowDefinition() { Height = gridlength200 });
                }
                Grid.SetRow(label, row);
                Grid.SetRow(imagectl, row+1);
                Grid.SetColumn(label, col);
                Grid.SetColumn(imagectl, col);
                this.GridGallery.Children.Add(label);
                this.GridGallery.Children.Add(imagectl);
                col++;
                if (col == 5) // A new row is started every 5th time
                {
                    col = 0;
                    row += 2;
                }
            }
            this.scroller.CanContentScroll = true;
            Mouse.OverrideCursor = null;
        }
 public DlgDateRereadDatesFromImages(DBData dbData)
 {
     InitializeComponent();
     this.dbData = dbData;
 }
Ejemplo n.º 14
0
        // Read all the data into the imageData structure from the XML file in the filepath.
        // Note that we need to know the code controls,as we have to associate any points read in with a particular counter control
        public static void Read(string filePath, DataTable template, DBData dbData)
        {
            // XML Preparation
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.Load(filePath);

            // Import the old log (if any)
            XmlNodeList nodeLog = xmlDoc.SelectNodes(IMAGES + SLASH + LOG);
            if (nodeLog.Count > 0)
            {
                XmlNode nlog = nodeLog[0];
                dbData.Log = nlog.InnerText;
            }

            XmlNodeList nodelist = xmlDoc.SelectNodes(IMAGES + SLASH + IMAGE);
            XmlNodeList innerNodeList;

            string filename = "";
            string date;
            string time;

            List<string> counts = new List<string>();
            ColumnTupleList countercoords = new ColumnTupleList();
            Dictionary<String, Object> dataline;
            Dictionary<Dictionary<String, Object>, String> control_values_to_update = new Dictionary<Dictionary<String, Object>, String>();
            List<ColumnTupleListWhere> marker_value_to_update = new List<ColumnTupleListWhere>();

            int id = 0;
            List<string> notenames = new List<string>();
            List<string> counternames = new List<string>();
            List<string> choicenames = new List<string>();

            // Create three lists, each one representing the datalabels (in order found in the template) of notes, counters and choices
            // We will use these to find the matching ones in the xml data table.
            for (int i = 0; i < template.Rows.Count; i++ )
            {
                if (template.Rows[i][Constants.TYPE].Equals (Constants.NOTE) )
                {
                    notenames.Add((string) template.Rows[i][Constants.DATALABEL]);
                }
                else if  (template.Rows[i][Constants.TYPE].Equals (Constants.COUNTER) )
                {
                    counternames.Add((string) template.Rows[i][Constants.DATALABEL]);
                }
                else if (template.Rows[i][Constants.TYPE].Equals(Constants.FIXEDCHOICE))
                {
                    choicenames.Add((string)template.Rows[i][Constants.DATALABEL]);
                }
            }

            foreach (XmlNode n in nodelist)
            {
                int idx;

                id++;
                dataline = new Dictionary<String, Object>(); // Populate the data

                // File Field - We use the file name as a key into a particular database row. We don't change the database field as it is our key.
                filename = n[FILE].InnerText;

                // If the Folder Path differs from where we had previously loaded it,
                // warn the user that the new path will be substituted in its place

                // Folder - We are going to leave this field unchanged, so ignore it
                //string folder = n[FOLDER].InnerText);

                // Date - We use the original date, as the analyst may have adjusted them
                date = n[DATE].InnerText;
                dataline.Add(Constants.DATE, date);

                // Date - We use the original time, although its almost certainly identical
                time = n[TIME].InnerText;
                dataline.Add(Constants.TIME, time);

                // We don't use the imagequality, as the new system may have altered how quality is determined (e.g., deleted files)
                // imagequality = n[IMAGEQUALITY].InnerText;
                // dataline.Add(Constants.IMAGEQUALITY, imagequality);
                // System.Diagnostics.Debug.Print("----" + filename + " " + date + " " + time + " " + imagequality);

                // Notes: Iterate through
                idx = 0;
                innerNodeList = n.SelectNodes(NOTE);
                foreach (XmlNode node in innerNodeList)
                {
                    dataline.Add(notenames[idx++], node.InnerText);
                }

                // Choices: Iterate through
                idx = 0;
                innerNodeList = n.SelectNodes(FIXEDCHOICE);
                foreach (XmlNode node in innerNodeList)
                {
                    dataline.Add(choicenames[idx++], node.InnerText);
                }

                // Counters: Iterate through
                idx = 0;
                innerNodeList = n.SelectNodes(COUNTER);

                // For each counter control
                string where = "";
                foreach (XmlNode node in innerNodeList)
                {
                    // Add the value of each counter to the dataline
                    XmlNodeList dataNode = node.SelectNodes(DATA);
                    dataline.Add(counternames[idx], dataNode[0].InnerText);

                    // For each counter, find the points associated with it and compose them together as x1,y1|x2,y2|...|xn,yn
                    XmlNodeList pointNodeList = node.SelectNodes(POINT);
                    string countercoord = "";
                    foreach (XmlNode pnode in pointNodeList)
                    {
                        String x = pnode.SelectSingleNode(X).InnerText;
                        if (x.Length > 5) x = x.Substring(0, 5);
                        String y = pnode.SelectSingleNode(Y).InnerText;
                        if (y.Length > 5) y = y.Substring(0, 5);
                        countercoord += x + "," + y + "|";
                    }

                    // Remove the last "|" from the point list
                    if (!countercoord.Equals(""))  countercoord = countercoord.Remove(countercoord.Length - 1); // Remove the last "|"

                    // Countercoords will have a list of points (possibly empty) with each list entry representing a control
                    countercoords.Add(new ColumnTuple (counternames[idx], countercoord));
                    idx++;
                }
                // Add this update to the list of all updates for the Datatable, and then update it
                control_values_to_update.Add(dataline, Constants.FILE + "='" + filename + "'");

                where = Constants.ID + "='" + id.ToString() + "'";
                marker_value_to_update.Add(new ColumnTupleListWhere (countercoords, where));
                //dbData.UpdateMarkersInRow (id, counternames, countercoords); // Update the marker table

                // Create a list of all updates for the MarkerTable, and then update it

                countercoords = new ColumnTupleList ();
            }
            // Update the various tables in one fell swoop
            dbData.RowsUpdateRowsFromFilenames(control_values_to_update);
            dbData.RowsUpdateMarkerRows(marker_value_to_update);
            dbData.UpdateMarkersInRows(marker_value_to_update);
        }
 public DlgCustomViewFilter(DBData db_data, CustomFilter custom_filter)
 {
     this.dbData = db_data;
     this.customFilter = custom_filter;
     InitializeComponent();
 }
Ejemplo n.º 16
0
        /// <summary>
        /// Check to see if we can swap the day and month in all date fields. It checks to see if this is possible.
        /// If it isn't, it returns false, else true
        /// Assumes that we are showing all images (i.e., it checks the current datatable)
        /// TODO: Change it to use a temp table?
        /// </summary>
        /// <param name="main"></param>
        /// 
        public static int SwapDayMonthIsPossible(DBData dbData)
        {
            DateTime date; //Month/Day order
            DateTime reversedDate;
            bool succeeded = true;
            string sdate ;

            // First, do a pass to see if swapping the date/time order is even possible
            for (int i = 0; i < dbData.dataTable.Rows.Count; i++)
            {
               // Skip over corrupted images for now, as we know those dates are likley wrong
               if (dbData.RowIsImageCorrupted(i)) continue;

               // Parse the date, which should always work at this point. But just in case, put out a debug message
               sdate = (string) dbData.dataTable.Rows[i][Constants.DATE] + " " + (string) dbData.dataTable.Rows[i][Constants.TIME];
               succeeded = DateTime.TryParse(sdate, out date);
               if (!succeeded) Debug.Print("In SwapDayMonth - something went wrong trying to parse a date!");

               // Now check to see if the reversed date is legit. If it throws an exception, we know its a problem so get out of here.
               try
               {
                   reversedDate = new DateTime(date.Year, date.Day, date.Month); // we have swapped the day with the month
                   succeeded = true;
               }
               catch
               {
                   return (i); // Return the first image where we couldn't swap the date
               }
               if (!succeeded) break;
               }

            return -1; //-1 means we can reverse the dates
        }