Beispiel #1
0
 def fastAddLastChild(self, parent_v, gnxString):
     '''
     Create new VNode as last child of the receiver.
     If the gnx exists already, create a clone instead of new VNode.
     '''
     trace = False and not g.unitTesting
     c = self.c
     indices = g.app.nodeIndices
     gnxString = g.toUnicode(gnxString)
     gnxDict = c.fileCommands.gnxDict
     if gnxString is None: v = None
     else: v = gnxDict.get(gnxString)
     is_clone = v is not None
     if trace: g.trace(
         'clone', '%-5s' % (is_clone),
         'parent_v', parent_v, 'gnx', gnxString, 'v', repr(v))
     if is_clone:
         pass
     else:
         if gnxString:
             assert g.isUnicode(gnxString)
             v = leoNodes.VNode(context=c, gnx=gnxString)
             if g.trace_gnxDict: g.trace(c.shortFileName(), gnxString, v)
         else:
             v = leoNodes.VNode(context=c)
             # This is not an error: it can happen with @auto nodes.
             # g.trace('**** no gnx for',v,parent_v)
     child_v = v
     child_v._linkAsNthChild(parent_v, parent_v.numberOfChildren())
     child_v.setVisited() # Supress warning/deletion of unvisited nodes.
     return is_clone, child_v
Beispiel #2
0
    def connect (self,fname):

        '''Connect to the server.  Return True if the connection was established.'''

        trace = False and not g.unitTesting

        if trace: g.trace(fname,socket)

        if hasattr(socket,'AF_UNIX'):
            try:
                # pylint: disable=E1101
                # E1101:LProtoClient.connect: Module 'socket' has no 'AF_UNIX' member
                self.socket = socket.socket(socket.AF_UNIX,socket.SOCK_STREAM)
                self.socket.connect(fname)
                return True
            except Exception:
                g.es_print('lproto.py: failed to connect!',fname)
                g.es_exception(full=False,c=None)
                return False
        else:
            try:
                host = '172.16.0.0' # host is a local address.
                port = 1
                self.socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                self.socket.connect((host,port),)
                self.socket.connect(fname)
                return True
            except Exception:
                g.es_print('lproto.py: failed to connect! host: %s, port: %s' % (
                    host,port))
                g.es_exception(full=False,c=None)
                return False
Beispiel #3
0
 def must_update (self,keywords):
     
     '''Return True if we must update the rendering pane.'''
     pc = self
     c,p = pc.c,pc.c.p
     if g.unitTesting:
         return False
     if keywords.get('force'):
         pc.active = True
         if trace: g.trace('force: activating')
         return True
     if c != keywords.get('c') or not pc.active:
         if trace: g.trace('not active')
         return False
     if pc.locked:
         if trace: g.trace('locked')
         return False
     if pc.gnx != p.v.gnx:
         if trace: g.trace('changed node')
         return True
     if len(p.b) != pc.length:
         if trace: g.trace('text changed')
         return True
     # This will be called at idle time.
     # if trace: g.trace('no change')
     return False
Beispiel #4
0
 def reportChangedClone(self, child_v, b, h, gnx):
     trace = (False or g.app.debug) and not g.unitTesting
     c = self.c
     fileName = c.cacheListFileName
     old, new = child_v.b, b
     same = (
         old == new or
         new.endswith('\n') and old == new[: -1] or
         old.endswith('\n') and new == old[: -1])
     # if trace and not same:
     if trace and (not same or h == 'writeException'):
         g.trace('same %s old %s new %s %s %s' % (
             same, len(old), len(new), h, fileName))
     # This would make it impossible to clear nodes!
     # if not new: return same
     if same: return
     c.nodeConflictList.append(g.bunch(
         tag='(cached)',
         fileName=fileName,
         gnx=gnx,
         b_old=child_v.b,
         h_old=child_v.h,
         b_new=b,
         h_new=h,
     ))
     # Always issue the warning.
     g.error("cached read node changed:", child_v.h)
     child_v.h, child_v.b = h, b
     child_v.setDirty()
     c.changed = True # Tell getLeoFile to propegate dirty nodes.
Beispiel #5
0
 def update_graphics_script (self,s,keywords):
     '''Update the graphics script in the vr pane.'''
     pc = self ; c = pc.c
     force = keywords.get('force')
     if pc.gs and not force:
         return
     if not pc.gs:
         splitter = c.free_layout.get_top_splitter()
         # Careful: we may be unit testing.
         if not splitter:
             g.trace('no splitter')
             return
         # Create the widgets.
         pc.gs = QtWidgets.QGraphicsScene(splitter)
         pc.gv = QtWidgets.QGraphicsView(pc.gs)
         w = pc.gv.viewport() # A QWidget
         # Embed the widgets.
         def delete_callback():
             for w in (pc.gs,pc.gv):
                 w.deleteLater()
             pc.gs = pc.gv = None
         pc.embed_widget(w,delete_callback=delete_callback)
     c.executeScript(
         script=s,
         namespace={'gs':pc.gs,'gv':pc.gv})
Beispiel #6
0
 def next_place(self, s, offset=0):
     """
     Given string s containing a placeholder like <| block |>,
     return (s2,start,end) where s2 is s without the <| and |>,
     and start, end are the positions of the beginning and end of block.
     """
     trace = False
     c = self.c
     new_pos = s.find(c.abbrev_place_start, offset)
     new_end = s.find(c.abbrev_place_end, offset)
     if (new_pos < 0 or new_end < 0) and offset:
         new_pos = s.find(c.abbrev_place_start)
         new_end = s.find(c.abbrev_place_end)
         if not (new_pos < 0 or new_end < 0):
             g.es("Found placeholder earlier in body")
     if new_pos < 0 or new_end < 0:
         if trace: g.trace('new_pos', new_pos, 'new_end', new_end)
         return s, None, None
     start = new_pos
     place_holder_delim = s[new_pos: new_end + len(c.abbrev_place_end)]
     place_holder = place_holder_delim[
         len(c.abbrev_place_start): -len(c.abbrev_place_end)]
     s2 = s[: start] + place_holder + s[start + len(place_holder_delim):]
     end = start + len(place_holder)
     if trace: g.trace(start, end, g.callers())
     return s2, start, end
Beispiel #7
0
def viewrendered(event):
    """Open render view for commander"""
    c = event.get('c')
    if not c:
        return None
    global controllers
    vr = controllers.get(c.hash())
    if vr:
        if trace: g.trace('** controller exists: %s' % (vr))
        vr.show()
    else:
        controllers[c.hash()] = vr = ViewRenderedController(c)
        if trace: g.trace('** new controller: %s' % (vr))
        if hasattr(c,'free_layout'):
            vr._ns_id = '_leo_viewrendered'  # for free_layout load/save
            splitter = c.free_layout.get_top_splitter()
            # Careful: we may be unit testing.
            if splitter:
                ok = splitter.add_adjacent(vr,'bodyFrame','right-of')
                if not ok:
                    splitter.insert(0, vr)
        else:
            vr.setWindowTitle("Rendered View")
            vr.resize(600, 600)
            vr.show()
    c.bodyWantsFocusNow()
    # The following conflicts with F11: help-for-command.
    # I'm not sure why it was needed, but for sure it can not be used.
        # def at_idle(c=c):
        #    c.bodyWantsFocusNow()
        # QtCore.QTimer.singleShot(0,at_idle)
    return vr
