rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
self.tree.register_cllbck('node-children-reordered',self.__reorder) | self.tree.register_cllbck('node-children-reordered',self.reorder) | def connect_model(self): if TM_USE_SIGNALS: self.tree.connect('node-added-inview',self.__add_task) self.tree.connect('node-deleted-inview',self.__remove_task) self.tree.connect('node-modified-inview',self.__update_task) self.tree.connect('node-children-reordered',self.__reorder) else: self.tree.register_cllbck('node-ad... |
def __reorder(self,nid,path,neworder): | def __reorder(self, sender, nid,path,neworder): | def __reorder(self,nid,path,neworder): actual_nid = self.tree.get_node_for_path(path) if nid == actual_nid: if path: rowref = self.get_iter(path) else: rowref = None self.rows_reordered(path,rowref,neworder) else: raise Exception('path/node mismatch in reorder') |
text5 += _("You can find the Plugin Manager by selecting Plugins > Plugin Preferences on the menu.") | text5 += _("You can find the Plugin Manager by selecting Edit in the Menu Bar, then clicking Preferences. You will then see a tab labeled Plugins.") | def populate(): doc,root = cleanxml.emptydoc("project") #Task 0@1: Getting started with GTG title1 = _("Getting started with GTG") text1 = _("Welcome to Getting Things Gnome!, your new task manager.") text1 += "\n\n" text1 += _("In GTG, everything is a task. From building a bridge over the Pacific Ocean to changing a l... |
def update_buttons_sensitivity(self): | def update_buttons_sensitivity(self,a=None,b=None,c=None): | def update_buttons_sensitivity(self): enable = self.selection.count_selected_rows() + \ self.closed_selection.count_selected_rows() > 0 self.edit_mi.set_sensitive(enable) self.new_subtask_mi.set_sensitive(enable) self.mark_done_mi.set_sensitive(enable) self.dismiss_mi.set_sensitive(enable) self.delete_mi.set_sensitive(... |
import sys if options.no_crash_handler == False: pass | def main(options=None, args=None): ''' Calling this starts the full GTG experience ( :-D ) ''' config, ds, req = core_main_init(options, args) # Launch task browser manager = Manager(req, config) #main loop #To be more user friendly and get the logs of crashes, we show an apport # hooked window upon crashes #with sign... | |
def on_close(self, widget): | def on_close(self, widget, data = None): | def on_close(self, widget): """Close the preferences dialog.""" self.dialog.hide() return True |
task = self.plugin_api.get_requester().new_task(pid=None, tags=None, newtask=False) task.title = title task.content = "<content>%s</content>" % (reference) | task = self.plugin_api.get_requester().new_task(pid=None, tags=None, newtask=True) task.set_title(title) task.set_text(reference) task.sync() | def import_tasks(self, widget): username = self.usernames[self.select_username.get_active()] re_dehtml = re.compile(r'<.*?>') |
node.set_parent(parent) | node.set_parent(parent.get_id()) | def add_node(self, node, parent=None): #print "*************adding node %s %s" %(node, parent) id = node.get_id() if self.nodes.get(id): print "Error : A node with this id %s already exists" %id return False else: #We add the node node.set_tree(self) if parent:# node.set_parent(parent) parent.add_child(id) else: self.r... |
plugin_api.remove_task_toolbar_item(self.tb_button) plugin_api.remove_task_toolbar_item(self.separator) | plugin_api.remove_toolbar_item(self.tb_button) plugin_api.remove_toolbar_item(self.separator) | def deactivate(self, plugin_api): plugin_api.remove_menu_item(self.menu_item) plugin_api.remove_task_toolbar_item(self.tb_button) plugin_api.remove_task_toolbar_item(self.separator) self.txtImport = None |
realend.forward_to_line_end() restofline = end_line.get_slice(realend) restofline.strip() | restofline = None if not realend.ends_line(): realend.forward_to_line_end() restofline = end_line.get_slice(realend) restofline.strip() | def _insert_at_cursor(self, tv, itera, tex, leng) : #We don't paste the bullet if tex.strip() != self.bullet1 : #print "text ###%s### inserted length = %s" %(tex,leng) #disable the insert signal to avoid recursion self.buff.disconnect(self.insert_sigid) self.insert_sigid = False self.buff.disconnect(self.modified_sigid... |
def configure_dialog(self, plugin_api): | def configure_dialog(self, plugin_api, manager_dialog): | def configure_dialog(self, plugin_api): self.on_geolocalized_preferences(plugin_api) |
'GTG.viewmanager': ['preferences.glade'], | 'GTG.viewmanager': ['preferences.glade', 'deletion.glade'], | def find_mo_files(self): data_files = [] for mo in glob.glob(os.path.join(MO_DIR, '*', 'gtg.mo')): lang = os.path.basename(os.path.dirname(mo)) dest = os.path.join('share', 'locale', lang, 'LC_MESSAGES') data_files.append((dest, [mo])) return data_files |
calls = [(self.tree.add_node, "ADDING"), (self.tree.refresh_node, "UPDATING"), (self.tree.del_node, "REMOVING")] for call, name in calls: start = time.time() for index in xrange(2000): node = DummyNode("stress" + str(index)) call(node) end = time.time() test.test_validity() if call != self.tree.del_node: self.asse... | nodes_id = [] start = time.time() for index in xrange(BIG_NUMBER): node = DummyNode("stress" + str(index)) nodes_id.append(node.get_id()) self.tree.add_node(node) end = time.time() test.test_validity() print "\nADDING %d NODES: %f" % (BIG_NUMBER, end - start) start = time.time() for node_id in nodes_id: self.tree.refr... | def test_speed(self): ''' Performance tests. Patches that reduce performance too much are not acceptable ''' view = self.tree.get_viewtree(refresh = False) test = TreeTester(view) calls = [(self.tree.add_node, "ADDING"), (self.tree.refresh_node, "UPDATING"), (self.tree.del_node, "REMOVING")] for call, name in calls: st... |
print "receiving add_task %s to state %s (current:%s)" %(tid,state_id,self.state_id) if TM_IDLE_ADD: gobject.idle_add(self.__update_task,None,tid,path,state_id,'add',priority=gobject.PRIORITY_HIGH) else: self.__update_task(None,tid,path,state_id,'add') def __add_task(self,sender,tid,path): self.__update_task(sender,t... | print "receiving add_task %s to state %s (current:%s)" \ %(tid,state_id,self.state_id) gobject.idle_add(self.__update_task,None,tid,path,state_id,'add',\ priority=gobject.PRIORITY_HIGH) | def add_task(self,tid,path,state_id): if DEBUG_MODEL: print "receiving add_task %s to state %s (current:%s)" %(tid,state_id,self.state_id) if TM_IDLE_ADD: gobject.idle_add(self.__update_task,None,tid,path,state_id,'add',priority=gobject.PRIORITY_HIGH) else: self.__update_task(None,tid,path,state_id,'add') |
if TM_IDLE_ADD: gobject.idle_add(self.__update_task,None,tid,path,state_id,data,priority=gobject.PRIORITY_HIGH) else: self.__update_task(None,tid,path,state_id,data) | gobject.idle_add(self.__update_task,None,tid,path,state_id,\ data,priority=gobject.PRIORITY_HIGH) | def update_task(self, tid,path,state_id,data=None): if TM_IDLE_ADD: gobject.idle_add(self.__update_task,None,tid,path,state_id,data,priority=gobject.PRIORITY_HIGH) else: self.__update_task(None,tid,path,state_id,data) |
if TM_IDLE_ADD: gobject.idle_add(self.__remove_task,None,tid,path,state_id,priority=gobject.PRIORITY_HIGH) else: self.__remove_task(None,tid,path,state_id) | gobject.idle_add(self.__remove_task,None,tid,path,state_id,\ priority=gobject.PRIORITY_HIGH) | def remove_task(self,tid,path,state_id): if TM_IDLE_ADD: gobject.idle_add(self.__remove_task,None,tid,path,state_id,priority=gobject.PRIORITY_HIGH) else: self.__remove_task(None,tid,path,state_id) |
if state_id > self.state_id: self.state_id = state_id if TM_IDLE_ADD: gobject.idle_add(self.__reorder,None,nid,path,neworder,state_id) else: self.__reorder(None,nid,path,neworder,state_id) | gobject.idle_add(self.__reorder,None,nid,path,neworder,state_id,\ priority=gobject.PRIORITY_HIGH) | def reorder(self,nid,path,neworder,state_id): if state_id > self.state_id: self.state_id = state_id if TM_IDLE_ADD: gobject.idle_add(self.__reorder,None,nid,path,neworder,state_id) else: self.__reorder(None,nid,path,neworder,state_id) |
self.state_id = state_id | def __reorder(self, sender, nid,path,neworder,state_id): actual_nid = self.tree.get_node_for_path(path,state_id=state_id) if nid == actual_nid: if path: rowref = self.get_iter(path) else: rowref = None self.state_id = state_id self.rows_reordered(path,rowref,neworder) else: raise Exception('path/node mismatch in reorde... | |
self.colToggle = gtk.TreeViewColumn("Enabled", self.rendererToggle) | self.colToggle = gtk.TreeViewColumn(_("Enabled"), self.rendererToggle) | def __init__(self, parent, plugins, pengine, plugin_apis): self.plugins = plugins self.pengine = pengine self.plugin_apis = plugin_apis self.builder = gtk.Builder() self.builder.add_from_file(GnomeConfig.GLADE_FILE) self.dialog = self.builder.get_object("PluginManagerDialog") # stuff to populate self.close_btn = self... |
self.colName = gtk.TreeViewColumn("Name", self.rendererName, text=1, foreground_set=4) | self.colName = gtk.TreeViewColumn(_("Name"), self.rendererName, text=1, foreground_set=4) | def __init__(self, parent, plugins, pengine, plugin_apis): self.plugins = plugins self.pengine = pengine self.plugin_apis = plugin_apis self.builder = gtk.Builder() self.builder.add_from_file(GnomeConfig.GLADE_FILE) self.dialog = self.builder.get_object("PluginManagerDialog") # stuff to populate self.close_btn = self... |
self.colVersion = gtk.TreeViewColumn("Version", self.rendererVersion, text=2, foreground_set=4) | self.colVersion = gtk.TreeViewColumn(_("Version"), self.rendererVersion, text=2, foreground_set=4) | def __init__(self, parent, plugins, pengine, plugin_apis): self.plugins = plugins self.pengine = pengine self.plugin_apis = plugin_apis self.builder = gtk.Builder() self.builder.add_from_file(GnomeConfig.GLADE_FILE) self.dialog = self.builder.get_object("PluginManagerDialog") # stuff to populate self.close_btn = self... |
date = "%i-%i-%i" % (t.year, t.month, t.day) | date = t.isoformat() | def get_canonical_date(self, arg): """ Transform "arg" in a valid yyyy-mm-dd date or return None. "arg" can be a yyyy-mm-dd, yyyymmdd, mmdd, today, next week, next month, next year, or a weekday name. """ day_names_en = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"] day_names = [_("monda... |
if date == no_date: | if date == str(no_date): | def get_canonical_date(self, arg): """ Transform "arg" in a valid yyyy-mm-dd date or return None. "arg" can be a yyyy-mm-dd, yyyymmdd, mmdd, today, next week, next month, next year, or a weekday name. """ day_names_en = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"] day_names = [_("monda... |
destination_tid = model.get_value(destination_iter, COL_TID) | if destination_iter: destination_tid = model.get_value(destination_iter, COL_TID) else: destination_tid = None | def on_drag_data_received(self, treeview, context, x, y, selection, info,\ timestamp): model = treeview.get_model() tasktree_model = model.get_model() drop_info = treeview.get_dest_row_at_pos(x, y) if drop_info: path, position = drop_info iter = model.get_iter(path) # Must add the task to the parent of the tas... |
str(task.get_closed_date()), | def task_to_TaskStr(self, task): return self.TaskStr(task.get_title(), str(task.get_text()), [], task.get_status(), str(task.get_modified()), str(task.get_due_date()), str(task.get_start_date()), str(task.get_days_left()), str(task.get_closed_date()), map(lambda t: t.get_name(), task.get_tags())) | |
plugin_api.remove_toolbar_item(self.tb_button) plugin_api.remove_toolbar_item(self.separator) | plugin_api.remove_task_toolbar_item(self.tb_button) plugin_api.remove_task_toolbar_item(self.separator) | def deactivate(self, plugin_api): plugin_api.remove_menu_item(self.menu_item) plugin_api.remove_toolbar_item(self.tb_button) plugin_api.remove_toolbar_item(self.separator) self.txtImport = None |
manager.main() | with signal_catcher(): manager.main() | def main(options=None, args=None): # Debugging subsystem initialization if options.debug: Log.setLevel(logging.DEBUG) Log.debug("Debug output enabled.") config = CoreConfig() check_instance(config.DATA_DIR) backends_list = config.get_backends_list() # Load data store ds = DataStore() for backend_dic in backends_list... |
bug = launchpad.bugs[bugno] for task in bug.bug_tasks: if task.bug_target_name == 'gtg' and task.status == 'Fix Committed': task.status = 'Fix Released' task.lp_save() print 'Bug %s marked as Fix Released' % bugno | try: bug = launchpad.bugs[bugno] for task in bug.bug_tasks: if task.bug_target_name == 'gtg' and task.status == 'Fix Committed': print task.status task.status = 'Fix Released' task.lp_save() print 'Bug %s marked as Fix Released' % bugno except: print 'UNABLE TO PROCESS BUG pass | def lp_login(): cachedir = os.path.expanduser('~/.cache/launchpadlib/') if not os.path.isdir(cachedir): os.makedirs(cachedir) creddir = os.path.expanduser("~/.cache/lp_credentials") if not os.path.isdir(creddir): os.makedirs(creddir) os.chmod(creddir, 0700) try: credfile = open(os.path.join(creddir, 'close_launchpad_bu... |
desc = store.get_value(iter, PLUGINS_COL_DESC) | desc = store.get_value(iter, PLUGINS_COL_SHORT_DESC) | def plugin_markup(column, cell, store, iter): """Callback to set the content of a PluginTree cell. See PreferencesDialog._init_plugin_tree(). """ name = store.get_value(iter, PLUGINS_COL_NAME) desc = store.get_value(iter, PLUGINS_COL_DESC) cell.set_property('markup', "<b>%s</b>\n%s" % (name, desc)) cell.set_property(... |
task.content = reference | task.content = "<content>%s</content>" % (reference) | def import_tasks(self, widget): username = self.usernames[self.select_username.get_active()] re_dehtml = re.compile(r'<.*?>') |
menu_item = gtk.ImageMenuItem(task.get_title()) | title = task.get_title()[0:self.MAX_TITLE_LEN] if len(title)== self.MAX_TITLE_LEN: title = title + "..." menu_item = gtk.ImageMenuItem(title) | def add_menu_task(self, tid, task = None): """Adds a task in the menu""" if task == None: task = self.plugin_api.get_task(tid) menu_item = gtk.ImageMenuItem(task.get_title()) menu_item.connect('activate', self.open_task, tid) self.menu.append(menu_item) self.tasks_in_menu[tid] = menu_item |
plugin_api.unregister_filter_cb(self.doable_tasks_filter) | def deactivate(self, plugin_api): self.statusicon.set_visible(False) self.plugin_api.get_browser().start_minimized = False plugin_api.unregister_filter_cb(self.doable_tasks_filter) | |
for i in task.get_self_and_all_subtasks(): if i not in tasks: tasks.append(i) | recursive_list_tasks(tasks, task) | def on_delete_task(self, widget=None, tid=None): #If we don't have a parameter, then take the selection in the treeview if not tid: #tid_to_delete is a [project,task] tuple self.tids_todelete = self.get_selected_tasks() else: self.tids_todelete = [tid] #We must at least have something to delete ! if len(self.tids_todel... |
label.set_text("%s %s" % (label_text, titles)) | label.set_text("%s %s" % (label_text, "\n - " + titles)) | def on_delete_task(self, widget=None, tid=None): #If we don't have a parameter, then take the selection in the treeview if not tid: #tid_to_delete is a [project,task] tuple self.tids_todelete = self.get_selected_tasks() else: self.tids_todelete = [tid] #We must at least have something to delete ! if len(self.tids_todel... |
self._add_accelerator_for_widget(agr, "edit_undo", "<Control>y") | self._add_accelerator_for_widget(agr, "edit_undo", "<Control>z") self._add_accelerator_for_widget(agr, "edit_redo", "<Control>y") | def _init_accelerators(self): agr = gtk.AccelGroup() self.builder.get_object("MainWindow").add_accel_group(agr) |
self._add_accelerator_for_widget(agr, "edit_b", "<Control>e") | def _init_accelerators(self): agr = gtk.AccelGroup() self.builder.get_object("MainWindow").add_accel_group(agr) | |
quickadd_field = self.builder.get_object('quickadd_field') key, mod = gtk.accelerator_parse('<Control>l') quickadd_field.add_accelerator( 'grab-focus', agr, key, mod, gtk.ACCEL_VISIBLE) | edit_button = self.builder.get_object("edit_b") key, mod = gtk.accelerator_parse("<Control>e") edit_button.add_accelerator("clicked", agr, key, mod, gtk.ACCEL_VISIBLE) quickadd_field = self.builder.get_object("quickadd_field") key, mod = gtk.accelerator_parse("<Control>l") quickadd_field.add_accelerator("grab-focus... | def _init_accelerators(self): agr = gtk.AccelGroup() self.builder.get_object("MainWindow").add_accel_group(agr) |
for k in self.__cllbcks.get(signal_name,[]): | for k in self.__cllbcks.get(signal_name, {}).copy(): | def __emit(self, signal_name, tid,path=None,state_id=None,neworder=None,): for k in self.__cllbcks.get(signal_name,[]): f = self.__cllbcks[signal_name][k] if neworder: f(tid,path,neworder,state_id) elif state_id: f(tid,path,state_id) else: f(tid,path) if signal_name.endswith('-inview'): self.emit(signal_name, tid,path)... |
task = self.req.get_task(tid) if task: task.delete() else: print "trying to delete task already deleted" | task = self.req.delete_task(tid) | def on_delete_confirm(self, widget): """if we pass a tid as a parameter, we delete directly otherwise, we will look which tid is selected""" for tid in self.tids_todelete: task = self.req.get_task(tid) if task: task.delete() else: print "trying to delete task already deleted" self.tids_todelete = [] |
ntag.set_parent(otag.get_parent()) | if otag.has_parent(): opar = otag.get_parent() ntag.reparent(opar) | def rename_tag(self, oldname, newname): if len(newname) > 0 and \ oldname not in ['gtg-tags-none','gtg-tags-all']: if newname[0] != "@": newname = "@" + newname if newname != oldname and newname != None \ and not self.tree.has_node(newname): ntag = self.new_tag(newname) otag = self.tree.get_node(oldname) #copy attribu... |
tree.print_tree() | def test_parent(self): tree = self._build_tree(4,flat=False) tree.print_tree() mynode = tree.get_node('3@3') self.assertEqual(True,mynode.has_parent()) p = mynode.get_parents()[0] par = tree.get_node(p) self.assertEqual('2@2',par.get_id()) | |
self.color_active = False | def __init__(self, requester, config, logger=None): | |
self.set_target_cursor() | def on_colorchooser_activate(self, widget): #TODO: Color chooser should be refactorized in its own class. Well, in #fact we should have a TagPropertiesEditor (like for project) Also, #color change should be immediate. There's no reason for a Ok/Cancel dialog = gtk.ColorSelectionDialog('Choose color') colorsel = dialog.... | |
self.tag_active = False | def reset_cursor(self): """ Returns the cursor to the tag that was selected prior to any right click action. Should be used whenever we're done working with any tag through a right click menu action. """ if self.tag_active: path, col = self.previous_cursor self.tags_tv.set_cursor(path, col, 0) self.tag_active = False | |
self.tag_active = True | def set_target_cursor(self): """ Selects the last tag to be right clicked. We need this because the context menu will deactivate (and in turn, call reset_cursor()) before, for example, the color picker dialog begins. Should be used at the beginning of any tag editing function to remind the user which tag they're worki... | |
pnode=self.new_tag(parent) | if self.__tagstore.has_node(parent): pnode = self.__tagstore.get_node(parent) else: pnode=self.new_tag(parent) | def load_tag_tree(self): # Loading tags tagfile = os.path.join(CoreConfig().get_data_dir(), TAG_XMLFILE) doc, xmlstore = cleanxml.openxmlfile(tagfile,TAG_XMLROOT) for t in xmlstore.childNodes: #We should only care about tag with a name beginning with "@" #Other are special tags tagname = t.getAttribute("name") tag = se... |
self.is_workable(task) | self.is_workable(task) and\ self.no_disabled_tag(task) | def workview(self,task,parameters=None): wv = self.active(task) and\ self.is_started(task) and\ self.is_workable(task) return wv |
print "ghost position for %s" %tid print "VR : %s " %self.virtual_root | Log.debug("ghost position for %s" %tid) Log.debug("VR : %s " %self.virtual_root) | def get_paths_for_node(self, node): """ Return a list of paths for a given node Return an empty list if no path for that Node. """ toreturn = [] if node: tid = node.get_id() pars = self.node_parents(node) #For that node, we should convert the base_path to path if not node or not self.is_displayed(node.get_id()): return... |
if not self.rtm_proxy.is_authenticated(): threading.Thread(target = self.rtm_proxy.get_rtm_tasks_dict).start() if self.enqueued_start_get_task: return else: self.enqueued_start_get_task = True self.rtm_proxy.wait_for_authentication() self.enqueued_start_get_task = False if not hasattr(self, 'token_saved'): self._sto... | def do_periodic_import(self): """ See PeriodicImportBackend for an explanation of this function. """ #we verify authentication if not self.rtm_proxy.is_authenticated(): #we try to reach RTM to trigger the authentication process threading.Thread(target = self.rtm_proxy.get_rtm_tasks_dict).start() if self.enqueued_start_... | |
rtm_task = self.rtm_proxy.create_new_rtm_task(task.get_title()) self._populate_rtm_task(task, rtm_task) | if task.get_status() != Task.STA_ACTIVE: return try: rtm_task = self.rtm_proxy.create_new_rtm_task(task.get_title()) self._populate_rtm_task(task, rtm_task) except: rtm_task.delete() raise | def set_task(self, task): """ See GenericBackend for an explanation of this function. """ if not self.rtm_proxy.is_authenticated(): return self.cancellation_point() tid = task.get_id() is_syncable = self._gtg_task_is_syncable_per_attached_tags(task) action, rtm_task_id = self.sync_engine.analyze_local_id( \ tid, \ self... |
self._populate_rtm_task(task, rtm_task) | transaction_ids = [] try: self._populate_rtm_task(task, rtm_task, transaction_ids) except: self.rtm_proxy.unroll_changes(transaction_ids) raise | def set_task(self, task): """ See GenericBackend for an explanation of this function. """ if not self.rtm_proxy.is_authenticated(): return self.cancellation_point() tid = task.get_id() is_syncable = self._gtg_task_is_syncable_per_attached_tags(task) action, rtm_task_id = self.sync_engine.analyze_local_id( \ tid, \ self... |
def _populate_rtm_task(self, task, rtm_task): | def _populate_rtm_task(self, task, rtm_task, transaction_ids = []): | def _populate_rtm_task(self, task, rtm_task): ''' Copies the content of a Task into a RTMTask ''' #Get methods of an rtm_task are fast, set are slow: therefore, # we try to use set as rarely as possible |
rtm_task.set_status(status) | self.__call_or_retry(rtm_task.set_status, status, transaction_ids) | def _populate_rtm_task(self, task, rtm_task): ''' Copies the content of a Task into a RTMTask ''' #Get methods of an rtm_task are fast, set are slow: therefore, # we try to use set as rarely as possible |
rtm_task.set_title(title) | self.__call_or_retry(rtm_task.set_title, title, transaction_ids) | def _populate_rtm_task(self, task, rtm_task): ''' Copies the content of a Task into a RTMTask ''' #Get methods of an rtm_task are fast, set are slow: therefore, # we try to use set as rarely as possible |
rtm_task.set_text(text) | self.__call_or_retry(rtm_task.set_text, text, transaction_ids) | def _populate_rtm_task(self, task, rtm_task): ''' Copies the content of a Task into a RTMTask ''' #Get methods of an rtm_task are fast, set are slow: therefore, # we try to use set as rarely as possible |
rtm_task.set_tags(tags) | self.__call_or_retry(rtm_task.set_tags, tags, transaction_ids) | def _populate_rtm_task(self, task, rtm_task): ''' Copies the content of a Task into a RTMTask ''' #Get methods of an rtm_task are fast, set are slow: therefore, # we try to use set as rarely as possible |
rtm_task.set_due_date(due_date) | self.__call_or_retry(rtm_task.set_due_date, due_date, transaction_ids) def __call_or_retry(self, fun, *args): ''' This function cannot stand the call "fun" to fail, so it retries three times before giving up. ''' MAX_ATTEMPTS = 3 for i in xrange(MAX_ATTEMPTS): try: return fun(*args) except: if i >= MAX_ATTEMPTS: raise | def _populate_rtm_task(self, task, rtm_task): ''' Copies the content of a Task into a RTMTask ''' #Get methods of an rtm_task are fast, set are slow: therefore, # we try to use set as rarely as possible |
print "UNLOCK" | def refresh_rtm_tasks_dict(self): ''' Builds a list of RTMTasks fetched from RTM ''' if not self.is_authenticated(): self.start_authentication() self.wait_for_authentication() | |
def create_new_rtm_task(self, title): | def create_new_rtm_task(self, title, transaction_ids = []): | def create_new_rtm_task(self, title): ''' Creates a new rtm task ''' result = self.rtm.tasks.add(timeline = self.timeline, name = title) rtm_task = RTMTask(result.list.taskseries.task, result.list.taskseries, result.list, self.rtm, self.timeline) #adding to the dict right away if hasattr(self, '_rtm_task_dict'): #if t... |
def set_title(self, title): | def set_title(self, title, transaction_ids = []): | def set_title(self, title): '''Sets the task title''' self.rtm.tasks.setName(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id, name = title) |
self.rtm.tasks.setName(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id, name = title) | title = cgi.escape(title) result = self.rtm.tasks.setName(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id, name = title) transaction_ids.append(result.transaction.id) | def set_title(self, title): '''Sets the task title''' self.rtm.tasks.setName(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id, name = title) |
def set_status(self, gtg_status): | def set_status(self, gtg_status, transaction_ids = []): | def set_status(self, gtg_status): '''Sets the task status, in GTG terminology''' status = GTG_TO_RTM_STATUS[gtg_status] if status == True: api_call = self.rtm.tasks.uncomplete else: api_call = self.rtm.tasks.complete api_call(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_task... |
api_call(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id) | result = api_call(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id) transaction_ids.append(result.transaction.id) | def set_status(self, gtg_status): '''Sets the task status, in GTG terminology''' status = GTG_TO_RTM_STATUS[gtg_status] if status == True: api_call = self.rtm.tasks.uncomplete else: api_call = self.rtm.tasks.complete api_call(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_task... |
def set_tags(self, tags): | def set_tags(self, tags, transaction_ids = []): | def set_tags(self, tags): ''' Sets a new set of tags to a task. Old tags are deleted. ''' #RTM accept tags without "@" as prefix, and lowercase tags = [tag[1:].lower() for tag in tags] #formatting them in a comma-separated string if len(tags) > 0: tagstxt = reduce(lambda x,y: x + ", " + y, tags) else: tagstxt = "" sel... |
self.rtm.tasks.setTags(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id, tags = tagstxt) | result = self.rtm.tasks.setTags(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id, tags = tagstxt) transaction_ids.append(result.transaction.id) | def set_tags(self, tags): ''' Sets a new set of tags to a task. Old tags are deleted. ''' #RTM accept tags without "@" as prefix, and lowercase tags = [tag[1:].lower() for tag in tags] #formatting them in a comma-separated string if len(tags) > 0: tagstxt = reduce(lambda x,y: x + ", " + y, tags) else: tagstxt = "" sel... |
def set_text(self, text): | def set_text(self, text, transaction_ids = []): | def set_text(self, text): ''' deletes all the old notes in a task and sets a single note with the given text ''' #delete old notes notes = self.rtm_taskseries.notes if notes: note_list = self.__getattr_the_rtm_way(notes, 'note') for note_id in [note.id for note in note_list]: self.rtm.tasksNotes.delete(timeline = self.... |
self.rtm.tasksNotes.delete(timeline = self.timeline, note_id = note_id) | result = self.rtm.tasksNotes.delete(timeline = self.timeline, note_id = note_id) transaction_ids.append(result.transaction.id) | def set_text(self, text): ''' deletes all the old notes in a task and sets a single note with the given text ''' #delete old notes notes = self.rtm_taskseries.notes if notes: note_list = self.__getattr_the_rtm_way(notes, 'note') for note_id in [note.id for note in note_list]: self.rtm.tasksNotes.delete(timeline = self.... |
self.rtm.tasksNotes.add(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id, note_title = "", note_text = text) | text = cgi.escape(text) text_cursor_end = len(text) while True: text_cursor_start = text_cursor_end - 1000 if text_cursor_start < 0: text_cursor_start = 0 result = self.rtm.tasksNotes.add(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.... | def set_text(self, text): ''' deletes all the old notes in a task and sets a single note with the given text ''' #delete old notes notes = self.rtm_taskseries.notes if notes: note_list = self.__getattr_the_rtm_way(notes, 'note') for note_id in [note.id for note in note_list]: self.rtm.tasksNotes.delete(timeline = self.... |
def set_due_date(self, due): | def set_due_date(self, due, transaction_ids = []): | def set_due_date(self, due): ''' Sets the task due date ''' if due != None: due_string = self.__time_date_to_rtm(due) self.rtm.tasks.setDueDate(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id, parse = 1, \ due=due_string) else: se... |
due_string = self.__time_date_to_rtm(due) self.rtm.tasks.setDueDate(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id, parse = 1, \ due=due_string) else: self.rtm.tasks.setDueDate(timeline = self.timeline, list_id = self.... | kwargs['parse'] = 1 kwargs['due'] = self.__time_date_to_rtm(due) result = self.rtm.tasks.setDueDate(**kwargs) transaction_ids.append(result.transaction.id) | def set_due_date(self, due): ''' Sets the task due date ''' if due != None: due_string = self.__time_date_to_rtm(due) self.rtm.tasks.setDueDate(timeline = self.timeline, list_id = self.rtm_list.id, taskseries_id = self.rtm_taskseries.id, task_id = self.rtm_task.id, parse = 1, \ due=due_string) else: se... |
task.set_title(text) | task.set_title(text.strip()) | def on_quickadd_activate(self, widget): text = self.quickadd_entry.get_text() due_date = no_date defer_date = no_date if text: tags, notagonly = self.get_selected_tags() # Get tags in the title #NOTE: the ?: tells regexp that the first one is # a non-capturing group, so it must not be returned # to findall. http://www.... |
'GTG.plugins.rtm_sync': ['rtm.ui', 'pyrtm/rtm.py', | 'GTG.plugins.rtm_sync': ['rtm.ui', 'pyrtm/rtm.py','pyrtm/__init__.py', | def find_mo_files(self): data_files = [] for mo in glob.glob(os.path.join(MO_DIR, '*', 'gtg.mo')): lang = os.path.basename(os.path.dirname(mo)) dest = os.path.join('share', 'locale', lang, 'LC_MESSAGES') data_files.append((dest, [mo])) return data_files |
Return None if no path for that Node. | Return an empty list if no path for that Node. | def get_paths_for_node(self, node): """ Return a list of paths for a given node Return None if no path for that Node. """ toreturn = [] if node: tid = node.get_id() #For that node, we should convert the base_path to path if not node or not self.is_displayed(node.get_id()): #print "not displayed %s" %node return None #T... |
return None | return toreturn | def get_paths_for_node(self, node): """ Return a list of paths for a given node Return None if no path for that Node. """ toreturn = [] if node: tid = node.get_id() #For that node, we should convert the base_path to path if not node or not self.is_displayed(node.get_id()): #print "not displayed %s" %node return None #T... |
toreturn = None | def get_paths_for_node(self, node): """ Return a list of paths for a given node Return None if no path for that Node. """ toreturn = [] if node: tid = node.get_id() #For that node, we should convert the base_path to path if not node or not self.is_displayed(node.get_id()): #print "not displayed %s" %node return None #T... | |
if len(toreturn) == 0: return None else: return toreturn | return toreturn | def get_paths_for_node(self, node): """ Return a list of paths for a given node Return None if no path for that Node. """ toreturn = [] if node: tid = node.get_id() #For that node, we should convert the base_path to path if not node or not self.is_displayed(node.get_id()): #print "not displayed %s" %node return None #T... |
return getattr(self.task[len(self.task.task) - 1], attr) | return getattr(self.task[len(self.task) - 1], attr) | def __get_rtm_task_attribute(self, attr): if hasattr(self.task, 'task'): if hasattr(self.task.task, 'list'): return getattr(self.task.task.list, attr) elif type(self.task.task) == list: return getattr(self.task.task[len(self.task.task) - 1], attr) else: return getattr(self.task.task, attr) else: if type(self.task) == l... |
if parent_tid in current_parents or parent_tid == child_tid: | if child_tid in genealogy or parent_tid == child_tid: | def move_task(self, parent_tid, child_tid): """Moves the task identified by child_tid under parent_tid, removing all the precedent parents. Child becomes a root task if parent_tid is None""" child_task = self.req.get_task(child_tid) current_parents = child_task.get_parents() #Avoid the typical time-traveller problem be... |
@dbus.service.method(BUSNAME) def open_new_task(self): | @dbus.service.method(BUSNAME, in_signature="ss") def open_new_task(self, title, description): | def open_task_editor(self, tid): self.ui.open_task(tid) |
return self.on_iter_nth_child(rowref,0) | nid = rowref.get_node() if self.tree.node_n_children(nid) > 0: return self.on_iter_nth_child(rowref,0) else: return None | def on_iter_children(self, rowref): return self.on_iter_nth_child(rowref,0) |
task = plugin_api.get_task() | task = plugin_api.get_ui().get_task() | def onTaskOpened(self, plugin_api): # add button button = gtk.ToolButton() button.set_label("Start") button.set_icon_name('hamster-applet') button.set_tooltip_text(_("Start a new activity in Hamster Time " + \ " Tracker based on this task")) button.connect('clicked', self.task_cb, plugin_api) button.show() self.taskbut... |
found = False | if line < self.buff.get_line_count() : found = False | def insert_newtask(self,fitera=None) : if not fitera : fitera = self.get_insert() #First, find a line without subtask line = fitera.get_line() #Avoid the title at all cost if line <= 0 : line = 1 startl = self.buff.get_iter_at_line(line) itera = None while not itera : found = True for t in startl.get_tags() : if t.get_... |
mark = self.buff.create_mark("temp",itera,True) | mark = self.buff.create_mark(None,itera,True) | def insert_newtask(self,fitera=None) : if not fitera : fitera = self.get_insert() #First, find a line without subtask line = fitera.get_line() #Avoid the title at all cost if line <= 0 : line = 1 startl = self.buff.get_iter_at_line(line) itera = None while not itera : found = True for t in startl.get_tags() : if t.get_... |
self.trace = '' | self.trace = '\nDEBUG TRACE for ViewTree %s\n----------------\n\n'%self | def __init__(self,tree,filtersbank,refresh=True): """ Construct a FilteredTree object on top of an existing task tree. @param req: The requestor object @param tree: The tree to filter from @param maintree: Whether this tree is the main tree. The requester must be used to change filters against the main tree. """ self.... |
error += "parent paths are %s" %self.get_paths_for_node(par) | error += "parent paths are %s\n" %self.get_paths_for_node(par) error += self.trace | def __add_node(self,nid,paths=None): error = "Adding node %s to paths %s\n" %(nid,paths) self.trace += " "+error #we only add node that really need it. curdis = self.is_displayed(nid) newdis = self.__is_displayed(nid) #it should not be displayed, don't add it. if not newdis: return False if not paths: paths = self... |
self.__toolbar = self.__builder.get_object('task_tb') | self.__toolbar = self.__builder.get_object('task_toolbar') print "TASKBROW", self.__toolbar | def __init__(self, requester, view_manager, taskeditor = None): """ Construct a PluginAPI object. |
if node: | if node and node.get_n_children() > n: | def node_nth_child(self, nid, n): toreturn = None if self.static: node = self.__get_static_node(nid) if node: toreturn = node.get_nth_child(n) else: toreturn = self.__ft.node_nth_child(nid,n) return toreturn |
else: | else: raise ValueError("node %s has less than %s nodes" %(nid,n)) else: if self.__ft.node_n_children(nid) <= n: raise ValueError("viewtree has less than %s nodes" %n) | def node_nth_child(self, nid, n): toreturn = None if self.static: node = self.__get_static_node(nid) if node: toreturn = node.get_nth_child(n) else: toreturn = self.__ft.node_nth_child(nid,n) return toreturn |
print "Something happened last time we tried to write file. Temp file found, using it as normal." | Log.debug("Something happened to the tags file. Using backup") | def openxmlfile(zefile,root ): tmpfile = zefile+'__' try: if os.path.exists(zefile): f = open(zefile, "r") elif os.path.exists(tmpfile): print "Something happened last time we tried to write file. Temp file found, using it as normal." os.rename(tmpfile, zefile) f = open(zefile, "r") else: # Creating empty file doc,xml... |
print "Error parsing XML file %s: %s" %(zefile, msg) | Log.debug("Error parsing XML file %s: %s" %(zefile, msg)) | def openxmlfile(zefile,root ): tmpfile = zefile+'__' try: if os.path.exists(zefile): f = open(zefile, "r") elif os.path.exists(tmpfile): print "Something happened last time we tried to write file. Temp file found, using it as normal." os.rename(tmpfile, zefile) f = open(zefile, "r") else: # Creating empty file doc,xml... |
if not self.flat and n.has_parent(): | if not self.flat and n and n.has_parent(): | def __is_root(self,n): is_root = True if not self.flat and n.has_parent(): for par in n.get_parents(): if self.__is_displayed(par): is_root = False return is_root |
chid = ch.get_id() if chid in self.virtual_root: | if ch: chid = ch.get_id() if chid in self.virtual_root: | def __root_update(self,tid,inroot): |
def get_all_descendant_tags(self, tname): tags = [tname] tt = self.req.get_tag(tname) if tt: children = tt.get_children() tags.extend(children) for child_tag in children: tags.extend(self.get_all_descendant_tags(child_tag)) return tags | def set_parameters(self,dic): self.dic = dic | |
tags = [self.tname] tt = self.req.get_tag(self.tname) if tt: tags += tt.get_children() | tags = self.get_all_descendant_tags(self.tname) | def is_displayed(self,tid): task = self.req.get_task(tid) value = True if not task: value = False else: tags = [self.tname] tt = self.req.get_tag(self.tname) if tt: tags += tt.get_children() value = task.has_tags(tags) if 'negate' in self.dic and self.dic['negate']: value = not value return value |
return [self.get_task(id) for id in self.get_task_ids()] | return [self.get_task(id) for id in self.get_task_ids(u"Active")] | def get_tasks(self): # Retrieve a list of task data dicts return [self.get_task(id) for id in self.get_task_ids()] |
nt = self.req.new_task(tags=tags) | tags_objects = [] for t in tags: tag_object = self.req.get_tag(t) if tag_object == None: tag_object = self.req.new_tag(t) tags_objects.append(tag_object) nt = self.req.new_task(tags=tags_objects) | def new_task(self, status, title, duedate, startdate, donedate, tags, text, subtasks): # Generate a new task object and return the task data as a dict nt = self.req.new_task(tags=tags) for sub in subtasks: nt.add_subtask(sub) nt.set_status(status, donedate=dates.strtodate(donedate)) nt.set_title(title) nt.set_due_date(... |
self._mark_today_in_bold() | def on_date_pressed(self, widget,data): """Called when the due button is clicked.""" self.__opened_date = data self._mark_today_in_bold() if self.__opened_date == "due" : toset = self.task.get_due_date() self.calendar_fuzzydate_btns.show() elif self.__opened_date == "start" : toset = self.task.get_start_date() self.ca... | |
if backend.should_task_id_be_stored(task_id): backend.queue_set_task(None, task_id) else: backend.queue_remove_task(None, task_id) | backend.queue_set_task(None, task_id) | def _internal_flush_all_tasks(): backend = self.backends[backend_id] for task_id in self.requester.get_all_tasks_list(): if backend.should_task_id_be_stored(task_id): backend.queue_set_task(None, task_id) else: backend.queue_remove_task(None, task_id) |
for str in ["1985-03-29", "now", "soon", "later", ""]: date = get_canonical_date(str) self.assertEqual(date.__str__(), str) | known_values = (("1985-03-29", "1985-03-29"), ("now", _("now")), ("soon", _("soon")), ("later", _("later")), ("", "")) for value, result in known_values: date = get_canonical_date(value) self.assertEqual(date.__str__(), result) | def test_get_canonical_date(self): ''' Tests for "get_canonical_date" ''' for str in ["1985-03-29", "now", "soon", "later", ""]: date = get_canonical_date(str) self.assertEqual(date.__str__(), str) |
print "we clikced on %s" %str(target) print "event.type = button_press : %s" %(event.type == gtk.gdk.BUTTON_PRESS) print "not mask : %s" %(not(event.state & (gtk.gdk.CONTROL_MASK|gtk.gdk.SHIFT_MASK))) print "is_selected : %s" %(self.get_selection().path_is_selected(target[0])) if (target and event.type == gtk.gdk.BUTTO... | if (target \ and event.type == gtk.gdk.BUTTON_PRESS\ and event.button == 1\ and not (event.state & (gtk.gdk.CONTROL_MASK|gtk.gdk.SHIFT_MASK))\ | def on_button_press(self, widget, event): # Here we intercept mouse clicks on selected items so that we can # drag multiple items without the click selecting only one target = self.get_path_at_pos(int(event.x), int(event.y)) print "we clikced on %s" %str(target) print "event.type = button_press : %s" %(event.type == gt... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.