Ejemplo n.º 1
0
        private void AddCsvField(CsvFieldType t, string strName, string strFormat)
        {
            string strText = CsvFieldToString(t);

            string strSub = string.Empty;

            if (strName != null)
            {
                strSub += strName;
            }
            if (!string.IsNullOrEmpty(strFormat))
            {
                if (strSub.Length > 0)
                {
                    strSub += ", ";
                }
                strSub += strFormat;
            }

            if (strSub.Length > 0)
            {
                strText += " (" + strSub + ")";
            }

            ListViewItem lvi = m_lvFields.Items.Add(strText);

            lvi.Tag = new CsvFieldInfo(t, strName, strFormat);
        }
Ejemplo n.º 2
0
		public void AbsorbOneValueFromStringThrows(object value, CsvFieldType fieldType) {
			if (value == null) {
				throw new Exception("CsvBar.AbsorbOneValueFromStringThrows(): don't make me absorb value=NULL");
			}
			switch(fieldType) {
				case CsvFieldType.DateTime: 	DateTime		= (DateTime)	value;	break;
				case CsvFieldType.Date:			DateAsString	= (string)		value;	break;
				case CsvFieldType.Time:			TimeAsString	= (string)		value;	break;
				case CsvFieldType.Open: 		Open			= (float)		value;	break;
				case CsvFieldType.High: 		High			= (float)		value;	break;
				case CsvFieldType.Low: 			Low				= (float)		value;	break;
				case CsvFieldType.Close: 		Close			= (float)		value;	break;
				case CsvFieldType.Volume: 		Volume			= (float)		value;	break;

				case CsvFieldType.Unknown:
				case CsvFieldType.Ignore:
				case CsvFieldType.Symbol:
				case CsvFieldType.Interval_Min:
				case CsvFieldType.Interval_Hrs:
				case CsvFieldType.Interval_Days:
					break;

				default:
					throw new Exception("CsvBar.AbsorbOneValueFromString():\r\nadd handler for [" + fieldType + "]");
			}
		}
Ejemplo n.º 3
0
        public object AspectGetterParsedRaw(object shouldBeListOfStrings)
        {
            List <string> pi = shouldBeListOfStrings as List <string>;

            if (pi == null)
            {
                Assembler.PopupException("shouldBeListOfStrings is not List<string>");
                this.Parser.CsvType = this.CsvTypeContentSuggested = CsvFieldType.Ignore;
                return("NOT_LIST<STRING>");
            }
            if (pi.Count == 0)
            {
                Assembler.PopupException("shouldBeListOfStrings.Count=0");
                this.Parser.CsvType = this.CsvTypeContentSuggested = CsvFieldType.Ignore;
                return("LIST<STRING>.COUNT=0");
            }
            try {
                var ret = pi[this.ColumnSerno];
                //this.guessCsvFieldType(ret);
                return(ret);
            } catch (Exception ex) {
                this.Parser.CsvType = this.CsvTypeContentSuggested = CsvFieldType.Ignore;
                return("OUT_OF_BOUNDARY");
            }
        }
		public List<string> FormatsAvailableForType(CsvFieldType type) {
			string storedUnderKey = this.GetAppropriateFormatKeyForType(type);
			if (storedUnderKey == null) {
				return new List<string>() { CsvTypeParser.FORMAT_VISUALIZE_EMPTY_STRING };
			}
			return this.CsvFieldTypeFormatsAvailable[storedUnderKey];
		}
