FLTK::Input - One-line text input field
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 utf8decode()).
\0
0..31
^X
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:
when()
WHEN_RELEASE
WHEN_NEVER
The callback is not done, but changed() is turned on.
changed()
WHEN_CHANGED
The callback is done each time the text is changed by the user.
WHEN_ENTER_KEY
Hitting the enter key after changing the text will cause the callback.
WHEN_ENTER_KEY_ALWAYS
The Enter key will do the callback even if the text has not changed. Useful for command fields. Also you need to do this if you want both the enter key and either WHEN_CHANGED or WHEN_RELEASE, in this case you can tell if Enter was typed by testing event_key() == FLTK::EnterKey.
event_key() == FLTK::EnterKey
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.
replace()
If you don't like the keybindings you can override handle() to change them.
handle()
All arguments that are lengths or offsets into the strings are in bytes, not the UTF-8 characters they represent.
at
my $chr = $input->at( $index );
Same as text()[$index], but may be faster in plausible implementations. No bounds checking is done.
text()[$index]
copy
my $okay = $input->copy( $to_clipboard );
Put the current selection between mark() and position() into the selection or clipboard by calling copy(). If position() and mark() are equal this does nothing (ie it does not clear the clipboard).
mark()
position()
copy()
If to_clipboard is true, the text is put into the user-visible cut & paste clipboard (this is probably what you want). If to_clipboard is false, it is put into the less-visible selection buffer that is used to do middle-mouse paste and drag & drop.
to_clipboard
To paste the clipboard, call paste(1) and fltk will send the widget a PASTE event with the text, which will cause it to be inserted.
paste(1)
PASTE
cut
my $okay = $input->cut( );
Wrapper around replace(), this deletes the region between the point and the mark. It does nothing if they are equal.
my $okay = $input->cut( $length );
Wrapper around replace() this deletes up to length characters after the point, or before the point if length is negative. length is bounds checked.
length
my $okay = $input->cut( $begin, $end );
Wrapper around replace() this deletes the characters between begin and end. The values are clamped to the ends of the string, and end can be less than begin.
begin
end
handle_key
my $handled = $input->handle_key( );
Handle KEY events. The default handle() method calls this. This provides an Emacs and Windows style of editing. Most Emacs commands are first run through try_shortcut() to test if they are menu items for the program.
KEY
try_shortcut()
Shift
LeftKey
Ctrl+B
Ctrl+LeftKey
Alt+B
RightKey
Ctrl+F
Ctrl+RightKey
Alt+F
Ctrl+A
HomeKey
EndKey
Ctrl+Insert
Shift+Insert
Shift+Delete
Delete
Ctrl+D
Ctrl+Delete
Alt+D
BackSpace
Ctrl+H
Ctrl+BackSpace
Alt+H
Return
KeypadEnter
when() & WHEN_ENTER_KEY
Ctrl+K
Ctrl+C
Ctrl+T
Ctrl+U
Ctrl+V
Ctrl+X
Ctrl+W
Ctrl+Y
Ctrl+Z
Ctrl+/
compose()
For Input widgets in WORDWRAP mode, you can also do these:
WORDWRAP
UpKey
Ctrl+P
DownKey
Ctrl+N
PageUpKey
PageDownKey
Ctrl+HomeKey
Alt+A
Ctrl+EndKey
Alt+E
Ctrl+O
This method may be overridden for subclassing.
insert
my $okay = $input->insert( $text );
Wrapper around replace(). This inserts the string at the point and leaves the point after it.
my $okay = $input->insert( $text, $length );
Wrapper around replace(). This inserts length characters from the text (including \0 characters!) at the point and leaves the point after it.
text
line_end
my $index = $input->line_end( $position );
Returns the location of the next newline or wordwrap space at or after position.
position
line_start
my $index = $input->line_start( $position );
Returns the location of the start of the line containing the position.
mark
my $mark = $input->mark( );
$input->mark( $new_mark );
Same as $input>position($input->position(),$index).
$input>position($input->position(),$index)
mouse_position
my $index = $input->mouse_position( $rectangle );
Figure out what character the most recent mouse event would be pointing to, assumming you drew the text by calling draw() with the same rectangle. Returns 0 if the mouse is before the first character, and size() if it is after the last one.
draw()
rectangle
0
size()
new
my $input = $input->new( $x, $y, $w, $h, $label );
Creates a new FLTK::Input object. Obviously.
FLTK::Input
my $pos = $input->position( );
Returns the current location of the cursor.
$input->position( $new_position );
Same as position($new_position, $new_position).
position($new_position, $new_position)
$input->position( $new_position, $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.
redraw()
It is up to the caller to make sure the position and mark are at the borders of UTF-8 characters!
replace
my $return = $input->replace( $begin, $end, $text, $length );
This call does all editing of the text. It deletes the region between begin and end (either one may be less or equal to the other), and then inserts length (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.
begin and end are bounds checked so don't worry about sending values outside the length of the string.
reserve
$input->reserve( $newsize );
Reserve the interal private buffer of at least newsize bytes, even if the current text() is not that long. Can be used to avoid unnecessary memory reallocations if you know you will be replacing the text() with a longer one later.
newsize
text()
size
my $length = $input->size( );
Returns the number of characters in text(). This may be greater than length($input-text())> if there are NULL characters in it.
length($input-
NULL
static_text
my $ret = $input->static_text( $string, $length );
Same as text($string, $length), except it does not copy the string, instead it makes text() return a pointer to $string (unless $length is 0, in which case it makes it point to a zero-length string).
text($string, $length)
$string
$length
$string 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.
my $ret = $input->static_text( $string );
Same as $input->static_text($string, $string ? length($string) : 0).
$input->static_text($string, $string ? length($string) : 0)
my $different = $input->text( $string, $length );
Change the text() to return the first length bytes of string and size() to return length, and set the position() to length and the mark() to zero (thus highlighting the entire value).
string
Returns true if the bytes in the new string are different than the old string.
my $different = $input->text( $string );
Same as $input->text($string, $string ? length($string) : 0).
$input->text($string, $string ? length($string) : 0)
my $string = $input->text( );
The current string, as edited by the user. size() returns how many bytes are in the string.
undo
my $okay = $input->undo( );
If this is the most recent widget on which replace() was done on, this will undo that replace() and probably several others (ie if the user has typed a lot of text it will undo all of it even though that was probably many calls to replace()). Returns true if any change was made.
up_down_position
$input->up_down_position( $position, $keepmark );
Does the correct thing for arrow keys. position must be the location of the start of a line. Sets the position (and mark if keepmark is false) to somewhere after position, such that pressing the arrows repeatedly will cause the point to move up and down.
keepmark
word_end
my $index = $input->word_end( $position );
Returns the location of the next word boundary at or after position.
word_start
my $index = $input->word_start( $position );
Returns the location of the first word boundary at or before position.
xscroll
my $x = $input->xscroll( );
yscroll
my $y = $input->yscroll( );
type
NORMAL
FLOAT_INPUT
INT_INPUT
SECRET
The following methods may be overridden in subclasses of FLTK::Input:
handle
You may override handle which accepts an event and a rectangle. 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.
event
The default handle...
Handles FOCUS, UNFOCUS
FOCUS
UNFOCUS
May do callback on HIDE
HIDE
Any keystrokes call handle_key()
handle_key()
Handles PUSH, DRAG, RELEASE to select regions of text, move the cursor, and start drag & drop. Double click selects words, triple click selects lines (triple click is broken on Windows).
PUSH
DRAG
RELEASE
Receives drag&drop and accepts.
Handles PASTE events caused by accepting the drag&drop or by calling paste() (which handle_key() does for ^V)
paste()
^V
Sanko Robinson <sanko@cpan.org> - http://sankorobinson.com/
Copyright (C) 2008-2010 by Sanko Robinson <sanko@cpan.org>
This program is free software; you can redistribute it and/or modify it under the terms of The Artistic License 2.0. See the LICENSE file included with this distribution or notes on the Artistic License 2.0 for clarification.
When separated from the distribution, all original POD documentation is covered by the Creative Commons Attribution-Share Alike 3.0 License. See the clarification of the CCA-SA3.0.
To install FLTK, copy and paste the appropriate command in to your terminal.
cpanm
cpanm FLTK
CPAN shell
perl -MCPAN -e shell install FLTK
For more information on module installation, please visit the detailed CPAN module installation guide.