libxmltv/Core/DataSourceBindable.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using libxmltv.Interfaces;
using System.Collections;

namespace libxmltv.Core
{
    public class ChannelList : List<IXMLTVChannel>, IDataSourceBindable//, IDataConverter<IChannelDefintionList>
    {
        private class ChannelDefintionList : List<IChannelDefintion>, IDataSourceSortable, IDataSourceFilterable, IChannelDefintionList   
        {
            public ChannelDefintionList() { }
            public ChannelDefintionList(List<IChannelDefintion> collection) { collection.ForEach(s => this.Add(s)); }
            #region IDataSourceSortable members
            public void Sort(ref object source, params string[] args)
            {
            }
            #endregion
            #region IDataSourceFilterable members
            public void Filter(ref object source, params string[] args)
            {
            }
            #endregion
        }
        private class ChannelDefintion : IChannelDefintion
        {
            public ChannelDefintion()
            {
                ChannelId = string.Empty;
                ChannelName = string.Empty;
            }
            public string ChannelId { get; internal set; }
            public string ChannelName { get; internal set; }

            
        }
        //static private List<string> known_columns;
        //static ChannelList()
        //{
        //    known_columns = new List<string>();
        //    known_columns.Add("Id");
        //    known_columns.Add("Name");
        //}
        public ChannelList() { }