Ejemplo n.º 5
0
        private static string CsvFieldToString(CsvFieldType t)
        {
            string strText;

            if (t == CsvFieldType.Ignore)
            {
                strText = "(" + KPRes.Ignore + ")";
            }
            else if (t == CsvFieldType.GroupName)
            {
                strText = KPRes.Group;
            }
            else if (t == CsvFieldType.Title)
            {
                strText = KPRes.Title;
            }
            else if (t == CsvFieldType.UserName)
            {
                strText = KPRes.UserName;
            }
            else if (t == CsvFieldType.Password)
            {
                strText = KPRes.Password;
            }
            else if (t == CsvFieldType.Url)
            {
                strText = KPRes.Url;
            }
            else if (t == CsvFieldType.Notes)
            {
                strText = KPRes.Notes;
            }
            else if (t == CsvFieldType.CustomString)
            {
                strText = KPRes.String;
            }
            else if (t == CsvFieldType.CreationTime)
            {
                strText = KPRes.CreationTime;
            }
            else if (t == CsvFieldType.LastAccessTime)
            {
                strText = KPRes.LastAccessTime;
            }
            else if (t == CsvFieldType.LastModTime)
            {
                strText = KPRes.LastModificationTime;
            }
            else if (t == CsvFieldType.ExpiryTime)
            {
                strText = KPRes.ExpiryTime;
            }
            else
            {
                Debug.Assert(false); strText = KPRes.Unknown;
            }

            return(strText);
        }
		public string GetAppropriateFormatKeyForType(CsvFieldType type) {
			string ret = null;
			foreach (string key in this.CsvFieldTypeFormatsAvailable.Keys) {
				if (key.Contains(type.ToString()) == false) continue;
				ret = key;
				break;
			}
			return ret;
		}
Ejemplo n.º 7
0
        private void OnFieldTypeSelectedIndexChanged(object sender, EventArgs e)
        {
            CsvFieldType t = GetCsvFieldType();

            if (t != m_tLastCsvType)
            {
                m_cmbFieldFormat.Text = string.Empty;
            }

            EnableControlsEx();
        }
Ejemplo n.º 8
0
		public bool IsValueValid(CsvFieldType fieldType) {
			switch(fieldType) {
				case CsvFieldType.DateTime: 	return this.DateTime != DateTime.MinValue;
				case CsvFieldType.Open: 		return this.Open > 0;
				case CsvFieldType.High: 		return this.High > 0;
				case CsvFieldType.Low: 			return this.Low > 0;
				case CsvFieldType.Close: 		return this.Close > 0;
				case CsvFieldType.Volume: 		return this.Volume > -1;
				default:
					return true;
			}
		}
Ejemplo n.º 9
0
        void olvFieldSetup_CellEditFinishing(object sender, CellEditEventArgs e)
        {
            if (e.Control is ComboBox == false)
            {
                string msg = "EDITOR_SHOULD_BE_COMBOBOX, instead I got e.Control.GetType()=[" + e.Control.GetType() + "]";
                Assembler.PopupException(msg + " olvFieldSetup_CellEditFinishing()");
                return;
            }

            ComboBox      editor         = (ComboBox)e.Control;
            FieldSetup    fieldSetup     = (FieldSetup)e.RowObject;
            ColumnCatcher iCatcherEdited = this.olvColGenFieldSetup[e.Column];

            switch (fieldSetup.RowIndexInObjectListView)
            {
            case 0:
                //CsvFieldType enumValueSelected1 = (CsvFieldType) Enum.Parse(typeof(CsvFieldType), editor.SelectedItem.ToString());
                CsvFieldType selectedType = (CsvFieldType)editor.SelectedIndex;
                iCatcherEdited.Parser.CsvType = selectedType;
                break;

            case 1:
                //CsvFieldType enumValueSelected1 = (CsvFieldType) Enum.Parse(typeof(CsvFieldType), editor.SelectedItem.ToString());
                string selectedFormat = editor.SelectedItem as string;
                if (selectedFormat == null)
                {
                    selectedFormat = editor.Text;                               //user typed new value => add it to source list
                    this.dataSnapshot.AddFormatForTypeUnique(selectedFormat, iCatcherEdited.Parser.CsvType);
                }
                if (selectedFormat == CsvTypeParser.FORMAT_VISUALIZE_EMPTY_STRING)
                {
                    selectedFormat = "";
                }
                iCatcherEdited.Parser.CsvTypeFormat = selectedFormat;
                break;

            default:
                throw new Exception("this.olvFieldSetup should contain exactly TWO identical rows; OLV should've passed rowIndex into AspectGetter and CellEdit");
                break;
            }
            editor.SelectedIndexChanged -= cb_SelectedIndexChanged;
            this.dataSnapshotSerializer.Serialize();

            this.olvFieldSetup.RefreshObject(iCatcherEdited);
            // Any updating will have been down in the SelectedIndexChanged event handler
            // Here we simply make the list redraw the involved ListViewItem
            //((ObjectListView)sender).RefreshItem(e.ListViewItem);
            // We have updated the model object, so we cancel the auto update
            //e.Cancel = true;

            //this.step3syncCsvRawAndFieldSetupToParsedByFormat();
            this.step3safe();
        }