Beispiel #8
0
 def find_parent(self, level, h):
     '''
     Return the parent at the indicated level, allocating
     place-holder nodes as necessary.
     '''
     assert level >= 0
     while level < len(self.stack):
         self.stack.pop()
     top = self.stack[-1]
     if 1: # Experimental fix for #877.
         if level > len(self.stack):
             print('')
             g.trace('Unexpected markdown level for: %s' % h)
             print('')
         while level > len(self.stack):
             child = self.create_child_node(
                 parent = top,
                 body = None,
                 headline = 'INSERTED NODE'
             )
             self.stack.append(child)
     assert level == len(self.stack), (level, len(self.stack))
     child = self.create_child_node(
         parent = top,
         body = None,
         headline = h, # Leave the headline alone
     )
     self.stack.append(child)
     assert self.stack
     assert 0 <= level < len(self.stack), (level, len(self.stack))
     return self.stack[level]
Beispiel #9
0
    def redraw(self):
        "redraw after menu used"

        g.trace(g.callers())

        # IMPORTANT ASSUMPTION: called only after menu used

        # read updates from menu choice

        # Tk seems to use menu label when '' is used as value?
        # note, keys not present if coming via clear_all
        if self.pickles.has_key('node'):
            if self.pickles['node'].get() == 'CLEO_BLANK': self.pickles['node'].set('')
        if self.pickles.has_key('archetype'):
            if self.pickles['archetype'].get() == 'CLEO_BLANK': self.pickles['archetype'].set('')

        for ky, vl in self.pickles.iteritems():
            self.setat(self.pickleV, ky, vl.get())

        self.loadIcons(self.pickleP)

        self.clear_marks(self.c.frame.tree.canvas)
        self.update_project(self.pickleP)
        c = self.c
        c.setChanged(True)
        c.redraw_now()
Beispiel #10
0
 def put_sentinels(self,i):
     '''Put all the sentinels to the results'''
     x = self
     if 0 <= i < len(x.sentinels):
         sentinels = x.sentinels[i] 
         if x.trace: g.trace('%3s %s' % (i,sentinels))
         x.results.extend(sentinels)
Beispiel #11
0
    def skip_possible_regex(self, s, i):
        '''look ahead for a regex /'''
        trace = False and not g.unitTesting
        if trace: g.trace(repr(s))
        assert s[i] in '=(', repr(s[i])
        i += 1
        while i < len(s) and s[i] in ' \t':
            i += 1
        if i < len(s) and s[i] == '/':
            i += 1
            while i < len(s):
                progress = i
                ch = s[i]
                # g.trace(repr(ch))
                if ch == '\\':
                    i += 2
                elif ch == '/':
                    i += 1
                    break
                else:
                    i += 1
                assert progress < i

        if trace: g.trace('returns', i, s[i] if i < len(s) else '')
        return i-1
Beispiel #12
0
 def parse_body(self,p):
     
     body = self.untangle(p) # body is the script in p's body.
     # print("Body")
     # print(body)
     if self.trace and self.verbose: g.trace('pass1',p.h,'\n',body)
     self.d ['p'] = p.copy()
     backop = None
     segs = re.finditer('^(@x (.*))$',body,re.MULTILINE)
     for mo in segs:
         op = mo.group(2).strip()
         # print("Oper",op)
         if op.startswith('='):
             # print("Assign", op)
             backop = ('=', op.rstrip('{').lstrip('='), mo.end(1))
         elif op == '{':
             backop = ('runblock', mo.end(1))
         elif op == '}':
             bo = backop[0]
             # print("backop",bo)
             if bo == '=':
                 self.let_body(backop[1].strip(), body[backop[2] : mo.start(1)])
             elif bo == 'runblock':
                 self.runblock(body[backop[1] : mo.start(1)])
         else:
             self.runblock(op)
Beispiel #13
0
    def propagate_changed_lines(self,new_public_lines,old_private_lines,marker,p=None):
        #@+<< docstring >>
        #@+node:ekr.20150207044400.9: *5*  << docstring >>
        '''
        The Mulder update algorithm, revised by EKR.

        Use the diff between the old and new public lines to insperse sentinels
        from old_private_lines into the result.

        The algorithm never deletes or rearranges sentinels. However, verbatim
        sentinels may be inserted or deleted as needed.
        '''
        #@-<< docstring >>
        x = self
        trace = (False or x.trace) and g.unitTesting
        x.init_ivars(new_public_lines,old_private_lines,marker)
        sm = difflib.SequenceMatcher(None,x.a,x.b)
        if trace: x.dump_args()
        # Ensure leading sentinels are put first.
        x.put_sentinels(0)
        x.sentinels[0] = []
        for tag,ai,aj,bi,bj in sm.get_opcodes():
            if trace: g.trace('%3s %s' % (ai,tag))
            f = x.dispatch_dict.get(tag,x.op_bad)
            f(tag,ai,aj,bi,bj)
        # Put the trailing sentinels & check the result.
        x.results.extend(x.trailing_sentinels)
        # check_output is likely to be more buggy than the code under test.
        # x.check_output()
        if trace: x.dump_lines(x.results,'results')
        return x.results
Beispiel #14
0
 def starts_block(self, i, lines, new_state, prev_state, stack):
     '''True if the line startswith class or def outside any context.'''
     # pylint: disable=arguments-differ
     trace = False and not g.unitTesting
     if prev_state.in_context():
         return False
     line = lines[i]
     m = self.starts_pattern.match(line)
     if not m:
         return False
     top = stack[-1]
     prev_indent = top.state.indent
     if top.kind == 'None' and new_state.indent > 0:
         # Underindented top-level class/def.
         return False
     elif top.kind == 'def' and new_state.indent > prev_indent:
         # class/def within a def.
         return False
     elif top.at_others_flag and new_state.indent > prev_indent:
         return False
     else:
         if trace and new_state.indent > prev_indent:
             g.trace(prev_indent, new_state.indent, repr(line))
             g.trace('@others', top.at_others_flag)
         return True
Beispiel #15
0
    def skip_block(self, i, index, lines, prev_state, stack):
        '''
        Find the end of a class/def starting at index
        on line i of lines.

        Return (kind, i, j), where kind in (None, 'class', 'def')
        .'''
        trace = True and not g.unitTesting
        index1 = index
        line = lines[i]
        kind = 'class' if line.strip().startswith('class') else 'def'
        i += 1
        while i < len(lines):
            progress = i
            line = lines[i]
            index += len(line)
            new_state = self.scan_line(line, prev_state)
            top = stack[-1]
            if trace: g.trace('new level', new_state.level(), 'line', line)
            # Similar to self.ends_block.
            if (not self.is_ws_line(line) and
                not prev_state.in_context() and
                new_state.level() <= top.state.level()
            ):
                return kind, index1, index
            prev_state = new_state
            i += 1
            assert progress < i
        return None, -1, -1
    def split(self,index,side,w=None,name=None):
        """replace the adjacent widget with a NestedSplitter containing
        the widget and an Action button"""

        trace = False and g and not g.unitTesting

        sizes = self.sizes()

        old = self.widget(index+side-1)
        #X old_name = old and old.objectName() or '<no name>'
        #X splitter_name = self.objectName() or '<no name>'

        if w is None:
            w = NestedSplitterChoice(self)

        if isinstance(old, NestedSplitter):
            old.addWidget(w)
            old.equalize_sizes()
            #X index = old.indexOf(w)
            #X return old,index # For viewrendered plugin.
        else:
            orientation = self.other_orientation[self.orientation()]
            new = NestedSplitter(self, orientation=orientation, root=self.root)
            #X if name: new.setObjectName(name)
            self.insertWidget(index+side-1, new)
            new.addWidget(old)
            new.addWidget(w)
            new.equalize_sizes()
            #X index = new.indexOf(w)
            #X return new,index # For viewrendered plugin.

        if trace: g.trace('name: %s index: %s side: %s w: %s' % (
            name,index,side,w))

        self.setSizes(sizes)
