def thumbnail_ora(procedure, file, thumb_size, args, data):
tempdir = tempfile.mkdtemp('gimp-plugin-file-openraster')
orafile = zipfile.ZipFile(file.peek_path())
stack, w, h = get_image_attributes(orafile)
# create temp file
tmp = os.path.join(tempdir, 'tmp.png')
with open(tmp, 'wb') as fid:
fid.write(orafile.read('Thumbnails/thumbnail.png'))
thumb_file = Gio.file_new_for_path(tmp)
result = Gimp.get_pdb().run_procedure('file-png-load', [
GObject.Value(Gimp.RunMode, Gimp.RunMode.NONINTERACTIVE),
GObject.Value(Gio.File, thumb_file),
])
os.remove(tmp)
os.rmdir(tempdir)
if (result.index(0) == Gimp.PDBStatusType.SUCCESS):
img = result.index(1)
# TODO: scaling
return Gimp.ValueArray.new_from_values([
GObject.Value(Gimp.PDBStatusType, Gimp.PDBStatusType.SUCCESS),
GObject.Value(Gimp.Image, img),
GObject.Value(GObject.TYPE_INT, w),
GObject.Value(GObject.TYPE_INT, h),
GObject.Value(Gimp.ImageType, Gimp.ImageType.RGB_IMAGE),
GObject.Value(GObject.TYPE_INT, 1)
])
else:
return procedure.new_return_values(result.index(0),
GLib.Error(result.index(1)))
def on_epub_scheme(self, request):
"""Callback function for epub scheme requests
Finish a WebKit2.URISchemeRequest by setting the contents of the request
and its mime type.
Args:
request (WebKit2.URISchemeRequest)
"""
if not self.doc:
return
uri = request.get_uri()
logger.info('Resource request:' + uri)
try:
path, fragment = self.get_path_fragment(uri)
if self.jump_to_path_fragment(path, fragment):
return
except BookError as e:
error_str = str(e)
logger.error('Could not get resource:' + error_str)
request.finish_error(GLib.Error(error_str))
else:
bytes = self.doc.get_resource(path)
gbytes = GLib.Bytes(bytes)
stream = Gio.MemoryInputStream.new_from_bytes(gbytes)
stream_length = gbytes.get_size()
mime = self.doc.get_resource_mime(path)
request.finish(stream, stream_length, mime)
def expand_all_cb(self, obj, result, task):
try:
self.expand_all_finish(result)
task.return_boolean(True)
except Exception as exc:
print(exc)
task.return_error(GLib.Error(repr(exc)))
def test_matches(self):
mydomain = GLib.quark_from_string('mydomain')
notmydomain = GLib.quark_from_string('notmydomain')
e = GLib.Error('test message', 'mydomain', 42)
self.assertTrue(e.matches(mydomain, 42))
self.assertFalse(e.matches(notmydomain, 42))
self.assertFalse(e.matches(mydomain, 40))
def _on_epub_scheme(self, request):
"""Callback function for epub scheme requests
Finish a WebKit2.URISchemeRequest by setting the contents of
the request and its mime type.
Args:
request (WebKit2.URISchemeRequest)
"""
if not self.doc:
return
uri = request.get_uri()
try:
path, fragment = self._get_path_fragment(uri)
except BookError as e:
error_str = e.args[1]
request.finish_error(GLib.Error(error_str))
return
if self.doc.is_page(path):
self.set_chapter_path_fragment(path, fragment)
return
resource_content = self.doc.get_resource_content(path)
resource_gbytes = GLib.Bytes(resource_content)
stream = Gio.MemoryInputStream.new_from_bytes(resource_gbytes)
stream_length = resource_gbytes.get_size()
mime = self.doc.get_resource_mime(path)
request.finish(stream, stream_length, mime)
def __on_web_process_crashed(self, view):
"""
We just crashed :-(
@param view as WebKit2.WebView
"""
self._error = GLib.Error()
f = Gio.File.new_for_uri("resource:///org/gnome/Eolie/error.css")
(status, css_content, tag) = f.load_contents(None)
css = css_content.decode("utf-8")
f = Gio.File.new_for_uri("resource:///org/gnome/Eolie/error.html")
(status, content, tag) = f.load_contents(None)
html = content.decode("utf-8")
html = html % (_("WebKit web engine crashed"), css,
"load_uri('https://bugs.webkit.org/"
"enter_bug.cgi?product=WebKit')",
"internal:/help-faq-symbolic",
_("WebKit web engine crashed"), "",
_("The webpage was terminated unexpectedly."
"To continue, reload or go to another page.<br/><br/>"
"If problem persist, you can report a bug :)<br/>"
"Use <b>'Webkit Gtk'</b> as component.<br/>"
"Set <b>[GTK]</b> as subject prefix."),
"suggested-action", _("Report a bug now"))
self.load_html(html, view.get_uri())
return True
def do_get_targets_async(self, cancellable, callback, data):
task = Ide.Task.new(self, cancellable, callback)
task.set_priority(GLib.PRIORITY_LOW)
context = self.get_context()
build_system = Ide.BuildSystem.from_context(context)
if type(build_system) != SwiftBuildSystem:
task.return_error(
GLib.Error('Not swift build system',
domain=GLib.quark_to_string(Gio.io_error_quark()),
code=Gio.IOErrorEnum.NOT_SUPPORTED))
return
print(Ide.BuildSystem.from_context(context).project_file.get_path())
pkg_dump = check_output(
["swift", "package", "dump-package"],
cwd=Ide.BuildSystem.from_context(context).project_file.get_path(),
universal_newlines=True)
pkg_set = json.loads(pkg_dump)
task.targets = []
for target in pkg_set["targets"]:
#if target["type"] == "regular":
newtarget = SwiftBuildTarget(target["name"])
print("newtarget = ", newtarget.target_name)
task.targets.append(build_system.ensure_child_typed(newtarget))
task.return_boolean(True)
def build_flags_thread():
commands_file = path.join(self._get_build_dir().get_path(),
'compile_commands.json')
try:
with open(commands_file) as f:
commands = json.loads(f.read(), encoding='utf-8')
except (json.JSONDecodeError, FileNotFoundError,
UnicodeDecodeError) as e:
task.return_error(
GLib.Error('Failed to decode meson json: {}'.format(e)))
return
infile = ifile.get_path()
for c in commands:
filepath = path.normpath(path.join(c['directory'], c['file']))
if filepath == infile:
try:
task.build_flags = extract_flags(c['command'])
except GLib.Error as e:
task.return_error(e)
return
break
else:
print('Meson: Warning: No flags found')
task.return_boolean(True)
def register(self):
node_xml = "<node name='/'><interface name='%s'>" % self._interface_name
for method_name, method_info in self._methods.items():
node_xml += "<method name='%s'>" % method_name
for argument in method_info[0]:
node_xml += "<arg type='%s' direction='in'/>" % argument
if method_info[1]:
node_xml += "<arg type='%s' direction='out'/>" % method_info[1]
node_xml += "</method>"
for signal_name, signal_signature in self._signals.items():
node_xml += "<signal name='%s'>" % signal_name
if signal_signature:
node_xml += "<arg type='%s'/>" % signal_signature
node_xml += "</signal>"
node_xml += "</interface></node>"
node_info = Gio.DBusNodeInfo.new_for_xml(node_xml)
regid = self._bus.register_object(self._path, node_info.interfaces[0],
self._handle_method_call, None, None)
if regid:
self._regid = regid
else:
raise GLib.Error('Failed to register object with path: %s',
self._path)
def on_disconnect(self,
_item: Gtk.MenuItem,
service: Service,
port: int = 0) -> None:
def ok(_obj: AppletService, _result: None, _user_date: None) -> None:
logging.info("disconnect success")
self.generate()
def err(_obj: Optional[AppletService], result: GLib.Error,
_user_date: None) -> None:
logging.warning(f"disconnect failed {result}")
msg, tb = e_(result.message)
MessageArea.show_message(_("Disconnection Failed: ") + msg, tb)
self.generate()
if self._appl is None:
err(None, GLib.Error('Applet DBus Service not available'), None)
return
self._appl.DisconnectService('(osd)',
service.device.get_object_path(),
service.uuid,
port,
result_handler=ok,
error_handler=err)
def on_connect(self, _item, service):
device = service.device
def success(obj, result, _user_data):
logging.info("success")
prog.message(_("Success!"))
if isinstance(service, SerialPort) and SERIAL_PORT_SVCLASS_ID == service.short_uuid:
MessageArea.show_message(_("Serial port connected to %s") % result, None, "dialog-information")
else:
MessageArea.close()
self.unset_op(device)
def fail(obj, result, _user_data):
prog.message(_("Failed"))
self.unset_op(device)
logging.warning("fail %s" % result)
msg, tb = e_(result.message)
MessageArea.show_message(_("Connection Failed: ") + msg, tb)
self.set_op(device, _("Connecting..."))
prog = ManagerProgressbar(self.Blueman, False)
if self._appl is None:
fail(None, GLib.Error('Applet DBus Service not available'), None)
return
self._appl.ConnectService('(os)', device.get_object_path(), service.uuid,
result_handler=success, error_handler=fail,
timeout=GLib.MAXINT)
prog.start()
def disconnect_service(self,
device: Device,
uuid: str = GENERIC_CONNECT,
port: int = 0) -> None:
def ok(_obj: AppletService, _result: None, _user_date: None) -> None:
logging.info("disconnect success")
self.generate()
def err(_obj: Optional[AppletService], result: GLib.Error,
_user_date: None) -> None:
logging.warning(f"disconnect failed {result}")
msg, tb = e_(result.message)
MessageArea.show_message(_("Disconnection Failed: ") + msg, tb)
self.generate()
if self._appl is None:
err(None, GLib.Error('Applet DBus Service not available'), None)
return
self._appl.DisconnectService('(osd)',
device.get_object_path(),
uuid,
port,
result_handler=ok,
error_handler=err,
timeout=GLib.MAXINT)
def do_find_nearest_scope_async(self,
location,
cancellable,
callback,
user_data=None):
task = Gio.Task.new(self, cancellable, callback)
task.return_error(GLib.Error('Not implemented'))
def do_update_async(self, cancellable, callback, data):
task = Gio.Task.new(self, cancellable, callback)
task.set_priority(GLib.PRIORITY_LOW)
context = self.get_context()
build_system = context.get_build_system()
if type(build_system) != DubBuildSystem:
task.return_boolean(True)
return
build_manager = context.get_build_manager()
pipeline = build_manager.get_pipeline()
if not pipeline:
task.return_error(
GLib.Error('Cannot update dependencies without build pipeline',
domain=GLib.quark_to_string(Gio.io_error_quark()),
code=Gio.IOErrorEnum.FAILED))
return
launcher = pipeline.create_launcher()
launcher.push_argv("dub")
launcher.push_argv("--root=" + get_working_dir(context).get_path())
launcher.push_argv("upgrade")
try:
subprocess = launcher.spawn()
subprocess.wait_check_async(None, self.wait_check_cb, task)
except Exception as ex:
task.return_error(ex)
def _get_build_flags_build_communicate_cb(self, subprocess, result, task):
"""
Completes the asynchronous request to get the build flags from the make
helper subprocess.
"""
try:
_, stdout, stderr = subprocess.communicate_utf8_finish(result)
info = {}
for line in stdout.split('\n'):
if '=' in line:
k, v = line.split('=', 1)
info[k.strip()] = v.strip()
if task.type == _TYPE_C:
flags = info.get('CFLAGS', '') + " " + info.get('INCLUDES', '')
elif task.type == _TYPE_CPLUSPLUS:
flags = info.get('CXXFLAGS', '') + " " + info.get(
'INCLUDES', '')
else:
raise RuntimeError
_, build_flags = GLib.shell_parse_argv(flags)
task.build_flags = build_flags
task.return_boolean(True)
except Exception as ex:
print(repr(ex))
task.return_error(GLib.Error(message=repr(ex)))
def do_lookup_symbol_async(self,
location,
cancellable,
callback,
user_data=None):
task = Gio.Task.new(self, cancellable, callback)
task.return_error(GLib.Error('Not implemented'))
def get_sphinx_rst_worker(self, task, text, path, basedir, builddir):
add_override_file(path, text)
if GLib.find_program_in_path('sphinx-build-3'):
program = 'sphinx-build-3'
else:
program = 'sphinx-build'
rel_path = os.path.relpath(path, start=basedir)
command = [program, '-Q', '-b', 'html', basedir, builddir, path]
rel_path_html = os.path.splitext(rel_path)[0] + '.html'
builddir_path = os.path.join(builddir, rel_path_html)
try:
launcher = Ide.SubprocessLauncher.new(
0) # Gio.SubprocessFlags.STDOUT_SILENCE |
# Gio.SubprocessFlags.STDERR_SILENCE)
launcher.push_args(command)
subprocess = launcher.spawn()
subprocess.wait_check()
task.builddir_path = builddir_path
task.return_boolean(True)
except Exception as ex:
task.return_error(GLib.Error(ex))
finally:
remove_override_file(path)
def register(self) -> None:
node_xml = f"<node name='/'><interface name='{self._interface_name}'>"
for property_name, signature in self._properties.items():
node_xml += f"<property name='{property_name}' type='{signature}' access='read'/>"
for method_name, method_info in self._methods.items():
node_xml += f"<method name='{method_name}'>"
for argument in method_info[0]:
node_xml += f"<arg type='{argument}' direction='in'/>"
for result in method_info[1]:
node_xml += f"<arg type='{result}' direction='out'/>"
node_xml += "</method>"
for signal_name, signal_signature in self._signals.items():
node_xml += f"<signal name='{signal_name}'>"
for signature in signal_signature:
node_xml += f"<arg type='{signature}'/>"
node_xml += "</signal>"
node_xml += "</interface></node>"
node_info = Gio.DBusNodeInfo.new_for_xml(node_xml)
regid = self._bus.register_object(self._path, node_info.interfaces[0],
self._handle_method_call,
self._get_property, None)
if regid:
self._regid = regid
else:
raise GLib.Error(
f"Failed to register object with path: {self._path}")
def on_drag_data_received(self, widget: Gtk.Widget,
drag_context: Gdk.DragContext, x: int, y: int,
data: Gtk.SelectionData, info: int,
time: int) -> None:
drop_source: Tuple[str, Any] = GLib.filename_from_uri(data.get_text())
folder_path: str = drop_source[0].rstrip()
saved_folders: List[str] = self.settings.get_value(
'saved-folders').unpack()
try:
if GLib.file_test(folder_path, GLib.FileTest.IS_DIR):
self._main_label_box.props.visible = False
label: str = folder_path
folder: FolderBox = FolderBox(label)
self._main_list_box.props.visible = True
folder.set_title(label)
self._main_list_box.add(folder)
saved_folders.append(label)
self.settings.set_value('saved-folders',
GLib.Variant('as', saved_folders))
else:
raise GLib.Error(
message=f'Error: {folder_path} is not a folder.')
except GLib.Error as err:
print('%s' % err.message)
def _get_build_flags_build_cb(self, build_manager, result, task):
"""
Completes the asynchronous call to advance the pipeline to CONFIGURE phase
and then runs a make subprocess to extract build flags from Makefile.
"""
try:
build_manager.build_finish(result)
pipeline = build_manager.get_pipeline()
# Launcher defaults to $builddir
launcher = pipeline.create_launcher()
launcher.set_flags(Gio.SubprocessFlags.STDIN_PIPE
| Gio.SubprocessFlags.STDOUT_PIPE
| Gio.SubprocessFlags.STDERR_PIPE)
launcher.push_argv('make')
launcher.push_argv('-f')
launcher.push_argv('-')
launcher.push_argv('print-CFLAGS')
launcher.push_argv('print-CXXFLAGS')
launcher.push_argv('print-INCLUDES')
subprocess = launcher.spawn()
subprocess.communicate_utf8_async(
_BUILD_FLAGS_STDIN_BUF, task.get_cancellable(),
self._get_build_flags_build_communicate_cb, task)
except Exception as ex:
print(repr(ex))
task.return_error(GLib.Error(message=repr(ex)))
def __on_web_process_crashed(self, view):
"""
We just crashed :-(
@param view as WebKit2.WebView
"""
self._error = GLib.Error()
print("WebViewErrors::__on_web_process_crashed():", view)
def signal_wait_timeout(self):
if not self.device or not self.connection:
self.err_cb(
GLib.Error("Network Manager did not support the connection"))
if self.connection:
self.remove_connection()
self.cleanup()
def do_find_references_async(self,
location,
language_id,
cancellable,
callback,
user_data=None):
task = Gio.Task.new(self, cancellable, callback)
task.return_error(GLib.Error('Not implemented'))
def expand_all_cb(self, obj, result, task):
try:
self.expand_all_finish(result)
task.return_boolean(True)
except Exception as exc:
if isinstance(exc, GLib.Error):
task.return_error(exc)
else:
task.return_error(GLib.Error(repr(exc)))
def do_generate_key_async(self,
location,
flags,
cancellable,
callback,
user_data=None):
# print('generate key')
task = Gio.Task.new(self, cancellable, callback)
task.return_error(GLib.Error('Not implemented'))
def _get_tree_thread(self, task, launcher, file_):
try:
proc = launcher.spawn()
success, stdout, stderr = proc.communicate_utf8(None, None)
if not success:
task.return_error(GLib.Error('Failed to run gjs'))
return
task.symbol_tree = JsSymbolTree(json.loads(stdout), file_)
except GLib.Error as err:
task.return_error(err)
except (json.JSONDecodeError, UnicodeDecodeError) as e:
task.return_error(GLib.Error('Failed to decode gjs json: {}'.format(e)))
except (IndexError, KeyError) as e:
task.return_error(GLib.Error('Failed to extract information from ast: {}'.format(e)))
else:
task.return_boolean(True)
def execute(self, task, launcher, srcdir, file, file_content):
try:
launcher.push_args(
(self._get_eslint(srcdir), '-f', 'json', '--ignore-pattern',
'!node_modules/*', '--ignore-pattern', '!bower_components/*'))
if file_content:
launcher.push_argv('--stdin')
launcher.push_argv('--stdin-filename=' + file.get_path())
else:
launcher.push_argv(file.get_path())
sub_process = launcher.spawn()
success, stdout, stderr = sub_process.communicate_utf8(
file_content, None)
if not success:
task.return_boolean(False)
return
results = json.loads(stdout)
for result in results:
for message in result.get('messages', []):
if 'line' not in message or 'column' not in message:
continue
start_line = max(message['line'] - 1, 0)
start_col = max(message['column'] - 1, 0)
start = Ide.SourceLocation.new(file, start_line, start_col,
0)
end = None
if 'endLine' in message:
end_line = max(message['endLine'] - 1, 0)
end_col = max(message['endColumn'] - 1, 0)
end = Ide.SourceLocation.new(file, end_line, end_col,
0)
severity = SEVERITY_MAP[message['severity']]
diagnostic = Ide.Diagnostic.new(severity,
message['message'], start)
if end is not None:
range_ = Ide.SourceRange.new(start, end)
diagnostic.add_range(range_)
# if 'fix' in message:
# Fixes often come without end* information so we
# will rarely get here, instead it has a file offset
# which is not actually implemented in IdeSourceLocation
# fixit = Ide.Fixit.new(range_, message['fix']['text'])
# diagnostic.take_fixit(fixit)
task.diagnostics_list.append(diagnostic)
except GLib.Error as err:
task.return_error(err)
except (json.JSONDecodeError, UnicodeDecodeError, IndexError) as e:
task.return_error(
GLib.Error('Failed to decode eslint json: {}'.format(e)))
else:
task.return_boolean(True)
def test_gerror_boxing(self):
error = GLib.Error('test message', domain='mydomain', code=42)
value = GObject.Value(GLib.Error, error)
self.assertEqual(value.g_type, GObject.type_from_name('GError'))
unboxed = value.get_value()
self.assertEqual(unboxed.message, error.message)
self.assertEqual(unboxed.domain, error.domain)
self.assertEqual(unboxed.code, error.code)
def _index_file_cb(self, subprocess, result, task):
try:
_, stdout, stderr = subprocess.communicate_utf8_finish(result)
ide_file = Ide.File(file=task.file, context=self.get_context())
try:
root_node = JsSymbolTree._node_from_dict(json.loads(stdout), ide_file)
except (json.JSONDecodeError, UnicodeDecodeError) as e:
raise GLib.Error('Failed to decode gjs json: {}'.format(e))
except (IndexError, KeyError) as e:
raise GLib.Error('Failed to extract information from ast: {}'.format(e))
builder = Ide.CodeIndexEntryBuilder()
entries = []
# TODO: Avoid recreating the same data
for node in self._flatten_node_list(root_node):
builder.set_key(node.props.file.get_path() + '|' + node.props.name) # Some unique value..
builder.set_name(self._get_node_name(node))
builder.set_kind(node.props.kind)
builder.set_flags(node.props.flags)
# Not sure why offset here doesn't match tree
builder.set_range(node.props.line + 1, node.props.col + 1, 0, 0)
entries.append(builder.build())
task.entries = JsCodeIndexEntries(task.file, entries)
task.return_boolean(True)
except Exception as ex:
print(repr(ex))
task.return_error(GLib.Error(message=repr(ex)))
finally:
try:
if self.queue:
task = self.queue.pop(0)
launcher = GjsSymbolProvider._get_launcher(self.get_context(), task.file)
proc = launcher.spawn()
proc.communicate_utf8_async(None, task.get_cancellable(), self._index_file_cb, task)
return
except Exception as ex:
print(repr(ex))
self.active = False
def update_title_task_func(task, source_object, task_data, cancellable):
try:
html = urllib.request.urlopen(self._data).read().decode("UTF-8")
soup = BeautifulSoup(html, "html.parser")
value = GObject.Value(str, soup.title.string)
task.return_value(value)
except (urllib.error.HTTPError, urllib.error.URLError) as ex:
error = GLib.Error("Fetching title for problem report failed: %s" % (ex))
task.return_error(error)
