def __init__(self, config):
self.radarr = Radarr(config.radarr_url, config.radarr_base_path,
config.radarr_api_key,
config.radarr_quality_profile)
self.imdb = Imdb()
self.score11 = Score11(self.imdb)
self.ask = Preferences(self.imdb)
def init(self):
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
connectionManager.onLoggedOn += self._onLoggedOn
def open_preferences(self, event): # wxGlade: MeerK40t.<event_handler>
project.close_old_window("preferences")
from Preferences import Preferences
window = Preferences(None, wx.ID_ANY, "")
window.set_project(project)
window.Show()
project.windows["preferences"] = window
def init(self):
self.tryPrepareWGCLogin()
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
self.connectionMgr.onLoggedOn += self._onLoggedOn
def __init__(self, arguments):
super().__init__(arguments)
self.mainWindow = None
self.setOrganizationName('QtHEP')
self.setApplicationName('QtHEP')
QStandardPaths.setTestModeEnabled(__DEVELOPEMENT__)
preferencesPath = QStandardPaths.writableLocation(
QStandardPaths.AppDataLocation)
if (not os.path.exists(preferencesPath)):
os.makedirs(preferencesPath)
self.preferencesFilename = os.path.join(
preferencesPath,
'{}.preferences.xml'.format(self.applicationName()))
self.preferences = Preferences()
if (os.path.exists(self.preferencesFilename)):
self.preferences.fromXML(self.preferencesFilename)
self.preferences.logging.initializeLog()
else:
self.preferences.toXML(self.preferencesFilename)
DiscFilenameTemplatesSingleton().set(
self.preferences.filenameTemplates)
DiscMixdownsSingleton().set(self.preferences.mixdowns.getMixdowns())
DiscPresetsSingleton().set(self.preferences.presets.getNames())
self.disc = Disc(self)
TitleVisibleSingleton().set(
self.preferences.autoTitle.minimumTitleSeconds,
self.disc.hideShortTitles)
self.defaultSessionFilename = "{}.state.xml".format(
self.applicationName())
if __DEVELOPEMENT__:
# self.settingsFilename = os.path.join(os.getcwd(), "{}.settings.xml".format(APP_NAME))
# self.fullDefaultSessionFilename = os.path.join(os.getcwd(), self.defaultSessionFilename)
s = os.path.join(os.getcwd(), 'TestFiles')
self.temporarySessionFilename = os.path.join(
s, "temp.{}".format(self.defaultSessionFilename))
# self.logFilename = os.path.join(os.getcwd(), "{}.log".format(APP_NAME))
else:
if (os.path.exists(self.standardPaths.GetUserDataDir()) == False):
os.makedirs(self.standardPaths.GetUserDataDir())
SingletonLog().writeline('{} created'.format(
self.standardPaths.GetUserDataDir()))
# self.settingsFilename = os.path.join(self.standardPaths.GetUserDataDir(), "{}.settings.xml".format(APP_NAME))
# self.fullDefaultSessionFilename = os.path.join(self.standardPaths.GetUserDataDir(), self.defaultSessionFilename)
self.temporarySessionFilename = os.path.join(
self.standardPaths.GetUserDataDir(),
"temp.{}".format(self.defaultSessionFilename))
def test_table_time_gen(sh):
startdate = datetime(2016, 01, 31, 12, 00, 00)
totalSeconds = 86400
interval = 3600
amount = totalSeconds / interval
pr = Preferences()
prefix = pr.get('DBPrefix')
sh.createNewTableStructure(prefix)
sh.generateTimeSlots(startdate, interval, amount, prefix)
def __init__(self, *args, **kwds):
# begin wxGlade: MainFrame.__init__
kwds["style"] = wx.DEFAULT_FRAME_STYLE
wx.Frame.__init__(self, *args, **kwds)
# Menu Bar
self.main_frame_menubar = wx.MenuBar()
self.File = wx.Menu()
self.Exit = wx.MenuItem(self.File, wx.ID_EXIT, _("E&xit\tCtrl-Q"), _("Exit"), wx.ITEM_NORMAL)
self.File.AppendItem(self.Exit)
self.main_frame_menubar.Append(self.File, _("&File"))
self.Help = wx.Menu()
self.About = wx.MenuItem(self.Help, wx.ID_ABOUT, _("&About"), _("About"), wx.ITEM_NORMAL)
self.Help.AppendItem(self.About)
self.main_frame_menubar.Append(self.Help, _("&Help"))
self.SetMenuBar(self.main_frame_menubar)
# Menu Bar end
self.logo_bitmap = wx.StaticBitmap(self, wx.ID_ANY, wx.NullBitmap)
self.src_dir_text_ctrl = wx.TextCtrl(self, wx.ID_ANY, "", style=wx.TE_READONLY)
self.src_dir_button = wx.Button(self, wx.ID_ANY, _("Source folder"))
self.dest_dir_text_ctrl = wx.TextCtrl(self, wx.ID_ANY, "", style=wx.TE_READONLY)
self.dst_folder_button = wx.Button(self, wx.ID_ANY, _("Destination folder"))
self.tiff_checkbox = wx.CheckBox(self, wx.ID_ANY, _("TIFF"))
self.dng_checkbox = wx.CheckBox(self, wx.ID_ANY, _("DNG"))
self.thumb_checkbox = wx.CheckBox(self, wx.ID_ANY, _("Thumbnail"))
self.rotate_checkbox = wx.CheckBox(self, wx.ID_ANY, _("Rotation"))
self.convert_button = wx.Button(self, wx.ID_ANY, _("Convert"))
self.status_text_ctrl = wx.TextCtrl(self, wx.ID_ANY, "", style=wx.TE_MULTILINE | wx.TE_READONLY)
self.abort_button = wx.Button(self, wx.ID_ANY, _("Abort"))
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_MENU, self.OnClose, self.Exit)
self.Bind(wx.EVT_MENU, self.OnMenuAbout, self.About)
self.Bind(wx.EVT_BUTTON, self.OnSrcFolder, self.src_dir_button)
self.Bind(wx.EVT_BUTTON, self.OnDstFolder, self.dst_folder_button)
self.Bind(wx.EVT_CHECKBOX, self.OnTIFFClicked, self.tiff_checkbox)
self.Bind(wx.EVT_CHECKBOX, self.OnDNGClicked, self.dng_checkbox)
self.Bind(wx.EVT_CHECKBOX, self.OnThumbnailClicked, self.thumb_checkbox)
self.Bind(wx.EVT_CHECKBOX, self.OnRotationClicked, self.rotate_checkbox)
self.Bind(wx.EVT_BUTTON, self.OnConvert, self.convert_button)
self.Bind(wx.EVT_BUTTON, self.OnAbort, self.abort_button)
# end wxGlade
self.images = Images()
self.logo_bitmap.SetBitmap(self.images.bmp_logo)
self.proc = None
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.SetMinSize(self.GetSize())
self.prefs = Preferences()
self.dng_checkbox.SetValue(self.prefs.get_dng())
self.tiff_checkbox.SetValue(self.prefs.get_tiff())
self.thumb_checkbox.SetValue(self.prefs.get_thumbnail())
self.rotate_checkbox.SetValue(self.prefs.get_rotate())
def test_competitor_creation(sh):
global pr
pr = Preferences()
prefix = pr.get('DBPrefix')
sh = SetupHelper.SetupHelper()
sh.setManualDbCursor(DatabaseConnection.DatabaseConnection().getDatabaseCursor())
if random() < 0.5:
print sh.createNewCompetitor(names.get_last_name(), names.get_first_name(gender='male'), "U18M", prefix)
else:
print sh.createNewCompetitor(names.get_last_name(), names.get_first_name(gender='female'), "U18F", prefix)
def init(self):
if WGC.prepare():
self.__wgcPublication = WGC.getPublication()
else:
_logger.error('WGC API initialization failed')
self.tryPrepareWGCLogin()
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
self.connectionMgr.onLoggedOn += self._onLoggedOn
def __init__(self, master):
self.valves = self.get_valves()
self.master = master
self.master.configure(bg='sky blue')
self.password = '******'
self.momentary = Momentary(self.master, self.valves)
self.edit = Edit(self.master, self.valves)
self.summary = Summary(self.master, self.valves)
self.preferences = Preferences(self.master, self.valves)
self.run_screen = RunScreen(self.master, self.valves)
self.header = self.make_header(self.master)
self.home = self.home_page(self.master)
self.frame = self.home
def init(self):
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
connectionManager.onLoggedOn += self._onLoggedOn
def __init__(self, layout='MainLayout', settings_key=""):
super(Plugin, self).__init__()
# Name of layout that this plugin should be added (see PluginManager.py)
self._main_layout_name = layout
# The default size policy
self.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Fixed)
# Must be a QtWidget
if not isinstance(self, QtWidgets.QWidget):
mooseutils.mooseError("A Plugin must also be a QWidget.")
return
# The Peacock tab index
self._index = None
self._plugin_manager = None
self._preferences = Preferences(settings_key)
def setDefaults(self):
"""
Setup parts of the application that have some sort of default.
Intended to be used when creating a new project to reset the application
to a blank slate.
"""
# Remove or hide any windows
subWindows = self.ui.workspace.subWindowList()
for window in subWindows:
if type(window).__name__ in ["DataTableSubWindow", "FigureSubWindow"]:
window.setAttribute(Qt.WA_DeleteOnClose)
window.close()
else:
window.setVisible(False)
# Remove signals
try:
self.waves().waveAdded.disconnect(self.model('appWaves').appendRow)
except:
pass
try:
self.waves().allWavesRemoved.disconnect(self.model('appWaves').removeAllWaves)
except:
pass
# Set variables
self._waves = Waves()
self._figures = Figures()
self._models = {}
self.projectDir = "" # current project directory
self.setCurrentProject("")
self._storedSettings = {} # this is a dict with widgetName: list pairs
# where each list has [setting-name, setting-value] pairs
# setting-value is a dict with (property-name: Property) pairs
# Load Preferences
Util.debug(2, "App", "Loading Preferences from file")
self.preferences = Preferences("~/.pysciplotrc")
# Create application-wide models
self._models['appWaves'] = WavesListModel(self.waves().waveNames())
# Signals
self.waves().waveAdded.connect(self.model('appWaves').appendRow)
self.waves().allWavesRemoved.connect(self.model('appWaves').removeAllWaves)
# Reload modules
for module in self._loadedModules.values():
module.reload()
def __init__(self):
# On cree l'instance de la classe dialog
self.dialog = Dialog()
self.dialog.setBackgroundTitle("TVDownloader")
# On recupere l'instance de API
self.api = API.getInstance()
# On instancie le gestionnaire de download
self.downloader = Downloader()
# On instancie le gestionnaire d'historique
self.historique = Historique()
# On instancie le gestionnaire de preferences
self.preferences = Preferences()
# Liste des telechargements
self.listeTelechargements = []
# Quand le programme se termine, on execute la fonction actionsAvantQuitter
atexit.register(self.actionsAvantQuitter)
# On commence
self.bouclePrincipale()
def __init__(self):
self.prefs = Preferences()
self.db = SQLController()
self.load_skill_bp_into_prefs()
self.__ui_components = {}
self.__pc_roster = {}
self.__skill_shorts = {}
pc_filepaths = []
#pc_filepaths.append('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml')
pc_filepaths.append('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml')
self.load_pc_roster(pc_filepaths)
#print(str(self.__pc_roster['Toni']))
self.prepare_skill_shorts()
weapons = self.prefs.transfer_wpns_from_txt_to_sql()
wpn_table=self.db.table('wpn_blueprints')
skills = self.prefs.get_skills_dictionary()
skill_bp_table = self.db.table('skill_blueprints')
#self.__wpn_db = WeaponSqlController()
self.add_skills_bp_to_db(skills, skill_bp_table)
#print(weapons)
for weapon in weapons:
name = str(weapon.get_attribute('name'))
type = str(weapon.get_attribute('type'))
wa = str(weapon.get_attribute('wa'))
con = str(weapon.get_attribute('con'))
av = str(weapon.get_attribute('av'))
dmg = str(weapon.get_attribute('dmg'))
ammo = str(weapon.get_attribute('ammo'))
shts = str(weapon.get_attribute('shts'))
rof = str(weapon.get_attribute('rof'))
rel = str(weapon.get_attribute('rel'))
range = str(weapon.get_attribute('range'))
cost = str(weapon.get_attribute('cost'))
source = str(weapon.get_attribute('source'))
category = str(weapon.get_attribute('category'))
wpn_table.add_wpn(name, type, wa, con, av, dmg, ammo, shts, rof, rel, range, cost, category=category, source=source)
#wpn_table.print_table()
self.load_character('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml')
self.db.add_character_to_database(self.c)
start = StartMenu(self)
class PreferencesTests( unittest.TestCase ): ## Initialisation def setUp( self ): self.preferences = Preferences() ## Fin def tearDown( self ): pass def testSingleton( self ): """Test si le pattern singleton est bien en place""" self.assertEqual( id( self.preferences ), id( Preferences() ) ) def testSauvegarde( self ): """Test si les preferences sont bien sauvegardees""" listePreferences = getattr( self.preferences, "preferences" ) nomPreference = listePreferences.keys()[ 0 ] nouvelleValeur = "ValeurDeTest" # On met en place la preference self.preferences.setPreference( nomPreference, nouvelleValeur ) # On verifie qu'elle est bien en place self.assertEqual( nouvelleValeur, self.preferences.getPreference( nomPreference ) )
def __init__(self, master):
self.valves = self.get_valves()
self.master = master
self.master.configure(bg='sky blue')
self.password = '******'
self.momentary = Momentary(self.master, self.valves)
self.edit = Edit(self.master, self.valves)
self.summary = Summary(self.master, self.valves)
self.preferences = Preferences(self.master, self.valves)
self.run_screen = RunScreen(self.master, self.valves)
self.header = self.make_header(self.master)
self.home = self.home_page(self.master)
self.frame = self.home
def __init__(self, layout='MainLayout', settings_key="", **kwargs):
super(Plugin, self).__init__()
# Name of layout that this plugin should be added (see PluginManager.py)
self._main_layout_name = layout
# The default size policy
self.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
# Must be a QtWidget
if not isinstance(self, QtWidgets.QWidget):
mooseutils.mooseError("A Plugin must also be a QWidget.")
return
# The Peacock tab index
self._index = None
self._plugin_manager = None
self._preferences = Preferences(settings_key)
def main():
from Preferences import Preferences
app = wx.PySimpleApp()
preferences = Preferences()
frame = PreferencesDialog(preferences)
result = frame.ShowModal()
if result == wx.ID_OK:
print 'OK'
for subject in preferences.default:
category = subject[0]
print category
for (field, value, width) in subject[1:]:
if type(value) == type([]):
print ' ', field,\
frame.controls[category][field].GetSelection()
else:
print ' ', field,\
frame.controls[category][field].GetValue()
else:
print 'Cancel'
frame.Destroy()
app.MainLoop()
# Dynamically imports all of the modules in the "animations" folder
animations = []
animationNames = []
for (_, name,
_) in pkgutil.iter_modules([Path('/home/pi/LEDWebsite/src/animations')]):
animations.append(import_module('animations.' + name, package=__name__))
for i in dir(animations[len(animations) - 1]):
attribute = getattr(animations[len(animations) - 1], i)
for i in dir(animations[len(animations) - 1]):
attribute = getattr(animations[len(animations) - 1], i)
if inspect.isclass(attribute):
setattr(sys.modules[__name__], name, attribute)
# Set up the preferences class
preferences = Preferences()
# Define the number of pixels for the LED Strip
numPixels = preferences.get_setup_preferences('num-pixels')
# Initializes the LED strip
pixels = neopixel.NeoPixel(
board.D18,
numPixels,
brightness=preferences.get_setup_preferences('brightness'),
auto_write=False,
pixel_order=neopixel.GRB)
def getAnimationOptions():
global thread
class Manager(object):
def __init__(self):
self._preferences = None
self.__servers = None
return
def init(self):
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
connectionManager.onLoggedOn += self._onLoggedOn
def fini(self):
connectionManager.onLoggedOn -= self._onLoggedOn
self._preferences = None
self.__servers.fini()
self.__servers = None
return
def initiateLogin(self, email, password, serverName, isSocialToken2Login, rememberUser):
isToken2Login = isSocialToken2Login or self._preferences['token2']
if isToken2Login:
authMethod = CONNECTION_METHOD.TOKEN2
else:
authMethod = CONNECTION_METHOD.BASIC
serverName = self._getHost(authMethod, serverName)
self._preferences['session'] = BigWorld.wg_cpsalt(self._preferences['session'])
self._preferences['password_length'] = len(password)
self._preferences['remember_user'] = rememberUser
self._preferences['login'] = email
self._preferences['server_name'] = serverName
loginParams = {'login': self._preferences['login'],
'session': self._preferences['session'],
'temporary': str(int(not rememberUser)),
'auth_method': authMethod}
if isToken2Login:
loginParams['token2'] = self._preferences['token2']
if isSocialToken2Login:
self._preferences['login_type'] = self._preferences['login_type']
else:
self._preferences['login_type'] = 'credentials'
connectionManager.initiateConnection(loginParams, password, serverName)
def initiateRelogin(self, login, token2, serverName):
loginParams = {'login': login,
'token2': token2,
'session': BigWorld.wg_cpsalt(self._preferences['session']),
'temporary': str(int(not self._preferences['remember_user'])),
'auth_method': CONNECTION_METHOD.TOKEN2}
self._preferences['server_name'] = serverName
connectionManager.initiateConnection(loginParams, '', serverName)
def getPreference(self, key):
return self._preferences[key]
def clearPreferences(self):
self._preferences.clear()
def clearToken2Preference(self):
self._preferences['token2'] = ''
def writePreferences(self):
self._preferences.writeLoginInfo()
@property
def servers(self):
return self.__servers
def _onLoggedOn(self, responseData):
name = responseData.get('name', 'UNKNOWN')
token2 = responseData.get('token2', '')
g_lobbyContext.setCredentials(name, token2)
if self._preferences['remember_user']:
self._preferences['name'] = name
self._preferences['token2'] = token2
if 'server_name' in self._preferences and AUTO_LOGIN_QUERY_ENABLED:
del self._preferences['server_name']
else:
email = self._preferences['login']
serverName = self._preferences['server_name']
session = self._preferences['session']
self._preferences.clear()
if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset:
self._preferences['login'] = email
if not AUTO_LOGIN_QUERY_ENABLED:
self._preferences['server_name'] = serverName
self._preferences['session'] = session
self.writePeripheryLifetime()
self._preferences.writeLoginInfo()
self.__dumpUserName(name)
self._showSecurityMessage(responseData)
def _showSecurityMessage(self, responseData):
securityWarningType = responseData.get('security_msg')
if securityWarningType is not None:
securityLink = ''
if not GUI_SETTINGS.isEmpty('securitySettingsURL'):
securityLink = makeHtmlString('html_templates:lobby/system_messages', 'link', {'text': _ms(SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS),
'linkType': 'securityLink'})
SystemMessages.pushI18nMessage('#system_messages:securityMessage/%s' % securityWarningType, type=SystemMessages.SM_TYPE.Warning, link=securityLink)
return
def writePeripheryLifetime(self):
if AUTO_LOGIN_QUERY_ENABLED and connectionManager.peripheryID:
self._preferences['peripheryLifetime'] = pickle.dumps((connectionManager.peripheryID, time.time() + _PERIPHERY_DEFAULT_LIFETIME))
def _getHost(self, authMethod, hostName):
if hostName != AUTO_LOGIN_QUERY_URL:
return hostName
else:
pickledData = self._preferences['peripheryLifetime']
if pickledData:
try:
peripheryID, expirationTimestamp = pickle.loads(pickledData)
except:
LOG_DEBUG("Couldn't to read pickled periphery data. Connecting to {0}.".format(hostName))
return hostName
if expirationTimestamp > time.time():
host = g_preDefinedHosts.periphery(peripheryID, False)
if host is None:
return hostName
if authMethod != CONNECTION_METHOD.BASIC and host.urlToken:
return host.urlToken
return host.url
return hostName
def __dumpUserName(self, name):
""" Dump user name to the preferences.xml (required by WGLeague's anti-cheat).
See WOTD-55587. This method doesn't belong to Preferences class, so it's placed here.
"""
Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO].writeString('user', name)
Settings.g_instance.save()
class Manager(ILoginManager):
def __init__(self):
self._preferences = None
self.__servers = None
return
def init(self):
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
connectionManager.onLoggedOn += self._onLoggedOn
def fini(self):
connectionManager.onLoggedOn -= self._onLoggedOn
self._preferences = None
self.__servers.fini()
self.__servers = None
return
def initiateLogin(self, email, password, serverName, isSocialToken2Login,
rememberUser):
isToken2Login = isSocialToken2Login or self._preferences['token2']
if isToken2Login:
authMethod = CONNECTION_METHOD.TOKEN2
else:
authMethod = CONNECTION_METHOD.BASIC
serverName = self._getHost(authMethod, serverName)
self._preferences['session'] = BigWorld.wg_cpsalt(
self._preferences['session'])
self._preferences['password_length'] = len(password)
self._preferences['remember_user'] = rememberUser
self._preferences['login'] = email
self._preferences['server_name'] = serverName
loginParams = {
'login': self._preferences['login'],
'session': self._preferences['session'],
'temporary': str(int(not rememberUser)),
'auth_method': authMethod
}
if isToken2Login:
loginParams['token2'] = self._preferences['token2']
if not isSocialToken2Login:
self._preferences['login_type'] = 'credentials'
connectionManager.initiateConnection(loginParams, password, serverName)
def initiateRelogin(self, login, token2, serverName):
loginParams = {
'login': login,
'token2': token2,
'session': BigWorld.wg_cpsalt(self._preferences['session']),
'temporary': str(int(not self._preferences['remember_user'])),
'auth_method': CONNECTION_METHOD.TOKEN2
}
self._preferences['server_name'] = serverName
connectionManager.initiateConnection(loginParams, '', serverName)
def getPreference(self, key):
return self._preferences[key]
def clearPreferences(self):
self._preferences.clear()
def clearToken2Preference(self):
self._preferences['token2'] = ''
def writePreferences(self):
self._preferences.writeLoginInfo()
@property
def servers(self):
return self.__servers
def _onLoggedOn(self, responseData):
name = responseData.get('name', 'UNKNOWN')
token2 = responseData.get('token2', '')
g_lobbyContext.setCredentials(name, token2)
if self._preferences['remember_user']:
self._preferences['name'] = name
self._preferences['token2'] = token2
if 'server_name' in self._preferences and AUTO_LOGIN_QUERY_ENABLED:
del self._preferences['server_name']
else:
email = self._preferences['login']
serverName = self._preferences['server_name']
session = self._preferences['session']
self._preferences.clear()
if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset:
self._preferences['login'] = email
if not AUTO_LOGIN_QUERY_ENABLED:
self._preferences['server_name'] = serverName
self._preferences['session'] = session
self._preferences.writeLoginInfo()
self.__dumpUserName(name)
self._showSecurityMessage(responseData)
def _showSecurityMessage(self, responseData):
securityWarningType = responseData.get('security_msg')
if securityWarningType is not None:
securityLink = ''
if not GUI_SETTINGS.isEmpty('securitySettingsURL'):
securityLink = makeHtmlString(
'html_templates:lobby/system_messages', 'link', {
'text': _ms(
SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS),
'linkType': 'securityLink'
})
SystemMessages.pushI18nMessage(
'#system_messages:securityMessage/%s' % securityWarningType,
type=SystemMessages.SM_TYPE.Warning,
link=securityLink)
return
def writePeripheryLifetime(self):
if AUTO_LOGIN_QUERY_ENABLED and connectionManager.peripheryID:
self._preferences['peripheryLifetime'] = pickle.dumps(
(connectionManager.peripheryID,
time.time() + _PERIPHERY_DEFAULT_LIFETIME))
self._preferences.writeLoginInfo()
def _getHost(self, authMethod, hostName):
if hostName != AUTO_LOGIN_QUERY_URL:
return hostName
else:
pickledData = self._preferences['peripheryLifetime']
if pickledData:
try:
peripheryID, expirationTimestamp = pickle.loads(
pickledData)
except:
LOG_DEBUG(
"Couldn't to read pickled periphery data. Connecting to {0}."
.format(hostName))
return hostName
if expirationTimestamp > time.time():
host = g_preDefinedHosts.periphery(peripheryID, False)
if host is None:
return hostName
if authMethod != CONNECTION_METHOD.BASIC and host.urlToken:
return host.urlToken
return host.url
return hostName
def __dumpUserName(self, name):
""" Dump user name to the preferences.xml (required by WGLeague's anti-cheat).
See WOTD-55587. This method doesn't belong to Preferences class, so it's placed here.
"""
Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO].writeString(
'user', name)
Settings.g_instance.save()
class MainWindow( QtGui.QMainWindow ):
## Constructeur
# Le constructeur va creer la fenetre principale en y ajoutant tous les widgets necessaires au programme
def __init__( self ):
# Appel au constructeur de la classe mere
QtGui.QMainWindow.__init__( self )
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle( "TVDownloader" )
# Mise en place de son icone
self.setWindowIcon( QtGui.QIcon( "ico/TVDownloader.png" ) )
###
# Mise en place des widgets dans la fenetre
###
# Widget central qui contiendra tout
self.centralWidget = QtGui.QWidget( self )
#
# Barre du haut
#
# Layout horizontal qui contiendra les listes deroulantes
self.horizontalLayoutBarreHaut = QtGui.QHBoxLayout()
# Liste deroulante pour choisir le site (plugin)
self.comboBoxSite = QtGui.QComboBox( self.centralWidget )
self.horizontalLayoutBarreHaut.addWidget( self.comboBoxSite )
# Liste deroulante pour choisir une chaine du site courant
self.comboBoxChaine = QtGui.QComboBox( self.centralWidget)
self.horizontalLayoutBarreHaut.addWidget( self.comboBoxChaine )
# Liste deroulante pour choisir une emission de la chaine courante
self.comboBoxEmission = QtGui.QComboBox( self.centralWidget )
self.horizontalLayoutBarreHaut.addWidget( self.comboBoxEmission )
#
# Onglets
#
# Gestionnaire onglets
self.tabWidget = QtGui.QTabWidget( self.centralWidget )
# Onglet Fichiers
self.tabFichiers = QtGui.QSplitter( self.centralWidget ) # L'onglet Fichier contient un splitter
self.tabWidget.addTab( self.tabFichiers, u"Choix des fichiers" )
# Onglet Telechargements
self.tabTelechargements = QtGui.QWidget( self.centralWidget )
self.tabWidget.addTab( self.tabTelechargements, u"Téléchargements" )
#
# Liste des fichiers
#
# Layout de grille qui contient le tableau qui liste les fichiers + boutons
self.gridLayoutFichiers = QtGui.QGridLayout( self.tabFichiers )
# Tableau qui contient la liste des fichiers disponibles pour l'emission courante
self.tableWidgetFichier = MyQTableWidget( self.tabFichiers )
# Il a 4 colonnes et 0 ligne (pour l'instant)
self.tableWidgetFichier.setColumnCount( 3 )
self.tableWidgetFichier.setRowCount( 0 )
# On ajoute les titres
self.tableWidgetFichier.setHorizontalHeaderItem( 0,
self.tableWidgetFichier.creerItem( "" ) )
self.tableWidgetFichier.setHorizontalHeaderItem( 1,
self.tableWidgetFichier.creerItem( "Date" ) )
self.tableWidgetFichier.setHorizontalHeaderItem( 2,
self.tableWidgetFichier.creerItem( "Emission" ) )
# On l'ajoute au layout
self.gridLayoutFichiers.addWidget( self.tableWidgetFichier, 0, 1, 6, 1 )
# Icones du tableWidget
self.iconeFichier = QtGui.QIcon( "ico/gtk-file.svg" )
self.iconeAjoute = QtGui.QIcon( "ico/gtk-add.svg" )
self.iconeTelecharge = QtGui.QIcon( "ico/gtk-apply.svg" )
# Bouton pour ajouter tous les fichiers a la liste des telechargements
self.pushButtonToutAjouter = MyQPushButton( self.tabFichiers )
self.pushButtonToutAjouter.setIcon( QtGui.QIcon( "ico/gtk-add.svg" ) )
self.pushButtonToutAjouter.setToolTip( u"Ajouter tous les fichiers à la liste des téléchargements" )
self.gridLayoutFichiers.addWidget( self.pushButtonToutAjouter, 0, 0, 2, 1 )
# Bouton pour rafraichir le plugin courant
self.pushButtonRafraichirPlugin = MyQPushButton( self.tabFichiers )
self.pushButtonRafraichirPlugin.setIcon( QtGui.QIcon( "ico/gtk-refresh.svg" ) )
self.pushButtonRafraichirPlugin.setToolTip( "Rafraichir le plugin" )
self.gridLayoutFichiers.addWidget( self.pushButtonRafraichirPlugin, 2, 0, 2, 1 )
# Bouton pour ouvrir la fenetre des preferences du plugin courant
self.pushButtonPreferencesPlugin = MyQPushButton( self.tabFichiers )
self.pushButtonPreferencesPlugin.setIcon( QtGui.QIcon( "ico/gtk-preferences.svg" ) )
self.pushButtonPreferencesPlugin.setToolTip( u"Ouvrir les préférences du plugin" )
self.gridLayoutFichiers.addWidget( self.pushButtonPreferencesPlugin, 4, 0, 2, 1 )
# On met en place ce layout sur un widget (pour le splitter)
self.widgetFichiers = QtGui.QWidget()
self.widgetFichiers.setLayout( self.gridLayoutFichiers )
#
# Descriptif des fichiers
#
# Layout de grille
self.gridLayoutDescriptif = QtGui.QGridLayout()
# Label pour afficher un logo
self.logoFichierDefaut = QtGui.QPixmap()
self.logoFichierDefaut.load( "img/gtk-dialog-question.svg" )
self.labelLogo = QtGui.QLabel( self.centralWidget )
self.labelLogo.setPixmap( self.logoFichierDefaut.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) )
self.gridLayoutDescriptif.addWidget( self.labelLogo, 0, 0, 1, 1 )
# Zone de texte pour afficher un descriptif
self.plainTextEdit = QtGui.QPlainTextEdit( self.centralWidget )
self.gridLayoutDescriptif.addWidget( self.plainTextEdit, 0, 1, 1, 2 )
# On met en place ce layout sur un widget (pour le splitter)
self.widgetDescriptif = QtGui.QWidget()
self.widgetDescriptif.setLayout( self.gridLayoutDescriptif )
# Onrientation verticale du splitter
self.tabFichiers.setOrientation( QtCore.Qt.Vertical )
# On ajoute les 2 elements au splitter (qui est notre onglet)
self.tabFichiers.addWidget( self.widgetFichiers )
self.tabFichiers.addWidget( self.widgetDescriptif )
#
# Liste des telechargements
#
# Layout de grille qui contient le tableau qui liste les fichiers a telecharger + les boutons pour le controller
self.gridLayoutTelechargement = QtGui.QGridLayout( self.tabTelechargements )
# Tableau qui contient la liste des fichiers a telecharger
self.tableWidgetTelechargement = MyQTableWidget( self.tabTelechargements )
# Il a 5 colonnes et 0 ligne (pour l'instant)
self.tableWidgetTelechargement.setColumnCount( 3 )
self.tableWidgetTelechargement.setRowCount( 0 )
# On ajoute le titre des 5 colonnes
self.tableWidgetTelechargement.setHorizontalHeaderItem( 0,
self.tableWidgetTelechargement.creerItem( "Date" ) )
self.tableWidgetTelechargement.setHorizontalHeaderItem( 1,
self.tableWidgetTelechargement.creerItem( "Emission" ) )
self.tableWidgetTelechargement.setHorizontalHeaderItem( 2,
self.tableWidgetTelechargement.creerItem( "Etat" ) )
# On l'ajoute au layout
self.gridLayoutTelechargement.addWidget( self.tableWidgetTelechargement, 0, 1, 4, 1 )
# Bouton pour monter l'element selectionne tout en haut de la liste
self.pushButtonExtremiteMonter = MyQPushButton( self.tabTelechargements )
self.pushButtonExtremiteMonter.setIcon( QtGui.QIcon( "ico/gtk-jump-to-rtl.svg" ) )
self.pushButtonExtremiteMonter.setToolTip( u"Placer l'élément sélectionné tout en haut" )
self.gridLayoutTelechargement.addWidget( self.pushButtonExtremiteMonter, 0, 0, 1, 1 )
# Bouton pour monter l'element selectionne d'un cran dans la liste
self.pushButtonMonter = MyQPushButton( self.tabTelechargements )
self.pushButtonMonter.setIcon( QtGui.QIcon( "ico/gtk-go-up.svg" ) )
self.pushButtonMonter.setToolTip( u"Monter l'élément sélectionné" )
self.gridLayoutTelechargement.addWidget( self.pushButtonMonter, 1, 0, 1, 1 )
# Bouton pour descendre l'element selectionne d'un cran dans la liste
self.pushButtonDescendre = MyQPushButton( self.tabTelechargements )
self.pushButtonDescendre.setIcon( QtGui.QIcon( "ico/gtk-go-down.svg" ) )
self.pushButtonDescendre.setToolTip( u"Descendre l'élément selectionné" )
self.gridLayoutTelechargement.addWidget( self.pushButtonDescendre, 2, 0, 1, 1 )
# Bouton pour descendre l'element selectionne tout en bas de la liste
self.pushButtonExtremiteDescendre = MyQPushButton( self.tabTelechargements )
self.pushButtonExtremiteDescendre.setIcon( QtGui.QIcon( "ico/gtk-jump-to-ltr.svg" ) )
self.pushButtonExtremiteDescendre.setToolTip( u"Placer l'élément sélectionné tout en bas" )
self.gridLayoutTelechargement.addWidget( self.pushButtonExtremiteDescendre, 3, 0, 1, 1 )
# Bouton pour supprimer tous les elements de la liste
self.pushButtonToutSupprimer = MyQPushButton( self.tabTelechargements )
self.pushButtonToutSupprimer.setIcon( QtGui.QIcon( "ico/gtk-cancel.svg" ) )
self.pushButtonToutSupprimer.setToolTip( u"Supprimer tous les téléchargements" )
self.gridLayoutTelechargement.addWidget( self.pushButtonToutSupprimer, 0, 2, 1, 1 )
# Bouton pour supprimer de la liste les telechargements termines
self.pushButtonNettoyer = MyQPushButton( self.tabTelechargements )
self.pushButtonNettoyer.setIcon( QtGui.QIcon( "ico/gtk-delete-full.svg" ) )
self.pushButtonNettoyer.setToolTip( u"Supprimer les téléchargement terminés" )
self.gridLayoutTelechargement.addWidget( self.pushButtonNettoyer, 1, 2, 1, 1 )
# Bouton pour ouvrir le dossier des telechargements
self.pushButtonOuvrirDossierTelechargement = MyQPushButton( self.tabTelechargements )
self.pushButtonOuvrirDossierTelechargement.setIcon( QtGui.QIcon( "ico/gtk-folder.svg" ) )
self.pushButtonOuvrirDossierTelechargement.setToolTip( u"Ouvrir le dossier des téléchargements" )
self.gridLayoutTelechargement.addWidget( self.pushButtonOuvrirDossierTelechargement, 2, 2, 1, 1 )
#
# Barre progression de telechargement d'un fichier
#
self.progressBarTelechargementFichier = QtGui.QProgressBar( self.centralWidget )
self.progressBarTelechargementFichier.setProperty( "value", 0 )
#
# Barre de progression de telechargement des fichiers
#
self.progressBarTelechargement = QtGui.QProgressBar( self.centralWidget )
self.progressBarTelechargement.setProperty( "value", 0 )
#
# Boutons du bas pour gerer ajouter/supprimer/lancer telechargements
#
# Layout horizontal qui contiendra les boutons
self.horizontalLayoutBarreBas = QtGui.QHBoxLayout()
# Bouton pour lancer les telechargements
self.pushButtonLancer = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-play-ltr.svg" ), u"Lancer téléchargement", self.centralWidget )
self.horizontalLayoutBarreBas.addWidget( self.pushButtonLancer )
# Bouton pour stopper les telechargements
self.pushButtonStop = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-stop.svg" ), u"Stopper le téléchargement", self.centralWidget )
self.pushButtonStop.setEnabled( False )
self.horizontalLayoutBarreBas.addWidget( self.pushButtonStop )
###
# Positionnement des differents widgets/layouts sur le layout de grille
###
# Layout de grille dans lequel on va placer nos widgets/layouts
self.gridLayout = QtGui.QGridLayout( self.centralWidget )
# On ajoute la barre du haut
self.gridLayout.addLayout( self.horizontalLayoutBarreHaut, 0, 0, 1, 3 )
# On ajoute le gestionnaire d'onglets
self.gridLayout.addWidget( self.tabWidget, 1, 0, 1, 3 )
# On ajoute la barre de progression de telechargement d'un fichier
self.gridLayout.addWidget( self.progressBarTelechargementFichier, 2, 0, 1, 3 )
# On ajoute la barre de progression de telechargement des fichiers
self.gridLayout.addWidget( self.progressBarTelechargement, 3, 0, 1, 3 )
# On ajoute les boutons ajouter/supprimer/lancer
self.gridLayout.addLayout( self.horizontalLayoutBarreBas, 4, 0, 1, 3 )
###
# Mise en place le central widget dans la fenetre
###
self.setCentralWidget( self.centralWidget )
###
# Mise en place du menu
###
# Menu barre
self.menubar = QtGui.QMenuBar( self )
self.menubar.setGeometry( QtCore.QRect( 0, 0, 480, 25 ) )
# Menu Fichier
self.menuFichier = QtGui.QMenu( "&Fichier", self.menubar )
self.menubar.addAction( self.menuFichier.menuAction() )
# Action Fichier -> Quitter
self.actionQuitter = QtGui.QAction( QtGui.QIcon( "ico/gtk-quit.svg" ), "&Quitter", self )
self.actionQuitter.setIconVisibleInMenu( True )
self.menuFichier.addAction( self.actionQuitter )
# Menu Edition
self.menuEdition = QtGui.QMenu( "&Edition", self.menubar )
self.menubar.addAction( self.menuEdition.menuAction() )
# Action Edition -> Mise a jour
self.actionMAJ = QtGui.QAction( QtGui.QIcon( "ico/gtk-refresh.svg" ), u"&Mise à jour des plugins", self )
self.actionMAJ.setIconVisibleInMenu( True )
self.menuEdition.addAction( self.actionMAJ )
# Action Edition -> Preferences
self.actionPreferences = QtGui.QAction( QtGui.QIcon( "ico/gtk-preferences.svg" ), u"&Préférences", self )
self.actionPreferences.setIconVisibleInMenu( True )
self.menuEdition.addAction( self.actionPreferences )
# Menu Aide
self.menuAide = QtGui.QMenu( "&Aide", self.menubar )
self.menubar.addAction( self.menuAide.menuAction() )
# Action Aide -> A propos
self.actionAPropos = QtGui.QAction( QtGui.QIcon( "ico/gtk-about.svg" ), u"À p&ropos", self )
self.actionAPropos.setIconVisibleInMenu( True )
self.menuAide.addAction( self.actionAPropos )
# Ajout du menu a l'interface
self.setMenuBar( self.menubar )
###
# Signaux provenants de l'interface
###
QtCore.QObject.connect( self.tableWidgetFichier,
QtCore.SIGNAL( "cellClicked(int,int)" ),
self.afficherInformationsFichier )
QtCore.QObject.connect( self.tableWidgetFichier,
QtCore.SIGNAL( "cellDoubleClicked(int,int)" ),
self.gererTelechargement )
QtCore.QObject.connect( self.pushButtonToutAjouter,
QtCore.SIGNAL( "clicked()" ),
self.ajouterTousLesFichiers )
QtCore.QObject.connect( self.pushButtonRafraichirPlugin,
QtCore.SIGNAL( "clicked()" ),
self.rafraichirPlugin )
QtCore.QObject.connect( self.tableWidgetTelechargement,
QtCore.SIGNAL( "cellDoubleClicked(int,int)" ),
self.supprimerTelechargement )
QtCore.QObject.connect( self.pushButtonExtremiteMonter,
QtCore.SIGNAL( "clicked()" ),
lambda versLeHaut = True, extremite = True : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) )
QtCore.QObject.connect( self.pushButtonMonter,
QtCore.SIGNAL( "clicked()" ),
lambda versLeHaut = True, extremite = False : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) )
QtCore.QObject.connect( self.pushButtonDescendre,
QtCore.SIGNAL( "clicked()" ),
lambda versLeHaut = False, extremite = False : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) )
QtCore.QObject.connect( self.pushButtonExtremiteDescendre,
QtCore.SIGNAL( "clicked()" ),
lambda versLeHaut = False, extremite = True : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) )
QtCore.QObject.connect( self.pushButtonToutSupprimer,
QtCore.SIGNAL( "clicked()" ),
self.supprimerTousLesTelechargements )
QtCore.QObject.connect( self.pushButtonNettoyer,
QtCore.SIGNAL( "clicked()" ),
self.nettoyer )
QtCore.QObject.connect( self.pushButtonLancer,
QtCore.SIGNAL( "clicked()" ),
self.lancerTelechargement )
QtCore.QObject.connect( self.pushButtonStop,
QtCore.SIGNAL( "clicked()" ),
self.stopperTelechargement )
QtCore.QObject.connect( self.actionQuitter,
QtCore.SIGNAL( "triggered()" ),
self.close )
################################################
# Instanciations + initialisation de variables #
################################################
# Fenetre About
self.aProposDialog = None
# Fenetre des preferences du logiciel
self.preferencesDialog = None
# Fenetre de mise a jour des plugins
self.updateManagerDialog = None
# Nom plugin courant
self.nomPluginCourant = ""
# Liste des fichiers
self.listeFichiers = []
# Liste des fichiers a telecharger
self.listeFichiersATelecharger = []
# Cache des images descriptive
# Clef : urlImage Valeur : image (binaire)
self.cacheImage = {}
# On intancie le lanceur de signaux
self.signaux = Signaux()
# On instancie le gestionnaire de preferences
self.preferences = Preferences()
# On instancie le gestionnaire de preferences des plugins
self.preferencesPluginDialog = PreferencePluginDialog( self )
# On instancie le gestionnaire de download
self.downloader = Downloader( self.signaux )
# On recupere l'instance de API
self.api = API.getInstance()
# On instancie le gestionnaire d'historique
self.historique = Historique()
# On instancie la fenetre d'attente
self.fenetreAttenteProgressDialog = FenetreAttenteProgressDialog( self )
# On instancie le gest
#
# Fenetre de confirmation pour quitter le logiciel
#
self.quitterMessageBox = QtGui.QMessageBox( self )
self.quitterMessageBox.setWindowTitle( "Fermeture de TVDownloader" )
self.quitterMessageBox.setText( u"Voulez-vous réellement quitter TVDownloader ?" )
self.quitterMessageBox.setInformativeText( u"Votre liste de téléchargement sera perdue" )
self.quitterMessageBox.addButton( "Oui", QtGui.QMessageBox.AcceptRole )
self.quitterMessageBox.addButton( "Non", QtGui.QMessageBox.RejectRole )
############################################################
# On connecte les signaux des instances precedements crees #
############################################################
QtCore.QObject.connect( self.pushButtonOuvrirDossierTelechargement,
QtCore.SIGNAL( "clicked()" ),
self.ouvrirRepertoireTelechargement )
QtCore.QObject.connect( self.comboBoxSite,
QtCore.SIGNAL( "activated(QString)" ),
self.listerChaines )
QtCore.QObject.connect( self.comboBoxChaine,
QtCore.SIGNAL( "activated(QString)" ),
self.listerEmissions )
QtCore.QObject.connect( self.comboBoxEmission,
QtCore.SIGNAL( "activated(QString)" ),
self.listerFichiers )
QtCore.QObject.connect( self.pushButtonPreferencesPlugin,
QtCore.SIGNAL( "clicked()" ),
self.ouvrirPreferencesPlugin )
QtCore.QObject.connect( self.actionPreferences,
QtCore.SIGNAL( "triggered()" ),
self.ouvrirPreferencesLogiciel )
QtCore.QObject.connect( self.actionMAJ,
QtCore.SIGNAL( "triggered()" ),
self.ouvrirFenetreMiseAJour )
QtCore.QObject.connect( self.actionAPropos,
QtCore.SIGNAL( "triggered()" ),
self.ouvrirFenetreAPropos )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ) , self.fenetreAttenteProgressDialog.ouvrirFenetreAttente )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finActualisation()" ) , self.fenetreAttenteProgressDialog.fermerFenetreAttente )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "actualiserListesDeroulantes()" ) , self.actualiserListesDeroulantes )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeChaines(PyQt_PyObject)" ) , self.ajouterChaines )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeEmissions(PyQt_PyObject)" ) , self.ajouterEmissions )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeFichiers(PyQt_PyObject)" ) , self.ajouterFichiers )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "nouvelleImage(PyQt_PyObject)" ) , self.mettreEnPlaceImage )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "debutTelechargement(int)" ) , self.debutTelechargement )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finTelechargement(int)" ) , self.finTelechargement )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finDesTelechargements()" ) , self.activerDesactiverInterface )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "pourcentageFichier(int)" ) , self.progressBarTelechargementFichier.setValue )
#########
# Début #
#########
# La fenetre prend la dimension qu'elle avait a sa fermeture
taille = self.preferences.getPreference( "tailleFenetre" )
self.resize( taille[ 0 ], taille[ 1 ] )
# Si aucun plugin n'est active, on ouvre la fenetre des preferences
if( len( self.preferences.getPreference( "pluginsActifs" ) ) == 0 ):
self.ouvrirPreferencesLogiciel()
# On actualise tous les plugins
self.rafraichirTousLesPlugins()
## Methode qui execute les actions necessaires avant de quitter le programme
def actionsAvantQuitter( self ):
# On sauvegarde les options des plugins
self.api.fermeture()
# On sauvegarde la taille de la fenetre
taille = self.size()
self.preferences.setPreference( "tailleFenetre", [ taille.width(), taille.height() ] )
# On sauvegarde les options du logiciel
self.preferences.sauvegarderConfiguration()
# On sauvegarde l'historique
self.historique.sauverHistorique()
# On stoppe les telechargements
self.stopperTelechargement()
#########################################
# Surcharge des methodes de QMainWindow #
#########################################
## Surcharge de la methode appelee lors de la fermeture de la fenetre
# Ne doit pas etre appele explicitement
# @param evenement Evenement qui a provoque la fermeture
def closeEvent( self, evenement ):
# On affiche une fenetre pour demander la fermeture si des fichiers sont dans la liste de telechargement
if( self.tableWidgetTelechargement.rowCount() > 0 ):
# On affiche une fenetre qui demande si on veut quitter
retour = self.quitterMessageBox.exec_()
# Si on veut quitter
if( retour == 0 ):
# On execute les actions necessaires
self.actionsAvantQuitter()
# On accept la fermeture
evenement.accept()
else:
# On refuse la fermeture
evenement.ignore()
else: # S'il n'y a pas de fichier
# On execute les actions necessaires
self.actionsAvantQuitter()
# On accept la fermeture
evenement.accept()
##############################################
# Methodes pour remplir les menus deroulants #
##############################################
## Methode qui actualise les listes deroulantes
def actualiserListesDeroulantes( self ):
# On lance juste l'ajout des sites en se basant sur les plugins actifs
self.ajouterSites( self.preferences.getPreference( "pluginsActifs" ) )
## Methode qui lance le listage des chaines
# @param site Nom du plugin/site pour lequel on va lister les chaines
def listerChaines( self, site ):
def threadListerChaines( self, nomPlugin ):
self.signaux.signal( "debutActualisation", nomPlugin )
listeChaines = self.api.getPluginListeChaines( nomPlugin )
self.signaux.signal( "listeChaines", listeChaines )
self.signaux.signal( "finActualisation" )
if( site != "" ):
self.nomPluginCourant = qstringToString( site )
threading.Thread( target = threadListerChaines, args = ( self, self.nomPluginCourant ) ).start()
# On active (ou pas) le bouton de preference du plugin
self.pushButtonPreferencesPlugin.setEnabled( self.api.getPluginListeOptions( self.nomPluginCourant ) != [] )
## Methode qui lance le listage des emissions
# @param chaine Nom de la chaine pour laquelle on va lister les emissions
def listerEmissions( self, chaine ):
def threadListerEmissions( self, nomPlugin, chaine ):
self.signaux.signal( "debutActualisation", nomPlugin )
listeEmissions = self.api.getPluginListeEmissions( nomPlugin, chaine )
self.signaux.signal( "listeEmissions", listeEmissions )
self.signaux.signal( "finActualisation" )
if( chaine != "" ):
threading.Thread( target = threadListerEmissions, args = ( self, self.nomPluginCourant, qstringToString( chaine ) ) ).start()
## Methode qui lance le listage des fichiers
# @param emission Nom de l'emission pour laquelle on va lister les fichiers
def listerFichiers( self, emission ):
def threadListerFichiers( self, nomPlugin, emission ):
self.signaux.signal( "debutActualisation", nomPlugin )
listeFichiers = self.api.getPluginListeFichiers( nomPlugin, emission )
self.signaux.signal( "listeFichiers", listeFichiers )
self.signaux.signal( "finActualisation" )
if( emission != "" ):
threading.Thread( target = threadListerFichiers, args = ( self, self.nomPluginCourant, qstringToString( emission ) ) ).start()
## Methode qui met en place une liste de sites sur l'interface
# @param listeSites Liste des sites a mettre en place
def ajouterSites( self, listeSites ):
# On efface la liste des sites
self.comboBoxSite.clear()
# On met en place les sites
for site in listeSites:
self.comboBoxSite.addItem( stringToQstring( site ) )
# On selectionne par defaut celui choisis dans les preference
index = self.comboBoxSite.findText( stringToQstring( self.preferences.getPreference( "pluginParDefaut" ) ) )
if( index != -1 ):
self.comboBoxSite.setCurrentIndex( index )
# On lance l'ajout des chaines
self.listerChaines( self.comboBoxSite.currentText() )
## Methode qui met en place une liste de chaines sur l'interface
# @param listeChaines Liste des chaines a mettre en place
def ajouterChaines( self, listeChaines ):
# On trie la liste des chaines
listeChaines.sort()
# On efface la liste des chaines
self.comboBoxChaine.clear()
# On efface la liste des emissions
self.comboBoxEmission.clear()
# On efface la liste des fichiers
self.tableWidgetFichier.toutSupprimer()
# On met en place les chaines
for chaine in listeChaines:
self.comboBoxChaine.addItem( stringToQstring( chaine ) )
# Si on a juste une seule chaine
if( self.comboBoxChaine.count() == 1 ):
# On lance l'ajout des emissions
self.listerEmissions( self.comboBoxChaine.currentText() )
else:
# On ne selectionne pas de chaine
self.comboBoxChaine.setCurrentIndex( -1 )
## Methode qui met en place une liste d'emissions sur l'interface
# @param listeEmissions Liste des emissions a mettre en place
def ajouterEmissions( self, listeEmissions ):
# On trie la liste des emissions
listeEmissions.sort()
# On efface la liste des emissions
self.comboBoxEmission.clear()
# On efface la liste des fichiers
self.tableWidgetFichier.toutSupprimer()
# On met en place la liste des emissions
for emission in listeEmissions:
self.comboBoxEmission.addItem( stringToQstring( emission ) )
# Si on a juste une seule emission
if( self.comboBoxEmission.count() == 1 ):
# On lance l'ajout des fichiers
self.listerFichiers( self.comboBoxEmission.currentText() )
else:
# On ne selectionne pas d'emission
self.comboBoxEmission.setCurrentIndex( -1 )
###############################################
# Methodes pour remplir la liste des fichiers #
###############################################
## Methode pour ajouter des fichiers a l'interface
# @param listeFichiers Liste des fichiers a ajouter
def ajouterFichiers( self, listeFichiers ):
self.listeFichiers = listeFichiers
# On efface la liste des fichiers
self.tableWidgetFichier.toutSupprimer()
# On commence au depart
ligneCourante = 0
# On met en place chacun des fichiers
for fichier in listeFichiers:
# On ajoute une ligne
self.tableWidgetFichier.insertRow( ligneCourante )
# On ajoute les informations au tableWidgetFichier
liste = []
liste.append( self.tableWidgetFichier.creerItem( "" ) )
liste.append( self.tableWidgetFichier.creerItem( getattr( fichier, "date" ) ) )
liste.append( self.tableWidgetFichier.creerItem( getattr( fichier, "nom" ) ) )
self.tableWidgetFichier.setLigne( ligneCourante, liste )
# On met en place l'icone qui va bien
self.gererIconeListeFichier( fichier )
ligneCourante += 1
# On adapte la taille des colonnes
self.tableWidgetFichier.adapterColonnes()
## Methode qui rafraichit le plugin courant
def rafraichirPlugin( self ):
def threadRafraichirPlugin( self, nomPlugin ):
self.signaux.signal( "debutActualisation", nomPlugin )
self.api.pluginRafraichir( nomPlugin )
self.signaux.signal( "finActualisation" )
threading.Thread( target = threadRafraichirPlugin, args = ( self, self.nomPluginCourant ) ).start()
## Methode qui met en place l'image de la description d'un fichier
# @param image Image a mettre en place (binaire)
def mettreEnPlaceImage( self, image ):
logoFichier = QtGui.QPixmap()
logoFichier.loadFromData( image )
self.labelLogo.setPixmap( logoFichier.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) )
## Methode qui affiche des informations sur le fichier selectionne
def afficherInformationsFichier( self, ligne, colonne ):
def threadRecupererImage( self, urlImage ):
image = self.api.getPage( urlImage )
self.cacheImage[ urlImage ] = image
self.signaux.signal( "nouvelleImage", image )
fichier = self.listeFichiers[ ligne ]
# On recupere le lien de l'image et le texte descriptif
urlImage = getattr( fichier, "urlImage" )
texteDescriptif = getattr( fichier, "descriptif" )
self.plainTextEdit.clear()
# Si on a un texte descriptif, on l'affiche
if( texteDescriptif != "" ):
self.plainTextEdit.appendPlainText( stringToQstring( texteDescriptif ) )
else:
self.plainTextEdit.appendPlainText( u"Aucune information disponible" )
# Si on n'a pas d'image
if( urlImage == "" ):
# On met en place celle par defaut
self.logoFichier = self.logoFichierDefaut
self.labelLogo.setPixmap( self.logoFichier.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) )
else: # Si on en a une
# Si elle est dans le cache des images
if( self.cacheImage.has_key( urlImage ) ):
self.mettreEnPlaceImage( self.cacheImage[ urlImage ] )
else: # Sinon
# On lance le thread pour la recuperer
threading.Thread( target = threadRecupererImage, args = ( self, urlImage ) ).start()
## Methode qui gere l'icone d'un fichier dans la liste des telechargements
# Il y a 3 icones possible :
# - C'est un fichier
# - C'est un fichier present dans l'historique (donc deja telecharge)
# - C'est un fichier present dans la liste des telechargements
# @param fichier Fichier a gerer
def gererIconeListeFichier( self, fichier ):
if( fichier in self.listeFichiers ):
ligneFichier = self.listeFichiers.index( fichier )
# On cherche quel icone mettre en place
if( fichier in self.listeFichiersATelecharger ):
icone = self.iconeAjoute
elif( self.historique.comparerHistorique( fichier ) ):
icone = self.iconeTelecharge
else:
icone = self.iconeFichier
# On met en place l'icone
self.tableWidgetFichier.item( ligneFichier, 0 ).setIcon( icone )
######################################################
# Methodes pour remplir la liste des telechargements #
######################################################
## Methode qui gere la liste des telechargements
# @param ligne Numero de la ligne (dans la liste des fichiers) de l'element a ajouter
# @param colonne Numero de colonne (inutile, juste pour le slot)
def gererTelechargement( self, ligne, colonne = 0 ):
fichier = self.listeFichiers[ ligne ]
# Si le fichier est deja dans la liste des telechargements
if( fichier in self.listeFichiersATelecharger ):
ligneTelechargement = self.listeFichiersATelecharger.index( fichier )
self.supprimerTelechargement( ligneTelechargement )
else: # S'il n'y est pas, on l'ajoute
self.listeFichiersATelecharger.append( fichier )
numLigne = self.tableWidgetTelechargement.rowCount()
# On insere une nouvelle ligne dans la liste des telechargements
self.tableWidgetTelechargement.insertRow( numLigne )
# On y insere les elements qui vont biens
self.tableWidgetTelechargement.setLigne( numLigne,
[ self.tableWidgetTelechargement.creerItem( getattr( fichier, "date" ) ),
self.tableWidgetTelechargement.creerItem( getattr( fichier, "nom" ) ),
self.tableWidgetTelechargement.creerItem( u"En attente de téléchargement" )
]
)
# On adapte la taille des colonnes
self.tableWidgetTelechargement.adapterColonnes()
# On modifie l'icone dans la liste des fichiers
self.gererIconeListeFichier( fichier )
## Methode qui ajoute tous les fichiers a la liste des telechargements
def ajouterTousLesFichiers( self ):
for i in range( self.tableWidgetFichier.rowCount() ):
self.gererTelechargement( i )
## Methode qui supprime un fichier de la liste des telechargements
# @param ligne Numero de la ligne a supprimer
# @param colonne Numero de colonne (inutile, juste pour le slot)
def supprimerTelechargement( self, ligne, colonne = 0 ):
fichier = self.listeFichiersATelecharger[ ligne ]
# On supprime l'element du tableWidgetTelechargement
self.tableWidgetTelechargement.removeRow( ligne )
# On supprime l'element de la liste des fichiers a telecharger
self.listeFichiersATelecharger.remove( fichier )
# On modifie l'icone dans la liste des fichiers
self.gererIconeListeFichier( fichier )
## Methode qui supprime tous les telechargement de la liste des telechargements
def supprimerTousLesTelechargements( self ):
for i in range( self.tableWidgetTelechargement.rowCount() -1, -1, -1 ):
self.supprimerTelechargement( i )
## Methode qui lance le telechargement des fichiers
def lancerTelechargement( self ):
# On liste les emissions a telecharger avec leurs numeros de ligne
listeFichiers = []
for i in range( self.tableWidgetTelechargement.rowCount() ): # Pour chaque ligne
fichier = self.listeFichiersATelecharger[ i ]
listeFichiers.append( [ i,
getattr( fichier, "lien" ),
getattr( fichier, "nomFichierSortie" ) ] )
nbATelecharger = len( listeFichiers )
# Si on a des elements a charger
if( nbATelecharger > 0 ):
# On met en place la valeur du progressBar
self.progressBarTelechargement.setMaximum( nbATelecharger )
self.progressBarTelechargement.setValue( 0 )
# On lance le telechargement
threading.Thread( target = self.downloader.lancerTelechargement, args = ( listeFichiers, ) ).start()
# On active/desactive ce qui va bien sur l'interface
self.activerDesactiverInterface( True )
## Methode qui stoppe le telechargement
def stopperTelechargement( self ):
# On stoppe le telechargement
self.downloader.stopperTelechargement()
############################################
# Methodes pour ouvrir les autres fenetres #
############################################
#
# Fenetre About
#
## Methode pour afficher la fenetre About
def ouvrirFenetreAPropos( self ):
if( self.aProposDialog == None ):
self.aProposDialog = AProposDialog()
self.aProposDialog.show()
#
# Fenetre de preference du logiciel
#
## Methode pour ouvrir les preferences du logiciel
def ouvrirPreferencesLogiciel( self ):
if( self.preferencesDialog == None ):
self.preferencesDialog = PreferencesDialog( self, self.signaux )
self.preferencesDialog.afficher()
#
# Fenetre de mise a jour des plugins
#
## Methode pour ouvrir la fenetre de mise a jour des plugins
def ouvrirFenetreMiseAJour( self ):
if( self.updateManagerDialog == None ):
self.updateManagerDialog = UpdateManagerDialog( self )
self.updateManagerDialog.afficher()
#
# Fenetre de preference des plugins
#
## Methode pour ouvrir les preferences du plugin courant
def ouvrirPreferencesPlugin( self ):
listeOptions = self.api.getPluginListeOptions( self.nomPluginCourant )
self.preferencesPluginDialog.ouvrirDialogPreferences( self.nomPluginCourant, listeOptions )
#########
# Slots #
#########
## Methode qui ouvre le repertoire de telechargement
def ouvrirRepertoireTelechargement( self ):
QtGui.QDesktopServices.openUrl( QtCore.QUrl.fromLocalFile( self.preferences.getPreference( "repertoireTelechargement" ) ) )
## Methode qui rafraichit le plugin courant
def rafraichirPlugin( self ):
def threadRafraichirPlugin( self, nomPlugin ):
self.signaux.signal( "debutActualisation", nomPlugin )
self.api.pluginRafraichir( nomPlugin )
self.signaux.signal( "finActualisation" )
threading.Thread( target = threadRafraichirPlugin, args = ( self, self.nomPluginCourant ) ).start()
## Methode qui rafraichit tous les plugins
# A utiliser au lancement du programme
def rafraichirTousLesPlugins( self ):
def threadRafraichirTousLesPlugins( self ):
self.signaux.signal( "debutActualisation", "TVDownloader" )
self.api.pluginRafraichirAuto()
self.signaux.signal( "finActualisation" )
self.signaux.signal( "actualiserListesDeroulantes" )
threading.Thread( target = threadRafraichirTousLesPlugins, args = ( self, ) ).start()
## Slot qui active/desactive des elements de l'interface pendant un telechargement
# @param telechargementEnCours Indique si on telecharge ou pas
def activerDesactiverInterface( self, telechargementEnCours = False ):
# Les boutons
self.pushButtonLancer.setEnabled( not telechargementEnCours )
self.pushButtonStop.setEnabled( telechargementEnCours )
self.pushButtonExtremiteMonter.setEnabled( not telechargementEnCours )
self.pushButtonMonter.setEnabled( not telechargementEnCours )
self.pushButtonDescendre.setEnabled( not telechargementEnCours )
self.pushButtonExtremiteDescendre.setEnabled( not telechargementEnCours )
self.pushButtonToutSupprimer.setEnabled( not telechargementEnCours )
self.pushButtonNettoyer.setEnabled( not telechargementEnCours )
# Le table widget
self.tableWidgetTelechargement.setEnabled( not telechargementEnCours )
## Slot appele lors ce qu'un le debut d'un telechargement commence
# @param numero Position dans la liste des telechargement du telechargement qui commence
def debutTelechargement( self, numero ):
self.tableWidgetTelechargement.item( numero, 2 ).setText( stringToQstring( u"Téléchargement en cours..." ) )
self.tableWidgetTelechargement.adapterColonnes()
self.progressBarTelechargementFichier.setValue( 0 )
## Slot appele lorsqu'un telechargement se finit
# @param numero Position dans la liste des telechargement du telechargement qui se finit
def finTelechargement( self, numero ):
fichier = self.listeFichiersATelecharger[ numero ]
# On ajoute le fichier a l'historique
self.historique.ajouterHistorique( fichier )
# On modifie l'icone dans la liste des fichiers
self.gererIconeListeFichier( fichier )
# On modifie l'interface
self.tableWidgetTelechargement.item( numero, 2 ).setText( stringToQstring( u"Fini !" ) )
self.progressBarTelechargement.setValue( self.progressBarTelechargement.value() + 1 )
self.tableWidgetTelechargement.adapterColonnes()
self.progressBarTelechargementFichier.setValue( 100 )
## Slot qui nettoie la liste des telechargements de tous les telechargements finis
def nettoyer( self ):
for i in range( self.tableWidgetTelechargement.rowCount() - 1, -1, -1 ): # [ nbLignes - 1, nbLignes - 2, ..., 1, 0 ]
if( self.tableWidgetTelechargement.item( i, 2 ).text() == u"Fini !" ): # Si c'est telecharge
self.supprimerTelechargement( i )
def setUp( self ): self.preferences = Preferences()
def __init__(self):
#declaration des variables
global choice, temp, plugins, chaines, programs, fichiers, DLlist
chaines = ''
programs = ''
fichiers = ''
temp = 0
choice = ""
selectedPlugin = ''
selectedChaine = ''
selectedProgram = ''
DLlist = []
################################################
# Instanciations + initialisation de variables #
################################################
# On instancie le plugin manager
self.pluginManager = PluginManager()
# On instancie le gestionnaire de preferences
self.preferences = Preferences()
# On instancie le gestionnaire de download
self.downloader = Downloader()
# On recupere l'instance de API
self.api = API.getInstance()
# # On instancie le gestionnaire d'historique
# self.historique = Historique()
# Si aucun plugin n'est active, on ouvre la fenetre des preferences
if (len(self.preferences.getPreference("pluginsActifs")) == 0):
choice = 'p'
self.api.pluginRafraichirAuto()
# On met en place la liste des plugins dans API
plugins = self.preferences.getPreference("pluginsActifs")
plugins.sort()
# On actualise tous les plugins
self.api.pluginRafraichirAuto()
#boucle qui raffraichit l'affichage apres chaque interaction utilisateur
while choice != 'exit':
#ouverture du menu de preferences
if choice == 'p' or choice == 'P':
prefs()
# On met en place la liste des plugins dans API
plugins = self.preferences.getPreference("pluginsActifs")
plugins.sort()
# On actualise tous les plugins
self.api.pluginRafraichirAuto()
#ouverture du menu de telechargement
elif choice == 't' or choice == 'T':
dl(DLlist)
#ouverture de l'invite de fermeture
elif choice == 'q' or choice == 'Q':
quitter()
#actualisation de l'affichage ecran
elif choice == 'i' or choice == 'I':
info()
#actualisation de l'affichage ecran
elif choice == 'a' or choice == 'A':
header(selectedPlugin, selectedChaine, selectedProgram)
print "\n\n\n\n\t\tRafraichissement\n\n\n"
self.api.pluginRafraichirAuto()
#recharger les listes
if len(selectedProgram) != 0:
fichiers = self.api.getPluginListeFichiers(
selectedPlugin, selectedProgram)
elif len(selectedChaine) != 0:
programs = self.api.getPluginListeEmissions(
selectedPlugin, selectedChaine)
elif len(selectedPlugin) != 0:
chaines = self.api.getPluginListeChaines(selectedPlugin)
elif len(selectedPlugin) == 0 and len(
selectedChaine) == 0 and len(selectedProgram) == 0:
plugins = self.preferences.getPreference("pluginsActifs")
plugins.sort()
#mise a jour de l'affichage
header(selectedPlugin, selectedChaine, selectedProgram)
print "\n\n\n\n\t\tVeuillez patientez pendant la mise a jour des informations\n\n\n"
time.sleep(1)
show(selectedPlugin, selectedChaine, selectedProgram, temp)
elif choice == 'r' or choice == 'R':
temp = 0
if len(selectedProgram) != 0:
selectedProgram = ""
elif len(selectedChaine) != 0:
selectedChaine = ""
if len(chaines) == 1:
selectedPlugin = ""
elif len(selectedPlugin) != 0:
selectedPlugin = ""
elif choice.isdigit() and int(choice) >= 0:
choice = 10 * temp + int(choice)
if len(selectedPlugin) == 0 and len(plugins) > choice:
temp = 0
selectedPlugin = plugins[choice]
chaines = self.api.getPluginListeChaines(selectedPlugin)
if len(chaines) == 1:
header(selectedPlugin, '', '')
print "Une seule chaine :", chaines
time.sleep(0.5)
selectedChaine = chaines[0]
programs = self.api.getPluginListeEmissions(
selectedPlugin, selectedChaine)
elif len(selectedChaine) == 0 and len(chaines) > choice:
temp = 0
selectedChaine = chaines[choice]
programs = self.api.getPluginListeEmissions(
selectedPlugin, selectedChaine)
elif len(selectedProgram) == 0 and len(programs) > choice:
selectedProgram = programs[choice]
header(selectedPlugin, selectedChaine, selectedProgram)
print "\n\n\n\n\t\tVeuillez patientez pendant le chargement des informations\n\n\n"
fichiers = self.api.getPluginListeFichiers(
selectedPlugin, selectedProgram)
if len(fichiers) == 0:
header(selectedPlugin, selectedChaine, selectedProgram)
print "\n\n\n\n\n\n\n\t\tAucun fichier dans le programme :", selectedProgram
time.sleep(1)
selectedProgram = ''
else:
temp = 0
elif len(selectedPlugin) != 0 and len(
selectedChaine) != 0 and len(
selectedProgram) != 0 and len(fichiers) > choice:
header(selectedPlugin, selectedChaine, selectedProgram)
if fichiers[choice] not in DLlist:
print "\n\n\n\n\n\n\najout", fichiers[
choice].nom, "a la liste de telechargement\n\n\n\n\n\n\n\n\n"
DLlist.append(fichiers[choice])
else:
print "\n\n\n\n\n\n\n\t\tFichier deja dans la liste de telechargement\n\n\n\n\n\n\n\n\n"
time.sleep(1)
os.system(['clear', 'cls'][os.name == 'nt'])
elif choice == '*':
# if len(selectedPlugin)==0:
# temp=0
# selectedPlugin = 'None'
# chaines = self.api.getPluginListeChaines()
# elif len(selectedChaine)==0:
# temp=0
# selectedChaine='None'
# programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine)
# el
if len(selectedProgram) == 0:
selectedProgram = 'Tous'
header(selectedPlugin, selectedChaine, selectedProgram)
print "\n\n\n\n\t\tVeuillez patientez pendant le chargement des informations\n\n\n"
# for choice in range(len(programs)) :
fichiers = self.api.getPluginListeFichiers(
selectedPlugin, None) #programs[choice])
elif len(selectedPlugin) != 0 and len(
selectedChaine) != 0 and len(selectedProgram) != 0:
header(selectedPlugin, selectedChaine, selectedProgram)
for choice in range(len(fichiers)):
if fichiers[int(choice)] not in DLlist:
header(selectedPlugin, selectedChaine,
selectedProgram)
print "\n\n\n\n\t\tajout", fichiers[int(
choice)].nom, "a la liste de telechargement"
DLlist.append(fichiers[int(choice)])
else:
print "\t\tFichier deja dans la liste de telechargement"
time.sleep(0.5)
#afficher la suite de la liste
elif choice == '+':
if len(selectedPlugin) == 0:
if len(plugins) > temp * 10 + 10: temp += 1
elif len(selectedChaine) == 0:
if len(chaines) > temp * 10 + 10: temp += 1
elif len(selectedProgram) == 0:
if len(programs) > temp * 10 + 10: temp += 1
elif len(selectedPlugin) != 0 and len(
selectedChaine) != 0 and len(selectedProgram) != 0:
if len(fichiers) > temp * 10 + 10: temp += 1
#afficher le debut de la liste
elif choice == '-':
if temp != 0: temp -= 1
show(selectedPlugin, selectedChaine, selectedProgram, temp)
choice = ''
# if not choice:choice=raw_input("\n\t\tEntrez votre choix : ")
if not choice: choice = getch()
def __init__( self, signaux = None ): self.preferences = Preferences() self.signaux = signaux self.arreter = True self.process = None
# CPU Temp Import
from gpiozero import CPUTemperature
# Read preferences from files
from Preferences import Preferences
preferences = Preferences()
# Gets the list of all possible information values to see on the webpage
# Format: DisplayName, Value, DisplayType, Parameters
# DisplayType Parameters:
# loadingBar: minValue, maxValue, displayUnits
# text: none
def getInfo():
params = []
# Add CPU Temperature
params.append(
['CPU Temperature',
get_CPU_temp(), 'loadingBar', 0, 87, '°C'])
# Add preferences from Setup File
for key, value in preferences.get_debug_preferences().items():
params.append([key, value, 'text'])
return params
# Gets the Pi's CPU temp to send to the client
def get_CPU_temp():
cpu = CPUTemperature()
def __init__( self, parent ): # Appel au constructeur de la classe mere QtGui.QDialog.__init__( self, parent ) self.preferences = Preferences() self.pluginManager = PluginManager() ########### # Fenetre # ########### ### # Reglages de la fenetre principale ### # Nom de la fenetre self.setWindowTitle( u"Préférences" ) # Dimensions la fenetre self.resize( 325, 510 ) # Mise en place de son icone self.setWindowIcon( QtGui.QIcon( "ico/gtk-preferences.svg" ) ) ### # Mise en place des widgets dans la fenetre ### # Layout du dialog (il ne contiendra que la scroll area) self.layoutPrincipal = QtGui.QVBoxLayout( self ) # Scroll Area (elle ne contiendra que le widget central) self.scrollArea = QtGui.QScrollArea( self ) self.layoutPrincipal.addWidget( self.scrollArea ) # Widget central self.widgetCentral = QtGui.QWidget( self.scrollArea ) # Layout de grillequi contient les elements self.gridLayout = QtGui.QGridLayout( self.widgetCentral ) # Font pour les titres fontTitres = QtGui.QFont() fontTitres.setPointSize( 11 ) fontTitres.setWeight( 75 ) fontTitres.setBold( True ) # # Choix du repertoire telechargement # # Label self.labelRepertoire = QtGui.QLabel( self ) self.labelRepertoire.setFont( fontTitres ) self.labelRepertoire.setText( u"Répertoire de téléchargement :" ) # Repertoire de telechargement self.lineEditRepertoireTelechargement = QtGui.QLineEdit( self ) # Bouton pour ouvrir la fenetre de selection de repertoire self.pushButtonSelectionDossier = QtGui.QPushButton( self ) self.pushButtonSelectionDossier.setIcon( QtGui.QIcon( "ico/gtk-folder.svg" ) ) # # Choix du plugin par defaut # # Label self.labelPluginDefaut = QtGui.QLabel( self ) self.labelPluginDefaut.setFont( fontTitres ) self.labelPluginDefaut.setText( u"Plugin par défaut :" ) # Liste de choix du plugin par defaut self.comboBoxPluginDefaut = QtGui.QComboBox( self ) # # Choix des plugins a activer # # Label self.labelPlugins = QtGui.QLabel( self ) self.labelPlugins.setFont( fontTitres ) self.labelPlugins.setText( "Plugins actifs :" ) # Liste des plugins self.listWidgetPlugin = QtGui.QListWidget( self ) # # Choix des parametres Internet # # Label self.labelInternet = QtGui.QLabel( self ) self.labelInternet.setFont( fontTitres ) self.labelInternet.setText( u"Paramètres Internet :" ) # Layout formulaire self.layoutInternet = QtGui.QFormLayout() # SpinBox pour choisir le timeOut self.spinBoxTimeOut = QtGui.QSpinBox() self.spinBoxTimeOut.setMinimum( 1 ) self.spinBoxTimeOut.setMaximum( 60 ) self.layoutInternet.addRow( u"Time out (en s) :", self.spinBoxTimeOut ) # SpinBox pour choisir le nombre de threads max self.spinBoxNbThread = QtGui.QSpinBox() self.spinBoxNbThread.setMinimum( 1 ) self.spinBoxNbThread.setMaximum( 100 ) self.layoutInternet.addRow( u"Nombre de threads max :", self.spinBoxNbThread ) # Bouton pour enregistrer/annuler les preferences self.buttonBox = QtGui.QDialogButtonBox( self ) self.buttonBox.addButton( "Enregistrer", QtGui.QDialogButtonBox.AcceptRole ) self.buttonBox.addButton( "Fermer", QtGui.QDialogButtonBox.RejectRole ) # On ajoute le tout au layout self.gridLayout.addWidget( self.labelRepertoire, 0, 0, 1, 2 ) self.gridLayout.addWidget( self.lineEditRepertoireTelechargement, 1, 0, 1, 1 ) self.gridLayout.addWidget( self.pushButtonSelectionDossier, 1, 1, 1, 1 ) self.gridLayout.addWidget( self.labelPluginDefaut, 2, 0, 1, 2 ) self.gridLayout.addWidget( self.comboBoxPluginDefaut, 3, 0, 1, 2 ) self.gridLayout.addWidget( self.labelPlugins, 4, 0, 1, 2 ) self.gridLayout.addWidget( self.listWidgetPlugin, 5, 0, 1, 2 ) self.gridLayout.addWidget( self.labelInternet, 6, 0, 1, 2 ) self.gridLayout.addLayout( self.layoutInternet, 7, 0, 1, 2 ) # Les boutons sont ajoutes au layout principal self.layoutPrincipal.addWidget( self.buttonBox ) # On adapte la taille du widget self.widgetCentral.adjustSize() # On ajoute le widget central a la scroll area self.scrollArea.setWidget( self.widgetCentral ) ### # Signaux provenants de l'interface ### QtCore.QObject.connect( self.pushButtonSelectionDossier, QtCore.SIGNAL( "clicked()" ), self.afficherSelecteurDossier ) QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "accepted()" ), self.enregistrerPreferences ) QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "rejected()" ), self.reject )
def __init__(self):
#declaration des variables
global choice, temp, plugins, chaines, programs, fichiers, DLlist
chaines=''
programs=''
fichiers=''
temp = 0
choice = ""
selectedPlugin =''
selectedChaine =''
selectedProgram = ''
DLlist=[]
################################################
# Instanciations + initialisation de variables #
################################################
# On instancie le plugin manager
self.pluginManager = PluginManager()
# On instancie le gestionnaire de preferences
self.preferences = Preferences()
# On instancie le gestionnaire de download
self.downloader = Downloader()
# On recupere l'instance de API
self.api = API.getInstance()
# # On instancie le gestionnaire d'historique
# self.historique = Historique()
# Si aucun plugin n'est active, on ouvre la fenetre des preferences
if( len( self.preferences.getPreference( "pluginsActifs" ) ) == 0 ):
choice = 'p'
self.api.pluginRafraichirAuto()
# On met en place la liste des plugins dans API
plugins = self.preferences.getPreference( "pluginsActifs" )
plugins.sort()
# On actualise tous les plugins
self.api.pluginRafraichirAuto()
#boucle qui raffraichit l'affichage apres chaque interaction utilisateur
while choice != 'exit':
#ouverture du menu de preferences
if choice == 'p' or choice == 'P':
prefs()
# On met en place la liste des plugins dans API
plugins = self.preferences.getPreference( "pluginsActifs" )
plugins.sort()
# On actualise tous les plugins
self.api.pluginRafraichirAuto()
#ouverture du menu de telechargement
elif choice == 't' or choice == 'T': dl(DLlist)
#ouverture de l'invite de fermeture
elif choice == 'q' or choice == 'Q': quitter()
#actualisation de l'affichage ecran
elif choice == 'i' or choice == 'I': info()
#actualisation de l'affichage ecran
elif choice == 'a' or choice == 'A':
header(selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\t\tRafraichissement\n\n\n"
self.api.pluginRafraichirAuto()
#recharger les listes
if len(selectedProgram)!=0:
fichiers = self.api.getPluginListeFichiers(selectedPlugin,selectedProgram)
elif len(selectedChaine)!=0:
programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine)
elif len(selectedPlugin)!=0:
chaines = self.api.getPluginListeChaines(selectedPlugin)
elif len(selectedPlugin)==0 and len(selectedChaine)==0 and len(selectedProgram)==0:
plugins = self.preferences.getPreference( "pluginsActifs" )
plugins.sort()
#mise a jour de l'affichage
header(selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\t\tVeuillez patientez pendant la mise a jour des informations\n\n\n"
time.sleep(1)
show(selectedPlugin,selectedChaine,selectedProgram,temp)
elif choice == 'r' or choice == 'R':
temp=0
if len(selectedProgram)!=0:
selectedProgram=""
elif len(selectedChaine)!=0:
selectedChaine=""
if len(chaines)==1:
selectedPlugin=""
elif len(selectedPlugin)!=0:
selectedPlugin=""
elif choice.isdigit() and int(choice)>=0:
choice=10*temp+int(choice)
if len(selectedPlugin)==0 and len(plugins)>choice:
temp=0
selectedPlugin = plugins[choice]
chaines = self.api.getPluginListeChaines(selectedPlugin)
if len(chaines)==1:
header(selectedPlugin,'','')
print "Une seule chaine :",chaines
time.sleep (0.5)
selectedChaine=chaines[0]
programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine)
elif len(selectedChaine)==0 and len(chaines)>choice:
temp=0
selectedChaine=chaines[choice]
programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine)
elif len(selectedProgram)==0 and len(programs)>choice:
selectedProgram=programs[choice]
header(selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\t\tVeuillez patientez pendant le chargement des informations\n\n\n"
fichiers = self.api.getPluginListeFichiers(selectedPlugin,selectedProgram)
if len(fichiers)==0:
header (selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\n\n\n\t\tAucun fichier dans le programme :",selectedProgram
time.sleep (1)
selectedProgram=''
else:temp=0
elif len(selectedPlugin)!=0 and len(selectedChaine)!=0 and len(selectedProgram)!=0 and len(fichiers)>choice:
header(selectedPlugin,selectedChaine,selectedProgram)
if fichiers[choice] not in DLlist:
print "\n\n\n\n\n\n\najout",fichiers[choice].nom,"a la liste de telechargement\n\n\n\n\n\n\n\n\n"
DLlist.append(fichiers[choice])
else: print "\n\n\n\n\n\n\n\t\tFichier deja dans la liste de telechargement\n\n\n\n\n\n\n\n\n"
time.sleep(1)
os.system(['clear','cls'][os.name == 'nt'])
elif choice=='*':
# if len(selectedPlugin)==0:
# temp=0
# selectedPlugin = 'None'
# chaines = self.api.getPluginListeChaines()
# elif len(selectedChaine)==0:
# temp=0
# selectedChaine='None'
# programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine)
# el
if len(selectedProgram)==0:
selectedProgram='Tous'
header(selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\t\tVeuillez patientez pendant le chargement des informations\n\n\n"
# for choice in range(len(programs)) :
fichiers = self.api.getPluginListeFichiers(selectedPlugin,None)#programs[choice])
elif len(selectedPlugin)!=0 and len(selectedChaine)!=0 and len(selectedProgram)!=0:
header(selectedPlugin,selectedChaine,selectedProgram)
for choice in range(len(fichiers)) :
if fichiers[int(choice)] not in DLlist:
header(selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\t\tajout",fichiers[int(choice)].nom,"a la liste de telechargement"
DLlist.append(fichiers[int(choice)])
else: print "\t\tFichier deja dans la liste de telechargement"
time.sleep(0.5)
#afficher la suite de la liste
elif choice=='+':
if len(selectedPlugin) == 0:
if len(plugins)>temp*10+10: temp+=1
elif len(selectedChaine) == 0:
if len(chaines)>temp*10+10: temp+=1
elif len(selectedProgram) == 0:
if len(programs)>temp*10+10: temp+=1
elif len(selectedPlugin) != 0 and len(selectedChaine) != 0 and len(selectedProgram) != 0:
if len(fichiers)>temp*10+10: temp+=1
#afficher le debut de la liste
elif choice=='-':
if temp!=0: temp-=1
show(selectedPlugin,selectedChaine,selectedProgram,temp)
choice=''
# if not choice:choice=raw_input("\n\t\tEntrez votre choix : ")
if not choice:choice=getch()
class PreferencesDialog( QtGui.QDialog ): ## Constructeur def __init__( self, parent ): # Appel au constructeur de la classe mere QtGui.QDialog.__init__( self, parent ) self.preferences = Preferences() self.pluginManager = PluginManager() ########### # Fenetre # ########### ### # Reglages de la fenetre principale ### # Nom de la fenetre self.setWindowTitle( u"Préférences" ) # Dimensions la fenetre self.resize( 325, 510 ) # Mise en place de son icone self.setWindowIcon( QtGui.QIcon( "ico/gtk-preferences.svg" ) ) ### # Mise en place des widgets dans la fenetre ### # Layout du dialog (il ne contiendra que la scroll area) self.layoutPrincipal = QtGui.QVBoxLayout( self ) # Scroll Area (elle ne contiendra que le widget central) self.scrollArea = QtGui.QScrollArea( self ) self.layoutPrincipal.addWidget( self.scrollArea ) # Widget central self.widgetCentral = QtGui.QWidget( self.scrollArea ) # Layout de grillequi contient les elements self.gridLayout = QtGui.QGridLayout( self.widgetCentral ) # Font pour les titres fontTitres = QtGui.QFont() fontTitres.setPointSize( 11 ) fontTitres.setWeight( 75 ) fontTitres.setBold( True ) # # Choix du repertoire telechargement # # Label self.labelRepertoire = QtGui.QLabel( self ) self.labelRepertoire.setFont( fontTitres ) self.labelRepertoire.setText( u"Répertoire de téléchargement :" ) # Repertoire de telechargement self.lineEditRepertoireTelechargement = QtGui.QLineEdit( self ) # Bouton pour ouvrir la fenetre de selection de repertoire self.pushButtonSelectionDossier = QtGui.QPushButton( self ) self.pushButtonSelectionDossier.setIcon( QtGui.QIcon( "ico/gtk-folder.svg" ) ) # # Choix du plugin par defaut # # Label self.labelPluginDefaut = QtGui.QLabel( self ) self.labelPluginDefaut.setFont( fontTitres ) self.labelPluginDefaut.setText( u"Plugin par défaut :" ) # Liste de choix du plugin par defaut self.comboBoxPluginDefaut = QtGui.QComboBox( self ) # # Choix des plugins a activer # # Label self.labelPlugins = QtGui.QLabel( self ) self.labelPlugins.setFont( fontTitres ) self.labelPlugins.setText( "Plugins actifs :" ) # Liste des plugins self.listWidgetPlugin = QtGui.QListWidget( self ) # # Choix des parametres Internet # # Label self.labelInternet = QtGui.QLabel( self ) self.labelInternet.setFont( fontTitres ) self.labelInternet.setText( u"Paramètres Internet :" ) # Layout formulaire self.layoutInternet = QtGui.QFormLayout() # SpinBox pour choisir le timeOut self.spinBoxTimeOut = QtGui.QSpinBox() self.spinBoxTimeOut.setMinimum( 1 ) self.spinBoxTimeOut.setMaximum( 60 ) self.layoutInternet.addRow( u"Time out (en s) :", self.spinBoxTimeOut ) # SpinBox pour choisir le nombre de threads max self.spinBoxNbThread = QtGui.QSpinBox() self.spinBoxNbThread.setMinimum( 1 ) self.spinBoxNbThread.setMaximum( 100 ) self.layoutInternet.addRow( u"Nombre de threads max :", self.spinBoxNbThread ) # Bouton pour enregistrer/annuler les preferences self.buttonBox = QtGui.QDialogButtonBox( self ) self.buttonBox.addButton( "Enregistrer", QtGui.QDialogButtonBox.AcceptRole ) self.buttonBox.addButton( "Fermer", QtGui.QDialogButtonBox.RejectRole ) # On ajoute le tout au layout self.gridLayout.addWidget( self.labelRepertoire, 0, 0, 1, 2 ) self.gridLayout.addWidget( self.lineEditRepertoireTelechargement, 1, 0, 1, 1 ) self.gridLayout.addWidget( self.pushButtonSelectionDossier, 1, 1, 1, 1 ) self.gridLayout.addWidget( self.labelPluginDefaut, 2, 0, 1, 2 ) self.gridLayout.addWidget( self.comboBoxPluginDefaut, 3, 0, 1, 2 ) self.gridLayout.addWidget( self.labelPlugins, 4, 0, 1, 2 ) self.gridLayout.addWidget( self.listWidgetPlugin, 5, 0, 1, 2 ) self.gridLayout.addWidget( self.labelInternet, 6, 0, 1, 2 ) self.gridLayout.addLayout( self.layoutInternet, 7, 0, 1, 2 ) # Les boutons sont ajoutes au layout principal self.layoutPrincipal.addWidget( self.buttonBox ) # On adapte la taille du widget self.widgetCentral.adjustSize() # On ajoute le widget central a la scroll area self.scrollArea.setWidget( self.widgetCentral ) ### # Signaux provenants de l'interface ### QtCore.QObject.connect( self.pushButtonSelectionDossier, QtCore.SIGNAL( "clicked()" ), self.afficherSelecteurDossier ) QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "accepted()" ), self.enregistrerPreferences ) QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "rejected()" ), self.reject ) ## Methode pour afficher la fenetre des preferences def afficher( self ): # On met en place dans le textEdit le repertoire self.lineEditRepertoireTelechargement.setText( stringToQstring( self.preferences.getPreference( "repertoireTelechargement" ) ) ) # On met en place le plugin par defaut self.remplirPluginParDefaut() # On met en place la liste des plugins self.afficherPlugins() # On met en place les valeurs des SpinBox self.spinBoxTimeOut.setValue( self.preferences.getPreference( "timeOut" ) ) self.spinBoxNbThread.setValue( self.preferences.getPreference( "nbThreadMax" ) ) # On affiche la fenetre self.exec_() ## Methode pour enregistrer les preferences du logiciel def enregistrerPreferences( self ): # On sauvegarde les valeurs des SpinBox self.preferences.setPreference( "nbThreadMax", self.spinBoxNbThread.value() ) self.preferences.setPreference( "timeOut", self.spinBoxTimeOut.value() ) # On sauvegarde les plugins actifs self.sauvegarderPlugins() # On sauvegarde le plugin par defaut self.preferences.setPreference( "pluginParDefaut", qstringToString( self.comboBoxPluginDefaut.currentText() ) ) # On sauvegarde le repertoire de telechargement self.preferences.setPreference( "repertoireTelechargement", qstringToString( self.lineEditRepertoireTelechargement.text() ) ) # On sauvegarde dans le fichier self.preferences.sauvegarderConfiguration() # On masque la fenetre self.hide() #################################################################### # Methodes qui gerent l'emplacement de telechargement des fichiers # #################################################################### ## Methode qui affiche le selecteur de dossier def afficherSelecteurDossier( self ): rep = QtGui.QFileDialog.getExistingDirectory( None, u"Sélectionnez le répertoire de téléchargement", self.lineEditRepertoireTelechargement.text(), QtGui.QFileDialog.ShowDirsOnly ) # Si le repertoire existe if( os.path.isdir( qstringToString( rep ) ) ): self.lineEditRepertoireTelechargement.setText( rep ) # On modifie la zone de texte qui affiche le repertoire ################################################ # Methodes qui gerent la partie plugins actifs # ################################################ ## Methode qui liste les plugins actif dans le listWidgetPlugin def afficherPlugins( self ): # On recupere les listes de plugins listePluginsDisponibles = self.pluginManager.getListeSites() listePluginsDisponibles.sort() # On trie cette liste listePluginsActives = self.preferences.getPreference( "pluginsActifs" ) # On remet a 0 le listWidget self.listWidgetPlugin.clear() # On affiche les plugins for plugin in listePluginsDisponibles: # On met en place l'item self.listWidgetPlugin.addItem( self.creerItem( plugin, plugin in listePluginsActives ) ) ## Methode qui remplie la combo box du plugin par defaut def remplirPluginParDefaut( self ): # On efface la liste self.comboBoxPluginDefaut.clear() # On ajoute les plugins actifs for plugin in self.preferences.getPreference( "pluginsActifs" ): self.comboBoxPluginDefaut.addItem( stringToQstring( plugin ) ) # On selectionne le plugin par defaut index = self.comboBoxPluginDefaut.findText( stringToQstring( self.preferences.getPreference( "pluginParDefaut" ) ) ) if( index != -1 ): self.comboBoxPluginDefaut.setCurrentIndex( index ) ## Methode qui sauvegarde les plugins actifs def sauvegarderPlugins( self ): # On liste les plugins actifs liste = [] for i in range( self.listWidgetPlugin.count() ): # Pour chaque ligne if( self.listWidgetPlugin.item( i ).checkState() == QtCore.Qt.Checked ): # Si elle est selectionnee liste.append( qstringToString( self.listWidgetPlugin.item( i ).text() ) ) # On met cela en place dans les preferences self.preferences.setPreference( "pluginsActifs", liste ) # On relance l'actualisation de l'affichage self.emit( QtCore.SIGNAL( "actualiserListesDeroulantes()" ) ) #################### # Autres methodes # #################### ## Methode qui creer une element pour un listeWidget # @param texte Texte de l'element # @param checkBox Si la checkBox de l'element est cochee ou non # @return L'element cree def creerItem( self, texte, checkBox = False ): # On cree l'item avec le texte item = QtGui.QListWidgetItem( stringToQstring( texte ) ) # On centre le texte item.setTextAlignment( QtCore.Qt.AlignCenter ) # L'item ne doit pas etre modifiable item.setFlags( item.flags() & ~QtCore.Qt.ItemIsEditable ) # L'item doit avoir sa checkBox cochee ? if( checkBox ): item.setCheckState( QtCore.Qt.Checked ) else: item.setCheckState( QtCore.Qt.Unchecked ) # On renvoie l'item return item
def __init__(self, preferences: Preferences):
"""
Create data model from given preferences object. This also lists all the fetch/settable values
:param preferences: Program preferences to establish model's default values
"""
self._master_combine_method: int = preferences.get_master_combine_method(
)
self._min_max_number_clipped_per_end: int = preferences.get_min_max_number_clipped_per_end(
)
self._sigma_clip_threshold: float = preferences.get_sigma_clip_threshold(
)
self._input_file_disposition: int = preferences.get_input_file_disposition(
)
self._disposition_subfolder_name: str = preferences.get_disposition_subfolder_name(
)
self._precalibration_type: int = preferences.get_precalibration_type()
self._precalibration_pedestal: int = preferences.get_precalibration_pedestal(
)
self._precalibration_fixed_path: str = preferences.get_precalibration_fixed_path(
)
self._precalibration_auto_directory: str = preferences.get_precalibration_auto_directory(
)
self._auto_directory_recursive: bool = preferences.get_auto_directory_recursive(
)
self._auto_directory_bias_only: bool = preferences.get_auto_directory_bias_only(
)
self._group_by_size: bool = preferences.get_group_by_size()
self._group_by_temperature: bool = preferences.get_group_by_temperature(
)
self._group_by_filter: bool = preferences.get_group_by_filter()
self._temperature_group_bandwidth: float = preferences.get_temperature_group_bandwidth(
)
self._ignore_file_type: bool = False
self._ignore_groups_fewer_than: bool = preferences.get_ignore_groups_fewer_than(
)
self._minimum_group_size: int = preferences.get_minimum_group_size()
self._display_average_adus: bool = preferences.get_display_average_adus(
)
self._display_auto_select_results: bool = preferences.get_display_auto_select_results(
)
class CLIDialog():
## Constructeur
def __init__(self):
# On cree l'instance de la classe dialog
self.dialog = Dialog()
self.dialog.setBackgroundTitle("TVDownloader")
# On recupere l'instance de API
self.api = API.getInstance()
# On instancie le gestionnaire de download
self.downloader = Downloader()
# On instancie le gestionnaire d'historique
self.historique = Historique()
# On instancie le gestionnaire de preferences
self.preferences = Preferences()
# Liste des telechargements
self.listeTelechargements = []
# Quand le programme se termine, on execute la fonction actionsAvantQuitter
atexit.register(self.actionsAvantQuitter)
# On commence
self.bouclePrincipale()
## Debut
def bouclePrincipale(self):
choix = (1, "")
while (choix != (0, "Quitter")):
# On affiche le menu principal
choix = self.dialog.menu(
text="Menu Principal",
choices=[
["Commencer", "Afficher la liste des plugins"],
["Téléchargements", "Gérer les téléchargements"],
["Préférences", "Modifier les préférences"],
["Quitter", "Quitter TVDownloader"],
])
# On lance la methode qui va bien
if (choix == (0, "Commencer")):
self.utilisationPlugins()
elif (choix == (0, "Téléchargements")):
self.utlisationTelechargements()
elif (choix == (0, "Préférences")):
pass
elif (choix == (0, "Quitter")):
# Rien a faire, atexit gere cela
pass
## Methode pour selectionner les fichiers a telecharger avec les plugins
def utilisationPlugins(self):
# Liste des plugins actifs
listePlugins = []
for nomPlugin in self.preferences.getPreference("pluginsActifs"):
listePlugins.append([nomPlugin, ""])
choixPlugin = (0, "")
while (choixPlugin[0] != 1):
# On affiche le menu de selection de plugins
choixPlugin = self.dialog.menu(
text="De quelle plugin voulez-vous voir les chaines ?",
choices=listePlugins)
if (choixPlugin[0] != 1):
# Liste des chaines du plugin
listeChaines = []
for nomChaine in self.api.getPluginListeChaines(
choixPlugin[1]):
listeChaines.append([nomChaine, ""])
choixChaine = (0, "")
while (choixChaine[0] != 1):
# On affiche le menu de selection de la chaine
choixChaine = self.dialog.menu(
text=
"De quelle chaine voulez-vous voir les emissions ?",
choices=listeChaines)
if (choixChaine[0] != 1):
# Liste des emissions de la chaine
listeEmissions = []
for nomEmission in self.api.getPluginListeEmissions(
choixPlugin[1], choixChaine[1]):
listeEmissions.append([nomEmission, ""])
choixEmission = (0, "")
while (choixEmission[0] != 1):
# On affiche le menu de selection de l'emission
choixEmission = self.dialog.menu(
text=
"De quelle emission voulez-vous voir les fichiers ?",
choices=listeEmissions)
if (choixEmission[0] != 1):
listeFichiersAAfficher = []
listeFichiersCoches = []
listeFichiersPrecedementCoches = []
listeFichiersAPI = self.api.getPluginListeFichiers(
choixPlugin[1], choixEmission[1])
i = 0
for fichier in listeFichiersAPI:
texteAAfficher = "(%s) %s" % (getattr(
fichier,
"date"), getattr(fichier, "nom"))
if (fichier in self.listeTelechargements):
listeFichiersPrecedementCoches.append(
fichier)
cochee = 1
else:
cochee = 0
listeFichiersAAfficher.append(
[str(i), texteAAfficher, cochee])
i += 1
choixFichiers = (0, [])
while (choixFichiers[0] != 1):
choixFichiers = self.dialog.checklist(
text=
"Quels fichiers voulez-vous ajouter à la liste des téléchargements ?",
choices=listeFichiersAAfficher)
if (choixFichiers[0] != 1):
for numeroFichier in choixFichiers[1]:
fichier = listeFichiersAPI[int(
numeroFichier)]
listeFichiersCoches.append(fichier)
for fichier in listeFichiersCoches:
if not (fichier in
listeFichiersPrecedementCoches
):
self.listeTelechargements.append(
fichier)
for fichier in listeFichiersPrecedementCoches:
if not (fichier
in listeFichiersCoches):
self.listeTelechargements.remove(
fichier)
# On retourne au menu precedent
choixFichiers = (1, "")
## Methode qui gere le gestionnaire de telechargement
def utlisationTelechargements(self):
choix = (0, "")
while (choix[0] != 1):
# On affiche le menu principal
choix = self.dialog.menu(
text="Gestionnaire de téléchargement",
choices=[["Consulter", "Consulter la liste"],
["Lancer", "Lancer les téléchargements"]])
# On lance la methode qui va bien
if (choix == (0, "Consulter")):
if (len(self.listeTelechargements) > 0):
texte = ""
for fichier in self.listeTelechargements:
texte += "(%s) %s\n" % (getattr(
fichier, "date"), getattr(fichier, "nom"))
else:
texte = "La liste des téléchargements est vide"
# On affiche la liste des fichiers a telecharger
self.dialog.msgbox(text=texte)
elif (choix == (0, "Lancer")):
if (len(self.listeTelechargements) > 0):
liste = []
for fichier in self.listeTelechargements:
lien = getattr(fichier, "lien")
nomFichierSortie = getattr(fichier, "nomFichierSortie")
if (
nomFichierSortie == ""
): # Si le nom du fichier de sortie n'existe pas, on l'extrait de l'URL
nomFichierSortie = os.path.basename(lien)
liste.append([0, lien, nomFichierSortie])
# On lance le telechargement
self.downloader.lancerTelechargement(liste)
self.dialog.msgbox(
text="Fin du téléchargement des fichiers")
del self.listeTelechargements[:]
else:
self.dialog.msgbox(text="Aucun fichier à télécharger")
## Methode qui execute les actions necessaires avant de quitter le programme
def actionsAvantQuitter(self):
print "Fermeture"
# On sauvegarde les options des plugins
self.api.fermeture()
# On sauvegarde l'historique
self.historique.sauverHistorique()
# On sauvegarde les options du logiciel
self.preferences.sauvegarderConfiguration()
class PreferencesDialog(QtGui.QDialog):
## Constructeur
# @param signaux Lanceur de signaux
def __init__(self, parent, signaux):
# Appel au constructeur de la classe mere
QtGui.QDialog.__init__(self, parent)
self.preferences = Preferences()
self.pluginManager = PluginManager()
self.signaux = signaux
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle(u"Préférences")
# Dimensions la fenetre
self.resize(280, 340)
# Mise en place de son icone
self.setWindowIcon(QtGui.QIcon("ico/gtk-preferences.svg"))
###
# Mise en place des widgets dans la fenetre
###
# Layout de grille principal
self.gridLayout = QtGui.QGridLayout(self)
# Font pour les titres
fontTitres = QtGui.QFont()
fontTitres.setPointSize(11)
fontTitres.setWeight(75)
fontTitres.setBold(True)
#
# Choix du repertoire telechargement
#
# Label
self.labelRepertoire = QtGui.QLabel(self)
self.labelRepertoire.setFont(fontTitres)
self.labelRepertoire.setText(u"Répertoire de téléchargement :")
# Repertoire de telechargement
self.lineEditRepertoireTelechargement = QtGui.QLineEdit(self)
# Bouton pour ouvrir la fenetre de selection de repertoire
self.pushButtonSelectionDossier = QtGui.QPushButton(self)
self.pushButtonSelectionDossier.setIcon(
QtGui.QIcon("ico/gtk-folder.svg"))
#
# Choix du plugin par defaut
#
# Label
self.labelPluginDefaut = QtGui.QLabel(self)
self.labelPluginDefaut.setFont(fontTitres)
self.labelPluginDefaut.setText(u"Plugin par défaut :")
# Liste de choix du plugin par defaut
self.comboBoxPluginDefaut = QtGui.QComboBox(self)
#
# Choix des plugins a activer
#
# Label
self.labelPlugins = QtGui.QLabel(self)
self.labelPlugins.setFont(fontTitres)
self.labelPlugins.setText("Plugins actifs :")
# Liste des plugins
self.listWidgetPlugin = QtGui.QListWidget(self)
#
# Choix des parametres Internet
#
# Label
self.labelInternet = QtGui.QLabel(self)
self.labelInternet.setFont(fontTitres)
self.labelInternet.setText(u"Paramètres Internet :")
# Layout formulaire
self.layoutInternet = QtGui.QFormLayout()
# SpinBox pour choisir le timeOut
self.spinBoxTimeOut = QtGui.QSpinBox()
self.spinBoxTimeOut.setMinimum(1)
self.spinBoxTimeOut.setMaximum(60)
self.layoutInternet.addRow(u"Time out (en s) :", self.spinBoxTimeOut)
# SpinBox pour choisir le nombre de threads max
self.spinBoxNbThread = QtGui.QSpinBox()
self.spinBoxNbThread.setMinimum(1)
self.spinBoxNbThread.setMaximum(100)
self.layoutInternet.addRow(u"Nombre de threads max :",
self.spinBoxNbThread)
# Bouton pour enregistrer/annuler les preferences
self.buttonBox = QtGui.QDialogButtonBox(self)
self.buttonBox.addButton("Enregistrer",
QtGui.QDialogButtonBox.AcceptRole)
self.buttonBox.addButton("Fermer", QtGui.QDialogButtonBox.RejectRole)
# On ajoute le tout au layout
self.gridLayout.addWidget(self.labelRepertoire, 0, 0, 1, 2)
self.gridLayout.addWidget(self.lineEditRepertoireTelechargement, 1, 0,
1, 1)
self.gridLayout.addWidget(self.pushButtonSelectionDossier, 1, 1, 1, 1)
self.gridLayout.addWidget(self.labelPluginDefaut, 2, 0, 1, 2)
self.gridLayout.addWidget(self.comboBoxPluginDefaut, 3, 0, 1, 2)
self.gridLayout.addWidget(self.labelPlugins, 4, 0, 1, 2)
self.gridLayout.addWidget(self.listWidgetPlugin, 5, 0, 1, 2)
self.gridLayout.addWidget(self.labelInternet, 6, 0, 1, 2)
self.gridLayout.addLayout(self.layoutInternet, 7, 0, 1, 2)
self.gridLayout.addWidget(self.buttonBox, 8, 0, 1, 2)
###
# Signaux provenants de l'interface
###
QtCore.QObject.connect(self.pushButtonSelectionDossier,
QtCore.SIGNAL("clicked()"),
self.afficherSelecteurDossier)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("accepted()"),
self.enregistrerPreferences)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("rejected()"),
self.reject)
## Methode pour afficher la fenetre des preferences
def afficher(self):
# On met en place dans le textEdit le repertoire
self.lineEditRepertoireTelechargement.setText(
stringToQstring(
self.preferences.getPreference("repertoireTelechargement")))
# On met en place le plugin par defaut
self.remplirPluginParDefaut()
# On met en place la liste des plugins
self.afficherPlugins()
# On met en place les valeurs des SpinBox
self.spinBoxTimeOut.setValue(self.preferences.getPreference("timeOut"))
self.spinBoxNbThread.setValue(
self.preferences.getPreference("nbThreadMax"))
# On affiche la fenetre
self.exec_()
## Methode pour enregistrer les preferences du logiciel
def enregistrerPreferences(self):
# On sauvegarde les valeurs des SpinBox
self.preferences.setPreference("nbThreadMax",
self.spinBoxNbThread.value())
self.preferences.setPreference("timeOut", self.spinBoxTimeOut.value())
# On sauvegarde les plugins actifs
self.sauvegarderPlugins()
# On sauvegarde le plugin par defaut
self.preferences.setPreference(
"pluginParDefaut",
qstringToString(self.comboBoxPluginDefaut.currentText()))
# On sauvegarde le repertoire de telechargement
self.preferences.setPreference(
"repertoireTelechargement",
qstringToString(self.lineEditRepertoireTelechargement.text()))
# On sauvegarde dans le fichier
self.preferences.sauvegarderConfiguration()
# On masque la fenetre
self.hide()
####################################################################
# Methodes qui gerent l'emplacement de telechargement des fichiers #
####################################################################
## Methode qui affiche le selecteur de dossier
def afficherSelecteurDossier(self):
rep = QtGui.QFileDialog.getExistingDirectory(
None, u"Sélectionnez le répertoire de téléchargement",
self.lineEditRepertoireTelechargement.text(),
QtGui.QFileDialog.ShowDirsOnly)
# Si le repertoire existe
if (os.path.isdir(rep)):
self.lineEditRepertoireTelechargement.setText(
rep) # On modifie la zone de texte qui affiche le repertoire
################################################
# Methodes qui gerent la partie plugins actifs #
################################################
## Methode qui liste les plugins actif dans le listWidgetPlugin
def afficherPlugins(self):
# On recupere les listes de plugins
listePluginsDisponibles = self.pluginManager.getListeSites()
listePluginsDisponibles.sort() # On trie cette liste
listePluginsActives = self.preferences.getPreference("pluginsActifs")
# On remet a 0 le listWidget
self.listWidgetPlugin.clear()
# On affiche les plugins
for plugin in listePluginsDisponibles:
# On met en place l'item
self.listWidgetPlugin.addItem(
self.creerItem(plugin, plugin in listePluginsActives))
## Methode qui remplie la combo box du plugin par defaut
def remplirPluginParDefaut(self):
# On efface la liste
self.comboBoxPluginDefaut.clear()
# On ajoute les plugins actifs
for plugin in self.preferences.getPreference("pluginsActifs"):
self.comboBoxPluginDefaut.addItem(stringToQstring(plugin))
# On selectionne le plugin par defaut
index = self.comboBoxPluginDefaut.findText(
stringToQstring(self.preferences.getPreference("pluginParDefaut")))
if (index != -1):
self.comboBoxPluginDefaut.setCurrentIndex(index)
## Methode qui sauvegarde les plugins actifs
def sauvegarderPlugins(self):
# On liste les plugins actifs
liste = []
for i in range(self.listWidgetPlugin.count()): # Pour chaque ligne
if (self.listWidgetPlugin.item(i).checkState() == QtCore.Qt.Checked
): # Si elle est selectionnee
liste.append(
qstringToString(self.listWidgetPlugin.item(i).text()))
# On met cela en place dans les preferences
self.preferences.setPreference("pluginsActifs", liste)
# On relance l'actualisation de l'affichage
self.signaux.signal("actualiserListesDeroulantes")
####################
# Autres methodes #
####################
## Methode qui creer une element pour un listeWidget
# @param texte Texte de l'element
# @param checkBox Si la checkBox de l'element est cochee ou non
# @return L'element cree
def creerItem(self, texte, checkBox=False):
# On cree l'item avec le texte
item = QtGui.QListWidgetItem(stringToQstring(texte))
# On centre le texte
item.setTextAlignment(QtCore.Qt.AlignCenter)
# L'item ne doit pas etre modifiable
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEditable)
# L'item doit avoir sa checkBox cochee ?
if (checkBox):
item.setCheckState(QtCore.Qt.Checked)
else:
item.setCheckState(QtCore.Qt.Unchecked)
# On renvoie l'item
return item
class ImdbSelect:
def __init__(self, config):
self.radarr = Radarr(config.radarr_url, config.radarr_base_path,
config.radarr_api_key,
config.radarr_quality_profile)
self.imdb = Imdb()
self.score11 = Score11(self.imdb)
self.ask = Preferences(self.imdb)
def add_all_actors(self,
actors,
rating_above=0,
votes_above=0,
manual=False,
retry=True):
for count, actor in enumerate(actors, start=1):
print("[ " + str(count) + "/" + str(len(actors)) +
" ] going through all movies with: " + actor)
imdb_ids = self.imdb.imdb_id_list_from_person(actor)
self.add_all_imdb_ids(imdb_ids, rating_above, votes_above, manual,
retry)
def add_all_imdb_ids(self,
imdb_ids,
rating_above=0,
votes_above=0,
manual=False,
retry=True):
movie_data_map = self.collect_movie_data(imdb_ids, retry)
self.choices(movie_data_map,
rating_above,
votes_above,
manual,
prepare=True)
movies_to_add = self.choices(movie_data_map, rating_above, votes_above,
manual)
self.add_movies(movies_to_add)
def collect_movie_data(self, imdb_ids, retry=True):
movie_data_map = {}
error_list = []
print("[ " + str(len(imdb_ids)) + " ] ", end='', flush=True)
next_print = 10
for count, imdb_id in enumerate(imdb_ids):
try:
if not self.ask.is_answered_no(
imdb_id) and not self.radarr.movie_exist(imdb_id):
movie_data_map[imdb_id] = self.radarr.get_movie(
imdb_id, retry)
print('.', end='', flush=True)
except MovieNotFoundError:
error_list.append(imdb_id)
print(Fore.RED + '.' + Style.RESET_ALL, end='', flush=True)
if 100 * count // len(imdb_ids) >= next_print:
print(str(next_print) + "%", end='', flush=True)
next_print += 10
print("/")
if len(error_list) > 0:
err_title = [
self.imdb.get_movie_title_year(imdb_id)
for imdb_id in error_list
]
print('Could not find ' + str(len(error_list)) + ': ' +
', '.join(err_title))
return movie_data_map
def choices(self,
movie_data_map,
rating_above=None,
votes_above=None,
manual=False,
prepare=False):
movies_to_add = []
for imdb_id, movie in movie_data_map.items():
if rating_above and votes_above:
if not movie.rating_above(rating_above):
if not prepare:
print("\t" + str(movie) + " has too low ratings")
continue
if not movie.votes_above(votes_above):
if not prepare:
print("\t\t" + str(movie) + " has not enough votes")
continue
if manual:
if self.ask.ask(imdb_id, movie, prepare):
movies_to_add.append(movie)
else:
if not prepare:
print(str(movie) + " has good ratings")
movies_to_add.append(movie)
elif manual and self.ask.ask(imdb_id, movie, prepare):
movies_to_add.append(movie)
return movies_to_add
def add_movies(self, movies_to_add):
for movie in movies_to_add:
status = self.radarr.add_movie(movie)
if status / 100 == 4:
print("\t" + movie.short_string() + " exists already.")
else:
print("\t" + movie.short_string() + " added.")
def delete_non_downloaded_movies_added_ago(self,
time_delta=timedelta(days=1)):
movies = self.radarr.get_all_non_downloaded_movies()
filtered = [
movie for movie in movies
if movie.added_date() > datetime.now(timezone.utc) - time_delta
]
count = len(filtered)
for movie in filtered:
print(count, movie.title())
count -= 1
self.radarr.remove_movie(movie)
class GUI:
def __init__(self, master):
self.valves = self.get_valves()
self.master = master
self.master.configure(bg='sky blue')
self.password = '******'
self.momentary = Momentary(self.master, self.valves)
self.edit = Edit(self.master, self.valves)
self.summary = Summary(self.master, self.valves)
self.preferences = Preferences(self.master, self.valves)
self.run_screen = RunScreen(self.master, self.valves)
self.header = self.make_header(self.master)
self.home = self.home_page(self.master)
self.frame = self.home
def make_header(self, master):
header = Frame(master, bg='sky blue')
self.label = StringVar()
self.label.set('NONE')
self.start_label = StringVar()
self.start_label.set('START')
self.lock_label = StringVar()
self.lock_label.set('LOCKED')
self.title = Label(header, textvariable=self.label, pady=20, font=('Lucida Console', 50))
self.title.config(bg='sky blue', fg='RoyalBlue4')
self.run_image = PhotoImage(file="img/animate.png").subsample(x=5, y=5)
self.run_button = Button(header, image=self.run_image, command=self.run, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.start_button = Button(header, textvariable=self.start_label, font=('Lucida Console', 30), command=self.start_stop, height=5)
self.start_button.config(bg='brown3', activebackground='brown4', fg='white', activeforeground='white', width=10, border=5)
self.save_image = PhotoImage(file="img/save.png").subsample(x=5, y=5)
self.save_button = Button(header, image=self.save_image, command=self.save, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.save_button.config(state='disabled')
self.reset_image = PhotoImage(file="img/reset.png").subsample(x=5, y=5)
self.reset_button = Button(header, image=self.reset_image, command=self.reset, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.home_image = PhotoImage(file="img/home.png").subsample(x=5, y=5)
self.home_button = Button(header, image=self.home_image, command=self.to_home, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.locked_image = PhotoImage(file="img/lock.png").subsample(x=5, y=5)
self.unlocked_image = PhotoImage(file="img/unlock.png").subsample(x=5, y=5)
self.lock_button = Button(header, image=self.locked_image, command=self.lock, bg='SkyBlue4', activebackground='midnight blue', border=5, textvariable=self.lock_label)
return header
def home_page(self, master):
frame = Frame(master)
frame.grid(row=0, column=0)
image = PhotoImage(file="img/guido.gif")
bg = Label(frame, image=image)
bg.image = image
bg.grid(row=0, column=0, rowspan=4, columnspan=2)
index = 0
while index < 3:
frame.grid_columnconfigure(index, minsize=200)
frame.grid_rowconfigure(index, minsize=80)
index += 1
summary_button = HomeButton(frame, self.to_summary, 'img/summary.png')
summary_button.grid(row=0, column=0, sticky='w')
edit_button = HomeButton(frame, self.to_edit, 'img/edit.png')
edit_button.grid(row=0, column=1, sticky='e')
momentary_button = HomeButton(frame, self.to_momentary, 'img/momentary.png')
momentary_button.grid(row=1, column=0, sticky='w')
preferences_button = HomeButton(frame, self.to_pref, 'img/preferences.png')
preferences_button.grid(row=1, column=1, sticky='e')
music = HomeButton(frame, self.to_summary, 'img/music.png')
music.grid(row=2, column=0, sticky='w')
info = HomeButton(frame, self.to_summary, 'img/info.png')
info.grid(row=2, column=1, sticky='e')
return frame
# CSV file input
def get_valves(self):
valves = [Valve('VALVE 1', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 2', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 3', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 4', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 5', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 6', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 7', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 8', 'DEFAULT', 'Action A', 'Action B', [0, 0])]
file = open('data.csv', 'rt', newline='')
try:
reader = csv.reader(file, lineterminator='\n')
index = 0
for row in reader:
if index == 0:
index += 1
continue
else:
run = int(row[4])
delay = int(row[5])
interval = [run, delay]
valves[index - 1] = Valve(row[0], row[1], row[2], row[3], interval)
index += 1
finally:
file.close()
return valves
def lock(self):
if self.lock_label.get() == 'LOCKED':
window = Toplevel()
window.geometry('318x550')
self.keypad = Keypad(window, self, self.password)
else:
self.save_button.config(state='disabled')
self.edit.lock()
self.preferences.lock()
self.lock_label.set('LOCKED')
self.lock_button.config(image=self.locked_image)
def save(self):
self.save_pref()
self.save_edit()
def save_edit(self):
file = open('data.csv', 'w')
interval = self.edit.get_intervals()
try:
writer = csv.writer(file, lineterminator='\n')
writer.writerow(('Name', 'Setting', 'Action A', 'Action B', 'Runtime', 'Delaytime'))
index = 0
for i in self.valves:
i.set_interval([interval[index].get(), interval[index + 8].get()])
valve_interval = i.get_interval()
if self.edit.plusInterval[index].cget('state') == 'disabled' and self.edit.motor[index].cget('state') != 'disabled':
i.set_setting('MOTOR')
writer.writerow((i.get_name().get(), i.get_setting(), i.get_action_a().get(), i.get_action_b().get(), 0, 0))
elif interval[index].get() is 0:
i.set_setting('INACTIVE')
writer.writerow((i.get_name().get(), i.get_setting(), 'NONE', 'NONE', 0, 0))
else:
i.set_setting('DEFAULT')
writer.writerow((i.get_name().get(), i.get_setting(), i.get_action_a().get(), i.get_action_b().get(), valve_interval[0], valve_interval[1]))
index += 1
finally:
file.close()
# must fix
def save_pref(self):
index = 0
for i in self.valves:
num = index * 3
if self.preferences.entry_field[num].get():
i.set_name(self.preferences.entry_field[num].get())
self.preferences.entry_field[num].delete(0, 'end')
if self.preferences.entry_field[num + 1].get():
i.set_action_a(self.preferences.entry_field[num + 1].get())
self.preferences.entry_field[num + 1].delete(0, 'end')
if self.preferences.entry_field[num + 2].get():
i.set_action_b(self.preferences.entry_field[num + 2].get())
self.preferences.entry_field[num + 2].delete(0, 'end')
index += 1
def start_stop(self):
if self.start_label.get() == 'START':
self.start_label.set('STOP')
self.master.update()
self.run_screen.run_all(True)
self.home_button.config(state='disabled')
else:
self.start_label.set('START')
self.run_screen.run_all(False)
self.home_button.config(state='normal')
def run(self):
self.summary.grid_remove()
self.run_button.pack_forget()
self.run_screen.make_frame()
self.frame = self.run_screen
self.frame.grid(row=0, column=0)
self.header.grid(row=0, column=1)
self.label.set('RUN')
self.title.pack(side='top')
self.start_button.pack()
self.home_button.pack(side='bottom')
def to_home(self):
self.momentary.end_all()
self.momentary.delete_frame()
self.lock_button.pack_forget()
self.run_button.pack_forget()
self.save_button.pack_forget()
self.reset_button.pack_forget()
self.home_button.pack_forget()
self.start_button.pack_forget()
self.preferences.grid_remove()
self.frame.grid_remove()
self.header.grid_remove()
self.frame = self.home
self.frame.grid(row=0, column=0)
def to_summary(self):
self.frame.grid_remove()
self.label.set('SUMMARY')
self.home_button.pack(side='right')
self.run_button.pack(side='right')
self.header.grid(row=0, column=0, columnspan=1, sticky='nsew')
self.title.pack(side='left')
self.summary = Summary(self.master, self.valves)
self.frame = self.summary
self.frame.grid(row=1, column=0)
def to_edit(self):
self.frame.grid_remove()
self.label.set('EDIT PROGRAM')
self.header.grid(row=0, column=0, columnspan=1, sticky='nsew')
self.home_button.pack(side='right')
self.save_button.pack(side='right')
self.lock_button.pack(side='right')
self.reset_button.pack(side='right')
self.title.pack(side='left')
self.frame = self.edit
self.frame.grid(row=1, column=0)
def to_momentary(self):
self.frame.grid_forget()
self.label.set('MOMENTARY')
self.header.grid(row=0, column=0, columnspan=12, sticky='ew')
self.title.pack(side='left')
self.home_button.pack(side='right')
self.momentary.make_frame()
def to_pref(self):
self.frame.grid_remove()
self.label.set('PREFERENCES')
self.header.grid(row=0, column=0, columnspan=1, sticky='nsew')
self.home_button.pack(side='right')
self.save_button.pack(side='right')
self.lock_button.pack(side='right')
self.reset_button.pack(side='right')
self.title.pack(side='left')
self.frame = self.preferences
self.frame.grid(row=1, column=0)
def reset(self):
self.master.quit()
def access_granted(self):
self.lock_label.set('UNLOCKED')
self.lock_button.config(image=self.unlocked_image)
self.save_button.config(state='normal')
index = 0
while index < 8:
self.edit.minusInterval[index].config(state='normal')
self.edit.minusDelay[index].config(state='normal')
self.edit.plusInterval[index].config(state='normal')
self.edit.plusDelay[index].config(state='normal')
self.edit.motor[index].config(state='normal')
self.edit.adv[index].config(state='normal')
index += 1
for each in self.preferences.entry_field:
each.config(state='normal')
self.edit.set_seconds()
self.save_button.config(state='normal')
class Downloader( object ):
# Instance de la classe (singleton)
instance = None
## Surcharge de la methode de construction standard (pour mettre en place le singleton)
def __new__( self, *args, **kwargs ):
if( self.instance is None ):
self.instance = super( Downloader, self ).__new__( self )
return self.instance
## Constructeur
# @param signaux Lanceur de signaux. Si on le precise pas, aucun signal n'est lance (mode CLI).
def __init__( self, signaux = None ):
self.preferences = Preferences()
self.signaux = signaux
self.arreter = True
self.process = None
## Methode pour afficher un pourcentage à l'ecran
# @param pourcentage Pourcentage actuel a afficher
def afficherPourcentage( self, pourcentage ):
# On s'assure que le pourcentage soit bien entre 0 et 100
if( pourcentage < 0 ):
pourcentage = 0
elif( pourcentage > 100 ):
pourcentage = 100
message = str( pourcentage ) + " %"
print '\r', # Permet d'écrire au même endroit
sys.stdout.write( message )
sys.stdout.flush()
## Methode pour lancer le telecharger des fichiers
# @param listeFichiers Liste des fichiers a telecharger
def lancerTelechargement( self, listeFichiers ):
self.arreter = False
for ( numero, fichier, nomFichierSortie ) in listeFichiers:
logger.info( u"téléchargement de %s" %( fichier ) )
# Si on demande de s'arreter, on sort
if self.arreter:
break
# Si on a le lanceur de signal
if self.signaux :
# On envoie le signal de debut de telechargement d'un fichier
self.signaux.signal( "debutTelechargement", numero )
else:
print "Debut telechargement", nomFichierSortie
# On ajoute le repertoire de destination au nom du fichier
fichierSortie = self.preferences.getPreference( "repertoireTelechargement" ) + "/" + nomFichierSortie
# On telecharge de differentes manieres selon le protocole
if( fichier[ :4 ] == "rtmp" ):
commande = urlToRtmpdump( fichier )
self.telecharger( commande + " -o \"" + fichierSortie + "\"" )
elif( fichier[ :4 ] == "http" or fichier[ :3 ] == "ftp" or fichier[ :3 ] == "mms" ):
self.telecharger( "msdl -c " + fichier + " -o \"" + fichierSortie + "\"" )
else:
logger.warn( "le protocole du fichier %s n'est pas gere" %( fichier ) )
# Si on a le lanceur de signal
if self.signaux :
# On envoie le signal de fin de telechargement d'un fichier
self.signaux.signal( "finTelechargement", numero )
else:
print "\n\tFin telechargement"
# Si on a le lanceur de signal
if self.signaux :
# On envoie le signal de fin de telechargement des fichiers
self.signaux.signal( "finDesTelechargements" )
## Methode qui telecharge un fichier
# @param commande Commande a lancer pour telecharger le fichier
def telecharger( self, commande ):
# Commande mise au bon format pour Popen
if( not isinstance( commande, str ) ):
commande = str( commande )
arguments = shlex.split( commande )
# On lance la commande en redirigeant stdout et stderr (stderr va dans stdout)
self.process = subprocess.Popen( arguments, stdout = subprocess.PIPE, stderr = subprocess.STDOUT )
# On recupere le flux stdout
stdoutF = self.process.stdout
# On recupere le descripteur de fichier de stdout
stdoutFD = stdoutF.fileno()
# On recupere les flags existants
stdoutFlags = fcntl.fcntl( stdoutFD, fcntl.F_GETFL )
# On modifie les flags existants en ajoutant le flag NoDelay
fcntl.fcntl( stdoutFD, fcntl.F_SETFL, stdoutFlags | os.O_NDELAY )
# Tant que le subprocess n'est pas fini
while( self.process.poll() == None ):
# On attent que stdout soit lisible
if( stdoutFD in select.select( [ stdoutFD ],[],[] )[ 0 ] ):
# On lit stdout
ligne = stdoutF.read()
# On affiche que les textes non vides
if ligne:
pourcentListe = re.findall( "(\d{1,3}\.{0,1}\d{0,1})%", ligne )
if( pourcentListe != [] ):
pourcent = int( float( pourcentListe[ -1 ] ) )
if( pourcent >= 0 and pourcent <= 100 ):
# Si on a le lanceur de signal
if not self.signaux :
self.afficherPourcentage( pourcent )
elif self.signaux :
# On envoit le pourcentage d'avancement a l'interface
self.signaux.signal( "pourcentageFichier", pourcent )
# On attent avant de recommencer a lire
time.sleep( 3 )
## Methode pour stopper le telechargement des fichiers
def stopperTelechargement( self ):
if not self.arreter:
# On sort de la boucle principale
self.arreter = True
# On stop le process s'il est lance
if( self.process.poll() == None ):
self.process.terminate()
class Plugin(MooseWidget):
"""
A base class for all plugin objects.
A plugin object are stand-alone widgets contained by a peacock tab. In general, the plugins
should be independent and be able to be removed or added to a given tab. Plugins are stored
Manager objects.
see Manager.py
"""
def __init__(self, layout='MainLayout', settings_key=""):
super(Plugin, self).__init__()
# Name of layout that this plugin should be added (see PluginManager.py)
self._main_layout_name = layout
# The default size policy
self.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Fixed)
# Must be a QtWidget
if not isinstance(self, QtWidgets.QWidget):
mooseutils.mooseError("A Plugin must also be a QWidget.")
return
# The Peacock tab index
self._index = None
self._plugin_manager = None
self._preferences = Preferences(settings_key)
@staticmethod
def commandLineArgs(parser):
"""
Allows the plugin to add command line options to the parser.
"""
def connect(self, other):
"""
Connect the slots of supplied plugin (other) to the signals emited by this (self) plugin.
Args:
other[Plugin]: A plugin object to connect.
"""
if self is not other:
for name, signal in self.signals().iteritems():
slot_name = 'on' + name[0].upper() + name[1:]
if hasattr(other, slot_name):
mooseutils.mooseDebug('{}.{} --> {}.{}'.format(
self.__class__.__name__, name,
other.__class__.__name__, slot_name))
signal.connect(getattr(other, slot_name))
#def initialize(self, *args, **kwargs):
# """
# This method is called by the Manager after all plugins have been created.
# """
# self.setEnabled(True)
def setMainLayoutName(self, name):
"""
Method for changing the name of the main layout that this plugin will be added.
Args:
name[str]: The name of the layout within the PluginManager.
"""
self._main_layout_name = name
def mainLayoutName(self):
"""
Return the name of the layout within the PluginManager that this plugin is to be added.
"""
return self._main_layout_name
def repr(self):
"""
Return data for reproducing the plugin as a script.
"""
return dict()
def canClose(self):
"""
Called when the application wants to close.
This is intended to allow the plugin to check if it has unsaved state and ask
the user if they want to cancel the close or throw away the changes.
Return:
bool: Whether it is OK to close
"""
return True
def closing(self):
"""
Called when the application is about to close.
This is intended to allow the plugin to do any cleanup before closing
"""
pass
def onPreferencesSaved(self):
"""
Called when the preferences have been saved.
"""
def clearRecentlyUsed(self):
"""
Clears any recently used items
"""
def addToMainMenu(self, menubar):
"""
This allows the plugin to add menu items to the main menu.
Args:
menubar[QMenuBar]: Menubar to add items to
"""
pass
def onCurrentChanged(self, index):
"""
Executes when the TabWidget (TabPluginManager) changes active tabs.
Inputs:
index[int]: The index of the active tab
"""
pass
def setTabIndex(self, index, signal=None):
"""
Set the Peacock Tab index (see TabPluginManager)
"""
if signal:
signal.connect(self.onCurrentChanged)
self._index = index
def preferenceWidgets(self):
return self._preferences.widgets()
def __init__(self):
from API import API
from APIPrive import APIPrive
from PluginManager import PluginManager
################################################
# Instanciations + initialisation de variables #
################################################
# On instancie le plugin manager
self.pluginManager = PluginManager()
# On instancie le gestionnaire de preferences et sa fenetre
self.preferences = Preferences()
# On instancie le gestionnaire de download
self.downloader = Downloader()
# On instancie seulement les plugins qui sont selectionnes dans les preferences
#~ self.pluginManager.activerPlugins( self.preferences.getPreference( "pluginsActifs" ) )
# On recupere l'instance de API
self.api = API.getInstance()
# On met en place la liste des plugins dans API
current=0
global choice
choice=''
while choice!='r' and choice!='R':
# self.api.setListeInstance( getattr( self.pluginManager, "listeInstances" ) )
pluginsActifs = self.pluginManager.listeInstances
plugins = self.pluginManager.getListeSites()
plugins.sort()
rep= self.preferences.getPreference( "repertoireTelechargement" )
# if choice.isdigit() and int(choice) < int(len(plugins)-10*current): print int(choice)+int(10*current)
# elif choice.isdigit() and int(choice) > int(len(plugins)-10*current): print int(choice)+int(10*current)
if choice=='q' or choice=='Q':
quitter()
elif choice.isdigit() and int(choice) < int(len(plugins)-10*current):
if plugins[int(choice)+10*current] in pluginsActifs:
self.pluginManager.desactiverPlugin(plugins[int(choice)+10*current])
print int(choice)+10*current,
else:
self.pluginManager.activerPlugin(plugins[int(choice)+10*current])
print int(choice)+10*current,
elif choice=='m' or choice =='M':
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Repertoire de telechargement')
choice=raw_input('\n\n\n\n\n\n\n\tVeuillez saisir un repertoire valide\n\n\t\t')
if not os.path.isdir(choice):
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Repertoire de telechargement')
print "\n\n\n\n\n\n\n\trepertoire ",choice," inexistant\n\n\t\tRepertoire courant:",rep
else :
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Repertoire de telechargement')
rep=choice
print "\n\n\n\n\n\n\n\tModification du repertoire de telechargement :\n\n\t\tNouveau repertoire :",choice
self.preferences.setPreference( "repertoireTelechargement", str(rep))
time.sleep(1)
elif choice=='+':
if len(plugins)>current*15+15: current+=1
elif choice=='-':
if current!=0: current-=1
#affichage a l'ecran de la liste
header ('','','Menus des options')
print " Repertoire de telechargement :",rep
for i in range(10) :
if i+10*current<len(plugins):
print "\n ",i,":",plugins[i+10*current],
if len(plugins[i+10*current])<=8:print"\t\t",
elif len(plugins[i+10*current])<=15:print"\t",
for j in pluginsActifs:
if j==plugins[i+10*current]:
print "actif",
else: print ""
print "\n\n m:modifier le repertoire de telechargement +/-:afficher les autres plugins"
footer()
choice=getch()
class WordFrequencies:
###############################################################################################
# Members
###############################################################################################
namesSet = set()
wordDict = WordDict()
namesDict = {} #{ name : ( count , last occurence ) }
# wordsPerDayDict = {} #{ word : { 'count': count , 'lastOccurence': last occurence } } only counts one occurence per day
wordsPerDayDict = WordsPerDayDict()
namesPerDayDict = {} #{ word : ( count , last occurence ) }
namesToGraphDict = {} #{ word : [ [ date , count ] ] }
namesToGraphDictUniqueOccurences = {} #{ word : [ date ] }
wordCountOfEntriesDict = {} #{ date : word count }
relatedNamesDict = {} #{ name : { name : unique day count } }
lastNamesForFirstNameDict = {} #{ first name : [ last names ] }
totalNumberOfWords = 0
dayEntryHashTable = {} #{ date : hash }
firstDate = datetime.datetime(datetime.MAXYEAR,12,31)
mostRecentDate = datetime.datetime(datetime.MINYEAR,1,1)
namesURL = os.path.dirname(os.path.realpath(__file__)) + '/names.txt'
prefs = Preferences() #stored the user's preferences for various things
printer = PrintHelper(prefs)
###############################################################################################
# Loading and Setup
###############################################################################################
###############################################################################################
# Data Processing
###############################################################################################
#parse a line and add the words to the dictionaries
#print the line to markunder file, with the proper qualification on names
#all markunder printing should happen here
def addLine(self, line, currentDate):
# markunderFile = open(self.markUnderFilePath, 'a')
words = line.split(' ')
wordsToCount = 0 #used to calculate the length of entries - don't want to include invalid words in the word count TODO: rethink this?
namesFound = set()
for word in words:
if word == '' or word == None or re.compile('^\s+$').search(word) != None:
continue
(beforeStuff, word, afterStuff) = Helper.cleanWordForInitialAdd(word)
word = WordClass(word) #words are represented by the WordClass, which is basically an encapsulation of normal words and markup names in one object
if self.prefs.COMBINE_PLURALS:
if word.endswith("'s"):
word = WordClass.addWordOrMarkup(word.toString()[:len(word)-2]) #TODO: this is broken
wasUpper = False;
if word.toString()[:1].isupper():
wasUpper = True;
originalWord = word
word = Helper.cleanWord(word) #this strips off all punctuation and other information that we want to pass into markup.
if not Helper.valid(word):
continue
wordsToCount += 1
#names
if word in self.namesSet and (Preferences.REQUIRE_CAPS_FOR_NAMES and wasUpper):
namesFound.add(word)
try:
self.namesDict[word] = (self.namesDict[word][0] + 1, currentDate)
except:
self.namesDict[word] = (1, currentDate)
#names per day
try:
if self.namesPerDayDict[word][1] != currentDate:
self.namesPerDayDict[word] = (self.namesPerDayDict[word][0] + 1, currentDate)
except:
self.namesPerDayDict[word] = (1, currentDate)
#names for graphing purposes
try: #{ word : [ [ date , count ] ] }
self.namesToGraphDict[word] #trigger exception
if self.namesToGraphDict[word][-1][0] == currentDate: #increment count
self.namesToGraphDict[word][-1][1] += 1
else: #start a new tuple with a new date
self.namesToGraphDict[word].append([currentDate, 1])
except: #this name hasn't been encountered yet
self.namesToGraphDict[word] = [[currentDate, 1]]
#names for graph, counting on unique occurences
try: #{ word : [ date ] }
self.namesToGraphDictUniqueOccurences[word].append(currentDate)
except:
self.namesToGraphDictUniqueOccurences[word] = [currentDate]
#words
if self.wordDict.exists(word):
self.wordDict.addOrReplaceWord(word, self.wordDict.getCount(word) + 1, currentDate, self.wordDict.getFirstOccurrence(word), wasUpper)
else:
self.wordDict.addWord(word, 1, currentDate, currentDate, wasUpper) #TODO: wasUpper wasn't there originally
#words per day
if self.wordsPerDayDict.exists(word):
self.wordsPerDayDict.addWord(word, self.wordsPerDayDict.getCount(word), currentDate) #TODO: was addOrReplaceWord, need to think what it should be
else:
self.wordsPerDayDict(word, 1, currentDate)
#TODO: this is being moved to its own class to be called separately
# if self.prefs.DO_MARK_UNDER:
# #if it's a name, qualify it for the markunder
# if word in self.namesSet:# or not (Preferences.REQUIRE_CAPS_FOR_NAMES and wasUpper):
# markUnderWord = self.getMarkUnderWord(word, originalWord, line, currentDate)
# else:
# markUnderWord = word
# markunderFile.write(markUnderWord + ' ')
# markunderFile.close()
return (wordsToCount, namesFound)
###############################################################################################
# Graphing and Printing
###############################################################################################
#print the x most occuring words
#num: number to print. if 'all', prints all
#TODO: it would be nice to move at least part of this function to the printer class
def printHighest(self, args, option):
if self.prefs.VERBOSE:
print('args: ', end=' ')
print(args)
print('option: ', end=' ')
print(option)
if option == PrintOption.RELATED:
nameForRelated = args[0]
args = args[1:]
if len(args) < 1:
print('Too few arguments.')
return
if self.prefs.VERBOSE:
print('nameForRelated: ' + nameForRelated)
start_num = 0
end_num = 0
index1 = 0
index2 = 1
if len(args) == 1: #only an end num
try:
if (args[index1] == 'all'):
end_num = float('inf')
else:
end_num = int(args[index1])
except:
print('Invalid arguments')
return
elif len(args) >= 2: #start and end
try:
start_num = int(args[index1])
if (args[index2] == 'all'):
end_num = float('inf')
else:
end_num = int(args[index2])
except:
print('Invalid arguments')
return
if self.prefs.VERBOSE:
print('start_num: ', end=' ')
print(start_num, end=' ')
print(' end_num ', end=' ')
print(end_num)
#TODO: add headers to all cases
if option == PrintOption.NAMES:
sortedNamesDict = sorted(list(self.namesDict.items()), key=operator.itemgetter(1))
sortedNamesDict.reverse()
end_num = min(end_num, len(sortedNamesDict))
self.printer.makePrettyHeader('Word', 'Count', 'Last Occurence')
for x in range(start_num, end_num):
self.printer.makeOutputPretty(sortedNamesDict[x])
elif option == PrintOption.RELATED:
#TODO: deal with 'all' here, since it won't be caught earlier
sortedRelatedNamesDict = sorted(list(self.relatedNamesDict[nameForRelated].items()), key=operator.itemgetter(1))
sortedRelatedNamesDict.reverse()
print('Related names for ' + nameForRelated + ':\n')
self.printer.makePrettyHeader('Name', 'Count')
end_num = min(end_num, len(sortedRelatedNamesDict))
for x in range(start_num, end_num):
self.printer.makeOutputPrettyRelated(sortedRelatedNamesDict[x])
elif option == PrintOption.WORDSPERDAY:
sortedWordsPerDayDict = self.wordsPerDayDict.getSortedDictByCount()
sortedWordsPerDayDict.reverse()
end_num = min(end_num, len(sortedWordsPerDayDict))
self.printer.makePrettyHeader('Word', 'Count', 'Last Occurence')
for x in range(start_num, end_num):
self.printer.makeOutputPrettyWPD(sortedWordsPerDayDict[x])
elif option == PrintOption.NAMESPERDAY:
sortedNamesPerDayDict = sorted(list(self.namesPerDayDict.items()), key=operator.itemgetter(1))
sortedNamesPerDayDict.reverse()
end_num = min(end_num, len(sortedNamesPerDayDict))
self.printer.makePrettyHeader('Name', 'Count', 'Last Occurence')
for x in range(start_num, end_num):
self.printer.makeOutputPretty(sortedNamesPerDayDict[x])
elif option == PrintOption.LENGTH:
sortedLengthOfEntriesDict = sorted(list(self.wordCountOfEntriesDict.items()), key=operator.itemgetter(1))
sortedLengthOfEntriesDict.reverse()
end_num = min(end_num, len(sortedLengthOfEntriesDict))
self.printer.makePrettyHeader('Date', 'Count')
for x in range(start_num, end_num):
self.printer.makeOutputPrettyLength(sortedLengthOfEntriesDict[x])
else: #regular words
self.printer.makePrettyHeader('Word', 'Count', 'Last Occurence')
sortedWordsDict = self.wordDict.getSortedDictByCount()
sortedWordsDict.reverse()
end_num = min(end_num, len(sortedWordsDict))
for x in range(start_num, end_num):
self.printer.makeOutputPrettyWordsDict(sortedWordsDict[x])
#graphs the number of occurences of the name per day
def graphAnalytics(self, args):
#{ word : [ [ date , count ] ] }
name = args[0]
try:
self.namesToGraphDict[name]
except:
print('Invalid input - must be a valid name')
return
try:
x = [date[0] for date in self.namesToGraphDict[name]]
y = [count[1] for count in self.namesToGraphDict[name]]
ax = plt.subplot(111)
ax.bar(x, y, width=2)
ax.xaxis_date()
plt.show()
except:
print('Unknown error occured while graphing')
#graphs a bar for each day that an entry exists
def graphEntries(self, args):
#{ date : word count }
sortedLengthOfEntriesDict = sorted(list(self.wordCountOfEntriesDict.items()), key=operator.itemgetter(1))
x = [i[0] for i in sortedLengthOfEntriesDict]
y = [1 for j in sortedLengthOfEntriesDict]
self.graphHelper(x, y)
def graphHelper(self, x, y):
ax = plt.subplot(111)
ax.bar(x, y, width=2)
ax.xaxis_date()
plt.show()
def graphNameValue(self, in_dict):
x = list(in_dict.keys())
y = list(in_dict.values())
self.graphHelper(x, y)
def lookupWord(self, args):
word = args[0]
if not self.wordDict.exists(word):
print('Invalid word')
return
print(word + ': ')
print('First usage: ' + str(self.wordDict.getFirstOccurrence(word)))
print('Last usage: ' + str(self.wordDict.getLastOccurrence(word)))
total_uses = self.wordDict.getCount(word)
total_days_used = self.wordsPerDayDict.getCount(word)
total_number_of_days = len(self.wordCountOfEntriesDict)
print('Total usages: ' + str(total_uses))
print('Total days with at least one usage: ' + str(total_days_used))
length = (self.wordDict.getLastOccurrence(word) - self.wordDict.getFirstOccurrence(word)).days
print('Length from first use to last: ' + Helper.daysAsPrettyLength(length))
print('Average usages per day: ' + str(float(total_uses) / length))
print('Percentage of days with at least one useage: ' + str(round(float(total_days_used) / total_number_of_days * 100, 2)) + '%')
def overallAnalytics(self):
print('Total number of entries: ', end=' ')
print(len(self.wordCountOfEntriesDict))
print('First entry: ', end=' ')
print(Helper.prettyPrintDate(self.firstDate))
print('Last entry: ', end=' ')
print(Helper.prettyPrintDate(self.mostRecentDate))
print('Total days from first to last entry: ', end=' ')
totalDays = self.mostRecentDate - self.firstDate #this is correct
days = totalDays.days
print(days)
print('Percentage of days from first to last with an entry: ', end=' ')
print(str(round(float(len(self.wordCountOfEntriesDict)) / days * 100, 2)) + '%')
print('Average length per entry: ', end=' ')
numberOfEntries = len(self.wordCountOfEntriesDict)
sumOfLengths = 0
longestEntryLength = 0
for date in list(self.wordCountOfEntriesDict.keys()):
length = self.wordCountOfEntriesDict[date]
if length > longestEntryLength:
longestEntryLength = length
longestEntryDate = date
sumOfLengths += length
print(round(float(sumOfLengths) / numberOfEntries, 2))
print('Longest entry: ' + str(longestEntryLength) + ' words on ', end=' ')
print(Helper.prettyPrintDate(longestEntryDate))
print('Total number of words written: ', end=' ')
print(locale.format("%d", self.totalNumberOfWords, grouping=True))
###############################################################################################
# Names
###############################################################################################
def addRelatedNames(self, namesFound):
#{ name : { name : unique day count } }
for keyName in namesFound:
for otherName in namesFound:
if keyName == otherName:
continue
try:
self.relatedNamesDict[keyName]
except:
self.relatedNamesDict[keyName] = {}
try:
self.relatedNamesDict[keyName][otherName] += 1
except:
self.relatedNamesDict[keyName][otherName] = 1
#populate namesList from file
def makeNamesSet(self):
try:
f = open(self.namesURL, 'r') #TODO: error handling
except:
raise Exception("Names file not found")
self.namesSet.clear()
line = f.readline()
while line != '':
self.namesSet.add(line.strip().lower()) #TODO: does this do anything? What?
line = f.readline()
f.close()
#iterate over
def guessNamesHelper(self, guessedNamesSet):
newNames = set()
print('Are these names? (y/n)')
for name in guessedNamesSet:
if name in self.namesSet:
break
inp = input(name + ': ')
if inp == 'y':
newNames.add(name.lower())
f = open(self.namesURL, 'r+')
for name in newNames:
f.write(name + '\n')
f.close()
#try to guess what is a name by looking for capitalized letters in the middle of sentences
def guessNames(self, line, testFlag = False):
guessedNamesSet = set()
names = regex.findall('[^\.]\s+([ABCDEFGHIJKLMNOPQRSTUVWXYZ][\w]+)\W', line, overlapped=True)
try:
for name in names:
if name.lower() not in self.namesSet:
guessedNamesSet.add(name)
except:
return
#want to return the guessedNamesSet here if this is running for a test
#TODO: figure out how to send more input during a test and get rid of this hack
if testFlag:
return guessedNamesSet
self.guessNamesHelper(guessedNamesSet)
#Add a name manually to the names set
def addName(self, args):
name = args[0]
if name in self.namesDict:
print("Name already added")
return
self.namesSet.add(name);
f = open(self.namesURL, 'a')
f.write('\n' + name)
f.close()
def removeName(self, name):
self.namesSet.remove(name);
f = open(self.namesURL, 'r+')
f.clear()
for name in self.namesSet:
f.write(name) + '\n'
f.close()
###############################################################################################
# Control Loop
###############################################################################################
def main(self, args):
self.mainSetup(args)
self.runMainLoop()
#break apart the main function for testing
def mainSetup(self, args):
locale.setlocale(locale.LC_ALL, 'en_US')
fileurl = args.file
if args.verbosity:
self.prefs.VERBOSE = True
if args.combineplurals:
self.prefs.COMBINE_PLURALS = True
if args.guessnames:
self.prefs.GUESS_NAMES = True
if args.markunder:
self.prefs.DO_MARK_UNDER = True
print('Set DO_MARK_UNDER=True')
# if args.noMarkunder:
# self.prefs.DO_MARK_UNDER = False
# print 'Set DO_MARK_UNDER=False'
self.makeNamesSet()
self.readFile(fileurl)
def runMainLoop(self):
# if self.prefs.GUESS_NAMES:
# self.getGuessedNames()
while True:
print('''
Options:
Highest x words highest [num | all] (num | all)
Highest x words per day wpd [num | all]
Lookup lookup [word]
Highest x names names [num | all]
Related Names related [name] [num | all]
Highest x names per day npd [num | all]
Graph names graph [name]
Graph entries graphentries
Graph length graphlength
Add name add name [name]
Set Options option [option_name] [value]
Length length [num | all]
Overall analytics overall
Exit exit
''')
if not self.parseInput(input('>')):
return
def parseInput(self, inpStr):
parts = inpStr.split()
command = parts[0].lower().strip().lstrip()
args = parts[1:]
if (self.prefs.VERBOSE):
print('Parsed arguments: command: ' + str(command) + ' args: ' + str(args))
return self.callInputFunction(command, args)
def readFile(self, url):
try:
f = open(url, 'r')
except:
print('File not found')
newPath = input('Enter new path > ');
return self.readFile(newPath) #TODO: this doesn't work for entirely unknown reasons
newdate = re.compile('\s*([0-9]{1,2}-[0-9]{1,2}-[0-9]{2})\s*')
currentDateStr = None
currentDateObj = None
numWords = 0
namesFound = set()
totalWordNum = 0
currentDayEntry = '' #holds all the lines for the current day, so we can compute a hash of the day later on
line = f.readline()
while (line != ''):
if self.prefs.GUESS_NAMES:
self.guessNames(line)
#check a line to see if it's a date, therefore a new day
dateFound = newdate.match(line)
if dateFound != None: #it's a new date, so wrapup the previous date and set up to move onto the next one
if namesFound != None:
self.addRelatedNames(namesFound)
namesFound = set()
self.dayEntryHashTable[currentDateObj] = hashlib.md5(currentDayEntry.encode()) #TODO: deal with first date
if numWords > 0:
self.wordCountOfEntriesDict[currentDateObj] = numWords #should be here, since we want it triggered at the end
totalWordNum += numWords
numWords = 0
currentDateStr = dateFound.group(0)
currentDateStr = Helper.formatDateStringIntoCleanedString(currentDateStr)
currentDateObj = Helper.makeDateObject(currentDateStr)
if currentDateObj > self.mostRecentDate: #found a higher date than what we've seen so far
self.mostRecentDate = currentDateObj
if currentDateObj < self.firstDate: #found a lower date than what we have now
self.firstDate = currentDateObj
line = line[len(currentDateStr):] #remove date from line, so it's not a word
if currentDateStr != None:
(wordsFound, namesFoundThisLine) = self.addLine(line, currentDateObj)
for name in namesFoundThisLine:
namesFound.add(name)
numWords += wordsFound
line = f.readline()
currentDayEntry += line #add line to the day's entry
#need to capture the last date for the entry length
self.wordCountOfEntriesDict[currentDateObj] = numWords
self.totalNumberOfWords = totalWordNum + numWords #need to get words from last line
f.close()
#args is a list of arguments in order
def callInputFunction(self, inp, args):
if inp == CommandOptions.HIGHEST.value:
self.printHighest(args, None)
elif inp == CommandOptions.LOOKUP.value:
self.lookupWord(args)
elif inp == CommandOptions.NAMES.value:
self.printHighest(args, PrintOption.NAMES)
elif inp == CommandOptions.RELATED.value:
self.printHighest(args, PrintOption.RELATED)
elif inp == CommandOptions.GRAPH.value:
self.graphAnalytics(args)
elif inp == CommandOptions.GRAPH_ENTRIES.value:
self.graphEntries(args)
# elif inp == 'gpd':
# self.graphAnalyticsPerDay(args)
elif inp == CommandOptions.WPD.value:
self.printHighest(args, PrintOption.WORDSPERDAY)
elif inp == CommandOptions.NPD.value:
self.printHighest(args, PrintOption.NAMESPERDAY)
elif inp == CommandOptions.ADDNAME.value:
self.addName(args)
elif inp == CommandOptions.OPTION.value:
print("Setting options isn't supported yet")
pass
elif inp == CommandOptions.LENGTH.value:
self.printHighest(args, PrintOption.LENGTH)
elif inp == CommandOptions.GRAPH_LENGTH.value:
self.graphNameValue(self.wordCountOfEntriesDict)
elif inp == CommandOptions.OVERALL.value:
self.overallAnalytics()
elif inp == CommandOptions.EXIT.value:
return False
else:
print('Unknown command.')
return True
def __init__(self, signaux=None):
self.preferences = Preferences()
self.signaux = signaux
self.arreter = True
self.process = None
def mass_test_raw_data_entry_creation(sh, start, end, interval=1):
pr = Preferences()
prefix = pr.get('DBPrefix')
sh.generateRawDataEntrys(start, end, interval, prefix)
def load_ui_from_prefs(self, preferences: Preferences):
"""Load the UI fields from the given preferences"""
# Filter wheel?
ufw = preferences.get_use_filter_wheel()
self.ui.useFilterWheel.setChecked(ufw if ufw is not None else False)
self.enable_filter_fields()
# Number of flats
self.ui.numFlats.setText(str(preferences.get_default_frame_count()))
# Target ADUs
self.ui.targetADUs.setText(str(preferences.get_target_adus()))
self.ui.aduTolerance.setText(str(preferences.get_adu_tolerance() * 100.0))
# Server address and port number
self.ui.serverAddress.setText(preferences.get_server_address())
self.ui.portNumber.setText(str(preferences.get_port_number()))
# Information about slewing to the flat light source
self.ui.sourceAlt.setText(str(round(preferences.get_source_alt(), 4)))
self.ui.sourceAz.setText(str(round(preferences.get_source_az(), 4)))
# Dithering
self.ui.ditherFlats.setChecked(preferences.get_dither_flats())
self.ui.ditherRadius.setText(str(preferences.get_dither_radius()))
self.ui.ditherMaxRadius.setText(str(preferences.get_dither_max_radius()))
# Filter specifications
filter_specs = preferences.get_filter_spec_list()
fs: FilterSpec
for fs in filter_specs:
check_box_name: str = f"useFilter_{fs.get_slot_number()}"
this_check_box: QCheckBox = self.ui.findChild(QCheckBox, check_box_name)
assert this_check_box is not None
this_check_box.setChecked(fs.get_is_used())
name_field_name: str = f"filterName_{fs.get_slot_number()}"
this_name_field: QLineEdit = self.ui.findChild(QLineEdit, name_field_name)
assert this_name_field is not None
this_name_field.setText(fs.get_name())
# Binning specifications
binning_specs = preferences.get_binning_spec_list()
bs: BinningSpec
for bs in binning_specs:
this_default_name: str = f"binDefault_{bs.get_binning_value()}"
this_available_name: str = f"binAvailable_{bs.get_binning_value()}"
this_off_name: str = f"binOff_{bs.get_binning_value()}"
default_button: QRadioButton = self.ui.findChild(QRadioButton, this_default_name)
assert default_button is not None
available_button: QRadioButton = self.ui.findChild(QRadioButton, this_available_name)
assert available_button is not None
off_button: QRadioButton = self.ui.findChild(QRadioButton, this_off_name)
assert off_button is not None
if bs.get_is_default():
default_button.setChecked(True)
elif bs.get_is_available():
available_button.setChecked(True)
else:
off_button.setChecked(True)
def __init__( self ):
# Appel au constructeur de la classe mere
QtGui.QMainWindow.__init__( self )
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle( "TVDownloader" )
# Mise en place de son icone
self.setWindowIcon( QtGui.QIcon( "ico/TVDownloader.png" ) )
###
# Mise en place des widgets dans la fenetre
###
# Widget central qui contiendra tout
self.centralWidget = QtGui.QWidget( self )
#
# Barre du haut
#
# Layout horizontal qui contiendra les listes deroulantes
self.horizontalLayoutBarreHaut = QtGui.QHBoxLayout()
# Liste deroulante pour choisir le site (plugin)
self.comboBoxSite = QtGui.QComboBox( self.centralWidget )
self.horizontalLayoutBarreHaut.addWidget( self.comboBoxSite )
# Liste deroulante pour choisir une chaine du site courant
self.comboBoxChaine = QtGui.QComboBox( self.centralWidget)
self.horizontalLayoutBarreHaut.addWidget( self.comboBoxChaine )
# Liste deroulante pour choisir une emission de la chaine courante
self.comboBoxEmission = QtGui.QComboBox( self.centralWidget )
self.horizontalLayoutBarreHaut.addWidget( self.comboBoxEmission )
#
# Onglets
#
# Gestionnaire onglets
self.tabWidget = QtGui.QTabWidget( self.centralWidget )
# Onglet Fichiers
self.tabFichiers = QtGui.QSplitter( self.centralWidget ) # L'onglet Fichier contient un splitter
self.tabWidget.addTab( self.tabFichiers, u"Choix des fichiers" )
# Onglet Telechargements
self.tabTelechargements = QtGui.QWidget( self.centralWidget )
self.tabWidget.addTab( self.tabTelechargements, u"Téléchargements" )
#
# Liste des fichiers
#
# Layout de grille qui contient le tableau qui liste les fichiers + boutons
self.gridLayoutFichiers = QtGui.QGridLayout( self.tabFichiers )
# Tableau qui contient la liste des fichiers disponibles pour l'emission courante
self.tableWidgetFichier = MyQTableWidget( self.tabFichiers )
# Il a 4 colonnes et 0 ligne (pour l'instant)
self.tableWidgetFichier.setColumnCount( 3 )
self.tableWidgetFichier.setRowCount( 0 )
# On ajoute les titres
self.tableWidgetFichier.setHorizontalHeaderItem( 0,
self.tableWidgetFichier.creerItem( "" ) )
self.tableWidgetFichier.setHorizontalHeaderItem( 1,
self.tableWidgetFichier.creerItem( "Date" ) )
self.tableWidgetFichier.setHorizontalHeaderItem( 2,
self.tableWidgetFichier.creerItem( "Emission" ) )
# On l'ajoute au layout
self.gridLayoutFichiers.addWidget( self.tableWidgetFichier, 0, 1, 6, 1 )
# Icones du tableWidget
self.iconeFichier = QtGui.QIcon( "ico/gtk-file.svg" )
self.iconeAjoute = QtGui.QIcon( "ico/gtk-add.svg" )
self.iconeTelecharge = QtGui.QIcon( "ico/gtk-apply.svg" )
# Bouton pour ajouter tous les fichiers a la liste des telechargements
self.pushButtonToutAjouter = MyQPushButton( self.tabFichiers )
self.pushButtonToutAjouter.setIcon( QtGui.QIcon( "ico/gtk-add.svg" ) )
self.pushButtonToutAjouter.setToolTip( u"Ajouter tous les fichiers à la liste des téléchargements" )
self.gridLayoutFichiers.addWidget( self.pushButtonToutAjouter, 0, 0, 2, 1 )
# Bouton pour rafraichir le plugin courant
self.pushButtonRafraichirPlugin = MyQPushButton( self.tabFichiers )
self.pushButtonRafraichirPlugin.setIcon( QtGui.QIcon( "ico/gtk-refresh.svg" ) )
self.pushButtonRafraichirPlugin.setToolTip( "Rafraichir le plugin" )
self.gridLayoutFichiers.addWidget( self.pushButtonRafraichirPlugin, 2, 0, 2, 1 )
# Bouton pour ouvrir la fenetre des preferences du plugin courant
self.pushButtonPreferencesPlugin = MyQPushButton( self.tabFichiers )
self.pushButtonPreferencesPlugin.setIcon( QtGui.QIcon( "ico/gtk-preferences.svg" ) )
self.pushButtonPreferencesPlugin.setToolTip( u"Ouvrir les préférences du plugin" )
self.gridLayoutFichiers.addWidget( self.pushButtonPreferencesPlugin, 4, 0, 2, 1 )
# On met en place ce layout sur un widget (pour le splitter)
self.widgetFichiers = QtGui.QWidget()
self.widgetFichiers.setLayout( self.gridLayoutFichiers )
#
# Descriptif des fichiers
#
# Layout de grille
self.gridLayoutDescriptif = QtGui.QGridLayout()
# Label pour afficher un logo
self.logoFichierDefaut = QtGui.QPixmap()
self.logoFichierDefaut.load( "img/gtk-dialog-question.svg" )
self.labelLogo = QtGui.QLabel( self.centralWidget )
self.labelLogo.setPixmap( self.logoFichierDefaut.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) )
self.gridLayoutDescriptif.addWidget( self.labelLogo, 0, 0, 1, 1 )
# Zone de texte pour afficher un descriptif
self.plainTextEdit = QtGui.QPlainTextEdit( self.centralWidget )
self.gridLayoutDescriptif.addWidget( self.plainTextEdit, 0, 1, 1, 2 )
# On met en place ce layout sur un widget (pour le splitter)
self.widgetDescriptif = QtGui.QWidget()
self.widgetDescriptif.setLayout( self.gridLayoutDescriptif )
# Onrientation verticale du splitter
self.tabFichiers.setOrientation( QtCore.Qt.Vertical )
# On ajoute les 2 elements au splitter (qui est notre onglet)
self.tabFichiers.addWidget( self.widgetFichiers )
self.tabFichiers.addWidget( self.widgetDescriptif )
#
# Liste des telechargements
#
# Layout de grille qui contient le tableau qui liste les fichiers a telecharger + les boutons pour le controller
self.gridLayoutTelechargement = QtGui.QGridLayout( self.tabTelechargements )
# Tableau qui contient la liste des fichiers a telecharger
self.tableWidgetTelechargement = MyQTableWidget( self.tabTelechargements )
# Il a 5 colonnes et 0 ligne (pour l'instant)
self.tableWidgetTelechargement.setColumnCount( 3 )
self.tableWidgetTelechargement.setRowCount( 0 )
# On ajoute le titre des 5 colonnes
self.tableWidgetTelechargement.setHorizontalHeaderItem( 0,
self.tableWidgetTelechargement.creerItem( "Date" ) )
self.tableWidgetTelechargement.setHorizontalHeaderItem( 1,
self.tableWidgetTelechargement.creerItem( "Emission" ) )
self.tableWidgetTelechargement.setHorizontalHeaderItem( 2,
self.tableWidgetTelechargement.creerItem( "Etat" ) )
# On l'ajoute au layout
self.gridLayoutTelechargement.addWidget( self.tableWidgetTelechargement, 0, 1, 4, 1 )
# Bouton pour monter l'element selectionne tout en haut de la liste
self.pushButtonExtremiteMonter = MyQPushButton( self.tabTelechargements )
self.pushButtonExtremiteMonter.setIcon( QtGui.QIcon( "ico/gtk-jump-to-rtl.svg" ) )
self.pushButtonExtremiteMonter.setToolTip( u"Placer l'élément sélectionné tout en haut" )
self.gridLayoutTelechargement.addWidget( self.pushButtonExtremiteMonter, 0, 0, 1, 1 )
# Bouton pour monter l'element selectionne d'un cran dans la liste
self.pushButtonMonter = MyQPushButton( self.tabTelechargements )
self.pushButtonMonter.setIcon( QtGui.QIcon( "ico/gtk-go-up.svg" ) )
self.pushButtonMonter.setToolTip( u"Monter l'élément sélectionné" )
self.gridLayoutTelechargement.addWidget( self.pushButtonMonter, 1, 0, 1, 1 )
# Bouton pour descendre l'element selectionne d'un cran dans la liste
self.pushButtonDescendre = MyQPushButton( self.tabTelechargements )
self.pushButtonDescendre.setIcon( QtGui.QIcon( "ico/gtk-go-down.svg" ) )
self.pushButtonDescendre.setToolTip( u"Descendre l'élément selectionné" )
self.gridLayoutTelechargement.addWidget( self.pushButtonDescendre, 2, 0, 1, 1 )
# Bouton pour descendre l'element selectionne tout en bas de la liste
self.pushButtonExtremiteDescendre = MyQPushButton( self.tabTelechargements )
self.pushButtonExtremiteDescendre.setIcon( QtGui.QIcon( "ico/gtk-jump-to-ltr.svg" ) )
self.pushButtonExtremiteDescendre.setToolTip( u"Placer l'élément sélectionné tout en bas" )
self.gridLayoutTelechargement.addWidget( self.pushButtonExtremiteDescendre, 3, 0, 1, 1 )
# Bouton pour supprimer tous les elements de la liste
self.pushButtonToutSupprimer = MyQPushButton( self.tabTelechargements )
self.pushButtonToutSupprimer.setIcon( QtGui.QIcon( "ico/gtk-cancel.svg" ) )
self.pushButtonToutSupprimer.setToolTip( u"Supprimer tous les téléchargements" )
self.gridLayoutTelechargement.addWidget( self.pushButtonToutSupprimer, 0, 2, 1, 1 )
# Bouton pour supprimer de la liste les telechargements termines
self.pushButtonNettoyer = MyQPushButton( self.tabTelechargements )
self.pushButtonNettoyer.setIcon( QtGui.QIcon( "ico/gtk-delete-full.svg" ) )
self.pushButtonNettoyer.setToolTip( u"Supprimer les téléchargement terminés" )
self.gridLayoutTelechargement.addWidget( self.pushButtonNettoyer, 1, 2, 1, 1 )
# Bouton pour ouvrir le dossier des telechargements
self.pushButtonOuvrirDossierTelechargement = MyQPushButton( self.tabTelechargements )
self.pushButtonOuvrirDossierTelechargement.setIcon( QtGui.QIcon( "ico/gtk-folder.svg" ) )
self.pushButtonOuvrirDossierTelechargement.setToolTip( u"Ouvrir le dossier des téléchargements" )
self.gridLayoutTelechargement.addWidget( self.pushButtonOuvrirDossierTelechargement, 2, 2, 1, 1 )
#
# Barre progression de telechargement d'un fichier
#
self.progressBarTelechargementFichier = QtGui.QProgressBar( self.centralWidget )
self.progressBarTelechargementFichier.setProperty( "value", 0 )
#
# Barre de progression de telechargement des fichiers
#
self.progressBarTelechargement = QtGui.QProgressBar( self.centralWidget )
self.progressBarTelechargement.setProperty( "value", 0 )
#
# Boutons du bas pour gerer ajouter/supprimer/lancer telechargements
#
# Layout horizontal qui contiendra les boutons
self.horizontalLayoutBarreBas = QtGui.QHBoxLayout()
# Bouton pour lancer les telechargements
self.pushButtonLancer = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-play-ltr.svg" ), u"Lancer téléchargement", self.centralWidget )
self.horizontalLayoutBarreBas.addWidget( self.pushButtonLancer )
# Bouton pour stopper les telechargements
self.pushButtonStop = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-stop.svg" ), u"Stopper le téléchargement", self.centralWidget )
self.pushButtonStop.setEnabled( False )
self.horizontalLayoutBarreBas.addWidget( self.pushButtonStop )
###
# Positionnement des differents widgets/layouts sur le layout de grille
###
# Layout de grille dans lequel on va placer nos widgets/layouts
self.gridLayout = QtGui.QGridLayout( self.centralWidget )
# On ajoute la barre du haut
self.gridLayout.addLayout( self.horizontalLayoutBarreHaut, 0, 0, 1, 3 )
# On ajoute le gestionnaire d'onglets
self.gridLayout.addWidget( self.tabWidget, 1, 0, 1, 3 )
# On ajoute la barre de progression de telechargement d'un fichier
self.gridLayout.addWidget( self.progressBarTelechargementFichier, 2, 0, 1, 3 )
# On ajoute la barre de progression de telechargement des fichiers
self.gridLayout.addWidget( self.progressBarTelechargement, 3, 0, 1, 3 )
# On ajoute les boutons ajouter/supprimer/lancer
self.gridLayout.addLayout( self.horizontalLayoutBarreBas, 4, 0, 1, 3 )
###
# Mise en place le central widget dans la fenetre
###
self.setCentralWidget( self.centralWidget )
###
# Mise en place du menu
###
# Menu barre
self.menubar = QtGui.QMenuBar( self )
self.menubar.setGeometry( QtCore.QRect( 0, 0, 480, 25 ) )
# Menu Fichier
self.menuFichier = QtGui.QMenu( "&Fichier", self.menubar )
self.menubar.addAction( self.menuFichier.menuAction() )
# Action Fichier -> Quitter
self.actionQuitter = QtGui.QAction( QtGui.QIcon( "ico/gtk-quit.svg" ), "&Quitter", self )
self.actionQuitter.setIconVisibleInMenu( True )
self.menuFichier.addAction( self.actionQuitter )
# Menu Edition
self.menuEdition = QtGui.QMenu( "&Edition", self.menubar )
self.menubar.addAction( self.menuEdition.menuAction() )
# Action Edition -> Mise a jour
self.actionMAJ = QtGui.QAction( QtGui.QIcon( "ico/gtk-refresh.svg" ), u"&Mise à jour des plugins", self )
self.actionMAJ.setIconVisibleInMenu( True )
self.menuEdition.addAction( self.actionMAJ )
# Action Edition -> Preferences
self.actionPreferences = QtGui.QAction( QtGui.QIcon( "ico/gtk-preferences.svg" ), u"&Préférences", self )
self.actionPreferences.setIconVisibleInMenu( True )
self.menuEdition.addAction( self.actionPreferences )
# Menu Aide
self.menuAide = QtGui.QMenu( "&Aide", self.menubar )
self.menubar.addAction( self.menuAide.menuAction() )
# Action Aide -> A propos
self.actionAPropos = QtGui.QAction( QtGui.QIcon( "ico/gtk-about.svg" ), u"À p&ropos", self )
self.actionAPropos.setIconVisibleInMenu( True )
self.menuAide.addAction( self.actionAPropos )
# Ajout du menu a l'interface
self.setMenuBar( self.menubar )
###
# Signaux provenants de l'interface
###
QtCore.QObject.connect( self.tableWidgetFichier,
QtCore.SIGNAL( "cellClicked(int,int)" ),
self.afficherInformationsFichier )
QtCore.QObject.connect( self.tableWidgetFichier,
QtCore.SIGNAL( "cellDoubleClicked(int,int)" ),
self.gererTelechargement )
QtCore.QObject.connect( self.pushButtonToutAjouter,
QtCore.SIGNAL( "clicked()" ),
self.ajouterTousLesFichiers )
QtCore.QObject.connect( self.pushButtonRafraichirPlugin,
QtCore.SIGNAL( "clicked()" ),
self.rafraichirPlugin )
QtCore.QObject.connect( self.tableWidgetTelechargement,
QtCore.SIGNAL( "cellDoubleClicked(int,int)" ),
self.supprimerTelechargement )
QtCore.QObject.connect( self.pushButtonExtremiteMonter,
QtCore.SIGNAL( "clicked()" ),
lambda versLeHaut = True, extremite = True : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) )
QtCore.QObject.connect( self.pushButtonMonter,
QtCore.SIGNAL( "clicked()" ),
lambda versLeHaut = True, extremite = False : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) )
QtCore.QObject.connect( self.pushButtonDescendre,
QtCore.SIGNAL( "clicked()" ),
lambda versLeHaut = False, extremite = False : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) )
QtCore.QObject.connect( self.pushButtonExtremiteDescendre,
QtCore.SIGNAL( "clicked()" ),
lambda versLeHaut = False, extremite = True : self.tableWidgetTelechargement.deplacerLigne( versLeHaut, extremite ) )
QtCore.QObject.connect( self.pushButtonToutSupprimer,
QtCore.SIGNAL( "clicked()" ),
self.supprimerTousLesTelechargements )
QtCore.QObject.connect( self.pushButtonNettoyer,
QtCore.SIGNAL( "clicked()" ),
self.nettoyer )
QtCore.QObject.connect( self.pushButtonLancer,
QtCore.SIGNAL( "clicked()" ),
self.lancerTelechargement )
QtCore.QObject.connect( self.pushButtonStop,
QtCore.SIGNAL( "clicked()" ),
self.stopperTelechargement )
QtCore.QObject.connect( self.actionQuitter,
QtCore.SIGNAL( "triggered()" ),
self.close )
################################################
# Instanciations + initialisation de variables #
################################################
# Fenetre About
self.aProposDialog = None
# Fenetre des preferences du logiciel
self.preferencesDialog = None
# Fenetre de mise a jour des plugins
self.updateManagerDialog = None
# Nom plugin courant
self.nomPluginCourant = ""
# Liste des fichiers
self.listeFichiers = []
# Liste des fichiers a telecharger
self.listeFichiersATelecharger = []
# Cache des images descriptive
# Clef : urlImage Valeur : image (binaire)
self.cacheImage = {}
# On intancie le lanceur de signaux
self.signaux = Signaux()
# On instancie le gestionnaire de preferences
self.preferences = Preferences()
# On instancie le gestionnaire de preferences des plugins
self.preferencesPluginDialog = PreferencePluginDialog( self )
# On instancie le gestionnaire de download
self.downloader = Downloader( self.signaux )
# On recupere l'instance de API
self.api = API.getInstance()
# On instancie le gestionnaire d'historique
self.historique = Historique()
# On instancie la fenetre d'attente
self.fenetreAttenteProgressDialog = FenetreAttenteProgressDialog( self )
# On instancie le gest
#
# Fenetre de confirmation pour quitter le logiciel
#
self.quitterMessageBox = QtGui.QMessageBox( self )
self.quitterMessageBox.setWindowTitle( "Fermeture de TVDownloader" )
self.quitterMessageBox.setText( u"Voulez-vous réellement quitter TVDownloader ?" )
self.quitterMessageBox.setInformativeText( u"Votre liste de téléchargement sera perdue" )
self.quitterMessageBox.addButton( "Oui", QtGui.QMessageBox.AcceptRole )
self.quitterMessageBox.addButton( "Non", QtGui.QMessageBox.RejectRole )
############################################################
# On connecte les signaux des instances precedements crees #
############################################################
QtCore.QObject.connect( self.pushButtonOuvrirDossierTelechargement,
QtCore.SIGNAL( "clicked()" ),
self.ouvrirRepertoireTelechargement )
QtCore.QObject.connect( self.comboBoxSite,
QtCore.SIGNAL( "activated(QString)" ),
self.listerChaines )
QtCore.QObject.connect( self.comboBoxChaine,
QtCore.SIGNAL( "activated(QString)" ),
self.listerEmissions )
QtCore.QObject.connect( self.comboBoxEmission,
QtCore.SIGNAL( "activated(QString)" ),
self.listerFichiers )
QtCore.QObject.connect( self.pushButtonPreferencesPlugin,
QtCore.SIGNAL( "clicked()" ),
self.ouvrirPreferencesPlugin )
QtCore.QObject.connect( self.actionPreferences,
QtCore.SIGNAL( "triggered()" ),
self.ouvrirPreferencesLogiciel )
QtCore.QObject.connect( self.actionMAJ,
QtCore.SIGNAL( "triggered()" ),
self.ouvrirFenetreMiseAJour )
QtCore.QObject.connect( self.actionAPropos,
QtCore.SIGNAL( "triggered()" ),
self.ouvrirFenetreAPropos )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ) , self.fenetreAttenteProgressDialog.ouvrirFenetreAttente )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finActualisation()" ) , self.fenetreAttenteProgressDialog.fermerFenetreAttente )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "actualiserListesDeroulantes()" ) , self.actualiserListesDeroulantes )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeChaines(PyQt_PyObject)" ) , self.ajouterChaines )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeEmissions(PyQt_PyObject)" ) , self.ajouterEmissions )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "listeFichiers(PyQt_PyObject)" ) , self.ajouterFichiers )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "nouvelleImage(PyQt_PyObject)" ) , self.mettreEnPlaceImage )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "debutTelechargement(int)" ) , self.debutTelechargement )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finTelechargement(int)" ) , self.finTelechargement )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "finDesTelechargements()" ) , self.activerDesactiverInterface )
QtCore.QObject.connect( self.signaux, QtCore.SIGNAL( "pourcentageFichier(int)" ) , self.progressBarTelechargementFichier.setValue )
#########
# Début #
#########
# La fenetre prend la dimension qu'elle avait a sa fermeture
taille = self.preferences.getPreference( "tailleFenetre" )
self.resize( taille[ 0 ], taille[ 1 ] )
# Si aucun plugin n'est active, on ouvre la fenetre des preferences
if( len( self.preferences.getPreference( "pluginsActifs" ) ) == 0 ):
self.ouvrirPreferencesLogiciel()
# On actualise tous les plugins
self.rafraichirTousLesPlugins()
class Plugin(MooseWidget):
"""
A base class for all plugin objects.
A plugin object are stand-alone widgets contained by a peacock tab. In general, the plugins
should be independent and be able to be removed or added to a given tab. Plugins are stored
Manager objects.
see Manager.py
"""
def __init__(self, layout='MainLayout', settings_key="", **kwargs):
super(Plugin, self).__init__()
# Name of layout that this plugin should be added (see PluginManager.py)
self._main_layout_name = layout
# The default size policy
self.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
# Must be a QtWidget
if not isinstance(self, QtWidgets.QWidget):
mooseutils.mooseError("A Plugin must also be a QWidget.")
return
# The Peacock tab index
self._index = None
self._plugin_manager = None
self._preferences = Preferences(settings_key)
@staticmethod
def commandLineArgs(parser):
"""
Allows the plugin to add command line options to the parser.
"""
def setup(self):
"""
Adds automatic Preference callback connection to the setup method.
"""
super(Plugin, self).setup()
for key, widget in self._preferences._widgets.iteritems():
name = key.split('/')[-1]
name = '_prefCallback{}{}'.format(name[0].upper(), name[1:])
callback = getattr(self, name, None)
if callback:
widget.valueSaved.connect(callback)
def connect(self, other):
"""
Connect the slots of supplied plugin (other) to the signals emited by this (self) plugin.
Args:
other[Plugin]: A plugin object to connect.
"""
if self is not other:
for name, signal in self.signals().iteritems():
slot_name = 'on' + name[0].upper() + name[1:]
if hasattr(other, slot_name):
mooseutils.mooseDebug('{}.{} --> {}.{}'.format(self.__class__.__name__, name,
other.__class__.__name__, slot_name))
signal.connect(getattr(other, slot_name))
def setMainLayoutName(self, name):
"""
Method for changing the name of the main layout that this plugin will be added.
Args:
name[str]: The name of the layout within the PluginManager.
"""
self._main_layout_name = name
def mainLayoutName(self):
"""
Return the name of the layout within the PluginManager that this plugin is to be added.
"""
return self._main_layout_name
def repr(self):
"""
Return data for reproducing the plugin as a script.
"""
return dict()
def canClose(self):
"""
Called when the application wants to close.
This is intended to allow the plugin to check if it has unsaved state and ask
the user if they want to cancel the close or throw away the changes.
Return:
bool: Whether it is OK to close
"""
return True
def closing(self):
"""
Called when the application is about to close.
This is intended to allow the plugin to do any cleanup before closing
"""
pass
def onPreferencesSaved(self):
"""
Called when the preferences have been saved.
"""
def clearRecentlyUsed(self):
"""
Clears any recently used items
"""
def addToMenu(self, menu):
pass
def addToMainMenu(self, menubar):
"""
This allows the plugin to add menu items to the main menu.
Args:
menubar[QMenuBar]: Menubar to add items to
"""
pass
def onCurrentChanged(self, index):
"""
Executes when the TabWidget (TabPluginManager) changes active tabs.
Inputs:
index[int]: The index of the active tab
"""
pass
def setTabIndex(self, index, signal=None):
"""
Set the Peacock Tab index (see TabPluginManager)
"""
if signal:
signal.connect(self.onCurrentChanged)
self._index = index
def preferenceWidgets(self):
return self._preferences.widgets()
def setupMenu(self, menu):
pass
def showPreferences(self): dlg = Preferences() dlg.exec_()
class Manager(object):
def __init__(self):
self._preferences = None
self.__servers = None
return
def init(self):
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
connectionManager.onLoggedOn += self._onLoggedOn
def fini(self):
connectionManager.onLoggedOn -= self._onLoggedOn
self._preferences = None
self.__servers.fini()
self.__servers = None
return
def initiateLogin(self, email, password, serverName, isSocialToken2Login, rememberUser):
authMethod = CONNECTION_METHOD.BASIC
self._preferences['session'] = BigWorld.wg_cpsalt(self._preferences['session'])
self._preferences['password_length'] = len(password)
self._preferences['remember_user'] = rememberUser
self._preferences['login'] = email
self._preferences['server_name'] = serverName
loginParams = {'login': self._preferences['login'],
'session': self._preferences['session'],
'temporary': str(int(not rememberUser)),
'auth_method': authMethod}
if isSocialToken2Login or self._preferences['token2']:
loginParams['auth_method'] = CONNECTION_METHOD.TOKEN2
loginParams['token2'] = self._preferences['token2']
if isSocialToken2Login:
self._preferences['login_type'] = self._preferences['login_type']
else:
self._preferences['login_type'] = 'credentials'
connectionManager.initiateConnection(loginParams, password, serverName)
def getPreference(self, key):
return self._preferences[key]
def clearPreferences(self):
self._preferences.clear()
def clearToken2Preference(self):
self._preferences['token2'] = ''
def writePreferences(self):
self._preferences.writeLoginInfo()
@property
def servers(self):
return self.__servers
def _onLoggedOn(self, responseData):
name = responseData.get('name', 'UNKNOWN')
token2 = responseData.get('token2', '')
g_lobbyContext.setCredentials(name, token2)
if self._preferences['remember_user']:
self._preferences['name'] = name
self._preferences['token2'] = token2
if not constants.IS_DEVELOPMENT:
del self._preferences['server_name']
else:
email = self._preferences['login']
serverName = self._preferences['server_name']
session = self._preferences['session']
self._preferences.clear()
if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset:
self._preferences['login'] = email
if constants.IS_DEVELOPMENT:
self._preferences['server_name'] = serverName
self._preferences['session'] = session
self._preferences.writeLoginInfo()
self._showSecurityMessage(responseData)
def _showSecurityMessage(self, responseData):
securityWarningType = responseData.get('security_msg')
if securityWarningType is not None:
securityLink = ''
if not GUI_SETTINGS.isEmpty('securitySettingsURL'):
securityLink = makeHtmlString('html_templates:lobby/system_messages', 'link', {'text': _ms(SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS),
'linkType': 'securityLink'})
SystemMessages.pushI18nMessage('#system_messages:securityMessage/%s' % securityWarningType, type=SystemMessages.SM_TYPE.Warning, link=securityLink)
return
def make_from_preferences(cls, preferences: Preferences):
"""Create a DataModel instance from the saved preferences"""
model = DataModel()
model.set_default_frame_count(preferences.get_default_frame_count())
model.set_target_adus(preferences.get_target_adus())
model.set_adu_tolerance(preferences.get_adu_tolerance())
model.set_server_address(preferences.get_server_address())
model.set_port_number(preferences.get_port_number())
model.set_warm_when_done(preferences.get_warm_when_done())
model.set_use_filter_wheel(preferences.get_use_filter_wheel())
model.set_filter_specs(preferences.get_filter_spec_list())
model.set_binning_specs(preferences.get_binning_spec_list())
model.set_save_files_locally(False)
model.set_flat_frame_count_table(
FlatFrameTable(preferences.get_default_frame_count(),
preferences.get_filter_spec_list(),
preferences.get_binning_spec_list()))
model.set_source_alt(float(preferences.get_source_alt()))
model.set_source_az(float(preferences.get_source_az()))
model.set_dither_flats(bool(preferences.get_dither_flats()))
model.set_dither_radius(float(preferences.get_dither_radius()))
model.set_dither_max_radius(float(preferences.get_dither_max_radius()))
return model
class Pysciplot(QMainWindow):
"""
This class initializes the PySciPlot program.
"""
def __init__(self):
QMainWindow.__init__(self)
Util.debug(2, "App", "Setting up UI")
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
def setup(self):
"""
Setup the application.
"""
# Variables
Util.debug(2, "App", "Initializing variables")
self._version = 1
self._loadedModules = {}
self.setDefaults()
# Let the workspace resize when the main window is resized
self.setCentralWidget(self.ui.workspace)
# Make signal/slot connections
Util.debug(2, "App", "Connecting signals and slots")
self.ui.actionQuit.triggered.connect(self.close)
self.ui.actionNew_Project.triggered.connect(self.newProjectSlot)
self.ui.actionLoad_Project.triggered.connect(self.loadProjectSlot)
self.ui.actionSave_Project.triggered.connect(self.saveProject)
self.ui.actionSave_Project_As.triggered.connect(self.saveProjectAs)
self.ui.actionSave_Current_Figure.triggered.connect(self.saveCurrentFigure)
self.ui.actionPreferences.triggered.connect(self.preferences.showDialog)
self.ui.actionShow_Waves.triggered.connect(self.printAllWaves)
self.ui.actionShow_Figures.triggered.connect(self.printAllFigures)
Util.debug(2, "App", "Loading modules")
for moduleName in modules.__all__:
module = eval(moduleName + "." + moduleName + "()")
module.load()
self._loadedModules[moduleName] = module
def setDefaults(self):
"""
Setup parts of the application that have some sort of default.
Intended to be used when creating a new project to reset the application
to a blank slate.
"""
# Remove or hide any windows
subWindows = self.ui.workspace.subWindowList()
for window in subWindows:
if type(window).__name__ in ["DataTableSubWindow", "FigureSubWindow"]:
window.setAttribute(Qt.WA_DeleteOnClose)
window.close()
else:
window.setVisible(False)
# Remove signals
try:
self.waves().waveAdded.disconnect(self.model('appWaves').appendRow)
except:
pass
try:
self.waves().allWavesRemoved.disconnect(self.model('appWaves').removeAllWaves)
except:
pass
# Set variables
self._waves = Waves()
self._figures = Figures()
self._models = {}
self.projectDir = "" # current project directory
self.setCurrentProject("")
self._storedSettings = {} # this is a dict with widgetName: list pairs
# where each list has [setting-name, setting-value] pairs
# setting-value is a dict with (property-name: Property) pairs
# Load Preferences
Util.debug(2, "App", "Loading Preferences from file")
self.preferences = Preferences("~/.pysciplotrc")
# Create application-wide models
self._models['appWaves'] = WavesListModel(self.waves().waveNames())
# Signals
self.waves().waveAdded.connect(self.model('appWaves').appendRow)
self.waves().allWavesRemoved.connect(self.model('appWaves').removeAllWaves)
# Reload modules
for module in self._loadedModules.values():
module.reload()
def waves(self):
"""
Return the app's Waves object. NOT A LIST OF WAVES.
"""
return self._waves
def figures(self):
"""
Return the app's Figures object. NOT A LIST OF FIGURES.
"""
return self._figures
def storedSettings(self):
"""
Return the storedSettings dict.
"""
return self._storedSettings
def models(self):
"""
Return the models dict.
"""
return self._models
def model(self, name):
"""
Return a specific model from the models dict.
"""
return self._models[name]
def createTable(self, waves=[], tableName="Table"):
"""
Create a table.
"""
Util.debug(2, "App.createTable", "Creating a table")
model = DataTableModel(waves, self)
# Connect slots
self.waves().waveRemoved[Wave].connect(model.removeWave)
self.waves().allWavesRemoved.connect(model.removeAllWaves)
return self.createDataTableView(model, tableName)
def createDataTableView(self, tableModel, tableName="Table"):
"""
Create a table view based on the given model.
"""
tableViewSubWindow = DataTableSubWindow(self.ui.workspace)
tableView = QDataTableView(tableModel, tableName, tableViewSubWindow)
tableViewSubWindow.setWidget(tableView)
tableViewSubWindow.setAttribute(Qt.WA_DeleteOnClose)
tableViewSubWindow.resize(600, 300)
self.ui.workspace.addSubWindow(tableViewSubWindow)
tableViewSubWindow.setVisible(True)
return tableViewSubWindow
def saveProjectAs(self):
"""
Save the current project to a file which will be selected by the user.
"""
Util.debug(2, "App.saveProjectAs", "Saving project as")
fileName = str(QFileDialog.getSaveFileName(self.ui.workspace, "Save Project", self.projectDirectory(), "PySciPlot Project (*.psp);;All Files (*)"))
Save.writeProjectToFile(self, fileName)
def saveProject(self):
"""
Save the current project to a file. If project has previously been saved, use
that location.
"""
Util.debug(2, "App.saveProject", "Saving project")
if self.currentProjectFile != "" and QFile.exists(self.currentProjectFile):
Save.writeProjectToFile(self, self.currentProjectFile)
else:
self.saveProjectAs()
def loadProjectSlot(self):
"""
Slot to pick up menu selection and run loadProject. Required because of different parameters.
"""
self.loadProject()
def loadProject(self, fileName="", confirmReset=True):
"""
Load a project from a file which will be selected by the user.
"""
Util.debug(2, "App.loadProject", "Loading project from file " + str(fileName))
# Reset app to a clean slate
self.resetToDefaults(confirmReset)
# Now load the project
if fileName == "":
fileDialog = QFileDialog(self.ui.workspace, "Load Project")
fileDialog.setNameFilter("PySciPlot Project (*.psp);;All Files (*)")
fileDialog.setDefaultSuffix("psp")
fileDialog.setConfirmOverwrite(False)
fileDialog.setDirectory(self.projectDirectory())
fileDialog.setAcceptMode(QFileDialog.AcceptOpen)
fileDialog.exec_()
fileName = str(fileDialog.selectedFiles()[0])
Load.loadProjectFromFile(self, fileName)
def newProjectSlot(self):
"""
Slot to pick up menu selection and create a new project. Required because of different parameters.
"""
Util.debug(2, "App.newProject", "Creating new project")
self.resetToDefaults(True)
def resetToDefaults(self, confirm=True):
"""
Reset the application to the defaults. At the very least,
this will delete all waves, tables, and figures.
Before resetting, this will ask the user if they want to save
the current project.
"""
Util.debug(2, "App.resetToDefaults", "Resetting application to defaults")
if confirm:
# Check to see if we want to save the current project
saveProjectMessage = QMessageBox()
saveProjectMessage.setText("You are about to load another project.")
saveProjectMessage.setInformativeText("Do you want to save your current project?")
saveProjectMessage.setStandardButtons(QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
saveProjectResponse = saveProjectMessage.exec_()
if saveProjectResponse == QMessageBox.Save:
self.saveProject()
elif saveProjectResponse == QMessageBox.Cancel:
return
# Now reset to a clean slate
self.setDefaults()
def setCurrentProject(self, fileName):
Util.debug(3, "App.setCurrentProject", "Setting current project title")
self.currentProjectFile = fileName
if fileName != "":
self.setWindowTitle("PySciPlot - " + fileName)
else:
self.setWindowTitle("PySciPlot")
def projectDirectory(self):
if os.path.isdir(self.projectDir):
return self.projectDir
return self.preferences.getInternal('projectDirectory')
def saveCurrentFigure(self):
"""
Save the current figure to a file.
First we make sure that the active window has a figure in it.
Then we ask the user for certain options to be set.
Then we ask for the file to save the figure to.
Then we save the file.
"""
Util.debug(2, "App.saveCurrentFigure", "Saving current Figure")
currentWindow = self.ui.workspace.activeSubWindow()
# Check if the active window has a figure in it
if type(currentWindow).__name__ != "FigureSubWindow":
notFigureMessage = QMessageBox()
notFigureMessage.setText("The active window is not a figure, so you cannot save it as a figure.")
notFigureMessage.exec_()
return False
# Ask user for user-configurable options
figureOptionsDialog = QDialog()
figureOptionsUi = Ui_SaveFigureOptionsDialog()
figureOptionsUi.setupUi(figureOptionsDialog)
figureOptionsSubWindow = self.ui.workspace.addSubWindow(figureOptionsDialog)
figureOptionsResult = figureOptionsDialog.exec_()
figureOptionsSubWindow.close()
dpi = 100
orientation = "Landscape"
if figureOptionsResult == QDialog.Accepted:
dpi = Util.getWidgetValue(figureOptionsUi.dpi)
orientation = Util.getWidgetValue(figureOptionsUi.orientation)
else:
return False
# As user for the filename to save to
fileName = QFileDialog.getSaveFileName(self.ui.workspace, "Save Figure", self.projectDirectory())
# Save the figure to the file
currentWindow.widget().figure.savefig(str(fileName), dpi=dpi, orientation=orientation)
######################
# temporary methods, for testing
######################
def createDefaultTable(self):
waveNames = self.model('appWaves').orderedWaveNames()
waves = []
for waveName in waveNames:
waves.append(self.waves().wave(waveName))
return self.createTable(waves)
def printAllWaves(self):
print self._waves
def printAllFigures(self):
print self._figures
def setTestData(self):
self._waves.addWave(Wave("Wave1", "Integer", [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
self._waves.addWave(Wave("Wave2", "Integer", [0, 1, 4, 9, 4, 1, 0, 1, 4, 9]))
self._waves.addWave(Wave("Wave3", "Integer", [0, 1, 3, 1, 3, 1, 3, 1, 3, 1]))
self._waves.addWave(Wave("Wave4", "Integer", [4, 3, 2, 1, 0, 1, 2, 3, 4, 5]))
def __init__(self, pixels, numPixels, name):
threading.Thread.__init__(self)
self.preferences = Preferences()
self.pixels = pixels
self.numPixels = numPixels
self.name = name
def __init__(self, preferences: Preferences, data_model: DataModel):
"""
Initialize the main window controller
:param preferences: Preferences object for application defaults
:param data_model: Data model object for the current run
"""
self._preferences = preferences
self._data_model = data_model
QMainWindow.__init__(self)
self.ui = uic.loadUi(
MultiOsUtil.path_for_file_in_program_directory("MainWindow.ui"))
self._field_validity: {object, bool} = {}
self._table_model: FitsFileTableModel
self._indent_level = 0
self._adu_values_known = False
# Load algorithm from preferences
algorithm = data_model.get_master_combine_method()
if algorithm == Constants.COMBINE_MEAN:
self.ui.combineMeanRB.setChecked(True)
elif algorithm == Constants.COMBINE_MEDIAN:
self.ui.combineMedianRB.setChecked(True)
elif algorithm == Constants.COMBINE_MINMAX:
self.ui.combineMinMaxRB.setChecked(True)
else:
assert (algorithm == Constants.COMBINE_SIGMA_CLIP)
self.ui.combineSigmaRB.setChecked(True)
self.ui.minMaxNumDropped.setText(
str(data_model.get_min_max_number_clipped_per_end()))
self.ui.sigmaThreshold.setText(
str(data_model.get_sigma_clip_threshold()))
# Load disposition from preferences
disposition = data_model.get_input_file_disposition()
if disposition == Constants.INPUT_DISPOSITION_SUBFOLDER:
self.ui.dispositionSubFolderRB.setChecked(True)
else:
assert (disposition == Constants.INPUT_DISPOSITION_NOTHING)
self.ui.dispositionNothingRB.setChecked(True)
self.ui.subFolderName.setText(
data_model.get_disposition_subfolder_name())
# Pre-calibration options
precalibration_option = data_model.get_precalibration_type()
if precalibration_option == Constants.CALIBRATION_FIXED_FILE:
self.ui.fixedPreCalFileRB.setChecked(True)
elif precalibration_option == Constants.CALIBRATION_NONE:
self.ui.noPreClalibrationRB.setChecked(True)
elif precalibration_option == Constants.CALIBRATION_AUTO_DIRECTORY:
self.ui.autoPreCalibrationRB.setChecked(True)
else:
assert precalibration_option == Constants.CALIBRATION_PEDESTAL
self.ui.fixedPedestalRB.setChecked(True)
self.ui.fixedPedestalAmount.setText(
str(data_model.get_precalibration_pedestal()))
self.ui.precalibrationPathDisplay.setText(
os.path.basename(data_model.get_precalibration_fixed_path()))
self.ui.autoDirectoryName.setText(
os.path.basename(data_model.get_precalibration_auto_directory()))
self.ui.autoRecursive.setChecked(
data_model.get_auto_directory_recursive())
self.ui.autoBiasOnly.setChecked(
data_model.get_auto_directory_bias_only())
self.ui.displayAutoResultsCB.setChecked(
data_model.get_display_auto_select_results())
# Grouping boxes and parameters
self.ui.groupBySizeCB.setChecked(data_model.get_group_by_size())
self.ui.groupByTemperatureCB.setChecked(
data_model.get_group_by_temperature())
self.ui.groupByFilterCB.setChecked(data_model.get_group_by_filter())
self.ui.ignoreSmallGroupsCB.setChecked(
data_model.get_ignore_groups_fewer_than())
self.ui.temperatureGroupBandwidth.setText(
f"{data_model.get_temperature_group_bandwidth()}")
self.ui.minimumGroupSize.setText(
str(data_model.get_minimum_group_size()))
# Display average ADUs
self.ui.displayAvgADUs.setChecked(
data_model.get_display_average_adus())
# Set up the file table
self._table_model = FitsFileTableModel(
self.ui.filesTable, data_model.get_ignore_file_type(),
preferences.get_display_average_adus())
self.ui.filesTable.setModel(self._table_model)
# Columns should resize to best fit their contents
self.ui.filesTable.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
# Write a summary, in the main tab, of the settings from the options tab (and data model)
self.fill_options_readout()
self.connect_responders()
# If a window size is saved, set the window size
window_size = self._preferences.get_main_window_size()
if window_size is not None:
self.ui.resize(window_size)
self.enable_fields()
self.enable_buttons()
def __init__(self, parent, signaux):
# Appel au constructeur de la classe mere
QtGui.QDialog.__init__(self, parent)
self.preferences = Preferences()
self.pluginManager = PluginManager()
self.signaux = signaux
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle(u"Préférences")
# Dimensions la fenetre
self.resize(280, 340)
# Mise en place de son icone
self.setWindowIcon(QtGui.QIcon("ico/gtk-preferences.svg"))
###
# Mise en place des widgets dans la fenetre
###
# Layout de grille principal
self.gridLayout = QtGui.QGridLayout(self)
# Font pour les titres
fontTitres = QtGui.QFont()
fontTitres.setPointSize(11)
fontTitres.setWeight(75)
fontTitres.setBold(True)
#
# Choix du repertoire telechargement
#
# Label
self.labelRepertoire = QtGui.QLabel(self)
self.labelRepertoire.setFont(fontTitres)
self.labelRepertoire.setText(u"Répertoire de téléchargement :")
# Repertoire de telechargement
self.lineEditRepertoireTelechargement = QtGui.QLineEdit(self)
# Bouton pour ouvrir la fenetre de selection de repertoire
self.pushButtonSelectionDossier = QtGui.QPushButton(self)
self.pushButtonSelectionDossier.setIcon(
QtGui.QIcon("ico/gtk-folder.svg"))
#
# Choix du plugin par defaut
#
# Label
self.labelPluginDefaut = QtGui.QLabel(self)
self.labelPluginDefaut.setFont(fontTitres)
self.labelPluginDefaut.setText(u"Plugin par défaut :")
# Liste de choix du plugin par defaut
self.comboBoxPluginDefaut = QtGui.QComboBox(self)
#
# Choix des plugins a activer
#
# Label
self.labelPlugins = QtGui.QLabel(self)
self.labelPlugins.setFont(fontTitres)
self.labelPlugins.setText("Plugins actifs :")
# Liste des plugins
self.listWidgetPlugin = QtGui.QListWidget(self)
#
# Choix des parametres Internet
#
# Label
self.labelInternet = QtGui.QLabel(self)
self.labelInternet.setFont(fontTitres)
self.labelInternet.setText(u"Paramètres Internet :")
# Layout formulaire
self.layoutInternet = QtGui.QFormLayout()
# SpinBox pour choisir le timeOut
self.spinBoxTimeOut = QtGui.QSpinBox()
self.spinBoxTimeOut.setMinimum(1)
self.spinBoxTimeOut.setMaximum(60)
self.layoutInternet.addRow(u"Time out (en s) :", self.spinBoxTimeOut)
# SpinBox pour choisir le nombre de threads max
self.spinBoxNbThread = QtGui.QSpinBox()
self.spinBoxNbThread.setMinimum(1)
self.spinBoxNbThread.setMaximum(100)
self.layoutInternet.addRow(u"Nombre de threads max :",
self.spinBoxNbThread)
# Bouton pour enregistrer/annuler les preferences
self.buttonBox = QtGui.QDialogButtonBox(self)
self.buttonBox.addButton("Enregistrer",
QtGui.QDialogButtonBox.AcceptRole)
self.buttonBox.addButton("Fermer", QtGui.QDialogButtonBox.RejectRole)
# On ajoute le tout au layout
self.gridLayout.addWidget(self.labelRepertoire, 0, 0, 1, 2)
self.gridLayout.addWidget(self.lineEditRepertoireTelechargement, 1, 0,
1, 1)
self.gridLayout.addWidget(self.pushButtonSelectionDossier, 1, 1, 1, 1)
self.gridLayout.addWidget(self.labelPluginDefaut, 2, 0, 1, 2)
self.gridLayout.addWidget(self.comboBoxPluginDefaut, 3, 0, 1, 2)
self.gridLayout.addWidget(self.labelPlugins, 4, 0, 1, 2)
self.gridLayout.addWidget(self.listWidgetPlugin, 5, 0, 1, 2)
self.gridLayout.addWidget(self.labelInternet, 6, 0, 1, 2)
self.gridLayout.addLayout(self.layoutInternet, 7, 0, 1, 2)
self.gridLayout.addWidget(self.buttonBox, 8, 0, 1, 2)
###
# Signaux provenants de l'interface
###
QtCore.QObject.connect(self.pushButtonSelectionDossier,
QtCore.SIGNAL("clicked()"),
self.afficherSelecteurDossier)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("accepted()"),
self.enregistrerPreferences)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("rejected()"),
self.reject)
class Controller(object):
"""description of class"""
def __init__(self):
self.prefs = Preferences()
self.db = SQLController()
self.load_skill_bp_into_prefs()
self.__ui_components = {}
self.__pc_roster = {}
self.__skill_shorts = {}
pc_filepaths = []
#pc_filepaths.append('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml')
pc_filepaths.append('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml')
self.load_pc_roster(pc_filepaths)
#print(str(self.__pc_roster['Toni']))
self.prepare_skill_shorts()
weapons = self.prefs.transfer_wpns_from_txt_to_sql()
wpn_table=self.db.table('wpn_blueprints')
skills = self.prefs.get_skills_dictionary()
skill_bp_table = self.db.table('skill_blueprints')
#self.__wpn_db = WeaponSqlController()
self.add_skills_bp_to_db(skills, skill_bp_table)
#print(weapons)
for weapon in weapons:
name = str(weapon.get_attribute('name'))
type = str(weapon.get_attribute('type'))
wa = str(weapon.get_attribute('wa'))
con = str(weapon.get_attribute('con'))
av = str(weapon.get_attribute('av'))
dmg = str(weapon.get_attribute('dmg'))
ammo = str(weapon.get_attribute('ammo'))
shts = str(weapon.get_attribute('shts'))
rof = str(weapon.get_attribute('rof'))
rel = str(weapon.get_attribute('rel'))
range = str(weapon.get_attribute('range'))
cost = str(weapon.get_attribute('cost'))
source = str(weapon.get_attribute('source'))
category = str(weapon.get_attribute('category'))
wpn_table.add_wpn(name, type, wa, con, av, dmg, ammo, shts, rof, rel, range, cost, category=category, source=source)
#wpn_table.print_table()
self.load_character('preferences/Rasmus_Shawn Everette Slow Curve Manning.xml')
self.db.add_character_to_database(self.c)
start = StartMenu(self)
#start = SkillShortsInspector(controller=self)
def add_skills_bp_to_db(self, skill_list, skill_table):
for key, value in skill_list.items():
name = value.get_attribute('name')
stat = value.get_attribute('stat')
short = value.get_attribute('short')
diff = value.get_attribute('diff')
category = value.get_attribute('category')
description = value.get_attribute('description')
chip = value.get_attribute('ischippable')
skill_table.add(name, stat, short, diff, category, chip, description)
def load_pc_roster(self, filepath_table):
for path in filepath_table:
c = Character(self.prefs)
self.prefs.load_character(path, c)
player = c.get_attribute('player')
self.__pc_roster[player] = c
#print(str(c))
def load_wpn_sql_table(self):
wpn = self.db.table('wpn_blueprints')
return wpn.query_all()
def load_single_sql_wpn(self, name):
wpn = self.db.table('wpn_blueprints')
return wpn.search_with_name(name)
def update_sql_wpn(self, name, type, wa, con, av, dmg, ammo, shts, rof, rel, range, cost, weight, flags, options, alt_munitions, description, category):
wpn_table = self.db.table('wpn_blueprints')
wpn_table.update_wpn(name, type, wa, con, av, dmg, ammo, shts, rof, rel, range, cost, weight, flags, options, alt_munitions, description, category)
def prepare_skill_shorts(self):
skills = self.prefs.get_skills_dictionary()
for key, value in skills.items():
try:
short = value.get_attribute('short')
name = value.get_attribute('name')
self.__skill_shorts[short] = name
except Exception:
pass
def get_skill_from_short(self, short):
try:
skill = self.__skill_shorts[short]
return skill
except Exception:
return 'error'
def get_pc_roster(self):
return self.__pc_roster
def load_character(self, filepath):
self.c = Character(self.prefs)
self.prefs.load_character(filepath,self.c)
def get_player_fuz_roll(self, player, detailed=False):
search_for = str.strip(player)
return self.__pc_roster[search_for].fuz_roll(detailed)
def set_char_stat(self, command, value):
self.c.set(command, value)
def destroy_char_attributes_of_type(self, type, attribute):
self.c.remove_all_attributes_of_type(type, attribute)
def add_skill_to_char(self, name, lvl, ip, chipped):
self.c.add_skill(name, lvl, ip=ip, chipped=chipped)
def get_slate_gameobject(self):
o = GameObject()
return o
def get_char_stat(self, name, attribute, search_category=False, return_all=False):
if search_category:
return self.c.get_stat(name, name, True, return_all)
return self.c.get_stat(name, attribute)
def get_char_attribute(self, name):
return self.c.get_attribute(name)
def get_char_stat_list(self, stat_type):
return self.c.get_stat_list(stat_type)
def get_char_inventory(self):
return self.c.get_inventory()
def get_char_bp_points(self, player, skill, detailed=False):
character = self.__pc_roster[player]
array = []
if detailed:
source_stat_name = character.get_stat(skill, 'stat')
source_stat_lvl = character.get_stat(source_stat_name, 'lvl')
skill_lvl = character.get_stat(skill, 'lvl')
array.append(source_stat_lvl)
array.append(skill_lvl)
return array
bp = character.get_bpoints(skill)
return bp
def add_ui_component(self, comp_name, component):
self.__ui_components[comp_name] = component
def save_to_xml(self, root_name, childname, values_dict, filepath):
x = XmlController()
x.create_root(root_name)
for key, value in values_dict.items():
x.create_sub_element(childname, 'root')
x.set_text(value, childname)
x.set_value('type',key, childname)
x.save_file(filepath)
def load_from_xml(self, filename, root_name):
x = XmlController()
x.load_file(filename)
return x.get_dataset(root_name, True, dict_tag_name='type')
def calc_dv_probabilities(self, bp, dv):
percent = self.prefs.get_probability(bp, dv)
return percent
def load_skill_bp_into_prefs(self):
skill_table = self.db.table('skill_blueprints')
skills = skill_table.query_all()
for skill in skills:
self.prefs.set_skill_blueprint(skill.name, skill.stat, skill.category, skill.description, skill.chip, skill.diff, skill.short)
def update_skill_bp_to_db(self):
skill_table = self.db.table('skill_blueprints')
for key, value in self.prefs.get_skills_dictionary().items():
name = value.get_attribute('name')
stat = value.get_attribute('stat')
short = value.get_attribute('short')
diff = value.get_attribute('diff')
category = value.get_attribute('category')
description = value.get_attribute('description')
chip = value.get_attribute('ischippable')
skill_table.update(name, stat, short, diff, category, chip, description)
def get_all_skill_blueprints(self):
skills_table = self.db.table('skill_blueprints')
return skills_table.query_all()
class MainWindow(QtGui.QMainWindow):
## Constructeur
# Le constructeur va creer la fenetre principale en y ajoutant tous les widgets necessaires au programme
def __init__(self):
# Appel au constructeur de la classe mere
QtGui.QMainWindow.__init__(self)
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle("TVDownloader")
# Mise en place de son icone
self.setWindowIcon(QtGui.QIcon("ico/TVDownloader.png"))
###
# Mise en place des widgets dans la fenetre
###
# Widget central qui contiendra tout
self.centralWidget = QtGui.QWidget(self)
#
# Barre du haut
#
# Layout horizontal qui contiendra les listes deroulantes
self.horizontalLayoutBarreHaut = QtGui.QHBoxLayout()
# Liste deroulante pour choisir le site (plugin)
self.comboBoxSite = QtGui.QComboBox(self.centralWidget)
self.horizontalLayoutBarreHaut.addWidget(self.comboBoxSite)
# Liste deroulante pour choisir une chaine du site courant
self.comboBoxChaine = QtGui.QComboBox(self.centralWidget)
self.horizontalLayoutBarreHaut.addWidget(self.comboBoxChaine)
# Liste deroulante pour choisir une emission de la chaine courante
self.comboBoxEmission = QtGui.QComboBox(self.centralWidget)
self.horizontalLayoutBarreHaut.addWidget(self.comboBoxEmission)
#
# Onglets
#
# Gestionnaire onglets
self.tabWidget = QtGui.QTabWidget(self.centralWidget)
# Onglet Fichiers
self.tabFichiers = QtGui.QSplitter(
self.centralWidget) # L'onglet Fichier contient un splitter
self.tabWidget.addTab(self.tabFichiers, u"Choix des fichiers")
# Onglet Telechargements
self.tabTelechargements = QtGui.QWidget(self.centralWidget)
self.tabWidget.addTab(self.tabTelechargements, u"Téléchargements")
#
# Liste des fichiers
#
# Layout de grille qui contient le tableau qui liste les fichiers + boutons
self.gridLayoutFichiers = QtGui.QGridLayout(self.tabFichiers)
# Tableau qui contient la liste des fichiers disponibles pour l'emission courante
self.tableWidgetFichier = MyQTableWidget(self.tabFichiers)
# Il a 4 colonnes et 0 ligne (pour l'instant)
self.tableWidgetFichier.setColumnCount(3)
self.tableWidgetFichier.setRowCount(0)
# On ajoute les titres
self.tableWidgetFichier.setHorizontalHeaderItem(
0, self.tableWidgetFichier.creerItem(""))
self.tableWidgetFichier.setHorizontalHeaderItem(
1, self.tableWidgetFichier.creerItem("Date"))
self.tableWidgetFichier.setHorizontalHeaderItem(
2, self.tableWidgetFichier.creerItem("Emission"))
# On l'ajoute au layout
self.gridLayoutFichiers.addWidget(self.tableWidgetFichier, 0, 1, 6, 1)
# Icones du tableWidget
self.iconeFichier = QtGui.QIcon("ico/gtk-file.svg")
self.iconeAjoute = QtGui.QIcon("ico/gtk-add.svg")
self.iconeTelecharge = QtGui.QIcon("ico/gtk-apply.svg")
# Bouton pour ajouter tous les fichiers a la liste des telechargements
self.pushButtonToutAjouter = MyQPushButton(self.tabFichiers)
self.pushButtonToutAjouter.setIcon(QtGui.QIcon("ico/gtk-add.svg"))
self.pushButtonToutAjouter.setToolTip(
u"Ajouter tous les fichiers à la liste des téléchargements")
self.gridLayoutFichiers.addWidget(self.pushButtonToutAjouter, 0, 0, 2,
1)
# Bouton pour rafraichir le plugin courant
self.pushButtonRafraichirPlugin = MyQPushButton(self.tabFichiers)
self.pushButtonRafraichirPlugin.setIcon(
QtGui.QIcon("ico/gtk-refresh.svg"))
self.pushButtonRafraichirPlugin.setToolTip("Rafraichir le plugin")
self.gridLayoutFichiers.addWidget(self.pushButtonRafraichirPlugin, 2,
0, 2, 1)
# Bouton pour ouvrir la fenetre des preferences du plugin courant
self.pushButtonPreferencesPlugin = MyQPushButton(self.tabFichiers)
self.pushButtonPreferencesPlugin.setIcon(
QtGui.QIcon("ico/gtk-preferences.svg"))
self.pushButtonPreferencesPlugin.setToolTip(
u"Ouvrir les préférences du plugin")
self.gridLayoutFichiers.addWidget(self.pushButtonPreferencesPlugin, 4,
0, 2, 1)
# On met en place ce layout sur un widget (pour le splitter)
self.widgetFichiers = QtGui.QWidget()
self.widgetFichiers.setLayout(self.gridLayoutFichiers)
#
# Descriptif des fichiers
#
# Layout de grille
self.gridLayoutDescriptif = QtGui.QGridLayout()
# Label pour afficher un logo
self.logoFichierDefaut = QtGui.QPixmap()
self.logoFichierDefaut.load("img/gtk-dialog-question.svg")
self.labelLogo = QtGui.QLabel(self.centralWidget)
self.labelLogo.setPixmap(
self.logoFichierDefaut.scaled(QtCore.QSize(150, 150),
QtCore.Qt.KeepAspectRatio))
self.gridLayoutDescriptif.addWidget(self.labelLogo, 0, 0, 1, 1)
# Zone de texte pour afficher un descriptif
self.plainTextEdit = QtGui.QPlainTextEdit(self.centralWidget)
self.gridLayoutDescriptif.addWidget(self.plainTextEdit, 0, 1, 1, 2)
# On met en place ce layout sur un widget (pour le splitter)
self.widgetDescriptif = QtGui.QWidget()
self.widgetDescriptif.setLayout(self.gridLayoutDescriptif)
# Onrientation verticale du splitter
self.tabFichiers.setOrientation(QtCore.Qt.Vertical)
# On ajoute les 2 elements au splitter (qui est notre onglet)
self.tabFichiers.addWidget(self.widgetFichiers)
self.tabFichiers.addWidget(self.widgetDescriptif)
#
# Liste des telechargements
#
# Layout de grille qui contient le tableau qui liste les fichiers a telecharger + les boutons pour le controller
self.gridLayoutTelechargement = QtGui.QGridLayout(
self.tabTelechargements)
# Tableau qui contient la liste des fichiers a telecharger
self.tableWidgetTelechargement = MyQTableWidget(
self.tabTelechargements)
# Il a 5 colonnes et 0 ligne (pour l'instant)
self.tableWidgetTelechargement.setColumnCount(3)
self.tableWidgetTelechargement.setRowCount(0)
# On ajoute le titre des 5 colonnes
self.tableWidgetTelechargement.setHorizontalHeaderItem(
0, self.tableWidgetTelechargement.creerItem("Date"))
self.tableWidgetTelechargement.setHorizontalHeaderItem(
1, self.tableWidgetTelechargement.creerItem("Emission"))
self.tableWidgetTelechargement.setHorizontalHeaderItem(
2, self.tableWidgetTelechargement.creerItem("Etat"))
# On l'ajoute au layout
self.gridLayoutTelechargement.addWidget(self.tableWidgetTelechargement,
0, 1, 4, 1)
# Bouton pour monter l'element selectionne tout en haut de la liste
self.pushButtonExtremiteMonter = MyQPushButton(self.tabTelechargements)
self.pushButtonExtremiteMonter.setIcon(
QtGui.QIcon("ico/gtk-jump-to-rtl.svg"))
self.pushButtonExtremiteMonter.setToolTip(
u"Placer l'élément sélectionné tout en haut")
self.gridLayoutTelechargement.addWidget(self.pushButtonExtremiteMonter,
0, 0, 1, 1)
# Bouton pour monter l'element selectionne d'un cran dans la liste
self.pushButtonMonter = MyQPushButton(self.tabTelechargements)
self.pushButtonMonter.setIcon(QtGui.QIcon("ico/gtk-go-up.svg"))
self.pushButtonMonter.setToolTip(u"Monter l'élément sélectionné")
self.gridLayoutTelechargement.addWidget(self.pushButtonMonter, 1, 0, 1,
1)
# Bouton pour descendre l'element selectionne d'un cran dans la liste
self.pushButtonDescendre = MyQPushButton(self.tabTelechargements)
self.pushButtonDescendre.setIcon(QtGui.QIcon("ico/gtk-go-down.svg"))
self.pushButtonDescendre.setToolTip(u"Descendre l'élément selectionné")
self.gridLayoutTelechargement.addWidget(self.pushButtonDescendre, 2, 0,
1, 1)
# Bouton pour descendre l'element selectionne tout en bas de la liste
self.pushButtonExtremiteDescendre = MyQPushButton(
self.tabTelechargements)
self.pushButtonExtremiteDescendre.setIcon(
QtGui.QIcon("ico/gtk-jump-to-ltr.svg"))
self.pushButtonExtremiteDescendre.setToolTip(
u"Placer l'élément sélectionné tout en bas")
self.gridLayoutTelechargement.addWidget(
self.pushButtonExtremiteDescendre, 3, 0, 1, 1)
# Bouton pour supprimer tous les elements de la liste
self.pushButtonToutSupprimer = MyQPushButton(self.tabTelechargements)
self.pushButtonToutSupprimer.setIcon(QtGui.QIcon("ico/gtk-cancel.svg"))
self.pushButtonToutSupprimer.setToolTip(
u"Supprimer tous les téléchargements")
self.gridLayoutTelechargement.addWidget(self.pushButtonToutSupprimer,
0, 2, 1, 1)
# Bouton pour supprimer de la liste les telechargements termines
self.pushButtonNettoyer = MyQPushButton(self.tabTelechargements)
self.pushButtonNettoyer.setIcon(QtGui.QIcon("ico/gtk-delete-full.svg"))
self.pushButtonNettoyer.setToolTip(
u"Supprimer les téléchargement terminés")
self.gridLayoutTelechargement.addWidget(self.pushButtonNettoyer, 1, 2,
1, 1)
# Bouton pour ouvrir le dossier des telechargements
self.pushButtonOuvrirDossierTelechargement = MyQPushButton(
self.tabTelechargements)
self.pushButtonOuvrirDossierTelechargement.setIcon(
QtGui.QIcon("ico/gtk-folder.svg"))
self.pushButtonOuvrirDossierTelechargement.setToolTip(
u"Ouvrir le dossier des téléchargements")
self.gridLayoutTelechargement.addWidget(
self.pushButtonOuvrirDossierTelechargement, 2, 2, 1, 1)
#
# Barre progression de telechargement d'un fichier
#
self.progressBarTelechargementFichier = QtGui.QProgressBar(
self.centralWidget)
self.progressBarTelechargementFichier.setProperty("value", 0)
#
# Barre de progression de telechargement des fichiers
#
self.progressBarTelechargement = QtGui.QProgressBar(self.centralWidget)
self.progressBarTelechargement.setProperty("value", 0)
#
# Boutons du bas pour gerer ajouter/supprimer/lancer telechargements
#
# Layout horizontal qui contiendra les boutons
self.horizontalLayoutBarreBas = QtGui.QHBoxLayout()
# Bouton pour lancer les telechargements
self.pushButtonLancer = QtGui.QPushButton(
QtGui.QIcon("ico/gtk-media-play-ltr.svg"),
u"Lancer téléchargement", self.centralWidget)
self.horizontalLayoutBarreBas.addWidget(self.pushButtonLancer)
# Bouton pour stopper les telechargements
self.pushButtonStop = QtGui.QPushButton(
QtGui.QIcon("ico/gtk-media-stop.svg"),
u"Stopper le téléchargement", self.centralWidget)
self.pushButtonStop.setEnabled(False)
self.horizontalLayoutBarreBas.addWidget(self.pushButtonStop)
###
# Positionnement des differents widgets/layouts sur le layout de grille
###
# Layout de grille dans lequel on va placer nos widgets/layouts
self.gridLayout = QtGui.QGridLayout(self.centralWidget)
# On ajoute la barre du haut
self.gridLayout.addLayout(self.horizontalLayoutBarreHaut, 0, 0, 1, 3)
# On ajoute le gestionnaire d'onglets
self.gridLayout.addWidget(self.tabWidget, 1, 0, 1, 3)
# On ajoute la barre de progression de telechargement d'un fichier
self.gridLayout.addWidget(self.progressBarTelechargementFichier, 2, 0,
1, 3)
# On ajoute la barre de progression de telechargement des fichiers
self.gridLayout.addWidget(self.progressBarTelechargement, 3, 0, 1, 3)
# On ajoute les boutons ajouter/supprimer/lancer
self.gridLayout.addLayout(self.horizontalLayoutBarreBas, 4, 0, 1, 3)
###
# Mise en place le central widget dans la fenetre
###
self.setCentralWidget(self.centralWidget)
###
# Mise en place du menu
###
# Menu barre
self.menubar = QtGui.QMenuBar(self)
self.menubar.setGeometry(QtCore.QRect(0, 0, 480, 25))
# Menu Fichier
self.menuFichier = QtGui.QMenu("&Fichier", self.menubar)
self.menubar.addAction(self.menuFichier.menuAction())
# Action Fichier -> Quitter
self.actionQuitter = QtGui.QAction(QtGui.QIcon("ico/gtk-quit.svg"),
"&Quitter", self)
self.actionQuitter.setIconVisibleInMenu(True)
self.menuFichier.addAction(self.actionQuitter)
# Menu Edition
self.menuEdition = QtGui.QMenu("&Edition", self.menubar)
self.menubar.addAction(self.menuEdition.menuAction())
# Action Edition -> Mise a jour
self.actionMAJ = QtGui.QAction(QtGui.QIcon("ico/gtk-refresh.svg"),
u"&Mise à jour des plugins", self)
self.actionMAJ.setIconVisibleInMenu(True)
self.menuEdition.addAction(self.actionMAJ)
# Action Edition -> Preferences
self.actionPreferences = QtGui.QAction(
QtGui.QIcon("ico/gtk-preferences.svg"), u"&Préférences", self)
self.actionPreferences.setIconVisibleInMenu(True)
self.menuEdition.addAction(self.actionPreferences)
# Menu Aide
self.menuAide = QtGui.QMenu("&Aide", self.menubar)
self.menubar.addAction(self.menuAide.menuAction())
# Action Aide -> A propos
self.actionAPropos = QtGui.QAction(QtGui.QIcon("ico/gtk-about.svg"),
u"À p&ropos", self)
self.actionAPropos.setIconVisibleInMenu(True)
self.menuAide.addAction(self.actionAPropos)
# Ajout du menu a l'interface
self.setMenuBar(self.menubar)
###
# Signaux provenants de l'interface
###
QtCore.QObject.connect(self.tableWidgetFichier,
QtCore.SIGNAL("cellClicked(int,int)"),
self.afficherInformationsFichier)
QtCore.QObject.connect(self.tableWidgetFichier,
QtCore.SIGNAL("cellDoubleClicked(int,int)"),
self.gererTelechargement)
QtCore.QObject.connect(self.pushButtonToutAjouter,
QtCore.SIGNAL("clicked()"),
self.ajouterTousLesFichiers)
QtCore.QObject.connect(self.pushButtonRafraichirPlugin,
QtCore.SIGNAL("clicked()"),
self.rafraichirPlugin)
QtCore.QObject.connect(self.tableWidgetTelechargement,
QtCore.SIGNAL("cellDoubleClicked(int,int)"),
self.supprimerTelechargement)
QtCore.QObject.connect(
self.pushButtonExtremiteMonter,
QtCore.SIGNAL("clicked()"),
lambda versLeHaut=True, extremite=True: self.
tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite))
QtCore.QObject.connect(
self.pushButtonMonter,
QtCore.SIGNAL("clicked()"),
lambda versLeHaut=True, extremite=False: self.
tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite))
QtCore.QObject.connect(
self.pushButtonDescendre,
QtCore.SIGNAL("clicked()"),
lambda versLeHaut=False, extremite=False: self.
tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite))
QtCore.QObject.connect(
self.pushButtonExtremiteDescendre,
QtCore.SIGNAL("clicked()"),
lambda versLeHaut=False, extremite=True: self.
tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite))
QtCore.QObject.connect(self.pushButtonToutSupprimer,
QtCore.SIGNAL("clicked()"),
self.supprimerTousLesTelechargements)
QtCore.QObject.connect(self.pushButtonNettoyer,
QtCore.SIGNAL("clicked()"), self.nettoyer)
QtCore.QObject.connect(self.pushButtonLancer,
QtCore.SIGNAL("clicked()"),
self.lancerTelechargement)
QtCore.QObject.connect(self.pushButtonStop, QtCore.SIGNAL("clicked()"),
self.stopperTelechargement)
QtCore.QObject.connect(self.actionQuitter,
QtCore.SIGNAL("triggered()"), self.close)
################################################
# Instanciations + initialisation de variables #
################################################
# Fenetre About
self.aProposDialog = None
# Fenetre des preferences du logiciel
self.preferencesDialog = None
# Fenetre de mise a jour des plugins
self.updateManagerDialog = None
# Nom plugin courant
self.nomPluginCourant = ""
# Liste des fichiers
self.listeFichiers = []
# Liste des fichiers a telecharger
self.listeFichiersATelecharger = []
# Cache des images descriptive
# Clef : urlImage Valeur : image (binaire)
self.cacheImage = {}
# On intancie le lanceur de signaux
self.signaux = Signaux()
# On instancie le gestionnaire de preferences
self.preferences = Preferences()
# On instancie le gestionnaire de preferences des plugins
self.preferencesPluginDialog = PreferencePluginDialog(self)
# On instancie le gestionnaire de download
self.downloader = Downloader(self.signaux)
# On recupere l'instance de API
self.api = API.getInstance()
# On instancie le gestionnaire d'historique
self.historique = Historique()
# On instancie la fenetre d'attente
self.fenetreAttenteProgressDialog = FenetreAttenteProgressDialog(self)
# On instancie le gest
#
# Fenetre de confirmation pour quitter le logiciel
#
self.quitterMessageBox = QtGui.QMessageBox(self)
self.quitterMessageBox.setWindowTitle("Fermeture de TVDownloader")
self.quitterMessageBox.setText(
u"Voulez-vous réellement quitter TVDownloader ?")
self.quitterMessageBox.setInformativeText(
u"Votre liste de téléchargement sera perdue")
self.quitterMessageBox.addButton("Oui", QtGui.QMessageBox.AcceptRole)
self.quitterMessageBox.addButton("Non", QtGui.QMessageBox.RejectRole)
############################################################
# On connecte les signaux des instances precedements crees #
############################################################
QtCore.QObject.connect(self.pushButtonOuvrirDossierTelechargement,
QtCore.SIGNAL("clicked()"),
self.ouvrirRepertoireTelechargement)
QtCore.QObject.connect(self.comboBoxSite,
QtCore.SIGNAL("activated(QString)"),
self.listerChaines)
QtCore.QObject.connect(self.comboBoxChaine,
QtCore.SIGNAL("activated(QString)"),
self.listerEmissions)
QtCore.QObject.connect(self.comboBoxEmission,
QtCore.SIGNAL("activated(QString)"),
self.listerFichiers)
QtCore.QObject.connect(self.pushButtonPreferencesPlugin,
QtCore.SIGNAL("clicked()"),
self.ouvrirPreferencesPlugin)
QtCore.QObject.connect(self.actionPreferences,
QtCore.SIGNAL("triggered()"),
self.ouvrirPreferencesLogiciel)
QtCore.QObject.connect(self.actionMAJ, QtCore.SIGNAL("triggered()"),
self.ouvrirFenetreMiseAJour)
QtCore.QObject.connect(self.actionAPropos,
QtCore.SIGNAL("triggered()"),
self.ouvrirFenetreAPropos)
QtCore.QObject.connect(
self.signaux, QtCore.SIGNAL("debutActualisation(PyQt_PyObject)"),
self.fenetreAttenteProgressDialog.ouvrirFenetreAttente)
QtCore.QObject.connect(
self.signaux, QtCore.SIGNAL("finActualisation()"),
self.fenetreAttenteProgressDialog.fermerFenetreAttente)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("actualiserListesDeroulantes()"),
self.actualiserListesDeroulantes)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("listeChaines(PyQt_PyObject)"),
self.ajouterChaines)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("listeEmissions(PyQt_PyObject)"),
self.ajouterEmissions)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("listeFichiers(PyQt_PyObject)"),
self.ajouterFichiers)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("nouvelleImage(PyQt_PyObject)"),
self.mettreEnPlaceImage)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("debutTelechargement(int)"),
self.debutTelechargement)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("finTelechargement(int)"),
self.finTelechargement)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("finDesTelechargements()"),
self.activerDesactiverInterface)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("pourcentageFichier(int)"),
self.progressBarTelechargementFichier.setValue)
#########
# Début #
#########
# La fenetre prend la dimension qu'elle avait a sa fermeture
taille = self.preferences.getPreference("tailleFenetre")
self.resize(taille[0], taille[1])
# Si aucun plugin n'est active, on ouvre la fenetre des preferences
if (len(self.preferences.getPreference("pluginsActifs")) == 0):
self.ouvrirPreferencesLogiciel()
# On actualise tous les plugins
self.rafraichirTousLesPlugins()
## Methode qui execute les actions necessaires avant de quitter le programme
def actionsAvantQuitter(self):
# On sauvegarde les options des plugins
self.api.fermeture()
# On sauvegarde la taille de la fenetre
taille = self.size()
self.preferences.setPreference(
"tailleFenetre", [taille.width(), taille.height()])
# On sauvegarde les options du logiciel
self.preferences.sauvegarderConfiguration()
# On sauvegarde l'historique
self.historique.sauverHistorique()
# On stoppe les telechargements
self.stopperTelechargement()
#########################################
# Surcharge des methodes de QMainWindow #
#########################################
## Surcharge de la methode appelee lors de la fermeture de la fenetre
# Ne doit pas etre appele explicitement
# @param evenement Evenement qui a provoque la fermeture
def closeEvent(self, evenement):
# On affiche une fenetre pour demander la fermeture si des fichiers sont dans la liste de telechargement
if (self.tableWidgetTelechargement.rowCount() > 0):
# On affiche une fenetre qui demande si on veut quitter
retour = self.quitterMessageBox.exec_()
# Si on veut quitter
if (retour == 0):
# On execute les actions necessaires
self.actionsAvantQuitter()
# On accept la fermeture
evenement.accept()
else:
# On refuse la fermeture
evenement.ignore()
else: # S'il n'y a pas de fichier
# On execute les actions necessaires
self.actionsAvantQuitter()
# On accept la fermeture
evenement.accept()
##############################################
# Methodes pour remplir les menus deroulants #
##############################################
## Methode qui actualise les listes deroulantes
def actualiserListesDeroulantes(self):
# On lance juste l'ajout des sites en se basant sur les plugins actifs
self.ajouterSites(self.preferences.getPreference("pluginsActifs"))
## Methode qui lance le listage des chaines
# @param site Nom du plugin/site pour lequel on va lister les chaines
def listerChaines(self, site):
def threadListerChaines(self, nomPlugin):
self.signaux.signal("debutActualisation", nomPlugin)
listeChaines = self.api.getPluginListeChaines(nomPlugin)
self.signaux.signal("listeChaines", listeChaines)
self.signaux.signal("finActualisation")
if (site != ""):
self.nomPluginCourant = qstringToString(site)
threading.Thread(target=threadListerChaines,
args=(self, self.nomPluginCourant)).start()
# On active (ou pas) le bouton de preference du plugin
self.pushButtonPreferencesPlugin.setEnabled(
self.api.getPluginListeOptions(self.nomPluginCourant) != [])
## Methode qui lance le listage des emissions
# @param chaine Nom de la chaine pour laquelle on va lister les emissions
def listerEmissions(self, chaine):
def threadListerEmissions(self, nomPlugin, chaine):
self.signaux.signal("debutActualisation", nomPlugin)
listeEmissions = self.api.getPluginListeEmissions(
nomPlugin, chaine)
self.signaux.signal("listeEmissions", listeEmissions)
self.signaux.signal("finActualisation")
if (chaine != ""):
threading.Thread(target=threadListerEmissions,
args=(self, self.nomPluginCourant,
qstringToString(chaine))).start()
## Methode qui lance le listage des fichiers
# @param emission Nom de l'emission pour laquelle on va lister les fichiers
def listerFichiers(self, emission):
def threadListerFichiers(self, nomPlugin, emission):
self.signaux.signal("debutActualisation", nomPlugin)
listeFichiers = self.api.getPluginListeFichiers(
nomPlugin, emission)
self.signaux.signal("listeFichiers", listeFichiers)
self.signaux.signal("finActualisation")
if (emission != ""):
threading.Thread(target=threadListerFichiers,
args=(self, self.nomPluginCourant,
qstringToString(emission))).start()
## Methode qui met en place une liste de sites sur l'interface
# @param listeSites Liste des sites a mettre en place
def ajouterSites(self, listeSites):
# On efface la liste des sites
self.comboBoxSite.clear()
# On met en place les sites
for site in listeSites:
self.comboBoxSite.addItem(stringToQstring(site))
# On selectionne par defaut celui choisis dans les preference
index = self.comboBoxSite.findText(
stringToQstring(self.preferences.getPreference("pluginParDefaut")))
if (index != -1):
self.comboBoxSite.setCurrentIndex(index)
# On lance l'ajout des chaines
self.listerChaines(self.comboBoxSite.currentText())
## Methode qui met en place une liste de chaines sur l'interface
# @param listeChaines Liste des chaines a mettre en place
def ajouterChaines(self, listeChaines):
# On trie la liste des chaines
listeChaines.sort()
# On efface la liste des chaines
self.comboBoxChaine.clear()
# On efface la liste des emissions
self.comboBoxEmission.clear()
# On efface la liste des fichiers
self.tableWidgetFichier.toutSupprimer()
# On met en place les chaines
for chaine in listeChaines:
self.comboBoxChaine.addItem(stringToQstring(chaine))
# Si on a juste une seule chaine
if (self.comboBoxChaine.count() == 1):
# On lance l'ajout des emissions
self.listerEmissions(self.comboBoxChaine.currentText())
else:
# On ne selectionne pas de chaine
self.comboBoxChaine.setCurrentIndex(-1)
## Methode qui met en place une liste d'emissions sur l'interface
# @param listeEmissions Liste des emissions a mettre en place
def ajouterEmissions(self, listeEmissions):
# On trie la liste des emissions
listeEmissions.sort()
# On efface la liste des emissions
self.comboBoxEmission.clear()
# On efface la liste des fichiers
self.tableWidgetFichier.toutSupprimer()
# On met en place la liste des emissions
for emission in listeEmissions:
self.comboBoxEmission.addItem(stringToQstring(emission))
# Si on a juste une seule emission
if (self.comboBoxEmission.count() == 1):
# On lance l'ajout des fichiers
self.listerFichiers(self.comboBoxEmission.currentText())
else:
# On ne selectionne pas d'emission
self.comboBoxEmission.setCurrentIndex(-1)
###############################################
# Methodes pour remplir la liste des fichiers #
###############################################
## Methode pour ajouter des fichiers a l'interface
# @param listeFichiers Liste des fichiers a ajouter
def ajouterFichiers(self, listeFichiers):
self.listeFichiers = listeFichiers
# On efface la liste des fichiers
self.tableWidgetFichier.toutSupprimer()
# On commence au depart
ligneCourante = 0
# On met en place chacun des fichiers
for fichier in listeFichiers:
# On ajoute une ligne
self.tableWidgetFichier.insertRow(ligneCourante)
# On ajoute les informations au tableWidgetFichier
liste = []
liste.append(self.tableWidgetFichier.creerItem(""))
liste.append(
self.tableWidgetFichier.creerItem(getattr(fichier, "date")))
liste.append(
self.tableWidgetFichier.creerItem(getattr(fichier, "nom")))
self.tableWidgetFichier.setLigne(ligneCourante, liste)
# On met en place l'icone qui va bien
self.gererIconeListeFichier(fichier)
ligneCourante += 1
# On adapte la taille des colonnes
self.tableWidgetFichier.adapterColonnes()
## Methode qui rafraichit le plugin courant
def rafraichirPlugin(self):
def threadRafraichirPlugin(self, nomPlugin):
self.signaux.signal("debutActualisation", nomPlugin)
self.api.pluginRafraichir(nomPlugin)
self.signaux.signal("finActualisation")
threading.Thread(target=threadRafraichirPlugin,
args=(self, self.nomPluginCourant)).start()
## Methode qui met en place l'image de la description d'un fichier
# @param image Image a mettre en place (binaire)
def mettreEnPlaceImage(self, image):
logoFichier = QtGui.QPixmap()
logoFichier.loadFromData(image)
self.labelLogo.setPixmap(
logoFichier.scaled(QtCore.QSize(150, 150),
QtCore.Qt.KeepAspectRatio))
## Methode qui affiche des informations sur le fichier selectionne
def afficherInformationsFichier(self, ligne, colonne):
def threadRecupererImage(self, urlImage):
image = self.api.getPage(urlImage)
self.cacheImage[urlImage] = image
self.signaux.signal("nouvelleImage", image)
fichier = self.listeFichiers[ligne]
# On recupere le lien de l'image et le texte descriptif
urlImage = getattr(fichier, "urlImage")
texteDescriptif = getattr(fichier, "descriptif")
self.plainTextEdit.clear()
# Si on a un texte descriptif, on l'affiche
if (texteDescriptif != ""):
self.plainTextEdit.appendPlainText(
stringToQstring(texteDescriptif))
else:
self.plainTextEdit.appendPlainText(
u"Aucune information disponible")
# Si on n'a pas d'image
if (urlImage == ""):
# On met en place celle par defaut
self.logoFichier = self.logoFichierDefaut
self.labelLogo.setPixmap(
self.logoFichier.scaled(QtCore.QSize(150, 150),
QtCore.Qt.KeepAspectRatio))
else: # Si on en a une
# Si elle est dans le cache des images
if (self.cacheImage.has_key(urlImage)):
self.mettreEnPlaceImage(self.cacheImage[urlImage])
else: # Sinon
# On lance le thread pour la recuperer
threading.Thread(target=threadRecupererImage,
args=(self, urlImage)).start()
## Methode qui gere l'icone d'un fichier dans la liste des telechargements
# Il y a 3 icones possible :
# - C'est un fichier
# - C'est un fichier present dans l'historique (donc deja telecharge)
# - C'est un fichier present dans la liste des telechargements
# @param fichier Fichier a gerer
def gererIconeListeFichier(self, fichier):
if (fichier in self.listeFichiers):
ligneFichier = self.listeFichiers.index(fichier)
# On cherche quel icone mettre en place
if (fichier in self.listeFichiersATelecharger):
icone = self.iconeAjoute
elif (self.historique.comparerHistorique(fichier)):
icone = self.iconeTelecharge
else:
icone = self.iconeFichier
# On met en place l'icone
self.tableWidgetFichier.item(ligneFichier, 0).setIcon(icone)
######################################################
# Methodes pour remplir la liste des telechargements #
######################################################
## Methode qui gere la liste des telechargements
# @param ligne Numero de la ligne (dans la liste des fichiers) de l'element a ajouter
# @param colonne Numero de colonne (inutile, juste pour le slot)
def gererTelechargement(self, ligne, colonne=0):
fichier = self.listeFichiers[ligne]
# Si le fichier est deja dans la liste des telechargements
if (fichier in self.listeFichiersATelecharger):
ligneTelechargement = self.listeFichiersATelecharger.index(fichier)
self.supprimerTelechargement(ligneTelechargement)
else: # S'il n'y est pas, on l'ajoute
self.listeFichiersATelecharger.append(fichier)
numLigne = self.tableWidgetTelechargement.rowCount()
# On insere une nouvelle ligne dans la liste des telechargements
self.tableWidgetTelechargement.insertRow(numLigne)
# On y insere les elements qui vont biens
self.tableWidgetTelechargement.setLigne(numLigne, [
self.tableWidgetTelechargement.creerItem(
getattr(fichier, "date")),
self.tableWidgetTelechargement.creerItem(
getattr(fichier, "nom")),
self.tableWidgetTelechargement.creerItem(
u"En attente de téléchargement")
])
# On adapte la taille des colonnes
self.tableWidgetTelechargement.adapterColonnes()
# On modifie l'icone dans la liste des fichiers
self.gererIconeListeFichier(fichier)
## Methode qui ajoute tous les fichiers a la liste des telechargements
def ajouterTousLesFichiers(self):
for i in range(self.tableWidgetFichier.rowCount()):
self.gererTelechargement(i)
## Methode qui supprime un fichier de la liste des telechargements
# @param ligne Numero de la ligne a supprimer
# @param colonne Numero de colonne (inutile, juste pour le slot)
def supprimerTelechargement(self, ligne, colonne=0):
fichier = self.listeFichiersATelecharger[ligne]
# On supprime l'element du tableWidgetTelechargement
self.tableWidgetTelechargement.removeRow(ligne)
# On supprime l'element de la liste des fichiers a telecharger
self.listeFichiersATelecharger.remove(fichier)
# On modifie l'icone dans la liste des fichiers
self.gererIconeListeFichier(fichier)
## Methode qui supprime tous les telechargement de la liste des telechargements
def supprimerTousLesTelechargements(self):
for i in range(self.tableWidgetTelechargement.rowCount() - 1, -1, -1):
self.supprimerTelechargement(i)
## Methode qui lance le telechargement des fichiers
def lancerTelechargement(self):
# On liste les emissions a telecharger avec leurs numeros de ligne
listeFichiers = []
for i in range(self.tableWidgetTelechargement.rowCount()
): # Pour chaque ligne
fichier = self.listeFichiersATelecharger[i]
listeFichiers.append([
i,
getattr(fichier, "lien"),
getattr(fichier, "nomFichierSortie")
])
nbATelecharger = len(listeFichiers)
# Si on a des elements a charger
if (nbATelecharger > 0):
# On met en place la valeur du progressBar
self.progressBarTelechargement.setMaximum(nbATelecharger)
self.progressBarTelechargement.setValue(0)
# On lance le telechargement
threading.Thread(target=self.downloader.lancerTelechargement,
args=(listeFichiers, )).start()
# On active/desactive ce qui va bien sur l'interface
self.activerDesactiverInterface(True)
## Methode qui stoppe le telechargement
def stopperTelechargement(self):
# On stoppe le telechargement
self.downloader.stopperTelechargement()
############################################
# Methodes pour ouvrir les autres fenetres #
############################################
#
# Fenetre About
#
## Methode pour afficher la fenetre About
def ouvrirFenetreAPropos(self):
if (self.aProposDialog == None):
self.aProposDialog = AProposDialog()
self.aProposDialog.show()
#
# Fenetre de preference du logiciel
#
## Methode pour ouvrir les preferences du logiciel
def ouvrirPreferencesLogiciel(self):
if (self.preferencesDialog == None):
self.preferencesDialog = PreferencesDialog(self, self.signaux)
self.preferencesDialog.afficher()
#
# Fenetre de mise a jour des plugins
#
## Methode pour ouvrir la fenetre de mise a jour des plugins
def ouvrirFenetreMiseAJour(self):
if (self.updateManagerDialog == None):
self.updateManagerDialog = UpdateManagerDialog(self)
self.updateManagerDialog.afficher()
#
# Fenetre de preference des plugins
#
## Methode pour ouvrir les preferences du plugin courant
def ouvrirPreferencesPlugin(self):
listeOptions = self.api.getPluginListeOptions(self.nomPluginCourant)
self.preferencesPluginDialog.ouvrirDialogPreferences(
self.nomPluginCourant, listeOptions)
#########
# Slots #
#########
## Methode qui ouvre le repertoire de telechargement
def ouvrirRepertoireTelechargement(self):
QtGui.QDesktopServices.openUrl(
QtCore.QUrl.fromLocalFile(
self.preferences.getPreference("repertoireTelechargement")))
## Methode qui rafraichit le plugin courant
def rafraichirPlugin(self):
def threadRafraichirPlugin(self, nomPlugin):
self.signaux.signal("debutActualisation", nomPlugin)
self.api.pluginRafraichir(nomPlugin)
self.signaux.signal("finActualisation")
threading.Thread(target=threadRafraichirPlugin,
args=(self, self.nomPluginCourant)).start()
## Methode qui rafraichit tous les plugins
# A utiliser au lancement du programme
def rafraichirTousLesPlugins(self):
def threadRafraichirTousLesPlugins(self):
self.signaux.signal("debutActualisation", "TVDownloader")
self.api.pluginRafraichirAuto()
self.signaux.signal("finActualisation")
self.signaux.signal("actualiserListesDeroulantes")
threading.Thread(target=threadRafraichirTousLesPlugins,
args=(self, )).start()
## Slot qui active/desactive des elements de l'interface pendant un telechargement
# @param telechargementEnCours Indique si on telecharge ou pas
def activerDesactiverInterface(self, telechargementEnCours=False):
# Les boutons
self.pushButtonLancer.setEnabled(not telechargementEnCours)
self.pushButtonStop.setEnabled(telechargementEnCours)
self.pushButtonExtremiteMonter.setEnabled(not telechargementEnCours)
self.pushButtonMonter.setEnabled(not telechargementEnCours)
self.pushButtonDescendre.setEnabled(not telechargementEnCours)
self.pushButtonExtremiteDescendre.setEnabled(not telechargementEnCours)
self.pushButtonToutSupprimer.setEnabled(not telechargementEnCours)
self.pushButtonNettoyer.setEnabled(not telechargementEnCours)
# Le table widget
self.tableWidgetTelechargement.setEnabled(not telechargementEnCours)
## Slot appele lors ce qu'un le debut d'un telechargement commence
# @param numero Position dans la liste des telechargement du telechargement qui commence
def debutTelechargement(self, numero):
self.tableWidgetTelechargement.item(numero, 2).setText(
stringToQstring(u"Téléchargement en cours..."))
self.tableWidgetTelechargement.adapterColonnes()
self.progressBarTelechargementFichier.setValue(0)
## Slot appele lorsqu'un telechargement se finit
# @param numero Position dans la liste des telechargement du telechargement qui se finit
def finTelechargement(self, numero):
fichier = self.listeFichiersATelecharger[numero]
# On ajoute le fichier a l'historique
self.historique.ajouterHistorique(fichier)
# On modifie l'icone dans la liste des fichiers
self.gererIconeListeFichier(fichier)
# On modifie l'interface
self.tableWidgetTelechargement.item(numero, 2).setText(
stringToQstring(u"Fini !"))
self.progressBarTelechargement.setValue(
self.progressBarTelechargement.value() + 1)
self.tableWidgetTelechargement.adapterColonnes()
self.progressBarTelechargementFichier.setValue(100)
## Slot qui nettoie la liste des telechargements de tous les telechargements finis
def nettoyer(self):
for i in range(self.tableWidgetTelechargement.rowCount() - 1, -1,
-1): # [ nbLignes - 1, nbLignes - 2, ..., 1, 0 ]
if (self.tableWidgetTelechargement.item(
i, 2).text() == u"Fini !"): # Si c'est telecharge
self.supprimerTelechargement(i)
def test_get_raw_data_cell(actions, timeSlotID, id, prefix=""):
print actions.getRawDataEntry(timeSlotID, id)
def test_get_competitor_info(actions, uuid, prefix=""):
timeSlots = range(1, 25)
return actions.getCompetitorInfo(timeSlots, uuid, prefix)
if __name__ == "__main__":
actions = Actions.Actions()
actions.setManualDbCursor(DatabaseConnection.DatabaseConnection().getDatabaseCursor())
# test_update_raw_data_cell(actions, 5, 5, 5)
# for i in range(50):
# test_random_update_raw_data_cell(actions)
try:
pr = Preferences()
while True:
test_random_update_raw_data_cell(actions, pr.get("DBPrefix"))
time.sleep(0.5)
except KeyboardInterrupt:
print "\nShutting down!\n"
sys.exit(0)
# test_get_raw_data_cell(actions, 2, 2)
# test_get_raw_data_cell(actions, 8, 7)
# print test_get_competitor_info(actions, 1, "testDB_")
def applicationDidFinishLaunching_(self, sender):
self.preferences = Preferences.alloc().init()
NSLog("Application did finish launching.")
def __init__(self):
# Appel au constructeur de la classe mere
QtGui.QMainWindow.__init__(self)
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle("TVDownloader")
# Mise en place de son icone
self.setWindowIcon(QtGui.QIcon("ico/TVDownloader.png"))
###
# Mise en place des widgets dans la fenetre
###
# Widget central qui contiendra tout
self.centralWidget = QtGui.QWidget(self)
#
# Barre du haut
#
# Layout horizontal qui contiendra les listes deroulantes
self.horizontalLayoutBarreHaut = QtGui.QHBoxLayout()
# Liste deroulante pour choisir le site (plugin)
self.comboBoxSite = QtGui.QComboBox(self.centralWidget)
self.horizontalLayoutBarreHaut.addWidget(self.comboBoxSite)
# Liste deroulante pour choisir une chaine du site courant
self.comboBoxChaine = QtGui.QComboBox(self.centralWidget)
self.horizontalLayoutBarreHaut.addWidget(self.comboBoxChaine)
# Liste deroulante pour choisir une emission de la chaine courante
self.comboBoxEmission = QtGui.QComboBox(self.centralWidget)
self.horizontalLayoutBarreHaut.addWidget(self.comboBoxEmission)
#
# Onglets
#
# Gestionnaire onglets
self.tabWidget = QtGui.QTabWidget(self.centralWidget)
# Onglet Fichiers
self.tabFichiers = QtGui.QSplitter(
self.centralWidget) # L'onglet Fichier contient un splitter
self.tabWidget.addTab(self.tabFichiers, u"Choix des fichiers")
# Onglet Telechargements
self.tabTelechargements = QtGui.QWidget(self.centralWidget)
self.tabWidget.addTab(self.tabTelechargements, u"Téléchargements")
#
# Liste des fichiers
#
# Layout de grille qui contient le tableau qui liste les fichiers + boutons
self.gridLayoutFichiers = QtGui.QGridLayout(self.tabFichiers)
# Tableau qui contient la liste des fichiers disponibles pour l'emission courante
self.tableWidgetFichier = MyQTableWidget(self.tabFichiers)
# Il a 4 colonnes et 0 ligne (pour l'instant)
self.tableWidgetFichier.setColumnCount(3)
self.tableWidgetFichier.setRowCount(0)
# On ajoute les titres
self.tableWidgetFichier.setHorizontalHeaderItem(
0, self.tableWidgetFichier.creerItem(""))
self.tableWidgetFichier.setHorizontalHeaderItem(
1, self.tableWidgetFichier.creerItem("Date"))
self.tableWidgetFichier.setHorizontalHeaderItem(
2, self.tableWidgetFichier.creerItem("Emission"))
# On l'ajoute au layout
self.gridLayoutFichiers.addWidget(self.tableWidgetFichier, 0, 1, 6, 1)
# Icones du tableWidget
self.iconeFichier = QtGui.QIcon("ico/gtk-file.svg")
self.iconeAjoute = QtGui.QIcon("ico/gtk-add.svg")
self.iconeTelecharge = QtGui.QIcon("ico/gtk-apply.svg")
# Bouton pour ajouter tous les fichiers a la liste des telechargements
self.pushButtonToutAjouter = MyQPushButton(self.tabFichiers)
self.pushButtonToutAjouter.setIcon(QtGui.QIcon("ico/gtk-add.svg"))
self.pushButtonToutAjouter.setToolTip(
u"Ajouter tous les fichiers à la liste des téléchargements")
self.gridLayoutFichiers.addWidget(self.pushButtonToutAjouter, 0, 0, 2,
1)
# Bouton pour rafraichir le plugin courant
self.pushButtonRafraichirPlugin = MyQPushButton(self.tabFichiers)
self.pushButtonRafraichirPlugin.setIcon(
QtGui.QIcon("ico/gtk-refresh.svg"))
self.pushButtonRafraichirPlugin.setToolTip("Rafraichir le plugin")
self.gridLayoutFichiers.addWidget(self.pushButtonRafraichirPlugin, 2,
0, 2, 1)
# Bouton pour ouvrir la fenetre des preferences du plugin courant
self.pushButtonPreferencesPlugin = MyQPushButton(self.tabFichiers)
self.pushButtonPreferencesPlugin.setIcon(
QtGui.QIcon("ico/gtk-preferences.svg"))
self.pushButtonPreferencesPlugin.setToolTip(
u"Ouvrir les préférences du plugin")
self.gridLayoutFichiers.addWidget(self.pushButtonPreferencesPlugin, 4,
0, 2, 1)
# On met en place ce layout sur un widget (pour le splitter)
self.widgetFichiers = QtGui.QWidget()
self.widgetFichiers.setLayout(self.gridLayoutFichiers)
#
# Descriptif des fichiers
#
# Layout de grille
self.gridLayoutDescriptif = QtGui.QGridLayout()
# Label pour afficher un logo
self.logoFichierDefaut = QtGui.QPixmap()
self.logoFichierDefaut.load("img/gtk-dialog-question.svg")
self.labelLogo = QtGui.QLabel(self.centralWidget)
self.labelLogo.setPixmap(
self.logoFichierDefaut.scaled(QtCore.QSize(150, 150),
QtCore.Qt.KeepAspectRatio))
self.gridLayoutDescriptif.addWidget(self.labelLogo, 0, 0, 1, 1)
# Zone de texte pour afficher un descriptif
self.plainTextEdit = QtGui.QPlainTextEdit(self.centralWidget)
self.gridLayoutDescriptif.addWidget(self.plainTextEdit, 0, 1, 1, 2)
# On met en place ce layout sur un widget (pour le splitter)
self.widgetDescriptif = QtGui.QWidget()
self.widgetDescriptif.setLayout(self.gridLayoutDescriptif)
# Onrientation verticale du splitter
self.tabFichiers.setOrientation(QtCore.Qt.Vertical)
# On ajoute les 2 elements au splitter (qui est notre onglet)
self.tabFichiers.addWidget(self.widgetFichiers)
self.tabFichiers.addWidget(self.widgetDescriptif)
#
# Liste des telechargements
#
# Layout de grille qui contient le tableau qui liste les fichiers a telecharger + les boutons pour le controller
self.gridLayoutTelechargement = QtGui.QGridLayout(
self.tabTelechargements)
# Tableau qui contient la liste des fichiers a telecharger
self.tableWidgetTelechargement = MyQTableWidget(
self.tabTelechargements)
# Il a 5 colonnes et 0 ligne (pour l'instant)
self.tableWidgetTelechargement.setColumnCount(3)
self.tableWidgetTelechargement.setRowCount(0)
# On ajoute le titre des 5 colonnes
self.tableWidgetTelechargement.setHorizontalHeaderItem(
0, self.tableWidgetTelechargement.creerItem("Date"))
self.tableWidgetTelechargement.setHorizontalHeaderItem(
1, self.tableWidgetTelechargement.creerItem("Emission"))
self.tableWidgetTelechargement.setHorizontalHeaderItem(
2, self.tableWidgetTelechargement.creerItem("Etat"))
# On l'ajoute au layout
self.gridLayoutTelechargement.addWidget(self.tableWidgetTelechargement,
0, 1, 4, 1)
# Bouton pour monter l'element selectionne tout en haut de la liste
self.pushButtonExtremiteMonter = MyQPushButton(self.tabTelechargements)
self.pushButtonExtremiteMonter.setIcon(
QtGui.QIcon("ico/gtk-jump-to-rtl.svg"))
self.pushButtonExtremiteMonter.setToolTip(
u"Placer l'élément sélectionné tout en haut")
self.gridLayoutTelechargement.addWidget(self.pushButtonExtremiteMonter,
0, 0, 1, 1)
# Bouton pour monter l'element selectionne d'un cran dans la liste
self.pushButtonMonter = MyQPushButton(self.tabTelechargements)
self.pushButtonMonter.setIcon(QtGui.QIcon("ico/gtk-go-up.svg"))
self.pushButtonMonter.setToolTip(u"Monter l'élément sélectionné")
self.gridLayoutTelechargement.addWidget(self.pushButtonMonter, 1, 0, 1,
1)
# Bouton pour descendre l'element selectionne d'un cran dans la liste
self.pushButtonDescendre = MyQPushButton(self.tabTelechargements)
self.pushButtonDescendre.setIcon(QtGui.QIcon("ico/gtk-go-down.svg"))
self.pushButtonDescendre.setToolTip(u"Descendre l'élément selectionné")
self.gridLayoutTelechargement.addWidget(self.pushButtonDescendre, 2, 0,
1, 1)
# Bouton pour descendre l'element selectionne tout en bas de la liste
self.pushButtonExtremiteDescendre = MyQPushButton(
self.tabTelechargements)
self.pushButtonExtremiteDescendre.setIcon(
QtGui.QIcon("ico/gtk-jump-to-ltr.svg"))
self.pushButtonExtremiteDescendre.setToolTip(
u"Placer l'élément sélectionné tout en bas")
self.gridLayoutTelechargement.addWidget(
self.pushButtonExtremiteDescendre, 3, 0, 1, 1)
# Bouton pour supprimer tous les elements de la liste
self.pushButtonToutSupprimer = MyQPushButton(self.tabTelechargements)
self.pushButtonToutSupprimer.setIcon(QtGui.QIcon("ico/gtk-cancel.svg"))
self.pushButtonToutSupprimer.setToolTip(
u"Supprimer tous les téléchargements")
self.gridLayoutTelechargement.addWidget(self.pushButtonToutSupprimer,
0, 2, 1, 1)
# Bouton pour supprimer de la liste les telechargements termines
self.pushButtonNettoyer = MyQPushButton(self.tabTelechargements)
self.pushButtonNettoyer.setIcon(QtGui.QIcon("ico/gtk-delete-full.svg"))
self.pushButtonNettoyer.setToolTip(
u"Supprimer les téléchargement terminés")
self.gridLayoutTelechargement.addWidget(self.pushButtonNettoyer, 1, 2,
1, 1)
# Bouton pour ouvrir le dossier des telechargements
self.pushButtonOuvrirDossierTelechargement = MyQPushButton(
self.tabTelechargements)
self.pushButtonOuvrirDossierTelechargement.setIcon(
QtGui.QIcon("ico/gtk-folder.svg"))
self.pushButtonOuvrirDossierTelechargement.setToolTip(
u"Ouvrir le dossier des téléchargements")
self.gridLayoutTelechargement.addWidget(
self.pushButtonOuvrirDossierTelechargement, 2, 2, 1, 1)
#
# Barre progression de telechargement d'un fichier
#
self.progressBarTelechargementFichier = QtGui.QProgressBar(
self.centralWidget)
self.progressBarTelechargementFichier.setProperty("value", 0)
#
# Barre de progression de telechargement des fichiers
#
self.progressBarTelechargement = QtGui.QProgressBar(self.centralWidget)
self.progressBarTelechargement.setProperty("value", 0)
#
# Boutons du bas pour gerer ajouter/supprimer/lancer telechargements
#
# Layout horizontal qui contiendra les boutons
self.horizontalLayoutBarreBas = QtGui.QHBoxLayout()
# Bouton pour lancer les telechargements
self.pushButtonLancer = QtGui.QPushButton(
QtGui.QIcon("ico/gtk-media-play-ltr.svg"),
u"Lancer téléchargement", self.centralWidget)
self.horizontalLayoutBarreBas.addWidget(self.pushButtonLancer)
# Bouton pour stopper les telechargements
self.pushButtonStop = QtGui.QPushButton(
QtGui.QIcon("ico/gtk-media-stop.svg"),
u"Stopper le téléchargement", self.centralWidget)
self.pushButtonStop.setEnabled(False)
self.horizontalLayoutBarreBas.addWidget(self.pushButtonStop)
###
# Positionnement des differents widgets/layouts sur le layout de grille
###
# Layout de grille dans lequel on va placer nos widgets/layouts
self.gridLayout = QtGui.QGridLayout(self.centralWidget)
# On ajoute la barre du haut
self.gridLayout.addLayout(self.horizontalLayoutBarreHaut, 0, 0, 1, 3)
# On ajoute le gestionnaire d'onglets
self.gridLayout.addWidget(self.tabWidget, 1, 0, 1, 3)
# On ajoute la barre de progression de telechargement d'un fichier
self.gridLayout.addWidget(self.progressBarTelechargementFichier, 2, 0,
1, 3)
# On ajoute la barre de progression de telechargement des fichiers
self.gridLayout.addWidget(self.progressBarTelechargement, 3, 0, 1, 3)
# On ajoute les boutons ajouter/supprimer/lancer
self.gridLayout.addLayout(self.horizontalLayoutBarreBas, 4, 0, 1, 3)
###
# Mise en place le central widget dans la fenetre
###
self.setCentralWidget(self.centralWidget)
###
# Mise en place du menu
###
# Menu barre
self.menubar = QtGui.QMenuBar(self)
self.menubar.setGeometry(QtCore.QRect(0, 0, 480, 25))
# Menu Fichier
self.menuFichier = QtGui.QMenu("&Fichier", self.menubar)
self.menubar.addAction(self.menuFichier.menuAction())
# Action Fichier -> Quitter
self.actionQuitter = QtGui.QAction(QtGui.QIcon("ico/gtk-quit.svg"),
"&Quitter", self)
self.actionQuitter.setIconVisibleInMenu(True)
self.menuFichier.addAction(self.actionQuitter)
# Menu Edition
self.menuEdition = QtGui.QMenu("&Edition", self.menubar)
self.menubar.addAction(self.menuEdition.menuAction())
# Action Edition -> Mise a jour
self.actionMAJ = QtGui.QAction(QtGui.QIcon("ico/gtk-refresh.svg"),
u"&Mise à jour des plugins", self)
self.actionMAJ.setIconVisibleInMenu(True)
self.menuEdition.addAction(self.actionMAJ)
# Action Edition -> Preferences
self.actionPreferences = QtGui.QAction(
QtGui.QIcon("ico/gtk-preferences.svg"), u"&Préférences", self)
self.actionPreferences.setIconVisibleInMenu(True)
self.menuEdition.addAction(self.actionPreferences)
# Menu Aide
self.menuAide = QtGui.QMenu("&Aide", self.menubar)
self.menubar.addAction(self.menuAide.menuAction())
# Action Aide -> A propos
self.actionAPropos = QtGui.QAction(QtGui.QIcon("ico/gtk-about.svg"),
u"À p&ropos", self)
self.actionAPropos.setIconVisibleInMenu(True)
self.menuAide.addAction(self.actionAPropos)
# Ajout du menu a l'interface
self.setMenuBar(self.menubar)
###
# Signaux provenants de l'interface
###
QtCore.QObject.connect(self.tableWidgetFichier,
QtCore.SIGNAL("cellClicked(int,int)"),
self.afficherInformationsFichier)
QtCore.QObject.connect(self.tableWidgetFichier,
QtCore.SIGNAL("cellDoubleClicked(int,int)"),
self.gererTelechargement)
QtCore.QObject.connect(self.pushButtonToutAjouter,
QtCore.SIGNAL("clicked()"),
self.ajouterTousLesFichiers)
QtCore.QObject.connect(self.pushButtonRafraichirPlugin,
QtCore.SIGNAL("clicked()"),
self.rafraichirPlugin)
QtCore.QObject.connect(self.tableWidgetTelechargement,
QtCore.SIGNAL("cellDoubleClicked(int,int)"),
self.supprimerTelechargement)
QtCore.QObject.connect(
self.pushButtonExtremiteMonter,
QtCore.SIGNAL("clicked()"),
lambda versLeHaut=True, extremite=True: self.
tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite))
QtCore.QObject.connect(
self.pushButtonMonter,
QtCore.SIGNAL("clicked()"),
lambda versLeHaut=True, extremite=False: self.
tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite))
QtCore.QObject.connect(
self.pushButtonDescendre,
QtCore.SIGNAL("clicked()"),
lambda versLeHaut=False, extremite=False: self.
tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite))
QtCore.QObject.connect(
self.pushButtonExtremiteDescendre,
QtCore.SIGNAL("clicked()"),
lambda versLeHaut=False, extremite=True: self.
tableWidgetTelechargement.deplacerLigne(versLeHaut, extremite))
QtCore.QObject.connect(self.pushButtonToutSupprimer,
QtCore.SIGNAL("clicked()"),
self.supprimerTousLesTelechargements)
QtCore.QObject.connect(self.pushButtonNettoyer,
QtCore.SIGNAL("clicked()"), self.nettoyer)
QtCore.QObject.connect(self.pushButtonLancer,
QtCore.SIGNAL("clicked()"),
self.lancerTelechargement)
QtCore.QObject.connect(self.pushButtonStop, QtCore.SIGNAL("clicked()"),
self.stopperTelechargement)
QtCore.QObject.connect(self.actionQuitter,
QtCore.SIGNAL("triggered()"), self.close)
################################################
# Instanciations + initialisation de variables #
################################################
# Fenetre About
self.aProposDialog = None
# Fenetre des preferences du logiciel
self.preferencesDialog = None
# Fenetre de mise a jour des plugins
self.updateManagerDialog = None
# Nom plugin courant
self.nomPluginCourant = ""
# Liste des fichiers
self.listeFichiers = []
# Liste des fichiers a telecharger
self.listeFichiersATelecharger = []
# Cache des images descriptive
# Clef : urlImage Valeur : image (binaire)
self.cacheImage = {}
# On intancie le lanceur de signaux
self.signaux = Signaux()
# On instancie le gestionnaire de preferences
self.preferences = Preferences()
# On instancie le gestionnaire de preferences des plugins
self.preferencesPluginDialog = PreferencePluginDialog(self)
# On instancie le gestionnaire de download
self.downloader = Downloader(self.signaux)
# On recupere l'instance de API
self.api = API.getInstance()
# On instancie le gestionnaire d'historique
self.historique = Historique()
# On instancie la fenetre d'attente
self.fenetreAttenteProgressDialog = FenetreAttenteProgressDialog(self)
# On instancie le gest
#
# Fenetre de confirmation pour quitter le logiciel
#
self.quitterMessageBox = QtGui.QMessageBox(self)
self.quitterMessageBox.setWindowTitle("Fermeture de TVDownloader")
self.quitterMessageBox.setText(
u"Voulez-vous réellement quitter TVDownloader ?")
self.quitterMessageBox.setInformativeText(
u"Votre liste de téléchargement sera perdue")
self.quitterMessageBox.addButton("Oui", QtGui.QMessageBox.AcceptRole)
self.quitterMessageBox.addButton("Non", QtGui.QMessageBox.RejectRole)
############################################################
# On connecte les signaux des instances precedements crees #
############################################################
QtCore.QObject.connect(self.pushButtonOuvrirDossierTelechargement,
QtCore.SIGNAL("clicked()"),
self.ouvrirRepertoireTelechargement)
QtCore.QObject.connect(self.comboBoxSite,
QtCore.SIGNAL("activated(QString)"),
self.listerChaines)
QtCore.QObject.connect(self.comboBoxChaine,
QtCore.SIGNAL("activated(QString)"),
self.listerEmissions)
QtCore.QObject.connect(self.comboBoxEmission,
QtCore.SIGNAL("activated(QString)"),
self.listerFichiers)
QtCore.QObject.connect(self.pushButtonPreferencesPlugin,
QtCore.SIGNAL("clicked()"),
self.ouvrirPreferencesPlugin)
QtCore.QObject.connect(self.actionPreferences,
QtCore.SIGNAL("triggered()"),
self.ouvrirPreferencesLogiciel)
QtCore.QObject.connect(self.actionMAJ, QtCore.SIGNAL("triggered()"),
self.ouvrirFenetreMiseAJour)
QtCore.QObject.connect(self.actionAPropos,
QtCore.SIGNAL("triggered()"),
self.ouvrirFenetreAPropos)
QtCore.QObject.connect(
self.signaux, QtCore.SIGNAL("debutActualisation(PyQt_PyObject)"),
self.fenetreAttenteProgressDialog.ouvrirFenetreAttente)
QtCore.QObject.connect(
self.signaux, QtCore.SIGNAL("finActualisation()"),
self.fenetreAttenteProgressDialog.fermerFenetreAttente)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("actualiserListesDeroulantes()"),
self.actualiserListesDeroulantes)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("listeChaines(PyQt_PyObject)"),
self.ajouterChaines)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("listeEmissions(PyQt_PyObject)"),
self.ajouterEmissions)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("listeFichiers(PyQt_PyObject)"),
self.ajouterFichiers)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("nouvelleImage(PyQt_PyObject)"),
self.mettreEnPlaceImage)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("debutTelechargement(int)"),
self.debutTelechargement)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("finTelechargement(int)"),
self.finTelechargement)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("finDesTelechargements()"),
self.activerDesactiverInterface)
QtCore.QObject.connect(self.signaux,
QtCore.SIGNAL("pourcentageFichier(int)"),
self.progressBarTelechargementFichier.setValue)
#########
# Début #
#########
# La fenetre prend la dimension qu'elle avait a sa fermeture
taille = self.preferences.getPreference("tailleFenetre")
self.resize(taille[0], taille[1])
# Si aucun plugin n'est active, on ouvre la fenetre des preferences
if (len(self.preferences.getPreference("pluginsActifs")) == 0):
self.ouvrirPreferencesLogiciel()
# On actualise tous les plugins
self.rafraichirTousLesPlugins()
class Downloader(object):
# Instance de la classe (singleton)
instance = None
## Surcharge de la methode de construction standard (pour mettre en place le singleton)
def __new__(self, *args, **kwargs):
if (self.instance is None):
self.instance = super(Downloader, self).__new__(self)
return self.instance
## Constructeur
# @param signaux Lanceur de signaux. Si on le precise pas, aucun signal n'est lance (mode CLI).
def __init__(self, signaux=None):
self.preferences = Preferences()
self.signaux = signaux
self.arreter = True
self.process = None
## Methode pour afficher un pourcentage à l'ecran
# @param pourcentage Pourcentage actuel a afficher
def afficherPourcentage(self, pourcentage):
# On s'assure que le pourcentage soit bien entre 0 et 100
if (pourcentage < 0):
pourcentage = 0
elif (pourcentage > 100):
pourcentage = 100
message = str(pourcentage) + " %"
print '\r', # Permet d'écrire au même endroit
sys.stdout.write(message)
sys.stdout.flush()
## Methode pour lancer le telecharger des fichiers
# @param listeFichiers Liste des fichiers a telecharger
def lancerTelechargement(self, listeFichiers):
self.arreter = False
for (numero, fichier, nomFichierSortie) in listeFichiers:
logger.info("Telechargement de %s" % (fichier))
# Si on demande de s'arreter, on sort
if self.arreter:
break
# Si on a le lanceur de signal
if self.signaux:
# On envoie le signal de debut de telechargement d'un fichier
self.signaux.signal("debutTelechargement", numero)
else:
print "Debut telechargement", nomFichierSortie
# On ajoute le repertoire de destination au nom du fichier
fichierSortie = self.preferences.getPreference(
"repertoireTelechargement") + "/" + nomFichierSortie
# On telecharge de differentes manieres selon le protocole
if (fichier[:4] == "rtmp"):
if (fichier.find("swfVfy") == -1):
commande = urlToRtmpdump(fichier)
else:
commande = "rtmpdump -r " + fichier
self.telecharger(commande + " -o \"" + fichierSortie + "\"")
elif (fichier[:4] == "http" or fichier[:3] == "ftp"
or fichier[:3] == "mms"):
self.telecharger("msdl -c " + fichier + " -o \"" +
fichierSortie + "\"")
else:
logger.warn("le protocole du fichier %s n'est pas gere" %
(fichier))
# Si on a le lanceur de signal
if self.signaux:
# On envoie le signal de fin de telechargement d'un fichier
self.signaux.signal("finTelechargement", numero)
else:
print "\n\tFin telechargement"
# Si on a le lanceur de signal
if self.signaux:
# On envoie le signal de fin de telechargement des fichiers
self.signaux.signal("finDesTelechargements")
## Methode qui telecharge un fichier
# @param commande Commande a lancer pour telecharger le fichier
def telecharger(self, commande):
# Commande mise au bon format pour Popen
if (not isinstance(commande, str)):
commande = str(commande)
arguments = shlex.split(commande)
# On lance la commande en redirigeant stdout et stderr (stderr va dans stdout)
self.process = subprocess.Popen(arguments,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
# On recupere le flux stdout
stdoutF = self.process.stdout
# On recupere le descripteur de fichier de stdout
stdoutFD = stdoutF.fileno()
# On recupere les flags existants
stdoutFlags = fcntl.fcntl(stdoutFD, fcntl.F_GETFL)
# On modifie les flags existants en ajoutant le flag NoDelay
fcntl.fcntl(stdoutFD, fcntl.F_SETFL, stdoutFlags | os.O_NDELAY)
# Tant que le subprocess n'est pas fini
while (self.process.poll() == None):
# On attent que stdout soit lisible
if (stdoutFD in select.select([stdoutFD], [], [])[0]):
# On lit stdout
ligne = stdoutF.read()
# On affiche que les textes non vides
if ligne:
pourcentListe = re.findall("(\d{1,3}\.{0,1}\d{0,1})%",
ligne)
if (pourcentListe != []):
pourcent = int(float(pourcentListe[-1]))
if (pourcent >= 0 and pourcent <= 100):
# Si on a le lanceur de signal
if not self.signaux:
self.afficherPourcentage(pourcent)
elif self.signaux:
# On envoit le pourcentage d'avancement a l'interface
self.signaux.signal("pourcentageFichier",
pourcent)
# On attent avant de recommencer a lire
time.sleep(3)
## Methode pour stopper le telechargement des fichiers
def stopperTelechargement(self):
if not self.arreter:
# On sort de la boucle principale
self.arreter = True
# On stop le process s'il est lance
if (self.process.poll() == None):
self.process.terminate()
def launchPreferences_(self, notification):
NSLog('AppDelegate: launchPreferences')
self.preferences = Preferences.alloc().init()
self.preferences.showWindow_(self)