Beispiel #17
0
 def unhide(self, all=False):
     trace = False and not g.unitTesting
     c = self.c
     w = c.frame.body.widget
     cursor = w.textCursor()
     cfmt = cursor.charFormat()
     if cfmt.fontPointSize() == self.pts or all:
         if trace: g.trace()
         if all:
             cursor.setPosition(0)
             cursor.setPosition(len(w.toPlainText()), cursor.KeepAnchor)
         else:
             end = cursor.position()
             # move left to find left end of range
             while (
                 cursor.movePosition(cursor.PreviousCharacter) and
                 cursor.charFormat().fontPointSize() == self.pts
             ):
                 pass
             start = cursor.position()
             # move right to find left end of range
             cursor.setPosition(end)
             while (
                 cursor.movePosition(cursor.NextCharacter) and
                 cursor.charFormat().fontPointSize() == self.pts
             ):
                 pass
             # select range and restore normal size
             cursor.setPosition(start, cursor.KeepAnchor)
         # Common code.
         cfmt.setFontPointSize(self.size)
         cfmt.setFontLetterSpacing(100)
         cursor.setCharFormat(cfmt)
Beispiel #18
0
    def check_the_final_output(self, new_private_lines, new_public_lines, sentinel_lines, marker):
        """
        Check that we produced a valid output.

        Input:
            new_targetlines:   the lines with sentinels which produce changed_lines_without_sentinels.
            sentinels:         new_targetlines should include all the lines from sentinels.

        checks:
            1. new_targetlines without sentinels must equal changed_lines_without_sentinels.
            2. the sentinel lines of new_targetlines must match 'sentinels'
        """
        new_public_lines2, new_sentinel_lines2 = self.separate_sentinels(
            new_private_lines, marker)

        lines1 = new_public_lines
        lines2 = new_public_lines2
        sents1 = sentinel_lines
        sents2 = new_sentinel_lines2
        if 1: # Ignore trailing ws:
            s1 = ''.join(lines1).rstrip()
            s2 = ''.join(lines2).rstrip()
            lines1 = g.splitLines(s1)
            lines2 = g.splitLines(s2)
        if 1: # Ignore trailing ws on every line.
            lines1 = [z.rstrip() for z in lines1]
            lines2 = [z.rstrip() for z in lines2]
            sents1 = [z.rstrip() for z in sents1]
            sents2 = [z.rstrip() for z in sents2]
        lines_ok = lines1 == lines2
        sents_ok = sents1 == sents2

        if g.unitTesting:
            # The unit test will report the error.
            return lines_ok and sents_ok

        if not lines_ok:
            if 1:
                g.trace()
                d = difflib.Differ()
                # g.trace('Different!!',d)
                aList = list(d.compare(new_public_lines2,new_public_lines))
                pprint.pprint(aList)
            else:
                self.show_error(
                    lines1 = new_public_lines2,
                    lines2 = new_public_lines,
                    message = "Error in updating public file!",
                    lines1_message = "new public lines (derived from new private lines)",
                    lines2_message = "new public lines")

        if not sents_ok:
            self.show_error(
                lines1 = sentinel_lines,
                lines2 = new_sentinel_lines2,
                message = "Sentinals not preserved!",
                lines1_message = "old sentinels",
                lines2_message = "new sentinels")

        return lines_ok and sents_ok
Beispiel #19
0
 def callTagHandler (self,bunch,tag,keywords):
     '''Call the event handler.'''
     trace = False and not g.unitTesting
     traceIdle = True
     handler,moduleName = bunch.fn,bunch.moduleName
     if trace and (traceIdle or tag != 'idle'):
         c = keywords.get('c')
         name = moduleName ; tag2 = 'leo.plugins.'
         if name.startswith(tag2): name = name[len(tag2):]
         g.trace('c: %s %23s : %s . %s' % (
             c and c.shortFileName() or '<no c>',
             tag,handler.__name__,name))
     # Make sure the new commander exists.
     for key in ('c','new_c'):
         c = keywords.get(key)
         if c:
             # Make sure c exists and has a frame.
             if not c.exists or not hasattr(c,'frame'):
                 # g.pr('skipping tag %s: c does not exist or does not have a frame.' % tag)
                 return None
     # Calls to registerHandler from inside the handler belong to moduleName.
     self.loadingModuleNameStack.append(moduleName)
     try:
         result = handler(tag,keywords)
     except Exception:
         g.es("hook failed: %s, %s, %s" % (tag, handler, moduleName))
         g.es_exception()
         result = None
     self.loadingModuleNameStack.pop()
     return result
Beispiel #20
0
 def adjustParent(self, parent, headline):
     '''Return the proper parent of the new node.'''
     trace = False and not g.unitTesting
     level, lastLevel = self.sectionLevel, self.lastSectionLevel
     lastParent = self.lastParent
     if trace: g.trace('**entry level: %s lastLevel: %s lastParent: %s' % (
         level, lastLevel, lastParent and lastParent.h or '<none>'))
     if self.lastParent:
         if level <= lastLevel:
             parent = lastParent.parent()
             while level < lastLevel:
                 level += 1
                 parent = parent.parent()
         else: # level > lastLevel.
             level -= 1
             parent = lastParent
             while level > lastLevel:
                 level -= 1
                 h2 = '@rst-no-head %s' % headline
                 body = ''
                 parent = self.createFunctionNode(h2, body, parent)
     else:
         assert self.root
         self.lastParent = self.root
     if not parent:
         parent = self.root
     if trace: g.trace('level %s lastLevel %s %s returns %s' % (
         level, lastLevel, headline, parent.h))
     #self.lastSectionLevel = self.sectionLevel
     self.lastParent = parent.copy()
     return parent.copy()
Beispiel #21
0
def onCreate(tag, keys):
    '''Create a Tables instance for the outline.'''
    c = keys.get('c')
    if c:
        c.tableController = TableController(c)
    else:
        g.trace('can not create TableController')
Beispiel #22
0
 def dismiss_menu_bar(self):
     m = self; c = m.c
     # c.frame.menu.deactivateMenuBar()
     g.trace()
     menubar = c.frame.top.leo_menubar
     menubar.setActiveAction(None)
     menubar.repaint()
 def undent_coffeescript_body(self, s):
     '''Return the undented body of s.'''
     trace = False and not g.unitTesting and self.root.h.endswith('1.coffee')
     lines = g.splitLines(s)
     if trace:
         g.trace('='*20)
         self.print_lines(lines)
     # Undent all leading whitespace or comment lines.
     leading_lines = []
     for line in lines:
         if self.is_ws_line(line):
             # Tricky.  Stipping a black line deletes it.
             leading_lines.append(line if line.isspace() else line.lstrip())
         else:
             break
     i = len(leading_lines)
     # Don't unindent the def/class line! It prevents later undents.
     tail = self.undent_body_lines(lines[i:], ignoreComments=True)
     # Remove all blank lines from leading lines.
     if 0:
         for i, line in enumerate(leading_lines):
             if not line.isspace():
                 leading_lines = leading_lines[i:]
                 break
     result = ''.join(leading_lines) + tail
     if trace:
         g.trace('-'*20)
         self.print_lines(g.splitLines(result))
     return result
