Index: /ipk/source.sh4/infos_formel1/CONTROL/control
===================================================================
--- /ipk/source.sh4/infos_formel1/CONTROL/control	(revision 7588)
+++ /ipk/source.sh4/infos_formel1/CONTROL/control	(revision 7589)
@@ -1,4 +1,4 @@
 Package: enigma2-plugin-infos-formel1
-Version: 0.7
+Version: 0.8
 Architecture: sh4
 OE: Sportinfo
Index: /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/Scroll.py
===================================================================
--- /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/Scroll.py	(revision 7589)
+++ /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/Scroll.py	(revision 7589)
@@ -0,0 +1,140 @@
+import skin
+from Components.HTMLComponent import HTMLComponent
+from Components.GUIComponent import GUIComponent
+from enigma import eLabel, eWidget, eSlider, fontRenderClass, ePoint, eSize
+
+class Scroll(HTMLComponent, GUIComponent):
+	def __init__(self, text=""):
+		GUIComponent.__init__(self)
+		self.message = text
+		self.instance = None
+		self.long_text = None
+		self.scrollbar = None
+		self.pages = None
+		self.total = None
+
+	def applySkin(self, desktop, parent):
+		ret = False
+		if self.skinAttributes is not None:
+			skin.applyAllAttributes(self.long_text, desktop, self.skinAttributes, parent.scale)
+			widget_attribs = [ ]
+			scrollbar_attribs = [ ]
+			for (attrib, value) in self.skinAttributes:
+				if attrib.find("borderColor") != -1 or attrib.find("borderWidth") != -1:
+					scrollbar_attribs.append((attrib,value))
+				if attrib.find("transparent") != -1 or attrib.find("backgroundColor") != -1:
+					widget_attribs.append((attrib,value))
+			skin.applyAllAttributes(self.instance, desktop, widget_attribs, parent.scale)
+			skin.applyAllAttributes(self.scrollbar, desktop, scrollbar_attribs+widget_attribs, parent.scale)
+			ret = True
+		s = self.long_text.size()
+		self.instance.move(self.long_text.position())
+		lineheight=fontRenderClass.getInstance().getLineHeight( self.long_text.getFont() )
+		if not lineheight:
+			lineheight = 30 # assume a random lineheight if nothing is visible
+		lines = (int)(s.height() / lineheight)
+		self.pageHeight = (int)(lines * lineheight)
+		self.instance.resize(eSize(s.width(), self.pageHeight+(int)(lineheight/6)))
+		self.scrollbar.move(ePoint(s.width()-20,0))
+		self.scrollbar.resize(eSize(20,self.pageHeight+(int)(lineheight/6)))
+		self.scrollbar.setOrientation(eSlider.orVertical);
+		self.scrollbar.setRange(0,100)
+		self.scrollbar.setBorderWidth(1)
+		self.long_text.move(ePoint(0,0))
+		self.long_text.resize(eSize(s.width()-30, self.pageHeight*16))
+		self.setText(self.message)
+		return ret
+
+	def setText(self, text):
+		self.message = text
+		if self.long_text is not None and self.pageHeight:
+			self.long_text.move(ePoint(0,0))
+			self.long_text.setText(self.message)
+			text_height=self.long_text.calculateSize().height()
+			total=self.pageHeight
+			pages=1
+			while total < text_height:
+				total=total+self.pageHeight
+				pages=pages+1
+			if pages > 1:
+				self.scrollbar.show()
+				self.total = total
+				self.pages = pages
+				self.updateScrollbar()
+			else:
+				self.scrollbar.hide()
+				self.total = None
+				self.pages = None
+
+	def appendText(self, text):
+		old_text = self.getText()
+		if len(str(old_text)) >0:
+			self.message += text
+		else:
+			self.message = text
+		if self.long_text is not None:
+			self.long_text.setText(self.message)
+			text_height=self.long_text.calculateSize().height()
+			total=self.pageHeight
+			pages=1
+			while total < text_height:
+				total=total+self.pageHeight
+				pages=pages+1
+			if pages > 1:
+				self.scrollbar.show()
+				self.total = total
+				self.pages = pages
+				self.updateScrollbar()
+			else:
+				self.scrollbar.hide()
+				self.total = None
+				self.pages = None
+
+	def updateScrollbar(self):
+		start = -self.long_text.position().y() * 100 / self.total
+		vis = self.pageHeight * 100 / self.total;
+		self.scrollbar.setStartEnd(start, start+vis)
+
+	def getText(self):
+		return self.message
+
+	def GUIcreate(self, parent):
+		self.instance = eWidget(parent)
+		self.scrollbar = eSlider(self.instance)
+		self.long_text = eLabel(self.instance)
+
+	def GUIdelete(self):
+		self.long_text = None
+		self.scrollbar = None
+		self.instance = None
+
+	def pageUp(self):
+		if self.total is not None:
+			curPos = self.long_text.position()
+			if curPos.y() < 0:
+				self.long_text.move( ePoint( curPos.x(), curPos.y() + self.pageHeight ) )
+				self.updateScrollbar()
+
+	def firstPage(self):
+		if self.total is not None:
+			curPos = self.long_text.position()
+			if curPos.y() < 0:
+				self.long_text.move( ePoint( curPos.x(), 0 ) )
+				self.updateScrollbar()
+
+	def pageDown(self):
+		if self.total is not None:
+			curPos = self.long_text.position()
+			if self.total-self.pageHeight >= abs( curPos.y() - self.pageHeight ):
+				self.long_text.move( ePoint( curPos.x(), curPos.y() - self.pageHeight ) )
+				self.updateScrollbar()
+
+	def lastPage(self):
+		i=1
+		while i < self.pages:
+			self.pageDown()
+			i += 1
+			self.updateScrollbar()
+
+	def produceHTML(self):
+		return self.getText()
Index: /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/getyoutube.py
===================================================================
--- /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/getyoutube.py	(revision 7589)
+++ /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/getyoutube.py	(revision 7589)
@@ -0,0 +1,3137 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Author: Ricardo Garcia Gonzalez
+# Author: Danny Colligan
+# Author: Benjamin Johnson
+# Author: Vasyl' Vavrychuk
+# Author: Witold Baryluk
+# Author: Paweł Paprota
+# Author: Gergely Imreh
+# License: Public domain code
+
+# modified by bauernbub to use for enigma2
+
+from Screens.Screen import Screen
+from enigma import ePicLoad, eTimer, getDesktop, eConsoleAppContainer, eBackgroundFileEraser, eServiceReference, iServiceInformation, iPlayableService
+from Components.ActionMap import ActionMap
+from Components.Label import Label
+from Components.Button import Button
+from Components.Sources.StaticText import StaticText
+from Components.config import config, configfile, getConfigListEntry, ConfigSubsection, ConfigYesNo, ConfigText, ConfigEnableDisable, ConfigSelection, NoSave
+from Components.ConfigList import ConfigList, ConfigListScreen
+from Components.Slider import Slider
+from Screens.MessageBox import MessageBox
+from Screens.Standby import TryQuitMainloop
+from Screens.TaskView import JobView
+from Components.Task import Task, Job, job_manager as JobManager, Condition
+from Components.ServiceEventTracker import ServiceEventTracker
+from Screens.InfoBar import MoviePlayer
+from Tools.Directories import fileExists, resolveFilename, SCOPE_LANGUAGE, SCOPE_PLUGINS
+from os import environ, stat as os_stat, listdir as os_listdir, path as os_path, readlink as os_readlink, system as os_system
+from time import time
+
+import cookielib
+import datetime
+
+import gzip
+import htmlentitydefs
+import httplib
+import locale
+import math
+import netrc
+import os
+import os.path
+import re
+import socket
+import string
+import StringIO
+import subprocess
+import sys
+import time
+import urllib
+import urllib2
+import zlib
+
+#import ctypes
+#import email.utils
+
+# parse_qs was moved from the cgi module to the urlparse module recently.
+try:
+	from urlparse import parse_qs
+except ImportError:
+	from cgi import parse_qs
+
+std_headers = {
+	'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:2.0b11) Gecko/20100101 Firefox/4.0b11',
+	'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
+	'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+	'Accept-Encoding': 'gzip, deflate',
+	'Accept-Language': 'en-us,en;q=0.5',
+}
+
+simple_title_chars = string.ascii_letters.decode('ascii') + string.digits.decode('ascii')
+
+def preferredencoding():
+	"""Get preferred encoding.
+
+	Returns the best encoding scheme for the system, based on
+	locale.getpreferredencoding() and some further tweaks.
+	"""
+	def yield_preferredencoding():
+		try:
+			pref = locale.getpreferredencoding()
+			u'TEST'.encode(pref)
+		except:
+			pref = 'UTF-8'
+		while True:
+			yield pref
+	return yield_preferredencoding().next()
+
+def htmlentity_transform(matchobj):
+	"""Transforms an HTML entity to a Unicode character.
+
+	This function receives a match object and is intended to be used with
+	the re.sub() function.
+	"""
+	entity = matchobj.group(1)
+
+	# Known non-numeric HTML entity
+	if entity in htmlentitydefs.name2codepoint:
+		return unichr(htmlentitydefs.name2codepoint[entity])
+
+	# Unicode character
+	mobj = re.match(ur'(?u)#(x?\d+)', entity)
+	if mobj is not None:
+		numstr = mobj.group(1)
+		if numstr.startswith(u'x'):
+			base = 16
+			numstr = u'0%s' % numstr
+		else:
+			base = 10
+		return unichr(long(numstr, base))
+
+	# Unknown entity in name, return its literal representation
+	return (u'&%s;' % entity)
+
+def sanitize_title(utitle):
+	"""Sanitizes a video title so it could be used as part of a filename."""
+	utitle = re.sub(ur'(?u)&(.+?);', htmlentity_transform, utitle)
+	return utitle.replace(unicode(os.sep), u'%')
+
+def sanitize_open(filename, open_mode):
+	"""Try to open the given filename, and slightly tweak it if this fails.
+
+	Attempts to open the given filename. If this fails, it tries to change
+	the filename slightly, step by step, until it's either able to open it
+	or it fails and raises a final exception, like the standard open()
+	function.
+
+	It returns the tuple (stream, definitive_file_name).
+	"""
+	try:
+		if filename == u'-':
+			if sys.platform == 'win32':
+				import msvcrt
+				msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
+			return (sys.stdout, filename)
+		stream = open(filename, open_mode)
+		return (stream, filename)
+	except (IOError, OSError), err:
+		# In case of error, try to remove win32 forbidden chars
+		filename = re.sub(ur'[/<>:"\|\?\*]', u'#', filename)
+
+		# An exception here should be caught in the caller
+		stream = open(filename, open_mode)
+		return (stream, filename)
+
+def timeconvert(timestr):
+    """Convert RFC 2822 defined time string into system timestamp"""
+    timestamp = None
+    #timetuple = email.utils.parsedate_tz(timestr)
+    #if timetuple is not None:
+    #    timestamp = email.utils.mktime_tz(timetuple)
+    return timestamp
+
+class DownloadError(Exception):
+	"""Download Error exception.
+
+	This exception may be thrown by FileDownloader objects if they are not
+	configured to continue on errors. They will contain the appropriate
+	error message.
+	"""
+	pass
+
+class SameFileError(Exception):
+	"""Same File exception.
+
+	This exception will be thrown by FileDownloader objects if they detect
+	multiple files would have to be downloaded to the same file on disk.
+	"""
+	pass
+
+class PostProcessingError(Exception):
+	"""Post Processing exception.
+
+	This exception may be raised by PostProcessor's .run() method to
+	indicate an error in the postprocessing task.
+	"""
+	pass
+
+class UnavailableVideoError(Exception):
+	"""Unavailable Format exception.
+
+	This exception will be thrown when a video is requested
+	in a format that is not available for that video.
+	"""
+	pass
+
+class ContentTooShortError(Exception):
+	"""Content Too Short exception.
+
+	This exception may be raised by FileDownloader objects when a file they
+	download is too small for what the server announced first, indicating
+	the connection was probably interrupted.
+	"""
+	# Both in bytes
+	downloaded = None
+	expected = None
+
+	def __init__(self, downloaded, expected):
+		self.downloaded = downloaded
+		self.expected = expected
+
+class YoutubeDLHandler(urllib2.HTTPHandler):
+	"""Handler for HTTP requests and responses.
+
+	This class, when installed with an OpenerDirector, automatically adds
+	the standard headers to every HTTP request and handles gzipped and
+	deflated responses from web servers. If compression is to be avoided in
+	a particular request, the original request in the program code only has
+	to include the HTTP header "Youtubedl-No-Compression", which will be
+	removed before making the real request.
+
+	Part of this code was copied from:
+
+	  http://techknack.net/python-urllib2-handlers/
+
+	Andrew Rowls, the author of that code, agreed to release it to the
+	public domain.
+	"""
+
+	@staticmethod
+	def deflate(data):
+		try:
+			return zlib.decompress(data, -zlib.MAX_WBITS)
+		except zlib.error:
+			return zlib.decompress(data)
+
+	@staticmethod
+	def addinfourl_wrapper(stream, headers, url, code):
+		if hasattr(urllib2.addinfourl, 'getcode'):
+			return urllib2.addinfourl(stream, headers, url, code)
+		ret = urllib2.addinfourl(stream, headers, url)
+		ret.code = code
+		return ret
+
+	def http_request(self, req):
+		for h in std_headers:
+			if h in req.headers:
+				del req.headers[h]
+			req.add_header(h, std_headers[h])
+		if 'Youtubedl-no-compression' in req.headers:
+			if 'Accept-encoding' in req.headers:
+				del req.headers['Accept-encoding']
+			del req.headers['Youtubedl-no-compression']
+		return req
+
+	def http_response(self, req, resp):
+		old_resp = resp
+		# gzip
+		if resp.headers.get('Content-encoding', '') == 'gzip':
+			gz = gzip.GzipFile(fileobj=StringIO.StringIO(resp.read()), mode='r')
+			resp = self.addinfourl_wrapper(gz, old_resp.headers, old_resp.url, old_resp.code)
+			resp.msg = old_resp.msg
+		# deflate
+		if resp.headers.get('Content-encoding', '') == 'deflate':
+			gz = StringIO.StringIO(self.deflate(resp.read()))
+			resp = self.addinfourl_wrapper(gz, old_resp.headers, old_resp.url, old_resp.code)
+			resp.msg = old_resp.msg
+		return resp
+
+class FileDownloader(object):
+	"""File Downloader class.
+
+	File downloader objects are the ones responsible of downloading the
+	actual video file and writing it to disk if the user has requested
+	it, among some other tasks. In most cases there should be one per
+	program. As, given a video URL, the downloader doesn't know how to
+	extract all the needed information, task that InfoExtractors do, it
+	has to pass the URL to one of them.
+
+	For this, file downloader objects have a method that allows
+	InfoExtractors to be registered in a given order. When it is passed
+	a URL, the file downloader handles it to the first InfoExtractor it
+	finds that reports being able to handle it. The InfoExtractor extracts
+	all the information about the video or videos the URL refers to, and
+	asks the FileDownloader to process the video information, possibly
+	downloading the video.
+
+	File downloaders accept a lot of parameters. In order not to saturate
+	the object constructor with arguments, it receives a dictionary of
+	options instead. These options are available through the params
+	attribute for the InfoExtractors to use. The FileDownloader also
+	registers itself as the downloader in charge for the InfoExtractors
+	that are added to it, so this is a "mutual registration".
+
+	Available options:
+
+	username:         Username for authentication purposes.
+	password:         Password for authentication purposes.
+	usenetrc:         Use netrc for authentication instead.
+	quiet:            Do not print messages to stdout.
+	forceurl:         Force printing final URL.
+	forcetitle:       Force printing title.
+	forcethumbnail:   Force printing thumbnail URL.
+	forcedescription: Force printing description.
+	forcefilename:    Force printing final filename.
+	simulate:         Do not download the video files.
+	format:           Video format code.
+	format_limit:     Highest quality format to try.
+	outtmpl:          Template for output names.
+	ignoreerrors:     Do not stop on download errors.
+	ratelimit:        Download speed limit, in bytes/sec.
+	nooverwrites:     Prevent overwriting files.
+	retries:          Number of times to retry for HTTP error 5xx
+	continuedl:       Try to continue downloads if possible.
+	noprogress:       Do not print the progress bar.
+	playliststart:    Playlist item to start at.
+	playlistend:      Playlist item to end at.
+	logtostderr:      Log messages to stderr instead of stdout.
+	consoletitle:     Display progress in console window's titlebar.
+	nopart:           Do not use temporary .part files.
+	updatetime:       Use the Last-modified header to set output file timestamps.
+	"""
+
+	params = None
+	_ies = []
+	_pps = []
+	_download_retcode = None
+	_num_downloads = None
+	_screen_file = None
+
+	def __init__(self, params):
+		"""Create a FileDownloader object with the given options."""
+		self._ies = []
+		self._pps = []
+		self._download_retcode = 0
+		self._num_downloads = 0
+		self._screen_file = [sys.stdout, sys.stderr][params.get('logtostderr', False)]
+		self.params = params
+		
+		#print "params=", params
+		# 'outtmpl': u'/tmp/test'
+		#sys.exit(u'\nERROR: Interrupted by me')
+
+	@staticmethod
+	def pmkdir(filename):
+		"""Create directory components in filename. Similar to Unix "mkdir -p"."""
+		components = filename.split(os.sep)
+		aggregate = [os.sep.join(components[0:x]) for x in xrange(1, len(components))]
+		aggregate = ['%s%s' % (x, os.sep) for x in aggregate] # Finish names with separator
+		for dir in aggregate:
+			if not os.path.exists(dir):
+				os.mkdir(dir)
+
+	@staticmethod
+	def format_bytes(bytes):
+		if bytes is None:
+			return 'N/A'
+		if type(bytes) is str:
+			bytes = float(bytes)
+		if bytes == 0.0:
+			exponent = 0
+		else:
+			exponent = long(math.log(bytes, 1024.0))
+		suffix = 'bkMGTPEZY'[exponent]
+		converted = float(bytes) / float(1024**exponent)
+		return '%.2f%s' % (converted, suffix)
+
+	@staticmethod
+	def calc_percent(byte_counter, data_len):
+		if data_len is None:
+			return '---.-%'
+		return '%6s' % ('%3.1f%%' % (float(byte_counter) / float(data_len) * 100.0))
+
+	@staticmethod
+	def calc_eta(start, now, total, current):
+		if total is None:
+			return '--:--'
+		dif = now - start
+		if current == 0 or dif < 0.001: # One millisecond
+			return '--:--'
+		rate = float(current) / dif
+		eta = long((float(total) - float(current)) / rate)
+		(eta_mins, eta_secs) = divmod(eta, 60)
+		if eta_mins > 99:
+			return '--:--'
+		return '%02d:%02d' % (eta_mins, eta_secs)
+
+	@staticmethod
+	def calc_speed(start, now, bytes):
+		dif = now - start
+		if bytes == 0 or dif < 0.001: # One millisecond
+			return '%10s' % '---b/s'
+		return '%10s' % ('%s/s' % FileDownloader.format_bytes(float(bytes) / dif))
+
+	@staticmethod
+	def best_block_size(elapsed_time, bytes):
+		new_min = max(bytes / 2.0, 1.0)
+		new_max = min(max(bytes * 2.0, 1.0), 4194304) # Do not surpass 4 MB
+		if elapsed_time < 0.001:
+			return long(new_max)
+		rate = bytes / elapsed_time
+		if rate > new_max:
+			return long(new_max)
+		if rate < new_min:
+			return long(new_min)
+		return long(rate)
+
+	@staticmethod
+	def parse_bytes(bytestr):
+		"""Parse a string indicating a byte quantity into a long integer."""
+		matchobj = re.match(r'(?i)^(\d+(?:\.\d+)?)([kMGTPEZY]?)$', bytestr)
+		if matchobj is None:
+			return None
+		number = float(matchobj.group(1))
+		multiplier = 1024.0 ** 'bkmgtpezy'.index(matchobj.group(2).lower())
+		return long(round(number * multiplier))
+
+	def add_info_extractor(self, ie):
+		"""Add an InfoExtractor object to the end of the list."""
+		self._ies.append(ie)
+		ie.set_downloader(self)
+
+	def add_post_processor(self, pp):
+		"""Add a PostProcessor object to the end of the chain."""
+		self._pps.append(pp)
+		pp.set_downloader(self)
+
+	def to_screen(self, message, skip_eol=False, ignore_encoding_errors=False):
+		"""Print message to stdout if not in quiet mode."""
+		try:
+			if not self.params.get('quiet', False):
+				terminator = [u'\n', u''][skip_eol]
+				print >>self._screen_file, (u'%s%s' % (message, terminator)).encode(preferredencoding()),
+			#self._screen_file.flush()
+		except (UnicodeEncodeError), err:
+			if not ignore_encoding_errors:
+				raise
+
+	def to_stderr(self, message):
+		"""Print message to stderr."""
+		print >>sys.stderr, message.encode(preferredencoding())
+
+	def to_cons_title(self, message):
+		"""Set console/terminal window title to message."""
+		if not self.params.get('consoletitle', False):
+			return
+		if os.name == 'nt' and ctypes.windll.kernel32.GetConsoleWindow():
+			# c_wchar_p() might not be necessary if `message` is
+			# already of type unicode()
+			ctypes.windll.kernel32.SetConsoleTitleW(ctypes.c_wchar_p(message))
+		elif 'TERM' in os.environ:
+			sys.stderr.write('\033]0;%s\007' % message.encode(preferredencoding()))
+
+	def fixed_template(self):
+		"""Checks if the output template is fixed."""
+		return (re.search(ur'(?u)%\(.+?\)s', self.params['outtmpl']) is None)
+
+	def trouble(self, message=None):
+		"""Determine action to take when a download problem appears.
+
+		Depending on if the downloader has been configured to ignore
+		download errors or not, this method may throw an exception or
+		not when errors are found, after printing the message.
+		"""
+		if message is not None:
+			self.to_stderr(message)
+		if not self.params.get('ignoreerrors', False):
+			raise DownloadError(message)
+		self._download_retcode = 1
+
+	def slow_down(self, start_time, byte_counter):
+		"""Sleep if the download speed is over the rate limit."""
+		rate_limit = self.params.get('ratelimit', None)
+		if rate_limit is None or byte_counter == 0:
+			return
+		now = time.time()
+		elapsed = now - start_time
+		if elapsed <= 0.0:
+			return
+		speed = float(byte_counter) / elapsed
+		if speed > rate_limit:
+			time.sleep((byte_counter - rate_limit * (now - start_time)) / rate_limit)
+
+	def temp_name(self, filename):
+		"""Returns a temporary filename for the given filename."""
+		if self.params.get('nopart', False) or filename == u'-' or \
+				(os.path.exists(filename) and not os.path.isfile(filename)):
+			return filename
+		return filename + u'.part'
+
+	def undo_temp_name(self, filename):
+		if filename.endswith(u'.part'):
+			return filename[:-len(u'.part')]
+		return filename
+
+	def try_rename(self, old_filename, new_filename):
+		try:
+			if old_filename == new_filename:
+				return
+			os.rename(old_filename, new_filename)
+		except (IOError, OSError), err:
+			self.trouble(u'ERROR: unable to rename file')
+
+	def try_utime(self, filename, last_modified_hdr):
+		"""Try to set the last-modified time of the given file."""
+		if last_modified_hdr is None:
+			return
+		if not os.path.isfile(filename):
+			return
+		timestr = last_modified_hdr
+		if timestr is None:
+			return
+		filetime = timeconvert(timestr)
+		if filetime is None:
+			return
+		try:
+			os.utime(filename,(time.time(), filetime))
+		except:
+			pass
+
+	def report_destination(self, filename):
+		"""Report destination filename."""
+		self.to_screen(u'[download] Destination: %s' % filename, ignore_encoding_errors=True)
+
+	def report_progress(self, percent_str, data_len_str, speed_str, eta_str):
+		"""Report download progress."""
+		if self.params.get('noprogress', False):
+			return
+
+		#self.progressupdate(percent_str, data_len_str, speed_str, eta_str)
+
+		self.to_screen(u'\r[download] %s of %s at %s ETA %s' %
+				(percent_str, data_len_str, speed_str, eta_str), skip_eol=True)
+		self.to_cons_title(u'youtube-dl - %s of %s at %s ETA %s' %
+				(percent_str.strip(), data_len_str.strip(), speed_str.strip(), eta_str.strip()))
+
+	#def progressupdate(self, percent_str, data_len_str, speed_str, eta_str):
+
+
+	def report_resuming_byte(self, resume_len):
+		"""Report attempt to resume at given byte."""
+		self.to_screen(u'[download] Resuming download at byte %s' % resume_len)
+
+	def report_retry(self, count, retries):
+		"""Report retry in case of HTTP error 5xx"""
+		self.to_screen(u'[download] Got server HTTP error. Retrying (attempt %d of %d)...' % (count, retries))
+
+	def report_file_already_downloaded(self, file_name):
+		"""Report file has already been fully downloaded."""
+		try:
+			self.to_screen(u'[download] %s has already been downloaded' % file_name)
+		except (UnicodeEncodeError), err:
+			self.to_screen(u'[download] The file has already been downloaded')
+
+	def report_unable_to_resume(self):
+		"""Report it was impossible to resume download."""
+		self.to_screen(u'[download] Unable to resume')
+
+	def report_finish(self):
+		"""Report download finished."""
+		if self.params.get('noprogress', False):
+			self.to_screen(u'[download] Download completed')
+		else:
+			self.to_screen(u'')
+
+	def increment_downloads(self):
+		"""Increment the ordinal that assigns a number to each file."""
+		self._num_downloads += 1
+
+	def prepare_filename(self, info_dict):
+		"""Generate the output filename."""
+		try:
+			template_dict = dict(info_dict)
+			template_dict['epoch'] = unicode(long(time.time()))
+			template_dict['autonumber'] = unicode('%05d' % self._num_downloads)
+			filename = self.params['outtmpl'] % template_dict
+			return filename
+		except (ValueError, KeyError), err:
+			self.trouble(u'ERROR: invalid system charset or erroneous output template')
+			return None
+
+	def process_info(self, info_dict):
+		"""Process a single dictionary returned by an InfoExtractor."""
+		filename = self.prepare_filename(info_dict)
+		# Do nothing else if in simulate mode
+		if self.params.get('simulate', False):
+			# Forced printings
+			if self.params.get('forcetitle', False):
+				print info_dict['title'].encode(preferredencoding(), 'xmlcharrefreplace')
+			if self.params.get('forceurl', False):
+				print info_dict['url'].encode(preferredencoding(), 'xmlcharrefreplace')
+			if self.params.get('forcethumbnail', False) and 'thumbnail' in info_dict:
+				print info_dict['thumbnail'].encode(preferredencoding(), 'xmlcharrefreplace')
+			if self.params.get('forcedescription', False) and 'description' in info_dict:
+				print info_dict['description'].encode(preferredencoding(), 'xmlcharrefreplace')
+			if self.params.get('forcefilename', False) and filename is not None:
+				print filename.encode(preferredencoding(), 'xmlcharrefreplace')
+
+			return
+
+		if filename is None:
+			return
+		if self.params.get('nooverwrites', False) and os.path.exists(filename):
+			self.to_stderr(u'WARNING: file exists and will be skipped')
+			return
+
+		try:
+			self.pmkdir(filename)
+		except (OSError, IOError), err:
+			self.trouble(u'ERROR: unable to create directories: %s' % str(err))
+			return
+
+		try:
+			success = self._do_download(filename, info_dict['url'].encode('utf-8'), info_dict.get('player_url', None))
+		except (OSError, IOError), err:
+			raise UnavailableVideoError
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self.trouble(u'ERROR: unable to download video data: %s' % str(err))
+			return
+		except (ContentTooShortError, ), err:
+			self.trouble(u'ERROR: content too short (expected %s bytes and served %s)' % (err.expected, err.downloaded))
+			return
+
+		if success:
+			try:
+				self.post_process(filename, info_dict)
+			except (PostProcessingError), err:
+				self.trouble(u'ERROR: postprocessing: %s' % str(err))
+				return
+
+	def download(self, url_list):
+		"""Download a given list of URLs."""
+		if len(url_list) > 1 and self.fixed_template():
+			print "url_list=",url_list
+			print "url_list=",self.fixed_template
+			#raise SameFileError(self.params['outtmpl'])
+
+		for url in url_list:
+			suitable_found = False
+			for ie in self._ies:
+				# Go to next InfoExtractor if not suitable
+				if not ie.suitable(url):
+					continue
+
+				# Suitable InfoExtractor found
+				suitable_found = True
+
+				# Extract information from URL and process it
+				ie.extract(url)
+
+				# Suitable InfoExtractor had been found; go to next URL
+				break
+
+			if not suitable_found:
+				self.trouble(u'ERROR: no suitable InfoExtractor: %s' % url)
+
+		return self._download_retcode
+
+	def post_process(self, filename, ie_info):
+		"""Run the postprocessing chain on the given file."""
+		info = dict(ie_info)
+		info['filepath'] = filename
+		for pp in self._pps:
+			info = pp.run(info)
+			if info is None:
+				break
+
+	def _download_with_rtmpdump(self, filename, url, player_url):
+		print "Download trmpdump 1"
+		self.report_destination(filename)
+		tmpfilename = self.temp_name(filename)
+
+		# Check for rtmpdump first
+		try:
+			subprocess.call(['rtmpdump', '-h'], stdout=(file(os.path.devnull, 'w')), stderr=subprocess.STDOUT)
+		except (OSError, IOError):
+			self.trouble(u'ERROR: RTMP download detected but "rtmpdump" could not be run')
+			return False
+
+		# Download using rtmpdump. rtmpdump returns exit code 2 when
+		# the connection was interrumpted and resuming appears to be
+		# possible. This is part of rtmpdump's normal usage, AFAIK.
+		basic_args = ['rtmpdump', '-q'] + [[], ['-W', player_url]][player_url is not None] + ['-r', url, '-o', tmpfilename]
+		retval = subprocess.call(basic_args + [[], ['-e', '-k', '1']][self.params.get('continuedl', False)])
+		while retval == 2 or retval == 1:
+			prevsize = os.path.getsize(tmpfilename)
+			self.to_screen(u'\r[rtmpdump] %s bytes' % prevsize, skip_eol=True)
+			time.sleep(5.0) # This seems to be needed
+			retval = subprocess.call(basic_args + ['-e'] + [[], ['-k', '1']][retval == 1])
+			cursize = os.path.getsize(tmpfilename)
+			if prevsize == cursize and retval == 1:
+				break
+		if retval == 0:
+			self.to_screen(u'\r[rtmpdump] %s bytes' % os.path.getsize(tmpfilename))
+			self.try_rename(tmpfilename, filename)
+			return True
+		else:
+			self.trouble(u'\nERROR: rtmpdump exited with code %d' % retval)
+			return False
+
+	def _do_download(self, filename, url, player_url):
+		# Check file already present
+		if self.params.get('continuedl', False) and os.path.isfile(filename) and not self.params.get('nopart', False):
+			self.report_file_already_downloaded(filename)
+			return True
+
+		# Attempt to download using rtmpdump
+		if url.startswith('rtmp'):
+			return self._download_with_rtmpdump(filename, url, player_url)
+
+		tmpfilename = self.temp_name(filename)
+		stream = None
+		open_mode = 'wb'
+
+		# Do not include the Accept-Encoding header
+		headers = {'Youtubedl-no-compression': 'True'}
+		basic_request = urllib2.Request(url, None, headers)
+		request = urllib2.Request(url, None, headers)
+
+		# Establish possible resume length
+		if os.path.isfile(tmpfilename):
+			resume_len = os.path.getsize(tmpfilename)
+		else:
+			resume_len = 0
+
+		# Request parameters in case of being able to resume
+		if self.params.get('continuedl', False) and resume_len != 0:
+			self.report_resuming_byte(resume_len)
+			request.add_header('Range','bytes=%d-' % resume_len)
+			open_mode = 'ab'
+
+		count = 0
+		retries = self.params.get('retries', 0)
+		while count <= retries:
+			# Establish connection
+			try:
+				data = urllib2.urlopen(request)
+				break
+			except (urllib2.HTTPError, ), err:
+				if (err.code < 500 or err.code >= 600) and err.code != 416:
+					# Unexpected HTTP error
+					raise
+				elif err.code == 416:
+					# Unable to resume (requested range not satisfiable)
+					try:
+						# Open the connection again without the range header
+						data = urllib2.urlopen(basic_request)
+						content_length = data.info()['Content-Length']
+					except (urllib2.HTTPError, ), err:
+						if err.code < 500 or err.code >= 600:
+							raise
+					else:
+						# Examine the reported length
+						if (content_length is not None and
+						    (resume_len - 100 < long(content_length) < resume_len + 100)):
+							# The file had already been fully downloaded.
+							# Explanation to the above condition: in issue #175 it was revealed that
+							# YouTube sometimes adds or removes a few bytes from the end of the file,
+							# changing the file size slightly and causing problems for some users. So
+							# I decided to implement a suggested change and consider the file
+							# completely downloaded if the file size differs less than 100 bytes from
+							# the one in the hard drive.
+							self.report_file_already_downloaded(filename)
+							self.try_rename(tmpfilename, filename)
+							return True
+						else:
+							# The length does not match, we start the download over
+							self.report_unable_to_resume()
+							open_mode = 'wb'
+							break
+			# Retry
+			count += 1
+			if count <= retries:
+				self.report_retry(count, retries)
+
+		if count > retries:
+			self.trouble(u'ERROR: giving up after %s retries' % retries)
+			return False
+
+		data_len = data.info().get('Content-length', None)
+		if data_len is not None:
+			data_len = long(data_len) + resume_len
+		data_len_str = self.format_bytes(data_len)
+		byte_counter = 0 + resume_len
+		block_size = 1024
+		start = time.time()
+		while True:
+			# Download and write
+			before = time.time()
+			data_block = data.read(block_size)
+			after = time.time()
+			if len(data_block) == 0:
+				break
+			byte_counter += len(data_block)
+
+			# Open file just in time
+			if stream is None:
+				try:
+					(stream, tmpfilename) = sanitize_open(tmpfilename, open_mode)
+					filename = self.undo_temp_name(tmpfilename)
+					print "Download 1"
+					self.report_destination(filename)
+				except (OSError, IOError), err:
+					self.trouble(u'ERROR: unable to open for writing: %s' % str(err))
+					return False
+			try:
+				stream.write(data_block)
+			except (IOError, OSError), err:
+				self.trouble(u'\nERROR: unable to write data: %s' % str(err))
+				return False
+			block_size = self.best_block_size(after - before, len(data_block))
+
+			# Progress message
+			percent_str = self.calc_percent(byte_counter, data_len)
+			eta_str = self.calc_eta(start, time.time(), data_len - resume_len, byte_counter - resume_len)
+			speed_str = self.calc_speed(start, time.time(), byte_counter - resume_len)
+			self.report_progress(percent_str, data_len_str, speed_str, eta_str)
+
+			# Apply rate limit
+			self.slow_down(start, byte_counter - resume_len)
+
+		stream.close()
+		self.report_finish()
+		if data_len is not None and byte_counter != data_len:
+			raise ContentTooShortError(byte_counter, long(data_len))
+		self.try_rename(tmpfilename, filename)
+
+		# Update file modification time
+		if self.params.get('updatetime', True):
+			self.try_utime(filename, data.info().get('last-modified', None))
+
+		return True
+
+class InfoExtractor(object):
+	"""Information Extractor class.
+
+	Information extractors are the classes that, given a URL, extract
+	information from the video (or videos) the URL refers to. This
+	information includes the real video URL, the video title and simplified
+	title, author and others. The information is stored in a dictionary
+	which is then passed to the FileDownloader. The FileDownloader
+	processes this information possibly downloading the video to the file
+	system, among other possible outcomes. The dictionaries must include
+	the following fields:
+
+	id:		Video identifier.
+	url:		Final video URL.
+	uploader:	Nickname of the video uploader.
+	title:		Literal title.
+	stitle:		Simplified title.
+	ext:		Video filename extension.
+	format:		Video format.
+	player_url:	SWF Player URL (may be None).
+
+	The following fields are optional. Their primary purpose is to allow
+	youtube-dl to serve as the backend for a video search function, such
+	as the one in youtube2mp3.  They are only used when their respective
+	forced printing functions are called:
+
+	thumbnail:	Full URL to a video thumbnail image.
+	description:	One-line video description.
+
+	Subclasses of this one should re-define the _real_initialize() and
+	_real_extract() methods, as well as the suitable() static method.
+	Probably, they should also be instantiated and added to the main
+	downloader.
+	"""
+
+	_ready = False
+	_downloader = None
+
+	def __init__(self, downloader=None):
+		"""Constructor. Receives an optional downloader."""
+		self._ready = False
+		self.set_downloader(downloader)
+
+	@staticmethod
+	def suitable(url):
+		"""Receives a URL and returns True if suitable for this IE."""
+		return False
+
+	def initialize(self):
+		"""Initializes an instance (authentication, etc)."""
+		if not self._ready:
+			self._real_initialize()
+			self._ready = True
+
+	def extract(self, url):
+		"""Extracts URL information and returns it in list of dicts."""
+		self.initialize()
+		return self._real_extract(url)
+
+	def set_downloader(self, downloader):
+		"""Sets the downloader for this IE."""
+		self._downloader = downloader
+
+	def _real_initialize(self):
+		"""Real initialization process. Redefine in subclasses."""
+		pass
+
+	def _real_extract(self, url):
+		"""Real extraction process. Redefine in subclasses."""
+		pass
+
+class YoutubeIE(InfoExtractor):
+	"""Information extractor for youtube.com."""
+
+	_VALID_URL = r'^((?:https?://)?(?:youtu\.be/|(?:\w+\.)?youtube(?:-nocookie)?\.com/)(?:(?:(?:v|embed|e)/)|(?:(?:watch(?:_popup)?(?:\.php)?)?(?:\?|#!?)(?:.+&)?v=)))?([0-9A-Za-z_-]+)(?(1).+)?$'
+	_LANG_URL = r'http://www.youtube.com/?hl=en&persist_hl=1&gl=US&persist_gl=1&opt_out_ackd=1'
+	_LOGIN_URL = 'https://www.youtube.com/signup?next=/&gl=US&hl=en'
+	_AGE_URL = 'http://www.youtube.com/verify_age?next_url=/&gl=US&hl=en'
+	_NETRC_MACHINE = 'youtube'
+	# Listed in order of quality
+	_available_formats = ['38', '37', '22', '45', '35', '34', '43', '18', '6', '5', '17', '13']
+	_video_extensions = {
+		'13': '3gp',
+		'17': 'mp4',
+		'18': 'mp4',
+		'22': 'mp4',
+		'37': 'mp4',
+		'38': 'video', # You actually don't know if this will be MOV, AVI or whatever
+		'43': 'webm',
+		'45': 'webm',
+	}
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(YoutubeIE._VALID_URL, url) is not None)
+
+	def report_lang(self):
+		"""Report attempt to set language."""
+		self._downloader.to_screen(u'[youtube] Setting language')
+
+	def report_login(self):
+		"""Report attempt to log in."""
+		self._downloader.to_screen(u'[youtube] Logging in')
+
+	def report_age_confirmation(self):
+		"""Report attempt to confirm age."""
+		self._downloader.to_screen(u'[youtube] Confirming age')
+
+	def report_video_webpage_download(self, video_id):
+		"""Report attempt to download video webpage."""
+		self._downloader.to_screen(u'[youtube] %s: Downloading video webpage' % video_id)
+
+	def report_video_info_webpage_download(self, video_id):
+		"""Report attempt to download video info webpage."""
+		self._downloader.to_screen(u'[youtube] %s: Downloading video info webpage' % video_id)
+
+	def report_information_extraction(self, video_id):
+		"""Report attempt to extract video information."""
+		self._downloader.to_screen(u'[youtube] %s: Extracting video information' % video_id)
+
+	def report_unavailable_format(self, video_id, format):
+		"""Report extracted video URL."""
+		self._downloader.to_screen(u'[youtube] %s: Format %s not available' % (video_id, format))
+
+	def report_rtmp_download(self):
+		"""Indicate the download will use the RTMP protocol."""
+		self._downloader.to_screen(u'[youtube] RTMP download detected')
+
+	def _real_initialize(self):
+		if self._downloader is None:
+			return
+
+		username = None
+		password = None
+		downloader_params = self._downloader.params
+
+		# Attempt to use provided username and password or .netrc data
+		if downloader_params.get('username', None) is not None:
+			username = downloader_params['username']
+			password = downloader_params['password']
+		elif downloader_params.get('usenetrc', False):
+			try:
+				info = netrc.netrc().authenticators(self._NETRC_MACHINE)
+				if info is not None:
+					username = info[0]
+					password = info[2]
+				else:
+					raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE)
+			except (IOError, netrc.NetrcParseError), err:
+				self._downloader.to_stderr(u'WARNING: parsing .netrc: %s' % str(err))
+				return
+
+		# Set language
+		request = urllib2.Request(self._LANG_URL)
+		try:
+			self.report_lang()
+			urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.to_stderr(u'WARNING: unable to set language: %s' % str(err))
+			return
+
+		# No authentication to be performed
+		if username is None:
+			return
+
+		# Log in
+		login_form = {
+				'current_form': 'loginForm',
+				'next':		'/',
+				'action_login':	'Log In',
+				'username':	username,
+				'password':	password,
+				}
+		request = urllib2.Request(self._LOGIN_URL, urllib.urlencode(login_form))
+		try:
+			self.report_login()
+			login_results = urllib2.urlopen(request).read()
+			if re.search(r'(?i)<form[^>]* name="loginForm"', login_results) is not None:
+				self._downloader.to_stderr(u'WARNING: unable to log in: bad username or password')
+				return
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.to_stderr(u'WARNING: unable to log in: %s' % str(err))
+			return
+
+		# Confirm age
+		age_form = {
+				'next_url':		'/',
+				'action_confirm':	'Confirm',
+				}
+		request = urllib2.Request(self._AGE_URL, urllib.urlencode(age_form))
+		try:
+			self.report_age_confirmation()
+			age_results = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: unable to confirm age: %s' % str(err))
+			return
+
+	def _real_extract(self, url):
+		# Extract video id from URL
+		mobj = re.match(self._VALID_URL, url)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+			return
+		video_id = mobj.group(2)
+
+		# Get video webpage
+		self.report_video_webpage_download(video_id)
+		request = urllib2.Request('http://www.youtube.com/watch?v=%s&gl=US&hl=en&amp;has_verified=1' % video_id)
+		try:
+			video_webpage = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % str(err))
+			return
+
+		# Attempt to extract SWF player URL
+		mobj = re.search(r'swfConfig.*?"(http:\\/\\/.*?watch.*?-.*?\.swf)"', video_webpage)
+		if mobj is not None:
+			player_url = re.sub(r'\\(.)', r'\1', mobj.group(1))
+		else:
+			player_url = None
+
+		# Get video info
+		self.report_video_info_webpage_download(video_id)
+		for el_type in ['&el=embedded', '&el=detailpage', '&el=vevo', '']:
+			video_info_url = ('http://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en'
+					   % (video_id, el_type))
+			request = urllib2.Request(video_info_url)
+			try:
+				video_info_webpage = urllib2.urlopen(request).read()
+				video_info = parse_qs(video_info_webpage)
+				
+				#print "Video_Info", video_info
+				if 'token' in video_info:
+					break
+			except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+				self._downloader.trouble(u'ERROR: unable to download video info webpage: %s' % str(err))
+				return
+		if 'token' not in video_info:
+			if 'reason' in video_info:
+				self._downloader.trouble(u'ERROR: YouTube said: %s' % video_info['reason'][0].decode('utf-8'))
+			else:
+				self._downloader.trouble(u'ERROR: "token" parameter not in video info for unknown reason')
+			return
+
+		# Start extracting information
+		self.report_information_extraction(video_id)
+
+		# uploader
+		if 'author' not in video_info:
+			self._downloader.trouble(u'ERROR: unable to extract uploader nickname')
+			return
+		video_uploader = urllib.unquote_plus(video_info['author'][0])
+
+		# title
+		if 'title' not in video_info:
+			self._downloader.trouble(u'ERROR: unable to extract video title')
+			return
+		video_title = urllib.unquote_plus(video_info['title'][0])
+		video_title = video_title.decode('utf-8')
+		video_title = sanitize_title(video_title)
+
+		# simplified title
+		simple_title = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', video_title)
+		simple_title = simple_title.strip(ur'_')
+
+		# thumbnail image
+		if 'thumbnail_url' not in video_info:
+			self._downloader.trouble(u'WARNING: unable to extract video thumbnail')
+			video_thumbnail = ''
+		else:	# don't panic if we can't find it
+			video_thumbnail = urllib.unquote_plus(video_info['thumbnail_url'][0])
+
+		# upload date
+		upload_date = u'NA'
+		mobj = re.search(r'id="eow-date.*?>(.*?)</span>', video_webpage, re.DOTALL)
+		if mobj is not None:
+			upload_date = ' '.join(re.sub(r'[/,-]', r' ', mobj.group(1)).split())
+			format_expressions = ['%d %B %Y', '%B %d %Y', '%b %d %Y']
+			for expression in format_expressions:
+				try:
+					upload_date = datetime.datetime.strptime(upload_date, expression).strftime('%Y%m%d')
+				except:
+					pass
+
+		# description
+		video_description = 'No description available.'
+		if self._downloader.params.get('forcedescription', False):
+			mobj = re.search(r'<meta name="description" content="(.*)"(?:\s*/)?>', video_webpage)
+			if mobj is not None:
+				video_description = mobj.group(1)
+
+		# token
+		video_token = urllib.unquote_plus(video_info['token'][0])
+
+		# Decide which formats to download
+		req_format = self._downloader.params.get('format', None)
+
+		if 'fmt_url_map' in video_info and len(video_info['fmt_url_map']) >= 1 and ',' in video_info['fmt_url_map'][0]:
+			url_map = dict(tuple(pair.split('|')) for pair in video_info['fmt_url_map'][0].split(','))
+			format_limit = self._downloader.params.get('format_limit', None)
+			if format_limit is not None and format_limit in self._available_formats:
+				format_list = self._available_formats[self._available_formats.index(format_limit):]
+			else:
+				format_list = self._available_formats
+			existing_formats = [x for x in format_list if x in url_map]
+			if len(existing_formats) == 0:
+				self._downloader.trouble(u'ERROR: no known formats available for video')
+				return
+			if req_format is None:
+				video_url_list = [(existing_formats[0], url_map[existing_formats[0]])] # Best quality
+			elif req_format == '-1':
+				video_url_list = [(f, url_map[f]) for f in existing_formats] # All formats
+			else:
+				# Specific format
+				if req_format not in url_map:
+					self._downloader.trouble(u'ERROR: requested format not available')
+					return
+				video_url_list = [(req_format, url_map[req_format])] # Specific format
+
+		elif 'conn' in video_info and video_info['conn'][0].startswith('rtmp'):
+			self.report_rtmp_download()
+			video_url_list = [(None, video_info['conn'][0])]
+
+		else:
+			self._downloader.trouble(u'ERROR: no fmt_url_map or conn information found in video info')
+			return
+
+		for format_param, video_real_url in video_url_list:
+			# At this point we have a new video
+			self._downloader.increment_downloads()
+
+			# Extension
+			video_extension = self._video_extensions.get(format_param, 'flv')
+
+			# Find the video URL in fmt_url_map or conn paramters
+			try:
+				# Process video information
+				self._downloader.process_info({
+					'id':		video_id.decode('utf-8'),
+					'url':		video_real_url.decode('utf-8'),
+					'uploader':	video_uploader.decode('utf-8'),
+					'upload_date':	upload_date,
+					'title':	video_title,
+					'stitle':	simple_title,
+					'ext':		video_extension.decode('utf-8'),
+					'format':	(format_param is None and u'NA' or format_param.decode('utf-8')),
+					'thumbnail':	video_thumbnail.decode('utf-8'),
+					'description':	video_description.decode('utf-8'),
+					'player_url':	player_url,
+				})
+			except UnavailableVideoError, err:
+				self._downloader.trouble(u'\nERROR: unable to download video')
+
+
+class MetacafeIE(InfoExtractor):
+	"""Information Extractor for metacafe.com."""
+
+	_VALID_URL = r'(?:http://)?(?:www\.)?metacafe\.com/watch/([^/]+)/([^/]+)/.*'
+	_DISCLAIMER = 'http://www.metacafe.com/family_filter/'
+	_FILTER_POST = 'http://www.metacafe.com/f/index.php?inputType=filter&controllerGroup=user'
+	_youtube_ie = None
+
+	def __init__(self, youtube_ie, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+		self._youtube_ie = youtube_ie
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(MetacafeIE._VALID_URL, url) is not None)
+
+	def report_disclaimer(self):
+		"""Report disclaimer retrieval."""
+		self._downloader.to_screen(u'[metacafe] Retrieving disclaimer')
+
+	def report_age_confirmation(self):
+		"""Report attempt to confirm age."""
+		self._downloader.to_screen(u'[metacafe] Confirming age')
+
+	def report_download_webpage(self, video_id):
+		"""Report webpage download."""
+		self._downloader.to_screen(u'[metacafe] %s: Downloading webpage' % video_id)
+
+	def report_extraction(self, video_id):
+		"""Report information extraction."""
+		self._downloader.to_screen(u'[metacafe] %s: Extracting information' % video_id)
+
+	def _real_initialize(self):
+		# Retrieve disclaimer
+		request = urllib2.Request(self._DISCLAIMER)
+		try:
+			self.report_disclaimer()
+			disclaimer = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: unable to retrieve disclaimer: %s' % str(err))
+			return
+
+		# Confirm age
+		disclaimer_form = {
+			'filters': '0',
+			'submit': "Continue - I'm over 18",
+			}
+		request = urllib2.Request(self._FILTER_POST, urllib.urlencode(disclaimer_form))
+		try:
+			self.report_age_confirmation()
+			disclaimer = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: unable to confirm age: %s' % str(err))
+			return
+
+	def _real_extract(self, url):
+		# Extract id and simplified title from URL
+		mobj = re.match(self._VALID_URL, url)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+			return
+
+		video_id = mobj.group(1)
+
+		# Check if video comes from YouTube
+		mobj2 = re.match(r'^yt-(.*)$', video_id)
+		if mobj2 is not None:
+			self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % mobj2.group(1))
+			return
+
+		# At this point we have a new video
+		self._downloader.increment_downloads()
+
+		simple_title = mobj.group(2).decode('utf-8')
+
+		# Retrieve video webpage to extract further information
+		request = urllib2.Request('http://www.metacafe.com/watch/%s/' % video_id)
+		try:
+			self.report_download_webpage(video_id)
+			webpage = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: unable retrieve video webpage: %s' % str(err))
+			return
+
+		# Extract URL, uploader and title from webpage
+		self.report_extraction(video_id)
+		mobj = re.search(r'(?m)&mediaURL=([^&]+)', webpage)
+		if mobj is not None:
+			mediaURL = urllib.unquote(mobj.group(1))
+			video_extension = mediaURL[-3:]
+
+			# Extract gdaKey if available
+			mobj = re.search(r'(?m)&gdaKey=(.*?)&', webpage)
+			if mobj is None:
+				video_url = mediaURL
+			else:
+				gdaKey = mobj.group(1)
+				video_url = '%s?__gda__=%s' % (mediaURL, gdaKey)
+		else:
+			mobj = re.search(r' name="flashvars" value="(.*?)"', webpage)
+			if mobj is None:
+				self._downloader.trouble(u'ERROR: unable to extract media URL')
+				return
+			vardict = parse_qs(mobj.group(1))
+			if 'mediaData' not in vardict:
+				self._downloader.trouble(u'ERROR: unable to extract media URL')
+				return
+			mobj = re.search(r'"mediaURL":"(http.*?)","key":"(.*?)"', vardict['mediaData'][0])
+			if mobj is None:
+				self._downloader.trouble(u'ERROR: unable to extract media URL')
+				return
+			mediaURL = mobj.group(1).replace('\\/', '/')
+			video_extension = mediaURL[-3:]
+			video_url = '%s?__gda__=%s' % (mediaURL, mobj.group(2))
+
+		mobj = re.search(r'(?im)<title>(.*) - Video</title>', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract title')
+			return
+		video_title = mobj.group(1).decode('utf-8')
+		video_title = sanitize_title(video_title)
+
+		mobj = re.search(r'(?ms)By:\s*<a .*?>(.+?)<', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract uploader nickname')
+			return
+		video_uploader = mobj.group(1)
+
+		try:
+			# Process video information
+			self._downloader.process_info({
+				'id':		video_id.decode('utf-8'),
+				'url':		video_url.decode('utf-8'),
+				'uploader':	video_uploader.decode('utf-8'),
+				'upload_date':	u'NA',
+				'title':	video_title,
+				'stitle':	simple_title,
+				'ext':		video_extension.decode('utf-8'),
+				'format':	u'NA',
+				'player_url':	None,
+			})
+		except UnavailableVideoError:
+			self._downloader.trouble(u'\nERROR: unable to download video')
+
+
+class DailymotionIE(InfoExtractor):
+	"""Information Extractor for Dailymotion"""
+
+	_VALID_URL = r'(?i)(?:https?://)?(?:www\.)?dailymotion\.[a-z]{2,3}/video/([^_/]+)_([^/]+)'
+
+	def __init__(self, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(DailymotionIE._VALID_URL, url) is not None)
+
+	def report_download_webpage(self, video_id):
+		"""Report webpage download."""
+		self._downloader.to_screen(u'[dailymotion] %s: Downloading webpage' % video_id)
+
+	def report_extraction(self, video_id):
+		"""Report information extraction."""
+		self._downloader.to_screen(u'[dailymotion] %s: Extracting information' % video_id)
+
+	def _real_initialize(self):
+		return
+
+	def _real_extract(self, url):
+		# Extract id and simplified title from URL
+		mobj = re.match(self._VALID_URL, url)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+			return
+
+		# At this point we have a new video
+		self._downloader.increment_downloads()
+		video_id = mobj.group(1)
+
+		simple_title = mobj.group(2).decode('utf-8')
+		video_extension = 'flv'
+
+		# Retrieve video webpage to extract further information
+		request = urllib2.Request(url)
+		try:
+			self.report_download_webpage(video_id)
+			webpage = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: unable retrieve video webpage: %s' % str(err))
+			return
+
+		# Extract URL, uploader and title from webpage
+		self.report_extraction(video_id)
+		mobj = re.search(r'(?i)addVariable\(\"video\"\s*,\s*\"([^\"]*)\"\)', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract media URL')
+			return
+		mediaURL = urllib.unquote(mobj.group(1))
+
+		# if needed add http://www.dailymotion.com/ if relative URL
+
+		video_url = mediaURL
+
+		# '<meta\s+name="title"\s+content="Dailymotion\s*[:\-]\s*(.*?)"\s*\/\s*>'
+		mobj = re.search(r'(?im)<title>Dailymotion\s*[\-:]\s*(.+?)</title>', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract title')
+			return
+		video_title = mobj.group(1).decode('utf-8')
+		video_title = sanitize_title(video_title)
+
+		mobj = re.search(r'(?im)<Attribute name="owner">(.+?)</Attribute>', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract uploader nickname')
+			return
+		video_uploader = mobj.group(1)
+
+		try:
+			# Process video information
+			self._downloader.process_info({
+				'id':		video_id.decode('utf-8'),
+				'url':		video_url.decode('utf-8'),
+				'uploader':	video_uploader.decode('utf-8'),
+				'upload_date':	u'NA',
+				'title':	video_title,
+				'stitle':	simple_title,
+				'ext':		video_extension.decode('utf-8'),
+				'format':	u'NA',
+				'player_url':	None,
+			})
+		except UnavailableVideoError:
+			self._downloader.trouble(u'\nERROR: unable to download video')
+
+class GoogleIE(InfoExtractor):
+	"""Information extractor for video.google.com."""
+
+	_VALID_URL = r'(?:http://)?video\.google\.(?:com(?:\.au)?|co\.(?:uk|jp|kr|cr)|ca|de|es|fr|it|nl|pl)/videoplay\?docid=([^\&]+).*'
+
+	def __init__(self, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(GoogleIE._VALID_URL, url) is not None)
+
+	def report_download_webpage(self, video_id):
+		"""Report webpage download."""
+		self._downloader.to_screen(u'[video.google] %s: Downloading webpage' % video_id)
+
+	def report_extraction(self, video_id):
+		"""Report information extraction."""
+		self._downloader.to_screen(u'[video.google] %s: Extracting information' % video_id)
+
+	def _real_initialize(self):
+		return
+
+	def _real_extract(self, url):
+		# Extract id from URL
+		mobj = re.match(self._VALID_URL, url)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+			return
+
+		# At this point we have a new video
+		self._downloader.increment_downloads()
+		video_id = mobj.group(1)
+
+		video_extension = 'mp4'
+
+		# Retrieve video webpage to extract further information
+		request = urllib2.Request('http://video.google.com/videoplay?docid=%s&hl=en&oe=utf-8' % video_id)
+		try:
+			self.report_download_webpage(video_id)
+			webpage = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % str(err))
+			return
+
+		# Extract URL, uploader, and title from webpage
+		self.report_extraction(video_id)
+		mobj = re.search(r"download_url:'([^']+)'", webpage)
+		if mobj is None:
+			video_extension = 'flv'
+			mobj = re.search(r"(?i)videoUrl\\x3d(.+?)\\x26", webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract media URL')
+			return
+		mediaURL = urllib.unquote(mobj.group(1))
+		mediaURL = mediaURL.replace('\\x3d', '\x3d')
+		mediaURL = mediaURL.replace('\\x26', '\x26')
+
+		video_url = mediaURL
+
+		mobj = re.search(r'<title>(.*)</title>', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract title')
+			return
+		video_title = mobj.group(1).decode('utf-8')
+		video_title = sanitize_title(video_title)
+		simple_title = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', video_title)
+
+		# Extract video description
+		mobj = re.search(r'<span id=short-desc-content>([^<]*)</span>', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract video description')
+			return
+		video_description = mobj.group(1).decode('utf-8')
+		if not video_description:
+			video_description = 'No description available.'
+
+		# Extract video thumbnail
+		if self._downloader.params.get('forcethumbnail', False):
+			request = urllib2.Request('http://video.google.com/videosearch?q=%s+site:video.google.com&hl=en' % abs(int(video_id)))
+			try:
+				webpage = urllib2.urlopen(request).read()
+			except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+				self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % str(err))
+				return
+			mobj = re.search(r'<img class=thumbnail-img (?:.* )?src=(http.*)>', webpage)
+			if mobj is None:
+				self._downloader.trouble(u'ERROR: unable to extract video thumbnail')
+				return
+			video_thumbnail = mobj.group(1)
+		else:	# we need something to pass to process_info
+			video_thumbnail = ''
+
+
+		try:
+			# Process video information
+			self._downloader.process_info({
+				'id':		video_id.decode('utf-8'),
+				'url':		video_url.decode('utf-8'),
+				'uploader':	u'NA',
+				'upload_date':	u'NA',
+				'title':	video_title,
+				'stitle':	simple_title,
+				'ext':		video_extension.decode('utf-8'),
+				'format':	u'NA',
+				'player_url':	None,
+			})
+		except UnavailableVideoError:
+			self._downloader.trouble(u'\nERROR: unable to download video')
+
+
+class PhotobucketIE(InfoExtractor):
+	"""Information extractor for photobucket.com."""
+
+	_VALID_URL = r'(?:http://)?(?:[a-z0-9]+\.)?photobucket\.com/.*[\?\&]current=(.*\.flv)'
+
+	def __init__(self, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(PhotobucketIE._VALID_URL, url) is not None)
+
+	def report_download_webpage(self, video_id):
+		"""Report webpage download."""
+		self._downloader.to_screen(u'[photobucket] %s: Downloading webpage' % video_id)
+
+	def report_extraction(self, video_id):
+		"""Report information extraction."""
+		self._downloader.to_screen(u'[photobucket] %s: Extracting information' % video_id)
+
+	def _real_initialize(self):
+		return
+
+	def _real_extract(self, url):
+		# Extract id from URL
+		mobj = re.match(self._VALID_URL, url)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+			return
+
+		# At this point we have a new video
+		self._downloader.increment_downloads()
+		video_id = mobj.group(1)
+
+		video_extension = 'flv'
+
+		# Retrieve video webpage to extract further information
+		request = urllib2.Request(url)
+		try:
+			self.report_download_webpage(video_id)
+			webpage = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % str(err))
+			return
+
+		# Extract URL, uploader, and title from webpage
+		self.report_extraction(video_id)
+		mobj = re.search(r'<link rel="video_src" href=".*\?file=([^"]+)" />', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract media URL')
+			return
+		mediaURL = urllib.unquote(mobj.group(1))
+
+		video_url = mediaURL
+
+		mobj = re.search(r'<title>(.*) video by (.*) - Photobucket</title>', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract title')
+			return
+		video_title = mobj.group(1).decode('utf-8')
+		video_title = sanitize_title(video_title)
+		simple_title = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', video_title)
+
+		video_uploader = mobj.group(2).decode('utf-8')
+
+		try:
+			# Process video information
+			self._downloader.process_info({
+				'id':		video_id.decode('utf-8'),
+				'url':		video_url.decode('utf-8'),
+				'uploader':	video_uploader,
+				'upload_date':	u'NA',
+				'title':	video_title,
+				'stitle':	simple_title,
+				'ext':		video_extension.decode('utf-8'),
+				'format':	u'NA',
+				'player_url':	None,
+			})
+		except UnavailableVideoError:
+			self._downloader.trouble(u'\nERROR: unable to download video')
+
+
+class YahooIE(InfoExtractor):
+	"""Information extractor for video.yahoo.com."""
+
+	# _VALID_URL matches all Yahoo! Video URLs
+	# _VPAGE_URL matches only the extractable '/watch/' URLs
+	_VALID_URL = r'(?:http://)?(?:[a-z]+\.)?video\.yahoo\.com/(?:watch|network)/([0-9]+)(?:/|\?v=)([0-9]+)(?:[#\?].*)?'
+	_VPAGE_URL = r'(?:http://)?video\.yahoo\.com/watch/([0-9]+)/([0-9]+)(?:[#\?].*)?'
+
+	def __init__(self, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(YahooIE._VALID_URL, url) is not None)
+
+	def report_download_webpage(self, video_id):
+		"""Report webpage download."""
+		self._downloader.to_screen(u'[video.yahoo] %s: Downloading webpage' % video_id)
+
+	def report_extraction(self, video_id):
+		"""Report information extraction."""
+		self._downloader.to_screen(u'[video.yahoo] %s: Extracting information' % video_id)
+
+	def _real_initialize(self):
+		return
+
+	def _real_extract(self, url, new_video=True):
+		# Extract ID from URL
+		mobj = re.match(self._VALID_URL, url)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+			return
+
+		# At this point we have a new video
+		self._downloader.increment_downloads()
+		video_id = mobj.group(2)
+		video_extension = 'flv'
+
+		# Rewrite valid but non-extractable URLs as
+		# extractable English language /watch/ URLs
+		if re.match(self._VPAGE_URL, url) is None:
+			request = urllib2.Request(url)
+			try:
+				webpage = urllib2.urlopen(request).read()
+			except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+				self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % str(err))
+				return
+
+			mobj = re.search(r'\("id", "([0-9]+)"\);', webpage)
+			if mobj is None:
+				self._downloader.trouble(u'ERROR: Unable to extract id field')
+				return
+			yahoo_id = mobj.group(1)
+
+			mobj = re.search(r'\("vid", "([0-9]+)"\);', webpage)
+			if mobj is None:
+				self._downloader.trouble(u'ERROR: Unable to extract vid field')
+				return
+			yahoo_vid = mobj.group(1)
+
+			url = 'http://video.yahoo.com/watch/%s/%s' % (yahoo_vid, yahoo_id)
+			return self._real_extract(url, new_video=False)
+
+		# Retrieve video webpage to extract further information
+		request = urllib2.Request(url)
+		try:
+			self.report_download_webpage(video_id)
+			webpage = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % str(err))
+			return
+
+		# Extract uploader and title from webpage
+		self.report_extraction(video_id)
+		mobj = re.search(r'<meta name="title" content="(.*)" />', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract video title')
+			return
+		video_title = mobj.group(1).decode('utf-8')
+		simple_title = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', video_title)
+
+		mobj = re.search(r'<h2 class="ti-5"><a href="http://video\.yahoo\.com/(people|profile)/[0-9]+" beacon=".*">(.*)</a></h2>', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract video uploader')
+			return
+		video_uploader = mobj.group(1).decode('utf-8')
+
+		# Extract video thumbnail
+		mobj = re.search(r'<link rel="image_src" href="(.*)" />', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract video thumbnail')
+			return
+		video_thumbnail = mobj.group(1).decode('utf-8')
+
+		# Extract video description
+		mobj = re.search(r'<meta name="description" content="(.*)" />', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract video description')
+			return
+		video_description = mobj.group(1).decode('utf-8')
+		if not video_description: video_description = 'No description available.'
+
+		# Extract video height and width
+		mobj = re.search(r'<meta name="video_height" content="([0-9]+)" />', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract video height')
+			return
+		yv_video_height = mobj.group(1)
+
+		mobj = re.search(r'<meta name="video_width" content="([0-9]+)" />', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract video width')
+			return
+		yv_video_width = mobj.group(1)
+
+		# Retrieve video playlist to extract media URL
+		# I'm not completely sure what all these options are, but we
+		# seem to need most of them, otherwise the server sends a 401.
+		yv_lg = 'R0xx6idZnW2zlrKP8xxAIR'  # not sure what this represents
+		yv_bitrate = '700'  # according to Wikipedia this is hard-coded
+		request = urllib2.Request('http://cosmos.bcst.yahoo.com/up/yep/process/getPlaylistFOP.php?node_id=' + video_id +
+				          '&tech=flash&mode=playlist&lg=' + yv_lg + '&bitrate=' + yv_bitrate + '&vidH=' + yv_video_height +
+					  '&vidW=' + yv_video_width + '&swf=as3&rd=video.yahoo.com&tk=null&adsupported=v1,v2,&eventid=1301797')
+		try:
+			self.report_download_webpage(video_id)
+			webpage = urllib2.urlopen(request).read()
+			#print "Request" + request
+			#print "Webpage" + webpage
+
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % str(err))
+			return
+
+		# Extract media URL from playlist XML
+		mobj = re.search(r'<STREAM APP="(http://.*)" FULLPATH="/?(/.*\.flv\?[^"]*)"', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: Unable to extract media URL')
+			return
+		video_url = urllib.unquote(mobj.group(1) + mobj.group(2)).decode('utf-8')
+		video_url = re.sub(r'(?u)&(.+?);', htmlentity_transform, video_url)
+
+		try:
+			# Process video information
+			self._downloader.process_info({
+				'id':		video_id.decode('utf-8'),
+				'url':		video_url,
+				'uploader':	video_uploader,
+				'upload_date':	u'NA',
+				'title':	video_title,
+				'stitle':	simple_title,
+				'ext':		video_extension.decode('utf-8'),
+				'thumbnail':	video_thumbnail.decode('utf-8'),
+				'description':	video_description,
+				'thumbnail':	video_thumbnail,
+				'description':	video_description,
+				'player_url':	None,
+			})
+		except UnavailableVideoError:
+			self._downloader.trouble(u'\nERROR: unable to download video')
+
+
+class GenericIE(InfoExtractor):
+	"""Generic last-resort information extractor."""
+
+	def __init__(self, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+
+	@staticmethod
+	def suitable(url):
+		return True
+
+	def report_download_webpage(self, video_id):
+		"""Report webpage download."""
+		self._downloader.to_screen(u'WARNING: Falling back on generic information extractor.')
+		self._downloader.to_screen(u'[generic] %s: Downloading webpage' % video_id)
+
+	def report_extraction(self, video_id):
+		"""Report information extraction."""
+		self._downloader.to_screen(u'[generic] %s: Extracting information' % video_id)
+
+	def _real_initialize(self):
+		return
+
+	def _real_extract(self, url):
+		# At this point we have a new video
+		self._downloader.increment_downloads()
+
+		video_id = url.split('/')[-1]
+		request = urllib2.Request(url)
+		try:
+			self.report_download_webpage(video_id)
+			webpage = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % str(err))
+			return
+		except ValueError, err:
+			# since this is the last-resort InfoExtractor, if
+			# this error is thrown, it'll be thrown here
+			self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+			return
+
+		self.report_extraction(video_id)
+		# Start with something easy: JW Player in SWFObject
+		mobj = re.search(r'flashvars: [\'"](?:.*&)?file=(http[^\'"&]*)', webpage)
+		if mobj is None:
+			# Broaden the search a little bit
+			mobj = re.search(r'[^A-Za-z0-9]?(?:file|source)=(http[^\'"&]*)', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+			return
+
+		# It's possible that one of the regexes
+		# matched, but returned an empty group:
+		if mobj.group(1) is None:
+			self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+			return
+
+		video_url = urllib.unquote(mobj.group(1))
+		video_id  = os.path.basename(video_url)
+
+		# here's a fun little line of code for you:
+		video_extension = os.path.splitext(video_id)[1][1:]
+		video_id        = os.path.splitext(video_id)[0]
+
+		# it's tempting to parse this further, but you would
+		# have to take into account all the variations like
+		#   Video Title - Site Name
+		#   Site Name | Video Title
+		#   Video Title - Tagline | Site Name
+		# and so on and so forth; it's just not practical
+		mobj = re.search(r'<title>(.*)</title>', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract title')
+			return
+		video_title = mobj.group(1).decode('utf-8')
+		video_title = sanitize_title(video_title)
+		simple_title = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', video_title)
+
+		# video uploader is domain name
+		mobj = re.match(r'(?:https?://)?([^/]*)/.*', url)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract title')
+			return
+		video_uploader = mobj.group(1).decode('utf-8')
+
+		try:
+			# Process video information
+			self._downloader.process_info({
+				'id':		video_id.decode('utf-8'),
+				'url':		video_url.decode('utf-8'),
+				'uploader':	video_uploader,
+				'upload_date':	u'NA',
+				'title':	video_title,
+				'stitle':	simple_title,
+				'ext':		video_extension.decode('utf-8'),
+				'format':	u'NA',
+				'player_url':	None,
+			})
+		except UnavailableVideoError, err:
+			self._downloader.trouble(u'\nERROR: unable to download video')
+
+
+class YoutubeSearchIE(InfoExtractor):
+	"""Information Extractor for YouTube search queries."""
+	_VALID_QUERY = r'ytsearch(\d+|all)?:[\s\S]+'
+	_TEMPLATE_URL = 'http://www.youtube.com/results?search_query=%s&page=%s&gl=US&hl=en'
+	_VIDEO_INDICATOR = r'href="/watch\?v=.+?"'
+	_MORE_PAGES_INDICATOR = r'(?m)>\s*Next\s*</a>'
+	_youtube_ie = None
+	_max_youtube_results = 1000
+
+	def __init__(self, youtube_ie, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+		self._youtube_ie = youtube_ie
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(YoutubeSearchIE._VALID_QUERY, url) is not None)
+
+	def report_download_page(self, query, pagenum):
+		"""Report attempt to download playlist page with given number."""
+		query = query.decode(preferredencoding())
+		self._downloader.to_screen(u'[youtube] query "%s": Downloading page %s' % (query, pagenum))
+
+	def _real_initialize(self):
+		self._youtube_ie.initialize()
+
+	def _real_extract(self, query):
+		mobj = re.match(self._VALID_QUERY, query)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: invalid search query "%s"' % query)
+			return
+
+		prefix, query = query.split(':')
+		prefix = prefix[8:]
+		query  = query.encode('utf-8')
+		if prefix == '':
+			self._download_n_results(query, 1)
+			return
+		elif prefix == 'all':
+			self._download_n_results(query, self._max_youtube_results)
+			return
+		else:
+			try:
+				n = long(prefix)
+				if n <= 0:
+					self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query))
+					return
+				elif n > self._max_youtube_results:
+					self._downloader.to_stderr(u'WARNING: ytsearch returns max %i results (you requested %i)'  % (self._max_youtube_results, n))
+					n = self._max_youtube_results
+				self._download_n_results(query, n)
+				return
+			except ValueError: # parsing prefix as integer fails
+				self._download_n_results(query, 1)
+				return
+
+	def _download_n_results(self, query, n):
+		"""Downloads a specified number of results for a query"""
+
+		video_ids = []
+		already_seen = set()
+		pagenum = 1
+
+		while True:
+			self.report_download_page(query, pagenum)
+			result_url = self._TEMPLATE_URL % (urllib.quote_plus(query), pagenum)
+			request = urllib2.Request(result_url)
+			try:
+				page = urllib2.urlopen(request).read()
+			except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+				self._downloader.trouble(u'ERROR: unable to download webpage: %s' % str(err))
+				return
+
+			# Extract video identifiers
+			for mobj in re.finditer(self._VIDEO_INDICATOR, page):
+				video_id = page[mobj.span()[0]:mobj.span()[1]].split('=')[2][:-1]
+				if video_id not in already_seen:
+					video_ids.append(video_id)
+					already_seen.add(video_id)
+					if len(video_ids) == n:
+						# Specified n videos reached
+						for id in video_ids:
+							self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % id)
+						return
+
+			if re.search(self._MORE_PAGES_INDICATOR, page) is None:
+				for id in video_ids:
+					self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % id)
+				return
+
+			pagenum = pagenum + 1
+
+class GoogleSearchIE(InfoExtractor):
+	"""Information Extractor for Google Video search queries."""
+	_VALID_QUERY = r'gvsearch(\d+|all)?:[\s\S]+'
+	_TEMPLATE_URL = 'http://video.google.com/videosearch?q=%s+site:video.google.com&start=%s&hl=en'
+	_VIDEO_INDICATOR = r'videoplay\?docid=([^\&>]+)\&'
+	_MORE_PAGES_INDICATOR = r'<span>Next</span>'
+	_google_ie = None
+	_max_google_results = 1000
+
+	def __init__(self, google_ie, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+		self._google_ie = google_ie
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(GoogleSearchIE._VALID_QUERY, url) is not None)
+
+	def report_download_page(self, query, pagenum):
+		"""Report attempt to download playlist page with given number."""
+		query = query.decode(preferredencoding())
+		self._downloader.to_screen(u'[video.google] query "%s": Downloading page %s' % (query, pagenum))
+
+	def _real_initialize(self):
+		self._google_ie.initialize()
+
+	def _real_extract(self, query):
+		mobj = re.match(self._VALID_QUERY, query)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: invalid search query "%s"' % query)
+			return
+
+		prefix, query = query.split(':')
+		prefix = prefix[8:]
+		query  = query.encode('utf-8')
+		if prefix == '':
+			self._download_n_results(query, 1)
+			return
+		elif prefix == 'all':
+			self._download_n_results(query, self._max_google_results)
+			return
+		else:
+			try:
+				n = long(prefix)
+				if n <= 0:
+					self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query))
+					return
+				elif n > self._max_google_results:
+					self._downloader.to_stderr(u'WARNING: gvsearch returns max %i results (you requested %i)'  % (self._max_google_results, n))
+					n = self._max_google_results
+				self._download_n_results(query, n)
+				return
+			except ValueError: # parsing prefix as integer fails
+				self._download_n_results(query, 1)
+				return
+
+	def _download_n_results(self, query, n):
+		"""Downloads a specified number of results for a query"""
+
+		video_ids = []
+		already_seen = set()
+		pagenum = 1
+
+		while True:
+			self.report_download_page(query, pagenum)
+			result_url = self._TEMPLATE_URL % (urllib.quote_plus(query), pagenum)
+			request = urllib2.Request(result_url)
+			try:
+				page = urllib2.urlopen(request).read()
+			except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+				self._downloader.trouble(u'ERROR: unable to download webpage: %s' % str(err))
+				return
+
+			# Extract video identifiers
+			for mobj in re.finditer(self._VIDEO_INDICATOR, page):
+				video_id = mobj.group(1)
+				if video_id not in already_seen:
+					video_ids.append(video_id)
+					already_seen.add(video_id)
+					if len(video_ids) == n:
+						# Specified n videos reached
+						for id in video_ids:
+							self._google_ie.extract('http://video.google.com/videoplay?docid=%s' % id)
+						return
+
+			if re.search(self._MORE_PAGES_INDICATOR, page) is None:
+				for id in video_ids:
+					self._google_ie.extract('http://video.google.com/videoplay?docid=%s' % id)
+				return
+
+			pagenum = pagenum + 1
+
+class YahooSearchIE(InfoExtractor):
+	"""Information Extractor for Yahoo! Video search queries."""
+	_VALID_QUERY = r'yvsearch(\d+|all)?:[\s\S]+'
+	_TEMPLATE_URL = 'http://video.yahoo.com/search/?p=%s&o=%s'
+	_VIDEO_INDICATOR = r'href="http://video\.yahoo\.com/watch/([0-9]+/[0-9]+)"'
+	_MORE_PAGES_INDICATOR = r'\s*Next'
+	_yahoo_ie = None
+	_max_yahoo_results = 1000
+
+	def __init__(self, yahoo_ie, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+		self._yahoo_ie = yahoo_ie
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(YahooSearchIE._VALID_QUERY, url) is not None)
+
+	def report_download_page(self, query, pagenum):
+		"""Report attempt to download playlist page with given number."""
+		query = query.decode(preferredencoding())
+		self._downloader.to_screen(u'[video.yahoo] query "%s": Downloading page %s' % (query, pagenum))
+
+	def _real_initialize(self):
+		self._yahoo_ie.initialize()
+
+	def _real_extract(self, query):
+		mobj = re.match(self._VALID_QUERY, query)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: invalid search query "%s"' % query)
+			return
+
+		prefix, query = query.split(':')
+		prefix = prefix[8:]
+		query  = query.encode('utf-8')
+		if prefix == '':
+			self._download_n_results(query, 1)
+			return
+		elif prefix == 'all':
+			self._download_n_results(query, self._max_yahoo_results)
+			return
+		else:
+			try:
+				n = long(prefix)
+				if n <= 0:
+					self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query))
+					return
+				elif n > self._max_yahoo_results:
+					self._downloader.to_stderr(u'WARNING: yvsearch returns max %i results (you requested %i)'  % (self._max_yahoo_results, n))
+					n = self._max_yahoo_results
+				self._download_n_results(query, n)
+				return
+			except ValueError: # parsing prefix as integer fails
+				self._download_n_results(query, 1)
+				return
+
+	def _download_n_results(self, query, n):
+		"""Downloads a specified number of results for a query"""
+
+		video_ids = []
+		already_seen = set()
+		pagenum = 1
+
+		while True:
+			self.report_download_page(query, pagenum)
+			result_url = self._TEMPLATE_URL % (urllib.quote_plus(query), pagenum)
+			request = urllib2.Request(result_url)
+			try:
+				page = urllib2.urlopen(request).read()
+			except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+				self._downloader.trouble(u'ERROR: unable to download webpage: %s' % str(err))
+				return
+
+			# Extract video identifiers
+			for mobj in re.finditer(self._VIDEO_INDICATOR, page):
+				video_id = mobj.group(1)
+				if video_id not in already_seen:
+					video_ids.append(video_id)
+					already_seen.add(video_id)
+					if len(video_ids) == n:
+						# Specified n videos reached
+						for id in video_ids:
+							self._yahoo_ie.extract('http://video.yahoo.com/watch/%s' % id)
+						return
+
+			if re.search(self._MORE_PAGES_INDICATOR, page) is None:
+				for id in video_ids:
+					self._yahoo_ie.extract('http://video.yahoo.com/watch/%s' % id)
+				return
+
+			pagenum = pagenum + 1
+
+class YoutubePlaylistIE(InfoExtractor):
+	"""Information Extractor for YouTube playlists."""
+
+	_VALID_URL = r'(?:http://)?(?:\w+\.)?youtube.com/(?:(?:view_play_list|my_playlists|artist)\?.*?(p|a)=|user/.*?/user/|p/|user/.*?#[pg]/c/)([0-9A-Za-z]+)(?:/.*?/([0-9A-Za-z_-]+))?.*'
+	_TEMPLATE_URL = 'http://www.youtube.com/%s?%s=%s&page=%s&gl=US&hl=en'
+	_VIDEO_INDICATOR = r'/watch\?v=(.+?)&'
+	_MORE_PAGES_INDICATOR = r'(?m)>\s*Next\s*</a>'
+	_youtube_ie = None
+
+	def __init__(self, youtube_ie, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+		self._youtube_ie = youtube_ie
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(YoutubePlaylistIE._VALID_URL, url) is not None)
+
+	def report_download_page(self, playlist_id, pagenum):
+		"""Report attempt to download playlist page with given number."""
+		self._downloader.to_screen(u'[youtube] PL %s: Downloading page #%s' % (playlist_id, pagenum))
+
+	def _real_initialize(self):
+		self._youtube_ie.initialize()
+
+	def _real_extract(self, url):
+		# Extract playlist id
+		mobj = re.match(self._VALID_URL, url)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: invalid url: %s' % url)
+			return
+
+		# Single video case
+		if mobj.group(3) is not None:
+			self._youtube_ie.extract(mobj.group(3))
+			return
+
+		# Download playlist pages
+		# prefix is 'p' as default for playlists but there are other types that need extra care
+		playlist_prefix = mobj.group(1)
+		if playlist_prefix == 'a':
+			playlist_access = 'artist'
+		else:
+			playlist_prefix = 'p'
+			playlist_access = 'view_play_list'
+		playlist_id = mobj.group(2)
+		video_ids = []
+		pagenum = 1
+
+		while True:
+			self.report_download_page(playlist_id, pagenum)
+			request = urllib2.Request(self._TEMPLATE_URL % (playlist_access, playlist_prefix, playlist_id, pagenum))
+			try:
+				page = urllib2.urlopen(request).read()
+			except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+				self._downloader.trouble(u'ERROR: unable to download webpage: %s' % str(err))
+				return
+
+			# Extract video identifiers
+			ids_in_page = []
+			for mobj in re.finditer(self._VIDEO_INDICATOR, page):
+				if mobj.group(1) not in ids_in_page:
+					ids_in_page.append(mobj.group(1))
+			video_ids.extend(ids_in_page)
+
+			if re.search(self._MORE_PAGES_INDICATOR, page) is None:
+				break
+			pagenum = pagenum + 1
+
+		playliststart = self._downloader.params.get('playliststart', 1) - 1
+		playlistend = self._downloader.params.get('playlistend', -1)
+		video_ids = video_ids[playliststart:playlistend]
+
+		for id in video_ids:
+			self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % id)
+		return
+
+class YoutubeUserIE(InfoExtractor):
+	"""Information Extractor for YouTube users."""
+
+	_VALID_URL = r'(?:(?:(?:http://)?(?:\w+\.)?youtube.com/user/)|ytuser:)([A-Za-z0-9_-]+)'
+	_TEMPLATE_URL = 'http://gdata.youtube.com/feeds/api/users/%s'
+	_GDATA_PAGE_SIZE = 50
+	_GDATA_URL = 'http://gdata.youtube.com/feeds/api/users/%s/uploads?max-results=%d&start-index=%d'
+	_VIDEO_INDICATOR = r'/watch\?v=(.+?)&'
+	_youtube_ie = None
+
+	def __init__(self, youtube_ie, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+		self._youtube_ie = youtube_ie
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(YoutubeUserIE._VALID_URL, url) is not None)
+
+	def report_download_page(self, username, start_index):
+		"""Report attempt to download user page."""
+		self._downloader.to_screen(u'[youtube] user %s: Downloading video ids from %d to %d' %
+				           (username, start_index, start_index + self._GDATA_PAGE_SIZE))
+
+	def _real_initialize(self):
+		self._youtube_ie.initialize()
+
+	def _real_extract(self, url):
+		# Extract username
+		mobj = re.match(self._VALID_URL, url)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: invalid url: %s' % url)
+			return
+
+		username = mobj.group(1)
+
+		# Download video ids using YouTube Data API. Result size per
+		# query is limited (currently to 50 videos) so we need to query
+		# page by page until there are no video ids - it means we got
+		# all of them.
+
+		video_ids = []
+		pagenum = 0
+
+		while True:
+			start_index = pagenum * self._GDATA_PAGE_SIZE + 1
+			self.report_download_page(username, start_index)
+
+			request = urllib2.Request(self._GDATA_URL % (username, self._GDATA_PAGE_SIZE, start_index))
+
+			try:
+				page = urllib2.urlopen(request).read()
+			except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+				self._downloader.trouble(u'ERROR: unable to download webpage: %s' % str(err))
+				return
+
+			# Extract video identifiers
+			ids_in_page = []
+
+			for mobj in re.finditer(self._VIDEO_INDICATOR, page):
+				if mobj.group(1) not in ids_in_page:
+					ids_in_page.append(mobj.group(1))
+
+			video_ids.extend(ids_in_page)
+
+			# A little optimization - if current page is not
+			# "full", ie. does not contain PAGE_SIZE video ids then
+			# we can assume that this page is the last one - there
+			# are no more ids on further pages - no need to query
+			# again.
+
+			if len(ids_in_page) < self._GDATA_PAGE_SIZE:
+				break
+
+			pagenum += 1
+
+		all_ids_count = len(video_ids)
+		playliststart = self._downloader.params.get('playliststart', 1) - 1
+		playlistend = self._downloader.params.get('playlistend', -1)
+
+		if playlistend == -1:
+			video_ids = video_ids[playliststart:]
+		else:
+			video_ids = video_ids[playliststart:playlistend]
+
+		self._downloader.to_screen("[youtube] user %s: Collected %d video ids (downloading %d of them)" %
+				           (username, all_ids_count, len(video_ids)))
+
+		for video_id in video_ids:
+			self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % video_id)
+
+
+class DepositFilesIE(InfoExtractor):
+	"""Information extractor for depositfiles.com"""
+
+	_VALID_URL = r'(?:http://)?(?:\w+\.)?depositfiles.com/(?:../(?#locale))?files/(.+)'
+
+	def __init__(self, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(DepositFilesIE._VALID_URL, url) is not None)
+
+	def report_download_webpage(self, file_id):
+		"""Report webpage download."""
+		self._downloader.to_screen(u'[DepositFiles] %s: Downloading webpage' % file_id)
+
+	def report_extraction(self, file_id):
+		"""Report information extraction."""
+		self._downloader.to_screen(u'[DepositFiles] %s: Extracting information' % file_id)
+
+	def _real_initialize(self):
+		return
+
+	def _real_extract(self, url):
+		# At this point we have a new file
+		self._downloader.increment_downloads()
+
+		file_id = url.split('/')[-1]
+		# Rebuild url in english locale
+		url = 'http://depositfiles.com/en/files/' + file_id
+
+		# Retrieve file webpage with 'Free download' button pressed
+		free_download_indication = { 'gateway_result' : '1' }
+		request = urllib2.Request(url, urllib.urlencode(free_download_indication))
+		try:
+			self.report_download_webpage(file_id)
+			webpage = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: Unable to retrieve file webpage: %s' % str(err))
+			return
+
+		# Search for the real file URL
+		mobj = re.search(r'<form action="(http://fileshare.+?)"', webpage)
+		if (mobj is None) or (mobj.group(1) is None):
+			# Try to figure out reason of the error.
+			mobj = re.search(r'<strong>(Attention.*?)</strong>', webpage, re.DOTALL)
+			if (mobj is not None) and (mobj.group(1) is not None):
+				restriction_message = re.sub('\s+', ' ', mobj.group(1)).strip()
+				self._downloader.trouble(u'ERROR: %s' % restriction_message)
+			else:
+				self._downloader.trouble(u'ERROR: unable to extract download URL from: %s' % url)
+			return
+
+		file_url = mobj.group(1)
+		file_extension = os.path.splitext(file_url)[1][1:]
+
+		# Search for file title
+		mobj = re.search(r'<b title="(.*?)">', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract title')
+			return
+		file_title = mobj.group(1).decode('utf-8')
+
+		try:
+			# Process file information
+			self._downloader.process_info({
+				'id':		file_id.decode('utf-8'),
+				'url':		file_url.decode('utf-8'),
+				'uploader':	u'NA',
+				'upload_date':	u'NA',
+				'title':	file_title,
+				'stitle':	file_title,
+				'ext':		file_extension.decode('utf-8'),
+				'format':	u'NA',
+				'player_url':	None,
+			})
+		except UnavailableVideoError, err:
+			self._downloader.trouble(u'ERROR: unable to download file')
+
+class FacebookIE(InfoExtractor):
+	"""Information Extractor for Facebook"""
+
+	_VALID_URL = r'^(?:https?://)?(?:\w+\.)?facebook.com/video/video.php\?(?:.*?)v=(?P<ID>\d+)(?:.*)'
+	_LOGIN_URL = 'https://login.facebook.com/login.php?m&next=http%3A%2F%2Fm.facebook.com%2Fhome.php&'
+	_NETRC_MACHINE = 'facebook'
+	_available_formats = ['highqual', 'lowqual']
+	_video_extensions = {
+		'highqual': 'mp4',
+		'lowqual': 'mp4',
+	}
+
+	def __init__(self, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+
+	@staticmethod
+	def suitable(url):
+		return (re.match(FacebookIE._VALID_URL, url) is not None)
+
+	def _reporter(self, message):
+		"""Add header and report message."""
+		self._downloader.to_screen(u'[facebook] %s' % message)
+
+	def report_login(self):
+		"""Report attempt to log in."""
+		self._reporter(u'Logging in')
+
+	def report_video_webpage_download(self, video_id):
+		"""Report attempt to download video webpage."""
+		self._reporter(u'%s: Downloading video webpage' % video_id)
+
+	def report_information_extraction(self, video_id):
+		"""Report attempt to extract video information."""
+		self._reporter(u'%s: Extracting video information' % video_id)
+
+	def _parse_page(self, video_webpage):
+		"""Extract video information from page"""
+		# General data
+		data = {'title': r'class="video_title datawrap">(.*?)</',
+			'description': r'<div class="datawrap">(.*?)</div>',
+			'owner': r'\("video_owner_name", "(.*?)"\)',
+			'upload_date': r'data-date="(.*?)"',
+			'thumbnail':  r'\("thumb_url", "(?P<THUMB>.*?)"\)',
+			}
+		video_info = {}
+		for piece in data.keys():
+			mobj = re.search(data[piece], video_webpage)
+			if mobj is not None:
+				video_info[piece] = urllib.unquote_plus(mobj.group(1).decode("unicode_escape"))
+
+		# Video urls
+		video_urls = {}
+		for fmt in self._available_formats:
+			mobj = re.search(r'\("%s_src\", "(.+?)"\)' % fmt, video_webpage)
+			if mobj is not None:
+				# URL is in a Javascript segment inside an escaped Unicode format within
+				# the generally utf-8 page
+				video_urls[fmt] = urllib.unquote_plus(mobj.group(1).decode("unicode_escape"))
+		video_info['video_urls'] = video_urls
+
+		return video_info
+
+	def _real_initialize(self):
+		if self._downloader is None:
+			return
+
+		useremail = None
+		password = None
+		downloader_params = self._downloader.params
+
+		# Attempt to use provided username and password or .netrc data
+		if downloader_params.get('username', None) is not None:
+			useremail = downloader_params['username']
+			password = downloader_params['password']
+		elif downloader_params.get('usenetrc', False):
+			try:
+				info = netrc.netrc().authenticators(self._NETRC_MACHINE)
+				if info is not None:
+					useremail = info[0]
+					password = info[2]
+				else:
+					raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE)
+			except (IOError, netrc.NetrcParseError), err:
+				self._downloader.to_stderr(u'WARNING: parsing .netrc: %s' % str(err))
+				return
+
+		if useremail is None:
+			return
+
+		# Log in
+		login_form = {
+			'email': useremail,
+			'pass': password,
+			'login': 'Log+In'
+			}
+		request = urllib2.Request(self._LOGIN_URL, urllib.urlencode(login_form))
+		try:
+			self.report_login()
+			login_results = urllib2.urlopen(request).read()
+			if re.search(r'<form(.*)name="login"(.*)</form>', login_results) is not None:
+				self._downloader.to_stderr(u'WARNING: unable to log in: bad username/password, or exceded login rate limit (~3/min). Check credentials or wait.')
+				return
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.to_stderr(u'WARNING: unable to log in: %s' % str(err))
+			return
+
+	def _real_extract(self, url):
+		mobj = re.match(self._VALID_URL, url)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+			return
+		video_id = mobj.group('ID')
+
+		# Get video webpage
+		self.report_video_webpage_download(video_id)
+		request = urllib2.Request('https://www.facebook.com/video/video.php?v=%s' % video_id)
+		try:
+			page = urllib2.urlopen(request)
+			video_webpage = page.read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % str(err))
+			return
+
+		# Start extracting information
+		self.report_information_extraction(video_id)
+
+		# Extract information
+		video_info = self._parse_page(video_webpage)
+
+		# uploader
+		if 'owner' not in video_info:
+			self._downloader.trouble(u'ERROR: unable to extract uploader nickname')
+			return
+		video_uploader = video_info['owner']
+
+		# title
+		if 'title' not in video_info:
+			self._downloader.trouble(u'ERROR: unable to extract video title')
+			return
+		video_title = video_info['title']
+		video_title = video_title.decode('utf-8')
+		video_title = sanitize_title(video_title)
+
+		# simplified title
+		simple_title = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', video_title)
+		simple_title = simple_title.strip(ur'_')
+
+		# thumbnail image
+		if 'thumbnail' not in video_info:
+			self._downloader.trouble(u'WARNING: unable to extract video thumbnail')
+			video_thumbnail = ''
+		else:
+			video_thumbnail = video_info['thumbnail']
+
+		# upload date
+		upload_date = u'NA'
+		if 'upload_date' in video_info:
+			upload_time = video_info['upload_date']
+			timetuple = email.utils.parsedate_tz(upload_time)
+			if timetuple is not None:
+				try:
+					upload_date = time.strftime('%Y%m%d', timetuple[0:9])
+				except:
+					pass
+
+		# description
+		video_description = 'No description available.'
+		if (self._downloader.params.get('forcedescription', False) and
+		    'description' in video_info):
+			video_description = video_info['description']
+
+		url_map = video_info['video_urls']
+		if len(url_map.keys()) > 0:
+			# Decide which formats to download
+			req_format = self._downloader.params.get('format', None)
+			format_limit = self._downloader.params.get('format_limit', None)
+
+			if format_limit is not None and format_limit in self._available_formats:
+				format_list = self._available_formats[self._available_formats.index(format_limit):]
+			else:
+				format_list = self._available_formats
+			existing_formats = [x for x in format_list if x in url_map]
+			if len(existing_formats) == 0:
+				self._downloader.trouble(u'ERROR: no known formats available for video')
+				return
+			if req_format is None:
+				video_url_list = [(existing_formats[0], url_map[existing_formats[0]])] # Best quality
+			elif req_format == '-1':
+				video_url_list = [(f, url_map[f]) for f in existing_formats] # All formats
+			else:
+				# Specific format
+				if req_format not in url_map:
+					self._downloader.trouble(u'ERROR: requested format not available')
+					return
+				video_url_list = [(req_format, url_map[req_format])] # Specific format
+
+		for format_param, video_real_url in video_url_list:
+
+			# At this point we have a new video
+			self._downloader.increment_downloads()
+
+			# Extension
+			video_extension = self._video_extensions.get(format_param, 'mp4')
+
+			# Find the video URL in fmt_url_map or conn paramters
+			try:
+				# Process video information
+				self._downloader.process_info({
+					'id':		video_id.decode('utf-8'),
+					'url':		video_real_url.decode('utf-8'),
+					'uploader':	video_uploader.decode('utf-8'),
+					'upload_date':	upload_date,
+					'title':	video_title,
+					'stitle':	simple_title,
+					'ext':		video_extension.decode('utf-8'),
+					'format':	(format_param is None and u'NA' or format_param.decode('utf-8')),
+					'thumbnail':	video_thumbnail.decode('utf-8'),
+					'description':	video_description.decode('utf-8'),
+					'player_url':	None,
+				})
+			except UnavailableVideoError, err:
+				self._downloader.trouble(u'\nERROR: unable to download video')
+
+class PostProcessor(object):
+	"""Post Processor class.
+
+	PostProcessor objects can be added to downloaders with their
+	add_post_processor() method. When the downloader has finished a
+	successful download, it will take its internal chain of PostProcessors
+	and start calling the run() method on each one of them, first with
+	an initial argument and then with the returned value of the previous
+	PostProcessor.
+
+	The chain will be stopped if one of them ever returns None or the end
+	of the chain is reached.
+
+	PostProcessor objects follow a "mutual registration" process similar
+	to InfoExtractor objects.
+	"""
+
+	_downloader = None
+
+	def __init__(self, downloader=None):
+		self._downloader = downloader
+
+	def set_downloader(self, downloader):
+		"""Sets the downloader for this PP."""
+		self._downloader = downloader
+
+	def run(self, information):
+		"""Run the PostProcessor.
+
+		The "information" argument is a dictionary like the ones
+		composed by InfoExtractors. The only difference is that this
+		one has an extra field called "filepath" that points to the
+		downloaded file.
+
+		When this method returns None, the postprocessing chain is
+		stopped. However, this method may return an information
+		dictionary that will be passed to the next postprocessing
+		object in the chain. It can be the one it received after
+		changing some fields.
+
+		In addition, this method may raise a PostProcessingError
+		exception that will be taken into account by the downloader
+		it was called from.
+		"""
+		return information # by default, do nothing
+
+class FFmpegExtractAudioPP(PostProcessor):
+
+	def __init__(self, downloader=None, preferredcodec=None):
+		PostProcessor.__init__(self, downloader)
+		if preferredcodec is None:
+			preferredcodec = 'best'
+		self._preferredcodec = preferredcodec
+
+	@staticmethod
+	def get_audio_codec(path):
+		try:
+			cmd = ['ffprobe', '-show_streams', '--', path]
+			handle = subprocess.Popen(cmd, stderr=file(os.path.devnull, 'w'), stdout=subprocess.PIPE)
+			output = handle.communicate()[0]
+			if handle.wait() != 0:
+				return None
+		except (IOError, OSError):
+			return None
+		audio_codec = None
+		for line in output.split('\n'):
+			if line.startswith('codec_name='):
+				audio_codec = line.split('=')[1].strip()
+			elif line.strip() == 'codec_type=audio' and audio_codec is not None:
+				return audio_codec
+		return None
+
+	@staticmethod
+	def run_ffmpeg(path, out_path, codec, more_opts):
+		try:
+			cmd = ['ffmpeg', '-y', '-i', path, '-vn', '-acodec', codec] + more_opts + ['--', out_path]
+			ret = subprocess.call(cmd, stdout=file(os.path.devnull, 'w'), stderr=subprocess.STDOUT)
+			return (ret == 0)
+		except (IOError, OSError):
+			return False
+
+	def run(self, information):
+		path = information['filepath']
+
+		filecodec = self.get_audio_codec(path)
+		if filecodec is None:
+			self._downloader.to_stderr(u'WARNING: unable to obtain file audio codec with ffprobe')
+			return None
+
+		more_opts = []
+		if self._preferredcodec == 'best' or self._preferredcodec == filecodec:
+			if filecodec == 'aac' or filecodec == 'mp3':
+				# Lossless if possible
+				acodec = 'copy'
+				extension = filecodec
+				if filecodec == 'aac':
+					more_opts = ['-f', 'adts']
+			else:
+				# MP3 otherwise.
+				acodec = 'libmp3lame'
+				extension = 'mp3'
+				more_opts = ['-ab', '128k']
+		else:
+			# We convert the audio (lossy)
+			acodec = {'mp3': 'libmp3lame', 'aac': 'aac'}[self._preferredcodec]
+			extension = self._preferredcodec
+			more_opts = ['-ab', '128k']
+			if self._preferredcodec == 'aac':
+				more_opts += ['-f', 'adts']
+
+		(prefix, ext) = os.path.splitext(path)
+		new_path = prefix + '.' + extension
+		self._downloader.to_screen(u'[ffmpeg] Destination: %s' % new_path)
+		status = self.run_ffmpeg(path, new_path, acodec, more_opts)
+
+		if not status:
+			self._downloader.to_stderr(u'WARNING: error running ffmpeg')
+			return None
+
+		try:
+			os.remove(path)
+		except (IOError, OSError):
+			self._downloader.to_stderr(u'WARNING: Unable to remove downloaded video file')
+			return None
+
+		information['filepath'] = new_path
+		return information
+
+#------------------------------------------------------------------------------------------
+#------------------------------------- Haupt Programm -------------------------------------
+#------------------------------------------------------------------------------------------
+class getyoutube(Screen):
+	skin = """
+		<screen position="center,center" size="450,240" title="Caching Video ..." >
+			<widget source="label_filename" transparent="1" render="Label" zPosition="2" position="10,10" size="430,21" font="Regular;19" />
+			<widget source="label_destination" transparent="1" render="Label" zPosition="2" position="10,35" size="430,21" font="Regular;19" />
+			<widget source="label_speed" transparent="1" render="Label" zPosition="2" position="10,60" size="430,21" font="Regular;19" />
+			<widget source="label_timeleft" transparent="1" render="Label" zPosition="2" position="10,85" size="430,21" font="Regular;19" />
+			<widget source="label_progress" transparent="1" render="Label" zPosition="2" position="10,110" size="430,21" font="Regular;19" />
+			<widget name="activityslider" position="10,150" size="430,30" zPosition="3" transparent="0" />
+			<widget name="key_red" position="10,200" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
+			<widget name="key_green" position="155,200" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
+			<widget name="key_blue" position="300,200" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
+			<ePixmap pixmap="/usr/share/enigma2/skin_default/buttons/red.png" position="10,200" size="140,40" alphatest="on" />
+			<ePixmap pixmap="/usr/share/enigma2/skin_default/buttons/green.png" position="155,200" size="140,40" alphatest="on" />
+			<ePixmap pixmap="/usr/share/enigma2/skin_default/buttons/blue.png" position="300,200" size="140,40" alphatest="on" />
+		</screen>"""
+
+	def __init__(self, session, url, filename):
+		self.skin = getyoutube.skin
+		Screen.__init__(self, session)
+
+		self.url = url
+		self.title = filename
+		self.movietitle = filename
+		self.movieinfo = filename
+		self.destination = config.plugins.formel1.Device.value
+		self.filename = self.destination + filename
+
+		self.streamactive = False
+		self.isVisible = True
+
+		self.container=eConsoleAppContainer()
+		self.container.appClosed.append(self.copyfinished)
+		self.container.stdoutAvail.append(self.UpdateStatus)
+		self.container.stderrAvail.append(self.UpdateStatus)
+		self.container.setCWD(self.destination)
+
+		self.oldService = self.session.nav.getCurrentlyPlayingServiceReference()
+		self.BgFileEraser = eBackgroundFileEraser.getInstance()
+
+		filesize = 14000
+		self.filesize = float(filesize) # in bytes
+
+		self.dummyfilesize = False
+		self.lastcmddata = None
+		self.lastlocalsize = 0
+
+		self["key_green"] = Button(_("Play now"))
+		self["key_red"] = Button(_("Cancel"))
+		self["key_blue"] = Button(_("Show/Hide"))
+
+		self["label_filename"] = StaticText("File: %s" % (self.movietitle))
+		self["label_destination"] = StaticText("Destination: %s" % (self.filename))
+		self["label_progress"] = StaticText("Progress: N/A")
+		self["label_speed"] = StaticText("Speed: N/A")
+		self["label_timeleft"] = StaticText("Time left: N/A")
+
+		self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
+		{
+			"cancel": self.exit,
+			"ok": self.okbuttonClick,
+			"red": self.exit,
+			"green": self.playfile,
+			"blue": self.visibility
+		}, -1)
+
+		self.StatusTimer = eTimer()
+		self.StatusTimer.callback.append(self.UpdateStatus)
+
+		self.activityslider = Slider(0, 100)
+		self["activityslider"] = self.activityslider
+
+		self.onFirstExecBegin.append(self.firstExecBegin)
+
+	def firstExecBegin(self):
+		self.progressperc = 0
+		self.okbuttonClick()
+		#self.copyfile(self.url)
+
+	def okbuttonClick(self):
+		#self.StatusTimer.start(2000, True)
+		self.UpdateStatus()
+		self.copyfile(self.url)
+
+	def UpdateStatus(self):
+		self.StatusTimer.stop()
+		print "##UpdateStatus##", self.filesize, self.dummyfilesize
+		if fileExists(self.filename, 'r'):
+			self.localsize = os_path.getsize(self.filename)
+		else:
+			self.localsize = 0
+
+		if self.filesize > 0 and not self.dummyfilesize:
+			self.progressperc = round((self.localsize / self.filesize) * 100, 2)
+
+		if int(self.progressperc) > 0:
+			self["activityslider"].setValue(int(self.progressperc))
+
+		if self.lastlocalsize != 0:
+			transferspeed = round(((self.localsize - self.lastlocalsize) / 1024.0) / 5, 0)
+			kbytesleft = round((self.filesize - self.localsize) / 1024.0,0)
+			if transferspeed > 0:
+				timeleft = round((kbytesleft / transferspeed) / 60,2)
+			else:
+				timeleft = 0
+		else:
+			transferspeed = 0
+			kbytesleft = 0
+			timeleft = 0
+
+		self.lastlocalsize = self.localsize
+
+		self["label_speed"].setText("Speed: " + str(transferspeed) + " KBit/s")
+		self["label_progress"].setText("Progress: " + str(round(((self.localsize / 1024.0) / 1024.0), 2)) + "MB of " + str(round(((self.filesize / 1024.0) / 1024.0), 2)) + "MB (" + str(self.progressperc) + "%)")
+		self["label_timeleft"].setText("Time left: " + str(timeleft) + " Minutes")
+		self.StatusTimer = eTimer()
+		self.StatusTimer.callback.append(self.UpdateStatus)
+		self.StatusTimer.start(1500, True)
+
+	def progressUpdate(self, data):
+		print "##progressUpdate##"
+		self.lastcmddata = data
+		if data.endswith('%)'):
+			startpos = data.rfind("sec (")+5
+			if startpos and startpos != -1:
+				self.progressperc = int(float(data[startpos:-4]))
+
+				if self.lastlocalsize > 0 and self.progressperc > 0:
+					self.filesize = int(float(self.lastlocalsize/self.progressperc)*100)
+					self.dummyfilesize = True
+
+	def playfile(self):
+		print "##playfile##", self.filename
+		if self.lastlocalsize >= 0:
+			self.StatusTimer.stop()
+			sref = eServiceReference(0x1001, 0, self.filename)
+			sref.setName(self.movietitle)
+			#self.session.open(PlayMovie, url, self.ort, "Streckeninfo", self.ort, filename)
+			#self.session.openWithCallback(self.MoviePlayerCallback, VideoMoviePlayer, sref, self.movieinfo)
+			self.session.open(VideoMoviePlayer, sref, self.movieinfo)
+		else:
+			self.session.openWithCallback(self.exit, MessageBox, _("Error downloading file:\n%s") % self.lastcmddata, MessageBox.TYPE_ERROR)
+
+	def copyfinished(self,retval):
+		self.StatusTimer.stop()
+		self.streamactive = False
+		self.UpdateStatus()
+		self["label_progress"].setText("Progress: 100%")
+		self["activityslider"].setValue(100)
+		print "##copyfinished##"
+		self.playfile()
+
+	def visibility(self):
+		if self.isVisible == True:
+			self.isVisible = False
+			self.hide()
+		else:
+			self.isVisible = True
+			self.show()
+
+	def exit(self, retval=None):
+		if self.isVisible == False:
+			self.visibility()
+			return
+		self.container.kill()
+		#self.BgFileEraser.erase(self.filename)
+
+		self.StatusTimer.stop()
+		self.session.nav.playService(self.oldService)
+		self.close()
+
+#------------------------------------------------------------------------------------------
+	def copyfile(self,url):
+		print "##copyfile##"
+		try:
+				# Modules needed only when running the main program
+				#import getpass
+				#import optparse
+
+				opts_cookiefile=None
+
+				# Open appropriate CookieJar
+				if opts_cookiefile is None:
+						jar = cookielib.CookieJar()
+				else:
+						try:
+							jar = cookielib.MozillaCookieJar(opts_cookiefile)
+							if os.path.isfile(opts_cookiefile) and os.access(opts_cookiefile, os.R_OK):
+								jar.load()
+						except (IOError, OSError), err:
+							sys.exit(u'ERROR: unable to open cookie file')
+
+				# General configuration
+				cookie_processor = urllib2.HTTPCookieProcessor(jar)
+				urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler(), cookie_processor, YoutubeDLHandler()))
+				socket.setdefaulttimeout(300) # 5 minutes should be enough (famous last words)
+
+				all_urls = []
+				all_urls.append(url)
+
+				# Information extractors
+				youtube_ie = YoutubeIE()
+				metacafe_ie = MetacafeIE(youtube_ie)
+				dailymotion_ie = DailymotionIE()
+				youtube_pl_ie = YoutubePlaylistIE(youtube_ie)
+				youtube_user_ie = YoutubeUserIE(youtube_ie)
+				youtube_search_ie = YoutubeSearchIE(youtube_ie)
+				google_ie = GoogleIE()
+				google_search_ie = GoogleSearchIE(google_ie)
+				photobucket_ie = PhotobucketIE()
+				yahoo_ie = YahooIE()
+				yahoo_search_ie = YahooSearchIE(yahoo_ie)
+				deposit_files_ie = DepositFilesIE()
+				facebook_ie = FacebookIE()
+				generic_ie = GenericIE()
+
+				opts_format=None
+				opts_getthumbnail=False
+				opts_format_limit=None
+				opts_ratelimit=None
+				opts_nooverwrites=False
+				opts_geturl=False
+				opts_nopart=False
+				opts_outtmpl=self.filename
+				opts_ignoreerrors=False
+				opts_gettitle=False
+				opts_username=None
+				opts_usenetrc=False
+				opts_noprogress=False
+				opts_playlistend=-1L
+				opts_simulate=False
+				opts_playliststart=1L
+				opts_continue_dl=False
+				opts_password=None
+				opts_retries=10L
+				opts_updatetime=True
+				opts_getfilename=False
+				opts_quiet=False
+				opts_consoletitle=False
+				opts_getdescription=False
+				opts_extractaudio=None
+				opts_autonumber=None
+
+				# File downloader
+				fd = FileDownloader({
+					'usenetrc': opts_usenetrc,
+					'username': opts_username,
+					'password': opts_password,
+					'quiet': (opts_quiet or opts_geturl or opts_gettitle or opts_getthumbnail or opts_getdescription or opts_getfilename),
+					'forceurl': opts_geturl,
+					'forcetitle': opts_gettitle,
+					'forcethumbnail': opts_getthumbnail,
+					'forcedescription': opts_getdescription,
+					'forcefilename': opts_getfilename,
+					'simulate': (opts_simulate or opts_geturl or opts_gettitle or opts_getthumbnail or opts_getdescription or opts_getfilename),
+					'format': opts_format,
+					'format_limit': opts_format_limit,
+					'outtmpl': opts_outtmpl,
+					'ignoreerrors': opts_ignoreerrors,
+					'ratelimit': opts_ratelimit,
+					'nooverwrites': opts_nooverwrites,
+					'retries': opts_retries,
+					'continuedl': opts_continue_dl,
+					'noprogress': opts_noprogress,
+					'playliststart': opts_playliststart,
+					'playlistend': opts_playlistend,
+					'logtostderr': opts_outtmpl == '-',
+					'consoletitle': opts_consoletitle,
+					'nopart': opts_nopart,
+					'updatetime': opts_updatetime,
+					})
+				fd.add_info_extractor(youtube_search_ie)
+				fd.add_info_extractor(youtube_pl_ie)
+				fd.add_info_extractor(youtube_user_ie)
+				fd.add_info_extractor(metacafe_ie)
+				fd.add_info_extractor(dailymotion_ie)
+				fd.add_info_extractor(youtube_ie)
+				fd.add_info_extractor(google_ie)
+				fd.add_info_extractor(google_search_ie)
+				fd.add_info_extractor(photobucket_ie)
+				fd.add_info_extractor(yahoo_ie)
+				fd.add_info_extractor(yahoo_search_ie)
+				fd.add_info_extractor(deposit_files_ie)
+				fd.add_info_extractor(facebook_ie)
+
+				# This must come last since it's the
+				# fallback if none of the others work
+				fd.add_info_extractor(generic_ie)
+
+				# PostProcessors
+				if opts_extractaudio:
+					fd.add_post_processor(FFmpegExtractAudioPP(preferredcodec=opts_audioformat))
+
+				# Maybe do nothing
+				if len(all_urls) < 1:
+					if not opts_update_self:
+								parser.error(u'you must provide at least one URL')
+					else:
+								sys.exit()
+				retcode = fd.download(all_urls)
+				print "retcode=", retcode
+				#self.close()
+
+				# Dump cookie jar if requested
+				if opts_cookiefile is not None:
+					try:
+								jar.save()
+					except (IOError, OSError), err:
+								exit(u'ERROR: unable to save cookie jar')
+
+				#exit(retcode)
+
+		except DownloadError:
+				exit(1)
+		except SameFileError:
+				exit(u'ERROR: fixed output name but more than one file to download')
+		except KeyboardInterrupt:
+				exit(u'\nERROR: Interrupted by user')
+
+#------------------------------------------------------------------------------------------
+class VideoMoviePlayer(MoviePlayer):
+	def __init__(self, session, service, movieinfo=None):
+		MoviePlayer.__init__(self, session, service)
+		self.skinName = "MoviePlayer"
+		self.movieinfo = movieinfo
+
+		self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+			{
+				iPlayableService.evUser+10: self.__evAudioDecodeError,
+				iPlayableService.evUser+11: self.__evVideoDecodeError,
+				iPlayableService.evUser+12: self.__evPluginError
+			})
+
+	def leavePlayer(self):
+		self.leavePlayerConfirmed(True)
+
+	def leavePlayerConfirmed(self, answer):
+		if answer:
+			self.close()
+
+	def doEofInternal(self, playing):
+		currPlay = self.session.nav.getCurrentService()
+		message = currPlay.info().getInfoString(iServiceInformation.sUser+12)
+		if message.find('Flash demuxer not available') != -1 or message.find('(AVI) demuxer not available') != -1:
+			self.session.openWithCallback(self.GSTplugincallback, MessageBox, _("Your Dreambox can't decode this video stream!\n%s\nDo you want to download and install it now?") % message, MessageBox.TYPE_YESNO)
+		elif message.find('GStreamer plugin') != -1 and message.find('not available') != -1:
+			self.__evPluginError()
+		else:
+			self.leavePlayerConfirmed(True)
+
+	def showMovies(self):
+		pass
+
+	def __evAudioDecodeError(self):
+		currPlay = self.session.nav.getCurrentService()
+		sTagAudioCodec = currPlay.info().getInfoString(iServiceInformation.sTagAudioCodec)
+		print "[__evAudioDecodeError] audio-codec %s can't be decoded by hardware" % (sTagAudioCodec)
+		self.session.open(MessageBox, _("This Dreambox can't decode %s streams!") % sTagAudioCodec, type=MessageBox.TYPE_INFO, timeout=20)
+
+	def __evVideoDecodeError(self):
+		currPlay = self.session.nav.getCurrentService()
+		sTagVideoCodec = currPlay.info().getInfoString(iServiceInformation.sTagVideoCodec)
+		print "[__evVideoDecodeError] video-codec %s can't be decoded by hardware" % (sTagVideoCodec)
+		self.session.open(MessageBox, _("This Dreambox can't decode %s streams!") % sTagVideoCodec, type=MessageBox.TYPE_INFO, timeout=20)
+
+	def __evPluginError(self):
+		currPlay = self.session.nav.getCurrentService()
+		message = currPlay.info().getInfoString(iServiceInformation.sUser+12)
+		print "[__evPluginError]" , message
+		if VLCSUPPORT and self.movieinfo is not None:
+			self.session.openWithCallback(self.VLCcallback, MessageBox, _("Your Dreambox can't decode this video stream!\n%s\nDo you want to stream it via VLC Server from your PC?") % message[17:], MessageBox.TYPE_YESNO)
+		else:
+			self.session.open(MessageBox, _("Your Dreambox can't decode this video stream!\n%s") % message, type=MessageBox.TYPE_INFO, timeout=20)
+
+	def GSTplugincallback(self, answer):
+		if answer is True:
+			self.container=eConsoleAppContainer()
+			self.container.appClosed.append(self.finishedPluginInstall)
+			self.container.execute("opkg update && opkg install gst-plugin-avi gst-plugin-flv gst-plugin-rtsp")
+		else:
+			self.close()
+
+	def finishedPluginInstall(self,retval):
+		self.session.openWithCallback(self.restartGUI, MessageBox, _("Missing GStreamer-Plugins were installed!\nDo you want to restart Enigma2 GUI now?"), MessageBox.TYPE_YESNO)
+
+	def restartGUI(self, answer):
+		if answer is True:
+			self.session.open(TryQuitMainloop, 3)
+
+	def VLCcallback(self, answer):
+		if answer is True:
+			self.close(self.movieinfo)
+		else:
+			self.close()
+
+
+# ------------- call youtobe --------------------
+#getyoutube('http://www.youtube.com/watch?v=unFYsw9QqwE',"/tmp/filename")
Index: /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/keymap.xml
===================================================================
--- /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/keymap.xml	(revision 7589)
+++ /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/keymap.xml	(revision 7589)
@@ -0,0 +1,43 @@
+<keymap>
+	<map context="AAFKeyActions">
+		<key id="KEY_UP" mapto="up" flags="m" />
+		<key id="KEY_DOWN" mapto="down" flags="m" />
+		<key id="KEY_LEFT" mapto="left" flags="m" />
+		<key id="KEY_RIGHT" mapto="right" flags="m" />
+
+		<key id="KEY_UP" mapto="upRepeated" flags="r" />
+		<key id="KEY_DOWN" mapto="downRepeated" flags="r" />
+		<key id="KEY_LEFT" mapto="leftRepeated" flags="r" />
+		<key id="KEY_RIGHT" mapto="rightRepeated" flags="r" />
+
+		<key id="KEY_RED" mapto="red" flags="m" />
+		<key id="KEY_GREEN" mapto="green" flags="m" />
+		<key id="KEY_YELLOW" mapto="yellow" flags="m" />
+		<key id="KEY_BLUE" mapto="blue" flags="m" />
+
+		<key id="KEY_1" mapto="1" flags="m" />
+		<key id="KEY_2" mapto="2" flags="m" />
+		<key id="KEY_3" mapto="3" flags="m" />
+		<key id="KEY_4" mapto="4" flags="m" />
+		<key id="KEY_5" mapto="5" flags="m" />
+		<key id="KEY_6" mapto="6" flags="m" />
+		<key id="KEY_7" mapto="7" flags="m" />
+		<key id="KEY_8" mapto="8" flags="m" />
+		<key id="KEY_9" mapto="9" flags="m" />
+		<key id="KEY_0" mapto="0" flags="m" />
+
+		<key id="KEY_CHANNELUP" mapto="chup" flags="mr" />
+		<key id="KEY_CHANNELDOWN" mapto="chdown" flags="mr" />
+
+		<key id="KEY_OK" mapto="ok" flags="m" />
+		<key id="KEY_PAGEUP" mapto="nextBouquet" flags="m" />
+		<key id="KEY_PAGEDOWN" mapto="prevBouquet" flags="m" />
+		<key id="KEY_TEXT" mapto="text" flags="m" />
+		<key id="KEY_MENU" mapto="menu" flags="m" />
+		<key id="KEY_EXIT" mapto="cancel" flags="m" />
+		<key id="KEY_HOME" mapto="cancel" flags="m" />
+		<key id="KEY_HELP" mapto="showEventInfo" flags="m" />
+		<key id="KEY_INFO" mapto="showEventInfo" flags="m" />
+		<key id="\x1b" mapto="cancel" flags="m" />
+	</map>
+</keymap>
Index: /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/plugin.py
===================================================================
--- /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/plugin.py	(revision 7589)
+++ /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/plugin.py	(revision 7589)
@@ -0,0 +1,1957 @@
+# -*- coding: UTF-8 -*-
+
+#-------------------------------------------------------
+#
+#              Formel1 2011
+#
+#   Dieses Plugin zeigt aktuelle Rennergebnisse
+#   und Bilder von den Rennstrecken 2011
+#
+#
+#   Wir wuenschen allen Benutzern viel Vergnügen!
+#
+#                 Version 0.8
+#
+#                  12.05.2011
+#
+#        Datenquelle: http://www.kicker.de
+#        Datenquelle: http://www.formel1.de
+#
+#             Designed und Idee von
+#                  @Bauernbub
+#
+#-------------------------------------------------------
+
+from Components.ActionMap import HelpableActionMap
+from Components.ActionMap import ActionMap, NumberActionMap
+from Components.AVSwitch import AVSwitch
+from Components.Label import Label
+from Components.Button import Button
+from Components.Sources.StaticText import StaticText
+from Components.ScrollLabel import ScrollLabel
+from Components.MenuList import MenuList
+from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
+from Components.Pixmap import Pixmap
+from Components.PluginComponent import plugins
+from Components.Console import Console
+from Components.config import *
+from Components.ConfigList import ConfigList, ConfigListScreen
+from enigma import eListboxPythonMultiContent, eListbox, ePicLoad, eServiceReference, eTimer, getDesktop, gFont, RT_HALIGN_LEFT
+from os import listdir, popen
+from Plugins.Plugin import PluginDescriptor
+from Screens.ChoiceBox import ChoiceBox
+from Screens.HelpMenu import HelpableScreen
+from Screens.InfoBar import MoviePlayer
+from Screens.MessageBox import MessageBox
+from Screens.Screen import Screen
+from Components.FileList import FileList
+from time import sleep
+from Tools.BoundFunction import boundFunction
+from Tools.Directories import resolveFilename, SCOPE_PLUGINS, fileExists
+from Tools.HardwareInfo import HardwareInfo
+from Tools.LoadPixmap import LoadPixmap
+from Screens.NetworkSetup import *
+from twisted.web.client import downloadPage
+from twisted.web import client
+from twisted.web.client import downloadPage, getPage
+from Scroll import Scroll
+
+from Components.HTMLComponent import HTMLComponent
+from Components.GUIComponent import GUIComponent
+from Screens.VirtualKeyBoard import VirtualKeyBoard
+from Components.Sources.Progress import Progress
+from enigma import eConsoleAppContainer, eBackgroundFileEraser, iServiceInformation, iPlayableService
+from Components.Slider import Slider
+from Components.ServiceEventTracker import ServiceEventTracker
+
+
+import re, urllib2, urllib
+from urllib2 import Request, urlopen
+from urllib import *
+from string import find, atoi, strip
+from re import sub, split, search, match, findall
+import os
+from os import system, remove, path, walk, makedirs, listdir
+from time import *
+
+from Screens.TaskView import JobView
+from Components.Task import Task, Job, job_manager as JobManager, Condition
+
+from Plugins.Extensions.Formel1.tipprunde import *
+from Plugins.Extensions.Formel1.getyoutube import *
+
+
+config.plugins.formel1 = ConfigSubsection()
+config.plugins.formel1.Device = ConfigSelection(default="/media/hdd/Formel1/", choices = [("/usr/lib/enigma2/python/Plugins/Extensions/Formel1/", _("...Plugins/Extensions/Formel1/")), ("/media/hdd/Formel1/", _("/media/hdd/Formel1/")), ("/var/swap/Formel1/", _("/var/swap/Formel1/"))])
+config.plugins.formel1.resize = ConfigSelection(default="0", choices = [("0", _("simple")), ("1", _("better"))])
+config.plugins.formel1.bgcolor = ConfigSelection(default="#00000000", choices = [("#00000000", _("black")),("#009eb9ff", _("blue")),("#00ff5a51", _("red")), ("#00ffe875", _("yellow")), ("#0038FF48", _("green"))])
+config.plugins.formel1.textcolor = ConfigSelection(default="#0038FF48", choices = [("#00000000", _("black")),("#009eb9ff", _("blue")),("#00ff5a51", _("red")), ("#00ffe875", _("yellow")), ("#0038FF48", _("green"))])
+config.plugins.formel1.framesize = ConfigInteger(default=5, limits=(5, 99))
+config.plugins.formel1.remove = ConfigSelection(default="0", choices = [("0", _("Yes")), ("1", _("No"))])
+config.plugins.formel1.slidetime = ConfigInteger(default=5, limits=(1, 60))
+config.plugins.formel1.infoline = ConfigEnableDisable(default=True)
+config.plugins.formel1.loop = ConfigEnableDisable(default=False)
+
+
+config.plugins.tipprunde = ConfigSubsection()
+config.plugins.tipprunde.spalte = ConfigSelection(default="0", choices = [("0", _("Spalte1")), ("1", _("Spalte2")), ("3", _("Spalte3"))])
+config.plugins.tipprunde.color1 = ConfigSelection(default="15794175", choices = [("15794175", _("weiss")),("0", _("black")),("10402303", _("blue")),("16734801", _("red")), ("16771189", _("yellow")), ("65280", _("green"))])
+config.plugins.tipprunde.color2 = ConfigSelection(default="65280", choices = [("15794175", _("weiss")),("0", _("black")),("10402303", _("blue")),("16734801", _("red")), ("16771189", _("yellow")), ("65280", _("green"))])
+config.plugins.tipprunde.bgcolor = ConfigSelection(default="#000000", choices = [("#ffffff", _("weiss")),("#000000", _("black")),("#9eb9ff", _("blue")),("#ff5a51", _("red")), ("#ffe875", _("yellow")), ("#38FF48", _("green"))])
+config.plugins.tipprunde.null = ConfigSelection(default="0", choices = [("0", _("Yes")), ("1", _("No"))])
+
+
+RT_HALIGN_LEFT = 0
+TYPE_TEXT = 0
+
+global MAIN_PAGE
+global slidelink
+deviceName = HardwareInfo().get_device_name()
+
+
+#------------------------------------------------------------------------------------------
+def TabelleListEntry(tipptext, color):
+	res = [ ]
+	if config.plugins.tipprunde.null.value == "0":
+		tipptext = tipptext.replace(' 00',"   ").replace('0.00',"    ")
+
+	#PyObject *type, *px, *py, *pwidth, *pheight, *pfnt, *pstring, *pflags;
+	res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 0, 500, 25, 0, RT_HALIGN_LEFT, " ", 65280))
+	res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 0, 1190, 25, 0, RT_HALIGN_LEFT, tipptext, float(color)))
+	return res
+
+#---------------------- Skin Funktionen ---------------------------------------------------
+def getAspect():
+	val = AVSwitch().getAspectRatioSetting()
+	return val/2
+
+def getScale():
+	return AVSwitch().getFramebufferScale()
+
+def applySkinVars(skin,dict):
+		for key in dict.keys():
+				try:
+						skin = skin.replace('{'+key+'}',dict[key])
+				except Exception,e:
+						print e,"@key=",key
+		return skin
+
+def transHTML(text):
+		text = text.replace('&nbsp;'," ").replace('&#39;',"'").replace('&szlig;',"sz").replace('&quot;','"').replace('&ndash;',"-")
+		text = text.replace('&copy;.*'," ").replace('&amp;',"&").replace('&uuml;',"ue").replace('&auml;',"ae").replace('&ouml;',"oe")
+		text = text.replace('&Uuml;',"Ue").replace('&Auml;',"Ae").replace('&Ouml;',"Oe")
+		text = text.replace('&#223;',"ae").replace('&raquo;',"").replace('&ldquo;','"').replace('&rdquo;','"')
+		text = text.replace('\xfc',"ue").replace('\xd6',"Oe").replace('\xf6',"oe").replace('\xe4',"ae").replace('<p>',"\n")
+		return text
+
+
+#------------------------------------------------------------------------------------------
+#----------------------------------  MainMenuList   ---------------------------------------
+#------------------------------------------------------------------------------------------
+class MainMenuList(MenuList):
+	def __init__(self):
+		MenuList.__init__(self, [], False, eListboxPythonMultiContent)
+		self.l.setFont(0, gFont("Regular", 26))
+		self.l.setFont(1, gFont("Regular", 32))
+		self.listCompleted = []
+		self.callback = None
+		#self.idx = 0
+		#self.thumb = ""
+
+
+#--------------------------- Alle Listeneintraege durchlaufen -----------------------------
+	def buildEntries(self):
+			#print "[Formel1] buildEntries:", len(self.list)
+			if self.idx == len(self.list):
+				self.setList(self.listCompleted)
+				if self.callback:
+					self.callback()
+			else:
+				self.buildEntry(None)
+
+#----------------------------------- Eintrasege fuer Liste bilden ------------------------------------------------
+	def buildEntry(self, picInfo=None):
+		print "[Formel1] buildEntry:", len(self.list)
+		self.x = self.list[self.idx]
+		self.res = [(self.x[0], self.x[1])]
+
+		rot = 16711680
+		gruen = 60928
+		dgruen = 52480
+		hlila = 0xffbbff
+		hlila2 = 0xee30a7
+		drot = 0xff3030
+		hrot = 0xff3030
+		orange =0xf47d19
+		gelb =0xffff00
+		mblau = 8900346
+		hblau = 0x00c5cd
+		dblau = 0x009acd
+		ddblau = 0x00688b
+		weiss = 0xffffff
+		hweiss =0xf7f7f7
+		grau = 0x565656
+		schwarz = 0x000000
+		grau = 0x565656
+
+# 		list.append(['27.03.11 08:00','/news/formel1/f1termine/2011/911/4/strecke_gp-von-australien-2011-911.html','gp-von-australien','Melbourne','/news/formel1/f1termine/2011/911/3/rennen_gp-von-australien-2011-911.html'])
+		# Zeit
+		self.res.append(MultiContentEntryText(pos=(487, 5), size=(240, 40), font=0, text=self.x[0], color=mblau, color_sel=mblau, backcolor_sel=grau))
+		# GP von
+		self.res.append(MultiContentEntryText(pos=(225, 0), size=(240, 40), font=1, text=self.x[2], color=ddblau, color_sel=ddblau, backcolor_sel=grau))
+		# Ort
+		self.res.append(MultiContentEntryText(pos=(225, 40), size=(380, 40), font=1, text=self.x[3], color=mblau, color_sel=mblau, backcolor_sel=grau))
+
+		pngpic = LoadPixmap("/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/" + self.x[2] + ".jpg")
+		#print "[Formel1] Picload", self.x[3] + ".jpg"
+		if pngpic is not None:
+				#print "[Formel1] Picload vorhanden *********"
+				self.res.append(MultiContentEntryPixmapAlphaTest(pos=(10, 5), size=(188, 100), png=pngpic))
+
+		pngpic = LoadPixmap("/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/" + self.x[2] + ".jpg")
+		#print "[Formel1] Picload", self.x[3] + ".jpg"
+		if pngpic is not None:
+				#print "[Formel1] Picload vorhanden *********"
+				self.res.append(MultiContentEntryPixmapAlphaTest(pos=(10, 5), size=(188, 100), png=pngpic))
+
+		pngpic = LoadPixmap("/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/kalender.png")
+		if pngpic is not None:
+				self.res.append(MultiContentEntryPixmapAlphaTest(pos=(515,40), size=(60, 47), png=pngpic))
+
+		pngpic = LoadPixmap("/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/uhr.png")
+		if pngpic is not None:
+				self.res.append(MultiContentEntryPixmapAlphaTest(pos=(622,40), size=(47, 47), png=pngpic))
+
+
+		self.listCompleted.append(self.res)
+		self.idx += 1
+		self.buildEntries()
+
+# -------------------------- Menue Liste aufbauen -----------------------------------------
+	def SetList(self, l):
+		##print "[Formel1] SetList"
+		self.list = l
+		self.l.setItemHeight(110)
+		del self.listCompleted
+		self.listCompleted = []
+		self.idx = 0
+		self.buildEntries()
+
+#------------------------------------------------------------------------------------------
+#------------------------------ Formel1 Rennuebersicht ------------------------------------
+#------------------------------------------------------------------------------------------
+class Formel1Preview(Screen, HelpableScreen):
+	def __init__(self, session):
+		global MAIN_PAGE, menu
+		self.session = session
+		desktop = getDesktop(0)
+		size = desktop.size()
+		width = size.width()
+		if width == 1280:
+			self.skin = """<screen position="center,center" size="720,532" title="Formel1 2011 V 0.8" backgroundColor="#252525" >"""
+			self.skin += """<widget name="MainList" position="0,10" size="720,445" zPosition="3" backgroundColor="#252525"  backgroundColorSelected="#565656" scrollbarMode="showOnDemand" />
+			<widget source="key_red" render="Label" position="50,461" zPosition="2" size="200,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd" />
+			<widget source="key_green" render="Label" position="260,461" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+			<widget source="key_yellow" render="Label" position="459,461" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+			<widget source="key_blue" render="Label" position="600,461" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+
+			<widget source="key_menu" render="Label" position="113,495" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+			<widget source="key_ok" render="Label" position="337,495" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+			<widget source="key_0" render="Label" position="520,495" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+
+			<ePixmap position="10,468" size="36,25" pixmap="skin_default/buttons/key_red.png" transparent="1" alphatest="on" />
+			<ePixmap position="220,468" size="36,25" pixmap="skin_default/buttons/key_green.png" transparent="1" alphatest="on" />
+			<ePixmap position="420,468" size="36,25" pixmap="skin_default/buttons/key_yellow.png" transparent="1" alphatest="on" />
+			<ePixmap position="560,468" size="36,25" pixmap="skin_default/buttons/key_blue.png" transparent="1" alphatest="on" />
+
+			<ePixmap position="40,500" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/menu.png" transparent="1" alphatest="on" />
+			<ePixmap position="290,500" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/ok.png" transparent="1" alphatest="on" />
+			<ePixmap position="480,500" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/key_0.png" transparent="1" alphatest="on" />
+
+			<eLabel position="5,462" zPosition="2" size="710,2" backgroundColor="#c1cdcd" />
+		</screen>"""
+		else:
+			self.skin = """<screen position="center,center" size="720,422" title="Formel1 2011 V 0.8" backgroundColor="#252525" >"""
+			self.skin += """<widget name="MainList" position="0,10" size="720,335" zPosition="3" backgroundColor="#252525"  backgroundColorSelected="#565656" scrollbarMode="showOnDemand" />
+			<widget source="key_red" render="Label" position="50,348" zPosition="2" size="200,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd" />
+			<widget source="key_green" render="Label" position="260,348" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+			<widget source="key_yellow" render="Label" position="450,348" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+			<widget source="key_blue" render="Label" position="580,348" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+
+			<widget source="key_menu" render="Label" position="113,382" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+			<widget source="key_ok" render="Label" position="337,382" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+			<widget source="key_0" render="Label" position="520,382" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+
+			<ePixmap position="10,353" size="36,25" pixmap="skin_default/buttons/key_red.png" transparent="1" alphatest="on" />
+			<ePixmap position="220,353" size="36,25" pixmap="skin_default/buttons/key_green.png" transparent="1" alphatest="on" />
+			<ePixmap position="410,353" size="36,25" pixmap="skin_default/buttons/key_yellow.png" transparent="1" alphatest="on" />
+			<ePixmap position="540,353" size="36,25" pixmap="skin_default/buttons/key_blue.png" transparent="1" alphatest="on" />
+
+			<ePixmap position="40,385" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/menu.png" transparent="1" alphatest="on" />
+			<ePixmap position="290,385" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/ok.png" transparent="1" alphatest="on" />
+			<ePixmap position="480,385" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/key_0.png" transparent="1" alphatest="on" />
+
+			<eLabel position="5,348" zPosition="2" size="710,2" backgroundColor="#c1cdcd" />
+		</screen>"""
+
+		Screen.__init__(self, session)
+		self["MainList"] = MainMenuList()
+		self["key_green"] = StaticText()
+		self["key_yellow"] = StaticText()
+		self["key_red"] = StaticText()
+		self["key_blue"] = StaticText()
+		self["key_ok"] = StaticText()
+		self["key_menu"] = StaticText()
+		self["key_0"] = StaticText()
+		self["key_red"].text = _("Fahrerwertung")
+		self["key_green"].text = _("Teamwertung")
+		self["key_yellow"].text = _("Strecke")
+		self["key_blue"].text = _("Teams")
+		self["key_ok"].text = _("Ergebnisse")
+		self["key_menu"].text = _("AAF-Tipprunde")
+		self["key_0"].text = _("Settings")
+
+		HelpableScreen.__init__(self)
+
+		# please help me, the current select position at first is tilt
+		self.previewtimeout = 600
+		self.ThumbTimer = eTimer()
+		self.ThumbTimer.callback.append(self.up)
+		self.ThumbTimer.start(self.previewtimeout, True)
+
+		self["actions"] = HelpableActionMap(self, "AAFKeyActions",
+			{
+				"cancel": (self.exit, "Beenden"),
+				"ok": (self.OK, "ok"),
+				"menu": (self.menu, "Menu"),
+				"0": (self.settings, "KEY_0"),
+				"left": (self.left, "Seite hoch"),
+				"right": (self.right, "Seite runter"),
+				"up": (self.up, "Hoch"),
+				"down": (self.down, "Runter"),
+				"red": (self.red, "Red"),
+				"green": (self.green, "Green"),
+				"yellow": (self.yellow, "Yellow"),
+				"blue": (self.blue, "Blue")
+			}, -2)
+
+		self.getKickerPage()
+
+	def getPage(self, url=None):
+		print "[Formel1] getPage:"
+		self.working = True
+		if not url:
+			url = ""
+		print "[Formel1] Url:" , url
+		getPage(url).addCallback(self.getPicture).addErrback(self.error)
+
+	def error(self, err=""):
+		print "[Formel1] Error:", err
+		self.working = False
+
+	def exit(self):
+		os.system("rm /tmp/f1/*.jpg; rm /tmp/*.jpg ")
+		self.close()
+
+	def red(self):
+		self.session.open(DriverPanel)
+
+	def green(self):
+		self.session.open(TeamPanel)
+
+	def settings(self):
+		self.session.open(PicSetup)
+
+	def blue(self):
+		self.session.open(TeamsPanel)
+
+	def OK(self):
+		# suche Link fuer Rennergebnisse
+# 		list.append(['27.03.11 08:00','/news/formel1/f1termine/2011/911/4/strecke_gp-von-australien-2011-911.html','gp-von-australien','Melbourne','/news/formel1/f1termine/2011/911/3/rennen_gp-von-australien-2011-911.html'])
+
+		curr = self["MainList"].getSelectedIndex()
+		print "[Formel1] Linkpage:", curr
+		DetailLink = "http://www.kicker.de" +self.mainlist[curr][4]
+		Ort = self.mainlist[curr][3]
+		self.ort = Ort
+		print "[Formel1] Linkpage:", DetailLink
+		self.session.open(RacingPanel, DetailLink, Ort)
+
+	def yellow(self):
+		country = "http://www.kicker.de" + self['MainList'].l.getCurrentSelection()[0][1]
+		print "[Formel1] Linkpage:", country
+		self.getPage(country)
+		
+	def getPicture(self,url):
+		fulltext = re.compile(r'<img src="http\:\/\/mediadb.kicker.de\/2011\/formel1\/strecken(.+?)"', re.DOTALL)
+		piclink = fulltext.findall(url)
+		url = "http://mediadb.kicker.de/2011/formel1/strecken" + str(piclink[0])
+		print "[Formel1] Piclink:" + url
+		
+		devicepath = "/tmp/kicker.png"
+		path = "/tmp"
+		h = urllib.urlretrieve(url, devicepath)
+		filelist = devicepath
+
+		curr = self["MainList"].getSelectedIndex()
+		Ort = self.mainlist[curr][3]
+		self.session.open(PicView, filelist, 0, path, False, Ort)
+
+	def left(self):
+		self["MainList"].pageUp()
+		self["MainList"].selectionEnabled(1)
+
+	def right(self):
+		self["MainList"].pageDown()
+		self["MainList"].selectionEnabled(1)
+
+	def up(self):
+		print "*****self.up*******"
+		self["MainList"].up()
+		self["MainList"].selectionEnabled(1)
+
+	def down(self):
+		self["MainList"].down()
+		self["MainList"].selectionEnabled(1)
+
+	def menu(self):
+		self.session.open(Tipprunde)
+				
+#------------------------------------------------------------------------------------------
+	def loadPicture(self,url=""):
+		devicepath = "/tmp/strecke.jpg"
+		path = "/tmp"
+		h = urllib.urlretrieve(url, devicepath)
+		filelist = devicepath
+		ort = ""
+		self.session.open(PicView, filelist, 0, path, False, ort)
+
+# ----------------------------------------------------------------------
+	def getKickerPage(self):
+		#Termin = <td class="alignleft first">10.04.11 10:00</td>
+		#fulltext = re.compile(r'<td class="alignleft first">(.+?)<', re.DOTALL)
+		#zeit = fulltext.findall(html)
+
+		self.mainlist = []
+		self.mainlist.append(['27.03.11 08:00','/news/formel1/f1termine/2011/911/4/strecke_gp-von-australien-2011-911.html','Australien','Melbourne','/news/formel1/f1termine/2011/911/3/rennen_gp-von-australien-2011-911.html'])
+		self.mainlist.append(['10.04.11 10:00','/news/formel1/f1termine/2011/912/4/strecke_gp-von-malaysia-2011-912.html','Malaysia','Kuala Lumpur','/news/formel1/f1termine/2011/912/3/rennen_gp-von-malaysia-2011-912.html'])
+		self.mainlist.append(['17.04.11 09:00','/news/formel1/f1termine/2011/913/4/strecke_gp-von-china-2011-913.html','China','Shanghai','/news/formel1/f1termine/2011/913/3/rennen_gp-von-china-2011-913.html'])
+		self.mainlist.append(['08.05.11 14:00','/news/formel1/f1termine/2011/914/4/strecke_gp-der-tuerkei-2011-914.html','Tuerkei','Istanbul','/news/formel1/f1termine/2011/914/3/rennen_gp-der-tuerkei-2011-914.html'])
+		self.mainlist.append(['22.05.11 14:00','/news/formel1/f1termine/2011/915/4/strecke_gp-von-spanien-2011-915.html','Spanien','Barcelona','/news/formel1/f1termine/2011/915/3/rennen_gp-von-spanien-2011-915.html'])
+		self.mainlist.append(['29.05.11 14:00','/news/formel1/f1termine/2011/916/4/strecke_gp-von-monaco-2011-916.html','Monaco','Monte Carlo','/news/formel1/f1termine/2011/916/3/rennen_gp-von-monaco-2011-916.html'])
+		self.mainlist.append(['12.06.11 19:00','/news/formel1/f1termine/2011/917/4/strecke_gp-von-kanada-2011-917.html','Kanada','Montreal','/news/formel1/f1termine/2011/917/3/rennen_gp-von-kanada-2011-917.html'])
+		self.mainlist.append(['26.06.11 14:00','/news/formel1/f1termine/2011/918/4/strecke_gp-von-europa-2011-918.html','Europa','Valencia','/news/formel1/f1termine/2011/918/3/rennen_gp-von-europa-2011-918.html'])
+		self.mainlist.append(['10.07.11 14:00','/news/formel1/f1termine/2011/919/4/strecke_gp-von-grossbritannien-2011-919.html','Grossbritannien','Silverstone','/news/formel1/f1termine/2011/919/3/rennen_gp-von-grossbritannien-2011-919.html'])
+		self.mainlist.append(['24.07.11 14:00','/news/formel1/f1termine/2011/920/4/strecke_gp-von-deutschland-2011-920.html','Deutschland','Nürburg','/news/formel1/f1termine/2011/920/3/rennen_gp-von-deutschland-2011-920.html'])
+		self.mainlist.append(['31.07.11 14:00','/news/formel1/f1termine/2011/921/4/strecke_gp-von-ungarn-2011-921.html','Ungarn','Budapest','/news/formel1/f1termine/2011/921/3/rennen_gp-von-ungarn-2011-921.html'])
+		self.mainlist.append(['28.08.11 14:00','/news/formel1/f1termine/2011/922/4/strecke_gp-von-belgien-2011-922.html','Belgien','Spa-Francorchamps','/news/formel1/f1termine/2011/922/3/rennen_gp-von-belgien-2011-922.html'])
+		self.mainlist.append(['11.09.11 14:00','/news/formel1/f1termine/2011/923/4/strecke_gp-von-italien-2011-923.html','Italien','Monza','/news/formel1/f1termine/2011/923/3/rennen_gp-von-italien-2011-923.html'])
+		self.mainlist.append(['25.09.11 14:00','/news/formel1/f1termine/2011/924/4/strecke_gp-von-singapur-2011-924.html','Singapur','Singapur','/news/formel1/f1termine/2011/924/3/rennen_gp-von-singapur-2011-924.html'])
+		self.mainlist.append(['09.10.11 08:00','/news/formel1/f1termine/2011/925/4/strecke_gp-von-japan-2011-925.html','Japan','Suzuka','/news/formel1/f1termine/2011/925/3/rennen_gp-von-japan-2011-925.html'])
+		self.mainlist.append(['16.10.11 08:00','/news/formel1/f1termine/2011/926/4/strecke_gp-von-suedkorea-2011-926.html','Suedkorea','Yeongam','/news/formel1/f1termine/2011/926/3/rennen_gp-von-suedkorea-2011-926.html'])
+		self.mainlist.append(['30.10.11 10:30','/news/formel1/f1termine/2011/927/4/strecke_gp-von-indien-2011-927.html','Indien', 'Greater Noida','/news/formel1/f1termine/2011/927/3/rennen_gp-von-indien-2011-927.html'])
+		self.mainlist.append(['13.11.11 14:00','/news/formel1/f1termine/2011/928/4/strecke_gp-von-abu-dhabi-2011-928.html','Abu-dhabi', 'Abu Dhabi','/news/formel1/f1termine/2011/928/3/rennen_gp-von-abu-dhabi-2011-928.html'])
+		self.mainlist.append(['27.11.11 17:00','/news/formel1/f1termine/2011/929/4/strecke_gp-von-brasilien-2011-929.html','Brasilien', 'Sao Paulo','/news/formel1/f1termine/2011/929/3/rennen_gp-von-brasilien-2011-929.html'])
+
+		self["MainList"].SetList(self.mainlist)
+		self["MainList"].show
+
+# -------------------------------------------------------------------
+class DriverPanelList(MenuList):
+	def __init__(self, list, font0 = 22, font1 = 18, itemHeight = 34, enableWrapAround = True):
+		MenuList.__init__(self, [], False, eListboxPythonMultiContent)
+		self.l.setFont(0, gFont("Regular", font0))
+		self.l.setFont(1, gFont("Regular", font1))
+		self.l.setItemHeight(itemHeight)
+
+# -------------------------------------------------------------------
+class DriverPanel(Screen, HelpableScreen):
+	def __init__(self, session):
+		self.session = session
+		desktop = getDesktop(0)
+		size = desktop.size()
+		width = size.width()
+		if width == 1024:
+			self.skin = """
+				<screen name="DriverPanel" position="center,55" size="830,510" title="Fahrerwertung und Fahrerinfos" backgroundColor="#252525">
+					<widget source="titel" render="Label" position="0,0" zPosition="3" size="830,40" font="Regular;28" valign="center" halign="left" transparent="1" foregroundColor="#e0eeee"/>
+					<eLabel position="5,37" zPosition="2" size="820,2" backgroundColor="#e0eeee" />
+					<widget name="Mlist" position="10,44" size="500,410" zPosition="3" backgroundColor="#252525"  backgroundColorSelected="#565656" scrollbarMode="showOnDemand" />
+					<widget name="Preview" position="570,130" size="200,200" alphatest="on"/>
+					<widget source="team" render="Label" position="570,50" zPosition="3" size="190,60" font="Regular;28" valign="center" halign="center" transparent="1" foregroundColor="#cd3700"/>
+					<widget source="geboren" render="Label" position="570,360" zPosition="2" size="190,30" font="Regular;28" valign="center" halign="center" transparent="1" foregroundColor="#f47d19"/>
+					<widget source="national" render="Label" position="570,390" zPosition="2" size="190,60" font="Regular;28" valign="center" halign="center" transparent="1" foregroundColor="#f47d19"/>
+					<eLabel position="5,458" zPosition="2" size="980,2" backgroundColor="#e0eeee" />
+					<widget source="titel2" render="Label" position="0,466" zPosition="3" size="920,40" font="Regular;26" valign="center" halign="center" transparent="1" foregroundColor="#c1cdcd"/>
+			</screen>"""
+		else:
+			self.skin = """
+				<screen name="DriverPanel" position="center,center" size="830,510" title="Fahrerwertung und Fahrerinfos" backgroundColor="#252525">
+					<widget source="titel" render="Label" position="0,0" zPosition="3" size="830,40" font="Regular;28" valign="center" halign="left" transparent="1" foregroundColor="#e0eeee"/>
+					<eLabel position="5,37" zPosition="2" size="820,2" backgroundColor="#e0eeee" />
+					<widget name="Mlist" position="10,44" size="500,410" zPosition="3" backgroundColor="#252525"  backgroundColorSelected="#565656" scrollbarMode="showOnDemand" />
+					<widget name="Preview" position="570,130" size="200,200" alphatest="on"/>
+					<widget source="team" render="Label" position="570,50" zPosition="3" size="190,60" font="Regular;28" valign="center" halign="center" transparent="1" foregroundColor="#cd3700"/>
+					<widget source="geboren" render="Label" position="570,360" zPosition="2" size="190,30" font="Regular;28" valign="center" halign="center" transparent="1" foregroundColor="#f47d19"/>
+					<widget source="national" render="Label" position="570,390" zPosition="2" size="190,60" font="Regular;28" valign="center" halign="center" transparent="1" foregroundColor="#f47d19"/>
+					<eLabel position="5,458" zPosition="2" size="980,2" backgroundColor="#e0eeee" />
+					<widget source="key_ok" render="Label" position="240,466" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+					<ePixmap position="180,471" zPosition="2" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/ok.png" transparent="0" alphatest="on" />
+					<widget source="key_esc" render="Label" position="570,466" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+					<ePixmap position="510,471" zPosition="2" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/esc.png" transparent="0" alphatest="on" />
+			</screen>"""
+
+		Screen.__init__(self, session)
+		self.Mlist = []
+		self.getDriverPage()
+
+		self["team"] = StaticText()
+		self["geboren"] = StaticText()
+		self["national"] = StaticText()
+		self["Mlist"] = DriverPanelList([])
+		self["Preview"] = Pixmap()
+		self["Preview"].hide()
+		self["titel"] = StaticText()
+		self["titel"].text = _("      Fahrer               Siege   Punkte                          Fahrerinfo")
+		self["key_esc"] = StaticText()
+		self["key_esc"].text = _("Verlassen")
+		self["key_ok"] = StaticText()
+		self["key_ok"].text = _("XL-Bild")
+
+
+		HelpableScreen.__init__(self)
+		self.previewtimeout = 600
+		self.ThumbTimer = eTimer()
+		self.ThumbTimer.callback.append(self.pic_download)
+
+		self["actions"] = HelpableActionMap(self,"AAFKeyActions",
+			{
+				"cancel": (self.Exit, "Beenden"),
+				"left": (self.left, "Seite hoch"),
+				"right": (self.right, "Seite runter"),
+				"up": (self.up, "Hoch"),
+				"down": (self.down, "Runter"),
+				"ok": (self.OK, "ok")
+			}, -2)
+
+# -------------------------------------------------------------------
+	def getDriverPage(self):
+		print "[Formel1] getDriverPage:"
+		url = "http://www.kicker.de/news/formel1/fahrerwertung/2011/fahrerwertung.html"
+		print "[Formel1] Url:" , url
+		getPage(url).addCallback(self.getDriverInfo).addErrback(self.error)
+
+	def error(self, err=""):
+		print "[Formel1] Error:", err
+
+	def getDriverInfo(self,html):
+		fulltext = re.compile(r'<td class="alignleft"><a class=.+?>(.+?)<\/a>', re.DOTALL)
+		fahrer = fulltext.findall(html)
+
+		fulltext = re.compile(r'<td class="alignright">(.+?)<\/td>.+?>(.+?)<', re.DOTALL)
+		punkte = fulltext.findall(html)
+
+		fulltext = re.compile(r'<td class="alignleft"><a class=\'link\' href=\'(.+?)\'>', re.DOTALL)
+		fahrerlink = fulltext.findall(html)
+
+		print "suche ....."
+		list = []
+		print "--------------------------------------------"
+		wert = len(fahrer)
+		print str(wert)
+		x = 0
+		while x < wert:
+				fahrerkompl = str(sub('&nbsp;'," ",str(fahrer[x])))
+				fahrerl = str(fahrerlink[x])
+				self.Mlist.append(self.F1EntryItem((fahrerkompl, fahrerl, punkte[x][0], punkte[x][1])))
+				#list.append([fahrerkompl, punkte[x][0], punkte[x][1]])
+				print fahrerkompl
+				print fahrerl
+				#print punkte[x][1]
+				print "--------------------------------------------"
+				x = x +1
+
+		self["Mlist"].l.setList(self.Mlist)
+		self["Mlist"].selectionEnabled(1)
+		self["Mlist"].show
+		self.up() # das erste Bild anzeigen
+
+# -------------------------------------------------------------------
+	def up(self):
+		#self["Preview"].hide()
+		self["Mlist"].up()
+		self["Mlist"].selectionEnabled(1)
+		self.ThumbTimer.start(self.previewtimeout, True)
+
+	def down(self):
+		#self["Preview"].hide()
+		self["Mlist"].down()
+		self["Mlist"].selectionEnabled(1)
+		self.ThumbTimer.start(self.previewtimeout, True)
+
+	def left(self):
+		#self["Preview"].hide()
+		self["Mlist"].pageUp()
+		self["Mlist"].selectionEnabled(1)
+		self.ThumbTimer.start(self.previewtimeout, True)
+
+	def right(self):
+		#self["Preview"].hide()
+		self["Mlist"].pageDown()
+		self["Mlist"].selectionEnabled(1)
+		self.ThumbTimer.start(self.previewtimeout, True)
+
+	def OK(self):
+		url = self.PicXL
+		print "[Formel1] PiclinkXL:" + url
+		devicepath = "/tmp/kicker.png"
+		path = "/tmp"
+		h = urllib.urlretrieve(url, devicepath)
+		filelist = devicepath
+		ort = ""
+		self.session.open(PicView, filelist, 0, path, False, ort)
+
+
+	def Exit(self):
+		self.close()
+
+	def F1EntryItem(self,entry):
+		rot = 16711680
+		gruen = 60928
+		dgruen = 52480
+		drot = 0xf47d19
+		mblau = 8900346
+		hblau = 11592447
+		dblau = 5215437
+		weiss = 0xffffff
+		orange = 0xf47d19
+		grau = 0x565656
+
+		res = [entry]
+		#	return (eListboxPythonMultiContent.TYPE_TEXT, pos[0], pos[1], size[0], size[1], font, flags, text, color, color_sel, backcolor, backcolor_sel, border_width, border_color)
+		#res.append(MultiContentEntryPixmapAlphaTest(pos=(2, 5), size=(100, 60), png=entry[0]))  # png vorn
+		res.append(MultiContentEntryText(pos=(10, 6), size=(220, 35), font=0, text=entry[0], color=mblau, color_sel=mblau, backcolor_sel=grau))
+		res.append(MultiContentEntryText(pos=(270, 6), size=(50, 35), font=0, text=entry[2], color=dblau, color_sel=dblau, backcolor_sel=grau))
+		res.append(MultiContentEntryText(pos=(355, 6), size=(50, 35), font=0, text=entry[3], color=drot, color_sel=drot, backcolor_sel=grau))
+
+		return res
+
+#----- load Menutext or Picture -------------------------------------------------------
+	def pic_download(self):
+		link = self['Mlist'].l.getCurrentSelection()[0][1]
+		link = "http://www.kicker.de" + link
+		print "Fahrerbild = ", link
+		getPage(link).addCallback(self.getDriverSide).addErrback(self.error)
+
+
+	def getDriverSide(self,html):
+		# hole die Bilder vom Fahrer und seinem Auto
+		fulltext = re.compile(r'<img src="http://mediadb.kicker.de/2011/formel1/autos(.+?)"', re.DOTALL)
+		auto = fulltext.findall(html)
+
+		fulltext = re.compile(r'<img class="steckbrief" src="http://mediadb.kicker.de/2011/formel1/fahrer(.+?)"', re.DOTALL)
+		fahrerbild = fulltext.findall(html)
+
+		fulltext = re.compile(r'<a href="http://mediadb.kicker.de/2011/formel1/fahrer(.+?)"', re.DOTALL)  #XL Bild
+		fahrerbildXL = fulltext.findall(html)
+
+		fulltext = re.compile(r'Geboren am:</b></td><td>(.+?)<', re.DOTALL)
+		geboren = fulltext.findall(html)
+
+		fulltext = re.compile(r'National.*?</td><td>(.+?)<', re.DOTALL)
+		national = fulltext.findall(html)
+
+		fulltext = re.compile(r'Team:.*?\/news\/formel1\/teams.+?>(.+?)<', re.DOTALL)
+		team= fulltext.findall(html)
+
+		#print "--------------------------------------------"
+		#print "http://mediadb.kicker.de/2011/formel1/autos" + auto[0]
+		#print "http://mediadb.kicker.de/2011/formel1/fahrer" + fahrerbild[0]
+		#print geboren[0]
+		#print national[0]
+		#print team[0]
+
+		self["team"].text = _(team[0])
+		self["geboren"].text = _(geboren[0])
+		self["national"].text = _(national[0])
+		self["Preview"].show()
+
+		# http://mediadb.kicker.de/2011/formel1/fahrer/xl/1568_2011222121010179.jpg
+		self.PicXL = "http://mediadb.kicker.de/2011/formel1/fahrer" + fahrerbildXL[0]
+		PICurl = "http://mediadb.kicker.de/2011/formel1/fahrer" + fahrerbild[0]
+		client.getPage(PICurl).addCallback(self.pic_finished).addErrback(self.pic_failed)
+
+
+#----- Pic Download Procedures -------------------------------------------------------
+	def pic_failed(self, failure_instance):
+		self["Preview"].hide()
+
+	def pic_finished(self,LISTdata=""):
+		self.LIST = LISTdata
+		if self.LIST != "":
+			# write skin-preview to file
+			ffile = open("/tmp/pic.jpg", "w")
+			ffile.write(self.LIST)
+			ffile.close()
+			pngpath = "/tmp/pic.jpg"
+			self.previewPath = pngpath
+
+			png = LoadPixmap(cached=False, path=self.previewPath)
+			self["Preview"].instance.setPixmap(png)
+			self["Preview"].show()
+#------------------------------------------------------------------------------------------
+#-------------------------- Bildbetrachter der Grossbilder --------------------------------
+#------------------------------------------------------------------------------------------
+class PicView(Screen):
+	def __init__(self, session, filelist, index, path, startslide, ort):
+		self.session = session
+		self.ort = ort
+		self.bgcolor = "#00000000"
+		space = 5
+		size_w = getDesktop(0).size().width()
+		size_h = getDesktop(0).size().height()
+
+		self.skindir = "/tmp"
+		self.skin = "<screen position=\"0,0\" size=\"" + str(size_w) + "," + str(size_h) + "\" > \
+			<eLabel position=\"0,0\" zPosition=\"0\" size=\""+ str(size_w) + "," + str(size_h) + "\" backgroundColor=\""+ self.bgcolor +"\" /><widget name=\"pic\" position=\"" + str(space) + "," + str(space) + "\" size=\"" + str(size_w-(space*2)) + "," + str(size_h-(space*2)) + "\" zPosition=\"1\" alphatest=\"on\" /></screen>"
+
+		Screen.__init__(self, session)
+		self["actions"] = ActionMap(["OkCancelActions", "ColorActions", "DirectionActions", "MovieSelectionActions", "MenuActions", "SetupActions"],
+		{
+			"cancel": self.Exit,
+		}, -1)
+
+		self["pic"] = Pixmap()
+		self.filelist = filelist
+		self.old_index = 0
+		self.lastindex = index
+		self.currPic = []
+		self.shownow = True
+		self.dirlistcount = 0
+		self.index = 0
+		self.picload = ePicLoad()
+		self.picload.PictureData.get().append(self.finish_decode)
+		self.onLayoutFinish.append(self.setPicloadConf)
+		self.startslide = startslide
+
+	def setPicloadConf(self):
+		sc = getScale()
+		self.picload.setPara([self["pic"].instance.size().width(), self["pic"].instance.size().height(), sc[0], sc[1], 0, 1, self.bgcolor])
+		self.start_decode()
+		#print "PicView setPicloadConf:", self.filelist
+
+	def ShowPicture(self):
+		if self.shownow and len(self.currPic):
+			self.shownow = False
+			self["pic"].instance.setPixmap(self.currPic[0].__deref__())
+
+	def finish_decode(self, picInfo=""):
+		ptr = self.picload.getData()
+		if ptr != None:
+			self.currPic = []
+			self.currPic.append(ptr)
+			self.ShowPicture()
+			print "PicView finish_decode:", self.filelist, self.ort
+
+			# Video laden
+			#if len(self.ort) >= 5:
+			#	self.GetVideos()
+
+
+	def start_decode(self):
+		self.picload.startDecode(self.filelist)
+
+	def Exit(self):
+		del self.picload
+		self.close(self.lastindex + self.dirlistcount)
+
+
+#------------------------------------------------------------------------------------------
+
+class TeamPanelList(MenuList):
+	def __init__(self, list, font0 = 22, font1 = 26, itemHeight = 100, enableWrapAround = True):
+		MenuList.__init__(self, [], False, eListboxPythonMultiContent)
+		self.l.setFont(0, gFont("Regular", font0))
+		self.l.setFont(1, gFont("Regular", font1))
+		self.l.setItemHeight(itemHeight)
+
+# -----------------------------------------------------------------------------------------
+class TeamPanel(Screen, HelpableScreen):
+	def __init__(self, session):
+		self.session = session
+		desktop = getDesktop(0)
+		size = desktop.size()
+		width = size.width()
+		if width == 1280:
+			self.skin = """
+				<screen name="TeamPanel" position="center,center" size="830,515" title="Formel1 Teamwertung" backgroundColor="#252525">
+					<widget source="titel" render="Label" position="0,0" zPosition="3" size="830,40" font="Regular;28" valign="center" halign="left" transparent="1" foregroundColor="#e0eeee"/>
+					<eLabel position="5,37" zPosition="2" size="820,2" backgroundColor="#e0eeee" />
+					<widget name="Mlist" position="10,50" size="810,407" zPosition="3" backgroundColor="#252525"  backgroundColorSelected="#565656" scrollbarMode="showOnDemand" />
+					<eLabel position="5,463" zPosition="2" size="820,2" backgroundColor="#e0eeee" />
+					<widget source="key_esc" render="Label" position="430,471" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+					<ePixmap position="370,476" zPosition="2" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/esc.png" transparent="0" alphatest="on" />
+			</screen>"""
+		else:
+			self.skin = """
+				<screen name="TeamPanel" position="center,65" size="830,515" title="Formel1 Teamwertung" backgroundColor="#252525">
+					<widget source="titel" render="Label" position="0,0" zPosition="3" size="830,40" font="Regular;28" valign="center" halign="left" transparent="1" foregroundColor="#e0eeee"/>
+					<eLabel position="5,37" zPosition="2" size="820,2" backgroundColor="#e0eeee" />
+					<widget name="Mlist" position="10,50" size="810,407" zPosition="3" backgroundColor="#252525"  backgroundColorSelected="#565656" scrollbarMode="showOnDemand" />
+					<eLabel position="5,463" zPosition="2" size="820,2" backgroundColor="#e0eeee" />
+					<widget source="key_esc" render="Label" position="430,471" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+					<ePixmap position="370,476" zPosition="2" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/esc.png" transparent="0" alphatest="on" />
+			</screen>"""
+
+		Screen.__init__(self, session)
+		self.Mlist = []
+		self.getTeamPage()
+
+		self["titel"] = StaticText()
+		self["titel"].text = _("            Team                           Punkte             Rennwagen")
+		self["Mlist"] = TeamPanelList([])
+		self["key_esc"] = StaticText()
+		self["key_esc"].text = _("Verlassen")
+
+
+		HelpableScreen.__init__(self)
+
+		self["actions"] = HelpableActionMap(self,"AAFKeyActions",
+			{
+				"cancel": (self.Exit, "Beenden"),
+				"left": (self.left, "Seite hoch"),
+				"right": (self.right, "Seite runter"),
+				"up": (self.up, "Hoch"),
+				"down": (self.down, "Runter")
+			}, -2)
+
+# -------------------------------------------------------------------
+	def getTeamPage(self):
+		print "[Formel1] getTeamPage:"
+		url = "http://www.kicker.de/news/formel1/teamwertung/2011/teamwertung.html"
+		print "[Formel1] Url:" , url
+		getPage(url).addCallback(self.getTeamInfo).addErrback(self.error)
+
+	def error(self, err=""):
+		print "[Formel1] Error:", err
+
+	def getTeamInfo(self,html):
+		fulltext = re.compile(r'<td class="alignleft first">(.+?)<', re.DOTALL)
+		first = fulltext.findall(html)
+
+		fulltext = re.compile(r'<td class="alignleft"><a class=\'link\' href=\'.+?>(.+?)<', re.DOTALL)
+		team = fulltext.findall(html)
+
+		fulltext = re.compile(r'<td class="alignright last">(.+?)<', re.DOTALL)
+		last = fulltext.findall(html)
+
+
+		print "suche ....."
+		list = []
+		print "--------------------------------------------"
+		wert = len(first)
+		print wert
+		x = 0
+		while x < wert:
+				teamtext = str(team[x])
+				self.Mlist.append(self.TeamEntryItem((teamtext, first[x], last[x])))
+				#print teamtext
+				#print first[x]
+				#print last[x]
+				#print "--------------------------------------------"
+				x = x +1
+
+		self["Mlist"].l.setList(self.Mlist)
+		self["Mlist"].selectionEnabled(1)
+		self["Mlist"].show
+		self.up() # das erste Bild anzeigen
+
+# -------------------------------------------------------------------
+	def up(self):
+		#self["Preview"].hide()
+		self["Mlist"].up()
+		self["Mlist"].selectionEnabled(1)
+
+
+	def down(self):
+		#self["Preview"].hide()
+		self["Mlist"].down()
+		self["Mlist"].selectionEnabled(1)
+
+
+	def left(self):
+		#self["Preview"].hide()
+		self["Mlist"].pageUp()
+		self["Mlist"].selectionEnabled(1)
+
+
+	def right(self):
+		#self["Preview"].hide()
+		self["Mlist"].pageDown()
+		self["Mlist"].selectionEnabled(1)
+
+
+	def OK(self):
+		url = "http://mediadb.kicker.de/2011/formel1/autos/xl/423_201122212955382.png"
+		print "[Formel1] PiclinkXL:" + url
+		devicepath = "/tmp/kicker.png"
+		path = "/tmp"
+		h = urllib.urlretrieve(url, devicepath)
+		filelist = devicepath
+		ort = ""
+		self.session.open(PicView, filelist, 0, path, False, ort)
+
+
+	def Exit(self):
+		self.close()
+
+	def TeamEntryItem(self,entry):
+		rot = 16711680
+		gruen = 60928
+		dgruen = 52480
+		drot = 0xf47d19
+		mblau = 8900346
+		hblau = 11592447
+		dblau = 5215437
+		weiss = 0xffffff
+		orange = 0xf47d19
+		grau = 0x565656
+
+		res = [entry]
+		res.append(MultiContentEntryText(pos=(7, 18), size=(50, 35), font=1, text=entry[1], color=dblau, color_sel=dblau, backcolor_sel=grau))
+		res.append(MultiContentEntryText(pos=(50, 18), size=(300, 35), font=1, text=entry[0], color=mblau, color_sel=mblau, backcolor_sel=grau))
+		res.append(MultiContentEntryText(pos=(360, 18), size=(90, 35), font=1, text=entry[2], color=drot, color_sel=drot, backcolor_sel=grau))
+
+		pngpic = LoadPixmap("/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/" + entry[0] + ".jpg")
+		print "[Formel1] TeamPicload", entry[0] + ".jpg"
+		if pngpic is not None:
+				print "[Formel1] Picload vorhanden *********"
+				res.append(MultiContentEntryPixmapAlphaTest(pos=(440, 15), size=(333, 77), png=pngpic))
+		return res
+
+
+
+#------------------------------------------------------------------------------------------
+
+class TeamsPanelList(MenuList):
+	def __init__(self, list, font0 = 18, font1 = 26, itemHeight = 150, enableWrapAround = True):
+		MenuList.__init__(self, [], False, eListboxPythonMultiContent)
+		self.l.setFont(0, gFont("Regular", font0))
+		self.l.setFont(1, gFont("Regular", font1))
+		self.l.setItemHeight(itemHeight)
+
+# -----------------------------------------------------------------------------------------
+class TeamsPanel(Screen, HelpableScreen):
+	def __init__(self, session):
+		self.session = session
+		desktop = getDesktop(0)
+		size = desktop.size()
+		width = size.width()
+		self.focus = 0  # Menueliste
+		if width == 1280:
+			self.skin = """
+				<screen name="TeamsPanel" position="center,center" size="630,520" title="Formel1 und die Teams 2011" backgroundColor="#252525">
+ 					<widget name="textpage" zPosition="-1" position="10,0" size="610,457" font="Regular;22" halign="left" transparent="1" />
+					<widget name="Mlist" position="10,10" size="610,457" zPosition="3" backgroundColor="#252525"  backgroundColorSelected="#565656" scrollbarMode="showOnDemand" />
+					<widget source="key_ok" render="Label" position="200,485" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+					<ePixmap position="140,490" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/ok.png" transparent="1" alphatest="on" />
+					<widget source="key_esc" render="Label" position="420,485" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+					<ePixmap position="360,490" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/esc.png" transparent="1" alphatest="on" />
+					<eLabel position="5,481" zPosition="2" size="620,2" backgroundColor="#c1cdcd" />
+				</screen>"""
+		else:
+			self.skin = """
+				<screen name="TeamsPanel" position="center,54" size="630,506" title="Formel1 und die Teams 2011" backgroundColor="#252525">
+ 					<widget name="textpage" zPosition="-1" position="10,0" size="610,447" font="Regular;22" halign="left" transparent="1" />
+					<widget name="Mlist" position="10,0" size="610,450" zPosition="3" backgroundColor="#252525"  backgroundColorSelected="#565656" scrollbarMode="showOnDemand" />
+					<widget source="key_ok" render="Label" position="200,485" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+					<ePixmap position="140,490" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/ok.png" transparent="1" alphatest="on" />
+					<widget source="key_esc" render="Label" position="420,485" zPosition="2" size="180,40" font="Regular;20" valign="center" halign="left" transparent="1" foregroundColor="#c1cdcd"/>
+					<ePixmap position="360,490" size="76,40" pixmap="/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/esc.png" transparent="1" alphatest="on" />
+					<eLabel position="5,456" zPosition="2" size="620,1" backgroundColor="#c1cdcd" />
+				</screen>"""
+
+		Screen.__init__(self, session)
+		self.Mlist = []
+		self.getTeamsPage()
+
+		self["textpage"] = Scroll("")
+		self["textpage"].hide()
+		self["Mlist"] = TeamsPanelList([])
+
+		self["key_esc"] = StaticText()
+		self["key_esc"].text = _("Verlassen")
+		self["key_ok"] = StaticText()
+		self["key_ok"].text = _("Teaminfo")
+
+
+
+		HelpableScreen.__init__(self)
+
+		self["actions"] = HelpableActionMap(self,"AAFKeyActions",
+			{
+				"cancel": (self.Exit, "Beenden"),
+				"left": (self.left, "Seite hoch"),
+				"right": (self.right, "Seite runter"),
+				"ok": (self.OK, "OK"),
+				"up": (self.up, "Hoch"),
+				"down": (self.down, "Runter")
+			}, -2)
+
+# -------------------------------------------------------------------
+	def getTeamsPage(self):
+		print "[Formel1] getTeamsPage:"
+		url = "http://www.formel1.de/de/48/Teams+%26+Fahrer"
+		print "[Formel1] Teams-Url:" , url
+		getPage(url).addCallback(self.getTeamsInfo).addErrback(self.error)
+
+	def error(self, err=""):
+		print "[Formel1] Error:", err
+
+	def getTeamsInfo(self,html):
+		fulltext = re.compile(r'<div class="tuflogo">.+?<img src="(.+?)"', re.DOTALL)
+		tuflogo = fulltext.findall(html)
+
+		fulltext = re.compile(r'<div class="tufdriverinner">.+?<img src="(.+?)".+?<a href=".+?">(.+?)&nbsp', re.DOTALL)
+		tufdriver = fulltext.findall(html)
+
+		fulltext = re.compile(r'<div class="tfdinner">.+?<p>(.+?)<\/div>', re.DOTALL)
+		tuftext = fulltext.findall(html)
+
+		#print "--------------------------------------------"
+		wert = len(tuflogo)
+
+		x = 0
+		y = 0
+		while x < wert:
+			#print tuflogo[x]
+			#print tufdriver[y]
+			#print tufdriver[y+1]
+			self.Mlist.append(self.TeamsEntryItem((tuflogo[x], tufdriver[y], tufdriver[y+1],tuftext[x])))
+			#print "--------------------------------------------"
+			x = x +1
+			y = y +2
+
+		self["Mlist"].l.setList(self.Mlist)
+		self["Mlist"].selectionEnabled(1)
+		self["Mlist"].show
+		self.up() # das erste Bild anzeigen
+
+# -------------------------------------------------------------------
+	def up(self):
+		#self["Preview"].hide()
+		if self.focus == 0:
+			self["Mlist"].up()
+			self["Mlist"].selectionEnabled(1)
+		else:
+			self["textpage"].pageUp()
+
+	def down(self):
+		if self.focus == 0:
+		#self["Preview"].hide()
+			self["Mlist"].down()
+			self["Mlist"].selectionEnabled(1)
+		else:
+			self["textpage"].pageDown()
+
+	def left(self):
+		if self.focus == 0:
+		#self["Preview"].hide()
+			self["Mlist"].pageUp()
+			self["Mlist"].selectionEnabled(1)
+		else:
+			self["textpage"].firstPage()
+
+	def right(self):
+		if self.focus == 0:
+		#self["Preview"].hide()
+			self["Mlist"].pageDown()
+			self["Mlist"].selectionEnabled(1)
+		else:
+			self["textpage"].lastPage()
+
+	def OK(self):
+		self.focus = 1
+		curr = self["Mlist"].getSelectedIndex()
+		print "[Formel1] Textpage:", curr
+		self["Mlist"].hide()
+		self["textpage"].show()
+		self.textlist = []
+		self.text = self.Mlist[curr][0][3]
+		self.text = sub('<[^>]*>',"",self.text)
+
+		self.textlist = transHTML(str(self.text))
+		print "Textpassage: ", self.textlist
+		self["textpage"].setText(self.textlist)
+
+	def Exit(self):
+		if self.focus == 0:
+			self.close()
+		else:
+			self.focus = 0
+			self["Mlist"].show()
+			self["textpage"].hide()
+
+# -------------------------------------------------------------------
+	def TeamsEntryItem(self,entry):
+		rot = 16711680
+		gruen = 60928
+		dgruen = 52480
+		drot = 0xf47d19
+		mblau = 8900346
+		hblau = 11592447
+		dblau = 5215437
+		weiss = 0xffffff
+		orange = 0xf47d19
+		grau = 0x565656
+
+		res = [entry]
+		textlang = len(str(entry[1][1]))
+		center = 300 - (textlang/2)*11
+		res.append(MultiContentEntryText(pos=(center, 120), size=(200, 35), font=0, text=entry[1][1], color=dblau, color_sel=dblau, backcolor_sel=grau))
+
+		textlang = len(entry[2][1])
+		center = 485 - (textlang/2)*11
+		res.append(MultiContentEntryText(pos=(center, 120), size=(200, 35), font=0, text=entry[2][1], color=mblau, color_sel=mblau, backcolor_sel=grau))
+
+		#self.loadTeamPic(entry[0])
+
+		# TeamLogo
+		team = entry[0].split(".gif")[0]
+		print "[Formel1] split1", team
+		teampic = team.split("/public/img/teams/logos/")[1]
+		print "[Formel1] split2", teampic
+		pngpic = LoadPixmap("/var/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/" + teampic + ".jpg")
+		if pngpic is not None:
+				print "[Formel1] Picload vorhanden *********"
+				res.append(MultiContentEntryPixmapAlphaTest(pos=(5, 7), size=(190, 140), png=pngpic))
+
+		# Fahrer 1
+		devicepath = "/tmp/team.jpg"
+		path = "/tmp"
+		print "[Formel1] TeamPicload", entry[1][0]
+		h = urllib.urlretrieve(entry[1][0], devicepath)
+		pngpic = LoadPixmap(devicepath)
+		print "[Formel1] TeamPicload", entry[1][0]
+		if pngpic is not None:
+				print "[Formel1] Picload vorhanden *********"
+				res.append(MultiContentEntryPixmapAlphaTest(pos=(260, 7), size=(92, 104), png=pngpic))
+
+
+		h = urllib.urlretrieve(entry[2][0], devicepath)
+		pngpic = LoadPixmap(devicepath)
+		print "[Formel1] TeamPicload", entry[2][0]
+		if pngpic is not None:
+				print "[Formel1] Picload vorhanden *********"
+				res.append(MultiContentEntryPixmapAlphaTest(pos=(440,7), size=(92, 104), png=pngpic))
+		return res
+
+# -------------------------------------------------------------------
+class RacingPanelList(MenuList):
+	def __init__(self, list, font0 = 22, font1 = 26, itemHeight = 40, enableWrapAround = True):
+		MenuList.__init__(self, [], False, eListboxPythonMultiContent)
+		self.l.setFont(0, gFont("Regular", font0))
+		self.l.setFont(1, gFont("Regular", font1))
+		self.l.setItemHeight(itemHeight)
+
+# -------------------------------------------------------------------
+class RacingPanel(Screen, HelpableScreen):
+	def __init__(self, session, rennen, ort):
+		self.session = session
+		self.ort = ort
+		desktop = getDesktop(0)
+		size = desktop.size()
+		width = size.width()
+		if width == 1280:
+			self.skin = """
+				<screen name="RacingPanel" position="center,center" size="1000,500" title="Formel1 Rennen Auswertung" backgroundColor="#252525">
+					<widget source="titel" render="Label" position="0,0" zPosition="3" size="900,40" font="Regular;28" valign="center" halign="left" transparent="1" foregroundColor="#e0eeee"/>
+					<eLabel position="5,37" zPosition="2" size="990,2" backgroundColor="#e0eeee" />
+					<widget name="Mlist" position="10,50" size="980,400" zPosition="3" backgroundColor="#252525"  backgroundColorSelected="#565656" scrollbarMode="showOnDemand" />
+					<ePixmap position="210,470" size="36,25" pixmap="skin_default/buttons/key_red.png" transparent="1" alphatest="on" />
+					<ePixmap position="550,470" size="36,25" pixmap="skin_default/buttons/key_green.png" transparent="1" alphatest="on" />
+					<eLabel position="5,458" zPosition="2" size="980,2" backgroundColor="#e0eeee" />
+					<widget name="key_red" position="260,463" zPosition="3" size="200,40" font="Regular;26" valign="center" halign="left" transparent="0" foregroundColor="#c1cdcd" backgroundColor="#252525"/>
+					<widget name="key_green" position="600,463" zPosition="3" size="200,40" font="Regular;26" valign="center" halign="left" transparent="0" foregroundColor="#c1cdcd" backgroundColor="#252525"/>
+				</screen>"""
+		else:
+			self.skin = """
+				<screen name="RacingPanel" position="center,55" size="950,500" title="Formel1 Rennen Auswertung" backgroundColor="#252525">
+					<widget source="titel" render="Label" position="0,0" zPosition="3" size="900,40" font="Regular;28" valign="center" halign="left" transparent="1" foregroundColor="#e0eeee"/>
+					<eLabel position="5,37" zPosition="2" size="940,2" backgroundColor="#e0eeee" />
+					<widget name="Mlist" position="10,50" size="930,400" zPosition="3" backgroundColor="#252525"  backgroundColorSelected="#565656" scrollbarMode="showOnDemand" />
+					<ePixmap position="210,470" size="36,25" pixmap="skin_default/buttons/key_red.png" transparent="1" alphatest="on" />
+					<ePixmap position="550,470" size="36,25" pixmap="skin_default/buttons/key_green.png" transparent="1" alphatest="on" />
+					<eLabel position="5,458" zPosition="2" size="930,2" backgroundColor="#e0eeee" />
+					<widget name="key_red" position="260,463" zPosition="3" size="200,40" font="Regular;26" valign="center" halign="left" transparent="0" foregroundColor="#c1cdcd" backgroundColor="#252525"/>
+					<widget name="key_green" position="600,463" zPosition="3" size="200,40" font="Regular;26" valign="center" halign="left" transparent="0" foregroundColor="#c1cdcd" backgroundColor="#252525"/>
+				</screen>"""
+
+
+		Screen.__init__(self, session)
+		self.Mlist = []
+		self.getRacingPage(rennen)
+
+		self["Mlist"] = RacingPanelList([])
+		self["titel"] = StaticText()
+		self["key_red"] = Label("")
+		self["key_green"] = Label("")
+		self["titel"].text = _(" Nr.         Fahrer                             Team                              Zeit")
+		self["key_red"].setText("Slideshow")
+		self["key_green"].setText("Video")
+		self.slidelink = "none"
+
+		HelpableScreen.__init__(self)
+
+		self["actions"] = HelpableActionMap(self,"AAFKeyActions",
+			{
+				"cancel": (self.Exit, "Beenden"),
+				"left": (self.left, "Seite hoch"),
+				"right": (self.right, "Seite runter"),
+				"up": (self.up, "Hoch"),
+				"down": (self.down, "Runter"),
+				"red": (self.OK, "red"),
+				"green": (self.GetVideos, "green")
+			}, -2)
+
+# -------------------------------------------------------------------
+	def getRacingPage(self, url):
+		print "[Formel1] getRacingPage:"
+		print "[Formel1] Url:" , url
+		getPage(url).addCallback(self.getRacingInfo).addErrback(self.error)
+
+	def error(self, err=""):
+		print "[Formel1] Error:", err
+
+	def getRacingInfo(self,html):
+		fulltext = re.compile(r'<td class="alignleft first">(.+?)<', re.DOTALL)
+		rang = fulltext.findall(html)
+		fulltext = re.compile(r'<td class="alignleft">.+?\/news\/formel1\/fahrer.+?>(.+?)<', re.DOTALL)
+		fahrer = fulltext.findall(html)
+		fulltext = re.compile(r'<td class="alignleft">.+?\/news\/formel1\/teams.+?>(.+?)<', re.DOTALL)
+		teams = fulltext.findall(html)
+		fulltext = re.compile(r'<td class="alignright last">(.+?)<', re.DOTALL)
+		zeit = fulltext.findall(html)
+		fulltext = re.compile(r'<a class=\'zumArtikel\' href=\'(.+?)\'>weiter', re.DOTALL)
+		sl = fulltext.findall(html)
+
+		wert = len(rang)
+		x = 0
+		while x < wert:
+			fahrerkompl = str(sub('&nbsp;'," ",str(fahrer[x])))
+			zeitkompl = str(sub('&nbsp;'," ",str(zeit[x])))
+			self.Mlist.append(self.RacingEntryItem((rang[x], fahrerkompl, teams[x], zeitkompl)))
+			#print rang[x]
+			#print fahrerkompl
+			#print teams[x]
+			#print zeitkompl
+			#print "--------------------------------------------"
+			x = x +1
+		#print sl[0]
+		self.slidelink =sl[0]
+		
+		self["Mlist"].l.setList(self.Mlist)
+		self["Mlist"].selectionEnabled(1)
+		self["Mlist"].show
+		self.up() # das erste Bild anzeigen
+
+# -------------------------------------------------------------------
+	def up(self):
+		#self["Preview"].hide()
+		self["Mlist"].up()
+		self["Mlist"].selectionEnabled(1)
+
+	def down(self):
+		#self["Preview"].hide()
+		self["Mlist"].down()
+		self["Mlist"].selectionEnabled(1)
+
+	def left(self):
+		#self["Preview"].hide()
+		self["Mlist"].pageUp()
+		self["Mlist"].selectionEnabled(1)
+
+	def right(self):
+		#self["Preview"].hide()
+		self["Mlist"].pageDown()
+		self["Mlist"].selectionEnabled(1)
+
+	def OK(self):
+		url = self.slidelink
+		url = "http://www.kicker.de" + url
+		print "[Formel1] Url:" , url
+		getPage(url).addCallback(self.getRacingDetailInfo).addErrback(self.error)
+		#self.session.open(View_Slideshow, 0, True)
+
+
+	def GetVideos(self):
+		# wenn nicht zugeordnet ist dann als Default Video Istanbul
+		ort = self.ort
+		url = 'http://www.youtube.com/watch?v=7ZM52oViOoc'
+		filename = "Melbourne.flv"
+
+		print ort
+		if ort == "Melbourne":
+			url = 'http://www.youtube.com/watch?v=7ZM52oViOoc'
+			filename = "Melbourne.flv"
+
+		if ort == "Kuala Lumpur":
+			url = 'http://www.youtube.com/watch?v=unFYsw9QqwE'
+			filename = "Kuala Lumpur.flv"
+
+		if ort == "Shanghai":
+			url = 'http://www.youtube.com/watch?v=ifubWJiJwBA'
+			filename = "Shanghai.flv"
+
+		if ort == "Istanbul":
+			url = 'http://www.youtube.com/watch?v=L14MT1N4eFc'
+			filename = "Istanbul.flv"
+
+		if ort == "Barcelona":
+			url = 'http://www.youtube.com/watch?v=Z_8att6ykys'
+			filename = "Barcelona.flv"
+
+		if ort == "Monte Carlo":
+			url = 'http://www.youtube.com/watch?v=Yu8OYS7i_D0'
+			filename = "Monte Carlo.flv"
+
+		if ort == "Montreal":
+			url = 'http://www.youtube.com/watch?v=QPXwDLZlqhY'
+			filename = "Montreal.flv"
+
+		if ort == "Valencia":
+			url = 'http://www.youtube.com/watch?v=KJ4JvqMo9Vk'
+			filename = "Valencia.flv"
+
+		if ort == "Silverstone":
+			url = 'http://www.youtube.com/watch?v=don9SEpAKnQ'
+			filename = "Silverstone.flv"
+
+		if ort == "Nürburgring":
+			url = 'http://www.youtube.com/watch?v=aIJrLIFO-1o'
+			filename = "Nürburgring.flv"
+
+		if ort == "Budapest":
+			url = 'http://www.youtube.com/watch?v=AtlAivlVmU4'
+			filename = "Budapest.flv"
+			
+		if ort == "Spa-Francorchamps":
+			url = 'http://www.youtube.com/watch?v=9MkGbenP7GY'
+			filename = "Spa-Francorchamps.flv"
+
+		if ort == "Monza":
+			url = 'http://www.youtube.com/watch?v=9xkibV5YJDc'
+			filename = "Monza.flv"
+
+		if ort == "Singapur":
+			url = 'http://www.youtube.com/watch?v=nwOi0u3q5bs'
+			filename = "Singapur.flv"
+
+		if ort == "Suzuka":
+			url = 'http://www.youtube.com/watch?v=cGqK41AejYY'
+			filename = "Suzuka.flv"
+
+		if ort == "Yeongam":
+			url = 'http://www.youtube.com/watch?v=i1mzuC977mk'
+			filename = "Yeongam.flv"
+
+		if ort == "##Greater Noida": #gesperrt
+			url = 'http://www.youtube.com/watch?v=Nz0B1NEVy8E'
+			filename = "Greater Noida.flv"
+
+		if ort == "Abu Dhabi":
+			url = 'http://www.youtube.com/watch?v=9YlhMf8vf3w'
+			filename = "Abu Dhabi.flv"
+
+		if ort == "Sao Paulo":
+			url = 'http://www.youtube.com/watch?v=MTg-KaoJoIc'
+			filename = "Sao Paulo.flv"
+
+		# check ob Video schon vorhanden ist
+		#if fileExists(config.plugins.formel1.Device.value + filename):
+		if fileExists(config.plugins.formel1.Device.value + filename, 'r'):
+			self.localsize = os_path.getsize(config.plugins.formel1.Device.value + filename)
+			# nur wenn groesser als 10 Mb abspielen, ist ein bischen buggy
+			print "[Formel1] Video vorhanden ", filename
+			if self.localsize >= 10000000:
+				sref = eServiceReference(0x1001, 0, config.plugins.formel1.Device.value + filename)
+				sref.setName(config.plugins.formel1.Device.value + filename)
+				self.session.open(MediathekMoviePlayer, sref, filename)
+			else:
+				self.useragent = "QuickTime/7.6.2 (qtver=7.6.2;os=Windows NT 5.1Service Pack 3)"
+				#self.session.open(getyoutube, url, filename)
+				self.DownloadYoutube(url, filename)
+		else:
+			self.useragent = "QuickTime/7.6.2 (qtver=7.6.2;os=Windows NT 5.1Service Pack 3)"
+			self.DownloadYoutube(url, filename)
+
+
+	def DownloadYoutube(self, url, filename):
+		print "DownloadYoutube START"
+		self.session.open(getyoutube, url, filename)
+		print "DownloadYoutube END"
+
+	def error(self, err=""):
+		print "[Formel1] Keine Daten zu diesem Rennen!"
+		message = "%s" % (_("Es sind noch keine Daten zu diesem Rennen vorhanden!\nSoll das Streckenvideo abgespielt werden?") )
+		#self.session.open( MessageBox, message, MessageBox.TYPE_ERROR, timeout=4)
+		self.session.openWithCallback(self.play_now, MessageBox, message, MessageBox.TYPE_YESNO)
+
+	def play_now(self, answer):
+		if answer == True:
+			self.GetVideos()
+			self.close()
+		else:
+			self.close()
+
+	def getRacingDetailInfo(self,html):
+		#<a href="javascript:ovSlArticleNext(550369,3)"><img class="pic" src="http://mediadb.kicker.de/news/1000/1020/22000/slideshow/750374/image_slshow_imArtikel_0_1.jpg"
+		# http://mediadb.kicker.de/news/1000/1020/22000/slideshow/750374/image_slshow_imArtikel_0_1.jpg
+		fulltext = re.compile(r'<a href="javascript:ovSlArticleNext.+?src="(.+?)_imArtikel', re.DOTALL)
+		showpic = fulltext.findall(html)
+		print "Pictureshowpic=", showpic
+		url = showpic[0] + "_imArtikel_0_"
+		print "Picturelink=", url
+		os.system("mkdir -p /tmp/f1")
+		os.system("rm /tmp/f1/*.jpg")
+
+		x = 0
+		while x < 10:
+			picurl = url + str(x+1) + ".jpg"
+			print "[Formel1] PiclinkLoop:", picurl
+			devicepath = "/tmp/f1/Bild" + str(x+1) + ".jpg"
+			path = "/tmp/f1"
+			h = urllib.urlretrieve(picurl, devicepath)
+			x = x +1
+		self.session.open(View_Slideshow, 0, True)
+
+	def Exit(self):
+		self.close()
+
+	def RacingEntryItem(self,entry):
+		rot = 16711680
+		gruen = 60928
+		dgruen = 52480
+		drot = 0xf47d19
+		mblau = 8900346
+		hblau = 11592447
+		dblau = 5215437
+		weiss = 0xffffff
+		orange = 0xf47d19
+		grau = 0x565656
+
+		res = [entry]
+		res.append(MultiContentEntryText(pos=(5, 2), size=(50, 30), font=1, text=entry[0], color=dblau, color_sel=dblau, backcolor_sel=grau))
+		res.append(MultiContentEntryText(pos=(50, 2), size=(250, 30), font=1, text=entry[1], color=mblau, color_sel=mblau, backcolor_sel=grau))
+		res.append(MultiContentEntryText(pos=(320, 2), size=(270, 30), font=1, text=entry[2], color=dblau, color_sel=dblau, backcolor_sel=grau))
+		res.append(MultiContentEntryText(pos=(620, 2), size=(300, 30), font=1, text=entry[3], color=drot, color_sel=drot, backcolor_sel=grau))
+		return res
+#------------------------------------------------------------------------------------------
+#class View_Slideshow(Screen, InfoBarAspectSelection, InfoBarResolutionSelection):
+class View_Slideshow(Screen):
+	def __init__(self, session, pindex, startslide):
+
+		print "SlideShow is running ......."
+		self.textcolor = config.plugins.formel1.textcolor.value
+		self.bgcolor = config.plugins.formel1.bgcolor.value
+		space = config.plugins.formel1.framesize.value
+		size_w = getDesktop(0).size().width()
+		size_h = getDesktop(0).size().height()
+
+		self.skindir = "/tmp"
+		self.skin = "<screen position=\"0,0\" size=\"" + str(size_w) + "," + str(size_h) + "\" flags=\"wfNoBorder\" > \
+			<eLabel position=\"0,0\" zPosition=\"0\" size=\""+ str(size_w) + "," + str(size_h) + "\" backgroundColor=\""+ self.bgcolor +"\" /><widget name=\"pic\" position=\"" + str(space) + "," + str(space) + "\" size=\"" + str(size_w-(space*2)) + "," + str(size_h-(space*2)) + "\" zPosition=\"1\" alphatest=\"on\" /> \
+			<widget name=\"point\" position=\""+ str(space+5) + "," + str(space+10) + "\" size=\"20,20\" zPosition=\"2\" pixmap=\"/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/record.png\" alphatest=\"on\" /> \
+			<widget name=\"play_icon\" position=\""+ str(space+25) + "," + str(space+10) + "\" size=\"20,20\" zPosition=\"2\" pixmap=\"/usr/lib/enigma2/python/Plugins/Extensions/Formel1/strecken/ico_mp_play.png\"  alphatest=\"on\" /> \
+			<widget name=\"file\" position=\""+ str(space+45) + "," + str(space+8) + "\" size=\""+ str(size_w-(space*2)-50) + ",25\" font=\"Regular;20\" halign=\"left\" foregroundColor=\"" + self.textcolor + "\" zPosition=\"2\" noWrap=\"1\" transparent=\"1\" /></screen>"
+		Screen.__init__(self, session)
+
+		#InfoBarAspectSelection.__init__(self)
+		self["actions"] = ActionMap(["OkCancelActions", "ColorActions", "DirectionActions", "MovieSelectionActions"],
+		{
+			"cancel": self.Exit,
+			"yellow": self.PlayPause,
+			"blue": self.sleepTimer,
+			"left": self.prevPic,
+			"right": self.nextPic,
+		}, -1)
+		self["point"] = Pixmap()
+		self["pic"] = Pixmap()
+		self["play_icon"] = Pixmap()
+		self["file"] = Label(_("please wait, loading picture..."))
+		self.old_index = 0
+		self.picfilelist = []
+		self.lastindex = pindex
+		self.currPic = []
+		self.shownow = True
+		self.dirlistcount = 0
+
+		devicepath = "/tmp/f1/"
+		currDir = devicepath
+		self.filelist = FileList(currDir, showDirectories = False, matchingPattern = "^.*\.(jpg)", useServiceRef = False)
+
+		for x in self.filelist.getFileList():
+				if x[0][1] == False:
+					self.picfilelist.append(currDir + x[0][0])
+				else:
+					self.dirlistcount += 1
+
+		self.maxentry = len(self.picfilelist)-1
+		self.pindex = pindex - self.dirlistcount
+		if self.pindex < 0:
+			self.pindex = 0
+		self.picload = ePicLoad()
+		self.picload.PictureData.get().append(self.finish_decode)
+		self.slideTimer = eTimer()
+		self.slideTimer.callback.append(self.slidePic)
+		if self.maxentry >= 0:
+			self.onLayoutFinish.append(self.setPicloadConf)
+		if startslide == True:
+			self.PlayPause();
+
+	def setPicloadConf(self):
+		sc = getScale()
+		self.picload.setPara([self["pic"].instance.size().width(), self["pic"].instance.size().height(), sc[0], sc[1], 0, int(config.plugins.formel1.resize.value), self.bgcolor])
+		self["play_icon"].hide()
+		if config.plugins.formel1.infoline.value == False:
+			self["file"].hide()
+		self.start_decode()
+
+	def ShowPicture(self):
+		if self.shownow and len(self.currPic):
+			self.shownow = False
+			self["file"].setText(self.currPic[0])
+			self.lastindex = self.currPic[1]
+			self["pic"].instance.setPixmap(self.currPic[2].__deref__())
+			self.currPic = []
+			self.next()
+			self.start_decode()
+
+	def finish_decode(self, picInfo=""):
+		self["point"].hide()
+		ptr = self.picload.getData()
+		if ptr != None:
+			text = ""
+			try:
+				text = picInfo.split('\n',1)
+				text = "(" + str(self.pindex+1) + "/" + str(self.maxentry+1) + ") " + text[0].split('/')[-1]
+			except:
+				pass
+			self.currPic = []
+			self.currPic.append(text)
+			self.currPic.append(self.pindex)
+			self.currPic.append(ptr)
+			self.ShowPicture()
+
+	def start_decode(self):
+		self.picload.startDecode(self.picfilelist[self.pindex])
+		self["point"].show()
+
+	def next(self):
+		self.pindex += 1
+		if self.pindex > self.maxentry:
+			self.pindex = 0
+
+	def prev(self):
+		self.pindex -= 1
+		if self.pindex < 0:
+			self.pindex = self.maxentry
+
+	def slidePic(self):
+		print "[Formel1] slide to next Picture index=" + str(self.lastindex)
+		if config.plugins.formel1.loop.value==False and self.lastindex == self.maxentry:
+			self.PlayPause()
+		self.shownow = True
+		self.ShowPicture()
+
+	def PlayPause(self):
+		if self.slideTimer.isActive():
+			self.slideTimer.stop()
+			self["play_icon"].hide()
+		else:
+			self.slideTimer.start(config.plugins.formel1.slidetime.value*1000)
+			self["play_icon"].show()
+			self.nextPic()
+
+	def prevPic(self):
+		self.currPic = []
+		self.pindex = self.lastindex
+		self.prev()
+		self.start_decode()
+		self.shownow = True
+
+	def nextPic(self):
+		self.shownow = True
+		self.ShowPicture()
+
+	def Exit(self):
+		del self.picload
+		self.close(self.lastindex + self.dirlistcount)
+
+	def sleepTimer(self):
+		from Screens.SleepTimerEdit import SleepTimerEdit
+		self.session.open(SleepTimerEdit)
+
+#------------------------------------------------------------------------------------------
+#-------------------------------- Formel1 Settings ----------------------------------------
+#------------------------------------------------------------------------------------------
+class PicSetup(Screen):
+	skin = """<screen position="center,center" size="480,260" title="Formel1 SlideShow Settings" backgroundColor="#000000" >
+		<widget name="liste" position="5,5" size="470,250" scrollbarMode="showOnDemand" />
+		<eLabel backgroundColor="red" position="28,250" size="140,3" zPosition="2"/>
+		<eLabel backgroundColor="green" position="228,250" size="140,3" zPosition="2"/>
+		<widget name="key_red" position="28,218" zPosition="3" size="140,40" font="Regular;19" valign="center" halign="center" transparent="1" />
+		<widget name="key_green" position="228,218" zPosition="3" size="140,40" font="Regular;19" valign="center" halign="center" transparent="1" />
+	</screen>"""
+
+	def __init__(self, session):
+		self.skin = PicSetup.skin
+		Screen.__init__(self, session)
+		self["key_red"] = Button(_("Back"))
+		self["key_green"] = Button(_("Save"))
+		self["actions"] = NumberActionMap(["SetupActions", "ColorActions"],
+		{
+			"ok": self.save,
+			"green": self.save,
+			"cancel": self.close,
+			"red": self.close,
+			"left": self.keyLeft,
+			"right": self.keyRight,
+			"0": self.keyNumber,
+			"1": self.keyNumber,
+			"2": self.keyNumber,
+			"3": self.keyNumber,
+			"4": self.keyNumber,
+			"5": self.keyNumber,
+			"6": self.keyNumber,
+			"7": self.keyNumber,
+			"8": self.keyNumber,
+			"9": self.keyNumber
+		}, -3)
+		self.list = []
+		self["liste"] = ConfigList(self.list)
+
+		#self.list.append(getConfigListEntry(_("Picture Y moving"), config.plugins.formel1.max_offsety))
+		#self.list.append(getConfigListEntry(_("delete cached Pictures"), config.plugins.formel1.remove))
+		self.list.append(getConfigListEntry(_("Video Cache"), config.plugins.formel1.Device))
+		self.list.append(getConfigListEntry(_("Scaling Mode"), config.plugins.formel1.resize))
+		self.list.append(getConfigListEntry(_("Frame size in full view"), config.plugins.formel1.framesize))
+		self.list.append(getConfigListEntry(_("backgroundcolor"), config.plugins.formel1.bgcolor))
+		self.list.append(getConfigListEntry(_("Textcolor"), config.plugins.formel1.textcolor))
+		self.list.append(getConfigListEntry(_("SlideTime"), config.plugins.formel1.slidetime))
+		self.list.append(getConfigListEntry(_("Show Infoline"), config.plugins.formel1.infoline))
+		self.list.append(getConfigListEntry(_("slide picture in loop"), config.plugins.formel1.loop))
+
+	def save(self):
+		for x in self["liste"].list:
+				x[1].save()
+		config.save()
+		self.close()
+
+	def keyLeft(self):
+		self["liste"].handleKey(KEY_LEFT)
+	def keyRight(self):
+		self["liste"].handleKey(KEY_RIGHT)
+	def keyNumber(self, number):
+		self["liste"].handleKey(KEY_0 + number)
+
+
+#------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------------------
+class PlayMovie(Screen):
+	skin = """
+		<screen position="center,center" size="450,240" title="Caching Video ..." >
+			<widget source="label_filename" transparent="1" render="Label" zPosition="2" position="10,10" size="430,21" font="Regular;19" />
+			<widget source="label_destination" transparent="1" render="Label" zPosition="2" position="10,35" size="430,21" font="Regular;19" />
+			<widget source="label_speed" transparent="1" render="Label" zPosition="2" position="10,60" size="430,21" font="Regular;19" />
+			<widget source="label_timeleft" transparent="1" render="Label" zPosition="2" position="10,85" size="430,21" font="Regular;19" />
+			<widget source="label_progress" transparent="1" render="Label" zPosition="2" position="10,110" size="430,21" font="Regular;19" />
+			<widget name="activityslider" position="10,150" size="430,30" zPosition="3" transparent="0" />
+			<widget name="key_red" position="10,200" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
+			<widget name="key_green" position="155,200" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
+			<widget name="key_blue" position="300,200" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
+			<ePixmap pixmap="/usr/share/enigma2/skin_default/buttons/red.png" position="10,200" size="140,40" alphatest="on" />
+			<ePixmap pixmap="/usr/share/enigma2/skin_default/buttons/green.png" position="155,200" size="140,40" alphatest="on" />
+			<ePixmap pixmap="/usr/share/enigma2/skin_default/buttons/blue.png" position="300,200" size="140,40" alphatest="on" />
+		</screen>"""
+
+	def __init__(self, session, url, titel, movietitle, movieinfo, filename):
+		self.skin = PlayMovie.skin
+		Screen.__init__(self, session)
+
+		self.url = url
+		self.title = titel
+		self.filename = filename
+
+		self.movietitle = movietitle
+		self.movieinfo = movieinfo
+		self.destination = config.plugins.formel1.Device.value
+
+		self.streamactive = False
+		self.isVisible = True
+
+		self.container=eConsoleAppContainer()
+		self.container.appClosed.append(self.copyfinished)
+		self.container.stdoutAvail.append(self.progressUpdate)
+		self.container.stderrAvail.append(self.progressUpdate)
+		self.container.setCWD(self.destination)
+
+		self.oldService = self.session.nav.getCurrentlyPlayingServiceReference()
+		self.BgFileEraser = eBackgroundFileEraser.getInstance()
+
+		try:
+			req = Request(self.url)
+			req.add_header('User-agent',self.useragent)
+			usock = urlopen(req)
+			filesize =  usock.info().get('Content-Length')
+		except Exception, e:
+			filesize = 0
+
+		if filesize is None:
+			filesize = 0
+
+		self.filesize = float(filesize) # in bytes
+
+		self.dummyfilesize = False
+		self.lastcmddata = None
+		self.lastlocalsize = 0
+
+		self["key_green"] = Button(_("Play now"))
+		self["key_red"] = Button(_("Cancel"))
+		self["key_blue"] = Button(_("Show/Hide"))
+
+		self["label_filename"] = StaticText("File: %s" % (self.filename))
+		self["label_destination"] = StaticText("Destination: %s" % (config.plugins.formel1.Device.value))
+		self["label_progress"] = StaticText("Progress: N/A")
+		self["label_speed"] = StaticText("Speed: N/A")
+		self["label_timeleft"] = StaticText("Time left: N/A")
+
+		self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
+		{
+			"cancel": self.exit,
+			"ok": self.okbuttonClick,
+			"red": self.exit,
+			"green": self.playfile,
+			"blue": self.visibility
+		}, -1)
+
+		self.StatusTimer = eTimer()
+		self.StatusTimer.callback.append(self.UpdateStatus)
+
+		self.activityslider = Slider(0, 100)
+		self["activityslider"] = self.activityslider
+
+		self.onFirstExecBegin.append(self.firstExecBegin)
+
+	def firstExecBegin(self):
+		self.progressperc = 0
+		self.copyfile()
+
+	def okbuttonClick(self):
+		if self.isVisible == False:
+			self.visibility()
+
+	def UpdateStatus(self):
+		if fileExists(self.destination + self.filename, 'r'):
+			self.localsize = os_path.getsize(self.destination + self.filename)
+		else:
+			self.localsize = 0
+
+		if self.filesize > 0 and not self.dummyfilesize:
+			self.progressperc = round((self.localsize / self.filesize) * 100, 2)
+
+		if int(self.progressperc) > 0:
+			self["activityslider"].setValue(int(self.progressperc))
+
+		if self.lastlocalsize != 0:
+			transferspeed = round(((self.localsize - self.lastlocalsize) / 1024.0) / 5, 0)
+			kbytesleft = round((self.filesize - self.localsize) / 1024.0,0)
+			if transferspeed > 0:
+				timeleft = round((kbytesleft / transferspeed) / 60,2)
+			else:
+				timeleft = 0
+		else:
+			transferspeed = 0
+			kbytesleft = 0
+			timeleft = 0
+
+		self.lastlocalsize = self.localsize
+
+		self["label_speed"].setText("Speed: " + str(transferspeed) + " KBit/s")
+		self["label_progress"].setText("Progress: " + str(round(((self.localsize / 1024.0) / 1024.0), 2)) + "MB of " + str(round(((self.filesize / 1024.0) / 1024.0), 2)) + "MB (" + str(self.progressperc) + "%)")
+		self["label_timeleft"].setText("Time left: " + str(timeleft) + " Minutes")
+		self.StatusTimer.start(5000, True)
+
+	def copyfile(self):
+		if fileExists(self.destination + self.filename, 'r'):
+			self.localsize = os_path.getsize(self.destination + self.filename)
+			if self.localsize > 0 and self.localsize >= self.filesize:
+				cmd = "echo File already downloaded! Skipping download ..."
+			elif self.localsize == 0:
+				self.BgFileEraser.erase(self.destination + self.filename)
+
+		self.StatusTimer.start(1000, True)
+		self.streamactive = True
+
+		print "[Mediathek] execute command: " + cmd
+		#self.container.execute(cmd)
+
+	def progressUpdate(self, data):
+		self.lastcmddata = data
+		if data.endswith('%)'):
+			startpos = data.rfind("sec (")+5
+			if startpos and startpos != -1:
+				self.progressperc = int(float(data[startpos:-4]))
+
+				if self.lastlocalsize > 0 and self.progressperc > 0:
+					self.filesize = int(float(self.lastlocalsize/self.progressperc)*100)
+					self.dummyfilesize = True
+
+	def copyfinished(self,retval):
+		self.streamactive = False
+		self.UpdateStatus()
+		self["label_progress"].setText("Progress: 100%")
+		self["activityslider"].setValue(100)
+		self.playfile()
+
+	def playfile(self):
+		if self.lastlocalsize > 0:
+			self.StatusTimer.stop()
+
+			print self.destination + self.filename
+
+			sref = eServiceReference(0x1001, 0, self.destination + self.filename)
+			sref.setName(self.movietitle)
+			self.session.openWithCallback(self.MoviePlayerCallback, MediathekMoviePlayer, sref, self.movieinfo)
+		else:
+			self.session.openWithCallback(self.exit, MessageBox, _("Error downloading file:\n%s") % self.lastcmddata, MessageBox.TYPE_ERROR)
+
+	def MoviePlayerCallback(self, response=None):
+		if self.isVisible == False:
+			self.visibility()
+		self.UpdateStatus()
+		if response is not None and VLCSUPPORT:
+			try:
+				ipaddress = self.convertIP(iNetwork.getAdapterAttribute("eth0", "ip"))
+				streamurl = "http://" + ipaddress + ":" + str(config.plugins.Webinterface.http.port.value) + "/file?file=" + self.destination + self.filename
+				#self.session.openWithCallback(self.exit, MessageBox, _("START VLC-STREAM:\n%s") % streamurl, MessageBox.TYPE_INFO)
+				if vlcServerConfig.getDefaultServer() is None:
+					self.session.openWithCallback(self.exit, MessageBox, _("No Default Server configured in VLC Settings"), MessageBox.TYPE_ERROR)
+				else:
+					vlcServerConfig.getDefaultServer().play(self.session, media=streamurl, name=self.movietitle, currentList=None, player=boundFunction(VlcPlayer))
+			except Exception, error:
+				self.session.openWithCallback(self.exit, MessageBox, _("VLC Plugin Error: %s") % error, MessageBox.TYPE_ERROR)
+
+	def convertIP(self, list):
+		if len(list) == 4:
+			retstr = "%s.%s.%s.%s" % (list[0], list[1], list[2], list[3])
+		else:
+			retstr = "0.0.0.0"
+		return retstr
+
+	def visibility(self):
+		if self.isVisible == True:
+			self.isVisible = False
+			self.hide()
+		else:
+			self.isVisible = True
+			self.show()
+
+	def exit(self, retval=None):
+		if self.isVisible == False:
+			self.visibility()
+			return
+
+		self.container.kill()
+		self.BgFileEraser.erase(self.destination + self.filename)
+
+		self.StatusTimer.stop()
+		self.session.nav.playService(self.oldService)
+		self.close()
+
+#------------------------------------------------------------------------------------------
+
+class MediathekMoviePlayer(MoviePlayer):
+	def __init__(self, session, service, movieinfo=None):
+		MoviePlayer.__init__(self, session, service)
+		self.skinName = "MoviePlayer"
+		self.movieinfo = movieinfo
+
+		self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+			{
+				iPlayableService.evUser+10: self.__evAudioDecodeError,
+				iPlayableService.evUser+11: self.__evVideoDecodeError,
+				iPlayableService.evUser+12: self.__evPluginError
+			})
+
+	def leavePlayer(self):
+		self.leavePlayerConfirmed(True)
+
+	def leavePlayerConfirmed(self, answer):
+		if answer:
+			self.close()
+
+	def doEofInternal(self, playing):
+		currPlay = self.session.nav.getCurrentService()
+		message = currPlay.info().getInfoString(iServiceInformation.sUser+12)
+		if message.find('Flash demuxer not available') != -1 or message.find('(AVI) demuxer not available') != -1:
+			self.session.openWithCallback(self.GSTplugincallback, MessageBox, _("Your Dreambox can't decode this video stream!\n%s\nDo you want to download and install it now?") % message, MessageBox.TYPE_YESNO)
+		elif message.find('GStreamer plugin') != -1 and message.find('not available') != -1:
+			self.__evPluginError()
+		else:
+			self.leavePlayerConfirmed(True)
+
+	def showMovies(self):
+		pass
+
+	def __evAudioDecodeError(self):
+		currPlay = self.session.nav.getCurrentService()
+		sTagAudioCodec = currPlay.info().getInfoString(iServiceInformation.sTagAudioCodec)
+		print "[__evAudioDecodeError] audio-codec %s can't be decoded by hardware" % (sTagAudioCodec)
+		self.session.open(MessageBox, _("This Dreambox can't decode %s streams!") % sTagAudioCodec, type=MessageBox.TYPE_INFO, timeout=20)
+
+	def __evVideoDecodeError(self):
+		currPlay = self.session.nav.getCurrentService()
+		sTagVideoCodec = currPlay.info().getInfoString(iServiceInformation.sTagVideoCodec)
+		print "[__evVideoDecodeError] video-codec %s can't be decoded by hardware" % (sTagVideoCodec)
+		self.session.open(MessageBox, _("This Dreambox can't decode %s streams!") % sTagVideoCodec, type=MessageBox.TYPE_INFO, timeout=20)
+
+	def __evPluginError(self):
+		currPlay = self.session.nav.getCurrentService()
+		message = currPlay.info().getInfoString(iServiceInformation.sUser+12)
+		print "[__evPluginError]" , message
+		if VLCSUPPORT and self.movieinfo is not None:
+			self.session.openWithCallback(self.VLCcallback, MessageBox, _("Your Dreambox can't decode this video stream!\n%s\nDo you want to stream it via VLC Server from your PC?") % message[17:], MessageBox.TYPE_YESNO)
+		else:
+			self.session.open(MessageBox, _("Your Dreambox can't decode this video stream!\n%s") % message, type=MessageBox.TYPE_INFO, timeout=20)
+
+	def GSTplugincallback(self, answer):
+		if answer is True:
+			self.container=eConsoleAppContainer()
+			self.container.appClosed.append(self.finishedPluginInstall)
+			self.container.execute("opkg update && opkg install gst-plugin-avi gst-plugin-flv gst-plugin-rtsp")
+		else:
+			self.close()
+
+	def finishedPluginInstall(self,retval):
+		self.session.openWithCallback(self.restartGUI, MessageBox, _("Missing GStreamer-Plugins were installed!\nDo you want to restart Enigma2 GUI now?"), MessageBox.TYPE_YESNO)
+
+	def restartGUI(self, answer):
+		if answer is True:
+			self.session.open(TryQuitMainloop, 3)
+
+	def VLCcallback(self, answer):
+		if answer is True:
+			self.close(self.movieinfo)
+		else:
+			self.close()
+
+
+#------------------------------------------------------------------------------------------
+#------------------------------------- Haupt Programm -------------------------------------
+#------------------------------------------------------------------------------------------
+def start(session, **kwargs):
+	session.open(Formel1Preview)
+
+def Plugins(**kwargs):
+	return PluginDescriptor(name="Formel1", description="Formel 1 Rennsaison 2011", where=[PluginDescriptor.WHERE_EXTENSIONSMENU, PluginDescriptor.WHERE_PLUGINMENU], fnc=start)
Index: /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/tipprunde.py
===================================================================
--- /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/tipprunde.py	(revision 7589)
+++ /ipk/source.sh4/infos_formel1/usr/lib/enigma2/python/Plugins/Extensions/Formel1/tipprunde.py	(revision 7589)
@@ -0,0 +1,663 @@
+# -*- coding: utf-8 -*-
+
+#-------------------------------------------------------
+#
+#              AAF Formel1 Tipspiel
+#
+#   Dieses Plugin dient zur Betrachtung der Ergebnisse
+#   der AAF - Tipprunde.
+#
+#
+#   Wir wuenschen allen Benutzern viel Spaß mit diesem
+#   nuetzlichem Plugin.
+#
+#    http://www.kicktipp.de/aafformel1/gesamtuebersicht
+#
+#                 13.05.2011
+#
+#
+#             Designed und Idee von
+#                 @Bauernbub
+#
+#-------------------------------------------------------
+
+from enigma import *
+from enigma import eActionMap
+from enigma import eListboxPythonMultiContent, eListbox, gFont
+from Screens.Screen import Screen
+from Screens.ServiceInfo import ServiceInfoList, ServiceInfoListEntry
+from Components.ActionMap import ActionMap, NumberActionMap, HelpableActionMap
+from Components.Pixmap import Pixmap, MovingPixmap
+from Components.Label import Label
+from Components.Button import Button
+from Components.Sources.List import List
+from Screens.MessageBox import MessageBox
+from Screens.HelpMenu import HelpableScreen
+from Components.ConfigList import ConfigList
+from Components.config import *
+from Tools.Directories import resolveFilename, fileExists, pathExists, createDir, SCOPE_MEDIA
+from Components.FileList import FileList
+from Components.AVSwitch import AVSwitch
+from Components.MultiContent import MultiContentEntryText
+from Plugins.Plugin import PluginDescriptor
+from Screens.VirtualKeyBoard import VirtualKeyBoard
+from Components.ConfigList import ConfigListScreen
+from os import path as os_path
+from os import system, remove, walk, makedirs, listdir, chdir
+from Screens.NetworkSetup import *
+from twisted.web.client import downloadPage
+from twisted.web import client
+from Components.HTMLComponent import HTMLComponent
+from Components.GUIComponent import GUIComponent
+from Screens.VirtualKeyBoard import VirtualKeyBoard
+from Components.Sources.Progress import Progress
+from re import sub, split, search, match, findall
+
+from string import find, atoi, strip
+
+import os
+import sys
+import urllib
+
+
+config.plugins.tipprunde = ConfigSubsection()
+config.plugins.tipprunde.spalte = ConfigSelection(default="0", choices = [("0", _("Spalte1")), ("1", _("Spalte2")), ("3", _("Spalte3"))])
+config.plugins.tipprunde.color1 = ConfigSelection(default="15794175", choices = [("15794175", _("weiss")),("0", _("black")),("10402303", _("blue")),("16734801", _("red")), ("16771189", _("yellow")), ("65280", _("green"))])
+config.plugins.tipprunde.color2 = ConfigSelection(default="65280", choices = [("15794175", _("weiss")),("0", _("black")),("10402303", _("blue")),("16734801", _("red")), ("16771189", _("yellow")), ("65280", _("green"))])
+config.plugins.tipprunde.bgcolor = ConfigSelection(default="#000000", choices = [("#ffffff", _("weiss")),("#000000", _("black")),("#9eb9ff", _("blue")),("#ff5a51", _("red")), ("#ffe875", _("yellow")), ("#38FF48", _("green"))])
+config.plugins.tipprunde.null = ConfigSelection(default="0", choices = [("0", _("Yes")), ("1", _("No"))])
+
+
+RT_HALIGN_LEFT = 0
+TYPE_TEXT = 0
+
+#---------------------- Skin Funktionen -----------------------------------------------------------
+def getAspect():
+	val = AVSwitch().getAspectRatioSetting()
+	return val/2
+
+def getScale():
+	return AVSwitch().getFramebufferScale()
+
+def applySkinVars(skin,dict):
+		for key in dict.keys():
+				try:
+						skin = skin.replace('{'+key+'}',dict[key])
+				except Exception,e:
+						print e,"@key=",key
+		return skin
+
+def transHTML(text):
+		text = text.replace('&nbsp;'," ").replace('&#39;',"'").replace('&szlig;',"sz").replace('&quot;','"').replace('&ndash;',"-")
+		text = text.replace('&copy;.*'," ").replace('&amp;',"&").replace('&uuml;',"ue").replace('&auml;',"ae").replace('&ouml;',"oe")
+		text = text.replace('&Uuml;',"Ue").replace('&Auml;',"Ae").replace('&Ouml;',"Oe")
+		text = text.replace('&#223;',"ae").replace('&raquo;',"").replace('&ldquo;','"').replace('&rdquo;','"')
+		text = text.replace('\xfc',"ue").replace('\xd6',"Oe").replace('\xf6',"oe").replace('\xe4',"ae")
+		return text
+
+#------------------------------------------------------------------------------------------
+def TabelleListEntry(tipptext, color):
+	res = [ ]
+	if config.plugins.tipprunde.null.value == "0":
+		tipptext = tipptext.replace(' 00',"   ").replace('0.00',"    ")
+
+	#PyObject *type, *px, *py, *pwidth, *pheight, *pfnt, *pstring, *pflags;
+	res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 0, 500, 25, 0, RT_HALIGN_LEFT, " ", 65280))
+	res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 0, 1190, 25, 0, RT_HALIGN_LEFT, tipptext, float(color)))
+	return res
+
+#------------------------------------------------------------------------------------------
+class TabelleList(HTMLComponent, GUIComponent):
+	def __init__(self, source):
+		GUIComponent.__init__(self)
+		self.l = eListboxPythonMultiContent()
+		self.list = source
+		self.l.setList(self.list)
+		self.l.setFont(0, gFont("Console", 20))
+		self.l.setItemHeight(22)
+
+	GUI_WIDGET = eListbox
+
+	def postWidgetCreate(self, instance):
+		self.instance.setContent(self.l)
+
+#------------------------------------------------------------------------------------------
+#------------------------------ Tipprunde AAF-Board ---------------------------------------
+#------------------------------------------------------------------------------------------
+
+class Tipprunde(Screen):
+	current_w = getDesktop(0).size().width()
+	current_h = getDesktop(0).size().height()
+
+	if current_w == 1280:
+		skin = """
+			<screen name="Tipprunde" position="{tip.pos}" size="{tip.size}" title="AAF Formel1 Tippspiel" backgroundColor="#1f1a21" >
+				<ePixmap pixmap="skin_default/buttons/button_red.png" position="80,480"  zPosition="2" size="15,16" alphatest="on" />
+				<ePixmap pixmap="skin_default/buttons/button_green.png" position="320,480"  zPosition="2" size="15,16" alphatest="on" />
+				<ePixmap pixmap="skin_default/buttons/button_yellow.png" position="580,480"  zPosition="2" size="15,16" alphatest="on" />
+				<ePixmap pixmap="skin_default/buttons/button_blue.png" position="780,480"  zPosition="2" size="15,16" alphatest="on" />
+
+				<widget source="key_red" render="Label" position="100,475" zPosition="1" size="350,25" font="Regular;22" halign="left" transparent="1" />
+				<widget source="key_green" render="Label" position="350,475" zPosition="1" size="250,25" font="Regular;22" halign="left" transparent="1" />
+				<widget source="key_yellow" render="Label" position="600,475" zPosition="1" size="250,25" font="Regular;22" halign="left"  transparent="1" />
+				<widget source="key_blue" render="Label" position="800,475" zPosition="1" size="250,25" font="Regular;22" halign="left"  transparent="1" />
+
+				<widget name="Kopfzeile" zPosition="2" position="0,8" size="1051,20" font="Console;20" halign="left" transparent="1" foregroundColor="#ffa500"/>
+				<widget name="feedlist" position="10,43" zPosition="1" size="{feed.size}" scrollbarMode="showOnDemand" />
+				<eLabel position="10,30" zPosition="2" size="1050,1" backgroundColor="#c1cdc1" />
+				<eLabel position="196,30" zPosition="2" size="1,420" backgroundColor="#c1cdc1" />
+				<eLabel position="266,30" zPosition="2" size="1,420" backgroundColor="#c1cdc1" />
+				<eLabel position="338,30" zPosition="2" size="1,420" backgroundColor="#c1cdc1" />
+				<eLabel position="410,30" zPosition="2" size="1,420" backgroundColor="#c1cdc1" />
+				<eLabel position="482,30" zPosition="2" size="1,420" backgroundColor="#c1cdc1" />
+				<eLabel position="554,30" zPosition="2" size="1,420" backgroundColor="#c1cdc1" />
+				<eLabel position="626,30" zPosition="2" size="1,420" backgroundColor="#c1cdc1" />
+				<eLabel position="698,30" zPosition="2" size="1,420" backgroundColor="#c1cdc1" />
+				<eLabel position="770,30" zPosition="2" size="1,420" backgroundColor="#c1cdc1" />
+				<eLabel position="842,30" zPosition="2" size="1,420" backgroundColor="#c1cdc1" />
+				<eLabel position="914,30" zPosition="2" size="2,420" backgroundColor="#c1cdc1" />
+
+				<eLabel position="1001,30" zPosition="2" size="1,420" backgroundColor="#c1cdc1" />
+				<eLabel position="1058,30" zPosition="2" size="2,420" backgroundColor="#c1cdc1" />
+
+
+				<eLabel position="10,449" zPosition="2" size="1050,1" backgroundColor="#c1cdc1" />
+			</screen>"""
+	else:
+		skin = """
+			<screen name="Tipprunde" position="{tip.pos}" size="{tip.size}" title="AAF Formel1 Tippspiel" backgroundColor="#1f1a21" >
+				<ePixmap pixmap="skin_default/buttons/button_red.png" position="45,430"  zPosition="2" size="15,16" alphatest="on" />
+				<ePixmap pixmap="skin_default/buttons/button_green.png" position="245,430"  zPosition="2" size="15,16" alphatest="on" />
+				<ePixmap pixmap="skin_default/buttons/button_yellow.png" position="440,430"  zPosition="2" size="15,16" alphatest="on" />
+				<ePixmap pixmap="skin_default/buttons/button_blue.png" position="630,430"  zPosition="2" size="15,16" alphatest="on" />
+
+				<widget source="key_red" render="Label" position="65,425" zPosition="1" size="350,25" font="Regular;22" halign="left" transparent="1" />
+				<widget source="key_green" render="Label" position="265,425" zPosition="1" size="250,25" font="Regular;22" halign="left" transparent="1" />
+				<widget source="key_yellow" render="Label" position="460,425" zPosition="1" size="250,25" font="Regular;22" halign="left"  transparent="1" />
+				<widget source="key_blue" render="Label" position="650,425" zPosition="1" size="250,25" font="Regular;22" halign="left"  transparent="1" />
+
+				<widget name="Kopfzeile" zPosition="2" position="0,8" size="750,20" font="Console;20" transparent="1" foregroundColor="#ffa500"/>
+				<widget name="feedlist" position="10,43" zPosition="1" size="{feed.size}" scrollbarMode="showOnDemand" />
+				<eLabel position="10,30" zPosition="2" size="761,1" backgroundColor="#c1cdc1" />
+				<eLabel position="196,30" zPosition="2" size="1,370" backgroundColor="#c1cdc1" />
+				<eLabel position="266,30" zPosition="2" size="1,370" backgroundColor="#c1cdc1" />
+				<eLabel position="338,30" zPosition="2" size="1,370" backgroundColor="#c1cdc1" />
+				<eLabel position="410,30" zPosition="2" size="1,370" backgroundColor="#c1cdc1" />
+				<eLabel position="517,30" zPosition="2" size="1,370" backgroundColor="#c1cdc1" />
+				<eLabel position="569,30" zPosition="2" size="1,370" backgroundColor="#c1cdc1" />
+				<eLabel position="10,399" zPosition="2" size="761,1" backgroundColor="#c1cdc1" />
+			</screen>"""
+
+#				<eLabel position="482,30" zPosition="2" size="1,370" backgroundColor="#c1cdc1" />
+
+	def __init__(self, session):
+		self.session = session
+		self.liste = 1
+		self.list = 1
+		liste = 1
+
+		#switch automatic to current skin
+		current_w = getDesktop(0).size().width()
+		current_h = getDesktop(0).size().height()
+
+		print "[Tipprunde] Aufloesung width :" + str(current_w)
+		print "[Tipprunde] Aufloesung height:" + str(current_h)
+
+		# define the start koordinates and size
+		if current_w == 1280:
+				size_w = 1024 + 71
+				size_h = 515
+				offsety = 15
+	 			offset = 30
+				kopf_pos = size_w/2 -380
+				feed_sizeh = size_h - 120  
+				feed_size = size_w - 20
+		else:
+				size_w = 617
+				size_h = 470
+				kopf_pos = 0
+				offsety = 15
+	 			offset = 5
+				feed_sizeh = size_h - 120
+				feed_size = size_w - 30
+
+		pos_w = (current_w - size_w)/2
+		pos_h = (current_h - size_h)/2 + offsety
+
+		# calculate Skin koordinates
+		font = "Regular;18"
+
+
+		offsett = 0
+		bgcolor = config.plugins.tipprunde.bgcolor.value
+
+		self.dict = {
+				'bgcolor': bgcolor,
+				'font': font,
+				'tip.size': "%i,%i"%(size_w,size_h),
+				'tip.pos': "%i,%i"%(pos_w,pos_h),
+				'kopf1.pos': "%i,240"%(kopf_pos),
+				'feed.size': "%i,%i"%(feed_size,feed_sizeh),
+			}
+
+		self.skin = applySkinVars(Tipprunde.skin,self.dict)
+		Screen.__init__(self, session)
+		self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ColorActions", "NumberActions"],
+		{
+			"cancel": self.close,
+			"red": self.Liste1,
+			"green": self.Liste2,
+			"yellow": self.TippListe2,
+			"ok": self.Tipp_download,
+			"blue": self.Setup,
+			"1": self.select_url1,
+			"2": self.select_url2,
+			"3": self.select_url3,
+			"4": self.select_url4,
+			"5": self.select_url5
+		}, -2)
+
+		self["StartPic"] = Pixmap()
+		self["key_red"] = StaticText(_("<< Spalte 1"))
+		self["key_green"] = StaticText(_("Spalte >>"))
+
+		self["key_yellow"] = StaticText(_("51-81"))
+		self["key_blue"] = StaticText(_("Settings"))
+		self["Kopfzeile"] = Label("")
+
+		if current_w == 1280:
+			if config.plugins.tipprunde.spalte.value == "0":
+				self["Kopfzeile"].setText(" Nr  Name        Bo Au Ma Ch Tü Sp Mo Ka Eu Gr De Un Be It Si Ja Ko In Ab Br  Sg    Pkt")
+		else:
+			if config.plugins.tipprunde.spalte.value == "0":
+				self["Kopfzeile"].setText(" Nr  Name        Bo Au Ma Ch Tü Sp Mo  Sg   Pkt")
+			if config.plugins.tipprunde.spalte.value == "1":
+				self["Kopfzeile"].setText(" Nr  Name        Ka Eu Gr De Un Be It  Sg   Pkt")
+			if config.plugins.tipprunde.spalte.value == "2":
+				self["Kopfzeile"].setText(" Nr  Name        Si Ja Ko In Ab Br     Sg   Pkt")
+
+
+		tlist = [ ]
+		self["feedlist"] = TabelleList(tlist)
+		self["feedlist"].hide
+
+		self.Tipp_download()
+
+	def Liste1(self):
+		current_w = getDesktop(0).size().width()
+		liste = 1
+		self.list = liste
+		self.liste_load(liste)
+		if current_w == 1280:
+			self["Kopfzeile"].setText(" Nr  Name        Bo Au Ma Ch Tü Sp Mo Ka Eu Gr De Un Be It Si Ja Ko In Ab Br  Sg    Pkt")
+		else:
+			if self.list == 1:
+				self["Kopfzeile"].setText(" Nr  Name        Bo Au Ma Ch Tü Sp Mo  Sg   Pkt")
+			if self.list == 2:
+				self["Kopfzeile"].setText(" Nr  Name        Ka Eu Gr De Un Be It  Sg   Pkt")
+			if self.list == 3:
+				self["Kopfzeile"].setText(" Nr  Name        Si Ja Ko In Ab Br     Sg   Pkt")
+
+	def Liste2(self):
+		current_w = getDesktop(0).size().width()
+		self.list = self.list + 1
+		liste = self.list
+
+		if liste == 2 and current_w == 1280: # HD Skin hat nur 1 Seite
+			liste = 1
+			self.list = liste
+		if liste > 3:
+			liste = 3
+			self.list = liste
+		self.liste_load(liste)
+		if current_w == 1280:
+			self["Kopfzeile"].setText(" Nr  Name        Bo Au Ma Ch Tü Sp Mo Ka Eu Gr De Un Be It Si Ja Ko In Ab Br Sg  Pkt")
+		else:
+			if self.list == 1:
+				self["Kopfzeile"].setText(" Nr  Name        Bo Au Ma Ch Tü Sp Mo  Sg   Pkt")
+			if self.list == 2:
+				self["Kopfzeile"].setText(" Nr  Name        Ka Eu Gr De Un Be It  Sg   Pkt")
+			if self.list == 3:
+				self["Kopfzeile"].setText(" Nr  Name        Si Ja Ko In Ab Br     Sg   Pkt")
+
+
+	def Setup(self):
+		self.session.open(TippSetup)
+
+	def select_url1(self):
+		self.liste = 1
+		self["key_yellow"].setText("51-81")
+		self.Tipp_download()
+
+	def select_url2(self):
+		self.liste = 2
+		self["key_yellow"].setText("81-110")
+		self.Tipp_download()
+	def select_url3(self):
+		self.liste = 3
+		self["key_yellow"].setText("111-140")
+		self.Tipp_download()
+
+	def select_url4(self):
+		self.liste = 4
+		self["key_yellow"].setText("141-170")
+		self.Tipp_download()
+
+	def select_url5(self):
+		self.liste = 5
+		self["key_yellow"].setText("51-81")
+		self.Tipp_download()
+
+	def TippListe2(self):
+		print "Liste=" + str(self.liste)
+		if self.liste == 1:
+				self.liste = 2
+				self["key_yellow"].setText("51-81")
+		elif self.liste == 2:
+				self.liste = 3
+				self["key_yellow"].setText("81-110")
+		elif self.liste == 3:
+				self.liste = 4
+				self["key_yellow"].setText("111-140")
+		elif self.liste == 4:
+				self.liste = 5
+				self["key_yellow"].setText("141-170")
+		elif self.liste == 5:
+				self.liste = 1
+				self["key_yellow"].setText("51-81")
+
+		self.Tipp_download()
+
+#----- Tipp Download Procedures -------------------------------------------------------
+	def Tipp_download(self):
+		self.feed_base = url="http://www.kicktipp.de/aafformel1/gesamtuebersicht"
+		if self.liste == 2:
+			self.feed_base = url="http://www.kicktipp.de/aafformel1/gesamtuebersicht?offset=51&tippspieltagVonIndex=0&tippspieltagBisIndex=34&ansicht=spieltagspunkteSummiert&sortBy=gesamtpunkte"
+		if self.liste == 3:
+			self.feed_base = url="http://www.kicktipp.de/aafformel1/gesamtuebersicht?offset=81&tippspieltagVonIndex=0&tippspieltagBisIndex=34&ansicht=spieltagspunkteSummiert&sortBy=gesamtpunkte"
+		if self.liste == 4:
+			self.feed_base = url="http://www.kicktipp.de/aafformel1/gesamtuebersicht?offset=111&tippspieltagVonIndex=0&tippspieltagBisIndex=34&ansicht=spieltagspunkteSummiert&sortBy=gesamtpunkte"
+		if self.liste == 5:
+			self.feed_base = url="http://www.kicktipp.de/aafformel1/gesamtuebersicht?offset=141&tippspieltagVonIndex=0&tippspieltagBisIndex=34&ansicht=spieltagspunkteSummiert&sortBy=gesamtpunkte"
+
+		print "[feed-download]" +  self.feed_base
+		client.getPage(self.feed_base).addCallback(self.feed_finished).addErrback(self.feed_failed)
+
+#------------------------------------------------------------------------------------------
+	def feed_failed(self, failure_instance):
+		print "[Tipprunde] [feed_failed] " + str(failure_instance)
+		self["Kopfzeile"].text = _("Error:") + " " + failure_instance.getErrorMessage() + "\n\n" + _("Please check your network settings!")
+
+#------------------------------------------------------------------------------------------
+	def liste_load(self,liste):
+		sp = []
+		font_s = 0
+
+		f = open("/tmp/gesamtuebersicht.txt", "r" )
+		for zeile in f:
+				#pos = find(zeile,'#')
+				zeile = zeile.replace('\n',"")
+				print len(zeile)
+				if len(zeile) == 0:
+					zeile = "0"
+				sp.append(zeile)
+		f.close
+
+		i=0
+		tlist = [ ]
+ 		color = config.plugins.tipprunde.color1.value
+		current_w = getDesktop(0).size().width()
+		current_h = getDesktop(0).size().height()
+
+		maxzahler = 2000
+		if self.liste == 2 or self.liste == 3 or self.liste == 4 or self.liste == 5:
+			maxzahler = 1200
+		if self.liste == 5:
+			maxzahler = self.maxuser*25
+			
+		maxzahler = self.maxuser*25
+
+		if current_w == 1280:
+			while i < maxzahler:
+				nr = sp[i+0] # Nr
+				nr = nr.ljust(3)
+				name = sp[i+2] # Name
+				name = name.ljust(11)
+				if len(name) >11:
+						name = name[:11]
+
+				if liste == 1:
+						text = "%s %s %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d%0.2f %03d" %  (nr,name,int(sp[i+4]),int(sp[i+5]),int(sp[i+6]),int(sp[i+7]),int(sp[i+8]),int(sp[i+9]),int(sp[i+10]),int(sp[i+11]),int(sp[i+12]),int(sp[i+13]),int(sp[i+14]),int(sp[i+15]),int(sp[i+16]),int(sp[i+17]),int(sp[i+18]),int(sp[i+19]),int(sp[i+20]),int(sp[i+21]),int(sp[i+22]),int(sp[i+23]),int(sp[i+24]),float(sp[i+25]),int(sp[i+26]))
+						tlist.append(TabelleListEntry(text, color))
+
+				if color == config.plugins.tipprunde.color2.value:
+ 					color = config.plugins.tipprunde.color1.value
+				else:
+					color = config.plugins.tipprunde.color2.value
+				#print text
+				i = i + 27
+
+
+		else:
+			while i < maxzahler:
+				nr = sp[i+0] # Nr
+				nr = nr.ljust(3)
+				name = sp[i+2] # Name
+				name = name.ljust(11)
+				if len(name) >11:
+						name = name[:11]
+
+				if self.list == 1:
+						text = "%s %s %02d %02d %02d %02d %02d %02d %02d %0.2f  %03d" %  (nr,name,int(sp[i+4]),int(sp[i+5]),int(sp[i+6]),int(sp[i+7]),int(sp[i+8]),int(sp[i+9]),int(sp[i+10]),float(sp[i+25]),int(sp[i+26]))
+						tlist.append(TabelleListEntry(text, color))
+				if self.list == 2:
+						text = "%s %s %02d %02d %02d %02d %02d %02d %02d %0.2f  %03d" %  (nr,name,int(sp[i+11]),int(sp[i+12]),int(sp[i+13]),int(sp[i+14]),int(sp[i+15]),int(sp[i+16]),int(sp[i+17]),float(sp[i+25]),int(sp[i+26]))
+						tlist.append(TabelleListEntry(text, color))
+				if self.list == 3:
+						text = "%s %s %02d %02d %02d %02d %02d %02d %02d %0.2f  %03d" %  (nr,name,int(sp[i+18]),int(sp[i+19]),int(sp[i+20]),int(sp[i+21]),int(sp[i+22]),int(sp[i+23]),int(sp[i+24]),float(sp[i+25]),int(sp[i+26]))
+						tlist.append(TabelleListEntry(text, color))
+
+				if color == config.plugins.tipprunde.color2.value:
+ 					color = config.plugins.tipprunde.color1.value
+				else:
+					color = config.plugins.tipprunde.color2.value
+				#print text
+				i = i + 27
+
+		self["feedlist"].l.setList(tlist)
+		self["feedlist"].show
+
+#------------------------------------------------------------------------------------------
+	def feed_finished(self, feedhtml):
+		print "[Tipprunde] [feed_finished] "
+		self.Tippfilter(feedhtml)
+		print "[Tipprunde] vom Filter zurueck " + str(self.liste)
+
+		sp = []
+		font_s = 0
+		f = open("/tmp/gesamtuebersicht.txt", "r" )
+		for zeile in f:
+				#pos = find(zeile,'#')
+				zeile = zeile.replace('\n',"")
+				#print len(zeile)
+				if len(zeile) == 0:
+					zeile = "0"
+				sp.append(zeile)
+		f.close
+
+		i=0
+		tlist = [ ]
+		del tlist[:]
+ 		color = config.plugins.tipprunde.color1.value
+
+		current_w = getDesktop(0).size().width()
+		current_h = getDesktop(0).size().height()
+
+		maxzahler = 2000
+		if self.liste == 2 or self.liste == 3 or self.liste == 4 or self.liste == 5:
+			maxzahler = 1200
+
+		maxzahler = self.maxuser*25
+
+		if current_w == 1280:
+			while i < maxzahler:
+			#while i < 10:
+				nr = sp[i+0] # Nr
+				nr = nr.ljust(3)
+				name = sp[i+2] # Name
+				name = name.ljust(11)
+				if len(name) >11:
+						name = name[:11]
+
+				if self.list == 1:
+						text = "%s %s %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d%0.2f %03d" %  (nr,name,int(sp[i+4]),int(sp[i+5]),int(sp[i+6]),int(sp[i+7]),int(sp[i+8]),int(sp[i+9]),int(sp[i+10]),int(sp[i+11]),int(sp[i+12]),int(sp[i+13]),int(sp[i+14]),int(sp[i+15]),int(sp[i+16]),int(sp[i+17]),int(sp[i+18]),int(sp[i+19]),int(sp[i+20]),int(sp[i+21]),int(sp[i+22]),int(sp[i+23]),int(sp[i+24]),float(sp[i+25]),int(sp[i+26]))
+						tlist.append(TabelleListEntry(text, color))
+
+				if color == config.plugins.tipprunde.color2.value:
+ 					color = config.plugins.tipprunde.color1.value
+				else:
+					color = config.plugins.tipprunde.color2.value
+				#print text
+				i = i + 27
+
+
+		else:
+			while i < maxzahler:
+				nr = sp[i+0] # Nr
+				nr = nr.ljust(3)
+				name = sp[i+2] # Name
+				name = name.ljust(11)
+				if len(name) >11:
+						name = name[:11]
+
+						#print (int(sp[i+18]),int(sp[i+19]))
+						#print (float(sp[i+20]),float(sp[i+21]),float(sp[i+22]),float(sp[i+23]))
+						# for debug, who is the float? ( bb 23.01.2011 )
+
+				if self.list == 1:
+						#text = "%s %s " %  (nr,name)
+						text = "%s %s %02d %02d %02d %02d %02d %02d %02d %0.2f  %03d" %  (nr,name,int(sp[i+4]),int(sp[i+5]),int(sp[i+6]),int(sp[i+7]),int(sp[i+8]),int(sp[i+9]),int(sp[i+10]),float(sp[i+25]),int(sp[i+26]))
+						tlist.append(TabelleListEntry(text, color))
+				if self.list == 2:
+						text = "%s %s %02d %02d %02d %02d %02d %02d %02d %0.2f  %03d" %  (nr,name,int(sp[i+11]),int(sp[i+12]),int(sp[i+13]),int(sp[i+14]),int(sp[i+15]),int(sp[i+16]),int(sp[i+17]),float(sp[i+25]),int(sp[i+26]))
+						tlist.append(TabelleListEntry(text, color))
+				if self.list == 3:
+						text = "%s %s %02d %02d %02d %02d %02d %02d %02d %0.2f  %03d" %  (nr,name,int(sp[i+18]),int(sp[i+19]),int(sp[i+20]),int(sp[i+21]),float(sp[i+22]),int(sp[i+23]),int(sp[i+24]),float(sp[i+25]),int(sp[i+26]))
+						tlist.append(TabelleListEntry(text, color))
+
+				if color == config.plugins.tipprunde.color2.value:
+ 					color = config.plugins.tipprunde.color1.value
+				else:
+					color = config.plugins.tipprunde.color2.value
+				i = i + 27
+
+		self["feedlist"].l.setList(tlist)
+		self["feedlist"].show
+		print "[Tipprunde] der Filter ist fertig "
+
+#------------------------------------------------------------------------------------------
+	def Tippfilter(self,output):
+		print "[Tipprunde] Seite wurde geladen"
+
+		startpos = find(output,'class="sort-aktiv"')  # class="sort-aktiv">Pkt<
+		endpos = find(output,'class="kicktipp-footer"><div>')  # class="pkt"><a href="gesamtuebersicht
+
+		if self.liste == 2:
+				startpos = find(output,'21 - 50') 
+				endpos = find(output,'81 - 110') 
+		if self.liste == 3:
+				startpos = find(output,'51 - 80')  
+				endpos = find(output,'111 - 140')  
+		if self.liste == 4:
+				startpos = find(output,'81 - 110') 
+				endpos = find(output,'141 - 153')  
+		if self.liste == 5:
+				startpos = find(output,'111 - 140')  
+				endpos = find(output,'Tipps und Anleitungen')  
+
+
+		print "[Tipprunde] Start/Endpos: ", startpos, endpos, str(self.liste)
+
+		if startpos >= endpos or startpos == -1 or endpos == -1:
+				print "[Tipprunde] Fehler startpos ",str(startpos)
+				return
+
+		bereich = output[startpos:endpos].decode("latin1").encode("utf-8")
+		bereich = output[startpos:endpos]
+		bereich = transHTML(bereich)
+		# <td class="pos">1.</td><td dir="ltr" class="mg_class"><a href="mitgliedsstatistik;jsessionid=hQm5TMj4YvtoKHXQZAlW.rochen?mitgliedId=3667344" class="">dela2203</a></td><td class="pkts">11</td><td class="pkt">7</td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="sptsiege"><b><span title="1.0">1,00</span></b></td><td class="gesamt"><b>18</b></td></tr><tr class="e ">
+		# <td class="pos">1.</td><td dir="ltr" class="mg_name">lelo</td><td class="pkt">0</td><td class="pkt">9</td><td class="pkt">6</td><td class="pkt">5</td><td class="pkt">3</td><td class="pkt">8</td><td class="pkt">10</td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="pkt"></td><td class="sptsiege"></td><td class="gesamt"><b>41</b></td
+		thread_all = findall(r'<td class="pos">(.*?)</td></tr>',bereich)
+		#print thread_all
+		ffile = open("/tmp/gesamtuebersicht.txt", "w")
+
+		# Tipzeile filtern
+		za = 0
+		for x in thread_all:
+			x = sub('<[^>]*>',"@",x)
+			res = [ x ]
+			za = za +1
+			thread = str(res)
+			thread = thread.replace('.',"").replace(',',".").replace('\']',"").replace('[\'',"").replace('@@',",").replace('0,,@',"0,").replace('1,,@',"1,").replace('2,,@',"2,").replace('3,,@',"3,").replace('4,,@',"4,").replace('5,,@',"5,").replace('6,,@',"6,").replace('7,,@',"7,").replace('8,,@',"8,").replace('9,,@',"9,").replace(',@',",,").replace('@',"").replace(',',"\n")
+			ffile.write(str(thread) + "\n")
+			#ffile.write(str(thread))
+		ffile.close()
+		self.maxuser = za
+
+#------------------------------------------------------------------------------------------
+#-------------------------------- Tipprunde Settings --------------------------------------
+#------------------------------------------------------------------------------------------
+class TippSetup(Screen):
+	skin = """<screen position="center,center" size="480,210" title="Tipprunde Settings" backgroundColor="#000000" >
+		<widget name="liste" position="5,5" size="470,200" scrollbarMode="showOnDemand" />
+		<eLabel backgroundColor="red" position="28,200" size="140,3" zPosition="2"/>
+		<eLabel backgroundColor="green" position="228,200" size="140,3" zPosition="2"/>
+		<widget name="key_red" position="28,168" zPosition="3" size="140,40" font="Regular;19" valign="center" halign="center" transparent="1" />
+		<widget name="key_green" position="228,168" zPosition="3" size="140,40" font="Regular;19" valign="center" halign="center" transparent="1" />
+	</screen>"""
+
+	def __init__(self, session):
+		self.skin = TippSetup.skin
+		Screen.__init__(self, session)
+		self["key_red"] = Button(_("Back"))
+		self["key_green"] = Button(_("Save"))
+		self["actions"] = NumberActionMap(["SetupActions", "ColorActions"],
+		{
+			"ok": self.save,
+			"green": self.save,
+			"cancel": self.close,
+			"red": self.close,
+			"left": self.keyLeft,
+			"right": self.keyRight,
+			"0": self.keyNumber,
+			"1": self.keyNumber,
+			"2": self.keyNumber,
+			"3": self.keyNumber,
+			"4": self.keyNumber,
+			"5": self.keyNumber,
+			"6": self.keyNumber,
+			"7": self.keyNumber,
+			"8": self.keyNumber,
+			"9": self.keyNumber
+		}, -3)
+		self.list = []
+		self["liste"] = ConfigList(self.list)
+
+		self.list.append(getConfigListEntry(_("Spaltenansicht"), config.plugins.tipprunde.spalte))
+		self.list.append(getConfigListEntry(_("Zeilenfarbe 1"), config.plugins.tipprunde.color1))
+		self.list.append(getConfigListEntry(_("Zeilenfarbe 2"), config.plugins.tipprunde.color2))
+		#self.list.append(getConfigListEntry(_("Hintergrundfarbe"), config.plugins.tipprunde.bgcolor))
+		self.list.append(getConfigListEntry(_("Nullunterdrückung"), config.plugins.tipprunde.null))
+
+	def save(self):
+		for x in self["liste"].list:
+				x[1].save()
+		config.save()
+		self.close()
+
+	def keyLeft(self):
+		self["liste"].handleKey(KEY_LEFT)
+	def keyRight(self):
+		self["liste"].handleKey(KEY_RIGHT)
+	def keyNumber(self, number):
+		self["liste"].handleKey(KEY_0 + number)