def update_emblem(self, provider, handle, closure, file):
for tag in self.tag_settings:
if self.tracker.has_tag(file.get_uri(), tag):
file.add_emblem(self.tag_settings[tag][0])
file.invalidate_extension_info()
Nautilus.info_provider_update_complete_invoke(closure, provider, handle, Nautilus.OperationResult.COMPLETE)
return False
def do_update_cb(self, provider, handle, closure, file_, uri):
# print "Running async callback on " + str(file.get_uri())
self.get_drive_managed_file_status(file, uri)
# Notify that we are done !
Nautilus.info_provider_update_complete_invoke(closure, provider,
handle,
Nautilus.OperationResult.COMPLETE)
# print "Update done"
# return False to kill the timeout !
return False
def get_columns(self):
return (
# exif support
Nautilus.Column(name='NautilusPython::exif_pixeldimensions_column',
attribute='exif_pixeldimensions',
label='EXIF Image Size',
description='EXIF Image size - pixel dimensions'),
Nautilus.Column(name='NautilusPython::pixeldimensions_column',
attribute='pixeldimensions',
label='Image Size',
description='Image size - pixel dimensions'),
)
def ask_for_menu_items(self, files):
record_separator = '\x1e'
filesstring = record_separator.join(files)
socketConnect.sendCommand('GET_MENU_ITEMS:{}\n'.format(filesstring))
done = False
start = time.time()
timeout = 0.1 # 100ms
menu_items = []
while not done:
dt = time.time() - start
if dt >= timeout:
break
if not socketConnect.read_socket_data_with_timeout(timeout - dt):
break
for line in socketConnect.get_available_responses():
# Process lines we don't care about
if done or not (line.startswith('GET_MENU_ITEMS:')
or line.startswith('MENU_ITEM:')):
socketConnect.handle_server_response(line)
continue
if line == 'GET_MENU_ITEMS:END':
done = True
# don't break - we'd discard other responses
if line.startswith('MENU_ITEM:'):
args = line.split(':')
if len(args) < 4:
continue
menu_items.append(
[args[1], 'd' not in args[2], ':'.join(args[3:])])
if not done:
return self.legacy_menu_items(files)
if len(menu_items) == 0:
return []
# Set up the 'ownCloud...' submenu
item_owncloud = Nautilus.MenuItem(name='IntegrationMenu',
label=self.strings.get(
'CONTEXT_MENU_TITLE', appname))
menu = Nautilus.Menu()
item_owncloud.set_submenu(menu)
for action, enabled, label in menu_items:
item = Nautilus.MenuItem(name=action,
label=label,
sensitive=enabled)
item.connect("activate", self.context_menu_action, action,
filesstring)
menu.append_item(item)
return [item_owncloud]
def _generate_background_menu(self, items):
top_background_menuitem = Nautilus.MenuItem(name='FolderCleanerMenu::Background', label=_("Sort Files"))
background_submenu = Nautilus.Menu()
top_background_menuitem.set_submenu(background_submenu)
item = Nautilus.MenuItem(name="name3", label=_("By Type"))
item.connect('activate', self.background_sort_by_type, items)
background_submenu.append_item(item)
item2 = Nautilus.MenuItem(name="name4", label=_("By Extension"))
item2.connect('activate', self.background_sort_by_ext, items)
background_submenu.append_item(item2)
return top_background_menuitem,
def _create_menu_items(self, files, group):
plural = len(files) > 1
item_path = Nautilus.MenuItem(
name="NautilusCopyPath::CopyPath" + group,
label="Copy Paths" if plural else "Copy Path",
)
item_name = Nautilus.MenuItem(
name="NautilusCopyPath::CopyName" + group,
label="Copy Names" if plural else "Copy Name",
)
item_path.connect("activate", self._copy_paths, files)
item_name.connect("activate", self._copy_names, files)
return [item_path, item_name]
def update_exif(self, provider, handle, closure, file_info):
filename = unquote(file_info.get_uri()[7:])
try:
data = getexiftool(filename)
attr = data[0]
except:
attr = ''
file_info.add_string_attribute('Exif:Image:DateTime', attr)
Nautilus.info_provider_update_complete_invoke(closure, provider,
handle, Nautilus.OperationResult.COMPLETE)
return False
def get_background_items(self, window, file):
submenu = Nautilus.Menu()
submenu.append_item(
Nautilus.MenuItem(name='ExampleMenuProvider::Bar2',
label='Bar2',
tip='',
icon=''))
menuitem = Nautilus.MenuItem(name='ExampleMenuProvider::Foo2',
label='Foo2',
tip='',
icon='')
menuitem.set_submenu(submenu)
return menuitem,
def get_background_items(self, window, file_):
items = []
if file_.get_uri_scheme() in REMOTE_URI_SCHEME:
item = Nautilus.MenuItem(name="NautilusPython::open_bg_remote_item",
label=_(u'Open Remote {} Here').format(terminal.title()),
tip=_(u'Open Remote {} In This Directory').format(terminal.title()))
item.connect("activate", self._menu_activate_cb, file_)
items.append(item)
item = Nautilus.MenuItem(name="NautilusPython::open_bg_file_item",
label=_(u'Open {} Here').format(terminal.title()),
tip=_(u'Open {} In This Directory').format(terminal.title()))
item.connect("activate", self._menu_background_activate_cb, file_)
items.append(item)
return items
def get_file_items(self, window, sel_items):
"""Adds the 'Add To Audacious Playlist' menu item to the Nautilus right-click menu,
connects its 'activate' signal to the 'run' method passing the list of selected Audio items"""
if len(sel_items) == 0: return
if sel_items[0].is_directory(
) or sel_items[0].get_uri_scheme() != 'file':
return
source_path_list = []
for sel_item in sel_items:
uri_raw = sel_item.get_uri()
if len(uri_raw) < 7: continue
source_path = re.escape(urllib.unquote(uri_raw[7:]))
for extension in EXTENSIONS_WHITELIST:
if source_path.endswith(extension):
source_path_list.append(source_path)
break
else:
filetype = subprocess.Popen(
"file -i %s" % source_path,
shell=True,
stdout=subprocess.PIPE).communicate()[0]
if "audio" in filetype\
or "application/ogg" in filetype:
source_path_list.append(source_path)
if source_path_list:
item = Nautilus.MenuItem(
name='NautilusPython::audacious',
label=_('Add To Audacious Playlist'),
tip=_(
'Add the selected Audio file(s) to the Audacious Playlist'
),
icon='audacious')
item.connect('activate', self.run, source_path_list)
return item,
def define_menu_helper(self, name, window, file):
item = Nautilus.MenuItem(name="RTermOpen::" + name,
label="Open RTerm",
tip="Opens RTerm in this directory",
icon="terminal")
item.connect('activate', self.menu_activate_cb, file)
return item,
def get_background_items(self, window, file):
item = Nautilus.MenuItem(name='NautilusOpenAlacritty',
label='Open in Alacritty',
tip='',
icon='')
item.connect('activate', self.menu_activate_cb, file)
return item,
def _generate_menu(self, items):
"""Generate menu"""
top_menuitem = Nautilus.MenuItem(name='CreateALauncher',
label=_("Create a launcher"),
sensitive=True)
top_menuitem.connect('activate', self.open_dialog)
return top_menuitem,
def _create_hide_item(self, files, hidden_path, hidden):
"""Creates the 'Hide file(s)' menu item."""
item = Nautilus.MenuItem(name="NautilusHide::HideFile",
label=ngettext("_Hide File", "_Hide Files", len(files)),
tip=ngettext("Hide this file", "Hide these files", len(files)))
item.connect("activate", self._hide_run, files, hidden_path, hidden)
return item
def get_background_items(self, _, files):
item = Nautilus.MenuItem(
name='LaunchVSCodeInDirectory',
label='Launch VSCode Here',
tip='Launches VSCode in the current directory')
item.connect('activate', self.launch_vscode, [files])
return [item]
def get_file_items(self, window, files):
if len(files) != 1:
return
file = files[0]
items = []
# internal or external file?!
syncedFile = False
for reg_path in self.registered_paths:
filename = get_local_path(file.get_uri())
if filename.startswith(reg_path):
syncedFile = True
# if it is neither in a synced folder or is a directory
if (not syncedFile):
return items
# create an menu item
labelStr = "Share with " + appname + "..."
item = Nautilus.MenuItem(name='NautilusPython::ShareItem',
label=labelStr,
tip='Share file %s through ownCloud' %
file.get_name())
item.connect("activate", self.menu_share, file)
items.append(item)
return items
def get_file_items(self, window, files):
# if multiple selection, nothing to do
if len(files) != 1: return
# check availability of video conversion tool
file = pathlib.Path("/usr/local/bin/video-convert2mkvaac")
if not file.exists(): return
# check if file is in the supported file types
if files[0].get_mime_type() in ('video/x-matroska'
'video/mp4'
'video/mpeg'
'video/web'
'video/x-msvideo'):
# get filename
filename = files[0].get_uri()
# create menu item for right click menu
convert_mkvaac_menu = Nautilus.MenuItem(
name='ConvertMkvAacMenuProvider::convert_mkvaac',
label='Video - Convert to MKV/AAC',
icon='video-aac')
convert_mkvaac_menu.connect('activate', self.convert_mkvaac,
filename)
return [convert_mkvaac_menu]
# else, nothing to do
else:
return
def get_file_items(self, window, files):
if len(files) != 1:
return
file = files[0]
text = file.get_uri()
try:
if text != None:
#syslog.syslog(__name__)
self.set_clipboard(text)
except Exception as e:
# syslog.syslog( "{}: {}".format(__name__, e))
pass
finally:
# don't need this anymore. Data is one clipboard
self.clipboard = None
item = Nautilus.MenuItem(
name="SimpleMenuExtension::Copy_Uri_to_Clipb",
#label="Copy uri %s" % file.get_name(),
#
label="Copy URI",
tip="Showing %s" % text)
#item.connect('activate', self.menu_activate_cb, file)
return [item]
def _gitg_menuitem(self, name, label, directory, *args, **kwargs):
menuitem = Nautilus.MenuItem(name='GitgHere::{}'.format(name),
label=label,
tip='Execute gitg',
icon='')
menuitem.connect('activate', self._gitg, directory, *args, **kwargs)
return menuitem
def get_file_items(self, window, files):
# Show the menu iif:
# - There is at least on file selected
# - All the selected files are images
# - All selected images are locals (currently Postr doesn't have
# support for gnome-vfs
# - Postr is installed (is in PATH)
if len(files) == 0:
return
for fd in files:
if fd.is_directory() or fd.get_uri_scheme() != 'file':
return
if not fd.is_mime_type("image/*"):
return
#self.program = self.locate_program(PROGRAM_NAME)
#if not self.program:
# return
item = Nautilus.MenuItem(
name='PostrExtension::upload_files',
label=_('Upload to Flickr...'),
tip=_('Upload the selected files into Flickr'),
icon="postr")
item.connect('activate', self.upload_files, files)
return item,
def get_file_items(self, window, files):
_ = window
main_item = Nautilus.MenuItem(name='Nautilus::nuxeodrive',
label='Nuxeo Drive',
tip='Nuxeo Drive')
main_item.connect("activate", self.open_metadata_view, files)
return main_item,
def get_background_items(self, window, file_):
items = []
if file_.get_uri_scheme() in REMOTE_URI_SCHEME:
item = Nautilus.MenuItem(
name='NautilusPython::open_bg_remote_item',
label=_(u'Open Remote Tilix Here'),
tip=_(u'Open Remote Tilix In This Directory'))
item.connect('activate', self._menu_activate_cb, file_)
items.append(item)
item = Nautilus.MenuItem(name='NautilusPython::open_bg_file_item',
label=_(u'Open Tilix Here'),
tip=_(u'Open Tilix In This Directory'))
item.connect('activate', self._menu_background_activate_cb, file_)
items.append(item)
return items
def get_background_items(self, window, file):
item = Nautilus.MenuItem(
name='NautilusPython::openterminal_file_item2',
label='Open Terminal (%s)' % self._get_terminal_exec(),
tip='Open Terminal In %s' % file.get_name())
item.connect('activate', self.menu_background_activate_cb, file)
return item,
def get_file_items(self, window, files):
if len(files) != 1: # no multi-files support
return
current_file = files.pop()
# We're only going to put ourselves on supported mimetypes' context menus
if not (current_file.get_mime_type() in [
i["mimetype"] for i in libmat.mat.list_supported_formats()
]):
logging.debug("%s is not supported by MAT",
current_file.get_mime_type())
return
# MAT can only handle local file:
if current_file.get_uri_scheme() != 'file':
logging.debug("%s files not supported by MAT",
current_file.get_uri_scheme())
return
# MAT can not clean non-writable files
if not current_file.can_write():
logging.debug("%s is not writable by MAT",
current_file.get_uri_scheme())
return
item = Nautilus.MenuItem(name="Nautilus::clean_metadata",
label=_("Clean metadata"),
tip=_("Clean file's metadata with MAT"),
icon="gtk-clear")
item.connect('activate', self.menu_activate_cb, current_file)
return item,
def get_background_items(self, window, file):
item = Nautilus.MenuItem(name='MenuProvider::VTerm',
label='Open in VTerm',
tip='Open VTerm here.',
icon='')
item.connect('activate', self.menu_activate_cb, file)
return item,
def get_background_items(self, window, file):
menuitem = Nautilus.MenuItem(name='ExampleMenuProvider::Foo',
label='Foo',
tip='',
icon='')
menuitem.connect('activate', self.menu_background_activate_cb, file)
return menuitem,
def get_file_items(self, window, sel_items):
if len(sel_items) == 2 or len(sel_items) == 3:
compare = COMPARE_NONE
for afile in sel_items:
if compare == COMPARE_NONE:
if afile.is_directory():
compare = COMPARE_DIRECTORIES
else:
compare = COMPARE_FILES
elif compare == COMPARE_DIRECTORIES:
if not afile.is_directory():
return
elif compare == COMPARE_FILES:
if afile.is_directory():
return
else:
return
if len(sel_items) == 2:
label = _('Compare {} with {}').format(sel_items[0].get_name(),
sel_items[1].get_name())
else:
label = _('Compare {} with {} and {}').format(
sel_items[0].get_name(), sel_items[1].get_name(),
sel_items[2].get_name())
menuitem = FileManager.MenuItem(
name='FileManagerCompare::compare_items',
label=label,
tip=_('Compare content'),
icon='org.gnome.meld')
menuitem.connect('activate', self.on_menuitem_activated, sel_items)
return menuitem,
def get_background_items(self, window, file_):
item = Nautilus.MenuItem(name='VSCodeOpenBackground',
label='Abrir ' + VSCODENAME + ' aqui',
tip='Abrir el directorio actual con VSCode')
item.connect('activate', self.launch_vscode, [file_])
return [item]
def get_file_items(self, window, files):
item = Nautilus.MenuItem(name='EmacsOpen',
label='Open In ' + NAME,
tip='Opens the selected files with ' + NAME)
item.connect('activate', self.launch_emacs, files)
return [item]
def get_background_items(self, window, file_):
item = Nautilus.MenuItem(name='VSCodeOpenBackground',
label='Open ' + VSCODENAME + ' Here',
tip='Opens VSCode in the current directory')
item.connect('activate', self.launch_vscode, [file_])
return [item]
def get_file_items(self, window, files):
item = Nautilus.MenuItem(name='VSCodeOpen',
label='Open In ' + VSCODENAME,
tip='Opens the selected files with VSCode')
item.connect('activate', self.launch_vscode, files)
return [item]
def get_background_items(self, window, folder):
paste_item = FileManager.MenuItem(
name='CopyPasteImagesMenuProvider::Gtk-cpim-paste-image',
label='Вставить как изображение')
location = folder.get_location()
paste_item.connect('activate', self.paste_image, location.get_path())
return paste_item,
def update_cb(self, provider, handle, closure):
print("update_cb")
Nautilus.info_provider_update_complete_invoke(closure, provider, handle, Nautilus.OperationResult.FAILED)
