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)
60 __gval__ = GlobalValues()
62 def setPluginBrowser(browser=None):
64 __gval__.plugin_browser = browser
65 def getPluginBrowser():
67 return __gval__.plugin_browser
69 def getPacketHeaders():
71 return (__gval__.packet_m, __gval__.packet_h, __gval__.packet_hl)
73 def setChannelInfo(sid, onid, tsid, name, orgid):
74 if sid is None: sid = 0;
75 if onid is None: onid = 0;
76 if tsid is None: tsid = 0;
77 if name is None: name = "";
78 if orgid is None: orgid = 0;
80 __gval__.channel_info_sid = sid
81 __gval__.channel_info_onid = onid
82 __gval__.channel_info_tsid = tsid
83 __gval__.channel_info_name = name
84 __gval__.channel_info_orgid = orgid
85 print "Set Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (sid, onid, tsid, name, orgid)
86 def getChannelInfos():
88 print "Get Channel Info >> sid : %X, onid : %X, tsid : %X, name : %s, orgid : %d " % (__gval__.channel_info_sid,
89 __gval__.channel_info_onid, __gval__.channel_info_tsid, __gval__.channel_info_name, __gval__.channel_info_orgid)
90 return (__gval__.channel_info_sid,
91 __gval__.channel_info_onid,
92 __gval__.channel_info_tsid,
93 __gval__.channel_info_name,
94 __gval__.channel_info_orgid)
98 print "Need Restart(GET) : ", __gval__.need_restart
99 return __gval__.need_restart
100 def setNeedRestart(n):
102 __gval__.need_restart = n
103 print "Need Restart(SET) : ", __gval__.need_restart
105 def getCommandUtil():
107 return __gval__.command_util
108 def getCommandServer():
110 return __gval__.command_server
112 def setBeforeService(s):
114 __gval__.before_service = s
115 def getBeforeService():
117 return __gval__.before_service
119 def _unpack(packed_data):
120 (mg, h, hlen) = getPacketHeaders()
122 if strIsEmpty(packed_data):
124 (m, o, l, s) = struct.unpack(h, packed_data[:hlen])
129 d = packed_data[hlen:hlen+l]
132 def _pack(opcode, params=None, reserved=0):
133 (m, h, hlen) = getPacketHeaders()
134 if strIsEmpty(params):
136 packed_data = struct.pack(h, m, opcode, len(params), reserved)
137 return packed_data + params
143 ,'User-Agent: NSPlayer/7.10.0.3059 '
145 ,'Connection: Close '
150 for m in self.headers:
151 self.sendmsg += m + '\n'
152 self.sendmsg += '\n\n'
154 def request(self, host, port=80, location='/'):
155 sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
156 sock.connect((host, port))
157 sock.send(self.sendmsg%(location, host))
159 print self.sendmsg%(location, host)
162 res = sock.recv(1024)
168 def parse(self, data):
169 for d in data.splitlines():
170 if d.startswith('Location: '):
174 def getLocationData(self, url):
175 url_list,host,location = None,None,None
177 url = url[url.find(':')+3:]
178 url_list = url.split('/')
180 location = url[len(url_list[0]):]
181 except Exception, err_msg:
184 html = self.request(host=host, location=location)
185 return self.parse(html)
190 "OP_UNKNOWN" : 0x0000
191 ,"OP_HBBTV_EXIT" : 0x0001
192 ,"OP_HBBTV_OPEN_URL" : 0x0002
193 ,"OP_HBBTV_LOAD_AIT" : 0x0003
194 ,"OP_HBBTV_UNLOAD_AIT" : 0x0004
195 ,"OP_HBBTV_FULLSCREEN" : 0x0005
196 ,"OP_HBBTV_TITLE" : 0x0006
197 ,"OP_HBBTV_RETRY_OPEN_URL" : 0x0009
198 ,"OP_HBBTV_CHANGE_CHANNEL" : 0x000A
199 ,"OP_OIPF_GET_CHANNEL_INFO_URL" : 0x0101
200 ,"OP_OIPF_GET_CHANNEL_INFO_AIT" : 0x0102
201 ,"OP_OIPF_GET_CHANNEL_INFO_LIST": 0x0103
202 ,"OP_VOD_URI" : 0x0201
203 ,"OP_VOD_PLAY" : 0x0202
204 ,"OP_VOD_STOP" : 0x0203
205 ,"OP_VOD_PAUSE" : 0x0204
206 ,"OP_VOD_STATUS" : 0x0205
207 ,"OP_VOD_FORBIDDEN" : 0x0206
208 ,"OP_VOD_STOPED" : 0x0207
209 ,"OP_VOD_SPEED_CTRL" : 0x0208
210 ,"OP_VOD_SEEK_CTRL" : 0x0209
211 ,"OP_BROWSER_OPEN_URL" : 0x0301
212 ,"OP_BROWSER_VKBD_REQ" : 0x0309
213 ,"OP_BROWSER_VKBD_RES" : 0x030A
214 ,"OP_BROWSER_VKBD_PASTE_REQ" : 0x030B
215 ,"OP_BROWSER_VKBD_PASTE_KEY" : 0x030C
216 ,"OP_BROWSER_VKBD_PASTE_MOUSE" : 0x030D
217 ,"OP_BROWSER_MENU_REQ" : 0x030E
218 ,"OP_BROWSER_MENU_RES" : 0x030F
219 ,"OP_BROWSER_NEED_RELOAD_KEYMAP": 0x0313
220 ,"OP_DVBAPP_VOL_UP" : 0x0401
221 ,"OP_DVBAPP_VOL_DOWN" : 0x0402
222 ,"OP_SYSTEM_OUT_OF_MEMORY" : 0x0501
223 ,"OP_SYSTEM_NOTIFY_MY_PID" : 0x0502
226 0x0000 : "OP_UNKNOWN"
227 ,0x0001 : "OP_HBBTV_EXIT"
228 ,0x0002 : "OP_HBBTV_OPEN_URL"
229 ,0x0003 : "OP_HBBTV_LOAD_AIT"
230 ,0x0004 : "OP_HBBTV_UNLOAD_AIT"
231 ,0x0005 : "OP_HBBTV_FULLSCREEN"
232 ,0x0006 : "OP_HBBTV_TITLE"
233 ,0x0009 : "OP_HBBTV_RETRY_OPEN_URL"
234 ,0x000A : "OP_HBBTV_CHANGE_CHANNEL"
235 ,0x0101 : "OP_OIPF_GET_CHANNEL_INFO_URL"
236 ,0x0102 : "OP_OIPF_GET_CHANNEL_INFO_AIT"
237 ,0x0103 : "OP_OIPF_GET_CHANNEL_INFO_LIST"
238 ,0x0201 : "OP_VOD_URI"
239 ,0x0202 : "OP_VOD_PLAY"
240 ,0x0203 : "OP_VOD_STOP"
241 ,0x0204 : "OP_VOD_PAUSE"
242 ,0x0205 : "OP_VOD_STATUS"
243 ,0x0206 : "OP_VOD_FORBIDDEN"
244 ,0x0207 : "OP_VOD_STOPED"
245 ,0x0208 : "OP_VOD_SPEED_CTRL"
246 ,0x0209 : "OP_VOD_SEEK_CTRL"
247 ,0x0301 : "OP_BROWSER_OPEN_URL"
248 ,0x0309 : "OP_BROWSER_VKBD_REQ"
249 ,0x030A : "OP_BROWSER_VKBD_RES"
250 ,0x030B : "OP_BROWSER_VKBD_PASTE_REQ"
251 ,0x030C : "OP_BROWSER_VKBD_PASTE_KEY"
252 ,0x030D : "OP_BROWSER_VKBD_PASTE_MOUSE"
253 ,0x030E : "OP_BROWSER_MENU_REQ"
254 ,0x030F : "OP_BROWSER_MENU_RES"
255 ,0x0313 : "OP_BROWSER_NEED_RELOAD_KEYMAP"
256 ,0x0401 : "OP_DVBAPP_VOL_UP"
257 ,0x0402 : "OP_DVBAPP_VOL_DOWN"
258 ,0x0501 : "OP_SYSTEM_OUT_OF_MEMORY"
259 ,0x0502 : "OP_SYSTEM_NOTIFY_MY_PID"
262 def get(self, opstr):
264 return self._opcode_[opstr]
266 return self._opcode_["OP_UNKNOWN"]
268 def what(self, opcode):
270 return self._opstr_[opcode]
272 return self._opstr_["0x0000"]
285 def __init__(self, params):
286 self._protocol = params.protocol
287 self._type = params.type
288 self._addr = params.addr
289 self._buf_size = params.buf_size
290 self._handler = params.handler
291 self._timeout = params.timeout
292 self._destroy = params.destroy
294 self._terminated = False
295 self._server_thread = None
297 self.onHbbTVCloseCB = []
298 self.onSetPageTitleCB = []
301 if self._destroy is not None:
302 self._destroy(self._addr)
305 self._terminated = True
306 if self._server_thread is not None:
307 self._server_thread.join()
308 self._server_thread = None
311 self._socket = socket.socket(self._protocol, self._type)
312 self._socket.settimeout(self._timeout)
313 self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
314 self._socket.bind(self._addr)
315 self._socket.listen(True)
317 self._server_thread = threading.Thread(target=self._listen)
318 self._server_thread.start()
321 select_list = [self._socket]
324 conn, addr = self._socket.accept()
325 self._client(conn, addr)
326 except Exception, ErrMsg:
327 print "ServerSocket Error >>", ErrMsg
330 while not self._terminated:
331 readable, writable, errored = select.select(select_list, [], [], self._timeout)
333 if s is self._socket:
336 def _client(self, conn, addr):
339 received_data = conn.recv(self._buf_size)
340 if self._handler is not None and not strIsEmpty(received_data):
341 send_data = self._handler.doHandle(received_data, self.onHbbTVCloseCB, self.onSetPageTitleCB)
342 self._send(conn, send_data)
343 except Exception, ErrMsg:
346 if self._handler is not None:
347 self._handler.printError(ErrMsg)
348 def _send(self, conn, data) :
353 def doListenUnixTCP(self, name, handler):
357 if os.path.exists(name):
359 print "Removed ", name
363 params = SocketParams()
364 params.protocol = socket.AF_UNIX
365 params.type = socket.SOCK_STREAM
367 params.handler = handler
368 params.destroy = destroy
370 streamServer = StreamServer(params)
374 def doListenInetTCP(self, ip, port, handler):
375 print "Not implemented yet!!"
376 def doListenUnixDGRAM(self, name, handler):
377 print "Not implemented yet!!"
378 def doListenInetDGRAM(self, ip, port, handler):
379 print "Not implemented yet!!"
382 def doUnpack(self, data):
385 def doPack(self, opcode, params, reserved=0):
386 return _pack(opcode, params, reserved)
388 def doHandle(self, data, onCloseCB):
389 opcode, params = 0x0, 'Invalid Request!!'
390 return _pack(opcode, params)
392 def printError(self, reason):
395 class BrowserCommandUtil(OpCodeSet):
398 OpCodeSet.__init__(self)
400 def isConnected(self):
405 def doConnect(self, filename):
406 if not os.path.exists(filename):
407 print "File not exists :", filename
410 self._fd = os.open(filename, os.O_WRONLY|os.O_NONBLOCK)
412 print "Fail to open file :", filename
414 except Exception, ErrMsg:
420 def doDisconnect(self):
426 def doSend(self, command, params=None, reserved=0):
428 print "No found pipe!!"
432 data = _pack(self.get(command), params, reserved)
435 os.write(self._fd, data)
436 print "Send OK!! :", command
440 def sendCommand(self, command, params=None, reserved=0):
441 if not self.isConnected():
443 self.doConnect(COMMAND_PATH)
444 result = self.doSend(command, params, reserved)
448 class HandlerHbbTV(Handler):
450 def __init__(self, session):
451 self._session = session
452 self.opcode = OpCodeSet()
454 0x0001 : self._cb_handleCloseHbbTVBrowser
455 ,0x0006 : self._cb_handleSetPageTitle
456 ,0x0009 : self._cb_handleHbbTVRetryOpen
457 ,0x000A : self._cb_handleHbbTVChangeChannel
458 ,0x0101 : self._cb_handleGetChannelInfoForUrl
459 ,0x0102 : self._cb_handleGetChannelInfoForAIT
460 ,0x0103 : self._cb_handleGetChannelInfoList
461 ,0x0201 : self._cb_handleVODPlayerURI
462 ,0x0202 : self._cb_handleVODPlayerPlay
463 ,0x0203 : self._cb_handleVODPlayerStop
464 ,0x0204 : self._cb_handleVODPlayerPlayPause
465 ,0x0401 : self._cb_handleDVBAppVolUp
466 ,0x0402 : self._cb_handleDVBAppVolDown
467 ,0x0208 : self._cb_handleVODSpeedCtrl
468 ,0x0209 : self._cb_handleVODSeekCtrl
469 ,0x0501 : self._cb_handleSystemOutOfMemory
470 ,0x0502 : self._cb_handleSystemNotufyMyPID
471 ,0x0309 : self._cb_handleShowVirtualKeyboard
472 ,0x030B : self._cb_handlePasteVirtualKeyboard
473 ,0x030E : self._cb_handleBrowserMenuReq
475 self._on_close_cb = None
476 self._on_set_title_cb = None
480 self._retry_open_url = None
481 self._timer_retry_open = eTimer()
482 self._timer_paste_vkbd = eTimer()
483 self._curren_title = None
485 def _handle_dump(self, handle, opcode, data=None):
489 print " - opcode : ", self.opcode.what(opcode)
491 print " - data : ", data
493 def doHandle(self, data, onCloseCB, onSetPageTitleCB):
494 opcode, params, reserved = None, None, 0
495 self._on_close_cb = onCloseCB
496 self._on_set_title_cb = onSetPageTitleCB
498 datas = self.doUnpack(data)
499 except Exception, ErrMsg:
500 print "Unpacking packet ERR :", ErrMsg
501 params = 'fail to unpack packet!!'
502 opcode = self.opcode.get("OP_UNKNOWN")
503 return self.doPack(opcode, params)
507 self.opcode.what(opcode)
510 #print self.handle_map[opcode]
511 (reserved, params) = self.handle_map[opcode](opcode, params)
512 except Exception, ErrMsg:
513 print "Handling packet ERR :", ErrMsg
514 params = 'fail to handle packet!!'
515 opcode = self.opcode.get("OP_UNKNOWN")
516 return self.doPack(opcode, params)
517 self._on_close_cb = None
518 self._on_set_title_cb = None
519 return self.doPack(opcode, params, reserved)
521 def _cb_handleHbbTVChangeChannel(self, opcode, data):
522 self._handle_dump(self._cb_handleHbbTVChangeChannel, opcode, data)
524 if _g_helper is None:
526 dataItems = data.split(":")
529 if not _g_helper.doChangeChannel(sid, tsid):
533 def _cb_handleBrowserMenuReq(self, opcode, data):
534 self._handle_dump(self._cb_handleBrowserMenuReq, opcode, data)
535 fbClass.getInstance().unlock()
536 eRCInput.getInstance().unlock()
537 browser = getPluginBrowser()
538 if browser is not None:
539 browser.setCurrentPageUrl(data, self._curren_title)
542 def _cb_handlePasteVirtualKeyboard(self, opcode, data):
543 self._handle_dump(self._cb_handlePasteVirtualKeyboard, opcode, data)
544 def _cb_PasteRefocusVirtualKeyboard():
545 self._timer_paste_vkbd.stop()
546 command_util = getCommandUtil()
547 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
549 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
551 def _cb_PasteKeyVirtualKeyboard():
552 self._timer_paste_vkbd.stop()
553 command_util = getCommandUtil()
554 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_KEY')
556 self._timer_paste_vkbd.callback.remove(_cb_PasteKeyVirtualKeyboard)
558 self._timer_paste_vkbd.callback.append(_cb_PasteRefocusVirtualKeyboard)
559 self._timer_paste_vkbd.start(100)
560 def _cb_PasteMouseVirtualKeyboard():
561 self._timer_paste_vkbd.stop()
562 command_util = getCommandUtil()
563 command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
565 #command_util.sendCommand('OP_BROWSER_VKBD_PASTE_MOUSE')
567 self._timer_paste_vkbd.callback.remove(_cb_PasteMouseVirtualKeyboard)
569 #self._timer_paste_vkbd.callback.append(_cb_PasteKeyVirtualKeyboard)
570 #self._timer_paste_vkbd.start(1000)
571 self._timer_paste_vkbd.callback.append(_cb_PasteMouseVirtualKeyboard)
572 self._timer_paste_vkbd.start(50)
575 def _cb_virtualKeyboardClosed(self, data=None):
576 fbClass.getInstance().lock()
577 eRCInput.getInstance().lock()
578 command_util = getCommandUtil()
579 command_util.sendCommand('OP_BROWSER_VKBD_RES', data)
580 def _cb_handleShowVirtualKeyboard(self, opcode, data):
581 self._handle_dump(self._cb_handleShowVirtualKeyboard, opcode, data)
582 fbClass.getInstance().unlock()
583 eRCInput.getInstance().unlock()
584 if data == 0 or strIsEmpty(data):
586 self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text=data)
589 def _cb_handleVODSeekCtrl(self, opcode, data):
590 self._handle_dump(self._cb_handleVODSeekCtrl, opcode, data)
591 headLen = struct.calcsize('!I')
592 unpackedData = struct.unpack('!I', data[:headLen])
593 seekTime = unpackedData[0]
594 service = self._session.nav.getCurrentService()
595 seekable = service.seek()
596 if seekable is None or not seekable.isCurrentlySeekable():
597 raise Exception("This stream is not support manual seek.")
599 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
602 def _cb_handleHbbTVRetryOpen(self, opcode, data):
603 def _cb_HbbTVRetryOpenURL():
604 self._timer_retry_open.stop()
605 if self._retry_open_url is not None:
606 command_util = getCommandUtil()
607 command_util.sendCommand('OP_HBBTV_RETRY_OPEN_URL', params=self._retry_open_url)
608 self._retry_open_url = None
610 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
612 self._handle_dump(self._cb_handleHbbTVRetryOpen, opcode, data)
613 headLen = struct.calcsize('!I')
614 unpackedData = struct.unpack('!I', data[:headLen])
615 delayTime = unpackedData[0]
616 restartUrl = data[headLen:]
618 self._retry_open_url = restartUrl.strip()
619 self._timer_retry_open.callback.append(_cb_HbbTVRetryOpenURL)
620 self._timer_retry_open.start(delayTime*1000)
623 def _cb_handleSystemNotufyMyPID(self, opcode, data):
624 self._handle_dump(self._cb_handleSystemNotufyMyPID, opcode, data)
627 def _cb_handleSystemOutOfMemory(self, opcode, data):
628 self._handle_dump(self._cb_handleSystemOutOfMemory, opcode, data)
632 def _cb_handleVODSpeedCtrl(self, opcode, data):
633 self._handle_dump(self._cb_handleVODSpeedCtrl, opcode, data)
634 headLen = struct.calcsize('!I')
635 unpackedData = struct.unpack('!I', data[:headLen])
636 playSpeed = unpackedData[0]
637 service = self._session.nav.getCurrentService()
638 pauseable = service.pause()
641 if pauseable.setFastForward(playSpeed) == -1:
642 pauseable.setFastForward(1)
643 raise Exception("This stream is not support trick play.")
646 def _cb_handleDVBAppVolUp(self, opcode, data):
647 self._handle_dump(self._cb_handleDVBAppVolUp, opcode, data)
648 vcm = VolumeControl.instance
652 def _cb_handleDVBAppVolDown(self, opcode, data):
653 self._handle_dump(self._cb_handleDVBAppVolDown, opcode, data)
654 vcm = VolumeControl.instance
658 def _cb_handleGetChannelInfoForUrl(self, opcode, data):
659 self._handle_dump(self._cb_handleGetChannelInfoForUrl, opcode, data)
660 (sid, onid, tsid, name, orgid) = getChannelInfos()
662 return (0, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
664 def _cb_handleGetChannelInfoForAIT(self, opcode, data):
665 self._handle_dump(self._cb_handleGetChannelInfoForAIT, opcode, data)
666 (sid, onid, tsid, name, orgid) = getChannelInfos()
668 return (0, struct.pack('!IIIII', orgid, sid, onid, tsid, namelen) + name)
670 def _cb_handleGetChannelInfoList(self, opcode, data):
671 self._handle_dump(self._cb_handleGetChannelInfoList, opcode, data)
672 (sid, onid, tsid, name, orgid) = getChannelInfos()
674 channel_list_size = 1
675 return (channel_list_size, struct.pack('!IIII', sid, onid, tsid, namelen) + name)
677 def _cb_handleSetPageTitle(self, opcode, data):
678 self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
679 if data.startswith('file://') or data.startswith('http://'):
681 if self._on_set_title_cb is not None:
682 for x in self._on_set_title_cb:
685 self._curren_title = data
686 except Exception, ErrMsg:
687 if x in self._on_set_title_cb:
688 self._on_set_title_cb.remove(x)
691 def _cb_handleCloseHbbTVBrowser(self, opcode, data):
692 self._timer_retry_open.stop()
694 self._timer_retry_open.callback.remove(_cb_HbbTVRetryOpenURL)
696 self._handle_dump(self._cb_handleCloseHbbTVBrowser, opcode, data)
698 if self._on_close_cb:
699 for x in self._on_close_cb:
702 except Exception, ErrMsg:
703 if x in self._on_close_cb:
704 self._on_close_cb.remove(x)
706 command_util = getCommandUtil()
707 command_util.sendCommand('OP_HBBTV_FULLSCREEN', None)
709 before_service = getBeforeService()
710 if before_service is not None:
711 self._session.nav.playService(before_service)
715 def _cb_handleVODPlayerURI(self, opcode, data):
717 hl = struct.calcsize('!II')
718 datas = struct.unpack('!II', data[:hl])
720 vodUri = data[hl:hl+uriLength]
721 self._handle_dump(self._cb_handleVODPlayerURI, opcode, vodUri)
722 self._vod_uri = vodUri
725 def doStop(self, restoreBeforeService=True, needStop=True):
727 self._session.nav.stopService()
728 if self._vod_service is not None and restoreBeforeService:
729 before_service = getBeforeService()
730 self._session.nav.playService(before_service)
732 self._vod_service = None
737 def doRetryOpen(self, url):
741 self._vod_service = None
743 print "Try to open vod [%d] : %s" % (ii, url)
744 self._vod_service = eServiceReference(4097, 0, url)
745 self._session.nav.playService(self._vod_service)
746 if self._vod_service is not None:
748 except Exception, ErrMsg:
749 print "OpenVOD ERR :", ErrMsg
753 def _cb_handleVODPlayerPlay(self, opcode, data):
754 self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
755 self.doStop(restoreBeforeService=False)
756 if self.doRetryOpen(url=self._vod_uri) == False:
760 def _cb_handleVODPlayerStop(self, opcode, data):
761 self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
765 def _cb_handleVODPlayerPlayPause(self, opcode, data):
766 self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
767 service = self._session.nav.getCurrentService()
770 servicePause = service.pause()
772 servicePause.unpause()
773 elif pauseFlag == 'P':
775 except Exception, ErrMsg:
776 print "onPause ERR :", ErrMsg
779 from libshm import SimpleSharedMemory
781 class HbbTVWindow(Screen, InfoBarNotifications):
783 <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
786 def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
787 self._session = session
788 fbClass.getInstance().lock()
789 eRCInput.getInstance().lock()
791 Screen.__init__(self, session)
792 InfoBarNotifications.__init__(self)
793 self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
794 iPlayableService.evUser+20: self._serviceForbiden,
795 iPlayableService.evStart: self._serviceStarted,
796 iPlayableService.evEOF: self._serviceEOF,
800 self._use_ait = useAIT
801 self._profile = profile
802 self._cb_closed_func = cbf
803 self.onLayoutFinish.append(self._layoutFinished)
805 command_server = getCommandServer()
806 if self._cb_set_page_title not in command_server.onSetPageTitleCB:
807 command_server.onSetPageTitleCB.append(self._cb_set_page_title)
809 if self._cb_close_window not in command_server.onHbbTVCloseCB:
810 command_server.onHbbTVCloseCB.append(self._cb_close_window)
812 self._closeTimer = eTimer()
813 self._closeTimer.callback.append(self._do_close)
815 self._currentServicePositionTimer = eTimer()
816 self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
823 def getVodPlayTime(self):
825 service = self._session.nav.getCurrentService()
826 seek = service and service.seek()
828 p = seek.getPlayPosition()
829 #return (p[1]/90000, l[1]/90000)
834 def _cb_currentServicePosition(self):
835 def getTimeString(t):
836 t = time.localtime(t/90000)
837 return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
838 position,length = 0,0
840 (position,length) = self.getVodPlayTime()
841 self._vod_length = length
842 if position == -1 and length == -1:
843 raise Exception("Can't get play status")
844 #print getTimeString(position), "/", getTimeString(length)
845 self._ssm.setStatus(position, length, 1)
846 except Exception, ErrMsg:
850 def _serviceStarted(self):
852 self._ssm.setStatus(0, 0, 0)
853 self._currentServicePositionTimer.start(1000)
854 except Exception, ErrMsg:
857 def _serviceEOF(self):
858 (position,length) = self.getVodPlayTime()
859 self._ssm.setStatus(length, length, 1)
861 self._currentServicePositionTimer.stop()
863 def _layoutFinished(self):
864 self.setTitle(_('HbbTV Plugin'))
865 command_util = getCommandUtil()
866 profile = self._profile
867 (sid, onid, tsid, name, orgid) = getChannelInfos()
868 params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
870 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
872 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
874 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
876 command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
878 def _cb_close_window(self):
879 self._closeTimer.start(1000)
882 self._closeTimer.stop()
883 command_server = getCommandServer()
885 if self._cb_set_page_title in command_server.onSetPageTitleCB:
886 command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
887 except Exception, ErrMsg: pass
889 if self._cb_close_window in command_server.onHbbTVCloseCB:
890 command_server.onHbbTVCloseCB.remove(self._cb_close_window)
891 except Exception, ErrMsg: pass
893 if self._cb_closed_func is not None:
894 self._cb_closed_func()
896 fbClass.getInstance().unlock()
897 eRCInput.getInstance().unlock()
900 def _serviceForbiden(self):
902 real_url = MMSStreamURL().getLocationData(__gval__.hbbtv_handelr.getUrl())
903 print "Received URI :\n", real_url
905 if real_url is not None:
906 __gval__.hbbtv_handelr.doRetryOpen(real_url.strip())
908 def _cb_set_page_title(self, title=None):
909 print "page title :",title
914 class HbbTVHelper(Screen):
915 skin = """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
916 def __init__(self, session):
918 __gval__.hbbtv_handelr = HandlerHbbTV(session)
919 __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
924 self._restart_opera()
926 Screen.__init__(self, session)
927 self._session = session
928 self._timer_infobar = eTimer()
929 self._timer_infobar.callback.append(self._cb_registrate_infobar)
930 self._timer_infobar.start(1000)
932 self._excuted_browser = False
935 __gval__.command_util = BrowserCommandUtil()
939 _g_ssm_ = SimpleSharedMemory()
942 def _cb_registrate_infobar(self):
944 self._timer_infobar.stop()
945 if self._cb_ready_for_ait not in InfoBar.instance.onReadyForAIT:
946 InfoBar.instance.onReadyForAIT.append(self._cb_ready_for_ait)
947 if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
948 InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
950 def _cb_ready_for_ait(self, orgId=0):
952 if not self._excuted_browser:
953 command_util = getCommandUtil()
954 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
956 setChannelInfo(None, None, None, None, None)
958 service = self._session.nav.getCurrentService()
959 info = service and service.info()
961 sid = info.getInfo(iServiceInformation.sSID)
962 onid = info.getInfo(iServiceInformation.sONID)
963 tsid = info.getInfo(iServiceInformation.sTSID)
964 name = info.getName()
969 for x in info.getInfoObject(iServiceInformation.sHBBTVUrl):
973 setChannelInfo(sid, onid, tsid, name, orgid)
975 def _cb_hbbtv_activated(self, title=None, url=None):
976 if not self._is_browser_running():
977 message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
978 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
980 service = self._session.nav.getCurrentlyPlayingServiceReference()
981 setBeforeService(service)
982 self._start_hbbtv_application(title, url)
984 def _start_hbbtv_application(self, title, url):
986 tmp_url = self.getStartHbbTVUrl()
990 print "can't get url of hbbtv!!"
992 print "success to get url of hbbtv!! >>", url
993 if self._excuted_browser:
994 print "already excuted opera browser!!"
998 self._restart_opera()
1000 setNeedRestart(False)
1002 for x in self._urls:
1005 if tmp_url == url and control_code == 1:
1007 self._excuted_browser = True
1008 self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
1010 def _cb_closed_browser(self):
1011 self._excuted_browser = False
1013 def _start_opera(self):
1014 if not self._is_browser_running():
1015 global HBBTVAPP_PATH
1016 start_command = '%s/launcher start'%(HBBTVAPP_PATH)
1017 os.system(start_command)
1019 def _stop_opera(self):
1020 global HBBTVAPP_PATH
1021 try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
1024 def _restart_opera(self):
1025 global HBBTVAPP_PATH
1026 try: os.system('%s/launcher restart'%(HBBTVAPP_PATH))
1029 def getStartHbbTVUrl(self):
1030 url, self._urls, self._profile = None, None, 0
1031 service = self._session.nav.getCurrentService()
1032 info = service and service.info()
1033 if not info: return None
1034 self._urls = info.getInfoObject(iServiceInformation.sHBBTVUrl)
1035 for u in self._urls:
1036 if u[0] in (1, -1): # 0:control code, 1:name, 2:url, 3:orgid, 4:appid, 5:profile code
1038 self._profile = u[5]
1040 url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1043 def showApplicationSelectionBox(self):
1046 if self.getStartHbbTVUrl():
1047 for x in self._urls:
1048 applications.append((x[1], x))
1049 else: applications.append((_("No detected HbbTV applications."), None))
1050 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1052 def _application_selected(self, selected):
1054 if selected[1] is None: return
1055 self._cb_hbbtv_activated(selected[1][1], selected[1][2])
1056 except Exception, ErrMsg: print ErrMsg
1058 def showBrowserConfigBox(self):
1059 start_stop_mode = []
1060 if self._is_browser_running():
1061 start_stop_mode.append((_('Stop'),'Stop'))
1062 else: start_stop_mode.append((_('Start'),'Start'))
1063 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1065 def _browser_config_selected(self, selected):
1066 if selected is None:
1071 if not self._is_browser_running():
1073 elif mode == 'Stop':
1075 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1077 def _is_browser_running(self):
1079 global HBBTVAPP_PATH
1080 ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1081 return ret.strip() != "0"
1082 except Exception, ErrMsg:
1083 print "Check Browser Running ERR :", ErrMsg
1086 def doChangeChannel(self, _sid, _tsid):
1087 root = eServiceReference(service_types_tv)
1090 serviceList = eServiceCenter.getInstance().list(root)
1091 if serviceList is None:
1094 service = serviceList.getNext()
1095 if service is None or not service.valid():
1098 #1:0:19:2840:3FB:1:C00000:0:0:0:
1099 serviceRef = service.toString()
1100 if strIsEmpty(serviceRef):
1102 serviceRefItems = serviceRef.split(":")
1103 if len(serviceRefItems) < 5:
1106 sid = serviceRefItems[3]
1107 tsid = serviceRefItems[4]
1108 if sid == _sid and tsid == _tsid:
1109 self._session.nav.playService(eServiceReference(serviceRef))
1110 service = self._session.nav.getCurrentlyPlayingServiceReference()
1111 setBeforeService(service)
1115 class OperaBrowserSetting:
1117 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1123 f = open(self._settingFileName)
1124 for line in f.readlines():
1125 if line.startswith('start='):
1126 tmp = line[6:len(line)-1].split()
1127 self._start = tmp[0]
1129 self._type = int(tmp[1])
1130 else: self._type = 0
1131 elif line.startswith('keymap='):
1132 self._keymap = line[7:len(line)-1]
1136 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1137 tmpstr.append('keymap=%s\n' % (self._keymap))
1138 f = open(self._settingFileName, 'w')
1139 f.writelines(tmpstr)
1141 def setData(self, start, types=0, keymap="us-rc"):
1144 self._keymap = keymap
1148 'start':self._start,
1150 'keymap':self._keymap,
1153 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1155 <screen position="center,center" size="600,350" title="Preference">
1156 <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1157 <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1159 <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1160 <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1162 <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" />
1163 <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" />
1166 def __init__(self, session, currentUrl):
1167 self.session = session
1168 Screen.__init__(self, session)
1171 ConfigListScreen.__init__(self, self.menulist)
1173 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1174 "red" : self.keyRed,
1175 "green" : self.keyGreen,
1177 "cancel" : self.keyRed
1179 self["key_red"] = StaticText(_("Cancel"))
1180 self["key_green"] = StaticText(_("Save"))
1181 self["url"] = Label()
1183 self._currentPageUrl = currentUrl
1184 if self._currentPageUrl is None:
1185 self._currentPageUrl = ''
1186 self._startPageUrl = None
1187 self._keymapType = None
1188 self.makeMenuEntry()
1189 self.onLayoutFinish.append(self.layoutFinished)
1191 def layoutFinished(self):
1192 self.setTitle(_('Preference'))
1194 def updateStartPageUrl(self):
1195 if self.menuItemStartpage.value == "startpage":
1196 self["url"].setText(self._startPageUrl)
1197 elif self.menuItemStartpage.value == "current":
1198 self["url"].setText(self._currentPageUrl)
1199 elif self.menuItemStartpage.value == "direct":
1200 self["url"].setText('')
1203 url = self["url"].getText()
1205 self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1208 if url.find('/usr/local/manual') > 0:
1210 self._keymapType = self.menuItemKeyboardLayout.value
1211 OperaBrowserSetting().setData(url, mode, self._keymapType)
1212 command_util = getCommandUtil()
1213 command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
1220 def _cb_directInputUrl(data):
1221 if strIsEmpty(data):
1223 self["url"].setText(data)
1224 if self.menuItemStartpage.value == "direct":
1225 self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1228 ConfigListScreen.keyLeft(self)
1229 self.updateStartPageUrl()
1232 ConfigListScreen.keyRight(self)
1233 self.updateStartPageUrl()
1235 def getKeymapTypeList(self):
1237 for f in os.listdir("/usr/local/hbb-browser/keymap"):
1238 filesplit = f.split('.')
1239 if len(filesplit) < 2:
1241 types.append((filesplit[1], filesplit[1]))
1245 def makeMenuEntry(self):
1247 l.append(("startpage", _("Start Page")))
1248 if not strIsEmpty(self._currentPageUrl):
1249 l.append(("current", _("Current Page")))
1250 l.append(("direct", _("Direct Input")))
1251 self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
1252 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1254 kl = self.getKeymapTypeList()
1257 d = OperaBrowserSetting().getData()
1258 self._startPageUrl = d['start']
1259 self._keymapType = d['keymap']
1261 except: self._startPageUrl = 'http://vuplus.com'
1262 self.updateStartPageUrl()
1264 if self._keymapType is None or len(self._keymapType) == 0:
1265 self._keymapType = "us-rc"
1266 self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
1267 self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
1268 self.resetMenuList()
1270 def resetMenuList(self):
1272 self.menulist.append(self.menuEntryStartpage)
1273 self.menulist.append(self.menuEntryKeyboardLayout)
1275 self["config"].list = self.menulist
1276 self["config"].l.setList(self.menulist)
1278 class BookmarkEditWindow(ConfigListScreen, Screen):
1279 CATEGORY,BOOKMARK = 0,1
1281 <screen position="center,center" size="600,140" title="Bookmark Edit">
1282 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1284 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1285 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1287 <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" />
1288 <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" />
1290 <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1294 def __init__(self, session, _mode, _type, _data, _bm):
1298 self.mSession = session
1299 self.mBookmarkManager = _bm
1301 if _data is not None:
1304 Screen.__init__(self, session)
1307 ConfigListScreen.__init__(self, self.menulist)
1309 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1310 "ok" : self.keyGreen,
1311 "green" : self.keyGreen,
1312 "red" : self.keyRed,
1313 "cancel" : self.keyRed,
1316 self["VKeyIcon"] = Pixmap()
1317 self["key_red"] = StaticText(_("Cancel"))
1318 self["key_green"] = StaticText(_("Save"))
1320 self.menuItemTitle = None
1321 self.menuItemUrl = None
1322 self.menuItemName = None
1324 self.menuEntryName = None
1325 self.menuEntryTitle = None
1326 self.menuEntryUrl = None
1328 self.makeConfigList()
1329 self.onLayoutFinish.append(self.layoutFinished)
1331 def layoutFinished(self):
1332 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1334 def selectedItem(self):
1335 currentPosition = self["config"].getCurrent()
1336 if self.mType == BookmarkEditWindow.CATEGORY:
1337 return (_("Name"), self.menuItemName)
1339 if currentPosition == self.menuEntryTitle:
1340 return (_("Title"), self.menuItemTitle)
1341 elif currentPosition == self.menuEntryUrl:
1342 return (_("Url"), self.menuItemUrl)
1345 def showMessageBox(self, text):
1346 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
1347 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1350 def showVKeyWindow(self, data=None):
1353 selected = self.selectedItem()
1354 if selected is not None:
1355 itemValue = selected[1].value
1356 if strIsEmpty(itemValue):
1358 itemTitle = selected[0]
1360 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1362 def cbVKeyWindow(self, data=None):
1363 if data is not None:
1364 selected = self.selectedItem()
1365 if selected is not None:
1366 selected[1].setValue(data)
1369 if self.mType == BookmarkEditWindow.CATEGORY:
1370 if self.mMode == _('Add'):
1371 categoryName = self.menuItemName.value
1372 if strIsEmpty(categoryName):
1373 return self.showMessageBox(_("Category Name"))
1374 self.mBookmarkManager.addCategory(categoryName)
1376 if strIsEmpty(self.menuItemName.value):
1377 return self.showMessageBox(_("Category Name"))
1378 self.mData.mName = self.menuItemName.value
1379 self.mBookmarkManager.updateCategory(self.mData)
1381 if self.mMode == _('Add'):
1382 bookmarkTitle = self.menuItemTitle.value
1383 bookmarkUrl = self.menuItemUrl.value
1384 if strIsEmpty(bookmarkTitle):
1385 self["config"].setCurrentIndex(0)
1386 return self.showMessageBox(_("Bookmark Title"))
1387 if strIsEmpty(bookmarkUrl):
1388 self["config"].setCurrentIndex(1)
1389 return self.showMessageBox(_("Bookmark URL"))
1390 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1392 if strIsEmpty(self.menuItemTitle.value):
1393 self["config"].setCurrentIndex(0)
1394 return self.showMessageBox(_("Bookmark Title"))
1395 if strIsEmpty(self.menuItemUrl.value):
1396 self["config"].setCurrentIndex(1)
1397 return self.showMessageBox(_("Bookmark URL"))
1398 self.mData.mTitle = self.menuItemTitle.value
1399 self.mData.mUrl = self.menuItemUrl.value
1400 self.mBookmarkManager.updateBookmark(self.mData)
1404 if not self.saveData():
1410 ConfigListScreen.keyLeft(self)
1412 ConfigListScreen.keyRight(self)
1413 def makeConfigList(self):
1416 if self.mType == BookmarkEditWindow.CATEGORY:
1417 self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1419 self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
1421 self.menulist.append(self.menuEntryName)
1423 self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1424 self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1426 self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1427 self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
1429 self.menulist.append(self.menuEntryTitle)
1430 self.menulist.append(self.menuEntryUrl)
1432 self["config"].list = self.menulist
1433 self["config"].l.setList(self.menulist)
1435 class OperaBrowserBookmarkWindow(Screen):
1437 <screen name="HbbTVBrowserBookmarkWindow" position="center,center" size="600,400" title="Bookmark" >
1438 <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1440 <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1441 <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1443 <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1444 <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1445 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1446 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1448 <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" />
1449 <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" />
1450 <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" />
1451 <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" />
1455 def __init__(self, _session, _url=None, _title=None):
1457 self.mTitle = _title
1458 self.mBookmarkManager = BookmarkManager.getInstance()
1459 self.mSession = _session
1460 Screen.__init__(self, _session)
1461 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1463 "cancel": self.keyCancel,
1464 "red" : self.keyRed,
1465 "green" : self.keyGreen,
1466 "yellow": self.keyYellow,
1467 "blue" : self.keyBlue,
1468 "0" : self.keyNumber,
1471 self["key_red"] = StaticText(_("Exit"))
1472 self["key_green"] = StaticText(_("Add"))
1473 self["key_yellow"] = StaticText(_("Edit"))
1474 self["key_blue"] = StaticText(_("Delete"))
1475 self["key_0"] = StaticText(_("Set as Startpage"))
1477 self.mBookmarkList = self.setBookmarkList()
1478 self["bookmarklist"] = MenuList(self.mBookmarkList)
1480 self.onLayoutFinish.append(self.layoutFinished)
1482 def layoutFinished(self):
1483 self.setTitle(_('Bookmark'))
1485 def setBookmarkList(self):
1487 #self.mBookmarkManager.dump()
1488 cd = self.mBookmarkManager.getBookmarkRoot()
1489 for ck in cd.iterkeys():
1490 l.append(('# ' + cd[ck].mName, cd[ck]))
1491 bd = cd[ck].mBookmarks
1492 for bk in bd.iterkeys():
1493 l.append((' - ' + bd[bk].mTitle, bd[bk]))
1495 def updateBookmarkList(self):
1496 self.mBookmarkList = self.setBookmarkList()
1497 self["bookmarklist"].setList(self.mBookmarkList)
1498 def cbEditWindow(self, ret=False):
1501 self.updateBookmarkList()
1502 def getParentCategory(self):
1503 idx = self["bookmarklist"].getSelectedIndex()
1506 data = self.mBookmarkList[idx][0].strip()
1508 return self.mBookmarkList[idx][1]
1512 def isCategoryItem(self):
1514 head = self["bookmarklist"].getCurrent()[0].strip()
1519 def keyNumber(self):
1520 data = self["bookmarklist"].getCurrent()[1]
1521 if strIsEmpty(data.mUrl):
1522 msg = _("Invalid URL. Please check again!!")
1523 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1525 def cbSetStartpage(ret=None):
1526 if ret is None: return
1528 data = self["bookmarklist"].getCurrent()[1]
1529 OperaBrowserSetting().setData(data.mUrl, data.mType)
1530 msg = _("Do you want to set selected url to the Startpage?")
1531 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1538 parent = self.getParentCategory()
1541 if strIsEmpty(self.mTitle):
1543 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1545 msg = _("Current page is already exist.")
1546 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1547 self.cbEditWindow(True)
1549 parent = self.getParentCategory()
1552 b = BookmarkData(0, '', '', parent.mId, 0)
1553 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1555 c = CategoryData(0, '')
1556 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1557 if strIsEmpty(self.mUrl):
1558 l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1559 else: l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1560 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1561 def keyYellow(self):
1562 data = self["bookmarklist"].getCurrent()[1]
1563 if self.isCategoryItem():
1564 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1565 else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1567 def cbBlue(ret=None):
1569 data = self["bookmarklist"].getCurrent()[1]
1570 if self.isCategoryItem():
1571 self.mBookmarkManager.deleteCategory(data.mId)
1572 else: self.mBookmarkManager.deleteBookmark(data.mId)
1573 self.updateBookmarkList()
1574 if self.isCategoryItem():
1575 msg = _("Do you want to delete the category and the bookmarks?")
1576 else: msg = _("Do you want to delete the bookmark?")
1577 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1579 if self.isCategoryItem(): return
1581 data = self["bookmarklist"].getCurrent()[1]
1582 url = data.mUrl.strip()
1584 self.session.open(MessageBox, _("Can't open selected bookmark.\n - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1588 lang = language.getLanguage()
1589 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1590 url = '/usr/local/manual/ru_RU/main.html'
1591 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1592 url = '/usr/local/manual/de_DE/main.html'
1593 self.close((url, mode))
1596 def keyCancel(self):
1599 class BrowserHelpWindow(Screen, HelpableScreen):
1600 MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1602 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1603 <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1604 <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1605 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1606 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1608 <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" />
1609 <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" />
1610 <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" />
1611 <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" />
1614 def __init__(self, session):
1615 Screen.__init__(self, session)
1616 HelpableScreen.__init__(self)
1618 self["key_red"] = StaticText(_("Exit"))
1619 self["key_green"] = StaticText(_("Global"))
1620 self["key_yellow"] = StaticText(_("Mouse"))
1621 self["key_blue"] = StaticText(_("Keyboard"))
1623 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1625 "cancel": self.keyRed,
1626 "red" : self.keyRed,
1627 "green" : self.keyGreen,
1628 "yellow": self.keyYellow,
1629 "blue" : self.keyBlue,
1632 self.showHelpTimer = eTimer()
1633 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1634 self.showHelpTimer.start(500)
1636 self.onLayoutFinish.append(self.layoutFinished)
1638 def layoutFinished(self):
1639 self.setTitle(_('Browser Help'))
1641 def cbShowHelpTimerClosed(self):
1642 self.showHelpTimer.stop()
1643 self.setHelpModeActions(self.MODE_GLOBAL)
1645 def setHelpModeActions(self, _mode=0):
1647 if _mode == self.MODE_GLOBAL:
1648 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1649 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1651 self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1652 "menu" : (self.keyPass, _("Show the Menu window.")),
1654 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1655 "green" : (self.keyPass, _("Enter Key")),
1656 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1657 "blue" : (self.keyPass, _("Backspace Key")),
1659 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1660 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1663 elif _mode == self.MODE_MOUSE:
1664 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1665 "up" : (self.keyPass, _("It will move the mouse pointer up.")),
1666 "down" : (self.keyPass, _("It will move the mouse pointer down.")),
1667 "left" : (self.keyPass, _("It will move the mouse pointer left.")),
1668 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1670 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1671 "ok" : (self.keyPass, _("Left Mouse Button")),
1673 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1674 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1675 "nextService" : (self.keyPass, _("Left Key")),
1676 "prevService" : (self.keyPass, _("Right Key")),
1678 elif _mode == self.MODE_KEYBOARD:
1679 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1680 "up" : (self.keyPass, _("Up Key")),
1681 "down" : (self.keyPass, _("Down Key")),
1682 "left" : (self.keyPass, _("Left Key")),
1683 "right" : (self.keyPass, _("Right Key")),
1685 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1686 "ok" : (self.keyPass, _("Enter Key")),
1688 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1689 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1690 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1691 "nextService" : (self.keyPass, _("Go to previous page.")),
1692 "prevService" : (self.keyPass, _("Go to next page.")),
1704 self.setHelpModeActions(self.MODE_GLOBAL)
1705 def keyYellow(self):
1706 self.setHelpModeActions(self.MODE_MOUSE)
1708 self.setHelpModeActions(self.MODE_KEYBOARD)
1710 class OperaBrowser(Screen):
1711 MENUBAR_ITEM_WIDTH = 150
1712 MENUBAR_ITEM_HEIGHT = 30
1713 SUBMENULIST_WIDTH = 200
1714 SUBMENULIST_HEIGHT = 25
1715 SUBMENULIST_NEXT = 2
1718 <screen name="Opera Browser" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1719 <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1720 <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1721 <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1722 <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1723 <widget name="menulist" position="50,%d" size="%d,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1724 <widget name="submenulist" position="%d,%d" size="%d,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1725 <widget name="bottomArea" position="0,640" size="1280,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1727 """ % (MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH, SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT, MENUBAR_ITEM_HEIGHT+30, SUBMENULIST_WIDTH)# modify menu
1729 MENUITEMS_LIST =[[(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1730 [(_('Bookmark'), None), (_('Preference'), None)],
1731 [(_('About'), None), (_('Help'), None)]]
1732 def __init__(self, session, url=None):
1733 Screen.__init__(self, session)
1734 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1735 "cancel" : self.keyCancel
1737 ,"left" : self.keyLeft
1738 ,"right" : self.keyRight
1740 ,"down" : self.keyDown
1741 ,"menu" : self.keyMenu
1744 self._terminatedBrowser = True
1745 self._enableKeyEvent = True
1746 self._currentPageUrl = None
1747 self._currentPageTitle = None
1748 self.menubarCurrentIndex = 0
1749 self.lvMenuItems = []
1750 self.lvSubMenuItems = []
1752 self["topArea"] = Label()
1753 self["bottomArea"] = Label()
1755 self["menuitemFile"] = MultiColorLabel()# modify menu
1756 self["menuitemTool"] = MultiColorLabel()
1757 self["menuitemHelp"] = MultiColorLabel()
1759 self["menulist"] = MenuList(self.setListOnView())
1760 self["submenulist"] = MenuList(self.setSubListOnView())
1762 self.toggleMainScreenFlag = True
1763 self.toggleListViewFlag = False
1764 self.toggleSubListViewFlag = False
1765 self.currentListView = self["menulist"]
1767 self.onLayoutFinish.append(self.layoutFinished)
1769 self._onCloseTimer = eTimer()
1770 self._onCloseTimer.callback.append(self._cb_onClose)
1774 def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1775 rcmouse_path = "/proc/stb/fp/mouse"
1776 if os.path.exists(rcmouse_path):
1777 os.system("echo %d > %s" % (mode, rcmouse_path))
1779 def layoutFinished(self):
1780 self["menuitemFile"].setText(_("File"))# modify menu
1781 self["menuitemTool"].setText(_("Tools"))
1782 self["menuitemHelp"].setText(_("Help"))
1784 self["menulist"].hide()
1785 self["submenulist"].hide()
1787 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1788 self.setTitle(_("BrowserMain"))
1789 self.selectMenuitem()
1791 if self.paramUrl is not None:
1793 self.cbUrlText(self.paramUrl, 1)
1795 def selectMenuitem(self):
1796 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1797 self["menuitemFile"].setForegroundColorNum(0)
1798 self["menuitemTool"].setForegroundColorNum(0)
1799 self["menuitemHelp"].setForegroundColorNum(0)
1800 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1802 def popupCloseAll(self):
1808 def setListOnView(self):
1809 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1810 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1811 l = [(_('Return'), None)]
1812 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1813 return self.lvMenuItems
1815 def setSubListOnView(self):
1816 self.lvSubMenuItems = []
1817 xl = self["menulist"].getCurrent()[1]
1818 if xl is None: return []
1820 self.lvSubMenuItems.append((x,None))
1821 return self.lvSubMenuItems
1823 def toggleMainScreen(self):
1824 if not self.toggleMainScreenFlag:
1827 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1829 def toggleListView(self):
1830 if not self.toggleListViewFlag:
1831 self["menulist"].show()
1832 else: self["menulist"].hide()
1833 self.toggleListViewFlag = not self.toggleListViewFlag
1835 def toggleSubListView(self):
1836 if not self.toggleSubListViewFlag:
1837 self["submenulist"].show()
1838 else: self["submenulist"].hide()
1839 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1841 def setCurrentListView(self, listViewIdx):
1842 if listViewIdx == 0:
1843 self.currentListView = None
1844 elif listViewIdx == 1:
1845 self.currentListView = self["menulist"]
1846 elif listViewIdx == 2:
1847 self.currentListView = self["submenulist"]
1849 def _cb_onClose(self):
1850 self._onCloseTimer.stop()
1851 command_server = getCommandServer()
1853 if self._on_close_window in command_server.onHbbTVCloseCB:
1854 command_server.onHbbTVCloseCB.remove(self._on_close_window)
1855 except Exception, ErrMsg: pass
1857 if self._on_setPageTitle in command_server.onSetPageTitleCB:
1858 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1859 except Exception, ErrMsg: pass
1860 self._on_setPageTitle(_('Opera Browser'))
1861 self.enableRCMouse(False)
1862 self.toggleMainScreen()
1863 fbClass.getInstance().unlock()
1864 eRCInput.getInstance().unlock()
1865 self._terminatedBrowser = True
1866 self._enableKeyEvent = True
1867 #if not self.toggleListViewFlag:
1869 self._currentPageUrl = ''
1870 if self.paramUrl is not None:
1876 def _on_setPageTitle(self, title=None):
1877 print "Title :",title
1880 self.setTitle(title)
1882 def cbUrlText(self, data=None, mode=0):
1883 print "Inputed Url :", data, mode
1884 if strIsEmpty(data):
1887 command_server = getCommandServer()
1888 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
1889 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
1890 if self._on_close_window not in command_server.onHbbTVCloseCB:
1891 command_server.onHbbTVCloseCB.append(self._on_close_window)
1892 self.toggleMainScreen()
1893 self.enableRCMouse(True)
1894 fbClass.getInstance().lock()
1895 eRCInput.getInstance().lock()
1896 command_util = getCommandUtil()
1897 command_util.sendCommand('OP_BROWSER_OPEN_URL', data, mode)
1898 self._terminatedBrowser = False
1899 self._enableKeyEvent = False
1901 def _on_close_window(self):
1902 self._onCloseTimer.start(1000)
1904 def _cb_bookmarkWindowClosed(self, data=None):
1908 self.cbUrlText(url, mode)
1910 def _cmd_on_OpenUrl(self):
1912 if not _g_helper._is_browser_running():
1913 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
1914 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
1916 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1917 def _cmd_on_About(self):
1918 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
1919 def _cmd_on_Exit(self):
1921 def _cmd_on_StartStop(self):
1923 if _g_helper is None:
1925 _g_helper.showBrowserConfigBox()
1926 def _cmd_on_Bookmark(self):
1927 url = self._currentPageUrl
1930 title = self._currentPageTitle
1933 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
1934 def _cmd_on_Preference(self):
1935 url = self._currentPageUrl
1938 self.session.open(OperaBrowserPreferenceWindow, url)
1939 def _cmd_on_OpenStartpage(self):
1941 if not _g_helper._is_browser_running():
1942 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
1943 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
1946 start = 'http://vuplus.com'
1948 d = OperaBrowserSetting().getData()
1952 self.cbUrlText(start, mode)
1953 def _cmd_on_ReturnToBrowser(self):
1956 def _cmd_on_Help(self):
1957 self.session.open(BrowserHelpWindow)
1959 def doCommand(self, command):
1962 cmd_map[_('Exit')] = self._cmd_on_Exit
1963 cmd_map[_('Help')] = self._cmd_on_Help
1964 cmd_map[_('About')] = self._cmd_on_About
1965 cmd_map[_('Open URL')] = self._cmd_on_OpenUrl
1966 cmd_map[_('Start/Stop')] = self._cmd_on_StartStop
1967 cmd_map[_('Bookmark')] = self._cmd_on_Bookmark
1968 cmd_map[_('Preference')] = self._cmd_on_Preference
1969 cmd_map[_('Return')] = self._cmd_on_ReturnToBrowser
1970 cmd_map[_('Open Startpage')] = self._cmd_on_OpenStartpage
1973 except Exception, ErrMsg: print ErrMsg
1976 if not self.toggleListViewFlag:
1979 if self.currentListView.getCurrent()[1] is None:
1980 self.doCommand(self.currentListView.getCurrent()[0])
1981 #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
1985 def updateSelectedMenuitem(self, status):
1986 if self.menubarCurrentIndex == 0 and status < 0:
1987 self.menubarCurrentIndex = 2 # modify menu
1988 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
1989 self.menubarCurrentIndex = 0
1990 else: self.menubarCurrentIndex += status
1991 self.selectMenuitem()
1994 if not self.toggleMainScreenFlag:
1996 if not self.toggleListViewFlag:
1997 self.updateSelectedMenuitem(-1)
1999 if self.toggleSubListViewFlag:
2000 self.setCurrentListView(1)
2001 self.toggleSubListView()
2003 #if self.currentListView.getSelectedIndex():
2004 self.currentListView.pageUp()
2010 if not self.toggleMainScreenFlag:
2012 if not self.toggleListViewFlag:
2013 self.updateSelectedMenuitem(1)
2015 if self.currentListView is None:
2017 if self.currentListView.getCurrent()[1] is not None:
2018 parentSelectedIndex = self.currentListView.getSelectedIndex()
2019 self.setCurrentListView(2)
2020 self.currentListView.setList(self.setSubListOnView())
2021 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
2022 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))
2023 self.toggleSubListView()
2025 self.currentListView.pageUp()
2031 if not self.toggleMainScreenFlag:
2033 if self.currentListView is None:
2035 if not self.toggleListViewFlag:
2036 self.currentListView.setList(self.setListOnView())
2037 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2038 self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2039 self.toggleListView()
2041 self.currentListView.down()
2044 if not self.toggleMainScreenFlag:
2046 if self.currentListView is None:
2048 if self.currentListView == self["menulist"]:
2049 if self.currentListView.getSelectedIndex() == 0:
2050 self.toggleListView()
2052 self.currentListView.up()
2054 def keyCancel(self):
2055 if not self._terminatedBrowser:
2056 #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2057 fbClass.getInstance().lock()
2058 eRCInput.getInstance().lock()
2059 if self.toggleListViewFlag:
2060 self.toggleMainScreen()
2061 self._currentPageUrl = None
2062 self._currentPageTitle = None
2063 command_util = getCommandUtil()
2064 command_util.sendCommand('OP_BROWSER_MENU_RES')
2069 self.toggleMainScreen()
2071 def setCurrentPageUrl(self, url, title=None):
2072 self._currentPageUrl = url
2075 if idx > 10: idx = 10
2077 self._currentPageTitle = title
2078 print self._currentPageUrl
2079 self.toggleMainScreen()
2083 def hideSubmenu(self):
2084 self.currentListView.pageUp()
2087 def auto_start_main(reason, **kwargs):
2089 command_server = getCommandServer()
2090 command_server.stop()
2092 from Screens.HelpMenu import HelpableScreen
2093 def session_start_main(session, reason, **kwargs):
2094 fbClass.getInstance().unlock()
2095 eRCInput.getInstance().unlock()
2097 _g_helper = session.open(HbbTVHelper)
2099 HelpableScreen.__init__ = HelpableScreen__init__
2100 HelpableScreen.session = session
2102 def HelpableScreen__init__(self):
2103 if isinstance(self, HelpableScreen):
2104 HelpableScreen.showManual = showManual
2106 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2107 "help_b" : self.showHelp,
2108 "help_l" : self.showManual,
2111 _g_clearBrowserDataTimer = eTimer()
2112 def showManual(self):
2113 if not os.path.exists('/usr/local/manual'):
2116 url = 'file:///usr/local/manual/main.html'
2117 lang = language.getLanguage()
2118 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2119 url = 'file:///usr/local/manual/ru_RU/main.html'
2120 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2121 url = 'file:///usr/local/manual/de_DE/main.html'
2124 _g_clearBrowserDataTimer.stop()
2125 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2127 setPluginBrowser(None)
2128 def clearBrowserData():
2129 _g_clearBrowserDataTimer.callback.append(_do_clean)
2130 _g_clearBrowserDataTimer.start(50)
2131 setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2133 def plugin_start_main(session, **kwargs):
2134 #session.open(OperaBrowser)
2136 _g_clearBrowserDataTimer.stop()
2137 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2139 setPluginBrowser(None)
2140 def clearBrowserData():
2141 _g_clearBrowserDataTimer.callback.append(_do_clean)
2142 _g_clearBrowserDataTimer.start(50)
2143 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2145 def plugin_extension_start_application(session, **kwargs):
2147 if _g_helper is None:
2149 _g_helper.showApplicationSelectionBox()
2151 def plugin_extension_browser_config(session, **kwargs):
2153 if _g_helper is None:
2155 _g_helper.showBrowserConfigBox()
2157 def Plugins(path, **kwargs):
2159 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2160 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2161 l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2162 l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2163 l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))