trunk/xmltv_parser/main.cs

#define DISABLE_RELEASE_MODE_KLOGLEVEL_DEBUG // when defined will turn off kLogLevel_Debug messages, in release mode
//#define DISABLE_DEBUG_MODE_KLOGLEVEL_VERBOSE_DEBUG // when defined will turn off kLogLevel_VerboseDebug message, in debug mode
//#define USE_DYNAMIC_SORTING_FILTERING_CONTROLS // when defined will setup dynamic sorting and filtering controls for XMLTV Data
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using libxmltv.Core;
using Enterprise.Logging;
using libxmltv.Interfaces;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Threading;
using System.Diagnostics;
using System.Xml.Linq;

namespace xmltv_parser
{

    public partial class main : Form
    {
        public main()
        {
            InitializeComponent();
            ListViewSorter Sorter = new ListViewSorter();
            //lstPrograms.ListViewItemSorter = Sorter;
            string log_path = Application.StartupPath;
            string log_filename = string.Format("{0}.log", typeof(main).Assembly.GetName().Name);
            gLog.CreateLog(string.Format(@"{0}\{1}", log_path, log_filename), false, LogLevel.kLogLevel_All_NoProgress, new EventHandler<LoggerOnFlushEventArgs>(Log_OnFlush));
#if DEBUG
            LogLevel gLevel = gLog.LogLevel;
#if DISABLE_DEBUG_MODE_KLOGLEVEL_VERBOSE_DEBUG
            gLevel &= ~LogLevel.kLogLevel_VerboseDebug;
#else
            gLevel |= LogLevel.kLogLevel_VerboseDebug;
#endif
            gLevel |= LogLevel.kLogLevel_Debug;
            gLog.SetLogLevel(gLevel);
#else
            LogLevel gLevel = LogLevel.kLogLevel_Default; // set the default log level: Info, Warn, Error, Debug
            // it is OK for kLogLevel_Debug to be set in Release mode ... must of the chatty messages are from kLogLevel_VerboseDebug
#if DISABLE_RELEASE_MODE_KLOGLEVEL_DEBUG
            gLevel &= ~LogLevel.kLogLevel_Debug;
#else
            gLevel |= LogLevel.kLogLevel_Debug;
#endif
            gLevel &= ~LogLevel.kLogLevel_VerboseDebug; // ensure this is not set, ever in release mode         
            gLog.SetLogLevel(gLevel);
#endif


            gLog.ReportProgressEvent += new EventHandler<ReportProgressEventArgs>(gLog_ReportProgress);
        }
        #region main form events
        private void mnuItemExit_Click(object sender, EventArgs e) { this.Close(); }
        private void main_Load(object sender, EventArgs e) { }
        private void main_Shown(object sender, EventArgs e) { }
        private void mnuItemOpenXMLTVFile_Click(object sender, EventArgs e)
        {
            try
            {
                var result = xmltv_file_chooser.ShowDialog();
                if (result != DialogResult.OK) return;
                ClearLocalLog();
                LoadXMLTVShcedule(xmltv_file_chooser.FileName);
            }
            catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
        }
        private void mnuItemOpenSavedData_Click(object sender, EventArgs e)
        {
            try
            {
                var result = xmltv_program_data_loader.ShowDialog();
                if (result != DialogResult.OK) return;
                string filename = xmltv_program_data_loader.FileName;
                Thread worker = new Thread(new ParameterizedThreadStart(DeserializeDataFromFile)); worker.Start(filename);
            }
            catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
        }
        private void mnuItemSaveData_Click(object sender, EventArgs e)
        {
            try
            {
                var result = xmltv_program_data_saver.ShowDialog();
                if (result != DialogResult.OK) return;
                string filename = xmltv_program_data_saver.FileName;
                Thread worker = new Thread(new ParameterizedThreadStart(DeserializeDataToFile)); worker.Start(filename);
            }
            catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
        }
        private void main_FormClosing(object sender, FormClosingEventArgs e) { try { XMLTV.Destroy(); } catch { } }
        private void mnuItemClearLocalLog_Click(object sender, EventArgs e) { ClearLocalLog(); }
        #endregion

        private void ReportProgress(int progress)
        {
            if (this.InvokeRequired)
            {
                try { this.Invoke((Action)(delegate { ReportProgress(progress); })); }
                catch { }
                return;
            }
            if (progress_status != null && !this.IsDisposed)
                progress_status.Value = progress;
        }

        #region gLog Events
        private void gLog_ReportProgress(object sender, ReportProgressEventArgs e) { ReportProgress(e.Progress); }
        #endregion
        #region XMLT Events
        void XMLTV_OnInstanceCreated(object sender, EventArgs e) { ReportProgress(0); CreateControls(); }
        void LoadXMLTVShcedule(string schedule_xml) { XMLTV.Create(schedule_xml, new EventHandler<EventArgs>(XMLTV_OnInstanceCreated)); }
        #endregion


