rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
flat = False | flat = True | def usage(): print '\nUsage: %s [options] [package]\n' % (sys.argv[0]) print 'Displays OE build dependencies for a given package or recipe.' print 'Uses the pn-depends.dot file for its raw data.' print 'Generate a pn-depends.dot file by running bitbake -g <recipe>.\n' print 'Options:' print '-h, --help\tShow this help ... |
elif o in ('-f', '--flat'): flat = True | elif o in ('-t', '--tree'): flat = False | def usage(): print '\nUsage: %s [options] [package]\n' % (sys.argv[0]) print 'Displays OE build dependencies for a given package or recipe.' print 'Uses the pn-depends.dot file for its raw data.' print 'Generate a pn-depends.dot file by running bitbake -g <recipe>.\n' print 'Options:' print '-h, --help\tShow this help ... |
list_reverse_deps(args[0], depth) | if flat: list_reverse_deps_flat(args[0], depth) else: list_reverse_deps(args[0], depth) | def usage(): print '\nUsage: %s [options] [package]\n' % (sys.argv[0]) print 'Displays OE build dependencies for a given package or recipe.' print 'Uses the pn-depends.dot file for its raw data.' print 'Generate a pn-depends.dot file by running bitbake -g <recipe>.\n' print 'Options:' print '-h, --help\tShow this help ... |
name = a | device = a | def main(): opts, args = getopt.getopt(sys.argv[1:], 'i:h') device = None for o, a in opts: if o == '-i': name = a else: usage() cap = pcap.pcap(device) cap.setfilter('dst port 80') processed = {} for ts, raw in cap: eth = dpkt.ethernet.Ethernet(raw) # Depending on platform, we can either get fully formed packets ... |
here_url = object.absolute_url() def fixURL(match): """Fix relative URL to absolute ones""" value = match.group() pos_s = value.find(match_start)+len(match_start) pos_e = value.find('"', pos_s+1) url = value[pos_s:pos_e] if not url.startswith(here_url): return value.replace(url, "%s/%s" % (here_url, url)) return value ... | def sendMail(object, event): """A Zope3 event for sending emails""" ploneboard_notify_properties = getToolByName(object,'portal_properties')['ploneboard_notify_properties'] debug_mode = ploneboard_notify_properties.debug_mode notify_encode = ploneboard_notify_properties.notify_encode portal = getToolByName(object,"port... | |
self.load(self.item) | def cancel(self): self.changed = False self.load(self.item) | |
if issubclass(item.__class__, DiagramItem): if item != self.itemSelected: self.itemSelected = item QObject.emit(self, SIGNAL("DiagramItemSelected"), item) | if item.hackselected is False: QObject.emit(self, SIGNAL("DiagramItemSelected"), item) | def itemSelected(self, item): if issubclass(item.__class__, DiagramItem): #TODO: Refactor this nicely # Due to DiagramItem::showSlot() l.350 qui désélectionne tout seul ! # http://www.qtforum.org/article/32164/setvisible-on-a-qgraphicsitemgroup-child-changes-the-group-selected-state.html if item != self.itemSelected: s... |
def __init__(self, *args): QGraphicsScene.__init__(self, *args) | DEFAULT_SIZE = QSizeF(700, 500) def __init__(self, *args, **kwargs): super(DiagramScene, self).__init__(*args, **kwargs) self.setSceneRect(QRectF(QPointF(), self.DEFAULT_SIZE)) | def boundingOffsets(self): return (0, -10, 0, 10) |
item.setPos(pos) | middle = pos - item.sceneBoundingRect().center() item.setPos(middle) | def addDiagramItem(self, pos, node, emit=True): item = DiagramItem.factory(node.__class__) item.node = node item.setPos(pos) self.addItem(item) item.update() if emit: QObject.emit(self, SIGNAL("diagramItemCreated"), item) return item |
diagrampanel.setSizes([210, 400, 150]) | diagrampanel.setSizes([180, 400, 150]) diagrampanel.setStretchFactor(0, 0) diagrampanel.setStretchFactor(1, 1) diagrampanel.setStretchFactor(2, 0) | def buildWidgets(self): # Main widgets self.statusBar() self.buildMenuToolbar() """ Diagram Panel """ # Scene self.scene = DiagramScene(self) self.view = QGraphicsView(self.scene) self.view.setRenderHint(QPainter.Antialiasing) # Node library self.nodelibrary = NodeLibrary() # Parameters Panel self.parameters = Paramete... |
def SVGShape(self): path = os.path.join(florun.icons_dir, self.SVG_SHAPE) if not os.path.exists(path): logger.warning("SVG missing '%s'" % path) return path | def shapes(self): if not self._shapes: self._shapes = {} for elt in ['default', 'start']: s = QGraphicsSvgItem(self.SVGShape()) s.setElementId(QString(elt)) self._shapes[elt] = s return self._shapes | |
self.setFlag(QGraphicsItem.ItemSendsScenePositionChanges, True) | self.setFlag(QGraphicsItem.ItemSendsGeometryChanges, True) | def __init__(self, *args): QGraphicsItemGroup.__init__(self, *args) #self.setAcceptHoverEvents(True) self.setFlag(QGraphicsItem.ItemIsMovable, True) self.setFlag(QGraphicsItem.ItemIsSelectable, True) self.setFlag(QGraphicsItem.ItemSendsScenePositionChanges, True) self._shapes = None self.text = None # Underlying object... |
for i in self.items(): if issubclass(i.__class__, DiagramItem): if i.node == node: return i | for i in self.diagramitems: if i.node == node: return i | def findDiagramItemByNode(self, node): for i in self.items(): if issubclass(i.__class__, DiagramItem): if i.node == node: return i raise Exception("%s : %s" % (self.tr(u"DiagramItem not found with node"), node)) |
self.center() | self.loadPreferences() | def __init__(self, filename=None, *args): QMainWindow.__init__(self, *args) MainWindow.ScissorsCursor = QCursor(self.loadIcon('cursor-scissors').pixmap(QSize(24, 24))) self.apptitle = florun.__title__ # Main attributes self.basedir = florun.base_dir self.asked = False self.tmpfile = None self.flow = None self.buildActi... |
mainWindow.setGeometry(100, 100, 800, 500) | def main(args, filename=None): app = QApplication(args) # Internationalization : Install file according to current locale translator = QTranslator() locale = QLocale.system().name() if translator.load(os.path.join(florun.locale_dir, '%s' % locale, "gui")): app.installTranslator(translator) else: logger.warning("Could n... | |
def clear(self): self.console.setText('') | def detachProcess(self): self.process = None self.enable() | |
self.changed = False | def cancel(self): self.load(self.item) self.changed = False | |
cmd = 'python florun.py --level %s --execute "%s"' % (self.console.loglevel, self.flow.filename) | florunmain = os.path.join(florun.base_dir, 'florun.py') cmd = 'python %s --level %s --execute "%s"' % (florunmain, self.console.loglevel, self.flow.filename) | def startFlow(self): """ Run current flow """ # Switch to console tab self.maintabs.setCurrentIndex(1) # Disable start self.start.setEnabled(False) self.stop.setEnabled(True) # Use process self.process = QProcess() self.console.attachProcess(self.process) self.connect(self.process, SIGNAL("readyReadStandardOutput()"), ... |
self.highlight = len(self.connectors) > 0 | self.highlight = False | def disconnect(self, connector): self.connectors.remove(connector) self.highlight = len(self.connectors) > 0 |
return self.parent().parent().parent().parent().parent().parent().parent().parent() | if self._window is None: widget = self.parent() while widget is not None and not issubclass(widget.__class__, MainWindow): widget = widget.parent() self._window = widget return self._window | def window(self): #TODO: what better way ? return self.parent().parent().parent().parent().parent().parent().parent().parent() |
errorbox.setText(u"An unhandled exception occurred.") | errorbox.setText(_(u"An unhandled exception occurred.")) | def messageException(cls, excType, excValue, tracebackobj): errmsg = u"%s: %s" % (str(excType), str(excValue)) tbinfofile = cStringIO.StringIO() traceback.print_tb(tracebackobj, None, tbinfofile) tbinfofile.seek(0) tbinfo = tbinfofile.read() logcore.debug(errmsg + "\n" + tbinfo) |
assert self.connector.startItem is not None assert self.connector.endItem is not None | assert connector.startItem is not None assert connector.endItem is not None | def connectorRemoved(self, connector): loggui.debug(self.tr("Main window: diagram connector removed : %1").arg(u'%s'%connector)) assert self.connector.startItem is not None assert self.connector.endItem is not None start = connector.startItem.interface end = connector.endItem.interface self.flow.removeConnector(start, ... |
self.setAcceptHoverEvents(True) | def __init__(self, parent, interface, textposition = None): QGraphicsEllipseItem.__init__(self, parent) assert issubclass(parent.__class__, DiagramItem) self.parent = parent self.connectors = [] # Underlying object self.interface = interface self.buildItem() self.highlight = False self.text.setPlainText(interface.name)... | |
QObject.emit(self.scene(), SIGNAL("connectorEnterEvent"), self) | hoverSlot = False for i in self.scene().items(event.scenePos()): if issubclass(i.__class__, SlotItem): hoverSlot = True if not hoverSlot: QObject.emit(self.scene(), SIGNAL("connectorEnterEvent"), self) | def hoverEnterEvent(self, event): QObject.emit(self.scene(), SIGNAL("connectorEnterEvent"), self) QGraphicsLineItem.hoverEnterEvent(self, event) |
self.setAcceptHoverEvents(True) | def __init__(self, *args): QGraphicsItemGroup.__init__(self, *args) self.setAcceptHoverEvents(True) self.setFlag(QGraphicsItem.ItemIsMovable, True) self.setFlag(QGraphicsItem.ItemIsSelectable, True) self.setHandlesChildEvents(True) self.text = None # Underlying object self._node = None self.buildItem() self.slotitems =... | |
self.setHandlesChildEvents(True) | def __init__(self, *args): QGraphicsItemGroup.__init__(self, *args) self.setAcceptHoverEvents(True) self.setFlag(QGraphicsItem.ItemIsMovable, True) self.setFlag(QGraphicsItem.ItemIsSelectable, True) self.setHandlesChildEvents(True) self.text = None # Underlying object self._node = None self.buildItem() self.slotitems =... | |
self._hoverslot = None | def __init__(self, *args): QGraphicsItemGroup.__init__(self, *args) self.setAcceptHoverEvents(True) self.setFlag(QGraphicsItem.ItemIsMovable, True) self.setFlag(QGraphicsItem.ItemIsSelectable, True) self.setHandlesChildEvents(True) self.text = None # Underlying object self._node = None self.buildItem() self.slotitems =... | |
def moveEvent(self, event): """ Called by DiagramItem::hoverMoveEvent() and DiagramScene::mouseMoveEvent() """ hoverslot = None for s in self.slotitems: rect = s.sceneBoundingRect() if rect.contains(event.scenePos()): hoverslot = s if hoverslot is None and self._hoverslot is not None: QObject.emit(self.scene(), SIGNA... | def findSlot(self, interface): """ Find the {SlotItem} matching the specified {flow.Interface}. @type interface: {flow.Interface} @rtype: {SlotItem} """ for s in self.slotitems: if s.interface == interface: return s raise Exception(u"SlotItem with interface %s not found on %s" % (interface, self)) | |
self.view.setCursor(Qt.ArrowCursor) | if self.connector is None: self.view.setCursor(Qt.ArrowCursor) | def slotLeaveEvent(self, slot): self.view.setCursor(Qt.ArrowCursor) slot.highlight = False self.slot = None |
if mouseEvent.buttons() != Qt.NoButton : for i in self.items(pos): if issubclass(i.__class__, DiagramItem): i.moveEvent(mouseEvent) | hoverslot = None for i in self.items(pos): if issubclass(i.__class__, SlotItem): hoverslot = i if hoverslot is None and self.slotHover is not None: QObject.emit(self, SIGNAL("slotLeaveEvent"), self.slotHover) if hoverslot is not None and self.slotHover is None: QObject.emit(self, SIGNAL("slotEnterEvent"), hoverslot) ... | def mouseMoveEvent(self, mouseEvent): pos = mouseEvent.scenePos() # If connector is not None, the user is drawing if self.connector is not None: self.connector.moveEnd(pos) # Gives sub items mouse move if mouse pressed if mouseEvent.buttons() != Qt.NoButton : for i in self.items(pos): if issubclass(i.__class__, Diagram... |
loggui.debug("Load icon file from '%s'" % path) return QIcon(QPixmap(path)) raise Exception("Could not find icon '%s'" % iconid) | if path != '': loggui.debug("Load icon file from '%s'" % path) return QIcon(QPixmap(path)) return QIcon(QPixmap()) | def loadIcon(self, iconid): """ @param iconid : Freedesktop identifier from http://standards.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html @type iconid : str @rtype: L{QtGui.QIcon} """ # Try Themed Icons (Qt >= 4.6) try: if QIcon.hasThemeIcon(iconid): return QIcon.fromTheme(iconid) except AttributeError... |
self.removeConnector(self.connector) self.addConnector(self.connector.startItem, self.slot) | exists = False for i in [item for item in self.items() if issubclass(item.__class__,DiagramConnector)]: if i.startItem == self.connector.startItem and i.endItem == self.slot: exists = True if not exists: self.removeConnector(self.connector) self.addConnector(self.connector.startItem, self.slot) else: self.window.setS... | def mouseReleaseEvent(self, mouseEvent): if self.connectorHover is not None: # Connector was clicked : remove it self.removeConnector(self.connectorHover, True) elif self.connector is not None: # Create connector if self.slot is not None: if self.connector.canConnect(self.slot): # New connector, remove the one being dr... |
def setStatusMessage(self, txt, timeout=3000): | def setStatusMessage(self, txt, timeout=6000): | def setStatusMessage(self, txt, timeout=3000): self.statusBar().showMessage(txt, timeout) |
filename = self.flow.filename if filename is None: filename = self.tr(u"Untitled") | filename = self.filename | def updateTitle(self): filename = self.flow.filename if filename is None: filename = self.tr(u"Untitled") if self.flow.modified: filename = "*"+filename self.setWindowTitle("%s - %s" % (filename, self.apptitle)) |
cliargs = [n.name.value for n in self.flow.CLIParameterNodes() if len(n.name.predecessors) == 0] loggui.debug(self.tr("CLI args required : %1").arg(', '.join(cliargs))) answer, userargs = self.FlowCLIArguments(cliargs) if answer == QDialog.Rejected: loggui.debug(self.tr("Flow start canceled by user.")) return | def startFlow(self): """ Run current flow """ if self.flow.modified: answer = MainWindow.messageCancelYesNo(self.tr(u"Save flow ?"), self.tr(u"The flow has been modified."), self.tr("Do you want to save your changes?")) if answer == QMessageBox.Yes: self.saveFlow() elif answer == QMessageBox.Cancel: loggui.debug(self.t... | |
cmd = u'python %s --level %s --execute "%s"' % (florunmain, self.console.loglevel, self.flow.filename) | cmd = u'python %s --level %s --execute "%s" %s' % \ (florunmain, self.console.loglevel, self.flow.filename, " ".join(['--%s "%s"' % (argname, argvalue) for argname, argvalue in userargs.items()])) | def startFlow(self): """ Run current flow """ if self.flow.modified: answer = MainWindow.messageCancelYesNo(self.tr(u"Save flow ?"), self.tr(u"The flow has been modified."), self.tr("Do you want to save your changes?")) if answer == QMessageBox.Yes: self.saveFlow() elif answer == QMessageBox.Cancel: loggui.debug(self.t... |
self.assertRaises(Exception, test_view('dashboard')) | test_view('dashboard') | def test0005views(self): ''' Test views. ''' self.assertRaises(Exception, test_view('dashboard')) |
if isinstance(ids, (int, long)) \ and dashboard_id == ids: res['arch'] = self.dashboard_view(cursor, user, res['arch'], context=context) | if isinstance(ids, (int, long)): if dashboard_id == ids: res['arch'] = self.dashboard_view(cursor, user, res['arch'], context=context) | def read(self, cursor, user, ids, fields_names=None, context=None): res = super(View, self).read(cursor, user, ids, fields_names=fields_names, context=context) if user == 0: return res dashboard_id = self.dashboard_id(cursor, user, context=context) if not dashboard_id: # Restart the cache self.dashboard_id(cursor.dbnam... |
self._map = _expand_list(self._map) | map = _expand_list(self._map) self._map = None | def expand(self, defaults=(), ignore_missing=(), recursive=True, _block=()): """Expand all :class:`Link` and sub-string variables in this and, if recursion is enabled, all child :class:`Struct` objects. This is normally called during parsing but may be useful if more control is required. |
if len(value) != len(self._map): | if len(value) != len(map): | def expand(self, defaults=(), ignore_missing=(), recursive=True, _block=()): """Expand all :class:`Link` and sub-string variables in this and, if recursion is enabled, all child :class:`Struct` objects. This is normally called during parsing but may be useful if more control is required. |
(len(self._map), key, len(value))) | (len(map), key, len(value))) | def expand(self, defaults=(), ignore_missing=(), recursive=True, _block=()): """Expand all :class:`Link` and sub-string variables in this and, if recursion is enabled, all child :class:`Struct` objects. This is normally called during parsing but may be useful if more control is required. |
for i, suffix in enumerate(self._map): | for i, suffix in enumerate(map): | def expand(self, defaults=(), ignore_missing=(), recursive=True, _block=()): """Expand all :class:`Link` and sub-string variables in this and, if recursion is enabled, all child :class:`Struct` objects. This is normally called during parsing but may be useful if more control is required. |
new._map = None | def expand(self, defaults=(), ignore_missing=(), recursive=True, _block=()): """Expand all :class:`Link` and sub-string variables in this and, if recursion is enabled, all child :class:`Struct` objects. This is normally called during parsing but may be useful if more control is required. | |
return self.__class__(value, container, name, self) | def fixpath(match): return "${%s}" % self._translate_path(match.group(1), self.container, container) | |
return self.__class__(leaf_value, container, name, self) | return self.__class__(value, container, name, self) | def fixpath(match): return "${%s}" % self._translate_path(match.group(1), self.container, container) |
def copy(sequence): for item in sequence: if isinstance(item, list): yield self.__class__(item) else: yield item super(List, self).__init__(copy(sequence)) | super(List, self).__init__( _copy_list_contents(sequence, self.__class__)) | def copy(sequence): for item in sequence: if isinstance(item, list): yield self.__class__(item) else: yield item |
subval = list(subval) | subval = List(subval) | def expand_link(link): try: subval = self.expanditem(link.path, defaults, ignore_missing, _block) except errors.KeyMissingError, ex: if ignore_missing is True or ex.key in ignore_missing: return link else: raise |
value = list(value) | value = _copy_list(value) | def dict(self): """Recursively copy this :class:`Struct` into normal *dict* objects""" |
current._extend(value, replace) | current._extend(value, recursive=True) | def setitem(key, value): if recursive and key in self: current = self._get(key) if (hasattr(value, 'iteritems') and isinstance(current, Struct)): current._extend(value, replace) return |
paths = self.get_paths_for_node(tid) | if self.is_displayed(tid): paths = self.get_paths_for_node(tid) else: paths = None | def __update_node(self,tid,inroot): if tid not in self.node_to_remove: todis = self.__is_displayed(tid) curdis = self.is_displayed(tid) if todis: #if the task was not displayed previously but now should #we add it. if not curdis: |
task.set_status(task_data["status"], donedate=task_data["donedate"]) | task.set_status(task_data["status"], donedate=dates.strtodate(task_data["donedate"])) | def modify_task(self, tid, task_data): # Apply supplied task data to the task object with the specified ID task = self.req.get_task(tid) task.set_status(task_data["status"], donedate=task_data["donedate"]) task.set_title(task_data["title"]) task.set_due_date(task_data["duedate"]) task.set_start_date(task_data["startdat... |
task.set_due_date(task_data["duedate"]) task.set_start_date(task_data["startdate"]) | task.set_due_date(dates.strtodate(task_data["duedate"])) task.set_start_date(dates.strtodate(task_data["startdate"])) | def modify_task(self, tid, task_data): # Apply supplied task data to the task object with the specified ID task = self.req.get_task(tid) task.set_status(task_data["status"], donedate=task_data["donedate"]) task.set_title(task_data["title"]) task.set_due_date(task_data["duedate"]) task.set_start_date(task_data["startdat... |
tb_Taskbutton = gtk.ToolButton(gtk.STOCK_EXECUTE) | tb_Taskicon = gtk.Image() tb_Taskicon.set_from_icon_name('mail-send', 32) tb_Taskicon.show() tb_Taskbutton = gtk.ToolButton(tb_Taskicon) | def onTaskOpened(self, plugin_api): # add a item (button) to the ToolBar tb_Taskbutton = gtk.ToolButton(gtk.STOCK_EXECUTE) tb_Taskbutton.set_label("Send via email") tb_Taskbutton.connect('clicked', self.onTbTaskButton, plugin_api) self.task_separator = plugin_api.add_task_toolbar_item(gtk.SeparatorToolItem()) self.tb_T... |
return True else: | self.sync() child.sync() return True else: Log.debug("child addition failed") | def add_child(self, tid): """Add a subtask to this task |
self.insert_indent(self.buff,end_i,1,enter=True) | if restofline and restofline.strip() != "" : self.__newsubtask(self.buff,restofline,\ line_nbr+1) else: self.insert_indent(self.buff,end_i,1,enter=True) | 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... |
self.tag_completion.set_text_column(2) | self.tag_completion.set_text_column(1) self.tag_completion.set_match_func(self.tag_match_func, 1) | def _init_tag_completion(self): self.tag_completion = gtk.EntryCompletion() self.tag_completion.set_model(self.tag_model) self.tag_completion.set_text_column(2) self.tag_completion.set_inline_completion(True) self.tag_completion.set_inline_selection(True) |
return cmp(t2_order, t1_order) | return cmp(t2_order, t1_order) def tag_match_func(self, completion, key, iter, column): model = completion.get_model() text = model.get_value(iter, column) text = text.lower() if text == "tg-tags-all" or text == "tg-tags-sep" or \ text =="tg-tags-none": return False elif text.startswith(key): return True else: re... | def tag_sort_func(self, model, iter1, iter2, user_data=None): order = self.tags_tv.get_model().get_sort_column_id()[1] t1 = model.get_value(iter1, tagtree.COL_OBJ) t2 = model.get_value(iter2, tagtree.COL_OBJ) t1_sp = t1.get_attribute("special") t2_sp = t2.get_attribute("special") t1_name = locale.strxfrm(t1.get_name())... |
if new_par_tag: self._update_tag_from_name(new_par_tag.get_name()) if old_par_tag: tasks_count = old_par_tag.get_tasks_nbr() if tasks_count > 0: self._update_tag_from_name(old_par_tag.get_name()) else: self.row_deleted(self.tree.get_path_for_node(old_par_tag)) | def move_tag(self, parent, child): Log.debug("Moving %s below %s" % (child, parent)) # Get child child_tag = self.get_value(child, COL_OBJ) child_path = self.get_path(child) # Get old parent old_par = self.iter_parent(child) if old_par: old_par_tag = self.get_value(old_par, COL_OBJ) old_par_n_children = self.iter_n_c... | |
self.separator = gtk.SeparatorToolItem() self.task_separator = None | def __init__(self): #task editor widget self.vbox = None self.button=gtk.ToolButton() self.menu_item = gtk.MenuItem(_("Start task in Hamster")) self.taskbutton = None self.separator = gtk.SeparatorToolItem() self.task_separator = None | |
plugin_api.add_toolbar_item(self.separator) | self.button.show() | def activate(self, plugin_api): self.plugin_api = plugin_api self.hamster=dbus.SessionBus().get_object('org.gnome.Hamster', '/org/gnome/Hamster') # add menu item self.menu_item.connect('activate', self.browser_cb, plugin_api) plugin_api.add_menu_item(self.menu_item) # and button self.button.set_label(_("Start in Hams... |
self.task_separator = plugin_api.add_task_toolbar_item(gtk.SeparatorToolItem()) self.taskbutton = plugin_api.add_task_toolbar_item(button) | button.show() self.taskbutton = plugin_api.add_toolbar_item(button) | 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) self.task_separator = plug... |
plugin_api.remove_toolbar_item(self.separator) plugin_api.remove_task_toolbar_item(self.task_separator) plugin_api.remove_task_toolbar_item(self.taskbutton) | plugin_api.remove_toolbar_item(self.taskbutton) | def deactivate(self, plugin_api): plugin_api.remove_menu_item(self.menu_item) plugin_api.remove_toolbar_item(self.button) plugin_api.remove_toolbar_item(self.separator) plugin_api.remove_task_toolbar_item(self.task_separator) plugin_api.remove_task_toolbar_item(self.taskbutton) plugin_api.remove_widget_from_taskeditor(... |
self.sendTask(plugin_api.get_selected_task()) | task_id = plugin_api.get_ui().get_selected_task() self.sendTask(plugin_api.get_requester().get_task(task_id)) | def browser_cb(self, widget, plugin_api): self.sendTask(plugin_api.get_selected_task()) |
self.sendTask(plugin_api.get_task()) | task = plugin_api.get_ui().get_task() self.sendTask(task) | def task_cb(self, widget, plugin_api): self.sendTask(plugin_api.get_task()) |
def configure_dialog(self, plugin_apis, manager_dialog): | def configure_dialog(self, manager_dialog): | def configure_dialog(self, plugin_apis, manager_dialog): self.preferences_load() self.preferences_dialog.set_transient_for(manager_dialog) def pref_to_dialog(pref): self.builder.get_object(pref+"_"+self.preferences[pref]) \ .set_active(True) pref_to_dialog("activity") pref_to_dialog("category") pref_to_dialog("descri... |
today = date_today() | today = datetime.datetime.now().date() | def delete_old_closed_tasks(self, widget = None): self.__log("Starting deletion of old tasks") today = date_today() requester = self.plugin_api.get_requester() closed_tids = requester.get_tasks_list(status = [Task.STA_DISMISSED, Task.STA_DONE]) closed_tasks = [requester.get_task(tid) for tid in closed_tids] to_remove =... |
to_remove = filter(lambda t: t.get_closed_date() < today, closed_tasks) | delta = datetime.timedelta(days = self.preferences["max_days"]) to_remove = filter(lambda t: t.get_closed_date().to_py_date() < today -delta,\ closed_tasks) | def delete_old_closed_tasks(self, widget = None): self.__log("Starting deletion of old tasks") today = date_today() requester = self.plugin_api.get_requester() closed_tids = requester.get_tasks_list(status = [Task.STA_DISMISSED, Task.STA_DONE]) closed_tasks = [requester.get_task(tid) for tid in closed_tids] to_remove =... |
print "old paths are : %s" %self.old_paths | Log.debug( "old paths are : %s" %self.old_paths ) | def get_deleted_path(self,id): toreturn = None print "old paths are : %s" %self.old_paths if self.old_paths.has_key(id): toreturn = self.old_paths.pop(id) return toreturn |
self.tags_tv.refresh() | def on_add_new_tag(self, widget=None, tid=None): if not tid: self.tids_to_addtag = self.get_selected_tasks() else: self.tids_to_addtag = [tid] if len(self.tids_to_addtag) > 0: #TODO: Apply to subtasks? #TODO: Access via hotkey #TODO: Autocomplete #TODO: Multiple tags~ #TODO: Menu icon? #TODO: ???????????????????????? ... | |
task.sync | task.sync() | def on_addtag_confirm(self, widget=None): tag_entry = self.builder.get_object("tag_entry") addtag_dialog = self.builder.get_object("TaskAddTag") if not tag_entry.get_text()[0] == "@": new_tagname = "@" + tag_entry.get_text() else: new_tagname = tag_entry.get_text() #TODO: What if I _want_ the new tag to be @@somethin... |
self.tags_tv.refresh() | def on_addtag_confirm(self, widget=None): tag_entry = self.builder.get_object("tag_entry") addtag_dialog = self.builder.get_object("TaskAddTag") if not tag_entry.get_text()[0] == "@": new_tagname = "@" + tag_entry.get_text() else: new_tagname = tag_entry.get_text() #TODO: What if I _want_ the new tag to be @@somethin... | |
todis = self.__is_displayed(tid) curdis = self.is_displayed(tid) if todis: if not curdis: self.__add_node(tid) | if tid not in self.node_to_remove: todis = self.__is_displayed(tid) curdis = self.is_displayed(tid) if todis: if not curdis: self.__add_node(tid) else: node = self.get_node(tid) self.update_count += 1 node = self.get_node(tid) self.__root_update(tid,inroot) self.emit("task-modified-inview", tid) for c in node.get_... | def __update_node(self,tid,inroot): todis = self.__is_displayed(tid) curdis = self.is_displayed(tid) if todis: #if the task was not displayed previously but now should #we add it. if not curdis: |
node = self.get_node(tid) self.update_count += 1 node = self.get_node(tid) self.__root_update(tid,inroot) self.emit("task-modified-inview", tid) for c in node.get_children(): self.__update_node(c,False) else: if curdis: self.__remove_node(tid) else: self.emit("task-deleted-inview", tid) | if curdis: self.__remove_node(tid) else: self.emit("task-deleted-inview", tid) | def __update_node(self,tid,inroot): todis = self.__is_displayed(tid) curdis = self.is_displayed(tid) if todis: #if the task was not displayed previously but now should #we add it. if not curdis: |
isroot = False if tid in self.displayed_nodes: isroot = self.__is_root(self.get_node(tid)) self.remove_count += 1 self.__nodes_count -= 1 self.emit('task-deleted-inview',tid) self.__root_update(tid,False) self.displayed_nodes.remove(tid) self.__reset_cache() parent = self.node_parents(self.get_node(tid)) if not isro... | if tid not in self.node_to_remove: self.node_to_remove.append(tid) isroot = False if tid in self.displayed_nodes: isroot = self.__is_root(self.get_node(tid)) self.remove_count += 1 self.__nodes_count -= 1 self.emit('task-deleted-inview',tid) self.__root_update(tid,False) self.displayed_nodes.remove(tid) self.__reset_ca... | def __remove_node(self,tid): isroot = False if tid in self.displayed_nodes: isroot = self.__is_root(self.get_node(tid)) self.remove_count += 1 self.__nodes_count -= 1 self.emit('task-deleted-inview',tid) self.__root_update(tid,False) self.displayed_nodes.remove(tid) self.__reset_cache() #Test if this is necessary paren... |
if node.has_parent(): parent_node = get_parents()[0] next_idx = parent_node.get_child_index(node.get_id()) + 1 if parent_node.get_n_children()-1 < next_idx: return None else: return parent_node.get_nth_child(next_idx) else: return None | if node: tid = node.get_id() parent_node = node.get_parent() if not parent_node: parent_node = self.tree.get_root() try: idx = parent_node.get_child_index(tid) + 1 nextnode = parent_node.get_nth_child(idx) except ValueError: nextnode = None else: nextnode = root return nextnode | def on_iter_next(self, node): if node.has_parent(): parent_node = get_parents()[0] next_idx = parent_node.get_child_index(node.get_id()) + 1 if parent_node.get_n_children()-1 < next_idx: return None else: return parent_node.get_nth_child(next_idx) else: return None |
self.row_inserted(tag_path, tag_iter) | self.tree.print_tree() | def add_tag(self, sender, tname): |
if type(self.task.task) != list: return self.task.task.id else: return self.task.task[0].id else: return self.task.id | if type(self.task.task) == type(list): return getattr(self.task.task[0], attr) else: return getattr(self.task.task, attr) else: return getattr(self.task, attr) | def _get_id(self): if hasattr(self.task, 'task'): if type(self.task.task) != list: return self.task.task.id else: return self.task.task[0].id else: return self.task.id |
if hasattr(self.task, 'task'): return self.get_proxy()._rtm_to_gtg_status[self.task.task.completed\ == ""] else: return self.get_proxy()._rtm_to_gtg_status[self.task.completed == ""] | completed = self.__get_rtm_task_attribute("completed") return self.get_proxy()._rtm_to_gtg_status[completed == ""] | def _get_status(self): if hasattr(self.task, 'task'): return self.get_proxy()._rtm_to_gtg_status[self.task.task.completed\ == ""] else: return self.get_proxy()._rtm_to_gtg_status[self.task.completed == ""] |
task_to_scroll_to = None | def update_start_date(self, widget, new_start_date): task_to_scroll_to = None tasks_uid = filter(lambda uid: uid != None, self.get_selected_tasks()) if len(tasks_uid) == 0: return tasks = [self.req.get_task(uid) for uid in tasks_uid] tasks_status = [task.get_status() for task in tasks] for uid, task, status in zip(task... | |
task_to_scroll_to = uid if task_to_scroll_to != None: gobject.idle_add(self.ctask_tv.scroll_to_task, task_to_scroll_to) | def update_start_date(self, widget, new_start_date): task_to_scroll_to = None tasks_uid = filter(lambda uid: uid != None, self.get_selected_tasks()) if len(tasks_uid) == 0: return tasks = [self.req.get_task(uid) for uid in tasks_uid] tasks_status = [task.get_status() for task in tasks] for uid, task, status in zip(task... | |
new_subtask_mi = self.builder.get_object("new_subtask_mi") | self.new_subtask_mi = self.builder.get_object("new_subtask_mi") | def _init_accelerators(self): |
new_subtask_mi.add_accelerator("activate", agr, key, mod,\ | self.new_subtask_mi.add_accelerator("activate", agr, key, mod,\ | def _init_accelerators(self): |
mark_done_mi = self.builder.get_object('mark_done_mi') | self.mark_done_mi = self.builder.get_object('mark_done_mi') | def _init_accelerators(self): |
mark_done_mi.add_accelerator( | self.mark_done_mi.add_accelerator( | def _init_accelerators(self): |
task_dismiss = self.builder.get_object('task_dismiss') | self.dismiss_mi = self.builder.get_object('task_dismiss') | def _init_accelerators(self): |
task_dismiss.add_accelerator( | self.dismiss_mi.add_accelerator( | def _init_accelerators(self): |
def connect_changed_signals(self): selection = self.task_tv.get_selection() closed_selection = self.ctask_tv.get_selection() selection.connect("changed", self.on_task_cursor_changed) closed_selection.connect("changed", self.on_taskdone_cursor_changed) | def general_refresh(self): if self.logger: self.logger.debug("Trigger refresh on taskbrowser.") self.tag_modelfilter.refilter() self.task_modelfilter.refilter() | |
self.connect_changed_signals() | def main(self): | |
rowref = self.get_iter(node_path) if data == 'add': self.row_inserted(node_path, rowref) else: self.row_changed(node_path, rowref) if self.tree.node_has_child(tid): self.row_has_child_toggled(node_path, rowref) | if tid == self.tree.get_node_for_path(node_path): rowref = self.get_iter(node_path) if data == 'add': self.row_inserted(node_path, rowref) else: self.row_changed(node_path, rowref) if self.tree.node_has_child(tid): self.row_has_child_toggled(node_path, rowref) | def update_task(self, tid,paths,data=None): |
if not dleft: | if dleft == None: | def on_get_value(self, rowref, column): node = self.tree.get_node_for_rowref(rowref) if not node: return None else: task = node.get_obj() if column == COL_TID: return task.get_id() elif column == COL_OBJ: return task elif column == COL_TITLE: return saxutils.escape(task.get_title()) elif column == COL_SDATE: return s... |
if dleft == 1: | elif dleft == 1: | def on_get_value(self, rowref, column): node = self.tree.get_node_for_rowref(rowref) if not node: return None else: task = node.get_obj() if column == COL_TID: return task.get_id() elif column == COL_OBJ: return task elif column == COL_TITLE: return saxutils.escape(task.get_title()) elif column == COL_SDATE: return s... |
if dleft == 0: | elif dleft == 0: | def on_get_value(self, rowref, column): node = self.tree.get_node_for_rowref(rowref) if not node: return None else: task = node.get_obj() if column == COL_TID: return task.get_id() elif column == COL_OBJ: return task elif column == COL_TITLE: return saxutils.escape(task.get_title()) elif column == COL_SDATE: return s... |
if dleft == -1: | elif dleft == -1: | def on_get_value(self, rowref, column): node = self.tree.get_node_for_rowref(rowref) if not node: return None else: task = node.get_obj() if column == COL_TID: return task.get_id() elif column == COL_OBJ: return task elif column == COL_TITLE: return saxutils.escape(task.get_title()) elif column == COL_SDATE: return s... |
if dleft < -1: | elif dleft < -1: | def on_get_value(self, rowref, column): node = self.tree.get_node_for_rowref(rowref) if not node: return None else: task = node.get_obj() if column == COL_TID: return task.get_id() elif column == COL_OBJ: return task elif column == COL_TITLE: return saxutils.escape(task.get_title()) elif column == COL_SDATE: return s... |
if dleft > 1 and dleft <= 15: | elif dleft > 1 and dleft <= 15: | def on_get_value(self, rowref, column): node = self.tree.get_node_for_rowref(rowref) if not node: return None else: task = node.get_obj() if column == COL_TID: return task.get_id() elif column == COL_OBJ: return task elif column == COL_TITLE: return saxutils.escape(task.get_title()) elif column == COL_SDATE: return s... |
self.row_inserted(node_path, node_iter) if self.tree.node_has_child(task): self.row_has_child_toggled(node_path,node_iter) | if self.iter_is_valid(node_iter): self.row_inserted(node_path, node_iter) if self.tree.node_has_child(task): self.row_has_child_toggled(node_path,node_iter) | def add_tasks(self): #self.lock = True while len(self.tasks_to_add) > 0: tid = self.tasks_to_add.pop() task = self.tree.get_node(tid) if task: node_paths = self.tree.get_paths_for_node(task) for node_path in node_paths: node_iter = self.get_iter(node_path) self.row_inserted(node_path, node_iter) #following is mandatory... |
ids = [None] | ids = [] | def get_selected_tasks(self, tv=None): """Returns a list of 'uids' of the selected tasks, and the corresponding iters |
def __init__(self,req): | MAXIMUM_TIDS_TO_SHOW = 20 def __init__(self, req): | def __init__(self,req): self.req = req self.tids_todelete = [] # Load window tree self.builder = gtk.Builder() self.builder.add_from_file(ViewConfig.DELETE_GLADE_FILE) signals = { "on_delete_confirm": self.on_delete_confirm, "on_delete_cancel": lambda x: x.hide,} self.builder.connect_signals(signals) |
tb_Taskbutton = gtk.ToolButton(tb_Taskicon) tb_Taskbutton.set_label("Send via email") tb_Taskbutton.connect('clicked', self.onTbTaskButton, plugin_api) self.task_separator = plugin_api.add_task_toolbar_item(gtk.SeparatorToolItem()) self.tb_Taskbutton = plugin_api.add_task_toolbar_item(tb_Taskbutton) | self.tb_Taskbutton = gtk.ToolButton(tb_Taskicon) self.tb_Taskbutton.set_label("Send via email") self.tb_Taskbutton.connect('clicked', self.onTbTaskButton, plugin_api) self.task_separator = gtk.SeparatorToolItem() plugin_api.add_task_toolbar_item(self.task_separator) plugin_api.add_task_toolbar_item(self.tb_Taskbutton) | def onTaskOpened(self, plugin_api): # add a item (button) to the ToolBar tb_Taskicon = gtk.Image() tb_Taskicon.set_from_icon_name('mail-send', 32) tb_Taskicon.show() tb_Taskbutton = gtk.ToolButton(tb_Taskicon) tb_Taskbutton.set_label("Send via email") tb_Taskbutton.connect('clicked', self.onTbTaskButton, plugin_api) se... |
plugin_api.remove_task_toolbar_item(self.task_separator) plugin_api.remove_task_toolbar_item(self.tb_Taskbutton) | if hasattr(self, "task_separator"): plugin_api.remove_task_toolbar_item(self.task_separator) if hasattr(self, "tb_Taskbutton"): print self.tb_Taskbutton plugin_api.remove_task_toolbar_item(self.tb_Taskbutton) print "ciao" | def deactivate(self, plugin_api): #everything should be removed, in case a task is currently opened plugin_api.remove_task_toolbar_item(self.task_separator) plugin_api.remove_task_toolbar_item(self.tb_Taskbutton) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.