Beispiel #1
0
    def show_binds(self):
        """
        Show keybindings
        """

        self.fire_event("show_binds")
        
        _data = self.xyz.km.get_binds()

        _entries = []

        _divattr = self.xyz.skin.attr(uilib.XYZListBox.resolution, u"border")

        _entries.append(lowui.Text(u"%-10s %-20s %s" %
                        (_(u"Context"), _(u"Bind"),
                         _(u"Method / Description"))))
        _entries.append(uilib.Separator(div_attr=_divattr))

        for _context in sorted(_data.keys()):
            for _bind in sorted(_data[_context].keys(),
                                cmp=lambda x, y: cmp(bstring(x), bstring(y))):
                if _data[_context][_bind] is None:
                    continue

                _entries.append(lowui.Text(u"%-10s %-20s %s" %
                                (_context, _bind, _data[_context][_bind].ns)))

        _walker = lowui.SimpleListWalker(_entries)

        _dim = tuple([x - 2 for x in self.xyz.screen.get_cols_rows()])

        uilib.XYZListBox(self.xyz, self.xyz.top, _walker,
                         _(u"Keybindings"), _dim).show()
Beispiel #2
0
    def _gid(self, gid):
        _name = util.get_group(gid)

        if _name is not None:
            return "%s (%s)" % (bstring(gid), _name)
        else:
            return bstring(gid)
Beispiel #3
0
    def _uid(self, uid):
        _name = util.get_user(uid)

        if _name is not None:
            return "%s (%s)" % (bstring(uid), _name)
        else:
            return bstring(uid)
Beispiel #4
0
    def complete(self, buf):
        """
        Take current buffer and return list-generator of all
                matched entries in current domain.

        @param buf: Current buffer
        @return: list-generator
        """

        buf = bstring(buf)

        if os.path.isdir(buf):
            _dir = buf
            _obj = ""
        # Treat as current dir
        elif os.path.sep not in buf:
            _dir = "."
            _obj = buf
        else:
            _dir = os.path.dirname(buf)
            _obj = os.path.basename(buf)

        _, dirs, files = os.walk(_dir).next()

        return itertools.ifilter(lambda x: x.startswith(_obj), dirs + files)
Beispiel #5
0
    def show_box(self, use_wrap=True):
        """
        Show test_box dialog
        @param use_wrap: Whether to use input wrapper which honours
        learned keys
        """

        _msg = _(u"Press any key. Escape twice to quit.")

        _escape = 0
        _escape_key = uilib.Shortcut(sc=[self._keys.ESCAPE])

        while True:
            shortcut = InputBox(self.xyz, self.xyz.top, bstring(_msg),
                                _(u"Input test")).show(use_wrap=use_wrap)

            if shortcut == _escape_key:
                _escape += 1
                if _escape == 2:
                    return
            else:
                _escape = 0

            method = self.xyz.km.get_method_by_key(shortcut)

            _msg = u"Shortcut: '%s'. Raw: '%s'" % (
                   (u" ".join([ustring(x) for x in shortcut.sc]),
                    u" ".join([ustring(x) for x in shortcut.raw])))

            if method is not None:
                _msg = u"%s\n[%s]" % (_msg, method.ns)
Beispiel #6
0
    def execute(self, cmd, wait=None):
        """
        Execute command in shell
        """

        cmd = bstring(cmd)
        self.fire_event("execute", cmd)

        def _exec():
            pid = os.fork()

            # Child - Exec passed cmd
            if pid == 0:
                os.execvp(self.shell[0], self.shell + [cmd])
                # WTF?
                sys.exit()
                # Parent
            else:
                while True:
                    try:
                        self.status = os.waitpid(pid, 0)
                    except KeyboardInterrupt:
                        pass
                    except OSError, e:
                        if e.errno != errno.EINTR:
                            break

            return self.status
Beispiel #7
0
    def complete(self, buf):
        """
        Take current buffer and return list-generator of all
                matched entries in current domain.

        @param buf: Current buffer
        @return: list-generator
        """

        return itertools.ifilter(lambda x: x.startswith(bstring(buf)),
                                 self._data)
Beispiel #8
0
    def _press_key(self, msg, key):
        """
        Print prompt and wait for the key to be pressed
        """

        sys.stdout.write(bstring(msg))
        sys.stdout.flush()
        
        while True:
            try:
                m = os.read(sys.stdin.fileno(), 1024)
                if key in m:
                    break
            except OSError, e:
                if e.errno != errno.EINTR:
                    break