Beispiel #24
0
    def selectChapterByName (self,name,collapse=True,create=True):

        '''Select a chapter.  Return True if a redraw is needed.'''

        trace = False and not g.unitTesting
        cc,c = self,self.c
        if type(name) == type(9):
            return cc.note('PyQt5 chapaters not supported')
        chapter = cc.chaptersDict.get(name)
        if chapter:
            cc.selectChapterByNameHelper(chapter,collapse=collapse)
        elif create:
            # There is an @chapter node, but no actual chapter.
            if trace: g.trace('*** creating',name)
            cc.createChapterByName(name,p=c.p,undoType='Create Chapter')
        else:
            # create is False if called from the minibuffer.
            # do nothing if the user mis-types.
            cc.note('no such chapter: %s' % name)
            chapter = cc.chaptersDict.get('main')
            if chapter:
                self.selectChapterByNameHelper(chapter,collapse=collapse)
            else:
                g.trace(g.callers())
                cc.error('no main chapter!')
 def post_pass(self, parent):
     '''Massage the created nodes.'''
     trace = False and not g.unitTesting and self.root.h.endswith('1.coffee')
     if trace:
         g.trace('='*60)
         for p in parent.self_and_subtree():
             print('***** %s' % p.h)
             g.printList(p.v._import_lines)
     # ===== Generic: use base Importer methods =====
     self.clean_all_headlines(parent)
     self.clean_all_nodes(parent)
     # ===== Specific to coffeescript =====
     #
     self.move_trailing_lines(parent)
     # ===== Generic: use base Importer methods =====
     self.unindent_all_nodes(parent)
     #
     # This sub-pass must follow unindent_all_nodes.
     self.promote_trailing_underindented_lines(parent)
     #
     # This probably should be the last sub-pass.
     self.delete_all_empty_nodes(parent)
     if trace:
         g.trace('-'*60)
         for p in parent.self_and_subtree():
             print('***** %s' % p.h)
             g.printList(p.v._import_lines)
Beispiel #26
0
 def get(self, key, default=None):
     trace = False and g.unitTesting
     if trace: g.trace('(PickleShareDB)')
     try:
         return self[key]
     except KeyError:
         return default
Beispiel #27
0
    def load_states(self):

        if not self.c.db:
            return
        try:
            stored = self.c.db['tabulanotes']
        except KeyError:
            return

        mwstate = stored.pop("mainwindow")
        self.restoreState(mwstate)

        # still think leo should maintain a dict like this.
        # EKR: :-)
        ncache = dict((p.gnx, p.copy()) for p in self.c.all_unique_positions())

        for gnx, geom in stored.items():
            try:
                ncache[gnx]
            except KeyError:
                g.trace("lost note", gnx)
                continue

            n = self.add_note(ncache[gnx])
            n.parent().restoreGeometry(geom)
Beispiel #28
0
 def readFile(self, fileName):
     '''Read the opml file.'''
     dumpTree = False
     if not fileName:
         return g.trace('no fileName')
     c = self.c.new()
         # Create the new commander *now*
         # so that created vnodes will have the proper context.
     # Pass one: create the intermediate nodes.
     dummyRoot = self.parse_opml_file(fileName)
     if not dummyRoot:
         return
     if dumpTree:
         self.dumpTree(dummyRoot)
     # Pass two: create the outline from the sax nodes.
     children = self.createVnodes(c, dummyRoot)
     p = leoNodes.Position(v=children[0], childIndex=0, stack=None)
     # Check the outline.
     errors = c.checkOutline()
     if errors:
         c.dumpOutline()
         return g.trace('%s errors!' % errors)
     # if self.opml_read_derived_files:
         # at = c.atFileCommands
         # c.fileCommands.tnodesDict = self.createTnodesDict()
         # self.resolveTnodeLists(c)
         # if self.opml_read_derived_files:
             # c.atFileCommands.readAll(c.rootPosition())
     c.selectPosition(p)
     c.redraw()
     return c # for testing.
Beispiel #29
0
    def __init__(self, root):
        """
        Init the PickleShareDB class.
        root: The directory that contains the data. Created if it doesn't exist.
        """
        trace = False and not g.unitTesting
        self.root = abspath(expanduser(root))
        if trace: g.trace('PickleShareDB', self.root)
        if not isdir(self.root) and not g.unitTesting:
            self._makedirs(self.root)
        self.cache = {}
            # Keys are normalized file names.
            # Values are tuples (obj, orig_mod_time)

        def loadz(fileobj):
            if fileobj:
                val = pickle.loads(
                    zlib.decompress(fileobj.read()))
                return val
            else:
                return None

        def dumpz(val, fileobj):
            if fileobj:
                compressed = zlib.compress(pickle.dumps(
                    val, pickle.HIGHEST_PROTOCOL))
                fileobj.write(compressed)

        self.loader = loadz
        self.dumper = dumpz
Beispiel #30
0
 def image(self, pane, fn, center=None, height=None, width=None):
     '''Put an image in the indicated pane.'''
     m = self
     parent = m.pane_widget(pane)
     if parent:
         w = QtGui.QLabel('label', parent)
         fn = m.resolve_icon_fn(fn)
         if not fn: return None
         pixmap = QtGui.QPixmap(fn)
         if not pixmap:
             return g.trace('Not a pixmap: %s' % (fn))
         if height:
             pixmap = pixmap.scaledToHeight(height)
         if width:
             pixmap = pixmap.scaledToWidth(width)
         w.setPixmap(pixmap)
         if center:
             g_w = w.geometry()
             g_p = parent.geometry()
             dx = (g_p.width() - g_w.width()) / 2
             w.move(g_w.x() + dx, g_w.y() + 10)
         w.show()
         m.widgets.append(w)
         return w
     else:
         g.trace('bad pane: %s' % (pane))
         return None
Beispiel #31
0
    def expandAbbrev(self, event, stroke):
        '''
        Not a command.  Called from k.masterCommand to expand
        abbreviations in event.widget.

        Words start with '@'.
        '''
        trace = False and not g.unitTesting
        verbose = True
        c, p = self.c, self.c.p
        w = self.editWidget(event, forceFocus=False)
        w_name = g.app.gui.widget_name(w)
        if not w:
            return False
        ch = self.get_ch(event, stroke, w)
        if not ch: return False
        if trace and verbose:
            g.trace('ch: %5r stroke.s: %12r w: %s %s %s' % (
                ch, stroke and stroke.s, id(w), w_name , p.h))
        s, i, j, prefixes = self.get_prefixes(w)
        for prefix in prefixes:
            i, tag, word, val = self.match_prefix(ch, i, j, prefix, s)
            if word:
                # Fix another part of #438.
                if w_name.startswith('head'):
                    if val == '__NEXT_PLACEHOLDER':
                        i = w.getInsertPoint()
                        if i > 0:
                            w.delete(i-1)
                            p.h = w.getAllText()
                    # Do not call c.endEditing here.
                if trace: g.trace('FOUND tag: %r word: %r' % (tag, word))
                break
        else:
            return False
        # 448: Add abbreviations for commands.
        if 0: # This is not worth documenting.
            val, tag = self.abbrevs.get(word, (None, None))
            if val and c.k.commandExists(val):
                if trace: g.trace(word, '==>', val)
                # Execute the command directly, so as not to call this method recursively.
                commandName = val
                func = c.commandsDict.get(commandName)
                c.doCommand(func, commandName, event)
                return
        c.abbrev_subst_env['_abr'] = word
        if tag == 'tree':
            self.root = p.copy()
            self.last_hit = p.copy()
            self.expand_tree(w, i, j, val, word)
        else:
            # Never expand a search for text matches.
            place_holder = '__NEXT_PLACEHOLDER' in val
            if place_holder:
                expand_search = bool(self.last_hit)
            else:
                self.last_hit = None
                expand_search = False
            if trace:
                g.trace('expand_search: %s last_hit: %s' % (
                    expand_search, self.last_hit and self.last_hit.h))
            self.expand_text(w, i, j, val, word, expand_search)
            # Restore the selection range.
            if self.save_ins:
                if trace:  g.trace('RESTORE sel: %s ins: %s' % (
                    self.save_sel, self.save_ins))
                ins = self.save_ins
                # pylint: disable=unpacking-non-sequence
                sel1, sel2 = self.save_sel
                if sel1 == sel2:
                    # New in Leo 5.5
                    self.post_pass()
                else:
                    # some abbreviations *set* the selection range
                    # so only restore non-empty ranges
                    w.setSelectionRange(sel1, sel2, insert=ins)
        return True
