In the name of this class, “V” may stand for “*V*ariable” because it can be
used for scrolling lines of variable heights; “*V*irtual” because it is not
necessary to know the heights of all lines in advance — only those which
are shown on the screen need to be measured; or, even, “*V*ertical” because
this class only supports scrolling in one direction currently (this could
and probably will change in the future however).
In any case, this is a generalization of the
ScrolledWindow class which can be only used when
all lines have the same height. It lacks some other ScrolledWindow
features however, notably there is currently no support for horizontal
scrolling; it can’t scroll another window nor only a rectangle of the
window and not its entire client area.
To use this class, you need to inherit from it in Ruby and implement
on_get_line_height. You also must
call set_line_count to let the base
class know how many lines it should display but from that moment on the
scrolling is handled entirely by VScrolledWindow, you only need to draw
the visible part of contents in your paint
method as usual. You should use
get_first_visible_line and
get_last_visible_line to
select the lines to display. Note that the device context origin is not
shifted so the first visible line always appears at the point (0, 0)
in physical as well as logical coordinates.
This is the normal constructor, no need to call Create() after using this one.
Note that VSCROLL
is always automatically added to our style, there is
no need to specify it explicitly.
NULL
ID_ANY
by defaultThis method is used internally by VScrolledWindow to estimate the total
height of the window when set_line_count
is called. The default implementation uses the brute force approach if
the number of the items in the control is small enough. Otherwise, it
tries to find the average line height using some lines in the beginning,
middle and the end.
If it is undesirable to access all these lines (some of which might be
never shown) just for the total height calculation, you may override the
function and provide your own guess better and/or faster.
Note that although returning a totally wrong value would still work, it
risks to result in very strange scrollbar behaviour so this function
should really try to make the best guess possible.
Returns the index of the first currently visible line.
This is same as get_visible_begin and
exists only for symmetry with get_last_visible_line.
Returns the index of the last currently visible line. Note that this method
returns (Integer)-1
(i.e. a huge positive number) if the control is
empty so if this is possible you should use get_visible_end
instead.
Get the number of lines this window contains (previously set by
set_line_count)
Returns the index of the first currently visible line.
Returns the index of the first line after the currently visible one. If the
return value is $0$ it means that no lines are currently shown (which only
happens if the control is empty). Note that the index returned by this method
is not always a valid index as it may be equal to get_line_count.
Return the item at the specified (in physical coordinates) position or
NOT_FOUND
if none, i.e. if it is below the last item.
Returns true
if the given line is (at least partially) visible or
false
otherwise.
This protected virtual function must be overridden in the derived class and it
should return the height of the given line in pixels.
This function doesn’t have to be overridden but it may be useful to do
it if calculating the lines heights is a relatively expensive operation
as it gives the user code a possibility to calculate several of them at
once.
on_get_lines_hint
is normally called just before
on_get_line_height but you shouldn’t
rely on the latter being called for all lines in the interval specified
here. It is also possible that on_get_lines_hint
will be called for the
lines outside of this interval, so this is really just a hint, not a
promise.
Finally note that lineMin is inclusive, while lineMax is exclusive,
as usual.
Refreshes the specified line — it will be redrawn during the next main loop
iteration.
Refreshes all lines between from and to, inclusive. from
should be less than or equal to to.
This function completely refreshes the control, recalculating the number of
items shown on screen and repainting them. It should be called when the values
returned by on_get_line_height change
for some reason and the window must be updated to reflect this.
Scroll by the specified number of lines which may be positive (to scroll down)
or negative (to scroll up).
Returns true
if the window was scrolled, false
otherwise (for
example if we’re trying to scroll down but we are already showing the last
line).
Scroll by the specified number of pages which may be positive (to scroll down)
or negative (to scroll up).
Scroll to the specified line: it will become the first visible line in
the window.
Return true
if we scrolled the window, false
if nothing was done.
Set the number of lines the window contains: the derived class must
provide the heights for all lines with indices up to the one given here
in its on_get_line_height.
[This page automatically generated from the Textile source at 2023-06-13 21:31:35 +0000]