        #region Logging Events
        StringBuilder log_flusher = new StringBuilder();
        void Log_OnFlush(object sender, LoggerOnFlushEventArgs e) { OnLogFlush(e.Buffer); }
        void OnLogFlush(string logmessage)
        {
            if (this.IsDisposed) { return; }
            UpdateStatus(logmessage);
            UpdateLogOutput(logmessage);
            Application.DoEvents();
        }
        private void ClearLocalLog()
        {
            var log_top_entry = txtLog.Lines.FirstOrDefault();
            txtLog.Clear();
            if (!string.IsNullOrEmpty(log_top_entry)) { txtLog.AppendText(log_top_entry); }
        }
        void UpdateStatus(string logmessage)
        {
            try
            {
                if (this.InvokeRequired)
                {
                    try { this.Invoke((Action)(delegate { UpdateStatus(logmessage); })); }
                    catch { }
                    return;
                }
                txtStatus.Text = logmessage.Replace(System.Environment.NewLine, "");
            }
            catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
        }
        void UpdateLogOutput(string logmessage)
        {
            try
            {
                if (this.InvokeRequired)
                {
                    try { this.Invoke((Action)(delegate { UpdateLogOutput(logmessage); })); }
                    catch { }
                    return;
                }
                txtLog.AppendText(logmessage);
                txtLog.SelectionStart = txtLog.Text.Length; //Set the current caret position to the end
                txtLog.ScrollToCaret(); //Now scroll it automatically
            }
            catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
        }
        #endregion

        #region Binary Data Read/Write support
        private void DeserializeDataFromFile(object filename)
        {
            if (filename == null) { throw new ArgumentNullException("filename", "cannot be null"); }
            XMLTV.Load(filename.ToString(), new EventHandler<EventArgs>(XMLTV_OnInstanceCreated));
        }
        private void DeserializeDataToFile(object filename)
        {
            if (filename == null) { throw new ArgumentNullException("filename", "cannot be null"); }
            XMLTV.Save(filename.ToString());
        }
        #endregion


        #region CreateControls
        void AutoResizeDataGridView()
        {
            //dataGrid.AutoResizeRow(2, DataGridViewAutoSizeRowMode.AllCellsExceptHeader);
        
            for (int i = 0; i < dataGrid.ColumnCount; i++)
            {
                dataGrid.Columns[i].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
            }
            //for (int i = 0; i < dataGrid.RowCount; i++)
            //{
            //    dataGrid.AutoResizeRow(i, DataGridViewAutoSizeRowMode.AllCellsExceptHeader);
            //}
        }
        void CreateControls()
        {
            try
            {
                if (this.InvokeRequired)
                {
                    try { this.Invoke((Action)(delegate { CreateControls(); })); }
                    catch { }
                    return;
                }
                Type data_type;
                object datasource = XMLTV.CreateBindingSourceFromData(XMLTV.GetPrograms(), out data_type);
                CreatControlsFromType(data_type);                
                dataGrid.DataSource = datasource;
                AutoResizeDataGridView();
                flow_datagrid_sort.Enabled = true;
                btnSort.PerformClick();
            }
            catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
        }


        void CreatControlsFromType(Type data_type)
        {
#if USE_DYNAMIC_SORTING_FILTERING_CONTROLS
              _CreatControlsFromType(data_type);
#else
            gLog.Verbose.Warn.WriteLine("Dynamic creation of sorting and filtering controls has not been enabled.");
            gLog.Verbose.Warn.WriteLine("To enable: #define USE_DYNAMIC_SORTING_FILTERING_CONTROLS");
#endif
        }
        [Conditional("USE_DYNAMIC_SORTING_FILTERING_CONTROLS")]
        void _CreatControlsFromType(Type data_type)
        {
            string strType = data_type.Name;
            switch (strType)
            {
                case "IChannelDefintionList": CreateChannelDefinitionControls(data_type); break;
                case "IProgramDefinitionList": CreateProgramDefinitionControls(data_type); break;
                case "IXMLTVSource": CreateSourceDefinitionControls(data_type); break;
                default: CreateDefaultControls(data_type); break;
            }
        }
        [Conditional("USE_DYNAMIC_SORTING_FILTERING_CONTROLS")]
        void CreateDefaultControls(Type data_type)
        {
            // no default controls
            gLog.Verbose.Warn.WriteLine("No controls have been defined for: {0}", data_type.Name);
        }
        [Conditional("USE_DYNAMIC_SORTING_FILTERING_CONTROLS")]
        void CreateSourceDefinitionControls(Type data_type)
        {
            // no controls needed
            gLog.Verbose.Warn.WriteLine("No controls have been defined for: {0}", data_type.Name);
        }
        [Conditional("USE_DYNAMIC_SORTING_FILTERING_CONTROLS")]
        void CreateChannelDefinitionControls(Type data_type)
        {
            gLog.Verbose.Warn.WriteLine("No controls have been defined for: {0}", data_type.Name);
        }
        [Conditional("USE_DYNAMIC_SORTING_FILTERING_CONTROLS")]
        void CreateProgramDefinitionControls(Type data_type)
        {
            gLog.Verbose.Warn.WriteLine("No controls have been defined for: {0}", data_type.Name);
        }
        #endregion