Beispiel #9
0
    def show(self, dim=None, exit_keys=None):
        """
        Show window. Update contents as user types
        """

        exit_keys = exit_keys or []

        if dim is None:
            dim = self.xyz.screen.get_cols_rows()

        _buf = u""
        _title = self.title

        while True:
            self.xyz.screen.draw_screen(dim, self.render(dim, True))

            _i = self.xyz.input.get()

            if self.xyz.input.WIN_RESIZE in _i:
                dim = self.xyz.screen.get_cols_rows()
                continue

            update = False

            if _i:
                for _k in _i:
                    if _k == self._keys.ESC:
                        return
                    elif _k == self._keys.BACKSPACE:
                        _buf = _buf[:-1]
                        update = True
                    elif _k == self._keys.ENTER:
                        entry, _ = self.listbox.get_focus()
                        return entry.text
                    elif len(ustring(_k)) == 1:
                        _buf += _k
                        update = True
                    else:
                        self._listbox.keypress(dim, _k)

                if update:
                    _b = bstring(_buf)
                    self.set_title(u"%s: %s" % (_title, _buf))

                    self.listbox.body.contents = [x for x in self._extra
                                                  if _b in x._text]
Beispiel #10
0
    def _exec_engine(self, cmd, cmdf, wait=None):
        """
        Execute command engine
        """

        self.xyz.screen.clear()
        stdout = sys.stdout
        self.xyz.screen.stop()

        _current_term = None
        
        # Restore original terminal settings
        if self.xyz.term is not None:
            _current_term = core.utils.term_settings()[-1]
            core.utils.restore_term(self.xyz.term)
        
        # Clear the screen
        #TODO: make it more portable!
        stdout.write("\x1b[H\x1b[2J")

        stdout.write("%s%s\n" %
                     (bstring(
                         self.xyz.conf[u"plugins"][":sys:cmd"][u"prompt"]),
                      cmd))
        stdout.flush()

        def _sigwinch(_a, _b):
            self.xyz.screen.resized = True

        signal.signal(signal.SIGWINCH, _sigwinch)

        status = cmdf()
        
        if _current_term is not None:
            core.utils.restore_term(_current_term)

        if wait == True or (wait != False and self.conf["wait"]):
            self._press_key(_(u"Press ENTER to continue..."), "\n")

        self.xyz.screen.start()

        return status
Beispiel #11
0
    def complete(self, buf):
        """
        Take current buffer and return list-generator of all
                matched entries in current domain.

        @param buf: Current buffer
        @return: list-generator
        """

        cmd = split_cmd(bstring(buf))

        _len = len(cmd)

        if len(cmd) == 1:
            obj = ""
        else:
            obj = cmd[-1]

        _, _, files = os.walk(self.INITD_DIR).next()

        return itertools.ifilter(lambda x: x.startswith(obj), files)
Beispiel #12
0
    def complete(self, buf, domains=None):
        """
        Take current buffer and return list of list-generator each entry for
        each domain.

        @param buf: Current buffer
        @param domains: List of domains to search in,
               if None search in all available domains.
        @return: List of list-generator each entry for each domain
        """

        buf = bstring(buf)

        result = []

        if domains is None:
            domains = self._domains.keys()

        for d in domains:
            result.append(self._domains[d].complete(buf))

        return result
Beispiel #13
0
    def mkdir(self):
        """
        Create new directory dialog
        """

        self._load_panel()

        _box = uilib.InputBox(self.xyz, self.xyz.top,
                              _(u"New directory name"),
                              title=_(u"Create directory"))

        _dir = _box.show()

        if not _dir:
            return
        else:
            _dir = bstring(_dir)

        try:
            self._panel.get_current().mkdir(_dir)
        except Exception, e:
            xyzlog.error(_(u"Unable to create directory: %s") %
                         unicode(e))
Beispiel #14
0
    def smart_complete(self, cmd):
        """
        Try to guess what completion domain can be used based on
        provided buffer and defined behaviour.

        @param cmd: Current buffer
        @return: List of list-generator each entry for each domain
        """

        if not cmd:
            return

        data = None
        pat_used = False
        buf = bstring(split_cmd(cmd)[-1])

        # First check the behaviour patterns
        for (pattern, domain) in self.conf["behaviour"]:
            if pattern.search(cmd) is not None:
                pat_used = True
                data = self.dialog(cmd, [domain])
                break

        # Else default fallback behaviour applied
        if pat_used == False:
            # Treat as path
            if buf.startswith(os.path.sep) or buf.startswith("./") or \
                   buf.startswith("../"):
                data = self.dialog(buf, ["fs"])
            else:
                # Treat as command in $PATH
                data = self.dialog(buf, ["binpath"])

        if data is not None:
            data = intersect(buf, data)
            self.xyz.pm.from_load(":sys:cmd", "append")(data)