Beispiel #32
0
    def selectChapterForPosition(self, p, chapter=None):
        '''
        Select a chapter containing position p.
        New in Leo 4.11: prefer the given chapter if possible.
        Do nothing if p if p does not exist or is in the presently selected chapter.

        Note: this code calls c.redraw() if the chapter changes.
        '''
        trace = False and not g.unitTesting
        c, cc = self.c, self
        # New in Leo 4.11
        if cc.selectChapterLockout:
            return
        selChapter = cc.getSelectedChapter()
        if trace:
            g.trace('***', p.h, chapter.name if chapter else None,
                    selChapter.name if selChapter else None, g.callers())
        if not p:
            if trace: g.trace('no p')
            return
        if not c.positionExists(p):
            if trace: g.trace('does not exist', p.h)
            return
        # New in Leo 4.11: prefer the given chapter if possible.
        theChapter = chapter or selChapter
        if not theChapter:
            return
        # First, try the presently selected chapter.
        firstName = theChapter.name
        if firstName == 'main':
            if trace: g.trace('no search: main chapter:', p.h)
            return
        if theChapter.positionIsInChapter(p):
            if trace:
                g.trace('position found in chapter:', theChapter.name, p.h)
            cc.selectChapterByName(theChapter.name)
            return
        for name in cc.chaptersDict:
            if name not in (firstName, 'main'):
                theChapter = cc.chaptersDict.get(name)
                if theChapter.positionIsInChapter(p):
                    if trace: g.trace('select:', theChapter.name)
                    cc.selectChapterByName(name)
                    break
        else:
            if trace: g.trace('select main')
            cc.selectChapterByName('main')
        # Fix bug 869385: Chapters make the nav_qt.py plugin useless
        c.redraw_now()
Beispiel #33
0
 def oops(message):
     g.trace(message)
def report_version():
    try:
        import flake8
        print('flake8 version: %s' % flake8.__version__)
    except ImportError:
        g.trace('can not import flake8')
Beispiel #35
0
def demo_end(self, event=None, chain=False):
    '''End the present demo.'''
    if getattr(g.app, 'demo', None):
        g.app.demo.end()
    else:
        g.trace('no demo instance')
Beispiel #36
0
def prev_command(self, event=None, chain=False):
    '''Run the next demo script.'''
    if getattr(g.app, 'demo', None):
        g.app.demo.prev()
    else:
        g.trace('no demo instance')
Beispiel #37
0
 def make_script_substitutions(self, i, j, val):
     '''Make scripting substitutions in node p.'''
     trace = False and not g.unitTesting
     c = self.c
     if not c.abbrev_subst_start:
         if trace: g.trace('no subst_start')
         return val, False
     # Nothing to undo.
     if c.abbrev_subst_start not in val:
         return val, False
     # Perform all scripting substitutions.
     self.save_ins = None
     self.save_sel = None
     while c.abbrev_subst_start in val:
         prefix, rest = val.split(c.abbrev_subst_start, 1)
         content = rest.split(c.abbrev_subst_end, 1)
         if len(content) != 2:
             break
         content, rest = content
         if trace:
             g.trace('**c', c.shortFileName())
             g.trace('**p', c.p.h)
             g.trace('**content', repr(content))
         try:
             self.expanding = True
             c.abbrev_subst_env['x'] = ''
             exec(content, c.abbrev_subst_env, c.abbrev_subst_env)
         except Exception:
             g.es_print('exception evaluating', content)
         finally:
             self.expanding = False
         x = c.abbrev_subst_env.get('x')
         if x is None: x = ''
         val = "%s%s%s" % (prefix, x, rest)
         # Save the selection range.
         w = c.frame.body.wrapper
         self.save_ins = w.getInsertPoint()
         self.save_sel = w.getSelectionRange()
         if trace: g.trace('sel', self.save_sel, 'ins', self.save_ins)
     if val == "__NEXT_PLACEHOLDER":
         # user explicitly called for next placeholder in an abbrev.
         # inserted previously
         val = ''
         do_placeholder = True
     else:
         do_placeholder = False
         # Huh?
         oldSel = i, j
         c.frame.body.onBodyChanged(undoType='Typing', oldSel=oldSel)
     if trace:
         g.trace(do_placeholder, val)
     return val, do_placeholder
Beispiel #38
0
    def open_temp_file(self, c, d, fn, testing=False):
        '''
        Open a temp file corresponding to fn in an external editor.
        
        d is a dictionary created from an @openwith settings node.

        'args':     the command-line arguments to be used to open the file.
        'ext':      the file extension.
        'kind':     the method used to open the file, such as subprocess.Popen.
        'name':     menu label (used only by the menu code).
        'shortcut': menu shortcut (used only by the menu code).
        '''
        trace = False and not g.unitTesting
        testing = testing or g.unitTesting
        arg_tuple = d.get('args', [])
        arg = ' '.join(arg_tuple)
        kind = d.get('kind')
        try:
            # All of these must be supported because they
            # could exist in @open-with nodes.
            command = '<no command>'
            if kind == 'os.startfile':
                command = 'os.startfile(%s)' % self.join(arg, fn)
                if trace: g.trace(command)
                # pylint: disable=no-member
                # trust the user not to use this option on Linux.
                if not testing: os.startfile(self.join(arg, fn))
            elif kind == 'exec':
                g.es_print('open-with exec no longer valid.')
                # command = 'exec(%s)' % self.join(arg,fn)
                # if trace: g.trace(command)
                # if not testing:
                # exec(self.join(arg,fn),{},{})
            elif kind == 'os.spawnl':
                filename = g.os_path_basename(arg)
                command = 'os.spawnl(%s,%s,%s)' % (arg, filename, fn)
                if trace: g.trace(command)
                if not testing: os.spawnl(os.P_NOWAIT, arg, filename, fn)
            elif kind == 'os.spawnv':
                filename = os.path.basename(arg_tuple[0])
                vtuple = arg_tuple[1:]
                vtuple.insert(0, filename)
                # add the name of the program as the first argument.
                # Change suggested by Jim Sizelove.
                vtuple.append(fn)
                command = 'os.spawnv(%s)' % (vtuple)
                if trace: g.trace(command)
                if not testing:
                    os.spawnv(os.P_NOWAIT, arg[0], vtuple)  #???
            elif kind == 'subprocess.Popen':
                c_arg = self.join(arg, fn)
                command = 'subprocess.Popen(%s)' % c_arg
                if trace: g.trace(command)
                if not testing:
                    try:
                        subprocess.Popen(c_arg, shell=True)
                    except OSError:
                        g.es_print('c_arg', repr(c_arg))
                        g.es_exception()
            elif g.isCallable(kind):
                # Invoke openWith like this:
                # c.openWith(data=[func,None,None])
                # func will be called with one arg, the filename
                if trace: g.trace('%s(%s)' % (kind, fn))
                command = '%s(%s)' % (kind, fn)
                if not testing: kind(fn)
            else:
                command = 'bad command:' + str(kind)
                if not testing: g.trace(command)
            return command  # for unit testing.
        except Exception:
            g.es('exception executing open-with command:', command)
            g.es_exception()
            return 'oops: %s' % command
 def oops():
     g.trace('unknown kind', self.kind)
