Inherits fltk::Widget.
Inherited by fltk::FileInput, fltk::MultiLineInput, fltk::NumericInput, fltk::Output, fltk::SecretInput, and fltk::WordwrapInput.
Public Member Functions | |
char | at (int i) const |
bool | copy (bool clipboard=true) |
bool | cut () |
bool | cut (int n) |
bool | cut (int a, int b) |
void | draw (const Rectangle &) |
void | draw () |
int | handle (int) |
int | handle (int event, const Rectangle &) |
bool | handle_key () |
Input (int, int, int, int, const char *=0) | |
bool | insert (const char *t) |
bool | insert (const char *t, int l) |
int | line_end (int i) const |
int | line_start (int i) const |
void | mark (int m) |
int | mouse_position (const Rectangle &) const |
void | position (int p, int m) |
void | position (int p) |
bool | replace (int a, int b, char c) |
virtual bool | replace (int, int, const char *, int) |
void | reserve (int newsize) |
int | size () const |
bool | static_text (const char *, int) |
bool | static_text (const char *) |
bool | text (const char *, int) |
const char * | text () const |
bool | text (const char *) |
bool | undo () |
void | up_down_position (int position, bool extend) |
int | word_end (int i) const |
int | word_start (int i) const |
~Input () | |
Private Member Functions | |
void | erase_cursor_at (int p) |
const char * | expand (const char *, char *, int) const |
float | expandpos (const char *, const char *, const char *, int *) const |
void | minimal_update (int p) |
void | minimal_update (int, int) |
void | shift_position (int p) |
void | shift_up_down_position (int p) |
This is the FLTK text input widget. It displays a single line of text and lets the user edit it. The text may contain any bytes (even '\0'). The bytes 0..31 are displayed in ^X notation, the rest are interpreted as UTF-8 (see fltk::utf8decode()).
The default when() is WHEN_RELEASE. This is fine for a popup control panel where nothing happens until the panel is closed. But for most other uses of the input field you want to change it. Useful values are:
If you wish to restrict the text the user can type (such as limiting it to numbers, a particular length, etc), you should subclass this and override the replace() function with a version that rejects changes you don't want to allow.
If you don't like the keybindings you can override handle() to change them.
All arguments that are lengths or offsets into the strings are in bytes, not the UTF-8 characters they represent.
Input::Input | ( | int | x, |
int | y, | ||
int | w, | ||
int | h, | ||
const char * | l = 0 |
||
) |
The constructor initializes:
Input::~Input | ( | ) |
The destructor destroys the memory used by text()
char Input::at | ( | int | i | ) | const [inline] |
Same as text()[n], but may be faster in plausible implementations. No bounds checking is done.
bool Input::copy | ( | bool | clipboard = true | ) |
Put the current selection between mark() and position() into the selection or clipboard by calling fltk::copy(). If position() and mark() are equal this does nothing (ie it does not clear the clipboard).
If clipboard is true the text is put into the user-visible cut & paste clipboard (this is probably what you want). If clipboard is false it is put into the less-visible selection buffer that is used to do middle-mouse paste and drag & drop.
To paste the clipboard, call fltk::paste(true) and fltk will send the widget a fltk::PASTE event with the text, which will cause it to be inserted.
bool Input::cut | ( | int | n | ) | [inline] |
Wrapper around replace() this deletes up to n characters after the point, or before the point if n is negative. N is bounds checked.
bool Input::cut | ( | int | a, |
int | b | ||
) | [inline] |
Wrapper around replace() this deletes the characters between a and b. The values are clamped to the ends of the string, and b can be less than a.
bool Input::cut | ( | ) | [inline] |
Wrapper around replace(), this deletes the region between the point and the mark. It does nothing if they are equal.
void Input::draw | ( | void | ) | [virtual] |
The default version draws the box and calls draw(x,y,w,h) with the area inside the box. It also draws any inside labels at the left of the text.
Reimplemented from fltk::Widget.
void Input::draw | ( | const Rectangle & | r | ) |
Draw the text, where the passed rectangle is the area the text is to be drawn into. This method is provided so a subclass can place the text into a subrectangle.
If damage()&fltk::DAMAGE_ALL is true, this assummes the area has already been erased to color(). Otherwise it does minimal update and erases the area itself.
void Input::erase_cursor_at | ( | int | p | ) | [private] |
Indicate that a cursor drawn a postion p must be redrawn.
const char * Input::expand | ( | const char * | p, |
char * | buf, | ||
int | wordwrap | ||
) | const [private] |
Copy string p to the buffer, replacing control characters with ^X. Stop at then end of the line, or truncate if necessary so the resulting string and null terminator fits in a buffer of size MAXBUF. Returns pointer to the character after the last one copied.
float Input::expandpos | ( | const char * | p, |
const char * | e, | ||
const char * | buf, | ||
int * | returnn | ||
) | const [private] |
After filling in a buffer with expand(), find the width to e.
int Input::handle | ( | int | event, |
const Rectangle & | r | ||
) |
Default handler for all event types, where the passed rectangle is the area the text is to be drawn into. This method is provided so a subclass can place the text into a subrectangle.
int Input::handle | ( | int | event | ) | [virtual] |
Calls handle(x,y,w,h) with the area inside the box().
Reimplemented from fltk::Widget.
Reimplemented in fltk::NumericInput, and fltk::Output.
bool Input::handle_key | ( | ) |
Handle KEY events. The handle() method calls this. This provides an Emacs and Windows style of editing. Most Emacs commands are first run through fltk::try_shortcut() to test if they are menu items for the program.
For the (obsolete) MULTILINE mode you can also do these:
bool Input::insert | ( | const char * | text, |
int | n | ||
) | [inline] |
Wrapper around replace(). This inserts n characters from the text (including '\0' characters!) at the point and leaves the point after it.
bool Input::insert | ( | const char * | text | ) |
Wrapper around replace(). This inserts the string at the point and leaves the point after it.
int Input::line_end | ( | int | i | ) | const |
Returns the location of the next newline or wordwrap space at or after position.
int Input::line_start | ( | int | i | ) | const |
Returns the location of the start of the line containing the position.
void Input::mark | ( | int | n | ) | [inline] |
Same as position(position(),n)
void Input::minimal_update | ( | int | p, |
int | q | ||
) | [private] |
Indicate that the characters between positions p and q must be redrawn. Currently this just does minimal_update(min(p,q)).
void Input::minimal_update | ( | int | p | ) | [private] |
int Input::mouse_position | ( | const Rectangle & | r | ) | const |
void Input::position | ( | int | new_position, |
int | new_mark | ||
) |
The input widget maintains two pointers into the string. The "position" is where the cursor is. The "mark" is the other end of the selected text. If they are equal then there is no selection. Changing this does not affect the X selection, call copy() if you want that.
Changing these values causes a redraw(). The new values are bounds checked and limited to the size of the string.
It is up to the caller to make sure the position and mark are at the borders of UTF-8 characters!
Reimplemented from fltk::Widget.
void Input::position | ( | int | n | ) | [inline] |
Same as position(n,n)
bool Input::replace | ( | int | b, |
int | e, | ||
const char * | text, | ||
int | ilen | ||
) | [virtual] |
This call does all editing of the text. It deletes the region between b and e (either one may be less or equal to the other), and then inserts ilen (which may be zero) characters from the string text at that point and leaves the mark() and position() after the insertion. If the text is changed the callback is done if the when() flags indicate it should be done.
Subclasses of Input can override this method to control what characters can be inserted into the text. A typical implementation will check the characters in the insertion for legality and then call Input::replace() only if they are all ok.
b and e are bounds checked so don't worry about sending values outside the length of the string.
Subclasses should return true if the keystroke that produced this call should be "eaten". If false is returned the keystroke is allowed to be tested as a shortcut for other widgets. In our experience it is best to return true even if you don't make changes. The base class version returns true always.
Reimplemented in fltk::FloatInput, and fltk::Output.
bool Input::replace | ( | int | a, |
int | b, | ||
char | c | ||
) | [inline] |
Wrapper around replace(). Deletes the characters between a and b and then inserts the single byte c.
void Input::reserve | ( | int | len | ) |
void Input::shift_position | ( | int | p | ) | [private] |
Move the point, move the mark only if shift is not held down.
void Input::shift_up_down_position | ( | int | p | ) | [private] |
Move the point, move the mark only if shift is not held down.
int Input::size | ( | ) | const [inline] |
bool Input::static_text | ( | const char * | str | ) |
Same as static_text(str, str ? strlen(str) : 0)
bool Input::static_text | ( | const char * | str, |
int | len | ||
) |
Same as text(str,len), except it does not copy the string, instead it makes text() return a pointer to str (unless len is 0, in which case it makes it point to a zero-length string).
str must point to static memory that will not be altered until at least the Input widget is destroyed or the text() is changed again. If the user attempts to edit the string it is then copied to the internal buffer and the editing done there. This can save a lot of time and memory if your program is changing the string to various constants a lot but the user rarely edits it.
bool Input::text | ( | const char * | str | ) |
Same as text(str, str ? strlen(str) : 0)
const char * Input::text | ( | ) | const [inline] |
The current string, as edited by the user. There is an extra NUL character at the end, so this returned pointer can be used directly by C functions. size() returns how many bytes are in the string, which is useful if you want to look at embedded NUL characters.
Pointer is to an internal buffer and is only value until the next event is handled by the Input widget.
bool Input::text | ( | const char * | str, |
int | len | ||
) |
bool Input::undo | ( | ) |
void Input::up_down_position | ( | int | i, |
bool | keepmark | ||
) |
Do the correct thing for arrow keys. i must be the location of the start of a line. Sets the position (and mark if keepmark is false) to somewhere after i, such that pressing the arrows repeatedly will cause the point to move up and down.
int Input::word_end | ( | int | i | ) | const |
Returns the location of the next word boundary at or after position.
int Input::word_start | ( | int | i | ) | const |
Returns the location of the first word boundary at or before position.