Ejemplo n.º 10
0
        public List <string> FormatsAvailableForType(CsvFieldType type)
        {
            string storedUnderKey = this.GetAppropriateFormatKeyForType(type);

            if (storedUnderKey == null)
            {
                return(new List <string>()
                {
                    CsvTypeParser.FORMAT_VISUALIZE_EMPTY_STRING
                });
            }
            return(this.CsvFieldTypeFormatsAvailable[storedUnderKey]);
        }
Ejemplo n.º 11
0
        public string GetAppropriateFormatKeyForType(CsvFieldType type)
        {
            string ret = null;

            foreach (string key in this.CsvFieldTypeFormatsAvailable.Keys)
            {
                if (key.Contains(type.ToString()) == false)
                {
                    continue;
                }
                ret = key;
                break;
            }
            return(ret);
        }
Ejemplo n.º 12
0
        private void OnBtnFieldAdd(object sender, EventArgs e)
        {
            bool         bName, bFormat;
            CsvFieldType t         = GetCsvFieldType(out bName, out bFormat);
            string       strName   = (bName ? m_tbFieldName.Text : null);
            string       strFormat = (bFormat ? m_cmbFieldFormat.Text : null);

            AddCsvField(t, strName, strFormat);
            ProcessResize();
            for (int i = 0; i < (m_lvFields.Items.Count - 1); ++i)
            {
                m_lvFields.Items[i].Selected = false;
            }
            m_lvFields.EnsureVisible(m_lvFields.Items.Count - 1);
            UIUtil.SetFocusedItem(m_lvFields, m_lvFields.Items[
                                      m_lvFields.Items.Count - 1], true);
        }
Ejemplo n.º 13
0
        object parse(string value, CsvFieldType typeOverridden = CsvFieldType.Unknown)
        {
            object ret = null;

            if (typeOverridden == CsvFieldType.Unknown)
            {
                typeOverridden = this.CsvType;
            }
            switch (typeOverridden)
            {
            case CsvFieldType.DateTime:
                if (this.CsvTypeFormat == FORMAT_VISUALIZE_EMPTY_STRING)
                {
                    ret = DateTime.Parse(value);
                }
                else
                {
                    ret = DateTime.ParseExact(value, this.CsvTypeFormat, CultureInfo.InvariantCulture);
                }
                break;

            case CsvFieldType.Open:
            case CsvFieldType.High:
            case CsvFieldType.Low:
            case CsvFieldType.Close:
            case CsvFieldType.Volume:
                //http://stackoverflow.com/questions/1354924/how-do-i-parse-a-string-with-a-decimal-point-to-a-double
                ret = float.Parse(value);
                break;

            case CsvFieldType.Date:
            case CsvFieldType.Time:
            case CsvFieldType.Unknown:
            case CsvFieldType.Ignore:
            case CsvFieldType.Symbol:
            case CsvFieldType.Interval_Min:
            case CsvFieldType.Interval_Hrs:
            case CsvFieldType.Interval_Days:
                break;

            default:
                throw new Exception("CsvTypeParser.parse():\r\nadd handler for [" + typeOverridden + "]");
            }
            return(ret);
        }
