def show_edit(self, branch_name):
self.state = STATE_EDIT
branch_name = saxutils.unescape(branch_name)
self.selected_branch = None
for item in self.branch_list:
if item.name == branch_name:
self.selected_branch = item
break
self.save_button.set_label(_("Save"))
if self.selected_branch:
self.branch_entry.set_text(S(self.selected_branch.name).display())
self.revision_label.set_text(
S(self.selected_branch.revision).display())
self.message_label.set_text(
S(self.selected_branch.message.rstrip("\n")).display())
if self.selected_branch.tracking:
self.checkout_checkbox.set_active(True)
self.checkout_checkbox.set_sensitive(False)
else:
self.checkout_checkbox.set_active(False)
self.checkout_checkbox.set_sensitive(True)
self.show_rows(self.view_rows)
self.get_widget("detail_label").set_markup(_("<b>Branch Detail</b>"))
def _populate_checker_tab(self, report_failure=True, connect=True):
# This is a limitation of GLADE, and can be removed when we migrate to
# GTK2 Builder
checker_service = self.checker_service
if not checker_service and connect:
checker_service = self._get_checker_service(report_failure)
self.get_widget("stop_checker").set_sensitive(bool(checker_service))
if (checker_service):
self.get_widget("checker_type").set_text(
S(checker_service.CheckerType()).display())
self.get_widget("pid").set_text(S(checker_service.PID()).display())
memory = checker_service.MemoryUsage()
if memory:
self.get_widget("memory_usage").set_text("%s KB" % memory)
else:
self.get_widget("memory_usage").set_text(CHECKER_UNKNOWN_INFO)
self.get_widget("locale").set_text(
S(".".join(checker_service.SetLocale())).display())
self._populate_info_table(checker_service.ExtraInformation())
else:
self.get_widget("checker_type").set_text(CHECKER_UNKNOWN_INFO)
self.get_widget("pid").set_text(CHECKER_UNKNOWN_INFO)
self.get_widget("memory_usage").set_text(CHECKER_UNKNOWN_INFO)
self.get_widget("locale").set_text(CHECKER_UNKNOWN_INFO)
self._clear_info_table()
def diff_previous_revision(self, widget, data=None):
prev = self.caller.previous_revision(self.revisions[0])
helper.launch_ui_window("diff", [
"%s@%s" % (self.path, S(prev)),
"%s@%s" % (self.path, S(self.revisions[0])),
"--vcs=%s" % self.caller.get_vcs_name()
])
def __init__(self, path):
'''
Initialises the UI.
'''
InterfaceView.__init__(self, "property_editor", "PropertyEditor")
note = rabbitvcs.ui.wraplabel.WrapLabel(PROP_EDITOR_NOTE)
note.set_hexpand(True)
note.set_use_markup(True)
self.get_widget("note_box").add(note)
self.get_widget("note_box").show_all()
self.path = path
self.get_widget("wc_text").set_text(
S(self.get_local_path(os.path.realpath(path))).display())
self.vcs = rabbitvcs.vcs.VCS()
self.svn = self.vcs.svn()
if not self.svn.is_versioned(self.path):
rabbitvcs.ui.dialog.MessageBox(
_("File is not under version control."))
self.close()
return
self.get_widget("remote_uri_text").set_text(
S(self.svn.get_repo_url(path)).display())
self.table = rabbitvcs.ui.widget.Table(
self.get_widget("table"), [
GObject.TYPE_STRING, rabbitvcs.ui.widget.TYPE_ELLIPSIZED,
GObject.TYPE_STRING, rabbitvcs.ui.widget.TYPE_STATUS
],
[_("Name"), _("Value"),
_("Reserved"), _("Status")],
filters=[{
"callback": rabbitvcs.ui.widget.long_text_filter,
"user_data": {
"cols": 0,
"column": 1
}
}, {
"callback": rabbitvcs.ui.widget.translate_filter,
"user_data": {
"column": 3
}
}],
callbacks={
"row-activated": self.on_table_row_activated,
"mouse-event": self.on_table_mouse_event,
"key-event": self.on_table_key_event
})
self.table.allow_multiple()
self.refresh()
def real_reply_handler(json_status):
# Note that this a closure referring to the outer functions callback
# parameter
status = self.decoder.decode(json_status)
path1 = S(path)
path2 = S(status.path)
assert path1 == path2, "Status check returned the wrong path "\
"(asked about %s, got back %s)" % \
(path1.display(), path2.display())
callback(status)
def diff_revisions(self, widget, data=None):
rev1 = self.revisions[0]
rev2 = self.revisions[-1]
if self.caller.compare_revision_order(rev1, rev2) > 0:
rev1, rev2 = rev2, rev1
helper.launch_ui_window("diff", [
"%s@%s" % (self.path, S(rev1)),
"%s@%s" % (self.path, S(rev2)),
"--vcs=%s" % self.caller.get_vcs_name()
])
def on_more_actions_view_unified_diff(self):
url1 = self.first_urls.get_active_text()
rev1 = self.get_first_revision()
rev2 = self.get_second_revision()
url2 = self.second_urls.get_active_text()
helper.launch_ui_window("diff", [
"%s@%s" % (url1, S(rev1)),
"%s@%s" % (url2, S(rev2)),
"--vcs=%s" % self.get_vcs_name()
])
def populate_table(self, item_index=0):
self.list_table.clear()
self.items = self.action.get_result(item_index)
self.items.sort(key=self.sort_files_key)
self.list_table.append([S(".."), "..", 0, 0, "", 0])
for item, locked in self.items[1:]:
self.list_table.append([
S(item.path), item.path, item.created_rev.number, item.size,
item.last_author, item.time
])
def show_revision(self, revision=None, forceload=False):
if revision is None:
revision = self.history[self.history_index]
revision = S(S(revision).strip())
self.revision.set_text(revision.display())
if revision.lower() != self.history[self.history_index].lower():
forceload = True
self.history_index += 1
self.history = self.history[:self.history_index] + [revision]
self.set_history_sensitive()
if forceload:
self.load(revision)
def compare_previous_revision(self, widget, data=None):
prev = self.caller.previous_revision(self.revisions[0])
path_older = self.path
if self.vcs_name == rabbitvcs.vcs.VCS_SVN:
path_older = self.vcs.svn().get_repo_url(self.path)
helper.launch_ui_window("diff", [
"-s",
"%s@%s" % (path_older, S(prev)),
"%s@%s" % (self.path, S(self.revisions[0])),
"--vcs=%s" % self.caller.get_vcs_name()
])
def file_column_callback(self, filename):
"""
Determine the node kind (dir or file) from our retrieved items list
"""
filename = S(filename).unicode()
if filename == six.u(".."):
return "dir"
for item, locked in self.items:
if S(item.path).unicode() == filename:
return self.svn.NODE_KINDS_REVERSE[item.kind]
return None
def compare_revisions(self, widget, data=None):
rev1 = self.revisions[0]
rev2 = self.revisions[-1]
if self.caller.compare_revision_order(rev1, rev2) > 0:
rev1, rev2 = rev2, rev1
path_older = self.path
if self.vcs_name == rabbitvcs.vcs.VCS_SVN:
path_older = self.vcs.svn().get_repo_url(self.path)
helper.launch_ui_window("diff", [
"-s",
"%s@%s" % (path_older, S(rev1)),
"%s@%s" % (self.path, S(rev2)),
"--vcs=%s" % self.caller.get_vcs_name()
])
def GenerateMenuConditions(self, paths):
upaths = []
for path in paths:
upaths.append(S(bytearray(path)))
path_dict = self.status_checker.generate_menu_conditions(upaths)
return json.dumps(path_dict)
def get_folder_menu_items(self, window, item):
"""
Menu activated on entering a directory. Builds context menu for File
menu and for window background.
@type window: NautilusNavigationWindow
@param window:
@type item: NautilusVFSFile
@param item:
@rtype: list of MenuItems
@return: The context menu entries to add to the menu.
"""
if not self.valid_uri(item.get_uri()): return
path = realpath(S(self.get_local_path(item)))
self.VFSFile_table[path] = item
# log.debug("get_background_items() called")
window.base_dir = path
return ThunarxMainContextMenu(self, path, [path]).get_menu()
def get_file_menu_items(self, window, items):
"""
Menu activated with items selected. Nautilus also calls this function
when rendering submenus, even though this is not needed since the entire
menu has already been returned.
Note that calling C{nautilusVFSFile.invalidate_extension_info()} will
also cause get_file_items to be called.
@type window: NautilusNavigationWindow
@param window:
@type items: list of NautilusVFSFile
@param items:
@rtype: list of MenuItems
@return: The context menu entries to add to the menu.
"""
paths = []
for item in items:
if self.valid_uri(item.get_uri()):
path = realpath(S(self.get_local_path(item)))
paths.append(path)
self.VFSFile_table[path] = item
if len(paths) == 0: return []
return ThunarxMainContextMenu(self, window.base_dir, paths).get_menu()
def __init__(self, message):
InterfaceView.__init__(self, "dialogs/message_box", "MessageBox")
self.get_widget("messagebox_message").set_text(S(message).display())
dialog = self.get_widget("MessageBox")
dialog.run()
dialog.destroy()
def generate_menu_conditions(self, provider, base_dir, paths, callback):
def real_reply_handler(obj):
# Note that this a closure referring to the outer functions callback
# parameter
path_dict = json.loads(obj)
callback(provider, base_dir, paths, path_dict)
def reply_handler(*args, **kwargs):
# The callback should be performed as a low priority task, so we
# keep Nautilus as responsive as possible.
GLib.idle_add(real_reply_handler, *args, **kwargs)
def error_handler(dbus_ex):
log.exception(dbus_ex)
self._connect_to_checker()
callback(provider, base_dir, paths, {})
bpaths = [bytearray(S(p).bytes()) for p in paths]
try:
self.status_checker.GenerateMenuConditions(
bpaths,
dbus_interface=INTERFACE,
timeout=TIMEOUT,
reply_handler=reply_handler,
error_handler=error_handler)
except dbus.DBusException as ex:
log.exception(ex)
callback(provider, base_dir, paths, {})
# Try to reconnect
self._connect_to_checker()
def __init__(self, title=None, label=None, current_text=None):
InterfaceView.__init__(self, "dialogs/one_line_text_change",
"OneLineTextChange")
if title:
self.get_widget("OneLineTextChange").set_title(title)
self.new_text = self.get_widget("new_text")
self.label = self.get_widget("label")
if label:
self.label.set_text(S(label).display())
if current_text:
self.new_text.set_text(S(current_text).display())
self.dialog = self.get_widget("OneLineTextChange")
def __init__(self, paths, base_dir=None, message=None):
"""
@type paths: list of strings
@param paths: A list of local paths.
"""
InterfaceView.__init__(self, "commit", "Commit")
self.base_dir = base_dir
self.vcs = rabbitvcs.vcs.VCS()
self.items = []
self.files_table = rabbitvcs.ui.widget.Table(
self.get_widget("files_table"), [
GObject.TYPE_BOOLEAN, rabbitvcs.ui.widget.TYPE_HIDDEN_OBJECT,
rabbitvcs.ui.widget.TYPE_PATH, GObject.TYPE_STRING,
rabbitvcs.ui.widget.TYPE_STATUS, GObject.TYPE_STRING
], [
rabbitvcs.ui.widget.TOGGLE_BUTTON, "",
_("Path"),
_("Extension"),
_("Text Status"),
_("Property Status")
],
filters=[{
"callback": rabbitvcs.ui.widget.path_filter,
"user_data": {
"base_dir": base_dir,
"column": 2
}
}],
callbacks={
"row-activated": self.on_files_table_row_activated,
"mouse-event": self.on_files_table_mouse_event,
"key-event": self.on_files_table_key_event,
"row-toggled": self.on_files_table_toggle_event
},
flags={
"sortable": True,
"sort_on": 2
})
self.files_table.allow_multiple()
self.get_widget("toggle_show_unversioned").set_active(
self.SHOW_UNVERSIONED)
if not message:
message = self.SETTINGS.get_multiline("general",
"default_commit_message")
self.message = rabbitvcs.ui.widget.TextView(self.get_widget("message"),
message)
self.paths = []
for path in paths:
if self.vcs.is_in_a_or_a_working_copy(path):
self.paths.append(S(path))
self.commit_and_push = False
self.repository_selector = None
self.is_git = False
self.datetime_format = "%y.%m.%d (%a) %p %I:%M"
def __init__(self):
InterfaceView.__init__(self, "dialogs/previous_messages",
"PreviousMessages")
self.message = rabbitvcs.ui.widget.TextView(
self.get_widget("prevmes_message"))
self.message_table = rabbitvcs.ui.widget.Table(
self.get_widget("prevmes_table"),
[GObject.TYPE_STRING, GObject.TYPE_STRING],
[_("Date"), _("Message")],
filters=[{
"callback": rabbitvcs.ui.widget.long_text_filter,
"user_data": {
"column": 1,
"cols": 80
}
}],
callbacks={
"cursor-changed": self.on_prevmes_table_cursor_changed,
"row-activated": self.on_prevmes_table_row_activated
})
self.entries = rabbitvcs.util.helper.get_previous_messages()
if self.entries is None:
return None
for entry in self.entries:
self.message_table.append([entry[0], entry[1]])
if len(self.entries) > 0:
self.message.set_text(S(self.entries[0][1]).display())
def __run(self, command):
sys.stdout, self.stdout = self.stdout, sys.stdout
sys.stderr, self.stderr = self.stderr, sys.stderr
# eval and exec are broken in how they deal with utf8-encoded
# strings so we have to explicitly decode the command before
# passing it along
command = S(command).unicode()
try:
try:
r = eval(command, globals(), self.namespace)
if not r is None:
print(repr(r))
except SystemExit:
self.exit()
except SyntaxError:
exec(command, globals(), self.namespace)
except SystemExit:
self.exit()
except:
if hasattr(sys, "last_type") and sys.last_type == SystemExit:
self.exit()
else:
traceback.print_exc()
sys.stdout, self.stdout = self.stdout, sys.stdout
sys.stderr, self.stderr = self.stderr, sys.stderr
def __init__(self, path=None, url=None, revision=None):
InterfaceView.__init__(self, "checkout", "Checkout")
self.path = path
self.vcs = rabbitvcs.vcs.VCS()
self.repositories = rabbitvcs.ui.widget.ComboBox(
self.get_widget("repositories"),
helper.get_repository_paths()
)
# We must set a signal handler for the Gtk.Entry inside the combobox
# Because glade will not retain that information
self.repositories.set_child_signal(
"key-release-event",
self.on_repositories_key_released
)
self.destination = helper.get_user_path()
if path is not None:
self.destination = path
self.get_widget("destination").set_text(S(path).display())
if url is not None:
self.repositories.set_child_text(url)
self.complete = False
def sort_files_key(self, x):
"""
Return a key to sort the browser listing so that folders are
on top and then sort alphabetically.
"""
kind = self.svn.NODE_KINDS_REVERSE[x[0].kind] != "dir"
return (kind, locale.strxfrm(S(x[0].repos_path)))
def check_status_now(self,
path,
recurse=False,
invalidate=False,
summary=False):
status = None
try:
json_status = self.status_checker.CheckStatus(
bytearray(S(path).bytes()),
recurse,
invalidate,
summary,
dbus_interface=INTERFACE,
timeout=TIMEOUT)
status = self.decoder.decode(json_status)
# Test client error problems :)
# raise dbus.DBusException("Test")
except dbus.DBusException as ex:
log.exception(ex)
status = rabbitvcs.vcs.status.Status.status_error(path)
# Try to reconnect
self._connect_to_checker()
return status
def __init__(self, path, revision):
"""
@type path: string
@param path: The path to open
@type revision: string
@param revision: The revision of the file to open
"""
InterfaceNonView.__init__(self)
self.vcs = rabbitvcs.vcs.VCS()
self.git = self.vcs.git(path)
if revision:
revision_obj = self.git.revision(revision)
else:
revision_obj = self.git.revision("HEAD")
dest_dir = helper.get_tmp_path("rabbitvcs-" + S(revision))
self.git.export(path, dest_dir, revision=revision_obj)
repo_path = self.git.find_repository_path(path)
relative_path = path
if path.startswith(repo_path):
relative_path = path[len(repo_path) + 1:]
dest_path = "%s/%s" % (dest_dir, relative_path)
helper.open_item(dest_path)
raise SystemExit()
def on_external_diff_tool_browse_clicked(self, widget):
chooser = rabbitvcs.ui.dialog.FileChooser(_("Select a program"),
"/usr/bin")
path = chooser.run()
if not path is None:
path = path.replace("file://", "")
self.get_widget("diff_tool").set_text(S(path).display())
def populate_files_table(self):
self.files_table.clear()
for item in self.items:
self.files_table.append([
True,
S(item.path), item.path,
helper.get_file_extension(item.path)
])
def __setstate__(self, state_dict):
del state_dict['__type__']
del state_dict['__module__']
# Store strings in native str type.
for key in state_dict:
if isinstance(state_dict[key], (six.string_types, six.text_type)):
state_dict[key] = str(S(state_dict[key]))
self.__dict__ = state_dict
def on_mergetree_prepare(self):
if not hasattr(self, "mergetree_from_repos"):
self.mergetree_from_repos = rabbitvcs.ui.widget.ComboBox(
self.get_widget("mergetree_from_urls"), self.repo_paths)
self.mergetree_to_repos = rabbitvcs.ui.widget.ComboBox(
self.get_widget("mergetree_to_urls"), self.repo_paths)
self.get_widget("mergetree_working_copy").set_text(
S(self.path).display())
def on_mergerange_prepare(self):
if not hasattr(self, "mergerange_repos"):
self.mergerange_repos = rabbitvcs.ui.widget.ComboBox(
self.get_widget("mergerange_from_urls"), self.repo_paths)
self.mergerange_repos.set_child_text(self.root_url)
self.get_widget("mergerange_working_copy").set_text(
S(self.path).display())
self.mergerange_check_ready()