def _event_handler(self, event):
     logger.log(9, '_event_handler(event=%s), event.arg=%r, event.context=%r, PluginInterface.detached=%r', 
         event, event.arg, event.context, PluginInterface.detached)
     gui = audio.player.get()
     if gui:
         p = gui.player
         if event == BUTTON:
             if event.arg == 'FFWD':
                 p.eventhandler(Event('SEEK', arg='10', context='audio'))
             elif event.arg == 'REW':
                 p.eventhandler(Event('SEEK', arg='-10', context='audio'))
             elif event.arg == 'PAUSE':
                 p.eventhandler(Event('PLAY', context='audio'))
             elif event.arg == 'STOP':
                 PluginInterface.detached = False
                 p.eventhandler(Event('STOP'))
             elif event.arg == 'NEXT':
                 p.eventhandler(Event('PLAYLIST_NEXT', context='audio'))
             elif event.arg == 'PREV':
                 p.eventhandler(Event('PLAYLIST_PREV', context='audio'))
         elif plugin.isevent(event) == 'DETACH':
             p.eventhandler(event)
             self._detach()
         elif plugin.isevent(event) == 'ATTACH':
             self._attach()
             p.eventhandler(event)
         elif event == VIDEO_START:
             PluginInterface.detached = False
             p.eventhandler(Event('STOP'))
         elif event == PLAY_START and gui.visible:
             rc.post_event(plugin.event('ATTACH'))

    def poll(self, menuw=None, arg=None):
        """
        poll to check for devices
        """
        changes = False

        current_devices = util.list_usb_devices()
        for d in current_devices:
            try:
                self.devices.remove(d)
            except ValueError:
                logger.debug('new device %s', d)
                for device, message, action in config.USB_HOTPLUG:
                    if d == device:
                        pop = dialog.show_working_indicator(message)
                        os.system(action)
                        pop.hide()
                        break
                else:
                    changes = True

        for d in self.devices:
            changes = True
            logger.debug('removed device %s', d)

        if changes:
            rc.post_event(plugin.event('USB'))

        self.devices = current_devices

    def stop(self, cmd=''):
        """
        stop the child
        """
        logger.log( 9, 'ChildApp2.stop(cmd=%r)', cmd)
        self.timer.stop()
        rc.unregister(self.stop)

        if cmd and self.isAlive():
            self.write(cmd)
            # wait for the app to terminate itself
            for i in range(60):
                if not self.isAlive():
                    break
                time.sleep(0.1)

        # kill the app
        if self.isAlive():
            self.kill()

        # Ok, we can use the OSD again.
        if self.stop_osd:
            osd.restart()

        if self.is_video:
            rc.post_event(Event(VIDEO_END))

    def __drawn(self, item):

        if plugin.getbyname('osd'):
            plugin.getbyname('osd').draw(('osd', None), self.osd)

        # draw
        self.osd.update()

        # start timer
        if self.duration and self.slideshow and not self.timer:
            self.timer = kaa.OneShotTimer(self.signalhandler)
            self.timer.start(self.duration)


        # stop slideshow at the end if configured
        try:
            index = item.parent.play_items.index(item)+1
            length = len(item.parent.play_items)
            if index == length:
                self.slideshow = config.IMAGEVIEWER_AUTOPLAY

            # send information event to LCD2
            rc.post_event(Event('IMAGE_VIEW_INFO', arg=(index, length, item.name)))
        except Exception, why:
            logger.warning('Invalid parent item: %s', why)

    def init_page(self):

        self.screen_transition = skin.TRANSITION_PAGE

        menu = self.menustack[-1]
        if not menu:
            return

        # Create the list of main selection items (menu_items)
        menu_items           = []
        first                = menu.page_start
        self.rows, self.cols = menu.items_per_page()

        for choice in menu.choices[first : first+(self.rows*self.cols)]:
            menu_items.append(choice)

        self.rows, self.cols = menu.items_per_page()

        self.menu_items = menu_items

        if len(menu_items) == 0:
            self.all_items = menu_items + [ MenuItem('Back', self.back_one_menu) ]
        else:
            self.all_items = menu_items

        if not menu.selected in self.all_items:
            menu.selected = self.all_items[0]

        if not menu.choices:
            menu.selected = self.all_items[0]

        rc.post_event(MENU_PROCESS_END)

    def __init__(self, app, debugname=None, doeslogging=0, stop_osd=2, callback_use_rc=True):
        """
        Initialise ChildApp2
        """
        logger.debug('ChildApp2.__init__(app=%r, debugname=%r, doeslogging=%r, stop_osd=%r)', app, debugname, doeslogging, stop_osd)

        self.timer = kaa.Timer(self.poll)
        self.timer.start(0.1)
        rc.register(self.stop, True, rc.SHUTDOWN)

        self.is_video = 0                       # Be more explicit
        if stop_osd == 2:
            self.is_video = 1
            rc.post_event(Event(VIDEO_START))
            stop_osd = config.OSD_STOP_WHEN_PLAYING

        self.stop_osd = stop_osd
        if self.stop_osd:
            osd.stop()

        if hasattr(self, 'item'):
            rc.post_event(Event(PLAY_START, arg=self.item))

        # return status of the child
        self.status = 0

        # start the child
        ChildApp.__init__(self, app, debugname, doeslogging, callback_use_rc)

    def poll(self):
        """
        plugin polling
        """
        if self.playing:
            self.timer += 1
            if self.timer >= 4:
                self.timer = 0

                # try to connect to xine and check answer
                if self.handle is None:
                    try:
                        self.handle = telnetlib.Telnet("127.0.0.1", 6789)
                        out = self.handle.read_until("\n", 0.1)
                        if out[-1] != "\n":
                            raise
                    except:
                        self.handle = None
                        logger.warning("Cannot telnet to xine at 127.0.0.1:6789")

                # try to get xine time info
                if self.handle is not None:
                    length = self.get_time("length")
                    elapsed = self.get_time("position")
                    if length and elapsed:
                        rc.post_event(Event("VIDEO_PLAY_INFO", arg=(elapsed, length)))

 def error_handler(self):
     """
     error handler if play doesn't work to send the end event and stop
     the player
     """
     rc.post_event(PLAY_END)
     self.stop()

    def run(self):
        logger.debug("run()")
        while 1:
            logger.debug("Record_Thread::run: mode=%s", self.mode)
            if self.mode == "idle":
                self.mode_flag.wait()
                self.mode_flag.clear()

            elif self.mode == "record":
                rc.post_event(Event("RECORD_START", arg=self.prog))
                logger.debug("Record_Thread::run: cmd=%s", self.command)

                self.app = RecordApp(self.command)
                logger.debug("app child pid: %s", self.app.child.pid)

                while self.mode == "record" and self.app.isAlive():
                    self.autokill -= 0.5
                    time.sleep(0.5)
                    if self.autokill <= 0:
                        logger.debug("autokill timeout, stopping recording")
                        self.mode = "stop"

                if self.app.isAlive():
                    logger.debug("Record_Thread::run: past wait!!")
                    self.app.kill()

                rc.post_event(Event("RECORD_STOP", arg=self.prog))
                logger.debug("Record_Thread::run: finished recording")

                self.mode = "idle"
            else:
                self.mode = "idle"
            time.sleep(0.5)

 def poll(self):
     """
     stop everything when child is dead
     """
     logger.log( 8, 'ChildApp2.poll()')
     if not self.isAlive():
         rc.post_event(self.stop_event())
         self.stop()

 def _timer_handler(self):
     if self.active:
         logger.info('Timeout reached without an event, posting events now.')
         for e in config.AUTOSTART_EVENTS:
             rc.post_event(Event(e))
         self.event.unregister()
         self.timer.stop()
         self.active = False

 def shuntItemInCart(self, item):
     ''' Move an image item into or out of the shopping cart
     '''
     if self.cart != [] and item in self.cart:
         self.cart.remove(item)
         rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('Removed Item from Cart')))
     else:
         self.cart.append(item)
         rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('Added Item to Cart')))

 def redraw(self):
     """
     Request that the dialog be redrawn.
     """
     #_stack_('Processing events? %r' % self.processing_event )
     if self.processing_event:
         self.force_redraw = True
     else:
         rc.post_event(event.Event(REDRAW_DIALOG, self))

 def Stop(self):
     """ Stop the xine player """
     logger.debug('XineIvtv.Stop()')
     dialog.disable_overlay_display()
     self.mixer.Stop()
     self.tuner.Stop()
     self.xine.Stop()
     rc.remove_app(self)
     rc.post_event(PLAY_END)
     logger.debug('Stopped %r app', self.mode)

 def eventhandler(self, event=None, menuw=None, arg=None):
     """
     eventhandler to handle the new events
     """
     for r in config.NEW_EVENTS:
         if event == r[0]:
             system(r[1])
             if len(r) > 2:
                 rc.post_event(Event(OSD_MESSAGE, arg=r[2]))
             return True

 def cd_backup(self, arg, menuw=None):
     device, type = arg
     self.rip_thread = main_backup_thread(device=device, rip_format=type)
     self.rip_thread.start()
     # delete the choose format menu
     menuw.delete_menu()
     # delete submenu
     menuw.delete_submenu()
     # show message
     rc.post_event(Event(OSD_MESSAGE, _('Ripping started')))

    def process_data(self):
        str_arg = ''
        command = None

        logger.log( 9, "Data received: %s", str(self.data))
        str_cmd = self.data[:4]
        if str_cmd in ('VOL-', 'VOL+', 'VOLM', 'MAIN', 'STAT'):
            command = self.cmds.get(str_cmd, '')
            if command:
                logger.debug('Event Translation: "%s" -> "%s"', str_cmd, command)
                if str_cmd in ('VOL-', 'VOL+'):
                    self.rc.post_event(em.Event(command, arg=config.MIXER_VOLUME_STEP))
                else:
                    self.rc.post_event(em.Event(command))

        elif str_cmd == 'TEXT':
            str_arg = self.data[4:]
            for letter in str_arg:
                command = self.rc.key_event_mapper(letter)
                if command:
                    logger.debug('Event with arg Translation: "%s" -> "%s %s"', self.data, command, letter)
                    self.rc.post_event(command)

        elif str_cmd == 'MSND':
            self.menu_client_waiting = True
            logger.debug('Client asked for menu')

        elif str_cmd == 'MITM':
            str_arg = self.data[4:]
            try:
                pos = int(str_arg)

                menu = self.menuw.menustack[-1]
                max  = len(menu.choices)
                if pos < max:
                    menu.selected = menu.choices[pos]
                    self.rc.post_event(em.MENU_SELECT)
                else:
                    logger.debug('Menu index too high!: %s (max=%s)', pos, max - 1)

            except ValueError:
                logger.debug('Menu index sent: %s', str_arg)
                pass

        else:
            command = self.rc.key_event_mapper(self.cmds.get(self.data, ''))
            if command:
                logger.debug('Event Translation: "%s" -> "%s"', self.data, command)
                self.rc.post_event(command)

        if command and self.osd_message:
            logger.debug('OSD Event: "%s"', command)
            rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('BT event %s' % command)))

        self.data=''

    def addToCart(self, arg=None, menuw=None):
        if hasattr(self.item, 'subitems') and self.item.subitems:
            for s in self.item.subitems:
                self.cart.append(s)
        else:
            self.cart.append(self.item)

        if isinstance(menuw.menustack[-1].selected, menu.MenuItem):
            rc.post_event(em.MENU_BACK_ONE_MENU)
        else:
            rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('Added to Cart')))

    def removeFromCart(self, arg=None, menuw=None):
        if hasattr(self.item, 'subitems') and self.item.subitems:
            for s in self.item.subitems:
                self.cart.remove(s)
        else:
            self.cart.remove(self.item)

        if isinstance(menuw.menustack[-1].selected, menu.MenuItem):
            rc.post_event(em.MENU_BACK_ONE_MENU)
        else:
            rc.post_event(em.Event(em.OSD_MESSAGE, arg=_('Removed from Cart')))

    def play(self, arg=None, menuw=None):
        logger.debug("%s.play(arg=%r, menuw=%r)", self.__module__, arg, menuw)
        self.elapsed = 0
        if not self.menuw:
            self.menuw = menuw

        self.player = PodCastPlayerGUI(self, menuw)  # LastFM
        error = self.player.play()

        if error and menuw:
            AlertBox(text=error).show()
            rc.post_event(rc.PLAY_END)