Ejemplo n.º 14
0
        public void AddFormatForTypeUnique(string selectedFormat, CsvFieldType csvFieldType)
        {
            string storedUnderKey = this.GetAppropriateFormatKeyForType(csvFieldType);

            if (storedUnderKey == null)
            {
                //throw new Exception("CANT_GUESS_KEY_FOR_FORMATS_AVAILABLE_FOR_TYPE dataSnapshot.GetAppropriateFormatKeyForType(" + iCatcherEdited.Parser.CsvType + ")=null");
                storedUnderKey = csvFieldType.ToString();
                this.CsvFieldTypeFormatsAvailable.Add(storedUnderKey, new List <string>());
            }
            List <string> typeFormats = this.CsvFieldTypeFormatsAvailable[storedUnderKey];

            if (typeFormats.Contains(selectedFormat) == false)
            {
                typeFormats.Add(selectedFormat);
                typeFormats.Sort();
            }
        }
Ejemplo n.º 15
0
        private CsvFieldType GetCsvFieldType(out bool bName, out bool bFormat)
        {
            int i = m_cmbFieldType.SelectedIndex;

            if ((i < (int)CsvFieldType.First) || (i >= (int)CsvFieldType.Count))
            {
                Debug.Assert(false);
                bName   = false;
                bFormat = false;
                return(CsvFieldType.Ignore);
            }

            CsvFieldType t = (CsvFieldType)i;

            bName   = (t == CsvFieldType.CustomString);
            bFormat = (IsTimeField(t) || (t == CsvFieldType.Group));
            return(t);
        }
Ejemplo n.º 16
0
        private CsvFieldType GetCsvFieldType(out bool bName, out bool bFormat)
        {
            int i = m_cmbFieldType.SelectedIndex;

            if ((i < (int)CsvFieldType.First) || (i >= (int)CsvFieldType.Count))
            {
                Debug.Assert(false);
                bName   = false;
                bFormat = false;
                return(CsvFieldType.Ignore);
            }

            CsvFieldType t = (CsvFieldType)i;

            bName   = (t == CsvFieldType.CustomString);
            bFormat = ((t == CsvFieldType.CreationTime) || (t == CsvFieldType.LastAccessTime) ||
                       (t == CsvFieldType.LastModTime) || (t == CsvFieldType.ExpiryTime));
            return(t);
        }
Ejemplo n.º 17
0
        public bool IsValueValid(CsvFieldType fieldType)
        {
            switch (fieldType)
            {
            case CsvFieldType.DateTime:     return(this.DateTime != DateTime.MinValue);

            case CsvFieldType.Open:                 return(this.Open > 0);

            case CsvFieldType.High:                 return(this.High > 0);

            case CsvFieldType.Low:                  return(this.Low > 0);

            case CsvFieldType.Close:                return(this.Close > 0);

            case CsvFieldType.Volume:               return(this.Volume > -1);

            default:
                return(true);
            }
        }
		public object AspectGetterParsedRaw(object shouldBeListOfStrings) {
			List<string> pi = shouldBeListOfStrings as List<string>;
			if (pi == null) {
				Assembler.PopupException("shouldBeListOfStrings is not List<string>");
				this.Parser.CsvType = this.CsvTypeContentSuggested = CsvFieldType.Ignore;
				return "NOT_LIST<STRING>";
			}
			if (pi.Count == 0) {
				Assembler.PopupException("shouldBeListOfStrings.Count=0");
				this.Parser.CsvType = this.CsvTypeContentSuggested = CsvFieldType.Ignore;
				return "LIST<STRING>.COUNT=0";
			}
			try {
				var ret = pi[this.ColumnSerno];
				//this.guessCsvFieldType(ret);
				return ret;
			} catch (Exception ex) {
				this.Parser.CsvType = this.CsvTypeContentSuggested = CsvFieldType.Ignore;
				return "OUT_OF_BOUNDARY";
			}
		}
