about summary refs log tree commit diff stats
path: root/apps/browse/paginated-screen.mu
blob: 0ceb3856f5aa78890819dc269044632a6c38257c (plain) (blame) 
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
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262

# If a screen is too wide, split it up into a fixed size of pages.
# We take control of drawing and moving the cursor, and delegate everything else.
# Never scroll; use the 'done-drawing?' method instead.
#
# Example usage:
#   initialize-paginated-screen
#   on each frame
#     start-drawing
#     while !done-drawing
#       add-grapheme ...

type paginated-screen {
  screen: (handle screen)
  nrows: int  # const
  ncols: int  # const
  page-width: int
  toprow: int
  botrow: int
  leftcol: int
  rightcol: int
  row: int
  col: int
}

fn initialize-paginated-screen _self: (addr paginated-screen), page-width: int {
  # hardcoded parameters:
  #   top-margin
  #   page-margin
  var self/esi: (addr paginated-screen) <- copy _self
  var screen-ah/eax: (addr handle screen) <- get self, screen
  var _screen-addr/eax: (addr screen) <- lookup *screen-ah
  var screen-addr/edi: (addr screen) <- copy _screen-addr
  var nrows/eax: int <- copy 0
  var ncols/ecx: int <- copy 0
  nrows, ncols <- screen-size screen-addr
  var dest/edx: (addr int) <- copy 0
  # self->nrows = nrows
  dest <- get self, nrows
  copy-to *dest, nrows
  # self->ncols = ncols
  dest <- get self, ncols
  copy-to *dest, ncols
  # self->page-width = page-width
  {
    var pg/eax: int <- copy page-width
    dest <- get self, page-width
    copy-to *dest, pg
  }
  # self->toprow = top-margin
  dest <- get self, toprow
  copy-to *dest, 2  # top-margin
  # self->botrow = nrows
  dest <- get self, botrow
  copy-to *dest, nrows
  #
  start-drawing self
}

fn start-drawing _self: (addr paginated-screen) {
  var self/esi: (addr paginated-screen) <- copy _self
  clear-paginated-screen self
  var tmp/eax: (addr int) <- copy 0
  var tmp2/ecx: int <- copy 0
  # self->leftcol = page-margin
  tmp <- get self, leftcol
  copy-to *tmp, 5  # left-margin
  # self->rightcol = self->leftcol + page-width
  tmp <- get self, page-width
  tmp2 <- copy *tmp
  tmp <- get self, rightcol
  copy-to *tmp, tmp2  # left-margin + page-width
  # self->row = self->toprow
  tmp <- get self, toprow
  tmp2 <- copy *tmp
  tmp <- get self, row
  copy-to *tmp, tmp2
  # self->col = self->leftcol
  tmp <- get self, leftcol
  tmp2 <- copy *tmp
  tmp <- get self, col
  copy-to *tmp, tmp2
  #
  reposition-cursor self
}

fn done-drawing? _self: (addr paginated-screen) -> result/eax: boolean {
$done-drawing?:body: {
  # return self->rightcol >= self->ncols
  var self/esi: (addr paginated-screen) <- copy _self
  var max/ecx: (addr int) <- get self, ncols
  var tmp/eax: (addr int) <- get self, rightcol
  var right/eax: int <- copy *tmp
  compare right, *max
  {
    break-if->=
    result <- copy 0  # false
    break $done-drawing?:body
  }
  {
    break-if-<
    result <- copy 1  # true
  }
}
}

fn add-grapheme _self: (addr paginated-screen), c: grapheme {
$add-grapheme:body: {
  var self/esi: (addr paginated-screen) <- copy _self
  {
    compare c, 0xa  # newline
    break-if-!=
    next-line self
    reposition-cursor self
    break $add-grapheme:body
  }
  # print c
  var screen-ah/eax: (addr handle screen) <- get self, screen
  var screen-addr/eax: (addr screen) <- lookup *screen-ah
  print-grapheme screen-addr, c
  # self->col++
  var tmp/eax: (addr int) <- get self, col
  increment *tmp
  # if (self->col > self->rightcol) next-line(self)
  var tmp2/ecx: int <- copy *tmp
  tmp <- get self, rightcol
  compare tmp2, *tmp
  {
    break-if-<=
    next-line self
    reposition-cursor self
  }
}
}

