Exemple #1
0
def Main( settingID=None ):
    setfocusid = 200
    if settingID == "use_intro_movie":
        xbmc.executebuiltin( "Skin.ToggleSetting(Use_Intro_Movie)" )
        xbmc.sleep( 100 )
        setting = ( "false", "true" )[ xbmc.getCondVisibility( "Skin.HasSetting(Use_Intro_Movie" ) ]
        Addon.setSetting( "use_intro_movie", setting )
        xbmc.sleep( 100 )
        setfocusid = ( 102, 103 )[ setting == "false" ]

    elif settingID == "splash":
        toggle = toggle_splash( Addon.getSetting( "splash" ) )
        Addon.setSetting( "splash", toggle )
        xbmc.sleep( 500 )
        setfocusid = ( 110, 111 )[ toggle == "false" ]

    elif settingID == "intro":
        w = DialogSelect( "DialogSelect.xml", Addon.getAddonInfo( "path" ) )
        w.doModal()
        del w
        setfocusid = 104

    xbmc.executebuiltin( "Addon.openSettings(script.xbmc.intro.movie)" )
    xbmc.executebuiltin( "SetFocus(200)" )
    xbmc.executebuiltin( "SetFocus(%i)" % setfocusid )
Exemple #2
0
 def onClick(self, controlId):
     if controlId == schedulesListBoxId:
         self.goEditSchedule()
     elif controlId == refreshButtonId:
         self.xnewa.cleanCache('scheduledRecordings.p')
         self.render()
     elif controlId == sortButtonId:
         order = [
             smartUTF8(__language__(30011)),
             smartUTF8(__language__(30012)),
             smartUTF8(__language__(30042))
         ]
         ret = xbmcgui.Dialog().select(smartUTF8(__language__(30122)),
                                       order)
         if ret != -1:
             if ret == 0:
                 self.sortkey = 'title'
             elif ret == 1:
                 self.sortkey = 'channel'
             elif ret == 2:
                 self.sortkey = 'priority'
             if self.sortkey != self.settings.XNEWA_SORT_RECURRING:
                 self.settings.XNEWA_SORT_RECURRING = self.sortkey
                 addon = Addon()
                 addon.setSetting(id='recurringSort', value=self.sortkey)
             self.render()
Exemple #3
0
    def getSettings( self, id="repository.xbmc.builds" ):
        settings = {}
        try:
            from xbmcaddon import Addon
            addon = Addon( id )
            usetempdir = addon.getSetting( "usetempdir" ) == "true" 
            browsedir  = addon.getSetting( "browsedir" ) == "true" 
            settings[ "downloadpath" ] = ( addon.getSetting( "downloadpath" ), "" )[ browsedir ] 
            if not usetempdir:
                #browse for save dir
                if not settings[ "downloadpath" ] or not os.path.exists( settings[ "downloadpath" ] ):
                    dpath = xbmc.translatePath( self.get_browse_dialog( heading="Recordings folder" ) )
                    if dpath and os.path.exists( dpath ):
                        settings[ "downloadpath" ] = dpath
                        addon.setSetting( "downloadpath", settings[ "downloadpath" ] )
                    else:
                        settings[ "downloadpath" ] = ""
            settings[ "downloadinbackground" ] = addon.getSetting( "downloadinbackground" ) == "true"
            settings[ "reportpercent" ] = int( "0|5|10|20|25|50|100".split( "|" )[ int( addon.getSetting( "reportpercent" ) ) ] )

            PROFILE_PATH = xbmc.translatePath( addon.getAddonInfo( "profile" ) )
            settings[ "iddl_data" ] = os.path.join( PROFILE_PATH, "iddl_data" )
            if not os.path.exists( settings[ "iddl_data" ] ): os.makedirs( settings[ "iddl_data" ] )
        except:
            pass
        return settings
Exemple #4
0
    def getSettings(self, id="repository.xbmc.builds"):
        settings = {}
        try:
            from xbmcaddon import Addon
            addon = Addon(id)
            usetempdir = addon.getSetting("usetempdir") == "true"
            browsedir = addon.getSetting("browsedir") == "true"
            settings["downloadpath"] = (addon.getSetting("downloadpath"),
                                        "")[browsedir]
            if not usetempdir:
                #browse for save dir
                if not settings["downloadpath"] or not os.path.exists(
                        settings["downloadpath"]):
                    dpath = xbmc.translatePath(
                        self.get_browse_dialog(heading="Recordings folder"))
                    if dpath and os.path.exists(dpath):
                        settings["downloadpath"] = dpath
                        addon.setSetting("downloadpath",
                                         settings["downloadpath"])
                    else:
                        settings["downloadpath"] = ""
            settings["downloadinbackground"] = addon.getSetting(
                "downloadinbackground") == "true"
            settings["reportpercent"] = int(
                "0|5|10|20|25|50|100".split("|")[int(
                    addon.getSetting("reportpercent"))])

            PROFILE_PATH = xbmc.translatePath(addon.getAddonInfo("profile"))
            settings["iddl_data"] = os.path.join(PROFILE_PATH, "iddl_data")
            if not os.path.exists(settings["iddl_data"]):
                os.makedirs(settings["iddl_data"])
        except:
            pass
        return settings
Exemple #5
0
def getWeatherSettings( loc_index="1" ):
    try:
        location = Addon.getSetting( 'areacode%s' % loc_index )
        SetProperty( "Location", location )
        for i in range( 1, 4 ):
            SetProperty( "Location%i" % i, Addon.getSetting( "areacode%i" % i ) )
        SetProperty( "Locations", str( i ) )
        Addon.setSetting( 'currentlocation', loc_index )
    except:
        print_exc()
    return location, loc_index
Exemple #6
0
    def onClick( self, controlID ):
        try:
            if controlID in [ 3, 6 ]:
                intro = self.control_list.getSelectedItem().getLabel()
                if intro: Addon.setSetting( "intro", intro )
                self._close_dialog()

            elif controlID == 5:
                self._close_dialog()
        except:
            print_exc()
Exemple #7
0
def getWeatherSettings(loc_index="1"):
    try:
        location = Addon.getSetting('areacode%s' % loc_index)
        SetProperty("Location", location)
        for i in range(1, 4):
            SetProperty("Location%i" % i, Addon.getSetting("areacode%i" % i))
        SetProperty("Locations", str(i))
        Addon.setSetting('currentlocation', loc_index)
    except:
        print_exc()
    return location, loc_index
Exemple #8
0
def service():
    from xml.dom.minidom import parseString
    has_splash = "true"
    dom = None
    try:
        dom = parseString( open( xbmc.translatePath( "special://userdata/advancedsettings.xml" ) ).read() )
        has_splash = dom.getElementsByTagName( "splash" )[ 0 ].firstChild.nodeValue
    except:
        print_exc()
    if dom: dom.unlink()
    if Addon.getSetting( "splash" ) != has_splash:
        Addon.setSetting( "splash", has_splash )
Exemple #9
0
def get_video_url(page_url,
                  premium=False,
                  user="",
                  password="",
                  video_password=""):
    import xbmc
    from xbmcaddon import Addon
    logger.debug("(page_url='%s')" % page_url)
    video_urls = []

    video_id = scrapertools.find_single_match(page_url,
                                              '(?:v=|embed/)([A-z0-9_-]{11})')
    inputstream = platformtools.install_inputstream()

    try:
        __settings__ = Addon(name)
        if inputstream:
            __settings__.setSetting('kodion.video.quality.mpd', 'true')
        else:
            __settings__.setSetting('kodion.video.quality.mpd', 'false')
        # video_urls = [['con YouTube', 'plugin://plugin.video.youtube/play/?video_id=' + video_id ]]
    except:
        path = xbmc.translatePath('special://home/addons/' + name)
        if filetools.exists(path):
            if platformtools.dialog_yesno(config.get_localized_string(70784),
                                          config.get_localized_string(70818)):
                xbmc.executeJSONRPC(
                    '{"jsonrpc": "2.0", "id":1, "method": "Addons.SetAddonEnabled", "params": { "addonid": "'
                    + name + '", "enabled": true }}')
            else:
                return [['', '']]
        else:
            xbmc.executebuiltin('InstallAddon(' + name + ')', wait=True)
            try:
                Addon(name)
            except:
                return [['', '']]
    my_addon = xbmcaddon.Addon('plugin.video.youtube')
    addon_dir = xbmc.translatePath(my_addon.getAddonInfo('path'))
    sys.path.append(filetools.join(addon_dir, 'resources', 'lib'))
    from youtube_resolver import resolve
    for stream in resolve(page_url):
        # title = scrapertools.find_single_match(stream['title'], '(\d+p)')
        if scrapertools.find_single_match(stream['title'], r'(\d+p)'):
            video_urls.append(
                [re.sub(r'(\[[^\]]+\])', '', stream['title']), stream['url']])
    video_urls.sort(key=lambda it: int(it[0].split("p", 1)[0]))

    return video_urls
Exemple #10
0
def get_video_url(page_url,
                  premium=False,
                  user="",
                  password="",
                  video_password=""):
    import xbmc
    from xbmcaddon import Addon
    logger.info("(page_url='%s')" % page_url)
    video_urls = []

    if not page_url.startswith("http"):
        page_url = "http://www.youtube.com/watch?v=%s" % page_url
        logger.info(" page_url->'%s'" % page_url)

    video_id = scrapertools.find_single_match(page_url,
                                              '(?:v=|embed/)([A-z0-9_-]{11})')
    inputstream = platformtools.install_inputstream()
    # from core.support import dbg;dbg()
    try:
        __settings__ = Addon(name)
        if inputstream:
            __settings__.setSetting('kodion.video.quality.mpd', 'true')
        else:
            __settings__.setSetting('kodion.video.quality.mpd', 'false')
        video_urls = [[
            'con YouTube',
            'plugin://plugin.video.youtube/play/?video_id=' + video_id
        ]]
    except:
        if filetools.exists(
                xbmc.translatePath('special://profile/addon_data/' + name)):
            if platformtools.dialog_yesno(config.get_localized_string(70784),
                                          config.get_localized_string(70818)):
                xbmc.executeJSONRPC(
                    '{"jsonrpc": "2.0", "id":1, "method": "Addons.SetAddonEnabled", "params": { "addonid": "'
                    + name + '", "enabled": true }}')
            else:
                return [['', '']]
        else:
            xbmc.executebuiltin('InstallAddon(' + name + ')', wait=True)
            try:
                Addon(name)
            except:
                return [['', '']]

        return get_video_url(page_url)
    return video_urls