        //public object ConvertObjectData(object source) { return this.ConvertData(source); }
        //public IChannelDefintionList ConvertData(object source)
        //{
        //    //object t = source;
        //    if (source.GetType() != typeof(ChannelDefintionList)) { throw new InvalidCastException(string.Format("Cannot cast: '{0}' to '{1}'", source.GetType().Name, typeof(ChannelDefintionList).Name)); }
        //    //if (type != typeof(IChannelDefintionList)) { throw new InvalidCastException(string.Format("Cannot cast: '{0}' to '{1}'", type.Name, typeof(IChannelDefintionList).Name)); }
        //    IChannelDefintionList t = (source as IChannelDefintionList);
        //    return t;
        //}
        /// <summary>
        /// 
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public object CreateBindableDataSource(out Type type)
        {
            type = typeof(IChannelDefintionList);
            object bindable = new object();
            ChannelDefintionList list = new ChannelDefintionList();
            
            foreach (var t in this)
            {
                try
                {
                    ChannelDefintion definition = new ChannelDefintion();
                    definition.ChannelId = t.Id;
                    definition.ChannelName = t.MetaData[XMLTVConstants.Channels.ChannelDisplayName].FirstOrDefault().Value.ToString();                    
                    list.Add(definition);
                }
                catch (Exception ex) { throw ex; }
            }
            list = new ChannelDefintionList(list.OrderBy(s => s.ChannelName).ToList());
            bindable = list;
            return bindable;
        }
      
    }
    public class ProgramList : List<IXMLTVProgram>, IDataSourceBindable//, IDataConverter<IProgramDefinitionList>
    {
        private class ProgramDefinitionList : List<IProgramDefinition>, IDataSourceSortable, IDataSourceFilterable, IProgramDefinitionList  
        {
            public ProgramDefinitionList() { }
            public ProgramDefinitionList(List<IProgramDefinition> collection) { collection.ForEach(s => this.Add(s)); }
            #region IDataSourceSortable members
            public void Sort(ref object source, params string[] args)
            {
                ProgramDefinitionList list = null;
                try
                {
                    list = (ProgramDefinitionList)source;

                    var col = args[0].ToLower();
                    switch (col)
                    {
                        case "channelname": list =new ProgramDefinitionList( list.OrderBy(s => s.ChannelName).ToList()); break;
                        case "start": list = new ProgramDefinitionList( list.OrderBy(s => s.Start).ToList()); break;
                        case "stop": list = new ProgramDefinitionList( list.OrderBy(s => s.Stop).ToList()); break;
                        case "description": list = new ProgramDefinitionList( list.OrderBy(s => s.Description).ToList()); break;
                        case "title": list = new ProgramDefinitionList( list.OrderBy(s => s.Title).ToList()); break;
                        case "subtitle": list = new ProgramDefinitionList(list.OrderBy(s => s.SubTitle).ToList()); break;
                    }

                }
                catch (Exception ex) { throw ex; }
                if (list != null) { source = list; }
            }
            #endregion
            #region IDataSourceFilterable members
            public void Filter(ref object source, params string[] args)
            {
            }
            #endregion
        }
        private class ProgramDefintion : IProgramDefinition
        {
            public ProgramDefintion()
            {
                //ChannelId = string.Empty;
                ChannelName = string.Empty;
                Start = new DateTime();
                Stop = new DateTime();
                Description = string.Empty;
                Title = string.Empty;
                SubTitle = string.Empty;
            }
            //public string ChannelId { get; internal set; }
            public string ChannelName { get; internal set; }
            public DateTime Start { get; internal set; }
            public DateTime Stop { get; internal set; }
            public string Title { get; internal set; }
            public string SubTitle { get; internal set; }
            public string Description { get; internal set; }

          
        }
        public ProgramList() { }
        //public object ConvertObjectData(object source) { return this.ConvertData(source); }
        //public IProgramDefinitionList ConvertData(object source)
        //{
        //    if (source.GetType() != typeof(ProgramDefinitionList)) { throw new InvalidCastException(string.Format("Cannot cast: '{0}' to '{1}'", source.GetType().Name, typeof(ProgramDefinitionList).Name)); }
        //    //if (type != typeof(IProgramDefinitionList)) { throw new InvalidCastException(string.Format("Cannot cast: '{0}' to '{1}'", type.Name, typeof(IProgramDefinitionList).Name)); }
        //    IProgramDefinitionList t = (source as IProgramDefinitionList);
        //    return t;
        //}
        /// <summary>
        /// 
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public object CreateBindableDataSource(out Type type)
        {
            type = typeof(IProgramDefinitionList);
            object bindable = new object();
            ProgramDefinitionList list = new ProgramDefinitionList();

            foreach (var t in this)
            {
                try
                {
                    ProgramDefintion definition = new ProgramDefintion();
                    string ChannelId = t.MetaData[XMLTVConstants.Programs.ProgramChannelId].ToString();
                    //definition.ChannelId = ChannelId;

                    var channels = XMLTV.GetChannels();
                    if (channels != null)
                    {
                        var channel = channels.Find(p => p.Id == ChannelId);
                        if (channel != null)
                        {
                            definition.ChannelName = channel.MetaData[XMLTVConstants.Channels.ChannelDisplayName].FirstOrDefault().Value.ToString();
                        }
                        else
                        {
                            definition.ChannelName = string.Empty;
                        }
                    }
                    else
                    {
                        definition.ChannelName = string.Empty;
                    }
                    definition.Start = (DateTime)t.MetaData[XMLTVConstants.Programs.ProgramStart];
                    definition.Stop = (DateTime)t.MetaData[XMLTVConstants.Programs.ProgramStop];
                    definition.Description = t.MetaData[XMLTVConstants.Programs.ProgramDescription].ToString();
                    definition.Title = t.MetaData[XMLTVConstants.Programs.ProgramTitle].ToString();
                    definition.SubTitle = t.MetaData[XMLTVConstants.Programs.ProgramSubTitle].ToString();
                    list.Add(definition);
                }
                catch (Exception ex) { throw ex; }
            }

            list = new ProgramDefinitionList(list.OrderBy(s => s.Start).ToList());

            bindable = list;
            return bindable;
        }
    }
    public class ExtraList : List<IExtraMetaData>, IDataSourceBindable
    {

