#!/usr/bin/env python
# -*- coding: utf-8 -*
""" Metadata anonymisation toolkit - GUI edition """
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import GObject, Gtk, GLib
from gi.repository import Gdk, GdkPixbuf
import gettext
import logging
import os
import sys
import xml.sax
try:
from urllib2 import unquote
except ImportError: # python3
from urllib.parse import unquote
from libmat import mat
from libmat import strippers
from libmat import parser
from libmat import archive
logging.basicConfig(level=mat.LOGGING_LEVEL)
class CFile(GObject.Object):
""" Contain the "parser" class of the file "filename"
This class exist just to be "around" my parser.Generic_parser class,
since the Gtk.ListStore does not accept it because it does not
extends Gobject.Object
"""
def __init__(self, filename, **kwargs):
self.file = mat.create_class_file(filename, False, **kwargs)
class GUI(object):
""" Main GUI class """
def __init__(self):
# Preferences
self.add2archive = False
self.pdf_quality = False
# Main window
self.builder = Gtk.Builder()
self.builder.set_translation_domain('MAT')
self.builder.add_from_file(mat.get_datafile_path('mat.glade'))
self.builder.connect_signals(self)
self.logo = mat.get_logo()
icon = GdkPixbuf.Pixbuf.new_from_file_at_size(self.logo, 50, 50)
self.window = self.builder.get_object('MainWindow')
self.window.set_icon(icon)
self.liststore = self.builder.get_object('MainWindowListstore')
''' The Liststore contains:
0: The CFile instance that represents the file
1: The file's name
2: The file's state (Localised string)
'''
self.treeview = self.builder.get_object('MainWindowTreeview')
self.statusbar = self.builder.get_object('Statusbar')
self.statusbar.push(1, _('Ready'))
self.__init_supported_popup()
self.__set_drag_treeview()
self.window.show_all()
def __init_supported_popup(self):
""" Initialise the "supported formats" popup """
self.supported_dict = mat.XMLParser()
xml_parser = xml.sax.make_parser()
xml_parser.setContentHandler(self.supported_dict)
path = mat.get_datafile_path('FORMATS')
with open(path, 'r') as xmlfile:
xml_parser.parse(xmlfile)
supported_cbox = self.builder.get_object('supported_cbox')
store = Gtk.ListStore(GObject.TYPE_INT, GObject.TYPE_STRING)
for i, j in enumerate(self.supported_dict.list):
store.append([i, j['name']])
supported_cbox.set_model(store)
supported_cbox.set_entry_text_column(1)
supported_cbox.set_active(0)
self.builder.get_object('supported_metadata').set_buffer(Gtk.TextBuffer())
self.builder.get_object('supported_remaining').set_buffer(Gtk.TextBuffer())
self.builder.get_object('supported_method').set_buffer(Gtk.TextBuffer())
self.cb_update_supported_popup(supported_cbox) # to initially fill the dialog
def __set_drag_treeview(self):
""" Setup the drag'n'drop handling by the treeview """
self.treeview.drag_dest_set(
Gtk.DestDefaults.MOTION |
Gtk.DestDefaults.HIGHLIGHT |
Gtk.DestDefaults.DROP,
[], Gdk.DragAction.COPY)
targets = Gtk.TargetList.new([])
targets.add_uri_targets(80)
self.treeview.drag_dest_set_target_list(targets)
@staticmethod
def cb_hide_widget(widget, _):
""" This function is a little hack to hide instead
of close re-usable popups, like supported-fileformats,
popup-metadata, ..."""
widget.hide()
return False
def cb_update_supported_popup(self, window):
""" Fill GtkEntries of the supported_format_popups
with corresponding data.
"""
index = window.get_model()[window.get_active_iter()][0]
support = self.builder.get_object('supported_support')
support.set_text(self.supported_dict.list[index]['support'])
metadata = self.builder.get_object('supported_metadata').get_buffer()
metadata.set_text(self.supported_dict.list[index]['metadata'])
method = self.builder.get_object('supported_method').get_buffer()
method.set_text(self.supported_dict.list[index]['method'])
remaining = self.builder.get_object('supported_remaining').get_buffer()
remaining.set_text(self.supported_dict.list[index]['remaining'])
@staticmethod
def cb_close_application(_):
""" Close the application """
Gtk.main_quit()
def cb_add_files(self, button):
""" Add the files chosen by the filechooser ("Add" button) """
chooser = Gtk.FileChooserDialog(title=_('Choose files'),
parent=self.window, action=Gtk.FileChooserAction.OPEN,
buttons=(Gtk.STOCK_OK, 0, Gtk.STOCK_CANCEL, 1))
chooser.set_default_response(0)
chooser.set_select_multiple(True)
# filter that shows only supported formats
supported_filter = Gtk.FileFilter()
supported_filter.set_name(_('Supported files'))
for i in strippers.STRIPPERS.keys():
supported_filter.add_mime_type(i)
chooser.add_filter(supported_filter)
# filter that shows all files
all_filter = Gtk.FileFilter()
all_filter.set_name(_('All files'))
all_filter.add_pattern('*')
chooser.add_filter(all_filter)
if not chooser.run(): # Gtk.STOCK_OK
filenames = chooser.get_filenames()
GLib.idle_add(self.populate(filenames).next) # asynchronous processing
chooser.destroy()
def cb_popup_metadata(self, widget, row, col):
""" Popup that display on double-click
metadata from a file
"""
metadataPopupListStore = self.builder.get_object('MetadataPopupListStore')
metadataPopupListStore.clear()
if self.liststore[row][0].file.is_clean():
self.liststore[row][2] = _('Clean')
metadataPopupListStore.append([_('No metadata found'), ''])
else:
self.liststore[row][2] = _('Dirty')
for i, j in self.liststore[row][0].file.get_meta().items():
metadataPopupListStore.append([i, j])
popup_metadata = self.builder.get_object('MetadataPopup')
title = self.liststore[row][0].file.basename
popup_metadata.set_title(_("%s's metadata") % title.decode('utf8'))
popup_metadata.show_all()
popup_metadata.run()
popup_metadata.hide()
def cb_about_popup(self, button):
""" About popup """
w = Gtk.AboutDialog()
w.set_authors(['Julien (jvoisin) Voisin', ])
w.set_artists(['Marine Benoît', ])
w.set_copyright('GNU General Public License v2')
w.set_comments(_('Trash your meta, keep your data'))
w.set_logo(GdkPixbuf.Pixbuf.new_from_file_at_size(self.logo, 400, 200))
w.set_program_name('Metadata Anonymisation Toolkit')
w.set_version(mat.__version__)
w.set_website('https://mat.boum.org')
w.set_website_label(_('Website'))
w.set_position(Gtk.WindowPosition.CENTER)
w.set_transient_for(self.window)
w.run()
w.destroy()
def cb_supported_popup(self, w):
""" Show the "supported formats" popup"""
dialog = self.builder.get_object('SupportedWindow')
dialog.show_all()
dialog.run()
dialog.hide()
def cb_clear_list(self, _):
""" Clear the file list """
self.liststore.clear()
def cb_mat_check(self, button):
""" Callback for checking files """
self.__process_files(self.__mat_check)
def cb_mat_clean(self, button):
""" Callback for cleaning files """
self.__process_files(self.__mat_clean)
def cb_preferences_popup(self, button):
""" Preferences popup """
dialog = Gtk.Dialog(_('Preferences'), self.window, 0, (Gtk.STOCK_OK, 0))
dialog.connect('delete-event', self.cb_hide_widget)
dialog.set_resizable(False)
hbox = Gtk.HBox()
dialog.get_content_area().pack_start(hbox, False, False, 0)
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_PREFERENCES, Gtk.IconSize.DIALOG)
hbox.pack_start(icon, False, False, 20)
table = Gtk.Table(2, 2, False) # nb rows, nb lines
hbox.pack_start(table, True, True, 0)
pdf_quality = Gtk.CheckButton(_('Reduce PDF quality'), False)
pdf_quality.set_active(self.pdf_quality)
pdf_quality.connect('toggled', self.__invert, 'pdf_quality')
pdf_quality.set_tooltip_text(_('Reduce the produced PDF size and quality'))
table.attach(pdf_quality, 0, 1, 0, 1)
add2archive = Gtk.CheckButton(_('Remove unsupported file from archives'), False)
add2archive.set_active(not self.add2archive)
add2archive.connect('toggled', self.__invert, 'add2archive')
add2archive.set_tooltip_text(_('Remove non-supported (and so \
non-anonymised) file from output archive'))
table.attach(add2archive, 0, 1, 1, 2)
hbox.show_all()
if not dialog.run(): # Gtk.STOCK_OK
for f in self.liststore: # update preferences
f[0].file.add2archive = self.add2archive
if f[0].file.mime.startswith('pdf'):
f[0].file.pdf_quality = self.pdf_quality
dialog.hide()
def cb_drag_data_received(self, widget, context, x, y, selection, target_type, timestamp):
""" This function is called when something is
drag'n'droped into mat.
It basically add files.
"""
def clean_path(url):
""" Since the dragged urls are ugly,
we need to process them
"""
url = unquote(url) # unquote url
url = url.decode('utf-8') # decode in utf-8
if url.startswith('file:\\\\\\'): # windows
return url[8:] # 8 is len('file:///')
elif url.startswith('file://'): # nautilus, rox, thunar
return url[7:] # 7 is len('file://')
elif url.startswith('file:'): # xffm
return url[5:] # 5 is len('file:')
dirty_urls = selection.get_uris()
cleaned_urls = map(clean_path, dirty_urls)
GLib.idle_add(self.populate(cleaned_urls).next) # asynchronous processing
def __add_file_to_treeview(self, filename):
""" Add a file to the list if its format is supported """
cf = CFile(filename, add2archive=self.add2archive, low_pdf_quality=self.pdf_quality)
if cf.file and cf.file.is_writable:
self.liststore.append([cf, cf.file.basename, _('Unknown')])
return False
return True
def __process_files(self, func):
""" Launch the function "func" in a asynchronous way """
iterator = self.treeview.get_selection().get_selected_rows()[1]
if not iterator: # if nothing is selected : select everything
iterator = range(len(self.liststore))
sync_task = func(iterator) # launch func() in an asynchronous way
GLib.idle_add(sync_task.next)
def __invert(self, button, name):
""" Invert a preference state """
if name == 'pdf_quality':
self.pdf_quality = not self.pdf_quality
elif name == 'add2archive':
self.add2archive = not self.add2archive
def populate(self, filenames):
""" Append selected files by add_file to the self.liststore
:param filenames: selected files
"""
not_supported = []
for filename in filenames: # filenames : all selected files/folders
if os.path.isdir(filename): # if "filename" is a directory
for root, dirs, files in os.walk(filename):
for item in files:
path_to_file = os.path.join(root, item)
if self.__add_file_to_treeview(path_to_file):
not_supported.append(item)
yield True
else: # filename is a regular file
if self.__add_file_to_treeview(filename):
not_supported.append(filename)
yield True
self.cb_mat_check(None)
if not_supported:
self.__popup_non_supported(not_supported)
yield False
def __popup_non_supported(self, filelist):
""" Popup that warn the user about the unsupported files
that he want to process
"""
dialog = Gtk.Dialog(title=_('Not-supported'), parent=self.window,
flags=Gtk.DialogFlags.MODAL, buttons=(Gtk.STOCK_OK, 0))
dialog.set_size_request(220, 180)
vbox = Gtk.VBox(spacing=5)
sc = Gtk.ScrolledWindow()
sc.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
sc.add_with_viewport(vbox)
dialog.get_content_area().pack_start(sc, True, True, 0)
store = Gtk.ListStore(str, str)
# appends "filename - reason" to the ListStore
for item in filelist:
if os.path.splitext(item)[1] in parser.NOMETA:
store.append([os.path.basename(item), _('Harmless fileformat')])
elif not os.access(item, os.R_OK):
store.append([os.path.basename(item), _('Cant read file')])
else:
store.append([os.path.basename(item), _('Fileformat not supported')])
treeview = Gtk.TreeView(store)
vbox.pack_start(Gtk.Label(_('These files can not be processed:')), False, False, 0)
vbox.pack_start(treeview, True, True, 0)
# Create columns
rendererText = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_('Filename'), rendererText, text=0)
treeview.append_column(column)
column = Gtk.TreeViewColumn(_('Reason'), rendererText, text=1)
treeview.append_column(column)
dialog.show_all()
dialog.run()
dialog.destroy()
def __popup_archive(self, file_name, files_list):
""" Popup that shows the user what files
are not going to be include into to outputed
archive
"""
dialog = Gtk.Dialog(title=_('Non-supported files in archive'), parent=self.window,
flags=Gtk.DialogFlags.MODAL, buttons=(_('Clean'), 0))
dialog.set_size_request(220, 180)
vbox = Gtk.VBox(spacing=5)
sc = Gtk.ScrolledWindow()
sc.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
sc.add_with_viewport(vbox)
dialog.get_content_area().pack_start(sc, True, True, 0)
store = Gtk.ListStore(GObject.TYPE_BOOLEAN, GObject.TYPE_STRING)
for i in files_list: # store.extend is not supported, wtf?!
store.append([0, os.path.basename(i)])
treeview = Gtk.TreeView(store)
column_toggle = Gtk.TreeViewColumn(_('Include'))
column_text = Gtk.TreeViewColumn(_('Filename'))
treeview.append_column(column_toggle)
treeview.append_column(column_text)
cellrenderer_text = Gtk.CellRendererText()
column_text.pack_start(cellrenderer_text, False)
column_text.add_attribute(cellrenderer_text, 'text', 1)
cellrenderer_toggle = Gtk.CellRendererToggle()
column_toggle.pack_start(cellrenderer_toggle, True)
column_toggle.add_attribute(cellrenderer_toggle, 'active', 0)
def cell_toggled(widget, path, model):
model[path][0] = not model[path][0]
cellrenderer_toggle.connect('toggled', cell_toggled, store)
vbox.pack_start(Gtk.Label(_('MAT is not able to clean the'
' following files, found in the %s archive') % file_name), False, False, 0)
label = Gtk.Label()
label.set_markup('Select the files you want to <b>include</b>'
' in the cleaned up archive anyway.')
vbox.pack_start(label, False, False, 0)
vbox.pack_start(treeview, True, True, 0)
dialog.show_all()
dialog.run()
dialog.destroy()
return [i[1] for i in store if i[0]]
def __mat_check(self, iterator):
""" Check elements in iterator are clean """
for line in iterator: # for each file in selection
msg = _('Checking %s') % self.liststore[line][1].decode('utf-8', 'replace')
logging.info(msg)
self.statusbar.push(0, msg)
if self.liststore[line][0].file.is_clean():
self.liststore[line][2] = _('Clean')
else:
self.liststore[line][2] = _('Dirty')
logging.info('%s is %s' % (self.liststore[line][1], self.liststore[line][2]))
yield True
self.statusbar.push(0, _('Ready'))
yield False
def __mat_clean(self, iterator):
""" Clean elements in iterator """
for line in iterator: # for each file in selection
msg = _('Cleaning %s') % self.liststore[line][1].decode('utf-8', 'replace')
logging.info(msg)
self.statusbar.push(0, msg)
is_archive = isinstance(self.liststore[line][0].file, archive.GenericArchiveStripper)
is_terminal = isinstance(self.liststore[line][0].file, archive.TerminalZipStripper)
list_to_add = []
if is_archive and not is_terminal:
unsupported_list = self.liststore[line][0].file.list_unsupported()
if type(unsupported_list) == list and unsupported_list:
logging.debug("Unsupported list: %s" % unsupported_list)
filename = os.path.basename(self.liststore[line][0].file.filename)
list_to_add = self.__popup_archive(filename, unsupported_list)
if self.liststore[line][0].file.remove_all(whitelist=list_to_add):
self.liststore[line][2] = _('Clean')
elif self.liststore[line][0].file.remove_all():
self.liststore[line][2] = _('Clean')
yield True
self.statusbar.push(0, _('Ready'))
yield False
if __name__ == '__main__':
gettext.install('MAT', unicode=True)
gui = GUI()
# Add files from command line
infiles = [arg for arg in sys.argv[1:] if os.path.exists(arg)]
if infiles:
task = gui.populate(infiles)
GLib.idle_add(task.next)
Gtk.main()