[pitivi] mainwindow: [pylint] prefix all unused arguments and variables.
- From: Mathieu Duponchelle <mathieudu src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [pitivi] mainwindow: [pylint] prefix all unused arguments and variables.
- Date: Fri, 7 Feb 2014 00:30:41 +0000 (UTC)
commit 20b00ae492b4883768a71616270841d69b2d36c5
Author: Mathieu Duponchelle <mduponchelle1 gmail com>
Date: Thu Feb 6 12:07:40 2014 +0100
mainwindow: [pylint] prefix all unused arguments and variables.
pitivi/application.py | 20 ++++++------
pitivi/effects.py | 22 +++++++-------
pitivi/mainwindow.py | 54 ++++++++++++++++++------------------
pitivi/mediafilespreviewer.py | 4 +-
pitivi/medialibrary.py | 18 ++++++------
pitivi/project.py | 34 +++++++++++-----------
pitivi/render.py | 38 ++++++++++++------------
pitivi/settings.py | 4 +-
pitivi/tabsmanager.py | 4 +-
pitivi/timeline/controls.py | 6 ++--
pitivi/timeline/elements.py | 52 +++++++++++++++++-----------------
pitivi/timeline/layer.py | 10 +++---
pitivi/timeline/previewers.py | 10 +++---
pitivi/timeline/ruler.py | 6 ++--
pitivi/timeline/timeline.py | 62 ++++++++++++++++++++--------------------
pitivi/titleeditor.py | 16 +++++-----
pitivi/transitions.py | 10 +++---
pitivi/undo/undo.py | 12 ++++----
pitivi/utils/extract.py | 4 +-
pitivi/utils/misc.py | 4 +-
pitivi/utils/pipeline.py | 4 +-
pitivi/utils/system.py | 2 +-
pitivi/utils/timeline.py | 2 +-
pitivi/utils/widgets.py | 12 ++++----
pitivi/viewer.py | 22 +++++++-------
25 files changed, 216 insertions(+), 216 deletions(-)
---
diff --git a/pitivi/application.py b/pitivi/application.py
index 1ed2216..51f227d 100644
--- a/pitivi/application.py
+++ b/pitivi/application.py
@@ -166,17 +166,17 @@ class Pitivi(Loggable, Signallable):
pm.connect("closing-project", self._projectManagerClosingProject)
pm.connect("project-closed", self._projectManagerProjectClosed)
- def _projectManagerNewProjectLoading(self, projectManager, uri):
+ def _projectManagerNewProjectLoading(self, unused_project_manager, uri):
self.emit("new-project-loading", uri)
- def _projectManagerNewProjectCreated(self, projectManager, project):
+ def _projectManagerNewProjectCreated(self, unused_project_manager, project):
self.current_project = project
self.emit("new-project-created", project)
- def _newProjectLoaded(self, project):
+ def _newProjectLoaded(self, unused_project):
pass
- def _projectManagerNewProjectLoaded(self, projectManager, project, unused_fully_loaded):
+ def _projectManagerNewProjectLoaded(self, unused_project_manager, project, unused_fully_loaded):
self.current_project = project
self.action_log.clean()
#self.timelineLogObserver.startObserving(project.timeline)
@@ -184,13 +184,13 @@ class Pitivi(Loggable, Signallable):
self._newProjectLoaded(project)
self.emit("new-project-loaded", project)
- def _projectManagerNewProjectFailed(self, projectManager, uri, exception):
+ def _projectManagerNewProjectFailed(self, unused_project_manager, uri, exception):
self.emit("new-project-failed", uri, exception)
- def _projectManagerClosingProject(self, projectManager, project):
+ def _projectManagerClosingProject(self, unused_project_manager, project):
return self.emit("closing-project", project)
- def _projectManagerProjectClosed(self, projectManager, project):
+ def _projectManagerProjectClosed(self, unused_project_manager, project):
#self.timelineLogObserver.stopObserving(project.timeline)
self.projectLogObserver.stopObserving(project)
self.current_project = None
@@ -242,7 +242,7 @@ class InteractivePitivi(Pitivi):
if debug:
sys.excepthook = self._excepthook
- def _excepthook(self, exc_type, value, tback):
+ def _excepthook(self, unused_exc_type, unused_value, tback):
import traceback
import pdb
traceback.print_tb(tback)
@@ -326,7 +326,7 @@ class ProjectCreatorGuiPitivi(GuiPitivi):
lib.connect("discovery-error", self._discoveryErrorCb, uris)
lib.addUris(uris)
- def _sourceAddedCb(self, medialibrary, info, startup_uris, add_to_timeline):
+ def _sourceAddedCb(self, unused_media_library, info, startup_uris, add_to_timeline):
if self._maybePopStartupUri(startup_uris, info.get_uri()) \
and add_to_timeline:
self.action_log.begin("add clip")
@@ -335,7 +335,7 @@ class ProjectCreatorGuiPitivi(GuiPitivi):
self.current_project.timeline.get_layers()[0].add_clip(src)
self.action_log.commit()
- def _discoveryErrorCb(self, medialibrary, uri, error, debug, startup_uris):
+ def _discoveryErrorCb(self, unused_media_library, uri, unused_error, unused_debug, startup_uris):
self._maybePopStartupUri(startup_uris, uri)
def _maybePopStartupUri(self, startup_uris, uri):
diff --git a/pitivi/effects.py b/pitivi/effects.py
index 0194a69..7b27772 100644
--- a/pitivi/effects.py
+++ b/pitivi/effects.py
@@ -371,7 +371,7 @@ GlobalSettings.addConfigSection('effect-library')
class EffectListWidget(Gtk.VBox, Loggable):
""" Widget for listing effects """
- def __init__(self, instance, uiman):
+ def __init__(self, instance, unused_uiman):
Gtk.VBox.__init__(self)
Loggable.__init__(self)
@@ -457,7 +457,7 @@ class EffectListWidget(Gtk.VBox, Loggable):
toolbar.show_all()
@staticmethod
- def view_description_cell_data_func(column, cell, model, iter_, data):
+ def view_description_cell_data_func(unused_column, cell, model, iter_, unused_data):
name, desc = model.get(iter_, COL_NAME_TEXT, COL_DESC_TEXT)
escape = GLib.markup_escape_text
@@ -509,10 +509,10 @@ class EffectListWidget(Gtk.VBox, Loggable):
if pixbuf:
Gtk.drag_set_icon_pixbuf(context, pixbuf, 0, 0)
- def _dndDragEndCb(self, unused_view, context):
+ def _dndDragEndCb(self, unused_view, unused_context):
self.info("Drag operation ended")
- def _dndDragDataGetCb(self, unused_view, context, data, info, timestamp):
+ def _dndDragDataGetCb(self, unused_view, unused_context, data, unused_info, unused_timestamp):
data.set_uris([self.getSelectedItems()])
def _rowUnderMouseSelected(self, view, event):
@@ -524,7 +524,7 @@ class EffectListWidget(Gtk.VBox, Loggable):
selection.count_selected_rows() > 0
return False
- def _enterPressEventCb(self, view, event=None):
+ def _enterPressEventCb(self, unused_view, unused_event=None):
factory_name = self.getSelectedItems()
if factory_name is not None:
self.app.gui.clipconfig.effect_expander.addEffectToCurrentSelection(factory_name)
@@ -576,16 +576,16 @@ class EffectListWidget(Gtk.VBox, Loggable):
self.populate_categories_widget()
self.modelFilter.refilter()
- def _categoryChangedCb(self, combobox):
+ def _categoryChangedCb(self, unused_combobox):
self.modelFilter.refilter()
- def _searchEntryChangedCb(self, entry):
+ def _searchEntryChangedCb(self, unused_entry):
self.modelFilter.refilter()
def _searchEntryIconClickedCb(self, entry, unused, unused1):
entry.set_text("")
- def _setRowVisible(self, model, iter, data):
+ def _setRowVisible(self, model, iter, unused_data):
if self._effectType == model.get_value(iter, COL_EFFECT_TYPE):
if model.get_value(iter, COL_EFFECT_CATEGORIES) is None:
return False
@@ -669,14 +669,14 @@ class EffectsPropertiesManager:
return effect_set_ui
- def _connectAllWidgetCbs(self, effect_configuration_ui, effect):
+ def _connectAllWidgetCbs(self, unused_effect_configuration_ui, unused_effect):
for prop, widget in effect_configuration_ui.properties.iteritems():
widget.connectValueChanged(self._onValueChangedCb, widget, prop)
- def _onSetDefaultCb(self, widget, dynamic):
+ def _onSetDefaultCb(self, unused_widget, dynamic):
dynamic.setWidgetToDefault()
- def _onValueChangedCb(self, widget, dynamic, prop):
+ def _onValueChangedCb(self, unused_widget, dynamic, prop):
value = dynamic.getWidgetValue()
#FIXME Workaround in order to make aspectratiocrop working
diff --git a/pitivi/mainwindow.py b/pitivi/mainwindow.py
index e4dd313..eccadb8 100644
--- a/pitivi/mainwindow.py
+++ b/pitivi/mainwindow.py
@@ -510,16 +510,16 @@ class PitiviMainWindow(Gtk.Window, Loggable):
self._fullscreen_toolbar_win.hide()
self.is_fullscreen = fullscreen
- def _slideFullscreenToolbarIn(self, *args):
+ def _slideFullscreenToolbarIn(self, *unused_args):
self._fullscreenToolbarDirection = "down"
GLib.timeout_add(25, self._animateFullscreenToolbar)
- def _slideFullscreenToolbarOut(self, *args):
+ def _slideFullscreenToolbarOut(self, *unused_args):
self._fullscreenToolbarDirection = "up"
GLib.timeout_add(25, self._animateFullscreenToolbar)
return False # Stop the initial gobject timer
- def _animateFullscreenToolbar(self, *args):
+ def _animateFullscreenToolbar(self, *unused_args):
"""
Animate the fullscreen toolbar by moving it up or down by a few pixels.
This is meant to be called repeatedly by a GLib timer.
@@ -582,7 +582,7 @@ class PitiviMainWindow(Gtk.Window, Loggable):
self.settings.mainWindowMainHPanePosition = self.mainhpaned.get_position()
self.settings.mainWindowVPanePosition = self.vpaned.get_position()
- def _mediaLibraryPlayCb(self, medialibrary, asset):
+ def _mediaLibraryPlayCb(self, unused_medialibrary, asset):
"""
If the media library item to preview is an image, show it in the user's
favorite image viewer. Else, preview the video/sound in Pitivi.
@@ -595,16 +595,16 @@ class PitiviMainWindow(Gtk.Window, Loggable):
else:
self._viewUri(asset.get_id())
- def _projectChangedCb(self, project):
+ def _projectChangedCb(self, unused_project):
self.main_actions.get_action("SaveProject").set_sensitive(True)
self.updateTitle()
- def _mediaLibrarySourceRemovedCb(self, project, asset):
+ def _mediaLibrarySourceRemovedCb(self, unused_project, asset):
"""When a clip is removed from the Media Library, tell the timeline
to remove all instances of that clip."""
self.timeline_ui.purgeObject(asset.get_id())
- def _selectedLayerChangedCb(self, widget, layer):
+ def _selectedLayerChangedCb(self, unused_widget, layer):
self.main_actions.get_action("RemoveLayer").set_sensitive(layer is not None)
## Toolbar/Menu actions callback
@@ -756,16 +756,16 @@ class PitiviMainWindow(Gtk.Window, Loggable):
chooser.destroy()
return True
- def _canLoadUri(self, filterinfo, uri):
+ def _canLoadUri(self, filterinfo, unused_uri):
try:
return GES.Formatter.can_load_uri(filterinfo.uri)
except:
return False
- def _undoCb(self, action):
+ def _undoCb(self, unused_action):
self.app.action_log.undo()
- def _redoCb(self, action):
+ def _redoCb(self, unused_action):
self.app.action_log.redo()
def _prefsCb(self, unused_action):
@@ -774,7 +774,7 @@ class PitiviMainWindow(Gtk.Window, Loggable):
self.prefsdialog = PreferencesDialog(self.app)
self.prefsdialog.run()
- def _projectManagerNewProjectLoadedCb(self, projectManager, project, unused_fully_loaded):
+ def _projectManagerNewProjectLoadedCb(self, projectManager, unused_project, unused_fully_loaded):
"""
Once a new project has been loaded, wait for media library's
"ready" signal to populate the timeline.
@@ -805,12 +805,12 @@ class PitiviMainWindow(Gtk.Window, Loggable):
if self.app.current_project.timeline.props.duration != 0:
self.render_button.set_sensitive(True)
- def _projectManagerNewProjectLoadingCb(self, projectManager, uri):
+ def _projectManagerNewProjectLoadingCb(self, unused_project_manager, uri):
if uri:
self.recent_manager.add_item(uri)
self.log("A NEW project is loading, deactivate UI")
- def _projectManagerSaveProjectFailedCb(self, projectManager, uri, exception=None):
+ def _projectManagerSaveProjectFailedCb(self, unused_project_manager, uri, exception=None):
project_filename = unquote(uri.split("/")[-1])
dialog = Gtk.MessageDialog(transient_for=self,
modal=True,
@@ -825,7 +825,7 @@ class PitiviMainWindow(Gtk.Window, Loggable):
dialog.destroy()
self.error("failed to save project")
- def _projectManagerProjectSavedCb(self, projectManager, project, uri):
+ def _projectManagerProjectSavedCb(self, unused_project_manager, project, uri):
# FIXME GES: Reimplement Undo/Redo
#self.app.action_log.checkpoint()
#self._syncDoUndo(self.app.action_log)
@@ -916,7 +916,7 @@ class PitiviMainWindow(Gtk.Window, Loggable):
return res
- def _projectManagerProjectClosedCb(self, projectManager, project):
+ def _projectManagerProjectClosedCb(self, unused_project_manager, project):
"""
This happens immediately when the user asks to load another project,
after the user confirmed that unsaved changes can be discarded but
@@ -933,7 +933,7 @@ class PitiviMainWindow(Gtk.Window, Loggable):
self.clipconfig.timeline = None
return False
- def _projectManagerRevertingToSavedCb(self, projectManager, unused_project):
+ def _projectManagerRevertingToSavedCb(self, unused_project_manager, unused_project):
if self.app.current_project.hasUnsavedModifications():
dialog = Gtk.MessageDialog(transient_for=self,
modal=True,
@@ -953,7 +953,7 @@ class PitiviMainWindow(Gtk.Window, Loggable):
return False
return True
- def _projectManagerNewProjectFailedCb(self, projectManager, uri, exception):
+ def _projectManagerNewProjectFailedCb(self, unused_project_manager, uri, exception):
project_filename = unquote(uri.split("/")[-1])
dialog = Gtk.MessageDialog(transient_for=self,
modal=True,
@@ -966,8 +966,8 @@ class PitiviMainWindow(Gtk.Window, Loggable):
dialog.run()
dialog.destroy()
- def _projectManagerMissingUriCb(self, u_project_manager, u_project,
- error, asset):
+ def _projectManagerMissingUriCb(self, unused_project_manager, unused_project,
+ unused_error, asset):
self._missingUriOnLoading = True
uri = asset.get_id()
new_uri = None
@@ -1026,7 +1026,7 @@ class PitiviMainWindow(Gtk.Window, Loggable):
# Use a Gtk FileFilter to only show files with the same extension
# Note that splitext gives us the extension with the ".", no need to
# add it inside the filter string.
- filename, extension = os.path.splitext(uri)
+ unused_filename, extension = os.path.splitext(uri)
filter = Gtk.FileFilter()
# Translators: this is a format filter in a filechooser. Ex: "AVI files"
filter.set_name(_("%s files" % extension))
@@ -1082,7 +1082,7 @@ class PitiviMainWindow(Gtk.Window, Loggable):
project.connect("asset-removed", self._mediaLibrarySourceRemovedCb)
project.connect("project-changed", self._projectChangedCb)
- def _actionLogCommit(self, action_log, stack, nested):
+ def _actionLogCommit(self, action_log, unused_stack, nested):
if nested:
return
@@ -1091,10 +1091,10 @@ class PitiviMainWindow(Gtk.Window, Loggable):
def _actionLogCleaned(self, action_log):
self._syncDoUndo(action_log)
- def _actionLogUndo(self, action_log, stack):
+ def _actionLogUndo(self, action_log, unused_stack):
self._syncDoUndo(action_log)
- def _actionLogRedo(self, action_log, stack):
+ def _actionLogRedo(self, action_log, unused_stack):
self._syncDoUndo(action_log)
def _syncDoUndo(self, action_log):
@@ -1145,7 +1145,7 @@ class PitiviMainWindow(Gtk.Window, Loggable):
folder_path = os.path.dirname(path_from_uri(self.app.current_project.uri))
self.settings.lastProjectFolder = folder_path
- def _renderingSettingsChangedCb(self, project, item=None, value=None):
+ def _renderingSettingsChangedCb(self, project, unused_item=None, unused_value=None):
"""
When the project setting change, we reset the viewer aspect ratio
"""
@@ -1154,8 +1154,8 @@ class PitiviMainWindow(Gtk.Window, Loggable):
self.viewer.setDisplayAspectRatio(ratio)
self.viewer.timecode_entry.setFramerate(project.videorate)
- def _sourceListMissingPluginsCb(self, project, uri, factory,
- details, descriptions, missingPluginsCallback):
+ def _sourceListMissingPluginsCb(self, unused_project, unused_uri, unused_factory,
+ details, unused_descriptions, missingPluginsCallback):
res = self._installPlugins(details, missingPluginsCallback)
return res
@@ -1211,7 +1211,7 @@ class PitiviMainWindow(Gtk.Window, Loggable):
chooser.destroy()
return ret
- def _showSaveAsDialog(self, project):
+ def _showSaveAsDialog(self, unused_project):
self.log("Save URI requested")
chooser = Gtk.FileChooserDialog(title=_("Save As..."),
diff --git a/pitivi/mediafilespreviewer.py b/pitivi/mediafilespreviewer.py
index a7f5a55..329e822 100644
--- a/pitivi/mediafilespreviewer.py
+++ b/pitivi/mediafilespreviewer.py
@@ -279,7 +279,7 @@ class PreviewWidget(Gtk.VBox, Loggable):
self.b_zoom_out.hide()
self.bbox.show()
- def show_error(self, uri):
+ def show_error(self, unused_uri):
self.l_error.show()
self.b_details.show()
@@ -345,7 +345,7 @@ class PreviewWidget(Gtk.VBox, Loggable):
err, dbg = message.parse_error()
self.error("Error: %s %s" % (err, dbg))
- def _update_position(self, *args):
+ def _update_position(self, *unused_args):
if self.is_playing and not self.slider_being_used:
curr_pos = self.player.query_position(self.time_format)[1]
self.pos_adj.set_value(long(curr_pos))
diff --git a/pitivi/medialibrary.py b/pitivi/medialibrary.py
index 449d48b..4b81af4 100644
--- a/pitivi/medialibrary.py
+++ b/pitivi/medialibrary.py
@@ -623,13 +623,13 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
# medialibrary callbacks
def _assetAddedCb(self, unused_project, asset,
- current_clip_iter=None, total_clips=None):
+ unused_current_clip_iter=None, unused_total_clips=None):
""" a file was added to the medialibrary """
if isinstance(asset, GES.UriClipAsset):
self._updateProgressbar()
self._addAsset(asset)
- def _assetRemovedCb(self, unsued_project, asset):
+ def _assetRemovedCb(self, unused_project, asset):
""" the given uri was removed from the medialibrary """
# find the good line in the storemodel and remove it
model = self.storemodel
@@ -642,19 +642,19 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
self._welcome_infobar.show_all()
self.debug("Removing: %s", uri)
- def _errorCreatingAssetCb(self, unsued_project, error, id, type):
+ def _errorCreatingAssetCb(self, unused_project, error, id, type):
""" The given uri isn't a media file """
if GObject.type_is_a(type, GES.UriClip):
error = (id, str(error.domain), error)
self._errors.append(error)
self._updateProgressbar()
- def _sourcesStartedImportingCb(self, unsued_project):
+ def _sourcesStartedImportingCb(self, unused_project):
self.import_start_time = time.time()
self._welcome_infobar.hide()
self._progressbar.show()
- def _sourcesStoppedImportingCb(self, unsued_project):
+ def _sourcesStoppedImportingCb(self, unused_project):
self.debug("Importing took %.3f seconds", time.time() - self.import_start_time)
self.flush_pending_rows()
self._progressbar.hide()
@@ -920,7 +920,7 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
else:
self._draggedPaths = None
- def _treeViewButtonReleaseEventCb(self, treeview, event):
+ def _treeViewButtonReleaseEventCb(self, unused_treeview, event):
ts = self.treeview.get_selection()
state = event.get_state() & (Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK)
path = self.treeview.get_path_at_pos(event.x, event.y)
@@ -980,7 +980,7 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
iconview.unselect_all()
iconview.select_path(current_cursor_pos)
- def _newProjectCreatedCb(self, app, project):
+ def _newProjectCreatedCb(self, unused_app, project):
if not self._project is project:
self._project = project
self._resetErrorList()
@@ -1042,7 +1042,7 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
self.app.current_project.addUris(filenames)
#used with TreeView and IconView
- def _dndDragDataGetCb(self, unused_view, context, data, info, timestamp):
+ def _dndDragDataGetCb(self, unused_view, unused_context, data, unused_info, unused_timestamp):
paths = self.getSelectedPaths()
uris = [self.modelFilter[path][COL_URI] for path in paths]
data.set_uris(uris)
@@ -1058,7 +1058,7 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
row = self.modelFilter[paths[0]]
Gtk.drag_set_icon_pixbuf(context, row[COL_ICON_64], 0, 0)
- def _dndDragEndCb(self, unused_view, context):
+ def _dndDragEndCb(self, unused_view, unused_context):
self.info("Drag operation ended")
self.dragged = False
diff --git a/pitivi/project.py b/pitivi/project.py
index bf59c0d..97ce064 100644
--- a/pitivi/project.py
+++ b/pitivi/project.py
@@ -461,7 +461,7 @@ class ProjectManager(Signallable, Loggable):
if self._backup_lock < 60:
self._backup_lock += 5
- def _saveBackupCb(self, project, uri):
+ def _saveBackupCb(self, unused_project, unused_uri):
if self._backup_lock > 10:
self._backup_lock -= 5
return True
@@ -489,10 +489,10 @@ class ProjectManager(Signallable, Loggable):
name, ext = os.path.splitext(uri)
return name + ext + "~"
- def _missingURICb(self, project, error, asset, what=None):
+ def _missingURICb(self, project, error, asset, unused_what=None):
return self.emit("missing-uri", project, error, asset)
- def _projectLoadedCb(self, project, timeline):
+ def _projectLoadedCb(self, unused_project, unused_timeline):
self.debug("Project loaded %s", self.current_project.props.uri)
self.emit("new-project-loaded", self.current_project, True)
self.time_loaded = time()
@@ -529,7 +529,7 @@ class Project(Loggable, GES.Project):
GObject.TYPE_PYOBJECT,))
}
- def __init__(self, name="", uri=None, **kwargs):
+ def __init__(self, name="", uri=None, **unused_kwargs):
"""
@param name: the name of the project
@param uri: the uri of the project
@@ -806,7 +806,7 @@ class Project(Loggable, GES.Project):
#--------------------------------------------#
# GES.Project virtual methods implementation #
#--------------------------------------------#
- def _handle_asset_loaded(self, id):
+ def _handle_asset_loaded(self, unused_id):
self.nb_imported_files += 1
self.nb_remaining_file_to_import = len([asset for asset in self.get_loading_assets() if
GObject.type_is_a(asset.get_extractable_type(), GES.UriClip)])
@@ -821,11 +821,11 @@ class Project(Loggable, GES.Project):
"""
self._handle_asset_loaded(asset.get_id())
- def do_loading_error(self, error, id, type):
+ def do_loading_error(self, unused_error, id, unused_type):
""" vmethod, get called on "asset-loading-error"""
self._handle_asset_loaded(id)
- def do_loaded(self, timeline):
+ def do_loaded(self, unused_timeline):
""" vmethod, get called on "loaded" """
self._ensureTracks()
#self._ensureLayer()
@@ -1326,12 +1326,12 @@ class ProjectSettingsDialog():
"height": self.project.videoheight,
"width": self.project.videowidth})
- def _newPresetCb(self, model, path, iter_, column, renderer, treeview):
+ def _newPresetCb(self, unused_model, path, unused_iter_, column, renderer, treeview):
""" Handle the addition of a preset to the model of the preset manager. """
treeview.set_cursor_on_cell(path, column, renderer, start_editing=True)
treeview.grab_focus()
- def _presetNameEditedCb(self, renderer, path, new_text, mgr):
+ def _presetNameEditedCb(self, unused_renderer, path, new_text, mgr):
"""Handle the renaming of a preset."""
try:
mgr.renamePreset(path, new_text)
@@ -1339,7 +1339,7 @@ class ProjectSettingsDialog():
error_markup = _('"%s" already exists.') % new_text
self._showPresetManagerError(mgr, error_markup)
- def _presetNameEditingStartedCb(self, renderer, editable, path, mgr):
+ def _presetNameEditingStartedCb(self, unused_renderer, unused_editable, unused_path, mgr):
"""Handle the start of a preset renaming."""
self._hidePresetManagerError(mgr)
@@ -1354,7 +1354,7 @@ class ProjectSettingsDialog():
update_preset_buttons_func()
self._hidePresetManagerError(mgr)
- def _treeviewDefocusedCb(self, widget, event, mgr):
+ def _treeviewDefocusedCb(self, unused_widget, unused_event, mgr):
self._hidePresetManagerError(mgr)
def _showPresetManagerError(self, mgr, error_markup):
@@ -1416,7 +1416,7 @@ class ProjectSettingsDialog():
i += 1
return preset_name
- def _addAudioPresetButtonClickedCb(self, button):
+ def _addAudioPresetButtonClickedCb(self, unused_button):
preset_name = self._getUniquePresetName(self.audio_presets)
self.audio_presets.addPreset(preset_name, {
"channels": get_combo_value(self.channels_combo),
@@ -1425,18 +1425,18 @@ class ProjectSettingsDialog():
self.audio_presets.restorePreset(preset_name)
self._updateAudioPresetButtons()
- def _removeAudioPresetButtonClickedCb(self, button):
+ def _removeAudioPresetButtonClickedCb(self, unused_button):
selection = self.audio_preset_treeview.get_selection()
model, iter_ = selection.get_selected()
if iter_:
self.audio_presets.removePreset(model[iter_][0])
- def _saveAudioPresetButtonClickedCb(self, button):
+ def _saveAudioPresetButtonClickedCb(self, unused_button):
self.audio_presets.saveCurrentPreset()
self.save_audio_preset_button.set_sensitive(False)
self.remove_audio_preset_button.set_sensitive(True)
- def _addVideoPresetButtonClickedCb(self, button):
+ def _addVideoPresetButtonClickedCb(self, unused_button):
preset_name = self._getUniquePresetName(self.video_presets)
self.video_presets.addPreset(preset_name, {
"width": int(self.width_spinbutton.get_value()),
@@ -1447,13 +1447,13 @@ class ProjectSettingsDialog():
self.video_presets.restorePreset(preset_name)
self._updateVideoPresetButtons()
- def _removeVideoPresetButtonClickedCb(self, button):
+ def _removeVideoPresetButtonClickedCb(self, unused_button):
selection = self.video_preset_treeview.get_selection()
model, iter_ = selection.get_selected()
if iter_:
self.video_presets.removePreset(model[iter_][0])
- def _saveVideoPresetButtonClickedCb(self, button):
+ def _saveVideoPresetButtonClickedCb(self, unused_button):
self.video_presets.saveCurrentPreset()
self.save_video_preset_button.set_sensitive(False)
self.remove_video_preset_button.set_sensitive(True)
diff --git a/pitivi/render.py b/pitivi/render.py
index af711be..10c1d92 100644
--- a/pitivi/render.py
+++ b/pitivi/render.py
@@ -520,13 +520,13 @@ class RenderDialog(Loggable):
mgr, update_buttons_func)
treeview.connect("focus-out-event", self._treeviewDefocusedCb, mgr)
- def _newPresetCb(self, model, path, iter_, column, renderer, treeview):
+ def _newPresetCb(self, unused_model, path, unused_iter_, column, renderer, treeview):
"""Handle the addition of a preset to the model of the preset manager.
"""
treeview.set_cursor_on_cell(path, column, renderer, start_editing=True)
treeview.grab_focus()
- def _presetNameEditedCb(self, renderer, path, new_text, mgr):
+ def _presetNameEditedCb(self, unused_renderer, path, new_text, mgr):
"""Handle the renaming of a preset."""
from pitivi.preset import DuplicatePresetNameException
@@ -537,11 +537,11 @@ class RenderDialog(Loggable):
error_markup = _('"%s" already exists.') % new_text
self._showPresetManagerError(mgr, error_markup)
- def _presetNameEditingStartedCb(self, renderer, editable, path, mgr):
+ def _presetNameEditingStartedCb(self, unused_renderer, unused_editable, unused_path, mgr):
"""Handle the start of a preset renaming."""
self._hidePresetManagerError(mgr)
- def _treeviewDefocusedCb(self, widget, event, mgr):
+ def _treeviewDefocusedCb(self, unused_widget, unused_event, mgr):
"""Handle the treeview loosing the focus."""
self._hidePresetManagerError(mgr)
@@ -582,7 +582,7 @@ class RenderDialog(Loggable):
i += 1
return preset_name
- def _addRenderPresetButtonClickedCb(self, button):
+ def _addRenderPresetButtonClickedCb(self, unused_button):
preset_name = self._getUniquePresetName(self.render_presets)
self.render_presets.addPreset(preset_name, {
"channels": int(get_combo_value(self.channels_combo)),
@@ -598,7 +598,7 @@ class RenderDialog(Loggable):
self.render_presets.restorePreset(preset_name)
self._updateRenderPresetButtons()
- def _saveRenderPresetButtonClickedCb(self, button):
+ def _saveRenderPresetButtonClickedCb(self, unused_button):
self.render_presets.saveCurrentPreset()
self.save_render_preset_button.set_sensitive(False)
self.remove_render_preset_button.set_sensitive(True)
@@ -609,7 +609,7 @@ class RenderDialog(Loggable):
can_remove = self.render_presets.isRemoveButtonSensitive()
self.remove_render_preset_button.set_sensitive(can_remove)
- def _removeRenderPresetButtonClickedCb(self, button):
+ def _removeRenderPresetButtonClickedCb(self, unused_button):
selection = self.render_preset_treeview.get_selection()
model, iter_ = selection.get_selected()
if iter_:
@@ -663,7 +663,7 @@ class RenderDialog(Loggable):
presets_toolbar = builder.get_object("render_presets_toolbar")
presets_toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_INLINE_TOOLBAR)
- def _settingsChanged(self, project, key, value):
+ def _settingsChanged(self, unused_project, unused_key, unused_value):
self.updateResolution()
def _initializeComboboxModels(self):
@@ -693,7 +693,7 @@ class RenderDialog(Loggable):
set_combo_value(self.muxercombobox,
Gst.ElementFactory.find(self.project.muxer))
- def _checkForExistingFile(self, *args):
+ def _checkForExistingFile(self, *unused_args):
"""
Display a warning icon and tooltip if the file path already exists.
"""
@@ -837,7 +837,7 @@ class RenderDialog(Loggable):
self._disconnectFromGst()
self._pipeline.set_mode(GES.PipelineFlags.FULL_PREVIEW)
- def _pauseRender(self, progress):
+ def _pauseRender(self, unused_progress):
self._rendering_is_paused = self.progress.play_pause_button.get_active()
if self._rendering_is_paused:
self._last_timestamp_when_pausing = time.time()
@@ -918,7 +918,7 @@ class RenderDialog(Loggable):
self.debug("Render dialog's Close button clicked")
self.destroy()
- def _deleteEventCb(self, window, event):
+ def _deleteEventCb(self, unused_window, unused_event):
self.debug("Render dialog is being deleted")
self.destroy()
@@ -992,7 +992,7 @@ class RenderDialog(Loggable):
else:
self.system.uninhibitSleep(RenderDialog.INHIBIT_REASON)
- def _updatePositionCb(self, pipeline, position):
+ def _updatePositionCb(self, unused_pipeline, position):
"""
Unlike other progression indicator callbacks, this one occurs every time
the pipeline emits a position changed signal, which is *very* often.
@@ -1018,7 +1018,7 @@ class RenderDialog(Loggable):
if not self._filesizeEstimateTimer and (fraction > 0.33 or timediff > 180):
self._filesizeEstimateTimer = GLib.timeout_add_seconds(5, self._updateFilesizeEstimateCb)
- def _elementAddedCb(self, bin, element):
+ def _elementAddedCb(self, unused_bin, element):
"""
Setting properties on Gst.Element-s has they are added to the
Gst.Encodebin
@@ -1035,7 +1035,7 @@ class RenderDialog(Loggable):
self.debug("Setting %s to %s", propname, value)
#-- Settings changed callbacks
- def _scaleSpinbuttonChangedCb(self, button):
+ def _scaleSpinbuttonChangedCb(self, unused_button):
render_scale = self.scale_spinbutton.get_value()
self.project.render_scale = render_scale
self.updateResolution()
@@ -1044,12 +1044,12 @@ class RenderDialog(Loggable):
width, height = self.project.getVideoWidthAndHeight(True)
self.resolution_label.set_text(u"%d×%d" % (width, height))
- def _projectSettingsButtonClickedCb(self, button):
+ def _projectSettingsButtonClickedCb(self, unused_button):
from pitivi.project import ProjectSettingsDialog
dialog = ProjectSettingsDialog(self.window, self.project)
dialog.window.run()
- def _audioOutputCheckbuttonToggledCb(self, audio):
+ def _audioOutputCheckbuttonToggledCb(self, unused_audio):
active = self.audio_output_checkbutton.get_active()
if active:
self.channels_combo.set_sensitive(True)
@@ -1065,7 +1065,7 @@ class RenderDialog(Loggable):
if not self.video_output_checkbutton.get_active():
self.render_button.set_sensitive(False)
- def _videoOutputCheckbuttonToggledCb(self, video):
+ def _videoOutputCheckbuttonToggledCb(self, unused_video):
active = self.video_output_checkbutton.get_active()
if active:
self.scale_spinbutton.set_sensitive(True)
@@ -1093,7 +1093,7 @@ class RenderDialog(Loggable):
# The user directly changed the video encoder combo.
self.preferred_vencoder = vencoder
- def _videoSettingsButtonClickedCb(self, button):
+ def _videoSettingsButtonClickedCb(self, unused_button):
factory = get_combo_value(self.video_encoder_combo)
self._elementSettingsDialog(factory, 'vcodecsettings')
@@ -1110,7 +1110,7 @@ class RenderDialog(Loggable):
# The user directly changed the audio encoder combo.
self.preferred_aencoder = aencoder
- def _audioSettingsButtonClickedCb(self, button):
+ def _audioSettingsButtonClickedCb(self, unused_button):
factory = get_combo_value(self.audio_encoder_combo)
self._elementSettingsDialog(factory, 'acodecsettings')
diff --git a/pitivi/settings.py b/pitivi/settings.py
index beebe79..f7205b2 100644
--- a/pitivi/settings.py
+++ b/pitivi/settings.py
@@ -76,7 +76,7 @@ def get_dirs(glob):
return [d for d in glob.split(os.path.pathsep) if os.path.exists(d)]
-def get_env_dir(var, default, autocreate=True):
+def get_env_dir(var, default, unused_autocreate=True):
return get_dir(get_env_default(var, default))
@@ -137,7 +137,7 @@ class GlobalSettings(Signallable):
defaults = {}
__signals__ = {}
- def __init__(self, **kwargs):
+ def __init__(self, **unused_kwargs):
Signallable.__init__(self)
self._config = SafeConfigParser()
self._readSettingsFromGlobalConfiguration()
diff --git a/pitivi/tabsmanager.py b/pitivi/tabsmanager.py
index f40b639..46db674 100644
--- a/pitivi/tabsmanager.py
+++ b/pitivi/tabsmanager.py
@@ -64,7 +64,7 @@ class BaseTabs(Gtk.Notebook):
self.insert_page(child, label, original_position)
self._set_child_properties(child, label)
- def _createWindowCb(self, from_notebook, child, unused_x, unused_y):
+ def _createWindowCb(self, unused_from_notebook, child, unused_x, unused_y):
"""
Callback that occurs when tearing off a tab to create a new window
"""
@@ -113,7 +113,7 @@ class BaseTabs(Gtk.Notebook):
else:
return notebook
- def _detachedComponentWindowConfiguredCb(self, window, event, child_name):
+ def _detachedComponentWindowConfiguredCb(self, unused_window, event, child_name):
"""
When the user configures the detached window
(changes its size, position, etc.), save the settings.
diff --git a/pitivi/timeline/controls.py b/pitivi/timeline/controls.py
index 1bee9ae..09e67cb 100644
--- a/pitivi/timeline/controls.py
+++ b/pitivi/timeline/controls.py
@@ -58,7 +58,7 @@ class ControlActor(GtkClutter.Actor):
self.dragAction.connect("drag-progress", self._dragProgressCb)
self.dragAction.connect("drag-end", self._dragEndCb)
- def _dragBeginCb(self, action, actor, event_x, event_y, modifiers):
+ def _dragBeginCb(self, unused_action, unused_actor, event_x, unused_event_y, unused_modifiers):
self.brother = self._container.getBrotherControl(self)
self.brother.raise_top()
@@ -67,7 +67,7 @@ class ControlActor(GtkClutter.Actor):
self.nbrLayers = len(self._container.timeline.bTimeline.get_layers())
self._dragBeginStartX = event_x
- def _dragProgressCb(self, action, actor, delta_x, delta_y):
+ def _dragProgressCb(self, unused_action, actor, unused_delta_x, delta_y):
y = self.dragAction.get_motion_coords()[1]
priority = self._getLayerForY(y)
lowerLimit = 0
@@ -82,7 +82,7 @@ class ControlActor(GtkClutter.Actor):
self._container.moveLayer(self, priority)
return False
- def _dragEndCb(self, action, actor, event_x, event_y, modifiers):
+ def _dragEndCb(self, unused_action, unused_actor, unused_event_x, event_y, unused_modifiers):
priority = self._getLayerForY(event_y)
if self.layer.get_priority() != priority and priority >= 0 and priority < self.nbrLayers:
diff --git a/pitivi/timeline/elements.py b/pitivi/timeline/elements.py
index d6a5a47..ebdc9d0 100644
--- a/pitivi/timeline/elements.py
+++ b/pitivi/timeline/elements.py
@@ -252,7 +252,7 @@ class TrimHandle(Clutter.Texture):
#Callbacks
- def _enterEventCb(self, actor, event):
+ def _enterEventCb(self, unused_actor, unused_event):
self.timelineElement.set_reactive(False)
for elem in self.timelineElement.get_children():
elem.set_reactive(False)
@@ -264,7 +264,7 @@ class TrimHandle(Clutter.Texture):
else:
self.timelineElement.timeline._container.embed.get_window().set_cursor(DRAG_RIGHT_HANDLEBAR_CURSOR)
- def _leaveEventCb(self, actor, event):
+ def _leaveEventCb(self, unused_actor, event):
self.timelineElement.set_reactive(True)
children = self.timelineElement.get_children()
@@ -277,13 +277,13 @@ class TrimHandle(Clutter.Texture):
self.set_from_file(os.path.join(configure.get_pixmap_dir(), "trimbar-normal.png"))
self.timelineElement.timeline._container.embed.get_window().set_cursor(NORMAL_CURSOR)
- def _elementEnterEventCb(self, actor, event):
+ def _elementEnterEventCb(self, unused_actor, unused_event):
self.show()
- def _elementLeaveEventCb(self, actor, event):
+ def _elementLeaveEventCb(self, unused_actor, unused_event):
self.hide()
- def _dragBeginCb(self, action, actor, event_x, event_y, modifiers):
+ def _dragBeginCb(self, unused_action, unused_actor, event_x, event_y, unused_modifiers):
self.dragBeginStartX = event_x
self.dragBeginStartY = event_y
elem = self.timelineElement.bElement.get_parent()
@@ -307,7 +307,7 @@ class TrimHandle(Clutter.Texture):
self._context.connect("clip-trim", self.clipTrimCb)
self._context.connect("clip-trim-finished", self.clipTrimFinishedCb)
- def _dragProgressCb(self, action, actor, delta_x, delta_y):
+ def _dragProgressCb(self, unused_action, unused_actor, delta_x, unused_delta_y):
# We can't use delta_x here because it fluctuates weirdly.
coords = self.dragAction.get_motion_coords()
delta_x = coords[0] - self.dragBeginStartX
@@ -317,7 +317,7 @@ class TrimHandle(Clutter.Texture):
self._context.editTo(new_start,
self.timelineElement.bElement.get_parent().get_layer().get_priority())
return False
- def _dragEndCb(self, action, actor, event_x, event_y, modifiers):
+ def _dragEndCb(self, unused_action, unused_actor, unused_event_x, unused_event_y, unused_modifiers):
self.timelineElement.setDragged(False)
self._context.finish()
@@ -653,21 +653,21 @@ class TimelineElement(Clutter.Actor, Zoomable):
def _dragBeginCb(self, action, actor, event_x, event_y, modifiers):
pass
- def _dragProgressCb(self, action, actor, delta_x, delta_y):
+ def _dragProgressCb(self, unused_action, unused_actor, unused_delta_x, unused_delta_y):
return False
def _dragEndCb(self, action, actor, event_x, event_y, modifiers):
pass
- def _durationChangedCb(self, element, duration):
+ def _durationChangedCb(self, unused_element, unused_duration):
if self.keyframesVisible:
self.updateKeyframes()
- def _inpointChangedCb(self, element, inpoint):
+ def _inpointChangedCb(self, unused_element, unused_inpoint):
if self.keyframesVisible:
self.updateKeyframes()
- def _selectedChangedCb(self, selected, isSelected):
+ def _selectedChangedCb(self, unused_selected, isSelected):
self.isSelected = isSelected
if not isSelected:
self.hideKeyframes()
@@ -693,7 +693,7 @@ class Gradient(Clutter.Actor):
self.set_content(self.canvas)
self.canvas.invalidate()
- def _drawCb(self, canvas, cr, width, height):
+ def _drawCb(self, unused_canvas, cr, unused_width, unused_height):
cr.set_operator(cairo.OPERATOR_CLEAR)
cr.paint()
cr.set_operator(cairo.OPERATOR_OVER)
@@ -733,7 +733,7 @@ class Line(Clutter.Actor):
self.previousKeyframe = lastKeyframe
self.nextKeyframe = keyframe
- def _drawCb(self, canvas, cr, width, unused_height):
+ def _drawCb(self, unused_canvas, cr, width, unused_height):
"""
This is where we actually create the line segments for keyframe curves.
We draw multiple lines (one-third of the height each) to add a "shadow"
@@ -780,7 +780,7 @@ class Line(Clutter.Actor):
self.timelineElement.set_reactive(True)
self.timelineElement.timeline._container.embed.get_window().set_cursor(NORMAL_CURSOR)
- def _clickedCb(self, actor, event):
+ def _clickedCb(self, unused_actor, event):
if self.gotDragged:
self.gotDragged = False
return
@@ -791,24 +791,24 @@ class Line(Clutter.Actor):
timestamp = Zoomable.pixelToNs(x)
self.timelineElement.addKeyframe(value, timestamp)
- def _enterEventCb(self, actor, event):
+ def _enterEventCb(self, unused_actor, unused_event):
self.timelineElement.set_reactive(False)
self.timelineElement.timeline._container.embed.get_window().set_cursor(DRAG_CURSOR)
- def _leaveEventCb(self, actor, event):
+ def _leaveEventCb(self, unused_actor, unused_event):
self._ungrab()
def _motionEventCb(self, actor, event):
pass
- def _dragBeginCb(self, action, actor, event_x, event_y, modifiers):
+ def _dragBeginCb(self, unused_action, unused_actor, event_x, event_y, unused_modifiers):
self.dragBeginStartX = event_x
self.dragBeginStartY = event_y
self.origY = self.props.y
self.previousKeyframe.startDrag(event_x, event_y, self)
self.nextKeyframe.startDrag(event_x, event_y, self)
- def _dragProgressCb(self, action, actor, delta_x, delta_y):
+ def _dragProgressCb(self, unused_action, unused_actor, unused_delta_x, delta_y):
self.gotDragged = True
coords = self.dragAction.get_motion_coords()
delta_x = coords[0] - self.dragBeginStartX
@@ -819,7 +819,7 @@ class Line(Clutter.Actor):
return False
- def _dragEndCb(self, action, actor, event_x, event_y, modifiers):
+ def _dragEndCb(self, unused_action, unused_actor, unused_event_x, unused_event_y, unused_modifiers):
self.previousKeyframe.endDrag()
self.nextKeyframe.endDrag()
if self.timelineElement.timeline.getActorUnderPointer() != self:
@@ -850,7 +850,7 @@ class KeyframeMenu(GtkClutter.Actor):
GtkClutter.Actor.hide(self)
self.vbox.hide()
- def _removeClickedCb(self, button):
+ def _removeClickedCb(self, unused_button):
self.keyframe.remove()
@@ -908,7 +908,7 @@ class Keyframe(Clutter.Actor):
if actor != self.menu:
self.menu.hide()
- def _clickedCb(self, actor, event):
+ def _clickedCb(self, unused_actor, event):
if (event.modifier_state & Clutter.ModifierType.CONTROL_MASK):
self.remove()
elif (datetime.now() - self.lastClick).total_seconds() < 0.5:
@@ -916,12 +916,12 @@ class Keyframe(Clutter.Actor):
self.lastClick = datetime.now()
- def _enterEventCb(self, actor, event):
+ def _enterEventCb(self, unused_actor, unused_event):
self.timelineElement.set_reactive(False)
self.set_background_color(KEYFRAME_SELECTED_COLOR)
self.timelineElement.timeline._container.embed.get_window().set_cursor(DRAG_CURSOR)
- def _leaveEventCb(self, actor, event):
+ def _leaveEventCb(self, unused_actor, unused_event):
self._unselect()
def startDrag(self, event_x, event_y, line=None):
@@ -971,11 +971,11 @@ class Keyframe(Clutter.Actor):
if not self.line:
self.timelineElement.timeline._container.seekInPosition(newTs + self.start)
- def _dragBeginCb(self, action, actor, event_x, event_y, modifiers):
+ def _dragBeginCb(self, unused_action, unused_actor, event_x, event_y, unused_modifiers):
self.dragProgressed = False
self.startDrag(event_x, event_y)
- def _dragProgressCb(self, action, actor, delta_x, delta_y):
+ def _dragProgressCb(self, unused_action, unused_actor, delta_x, delta_y):
self.dragProgressed = True
coords = self.dragAction.get_motion_coords()
delta_x = coords[0] - self.dragBeginStartX
@@ -983,7 +983,7 @@ class Keyframe(Clutter.Actor):
self.updateValue(delta_x, delta_y)
return False
- def _dragEndCb(self, action, actor, event_x, event_y, modifiers):
+ def _dragEndCb(self, unused_action, unused_actor, unused_event_x, unused_event_y, unused_modifiers):
self.endDrag()
if self.timelineElement.timeline.getActorUnderPointer() != self:
self._unselect()
diff --git a/pitivi/timeline/layer.py b/pitivi/timeline/layer.py
index 4c6cdbe..944ba48 100644
--- a/pitivi/timeline/layer.py
+++ b/pitivi/timeline/layer.py
@@ -166,7 +166,7 @@ class BaseLayerControl(Gtk.VBox, Loggable):
selected = property(getSelected, setSelected, None, "Selection state")
- def _foldingChangedCb(self, button, state):
+ def _foldingChangedCb(self, unused_button, state):
if state:
self.lower_hbox.show()
else:
@@ -189,7 +189,7 @@ class BaseLayerControl(Gtk.VBox, Loggable):
# Enable all layers
self._app.gui.timeline_ui.controls.soloLayer(None)
- def _buttonPressCb(self, widget, event):
+ def _buttonPressCb(self, unused_widget, event):
"""
Look if user selected layer or wants popup menu
"""
@@ -211,10 +211,10 @@ class BaseLayerControl(Gtk.VBox, Loggable):
# continue GTK signal propagation
return True
- def _deleteLayerCb(self, widget):
+ def _deleteLayerCb(self, unused_widget):
self._control_container.timeline.bTimeline.remove_layer(self.layer)
- def _moveLayerCb(self, widget, step):
+ def _moveLayerCb(self, unused_widget, step):
index = self.layer.get_priority()
if abs(step) == 1:
index += step
@@ -351,7 +351,7 @@ class TwoStateButton(Gtk.Button):
def set_states(self, state1, state2):
self.states = {True: state1, False: state2}
- def _clickedCb(self, widget):
+ def _clickedCb(self, unused_widget):
self._state = not self._state
self.set_label(self.states[self._state])
diff --git a/pitivi/timeline/previewers.py b/pitivi/timeline/previewers.py
index be49b94..6fdb5d0 100644
--- a/pitivi/timeline/previewers.py
+++ b/pitivi/timeline/previewers.py
@@ -483,7 +483,7 @@ class VideoPreviewer(Clutter.ScrollActor, PreviewGenerator, Zoomable, Loggable):
self._checkCPU()
return Gst.BusSyncReply.PASS
- def _autoplugSelectCb(self, decode, pad, caps, factory):
+ def _autoplugSelectCb(self, unused_decode, unused_pad, unused_caps, factory):
# Don't plug audio decoders / parsers.
if "Audio" in factory.get_klass():
return True
@@ -701,7 +701,7 @@ class PipelineCpuAdapter(Loggable):
# Keep the glib timer running:
return True
- def _messageCb(self, bus, message):
+ def _messageCb(self, unused_bus, message):
if not self.ready:
return
if message.type == Gst.MessageType.STATE_CHANGED:
@@ -786,7 +786,7 @@ class AudioPreviewer(Clutter.Actor, PreviewGenerator, Zoomable, Loggable):
bus.connect("message", self._messageCb)
self.becomeControlled()
- def set_size(self, width, height):
+ def set_size(self, unused_width, unused_height):
if self.discovered:
self._maybeUpdate()
@@ -933,13 +933,13 @@ class AudioPreviewer(Clutter.Actor, PreviewGenerator, Zoomable, Loggable):
self.adapter = PipelineCpuAdapter(self.pipeline)
self.adapter.start()
- def _autoplugSelectCb(self, decode, pad, caps, factory):
+ def _autoplugSelectCb(self, unused_decode, unused_pad, unused_caps, factory):
# Don't plug video decoders / parsers.
if "Video" in factory.get_klass():
return True
return False
- def _drawContentCb(self, canvas, cr, surf_w, surf_h):
+ def _drawContentCb(self, unused_canvas, cr, unused_surf_w, unused_surf_h):
cr.set_operator(cairo.OPERATOR_CLEAR)
cr.paint()
if not self.discovered:
diff --git a/pitivi/timeline/ruler.py b/pitivi/timeline/ruler.py
index 76a47f3..6e42113 100644
--- a/pitivi/timeline/ruler.py
+++ b/pitivi/timeline/ruler.py
@@ -155,12 +155,12 @@ class ScaleRuler(Gtk.DrawingArea, Zoomable, Loggable):
def setPipeline(self, pipeline):
pipeline.connect('position', self.timelinePositionCb)
- def timelinePositionCb(self, pipeline, position):
+ def timelinePositionCb(self, unused_pipeline, position):
self.position = position
self.queue_draw()
## Gtk.Widget overrides
- def configureEventCb(self, widget, event, data=None):
+ def configureEventCb(self, widget, unused_event, unused_data=None):
width = widget.get_allocated_width()
height = widget.get_allocated_height()
self.debug("Configuring, height %d, width %d", width, height)
@@ -175,7 +175,7 @@ class ScaleRuler(Gtk.DrawingArea, Zoomable, Loggable):
return False
- def drawCb(self, widget, context):
+ def drawCb(self, unused_widget, context):
if self.pixbuf is None:
self.info('No buffer to paint')
return False
diff --git a/pitivi/timeline/timeline.py b/pitivi/timeline/timeline.py
index bd002fe..20ed640 100644
--- a/pitivi/timeline/timeline.py
+++ b/pitivi/timeline/timeline.py
@@ -211,7 +211,7 @@ class TimelineStage(Clutter.ScrollActor, Zoomable):
del ghostclip
self.ghostClips = []
- def addGhostClip(self, asset, x, y):
+ def addGhostClip(self, asset, unused_x, unused_y):
ghostAudio = ghostVideo = None
if asset.get_supported_formats() & GES.TrackType.VIDEO:
@@ -426,7 +426,7 @@ class TimelineStage(Clutter.ScrollActor, Zoomable):
self.add_child(element)
- def _removeTimelineElement(self, track, bElement):
+ def _removeTimelineElement(self, unused_track, bElement):
if isinstance(bElement, GES.Effect):
return
bElement.disconnect_by_func(self._elementStartChangedCb)
@@ -526,7 +526,7 @@ class TimelineStage(Clutter.ScrollActor, Zoomable):
# Callbacks
- def _dragBeginCb(self, actor, event):
+ def _dragBeginCb(self, unused_actor, event):
self.drawMarquee = self.getActorUnderPointer() == self
if not self.drawMarquee:
return
@@ -541,7 +541,7 @@ class TimelineStage(Clutter.ScrollActor, Zoomable):
self.marquee.set_position(event.x - CONTROL_WIDTH, event.y)
self.marquee.show()
- def _dragProgressCb(self, actor, event):
+ def _dragProgressCb(self, unused_actor, event):
if not self.drawMarquee:
return False
@@ -552,7 +552,7 @@ class TimelineStage(Clutter.ScrollActor, Zoomable):
return False
- def _dragEndCb(self, actor, event):
+ def _dragEndCb(self, unused_actor, event):
if not self.drawMarquee:
return
self.drawMarquee = False
@@ -575,7 +575,7 @@ class TimelineStage(Clutter.ScrollActor, Zoomable):
return elements
# snapping indicator
- def _snapCb(self, unused_timeline, obj1, obj2, position):
+ def _snapCb(self, unused_timeline, unused_obj1, unused_obj2, position):
"""
Display or hide a snapping indicator line
"""
@@ -587,13 +587,13 @@ class TimelineStage(Clutter.ScrollActor, Zoomable):
self._snap_indicator.props.x = Zoomable.nsToPixel(position)
self._snap_indicator.props.visible = True
- def _snapEndedCb(self, *args):
+ def _snapEndedCb(self, *unused_args):
self._snap_indicator.props.visible = False
- def _layerAddedCb(self, timeline, layer):
+ def _layerAddedCb(self, unused_timeline, layer):
self._add_layer(layer)
- def _layerRemovedCb(self, timeline, layer):
+ def _layerRemovedCb(self, unused_timeline, layer):
# FIXME : really remove layer ^^
for lyr in self.bTimeline.get_layers():
if lyr.props.priority > layer.props.priority:
@@ -601,11 +601,11 @@ class TimelineStage(Clutter.ScrollActor, Zoomable):
self._remove_layer(layer)
self._updatePlayHead()
- def _trackAddedCb(self, timeline, track):
+ def _trackAddedCb(self, unused_timeline, track):
self._connectTrack(track)
self._container.app.current_project.update_restriction_caps()
- def _trackRemovedCb(self, timeline, track):
+ def _trackRemovedCb(self, unused_timeline, track):
self._disconnectTrack(track)
for element in track.get_elements():
self._trackElementRemovedCb(track, element)
@@ -616,10 +616,10 @@ class TimelineStage(Clutter.ScrollActor, Zoomable):
def _trackElementRemovedCb(self, track, bElement):
self._removeTimelineElement(track, bElement)
- def _elementPriorityChangedCb(self, bElement, priority, element):
+ def _elementPriorityChangedCb(self, unused_bElement, unused_priority, element):
self._setElementY(element)
- def _elementStartChangedCb(self, bElement, start, element):
+ def _elementStartChangedCb(self, unused_bElement, unused_start, element):
self._updateSize()
self.allowSeek = False
@@ -628,16 +628,16 @@ class TimelineStage(Clutter.ScrollActor, Zoomable):
else:
self._setElementX(element)
- def _elementDurationChangedCb(self, bElement, duration, element):
+ def _elementDurationChangedCb(self, unused_bElement, unused_duration, element):
self._updateSize()
self.allowSeek = False
element.update(False)
- def _elementInPointChangedCb(self, bElement, inpoint, element):
+ def _elementInPointChangedCb(self, unused_bElement, unused_inpoint, element):
self.allowSeek = False
self._setElementX(element, ease=False)
- def _layerPriorityChangedCb(self, layer, priority):
+ def _layerPriorityChangedCb(self, unused_layer, unused_priority):
self._redraw()
@@ -918,7 +918,7 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
self.info("Blocking timeline mouse and keyboard signals")
self.stage.connect("captured-event", self._ignoreAllEventsCb)
- def _ignoreAllEventsCb(self, *args):
+ def _ignoreAllEventsCb(self, *unused_args):
return True
def _setUpDragAndDrop(self):
@@ -1033,7 +1033,7 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
self.playhead_actions.add_actions(playhead_actions)
self.ui_manager.insert_action_group(self.playhead_actions, -1)
- def _updateScrollPosition(self, adjustment):
+ def _updateScrollPosition(self, unused_adjustment):
self._scroll_pos_ns = Zoomable.pixelToNs(self.hadj.get_value())
point = Clutter.Point()
point.x = self.hadj.get_value()
@@ -1204,7 +1204,7 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
self.error("Could not start the autoaligner: %s" % e)
progress_dialog.window.destroy()
- def _splitCb(self, action):
+ def _splitCb(self, unused_action):
"""
If clips are selected, split them at the current playhead position.
Otherwise, split all clips at the playhead position.
@@ -1228,7 +1228,7 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
clip = element.get_parent()
clip.split(position)
- def _keyframeCb(self, action):
+ def _keyframeCb(self, unused_action):
"""
Add or remove a keyframe at the current position of the selected clip.
"""
@@ -1327,7 +1327,7 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
else:
self._project.pipeline.stepFrame(self._framerate, 1)
- def _keyReleaseEventCb(self, widget, event):
+ def _keyReleaseEventCb(self, unused_widget, event):
if event.keyval == Gdk.KEY_Shift_L:
self._shiftMask = False
elif event.keyval == Gdk.KEY_Control_L:
@@ -1341,7 +1341,7 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
self.log("Timeline has lost focus")
self.setActionsSensitivity(False)
- def _timelineClickedCb(self, unused_timeline, event):
+ def _timelineClickedCb(self, unused_timeline, unused_event):
self.pressed = True
self.grab_focus() # Prevent other widgets from being confused
@@ -1371,11 +1371,11 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
if item == "width" or item == "height" or item == "videorate":
project.update_restriction_caps()
- def _snapDistanceChangedCb(self, settings):
+ def _snapDistanceChangedCb(self, unused_settings):
if self.bTimeline:
self.bTimeline.set_snapping_distance(Zoomable.pixelToNs(self._settings.edgeSnapDeadband))
- def _projectChangedCb(self, app, project, unused_fully_loaded):
+ def _projectChangedCb(self, unused_app, project, unused_fully_loaded):
"""
When a project is loaded, we connect to its pipeline
"""
@@ -1390,7 +1390,7 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
self._renderingSettingsChangedCb(self._project, None, None)
self._setBestZoomRatio()
- def _projectCreatedCb(self, app, project):
+ def _projectCreatedCb(self, unused_app, project):
"""
When a project is created, we connect to it timeline
"""
@@ -1418,7 +1418,7 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
self.log("Setting 'zoomed_fitted' to False")
self.zoomed_fitted = False
- def _zoomFitCb(self, unused, unsued2=None):
+ def _zoomFitCb(self, unused, unused_2=None):
self._setBestZoomRatio(allow_zoom_in=True)
def _screenshotCb(self, unused_action):
@@ -1430,21 +1430,21 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
path, mime = foo[0], foo[1]
self._project.pipeline.save_thumbnail(-1, -1, mime, path)
- def _previousKeyframeCb(self, action):
+ def _previousKeyframeCb(self, unused_action):
position = self._project.pipeline.getPosition()
prev_kf = self.timeline.getPrevKeyframe(position)
if prev_kf:
self._seeker.seek(prev_kf)
self.scrollToPlayhead()
- def _nextKeyframeCb(self, action):
+ def _nextKeyframeCb(self, unused_action):
position = self._project.pipeline.getPosition()
next_kf = self.timeline.getNextKeyframe(position)
if next_kf:
self._seeker.seek(next_kf)
self.scrollToPlayhead()
- def _scrollEventCb(self, embed, event):
+ def _scrollEventCb(self, unused_embed, event):
# FIXME : see https://bugzilla.gnome.org/show_bug.cgi?id=697522
deltas = event.get_scroll_deltas()
if event.state & Gdk.ModifierType.CONTROL_MASK:
@@ -1489,7 +1489,7 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
# drag and drop
- def _dragDataReceivedCb(self, widget, context, x, y, data, info, time):
+ def _dragDataReceivedCb(self, widget, context, unused_x, unused_y, data, unused_info, time):
if not self.dropDataReady:
if data.get_length() > 0:
if not self.dropOccured:
@@ -1563,7 +1563,7 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
self.dropHighlight = True
return True
- def _dragLeaveCb(self, widget, context, time):
+ def _dragLeaveCb(self, widget, unused_context, unused_time):
if self.dropDataReady:
self.dropDataReady = False
if self.dropHighlight:
diff --git a/pitivi/titleeditor.py b/pitivi/titleeditor.py
index c540ad1..bfd358c 100644
--- a/pitivi/titleeditor.py
+++ b/pitivi/titleeditor.py
@@ -96,7 +96,7 @@ class AttrIterator():
def get_iterator(self):
tmplist = []
- def fil(val, data):
+ def fil(val, unused_data):
tmplist.append(val)
return False
@@ -364,7 +364,7 @@ class PangoBuffer(Gtk.TextBuffer):
intervals.extend(tmpint)
return tagdict
- def get_text(self, start=None, end=None, include_hidden_chars=True):
+ def get_text(self, start=None, end=None, unused_include_hidden_chars=True):
tagdict = self.get_tags()
if not start:
start = self.get_start_iter()
@@ -570,7 +570,7 @@ class InteractivePangoBuffer(PangoBuffer):
class TitleEditor(Loggable):
- def __init__(self, instance, uimap):
+ def __init__(self, instance, unused_uimap):
Loggable.__init__(self)
Signallable.__init__(self)
self.app = instance
@@ -726,7 +726,7 @@ class TitleEditor(Loggable):
else:
self.bt["back_color"].set_visible(False)
- def _updateSourceText(self, updated_obj):
+ def _updateSourceText(self, unused_updated_obj):
if self.source is not None:
if self.markup_button.get_active():
text = self.textbuffer.get_text(self.textbuffer.get_start_iter(),
@@ -820,7 +820,7 @@ class TitleEditor(Loggable):
self.app.gui.viewer.target.disconnect_by_func(self.drag_release_event)
self._signals_connected = False
- def drag_press_event(self, widget, event):
+ def drag_press_event(self, unused_widget, event):
if event.button == 1:
self._drag_events = [(event.x, event.y)]
#Update drag by drag event change, but not too often
@@ -858,17 +858,17 @@ class TitleEditor(Loggable):
else:
return False
- def drag_notify_event(self, widget, event):
+ def drag_notify_event(self, unused_widget, event):
if len(self._drag_events) > 0 and event.get_state() & Gdk.ModifierType.BUTTON1_MASK:
self._drag_updated = True
self._drag_events.append((event.x, event.y))
st = self._drag_events[0]
e = self._drag_events[-1]
- def drag_release_event(self, widget, event):
+ def drag_release_event(self, unused_widget, unused_event):
self._drag_events = []
- def tab_switched(self, unused_notebook, arg1, arg2):
+ def tab_switched(self, unused_notebook, unused_arg1, arg2):
if arg2 == 2:
self._connect_signals()
else:
diff --git a/pitivi/transitions.py b/pitivi/transitions.py
index d8e92e2..d056a09 100644
--- a/pitivi/transitions.py
+++ b/pitivi/transitions.py
@@ -42,7 +42,7 @@ from pitivi.utils.ui import SPACING, PADDING
class TransitionsListWidget(Signallable, Gtk.VBox, Loggable):
- def __init__(self, instance, uiman):
+ def __init__(self, instance, unused_uiman):
Gtk.VBox.__init__(self)
Loggable.__init__(self)
Signallable.__init__(self)
@@ -145,7 +145,7 @@ class TransitionsListWidget(Signallable, Gtk.VBox, Loggable):
# UI callbacks
- def _transitionSelectedCb(self, event):
+ def _transitionSelectedCb(self, unused_event):
transition_asset = self.getSelectedItem()
if not transition_asset:
# The user clicked between icons
@@ -191,10 +191,10 @@ class TransitionsListWidget(Signallable, Gtk.VBox, Loggable):
self.borderScale.add_mark(0, Gtk.PositionType.BOTTOM, _("Sharp"))
self.borderScale.add_mark(25000, Gtk.PositionType.BOTTOM, _("Smooth"))
- def _searchEntryChangedCb(self, entry):
+ def _searchEntryChangedCb(self, unused_entry):
self.modelFilter.refilter()
- def _searchEntryIconClickedCb(self, entry, unused, unsed1):
+ def _searchEntryIconClickedCb(self, entry, unused, unused_1):
entry.set_text("")
# GES callbacks
@@ -346,7 +346,7 @@ class TransitionsListWidget(Signallable, Gtk.VBox, Loggable):
return None
return self.modelFilter[path[0]][COL_TRANSITION_ASSET]
- def _setRowVisible(self, model, iter, data):
+ def _setRowVisible(self, model, iter, unused_data):
"""
Filters the icon view depending on the search results
"""
diff --git a/pitivi/undo/undo.py b/pitivi/undo/undo.py
index b579ca8..489ec47 100644
--- a/pitivi/undo/undo.py
+++ b/pitivi/undo/undo.py
@@ -225,7 +225,7 @@ class UndoableActionLog(Signallable, Loggable):
current_snapshot = self._takeSnapshot()
return current_snapshot != self._checkpoint
- def _runStack(self, stack, run):
+ def _runStack(self, unused_stack, run):
self.running = True
try:
run()
@@ -244,7 +244,7 @@ class UndoableActionLog(Signallable, Loggable):
return stack
- def _stackIsNested(self, stack):
+ def _stackIsNested(self, unused_stack):
return bool(len(self.stacks))
@@ -272,16 +272,16 @@ class DebugActionLogObserver(Loggable):
self._actionLogrollbackCb, self._actionLogPushCb):
log.disconnect_by_func(method)
- def _actionLogBeginCb(self, log, stack, nested):
+ def _actionLogBeginCb(self, unused_log, stack, nested):
self.debug("begin action %s nested %s", stack.action_group_name, nested)
- def _actionLogCommitCb(self, log, stack, nested):
+ def _actionLogCommitCb(self, unused_log, stack, nested):
self.debug("commit action %s nested %s", stack.action_group_name, nested)
- def _actionLogRollbackCb(self, log, stack, nested):
+ def _actionLogRollbackCb(self, unused_log, stack, nested):
self.debug("rollback action %s nested %s", stack.action_group_name, nested)
- def _actionLogPushCb(self, log, stack, action):
+ def _actionLogPushCb(self, unused_log, stack, action):
self.debug("push %s in %s", action, stack.action_group_name)
diff --git a/pitivi/utils/extract.py b/pitivi/utils/extract.py
index dd2760c..6ab6682 100644
--- a/pitivi/utils/extract.py
+++ b/pitivi/utils/extract.py
@@ -177,13 +177,13 @@ class RandomAccessAudioExtractor(RandomAccessExtractor):
# message is received before setting self._ready = True,
# which enables extraction to proceed.
- def _busMessageErrorCb(self, bus, message):
+ def _busMessageErrorCb(self, unused_bus, message):
error, debug = message.parse_error()
self.error("Event bus error: %s; %s", error, debug)
return Gst.BusSyncReply.PASS
- def _busMessageAsyncDoneCb(self, bus, message):
+ def _busMessageAsyncDoneCb(self, bus, unused_message):
self.debug("Pipeline is ready for seeking")
bus.disconnect(self._donecb_id) # Don't call me again
self._ready = True
diff --git a/pitivi/utils/misc.py b/pitivi/utils/misc.py
index a64800e..86be75c 100644
--- a/pitivi/utils/misc.py
+++ b/pitivi/utils/misc.py
@@ -259,7 +259,7 @@ def get_controllable_properties(element):
def linkDynamic(element, target):
- def pad_added(bin, pad, target):
+ def pad_added(unused_bin, pad, target):
compatpad = target.get_compatible_pad(pad)
if compatpad:
pad.link_full(compatpad, Gst.PAD_LINK_CHECK_NOTHING)
@@ -344,7 +344,7 @@ def profile(func, profiler_filename="result.prof"):
output_filename = profiler_filename + str(counter)
counter += 1
- def _wrapper(*args, **kwargs):
+ def _wrapper(*unused_args, **kwargs):
local_func = func
cProfile.runctx("result = local_func(*args, **kwargs)", globals(), locals(),
filename=output_filename)
diff --git a/pitivi/utils/pipeline.py b/pitivi/utils/pipeline.py
index 2fee741..4e1d1f0 100644
--- a/pitivi/utils/pipeline.py
+++ b/pitivi/utils/pipeline.py
@@ -474,7 +474,7 @@ class SimplePipeline(Signallable, Loggable):
self._pipeline.set_state(Gst.State.PAUSED)
self._attempted_recoveries += 1
- def _queryDurationAsync(self, *args, **kwargs):
+ def _queryDurationAsync(self, *unused_args, **unused_kwargs):
try:
self.getDuration()
except:
@@ -577,7 +577,7 @@ class Pipeline(GES.Pipeline, SimplePipeline):
new_pos / float(Gst.SECOND))
self.simple_seek(new_pos)
- def _seekCb(self, ruler, position, format):
+ def _seekCb(self, unused_ruler, position, unused_format):
"""
The app's main seek method used when the user seeks manually.
diff --git a/pitivi/utils/system.py b/pitivi/utils/system.py
index 61feb14..01a2204 100644
--- a/pitivi/utils/system.py
+++ b/pitivi/utils/system.py
@@ -150,7 +150,7 @@ class System(Signallable, Loggable):
self._reset()
self.emit('update-power-inhibition')
- def desktopMessage(self, title, message, icon=None):
+ def desktopMessage(self, title, message, unused_icon=None):
"""send a message to the desktop to be displayed to the user
@arg title: C{str} the title of the message
@arg message: C{str} the body of the message
diff --git a/pitivi/utils/timeline.py b/pitivi/utils/timeline.py
index a6150c3..8c1c10d 100644
--- a/pitivi/utils/timeline.py
+++ b/pitivi/utils/timeline.py
@@ -218,7 +218,7 @@ class EditingContext(Signallable):
"clip-trim-finished": [],
}
- def __init__(self, focus, timeline, mode, edge, settings, action_log):
+ def __init__(self, focus, timeline, mode, edge, unused_settings, action_log):
"""
@param focus: the Clip or TrackElement which is to be the
main target of interactive editing, such as the object directly under the
diff --git a/pitivi/utils/widgets.py b/pitivi/utils/widgets.py
index 6f9fa6a..606fbd9 100644
--- a/pitivi/utils/widgets.py
+++ b/pitivi/utils/widgets.py
@@ -78,7 +78,7 @@ class DynamicWidget(object):
class DefaultWidget(Gtk.Label):
"""When all hope fails...."""
- def __init__(self, *unused, **kw_unused):
+ def __init__(self, *unused, **unused_kwargs):
Gtk.Label.__init__(self, _("Implement Me"))
@@ -712,7 +712,7 @@ class GstElementSettingsWidget(Gtk.VBox, Loggable):
self.pack_start(table, expand=True, fill=True, padding=0)
self.show_all()
- def _propertyChangedCb(self, element, pspec, widget):
+ def _propertyChangedCb(self, unused_element, pspec, widget):
widget.setWidgetValue(self.element.get_property(pspec.name))
def _getKeyframeToggleButton(self, prop):
@@ -723,7 +723,7 @@ class GstElementSettingsWidget(Gtk.VBox, Loggable):
button.connect('toggled', self._showKeyframesToggledCb, prop)
return button
- def _getResetToDefaultValueButton(self, prop, widget):
+ def _getResetToDefaultValueButton(self, unused_prop, widget):
icon = Gtk.Image()
icon.set_from_icon_name("edit-clear-all-symbolic", Gtk.IconSize.MENU)
button = Gtk.Button()
@@ -769,7 +769,7 @@ class GstElementSettingsWidget(Gtk.VBox, Loggable):
elif hasattr(track_element, "ui_element") and track_type == track_element.get_track_type():
track_element.ui_element.hideKeyframes()
- def _defaultBtnClickedCb(self, button, widget):
+ def _defaultBtnClickedCb(self, unused_button, widget):
try:
binding = self.bindings[widget]
except KeyError:
@@ -938,7 +938,7 @@ class BaseTabs(Gtk.Notebook):
if self._hide_hpaned:
self._showSecondHpanedInMainWindow()
- def _createWindowCb(self, from_notebook, child, x, y):
+ def _createWindowCb(self, unused_from_notebook, child, x, y):
original_position = self.child_get_property(child, "position")
label = self.child_get_property(child, "tab-label")
window = Gtk.Window()
@@ -1028,7 +1028,7 @@ class ZoomBox(Gtk.HBox, Zoomable):
self.zoomed_fitted = False
self._updateZoomSlider = True
- def _zoomFitCb(self, button):
+ def _zoomFitCb(self, unused_button):
self.timeline.zoomFit()
def _zoomSliderScrollCb(self, unused, event):
diff --git a/pitivi/viewer.py b/pitivi/viewer.py
index e6dc017..d4412b3 100644
--- a/pitivi/viewer.py
+++ b/pitivi/viewer.py
@@ -170,11 +170,11 @@ class ViewerContainer(Gtk.VBox, Loggable):
if active:
self.emit("activate-playback-controls", True)
- def _externalWindowDeleteCb(self, window, event):
+ def _externalWindowDeleteCb(self, unused_window, unused_event):
self.dock()
return True
- def _externalWindowConfigureCb(self, window, event):
+ def _externalWindowConfigureCb(self, unused_window, event):
self.settings.viewerWidth = event.width
self.settings.viewerHeight = event.height
self.settings.viewerX = event.x
@@ -298,7 +298,7 @@ class ViewerContainer(Gtk.VBox, Loggable):
self.internal_aframe.set_property("ratio", float(ratio))
self.external_aframe.set_property("ratio", float(ratio))
- def _entryActivateCb(self, entry):
+ def _entryActivateCb(self, unused_entry):
self._seekFromTimecodeWidget()
def _seekFromTimecodeWidget(self):
@@ -332,7 +332,7 @@ class ViewerContainer(Gtk.VBox, Loggable):
self.target.sink = self.sink
self.target.renderbox()
- def _playButtonCb(self, unused_button, playing):
+ def _playButtonCb(self, unused_button, unused_playing):
self.app.current_project.pipeline.togglePlayback()
def _goToStartCb(self, unused_button):
@@ -401,7 +401,7 @@ class ViewerContainer(Gtk.VBox, Loggable):
self._switch_output_window()
self.external_window.hide()
- def _toggleDocked(self, action):
+ def _toggleDocked(self, unused_action):
if self.docked:
self.undock()
else:
@@ -465,7 +465,7 @@ class ViewerContainer(Gtk.VBox, Loggable):
self.setPipeline(self.app.current_project.pipeline, self._oldTimelinePos)
self.debug("Back to old pipeline")
- def _pipelineStateChangedCb(self, pipeline, state):
+ def _pipelineStateChangedCb(self, unused_pipeline, state):
"""
When playback starts/stops, update the viewer widget,
play/pause button and (un)inhibit the screensaver.
@@ -866,7 +866,7 @@ class ViewerWidget(Gtk.DrawingArea, Loggable):
self.renderbox()
"""
- def _sizeCb(self, widget, area):
+ def _sizeCb(self, unused_widget, unused_area):
# The transformation box is cleared when using regular rendering
# so we need to flush the pipeline
self.seeker.flush()
@@ -906,7 +906,7 @@ class ViewerWidget(Gtk.DrawingArea, Loggable):
self.stored = True
- def button_release_event(self, widget, event):
+ def button_release_event(self, unused_widget, event):
if event.button == 1:
self.box.update_effect_properties()
self.box.release_point()
@@ -914,12 +914,12 @@ class ViewerWidget(Gtk.DrawingArea, Loggable):
self.stored = False
return True
- def button_press_event(self, widget, event):
+ def button_press_event(self, unused_widget, event):
if event.button == 1:
self.box.select_point(event)
return True
- def _currentStateCb(self, pipeline, state):
+ def _currentStateCb(self, unused_pipeline, unused_state):
self.fixme("TransformationBox disabled")
"""
self.pipeline = pipeline
@@ -928,7 +928,7 @@ class ViewerWidget(Gtk.DrawingArea, Loggable):
self.renderbox()
"""
- def motion_notify_event(self, widget, event):
+ def motion_notify_event(self, unused_widget, event):
if event.get_state() & Gdk.ModifierType.BUTTON1_MASK:
if self.box.transform(event):
if self.stored:
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