        #region Program Entry Display        
        private int CurrentRowIndex = -1;
        void DisplaySelectedProgramEntry(DataGridViewRow row)
        {
            int RowIndex = row.Index; // this is the index in the list

            //if (CurrentRowIndex == -1) { AlreadyDisplayedProgramEntryForIndex = false; CurrentRowIndex = RowIndex; }
            //if (CurrentRowIndex == RowIndex && AlreadyDisplayedProgramEntryForIndex) { 
            bool DoDisplay = false;
            if (CurrentRowIndex == -1)
            {
                DoDisplay = true;
            }
            if (CurrentRowIndex == RowIndex)
            {
                DoDisplay = false;
            }
            else
            {
                DoDisplay = true;
            }

            if (DoDisplay)
            {
                 CurrentRowIndex = RowIndex;
                List<IProgramDefinition> list = (dataGrid.DataSource as List<IProgramDefinition>);
                if (list == null)
                {
                    gLog.Warn.WriteLine("Unable to display program entry for rowindex: {0}", RowIndex);
                   
                    return;
                }
                try
                {
                    IProgramDefinition program = list[RowIndex];
                    ProgramEntryControl c = new ProgramEntryControl(program);
                    c.Dock = DockStyle.Fill;
                    split_bottom.Panel2.Controls.Clear();
                    split_bottom.Panel2.Controls.Add(c);                    
                }
                catch (Exception ex)
                {
                    gLog.Error.WriteLine(ex.ToString());
                }
            }
        }
        #endregion
        #region Datasource support / events
        private void dataGrid_SelectionChanged(object sender, EventArgs e)
        {
            try
            {
                DataGridView dgv = (DataGridView)sender;
                //var row = dgv.SelectedRows[0]; // the row that was selected
                //var cell = dgv.SelectedCells[0];
                DataGridViewRow row = null;
                string data = string.Empty;
                if (dgv.SelectedCells.Count > 0)
                {
                    var cell = dgv.SelectedCells[0];
                    row = dgv.Rows[cell.RowIndex];
                }
                if (dgv.SelectedRows.Count > 0)
                {
                    row = dgv.SelectedRows[0];
                }

                if (row != null)
                {
                    RadioButton button = GetSelectedFilteringControl();
                    int index = GetColumnIndexForRadioButton(button);
                    data = row.Cells[index].Value.ToString();
                    txtFilterText.Text = data;
                    DisplaySelectedProgramEntry(row);
                }
            }
            catch (Exception ex)
            {
                gLog.Verbose.Error.WriteLine(ex.ToString());
            }
        }
        private int GetColumnIndexForRadioButton(RadioButton radio) { return GetColumnIndex(radio.Tag as string); }
        private int GetColumnIndex(string columnname)
        {
            int index =0;
            Type t = typeof(IProgramDefinition);

            var props = t.GetProperties();
            foreach (var prop in props)
            {
                if (prop.Name.ToLower() == columnname.ToLower()) { break; }
                index++;
            }
            return index;
        }
        #endregion
        #region Reset event
        private void btnResetSort_Click(object sender, EventArgs e)
        {
            Type data_type;
            object datasource = XMLTV.CreateBindingSourceFromData(XMLTV.GetPrograms(), out data_type);
            dataGrid.DataSource = datasource;
            ToggleDescedning();
        }
        #endregion
        #region Filtering events
        private void FilterByColumn(RadioButton button)
        {
            Type data_type;
            string column = (button.Tag as string);
            object data = XMLTV.CreateBindingSourceFromData(XMLTV.GetPrograms(), out data_type);
            XMLTV.CreateFilterFromDataSource(ref data, column, txtFilterText.Text);
            dataGrid.DataSource = data;
        }
        private RadioButton GetSelectedFilteringControl()
        {
            bool control_selected = false;
            RadioButton button = new RadioButton();
            foreach (var c in grpFilter_flow.Controls)
            {
                button = (c as RadioButton);
                if (button != null) { if (button.Checked) { control_selected = true; break; } }
                else { continue; }
            }
            if (!control_selected)
            {
                gLog.Verbose.Warn.WriteLine("Unkown filter value used.  Was not: channelname, title, subtitle, description, start, or stop.");
                //throw new InvalidOperationException("No filtering control is currently selected.");
                return button;
            }
            else { return button; }
        }
        private void UpdateFilterText(RadioButton radio, DataGridView dgv)
        {
            if (radio.Checked)
            {
                int cellindex = GetColumnIndexForRadioButton(radio);
                string t = radio.Tag as string;
                DataGridViewRow row = null;
                string data = string.Empty;
                if (dgv.SelectedCells.Count > 0)
                {
                    var cell = dgv.SelectedCells[0];
                    row = dgv.Rows[cell.RowIndex];
                }
                if (dgv.SelectedRows.Count > 0)
                {
                    row = dgv.SelectedRows[0];
                }
                data = row.Cells[cellindex].Value.ToString();
                txtFilterText.Text = data;
            }
        }
        private void btnFilter_Click(object sender, EventArgs e)
        {
            RadioButton button = GetSelectedFilteringControl();
            FilterByColumn(button);
        }
        private void radio_filter_channelnumber_CheckedChanged(object sender, EventArgs e)
        {
            RadioButton radio = (sender as RadioButton);
            UpdateFilterText(radio, dataGrid);
        }
        private void radio_filter_title_CheckedChanged(object sender, EventArgs e)
        {
            RadioButton radio = (sender as RadioButton);
            UpdateFilterText(radio, dataGrid);
        }
        private void radio_filter_subtitle_CheckedChanged(object sender, EventArgs e)
        {
            RadioButton radio = (sender as RadioButton);
            UpdateFilterText(radio, dataGrid);
        }
        private void radio_filter_description_CheckedChanged(object sender, EventArgs e)
        {
            RadioButton radio = (sender as RadioButton);
            UpdateFilterText(radio, dataGrid);
        }
        private void radio_filter_channelname_CheckedChanged(object sender, EventArgs e)
        {
            RadioButton radio = (sender as RadioButton);
            UpdateFilterText(radio, dataGrid);
        }
        private void radio_filter_start_CheckedChanged(object sender, EventArgs e)
        {
            RadioButton radio = (sender as RadioButton);
            UpdateFilterText(radio, dataGrid);
        }
        private void radio_filter_stop_CheckedChanged(object sender, EventArgs e)
        {
            RadioButton radio = (sender as RadioButton);
            UpdateFilterText(radio, dataGrid);
        }
        #endregion
        #region Sorting events
        private bool Descending = false;
        private void ToggleDescedning() { Descending = Descending ? false : true; }
        private void SortByColumn(RadioButton button)
        {
            string column = (button.Tag as string);
            object data = dataGrid.DataSource;
            XMLTV.CreateSorterFromDataSource(ref data, Descending, column);
            dataGrid.DataSource = data;
            ToggleDescedning();
        }
        private RadioButton GetSelectedSortControl()
        {
            bool control_selected = false;
            RadioButton button = new RadioButton();
            foreach (var c in grpSort_flow.Controls)
            {
                button = (c as RadioButton);
                if (button != null) { if (button.Checked) { control_selected = true; break; } }
                else { continue; }
            }
            if (!control_selected)
            {
                gLog.Warn.WriteLine("Unkown sort value used.  Was not: channelname, title, subtitle, description, stop, or start.");
                //throw new InvalidOperationException("No sorting control is currently selected.");
                return button;
            }
            else { return button; }
        }
        private void btnSort_Click(object sender, EventArgs e)
        {
            RadioButton button = GetSelectedSortControl();
            SortByColumn(button);
        }
        #endregion
    }
}

