I'm fairly new at d3 and I've built the code from a couple of sources so it's probably just that I have it initializing incorrectly but I'm not seeing what it is. The page I'm building dynamically fetches geojson from a database and renders a simple map with a label. This works correctly but whe I added code to give the map zoom/pan functionality the map behaves correctly but the transform on the text moves the label to 0 postition with the <g> element and I'm not sure why? When I zoom in the map and text increases in size as expected but the text position stays at 0/0.
Instead of dumping a lot of code here I've put together this fiddle so that it could easily be seen and tested.
I think that anyone more familiar with d3 probably knows what I've got wrong here. I would sure appreciate someone pointing it out to me. Thanks
See your problem saved in the fiddle:
const items = g.selectAll('g.item')
.data(bb.features)
.enter()
.append('g')
.classed('item', true);
items.append('path').attr(...)
items.append('text').attr(...)
Instead of entering path and text elements separately, enter a g container and then append path and text under the g.
I want to update a circle and text element at the same time. I was able to make it work with only the circle:
https://plnkr.co/edit/FckQcVd1EkYLoZggmJN4
However, when I try adding a wrapping g to contain the circle and text it doesn't update properly.
https://plnkr.co/edit/EtL11O5qQph0xAeu88mu?p=preview
Any insight how to fix it?
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.
I am trying to design a little game using JS, and what I want it to do is make a random number say... 1-100 and then randomly scatter the dots (I used periods with the font size at 200) on the screen. By random, I just mean that I don't want them to be arranged in rows and columns. What I have so far achieves all but scattering the dots, so how do I do that?
var i=0;
var inhtml="."
var num=10
function exe(){
i=Math.floor(Math.random()*100)
//alert(i)
while (i<=100){
document.getElementById("dot").innerHTML = inhtml + "."
inhtml = document.getElementById("dot").innerHTML
if (inhtml.length>num){
inhtml=document.getElementById("dot").innerHTML+"<br />"
num=num+20
}
i++;
}
}
Instead of using a single element containing several periods at a large size, I'd recommend using separate elements for each dot. Then, (besides not having to use 200px periods), you can use CSS to position each element however you want. I have an example here.
Edit: I don't know what the exact problem with getting the dots to not overlap you're having is, but you basically need to do this:
First you pick a position. Then, you check that position against all the other positions (which you'd probably want to do using Manhattan distance). If the point is valid, you use that point and add it to the array of taken positions. Otherwise, go back to the first step.
You may want to check your syntax errors before progressing; I do not know whether you copied all of your code, but you are missing semicolons at the end of your lines. Syntactical issues aside, one possible way to achieve what you describe would be to assign the x- and y-coordinate of each point to a random number. Examination of the code reveals that only the initial value of i is assigned to the value of random(). Incrementing i will make the coordinates of future points dependent on the initial value of i, which is something you may want to take into account. But nowhere in your code do I see you changing the position of the each element based on the values you generate.
I strongly suggest that you use the HTML5 Canvas instead of attempting to move HTML elements; the latter would be cumbersome and lead to messy and inefficient code. If you still want to stick to the method you are trying to use now, check to make sure that the CSS display property is set to block for these elements. You are using the getElementById() method, which is not very useful in this circumstance, since IDs are unique in HTML files. I would suggest using getElementsByTagName() and using those returned elements with a specific class attribute instead.
You might want to look at the HTML 5 Canvas. It allows you draw arcs (aka circles) In any postion, size, and fill color.
Look here for details, here for a tutorial, and here for a demo.
To not be bound by the browser's text layout constraints, you pretty much have to absolutely position your dots:
<div style="position: absolute; top: {random number}; left: {random number}">.</div>
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.