Beispiel #40
0
    def open_file_in_external_editor(self, c, d, fn, testing=False):
        """
        Open a file fn in an external editor.

        This will be an entire external file, or a temp file for a single node.

        d is a dictionary created from an @openwith settings node.

            'args':     the command-line arguments to be used to open the file.
            'ext':      the file extension.
            'kind':     the method used to open the file, such as subprocess.Popen.
            'name':     menu label (used only by the menu code).
            'p':        the nearest @<file> node, or None.
            'shortcut': menu shortcut (used only by the menu code).
        """
        testing = testing or g.unitTesting
        arg_tuple = d.get('args', [])
        arg = ' '.join(arg_tuple)
        kind = d.get('kind')
        try:
            # All of these must be supported because they
            # could exist in @open-with nodes.
            command = '<no command>'
            if kind in ('os.system', 'os.startfile'):
                # New in Leo 5.7:
                # Use subProcess.Popen(..., shell=True)
                c_arg = self.join(arg, fn)
                if not testing:
                    try:
                        subprocess.Popen(c_arg, shell=True)
                    except OSError:
                        g.es_print('c_arg', repr(c_arg))
                        g.es_exception()
            elif kind == 'exec':
                g.es_print('open-with exec no longer valid.')
            elif kind == 'os.spawnl':
                filename = g.os_path_basename(arg)
                command = f"os.spawnl({arg},{filename},{fn})"
                if not testing:
                    os.spawnl(os.P_NOWAIT, arg, filename, fn)
            elif kind == 'os.spawnv':
                filename = os.path.basename(arg_tuple[0])
                vtuple = arg_tuple[1:]
                # add the name of the program as the first argument.
                # Change suggested by Jim Sizelove.
                vtuple.insert(0, filename)
                vtuple.append(fn)
                command = f"os.spawnv({vtuple})"
                if not testing:
                    os.spawnv(os.P_NOWAIT, arg[0], vtuple)  #???
            elif kind == 'subprocess.Popen':
                c_arg = self.join(arg, fn)
                command = f"subprocess.Popen({c_arg})"
                if not testing:
                    try:
                        subprocess.Popen(c_arg, shell=True)
                    except OSError:
                        g.es_print('c_arg', repr(c_arg))
                        g.es_exception()
            elif hasattr(kind, '__call__'):
                # Invoke openWith like this:
                # c.openWith(data=[func,None,None])
                # func will be called with one arg, the filename
                command = f"{kind}({fn})"
                if not testing:
                    kind(fn)
            else:
                command = 'bad command:' + str(kind)
                if not testing:
                    g.trace(command)
            return command  # for unit testing.
        except Exception:
            g.es('exception executing open-with command:', command)
            g.es_exception()
            return f"oops: {command}"
Beispiel #41
0
 def createCommonButton(self, p, script, rclicks=None):
     '''
     Create a button in the icon area for a common @button node in an @setting
     tree. Binds button presses to a callback that executes the script.
     
     Important: Common @button and @command scripts now *do* update
     dynamically provided that myLeoSettings.leo is open. Otherwise the
     callback executes the static script.
     
     See https://github.com/leo-editor/leo-editor/issues/171
     '''
     trace = False and not g.unitTesting
     c = self.c
     if trace:
         g.trace('global @button IN', c.shortFileName())
         g.trace('FROM:', p.gnx, p.v.context.shortFileName(), p.h)
     gnx = p.gnx
     args = self.getArgs(p)
     # Fix bug #74: problems with @button if defined in myLeoSettings.leo
     docstring = g.getDocString(p.b).strip()
     statusLine = docstring or 'Global script button'
     shortcut = self.getShortcut(p.h)
     # Get the shortcut from the @key field in the headline.
     if shortcut:
         statusLine = '%s = %s' % (statusLine.rstrip(), shortcut)
     # We must define the callback *after* defining b,
     # so set both command and shortcut to None here.
     b = self.createIconButton(
         args=args,
         text=p.h,
         command=None,
         statusLine=statusLine,
         kind='at-button',
     )
     if not b:
         return
     # Now that b is defined we can define the callback.
     # Yes, the callback *does* use b (to delete b if requested by the script).
     buttonText = self.cleanButtonText(p.h)
     cb = AtButtonCallback(
         b=b,
         buttonText=buttonText,
         c=c,
         controller=self,
         docstring=docstring,
         gnx=gnx,
         # tag:#367: the gnx is needed for the Goto Script command.
         # 2018/03/13: Use gnx to search myLeoSettings.leo if it is open.
         script=script,
     )
     # Now patch the button.
     self.iconBar.setCommandForButton(
         button=b,
         command=cb,  # This encapsulates the script.
         command_p=p and p.copy(),  # tag:#567
         controller=self,
         gnx=gnx,  # For the find-button function.
         script=script,
     )
     self.handleRclicks(rclicks)
     # At last we can define the command.
     self.registerAllCommands(args=args,
                              func=cb,
                              h=p.h,
                              pane='button',
                              source_c=p.v.context,
                              tag='@button')
Beispiel #42
0
def init():
    '''Return True if the plugin has loaded successfully.'''
    g.trace('pyplot_backend.py is not a plugin.')
    return False
Beispiel #43
0
    def find_script(self):

        trace = False and not g.unitTesting
        gnx = self.gnx
        # First, search self.c for the gnx.
        if trace:
            g.trace('searching %s for %s' % (self.c.shortFileName(), gnx))
        for p in self.c.all_positions():
            if p.gnx == gnx:
                script = self.controller.getScript(p)
                if trace: g.trace('FOUND', len(script or ''))
                return script
        # See if myLeoSettings.leo is open.
        for c in g.app.commanders():
            if c.shortFileName().endswith('myLeoSettings.leo'):
                break
        else:
            c = None
            if trace: g.trace('myLeoSettings.leo is not open')
        if c:
            # Search myLeoSettings.leo file for the gnx.
            if trace:
                g.trace('searching %s for %s' % (c.shortFileName(), gnx))
            for p in c.all_positions():
                if p.gnx == gnx:
                    script = self.controller.getScript(p)
                    if trace: g.trace('FOUND', len(script or ''))
                    return script
            if trace:
                g.trace('can not find gnx: %s in %s' %
                        (gnx, c.shortFileName()))
        if trace:
            g.trace('Using STATIC script: length: %s' % len(self.script or ''))
            # g.printObj(g.splitLines(self.script or ''))
        return self.script