## tests

fn initialize-fake-paginated-screen _self: (addr paginated-screen), nrows: int, ncols: int, page-width: int {
  var self/esi: (addr paginated-screen) <- copy _self
  var screen-ah/eax: (addr handle screen) <- get self, screen
  allocate screen-ah
  var screen-addr/eax: (addr screen) <- lookup *screen-ah
  initialize-screen screen-addr, nrows, ncols
  initialize-paginated-screen self, page-width
}

## simple delegates

fn reposition-cursor _self: (addr paginated-screen) {
  var self/esi: (addr paginated-screen) <- copy _self
  var r/ecx: (addr int) <- get self, row
  var c/edx: (addr int) <- get self, col
  var screen-ah/eax: (addr handle screen) <- get self, screen
  var screen-addr/eax: (addr screen) <- lookup *screen-ah
  move-cursor screen-addr, *r *c
}

fn clear-paginated-screen _self: (addr paginated-screen) {
  var self/esi: (addr paginated-screen) <- copy _self
  var screen-ah/eax: (addr handle screen) <- get self, screen
  var screen-addr/eax: (addr screen) <- lookup *screen-ah
  clear-screen screen-addr
}

fn start-color-on-paginated-screen _self: (addr paginated-screen), fg: int, bg: int {
  var self/esi: (addr paginated-screen) <- copy _self
  var screen-ah/eax: (addr handle screen) <- get self, screen
  var screen-addr/eax: (addr screen) <- lookup *screen-ah
  start-color screen-addr, fg, bg
}

fn start-bold-on-paginated-screen _self: (addr paginated-screen) {
  var self/esi: (addr paginated-screen) <- copy _self
  var screen-ah/eax: (addr handle screen) <- get self, screen
  var screen-addr/eax: (addr screen) <- lookup *screen-ah
  start-bold screen-addr
}

fn start-underline-on-paginated-screen _self: (addr paginated-screen) {
  var self/esi: (addr paginated-screen) <- copy _self
  var screen-ah/eax: (addr handle screen) <- get self, screen
  var screen-addr/eax: (addr screen) <- lookup *screen-ah
  start-underline screen-addr
}

fn start-reverse-video-on-paginated-screen _self: (addr paginated-screen) {
  var self/esi: (addr paginated-screen) <- copy _self
  var screen-ah/eax: (addr handle screen) <- get self, screen
  var screen-addr/eax: (addr screen) <- lookup *screen-ah
  start-reverse-video screen-addr
}

fn start-blinking-on-paginated-screen _self: (addr paginated-screen) {
  var self/esi: (addr paginated-screen) <- copy _self
  var screen-ah/eax: (addr handle screen) <- get self, screen
  var screen-addr/eax: (addr screen) <- lookup *screen-ah
  start-blinking screen-addr
}

fn reset-formatting-on-paginated-screen _self: (addr paginated-screen) {
  var self/esi: (addr paginated-screen) <- copy _self
  var screen-ah/eax: (addr handle screen) <- get self, screen
  var screen-addr/eax: (addr screen) <- lookup *screen-ah
  reset-formatting screen-addr
}

## helpers

fn next-line _self: (addr paginated-screen) {
  var self/esi: (addr paginated-screen) <- copy _self
  var tmp/eax: (addr int) <- copy 0
  var tmp2/ecx: int <- copy 0
  # self->col = self->leftcol
  tmp <- get self, leftcol
  tmp2 <- copy *tmp
  tmp <- get self, col
  copy-to *tmp, tmp2
  # self->row++
  tmp <- get self, row
  increment *tmp
  # if (self->row > self->botrow) next-page(self)
  tmp2 <- copy *tmp
  tmp <- get self, botrow
  compare tmp2, *tmp
  {
    break-if-<=
    next-page self
  }
}

