1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
# Copyright (C) 2009, 2010, 2011 Roman Zimbelmann <romanz@lavabit.com>
# This software is distributed under the terms of the GNU GPL version 3.
"""
The File Manager, putting the pieces together
"""
from time import time
from collections import deque
import mimetypes
import os
import stat
import sys
import ranger
from ranger.core.actions import Actions
from ranger.container.tags import Tags
from ranger.gui.ui import UI
from ranger.container.bookmarks import Bookmarks
from ranger.core.runner import Runner
from ranger.ext.get_executables import get_executables
from ranger.ext.rifle import Rifle
from ranger.fsobject import Directory
from ranger.ext.signals import SignalDispatcher
from ranger import __version__
from ranger.core.loader import Loader
class FM(Actions, SignalDispatcher):
input_blocked = False
input_blocked_until = 0
mode = 'normal' # either 'normal' or 'visual'.
search_method = 'ctime'
_previous_selection = None
_visual_reverse = False
_visual_start = None
_visual_start_pos = None
def __init__(self, ui=None, bookmarks=None, tags=None):
"""Initialize FM."""
Actions.__init__(self)
SignalDispatcher.__init__(self)
self.ui = ui
self.directories = dict()
self.log = deque(maxlen=20)
self.bookmarks = bookmarks
self.tags = tags
self.tabs = {}
self.py3 = sys.version_info >= (3, )
self.previews = {}
self.current_tab = 1
self.loader = Loader()
self.copy_buffer = set()
self.do_cut = False
self.log.append('ranger {0} started! Process ID is {1}.' \
.format(__version__, os.getpid()))
self.log.append('Running on Python ' + sys.version.replace('\n',''))
mimetypes.knownfiles.append(os.path.expanduser('~/.mime.types'))
mimetypes.knownfiles.append(self.relpath('data/mime.types'))
self.mimetypes = mimetypes.MimeTypes()
def initialize(self):
"""If ui/bookmarks are None, they will be initialized here."""
if not ranger.arg.clean and os.path.isfile(self.confpath('rifle.conf')):
rifleconf = self.confpath('rifle.conf')
else:
rifleconf = self.relpath('config/rifle.conf')
self.rifle = Rifle(rifleconf)
self.rifle.reload_config()
if self.bookmarks is None:
if ranger.arg.clean:
bookmarkfile = None
else:
bookmarkfile = self.confpath('bookmarks')
self.bookmarks = Bookmarks(
bookmarkfile=bookmarkfile,
bookmarktype=Directory,
autosave=self.settings.autosave_bookmarks)
self.bookmarks.load()
if not ranger.arg.clean and self.tags is None:
self.tags = Tags(self.confpath('tagged'))
if self.ui is None:
self.ui = UI()
self.ui.initialize()
self.rifle.hook_before_executing = lambda a, b, flags: \
self.ui.suspend() if 'f' not in flags else None
self.rifle.hook_after_executing = lambda a, b, flags: \
self.ui.initialize() if 'f' not in flags else None
self.rifle.hook_logger = self.notify
def mylogfunc(text):
self.notify(text, bad=True)
self.run = Runner(ui=self.ui, logfunc=mylogfunc, fm=self)
self.env.signal_bind('cd', self._update_current_tab)
if self.settings.init_function:
self.settings.init_function(self)
def destroy(self):
debug = ranger.arg.debug
if self.ui:
try:
self.ui.destroy()
except:
if debug:
raise
if self.loader:
try:
self.loader.destroy()
except:
if debug:
raise
def block_input(self, sec=0):
self.input_blocked = sec != 0
self.input_blocked_until = time() + sec
def input_is_blocked(self):
if self.input_blocked and time() > self.input_blocked_until:
self.input_blocked = False
return self.input_blocked
def copy_config_files(self, which):
if ranger.arg.clean:
sys.stderr.write("refusing to copy config files in clean mode\n")
return
import shutil
def copy(_from, to):
if os.path.exists(self.confpath(to)):
sys.stderr.write("already exists: %s\n" % self.confpath(to))
else:
sys.stderr.write("creating: %s\n" % self.confpath(to))
try:
shutil.copy(self.relpath(_from), self.confpath(to))
except Exception as e:
sys.stderr.write(" ERROR: %s\n" % str(e))
if which == 'rifle' or which == 'all':
copy('config/rifle.conf', 'rifle.conf')
if which == 'commands' or which == 'all':
copy('config/commands.py', 'commands.py')
if which == 'rc' or which == 'all':
copy('config/rc.conf', 'rc.conf')
if which == 'options' or which == 'all':
copy('config/options.py', 'options.py')
if which == 'scope' or which == 'all':
copy('data/scope.sh', 'scope.sh')
os.chmod(self.confpath('scope.sh'),
os.stat(self.confpath('scope.sh')).st_mode | stat.S_IXUSR)
if which not in \
('all', 'rifle', 'scope', 'commands', 'rc', 'options'):
sys.stderr.write("Unknown config file `%s'\n" % which)
def confpath(self, *paths):
"""returns the path relative to rangers configuration directory"""
if ranger.arg.clean:
assert 0, "Should not access relpath_conf in clean mode!"
else:
return os.path.join(ranger.arg.confdir, *paths)
def relpath(self, *paths):
"""returns the path relative to rangers library directory"""
return os.path.join(ranger.RANGERDIR, *paths)
def loop(self):
"""
The main loop consists of:
1. reloading bookmarks if outdated
2. letting the loader work
3. drawing and finalizing ui
4. reading and handling user input
5. after X loops: collecting unused directory objects
"""
self.env.enter_dir(self.env.path)
gc_tick = 0
# for faster lookup:
ui = self.ui
throbber = ui.throbber
loader = self.loader
env = self.env
has_throbber = hasattr(ui, 'throbber')
zombies = self.run.zombies
try:
while True:
loader.work()
if has_throbber:
if loader.has_work():
throbber(loader.status)
else:
throbber(remove=True)
ui.redraw()
ui.set_load_mode(not loader.paused and loader.has_work())
ui.handle_input()
if zombies:
for zombie in tuple(zombies):
if zombie.poll() is not None:
zombies.remove(zombie)
gc_tick += 1
if gc_tick > ranger.TICKS_BEFORE_COLLECTING_GARBAGE:
gc_tick = 0
env.garbage_collect(
ranger.TIME_BEFORE_FILE_BECOMES_GARBAGE, self.tabs)
except KeyboardInterrupt:
# this only happens in --debug mode. By default, interrupts
# are caught in curses_interrupt_handler
raise SystemExit
finally:
if ranger.arg.choosedir and self.env.cwd and self.env.cwd.path:
# XXX: UnicodeEncodeError: 'utf-8' codec can't encode character
# '\udcf6' in position 42: surrogates not allowed
open(ranger.arg.choosedir, 'w').write(self.env.cwd.path)
self.bookmarks.remember(env.cwd)
self.bookmarks.save()
|