def test_beautifier(c, h, p, settings):
    '''Test Leo's beautifier code'''
    if not p:
        g.trace('not found: %s' % h)
        return
    s = g.getScript(c,
                    p,
                    useSelectedText=False,
                    forcePythonSentinels=True,
                    useSentinels=False)
    g.trace(h.strip())
    t1 = time.time()
    s1 = g.toEncodedString(s)
    node1 = ast.parse(s1, filename='before', mode='exec')
    t2 = time.time()
    readlines = g.ReadLinesClass(s).next
    tokens = list(tokenize.generate_tokens(readlines))
    t3 = time.time()
    beautifier = PythonTokenBeautifier(c)
    keep_blank_lines = settings.get('tidy-keep-blank-lines')
    if keep_blank_lines is not None:
        beautifier.delete_blank_lines = not keep_blank_lines
    s2 = beautifier.run(tokens)
    t4 = time.time()
    try:
        s2_e = g.toEncodedString(s2)
        node2 = ast.parse(s2_e, filename='before', mode='exec')
        ok = compare_ast(node1, node2)
    except Exception:
        g.es_exception()
        ok = False
    t5 = time.time()
    #  Update the stats
    beautifier.n_input_tokens += len(tokens)
    beautifier.n_output_tokens += len(beautifier.code_list)
    beautifier.n_strings += len(s2)
    beautifier.parse_time += (t2 - t1)
    beautifier.tokenize_time += (t3 - t2)
    beautifier.beautify_time += (t4 - t3)
    beautifier.check_time += (t5 - t4)
    beautifier.total_time += (t5 - t1)
    if settings.get('input_string'):
        print('==================== input_string')
        for i, z in enumerate(g.splitLines(s)):
            print('%4s %s' % (i + 1, z.rstrip()))
    if settings.get('input_lines'):
        print('==================== input_lines')
        dump_tokens(tokens, verbose=False)
    if settings.get('input_tokens'):
        print('==================== input_tokens')
        dump_tokens(tokens, verbose=True)
    if settings.get('output_tokens'):
        print('==================== code_list')
        for i, z in enumerate(beautifier.code_list):
            print('%4s %s' % (i, z))
    if settings.get('output_string'):
        print('==================== output_string')
        for i, z in enumerate(g.splitLines(s2)):
            if z == '\n':
                print('%4s' % (i + 1))
            elif z.rstrip():
                print('%4s %s' % (i + 1, z.rstrip()))
            else:
                print('%4s %r' % (i + 1, str(z)))
    if settings.get('stats'):
        beautifier.print_stats()
    if not ok:
        print('*************** fail: %s ***************' % (h))
    return beautifier
Beispiel #45
0
 def __iter__(self):
     trace = False and g.unitTesting
     if trace: g.trace('(PickleShareDB)', list(self.keys()))
     for k in list(self.keys()):
         yield k
Beispiel #46
0
 def runDebugScriptCommand(self, event=None):
     '''Called when user presses the 'debug-script' button or executes the debug-script command.'''
     c = self.c
     p = c.p
     script = g.getScript(c, p, useSelectedText=True, useSentinels=False)
     if script:
         #@+<< set debugging if debugger is active >>
         #@+node:ekr.20060523084441: *5* << set debugging if debugger is active >>
         g.trace(self.debuggerKind)
         if self.debuggerKind == 'winpdb':
             try:
                 import rpdb2
                 debugging = rpdb2.g_debugger is not None
             except ImportError:
                 debugging = False
         elif self.debuggerKind == 'idle':
             # import idlelib.Debugger.py as Debugger
             # debugging = Debugger.interacting
             debugging = True
         else:
             debugging = False
         #@-<< set debugging if debugger is active >>
         if debugging:
             #@+<< create leoScriptModule >>
             #@+node:ekr.20060524073716: *5* << create leoScriptModule >> (mod_scripting.py)
             target = g.os_path_join(g.app.loadDir, 'leoScriptModule.py')
             f = None
             try:
                 f = open(target, 'w')
                 f.write('# A module holding the script to be debugged.\n')
                 if self.debuggerKind == 'idle':
                     # This works, but uses the lame pdb debugger.
                     f.write('import pdb\n')
                     f.write('pdb.set_trace() # Hard breakpoint.\n')
                 elif self.debuggerKind == 'winpdb':
                     f.write('import rpdb2\n')
                     f.write(
                         'if rpdb2.g_debugger is not None: # don\'t hang if the debugger isn\'t running.\n'
                     )
                     f.write(
                         '  rpdb2.start_embedded_debugger(pwd="",fAllowUnencrypted=True) # Hard breakpoint.\n'
                     )
                 # f.write('# Remove all previous variables.\n')
                 f.write('# Predefine c, g and p.\n')
                 f.write('import leo.core.leoGlobals as g\n')
                 f.write('c = g.app.scriptDict.get("c")\n')
                 f.write(
                     'script_gnx = g.app.scriptDict.get("script_gnx")\n')
                 f.write('p = c.p\n')
                 f.write('# Actual script starts here.\n')
                 f.write(script + '\n')
             finally:
                 if f: f.close()
             #@-<< create leoScriptModule >>
             # pylint: disable=no-name-in-module
             g.app.scriptDict['c'] = c
             g.app.scriptDict = {'script_gnx': p.gnx}
             if 'leoScriptModule' in sys.modules.keys():
                 del sys.modules['leoScriptModule']  # Essential.
             import leo.core.leoScriptModule as leoScriptModule
             assert leoScriptModule  # for pyflakes.
         else:
             g.error('No debugger active')
     c.bodyWantsFocus()
Beispiel #47
0
        def trace(self):

            if self.tracing:

                g.trace("%10s: %s" %
                        (self.name, repr(g.toEncodedString(self.val))))
Beispiel #48
0
 def _makedirs(self, fn, mode=0o777):
     trace = False and not g.unitTesting
     if trace: g.trace(self.root)
     os.makedirs(fn, mode)
Beispiel #49
0
 def endElementNS(self, name, qname):
     g.trace(name)
Beispiel #50
0
 def __contains__(self, key):
     trace = False and g.unitTesting
     if trace: g.trace('(PickleShareDB)', key)
     return self.has_key(key)  # NOQA
Beispiel #51
0
 def skippedEntity(self, name):
     g.trace(name)
def save(self, event=None, fileName=None):
    """Save a Leo outline to a file."""
    if False and g.app.gui.guiName() == 'curses':
        g.trace('===== Save disabled in curses gui =====')
        return
    c = self
    p = c.p
    # Do this now: w may go away.
    w = g.app.gui.get_focus(c)
    inBody = g.app.gui.widget_name(w).startswith('body')
    if inBody:
        p.saveCursorAndScroll()
    if g.unitTesting and g.app.unitTestDict.get('init_error_dialogs') is not None:
        # A kludge for unit testing:
        # indicated that c.init_error_dialogs and c.raise_error_dialogs
        # will be called below, *without* actually saving the .leo file.
        c.init_error_dialogs()
        c.raise_error_dialogs(kind='write')
        return
    if g.app.disableSave:
        g.es("save commands disabled", color="purple")
        return
    c.init_error_dialogs()
    # 2013/09/28: use the fileName keyword argument if given.
    # This supports the leoBridge.
    # Make sure we never pass None to the ctor.
    if fileName:
        c.frame.title = g.computeWindowTitle(fileName)
        c.mFileName = fileName
    if not c.mFileName:
        c.frame.title = ""
        c.mFileName = ""
    if c.mFileName:
        # Calls c.setChanged(False) if no error.
        g.app.syntax_error_files = []
        c.fileCommands.save(c.mFileName)
        c.syntaxErrorDialog()
    else:
        root = c.rootPosition()
        if not root.next() and root.isAtEditNode():
            # There is only a single @edit node in the outline.
            # A hack to allow "quick edit" of non-Leo files.
            # See https://bugs.launchpad.net/leo-editor/+bug/381527
            fileName = None
            # Write the @edit node if needed.
            if root.isDirty():
                c.atFileCommands.writeOneAtEditNode(root) 
            c.setChanged(False)
        else:
            fileName = ''.join(c.k.givenArgs)
            if not fileName:
                fileName = g.app.gui.runSaveFileDialog(c,
                    initialfile=c.mFileName,
                    title="Save",
                    filetypes=[("Leo files", "*.leo *.db"),],
                    defaultextension=g.defaultLeoFileExtension(c))
        c.bringToFront()
        if fileName:
            # Don't change mFileName until the dialog has suceeded.
            c.mFileName = g.ensure_extension(fileName, g.defaultLeoFileExtension(c))
            c.frame.title = c.computeWindowTitle(c.mFileName)
            c.frame.setTitle(c.computeWindowTitle(c.mFileName))
                # 2013/08/04: use c.computeWindowTitle.
            c.openDirectory = c.frame.openDirectory = g.os_path_dirname(c.mFileName)
                # Bug fix in 4.4b2.
            if g.app.qt_use_tabs and hasattr(c.frame, 'top'):
                c.frame.top.leo_master.setTabName(c, c.mFileName)
            c.fileCommands.save(c.mFileName)
            g.app.recentFilesManager.updateRecentFiles(c.mFileName)
            g.chdir(c.mFileName)
    # Done in FileCommands.save.
    # c.redraw_after_icons_changed()
    c.raise_error_dialogs(kind='write')
    # *Safely* restore focus, without using the old w directly.
    if inBody:
        c.bodyWantsFocus()
        p.restoreCursorAndScroll()
    else:
        c.treeWantsFocus()