Exemple #11
0
 def onClick(self, controlId):
     if controlId == schedulesListBoxId:
         self.goEditSchedule()
     elif controlId == refreshButtonId:
         self.xnewa.cleanCache('scheduledRecordings.p')
         self.render()
     elif controlId == sortButton.Id:
         order = [smartUTF8(__language__(30011)),smartUTF8(__language__(30012)),smartUTF8(__language__(30042))]
         ret = xbmcgui.Dialog().select(smartUTF8(__language__(30122)), order);
         if ret != -1:
             if ret == 0:
                 self.sortkey = 'title'
             elif ret == 1:
                 self.sortkey = 'channel'
             elif ret == 2:
                 self.sortkey = 'priority'
             if self.sortkey != self.settings.XNEWA_SORT_RECURRING:
                 self.settings.XNEWA_SORT_RECURRING = self.sortkey
                 addon = Addon()
                 addon.setSetting(id='recurringSort',value=self.sortkey)
             self.render()
def migrate_from_3_to_4(addon: xbmcaddon.Addon) -> int:

    RANGE_ONCE_TIMERS = 7

    TIMER_DAYS_PRESETS = [
        [],  # off
        [0],  # mon
        [1],  # tue
        [2],  # wed
        [3],  # thu
        [4],  # fri
        [5],  # sat
        [6],  # sun
        [0],  # mons
        [1],  # tues
        [2],  # weds
        [3],  # thus
        [4],  # fris
        [5],  # sats
        [6],  # suns
        [0, 1, 2, 3],  # mon-thu
        [0, 1, 2, 3, 4],  # mon-fri
        [0, 1, 2, 3, 4, 5],  # mon-sat
        [1, 2, 3, 4],  # tue-fri
        [3, 4, 5],  # thu-sat
        [4, 5],  # fri-sat
        [4, 5, 6],  # fri-sun
        [5, 6],  # sat-sun
        [5, 6, 0],  # sat-mon
        [6, 0, 1, 2],  # sun-wed
        [6, 0, 1, 2, 3],  # sun-thu
        [0, 1, 2, 3, 4, 5, 6]  # everyday
    ]

    xbmc.log("[script.timers] migrate settings to version 4", xbmc.LOGINFO)

    for i in range(TIMERS):

        # rename filename -> path
        path = addon.getSetting("timer_%i_filename" % i)
        addon.setSetting("timer_%i_path" % i, path)

        # days: enum -> multiselect
        schedule = int("0%s" % addon.getSetting("timer_%i" % i))
        if schedule > 0:
            days = "|".join([str(d) for d in TIMER_DAYS_PRESETS[schedule]])
            if days and schedule > RANGE_ONCE_TIMERS:
                days += "|7"

            addon.setSetting("timer_%i_days" % i, days)

        else:
            addon.setSetting("timer_%i_days" % i, "")

    return 4
Exemple #13
0
else:
    DEVICE = "Unknown"

try:
    MODEL = platform.release() or 'Unknown'
except IOError:
    # E.g. iOS
    # It seems that Kodi doesn't allow python to spawn subprocesses in order to
    # determine the system name
    # See https://github.com/psf/requests/issues/4434
    MODEL = 'Unknown'

DEVICENAME = try_decode(_ADDON.getSetting('deviceName'))
if not DEVICENAME:
    DEVICENAME = try_decode(xbmc.getInfoLabel('System.FriendlyName'))
    _ADDON.setSetting('deviceName', DEVICENAME)
DEVICENAME = DEVICENAME.replace(":", "")
DEVICENAME = DEVICENAME.replace("/", "-")
DEVICENAME = DEVICENAME.replace("\\", "-")
DEVICENAME = DEVICENAME.replace("<", "")
DEVICENAME = DEVICENAME.replace(">", "")
DEVICENAME = DEVICENAME.replace("*", "")
DEVICENAME = DEVICENAME.replace("?", "")
DEVICENAME = DEVICENAME.replace('|', "")
DEVICENAME = DEVICENAME.replace('(', "")
DEVICENAME = DEVICENAME.replace(')', "")
DEVICENAME = DEVICENAME.replace(' ', "")

COMPANION_PORT = int(_ADDON.getSetting('companionPort'))

# Unique ID for this Plex client; also see clientinfo.py
# condition pour mettre a jour la base
UpdateUserDB = False

# initialize Keyboard
kb = xbmc.Keyboard( default, heading, hidden )
# optional hidden pass
kb.setHiddenInput( hidden )
# call Keyboard
kb.doModal()
# si confirmation on continue les changement
if kb.isConfirmed():
    # recup du text
    text = kb.getText()
    # si le text est pas vide et pas pareil que le default ou pas de token, on change
    if text:# and ( text != default or not hasToken ):
        Addon.setSetting( "scraper", "Media-Passion" )
        # set our codes
        if settingId == "username":
            token    = sha1( text.lower() + passw ).hexdigest()
            tokenb64 = b64encode( text )
            login    = text
            if not passw:
                xbmc.executebuiltin( "Action(Down)" )
        else:
            token    = sha1( login.lower() + text ).hexdigest()
            tokenb64 = b64encode( login )
            passw    = text
        # save cached settings infos
        Addon.setSetting( "token"    , token )
        Addon.setSetting( "tokenb64" , tokenb64 )
        # save setting for visible infos
Exemple #15
0
# condition pour mettre a jour la base
UpdateUserDB = False

# initialize Keyboard
kb = xbmc.Keyboard( default, heading, hidden )
# optional hidden pass
kb.setHiddenInput( hidden )
# call Keyboard
kb.doModal()
# si confirmation on continue les changement
if kb.isConfirmed():
    # recup du text
    text = kb.getText()
    # si le text est pas vide et pas pareil que le default ou pas de token, on change
    if text:# and ( text != default or not hasToken ):
        Addon.setSetting( "scraper", ( "Cine-Passion", "Media-Passion" )[ bool( settingMP ) ] )
        # set our codes
        if settingId == "username" + settingMP:
            token    = sha1( text.lower() + passw ).hexdigest()
            tokenb64 = b64encode( text )
            login    = text
            if not passw:
                xbmc.executebuiltin( "Action(Down)" )
        else:
            token    = sha1( login.lower() + text ).hexdigest()
            tokenb64 = b64encode( login )
            passw    = text
        # save cached settings infos
        Addon.setSetting( "token"    + settingMP, token )
        Addon.setSetting( "tokenb64" + settingMP, tokenb64 )
        # save setting for visible infos
Exemple #16
0
class NetflixCommon(object):
    """
    Stuff shared between / used from service and addon"""
    def __init__(self, plugin_handle, base_url):

        self.addon = Addon()
        self.data_path = xbmc.translatePath(self.addon.getAddonInfo('profile'))
        self.cookie_path = self.data_path + 'COOKIE'
        self.plugin = self.addon.getAddonInfo('name')
        self.verb_log = self.addon.getSetting('logging') == 'true'
        self.plugin_handle = plugin_handle
        self.base_url = base_url
        self.version = self.addon.getAddonInfo('version')

        xbmcvfs.mkdir(path=self.data_path)

    def get_addon(self):
        """Return the current addon instance"""
        return self.addon

    def get_addon_info(self, name):
        """Return the current addon instance"""
        return self.addon.getAddonInfo(name)

    def set_setting(self, key, value):
        return self.addon.setSetting(key, value)

    def get_setting(self, key):
        return self.addon.getSetting(key)

    def flush_settings(self):
        self.addon = Addon()

    def get_esn(self):
        """
        Returns the esn from settings
        """
        return self.addon.getSetting('esn')

    def set_esn(self, esn):
        """
        Returns True if MSL reset is required
        """
        stored_esn = self.get_esn()
        if not stored_esn and esn:
            self.set_setting('esn', esn)
            return True
        return False

    def get_credentials(self):
        from NetflixCredentials import NetflixCredentials
        email = self.get_setting('email')
        password = self.get_setting('password')

        if '@' in email:
            self.set_credentials(email, password)
            return {'email': email, 'password': password}

        return NetflixCredentials().decode_credentials(email, password)

    def set_credentials(self, email, password):
        from NetflixCredentials import NetflixCredentials
        encoded = NetflixCredentials().encode_credentials(email, password)
        self.set_setting('email', encoded['email'])
        self.set_setting('password', encoded['password'])

    def log(self, msg, level=xbmc.LOGDEBUG):
        """Adds a log entry to the Kodi log

        Parameters
        ----------
        msg : :obj:`str`
            Entry that should be turned into a list item

        level : :obj:`int`
            Kodi log level
        """
        if isinstance(msg, unicode):
            msg = msg.encode('utf-8')
        xbmc.log('[%s] %s' % (self.plugin, msg.__str__()), level)

    @staticmethod
    def check_folder_path(path):
        """
        Check if folderpath ends with path delimator
        If not correct it (makes sure xbmcvfs.exists is working correct)
        """
        if isinstance(path, unicode):
            check = path.encode('ascii', 'ignore')
            if '/' in check and not str(check).endswith('/'):
                end = u'/'
                path = path + end
                return path
            if '\\' in check and not str(check).endswith('\\'):
                end = u'\\'
                path = path + end
                return path
        if '/' in path and not str(path).endswith('/'):
            path = path + '/'
            return path
        if '\\' in path and not str(path).endswith('\\'):
            path = path + '\\'
            return path

    @staticmethod
    def file_exists(data_path, filename):
        """
        Checks if a given file exists
        :param filename: The filename
        :return: True if so
        """
        return xbmcvfs.exists(path=data_path + filename)

    @staticmethod
    def save_file(data_path, filename, content):
        """
        Saves the given content under given filename
        :param filename: The filename
        :param content: The content of the file
        """

        file_handle = xbmcvfs.File(filepath=data_path + filename, mode='w')
        file_content = file_handle.write(content)
        file_handle.close()

    @staticmethod
    def load_file(data_path, filename):
        """
        Loads the content of a given filename
        :param filename: The file to load
        :return: The content of the file
        """
        file_handle = xbmcvfs.File(filepath=data_path + filename)
        file_content = file_handle.read()
        file_handle.close()
        return file_content

    @staticmethod
    def list_dir(data_path):
        return xbmcvfs.listdir(data_path)
