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 print "Try to open vod"
785 self._vod_service = eServiceReference(4097, 0, url)
786 self._session.nav.playService(self._vod_service)
787 if self._vod_service is not None:
789 except Exception, ErrMsg:
790 print "OpenVOD ERR :", ErrMsg
794 def _cb_handleVODPlayerPlay(self, opcode, data):
795 self._handle_dump(self._cb_handleVODPlayerPlay, opcode, data)
796 self.doStop(restoreBeforeService=False)
797 if self.doRetryOpen(url=self._vod_uri) == False:
801 def _cb_handleVODPlayerStop(self, opcode, data):
802 self._handle_dump(self._cb_handleVODPlayerStop, opcode, data)
806 def _cb_handleVODPlayerPlayPause(self, opcode, data):
807 self._handle_dump(self._cb_handleVODPlayerPlayPause, opcode, data)
808 service = self._session.nav.getCurrentService()
811 servicePause = service.pause()
813 servicePause.unpause()
814 elif pauseFlag == 'P':
816 except Exception, ErrMsg:
817 print "onPause ERR :", ErrMsg
820 from libshm import SimpleSharedMemory
822 class HbbTVWindow(Screen, InfoBarNotifications):
824 <screen name="HbbTVWindow" position="0,0" size="1280,720" backgroundColor="transparent" flags="wfNoBorder" title="HbbTV Plugin">
827 def __init__(self, session, url=None, cbf=None, useAIT=False, profile=0):
828 self._session = session
829 setResolution(1280, 720)
830 fbClass.getInstance().lock()
831 eRCInput.getInstance().lock()
833 Screen.__init__(self, session)
834 InfoBarNotifications.__init__(self)
835 self.__event_tracker = ServiceEventTracker(screen = self, eventmap = {
836 iPlayableService.evUser+20: self._serviceForbiden,
837 iPlayableService.evStart: self._serviceStarted,
838 iPlayableService.evEOF: self._serviceEOF,
842 self._use_ait = useAIT
843 self._profile = profile
844 self._cb_closed_func = cbf
845 self.onLayoutFinish.append(self._layoutFinished)
847 command_server = getCommandServer()
848 if self._cb_set_page_title not in command_server.onSetPageTitleCB:
849 command_server.onSetPageTitleCB.append(self._cb_set_page_title)
851 if self._cb_close_window not in command_server.onHbbTVCloseCB:
852 command_server.onHbbTVCloseCB.append(self._cb_close_window)
854 self._closeTimer = eTimer()
855 self._closeTimer.callback.append(self._do_close)
857 self._currentServicePositionTimer = eTimer()
858 self._currentServicePositionTimer.callback.append(self._cb_currentServicePosition)
865 def getVodPlayTime(self):
867 service = self._session.nav.getCurrentService()
868 seek = service and service.seek()
870 p = seek.getPlayPosition()
871 #return (p[1]/90000, l[1]/90000)
876 def _cb_currentServicePosition(self):
877 def getTimeString(t):
878 t = time.localtime(t/90000)
879 return "%2d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec)
880 position,length = 0,0
882 (position,length) = self.getVodPlayTime()
883 self._vod_length = length
884 if position == -1 and length == -1:
885 raise Exception("Can't get play status")
886 #print getTimeString(position), "/", getTimeString(length)
887 self._ssm.setStatus(position, length, 1)
888 except Exception, ErrMsg:
892 def _serviceStarted(self):
894 self._ssm.setStatus(0, 0, 0)
895 self._currentServicePositionTimer.start(1000)
896 except Exception, ErrMsg:
899 def _serviceEOF(self):
900 (position,length) = self.getVodPlayTime()
901 self._ssm.setStatus(length, length, 1)
903 self._currentServicePositionTimer.stop()
905 def _layoutFinished(self):
906 self.setTitle(_('HbbTV Plugin'))
907 command_util = getCommandUtil()
908 profile = self._profile
909 (sid, onid, tsid, name, orgid) = getChannelInfos()
910 params = struct.pack('!IIIIII', orgid, profile, sid, onid, tsid, len(name)) + name
912 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
914 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params, 1)
916 command_util.sendCommand('OP_HBBTV_LOAD_AIT', params)
918 command_util.sendCommand('OP_HBBTV_OPEN_URL', self._url)
920 def _cb_close_window(self):
921 self._closeTimer.start(1000)
924 self._closeTimer.stop()
925 command_server = getCommandServer()
927 if self._cb_set_page_title in command_server.onSetPageTitleCB:
928 command_server.onSetPageTitleCB.remove(self._cb_set_page_title)
929 except Exception, ErrMsg: pass
931 if self._cb_close_window in command_server.onHbbTVCloseCB:
932 command_server.onHbbTVCloseCB.remove(self._cb_close_window)
933 except Exception, ErrMsg: pass
935 if self._cb_closed_func is not None:
936 self._cb_closed_func()
939 fbClass.getInstance().unlock()
940 eRCInput.getInstance().unlock()
943 def _serviceForbiden(self):
945 real_url = MMSStreamURL().getLocationData(__gval__.hbbtv_handelr.getUrl())
946 #print "Received URI :\n", real_url
948 if real_url is not None:
949 __gval__.hbbtv_handelr.doRetryOpen(real_url.strip())
951 def _cb_set_page_title(self, title=None):
952 print "page title :",title
957 class HbbTVHelper(Screen):
958 skin = """<screen name="HbbTVHelper" position="0,0" size="0,0" backgroundColor="transparent" flags="wfNoBorder" title=" "></screen>"""
959 def __init__(self, session):
961 __gval__.hbbtv_handelr = HandlerHbbTV(session)
962 __gval__.command_server = ServerFactory().doListenUnixTCP('/tmp/.sock.hbbtv.url', __gval__.hbbtv_handelr)
966 Screen.__init__(self, session)
967 self._session = session
969 self._restart_opera()
971 self._timer_infobar = eTimer()
972 self._timer_infobar.callback.append(self._cb_registrate_infobar)
973 self._timer_infobar.start(1000)
975 self._excuted_browser = False
978 __gval__.command_util = BrowserCommandUtil()
982 _g_ssm_ = SimpleSharedMemory()
985 self._callbackStartStop = None
987 def _cb_registrate_infobar(self):
989 self._timer_infobar.stop()
990 if self._cb_ready_for_ait not in InfoBar.instance.onReadyForAIT:
991 InfoBar.instance.onReadyForAIT.append(self._cb_ready_for_ait)
992 if self._cb_hbbtv_activated not in InfoBar.instance.onHBBTVActivation:
993 InfoBar.instance.onHBBTVActivation.append(self._cb_hbbtv_activated)
995 def _cb_ready_for_ait(self, orgId=0):
997 if not self._excuted_browser:
998 command_util = getCommandUtil()
999 command_util.sendCommand('OP_HBBTV_UNLOAD_AIT')
1001 setChannelInfo(None, None, None, None, None)
1003 service = self._session.nav.getCurrentService()
1004 info = service and service.info()
1005 if info is not None:
1006 sid = info.getInfo(iServiceInformation.sSID)
1007 onid = info.getInfo(iServiceInformation.sONID)
1008 tsid = info.getInfo(iServiceInformation.sTSID)
1009 name = info.getName()
1014 for x in info.getInfoObject(iServiceInformation.sHBBTVUrl):
1015 if x[0] in (1, -1) :
1018 setChannelInfo(sid, onid, tsid, name, orgid)
1020 def _cb_hbbtv_activated(self, title=None, url=None):
1021 if not self._is_browser_running():
1022 message = _("HbbTV Browser was not running.\nPlease running browser before start HbbTV Application.")
1023 self._session.open(MessageBox, message, MessageBox.TYPE_INFO)
1025 service = self._session.nav.getCurrentlyPlayingServiceReference()
1026 setBeforeService(service)
1027 self._start_hbbtv_application(title, url)
1029 def _start_hbbtv_application(self, title, url):
1031 tmp_url = self.getStartHbbTVUrl()
1035 print "can't get url of hbbtv!!"
1037 print "success to get url of hbbtv!! >>", url
1038 if self._excuted_browser:
1039 print "already excuted opera browser!!"
1043 self._restart_opera()
1045 setNeedRestart(False)
1047 for x in self._urls:
1050 if tmp_url == url and control_code == 1:
1052 self._excuted_browser = True
1053 self._session.open(HbbTVWindow, url, self._cb_closed_browser, use_ait, self._profile)
1055 def _cb_closed_browser(self):
1056 self._excuted_browser = False
1058 def _start_opera(self):
1059 if not self._is_browser_running():
1060 global HBBTVAPP_PATH
1061 start_command = '%s/launcher start'%(HBBTVAPP_PATH)
1062 os.system(start_command)
1065 def _stop_opera(self):
1066 global HBBTVAPP_PATH
1067 try: os.system('%s/launcher stop'%(HBBTVAPP_PATH))
1070 def _restart_opera(self):
1071 global HBBTVAPP_PATH
1072 try: os.system('%s/launcher restart'%(HBBTVAPP_PATH))
1076 def getStartHbbTVUrl(self):
1077 url, self._urls, self._profile = None, None, 0
1078 service = self._session.nav.getCurrentService()
1079 info = service and service.info()
1080 if not info: return None
1081 self._urls = info.getInfoObject(iServiceInformation.sHBBTVUrl)
1082 for u in self._urls:
1083 if u[0] in (1, -1): # 0:control code, 1:name, 2:url, 3:orgid, 4:appid, 5:profile code
1085 self._profile = u[5]
1087 url = info.getInfoString(iServiceInformation.sHBBTVUrl)
1090 def showApplicationSelectionBox(self):
1093 if self.getStartHbbTVUrl():
1094 for x in self._urls:
1095 applications.append((x[1], x))
1096 else: applications.append((_("No detected HbbTV applications."), None))
1097 self._session.openWithCallback(self._application_selected, ChoiceBox, title=_("Please choose an HbbTV application."), list=applications)
1099 def _application_selected(self, selected):
1101 if selected[1] is None: return
1102 self._cb_hbbtv_activated(selected[1][1], selected[1][2])
1103 except Exception, ErrMsg: print ErrMsg
1105 def showBrowserConfigBox(self, callback=None):
1106 start_stop_mode = []
1107 self._callbackStartStop = callback
1108 if self._is_browser_running():
1109 start_stop_mode.append((_('Stop'),'Stop'))
1110 else: start_stop_mode.append((_('Start'),'Start'))
1111 self._session.openWithCallback(self._browser_config_selected, ChoiceBox, title=_("Please choose one."), list=start_stop_mode)
1113 def _browser_config_selected(self, selected):
1114 if selected is None:
1116 if self._callbackStartStop is not None:
1117 self._callbackStartStop()
1121 if not self._is_browser_running():
1123 elif mode == 'Stop':
1125 except Exception, ErrMsg: print "Config ERR :", ErrMsg
1127 def _is_browser_running(self):
1129 global HBBTVAPP_PATH
1130 ret = os.popen('%s/launcher check'%(HBBTVAPP_PATH)).read()
1131 return ret.strip() != "0"
1132 except Exception, ErrMsg:
1133 print "Check Browser Running ERR :", ErrMsg
1136 def doChangeChannel(self, _sid, _tsid):
1137 root = eServiceReference(service_types_tv)
1140 serviceList = eServiceCenter.getInstance().list(root)
1141 if serviceList is None:
1144 service = serviceList.getNext()
1145 if service is None or not service.valid():
1148 #1:0:19:2840:3FB:1:C00000:0:0:0:
1149 serviceRef = service.toString()
1150 if strIsEmpty(serviceRef):
1152 serviceRefItems = serviceRef.split(":")
1153 if len(serviceRefItems) < 5:
1156 sid = serviceRefItems[3]
1157 tsid = serviceRefItems[4]
1158 if sid == _sid and tsid == _tsid:
1159 self._session.nav.playService(eServiceReference(serviceRef))
1160 service = self._session.nav.getCurrentlyPlayingServiceReference()
1161 setBeforeService(service)
1165 class OperaBrowserSetting:
1167 self._settingFileName = '/usr/local/hbb-browser/home/setting.ini'
1173 f = open(self._settingFileName)
1174 for line in f.readlines():
1175 if line.startswith('start='):
1176 tmp = line[6:len(line)-1].split()
1177 self._start = tmp[0]
1179 self._type = int(tmp[1])
1180 else: self._type = 0
1181 elif line.startswith('keymap='):
1182 self._keymap = line[7:len(line)-1]
1186 tmpstr.append('start=%s %d\n' % (self._start, self._type))
1187 tmpstr.append('keymap=%s\n' % (self._keymap))
1188 f = open(self._settingFileName, 'w')
1189 f.writelines(tmpstr)
1191 def setData(self, start, types=0, keymap="us-rc"):
1194 self._keymap = keymap
1198 'start':self._start,
1200 'keymap':self._keymap,
1203 class OperaBrowserPreferenceWindow(ConfigListScreen, Screen):
1205 <screen position="center,120" size="600,350" title="Preference">
1206 <widget name="url" position="5,0" size="590,100" valign="center" font="Regular;20" />
1207 <widget name="config" position="0,100" size="600,200" scrollbarMode="showOnDemand" />
1209 <ePixmap pixmap="skin_default/buttons/red.png" position="310,310" size="140,40" alphatest="on" />
1210 <ePixmap pixmap="skin_default/buttons/green.png" position="150,310" size="140,40" alphatest="on" />
1212 <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" />
1213 <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" />
1216 def __init__(self, session, currentUrl):
1217 self.session = session
1218 Screen.__init__(self, session)
1221 ConfigListScreen.__init__(self, self.menulist)
1223 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], {
1224 "red" : self.keyRed,
1225 "green" : self.keyGreen,
1227 "cancel" : self.keyRed
1229 self["key_red"] = StaticText(_("Cancel"))
1230 self["key_green"] = StaticText(_("Save"))
1231 self["url"] = Label()
1233 self._currentPageUrl = currentUrl
1234 if self._currentPageUrl is None:
1235 self._currentPageUrl = ''
1236 self._startPageUrl = None
1237 self._keymapType = None
1238 self.makeMenuEntry()
1239 self.onLayoutFinish.append(self.layoutFinished)
1241 def layoutFinished(self):
1242 self.setTitle(_('Preference'))
1244 def updateStartPageUrl(self):
1245 if self.menuItemStartpage.value == "startpage":
1246 self["url"].setText(self._startPageUrl)
1247 elif self.menuItemStartpage.value == "current":
1248 self["url"].setText(self._currentPageUrl)
1249 elif self.menuItemStartpage.value == "direct":
1250 self["url"].setText('')
1253 url = self["url"].getText()
1255 self.session.open(MessageBox, _('Invalid URL!!(Empty)\nPlease, Input to the URL.'), type = MessageBox.TYPE_INFO)
1258 if url.find('/usr/local/manual') > 0:
1260 self._keymapType = self.menuItemKeyboardLayout.value
1261 OperaBrowserSetting().setData(url, mode, self._keymapType)
1262 command_util = getCommandUtil()
1263 command_util.sendCommand('OP_BROWSER_NEED_RELOAD_KEYMAP')
1270 def _cb_directInputUrl(data):
1271 if strIsEmpty(data):
1273 self["url"].setText(data)
1274 if self.menuItemStartpage.value == "direct":
1275 self.session.openWithCallback(_cb_directInputUrl, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
1278 ConfigListScreen.keyLeft(self)
1279 self.updateStartPageUrl()
1282 ConfigListScreen.keyRight(self)
1283 self.updateStartPageUrl()
1285 def getKeymapTypeList(self):
1287 for f in os.listdir("/usr/local/hbb-browser/keymap"):
1288 filesplit = f.split('.')
1289 if len(filesplit) < 2:
1291 types.append((filesplit[1], filesplit[1]))
1295 def makeMenuEntry(self):
1297 l.append(("startpage", _("Start Page")))
1298 if not strIsEmpty(self._currentPageUrl):
1299 l.append(("current", _("Current Page")))
1300 l.append(("direct", _("Direct Input")))
1301 self.menuItemStartpage = ConfigSelection(default="startpage", choices = l)
1302 self.menuEntryStartpage = getConfigListEntry(_("Startpage"), self.menuItemStartpage)
1304 kl = self.getKeymapTypeList()
1307 d = OperaBrowserSetting().getData()
1308 self._startPageUrl = d['start']
1309 self._keymapType = d['keymap']
1311 except: self._startPageUrl = 'http://vuplus.com'
1312 self.updateStartPageUrl()
1314 if self._keymapType is None or len(self._keymapType) == 0:
1315 self._keymapType = "us-rc"
1316 self.menuItemKeyboardLayout = ConfigSelection(default=self._keymapType, choices = kl)
1317 self.menuEntryKeyboardLayout = getConfigListEntry(_("Keyboard Layout"), self.menuItemKeyboardLayout)
1318 self.resetMenuList()
1320 def resetMenuList(self):
1322 self.menulist.append(self.menuEntryStartpage)
1323 self.menulist.append(self.menuEntryKeyboardLayout)
1325 self["config"].list = self.menulist
1326 self["config"].l.setList(self.menulist)
1328 class BookmarkEditWindow(ConfigListScreen, Screen):
1329 CATEGORY,BOOKMARK = 0,1
1331 <screen position="center,center" size="600,140" title="Bookmark Edit">
1332 <widget name="config" position="0,0" size="600,100" scrollbarMode="showOnDemand" />
1334 <ePixmap pixmap="skin_default/buttons/red.png" position="310,100" size="140,40" alphatest="on" />
1335 <ePixmap pixmap="skin_default/buttons/green.png" position="150,100" size="140,40" alphatest="on" />
1337 <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" />
1338 <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" />
1340 <widget name="VKeyIcon" pixmap="skin_default/buttons/key_text.png" position="0,100" zPosition="10" size="35,25" transparent="1" alphatest="on" />
1344 def __init__(self, session, _mode, _type, _data, _bm):
1348 self.mSession = session
1349 self.mBookmarkManager = _bm
1351 if _data is not None:
1354 Screen.__init__(self, session)
1357 ConfigListScreen.__init__(self, self.menulist)
1359 self["actions"] = ActionMap(["OkCancelActions", "ColorActions",], {
1360 "ok" : self.keyGreen,
1361 "green" : self.keyGreen,
1362 "red" : self.keyRed,
1363 "cancel" : self.keyRed,
1366 self["VKeyIcon"] = Pixmap()
1367 self["key_red"] = StaticText(_("Cancel"))
1368 self["key_green"] = StaticText(_("Save"))
1370 self.menuItemTitle = None
1371 self.menuItemUrl = None
1372 self.menuItemName = None
1374 self.menuEntryName = None
1375 self.menuEntryTitle = None
1376 self.menuEntryUrl = None
1378 self.makeConfigList()
1379 self.onLayoutFinish.append(self.layoutFinished)
1381 def layoutFinished(self):
1382 self.setTitle(_('Bookmark') + ' ' + self.mMode)
1384 def selectedItem(self):
1385 currentPosition = self["config"].getCurrent()
1386 if self.mType == BookmarkEditWindow.CATEGORY:
1387 return (_("Name"), self.menuItemName)
1389 if currentPosition == self.menuEntryTitle:
1390 return (_("Title"), self.menuItemTitle)
1391 elif currentPosition == self.menuEntryUrl:
1392 return (_("Url"), self.menuItemUrl)
1395 def showMessageBox(self, text):
1396 msg = _("Invalid ") + text + _("!!(Empty)\nPlease, Input to the ") + text + "."
1397 self.mSession.openWithCallback(self.showVKeyWindow, MessageBox, msg, MessageBox.TYPE_INFO)
1400 def showVKeyWindow(self, data=None):
1403 selected = self.selectedItem()
1404 if selected is not None:
1405 itemValue = selected[1].value
1406 if strIsEmpty(itemValue):
1408 itemTitle = selected[0]
1410 self.session.openWithCallback(self.cbVKeyWindow, VirtualKeyBoard, title=itemTitle, text=itemValue)
1412 def cbVKeyWindow(self, data=None):
1413 if data is not None:
1414 selected = self.selectedItem()
1415 if selected is not None:
1416 selected[1].setValue(data)
1419 if self.mType == BookmarkEditWindow.CATEGORY:
1420 if self.mMode == _('Add'):
1421 categoryName = self.menuItemName.value
1422 if strIsEmpty(categoryName):
1423 return self.showMessageBox(_("Category Name"))
1424 self.mBookmarkManager.addCategory(categoryName)
1426 if strIsEmpty(self.menuItemName.value):
1427 return self.showMessageBox(_("Category Name"))
1428 self.mData.mName = self.menuItemName.value
1429 self.mBookmarkManager.updateCategory(self.mData)
1431 if self.mMode == _('Add'):
1432 bookmarkTitle = self.menuItemTitle.value
1433 bookmarkUrl = self.menuItemUrl.value
1434 if strIsEmpty(bookmarkTitle):
1435 self["config"].setCurrentIndex(0)
1436 return self.showMessageBox(_("Bookmark Title"))
1437 if strIsEmpty(bookmarkUrl):
1438 self["config"].setCurrentIndex(1)
1439 return self.showMessageBox(_("Bookmark URL"))
1440 self.mBookmarkManager.addBookmark(bookmarkTitle, bookmarkUrl, self.mData.mParent, 0)
1442 if strIsEmpty(self.menuItemTitle.value):
1443 self["config"].setCurrentIndex(0)
1444 return self.showMessageBox(_("Bookmark Title"))
1445 if strIsEmpty(self.menuItemUrl.value):
1446 self["config"].setCurrentIndex(1)
1447 return self.showMessageBox(_("Bookmark URL"))
1448 self.mData.mTitle = self.menuItemTitle.value
1449 self.mData.mUrl = self.menuItemUrl.value
1450 self.mBookmarkManager.updateBookmark(self.mData)
1454 if not self.saveData():
1460 ConfigListScreen.keyLeft(self)
1462 ConfigListScreen.keyRight(self)
1463 def makeConfigList(self):
1466 if self.mType == BookmarkEditWindow.CATEGORY:
1467 self.menuItemName = ConfigText(default=self.mData.mName, visible_width=65, fixed_size=False)
1469 self.menuEntryName = getConfigListEntry(_("Name"), self.menuItemName)
1471 self.menulist.append(self.menuEntryName)
1473 self.menuItemTitle = ConfigText(default=self.mData.mTitle, visible_width=65, fixed_size=False)
1474 self.menuItemUrl = ConfigText(default=self.mData.mUrl, visible_width=65, fixed_size=False)
1476 self.menuEntryTitle = getConfigListEntry(_("Title"), self.menuItemTitle)
1477 self.menuEntryUrl = getConfigListEntry(_("Url"), self.menuItemUrl)
1479 self.menulist.append(self.menuEntryTitle)
1480 self.menulist.append(self.menuEntryUrl)
1482 self["config"].list = self.menulist
1483 self["config"].l.setList(self.menulist)
1485 class OperaBrowserBookmarkWindow(Screen):
1487 <screen name="HbbTVBrowserBookmarkWindow" position="center,120" size="600,400" title="Bookmark" >
1488 <widget name="bookmarklist" position="0,0" size="600,200" zPosition="10" scrollbarMode="showOnDemand" />
1490 <ePixmap pixmap="skin_default/buttons/key_0.png" position="556,330" size="35,30" alphatest="on" />
1491 <widget source="key_0" render="Label" position="258,330" zPosition="1" size="300,30" font="Regular;20" halign="right" valign="center"/>
1493 <ePixmap pixmap="skin_default/buttons/red.png" position="5,360" size="140,40" alphatest="on" />
1494 <ePixmap pixmap="skin_default/buttons/green.png" position="155,360" size="140,40" alphatest="on" />
1495 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,360" size="140,40" alphatest="on" />
1496 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,360" size="140,40" alphatest="on" />
1498 <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" />
1499 <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" />
1500 <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" />
1501 <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" />
1505 def __init__(self, _session, _url=None, _title=None):
1507 self.mTitle = _title
1508 self.mBookmarkManager = BookmarkManager.getInstance()
1509 self.mSession = _session
1510 Screen.__init__(self, _session)
1511 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions", "NumberActions"], {
1513 "cancel": self.keyCancel,
1514 "red" : self.keyRed,
1515 "green" : self.keyGreen,
1516 "yellow": self.keyYellow,
1517 "blue" : self.keyBlue,
1518 "0" : self.keyNumber,
1521 self["key_red"] = StaticText(_("Exit"))
1522 self["key_green"] = StaticText(_("Add"))
1523 self["key_yellow"] = StaticText(_("Edit"))
1524 self["key_blue"] = StaticText(_("Delete"))
1525 self["key_0"] = StaticText(_("Set as Startpage"))
1527 self.mBookmarkList = self.setBookmarkList()
1528 self["bookmarklist"] = MenuList(self.mBookmarkList)
1530 self.onLayoutFinish.append(self.layoutFinished)
1532 def layoutFinished(self):
1533 self.setTitle(_('Bookmark'))
1535 def setBookmarkList(self):
1537 #self.mBookmarkManager.dump()
1538 cd = self.mBookmarkManager.getBookmarkRoot()
1539 for ck in cd.iterkeys():
1540 l.append(('# ' + cd[ck].mName, cd[ck]))
1541 bd = cd[ck].mBookmarks
1542 for bk in bd.iterkeys():
1543 l.append((' - ' + bd[bk].mTitle, bd[bk]))
1545 def updateBookmarkList(self):
1546 self.mBookmarkList = self.setBookmarkList()
1547 self["bookmarklist"].setList(self.mBookmarkList)
1548 def cbEditWindow(self, ret=False):
1551 self.updateBookmarkList()
1552 def getParentCategory(self):
1553 idx = self["bookmarklist"].getSelectedIndex()
1556 data = self.mBookmarkList[idx][0].strip()
1558 return self.mBookmarkList[idx][1]
1562 def isCategoryItem(self):
1564 head = self["bookmarklist"].getCurrent()[0].strip()
1569 def keyNumber(self):
1570 data = self["bookmarklist"].getCurrent()[1]
1571 if strIsEmpty(data.mUrl):
1572 msg = _("Invalid URL. Please check again!!")
1573 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1575 def cbSetStartpage(ret=None):
1576 if ret is None: return
1578 data = self["bookmarklist"].getCurrent()[1]
1579 OperaBrowserSetting().setData(data.mUrl, data.mType)
1580 msg = _("Do you want to set selected url to the Startpage?")
1581 self.mSession.openWithCallback(cbSetStartpage, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1588 parent = self.getParentCategory()
1591 if strIsEmpty(self.mTitle):
1593 retAdd = self.mBookmarkManager.addBookmark(self.mTitle, self.mUrl, parent.mId, 0)
1595 msg = _("Current page is already exist.")
1596 self.mSession.open(MessageBox, msg, MessageBox.TYPE_INFO)
1597 self.cbEditWindow(True)
1599 parent = self.getParentCategory()
1602 b = BookmarkData(0, '', '', parent.mId, 0)
1603 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.BOOKMARK, b, self.mBookmarkManager)
1605 c = CategoryData(0, '')
1606 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Add'), BookmarkEditWindow.CATEGORY, c, self.mBookmarkManager)
1607 if strIsEmpty(self.mUrl):
1608 l = [(_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1609 else: l = [(_('Currentpage(Bookmark)'),1,), (_('Direct Input(Bookmark)'),2,), (_('Direct Input(Category)'),3,)]
1610 self.mSession.openWithCallback(cbGreen, ChoiceBox, title=_("Please choose."), list=l)
1611 def keyYellow(self):
1612 data = self["bookmarklist"].getCurrent()[1]
1613 if self.isCategoryItem():
1614 self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.CATEGORY, data, self.mBookmarkManager)
1615 else: self.mSession.openWithCallback(self.cbEditWindow, BookmarkEditWindow, _('Edit'), BookmarkEditWindow.BOOKMARK, data, self.mBookmarkManager)
1617 def cbBlue(ret=None):
1619 data = self["bookmarklist"].getCurrent()[1]
1620 if self.isCategoryItem():
1621 self.mBookmarkManager.deleteCategory(data.mId)
1622 else: self.mBookmarkManager.deleteBookmark(data.mId)
1623 self.updateBookmarkList()
1624 if self.isCategoryItem():
1625 msg = _("Do you want to delete the category and the bookmarks?")
1626 else: msg = _("Do you want to delete the bookmark?")
1627 self.mSession.openWithCallback(cbBlue, MessageBox, msg, MessageBox.TYPE_YESNO, default=True)
1629 if self.isCategoryItem(): return
1631 data = self["bookmarklist"].getCurrent()[1]
1632 url = data.mUrl.strip()
1634 self.session.open(MessageBox, _("Can't open selected bookmark.\n - URL data is empty!!"), type = MessageBox.TYPE_INFO)
1638 lang = language.getLanguage()
1639 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
1640 url = '/usr/local/manual/ru_RU/main.html'
1641 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
1642 url = '/usr/local/manual/de_DE/main.html'
1643 self.close((url, mode))
1646 def keyCancel(self):
1649 class BrowserHelpWindow(Screen, HelpableScreen):
1650 MODE_GLOBAL,MODE_KEYBOARD,MODE_MOUSE = 1,2,3
1652 <screen name="BrowserHelpWindow" position="center,center" size="600,40" title="Browser Help" >
1653 <ePixmap pixmap="skin_default/buttons/red.png" position="5,0" size="140,40" alphatest="on" />
1654 <ePixmap pixmap="skin_default/buttons/green.png" position="155,0" size="140,40" alphatest="on" />
1655 <ePixmap pixmap="skin_default/buttons/yellow.png" position="305,0" size="140,40" alphatest="on" />
1656 <ePixmap pixmap="skin_default/buttons/blue.png" position="450,0" size="140,40" alphatest="on" />
1658 <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" />
1659 <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" />
1660 <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" />
1661 <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" />
1664 def __init__(self, session):
1665 Screen.__init__(self, session)
1666 HelpableScreen.__init__(self)
1668 self["key_red"] = StaticText(_("Exit"))
1669 self["key_green"] = StaticText(_("Global"))
1670 self["key_yellow"] = StaticText(_("Mouse"))
1671 self["key_blue"] = StaticText(_("Keyboard"))
1673 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
1675 "cancel": self.keyRed,
1676 "red" : self.keyRed,
1677 "green" : self.keyGreen,
1678 "yellow": self.keyYellow,
1679 "blue" : self.keyBlue,
1682 self.showHelpTimer = eTimer()
1683 self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
1684 self.showHelpTimer.start(500)
1686 self.onLayoutFinish.append(self.layoutFinished)
1688 def layoutFinished(self):
1689 self.setTitle(_('Browser Help'))
1691 def cbShowHelpTimerClosed(self):
1692 self.showHelpTimer.stop()
1693 self.setHelpModeActions(self.MODE_GLOBAL)
1695 def setHelpModeActions(self, _mode=0):
1697 if _mode == self.MODE_GLOBAL:
1698 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1699 "cancel" : (self.keyPass, _("Exit the Opera browser.")),
1701 self["MenuActions"] = HelpableActionMap(self, "MenuActions", {
1702 "menu" : (self.keyPass, _("Show the Menu window.")),
1704 self["ColorActions"] = HelpableActionMap(self, "ColorActions", {
1705 "green" : (self.keyPass, _("Enter Key")),
1706 "yellow" : (self.keyPass, _("Show the Virtual keyboard window.")),
1707 "blue" : (self.keyPass, _("Backspace Key")),
1709 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1710 "info" : (self.keyPass, _("Switch to keyboard/mouse mode.")),
1713 elif _mode == self.MODE_MOUSE:
1714 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1715 "up" : (self.keyPass, _("It will move the mouse pointer up.")),
1716 "down" : (self.keyPass, _("It will move the mouse pointer down.")),
1717 "left" : (self.keyPass, _("It will move the mouse pointer left.")),
1718 "right" : (self.keyPass, _("It will move the mouse pointer right.")),
1720 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1721 "ok" : (self.keyPass, _("Left Mouse Button")),
1723 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1724 "nextBouquet" : (self.keyPass, _("Right Mouse Button")),
1725 "nextService" : (self.keyPass, _("Left Key")),
1726 "prevService" : (self.keyPass, _("Right Key")),
1728 elif _mode == self.MODE_KEYBOARD:
1729 self["DirectionActions"] = HelpableActionMap(self, "DirectionActions", {
1730 "up" : (self.keyPass, _("Up Key")),
1731 "down" : (self.keyPass, _("Down Key")),
1732 "left" : (self.keyPass, _("Left Key")),
1733 "right" : (self.keyPass, _("Right Key")),
1735 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
1736 "ok" : (self.keyPass, _("Enter Key")),
1738 self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions", {
1739 "nextBouquet" : (self.keyPass, _("PageUp Key")),
1740 "prevBouquet" : (self.keyPass, _("PageDown Key")),
1741 "nextService" : (self.keyPass, _("Go to previous page.")),
1742 "prevService" : (self.keyPass, _("Go to next page.")),
1754 self.setHelpModeActions(self.MODE_GLOBAL)
1755 def keyYellow(self):
1756 self.setHelpModeActions(self.MODE_MOUSE)
1758 self.setHelpModeActions(self.MODE_KEYBOARD)
1760 class OperaBrowser(Screen):
1761 MENUBAR_ITEM_WIDTH = 150
1762 MENUBAR_ITEM_HEIGHT = 30
1763 SUBMENULIST_WIDTH = 200
1764 SUBMENULIST_HEIGHT = 25
1765 SUBMENULIST_NEXT = 2
1767 # menulist->position->y : MENUBAR_ITEM_HEIGHT+30
1768 # menulist->size->x : SUBMENULIST_WIDTH
1769 # submenulist->position->x : SUBMENULIST_WIDTH+50+SUBMENULIST_NEXT
1770 # submenulist->position->y : MENUBAR_ITEM_HEIGHT+30
1771 # submenulist->size->x : SUBMENULIST_WIDTH
1773 size = getDesktop(0).size()
1774 WIDTH = int(size.width())
1775 HEIGHT = int(size.height())
1777 <screen name="OperaBrowser" position="0,0" size="%(width)d,%(height)d" backgroundColor="transparent" flags="wfNoBorder" title="Opera Browser">
1778 <widget name="topArea" zPosition="-1" position="0,0" size="1280,60" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1779 <widget name="menuitemFile" position="30,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1780 <widget name="menuitemTool" position="180,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1781 <widget name="menuitemHelp" position="330,20" size="150,30" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" foregroundColors="#9f1313,#a08500" />
1782 <widget name="menulist" position="50,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1783 <widget name="submenulist" position="252,60" size="200,150" backgroundColor="#000000" zPosition="10" scrollbarMode="showOnDemand" />
1784 <widget name="bottomArea" position="0,%(bottom_pos_y)d" size="%(bottom_size_x)d,80" font="Regular;20" valign="center" halign="center" backgroundColor="#000000" />
1786 """ % { 'width' :WIDTH,
1788 'bottom_pos_y' :HEIGHT-80,
1789 'bottom_size_x' :WIDTH }
1793 def __init__(self, session, url=None):
1794 Screen.__init__(self, session)
1795 self["actions"] = ActionMap(["DirectionActions", "MenuActions", "OkCancelActions"], {
1796 "cancel" : self.keyCancel
1798 ,"left" : self.keyLeft
1799 ,"right" : self.keyRight
1801 ,"down" : self.keyDown
1802 ,"menu" : self.keyMenu
1805 self.UpdateLanguageCB()
1807 self._terminatedBrowser = True
1808 self._enableKeyEvent = True
1809 self._currentPageUrl = None
1810 self._currentPageTitle = None
1811 self.menubarCurrentIndex = 0
1812 self.lvMenuItems = []
1813 self.lvSubMenuItems = []
1815 self["topArea"] = Label()
1816 self["bottomArea"] = Label()
1818 self["menuitemFile"] = MultiColorLabel()# modify menu
1819 self["menuitemTool"] = MultiColorLabel()
1820 self["menuitemHelp"] = MultiColorLabel()
1822 self["menulist"] = MenuList(self.setListOnView())
1823 self["submenulist"] = MenuList(self.setSubListOnView())
1825 self.toggleMainScreenFlag = True
1826 self.toggleListViewFlag = False
1827 self.toggleSubListViewFlag = False
1828 self.currentListView = self["menulist"]
1830 self.onLayoutFinish.append(self.layoutFinished)
1832 self._onCloseTimer = eTimer()
1833 self._onCloseTimer.callback.append(self._cb_onClose)
1836 language.addCallback(self.UpdateLanguageCB)
1838 def UpdateLanguageCB(self):
1840 self.MENUITEMS_LIST = [
1841 [(_('Open Startpage'), None), (_('Open URL'), None), (_('Start/Stop'),None), (_('Exit'), None)],
1842 [(_('Bookmark'), None), (_('Preference'), None)],
1843 [(_('About'), None), (_('Help'), None)]]
1844 self.COMMAND_MAP = {}
1845 self.COMMAND_MAP[_('Exit')] = self._cmd_on_Exit
1846 self.COMMAND_MAP[_('Help')] = self._cmd_on_Help
1847 self.COMMAND_MAP[_('About')] = self._cmd_on_About
1848 self.COMMAND_MAP[_('Open URL')] = self._cmd_on_OpenUrl
1849 self.COMMAND_MAP[_('Start/Stop')] = self._cmd_on_StartStop
1850 self.COMMAND_MAP[_('Bookmark')] = self._cmd_on_Bookmark
1851 self.COMMAND_MAP[_('Preference')] = self._cmd_on_Preference
1852 self.COMMAND_MAP[_('Return')] = self._cmd_on_ReturnToBrowser
1853 self.COMMAND_MAP[_('Open Startpage')] = self._cmd_on_OpenStartpage
1855 def enableRCMouse(self, mode): #mode=[0|1]|[False|True]
1856 rcmouse_path = "/proc/stb/fp/mouse"
1857 if os.path.exists(rcmouse_path):
1858 os.system("echo %d > %s" % (mode, rcmouse_path))
1860 def layoutFinished(self):
1861 self["menuitemFile"].setText(_("File"))# modify menu
1862 self["menuitemTool"].setText(_("Tools"))
1863 self["menuitemHelp"].setText(_("Help"))
1865 self["menulist"].hide()
1866 self["submenulist"].hide()
1868 self["bottomArea"].setText(_("Opera Web Browser Plugin v1.0"))
1869 self.setTitle(_("BrowserMain"))
1870 self.selectMenuitem()
1872 if self.paramUrl is not None:
1874 self.cbUrlText(self.paramUrl, 1)
1876 def selectMenuitem(self):
1877 tmp = [self["menuitemFile"], self["menuitemTool"], self["menuitemHelp"]]# modify menu
1878 self["menuitemFile"].setForegroundColorNum(0)
1879 self["menuitemTool"].setForegroundColorNum(0)
1880 self["menuitemHelp"].setForegroundColorNum(0)
1881 tmp[self.menubarCurrentIndex].setForegroundColorNum(1)
1883 def popupCloseAll(self):
1889 def setListOnView(self):
1890 l = self.MENUITEMS_LIST[self.menubarCurrentIndex]
1891 if not self._terminatedBrowser and self.menubarCurrentIndex == 0: # running
1892 l = [(_('Return'), None)]
1893 self.lvMenuItems = l #self.MENUITEMS_LIST[self.menubarCurrentIndex]
1894 return self.lvMenuItems
1896 def setSubListOnView(self):
1897 self.lvSubMenuItems = []
1898 xl = self["menulist"].getCurrent()[1]
1899 if xl is None: return []
1901 self.lvSubMenuItems.append((x,None))
1902 return self.lvSubMenuItems
1904 def toggleMainScreen(self):
1905 if not self.toggleMainScreenFlag:
1908 self.toggleMainScreenFlag = not self.toggleMainScreenFlag
1910 def toggleListView(self):
1911 if not self.toggleListViewFlag:
1912 self["menulist"].show()
1913 else: self["menulist"].hide()
1914 self.toggleListViewFlag = not self.toggleListViewFlag
1916 def toggleSubListView(self):
1917 if not self.toggleSubListViewFlag:
1918 self["submenulist"].show()
1919 else: self["submenulist"].hide()
1920 self.toggleSubListViewFlag = not self.toggleSubListViewFlag
1922 def setCurrentListView(self, listViewIdx):
1923 if listViewIdx == 0:
1924 self.currentListView = None
1925 elif listViewIdx == 1:
1926 self.currentListView = self["menulist"]
1927 elif listViewIdx == 2:
1928 self.currentListView = self["submenulist"]
1930 def _cb_onClose(self):
1931 self._onCloseTimer.stop()
1932 command_server = getCommandServer()
1934 if self._on_close_window in command_server.onHbbTVCloseCB:
1935 command_server.onHbbTVCloseCB.remove(self._on_close_window)
1936 except Exception, ErrMsg: pass
1938 if self._on_setPageTitle in command_server.onSetPageTitleCB:
1939 command_server.onSetPageTitleCB.remove(self._on_setPageTitle)
1940 except Exception, ErrMsg: pass
1941 self._on_setPageTitle(_('Opera Browser'))
1942 self.enableRCMouse(False)
1943 self.toggleMainScreen()
1945 fbClass.getInstance().unlock()
1946 eRCInput.getInstance().unlock()
1947 self._terminatedBrowser = True
1948 self._enableKeyEvent = True
1949 #if not self.toggleListViewFlag:
1952 self._currentPageUrl = ''
1953 if self.paramUrl is not None:
1959 def _on_setPageTitle(self, title=None):
1960 print "Title :",title
1963 self.setTitle(title)
1965 def cbUrlText(self, data=None, mode=0):
1967 if not _g_helper._is_browser_running():
1969 print "Inputed Url :", data, mode
1970 if strIsEmpty(data):
1973 command_server = getCommandServer()
1974 if self._on_setPageTitle not in command_server.onSetPageTitleCB:
1975 command_server.onSetPageTitleCB.append(self._on_setPageTitle)
1976 if self._on_close_window not in command_server.onHbbTVCloseCB:
1977 command_server.onHbbTVCloseCB.append(self._on_close_window)
1978 self.toggleMainScreen()
1979 self.enableRCMouse(True)
1981 fbClass.getInstance().lock()
1982 eRCInput.getInstance().lock()
1984 setResolution(1280, 720)
1986 command_util = getCommandUtil()
1987 command_util.sendCommand('OP_BROWSER_OPEN_URL', data, mode)
1988 self._terminatedBrowser = False
1989 self._enableKeyEvent = False
1991 def _on_close_window(self):
1992 self._onCloseTimer.start(1000)
1994 def _cb_bookmarkWindowClosed(self, data=None):
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.cbUrlText(url, mode)
2005 def _cmd_on_OpenUrl(self):
2007 if not _g_helper._is_browser_running():
2008 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2009 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2011 self.session.openWithCallback(self.cbUrlText, VirtualKeyBoard, title=(_("Please enter URL here")), text='http://')
2012 def _cmd_on_About(self):
2013 self.session.open(MessageBox, _('Opera Web Browser Plugin v1.0'), type = MessageBox.TYPE_INFO)
2014 def _cmd_on_Exit(self):
2016 def _cb_cmdOnStartSTop(self):
2018 def _cmd_on_StartStop(self):
2020 if _g_helper is None:
2022 _g_helper.showBrowserConfigBox(self._cb_cmdOnStartSTop)
2024 def _cmd_on_Bookmark(self):
2025 url = self._currentPageUrl
2028 title = self._currentPageTitle
2031 self.session.openWithCallback(self._cb_bookmarkWindowClosed, OperaBrowserBookmarkWindow, url, title)
2032 def _cmd_on_Preference(self):
2033 url = self._currentPageUrl
2036 self.session.open(OperaBrowserPreferenceWindow, url)
2037 def _cmd_on_OpenStartpage(self):
2039 if not _g_helper._is_browser_running():
2040 message = _("Opera Browser was not running.\nPlease running browser using [File]>[Start/Stop] menu.")
2041 self.session.open(MessageBox, message, MessageBox.TYPE_INFO)
2044 start = 'http://vuplus.com'
2046 d = OperaBrowserSetting().getData()
2050 self.cbUrlText(start, mode)
2051 def _cmd_on_ReturnToBrowser(self):
2054 def _cmd_on_Help(self):
2055 self.session.open(BrowserHelpWindow)
2057 def doCommand(self, command):
2059 self.COMMAND_MAP[command]()
2060 except Exception, ErrMsg: print ErrMsg
2063 if not self.toggleMainScreenFlag:
2066 if not self.toggleListViewFlag:
2069 if self.currentListView.getCurrent()[1] is None:
2070 self.doCommand(self.currentListView.getCurrent()[0])
2071 #self.session.open(MessageBox, _(self.currentListView.getCurrent()[0]), type = MessageBox.TYPE_INFO)
2075 def updateSelectedMenuitem(self, status):
2076 if self.menubarCurrentIndex == 0 and status < 0:
2077 self.menubarCurrentIndex = 2 # modify menu
2078 elif self.menubarCurrentIndex == 2 and status > 0: # modify menu
2079 self.menubarCurrentIndex = 0
2080 else: self.menubarCurrentIndex += status
2081 self.selectMenuitem()
2084 if not self.toggleMainScreenFlag:
2086 if not self.toggleListViewFlag:
2087 self.updateSelectedMenuitem(-1)
2089 if self.toggleSubListViewFlag:
2090 self.setCurrentListView(1)
2091 self.toggleSubListView()
2093 #if self.currentListView.getSelectedIndex():
2094 self.currentListView.pageUp()
2100 if not self.toggleMainScreenFlag:
2102 if not self.toggleListViewFlag:
2103 self.updateSelectedMenuitem(1)
2105 if self.currentListView is None:
2107 if self.currentListView.getCurrent()[1] is not None:
2108 parentSelectedIndex = self.currentListView.getSelectedIndex()
2109 self.setCurrentListView(2)
2110 self.currentListView.setList(self.setSubListOnView())
2111 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvSubMenuItems)+5)
2112 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))
2113 self.toggleSubListView()
2115 self.currentListView.pageUp()
2121 if not self.toggleMainScreenFlag:
2123 if self.currentListView is None:
2125 if not self.toggleListViewFlag:
2126 self.currentListView.setList(self.setListOnView())
2127 self.currentListView.resize(self.SUBMENULIST_WIDTH, self.SUBMENULIST_HEIGHT*len(self.lvMenuItems)+5)
2128 self.currentListView.move(self.MENUBAR_ITEM_WIDTH*self.menubarCurrentIndex+1+ 50,self.MENUBAR_ITEM_HEIGHT+30)
2129 self.toggleListView()
2131 self.currentListView.down()
2134 if not self.toggleMainScreenFlag:
2136 if self.currentListView is None:
2138 if self.currentListView == self["menulist"]:
2139 if self.currentListView.getSelectedIndex() == 0:
2140 self.toggleListView()
2142 self.currentListView.up()
2144 def keyCancel(self):
2145 if not self._terminatedBrowser:
2146 #self._session.openWithCallback(self._cb_virtualKeyboardClosed, VirtualKeyBoard, title=("Please enter URL here"), text="")
2147 fbClass.getInstance().lock()
2148 eRCInput.getInstance().lock()
2149 setResolution(1280, 720)
2150 if self.toggleListViewFlag:
2151 self.toggleMainScreen()
2152 self._currentPageUrl = None
2153 self._currentPageTitle = None
2154 command_util = getCommandUtil()
2155 command_util.sendCommand('OP_BROWSER_MENU_RES')
2160 self.toggleMainScreen()
2162 def setCurrentPageUrl(self, url, title=None):
2163 self._currentPageUrl = url
2166 if idx > 10: idx = 10
2168 self._currentPageTitle = title
2169 print self._currentPageUrl
2170 self.toggleMainScreen()
2174 def hideSubmenu(self):
2175 self.currentListView.pageUp()
2178 def auto_start_main(reason, **kwargs):
2180 command_server = getCommandServer()
2181 command_server.stop()
2183 from Screens.HelpMenu import HelpableScreen
2184 def session_start_main(session, reason, **kwargs):
2185 fbClass.getInstance().unlock()
2186 eRCInput.getInstance().unlock()
2188 from enigma import getDesktop
2189 desktopSize = getDesktop(0).size()
2190 setDefaultResolution(desktopSize.width(), desktopSize.height())
2193 _g_helper = session.open(HbbTVHelper)
2195 HelpableScreen.__init__ = HelpableScreen__init__
2196 HelpableScreen.session = session
2198 def HelpableScreen__init__(self):
2199 if isinstance(self, HelpableScreen):
2200 HelpableScreen.showManual = showManual
2202 self["helpActions"] = ActionMap(["HelpbuttonActions"], {
2203 "help_b" : self.showHelp,
2204 "help_l" : self.showManual,
2207 _g_clearBrowserDataTimer = eTimer()
2208 def showManual(self):
2209 if not os.path.exists('/usr/local/manual'):
2212 url = 'file:///usr/local/manual/main.html'
2213 lang = language.getLanguage()
2214 if lang == 'ru_RU' and os.path.exists('/usr/local/manual/ru_RU'):
2215 url = 'file:///usr/local/manual/ru_RU/main.html'
2216 elif lang == 'de_DE' and os.path.exists('/usr/local/manual/de_DE'):
2217 url = 'file:///usr/local/manual/de_DE/main.html'
2220 _g_clearBrowserDataTimer.stop()
2221 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2223 setPluginBrowser(None)
2224 def clearBrowserData():
2225 _g_clearBrowserDataTimer.callback.append(_do_clean)
2226 _g_clearBrowserDataTimer.start(50)
2227 setPluginBrowser(self.session.openWithCallback(clearBrowserData, OperaBrowser, url))
2229 def plugin_start_main(session, **kwargs):
2230 #session.open(OperaBrowser)
2232 _g_clearBrowserDataTimer.stop()
2233 try: _g_clearBrowserDataTimer.callback.remove(_do_clean)
2235 setPluginBrowser(None)
2236 def clearBrowserData():
2237 _g_clearBrowserDataTimer.callback.append(_do_clean)
2238 _g_clearBrowserDataTimer.start(50)
2239 setPluginBrowser(session.openWithCallback(clearBrowserData, OperaBrowser))
2241 def plugin_extension_start_application(session, **kwargs):
2243 if _g_helper is None:
2245 _g_helper.showApplicationSelectionBox()
2247 def plugin_extension_browser_config(session, **kwargs):
2249 if _g_helper is None:
2251 _g_helper.showBrowserConfigBox()
2253 def Plugins(path, **kwargs):
2255 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_AUTOSTART, fnc=auto_start_main))
2256 l.append(PluginDescriptor(where=PluginDescriptor.WHERE_SESSIONSTART, needsRestart=True, fnc=session_start_main, weight=-10))
2257 l.append(PluginDescriptor(name=_("HbbTV Applications"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_start_application))
2258 l.append(PluginDescriptor(name=_("Browser Start/Stop"), where=PluginDescriptor.WHERE_EXTENSIONSMENU, needsRestart=True, fnc=plugin_extension_browser_config))
2259 l.append(PluginDescriptor(name=_("Opera Web Browser"), description=_("start opera web browser"), where=PluginDescriptor.WHERE_PLUGINMENU, needsRestart=True, fnc=plugin_start_main))