Beispiel #15
0
    def __init__(self, xyz, srctxt, dst, caption):
        self.xyz = xyz
        self._attr = lambda name: self.xyz.skin.attr(self.resolution, name)
        self._keys = uilib.Keys()

        srclabel = lowui.Text(bstring(_(u"Source:")))
        srctxt = lowui.Text(bstring(srctxt))
        dstlabel = lowui.Text(bstring(_(u"Destination:")))

        self.dstw = lowui.AttrWrap(lowui.Edit(edit_text=ustring(dst),
                                              wrap='clip'),
                                   self._attr("input"))

        self.save_attrw = lowui.CheckBox(bstring(_(u"Save attributes")),
                                         state=True)
        self.follow_linksw = lowui.CheckBox(bstring(_(u"Follow links")))
        self.buttonsw = lowui.Columns([self.save_attrw, self.follow_linksw])

        spacer = lowui.Text(" ")
        msg = lowui.Text(
            bstring(_(u"TAB to cycle. ENTER to submit. ESCAPE to cancel")),
            align=uilib.align.CENTER)
        
        w = [
            srclabel,
            srctxt,
            spacer,
            dstlabel,
            self.dstw,
            spacer,
            self.buttonsw,
            uilib.Separator(),
            msg
            ]

        self.widgets = lowui.Pile(w)
        box = lowui.AttrWrap(lowui.Filler(self.widgets), self._attr("box"))

        self.widget = uilib.Border(box, caption, self._attr("title"),
                              self._attr("border"))
                              
        super(CopyBox, self).__init__(self.widget)
Beispiel #16
0
    def _write(self, msg):
        """
        Write text to output
        """

        self.output.extend([lowui.Text(x) for x in bstring(msg).split("\n")])
Beispiel #17
0
    def show(self):
        def _setup(dim):
            width = int((dim[0] / 100.0) * 80)
            height = int((dim[1] / 100.0) * 40)
            
            mount = lowui.AttrWrap(lowui.Filler(lowui.Text(u"")),
                               self._attr(u"mount"))
            mount = lowui.Overlay(mount, self.xyz.top, uilib.align.CENTER,
                               width, uilib.align.MIDDLE, height)

            return lowui.Overlay(self.widget, mount, uilib.align.CENTER,
                                 width - 2, uilib.align.MIDDLE, height - 2)

        #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        def _focus_button(b):
            self.widgets.set_focus(self.buttonsw)
            self.buttonsw.set_focus(b)
            
            return b

        #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        def _focus_edit():
            self.widgets.set_focus(self.dstw)
            
            return self.dstw

        #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        focus_data = {1: lambda: _focus_edit(),
                      2: lambda: _focus_button(self.save_attrw),
                      3: lambda: _focus_button(self.follow_linksw)
                      }
        focus = 1
        focusw = self.dstw
        
        dim = self.xyz.screen.get_cols_rows()
        box = _setup(dim)

        result = None

        while True:
            self.xyz.screen.draw_screen(dim, box.render(dim, True))

            _input = self.xyz.input.get()

            if self.xyz.input.WIN_RESIZE in _input:
                dim = self.xyz.screen.get_cols_rows()
                box = _setup(dim)
                continue

            if self._keys.TAB in _input:
                if focus >= len(focus_data):
                    focus = 1
                else:
                    focus +=1

                focusw = focus_data[focus]()
            elif self._keys.ESCAPE in _input:
                break
            elif self._keys.ENTER in _input:
                result = {
                    'dst': bstring(self.dstw.get_edit_text()),
                    'save_attributes': self.save_attrw.get_state(),
                    'follow_links': self.follow_linksw.get_state()
                    }
                break
            else:
                for k in _input:
                    focusw.keypress((dim[0],), k)

        return result
