Support static areas (such as bottom line of pixels) that get excluded from scrolling

[thediveo]

When using a smaller font for scrolling text through the LED matrix, a static top/bottom row of pixels could be used to signal some static information, such as a progress bar, status "bar", et cetera.

[Gadgetoid]

This is an interesting idea. I'll have to think if there's a graceful way to integrate it into the library without beginning to make things overly complicated.

[Gadgetoid]

I think this may be one of those things that's best demonstrated with an example, rather than building it directly into the library itself.

That said, it does require a redraw of the lower portion of the buffer after each scroll to place the "fix" portion into the right place. So perhaps a static layer is a good idea?

Thinking about it, a balance between these two extremes- keeping the library simple, but making it easier to produce an example that accomplishes this effect (and more)- might be the best approach.

Here's the contents of show() presently:

scroll-phat-hd/library/scrollphathd/is31fl3731.py

Lines 453 to 506 in edb45d8

	def show(self):
	"""Show the buffer contents on the display.
	The buffer is copied, then scrolling, rotation and flip y/x
	transforms applied before taking a 17x7 slice and displaying.
	"""
	self.setup()
	next_frame = 0 if self._current_frame == 1 else 0
	display_shape = self.get_shape()
	display_buffer = self._grow_buffer(self.buf, display_shape)
	for axis in [0,1]:
	if not self._scroll[axis] == 0:
	display_buffer = numpy.roll(display_buffer, -self._scroll[axis], axis=axis)
	# Chop a width * height window out of the display buffer
	display_buffer = display_buffer[:display_shape[0], :display_shape[1]]
	if self._flipx:
	display_buffer = numpy.flipud(display_buffer)
	if self._flipy:
	display_buffer = numpy.fliplr(display_buffer)
	if self._rotate:
	display_buffer = numpy.rot90(display_buffer, self._rotate)
	output = [0 for x in range(144)]
	for x in range(self._width):
	for y in range(self._height):
	idx = self._pixel_addr(x, self._height-(y+1))
	try:
	output[idx] = self._gamma_table[int(display_buffer[x][y] * self._brightness)]
	except IndexError:
	output[idx] = 0
	self._bank(next_frame)
	offset = 0
	for chunk in self._chunk(output, 32):
	#print(chunk)
	self.i2c.write_i2c_block_data(self.address, _COLOR_OFFSET + offset, chunk)
	offset += 32
	self._frame(next_frame)
	del display_buffer

What if we had a before_display handler- a function you could pass to show() which received the buffer right after it's grabbed in the line: display_buffer = display_buffer[:display_shape[0], :display_shape[1]] but just before the horizontal/vertical flip and rotation are applied.

This would allow you to modify the buffer in-place right before it's displayed on Scroll pHAT HD, giving an opportunity to draw static UI over the top without having a whole spaghetti mess of static drawing functions and an additional buffer stored within the library.

How does that sound?

[thediveo]

Sounds very sound!

[Gadgetoid]

See: f6447a6

This includes a proposed static drawing hook, plus an example to demonstrate how it works.

You get direct access to the raw buffer right before it's rotated and drawn. This buffer is two dimensional, indexed X then Y and is the same size as the Scroll pHAT HD display. It represents the slice of the full buffer that is going to be drawn in that show() call.

My example is not very imaginative, but serves to demonstrate how it works.