1 from Plugins.Plugin import PluginDescriptor
3 from Screens.Screen import Screen
4 from Screens.InfoBar import InfoBar
5 from Screens.ChoiceBox import ChoiceBox
6 from Screens.MessageBox import MessageBox
7 from Screens.InfoBarGenerics import InfoBarNotifications
8 from Screens.VirtualKeyBoard import VirtualKeyBoard
9 from Screens.HelpMenu import HelpableScreen
10 from Screens.ChannelSelection import service_types_tv
12 from Components.Language import language
13 from Components.PluginComponent import plugins
14 from Components.Button import Button
15 from Components.Sources.StaticText import StaticText
16 from Components.ActionMap import NumberActionMap, ActionMap, HelpableActionMap
17 from Components.ServiceEventTracker import ServiceEventTracker
18 from Components.MenuList import MenuList
19 from Components.Label import Label, MultiColorLabel
20 from Components.ConfigList import ConfigListScreen
21 from Components.VolumeControl import VolumeControl
22 from Components.Pixmap import Pixmap
23 from Components.config import config, ConfigSubsection, ConfigPosition, getConfigListEntry, ConfigBoolean, ConfigInteger, ConfigText, ConfigSelection, configfile, getCharValue
25 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
27 from bookmark import BookmarkManager, BookmarkData, CategoryData
29 import os, struct, threading, stat, select, time, socket, select
31 from __init__ import _
33 strIsEmpty = lambda x: x is None or len(x) == 0
35 HBBTVAPP_PATH = "/usr/local/hbb-browser"
36 COMMAND_PATH = '/tmp/.sock.hbbtv.cmd'
46 channel_info_sid = None
47 channel_info_onid = None
48 channel_info_tsid = None
49 channel_info_name = None
50 channel_info_orgid = None
56 packet_hl = struct.calcsize(packet_h)
63 def UpdateInfoBar(self):
64 if self.resX == 1024 and self.resY == 720:
67 infobar = InfoBar.instance
68 if infobar._InfoBarShowHide__state != 3:
71 infobar.serviceStarted()
74 __gval__ = GlobalValues()
76 def setDefaultResolution(x, y):
81 def setResolution(xres, yres):
83 if __gval__.resX == 1280 and __gval__.resY == 720:
85 from enigma import gMainDC
86 gMainDC.getInstance().setResolution(xres, yres)
88 def restoreResolution():
90 setResolution(1280, 720)
91 setResolution(__gval__.resX, __gval__.resY)
93 if __gval__.resX == 1280 and __gval__.resY == 720:
95 __gval__.UpdateInfoBar()
97 def setPluginBrowser(browser=None):
99 __gval__.plugin_browser = browser
100 def getPluginBrowser():
102 return __gval__.plugin_browser
104 def getPacketHeaders():
106 return (__gval__.packet_m, __gval__.packet_h, __gval__.packet_hl)
108 def setChannelInfo(sid, onid, tsid, name, orgid):
109 if sid is None: sid = 0;
110 if onid is None: onid = 0;
111 if tsid is None: tsid = 0;
112 if name is None: name = "";
113 if orgid is None: orgid = 0;
115 __gval__.channel_info_sid = sid
116 __gval__.channel_info_onid = onid
117 __gval__.channel_info_tsid = tsid
118 __gval__.channel_info_name = name
119 __gval__.channel_info_orgid = orgid
120 print "Set Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (sid, onid, tsid, name, orgid)
121 def getChannelInfos():
123 print "Get Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (__gval__.channel_info_sid,
124 __gval__.channel_info_onid, __gval__.channel_info_tsid, __gval__.channel_info_name, __gval__.channel_info_orgid)
125 return (__gval__.channel_info_sid,
126 __gval__.channel_info_onid,
127 __gval__.channel_info_tsid,
128 __gval__.channel_info_name,
129 __gval__.channel_info_orgid)
133 print "Need Restart(GET) : ", __gval__.need_restart
134 return __gval__.need_restart
135 def setNeedRestart(n):
137 __gval__.need_restart = n
138 print "Need Restart(SET) : ", __gval__.need_restart
140 def getCommandUtil():
142 return __gval__.command_util
143 def getCommandServer():
145 return __gval__.command_server
147 def setBeforeService(s):
149 __gval__.before_service = s
150 def getBeforeService():
152 return __gval__.before_service
154 def _unpack(packed_data):
155 (mg, h, hlen) = getPacketHeaders()
157 if strIsEmpty(packed_data):
159 (m, o, l, s) = struct.unpack(h, packed_data[:hlen])
164 d = packed_data[hlen:hlen+l]
167 def _pack(opcode, params=None, reserved=0):
168 (m, h, hlen) = getPacketHeaders()
169 if strIsEmpty(params):
171 packed_data = struct.pack(h, m, opcode, len(params), reserved)
172 return packed_data + params
178 ,'User-Agent: NSPlayer/7.10.0.3059 '
180 ,'Connection: Close '
185 for m in self.headers:
186 self.sendmsg += m + '\n'
187 self.sendmsg += '\n\n'
189 def request(self, host, port=80, location='/'):
190 sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
191 sock.connect((host, port))
192 sock.send(self.sendmsg%(location, host))
194 print self.sendmsg%(location, host)
197 res = sock.recv(1024)
203 def parse(self, data):
204 for d in data.splitlines():
205 if d.startswith('Location: '):
209 def getLocationData(self, url):
210 url_list,host,location = None,None,None
212 url = url[url.find(':')+3:]
213 url_list = url.split('/')
215 location = url[len(url_list[0]):]
216 except Exception, err_msg:
219 html = self.request(host=host, location=location)
220 return self.parse(html)
225 "OP_UNKNOWN" : 0x0000
226 ,"OP_HBBTV_EXIT" : 0x0001
227 ,"OP_HBBTV_OPEN_URL" : 0x0002
228 ,"OP_HBBTV_LOAD_AIT" : 0x0003
229 ,"OP_HBBTV_UNLOAD_AIT" : 0x0004
230 ,"OP_HBBTV_FULLSCREEN" : 0x0005
231 ,"OP_HBBTV_TITLE" : 0x0006
232 ,"OP_HBBTV_RETRY_OPEN_URL" : 0x0009
233 ,"OP_HBBTV_CHANGE_CHANNEL" : 0x000A
234 ,"OP_OIPF_GET_CHANNEL_INFO_URL" : 0x0101
235 ,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102
236 ,"OP_OIPF_GET_CHANNEL_INFO_LIST": 0x0103
237 ,"OP_VOD_URI" : 0x0201
238 ,"OP_VOD_PLAY" : 0x0202
239 ,"OP_VOD_STOP" : 0x0203
240 ,"OP_VOD_PAUSE" : 0x0204
241 ,"OP_VOD_STATUS" : 0x0205
242 ,"OP_VOD_FORBIDDEN" : 0x0206
243 ,"OP_VOD_STOPED" : 0x0207
244 ,"OP_VOD_SPEED_CTRL" : 0x0208
245 ,"OP_VOD_SEEK_CTRL" : 0x0209
246 ,"OP_BROWSER_OPEN_URL" : 0x0301
247 ,"OP_BROWSER_VKBD_REQ" : 0x0309
248 ,"OP_BROWSER_VKBD_RES" : 0x030A
249 ,"OP_BROWSER_VKBD_PASTE_REQ" : 0x030B
250 ,"OP_BROWSER_VKBD_PASTE_KEY" : 0x030C
251 ,"OP_BROWSER_VKBD_PASTE_MOUSE" : 0x030D
252 ,"OP_BROWSER_MENU_REQ" : 0x030E
253 ,"OP_BROWSER_MENU_RES" : 0x030F
254 ,"OP_BROWSER_NEED_RELOAD_KEYMAP": 0x0313
255 ,"OP_DVBAPP_VOL_UP" : 0x0401
256 ,"OP_DVBAPP_VOL_DOWN" : 0x0402
257 ,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501
258 ,"OP_SYSTEM_NOTIFY_MY_PID" : 0x0502
261 0x0000 : "OP_UNKNOWN"
262 ,0x0001 : "OP_HBBTV_EXIT"
263 ,0x0002 : "OP_HBBTV_OPEN_URL"
264 ,0x0003 : "OP_HBBTV_LOAD_AIT"
265 ,0x0004 : "OP_HBBTV_UNLOAD_AIT"
266 ,0x0005 : "OP_HBBTV_FULLSCREEN"
267 ,0x0006 : "OP_HBBTV_TITLE"
268 ,0x0009 : "OP_HBBTV_RETRY_OPEN_URL"
269 ,0x000A : "OP_HBBTV_CHANGE_CHANNEL"
270 ,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL"
271 ,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT"
272 ,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST"
273 ,0x0201 : "OP_VOD_URI"
274 ,0x0202 : "OP_VOD_PLAY"
275 ,0x0203 : "OP_VOD_STOP"
276 ,0x0204 : "OP_VOD_PAUSE"
277 ,0x0205 : "OP_VOD_STATUS"
278 ,0x0206 : "OP_VOD_FORBIDDEN"
279 ,0x0207 : "OP_VOD_STOPED"
280 ,0x0208 : "OP_VOD_SPEED_CTRL"
281 ,0x0209 : "OP_VOD_SEEK_CTRL"
282 ,0x0301 : "OP_BROWSER_OPEN_URL"
283 ,0x0309 : "OP_BROWSER_VKBD_REQ"
284 ,0x030A : "OP_BROWSER_VKBD_RES"
285 ,0x030B : "OP_BROWSER_VKBD_PASTE_REQ"
286 ,0x030C : "OP_BROWSER_VKBD_PASTE_KEY"
287 ,0x030D : "OP_BROWSER_VKBD_PASTE_MOUSE"
288 ,0x030E : "OP_BROWSER_MENU_REQ"
289 ,0x030F : "OP_BROWSER_MENU_RES"
290 ,0x0313 : "OP_BROWSER_NEED_RELOAD_KEYMAP"
291 ,0x0401 : "OP_DVBAPP_VOL_UP"
292 ,0x0402 : "OP_DVBAPP_VOL_DOWN"
293 ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
294 ,0x0502 : "OP_SYSTEM_NOTIFY_MY_PID"
297 def get(self, opstr):
299 return self._opcode_[opstr]
301 return self._opcode_["OP_UNKNOWN"]
303 def what(self, opcode):
305 return self._opstr_[opcode]
307 return self._opstr_["0x0000"]
320 def __init__(self, params):
321 self._protocol = params.protocol
322 self._type = params.type
323 self._addr = params.addr
324 self._buf_size = params.buf_size
325 self._handler = params.handler
326 self._timeout = params.timeout
327 self._destroy = params.destroy
329 self._terminated = False
330 self._server_thread = None
332 self.onHbbTVCloseCB = []
333 self.onSetPageTitleCB = []
336 if self._destroy is not None:
337 self._destroy(self._addr)
340 self._terminated = True
341 if self._server_thread is not None:
342 self._server_thread.join()
343 self._server_thread = None
346 self._socket = socket.socket(self._protocol, self._type)
347 self._socket.settimeout(self._timeout)
348 self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
349 self._socket.bind(self._addr)
350 self._socket.listen(True)
352 self._server_thread = threading.Thread(target=self._listen)
353 self._server_thread.start()
356 select_list = [self._socket]
359 conn, addr = self._socket.accept()
360 self._client(conn, addr)
361 except Exception, ErrMsg:
362 print "ServerSocket Error >>", ErrMsg
365 while not self._terminated:
366 readable, writable, errored = select.select(select_list, [], [], self._timeout)
368 if s is self._socket:
371 def _client(self, conn, addr):
374 received_data = conn.recv(self._buf_size)
375 if self._handler is not None and not strIsEmpty(received_data):
376 send_data = self._handler.doHandle(received_data, self.onHbbTVCloseCB, self.onSetPageTitleCB)
377 self._send(conn, send_data)
378 except Exception, ErrMsg:
381 if self._handler is not None:
382 self._handler.printError(ErrMsg)
383 def _send(self, conn, data) :
388 def doListenUnixTCP(self, name, handler):
392 if os.path.exists(name):
394 print "Removed ", name
398 params = SocketParams()
399 params.protocol = socket.AF_UNIX
400 params.type = socket.SOCK_STREAM
402 params.handler = handler
403 params.destroy = destroy
405 streamServer = StreamServer(params)
409 def doListenInetTCP(self, ip, port, handler):
410 print "Not implemented yet!!"
411 def doListenUnixDGRAM(self, name, handler):
412 print "Not implemented yet!!"
413 def doListenInetDGRAM(self, ip, port, handler):
414 print "Not implemented yet!!"
417 def doUnpack(self, data):
420 def doPack(self, opcode, params, reserved=0):
421 return _pack(opcode, params, reserved)
423 def doHandle(self, data, onCloseCB):
424 opcode, params = 0x0, 'Invalid Request!!'
425 return _pack(opcode, params)
427 def printError(self, reason):
430 class BrowserCommandUtil(OpCodeSet):
433 OpCodeSet.__init__(self)
435 def isConnected(self):
440 def doConnect(self, filename):
441 if not os.path.exists(filename):
442 print "File not exists :", filename
445 self._fd = os.open(filename, os.O_WRONLY|os.O_NONBLOCK)
447 print "Fail to open file :", filename
449 except Exception, ErrMsg:
455 def doDisconnect(self):
461 def doSend(self, command, params=None, reserved=0):
463 print "No found pipe!!"
467 data = _pack(self.get(command), params, reserved)
470 os.write(self._fd, data)
471 print "Send OK!! :", command
475 def sendCommand(self, command, params=None, reserved=0):
476 if not self.isConnected():
478 self.doConnect(COMMAND_PATH)
479 result = self.doSend(command, params, reserved)
483 class HandlerHbbTV(Handler):
485 def __init__(self, session):
486 self._session = session
487 self.opcode = OpCodeSet()
489 0x0001 : self._cb_handleCloseHbbTVBrowser
490 ,0x0006 : self._cb_handleSetPageTitle
491 ,0x0009 : self._cb_handleHbbTVRetryOpen
492 ,0x000A : self._cb_handleHbbTVChangeChannel
493 ,0x0101 : self._cb_handleGetChannelInfoForUrl
494 ,0x0102 : self._cb_handleGetChannelInfoForAIT
495 ,0x0103 : self._cb_handleGetChannelInfoList
496 ,0x0201 : self._cb_handleVODPlayerURI
497 ,0x0202 : self._cb_handleVODPlayerPlay
498 ,0x0203 : self._cb_handleVODPlayerStop
499 ,0x0204 : self._cb_handleVODPlayerPlayPause
500 ,0x0401 : self._cb_handleDVBAppVolUp
501 ,0x0402 : self._cb_handleDVBAppVolDown
502 ,0x0208 : self._cb_handleVODSpeedCtrl
503 ,0x0209 : self._cb_handleVODSeekCtrl
504 ,0x0501 : self._cb_handleSystemOutOfMemory
505 ,0x0502 : self._cb_handleSystemNotufyMyPID
506 ,0x0309 : self._cb_handleShowVirtualKeyboard
507 ,0x030B : self._cb_handlePasteVirtualKeyboard
508 ,0x030E : self._cb_handleBrowserMenuReq
510 self._on_close_cb = None
511 self._on_set_title_cb = None
515 self._retry_open_url = None
516 self._timer_retry_open = eTimer()
517 self._timer_paste_vkbd = eTimer()
518 self._curren_title = None
520 def _handle_dump(self, handle, opcode, data=None):
524 print " - opcode : ", self.opcode.what(opcode)
526 print " - data : ", data
528 def doHandle(self, data, onCloseCB, onSetPageTitleCB):
529 opcode, params, reserved = None, None, 0
530 self._on_close_cb = onCloseCB
531 self._on_set_title_cb = onSetPageTitleCB
533 datas = self.doUnpack(data)
534 except Exception, ErrMsg:
535 print "Unpacking packet ERR :", ErrMsg
536 params = 'fail to unpack packet!!'
537 opcode = self.opcode.get("OP_UNKNOWN")
538 return self.doPack(opcode, params)
542 self.opcode.what(opcode)
545 #print self.handle_map[opcode]
546 (reserved, params) = self.handle_map[opcode](opcode, params)
547 except Exception, ErrMsg:
548 print "Handling packet ERR :", ErrMsg
549 params = 'fail to handle packet!!'
550 opcode = self.opcode.get("OP_UNKNOWN")
551 return self.doPack(opcode, params)
552 self._on_close_cb = None
553 self._on_set_title_cb = None
554 return self.doPack(opcode, params, reserved)
556 def _cb_handleHbbTVChangeChannel(self, opcode, data):
557 self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
559 if _g_helper is None:
561 dataItems = data.split(":")
564 if not _g_helper.doChangeChannel(sid, tsid):
568 def _cb_handleBrowserMenuReq(self, opcode, data):
569 self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
571 fbClass.getInstance().unlock()
572 eRCInput.getInstance().unlock()
573 browser = getPluginBrowser()
574 if browser is not None:
575 browser.setCurrentPageUrl(data, self._curren_title)
578 def _cb_handlePasteVirtualKeyboard(self, opcode, data):
579 self._handle_dump(self._cb_handlePasteVirtualKeyboard, opcode, data)
580 def _cb_PasteRefocusVirtualKeyboard():
581 self._timer_paste_vkbd.stop()
582 command_util = getCommandUtil()
583 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
585 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
587 def _cb_PasteKeyVirtualKeyboard():
588 self._timer_paste_vkbd.stop()
589 command_util = getCommandUtil()
590 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_KEY')
592 self._timer_paste_vkbd.callback.remove(_cb_PasteKeyVirtualKeyboard)
594 self._timer_paste_vkbd.callback.append(_cb_PasteRefocusVirtualKeyboard)
595 self._timer_paste_vkbd.start(100)
596 def _cb_PasteMouseVirtualKeyboard():
597 self._timer_paste_vkbd.stop()
598 command_util = getCommandUtil()
599 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
601 #command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
603 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
605 #self._timer_paste_vkbd.callback.append(_cb_PasteKeyVirtualKeyboard)
606 #self._timer_paste_vkbd.start(1000)
607 self._timer_paste_vkbd.callback.append(_cb_PasteMouseVirtualKeyboard)
608 self._timer_paste_vkbd.start(50)
611 def _cb_virtualKeyboardClosed(self, data=None):
612 fbClass.getInstance().lock()
613 eRCInput.getInstance().lock()
614 setResolution(1280, 720)
615 command_util = getCommandUtil()
616 command_util.sendCommand('OP_BROWSER_VKBD_RES', data)
617 def _cb_handleShowVirtualKeyboard(self, opcode, data):
618 self._handle_dump(self._cb_handleShowVirtualKeyboard, opcode, data)
620 fbClass.getInstance().unlock()
621 eRCInput.getInstance().unlock()
622 if data == 0 or strIsEmpty(data):
624 self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text=data)
627 def _cb_handleVODSeekCtrl(self, opcode, data):
628 self._handle_dump(self._cb_handleVODSeekCtrl, opcode, data)
629 headLen = struct.calcsize('!I')
630 unpackedData = struct.unpack('!I', data[:headLen])
631 seekTime = unpackedData[0]
632 service = self._session.nav.getCurrentService()
633 seekable = service.seek()
634 if seekable is None or not seekable.isCurrentlySeekable():
635 raise Exception("This stream is not support manual seek.")
637 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
640 def _cb_handleHbbTVRetryOpen(self, opcode, data):
641 def _cb_HbbTVRetryOpenURL():
642 self._timer_retry_open.stop()
643 if self._retry_open_url is not None:
644 command_util = getCommandUtil()
645 command_util.sendCommand('OP_HBBTV_RETRY_OPEN_URL', params=self._retry_open_url)
646 self._retry_open_url = None
648 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
650 self._handle_dump(self._cb_handleHbbTVRetryOpen, opcode, data)
651 headLen = struct.calcsize('!I')
652 unpackedData = struct.unpack('!I', data[:headLen])
653 delayTime = unpackedData[0]
654 restartUrl = data[headLen:]
656 self._retry_open_url = restartUrl.strip()
657 self._timer_retry_open.callback.append(_cb_HbbTVRetryOpenURL)
658 self._timer_retry_open.start(delayTime*1000)
661 def _cb_handleSystemNotufyMyPID(self, opcode, data):
662 self._handle_dump(self._cb_handleSystemNotufyMyPID, opcode, data)
665 def _cb_handleSystemOutOfMemory(self, opcode, data):
666 self._handle_dump(self._cb_handleSystemOutOfMemory, opcode, data)
670 def _cb_handleVODSpeedCtrl(self, opcode, data):
671 self._handle_dump(self._cb_handleVODSpeedCtrl, opcode, data)
672 headLen = struct.calcsize('!I')
673 unpackedData = struct.unpack('!I', data[:headLen])
674 playSpeed = unpackedData[0]
675 service = self._session.nav.getCurrentService()
676 pauseable = service.pause()
679 if pauseable.setFastForward(playSpeed) == -1:
680 pauseable.setFastForward(1)
681 raise Exception("This stream is not support trick play.")
684 def _cb_handleDVBAppVolUp(self, opcode, data):
685 self._handle_dump(self._cb_handleDVBAppVolUp, opcode, data)
686 vcm = VolumeControl.instance
690 def _cb_handleDVBAppVolDown(self, opcode, data):
691 self._handle_dump(self._cb_handleDVBAppVolDown, opcode, data)
692 vcm = VolumeControl.instance
696 def _cb_handleGetChannelInfoForUrl(self, opcode, data):
697 self._handle_dump(self._cb_handleGetChannelInfoForUrl, opcode, data)
698 (sid, onid, tsid, name, orgid) = getChannelInfos()
700 return (0, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
702 def _cb_handleGetChannelInfoForAIT(self, opcode, data):
703 self._handle_dump(self._cb_handleGetChannelInfoForAIT, opcode, data)
704 (sid, onid, tsid, name, orgid) = getChannelInfos()
706 return (0, struct.pack('!IIIII', orgid, sid, onid, tsid, namelen) + name)
708 def _cb_handleGetChannelInfoList(self, opcode, data):
709 self._handle_dump(self._cb_handleGetChannelInfoList, opcode, data)
710 (sid, onid, tsid, name, orgid) = getChannelInfos()
712 channel_list_size = 1
713 return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
715 def _cb_handleSetPageTitle(self, opcode, data):
716 self._handle_dump(self._cb_handleSetPageTitle, opcode, data)
717 if data.startswith('file://') or data.startswith('http://'):
719 if self._on_set_title_cb is not None:
720 for x in self._on_set_title_cb:
723 self._curren_title = data
724 except Exception, ErrMsg:
725 if x in self._on_set_title_cb:
726 self._on_set_title_cb.remove(x)
729 def _cb_handleCloseHbbTVBrowser(self, opcode, data):
730 self._timer_retry_open.stop()
732 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
734 self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
736 if self._on_close_cb:
737 for x in self._on_close_cb:
740 except Exception, ErrMsg:
741 if x in self._on_close_cb:
742 self._on_close_cb.remove(x)
744 command_util = getCommandUtil()
745 command_util.sendCommand('OP_HBBTV_FULLSCREEN', None)
747 before_service = getBeforeService()
748 if before_service is not None:
749 self._session.nav.playService(before_service)
755 def _cb_handleVODPlayerURI(self, opcode, data):
757 hl = struct.calcsize('!II')
758 datas = struct.unpack('!II', data[:hl])
760 vodUri = data[hl:hl+uriLength]
761 self._handle_dump(self._cb_handleVODPlayerURI, opcode, vodUri)
762 self._vod_uri = vodUri
765 def doStop(self, restoreBeforeService=True, needStop=True):
767 self._session.nav.stopService()
768 if self._vod_service is not None and restoreBeforeService:
769 before_service = getBeforeService()
770 self._session.nav.playService(before_service)
772 self._vod_service = None
777 def doRetryOpen(self, url):
781 self._vod_service = None
783 print "Try to open vod [%d] : %s" % (ii, url)
784 self._vod_service = eServiceReference(4097, 0, url)
785 self._session.nav.playService(self._vod_service)
786 if self._vod_service is not None:
788 except Exception, ErrMsg:
789 print "OpenVOD ERR :", ErrMsg
793 def _cb_handleVODPlayerPlay(self, opcode, data):
794 self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
795 self.doStop(restoreBeforeService=False)
796 if self.doRetryOpen(url=self._vod_uri) == False:
800 def _cb_handleVODPlayerStop(self, opcode, data):
801 self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
805 def _cb_handleVODPlayerPlayPause(self, opcode, data):
806 self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
807 service = self._session.nav.getCurrentService()
810 servicePause = service.pause()
812 servicePause.unpause()
813 elif pauseFlag == 'P':
815 except Exception, ErrMsg:
816 print "onPause ERR :", ErrMsg
819 from libshm import SimpleSharedMemory
821 class HbbTVWindow(Screen, InfoBarNotifications):
823 <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
826 def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
827 self._session = session
828 setResolution(1280, 720)
829 fbClass.getInstance().lock()
830 eRCInput.getInstance().lock()
832 Screen.__init__(self, session)
833 InfoBarNotifications.__init__(self)
834 self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
835 iPlayableService.evUser+20: self._serviceForbiden,
836 iPlayableService.evStart: self._serviceStarted,
837 iPlayableService.evEOF: self._serviceEOF,
841 self._use_ait = useAIT
842 self._profile = profile
843 self._cb_closed_func = cbf
844 self.onLayoutFinish.append(self._layoutFinished)
846 command_server = getCommandServer()
847 if self._cb_set_page_title not in command_server.onSetPageTitleCB:
848 command_server.onSetPageTitleCB.append(self._cb_set_page_title)
850 if self._cb_close_window not in command_server.onHbbTVCloseCB:
851 command_server.onHbbTVCloseCB.append(self._cb_close_window)
853 self._closeTimer = eTimer()
854 self._closeTimer.callback.append(self._do_close)
856 self._currentServicePositionTimer = eTimer()
857 self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
864 def getVodPlayTime(self):
866 service = self._session.nav.getCurrentService()
867 seek = service and service.seek()
869 p = seek.getPlayPosition()
870 #return (p[1]/90000, l[1]/90000)
875 def _cb_currentServicePosition(self):
876 def getTimeString(t):
877 t = time.localtime(t/90000)
878 return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
879 position,length = 0,0
881 (position,length) = self.getVodPlayTime()
882 self._vod_length = length
883 if position == -1 and length == -1:
884 raise Exception("Can't get play status")
885 #print getTimeString(position), "/", getTimeString(length)
886 self._ssm.setStatus(position, length, 1)
887 except Exception, ErrMsg:
891 def _serviceStarted(self):
893 self._ssm.setStatus(0, 0, 0)
894 self._currentServicePositionTimer.start(1000)
895 except Exception, ErrMsg:
898 def _serviceEOF(self):
899 (position,length) = self.getVodPlayTime()
900 self._ssm.setStatus(length, length, 1)
902 self._currentServicePositionTimer.stop()
904 def _layoutFinished(self):
905 self.setTitle(_('HbbTV Plugin'))
906 command_util = getCommandUtil()
907 profile = self._profile
908 (sid, onid, tsid, name, orgid) = getChannelInfos()
909 params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
911 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
913 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
915 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
917 command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
919 def _cb_close_window(self):
920 self._closeTimer.start(1000)
923 self._closeTimer.stop()
924 command_server = getCommandServer()
926 if self._cb_set_page_title in command_server.onSetPageTitleCB:
927 command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
928 except Exception, ErrMsg: pass
930 if self._cb_close_window in command_server.onHbbTVCloseCB:
931 command_server.onHbbTVCloseCB.remove(self._cb_close_window)
932 except Exception, ErrMsg: pass
934 if self._cb_closed_func is not None:
935 self._cb_closed_func()
938 fbClass.getInstance().unlock()
939 eRCInput.getInstance().unlock()
942 def _serviceForbiden(self):
944 real_url = MMSStreamURL().getLocationData(__gval__.hbbtv_handelr.getUrl())
945 print "Received URI :\n", real_url
947 if real_url is not None:
948 __gval__.hbbtv_handelr.doRetryOpen(real_url.strip())
950 def _cb_set_page_title(self, title=None):
951 print "page title :",title
956 class HbbTVHelper(Screen):
957 skin = """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
958 def __init__(self, session):
960 __gval__.hbbtv_handelr = HandlerHbbTV(session)
961 __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
965 Screen.__init__(self, session)
966 self._session = session
968 self._restart_opera()
970 self._timer_infobar = eTimer()
971 self._timer_infobar.callback.append(self._cb_registrate_infobar)
972 self._timer_infobar.start(1000)
974 self._excuted_browser = False
977 __gval__.command_util = BrowserCommandUtil()
981 _g_ssm_ = SimpleSharedMemory()
984 self._callbackStartStop = None
986 def _cb_registrate_infobar(self):
988 self._timer_infobar.stop()
989 if self._cb_ready_for_ait not in InfoBar.instance.onReadyForAIT:
990 InfoBar.instance.onReadyForAIT.append(self._cb_ready_for_ait)
991 if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
992 InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
994 def _cb_ready_for_ait(self, orgId=0):
996 if not self._excuted_browser:
997 command_util = getCommandUtil()
998 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
1000 setChannelInfo(None, None, None, None, None)
1002 service = self._session.nav.getCurrentService()
1003 info = service and service.info()
1004 if info is not None:
1005 sid = info.getInfo(iServiceInformation.sSID)
1006 onid = info.getInfo(iServiceInformation.sONID)
1007 tsid = info.getInfo(iServiceInformation.sTSID)
1008 name = info.getName()
1013 for x in info.getInfoObject(iServiceInformation.sHBBTVUrl):
1014 if x[0] in (1, -1) :
1017 setChannelInfo(sid, onid, tsid, name, orgid)
1019 def _cb_hbbtv_activated(self, title=None, url=None):
1020 if not self._is_browser_running():
1021 message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
1022 self._session.open(MessageBox, message, MessageBox.TYPE_INFO)
1024 service = self._session.nav.getCurrentlyPlayingServiceReference()
1025 setBeforeService(service)
1026 self._start_hbbtv_application(title, url)
1028 def _start_hbbtv_application(self, title, url):
1030 tmp_url = self.getStartHbbTVUrl()
1034 print "can't get url of hbbtv!!"
1036 print "success to get url of hbbtv!! >>", url
1037 if self._excuted_browser:
1038 print "already excuted opera browser!!"
1042 self._restart_opera()
1044 setNeedRestart(False)
1046 for x in self._urls:
1049 if tmp_url == url and control_code == 1:
1051 self._excuted_browser = True
1052 self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
1054 def _cb_closed_browser(self):
1055 self._excuted_browser = False
1057 def _start_opera(self):
1058 if not self._is_browser_running():
1059 global HBBTVAPP_PATH
1060 start_command = '%s/launcher start'%(HBBTVAPP_PATH)
1061 os.system(start_command)
1064 def _stop_opera(self):
1065 global HBBTVAPP_PATH
1066 try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
1069 def _restart_opera(self):
1070 global HBBTVAPP_PATH
1071 try: os.system('%s/launcher restart'%(HBBTVAPP_PATH))
1075 def getStartHbbTVUrl(self):
1076 url, self._urls, self._profile = None, None, 0
1077 service = self._session.nav.getCurrentService()
1078 info = service and service.info()
1079 if not info: return None
1080 self._urls = info.getInfoObject(iServiceInformation.sHBBTVUrl)
1081 for u in self._urls:
1082 if u[0] in (1, -1): # 0:control code, 1:name, 2:url, 3:orgid, 4:appid, 5:profile code
1084 self._profile = u[5]
1086 url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1089 def showApplicationSelectionBox(self):
1092 if self.getStartHbbTVUrl():
1093 for x in self._urls:
1094 applications.append((x[1], x))
1095 else: applications.append((_("No detected HbbTV applications."), None))
1096 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1098 def _application_selected(self, selected):
1100 if selected[1] is None: return
1101 self._cb_hbbtv_activated(selected[1][1], selected[1][2])
1102 except Exception, ErrMsg: print ErrMsg
1104 def showBrowserConfigBox(self, callback=None):
1105 start_stop_mode = []
1106 self._callbackStartStop = callback
1107 if self._is_browser_running():
1108 start_stop_mode.append((_('Stop'),'Stop'))
1109 else: start_stop_mode.append((_('Start'),'Start'))
1110 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1112 def _browser_config_selected(self, selected):
1113 if selected is None:
1115 if self._callbackStartStop is not None:
1116 self._callbackStartStop()
1120 if not self._is_browser_running():
1122 elif mode == 'Stop':
1124 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1126 def _is_browser_running(self):
1128 global HBBTVAPP_PATH
1129 ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1130 return ret.strip() != "0"
1131 except Exception, ErrMsg:
1132 print "Check Browser Running ERR :", ErrMsg
1135 def doChangeChannel(self, _sid, _tsid):
1136 root = eServiceReference(service_types_tv)
1139 serviceList = eServiceCenter.getInstance().list(root)
1140 if serviceList is None:
1143 service = serviceList.getNext()
1144 if service is None or not service.valid():
1147 #1:0:19:2840:3FB:1:C00000:0:0:0:
1148 serviceRef = service.toString()
1149 if strIsEmpty(serviceRef):
1151 serviceRefItems = serviceRef.split(":")
1152 if len(serviceRefItems) < 5:
1155 sid = serviceRefItems[3]
1156 tsid = serviceRefItems[4]
1157 if sid == _sid and tsid == _tsid:
1158 self._session.nav.playService(eServiceReference(serviceRef))
1159 service = self._session.nav.getCurrentlyPlayingServiceReference()
1160 setBeforeService(service)
1164 class OperaBrowserSetting:
1166 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1172 f = open(self._settingFileName)
1173 for line in f.readlines():
1174 if line.startswith('start='):
1175 tmp = line[6:len(line)-1].split()
1176 self._start = tmp[0]
1178 self._type = int(tmp[1])
1179 else: self._type = 0
1180 elif line.startswith('keymap='):
1181 self._keymap = line[7:len(line)-1]
1185 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1186 tmpstr.append('keymap=%s\n' % (self._keymap))
1187 f = open(self._settingFileName, 'w')
1188 f.writelines(tmpstr)
1190 def setData(self, start, types=0, keymap="us-rc"):
1193 self._keymap = keymap
1197 'start':self._start,
1199 'keymap':self._keymap,
1202 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1204 <screen position="center,120" size="600,350" title="Preference">
1205 <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1206 <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1208 <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1209 <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1211 <widget source="key_red" render="Label" position="310,310" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
1212 <widget source="key_green" render="Label" position="150,310" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
1215 def __init__(self, session, currentUrl):
1216 self.session = session
1217 Screen.__init__(self, session)
1220 ConfigListScreen.__init__(self, self.menulist)
1222 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1223 "red" : self.keyRed,
1224 "green" : self.keyGreen,
1226 "cancel" : self.keyRed
1228 self["key_red"] = StaticText(_("Cancel"))
1229 self["key_green"] = StaticText(_("Save"))
1230 self["url"] = Label()
1232 self._currentPageUrl = currentUrl
1233 if self._currentPageUrl is None:
1234 self._currentPageUrl = ''
1235 self._startPageUrl = None
1236 self._keymapType = None
1237 self.makeMenuEntry()
1238 self.onLayoutFinish.append(self.layoutFinished)
1240 def layoutFinished(self):
1241 self.setTitle(_('Preference'))
1243 def updateStartPageUrl(self):
1244 if self.menuItemStartpage.value == "startpage":
1245 self["url"].setText(self._startPageUrl)
1246 elif self.menuItemStartpage.value == "current":
1247 self["url"].setText(self._currentPageUrl)
1248 elif self.menuItemStartpage.value == "direct":
1249 self["url"].setText('')
1252 url = self["url"].getText()
1254 self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1257 if url.find('/usr/local/manual') > 0:
1259 self._keymapType = self.menuItemKeyboardLayout.value
1260 OperaBrowserSetting().setData(url, mode, self._keymapType)
1261 command_util = getCommandUtil()
1262 command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
1269 def _cb_directInputUrl(data):
1270 if strIsEmpty(data):
1272 self["url"].setText(data)
1273 if self.menuItemStartpage.value == "direct":
1274 self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1277 ConfigListScreen.keyLeft(self)
1278 self.updateStartPageUrl()
1281 ConfigListScreen.keyRight(self)
1282 self.updateStartPageUrl()
1284 def getKeymapTypeList(self):
1286 for f in os.listdir("/usr/local/hbb-browser/keymap"):
1287 filesplit = f.split('.')
1288 if len(filesplit) < 2:
1290 types.append((filesplit[1], filesplit[1]))
1294 def makeMenuEntry(self):
1296 l.append(("startpage", _("Start Page")))
1297 if not strIsEmpty(self._currentPageUrl):
1298 l.append(("current", _("Current Page")))
1299 l.append(("direct", _("Direct Input")))
1300 self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
1301 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1303 kl = self.getKeymapTypeList()
1306 d = OperaBrowserSetting().getData()
1307 self._startPageUrl = d['start']
1308 self._keymapType = d['keymap']
1310 except: self._startPageUrl = 'http://vuplus.com'
1311 self.updateStartPageUrl()
1313 if self._keymapType is None or len(self._keymapType) == 0:
1314 self._keymapType = "us-rc"
1315 self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
1316 self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
1317 self.resetMenuList()
1319 def resetMenuList(self):
1321 self.menulist.append(self.menuEntryStartpage)
1322 self.menulist.append(self.menuEntryKeyboardLayout)
1324 self["config"].list = self.menulist
1325 self["config"].l.setList(self.menulist)
1327 class BookmarkEditWindow(ConfigListScreen, Screen):
1328 CATEGORY,BOOKMARK = 0,1
1330 <screen position="center,center" size="600,140" title="Bookmark Edit">
1331 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1333 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1334 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1336 <widget source="key_red" render="Label" position="310,100" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
1337 <widget source="key_green" render="Label" position="150,100" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
1339 <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1343 def __init__(self, session, _mode, _type, _data, _bm):
1347 self.mSession = session
1348 self.mBookmarkManager = _bm
1350 if _data is not None:
1353 Screen.__init__(self, session)
1356 ConfigListScreen.__init__(self, self.menulist)
1358 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1359 "ok" : self.keyGreen,
1360 "green" : self.keyGreen,
1361 "red" : self.keyRed,
1362 "cancel" : self.keyRed,
1365 self["VKeyIcon"] = Pixmap()
1366 self["key_red"] = StaticText(_("Cancel"))
1367 self["key_green"] = StaticText(_("Save"))
1369 self.menuItemTitle = None
1370 self.menuItemUrl = None
1371 self.menuItemName = None
1373 self.menuEntryName = None
1374 self.menuEntryTitle = None
1375 self.menuEntryUrl = None
1377 self.makeConfigList()
1378 self.onLayoutFinish.append(self.layoutFinished)
1380 def layoutFinished(self):
1381 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1383 def selectedItem(self):
1384 currentPosition = self["config"].getCurrent()
1385 if self.mType == BookmarkEditWindow.CATEGORY:
1386 return (_("Name"), self.menuItemName)
1388 if currentPosition == self.menuEntryTitle:
1389 return (_("Title"), self.menuItemTitle)
1390 elif currentPosition == self.menuEntryUrl:
1391 return (_("Url"), self.menuItemUrl)
1394 def showMessageBox(self, text):
1395 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
1396 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1399 def showVKeyWindow(self, data=None):
1402 selected = self.selectedItem()
1403 if selected is not None:
1404 itemValue = selected[1].value
1405 if strIsEmpty(itemValue):
1407 itemTitle = selected[0]
1409 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1411 def cbVKeyWindow(self, data=None):
1412 if data is not None:
1413 selected = self.selectedItem()
1414 if selected is not None:
1415 selected[1].setValue(data)
1418 if self.mType == BookmarkEditWindow.CATEGORY:
1419 if self.mMode == _('Add'):
1420 categoryName = self.menuItemName.value
1421 if strIsEmpty(categoryName):
1422 return self.showMessageBox(_("Category Name"))
1423 self.mBookmarkManager.addCategory(categoryName)
1425 if strIsEmpty(self.menuItemName.value):
1426 return self.showMessageBox(_("Category Name"))
1427 self.mData.mName = self.menuItemName.value
1428 self.mBookmarkManager.updateCategory(self.mData)
1430 if self.mMode == _('Add'):
1431 bookmarkTitle = self.menuItemTitle.value
1432 bookmarkUrl = self.menuItemUrl.value
1433 if strIsEmpty(bookmarkTitle):
1434 self["config"].setCurrentIndex(0)
1435 return self.showMessageBox(_("Bookmark Title"))
1436 if strIsEmpty(bookmarkUrl):
1437 self["config"].setCurrentIndex(1)
1438 return self.showMessageBox(_("Bookmark URL"))
1439 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1441 if strIsEmpty(self.menuItemTitle.value):
1442 self["config"].setCurrentIndex(0)
1443 return self.showMessageBox(_("Bookmark Title"))
1444 if strIsEmpty(self.menuItemUrl.value):
1445 self["config"].setCurrentIndex(1)
1446 return self.showMessageBox(_("Bookmark URL"))
1447 self.mData.mTitle = self.menuItemTitle.value
1448 self.mData.mUrl = self.menuItemUrl.value
1449 self.mBookmarkManager.updateBookmark(self.mData)
1453 if not self.saveData():
1459 ConfigListScreen.keyLeft(self)
1461 ConfigListScreen.keyRight(self)
1462 def makeConfigList(self):
1465 if self.mType == BookmarkEditWindow.CATEGORY:
1466 self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1468 self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
1470 self.menulist.append(self.menuEntryName)
1472 self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1473 self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1475 self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1476 self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
1478 self.menulist.append(self.menuEntryTitle)
1479 self.menulist.append(self.menuEntryUrl)
1481 self["config"].list = self.menulist
1482 self["config"].l.setList(self.menulist)
1484 class OperaBrowserBookmarkWindow(Screen):
1486 <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
1487 <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1489 <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1490 <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1492 <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1493 <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1494 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1495 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1497 <widget source="key_red" render="Label" position="5,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
1498 <widget source="key_green" render="Label" position="155,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
1499 <widget source="key_yellow" render="Label" position="305,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#a08500" foregroundColor="#ffffff" transparent="1" />
1500 <widget source="key_blue" render="Label" position="450,360" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#18188b" foregroundColor="#ffffff" transparent="1" />
1504 def __init__(self, _session, _url=None, _title=None):
1506 self.mTitle = _title
1507 self.mBookmarkManager = BookmarkManager.getInstance()
1508 self.mSession = _session
1509 Screen.__init__(self, _session)
1510 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1512 "cancel": self.keyCancel,
1513 "red" : self.keyRed,
1514 "green" : self.keyGreen,
1515 "yellow": self.keyYellow,
1516 "blue" : self.keyBlue,
1517 "0" : self.keyNumber,
1520 self["key_red"] = StaticText(_("Exit"))
1521 self["key_green"] = StaticText(_("Add"))
1522 self["key_yellow"] = StaticText(_("Edit"))
1523 self["key_blue"] = StaticText(_("Delete"))
1524 self["key_0"] = StaticText(_("Set as Startpage"))
1526 self.mBookmarkList = self.setBookmarkList()
1527 self["bookmarklist"] = MenuList(self.mBookmarkList)
1529 self.onLayoutFinish.append(self.layoutFinished)
1531 def layoutFinished(self):
1532 self.setTitle(_('Bookmark'))
1534 def setBookmarkList(self):
1536 #self.mBookmarkManager.dump()
1537 cd = self.mBookmarkManager.getBookmarkRoot()
1538 for ck in cd.iterkeys():
1539 l.append(('# ' + cd[ck].mName, cd[ck]))
1540 bd = cd[ck].mBookmarks
1541 for bk in bd.iterkeys():
1542 l.append((' - ' + bd[bk].mTitle, bd[bk]))
1544 def updateBookmarkList(self):
1545 self.mBookmarkList = self.setBookmarkList()
1546 self["bookmarklist"].setList(self.mBookmarkList)
1547 def cbEditWindow(self, ret=False):
1550 self.updateBookmarkList()
1551 def getParentCategory(self):
1552 idx = self["bookmarklist"].getSelectedIndex()
1555 data = self.mBookmarkList[idx][0].strip()
1557 return self.mBookmarkList[idx][1]
1561 def isCategoryItem(self):
1563 head = self["bookmarklist"].getCurrent()[0].strip()
1568 def keyNumber(self):
1569 data = self["bookmarklist"].getCurrent()[1]
1570 if strIsEmpty(data.mUrl):
1571 msg = _("Invalid URL. Please check again!!")
1572 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1574 def cbSetStartpage(ret=None):
1575 if ret is None: return
1577 data = self["bookmarklist"].getCurrent()[1]
1578 OperaBrowserSetting().setData(data.mUrl, data.mType)
1579 msg = _("Do you want to set selected url to the Startpage?")
1580 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1587 parent = self.getParentCategory()
1590 if strIsEmpty(self.mTitle):
1592 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1594 msg = _("Current page is already exist.")
1595 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1596 self.cbEditWindow(True)
1598 parent = self.getParentCategory()
1601 b = BookmarkData(0, '', '', parent.mId, 0)
1602 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1604 c = CategoryData(0, '')
1605 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1606 if strIsEmpty(self.mUrl):
1607 l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1608 else: l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1609 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1610 def keyYellow(self):
1611 data = self["bookmarklist"].getCurrent()[1]
1612 if self.isCategoryItem():
1613 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1614 else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1616 def cbBlue(ret=None):
1618 data = self["bookmarklist"].getCurrent()[1]
1619 if self.isCategoryItem():
1620 self.mBookmarkManager.deleteCategory(data.mId)
1621 else: self.mBookmarkManager.deleteBookmark(data.mId)
1622 self.updateBookmarkList()
1623 if self.isCategoryItem():
1624 msg = _("Do you want to delete the category and the bookmarks?")
1625 else: msg = _("Do you want to delete the bookmark?")
1626 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1628 if self.isCategoryItem(): return
1630 data = self["bookmarklist"].getCurrent()[1]
1631 url = data.mUrl.strip()
1633 self.session.open(MessageBox, _("Can't open selected bookmark.\n - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1637 lang = language.getLanguage()
1638 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1639 url = '/usr/local/manual/ru_RU/main.html'
1640 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1641 url = '/usr/local/manual/de_DE/main.html'
1642 self.close((url, mode))
1645 def keyCancel(self):
1648 class BrowserHelpWindow(Screen, HelpableScreen):
1649 MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1651 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1652 <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1653 <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1654 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1655 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1657 <widget source="key_red" render="Label" position="5,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1" />
1658 <widget source="key_green" render="Label" position="155,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1" />
1659 <widget source="key_yellow" render="Label" position="305,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#a08500" foregroundColor="#ffffff" transparent="1" />
1660 <widget source="key_blue" render="Label" position="450,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#18188b" foregroundColor="#ffffff" transparent="1" />
1663 def __init__(self, session):
1664 Screen.__init__(self, session)
1665 HelpableScreen.__init__(self)
1667 self["key_red"] = StaticText(_("Exit"))
1668 self["key_green"] = StaticText(_("Global"))
1669 self["key_yellow"] = StaticText(_("Mouse"))
1670 self["key_blue"] = StaticText(_("Keyboard"))
1672 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1674 "cancel": self.keyRed,
1675 "red" : self.keyRed,
1676 "green" : self.keyGreen,
1677 "yellow": self.keyYellow,
1678 "blue" : self.keyBlue,
1681 self.showHelpTimer = eTimer()
1682 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1683 self.showHelpTimer.start(500)
1685 self.onLayoutFinish.append(self.layoutFinished)
1687 def layoutFinished(self):
1688 self.setTitle(_('Browser Help'))
1690 def cbShowHelpTimerClosed(self):
1691 self.showHelpTimer.stop()
1692 self.setHelpModeActions(self.MODE_GLOBAL)
1694 def setHelpModeActions(self, _mode=0):
1696 if _mode == self.MODE_GLOBAL:
1697 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1698 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1700 self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1701 "menu" : (self.keyPass, _("Show the Menu window.")),
1703 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1704 "green" : (self.keyPass, _("Enter Key")),
1705 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1706 "blue" : (self.keyPass, _("Backspace Key")),
1708 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1709 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1712 elif _mode == self.MODE_MOUSE:
1713 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1714 "up" : (self.keyPass, _("It will move the mouse pointer up.")),
1715 "down" : (self.keyPass, _("It will move the mouse pointer down.")),
1716 "left" : (self.keyPass, _("It will move the mouse pointer left.")),
1717 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1719 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1720 "ok" : (self.keyPass, _("Left Mouse Button")),
1722 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1723 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1724 "nextService" : (self.keyPass, _("Left Key")),
1725 "prevService" : (self.keyPass, _("Right Key")),
1727 elif _mode == self.MODE_KEYBOARD:
1728 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1729 "up" : (self.keyPass, _("Up Key")),
1730 "down" : (self.keyPass, _("Down Key")),
1731 "left" : (self.keyPass, _("Left Key")),
1732 "right" : (self.keyPass, _("Right Key")),
1734 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1735 "ok" : (self.keyPass, _("Enter Key")),
1737 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1738 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1739 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1740 "nextService" : (self.keyPass, _("Go to previous page.")),
1741 "prevService" : (self.keyPass, _("Go to next page.")),
1753 self.setHelpModeActions(self.MODE_GLOBAL)
1754 def keyYellow(self):
1755 self.setHelpModeActions(self.MODE_MOUSE)
1757 self.setHelpModeActions(self.MODE_KEYBOARD)
1759 class OperaBrowser(Screen):
1760 MENUBAR_ITEM_WIDTH = 150
1761 MENUBAR_ITEM_HEIGHT = 30
1762 SUBMENULIST_WIDTH = 200
1763 SUBMENULIST_HEIGHT = 25
1764 SUBMENULIST_NEXT = 2
1766 # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
1767 # menulist->size->x : SUBMENULIST_WIDTH
1768 # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
1769 # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
1770 # submenulist->size->x : SUBMENULIST_WIDTH
1772 <screen name="OperaBrowser" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1773 <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1774 <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1775 <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1776 <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1777 <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1778 <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1779 <widget name="bottomArea" position="0,640" size="1280,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1785 def __init__(self, session, url=None):
1786 Screen.__init__(self, session)
1787 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1788 "cancel" : self.keyCancel
1790 ,"left" : self.keyLeft
1791 ,"right" : self.keyRight
1793 ,"down" : self.keyDown
1794 ,"menu" : self.keyMenu
1797 self.UpdateLanguageCB()
1799 self._terminatedBrowser = True
1800 self._enableKeyEvent = True
1801 self._currentPageUrl = None
1802 self._currentPageTitle = None
1803 self.menubarCurrentIndex = 0
1804 self.lvMenuItems = []
1805 self.lvSubMenuItems = []
1807 self["topArea"] = Label()
1808 self["bottomArea"] = Label()
1810 self["menuitemFile"] = MultiColorLabel()# modify menu
1811 self["menuitemTool"] = MultiColorLabel()
1812 self["menuitemHelp"] = MultiColorLabel()
1814 self["menulist"] = MenuList(self.setListOnView())
1815 self["submenulist"] = MenuList(self.setSubListOnView())
1817 self.toggleMainScreenFlag = True
1818 self.toggleListViewFlag = False
1819 self.toggleSubListViewFlag = False
1820 self.currentListView = self["menulist"]
1822 self.onLayoutFinish.append(self.layoutFinished)
1824 self._onCloseTimer = eTimer()
1825 self._onCloseTimer.callback.append(self._cb_onClose)
1828 language.addCallback(self.UpdateLanguageCB)
1830 def UpdateLanguageCB(self):
1832 self.MENUITEMS_LIST = [
1833 [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1834 [(_('Bookmark'), None), (_('Preference'), None)],
1835 [(_('About'), None), (_('Help'), None)]]
1836 self.COMMAND_MAP = {}
1837 self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit
1838 self.COMMAND_MAP[_('Help')] = self._cmd_on_Help
1839 self.COMMAND_MAP[_('About')] = self._cmd_on_About
1840 self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl
1841 self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop
1842 self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark
1843 self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference
1844 self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser
1845 self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage
1847 def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1848 rcmouse_path = "/proc/stb/fp/mouse"
1849 if os.path.exists(rcmouse_path):
1850 os.system("echo %d > %s" % (mode, rcmouse_path))
1852 def layoutFinished(self):
1853 self["menuitemFile"].setText(_("File"))# modify menu
1854 self["menuitemTool"].setText(_("Tools"))
1855 self["menuitemHelp"].setText(_("Help"))
1857 self["menulist"].hide()
1858 self["submenulist"].hide()
1860 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1861 self.setTitle(_("BrowserMain"))
1862 self.selectMenuitem()
1864 if self.paramUrl is not None:
1866 self.cbUrlText(self.paramUrl, 1)
1868 def selectMenuitem(self):
1869 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1870 self["menuitemFile"].setForegroundColorNum(0)
1871 self["menuitemTool"].setForegroundColorNum(0)
1872 self["menuitemHelp"].setForegroundColorNum(0)
1873 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1875 def popupCloseAll(self):
1881 def setListOnView(self):
1882 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1883 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1884 l = [(_('Return'), None)]
1885 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1886 return self.lvMenuItems
1888 def setSubListOnView(self):
1889 self.lvSubMenuItems = []
1890 xl = self["menulist"].getCurrent()[1]
1891 if xl is None: return []
1893 self.lvSubMenuItems.append((x,None))
1894 return self.lvSubMenuItems
1896 def toggleMainScreen(self):
1897 if not self.toggleMainScreenFlag:
1900 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1902 def toggleListView(self):
1903 if not self.toggleListViewFlag:
1904 self["menulist"].show()
1905 else: self["menulist"].hide()
1906 self.toggleListViewFlag = not self.toggleListViewFlag
1908 def toggleSubListView(self):
1909 if not self.toggleSubListViewFlag:
1910 self["submenulist"].show()
1911 else: self["submenulist"].hide()
1912 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1914 def setCurrentListView(self, listViewIdx):
1915 if listViewIdx == 0:
1916 self.currentListView = None
1917 elif listViewIdx == 1:
1918 self.currentListView = self["menulist"]
1919 elif listViewIdx == 2:
1920 self.currentListView = self["submenulist"]
1922 def _cb_onClose(self):
1923 self._onCloseTimer.stop()
1924 command_server = getCommandServer()
1926 if self._on_close_window in command_server.onHbbTVCloseCB:
1927 command_server.onHbbTVCloseCB.remove(self._on_close_window)
1928 except Exception, ErrMsg: pass
1930 if self._on_setPageTitle in command_server.onSetPageTitleCB:
1931 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1932 except Exception, ErrMsg: pass
1933 self._on_setPageTitle(_('Opera Browser'))
1934 self.enableRCMouse(False)
1935 self.toggleMainScreen()
1937 fbClass.getInstance().unlock()
1938 eRCInput.getInstance().unlock()
1939 self._terminatedBrowser = True
1940 self._enableKeyEvent = True
1941 #if not self.toggleListViewFlag:
1944 self._currentPageUrl = ''
1945 if self.paramUrl is not None:
1951 def _on_setPageTitle(self, title=None):
1952 print "Title :",title
1955 self.setTitle(title)
1957 def cbUrlText(self, data=None, mode=0):
1959 if not _g_helper._is_browser_running():
1961 print "Inputed Url :", data, mode
1962 if strIsEmpty(data):
1965 command_server = getCommandServer()
1966 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
1967 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
1968 if self._on_close_window not in command_server.onHbbTVCloseCB:
1969 command_server.onHbbTVCloseCB.append(self._on_close_window)
1970 self.toggleMainScreen()
1971 self.enableRCMouse(True)
1973 fbClass.getInstance().lock()
1974 eRCInput.getInstance().lock()
1976 setResolution(1280, 720)
1978 command_util = getCommandUtil()
1979 command_util.sendCommand('OP_BROWSER_OPEN_URL', data, mode)
1980 self._terminatedBrowser = False
1981 self._enableKeyEvent = False
1983 def _on_close_window(self):
1984 self._onCloseTimer.start(1000)
1986 def _cb_bookmarkWindowClosed(self, data=None):
1991 if not _g_helper._is_browser_running():
1992 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
1993 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
1995 self.cbUrlText(url, mode)
1997 def _cmd_on_OpenUrl(self):
1999 if not _g_helper._is_browser_running():
2000 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2001 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2003 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
2004 def _cmd_on_About(self):
2005 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
2006 def _cmd_on_Exit(self):
2008 def _cb_cmdOnStartSTop(self):
2010 def _cmd_on_StartStop(self):
2012 if _g_helper is None:
2014 _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
2016 def _cmd_on_Bookmark(self):
2017 url = self._currentPageUrl
2020 title = self._currentPageTitle
2023 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
2024 def _cmd_on_Preference(self):
2025 url = self._currentPageUrl
2028 self.session.open(OperaBrowserPreferenceWindow, url)
2029 def _cmd_on_OpenStartpage(self):
2031 if not _g_helper._is_browser_running():
2032 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2033 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2036 start = 'http://vuplus.com'
2038 d = OperaBrowserSetting().getData()
2042 self.cbUrlText(start, mode)
2043 def _cmd_on_ReturnToBrowser(self):
2046 def _cmd_on_Help(self):
2047 self.session.open(BrowserHelpWindow)
2049 def doCommand(self, command):
2051 self.COMMAND_MAP[command]()
2052 except Exception, ErrMsg: print ErrMsg
2055 if not self.toggleMainScreenFlag:
2058 if not self.toggleListViewFlag:
2061 if self.currentListView.getCurrent()[1] is None:
2062 self.doCommand(self.currentListView.getCurrent()[0])
2063 #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
2067 def updateSelectedMenuitem(self, status):
2068 if self.menubarCurrentIndex == 0 and status < 0:
2069 self.menubarCurrentIndex = 2 # modify menu
2070 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
2071 self.menubarCurrentIndex = 0
2072 else: self.menubarCurrentIndex += status
2073 self.selectMenuitem()
2076 if not self.toggleMainScreenFlag:
2078 if not self.toggleListViewFlag:
2079 self.updateSelectedMenuitem(-1)
2081 if self.toggleSubListViewFlag:
2082 self.setCurrentListView(1)
2083 self.toggleSubListView()
2085 #if self.currentListView.getSelectedIndex():
2086 self.currentListView.pageUp()
2092 if not self.toggleMainScreenFlag:
2094 if not self.toggleListViewFlag:
2095 self.updateSelectedMenuitem(1)
2097 if self.currentListView is None:
2099 if self.currentListView.getCurrent()[1] is not None:
2100 parentSelectedIndex = self.currentListView.getSelectedIndex()
2101 self.setCurrentListView(2)
2102 self.currentListView.setList(self.setSubListOnView())
2103 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
2104 self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex + self.SUBMENULIST_WIDTH+self.SUBMENULIST_NEXT + 50,self.MENUBAR_ITEM_HEIGHT+30+(parentSelectedIndex*self.SUBMENULIST_HEIGHT))
2105 self.toggleSubListView()
2107 self.currentListView.pageUp()
2113 if not self.toggleMainScreenFlag:
2115 if self.currentListView is None:
2117 if not self.toggleListViewFlag:
2118 self.currentListView.setList(self.setListOnView())
2119 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2120 self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2121 self.toggleListView()
2123 self.currentListView.down()
2126 if not self.toggleMainScreenFlag:
2128 if self.currentListView is None:
2130 if self.currentListView == self["menulist"]:
2131 if self.currentListView.getSelectedIndex() == 0:
2132 self.toggleListView()
2134 self.currentListView.up()
2136 def keyCancel(self):
2137 if not self._terminatedBrowser:
2138 #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2139 fbClass.getInstance().lock()
2140 eRCInput.getInstance().lock()
2141 setResolution(1280, 720)
2142 if self.toggleListViewFlag:
2143 self.toggleMainScreen()
2144 self._currentPageUrl = None
2145 self._currentPageTitle = None
2146 command_util = getCommandUtil()
2147 command_util.sendCommand('OP_BROWSER_MENU_RES')
2152 self.toggleMainScreen()
2154 def setCurrentPageUrl(self, url, title=None):
2155 self._currentPageUrl = url
2158 if idx > 10: idx = 10
2160 self._currentPageTitle = title
2161 print self._currentPageUrl
2162 self.toggleMainScreen()
2166 def hideSubmenu(self):
2167 self.currentListView.pageUp()
2170 def auto_start_main(reason, **kwargs):
2172 command_server = getCommandServer()
2173 command_server.stop()
2175 from Screens.HelpMenu import HelpableScreen
2176 def session_start_main(session, reason, **kwargs):
2177 fbClass.getInstance().unlock()
2178 eRCInput.getInstance().unlock()
2180 from enigma import getDesktop
2181 desktopSize = getDesktop(0).size()
2182 setDefaultResolution(desktopSize.width(), desktopSize.height())
2185 _g_helper = session.open(HbbTVHelper)
2187 HelpableScreen.__init__ = HelpableScreen__init__
2188 HelpableScreen.session = session
2190 def HelpableScreen__init__(self):
2191 if isinstance(self, HelpableScreen):
2192 HelpableScreen.showManual = showManual
2194 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2195 "help_b" : self.showHelp,
2196 "help_l" : self.showManual,
2199 _g_clearBrowserDataTimer = eTimer()
2200 def showManual(self):
2201 if not os.path.exists('/usr/local/manual'):
2204 url = 'file:///usr/local/manual/main.html'
2205 lang = language.getLanguage()
2206 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2207 url = 'file:///usr/local/manual/ru_RU/main.html'
2208 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2209 url = 'file:///usr/local/manual/de_DE/main.html'
2212 _g_clearBrowserDataTimer.stop()
2213 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2215 setPluginBrowser(None)
2216 def clearBrowserData():
2217 _g_clearBrowserDataTimer.callback.append(_do_clean)
2218 _g_clearBrowserDataTimer.start(50)
2219 setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2221 def plugin_start_main(session, **kwargs):
2222 #session.open(OperaBrowser)
2224 _g_clearBrowserDataTimer.stop()
2225 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2227 setPluginBrowser(None)
2228 def clearBrowserData():
2229 _g_clearBrowserDataTimer.callback.append(_do_clean)
2230 _g_clearBrowserDataTimer.start(50)
2231 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2233 def plugin_extension_start_application(session, **kwargs):
2235 if _g_helper is None:
2237 _g_helper.showApplicationSelectionBox()
2239 def plugin_extension_browser_config(session, **kwargs):
2241 if _g_helper is None:
2243 _g_helper.showBrowserConfigBox()
2245 def Plugins(path, **kwargs):
2247 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2248 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2249 l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2250 l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2251 l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))