Revision:	149
Committed:	Thu Mar 14 15:36:22 2013 UTC (9 years, 10 months ago) by william
File size:	20382 byte(s)
Log Message:
#	Content
1	#define DISABLE_RELEASE_MODE_KLOGLEVEL_DEBUG // when defined will turn off kLogLevel_Debug messages, in release mode
2	//#define DISABLE_DEBUG_MODE_KLOGLEVEL_VERBOSE_DEBUG // when defined will turn off kLogLevel_VerboseDebug message, in debug mode
3	//#define USE_DYNAMIC_SORTING_FILTERING_CONTROLS // when defined will setup dynamic sorting and filtering controls for XMLTV Data
4	using System;
5	using System.Collections.Generic;
6	using System.ComponentModel;
7	using System.Data;
8	using System.Linq;
9	using System.Drawing;
10	using System.Text;
11	using System.Windows.Forms;
12	using libxmltv.Core;
13	using Enterprise.Logging;
14	using libxmltv.Interfaces;
15	using System.IO;
16	using System.Runtime.Serialization.Formatters.Binary;
17	using System.Threading;
18	using System.Diagnostics;
19	using System.Xml.Linq;
20
21	namespace xmltv_parser
22	{
23
24	public partial class main : Form
25	{
26	public main()
27	{
28	InitializeComponent();
29	ListViewSorter Sorter = new ListViewSorter();
30	//lstPrograms.ListViewItemSorter = Sorter;
31	string log_path = Application.StartupPath;
32	string log_filename = string.Format("{0}.log", typeof(main).Assembly.GetName().Name);
33	gLog.CreateLog(string.Format(@"{0}\{1}", log_path, log_filename), false, LogLevel.kLogLevel_All_NoProgress, new EventHandler<LoggerOnFlushEventArgs>(Log_OnFlush));
34	#if DEBUG
35	LogLevel gLevel = gLog.LogLevel;
36	#if DISABLE_DEBUG_MODE_KLOGLEVEL_VERBOSE_DEBUG
37	gLevel &= ~LogLevel.kLogLevel_VerboseDebug;
38	#else
39	gLevel \|= LogLevel.kLogLevel_VerboseDebug;
40	#endif
41	gLevel \|= LogLevel.kLogLevel_Debug;
42	gLog.SetLogLevel(gLevel);
43	#else
44	LogLevel gLevel = LogLevel.kLogLevel_Default; // set the default log level: Info, Warn, Error, Debug
45	// it is OK for kLogLevel_Debug to be set in Release mode ... must of the chatty messages are from kLogLevel_VerboseDebug
46	#if DISABLE_RELEASE_MODE_KLOGLEVEL_DEBUG
47	gLevel &= ~LogLevel.kLogLevel_Debug;
48	#else
49	gLevel \|= LogLevel.kLogLevel_Debug;
50	#endif
51	gLevel &= ~LogLevel.kLogLevel_VerboseDebug; // ensure this is not set, ever in release mode
52	gLog.SetLogLevel(gLevel);
53	#endif
54
55
56	gLog.ReportProgressEvent += new EventHandler<ReportProgressEventArgs>(gLog_ReportProgress);
57	}
58	#region main form events
59	private void mnuItemExit_Click(object sender, EventArgs e) { this.Close(); }
60	private void main_Load(object sender, EventArgs e) { }
61	private void main_Shown(object sender, EventArgs e) { }
62	private void mnuItemOpenXMLTVFile_Click(object sender, EventArgs e)
63	{
64	try
65	{
66	var result = xmltv_file_chooser.ShowDialog();
67	if (result != DialogResult.OK) return;
68	ClearLocalLog();
69	LoadXMLTVShcedule(xmltv_file_chooser.FileName);
70	}
71	catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
72	}
73	private void mnuItemOpenSavedData_Click(object sender, EventArgs e)
74	{
75	try
76	{
77	var result = xmltv_program_data_loader.ShowDialog();
78	if (result != DialogResult.OK) return;
79	string filename = xmltv_program_data_loader.FileName;
80	Thread worker = new Thread(new ParameterizedThreadStart(DeserializeDataFromFile)); worker.Start(filename);
81	}
82	catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
83	}
84	private void mnuItemSaveData_Click(object sender, EventArgs e)
85	{
86	try
87	{
88	var result = xmltv_program_data_saver.ShowDialog();
89	if (result != DialogResult.OK) return;
90	string filename = xmltv_program_data_saver.FileName;
91	Thread worker = new Thread(new ParameterizedThreadStart(DeserializeDataToFile)); worker.Start(filename);
92	}
93	catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
94	}
95	private void main_FormClosing(object sender, FormClosingEventArgs e) { try { XMLTV.Destroy(); } catch { } }
96	private void mnuItemClearLocalLog_Click(object sender, EventArgs e) { ClearLocalLog(); }
97	#endregion
98
99	private void ReportProgress(int progress)
100	{
101	if (this.InvokeRequired)
102	{
103	try { this.Invoke((Action)(delegate { ReportProgress(progress); })); }
104	catch { }
105	return;
106	}
107	if (progress_status != null && !this.IsDisposed)
108	progress_status.Value = progress;
109	}
110
111	#region gLog Events
112	private void gLog_ReportProgress(object sender, ReportProgressEventArgs e) { ReportProgress(e.Progress); }
113	#endregion
114	#region XMLT Events
115	void XMLTV_OnInstanceCreated(object sender, EventArgs e) { ReportProgress(0); CreateControls(); }
116	void LoadXMLTVShcedule(string schedule_xml) { XMLTV.Create(schedule_xml, new EventHandler<EventArgs>(XMLTV_OnInstanceCreated)); }
117	#endregion
118
119
120	#region Logging Events
121	StringBuilder log_flusher = new StringBuilder();
122	void Log_OnFlush(object sender, LoggerOnFlushEventArgs e) { OnLogFlush(e.Buffer); }
123	void OnLogFlush(string logmessage)
124	{
125	if (this.IsDisposed) { return; }
126	UpdateStatus(logmessage);
127	UpdateLogOutput(logmessage);
128	Application.DoEvents();
129	}
130	private void ClearLocalLog()
131	{
132	var log_top_entry = txtLog.Lines.FirstOrDefault();
133	txtLog.Clear();
134	if (!string.IsNullOrEmpty(log_top_entry)) { txtLog.AppendText(log_top_entry); }
135	}
136	void UpdateStatus(string logmessage)
137	{
138	try
139	{
140	if (this.InvokeRequired)
141	{
142	try { this.Invoke((Action)(delegate { UpdateStatus(logmessage); })); }
143	catch { }
144	return;
145	}
146	txtStatus.Text = logmessage.Replace(System.Environment.NewLine, "");
147	}
148	catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
149	}
150	void UpdateLogOutput(string logmessage)
151	{
152	try
153	{
154	if (this.InvokeRequired)
155	{
156	try { this.Invoke((Action)(delegate { UpdateLogOutput(logmessage); })); }
157	catch { }
158	return;
159	}
160	txtLog.AppendText(logmessage);
161	txtLog.SelectionStart = txtLog.Text.Length; //Set the current caret position to the end
162	txtLog.ScrollToCaret(); //Now scroll it automatically
163	}
164	catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
165	}
166	#endregion
167
168	#region Binary Data Read/Write support
169	private void DeserializeDataFromFile(object filename)
170	{
171	if (filename == null) { throw new ArgumentNullException("filename", "cannot be null"); }
172	XMLTV.Load(filename.ToString(), new EventHandler<EventArgs>(XMLTV_OnInstanceCreated));
173	}
174	private void DeserializeDataToFile(object filename)
175	{
176	if (filename == null) { throw new ArgumentNullException("filename", "cannot be null"); }
177	XMLTV.Save(filename.ToString());
178	}
179	#endregion
180
181
182	#region CreateControls
183	void AutoResizeDataGridView()
184	{
185	//dataGrid.AutoResizeRow(2, DataGridViewAutoSizeRowMode.AllCellsExceptHeader);
186
187	for (int i = 0; i < dataGrid.ColumnCount; i++)
188	{
189	dataGrid.Columns[i].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
190	}
191	//for (int i = 0; i < dataGrid.RowCount; i++)
192	//{
193	// dataGrid.AutoResizeRow(i, DataGridViewAutoSizeRowMode.AllCellsExceptHeader);
194	//}
195	}
196	void CreateControls()
197	{
198	try
199	{
200	if (this.InvokeRequired)
201	{
202	try { this.Invoke((Action)(delegate { CreateControls(); })); }
203	catch { }
204	return;
205	}
206	Type data_type;
207	object datasource = XMLTV.CreateBindingSourceFromData(XMLTV.GetPrograms(), out data_type);
208	CreatControlsFromType(data_type);
209	dataGrid.DataSource = datasource;
210	AutoResizeDataGridView();
211	flow_datagrid_sort.Enabled = true;
212	btnSort.PerformClick();
213	}
214	catch (Exception ex) { gLog.Error.WriteLine(ex.ToString()); }
215	}
216
217
218	void CreatControlsFromType(Type data_type)
219	{
220	#if USE_DYNAMIC_SORTING_FILTERING_CONTROLS
221	_CreatControlsFromType(data_type);
222	#else
223	gLog.Verbose.Warn.WriteLine("Dynamic creation of sorting and filtering controls has not been enabled.");
224	gLog.Verbose.Warn.WriteLine("To enable: #define USE_DYNAMIC_SORTING_FILTERING_CONTROLS");
225	#endif
226	}
227	[Conditional("USE_DYNAMIC_SORTING_FILTERING_CONTROLS")]
228	void _CreatControlsFromType(Type data_type)
229	{
230	string strType = data_type.Name;
231	switch (strType)
232	{
233	case "IChannelDefintionList": CreateChannelDefinitionControls(data_type); break;
234	case "IProgramDefinitionList": CreateProgramDefinitionControls(data_type); break;
235	case "IXMLTVSource": CreateSourceDefinitionControls(data_type); break;
236	default: CreateDefaultControls(data_type); break;
237	}
238	}
239	[Conditional("USE_DYNAMIC_SORTING_FILTERING_CONTROLS")]
240	void CreateDefaultControls(Type data_type)
241	{
242	// no default controls
243	gLog.Verbose.Warn.WriteLine("No controls have been defined for: {0}", data_type.Name);
244	}
245	[Conditional("USE_DYNAMIC_SORTING_FILTERING_CONTROLS")]
246	void CreateSourceDefinitionControls(Type data_type)
247	{
248	// no controls needed
249	gLog.Verbose.Warn.WriteLine("No controls have been defined for: {0}", data_type.Name);
250	}
251	[Conditional("USE_DYNAMIC_SORTING_FILTERING_CONTROLS")]
252	void CreateChannelDefinitionControls(Type data_type)
253	{
254	gLog.Verbose.Warn.WriteLine("No controls have been defined for: {0}", data_type.Name);
255	}
256	[Conditional("USE_DYNAMIC_SORTING_FILTERING_CONTROLS")]
257	void CreateProgramDefinitionControls(Type data_type)
258	{
259	gLog.Verbose.Warn.WriteLine("No controls have been defined for: {0}", data_type.Name);
260	}
261	#endregion
262
263	#region Program Entry Display
264	private int CurrentRowIndex = -1;
265	void DisplaySelectedProgramEntry(DataGridViewRow row)
266	{
267	int RowIndex = row.Index; // this is the index in the list
268
269	//if (CurrentRowIndex == -1) { AlreadyDisplayedProgramEntryForIndex = false; CurrentRowIndex = RowIndex; }
270	//if (CurrentRowIndex == RowIndex && AlreadyDisplayedProgramEntryForIndex) {
271	bool DoDisplay = false;
272	if (CurrentRowIndex == -1)
273	{
274	DoDisplay = true;
275	}
276	if (CurrentRowIndex == RowIndex)
277	{
278	DoDisplay = false;
279	}
280	else
281	{
282	DoDisplay = true;
283	}
284
285	if (DoDisplay)
286	{
287	CurrentRowIndex = RowIndex;
288	List<IProgramDefinition> list = (dataGrid.DataSource as List<IProgramDefinition>);
289	if (list == null)
290	{
291	gLog.Warn.WriteLine("Unable to display program entry for rowindex: {0}", RowIndex);
292
293	return;
294	}
295	try
296	{
297	IProgramDefinition program = list[RowIndex];
298	ProgramEntryControl c = new ProgramEntryControl(program);
299	c.Dock = DockStyle.Fill;
300	split_bottom.Panel2.Controls.Clear();
301	split_bottom.Panel2.Controls.Add(c);
302	}
303	catch (Exception ex)
304	{
305	gLog.Error.WriteLine(ex.ToString());
306	}
307	}
308	}
309	#endregion
310	#region Datasource support / events
311	private void dataGrid_SelectionChanged(object sender, EventArgs e)
312	{
313	try
314	{
315	DataGridView dgv = (DataGridView)sender;
316	//var row = dgv.SelectedRows[0]; // the row that was selected
317	//var cell = dgv.SelectedCells[0];
318	DataGridViewRow row = null;
319	string data = string.Empty;
320	if (dgv.SelectedCells.Count > 0)
321	{
322	var cell = dgv.SelectedCells[0];
323	row = dgv.Rows[cell.RowIndex];
324	}
325	if (dgv.SelectedRows.Count > 0)
326	{
327	row = dgv.SelectedRows[0];
328	}
329
330	if (row != null)
331	{
332	RadioButton button = GetSelectedFilteringControl();
333	int index = GetColumnIndexForRadioButton(button);
334	data = row.Cells[index].Value.ToString();
335	txtFilterText.Text = data;
336	DisplaySelectedProgramEntry(row);
337	}
338	}
339	catch (Exception ex)
340	{
341	gLog.Verbose.Error.WriteLine(ex.ToString());
342	}
343	}
344	private int GetColumnIndexForRadioButton(RadioButton radio) { return GetColumnIndex(radio.Tag as string); }
345	private int GetColumnIndex(string columnname)
346	{
347	int index =0;
348	Type t = typeof(IProgramDefinition);
349
350	var props = t.GetProperties();
351	foreach (var prop in props)
352	{
353	if (prop.Name.ToLower() == columnname.ToLower()) { break; }
354	index++;
355	}
356	return index;
357	}
358	#endregion
359	#region Reset event
360	private void btnResetSort_Click(object sender, EventArgs e)
361	{
362	Type data_type;
363	object datasource = XMLTV.CreateBindingSourceFromData(XMLTV.GetPrograms(), out data_type);
364	dataGrid.DataSource = datasource;
365	ToggleDescedning();
366	}
367	#endregion
368	#region Filtering events
369	private void FilterByColumn(RadioButton button)
370	{
371	Type data_type;
372	string column = (button.Tag as string);
373	object data = XMLTV.CreateBindingSourceFromData(XMLTV.GetPrograms(), out data_type);
374	XMLTV.CreateFilterFromDataSource(ref data, column, txtFilterText.Text);
375	dataGrid.DataSource = data;
376	}
377	private RadioButton GetSelectedFilteringControl()
378	{
379	bool control_selected = false;
380	RadioButton button = new RadioButton();
381	foreach (var c in grpFilter_flow.Controls)
382	{
383	button = (c as RadioButton);
384	if (button != null) { if (button.Checked) { control_selected = true; break; } }
385	else { continue; }
386	}
387	if (!control_selected)
388	{
389	gLog.Verbose.Warn.WriteLine("Unkown filter value used. Was not: channelname, title, subtitle, description, start, or stop.");
390	//throw new InvalidOperationException("No filtering control is currently selected.");
391	return button;
392	}
393	else { return button; }
394	}
395	private void UpdateFilterText(RadioButton radio, DataGridView dgv)
396	{
397	if (radio.Checked)
398	{
399	int cellindex = GetColumnIndexForRadioButton(radio);
400	string t = radio.Tag as string;
401	DataGridViewRow row = null;
402	string data = string.Empty;
403	if (dgv.SelectedCells.Count > 0)
404	{
405	var cell = dgv.SelectedCells[0];
406	row = dgv.Rows[cell.RowIndex];
407	}
408	if (dgv.SelectedRows.Count > 0)
409	{
410	row = dgv.SelectedRows[0];
411	}
412	data = row.Cells[cellindex].Value.ToString();
413	txtFilterText.Text = data;
414	}
415	}
416	private void btnFilter_Click(object sender, EventArgs e)
417	{
418	RadioButton button = GetSelectedFilteringControl();
419	FilterByColumn(button);
420	}
421	private void radio_filter_channelnumber_CheckedChanged(object sender, EventArgs e)
422	{
423	RadioButton radio = (sender as RadioButton);
424	UpdateFilterText(radio, dataGrid);
425	}
426	private void radio_filter_title_CheckedChanged(object sender, EventArgs e)
427	{
428	RadioButton radio = (sender as RadioButton);
429	UpdateFilterText(radio, dataGrid);
430	}
431	private void radio_filter_subtitle_CheckedChanged(object sender, EventArgs e)
432	{
433	RadioButton radio = (sender as RadioButton);
434	UpdateFilterText(radio, dataGrid);
435	}
436	private void radio_filter_description_CheckedChanged(object sender, EventArgs e)
437	{
438	RadioButton radio = (sender as RadioButton);
439	UpdateFilterText(radio, dataGrid);
440	}
441	private void radio_filter_channelname_CheckedChanged(object sender, EventArgs e)
442	{
443	RadioButton radio = (sender as RadioButton);
444	UpdateFilterText(radio, dataGrid);
445	}
446	private void radio_filter_start_CheckedChanged(object sender, EventArgs e)
447	{
448	RadioButton radio = (sender as RadioButton);
449	UpdateFilterText(radio, dataGrid);
450	}
451	private void radio_filter_stop_CheckedChanged(object sender, EventArgs e)
452	{
453	RadioButton radio = (sender as RadioButton);
454	UpdateFilterText(radio, dataGrid);
455	}
456	#endregion
457	#region Sorting events
458	private bool Descending = false;
459	private void ToggleDescedning() { Descending = Descending ? false : true; }
460	private void SortByColumn(RadioButton button)
461	{
462	string column = (button.Tag as string);
463	object data = dataGrid.DataSource;
464	XMLTV.CreateSorterFromDataSource(ref data, Descending, column);
465	dataGrid.DataSource = data;
466	ToggleDescedning();
467	}
468	private RadioButton GetSelectedSortControl()
469	{
470	bool control_selected = false;
471	RadioButton button = new RadioButton();
472	foreach (var c in grpSort_flow.Controls)
473	{
474	button = (c as RadioButton);
475	if (button != null) { if (button.Checked) { control_selected = true; break; } }
476	else { continue; }
477	}
478	if (!control_selected)
479	{
480	gLog.Warn.WriteLine("Unkown sort value used. Was not: channelname, title, subtitle, description, stop, or start.");
481	//throw new InvalidOperationException("No sorting control is currently selected.");
482	return button;
483	}
484	else { return button; }
485	}
486	private void btnSort_Click(object sender, EventArgs e)
487	{
488	RadioButton button = GetSelectedSortControl();
489	SortByColumn(button);
490	}
491	#endregion
492	}
493	}
494