Exemple #17
0
class KodiWrapper:
    """ A wrapper around all Kodi functionality """
    def __init__(self, routing=None):
        """ Initialize the Kodi wrapper """
        self.routing = None
        if routing:
            self.routing = routing
            self._handle = self.routing.handle
            self._url = self.routing.base_url
        self._addon = Addon()
        self._system_locale_works = None
        self._addon_name = self._addon.getAddonInfo('name')
        self._addon_id = self._addon.getAddonInfo('id')
        self._global_debug_logging = self.get_global_setting(
            'debug.showloginfo')  # Returns a boolean
        self._debug_logging = self.get_setting_as_bool('debug_logging')
        self._cache_path = self.get_userdata_path() + 'cache/'

    def show_listing(self,
                     title_items,
                     category=None,
                     sort='unsorted',
                     content=None,
                     cache=True):
        """ Show a virtual directory in Kodi """
        if content:
            # content is one of: files, songs, artists, albums, movies, tvshows, episodes, musicvideos, videos, images, games
            xbmcplugin.setContent(self._handle, content=content)

        # Jump through hoops to get a stable breadcrumbs implementation
        category_label = ''
        if category:
            if not content:
                category_label = self._addon_name + ' / '
            if self.kids_mode():
                category_label += 'KIDS / '
            if isinstance(category, int):
                category_label += self.localize(category)
            else:
                category_label += category
        elif not content:
            category_label = self._addon_name
            if self.kids_mode():
                category_label += ' / KIDS'

        xbmcplugin.setPluginCategory(handle=self._handle,
                                     category=category_label)

        # Add all sort methods to GUI (start with preferred)
        xbmcplugin.addSortMethod(handle=self._handle,
                                 sortMethod=SORT_METHODS[sort])
        for key in sorted(SORT_METHODS):
            if key != sort:
                xbmcplugin.addSortMethod(handle=self._handle,
                                         sortMethod=SORT_METHODS[key])

        # Add the listings
        listing = []
        for title_item in title_items:
            list_item = self._generate_listitem(title_item)

            is_folder = bool(not title_item.is_playable and title_item.path)
            url = title_item.path if title_item.path else None
            listing.append((url, list_item, is_folder))

        succeeded = xbmcplugin.addDirectoryItems(self._handle, listing,
                                                 len(listing))
        xbmcplugin.endOfDirectory(self._handle, succeeded, cacheToDisc=cache)

    @staticmethod
    def _generate_listitem(title_item):
        """ Generate a ListItem from a TitleItem """
        from xbmcgui import ListItem

        # Three options:
        #  - item is a virtual directory/folder (not playable, path)
        #  - item is a playable file (playable, path)
        #  - item is non-actionable item (not playable, no path)
        is_folder = bool(not title_item.is_playable and title_item.path)
        is_playable = bool(title_item.is_playable and title_item.path)

        list_item = ListItem(label=title_item.title, path=title_item.path)

        if title_item.prop_dict:
            list_item.setProperties(title_item.prop_dict)
        list_item.setProperty(key='IsPlayable',
                              value='true' if is_playable else 'false')

        list_item.setIsFolder(is_folder)

        if title_item.art_dict:
            list_item.setArt(title_item.art_dict)

        if title_item.info_dict:
            # type is one of: video, music, pictures, game
            list_item.setInfo(type='video', infoLabels=title_item.info_dict)

        if title_item.stream_dict:
            # type is one of: video, audio, subtitle
            list_item.addStreamInfo('video', title_item.stream_dict)

        if title_item.context_menu:
            list_item.addContextMenuItems(title_item.context_menu)

        return list_item

    def play(self, title_item, license_key=None):
        """ Play the passed TitleItem.
        :type title_item: TitleItem
        :type license_key: string
        """
        play_item = self._generate_listitem(title_item)
        play_item.setProperty('inputstreamaddon', 'inputstream.adaptive')
        play_item.setProperty('inputstream.adaptive.max_bandwidth',
                              str(self.get_max_bandwidth() * 1000))
        play_item.setProperty('network.bandwidth',
                              str(self.get_max_bandwidth() * 1000))
        play_item.setProperty('inputstream.adaptive.manifest_type', 'mpd')
        play_item.setMimeType('application/dash+xml')
        play_item.setContentLookup(False)

        if license_key is not None:
            play_item.setProperty('inputstream.adaptive.license_type',
                                  'com.widevine.alpha')
            play_item.setProperty('inputstream.adaptive.license_key',
                                  license_key)

        if title_item.subtitles_path:
            play_item.setSubtitles(title_item.subtitles_path)

        # To support video playback directly from RunPlugin() we need to use xbmc.Player().play instead of
        # setResolvedUrl that only works with PlayMedia() or with internal playable menu items
        xbmcplugin.setResolvedUrl(self._handle, True, listitem=play_item)

        if self.get_setting_as_bool('showsubtitles'):
            while not xbmc.Player().isPlaying() and not xbmc.Monitor(
            ).abortRequested():
                xbmc.sleep(100)
            xbmc.Player().showSubtitles(True)

    @staticmethod
    def get_search_string(heading='', message=''):
        """ Ask the user for a search string """
        search_string = None
        keyboard = xbmc.Keyboard(message, heading)
        keyboard.doModal()
        if keyboard.isConfirmed():
            search_string = to_unicode(keyboard.getText())
        return search_string

    def show_ok_dialog(self, heading='', message=''):
        """ Show Kodi's OK dialog """
        from xbmcgui import Dialog
        if not heading:
            heading = self._addon.getAddonInfo('name')
        return Dialog().ok(heading=heading, line1=message)

    def show_notification(self,
                          heading='',
                          message='',
                          icon='info',
                          time=4000):
        """ Show a Kodi notification """
        from xbmcgui import Dialog
        if not heading:
            heading = self._addon.getAddonInfo('name')
        Dialog().notification(heading=heading,
                              message=message,
                              icon=icon,
                              time=time)

    def show_multiselect(self,
                         heading='',
                         options=None,
                         autoclose=0,
                         preselect=None,
                         use_details=False):
        """ Show a Kodi multi-select dialog """
        from xbmcgui import Dialog
        if not heading:
            heading = self._addon.getAddonInfo('name')
        return Dialog().multiselect(heading=heading,
                                    options=options,
                                    autoclose=autoclose,
                                    preselect=preselect,
                                    useDetails=use_details)

    def show_progress(self, heading='', message=''):
        """ Show a Kodi progress dialog """
        from xbmcgui import DialogProgress
        if not heading:
            heading = self._addon.getAddonInfo('name')
        progress = DialogProgress()
        progress.create(heading=heading, line1=message)
        return progress

    def show_progress_background(self, heading='', message=''):
        """ Show a Kodi progress dialog """
        from xbmcgui import DialogProgressBG
        if not heading:
            heading = self._addon.getAddonInfo('name')
        progress = DialogProgressBG()
        progress.create(heading=heading, message=message)
        return progress

    def set_locale(self):
        """ Load the proper locale for date strings """
        import locale
        locale_lang = self.get_global_setting('locale.language').split('.')[-1]
        try:
            # NOTE: This only works if the platform supports the Kodi configured locale
            locale.setlocale(locale.LC_ALL, locale_lang)
            return True
        except Exception as exc:  # pylint: disable=broad-except
            if locale_lang == 'en_gb':
                return True
            self.log("Your system does not support locale '{locale}': {error}",
                     LOG_DEBUG,
                     locale=locale_lang,
                     error=exc)
            return False

    def localize(self, string_id, **kwargs):
        """ Return the translated string from the .po language files, optionally translating variables """
        if kwargs:
            import string
            return string.Formatter().vformat(
                self._addon.getLocalizedString(string_id), (),
                SafeDict(**kwargs))

        return self._addon.getLocalizedString(string_id)

    def get_setting(self, setting_id, default=None):
        """ Get an add-on setting """
        value = to_unicode(self._addon.getSetting(setting_id))
        if value == '' and default is not None:
            return default
        return value

    def get_setting_as_bool(self, setting):
        """ Get an add-on setting as a boolean value """
        return self.get_setting(setting).lower() == "true"

    def set_setting(self, setting_id, setting_value):
        """ Set an add-on setting """
        return self._addon.setSetting(setting_id, setting_value)

    def open_settings(self):
        """ Open the add-in settings window """
        self._addon.openSettings()

    @staticmethod
    def get_global_setting(setting):
        """ Get a Kodi setting """
        import json
        json_result = xbmc.executeJSONRPC(
            '{"jsonrpc": "2.0", "method": "Settings.GetSettingValue", "params": {"setting": "%s"}, "id": 1}'
            % setting)
        return json.loads(json_result).get('result', dict()).get('value')

    def get_cache(self, key, ttl=None):
        """ Get an item from the cache
        :type key: list[str]
        :type ttl: int
        """
        import time

        fullpath = self._cache_path + '.'.join(key)

        if not self.check_if_path_exists(fullpath):
            return None

        if ttl and time.mktime(
                time.localtime()) - self.stat_file(fullpath).st_mtime() > ttl:
            return None

        with self.open_file(fullpath, 'r') as fdesc:
            try:
                import json
                value = json.load(fdesc)
                self.log('Fetching {file} from cache', file=fullpath)
                return value
            except (ValueError, TypeError):
                return None

    def set_cache(self, key, data):
        """ Store an item in the cache
        :type key: list[str]
        :type data: str
        """
        if not self.check_if_path_exists(self._cache_path):
            self.mkdirs(self._cache_path)

        fullpath = self._cache_path + '.'.join(key)
        with self.open_file(fullpath, 'w') as fdesc:
            import json
            self.log('Storing to cache as {file}', file=fullpath)
            json.dump(data, fdesc)

    def invalidate_cache(self, ttl=None):
        """ Clear the cache """
        if not self.check_if_path_exists(self._cache_path):
            return
        _, files = self.listdir(self._cache_path)
        import time
        now = time.mktime(time.localtime())
        for filename in files:
            fullpath = self._cache_path + filename
            if ttl and now - self.stat_file(fullpath).st_mtime() < ttl:
                continue
            self.delete_file(fullpath)

    def get_max_bandwidth(self):
        """ Get the max bandwidth based on Kodi and add-on settings """
        addon_max_bandwidth = int(self.get_setting('max_bandwidth', '0'))
        global_max_bandwidth = int(
            self.get_global_setting('network.bandwidth'))
        if addon_max_bandwidth != 0 and global_max_bandwidth != 0:
            return min(addon_max_bandwidth, global_max_bandwidth)
        if addon_max_bandwidth != 0:
            return addon_max_bandwidth
        if global_max_bandwidth != 0:
            return global_max_bandwidth
        return 0

    def get_proxies(self):
        """ Return a usable proxies dictionary from Kodi proxy settings """
        usehttpproxy = self.get_global_setting('network.usehttpproxy')
        if usehttpproxy is not True:
            return None

        try:
            httpproxytype = int(
                self.get_global_setting('network.httpproxytype'))
        except ValueError:
            httpproxytype = 0

        socks_supported = has_socks()
        if httpproxytype != 0 and not socks_supported:
            # Only open the dialog the first time (to avoid multiple popups)
            if socks_supported is None:
                self.show_ok_dialog('',
                                    self.localize(30966))  # Requires PySocks
            return None

        proxy_types = ['http', 'socks4', 'socks4a', 'socks5', 'socks5h']
        if 0 <= httpproxytype < 5:
            httpproxyscheme = proxy_types[httpproxytype]
        else:
            httpproxyscheme = 'http'

        httpproxyserver = self.get_global_setting('network.httpproxyserver')
        httpproxyport = self.get_global_setting('network.httpproxyport')
        httpproxyusername = self.get_global_setting(
            'network.httpproxyusername')
        httpproxypassword = self.get_global_setting(
            'network.httpproxypassword')

        if httpproxyserver and httpproxyport and httpproxyusername and httpproxypassword:
            proxy_address = '%s://%s:%s@%s:%s' % (
                httpproxyscheme, httpproxyusername, httpproxypassword,
                httpproxyserver, httpproxyport)
        elif httpproxyserver and httpproxyport and httpproxyusername:
            proxy_address = '%s://%s@%s:%s' % (httpproxyscheme,
                                               httpproxyusername,
                                               httpproxyserver, httpproxyport)
        elif httpproxyserver and httpproxyport:
            proxy_address = '%s://%s:%s' % (httpproxyscheme, httpproxyserver,
                                            httpproxyport)
        elif httpproxyserver:
            proxy_address = '%s://%s' % (httpproxyscheme, httpproxyserver)
        else:
            return None

        return dict(http=proxy_address, https=proxy_address)

    @staticmethod
    def get_cond_visibility(condition):
        """ Test a condition in XBMC """
        return xbmc.getCondVisibility(condition)

    def has_inputstream_adaptive(self):
        """ Whether InputStream Adaptive is installed and enabled in add-on settings """
        return self.get_setting(
            'useinputstreamadaptive',
            'true') == 'true' and xbmc.getCondVisibility(
                'System.HasAddon(inputstream.adaptive)') == 1

    def credentials_filled_in(self):
        """ Whether the add-on has credentials filled in """
        return bool(
            self.get_setting('username') and self.get_setting('password'))

    @staticmethod
    def kodi_version():
        """ Returns major Kodi version """
        return int(xbmc.getInfoLabel('System.BuildVersion').split('.')[0])

    def can_play_drm(self):
        """ Whether this Kodi can do DRM using InputStream Adaptive """
        return self.get_setting('usedrm',
                                'true') == 'true' and self.get_setting(
                                    'useinputstreamadaptive',
                                    'true') == 'true' and self.supports_drm()

    def supports_drm(self):
        """ Whether this Kodi version supports DRM decryption using InputStream Adaptive """
        return self.kodi_version() > 17

    def get_userdata_path(self):
        """ Return the profile's userdata path """
        return to_unicode(
            xbmc.translatePath(self._addon.getAddonInfo('profile')))

    def get_addon_path(self):
        """ Return the profile's addon path """
        return to_unicode(xbmc.translatePath(self._addon.getAddonInfo('path')))

    def get_addon_info(self, key):
        """ Return addon information """
        return self._addon.getAddonInfo(key)

    @staticmethod
    def listdir(path):
        """ Return all files in a directory (using xbmcvfs)"""
        from xbmcvfs import listdir
        return listdir(path)

    def mkdir(self, path):
        """ Create a directory (using xbmcvfs) """
        from xbmcvfs import mkdir
        self.log("Create directory '{path}'.", LOG_DEBUG, path=path)
        return mkdir(path)

    def mkdirs(self, path):
        """ Create directory including parents (using xbmcvfs) """
        from xbmcvfs import mkdirs
        self.log("Recursively create directory '{path}'.",
                 LOG_DEBUG,
                 path=path)
        return mkdirs(path)

    @staticmethod
    def check_if_path_exists(path):
        """ Whether the path exists (using xbmcvfs)"""
        from xbmcvfs import exists
        return exists(path)

    @staticmethod
    @contextmanager
    def open_file(path, flags='r'):
        """ Open a file (using xbmcvfs) """
        from xbmcvfs import File
        fdesc = File(path, flags)
        yield fdesc
        fdesc.close()

    @staticmethod
    def stat_file(path):
        """ Return information about a file (using xbmcvfs) """
        from xbmcvfs import Stat
        return Stat(path)

    def delete_file(self, path):
        """ Remove a file (using xbmcvfs) """
        from xbmcvfs import delete
        self.log("Delete file '{path}'.", LOG_DEBUG, path=path)
        return delete(path)

    def end_of_directory(self):
        """ Close a virtual directory, required to avoid a waiting Kodi """
        xbmcplugin.endOfDirectory(handle=self._handle,
                                  succeeded=False,
                                  updateListing=False,
                                  cacheToDisc=False)

    def log(self, message, log_level=LOG_INFO, **kwargs):
        """ Log info messages to Kodi """
        if not self._global_debug_logging and self._debug_logging and log_level in [
                LOG_DEBUG, LOG_INFO
        ]:
            # If Debug Logging is not enabled, Kodi filters everything up to NOTICE out
            log_level = LOG_NOTICE
        if kwargs:
            import string
            message = string.Formatter().vformat(message, (),
                                                 SafeDict(**kwargs))
        message = '[{addon}] {message}'.format(addon=self._addon_id,
                                               message=message)
        xbmc.log(msg=from_unicode(message), level=log_level)

    def kids_mode(self):
        """ Returns if kids zone is active """
        if self.get_setting_as_bool('force_kids_zone'):
            return True

        if self.routing and self.routing.path.startswith('/kids'):
            return True
        return False
    text = kb.getText()
    # si le text est pas vide et pas pareil que le default ou pas de token, on change
    if text:# and ( text != default or not hasToken ):
        # set our codes
        if settingId == "username":
            token = sha1( text.lower() + passw ).hexdigest()
            tokenb64 = b64encode( text )
            login = text
            if not passw:
                xbmc.executebuiltin( "Action(Down)" )
        else:
            token = sha1( login.lower() + text ).hexdigest()
            tokenb64 = b64encode( login )
            passw = text
        # save cached settings infos
        Addon.setSetting( "token", token )
        Addon.setSetting( "tokenb64", tokenb64 )
        # save setting for visible infos
        Addon.setSetting( settingId, text )
        UpdateUserDB = True