Ejemplo n.º 19
0
        private void OnFieldFormatLinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            CsvFieldType t = GetCsvFieldType();

            string strUrl = null;

            if (IsTimeField(t))
            {
                strUrl = "https://msdn.microsoft.com/en-us/library/8kb3ddd4.aspx";
            }
            // else if(t == CsvFieldType.Group)
            // {
            //	AppHelp.ShowHelp(AppDefs.HelpTopics.ImportExport,
            //		AppDefs.HelpTopics.ImportExportGenericCsv);
            //	return;
            // }
            else
            {
                Debug.Assert(false); return;
            }

            WinUtil.OpenUrl(strUrl, null);
        }
		object parse(string value, CsvFieldType typeOverridden = CsvFieldType.Unknown) {
			object ret = null;
			
			if (typeOverridden == CsvFieldType.Unknown) typeOverridden = this.CsvType;
			switch(typeOverridden) {
				case CsvFieldType.DateTime:
					if (this.CsvTypeFormat == FORMAT_VISUALIZE_EMPTY_STRING) {
						ret = DateTime.Parse(value);
					} else {
						ret = DateTime.ParseExact(value, this.CsvTypeFormat, CultureInfo.InvariantCulture);
					}
					break;
					
				case CsvFieldType.Open:
				case CsvFieldType.High:
				case CsvFieldType.Low:
				case CsvFieldType.Close:
				case CsvFieldType.Volume:
					//http://stackoverflow.com/questions/1354924/how-do-i-parse-a-string-with-a-decimal-point-to-a-double
					ret	= float.Parse(value);
					break;

				case CsvFieldType.Date:
				case CsvFieldType.Time:
				case CsvFieldType.Unknown:
				case CsvFieldType.Ignore:
				case CsvFieldType.Symbol:
				case CsvFieldType.Interval_Min:
				case CsvFieldType.Interval_Hrs:
				case CsvFieldType.Interval_Days:
					break;

				default:
					throw new Exception("CsvTypeParser.parse():\r\nadd handler for [" + typeOverridden + "]");
			}
			return ret;
		}
Ejemplo n.º 21
0
        private void OnFieldFormatLinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            CsvFieldType t = GetCsvFieldType();

            string strUrl = null;

            if (IsTimeField(t))
            {
                strUrl = @"http://msdn.microsoft.com/en-us/library/8kb3ddd4.aspx";
            }
            // else if(t == CsvFieldType.Group)
            // {
            //	AppHelp.ShowHelp(AppDefs.HelpTopics.ImportExport,
            //		AppDefs.HelpTopics.ImportExportGenericCsv);
            //	return;
            // }
            else
            {
                Debug.Assert(false); return;
            }

            try { Process.Start(strUrl); }
            catch (Exception ex) { MessageService.ShowWarning(strUrl, ex.Message); }
        }
Ejemplo n.º 22
0
        public void AbsorbOneValueFromStringThrows(object value, CsvFieldType fieldType)
        {
            if (value == null)
            {
                throw new Exception("CsvBar.AbsorbOneValueFromStringThrows(): don't make me absorb value=NULL");
            }
            switch (fieldType)
            {
            case CsvFieldType.DateTime:     DateTime = (DateTime)value;  break;

            case CsvFieldType.Date:                 DateAsString = (string)value;  break;

            case CsvFieldType.Time:                 TimeAsString = (string)value;  break;

            case CsvFieldType.Open:                 Open = (float)value;  break;

            case CsvFieldType.High:                 High = (float)value;  break;

            case CsvFieldType.Low:                  Low = (float)value;  break;

            case CsvFieldType.Close:                Close = (float)value;  break;

            case CsvFieldType.Volume:               Volume = (float)value;  break;

            case CsvFieldType.Unknown:
            case CsvFieldType.Ignore:
            case CsvFieldType.Symbol:
            case CsvFieldType.Interval_Min:
            case CsvFieldType.Interval_Hrs:
            case CsvFieldType.Interval_Days:
                break;

            default:
                throw new Exception("CsvBar.AbsorbOneValueFromString():\r\nadd handler for [" + fieldType + "]");
            }
        }
		public void AddFormatForTypeUnique(string selectedFormat, CsvFieldType csvFieldType) {
			string storedUnderKey = this.GetAppropriateFormatKeyForType(csvFieldType);
			if (storedUnderKey == null) {
				//throw new Exception("CANT_GUESS_KEY_FOR_FORMATS_AVAILABLE_FOR_TYPE dataSnapshot.GetAppropriateFormatKeyForType(" + iCatcherEdited.Parser.CsvType + ")=null");
				storedUnderKey = csvFieldType.ToString();
				this.CsvFieldTypeFormatsAvailable.Add(storedUnderKey, new List<string>());
			}
			List<string> typeFormats = this.CsvFieldTypeFormatsAvailable[storedUnderKey];
			if (typeFormats.Contains(selectedFormat) == false) {
				typeFormats.Add(selectedFormat);
				typeFormats.Sort();
			}
		}
