mirror of
https://github.com/arsenetar/dupeguru.git
synced 2024-10-30 05:15:57 +00:00
194 lines
6.1 KiB
Python
194 lines
6.1 KiB
Python
# Created By: Virgil Dupras
|
|
# Created On: 2010-02-11
|
|
# Copyright 2015 Hardcoded Software (http://www.hardcoded.net)
|
|
#
|
|
# This software is licensed under the "GPLv3" License as described in the "LICENSE" file,
|
|
# which should be included with this package. The terms are also available at
|
|
# http://www.gnu.org/licenses/gpl-3.0.html
|
|
|
|
from operator import attrgetter
|
|
|
|
from hscommon.gui.table import GUITable, Row
|
|
from hscommon.gui.column import Columns
|
|
|
|
from core.gui.base import DupeGuruGUIObject
|
|
|
|
|
|
class DupeRow(Row):
|
|
def __init__(self, table, group, dupe):
|
|
Row.__init__(self, table)
|
|
self._app = table.app
|
|
self._group = group
|
|
self._dupe = dupe
|
|
self._data = None
|
|
self._data_delta = None
|
|
self._delta_columns = None
|
|
|
|
def is_cell_delta(self, column_name):
|
|
"""Returns whether a cell is in delta mode (orange color).
|
|
|
|
If the result table is in delta mode, returns True if the column is one of the "delta
|
|
columns", that is, one of the columns that display a a differential value rather than an
|
|
absolute value.
|
|
|
|
If not, returns True if the dupe's value is different from its ref value.
|
|
"""
|
|
if not self.table.delta_values:
|
|
return False
|
|
if self.isref:
|
|
return False
|
|
if self._delta_columns is None:
|
|
# table.DELTA_COLUMNS are always "delta"
|
|
self._delta_columns = self.table.DELTA_COLUMNS.copy()
|
|
dupe_info = self.data
|
|
if self._group.ref is None:
|
|
return False
|
|
ref_info = self._group.ref.get_display_info(group=self._group, delta=False)
|
|
for key, value in dupe_info.items():
|
|
if (key not in self._delta_columns) and (ref_info[key].lower() != value.lower()):
|
|
self._delta_columns.add(key)
|
|
return column_name in self._delta_columns
|
|
|
|
@property
|
|
def data(self):
|
|
if self._data is None:
|
|
self._data = self._app.get_display_info(self._dupe, self._group, False)
|
|
return self._data
|
|
|
|
@property
|
|
def data_delta(self):
|
|
if self._data_delta is None:
|
|
self._data_delta = self._app.get_display_info(self._dupe, self._group, True)
|
|
return self._data_delta
|
|
|
|
@property
|
|
def isref(self):
|
|
return self._dupe is self._group.ref
|
|
|
|
@property
|
|
def markable(self):
|
|
return self._app.results.is_markable(self._dupe)
|
|
|
|
@property
|
|
def marked(self):
|
|
return self._app.results.is_marked(self._dupe)
|
|
|
|
@marked.setter
|
|
def marked(self, value):
|
|
self._app.mark_dupe(self._dupe, value)
|
|
|
|
|
|
class ResultTable(GUITable, DupeGuruGUIObject):
|
|
def __init__(self, app):
|
|
GUITable.__init__(self)
|
|
DupeGuruGUIObject.__init__(self, app)
|
|
self._columns = Columns(self, prefaccess=app, savename="ResultTable")
|
|
self._power_marker = False
|
|
self._delta_values = False
|
|
self._sort_descriptors = ("name", True)
|
|
|
|
# --- Override
|
|
def _view_updated(self):
|
|
self._refresh_with_view()
|
|
|
|
def _restore_selection(self, previous_selection):
|
|
if self.app.selected_dupes:
|
|
to_find = set(self.app.selected_dupes)
|
|
indexes = [i for i, r in enumerate(self) if r._dupe in to_find]
|
|
self.selected_indexes = indexes
|
|
|
|
def _update_selection(self):
|
|
rows = self.selected_rows
|
|
self.app._select_dupes(list(map(attrgetter("_dupe"), rows)))
|
|
|
|
def _fill(self):
|
|
if not self.power_marker:
|
|
for group in self.app.results.groups:
|
|
self.append(DupeRow(self, group, group.ref))
|
|
for dupe in group.dupes:
|
|
self.append(DupeRow(self, group, dupe))
|
|
else:
|
|
for dupe in self.app.results.dupes:
|
|
group = self.app.results.get_group_of_duplicate(dupe)
|
|
self.append(DupeRow(self, group, dupe))
|
|
|
|
def _refresh_with_view(self):
|
|
self.refresh()
|
|
self.view.show_selected_row()
|
|
|
|
# --- Public
|
|
def get_row_value(self, index, column):
|
|
try:
|
|
row = self[index]
|
|
except IndexError:
|
|
return "---"
|
|
if self.delta_values:
|
|
return row.data_delta[column]
|
|
else:
|
|
return row.data[column]
|
|
|
|
def rename_selected(self, newname):
|
|
row = self.selected_row
|
|
if row is None:
|
|
# There's all kinds of way the current row can be swept off during rename. When it
|
|
# happens, selected_row will be None.
|
|
return False
|
|
row._data = None
|
|
row._data_delta = None
|
|
return self.app.rename_selected(newname)
|
|
|
|
def sort(self, key, asc):
|
|
if self.power_marker:
|
|
self.app.results.sort_dupes(key, asc, self.delta_values)
|
|
else:
|
|
self.app.results.sort_groups(key, asc)
|
|
self._sort_descriptors = (key, asc)
|
|
self._refresh_with_view()
|
|
|
|
# --- Properties
|
|
@property
|
|
def power_marker(self):
|
|
return self._power_marker
|
|
|
|
@power_marker.setter
|
|
def power_marker(self, value):
|
|
if value == self._power_marker:
|
|
return
|
|
self._power_marker = value
|
|
key, asc = self._sort_descriptors
|
|
self.sort(key, asc)
|
|
# no need to refresh, it has happened in sort()
|
|
|
|
@property
|
|
def delta_values(self):
|
|
return self._delta_values
|
|
|
|
@delta_values.setter
|
|
def delta_values(self, value):
|
|
if value == self._delta_values:
|
|
return
|
|
self._delta_values = value
|
|
self.refresh()
|
|
|
|
@property
|
|
def selected_dupe_count(self):
|
|
return sum(1 for row in self.selected_rows if not row.isref)
|
|
|
|
# --- Event Handlers
|
|
def marking_changed(self):
|
|
self.view.invalidate_markings()
|
|
|
|
def results_changed(self):
|
|
self._refresh_with_view()
|
|
|
|
def results_changed_but_keep_selection(self):
|
|
# What we want to to here is that instead of restoring selected *dupes* after refresh, we
|
|
# restore selected *paths*.
|
|
indexes = self.selected_indexes
|
|
self.refresh(refresh_view=False)
|
|
self.select(indexes)
|
|
self.view.refresh()
|
|
|
|
def save_session(self):
|
|
self._columns.save_columns()
|