# reset hidden input
kb.setHiddenInput( False )


if UpdateUserDB:
    # Modules General
    import time
    # temps du depart
    t1 = time.time()
    from re import findall, sub
    from urllib import quote_plus
Exemple #19
0
kb.doModal()
# si confirmation on continue les changement
if kb.isConfirmed():
    # recup du text
    text = kb.getText()
    # si le text est pas vide et pas pareil que le default ou pas de token, on change
    if text:# and ( text != default or not hasToken ):
        # set our codes
        if settingId == "username":
            token = sha.new( text.lower() + passw ).hexdigest()
            tokenb64 = b64encode( text )
        else:
            token = sha.new( login.lower() + text ).hexdigest()
            tokenb64 = b64encode( login )
        # save cached settings infos
        Addon.setSetting( "token", token )
        Addon.setSetting( "tokenb64", tokenb64 )
        # save setting for visible infos
        Addon.setSetting( settingId, text )
        CloseDialogs = True
        UpdateUserDB = True
# reset hidden input
kb.setHiddenInput( False )

if CloseDialogs:
    if AddonInfoIsVisible:
        # fermeture du dialogue addon info
        xbmc.executebuiltin( "Dialog.Close(addoninformation)" )
        xbmc.sleep( 200 )

    if xbmc.getCondVisibility( "Window.IsVisible(addonsettings)" ):#AddonSettingsIsVisible:
Exemple #20
0
    # 8- write back data
    #


def getFolders():
    global watched_db, watched_pending_db
    watched_pending_db = os.path.join(
        ADDON_CACHE,
        "watched_pending_" + str(ADDON.getSetting("username")) + ".db")
    watched_db = os.path.join(
        ADDON_CACHE, "watched_" + str(ADDON.getSetting("username")) + ".db")


if not ADDON.getSetting("setupOK"):
    ADDON.openSettings()
    ADDON.setSetting("setupOK", "True")


def getPendingWatchFile():
    global watched_db, watched_pending_db

    if os.path.exists(watched_pending_db):
        pendWatched = open(watched_pending_db).read()
    else:
        f = open(watched_pending_db, "w")
        f.write("{}")
        f.close()
        pendWatched = "{}"

    data = None
    try:
Exemple #21
0
class Translator(xbmcgui.WindowXML):
    CONTROL_LIST_A = 50

    def __init__(self, *args, **kwargs):
        self.RestartXBMC_ReloadLanguage = False
        self.IsModified = False
        self.googleTrans = False
        self.listitems = []

        self.Addon = Addon(AddonId)
        self._get_settings()

    def _get_settings(self):
        self.settings = {}
        self.settings["LanguagePath"] = self.Addon.getSetting("LanguagePath")

        self.settings["viewmode"] = int(self.Addon.getSetting("viewmode"))
        self.settings["sortmethod"] = int(self.Addon.getSetting("sortmethod"))
        self.settings["sortorder"] = int(self.Addon.getSetting("sortorder"))
        self.settings["savefolderviews"] = (
            self.Addon.getSetting("savefolderviews") == "true")

    def setListItems(self):
        self.DefaultLanguage = "English"
        self.CurrentLanguage = xbmc.getLanguage()
        self.FolderLanguage = self.settings["LanguagePath"]
        self.DefaultFolderLanguage = "special://xbmc/language/"
        if not os.path.exists(xbmc.translatePath(self.FolderLanguage)):
            print "Folder language not exists! '%s'" % self.FolderLanguage
            self.FolderLanguage = self.DefaultFolderLanguage

        if not self.FolderLanguage.startswith("special"):
            for folder in ["profile", "home", "xbmc"]:
                special = "special://%s/" % folder
                self.FolderLanguage = self.FolderLanguage.replace(
                    xbmc.translatePath(special), special)

        if (xbmc.translatePath("special://skin/")
                in xbmc.translatePath(self.FolderLanguage)):
            self.FolderLanguage = "special://skin/language/"
        self.FolderLanguage = self.FolderLanguage.replace("\\",
                                                          "/").rstrip("/")

        self.setContainerProperties()
        # get languages source
        self.language = Language(self)
        self.listitems = self.language.listitems

    def onInit(self):
        xbmc.executebuiltin("ActivateWindow(busydialog)")
        self.setSortMethodControl()
        self.setContainer(setviewmode=self.settings["viewmode"])
        LOG("notice", "initialized took %s", time_took(START_TIME))
        xbmc.executebuiltin("Dialog.Close(busydialog)")

    def setSortMethodControl(self):
        label = (20316, 103)[self.settings["sortmethod"]]
        self.getControl(13).setLabel(xbmc.getLocalizedString(label))

    def setContainerProperties(self):
        self.setProperty("IsModified",
                         ("",
                          "Language file has been changed!")[self.IsModified])
        self.setProperty("CurrentLanguage", self.CurrentLanguage)
        self.setProperty("FolderLanguage", self.FolderLanguage)
        self.setProperty("CurrentEnglishString", "")
        self.Addon = Addon(AddonId)
        self.setProperty("ExtraKeyboard_TopOrBottom",
                         ("top",
                          "bottom")[int(self.Addon.getSetting("ExtraKB"))])

    def setContainer(self, filter="", SelectId="", setviewmode=None):
        if setviewmode is not None:
            self.ContainerId = (50, 51)[setviewmode]
            if setviewmode: xbmc.executebuiltin("SendClick(2)")
        else:
            self.ContainerId = (
                50, 51)[xbmc.getCondVisibility("Control.IsVisible(51)")]
        try:

            if not bool(self.listitems):
                if self.IsModified:
                    # ask for save change
                    self._save_change()
                self.IsModified = False
                self.googleTrans = False
                self.getControl(self.ContainerId).reset()
                self.setListItems()

            self.setContainerProperties()
            if self.listitems:
                selectitem = 0

                additems = []
                if not filter:
                    additems = self.listitems
                else:
                    for li in self.listitems:
                        if filter == "UnTranslated" and li.getProperty(
                                "UnTranslated") == "false":
                            continue
                        if filter == "Translated" and li.getProperty(
                                "IsModified") != "true":
                            continue
                        additems.append(li)

                if additems:
                    if self.settings["sortmethod"]:
                        additems = sorted(additems,
                                          key=lambda li: normalize_string(
                                              li.getLabel(), True))
                    if self.settings["sortorder"]:
                        additems = list(reversed(additems))
                    for count, li in enumerate(additems):
                        if li.getProperty("id") == SelectId:
                            selectitem = count

                # add listitems
                self.getControl(self.ContainerId).reset()
                self.getControl(self.ContainerId).addItems(additems)
                if additems:  #self.getControl( self.ContainerId ).size():
                    self.getControl(self.ContainerId).selectItem(selectitem)
                    self.setFocusId(self.ContainerId)

            # fixe view on xbox
            if UNDER_XBOX and setviewmode is not None:
                xbmc.executebuiltin("Container.SetViewMode(%i)" %
                                    self.ContainerId)
                xbmc.sleep(20)
                self.setFocusId(self.ContainerId)
        except:
            print_exc()

    def onFocus(self, controlID):
        pass

    def sendClick(self, controlID):
        try:
            self.onClick(controlID)
        except:
            print_exc()

    def getTranslate(self, text, minimal=2):
        translated = ""
        if text:
            if (len(text) <= minimal) or text.isdigit():
                translated = text
            else:
                country = self.Addon.getSetting("country")
                if country.lower() == "auto": country = self.CurrentLanguage
                pDialog = xbmcgui.DialogProgress()
                pDialog.create("Google Translate", "English to %s" % country,
                               text, "Please wait...")
                try:
                    import LanguageTools
                    translated = LanguageTools.translate_text(
                        text, country, "google")
                except:
                    print_exc()
        self.googleTrans = False
        xbmc.executebuiltin("Dialog.Close(progressdialog)")
        return translated

    def onClick(self, controlID):
        try:
            self.ContainerId = (
                50, 51)[xbmc.getCondVisibility("Control.IsVisible(51)")]
            if controlID == self.ContainerId:
                # get clicked listitem
                listitem = self.getControl(self.ContainerId).getSelectedItem()
                # get position
                pos = int(listitem.getProperty("Position"))
                # get id
                id = listitem.getProperty("id")
                if id:
                    CurrentEnglishString = fixe_line_return(
                        listitem.getLabel2(), True)

                    DefaultText = fixe_line_return(listitem.getLabel(), True)
                    old_text = DefaultText
                    if self.googleTrans:
                        old_text = self.getTranslate(CurrentEnglishString)
                    old_text = old_text or DefaultText

                    if (self.Addon.getSetting("BoldKB") == "true"):
                        CurrentEnglishString = "[B]%s[/B]" % CurrentEnglishString
                    self.setProperty("CurrentEnglishString",
                                     CurrentEnglishString)
                    self.setProperty("ShowCurrentEnglishString", "true")

                    kb = xbmc.Keyboard(
                        old_text,
                        self.CurrentLanguage + " (Enter desired string)",
                        False)
                    kb.doModal()
                    if kb.isConfirmed():
                        new_text = kb.getText()
                        if new_text != DefaultText:
                            new_text = fixe_line_return(new_text)
                            self.listitems[pos].setLabel(new_text)
                            self.listitems[pos].setProperty(
                                "IsModified", "true")
                            self.setProperty(
                                "IsModified",
                                "Language file has been changed!")
                            self.IsModified = True
                    self.setProperty("ShowCurrentEnglishString", "")

            # PAS TRES BON COMME FILTRE :(
            UnTranslated = self.getControl(19).isSelected()
            Translated = self.getControl(20).isSelected()
            Changed = self.getControl(21).isSelected()
            filter = ("", "UnTranslated")[UnTranslated]
            filter = (filter, "Translated")[Translated]
            filter = (filter, "Changed")[Changed]

            # get selected id for selectitem again, if controlID 22 clicked
            SelectId = xbmc.getInfoLabel(
                "Container(50).ListItem.Property(id)") or xbmc.getInfoLabel(
                    "Container(51).ListItem.Property(id)")
            if controlID == 19:
                # UNTRANSLATED BUTTON
                filter = ("", "UnTranslated")[UnTranslated]
                self.setContainer(filter, SelectId)
                self.getControl(19).setSelected(UnTranslated)
                self.getControl(20).setSelected(False)
                self.getControl(21).setSelected(False)

            elif controlID == 20:
                # TRANSLATED BUTTON
                filter = ("", "Translated")[Translated]
                self.setContainer(filter, SelectId)
                self.getControl(20).setSelected(Translated)
                self.getControl(19).setSelected(False)
                self.getControl(21).setSelected(False)

            elif controlID == 21:
                # CHANGED BUTTON
                filter = ("", "Changed")[Changed]
                self.setContainer(filter, SelectId)
                self.getControl(21).setSelected(Changed)
                self.getControl(19).setSelected(False)
                self.getControl(20).setSelected(False)

            elif controlID == 22:
                # VIEW AS BUTTON
                self.settings["viewmode"] = (1, 0)[self.settings["viewmode"]]
                xbmc.sleep(50)
                self.setContainer(filter, SelectId)

            elif controlID == 13:
                # SORT BY BUTTON
                self.settings["sortmethod"] = (1,
                                               0)[self.settings["sortmethod"]]
                self.setSortMethodControl()
                self.setContainer(filter, SelectId)

            elif controlID == 14:
                # SORT ASC BUTTON
                self.settings["sortorder"] = (1, 0)[self.settings["sortorder"]]
                self.setContainer(filter, SelectId)

            elif controlID == 32:
                # SETTINGS BUTTON
                self.Addon = Addon(AddonId)
                self.Addon.openSettings()
                xbmc.sleep(10)
                if self.settings["LanguagePath"] != self.Addon.getSetting(
                        "LanguagePath"):
                    self.settings["LanguagePath"] = self.Addon.getSetting(
                        "LanguagePath")
                    self.listitems = []
                self.setContainer(filter, SelectId)

            elif controlID == 33:
                # FIND BUTTON
                default = self.getControl(33).getLabel2()
                kb = xbmc.Keyboard(default, "Find what ...", False)
                kb.doModal()
                if kb.isConfirmed():
                    find_text = kb.getText()
                    #self.getControl( 33 ).setLabel( "Find", label2=find_text )
                    self.setProperty("FindText", find_text)
                    if find_text:  # and find_text != default:
                        for count, li in enumerate(self.listitems):
                            #l_text = find_text.lower()
                            #match = ( l_text in li.getLabel().lower() ) or ( l_text in li.getLabel2().lower() ) or ( l_text == li.getProperty( "id" ) )
                            #match = match or ( l_text == li.getLabel().lower() ) or ( l_text == li.getLabel2().lower() )
                            #if not match: continue
                            if self.findText(find_text, li):
                                self.getControl(
                                    self.ContainerId).selectItem(count)
                                self.setFocusId(self.ContainerId)
                                break

            elif controlID == 34:
                # FIND NEXT BUTTON
                find_next = self.getControl(33).getLabel2().encode("utf-8")
                pos = self.getControl(self.ContainerId).getSelectedPosition()
                for count, li in enumerate(self.listitems):
                    if count <= pos: continue
                    #if find_next in li.getLabel() or find_next == li.getProperty( "id" ):
                    if self.findText(find_next, li):
                        self.getControl(self.ContainerId).selectItem(count)
                        break

        except:
            print_exc()

    def findText(self, text, listitem):
        return re.search(
            text.lower(), "|".join([
                listitem.getLabel(),
                listitem.getLabel2(),
                listitem.getProperty("id")
            ]).lower())

    def onAction(self, action):
        if action in [9, 10]:
            self._close_window()

        elif action == 117:
            try:
                cm = DialogContextMenu("Translator-DialogContextMenu.xml",
                                       CWD,
                                       parent=self)
                cm.doModal()
                del cm
            except:
                print_exc()
        else:
            try:
                bcode = action.getButtonCode()
                # keyboard press F3
                if bcode == 127138: self.sendClick(34)
                #
            except:
                print_exc()

    def _close_window(self):
        xbmc.executebuiltin("ActivateWindow(busydialog)")
        if self.settings["savefolderviews"]:
            self.Addon.setSetting("viewmode", str(self.settings["viewmode"]))
            self.Addon.setSetting("sortmethod",
                                  str(self.settings["sortmethod"]))
            self.Addon.setSetting("sortorder", str(self.settings["sortorder"]))
            xbmc.sleep(10)

        if self.IsModified:
            # ask for save change
            xbmc.executebuiltin("Dialog.Close(busydialog)")
            self._save_change()

        try:
            del self.language
        except:
            pass
        self.close()

    def _save_change(self):
        if xbmcgui.Dialog().yesno("Confirm file save",
                                  "Language file has been changed!",
                                  self.language.current_xml,
                                  "Do you want save your change?", ""):
            xbmc.executebuiltin("ActivateWindow(busydialog)")
            OK = self.language.save_strings()
            xbmc.executebuiltin("Dialog.Close(busydialog)")

            if (self.DefaultFolderLanguage.rstrip("/") == self.FolderLanguage
                ) or (xbmc.translatePath("special://skin/")
                      in xbmc.translatePath(self.FolderLanguage)):
                # if default xbmc language file has been changed,
                # set True, XBMC require Restart or reload language
                self.RestartXBMC_ReloadLanguage = OK or self.RestartXBMC_ReloadLanguage