Ejemplo n.º 24
0
 public CsvTypeParser()
 {
     this.CsvType       = CsvFieldType.Unknown;
     this.CsvTypeFormat = "";
 }
Ejemplo n.º 25
0
        private void EnableControlsEx()
        {
            if (m_bInitializing)
            {
                return;
            }

            List <CsvFieldInfo> lFields = GetCsvFieldInfos();

            bool bSelField  = (m_lvFields.SelectedIndices.Count >= 1);
            bool bSel1Field = (m_lvFields.SelectedIndices.Count == 1);

            m_btnFieldDel.Enabled      = bSelField;
            m_btnFieldMoveUp.Enabled   = bSel1Field;
            m_btnFieldMoveDown.Enabled = bSel1Field;

            bool         bFieldName, bFieldFormat;
            CsvFieldType t = GetCsvFieldType(out bFieldName, out bFieldFormat);

            m_lblFieldName.Enabled    = bFieldName;
            m_tbFieldName.Enabled     = bFieldName;
            m_lblFieldFormat.Enabled  = bFieldFormat;
            m_cmbFieldFormat.Enabled  = bFieldFormat;
            m_linkFieldFormat.Enabled = IsTimeField(t);

            int iTab = m_tabMain.SelectedIndex, nTabs = m_tabMain.TabCount;

            m_btnTabBack.Enabled = (iTab > 0);
            m_btnTabNext.Enabled = (iTab < (nTabs - 1));

            bool bValidFieldSep = (GetCharFromDef(m_cmbFieldSep.Text) != char.MinValue);
            bool bValidRecSep   = (GetCharFromDef(m_cmbRecSep.Text) != char.MinValue);
            bool bValidTextQual = (GetCharFromDef(m_cmbTextQual.Text) != char.MinValue);

            if (bValidFieldSep)
            {
                m_cmbFieldSep.ResetBackColor();
            }
            else
            {
                m_cmbFieldSep.BackColor = AppDefs.ColorEditError;
            }
            if (bValidRecSep)
            {
                m_cmbRecSep.ResetBackColor();
            }
            else
            {
                m_cmbRecSep.BackColor = AppDefs.ColorEditError;
            }
            if (bValidTextQual)
            {
                m_cmbTextQual.ResetBackColor();
            }
            else
            {
                m_cmbTextQual.BackColor = AppDefs.ColorEditError;
            }

            bool bOK = true;

            bOK            &= (iTab == (nTabs - 1));
            bOK            &= (bValidFieldSep && bValidRecSep && bValidTextQual);
            m_btnOK.Enabled = bOK;

            if (t != m_tLastCsvType)
            {
                m_cmbFieldFormat.Items.Clear();

                string[] vItems;
                if (IsTimeField(t))
                {
                    vItems = new string[] {
                        string.Empty,
                        @"yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffzz",
                        @"ddd, dd MMM yyyy HH':'mm':'ss 'GMT'", @"yyyy'-'MM'-'dd'T'HH':'mm':'ss",
                        @"yyyy'-'MM'-'dd HH':'mm':'ss'Z'",
                        @"yyyy/MM/dd HH:mm:ss",
                        @"yyyy/MM/dd", @"MM/dd/yy", @"MMMM dd, yyyy", @"MM/dd/yy H:mm:ss zzz"
                    }
                }
                ;
                else if (t == CsvFieldType.Group)
                {
                    vItems = new string[] { string.Empty, ".", "/", "\\" }
                }
                ;
                else
                {
                    vItems = new string[0];
                }

                foreach (string strPre in vItems)
                {
                    m_cmbFieldFormat.Items.Add(strPre);
                }

                if (t == CsvFieldType.Group)
                {
                    UIUtil.SetText(m_lblFieldFormat, KPRes.Separator + ":");
                }
                else
                {
                    UIUtil.SetText(m_lblFieldFormat, KPRes.Format + ":");
                }
            }
            m_tLastCsvType = t;

            bool bHasGroup = false;

            foreach (CsvFieldInfo cfi in lFields)
            {
                if (cfi.Type == CsvFieldType.Group)
                {
                    bHasGroup = true; break;
                }
            }
            if (!bHasGroup)
            {
                m_cbMergeGroups.Checked = false;
            }
            m_cbMergeGroups.Enabled = bHasGroup;
        }