Beispiel #53
0
 def ignorableWhitespace(self, content):
     g.trace()
Beispiel #54
0
 def startElementNS(self, name, qname, attrs):
     g.trace(name)
Beispiel #55
0
    def get_new_dict(self, context):
        '''
        Return a *general* state dictionary for the given context.
        Subclasses may override...
        '''
        trace = False and g.unitTesting
        comment, block1, block2 = self.single_comment, self.block1, self.block2

        def add_key(d, key, data):
            aList = d.get(key, [])
            aList.append(data)
            d[key] = aList

        if context:
            d = {
                # key    kind   pattern  ends?
                '\\': [
                    ('len+1', '\\', None),
                ],
                '#': [
                    ('len', '###', context == '###'),
                ],
                '"': [
                    ('len', '"', context == '"'),
                ],
                "'": [
                    ('len', "'", context == "'"),
                ],
            }
            if block1 and block2:
                add_key(d, block2[0], ('len', block1, True))
        else:
            # Not in any context.
            d = {
                # key    kind pattern new-ctx  deltas
                '\\': [
                    ('len+1', '\\', context, None),
                ],
                '#': [
                    ('len', '###', '###', None),
                ],  # Docstring
                '"': [
                    ('len', '"', '"', None),
                ],
                "'": [
                    ('len', "'", "'", None),
                ],
                '{': [
                    ('len', '{', context, (1, 0, 0)),
                ],
                '}': [
                    ('len', '}', context, (-1, 0, 0)),
                ],
                '(': [
                    ('len', '(', context, (0, 1, 0)),
                ],
                ')': [
                    ('len', ')', context, (0, -1, 0)),
                ],
                '[': [
                    ('len', '[', context, (0, 0, 1)),
                ],
                ']': [
                    ('len', ']', context, (0, 0, -1)),
                ],
            }
            if comment:
                add_key(d, comment[0], ('all', comment, '', None))
            if block1 and block2:
                add_key(d, block1[0], ('len', block1, block1, None))
        if trace:
            g.trace('created %s dict for %r state ' % (self.name, context))
        return d
Beispiel #56
0
 def processingInstruction(self, target, data):
     g.trace()
Beispiel #57
0
 def unselect(self):
     '''Remember chapter info when a chapter is about to be unselected.'''
     trace = False and not g.unitTesting
     c = self.c
     # Always try to return to the same position.
     if trace:
         g.trace('======================', self)
         # g.trace('main', self.cc.getChapter('main'))
     self.p = c.p
     if self.name == 'main':
         if trace: g.trace(self)
         return
     root = None
     while c.hoistStack:
         bunch = c.hoistStack.pop()
         root = bunch.p
         if root == self.root:
             if trace: g.trace('found', root.h)
             break
     if trace and not root:
         # Not serious. Can be caused by a user de-hoist.
         g.trace('error unselecting', self)
     # Re-institute the previous hoist.
     if c.hoistStack:
         p = c.hoistStack[-1].p
         if trace: g.trace('re-hoist', p.h, c.positionExists(p))
         # Careful: c.selectPosition would pop the hoist stack.
         c.setCurrentPosition(p)
     else:
         if trace: g.trace('empty hoist-stack')
         p = root or c.p
         c.setCurrentPosition(p)
     if trace: g.trace(c.hoistStack)
 def must_update(self, keywords):
     '''Return True if we must update the rendering pane.'''
     pc = self
     c, p = pc.c, pc.c.p
     if g.unitTesting:
         return False
     if keywords.get('force'):
         pc.active = True
         if trace: g.trace('force: activating', p.h)
         return True
     if c != keywords.get('c') or not pc.active:
         if trace: g.trace('not active', p.h)
         return False
     if pc.locked:
         if trace: g.trace('locked', p.h)
         return False
     if pc.gnx != p.v.gnx:
         if trace: g.trace('changed node', p.h)
         return True
     if len(p.b) != pc.length:
         if pc.get_kind(p) in ('html', 'pyplot'):
             if trace: g.trace('html or pyplot text changed', p.h)
             pc.length = len(p.b)
             return False # Only update explicitly.
         else:
             if trace: g.trace('text changed', p.h)
             return True
     # This will be called at idle time.
     # if trace: g.trace('no change')
     return False
Beispiel #59
0
 def findPositionInChapter(self, p1, strict=False):
     '''Return a valid position p such that p.v == v.'''
     trace = False and not g.unitTesting
     verbose = False
     c, name = self.c, self.name
     # Bug fix: 2012/05/24: Search without root arg in the main chapter.
     if name == 'main' and c.positionExists(p1):
         return p1
     if not p1:
         if trace and verbose: g.trace('no p1', self)
         return None
     root = self.findRootNode()
     if not root:
         if trace: g.trace('no root:', self)
         return None
     if c.positionExists(p1, root=root.copy()):
         if trace and verbose: g.trace('found', p1.h, 'in', self)
         return p1
     if strict:
         if trace: g.trace('strict test fails', p1.h, 'in', self)
         return None
     if name == 'main':
         theIter = c.all_unique_positions
     else:
         theIter = root.self_and_subtree
     for p in theIter():
         if p.v == p1.v:
             if trace: g.trace('found vnode', p1.h, 'in', self)
             return p.copy()
     if trace: g.trace('not found', p1.h, 'in', self)
     return None
Beispiel #60
0
 def cut_stack(self, new_state, stack):
     '''Cut back the stack until stack[-1] matches new_state.'''
     trace = False and g.unitTesting
     if trace:
         g.trace(new_state)
         g.printList(stack)
     assert len(stack) > 1  # Fail on entry.
     while stack:
         top_state = stack[-1].state
         if new_state.level() < top_state.level():
             if trace: g.trace('new_state < top_state', top_state)
             assert len(stack) > 1, stack  # <
             stack.pop()
         elif top_state.level() == new_state.level():
             if trace: g.trace('new_state == top_state', top_state)
             assert len(stack) > 1, stack  # ==
             stack.pop()
             break
         else:
             # This happens often in valid coffescript programs.
             if trace: g.trace('new_state > top_state', top_state)
             break
     # Restore the guard entry if necessary.
     if len(stack) == 1:
         if trace: g.trace('RECOPY:', stack)
         stack.append(stack[-1])
     assert len(stack) > 1  # Fail on exit.
     if trace: g.trace('new target.p:', stack[-1].p.h)