Exemple #22
0
# condition pour mettre a jour la base
UpdateUserDB = False

# initialize Keyboard
kb = xbmc.Keyboard(default, heading, hidden)
# optional hidden pass
kb.setHiddenInput(hidden)
# call Keyboard
kb.doModal()
# si confirmation on continue les changement
if kb.isConfirmed():
    # recup du text
    text = kb.getText()
    # si le text est pas vide et pas pareil que le default ou pas de token, on change
    if text:  # and ( text != default or not hasToken ):
        Addon.setSetting("scraper",
                         ("Cine-Passion", "Media-Passion")[bool(settingMP)])
        # set our codes
        if settingId == "username" + settingMP:
            token = sha1(text.lower() + passw).hexdigest()
            tokenb64 = b64encode(text)
            login = text
            if not passw:
                xbmc.executebuiltin("Action(Down)")
        else:
            token = sha1(login.lower() + text).hexdigest()
            tokenb64 = b64encode(login)
            passw = text
        # save cached settings infos
        Addon.setSetting("token" + settingMP, token)
        Addon.setSetting("tokenb64" + settingMP, tokenb64)
        # save setting for visible infos
class NetflixCommon(object):
    """
    Stuff shared between / used from service and addon"""

    def __init__(self, plugin_handle, base_url):

        self.addon = Addon()
        self.data_path = xbmc.translatePath(self.addon.getAddonInfo('profile'))
        self.cookie_path = self.data_path + 'COOKIE'
        self.plugin = self.addon.getAddonInfo('name')
        self.verb_log = self.addon.getSetting('logging') == 'true'
        self.plugin_handle = plugin_handle
        self.base_url = base_url
        self.version = self.addon.getAddonInfo('version')

        xbmcvfs.mkdir(path=self.data_path)

    def get_addon(self):
        """Return the current addon instance"""
        return self.addon

    def get_addon_info(self, name):
        """Return the current addon instance"""
        return self.addon.getAddonInfo(name)

    def set_setting(self, key, value):
        return self.addon.setSetting(key, value)

    def get_setting(self, key):
        return self.addon.getSetting(key)

    def flush_settings(self):
        self.addon = Addon()

    def get_esn(self):
        """
        Returns the esn from settings
        """
        return self.addon.getSetting('esn')

    def set_esn(self, esn):
        """
        Returns True if MSL reset is required
        """
        stored_esn = self.get_esn()
        if not stored_esn and esn:
            self.set_setting('esn', esn)
            return True
        return False

    def get_credentials(self):
        from NetflixCredentials import NetflixCredentials
        email = self.get_setting('email')
        password = self.get_setting('password')

        if '@' in email:
            self.set_credentials(email, password)
            return {'email' : email, 'password' : password }

        return NetflixCredentials().decode_credentials(email, password)

    def set_credentials(self, email, password):
        from NetflixCredentials import NetflixCredentials
        encoded = NetflixCredentials().encode_credentials(email, password)
        self.set_setting('email',encoded['email'])
        self.set_setting('password',encoded['password'])

    def log(self, msg, level=xbmc.LOGDEBUG):
        """Adds a log entry to the Kodi log

        Parameters
        ----------
        msg : :obj:`str`
            Entry that should be turned into a list item

        level : :obj:`int`
            Kodi log level
        """
        if isinstance(msg, unicode):
            msg = msg.encode('utf-8')
        xbmc.log('[%s] %s' % (self.plugin, msg.__str__()), level)

    @staticmethod
    def check_folder_path(path):
        """
        Check if folderpath ends with path delimator
        If not correct it (makes sure xbmcvfs.exists is working correct)
        """
        if isinstance(path, unicode):
            check = path.encode('ascii', 'ignore')
            if '/' in check and not str(check).endswith('/'):
                end = u'/'
                path = path + end
                return path
            if '\\' in check and not str(check).endswith('\\'):
                end = u'\\'
                path = path + end
                return path
        if '/' in path and not str(path).endswith('/'):
            path = path + '/'
            return path
        if '\\' in path and not str(path).endswith('\\'):
            path = path + '\\'
            return path

    @staticmethod
    def file_exists(data_path, filename):
        """
        Checks if a given file exists
        :param filename: The filename
        :return: True if so
        """
        return xbmcvfs.exists(path=data_path + filename)

    @staticmethod
    def save_file(data_path, filename, content):
        """
        Saves the given content under given filename
        :param filename: The filename
        :param content: The content of the file
        """

        file_handle = xbmcvfs.File(
            filepath=data_path + filename,
            mode='w')
        file_content = file_handle.write(content)
        file_handle.close()

    @staticmethod
    def load_file(data_path, filename):
        """
        Loads the content of a given filename
        :param filename: The file to load
        :return: The content of the file
        """
        file_handle = xbmcvfs.File(
            filepath=data_path + filename)
        file_content = file_handle.read()
        file_handle.close()
        return file_content

    @staticmethod
    def list_dir(data_path):
        return xbmcvfs.listdir(data_path)
Exemple #24
0
    intros_dir = os.path.join( Addon.getAddonInfo( "path" ), "resources", "intros" )
    intro = Addon.getSetting( "intro" )

    if Addon.getSetting( "use_custom_intro" ) == "true":
        c_intro = Addon.getSetting( "path_custom_intro" )
        if c_intro and xbmcvfs.exists( c_intro ):
            intro = c_intro

    if intro == "Random":
        intros = os.listdir( intros_dir )
        last = Addon.getSetting( "last_random" )
        if last and last in intros:
            del intros[ intros.index( last ) ]
        random.shuffle( intros )
        intro = random.choice( intros )
        Addon.setSetting( "last_random", intro )

    player = xbmc.Player()
    player.play( os.path.join( intros_dir, intro ) )
    xbmcgui.Window( 10000 ).setProperty( "intro.isplayed", "true" )

    if ReplaceWindowHome:
        xbmc.sleep( 1000 )

        while player.isPlaying():
            #continue
            time.sleep( .2 )

        xbmc.executebuiltin( "ReplaceWindow(Home)" )

        xbmc.sleep( 1000 )
Exemple #25
0
def selectDevice():
    import xbmc
    from xbmcgui import Dialog
    from xbmcaddon import Addon
    ADDON = Addon("script.samsung.remote")
    xbmc.executebuiltin('ActivateWindow(busydialog)')
    tv_devices = sorted(getSamDevices().items())
    choices = ["%s (%s) @ %s" % (v[0], v[1], k) for k, v in tv_devices] + ["Manual", "Cancel"]
    xbmc.executebuiltin('Dialog.Close(busydialog,true)')
    selected = Dialog().select("Select your Samsung device", choices)
    device = None
    if selected >= 0 and selected < len(tv_devices):
        # auto and selected
        device = tv_devices[selected]
        ADDON.setSetting("autosam", "$LOCALIZE[13416]")
        ADDON.setSetting("manualsam", "false")
        ADDON.setSetting("tvmodel", device[1][1])
        ADDON.setSetting("tvname", device[1][0])
        ADDON.setSetting("tvip", device[0])

    elif selected == len(tv_devices):
        # manual
        ADDON.setSetting("autosam", "$LOCALIZE[413]")
        ADDON.setSetting("manualsam", "true")
        xbmc.sleep(500)
        xbmc.executebuiltin('Action(Down)')