Ejemplo n.º 26
0
 private static bool IsTimeField(CsvFieldType t)
 {
     return((t == CsvFieldType.CreationTime) ||
            // (t == CsvFieldType.LastAccessTime) ||
            (t == CsvFieldType.LastModTime) || (t == CsvFieldType.ExpiryTime));
 }
Ejemplo n.º 27
0
 public CsvFieldInfo(CsvFieldType t, string strName, string strFormat)
 {
     m_t = t;
     m_strName = strName; // May be null
     m_strFormat = strFormat; // May be null
 }
Ejemplo n.º 28
0
        private void EnableControlsEx()
        {
            if(m_bInitializing) return;

            List<CsvFieldInfo> lFields = GetCsvFieldInfos();

            bool bSelField = (m_lvFields.SelectedIndices.Count >= 1);
            bool bSel1Field = (m_lvFields.SelectedIndices.Count == 1);
            m_btnFieldDel.Enabled = bSelField;
            m_btnFieldMoveUp.Enabled = bSel1Field;
            m_btnFieldMoveDown.Enabled = bSel1Field;

            bool bFieldName, bFieldFormat;
            CsvFieldType t = GetCsvFieldType(out bFieldName, out bFieldFormat);
            m_lblFieldName.Enabled = bFieldName;
            m_tbFieldName.Enabled = bFieldName;
            m_lblFieldFormat.Enabled = bFieldFormat;
            m_cmbFieldFormat.Enabled = bFieldFormat;
            m_linkFieldFormat.Enabled = IsTimeField(t);

            int iTab = m_tabMain.SelectedIndex, nTabs = m_tabMain.TabCount;
            m_btnTabBack.Enabled = (iTab > 0);
            m_btnTabNext.Enabled = (iTab < (nTabs - 1));

            bool bValidFieldSep = (GetCharFromDef(m_cmbFieldSep.Text) != char.MinValue);
            bool bValidRecSep = (GetCharFromDef(m_cmbRecSep.Text) != char.MinValue);
            bool bValidTextQual = (GetCharFromDef(m_cmbTextQual.Text) != char.MinValue);

            if(bValidFieldSep) m_cmbFieldSep.ResetBackColor();
            else m_cmbFieldSep.BackColor = AppDefs.ColorEditError;
            if(bValidRecSep) m_cmbRecSep.ResetBackColor();
            else m_cmbRecSep.BackColor = AppDefs.ColorEditError;
            if(bValidTextQual) m_cmbTextQual.ResetBackColor();
            else m_cmbTextQual.BackColor = AppDefs.ColorEditError;

            bool bOK = true;
            bOK &= (iTab == (nTabs - 1));
            bOK &= (bValidFieldSep && bValidRecSep && bValidTextQual);
            m_btnOK.Enabled = bOK;

            if(t != m_tLastCsvType)
            {
                m_cmbFieldFormat.Items.Clear();

                string[] vItems;
                if(IsTimeField(t))
                    vItems = new string[] {
                        string.Empty,
                        @"yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffzz",
                        @"ddd, dd MMM yyyy HH':'mm':'ss 'GMT'", @"yyyy'-'MM'-'dd'T'HH':'mm':'ss",
                        @"yyyy'-'MM'-'dd HH':'mm':'ss'Z'",
                        @"yyyy/MM/dd HH:mm:ss",
                        @"yyyy/MM/dd", @"MM/dd/yy", @"MMMM dd, yyyy", @"MM/dd/yy H:mm:ss zzz"
                    };
                else if(t == CsvFieldType.Group)
                    vItems = new string[] { string.Empty, ".", "/", "\\" };
                else vItems = new string[0];

                foreach(string strPre in vItems)
                    m_cmbFieldFormat.Items.Add(strPre);

                if(t == CsvFieldType.Group)
                    m_lblFieldFormat.Text = KPRes.Separator + ":";
                else m_lblFieldFormat.Text = KPRes.Format + ":";
            }
            m_tLastCsvType = t;

            bool bHasGroup = false;
            foreach(CsvFieldInfo cfi in lFields)
            {
                if(cfi.Type == CsvFieldType.Group) { bHasGroup = true; break; }
            }
            if(!bHasGroup) m_cbMergeGroups.Checked = false;
            m_cbMergeGroups.Enabled = bHasGroup;
        }
