def get_columns(self):
"""
Return all the columns we support.
"""
return (
Nemo.Column(
name="RabbitVCS::status_column",
attribute="status",
label=_("RVCS Status"),
description=""
),
Nemo.Column(
name="RabbitVCS::revision_column",
attribute="revision",
label=_("RVCS Revision"),
description=""
),
Nemo.Column(
name="RabbitVCS::author_column",
attribute="author",
label=_("RVCS Author"),
description=""
),
Nemo.Column(
name="RabbitVCS::age_column",
attribute="age",
label=_("RVCS Age"),
description=""
)
)
def get_file_items(self, window, files):
""" Tell nemo whether and when to show the menu """
if len(files) == 0:
return
myfile = files[0]
if not self.is_valid_file(myfile):
return
item1 = Nemo.MenuItem(
name='Nemo::gnupg_scripts_encrypt',
label=gettext.dgettext('gnupg-scripts',
'Encrypt').decode('utf-8', 'replace'),
tip=gettext.dgettext('gnupg-scripts',
'Encrypt the file(s) with GnuPG').decode(
'utf-8', 'replace'),
icon="gnupg-scripts-encrypt")
item1.connect('activate', self.menu1_activate_cb, files)
item2 = Nemo.MenuItem(
name='Nemo::gnupg_scripts_sign',
label=gettext.dgettext('gnupg-scripts',
'Sign').decode('utf-8', 'replace'),
tip=gettext.dgettext(
'gnupg-scripts',
'Signs the selected file with a detached signature').decode(
'utf-8', 'replace'),
icon="gnupg-scripts-sign")
item2.connect('activate', self.menu2_activate_cb, files)
return item1, item2,
def get_file_items(self, window, files):
"""Ensure there are reachable devices"""
try:
devices = self.get_reachable_devices()
except Exception as e:
raise Exception("Error while getting reachable devices")
"""if there is no reacheable devices don't show this on context menu"""
if not devices:
return
"""Ensure that user only select files"""
for file in files:
if file.get_uri_scheme() != 'file' or file.is_directory() and os.path.isfile(file):
return
self.setup_gettext()
"""If user only select file(s) create menu and sub menu"""
menu = Nemo.MenuItem(name='KdeConnectSendExtension::KDEConnect_Send',
label=_('KDEConnect - Send To'),
tip=_('send file(s) with kdeconnect'),
icon='kdeconnect')
sub_menu = Nemo.Menu()
menu.set_submenu(sub_menu)
for device in devices:
item = Nemo.MenuItem(name="KDEConnectSendExtension::Send_File_To",
label=device["name"])
item.connect('activate', self.menu_activate_cb, files, device["id"], device["name"])
sub_menu.append_item(item)
return menu,
def get_file_items(self, window, files):
if len(files) != 1:
return
nfile = files[0]
if nfile.is_directory():
return
if nfile.get_mime_type().split("/")[0] != "image":
return
menu = FileManager.MenuItem(name="SearchByImageExtension::Engines",
label="Search by image")
submenu = FileManager.Menu()
menu.set_submenu(submenu)
for engine in SEARCH_URLS.keys():
item = FileManager.MenuItem(
name=f"SearchByImageExtension::{engine}",
label=f"Search image on {engine}",
tip=f"Use {engine} reverse image search on {nfile.get_name()}",
)
item.connect("activate", self._search_image, nfile, engine)
submenu.append_item(item)
return (menu, )
def write_creation_time_callback(self, provider, handle, closure, fileinfo):
"""
Callback to update the creation time for a file.
"""
filename = fileinfo.get_location().get_path()
try:
crtime = get_crtime(filename)
except:
traceback.print_exc() # Log exceptions
else:
# get_crtime() returns None if on an unsupported file system
if crtime is not None:
struct_time = time.gmtime(crtime)
# Respect Nemo's time formatting. XXX: can we get this data from Nemo directly?
settings = Gio.Settings.new('org.nemo.preferences')
timeformat = settings.get_enum('date-format')
if timeformat == NEMO_DATE_FORMAT_LOCALE:
formatted_time = time.strftime('%c', struct_time)
else: # XXX: no support for "informal" time format yet
formatted_time = time.strftime('%Y-%m-%d %H:%M:%S', struct_time)
fileinfo.invalidate_extension_info()
fileinfo.add_string_attribute('creation_time', formatted_time)
# Tell nemo that we're done processing.
Nemo.info_provider_update_complete_invoke(closure, provider,
handle, Nemo.OperationResult.COMPLETE)
return False
def update_cb(self, provider, handle, closure, file):
self.do_update_file_info(file)
if handle in self.ids_by_handle.keys():
del self.ids_by_handle[handle]
Nemo.info_provider_update_complete_invoke(closure, provider, handle, Nemo.OperationResult.COMPLETE)
return False
def update_cb(self, provider, handle, closure, file):
self.current_idle_id = 0
self.do_update_file_info(file)
Nemo.info_provider_update_complete_invoke(
closure, provider, handle, Nemo.OperationResult.COMPLETE)
return False
def get_file_items(self, window, files):
if len(files) != 1: #Only allow for a single folder selection
return
folder = files[0]
if not folder.is_directory(): #Only allow on folders
return
#Get the full system path of the selected folder
folder_uri = urllib.parse.unquote(folder.get_uri()[7:]) if PYTHON3 else urllib.unquote(folder.get_uri()[7:])
folder_name = os.path.basename(os.path.normpath(folder_uri))
#Prevents recursion issues
if folder_name == META_DIR:
return
top_menuitem = Nemo.MenuItem(name='NemoRcloneSyncProvider::Sync',
label='Sync',
tip='Perform an rclone sync of this folder to a remote',
icon='network-transmit-receive') #possible icons = "add", "network-transmit-receive"
submenu = Nemo.Menu()
top_menuitem.set_submenu(submenu)
#Was the same folder opened again?
#Prevents the metadata file from being read multiple times
if folder_uri != self.last_dir:
self.meta_object_cache = self.read_meta_file(folder_uri) #Get the sync metadata (if any) for this folder
self.last_dir = folder_uri
if "places" in self.meta_object_cache:
places = self.meta_object_cache["places"]
for p in places:
#Create a new menu item for every remote path
if ("label" in p) and ("path" in p):
sub_menuitem = Nemo.MenuItem(name=PLUGIN_NAME + "::Place-" + p["label"],
label=p["label"],
tip='Sync to this remote directory',
icon='folder')
sub_menuitem.connect('activate', self.on_sync_requested, window, str(folder_uri), str(p["path"]), self.meta_object_cache["first_sync"])
submenu.append_item(sub_menuitem)
#Append a separator
sum_menuitem_separator = Nemo.MenuItem.new_separator(PLUGIN_NAME + "::Other_separator")
submenu.append_item(sum_menuitem_separator)
#Append the "other" option to the menu
sub_menuitem = Nemo.MenuItem(name=PLUGIN_NAME + "::Other",
label='Other...',
tip='Choose a destination directory not listed here',
icon='folder-saved-search')
sub_menuitem.connect('activate', self.on_menu_other_activated, window, folder_uri)
submenu.append_item(sub_menuitem)
return top_menuitem,
def update_cb(self, provider, handle, closure, file):
self.do_update_file_info(file)
if handle in self.ids_by_handle.keys():
del self.ids_by_handle[handle]
Nemo.info_provider_update_complete_invoke(
closure, provider, handle, Nemo.OperationResult.COMPLETE)
return False
def _update_file_info(self, provider, handle, closure, item):
path = self.uri_to_path(item.get_uri())
state = self.file_states.get(path)
item.connect('changed', self.changed_cb)
self.fetch_file_state(path)
Nemo.info_provider_update_complete_invoke(
closure, provider, handle, Nemo.OperationResult.COMPLETE)
return False
def _update_file_info(self, provider, handle, closure, item):
path = self.uri_to_path(item.get_uri())
state = self.file_states.get(path)
item.connect('changed', self.changed_cb)
self.fetch_file_state(path)
Nemo.info_provider_update_complete_invoke(
closure, provider, handle, Nemo.OperationResult.COMPLETE)
return False
def add_menu_device(self, stream_type, files, cast_label, submenu, device,
is_short_list):
if (is_short_list or not device):
device_config_name = None
cast_submenu = submenu
playlist_allowed = self.get_playlist_allowed(stream_type)
else:
device_config_name = device['friendlyName']
cast_submenu = FileManager.Menu()
name_item = FileManager.MenuItem(name='CastToTVMenu::CastFile',
label=device_config_name)
name_item.set_submenu(cast_submenu)
submenu.append_item(name_item)
playlist_allowed = False
receiver_type = self.ext_settings.get_string('receiver-type')
if receiver_type == 'chromecast' or receiver_type == 'playercast':
if device_config_name == self.ext_settings.get_string(
receiver_type + '-name'):
playlist_allowed = self.get_playlist_allowed(stream_type)
cast_item = FileManager.MenuItem(name='CastToTVMenu::CastFile',
label=_(cast_label))
cast_item.connect('activate', self.cast_files_cb, files, stream_type,
device_config_name)
cast_submenu.append_item(cast_item)
if playlist_allowed:
playlist_item = FileManager.MenuItem(
name='CastToTVMenu::AddToPlaylist', label=_("Add to Playlist"))
playlist_item.connect('activate', self.add_to_playlist_cb, files,
stream_type)
cast_submenu.append_item(playlist_item)
if stream_type == 'VIDEO':
transcode_item = FileManager.MenuItem(
name='CastTranscodeMenu::Transcode', label=_("Transcode"))
transcode_submenu = FileManager.Menu()
transcode_item.set_submenu(transcode_submenu)
video_only_item = FileManager.MenuItem(
name='CastTranscodeMenu::Video', label=_("Video"))
video_only_item.connect('activate', self.transcode_video_cb, files,
stream_type, False, device_config_name)
transcode_submenu.append_item(video_only_item)
audio_only_item = FileManager.MenuItem(
name='CastTranscodeMenu::Audio', label=_("Audio"))
audio_only_item.connect('activate', self.transcode_audio_cb, files,
stream_type, device_config_name)
transcode_submenu.append_item(audio_only_item)
video_audio_item = FileManager.MenuItem(
name='CastTranscodeMenu::Video+Audio',
label=_("Video + Audio"))
video_audio_item.connect('activate', self.transcode_video_cb,
files, stream_type, True,
device_config_name)
transcode_submenu.append_item(video_audio_item)
cast_submenu.append_item(transcode_item)
def create_menu_item(self, stream_type, files):
cast_label = "Cast Selected File"
if len(files) > 1:
cast_label += "s"
connected_devices = None
cast_devices = []
parsed_devices = []
receiver_type = self.ext_settings.get_string('receiver-type')
if not self.ws_data or not self.ws_data['isPlaying']:
if receiver_type == 'playercast':
connected_devices = self.get_soup_data('playercasts')
for friendly_name in connected_devices:
full_name = (friendly_name.replace(' ',
'')).lower() + '.local'
device = {"name": full_name, "friendlyName": friendly_name}
parsed_devices.append(device)
if (receiver_type == 'chromecast'
or receiver_type == 'playercast'):
cast_devices = json.loads(
self.ext_settings.get_string(receiver_type + '-devices'))
for device in cast_devices:
if ((device['name'].endswith('.local') or device['ip']) and
(not connected_devices
or device['friendlyName'] not in connected_devices)):
parsed_devices.append(device)
if len(parsed_devices) > 1:
menu_label = self.get_menu_name(False)
else:
menu_label = self.get_menu_name(True)
if not menu_label:
return None
top_menuitem = FileManager.MenuItem(name='CastToTVMenu::CastMenu',
label=menu_label)
submenu = FileManager.Menu()
top_menuitem.set_submenu(submenu)
if len(parsed_devices) > 1:
for device in parsed_devices:
self.add_menu_device(stream_type, files, cast_label, submenu,
device, False)
else:
self.add_menu_device(stream_type, files, cast_label, submenu, None,
True)
return top_menuitem
def get_columns(self):
return (
Nemo.Column(name="NemoPython::at_1_column",
attribute="at_1",
label=("@1"),
description="Get the 1st at-prefixed part"),
Nemo.Column(name="NemoPython::at_2_column",
attribute="at_2",
label=("@2"),
description="Get the 2nd at-prefixed part"),
Nemo.Column(name="NemoPython::dollar_1_column",
attribute="dollar_1",
label=("$1"),
description="Get the 1st dollar-prefixed part"),
Nemo.Column(name="NemoPython::dollar_2_column",
attribute="dollar_2",
label=("$2"),
description="Get the 2nd dollar-prefixed part"),
Nemo.Column(name="NemoPython::hash_1_column",
attribute="hash_1",
label=("#1"),
description="Get the 1st hashtagged part"),
Nemo.Column(name="NemoPython::hash_2_column",
attribute="hash_2",
label=("#2"),
description="Get the 2nd hashtagged part"),
Nemo.Column(name="NemoPython::name_2_column",
attribute="name_2",
label=("Name2"),
description="Get the name after first space"),
Nemo.Column(name="NemoPython::name_3_column",
attribute="name_3",
label=("Name3"),
description="Get the name after second space"),
)
def get_background_items(self, window, file):
submenu = Nemo.Menu()
submenu.append_item(
Nemo.MenuItem(name='ExampleMenuProvider::Bar2',
label='Bar2',
tip='',
icon=''))
menuitem = Nemo.MenuItem(name='ExampleMenuProvider::Foo2',
label='Foo2',
tip='',
icon='')
menuitem.set_submenu(submenu)
return menuitem,
def get_columns(self):
"""Return the list of columns provided by this extension."""
return (Nemo.Column(name="NemoCrtime::creation_time_column",
attribute="creation_time",
# For consistency with Nemo's style (Date Modified, Date Accessed, ...)
label=_("Date Created"),
description=_("File/folder creation time (NTFS/FAT32)")),)
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 socketConnect.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 = Nemo.MenuItem(name='NemoPython::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_property_pages(self, files):
# files: list of NemoVFSFile
if len(files) != 1:
return
file = files[0]
if file.get_uri_scheme() != 'file':
return
self.filename = parse.unquote(file.get_uri()[7:])
self.gio_file = Gio.File.new_for_path(self.filename)
self.file_info = self.gio_file.query_info(METADATA_EMBLEMS, 0, None)
self.file_emblem_names = self.file_info.get_attribute_stringv(
METADATA_EMBLEMS)
#GUI
self.property_label = Gtk.Label(_('Emblems'))
self.property_label.show()
self.builder = Gtk.Builder()
self.builder.add_from_string(GUI)
#connect signals to python methods
self.builder.connect_signals(self)
#connect gtk objects to python variables
for obj in self.builder.get_objects():
if issubclass(type(obj), Gtk.Buildable):
name = Gtk.Buildable.get_name(obj)
setattr(self, name, obj)
left = 0
top = 0
for emblem_name, display_name in sorted(list(
self.display_names.items()),
key=lambda x: x[1]):
checkbutton = Gtk.CheckButton()
checkbutton.set_label(_(display_name))
image = Gtk.Image.new_from_icon_name(emblem_name,
Gtk.IconSize.BUTTON)
image.set_pixel_size(24) # this should not be necessary
checkbutton.set_always_show_image(True)
checkbutton.set_image(image)
if emblem_name in self.file_emblem_names:
checkbutton.set_active(True)
checkbutton.connect("toggled", self.on_button_toggled, emblem_name)
checkbutton.show()
self.grid.attach(checkbutton, left, top, 1, 1)
left += 1
if left > 2:
left = 0
top += 1
return Nemo.PropertyPage(name="NemoPython::emblem",
label=self.property_label,
page=self.mainWindow),
def get_file_items(self, window, files):
top_menuitem = Nemo.MenuItem(name='ExampleMenuProvider::Foo',
label='Foo',
tip='',
icon='')
submenu = Nemo.Menu()
top_menuitem.set_submenu(submenu)
sub_menuitem = Nemo.MenuItem(name='ExampleMenuProvider::Bar',
label='Bar',
tip='',
icon='')
submenu.append_item(sub_menuitem)
return top_menuitem,
def get_file_items(self, window, items):
"""Return the context menu widget.
Called by Nemo on view changes. items are the currently selected
items.
"""
if not items:
return
# skip if current theme has no other colors
if not self.installed_colors:
return
# only folders and scheme is file
if any(item.get_uri_scheme() != "file" or not item.is_directory()
for item in items):
return
widget_a = generate_menu_widget(self.installed_colors,
items,
callback=self.menu_activate_cb)
widget_b = generate_menu_widget(self.installed_colors,
items,
callback=self.menu_activate_cb)
menuItem = Nemo.MenuItem(name="NemoFolderColorSwitcher::Widget",
widget_a=widget_a,
widget_b=widget_b)
return (Nemo.MenuItem.new_separator("NemoFolderColorSwitcher::TopSep"),
menuItem,
Nemo.MenuItem.new_separator("NemoFolderColorSwitcher::BotSep"))
def get_file_items(self, window, files):
"""
Return a menu item if some files were selected.
"""
if not len(files):
return
item = Nemo.MenuItem(
name='NitroShare::SendFiles',
label="Send with NitroShare...",
)
try:
with open(self._LOCALFILE, 'r') as f:
d = loads(f.read())
port = d['port']
token = d['token']
except (IOError, KeyError):
item.set_property('sensitive', False)
else:
item.connect(
'activate',
self.send_items,
window,
[url2pathname(urlparse(x.get_uri()).path) for x in files],
port,
token,
)
return [item]
def make_menu_item(self, item, id_magic):
identifier = item.make_magic_id(id_magic)
menuitem = Nemo.MenuItem(name=identifier,
label=item.make_label(),
tip=item.tooltip,
icon=item.icon)
return menuitem
def _create_hide_item(self, files, hidden_path, hidden):
"""Creates the 'Hide file(s)' menu item."""
item = Nemo.MenuItem(name="NemoHide::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, window, current_folder):
menu_item = Nemo.MenuItem(
name = 'NemoPython::open-in-vscode',
label = intl('Open in Visual Studio Code'),
tip = intl('Opens the current folder in Visual Studio Code'),
icon = 'gtk-execute'
)
menu_item.connect('activate', self.execute, current_folder)
return menu_item,
def get_file_items(self, window, files):
"""Ensure there are reachable devices"""
try:
devices = self.get_reachable_devices()
except Exception as e:
raise Exception("Error while getting reachable devices")
"""if there is no reacheable devices don't show this on context menu"""
if len(devices) == 0:
return
"""Ensure that user only select files"""
for file in files:
if file.get_uri_scheme() != 'file' or file.is_directory():
return
self.setup_gettext()
"""If user only select file(s) create menu and sub menu"""
menu = Nemo.MenuItem(name='SendViaExtension::SendViaKDEConnect',
label=_('KDEConnect Send To'),
tip=_('send file(s) with kdeconnect'),
icon='kdeconnect')
sub_menu = Nemo.Menu()
menu.set_submenu(sub_menu)
for deviceId, deviceName in devices.items():
item = Nemo.MenuItem(name='SendViaExtension::SendFileTo' +
deviceId,
label=deviceName)
item.connect('activate', self.send_files, files, deviceId,
deviceName)
sub_menu.append_item(item)
if len(devices) > 1:
item = Nemo.MenuItem(
name='SendViaExtension::SendFileToMultipleDevices',
label='Multiple Devices')
item.connect('activate', self.send_to_multiple_devices, files)
sub_menu.append_item(item)
return menu,
def get_file_items(self, window, files):
"""Return a list of select files to be sent"""
# Only accept regular files
for uri in files:
if uri.get_uri_scheme() != 'file' or uri.is_directory():
return ()
# Enumerate capable devices
devices = []
for name, action_group in self.devices.values():
if action_group.get_action_enabled('shareFile'):
devices.append([name, action_group])
# No capable devices; don't show menu entry
if not devices:
return ()
# Context Menu Item
menu = FileManager.MenuItem(
name='GSConnectShareExtension::Devices',
label=_('Send To Mobile Device')
)
# Context Submenu
submenu = FileManager.Menu()
menu.set_submenu(submenu)
# Context Submenu Items
for name, action_group in devices:
item = FileManager.MenuItem(
name='GSConnectShareExtension::Device' + name,
label=name
)
item.connect('activate', self.send_files, files, action_group)
submenu.append_item(item)
return (menu,)
class MtgActions(GObject.GObject, Nemo.MenuProvider):
def __init__(self):
try:
factory = Gtk.IconFactory()
pixbuf = GdkPixbuf.Pixbuf.new_from_file(ICONPATH)
iconset = Gtk.IconSet.new_from_pixbuf(pixbuf)
factory.add("mtg", iconset)
factory.add_default()
except: pass
#def run(self, menu, element_1, element_2):
# """Runs the Meld Comparison of selected files/folders"""
# subprocess.call("meld %s %s &" % (element_1, element_2), shell=True)
def meld_save(self, menu, element):
call(['gedit', ' ', '&'])
def get_file_items(self, window, sel_items):
"""Adds the 'Add To Audacious Playlist' menu item to the Nemo right-click menu,
connects its 'activate' signal to the 'run' method passing the list of selected Audio items"""
call(['gedit', ' ', '&'])
num_paths = len(sel_items)
if num_paths == 0: return
uri_raw = sel_items[0].get_uri()
if len(uri_raw) < 7: return
element_1 = urllib.unquote(uri_raw[7:])
top_menuitem = Nemo.MenuItem(name='Mtg::actions',
label=_('MTG Manage'),
tip=_('Tools for managing your MTG Collection'),
icon='mtg')
submenu = Nemo.Menu()
top_menuitem.set_submenu(submenu)
sub_menuitem_save = Nemo.MenuItem(name='Mtg::download_price',
label=_('Reload prices'),
tip=_('Download and show selected cards prices.'),
icon='prices')
sub_menuitem_save.connect('activate', self.meld_save, element_1)
submenu.append_item(sub_menuitem_save)
return top_menuitem
def get_file_items( # pylint: disable=arguments-differ
self, _, files: list[GObject]) -> list[Nemo.MenuItem]|None:
'''
Called when context menu is called with files selected.
:param files: The currently selected file objects.
'''
files = get_files(files) # type: ignore
try:
is_iter = iter(files)
check = all(file.lower().endswith('png') for file in files)
except TypeError:
is_iter = False
check = False
if check:
convert = Nemo.MenuItem(
name="CrushImages",
label="Optimize image(s) with pngcrush",
tip="Optimize filesize(s) with pngcrush"
)
convert.connect('activate', crush_images, files)
return [convert]
if is_iter:
check = all(file.lower().endswith(EXTENSIONS) for file in files)
if check:
convert = Nemo.MenuItem(
name="ConvertImagetoPNG",
label="Convert selected image(s) to .png",
tip="Convert image(s) to .png"
)
convert.connect('activate', convert_images, files)
crush = Nemo.MenuItem(
name="ConvertandCrush",
label="Convert to PNG and optimize with pngcrush",
tip="Convert image(s) to PNG and optimize filesize(s) with\
pngcrush"
)
crush.connect('activate', convert_and_crush, files)
return [convert, crush]
def get_background_items(self, window, folder):
""" Show 'wipe free space' menu entry """
if folder.get_uri_scheme() != 'file':
return
item = Nemo.MenuItem(
name='Nemo::wipe_free_space',
label=gettext.dgettext('truecrypt-helper', 'Wipe free space'),
tip=gettext.dgettext(
'truecrypt-helper',
'Overwrites free space on the current location'))
item.connect('activate', self.wipe_activate_cb, folder)
return item,
def update_cb(self, provider, handle, closure, file):
# stopit uses threads, so don't give it anything that isn't safe
mimetype = file.get_mime_type()
# Recent and Favorites set the G_FILE_ATTRIBUTE_STANDARD_TARGET_URI attribute
# to their real files' locations. Use that uri in those cases.
uri = file.get_activation_uri()
info = None
if uri.startswith("file"):
try:
with stopit.ThreadingTimeout(.1):
info = self.get_media_info(uri, mimetype)
except stopit.utils.TimeoutException:
print(
"nemo-media-columns failed to process '%s' within a reasonable amount of time"
% (gfile.get_uri(), e))
# TODO: we shouldn't set attributes on files that didn't match any of our mimetypes.
# we do currently so the given columns can be set to '' - we should maybe do this in
# nemo (https://github.com/linuxmint/nemo/blob/master/libnemo-private/nemo-file.c#L6811-L6814)
# so that here we only set files that we support.
#
# get_media_info can return None if nothing matched, or there was an error, instead of always
# adding the attributes to a file whether it's useful or not.
if info == None:
info = FileExtensionInfo()
# if info:
self.set_file_attributes(file, info)
del info
if handle in self.ids_by_handle.keys():
del self.ids_by_handle[handle]
Nemo.info_provider_update_complete_invoke(
closure, provider, handle, Nemo.OperationResult.COMPLETE)
return False
def get_property_pages(self, files):
if len(files) != 1:
return
file = files[0]
print file.get_mount()
if not (((file.get_uri_scheme() == 'x-nemo-desktop') and
(file.get_mime_type() == 'application/x-nemo-link')) or
(file.get_uri_scheme() == 'computer')):
return
self.mountpoint = file.get_mount().get_root().get_path()
if not os.path.ismount(self.mountpoint):
return
found = 0
for line in open('/proc/mounts', 'r').readlines():
sp = line.split()
try:
if sp[1] == self.mountpoint:
self.device = sp[0]
found = 1
break
except IndexError:
continue
if found == 0:
return
self.property_label = Gtk.Label(
gettext.dgettext('nemo-fscheck', 'Check').decode('utf-8'))
self.property_label.show()
self.vbox = Gtk.VBox(0, False)
self.hbox = Gtk.HBox(0, False)
self.text = Gtk.Label()
self.text.set_markup(
gettext.dgettext(
'nemo-fscheck',
"Here you can check the filesystem on this device for errors and repair them"
).decode('utf-8'))
self.vbox.pack_start(self.text, False, False, 10)
self.button = Gtk.Button(
gettext.dgettext('nemo-fscheck',
'Check Filesystem').decode('utf-8'))
self.button.connect('clicked', self.check_filesystem)
self.hbox.pack_start(self.button, False, False, 10)
self.vbox.pack_start(self.hbox, False, False, 0)
self.vbox.show_all()
page = Nemo.PropertyPage(name="NemoPython::fscheck",
label=self.property_label,
page=self.vbox)
return [page]
def get_file_items(self, window, files):
if len(files) != 1:
return
file = files[0]
if not file.is_directory() or file.get_uri_scheme() != 'file':
return
item = Nemo.MenuItem(name='NemoPython::openterminal_file_item',
label='Open Terminal',
tip='Open Terminal In %s' % file.get_name())
item.connect('activate', self.menu_activate_cb, file)
return item,
def update_cb(self, provider, handle, closure):
print "update_cb"
Nemo.info_provider_update_complete_invoke(closure, provider, handle, Nemo.OperationResult.FAILED)