fn next-page _self: (addr paginated-screen) {
  var self/esi: (addr paginated-screen) <- copy _self
  var pg/edi: (addr int) <- get self, page-width
  var tmp/eax: (addr int) <- copy 0
  var tmp2/ecx: int <- copy 0
#?   # temporary: stop
#?   tmp <- get self, ncols
#?   tmp2 <- copy *tmp
#?   tmp <- get self, rightcol
#?   copy-to *tmp, tmp2
  # real: multiple pages
  # self->leftcol = self->rightcol + page-margin
  tmp <- get self, rightcol
  tmp2 <- copy *tmp
  tmp2 <- add 5  # page-margin
  tmp <- get self, leftcol
  copy-to *tmp, tmp2
  # self->rightcol = self->leftcol + page-width
  tmp2 <- copy *tmp
  tmp2 <- add *pg
  tmp <- get self, rightcol
  copy-to *tmp, tmp2
  # self->row = self->toprow
  tmp <- get self, toprow
  tmp2 <- copy *tmp
  tmp <- get self, row
  copy-to *tmp, tmp2
  # self->col = self->leftcol
  tmp <- get self, leftcol
  tmp2 <- copy *tmp
  tmp <- get self, col
  copy-to *tmp, tmp2
}
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-09-13 16:20:16 +0000
ible = False self.runnable = False return 0 else: if size is None: self.infostring = '' else: self.infostring = ' %d' % size self.accessible = True self.runnable = True return size @lazy_property def infostring(self): self.size # trigger the lazy property initializer if self.is_link: return '->' + self.infostring return self.infostring @lazy_property def runnable(self): self.size # trigger the lazy property initializer return self.runnable def sort_if_outdated(self): """Sort the containing files if they are outdated""" if self.order_outdated: self.order_outdated = False self.sort() return True return False def move_to_obj(self, arg): try: arg = arg.path except: pass self.load_content_once(schedule=False) if self.empty(): return Accumulator.move_to_obj(self, arg, attr='path') def search_fnc(self, fnc, offset=1, forward=True): if not hasattr(fnc, '__call__'): return False length = len(self) if forward: generator = ((self.pointer + (x + offset)) % length \ for x in range(length - 1)) else: generator = ((self.pointer - (x + offset)) % length \ for x in range(length - 1)) for i in generator: _file = self.files[i] if fnc(_file): self.pointer = i self.pointed_obj = _file self.correct_pointer() return True return False def set_cycle_list(self, lst): self.cycle_list = deque(lst) def cycle(self, forward=True): if self.cycle_list: if forward is True: self.cycle_list.rotate(-1) elif forward is False: self.cycle_list.rotate(1) self.move_to_obj(self.cycle_list[0]) def correct_pointer(self): """Make sure the pointer is in the valid range""" Accumulator.correct_pointer(self) try: if self == self.fm.thisdir: self.fm.thisfile = self.pointed_obj except: pass def load_content_once(self, *a, **k): """Load the contents of the directory if not done yet""" if not self.content_loaded: self.load_content(*a, **k) return True return False def load_content_if_outdated(self, *a, **k): """Load the contents of the directory if outdated""" if self.load_content_once(*a, **k): return True if self.files_all is None or self.content_outdated: self.load_content(*a, **k) return True try: if self.flat: real_mtime = mtimelevel(self.path, self.flat) else: real_mtime = os.stat(self.path).st_mtime except OSError: real_mtime = None return False if self.stat: cached_mtime = self.load_content_mtime else: cached_mtime = 0 if real_mtime != cached_mtime: self.load_content(*a, **k) return True return False def get_description(self): return "Loading " + str(self) def use(self): """mark the filesystem-object as used at the current time""" self.last_used = time() def is_older_than(self, seconds): """returns whether this object wasn't use()d in the last n seconds""" if seconds < 0: return True return self.last_used + seconds < time() def go(self, history=True): """enter the directory if the filemanager is running""" if self.fm: return self.fm.enter_dir(self.path, history=history) return False def empty(self): """Is the directory empty?""" return self.files is None or len(self.files) == 0 def _set_linemode_of_children(self, mode): for f in self.files: f._set_linemode(mode) def __nonzero__(self): """Always True""" return True __bool__ = __nonzero__ def __len__(self): """The number of containing files""" assert self.accessible assert self.content_loaded assert self.files is not None return len(self.files) def __eq__(self, other): """Check for equality of the directories paths""" return isinstance(other, Directory) and self.path == other.path def __neq__(self, other): """Check for inequality of the directories paths""" return not self.__eq__(other) def __hash__(self): return hash(self.path)
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-09-13 16:20:10 +0000