Beispiel #18
0
    def _info(self):
        """
        Show plugin detailed info
        """

        def _add_info():
            if _plugin.AUTHOR is not None:
                _data.append(lowui.Text(_(u"Author: %s") % _plugin.AUTHOR))

            if _plugin.VERSION is not None:
                _data.append(lowui.Text(_(u"Version: %s") % _plugin.VERSION))

            if _plugin.MIN_XYZ_VERSION is not None:
                _data.append(lowui.Text(_(u"Minimal compatible version: %s")
                                          % _plugin.MIN_XYZ_VERSION))

            if _plugin.HOMEPAGE is not None:
                _data.append(lowui.Text(_(u"Homepage: %s") % _plugin.HOMEPAGE))

            _data.append(_div)

            if _plugin.FULL_DESCRIPTION is not None:
                _data.append(lowui.Text(_plugin.FULL_DESCRIPTION))

        #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        def make_args(func):
            _args, _varargs, _varkw, _def = inspect.getargspec(func)

            # We will be inspecting only methods, so always skip self
            if len(_args) == 1:
                return u""

            _args = _args[1:]
            _tmp = []

            # No defaults
            if _def is None:
                _tmp = _args
            else:
                _delta = len(_args) - len(_def)

                if _delta > 0:
                    _tmp.extend(_args[:_delta])
                    _args = _args[_delta:]

                for _a, _d in zip(_args, _def):
                    _tmp.append(u"=".join((ustring(_a), ustring(_d))))

            return u",".join(_tmp)

        #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        def _add_public_data():
            if _plugin.public_data:
                _data.append(uilib.Separator(_(u"Public data"),
                                             title_attr=_titleattr,
                                             div_attr=_divattr))

                _dlen = len(_plugin.public_data)
                _di = 0

                for k, v in _plugin.public_data.iteritems():
                    _data.append(lowui.Text(u"%s: %s" % (k, type(v))))

                    _di += 1

                    if _di < _dlen:
                        _data.append(_div)

        #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        def _add_public_methods():
            _data.append(uilib.Separator(_(u"Public methods"),
                                         title_attr=_titleattr,
                                         div_attr=_divattr))

            _bind_data = self.xyz.km.get_binds()

            _len = len(_plugin.public)
            _i = 0

            for k in sorted(_plugin.public.keys()):
                v = _plugin.public[k]

                if v.__doc__ is not None:
                    _doc = v.__doc__.rstrip()
                else:
                    _doc = v.__doc__

                _cur_bind = _(u"N/A")

                # Try to find current binding for the method
                for context in _bind_data:
                    for bind in _bind_data[context]:
                        if _bind_data[context][bind] is v:
                            _cur_bind = bind

                _data.append(lowui.Text(u"%s(%s) [%s]: %s" %
                             (k, make_args(v), _cur_bind, _doc)))

                _i += 1

                if _i < _len:
                    _data.append(_div)

        #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        _w = self._walker.get_focus()[0]
        _plugin = _w.plugin

        self.fire_event("info", _plugin)
        _divattr = self.xyz.skin.attr(uilib.XYZListBox.resolution, u"border")
        _titleattr = self.xyz.skin.attr(uilib.XYZListBox.resolution, u"title")
        _div = lowui.Text("")

        _data = []

        _add_info()

        if _plugin.DOC is not None:
            _data.append(uilib.Separator(_(u"Plugin doc"),
                                         title_attr=_titleattr,
                                         div_attr=_divattr))

            _data.append(lowui.Text(_plugin.DOC))

        if isinstance(_plugin.EVENTS, list):
            _data.append(uilib.Separator(_(u"Plugin events"),
                                         title_attr=_titleattr,
                                         div_attr=_divattr))

            for event, desc in _plugin.EVENTS:
                _data.append(lowui.Text("%s -- %s" %
                                        (bstring(_plugin.event_name(event)),
                                         bstring(desc))))

        _add_public_data()
        _add_public_methods()

        _method_walker = lowui.SimpleListWalker(_data)
        _dim = tuple([x - 2 for x in self.xyz.screen.get_cols_rows()])

        uilib.XYZListBox(self.xyz, self.xyz.top, _method_walker,
                         _(u"Plugin info %s") % _plugin.ns, _dim).show()