Exemple #26
0
    def onClick(self, controlId):
        if controlId == programsListBoxId:
            self.goEditSchedule()
        elif controlId == refreshButtonId:
            self.xnewa.cleanCache('recentRecordings*.p')
            self.xnewa.cleanCache('summary.List')
            self.render()
        elif controlId == importButtonId:
            dialog = xbmcgui.Dialog()
            ret = dialog.yesno(smartUTF8(__language__(30127)), '%s %s' % (smartUTF8(__language__(30121)), self.recentData[self.programsListBox.getSelectedPosition()]['title']))
        elif controlId == actionButtonId:
            order = [__language__(30038),__language__(30039),__language__(32003),__language__(30054),__language__(32004),__language__(30033)]
            ret = xbmcgui.Dialog().select(__language__(32005), order);
            if ret > 0:
                self.processFile(order[ret])
                if self.selections > 0:
                    self.win.setProperty('tagged', 'true')
                else:
                    self.win.setProperty('tagged', 'false')
                if self.mode ==0:
                    self.render()

        elif controlId == filterButtonId:
            choices = list(self.xnewa.RecDirs.keys())
            if self.filterButton.isSelected():
                archive =  xbmcgui.Dialog().select(smartUTF8(__language__(30115)), choices)
                if archive != -1:
                    self.filtered = True
                    self.win.setProperty('archive', choices[archive])
                    self.recDir = self.xnewa.RecDirs[choices[archive]]
            else:
                self.recDir = None
                archive = 0
                self.win.setProperty('archive', __language__(30020))

            if archive != -1:
                self.xnewa.cleanCache('recentRecordings*.p')
                self.xnewa.cleanCache('summary.List')
                self.render()
        elif controlId == sortButtonId:
            order = [smartUTF8(__language__(30011)),smartUTF8(__language__(30148)),smartUTF8(__language__(30149)),__language__(32006)]
            ret = xbmcgui.Dialog().select(smartUTF8(__language__(30122)), order);
            if ret != -1:
                if ret == 0:
                    self.sortTitle[self.mode] = True
                    self.sortDate[self.mode] = True
                elif ret == 1:
                    self.sortTitle[self.mode] = False
                    self.sortDate[self.mode] = True
                elif ret == 2:
                    self.sortTitle[self.mode] = False
                    self.sortDate[self.mode] = False
                if self.mode == 0:
                    if ret != self.settings.XNEWA_SORT_RECORDING:
                        addon = Addon()
                        addon.setSetting(id='recordingSort',value=str(ret))
                        self.settings.XNEWA_SORT_RECORDING = ret
                        self.xnewa.cleanCache('summary.List')
                else:
                    if ret != self.settings.XNEWA_SORT_EPISODE:
                        addon = Addon()
                        addon.setSetting(id='episodeSort',value=str(ret))
                        self.settings.XNEWA_SORT_EPISODE = ret
                        self.xnewa.cleanCache('recentRecordings*.p')
                self.render()