Ejemplo n.º 29
0
        private void AddCsvField(CsvFieldType t, string strName, string strFormat)
        {
            string strText = CsvFieldToString(t);

            string strSub = string.Empty;
            if(strName != null) strSub += strName;
            if(!string.IsNullOrEmpty(strFormat))
            {
                if(strSub.Length > 0) strSub += ", ";
                strSub += strFormat;
            }

            if(strSub.Length > 0) strText += " (" + strSub + ")";

            ListViewItem lvi = m_lvFields.Items.Add(strText);
            lvi.Tag = new CsvFieldInfo(t, strName, strFormat);
        }
Ejemplo n.º 30
0
 private static bool IsTimeField(CsvFieldType t)
 {
     return ((t == CsvFieldType.CreationTime) ||
         // (t == CsvFieldType.LastAccessTime) ||
         (t == CsvFieldType.LastModTime) || (t == CsvFieldType.ExpiryTime));
 }
Ejemplo n.º 31
0
        private static string CsvFieldToString(CsvFieldType t)
        {
            string strText;
            if(t == CsvFieldType.Ignore) strText = "(" + KPRes.Ignore + ")";
            else if(t == CsvFieldType.Group) strText = KPRes.Group;
            else if(t == CsvFieldType.Title) strText = KPRes.Title;
            else if(t == CsvFieldType.UserName) strText = KPRes.UserName;
            else if(t == CsvFieldType.Password) strText = KPRes.Password;
            else if(t == CsvFieldType.Url) strText = KPRes.Url;
            else if(t == CsvFieldType.Notes) strText = KPRes.Notes;
            else if(t == CsvFieldType.CustomString)
                strText = KPRes.String;
            else if(t == CsvFieldType.CreationTime)
                strText = KPRes.CreationTime;
            // else if(t == CsvFieldType.LastAccessTime)
            //	strText = KPRes.LastAccessTime;
            else if(t == CsvFieldType.LastModTime)
                strText = KPRes.LastModificationTime;
            else if(t == CsvFieldType.ExpiryTime)
                strText = KPRes.ExpiryTime;
            else if(t == CsvFieldType.Tags)
                strText = KPRes.Tags;
            else { Debug.Assert(false); strText = KPRes.Unknown; }

            return strText;
        }
Ejemplo n.º 32
0
 public CsvFieldInfo(CsvFieldType t, string strName, string strFormat)
 {
     m_t         = t;
     m_strName   = strName;               // May be null
     m_strFormat = strFormat;             // May be null
 }
		public CsvTypeParser() {
			this.CsvType = CsvFieldType.Unknown;
			this.CsvTypeFormat = "";
		}