Beispiel #19
0
    def copy(self, move=False):
        """
        Copy objects dialog
        """

        self._load_panel()
        objs = self._panel.get_active()

        if not objs:
            return

        if len(objs) == 1:
            srctxt = ustring(objs[0].full_path)
        else:
            srctxt = _(u"%d objects") % len(objs)
            
        srctxt = bstring(srctxt)

        if move:
            _m = _(u"Move")
            msg = _(u"Moving object: %s")
            caption = _(u"Moving")
            unable_msg = _(u"Unable to move object: %s")
            unable_caption = _(u"Move error")
        else:
            _m = _(u"Copy")
            msg = _(u"Copying object: %s")
            caption = _(u"Copying")
            unable_msg = _(u"Unable to copy object: %s")
            unable_caption = _(u"Copy error")

        msg += _(u"\nESCAPE to abort")
        data = CopyBox(self.xyz, srctxt, self._panel.cwd(active=False),
                       bstring(_m)).show()

        if data is None:
            return

        stopped = threading.Event()
        cancel = threading.Event()
        free = threading.Event()
        free.set()

        def existcb(vfsobj):
            free.clear()
            
            buttons = [
                (_(u"Yes"), "override"),
                (_(u"All"), "override all"),
                (_(u"Skip"), "skip"),
                (_(u"Skip all"), "skip all"),
                (_(u"Abort"), "abort"),
                ]

            try:
                name = ustring(vfsobj.name)
            
                _rec = uilib.ButtonBox(
                    self.xyz, self.xyz.top,
                    _(u"Object %s already exists. Really override?") % name,
                    buttons, title=_(u"Override %s") % name).show()

                uilib.MessageBox(self.xyz, self.xyz.top,
                                 caption, caption).show(wait=False)

                free.set()
                return _rec or 'abort'
            except Exception:
                free.set()

        #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        def errorcb(vfsobj, errstr):
            free.clear()

            buttons = [
                (_(u"Skip"), "skip"),
                (_(u"Skip all"), "skip all"),
                (_(u"Abort"), "abort"),
                ]

            try:
                _rec = uilib.ButtonBox(
                    self.xyz, self.xyz.top,
                    _(u"An error occured %s: %s") % (
                        ustring(vfsobj.full_path), ustring(errstr)),
                    buttons, title=_(u"Copy error")).show()

                uilib.MessageBox(self.xyz, self.xyz.top,
                                 caption, caption).show(wait=False)

                free.set()
                return _rec or 'abort'
            except Exception:
                free.set()

        #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        args = {
            "existcb": existcb,
            "errorcb": errorcb,
            "save_attrs": data["save_attributes"],
            "follow_links": data["follow_links"],
            "cancel": cancel
            }

        runner_error = []
        
        def frun(o, err):
            stopped.clear()

            try:
                if move:
                    attr = "move"
                else:
                    attr = "copy"

                getattr(o, attr)(data["dst"], **args)
            except StopIteration, e:
                pass
            except Exception, e:
                err.append(unicode(e))
Beispiel #20
0
    def __init__(self, xyz, path, full_path, ext_path, driver, parent,
                 enc=None, **kwargs):
        self.xyz = xyz
        self.enc = enc or xyzenc
        # Internal VFS path
        self.path = bstring(path, self.enc)
        # Full VFS path
        self.full_path = bstring(full_path, self.enc)
        # External VFS path
        self.ext_path = bstring(ext_path, self.enc)
        self.parent = parent
        self.driver = driver
        self.kwargs = kwargs
        self.fileobj = None

        # File name
        self.name = os.path.basename(self.path)

        # File type
        self.ftype = None

        # Access time
        self.atime = None

        # Modified time
        self.mtime = None

        # Changed time
        self.ctime = None

        # Size in bytes
        self.size = None

        # Owner UID
        self.uid = None

        # Group
        self.gid = None

        # Mode
        self.mode = None

        # Inode
        self.inode = None

        # Visual file type
        self.vtype = None

        # Visual file representation
        self.visual = None

        # File info
        self.info = None

        # Any type-specific data
        self.data = None

        # List of significant attributes
        self.attributes = ()

        # Run local constructor
        self._prepare()

        self.__ni_msg = _(u"Feature not implemented")
Beispiel #21
0
        try:
            return _parser.parse(_file)
        except ParseError, e:
            xyzlog.error(_(u"Error parsing bookmarks file: %s") %
                         unicode(e))
        _file.close()

        return None

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def _save_data(self, data):
        """
        Save data to bookmarks file
        data is a mapping: {name: path}
        """

        try:
            _file = self._ud.openfile(self._bmfile, "w", self._bmsubdir)
        except XYZRuntimeError, e:
            xyzlog.info("Unable to open bookmarks file: %s" % unicode(e))
            return None

        for _name, _path in data.iteritems():
            _file.write('"%s": "%s"\n' %
                        (bstring(_name), bstring(_path)))

        _file.close()

        return True