I know I can use the following line to get the offset of the caret (cursor position) relative to the current element:
offset = window.getSelection().getRangeAt(0).startOffset;
But sometimes the element will contain a lot of text, and the text will wrap. How can I find the offset relative to the nearest wrap (if any)?
For instance, given the following text which is all in one element:
<p>abcdefghjiklmnopqrstuvwxyz test</p>
Suppose it is automatically line-wrapped as follows:
abcdefghjiklmnopqrstuvwxyz
test
^cursor before this 't'
If the cursor is between the "s" and "t" in test, the above code will assign a value of 30 (26 characters on 1st line, plus space, plus t,e, and s.) to offset. But I want it to return 3 in this case: relative to the apparent start of the line, the cursor is only offset 3 ('t', 'e', and 's' come before the cursor.)
How can I accomplish this in plain, cross-platform javascript?
Update:
In case there is an easier way to accomplish what I am trying to do, here it is. I have a table of elements that I am individually turning into content editable blocks. When the down arrow is released and I see that the arrow was moved to the end of the TD, I move the focus (and the content editable) to the next cell down. However, I also need to position the cursor so it is below where it previously was on the previous line. I'm using a monospaced font, so just using the same offset as the previous apparent start of line would be sufficient.
Setting the entire table to be contentEditable doesn't work, because the behavior of the arrow keys isn't what I want. For instance, when I press down at the bottom of the field, it moves the cursor to the start of the next field to the right, which makes no sense to me.
You can use Range.prototype.getClientRects() to obtain the bounding client rects for a range. If there is a text node wrapping around to a second line, for instance, its range will have rects for each line. You can create a ‘sentinel’ range just to read its rects, then adjust it in a loop until the rect’s top or bottom changes, wind it back a bit, and check out its position. Then compare its position to your starting point and you will have the line-relative offset.
I think this question is simple, but I've been unable to figure it out. I hit a stopping point using the simpler solution for getting the caret position in a contenteditable div from Get caret position in contentEditable div. I've been attempting to get the line number of the caret position, and I've got a lot of the logic done, but because that one treats the end of one line the same as it treats the start of the next, it's proven pretty much impossible.
So, instead I've been trying to use the rangy library to get the caret position, in the hope that it treats the end of lines appropriately(counting the end of a line as one less than the start of the next,) but I haven't quite figured out how to get it to work the way I'd like. My code looks like this:
var sel = rangy.getSelection();
var range = sel.getRangeAt(0);
var cursorPos = sel.focusOffset;
It seems to work when I hit enter to go to a new line (the position is incremented by 1) but after that the caretPos starts again at 0 at the start of each line. Is there a way to get an overall cursor position, which accounts for new lines? To be clear, I'm not asking how to get the line number from rangy, just the caret position.
Thank you, and sorry if I'm missing something obvious.
Rangy by itself does not have the capability to give you line numbers. sel.focusOffset in the code you show in the question is either an offset among the children of an element node or an offset in the text of a text node. If it appears to you to correspond to a line number, this is just chance.
Basically, rangy would not play an essential role in the problem you are presenting. Whatever system that would be able to provide line numbers would be able to work independently of rangy.
Edit in response to comment: Your question says "in the hope that it treats the end of lines appropriately(counting the end of a line as one less than the start of the next,)". Since the topic of conversation is Rangy, I'm understanding "it" as "Rangy." Rangy does not have a notion of "end of line", so it cannot treat them in any fashion.
I'm not sure if this is possible, but here goes:
I want to find the y co-ordinate of some text. For my purposes, the y co-ordinate of the element containing that text does not suffice. Here's why:
http://jsfiddle.net/3kh3p/
In the above jsfiddle are two characters, one in Georgia, one in Verdana. They are both positioned absolutely with top:0. As you can see, the Verdana character begins at a lower point than the Georgia character.
I need to get the y co-ordinate of the text itself, fairly accurately, because I am using that value to write text to an image using PHP's imagettftext function, and being 5 or 10 pixels out is not OK.
Is there a way?
The only way I can think of would be to draw the text (fillText) into a canvas element, and then query the element's pixel data (getImageData and such) to find out where a given character actually starts vertically according to whatever criteria you want to use (e.g., do you want to ignore upward serifs or not, etc.). Not for the faint of heart, if there's any other way to achieve your overall goal, I'd look elsewhere.
Currently I'm getting the selected text in the browser doing this:
window.getSelection();
Now I need to show a tooltip above that text when pressing a custom key(note that the mouse could not be over the text anymore), so in order to do that I need the absolute position of that selected text.
Is there a way to do that, maybe wrapping that text inside a tag and then getting the offsets? It just has to work in Chrome, not all browsers.
s = window.getSelection();
Returns a Selection. So try
s = window.getSelection();
oRange = s.getRangeAt(0); //get the text range
oRect = oRange.getBoundingClientRect();
oRect will be the bounding rectangle in client (fixed) coordinates.
The easiest way is to insert a temporary marker element at the start or end of the selection and get its position. I've demonstrated how to do this before on Stack Overflow: How can I position an element next to user text selection?
Before using getBoundingClientRect, you need to know this note:
CSSOM working draft specifies that it returns a ClientRect for each border box
And by this 'standard':
For an inline element, the two definitions are the same. But for a block element, Mozilla will return only a single rectangle.
So if anyone reading this post wants a general solution for more precise positions and layouts of selected texts, I suggest the following approaches:
Option 1: Find exact starting and and ending point of texts by inserting invisible elements. Then calculate selected line rectangles with extracted computed line height and container width. APIs in use: window.getComputedStyle.
Pro: the result would be most precise for each line of text.
Con: 1) If the selection is across several nodes with different line heights and widths, the algorithm becomes complex. 2) And you need to implement the computation algorithm, which is too time consuming when implementing a simple feature.
Option 2: Wrap each text with a carefully styled inline element, extracting
layout of each box, and merge results into lines.
Pro: Works for all continuous selections (that basically means all cases in current mainstream browser implementations.). Good enough precision for each line of texts.
Con: 1) Its result is a little inaccurate in some cases, as it adds error widths of kerning. 2) It's slow on very large selection of texts.
For option 2, rangeblock is an existing implementation with an easy API which gives you the absolution layout of each line of text:
let block = rangeblock.extractSelectedBlock(window, document);
console.info("Text layout: " + JSON.stringify(block.dimensions));
// output: Text layout: {Left: 100, Top: 90, Width: 200, Height: 50}
Any suggestion is highly appreciated.
Text selection has many components to it some visual, some non-visual.
First, make text selectable you must keep an array, of where the text is, what the text is, and what font was used. You will use this information with the Canvas function measureText.
By using measureText, with your text string, you can identify what letter the cursor should land on when you click on an image.
ctx.fillText("My String", 100, 100);
textWidth = ctx.measureText("My String").width;
You will still have to parse the font height from the "font" property,
as it is not currently included in text metrics. Canvas text is aligned
to the baseline by default.
With this information, you now have a bounding box, which you can check against.
If the cursor is inside of the bounding box, you now have the unfortunate task of deducing
which letter was intentionally selected; where the start of your cursor should be placed. This may involve calling measureText several times.
At that point you know where the cursor should go; you will need to store your
text string as a text string, in a variable, of course.
Once you have defined the start and stop points of your range, you have to draw
a selection indicator. This can be done in a new layer (a second canvas element),
or by drawing a rectangle using the XOR composition mode. It can also be done by
simply clearing and redrawing the text on top of a filled rectangle.
All told, text selection, text editing in Canvas are quite laborious to program, and it would be wise to re-use components already written, Bespin being an excellent example.
I'll edit my post should I come across other public examples. I believe that Bespin uses a grid-based selection method, possibly requiring a monospaced font. Ligatures, kerning, bi-directionality and other advanced features of font rendering require additional programming; it's a complex problem.
TextInput controls are complicated
Let me begin by saying I am not an expert in text controls, but by now I'm sure that this doesn't matter, because I can help you get into the woods and out safely. These things are complicated in nature and require plenty of intuition and knowledge of how things work. However, you can inspect the code that runs in the senpai-js/senpai-stage repository here.
We should define a few things up front:
Text can be any valid unicode character. You can parse that using this regex: /^.$/u
You need to keep track of three different sorts of text editing modes: Insert, Selection, Basic (I use the SelectionState enum in my library and inspect the insertMode property on stage)
You should implement sanity checks at every turn, or you will have undefined and unexpected behavior
Most people expect text inputs to be sizable by width, so make sure you use a pattern for the innards of the text box if you plan on using a texture
mouse/touch point collision detection is complicated unless you guarantee that the text input control won't rotate
The text should scroll when it's larger than the textbox in the horizontal direction. We will refer to this as textScroll which is always a negative number
Now I will go over each function to describe it's behavior to describe exactly how a textbox control should work.
Collision (broadPhase, and narrowPhase)
Collision detection is a monster. Normalizing point movement between mouse and touch events is a complicated beast not covered in this text. Once you handle point events, you have to perform some sort of general collision detection for a rectangle. This means doing AABB collision. If the textbox sprite itself is rotated, you will have to "un-rotate" the point itself. However, we bypass this check if the mouse/touch point is already down over the textbox. This is because once you start selecting text, you want this function to always return true. Then we move to narrowPhase collision, which actually checks to see if the "un-transformed" mouse/touch point is within the padding of the textbox. If it is, or the textbox is active, we return a truthy value here.
Once we know that the mouse/touch point is within the bounds of our textbox, we change the css of the canvas to cursor: text; visually.
pointCollision
When we press the mouse button down over the textbox, we need to calculate where to move the caret. The caret can exist in a range from 0 to text.length inclusive. Note that this isn't exactly right because unicode characters can have a length of 2. You must keep track of each character added to your text inside an array to assert that you aren't measuring faulty unicode characters. Calculating the target index means looping over each character of the current text and appending it to a temporary string, measuring each time until the measured width is greater than the current textScroll + the measured textWidth.
Once we have garunteed that the point has gone down on top of the textbox and the starting point is set, we can start the "selection" mode. Dragging the point should move the selection from the starting caretIndex to the new calculated end index. This goes in both directions.
An example of this is shown here.
keyPresses
The solution for web key presses is to inspect the key property on the KeyEvent. Despite a lot of what everyone says, it's possible to test that text property by testing it against the aforementioned unicode regex. If it matches, chances are that key has actually been pressed on the keyboard. This doesn't account for key combinations like ctrl + c and ctrl + v for copy and pasting. These features are trivial and are left up to the reader to decide how to implement these.
The few exceptions are the arrow keys: "ArrowLeft", "ArrowRight" etc. These keys actually modify the state of your control, and change how it functions. It's important to remember that key events should only be handled by the currently focused control. This means you should check and make sure the control is focused during text input. This of course happens at a higher level than I have coded in my library, so this is trivial.
The next problem that needs to be solved is how each character input should modify the state of your control. The keyDown method discerns the selectionState and calls a different function based on it's state. This is not optimized pseudo-code, but is used for clarity, and is perfect for our purposes in describing the behavior.
keydown on a selection
Normal key presses replace the content of the selected text
Splice out from selectionStart, and insert the new key into the text array
if "delete" or "backspace" is pressed, splice out the selection and return the selection mode to Normal or Caret
if the "left" or "right" key is pressed, move the cursor to the beginning or the end respectively and return the selection mode to Normal unless the shift key is pressed
if the shift key is pressed, then we actually want to extend the selection further
selection start will always be at the caretIndex, and we essentially move the selection end point left or right with this key combination
if selection end returns back to the caret index, we return the selectionState to Normal again
the "home" and "end" keys work the same way, only the caret is moved to 0 and text.length indexes respectively
also note that holding down the shift key extends selection from the caretIndex once again
keydown on normal mode (caret mode)
in caret mode, we don't replace any text, just insert new characters at the current position
keydowns that match the unicode regex are inserted using the splice method
move the caret to the right after splicing the text in (check and make sure that you don't go over text length)
Backspace removes one character before the index at caretIndex - 1
Delete removes one character after the index at caretIndex
text selection applies for left and right keys while the shift key is pressed
when shift isn't pressed, left and right move the caret to the left and right respectively
the home key sets the caretIndex to 0
the end key sets the caretIndex to text.length
keyDown on insert mode
in insert mode, we replace the currently selected character at caretIndex
keydowns that match the unicode regex are inserted using the splice method
move the caret to the right after splicing the text in (check and make sure that you don't go over text length)
the backspace remove the character BEFORE the current selection
delete removes the currently selected character
the arrow keys work as expected and described in normal mode
the home and end keys work as expected and described in normal mode
updating the textbox every frame
If the textbox is focused, you should start flashing the caret to let the user know they are editing text in the textbox
when moving the caret left or right in Caret mode, you should restart the flash mechanism so that it shows exactly where they are each time the caret moves
Flash the caret about once every 30 frames, or half a second
measure how far the caret is along the text by using ctx.measureText to the caret index by slicing the text to the caret position unless the mode is Selection
It's still useful to measure how far along the text is in selection mode Selection, because we always want the end of the text selection to be visible to the user
Make sure that the caret is always visible within the visible bounds of the textbox, taking into account the current textScroll
rendering the textbox
save the context first ctx.save() (basic canvas)
if you are not drawing the textbox with paths, draw the left cap of the textbox, draw the middle pattern, and the right cap respectively on the first layer
use a path defined by the padding and the size of the textbox to clip out a square to prevent the text from bleeding out
translate to the x textScroll value which should be a negative number
translate to the y midline value which should be the middle of the textbox vertically
set the font property
set the text baseline to middle and fill the text by calling text.join("") on your text array
if there is a selection, or insert mode, make sure to draw a "blue" square behind the selected text and invert the font color of the selected text (this is non-trivial and left to the reader as an exercise)
the text drawn in canvas elements cannot be selected, because of the nature of the canvas tag. But there are a few workarounds, like the one used in typefaceJS.
Another solution would be to add text with positioned div elements instead of useing strokeText or fillText.
If you need to have selectable text it would be a lot easier to just create a div or whatever, and position it on top of the canvas where you want the text to show.
canvas does not have any built-in mechanism for selecting text, so you would have to roll out your own text rendering and selecting code - which can be rather tricky to get right.
You may get some ideas from Bespin.
They implemented a text editor in javascript using canvas with text selection, scroll bars, cursor blinking, etc.
Source Code
I would suggest using EaselJS library, you can add each letter as a child and even add mouse events to that object, its an amazing library, go check it out!
A simple answer would be: either use HTML or SVG instead of canvas. Unless you really need the degree of lowlevel control canvas offers.
FabricJS now has the ability to interact with objects outside the canvas element - eg this demo shows a button that is linked to an image loaded in a canvas element.
The same approach can be used in other libs such as Raphael by hooking any move event, getting the bounding box of the element and re-positioning the HTML element.
canvas is just a drawing surface. You render and the result is pixels. So, you'd need to track the positions of all text you have rendered to the canvas in a some kind of data structure which you'd process during mouse events.