Exemple #27
0
class Translator( xbmcgui.WindowXML ):
    CONTROL_LIST_A = 50

    def __init__( self, *args, **kwargs ):
        self.RestartXBMC_ReloadLanguage = False
        self.IsModified = False
        self.googleTrans = False
        self.listitems = []

        self.Addon = Addon( AddonId )
        self._get_settings()

    def _get_settings( self ):
        self.settings = {}
        self.settings[ "LanguagePath" ] = self.Addon.getSetting( "LanguagePath" )

        self.settings[ "viewmode" ]     = int( self.Addon.getSetting( "viewmode" ) )
        self.settings[ "sortmethod" ]   = int( self.Addon.getSetting( "sortmethod" ) )
        self.settings[ "sortorder" ]    = int( self.Addon.getSetting( "sortorder" ) )
        self.settings[ "savefolderviews" ] = ( self.Addon.getSetting( "savefolderviews" ) == "true" )

    def setListItems( self ):
        self.DefaultLanguage = "English"
        self.CurrentLanguage = xbmc.getLanguage()
        self.FolderLanguage  = self.settings[ "LanguagePath" ]
        self.DefaultFolderLanguage = "special://xbmc/language/"
        if not os.path.exists( xbmc.translatePath( self.FolderLanguage ) ):
            print "Folder language not exists! '%s'" % self.FolderLanguage
            self.FolderLanguage = self.DefaultFolderLanguage

        if not self.FolderLanguage.startswith( "special" ):
            for folder in [ "profile", "home", "xbmc" ]:
                special = "special://%s/" % folder
                self.FolderLanguage = self.FolderLanguage.replace( xbmc.translatePath( special ), special )

        if ( xbmc.translatePath( "special://skin/" ) in xbmc.translatePath( self.FolderLanguage ) ):
            self.FolderLanguage = "special://skin/language/"
        self.FolderLanguage = self.FolderLanguage.replace( "\\", "/" ).rstrip( "/" )

        self.setContainerProperties()
        # get languages source
        self.language = Language( self )
        self.listitems = self.language.listitems

    def onInit( self ):
        xbmc.executebuiltin( "ActivateWindow(busydialog)" )
        self.setSortMethodControl()
        self.setContainer( setviewmode=self.settings[ "viewmode" ] )
        LOG( "notice", "initialized took %s", time_took( START_TIME ) )
        xbmc.executebuiltin( "Dialog.Close(busydialog)" )

    def setSortMethodControl( self ):
        label = ( 20316, 103 )[ self.settings[ "sortmethod" ] ]
        self.getControl( 13 ).setLabel( xbmc.getLocalizedString( label ) )

    def setContainerProperties( self ):
        self.setProperty( "IsModified", ( "", "Language file has been changed!" )[ self.IsModified ] )
        self.setProperty( "CurrentLanguage", self.CurrentLanguage )
        self.setProperty( "FolderLanguage", self.FolderLanguage )
        self.setProperty( "CurrentEnglishString", "" )
        self.Addon = Addon( AddonId )
        self.setProperty( "ExtraKeyboard_TopOrBottom", ( "top", "bottom" )[ int( self.Addon.getSetting( "ExtraKB" ) ) ] )

    def setContainer( self, filter="", SelectId="", setviewmode=None ):
        if setviewmode is not None:
            self.ContainerId = ( 50, 51 )[ setviewmode ]
            if setviewmode: xbmc.executebuiltin( "SendClick(2)" )
        else:
            self.ContainerId = ( 50, 51 )[ xbmc.getCondVisibility( "Control.IsVisible(51)" ) ]
        try:

            if not bool( self.listitems ):
                if self.IsModified:
                    # ask for save change
                    self._save_change()
                self.IsModified = False
                self.googleTrans = False
                self.getControl( self.ContainerId ).reset()
                self.setListItems()

            self.setContainerProperties()
            if self.listitems:
                selectitem = 0

                additems = []
                if not filter:
                    additems = self.listitems
                else:
                    for li in self.listitems:
                        if filter == "UnTranslated" and li.getProperty( "UnTranslated" ) == "false":
                            continue
                        if filter == "Translated" and li.getProperty( "IsModified" ) != "true":
                            continue
                        additems.append( li )

                if additems:
                    if self.settings[ "sortmethod" ]:
                        additems = sorted( additems, key=lambda li: normalize_string( li.getLabel(), True ) )
                    if self.settings[ "sortorder" ]:
                        additems = list( reversed( additems ) )
                    for count, li in enumerate( additems ):
                        if li.getProperty( "id" ) == SelectId:
                            selectitem = count

                # add listitems
                self.getControl( self.ContainerId ).reset()
                self.getControl( self.ContainerId ).addItems( additems )
                if additems: #self.getControl( self.ContainerId ).size():
                    self.getControl( self.ContainerId ).selectItem( selectitem )
                    self.setFocusId( self.ContainerId )

            # fixe view on xbox
            if UNDER_XBOX and setviewmode is not None:
                xbmc.executebuiltin( "Container.SetViewMode(%i)" % self.ContainerId )
                xbmc.sleep( 20 )
                self.setFocusId( self.ContainerId )
        except:
            print_exc()

    def onFocus( self, controlID ):
        pass

    def sendClick( self, controlID ):
        try: self.onClick( controlID )
        except: print_exc()

    def getTranslate( self, text, minimal=2 ):
        translated = ""
        if text:
            if ( len( text ) <= minimal ) or text.isdigit():
                translated = text
            else:
                country = self.Addon.getSetting( "country" )
                if country.lower() == "auto": country = self.CurrentLanguage
                pDialog = xbmcgui.DialogProgress()
                pDialog.create( "Google Translate", "English to %s" % country, text, "Please wait..." )
                try:
                    import LanguageTools
                    translated = LanguageTools.translate_text( text, country, "google" )
                except:
                    print_exc()
        self.googleTrans = False
        xbmc.executebuiltin( "Dialog.Close(progressdialog)" )
        return translated

    def onClick( self, controlID ):
        try:
            self.ContainerId = ( 50, 51 )[ xbmc.getCondVisibility( "Control.IsVisible(51)" ) ]
            if controlID == self.ContainerId:
                # get clicked listitem
                listitem = self.getControl( self.ContainerId ).getSelectedItem()
                # get position
                pos = int( listitem.getProperty( "Position" ) )
                # get id
                id = listitem.getProperty( "id" )
                if id:
                    CurrentEnglishString = fixe_line_return( listitem.getLabel2(), True )
                    
                    DefaultText = fixe_line_return( listitem.getLabel(), True )
                    old_text = DefaultText
                    if self.googleTrans: old_text = self.getTranslate( CurrentEnglishString )
                    old_text = old_text or DefaultText

                    if ( self.Addon.getSetting( "BoldKB" ) == "true" ):
                        CurrentEnglishString = "[B]%s[/B]" % CurrentEnglishString
                    self.setProperty( "CurrentEnglishString", CurrentEnglishString )
                    self.setProperty( "ShowCurrentEnglishString", "true" )
                    
                    kb = xbmc.Keyboard( old_text, self.CurrentLanguage + " (Enter desired string)", False )
                    kb.doModal()
                    if kb.isConfirmed():
                        new_text = kb.getText()
                        if new_text != DefaultText:
                            new_text = fixe_line_return( new_text )
                            self.listitems[ pos ].setLabel( new_text )
                            self.listitems[ pos ].setProperty( "IsModified", "true" )
                            self.setProperty( "IsModified", "Language file has been changed!" )
                            self.IsModified = True
                    self.setProperty( "ShowCurrentEnglishString", "" )

            # PAS TRES BON COMME FILTRE :(
            UnTranslated = self.getControl( 19 ).isSelected()
            Translated = self.getControl( 20 ).isSelected()
            Changed = self.getControl( 21 ).isSelected()
            filter = ( "", "UnTranslated" )[ UnTranslated ]
            filter = ( filter, "Translated" )[ Translated ]
            filter = ( filter, "Changed" )[ Changed ]
            
            # get selected id for selectitem again, if controlID 22 clicked
            SelectId = xbmc.getInfoLabel( "Container(50).ListItem.Property(id)" ) or xbmc.getInfoLabel( "Container(51).ListItem.Property(id)" )
            if controlID == 19:
                # UNTRANSLATED BUTTON
                filter = ( "", "UnTranslated" )[ UnTranslated ]
                self.setContainer( filter, SelectId )
                self.getControl( 19 ).setSelected( UnTranslated )
                self.getControl( 20 ).setSelected( False )
                self.getControl( 21 ).setSelected( False )

            elif controlID == 20:
                # TRANSLATED BUTTON
                filter = ( "", "Translated" )[ Translated ]
                self.setContainer( filter, SelectId )
                self.getControl( 20 ).setSelected( Translated )
                self.getControl( 19 ).setSelected( False )
                self.getControl( 21 ).setSelected( False )

            elif controlID == 21:
                # CHANGED BUTTON
                filter = ( "", "Changed" )[ Changed ]
                self.setContainer( filter, SelectId )
                self.getControl( 21 ).setSelected( Changed )
                self.getControl( 19 ).setSelected( False )
                self.getControl( 20 ).setSelected( False )

            elif controlID == 22:
                # VIEW AS BUTTON
                self.settings[ "viewmode" ] = ( 1, 0 )[ self.settings[ "viewmode" ] ]
                xbmc.sleep( 50 )
                self.setContainer( filter, SelectId )

            elif controlID == 13:
                # SORT BY BUTTON
                self.settings[ "sortmethod" ] = ( 1, 0 )[ self.settings[ "sortmethod" ] ]
                self.setSortMethodControl()
                self.setContainer( filter, SelectId )

            elif controlID == 14:
                # SORT ASC BUTTON
                self.settings[ "sortorder" ] = ( 1, 0 )[ self.settings[ "sortorder" ] ]
                self.setContainer( filter, SelectId )

            elif controlID == 32:
                # SETTINGS BUTTON
                self.Addon = Addon( AddonId )
                self.Addon.openSettings()
                xbmc.sleep( 10 )
                if self.settings[ "LanguagePath" ] != self.Addon.getSetting( "LanguagePath" ):
                    self.settings[ "LanguagePath" ] = self.Addon.getSetting( "LanguagePath" )
                    self.listitems = []
                self.setContainer( filter, SelectId )

            elif controlID == 33:
                # FIND BUTTON
                default = self.getControl( 33 ).getLabel2()
                kb = xbmc.Keyboard( default, "Find what ...", False )
                kb.doModal()
                if kb.isConfirmed():
                    find_text = kb.getText()
                    #self.getControl( 33 ).setLabel( "Find", label2=find_text )
                    self.setProperty( "FindText", find_text )
                    if find_text:# and find_text != default:
                        for count, li in enumerate( self.listitems ):
                            #l_text = find_text.lower()
                            #match = ( l_text in li.getLabel().lower() ) or ( l_text in li.getLabel2().lower() ) or ( l_text == li.getProperty( "id" ) )
                            #match = match or ( l_text == li.getLabel().lower() ) or ( l_text == li.getLabel2().lower() )
                            #if not match: continue
                            if self.findText( find_text, li ):
                                self.getControl( self.ContainerId ).selectItem( count )
                                self.setFocusId( self.ContainerId )
                                break

            elif controlID == 34:
                # FIND NEXT BUTTON
                find_next = self.getControl( 33 ).getLabel2().encode( "utf-8" )
                pos = self.getControl( self.ContainerId ).getSelectedPosition()
                for count, li in enumerate( self.listitems ):
                    if count <= pos: continue
                    #if find_next in li.getLabel() or find_next == li.getProperty( "id" ):
                    if self.findText( find_next, li ):
                        self.getControl( self.ContainerId ).selectItem( count )
                        break

        except:
            print_exc()

    def findText( self, text, listitem ):
        return re.search( text.lower(), "|".join(
            [ listitem.getLabel(), listitem.getLabel2(), listitem.getProperty( "id" ) ]
            ).lower() )

    def onAction( self, action ):
        if action in [ 9, 10 ]:
            self._close_window()

        elif action == 117:
            try:
                cm = DialogContextMenu( "Translator-DialogContextMenu.xml", CWD, parent=self )
                cm.doModal()
                del cm
            except:
                print_exc()
        else:
            try:
                bcode = action.getButtonCode()
                # keyboard press F3
                if bcode == 127138: self.sendClick( 34 )
                #
            except:
                print_exc()

    def _close_window( self ):
        xbmc.executebuiltin( "ActivateWindow(busydialog)" )
        if self.settings[ "savefolderviews" ]:
            self.Addon.setSetting( "viewmode",   str( self.settings[ "viewmode" ] ) )
            self.Addon.setSetting( "sortmethod", str( self.settings[ "sortmethod" ] ) )
            self.Addon.setSetting( "sortorder",  str( self.settings[ "sortorder" ] ) )
            xbmc.sleep( 10 )

        if self.IsModified:
            # ask for save change
            xbmc.executebuiltin( "Dialog.Close(busydialog)" )
            self._save_change()

        try: del self.language
        except: pass
        self.close()

    def _save_change( self ):
        if xbmcgui.Dialog().yesno( "Confirm file save", "Language file has been changed!", self.language.current_xml, "Do you want save your change?", "" ):
            xbmc.executebuiltin( "ActivateWindow(busydialog)" )
            OK = self.language.save_strings()
            xbmc.executebuiltin( "Dialog.Close(busydialog)" )

            if ( self.DefaultFolderLanguage.rstrip( "/" ) == self.FolderLanguage ) or ( xbmc.translatePath( "special://skin/" ) in xbmc.translatePath( self.FolderLanguage ) ):
                # if default xbmc language file has been changed,
                # set True, XBMC require Restart or reload language
                self.RestartXBMC_ReloadLanguage = OK or self.RestartXBMC_ReloadLanguage
Exemple #28
0
    def onClick(self, controlId):
        if controlId == programsListBoxId:
            self.goEditSchedule()
        elif controlId == refreshButtonId:
            self.xnewa.cleanCache('recentRecordings*.p')
            self.xnewa.cleanCache('summary.List')
            self.render()
        elif controlId == importButtonId:
            dialog = xbmcgui.Dialog()
            ret = dialog.yesno(
                smartUTF8(__language__(30127)),
                '%s %s' % (smartUTF8(__language__(30121)), self.recentData[
                    self.programsListBox.getSelectedPosition()]['title']))
        elif controlId == actionButtonId:
            order = [
                __language__(30038),
                __language__(30039),
                __language__(32003),
                __language__(30054),
                __language__(32004),
                __language__(30033)
            ]
            ret = xbmcgui.Dialog().select(__language__(32005), order)
            if ret > 0:
                self.processFile(order[ret])
                if self.selections > 0:
                    self.win.setProperty('tagged', 'true')
                else:
                    self.win.setProperty('tagged', 'false')
                if self.mode == 0:
                    self.render()

        elif controlId == filterButtonId:
            choices = list(self.xnewa.RecDirs.keys())
            if self.filterButton.isSelected():
                archive = xbmcgui.Dialog().select(
                    smartUTF8(__language__(30115)), choices)
                if archive != -1:
                    self.filtered = True
                    self.win.setProperty('archive', choices[archive])
                    self.recDir = self.xnewa.RecDirs[choices[archive]]
            else:
                self.recDir = None
                archive = 0
                self.win.setProperty('archive', __language__(30020))

            if archive != -1:
                self.xnewa.cleanCache('recentRecordings*.p')
                self.xnewa.cleanCache('summary.List')
                self.render()
        elif controlId == sortButtonId:
            order = [
                smartUTF8(__language__(30011)),
                smartUTF8(__language__(30148)),
                smartUTF8(__language__(30149)),
                __language__(32006)
            ]
            ret = xbmcgui.Dialog().select(smartUTF8(__language__(30122)),
                                          order)
            if ret != -1:
                if ret == 0:
                    self.sortTitle[self.mode] = True
                    self.sortDate[self.mode] = True
                elif ret == 1:
                    self.sortTitle[self.mode] = False
                    self.sortDate[self.mode] = True
                elif ret == 2:
                    self.sortTitle[self.mode] = False
                    self.sortDate[self.mode] = False
                if self.mode == 0:
                    if ret != self.settings.XNEWA_SORT_RECORDING:
                        addon = Addon()
                        addon.setSetting(id='recordingSort', value=str(ret))
                        self.settings.XNEWA_SORT_RECORDING = ret
                        self.xnewa.cleanCache('summary.List')
                else:
                    if ret != self.settings.XNEWA_SORT_EPISODE:
                        addon = Addon()
                        addon.setSetting(id='episodeSort', value=str(ret))
                        self.settings.XNEWA_SORT_EPISODE = ret
                        self.xnewa.cleanCache('recentRecordings*.p')
                self.render()