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