        public ExtraList() { }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public object CreateBindableDataSource(out Type type)
        {
            type = typeof(object);
            throw new NotImplementedException("Conversion of Extra MetaData to a bindable datasource has not been implemented.");
            //object bindable = new object();
            //return bindable;
        }
        //public object ConvertObjectData(object source) { return source; }
        //public object Convert(object source)
        //{
        //    throw new NotImplementedException("Conversion of Extra MetaData to a bindable datasource has not been implemented.");
        //}
    }
}
1	william	120	using System;
2			using System.Collections.Generic;
3			using System.Linq;
4			using System.Text;
5			using libxmltv.Interfaces;
6	william	126	using System.Collections;
7	william	120
8			namespace libxmltv.Core
9			{
10	william	128	public class ChannelList : List<IXMLTVChannel>, IDataSourceBindable//, IDataConverter<IChannelDefintionList>
11	william	120	{
12	william	128	private class ChannelDefintionList : List<IChannelDefintion>, IDataSourceSortable, IDataSourceFilterable, IChannelDefintionList
13	william	121	{
14	william	126	public ChannelDefintionList() { }
15	william	128	public ChannelDefintionList(List<IChannelDefintion> collection) { collection.ForEach(s => this.Add(s)); }
16	william	125	#region IDataSourceSortable members
17	william	126	public void Sort(ref object source, params string[] args)
18	william	125	{
19			}
20			#endregion
21			#region IDataSourceFilterable members
22	william	126	public void Filter(ref object source, params string[] args)
23	william	125	{
24			}
25			#endregion
26	william	121	}
27	william	128	private class ChannelDefintion : IChannelDefintion
28	william	126	{
29			public ChannelDefintion()
30			{
31			ChannelId = string.Empty;
32			ChannelName = string.Empty;
33			}
34			public string ChannelId { get; internal set; }
35			public string ChannelName { get; internal set; }
36
37
38			}
39	william	122	//static private List<string> known_columns;
40			//static ChannelList()
41			//{
42			// known_columns = new List<string>();
43			// known_columns.Add("Id");
44			// known_columns.Add("Name");
45			//}
46	william	120	public ChannelList() { }
47
48	william	128	//public object ConvertObjectData(object source) { return this.ConvertData(source); }
49			//public IChannelDefintionList ConvertData(object source)
50			//{
51			// //object t = source;
52			// if (source.GetType() != typeof(ChannelDefintionList)) { throw new InvalidCastException(string.Format("Cannot cast: '{0}' to '{1}'", source.GetType().Name, typeof(ChannelDefintionList).Name)); }
53			// //if (type != typeof(IChannelDefintionList)) { throw new InvalidCastException(string.Format("Cannot cast: '{0}' to '{1}'", type.Name, typeof(IChannelDefintionList).Name)); }
54			// IChannelDefintionList t = (source as IChannelDefintionList);
55			// return t;
56			//}
57			/// <summary>
58			///
59			/// </summary>
60			/// <param name="type"></param>
61			/// <returns></returns>
62			public object CreateBindableDataSource(out Type type)
63	william	120	{
64	william	128	type = typeof(IChannelDefintionList);
65	william	120	object bindable = new object();
66	william	126	ChannelDefintionList list = new ChannelDefintionList();
67	william	122
68			foreach (var t in this)
69			{
70			try
71			{
72			ChannelDefintion definition = new ChannelDefintion();
73			definition.ChannelId = t.Id;
74	william	123	definition.ChannelName = t.MetaData[XMLTVConstants.Channels.ChannelDisplayName].FirstOrDefault().Value.ToString();
75	william	122	list.Add(definition);
76			}
77			catch (Exception ex) { throw ex; }
78			}
79	william	126	list = new ChannelDefintionList(list.OrderBy(s => s.ChannelName).ToList());
80	william	122	bindable = list;
81	william	120	return bindable;
82			}
83	william	128
84	william	120	}
85	william	128	public class ProgramList : List<IXMLTVProgram>, IDataSourceBindable//, IDataConverter<IProgramDefinitionList>
86	william	120	{
87	william	128	private class ProgramDefinitionList : List<IProgramDefinition>, IDataSourceSortable, IDataSourceFilterable, IProgramDefinitionList
88	william	121	{
89	william	126	public ProgramDefinitionList() { }
90	william	128	public ProgramDefinitionList(List<IProgramDefinition> collection) { collection.ForEach(s => this.Add(s)); }
91	william	126	#region IDataSourceSortable members
92			public void Sort(ref object source, params string[] args)
93			{
94			ProgramDefinitionList list = null;
95			try
96			{
97			list = (ProgramDefinitionList)source;
98
99			var col = args[0].ToLower();
100			switch (col)
101			{
102			case "channelname": list =new ProgramDefinitionList( list.OrderBy(s => s.ChannelName).ToList()); break;
103			case "start": list = new ProgramDefinitionList( list.OrderBy(s => s.Start).ToList()); break;
104			case "stop": list = new ProgramDefinitionList( list.OrderBy(s => s.Stop).ToList()); break;
105			case "description": list = new ProgramDefinitionList( list.OrderBy(s => s.Description).ToList()); break;
106			case "title": list = new ProgramDefinitionList( list.OrderBy(s => s.Title).ToList()); break;
107			case "subtitle": list = new ProgramDefinitionList(list.OrderBy(s => s.SubTitle).ToList()); break;
108			}
109
110			}
111			catch (Exception ex) { throw ex; }
112			if (list != null) { source = list; }
113			}
114			#endregion
115			#region IDataSourceFilterable members
116			public void Filter(ref object source, params string[] args)
117			{
118			}
119			#endregion
120			}
121	william	128	private class ProgramDefintion : IProgramDefinition
122	william	126	{
123	william	122	public ProgramDefintion()
124			{
125	william	123	//ChannelId = string.Empty;
126	william	122	ChannelName = string.Empty;
127			Start = new DateTime();
128			Stop = new DateTime();
129			Description = string.Empty;
130			Title = string.Empty;
131			SubTitle = string.Empty;
132			}
133	william	123	//public string ChannelId { get; internal set; }
134	william	122	public string ChannelName { get; internal set; }
135			public DateTime Start { get; internal set; }
136			public DateTime Stop { get; internal set; }
137			public string Title { get; internal set; }
138			public string SubTitle { get; internal set; }
139	william	125	public string Description { get; internal set; }
140
141	william	126
142	william	121	}
143	william	120	public ProgramList() { }
144	william	128	//public object ConvertObjectData(object source) { return this.ConvertData(source); }
145			//public IProgramDefinitionList ConvertData(object source)
146			//{
147			// if (source.GetType() != typeof(ProgramDefinitionList)) { throw new InvalidCastException(string.Format("Cannot cast: '{0}' to '{1}'", source.GetType().Name, typeof(ProgramDefinitionList).Name)); }
148			// //if (type != typeof(IProgramDefinitionList)) { throw new InvalidCastException(string.Format("Cannot cast: '{0}' to '{1}'", type.Name, typeof(IProgramDefinitionList).Name)); }
149			// IProgramDefinitionList t = (source as IProgramDefinitionList);
150			// return t;
151			//}
152			/// <summary>
153			///
154			/// </summary>
155			/// <param name="type"></param>
156			/// <returns></returns>
157			public object CreateBindableDataSource(out Type type)
158	william	120	{
159	william	128	type = typeof(IProgramDefinitionList);
160	william	120	object bindable = new object();
161	william	126	ProgramDefinitionList list = new ProgramDefinitionList();
162	william	121
163	william	122	foreach (var t in this)
164			{
165			try
166			{
167			ProgramDefintion definition = new ProgramDefintion();
168	william	123	string ChannelId = t.MetaData[XMLTVConstants.Programs.ProgramChannelId].ToString();
169			//definition.ChannelId = ChannelId;
170	william	121
171	william	122	var channels = XMLTV.GetChannels();
172			if (channels != null)
173			{
174	william	123	var channel = channels.Find(p => p.Id == ChannelId);
175	william	122	if (channel != null)
176			{
177			definition.ChannelName = channel.MetaData[XMLTVConstants.Channels.ChannelDisplayName].FirstOrDefault().Value.ToString();
178			}
179			else
180			{
181			definition.ChannelName = string.Empty;
182			}
183			}
184			else
185			{
186			definition.ChannelName = string.Empty;
187			}
188			definition.Start = (DateTime)t.MetaData[XMLTVConstants.Programs.ProgramStart];
189			definition.Stop = (DateTime)t.MetaData[XMLTVConstants.Programs.ProgramStop];
190			definition.Description = t.MetaData[XMLTVConstants.Programs.ProgramDescription].ToString();
191			definition.Title = t.MetaData[XMLTVConstants.Programs.ProgramTitle].ToString();
192			definition.SubTitle = t.MetaData[XMLTVConstants.Programs.ProgramSubTitle].ToString();
193			list.Add(definition);
194			}
195			catch (Exception ex) { throw ex; }
196			}
197	william	123
198	william	126	list = new ProgramDefinitionList(list.OrderBy(s => s.Start).ToList());
199	william	123
200	william	122	bindable = list;
201	william	120	return bindable;
202			}
203			}
204			public class ExtraList : List<IExtraMetaData>, IDataSourceBindable
205			{
206	william	121
207	william	120	public ExtraList() { }
208	william	128	/// <summary>
209			///
210			/// </summary>
211			/// <param name="type"></param>
212			/// <returns></returns>
213			public object CreateBindableDataSource(out Type type)
214	william	120	{
215	william	128	type = typeof(object);
216	william	124	throw new NotImplementedException("Conversion of Extra MetaData to a bindable datasource has not been implemented.");
217			//object bindable = new object();
218			//return bindable;
219	william	120	}
220	william	128	//public object ConvertObjectData(object source) { return source; }
221			//public object Convert(object source)
222			//{
223			// throw new NotImplementedException("Conversion of Extra MetaData to a bindable datasource has not been implemented.");
224			//}
225	william	120	}
226			}