from Screens.InfoBarGenerics import InfoBarNotifications
from Screens.VirtualKeyBoard import VirtualKeyBoard
from Screens.HelpMenu import HelpableScreen
+from Screens.ChannelSelection import service_types_tv
+from Components.Language import language
from Components.PluginComponent import plugins
from Components.Button import Button
from Components.Sources.StaticText import StaticText
from Components.Pixmap import Pixmap
from Components.config import config, ConfigSubsection, ConfigPosition, getConfigListEntry, ConfigBoolean, ConfigInteger, ConfigText, ConfigSelection, configfile, getCharValue
-from enigma import eTimer, eConsoleAppContainer, getDesktop, eServiceReference, iPlayableService, iServiceInformation, RT_HALIGN_LEFT, RT_HALIGN_RIGHT, RT_HALIGN_CENTER, RT_VALIGN_CENTER, getPrevAsciiCode, eRCInput, fbClass
+from enigma import eTimer, eConsoleAppContainer, getDesktop, eServiceReference, iPlayableService, iServiceInformation, RT_HALIGN_LEFT, RT_HALIGN_RIGHT, RT_HALIGN_CENTER, RT_VALIGN_CENTER, getPrevAsciiCode, eRCInput, fbClass, eServiceCenter
from bookmark import BookmarkManager, BookmarkData, CategoryData
import os, struct, threading, stat, select, time, socket, select
+from __init__ import _
+
strIsEmpty = lambda x: x is None or len(x) == 0
HBBTVAPP_PATH = "/usr/local/hbb-browser"
COMMAND_PATH = '/tmp/.sock.hbbtv.cmd'
+_g_helper = None
+
class GlobalValues:
command_util = None
command_server = None
need_restart = False
plugin_browser = None
+
+ resX = 0
+ resY = 0
+ def UpdateInfoBar(self):
+ if self.resX == 1024 and self.resY == 720:
+ return
+ try:
+ infobar = InfoBar.instance
+ if infobar._InfoBarShowHide__state != 3:
+ return
+ infobar.doTimerHide()
+ infobar.serviceStarted()
+ except: pass
+
__gval__ = GlobalValues()
+def setDefaultResolution(x, y):
+ global __gval__
+ __gval__.resX = x
+ __gval__.resY = y
+
+def setResolution(xres, yres):
+ global __gval__
+ if __gval__.resX == 1280 and __gval__.resY == 720:
+ return
+ from enigma import gMainDC
+ gMainDC.getInstance().setResolution(xres, yres)
+
+def restoreResolution():
+ global __gval__
+ setResolution(1280, 720)
+ setResolution(__gval__.resX, __gval__.resY)
+
+ if __gval__.resX == 1280 and __gval__.resY == 720:
+ return
+ __gval__.UpdateInfoBar()
+
def setPluginBrowser(browser=None):
global __gval__
__gval__.plugin_browser = browser
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.connect((host, port))
sock.send(self.sendmsg%(location, host))
- print "Request."
- print self.sendmsg%(location, host)
+ #print "Request."
+ #print self.sendmsg%(location, host)
fullydata = ''
while 1:
res = sock.recv(1024)
,"OP_HBBTV_FULLSCREEN" : 0x0005
,"OP_HBBTV_TITLE" : 0x0006
,"OP_HBBTV_RETRY_OPEN_URL" : 0x0009
+ ,"OP_HBBTV_CHANGE_CHANNEL" : 0x000A
,"OP_OIPF_GET_CHANNEL_INFO_URL" : 0x0101
,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102
,"OP_OIPF_GET_CHANNEL_INFO_LIST": 0x0103
,"OP_BROWSER_VKBD_PASTE_MOUSE" : 0x030D
,"OP_BROWSER_MENU_REQ" : 0x030E
,"OP_BROWSER_MENU_RES" : 0x030F
+ ,"OP_BROWSER_NEED_RELOAD_KEYMAP": 0x0313
,"OP_DVBAPP_VOL_UP" : 0x0401
,"OP_DVBAPP_VOL_DOWN" : 0x0402
,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501
,0x0005 : "OP_HBBTV_FULLSCREEN"
,0x0006 : "OP_HBBTV_TITLE"
,0x0009 : "OP_HBBTV_RETRY_OPEN_URL"
+ ,0x000A : "OP_HBBTV_CHANGE_CHANNEL"
,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL"
,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT"
,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST"
,0x030D : "OP_BROWSER_VKBD_PASTE_MOUSE"
,0x030E : "OP_BROWSER_MENU_REQ"
,0x030F : "OP_BROWSER_MENU_RES"
+ ,0x0313 : "OP_BROWSER_NEED_RELOAD_KEYMAP"
,0x0401 : "OP_DVBAPP_VOL_UP"
,0x0402 : "OP_DVBAPP_VOL_DOWN"
,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
class ServerFactory:
def doListenUnixTCP(self, name, handler):
def destroy(name):
- if os.path.exists(name):
- os.unlink(name)
- print "Removed ", name
+ import os
+ try:
+ if os.path.exists(name):
+ os.unlink(name)
+ print "Removed ", name
+ except: pass
destroy(name)
params = SocketParams()
0x0001 : self._cb_handleCloseHbbTVBrowser
,0x0006 : self._cb_handleSetPageTitle
,0x0009 : self._cb_handleHbbTVRetryOpen
+ ,0x000A : self._cb_handleHbbTVChangeChannel
,0x0101 : self._cb_handleGetChannelInfoForUrl
,0x0102 : self._cb_handleGetChannelInfoForAIT
,0x0103 : self._cb_handleGetChannelInfoList
self._on_set_title_cb = None
return self.doPack(opcode, params, reserved)
+ def _cb_handleHbbTVChangeChannel(self, opcode, data):
+ self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
+ global _g_helper
+ if _g_helper is None:
+ return (0, "NOK")
+ dataItems = data.split(":")
+ sid = dataItems[0]
+ tsid = dataItems[1]
+ if not _g_helper.doChangeChannel(sid, tsid):
+ return (0, "NOK")
+ return (0, "OK")
+
def _cb_handleBrowserMenuReq(self, opcode, data):
self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
+ restoreResolution()
+ fbClass.getInstance().unlock()
eRCInput.getInstance().unlock()
browser = getPluginBrowser()
if browser is not None:
return (0, "OK")
def _cb_virtualKeyboardClosed(self, data=None):
+ fbClass.getInstance().lock()
eRCInput.getInstance().lock()
+ setResolution(1280, 720)
command_util = getCommandUtil()
command_util.sendCommand('OP_BROWSER_VKBD_RES', data)
def _cb_handleShowVirtualKeyboard(self, opcode, data):
self._handle_dump(self._cb_handleShowVirtualKeyboard, opcode, data)
+ restoreResolution()
+ fbClass.getInstance().unlock()
eRCInput.getInstance().unlock()
if data == 0 or strIsEmpty(data):
data = ""
return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
def _cb_handleSetPageTitle(self, opcode, data):
- self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
+ self._handle_dump(self._cb_handleSetPageTitle, opcode, data)
if data.startswith('file://') or data.startswith('http://'):
return "OK"
if self._on_set_title_cb is not None:
if before_service is not None:
self._session.nav.playService(before_service)
self._vod_uri = None
+
+ restoreResolution()
return (0, "OK")
def _cb_handleVODPlayerURI(self, opcode, data):
for ii in range(5):
self._vod_service = None
try:
- print "Try to open vod [%d] : %s" % (ii, url)
+ #print "Try to open vod [%d] : %s" % (ii, url)
+ print "Try to open vod"
self._vod_service = eServiceReference(4097, 0, url)
self._session.nav.playService(self._vod_service)
if self._vod_service is not None:
"""
def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
self._session = session
+ setResolution(1280, 720)
+ fbClass.getInstance().lock()
eRCInput.getInstance().lock()
Screen.__init__(self, session)
print ErrMsg
def _serviceEOF(self):
+ (position,length) = self.getVodPlayTime()
+ self._ssm.setStatus(length, length, 1)
+ print "service EOF"
self._currentServicePositionTimer.stop()
def _layoutFinished(self):
+ self.setTitle(_('HbbTV Plugin'))
command_util = getCommandUtil()
profile = self._profile
(sid, onid, tsid, name, orgid) = getChannelInfos()
if self._cb_closed_func is not None:
self._cb_closed_func()
except: pass
+ restoreResolution()
+ fbClass.getInstance().unlock()
eRCInput.getInstance().unlock()
self.close()
def _serviceForbiden(self):
global __gval__
real_url = MMSStreamURL().getLocationData(__gval__.hbbtv_handelr.getUrl())
- print "Received URI :\n", real_url
+ #print "Received URI :\n", real_url
if real_url is not None:
__gval__.hbbtv_handelr.doRetryOpen(real_url.strip())
__gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
self._urls = None
- #self._stop_opera()
- #self._start_opera()
- self._restart_opera()
Screen.__init__(self, session)
self._session = session
+
+ self._restart_opera()
+
self._timer_infobar = eTimer()
self._timer_infobar.callback.append(self._cb_registrate_infobar)
self._timer_infobar.start(1000)
_g_ssm_ = SimpleSharedMemory()
_g_ssm_.doConnect()
+ self._callbackStartStop = None
+
def _cb_registrate_infobar(self):
if InfoBar.instance:
self._timer_infobar.stop()
def _cb_hbbtv_activated(self, title=None, url=None):
if not self._is_browser_running():
- message = "HbbTV Browser was not running.\nPlease running browser before start HbbTV Application."
- self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
+ message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
+ self._session.open(MessageBox, message, MessageBox.TYPE_INFO)
return
service = self._session.nav.getCurrentlyPlayingServiceReference()
setBeforeService(service)
global HBBTVAPP_PATH
start_command = '%s/launcher start'%(HBBTVAPP_PATH)
os.system(start_command)
+ return True
def _stop_opera(self):
global HBBTVAPP_PATH
global HBBTVAPP_PATH
try: os.system('%s/launcher restart'%(HBBTVAPP_PATH))
except: pass
+ return True
def getStartHbbTVUrl(self):
url, self._urls, self._profile = None, None, 0
if self.getStartHbbTVUrl():
for x in self._urls:
applications.append((x[1], x))
- else: applications.append(("No detected HbbTV applications.", None))
+ else: applications.append((_("No detected HbbTV applications."), None))
self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
def _application_selected(self, selected):
self._cb_hbbtv_activated(selected[1][1], selected[1][2])
except Exception, ErrMsg: print ErrMsg
- def showBrowserConfigBox(self):
+ def showBrowserConfigBox(self, callback=None):
start_stop_mode = []
+ self._callbackStartStop = callback
if self._is_browser_running():
- start_stop_mode.append(('Stop',None))
- else: start_stop_mode.append(('Start',None))
+ start_stop_mode.append((_('Stop'),'Stop'))
+ else: start_stop_mode.append((_('Start'),'Start'))
self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
def _browser_config_selected(self, selected):
if selected is None:
return
+ if self._callbackStartStop is not None:
+ self._callbackStartStop()
try:
- mode = selected[0]
+ mode = selected[1]
if mode == 'Start':
if not self._is_browser_running():
self._start_opera()
print "Check Browser Running ERR :", ErrMsg
return False
+ def doChangeChannel(self, _sid, _tsid):
+ root = eServiceReference(service_types_tv)
+ if root is None:
+ return False
+ serviceList = eServiceCenter.getInstance().list(root)
+ if serviceList is None:
+ return False
+ while True:
+ service = serviceList.getNext()
+ if service is None or not service.valid():
+ break
+
+ #1:0:19:2840:3FB:1:C00000:0:0:0:
+ serviceRef = service.toString()
+ if strIsEmpty(serviceRef):
+ continue
+ serviceRefItems = serviceRef.split(":")
+ if len(serviceRefItems) < 5:
+ continue
+
+ sid = serviceRefItems[3]
+ tsid = serviceRefItems[4]
+ if sid == _sid and tsid == _tsid:
+ self._session.nav.playService(eServiceReference(serviceRef))
+ service = self._session.nav.getCurrentlyPlayingServiceReference()
+ setBeforeService(service)
+ return True
+ return False
+
class OperaBrowserSetting:
def __init__(self):
self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
self._start = None
+ self._type = None
+ self._keymap = None
self._read()
def _read(self):
f = open(self._settingFileName)
for line in f.readlines():
if line.startswith('start='):
- self._start = line[6:len(line)-1]
+ tmp = line[6:len(line)-1].split()
+ self._start = tmp[0]
+ if len(tmp) > 1:
+ self._type = int(tmp[1])
+ else: self._type = 0
+ elif line.startswith('keymap='):
+ self._keymap = line[7:len(line)-1]
f.close()
def _write(self):
tmpstr = []
- tmpstr.append('start=%s\n' % (self._start))
+ tmpstr.append('start=%s %d\n' % (self._start, self._type))
+ tmpstr.append('keymap=%s\n' % (self._keymap))
f = open(self._settingFileName, 'w')
f.writelines(tmpstr)
f.close()
- def setData(self, start):
+ def setData(self, start, types=0, keymap="us-rc"):
self._start = start
+ self._type = types
+ self._keymap = keymap
self._write()
def getData(self):
return {
- 'start':self._start
+ 'start':self._start,
+ 'type':self._type,
+ 'keymap':self._keymap,
}
class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
skin= """
- <screen position="center,center" size="600,350" title="Proference">
+ <screen position="center,120" size="600,350" title="Preference">
<widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
<widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
if self._currentPageUrl is None:
self._currentPageUrl = ''
self._startPageUrl = None
-
+ self._keymapType = None
self.makeMenuEntry()
self.onLayoutFinish.append(self.layoutFinished)
def layoutFinished(self):
- try:
- self._startPageUrl = OperaBrowserSetting().getData()['start']
- except: self._startPageUrl = 'http://vuplus.com'
- self.updateStartPageUrl()
+ self.setTitle(_('Preference'))
def updateStartPageUrl(self):
if self.menuItemStartpage.value == "startpage":
def keyGreen(self):
url = self["url"].getText()
if strIsEmpty(url):
- self.session.open(MessageBox, 'Invalid URL!!(Empty)\nPlease, Input to the URL.', type = MessageBox.TYPE_INFO)
+ self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
return
- OperaBrowserSetting().setData(url)
+ mode = 0
+ if url.find('/usr/local/manual') > 0:
+ mode = 1
+ self._keymapType = self.menuItemKeyboardLayout.value
+ OperaBrowserSetting().setData(url, mode, self._keymapType)
+ command_util = getCommandUtil()
+ command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
self.close()
def keyRed(self):
return
self["url"].setText(data)
if self.menuItemStartpage.value == "direct":
- self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=("Please enter URL here"), text='http://')
+ self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
def keyLeft(self):
ConfigListScreen.keyLeft(self)
ConfigListScreen.keyRight(self)
self.updateStartPageUrl()
+ def getKeymapTypeList(self):
+ types = []
+ for f in os.listdir("/usr/local/hbb-browser/keymap"):
+ filesplit = f.split('.')
+ if len(filesplit) < 2:
+ continue
+ types.append((filesplit[1], filesplit[1]))
+ types.sort()
+ return types
+
def makeMenuEntry(self):
l = []
l.append(("startpage", _("Start Page")))
l.append(("direct", _("Direct Input")))
self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
+
+ kl = self.getKeymapTypeList()
+
+ try:
+ d = OperaBrowserSetting().getData()
+ self._startPageUrl = d['start']
+ self._keymapType = d['keymap']
+ #d['type']
+ except: self._startPageUrl = 'http://vuplus.com'
+ self.updateStartPageUrl()
+
+ if self._keymapType is None or len(self._keymapType) == 0:
+ self._keymapType = "us-rc"
+ self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
+ self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
self.resetMenuList()
def resetMenuList(self):
self.menulist = []
self.menulist.append(self.menuEntryStartpage)
+ self.menulist.append(self.menuEntryKeyboardLayout)
self["config"].list = self.menulist
self["config"].l.setList(self.menulist)
self.mMode = _mode
self.mType = _type
self.mData = _data
- self.session = session
+ self.mSession = session
self.mBookmarkManager = _bm
if _data is not None:
self.menuItemUrl = None
self.menuItemName = None
+ self.menuEntryName = None
+ self.menuEntryTitle = None
+ self.menuEntryUrl = None
+
self.makeConfigList()
self.onLayoutFinish.append(self.layoutFinished)
def layoutFinished(self):
- self.setTitle('Bookmark ' + self.mMode)
+ self.setTitle(_('Bookmark') + ' ' + self.mMode)
+
+ def selectedItem(self):
+ currentPosition = self["config"].getCurrent()
+ if self.mType == BookmarkEditWindow.CATEGORY:
+ return (_("Name"), self.menuItemName)
+ else:
+ if currentPosition == self.menuEntryTitle:
+ return (_("Title"), self.menuItemTitle)
+ elif currentPosition == self.menuEntryUrl:
+ return (_("Url"), self.menuItemUrl)
+ return None
+
+ def showMessageBox(self, text):
+ msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
+ self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
+ return False
+
+ def showVKeyWindow(self, data=None):
+ itemTitle = ""
+ itemValue = ""
+ selected = self.selectedItem()
+ if selected is not None:
+ itemValue = selected[1].value
+ if strIsEmpty(itemValue):
+ itemValue = ""
+ itemTitle = selected[0]
+
+ self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
+
+ def cbVKeyWindow(self, data=None):
+ if data is not None:
+ selected = self.selectedItem()
+ if selected is not None:
+ selected[1].setValue(data)
+
def saveData(self):
if self.mType == BookmarkEditWindow.CATEGORY:
- if self.mMode == 'Add':
+ if self.mMode == _('Add'):
categoryName = self.menuItemName.value
if strIsEmpty(categoryName):
- msg = "Invalid Category Name!!(Empty)\nPlease, Input to the Category Name."
- self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
- return False
+ return self.showMessageBox(_("Category Name"))
self.mBookmarkManager.addCategory(categoryName)
else:
if strIsEmpty(self.menuItemName.value):
- msg = "Invalid Category Name!!(Empty)\nPlease, Input to the Category Name."
- self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
- return False
+ return self.showMessageBox(_("Category Name"))
self.mData.mName = self.menuItemName.value
self.mBookmarkManager.updateCategory(self.mData)
else:
- if self.mMode == 'Add':
+ if self.mMode == _('Add'):
bookmarkTitle = self.menuItemTitle.value
bookmarkUrl = self.menuItemUrl.value
if strIsEmpty(bookmarkTitle):
- msg = "Invalid Bookmark Title!!(Empty)\nPlease input to the Bookmark Title."
- self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
- return False
- self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent)
+ self["config"].setCurrentIndex(0)
+ return self.showMessageBox(_("Bookmark Title"))
+ if strIsEmpty(bookmarkUrl):
+ self["config"].setCurrentIndex(1)
+ return self.showMessageBox(_("Bookmark URL"))
+ self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
else:
if strIsEmpty(self.menuItemTitle.value):
- msg = "Invalid Bookmark Title!!(Empty)\nPlease input to the Bookmark Title."
- self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
- return False
+ self["config"].setCurrentIndex(0)
+ return self.showMessageBox(_("Bookmark Title"))
+ if strIsEmpty(self.menuItemUrl.value):
+ self["config"].setCurrentIndex(1)
+ return self.showMessageBox(_("Bookmark URL"))
self.mData.mTitle = self.menuItemTitle.value
self.mData.mUrl = self.menuItemUrl.value
self.mBookmarkManager.updateBookmark(self.mData)
return True
+
def keyGreen(self):
if not self.saveData():
return
if self.mType == BookmarkEditWindow.CATEGORY:
self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
- menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
- self.menulist.append(menuEntryName)
+
+ self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
+
+ self.menulist.append(self.menuEntryName)
else:
self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
- menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
- menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
- self.menulist.append(menuEntryTitle)
- self.menulist.append(menuEntryUrl)
+
+ self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
+ self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
+
+ self.menulist.append(self.menuEntryTitle)
+ self.menulist.append(self.menuEntryUrl)
self["config"].list = self.menulist
self["config"].l.setList(self.menulist)
class OperaBrowserBookmarkWindow(Screen):
skin = """
- <screen name="HbbTVBrowserBookmarkWindow" position="center,center" size="600,400" title="Bookmark" >
+ <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
<widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
<ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
self.mBookmarkList = self.setBookmarkList()
self["bookmarklist"] = MenuList(self.mBookmarkList)
+ self.onLayoutFinish.append(self.layoutFinished)
+
+ def layoutFinished(self):
+ self.setTitle(_('Bookmark'))
+
def setBookmarkList(self):
l = []
#self.mBookmarkManager.dump()
def keyNumber(self):
data = self["bookmarklist"].getCurrent()[1]
if strIsEmpty(data.mUrl):
- msg = "Invalid URL. Please check again!!"
+ msg = _("Invalid URL. Please check again!!")
self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
return
def cbSetStartpage(ret=None):
if ret is None: return
if ret:
data = self["bookmarklist"].getCurrent()[1]
- OperaBrowserSetting().setData(data.mUrl)
- msg = "Do you want to set selected url to the Startpage?"
+ OperaBrowserSetting().setData(data.mUrl, data.mType)
+ msg = _("Do you want to set selected url to the Startpage?")
self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
def keyGreen(self):
return
if strIsEmpty(self.mTitle):
return
- retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId)
+ retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
if not retAdd:
- msg = "Current page is already exist."
+ msg = _("Current page is already exist.")
self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
self.cbEditWindow(True)
elif data[1] == 2:
parent = self.getParentCategory()
if parent is None:
return
- b = BookmarkData(0, '', '', parent.mId)
- self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, 'Add', BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
+ b = BookmarkData(0, '', '', parent.mId, 0)
+ self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
elif data[1] == 3:
c = CategoryData(0, '')
- self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, 'Add', BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
+ self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
if strIsEmpty(self.mUrl):
- l = [('Direct Input(Bookmark)',2,), ('Direct Input(Category)',3,)]
- else: l = [('Currentpage(Bookmark)',1,), ('Direct Input(Bookmark)',2,), ('Direct Input(Category)',3,)]
+ l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
+ else: l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
def keyYellow(self):
data = self["bookmarklist"].getCurrent()[1]
if self.isCategoryItem():
- self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, 'Edit', BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
- else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, 'Edit', BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
+ self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
+ else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
def keyBlue(self):
def cbBlue(ret=None):
if not ret: return
else: self.mBookmarkManager.deleteBookmark(data.mId)
self.updateBookmarkList()
if self.isCategoryItem():
- msg = "Do you want to delete the category and the bookmarks?"
- else: msg = "Do you want to delete the bookmark?"
+ msg = _("Do you want to delete the category and the bookmarks?")
+ else: msg = _("Do you want to delete the bookmark?")
self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
def keyOK(self):
if self.isCategoryItem(): return
data = self["bookmarklist"].getCurrent()[1]
url = data.mUrl.strip()
if len(url) == 0:
- self.session.open(MessageBox, "Can't open selected bookmark.\n - URL data is empty!!", type = MessageBox.TYPE_INFO)
+ self.session.open(MessageBox, _("Can't open selected bookmark.\n - URL data is empty!!"), type = MessageBox.TYPE_INFO)
return
- self.close(url)
+ mode = data.mType
+ if mode:
+ lang = language.getLanguage()
+ if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
+ url = '/usr/local/manual/ru_RU/main.html'
+ elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
+ url = '/usr/local/manual/de_DE/main.html'
+ self.close((url, mode))
def keyRed(self):
self.keyCancel()
def keyCancel(self):
self.close()
-
class BrowserHelpWindow(Screen, HelpableScreen):
MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
skin = """
self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
self.showHelpTimer.start(500)
+ self.onLayoutFinish.append(self.layoutFinished)
+
+ def layoutFinished(self):
+ self.setTitle(_('Browser Help'))
+
def cbShowHelpTimerClosed(self):
self.showHelpTimer.stop()
self.setHelpModeActions(self.MODE_GLOBAL)
def keyBlue(self):
self.setHelpModeActions(self.MODE_KEYBOARD)
-_g_helper = None
class OperaBrowser(Screen):
MENUBAR_ITEM_WIDTH = 150
MENUBAR_ITEM_HEIGHT = 30
SUBMENULIST_HEIGHT = 25
SUBMENULIST_NEXT = 2
+ # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
+ # menulist->size->x : SUBMENULIST_WIDTH
+ # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
+ # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
+ # submenulist->size->x : SUBMENULIST_WIDTH
+
+ size = getDesktop(0).size()
+ WIDTH = int(size.width())
+ HEIGHT = int(size.height())
skin = """
- <screen name="Opera Browser" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
+ <screen name="OperaBrowser" position="0,0" size="%(width)d,%(height)d" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
<widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
<widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
<widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
<widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
- <widget name="menulist" position="50,%d" size="%d,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
- <widget name="submenulist" position="%d,%d" size="%d,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
- <widget name="bottomArea" position="0,640" size="1280,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
- </screen>
- """ % (MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH, SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT, MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH)# modify menu
-
- MENUITEMS_LIST =[[('Open Startpage', None), ('Open URL', None), ('Start/Stop',None), ('Exit', None)],
- [('Bookmark', None), ('Preference', None)],
- [('About', None), ('Help', None)]]
- def __init__(self, session):
+ <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
+ <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
+ <widget name="bottomArea" position="0,%(bottom_pos_y)d" size="%(bottom_size_x)d,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
+ </screen>
+ """ % { 'width' :WIDTH,
+ 'height' :HEIGHT,
+ 'bottom_pos_y' :HEIGHT-80,
+ 'bottom_size_x' :WIDTH }
+
+ COMMAND_MAP = {}
+ MENUITEMS_LIST =[]
+ def __init__(self, session, url=None):
Screen.__init__(self, session)
self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
"cancel" : self.keyCancel
,"menu" : self.keyMenu
}, -2)
+ self.UpdateLanguageCB()
+
self._terminatedBrowser = True
self._enableKeyEvent = True
self._currentPageUrl = None
self._onCloseTimer = eTimer()
self._onCloseTimer.callback.append(self._cb_onClose)
+ self.paramUrl = url
+ language.addCallback(self.UpdateLanguageCB)
+
+ def UpdateLanguageCB(self):
+ # modify menu
+ self.MENUITEMS_LIST = [
+ [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
+ [(_('Bookmark'), None), (_('Preference'), None)],
+ [(_('About'), None), (_('Help'), None)]]
+ self.COMMAND_MAP = {}
+ self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit
+ self.COMMAND_MAP[_('Help')] = self._cmd_on_Help
+ self.COMMAND_MAP[_('About')] = self._cmd_on_About
+ self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl
+ self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop
+ self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark
+ self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference
+ self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser
+ self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage
+
def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
rcmouse_path = "/proc/stb/fp/mouse"
if os.path.exists(rcmouse_path):
os.system("echo %d > %s" % (mode, rcmouse_path))
def layoutFinished(self):
- self["menuitemFile"].setText("File")# modify menu
- self["menuitemTool"].setText("Tools")
- self["menuitemHelp"].setText("Help")
+ self["menuitemFile"].setText(_("File"))# modify menu
+ self["menuitemTool"].setText(_("Tools"))
+ self["menuitemHelp"].setText(_("Help"))
self["menulist"].hide()
self["submenulist"].hide()
- self["bottomArea"].setText("Opera Web Browser Plugin v1.0")
- self.setTitle("BrowserMain")
+ self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
+ self.setTitle(_("BrowserMain"))
self.selectMenuitem()
+ if self.paramUrl is not None:
+ self.keyMenu()
+ self.cbUrlText(self.paramUrl, 1)
+
def selectMenuitem(self):
tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
self["menuitemFile"].setForegroundColorNum(0)
def setListOnView(self):
l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
- l = [('Return', None)]
+ l = [(_('Return'), None)]
self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
return self.lvMenuItems
if self._on_setPageTitle in command_server.onSetPageTitleCB:
command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
except Exception, ErrMsg: pass
- self._on_setPageTitle('Opera Browser')
+ self._on_setPageTitle(_('Opera Browser'))
self.enableRCMouse(False)
self.toggleMainScreen()
+ restoreResolution()
+ fbClass.getInstance().unlock()
eRCInput.getInstance().unlock()
self._terminatedBrowser = True
self._enableKeyEvent = True
#if not self.toggleListViewFlag:
# self.keyDown()
- self.keyRight()
- self.keyLeft()
+
+ self._currentPageUrl = ''
+ if self.paramUrl is not None:
+ self.keyCancel()
+ else:
+ self.keyRight()
+ self.keyLeft()
def _on_setPageTitle(self, title=None):
print "Title :",title
return
self.setTitle(title)
- def cbUrlText(self, data=None):
- print "Inputed Url :", data
+ def cbUrlText(self, data=None, mode=0):
+ global _g_helper
+ if not _g_helper._is_browser_running():
+ return
+ print "Inputed Url :", data, mode
if strIsEmpty(data):
return
#self.hideSubmenu()
command_server.onHbbTVCloseCB.append(self._on_close_window)
self.toggleMainScreen()
self.enableRCMouse(True)
+
+ fbClass.getInstance().lock()
eRCInput.getInstance().lock()
+
+ setResolution(1280, 720)
+
command_util = getCommandUtil()
- command_util.sendCommand('OP_BROWSER_OPEN_URL', data)
+ command_util.sendCommand('OP_BROWSER_OPEN_URL', data, mode)
self._terminatedBrowser = False
self._enableKeyEvent = False
def _cb_bookmarkWindowClosed(self, data=None):
if data is None:
return
- self.cbUrlText(data)
+ (url, mode) = data
+ global _g_helper
+ if not _g_helper._is_browser_running():
+ message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
+ self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
+ return
+ self.cbUrlText(url, mode)
def _cmd_on_OpenUrl(self):
global _g_helper
if not _g_helper._is_browser_running():
- message = "Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu."
+ message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
return
- self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=("Please enter URL here"), text='http://')
+ self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
def _cmd_on_About(self):
- self.session.open(MessageBox, 'Opera Web Browser Plugin v1.0', type = MessageBox.TYPE_INFO)
+ self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
def _cmd_on_Exit(self):
self.close()
+ def _cb_cmdOnStartSTop(self):
+ self.keyMenu()
def _cmd_on_StartStop(self):
global _g_helper
if _g_helper is None:
return
- _g_helper.showBrowserConfigBox()
+ _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
+
def _cmd_on_Bookmark(self):
url = self._currentPageUrl
if url is None:
url = ''
self.session.open(OperaBrowserPreferenceWindow, url)
def _cmd_on_OpenStartpage(self):
+ global _g_helper
+ if not _g_helper._is_browser_running():
+ message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
+ self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
+ return
+ mode = 0
start = 'http://vuplus.com'
try:
- start = OperaBrowserSetting().getData()['start']
+ d = OperaBrowserSetting().getData()
+ start = d['start']
+ mode = d['type']
except: pass
- self.cbUrlText(start)
+ self.cbUrlText(start, mode)
def _cmd_on_ReturnToBrowser(self):
self.keyCancel()
self.session.open(BrowserHelpWindow)
def doCommand(self, command):
- cmd_map = {# modify menu
- 'Exit' :self._cmd_on_Exit
- ,'Help' :self._cmd_on_Help
- ,'About' :self._cmd_on_About
- ,'Open URL' :self._cmd_on_OpenUrl
- ,'Start/Stop' :self._cmd_on_StartStop
- ,'Bookmark' :self._cmd_on_Bookmark
- ,'Preference' :self._cmd_on_Preference
- ,'Return' :self._cmd_on_ReturnToBrowser
- ,'Open Startpage' :self._cmd_on_OpenStartpage
- }
try:
- cmd_map[command]()
+ self.COMMAND_MAP[command]()
except Exception, ErrMsg: print ErrMsg
def keyOK(self):
+ if not self.toggleMainScreenFlag:
+ self.keyMenu()
+ return
if not self.toggleListViewFlag:
self.keyDown()
return
def keyCancel(self):
if not self._terminatedBrowser:
#self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
+ fbClass.getInstance().lock()
eRCInput.getInstance().lock()
+ setResolution(1280, 720)
if self.toggleListViewFlag:
self.toggleMainScreen()
self._currentPageUrl = None
self.currentListView.pageUp()
self.keyUp()
-
-
def auto_start_main(reason, **kwargs):
if reason:
command_server = getCommandServer()
command_server.stop()
+from Screens.HelpMenu import HelpableScreen
def session_start_main(session, reason, **kwargs):
+ fbClass.getInstance().unlock()
eRCInput.getInstance().unlock()
+
+ from enigma import getDesktop
+ desktopSize = getDesktop(0).size()
+ setDefaultResolution(desktopSize.width(), desktopSize.height())
+
global _g_helper
_g_helper = session.open(HbbTVHelper)
+ HelpableScreen.__init__ = HelpableScreen__init__
+ HelpableScreen.session = session
+
+def HelpableScreen__init__(self):
+ if isinstance(self, HelpableScreen):
+ HelpableScreen.showManual = showManual
+
+ self["helpActions"] = ActionMap(["HelpbuttonActions"], {
+ "help_b" : self.showHelp,
+ "help_l" : self.showManual,
+ }, -2)
+
_g_clearBrowserDataTimer = eTimer()
+def showManual(self):
+ if not os.path.exists('/usr/local/manual'):
+ return
+
+ url = 'file:///usr/local/manual/main.html'
+ lang = language.getLanguage()
+ if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
+ url = 'file:///usr/local/manual/ru_RU/main.html'
+ elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
+ url = 'file:///usr/local/manual/de_DE/main.html'
+
+ def _do_clean():
+ _g_clearBrowserDataTimer.stop()
+ try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
+ except: pass
+ setPluginBrowser(None)
+ def clearBrowserData():
+ _g_clearBrowserDataTimer.callback.append(_do_clean)
+ _g_clearBrowserDataTimer.start(50)
+ setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
+
def plugin_start_main(session, **kwargs):
#session.open(OperaBrowser)
def _do_clean():
_g_helper.showBrowserConfigBox()
def Plugins(path, **kwargs):
- return [
- PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main),
- PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10),
- PluginDescriptor(name="HbbTV Applications", where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application),
- PluginDescriptor(name="Browser Start/Stop", where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config),
- PluginDescriptor(name="Opera Web Browser", description="start opera web browser", where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main),
- ]
+ l = []
+ l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
+ l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
+ l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
+ l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
+ l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))
+
+ return l
projects / vuplus_dvbapp / blobdiff