vbox

set_fixed_height_form_font works in Gtk2, but behaves differently in Gtk3.

My solution (in the OCaml interface, as originally posted), was to compute the height explicitly following cell_renderer_text.get_size:

This is what I came up with, try it and see if it is what you want.

You may need to change some things to reach your final desired layout, but hopefully this addresses your immediate wrapping issue.

I think the BASELINE_CENTER alignment on the outer VBox was confusing things, but I changed a couple of other things, so it may have been something else.

There are several misunderstandings in your code. The first is about cells and reuse (a TableRow is a Cell). Cells can be reused arbitrarily, and potentially frequently (especially during user scrolling) to stop displaying one item and display a different one.

In your code, if the row is used to display an entity that is invalid, the listener on the row's itemProperty will trigger the runnable on the background thread, which will at some point set the pseudoclass state to true.

If the cell is subsequently reused to display a valid item, however, the next runnable that is executed does not change the pseudoclass state. So that state remains true and the row color remains red.

Consequently, a row is red if it ever displayed an invalid item at some point. (Not if it is currently displaying an invalid item.) If you scroll enough, eventually all cells will be red.

Secondly, you must not update any UI that is part of the scene graph from any thread other than the FX Application Thread. Additionally, some other operations, such as creating Window instances (Tooltip is a subclass of Window) must be performed on the FX Application Thread. Note that this includes modifying model properties which are bound to the UI, including properties used in the table columns. You violate this in your validationThread, where you create a Tooltip, set it on the row, and change the pseudoclass state, all in a background thread.

A good approach here is to use the JavaFX concurrency API. Use Tasks which, as far as possible, use only immutable data and return an immutable value. If you do need to update properties which are displayed in the UI, use Platform.runLater(...) to schedule those updates on the FX Application Thread.

In terms of MVC design, it is a good practice for your Model class(es) to store all the data needed by the View. Your design runs into trouble because there is no real place where the validation status is stored. Moreover, the validation status is really more than just "valid" or "invalid"; there is a phase while the thread is running but not completed where the validation status is unknown.

Here's my solution, which addresses these issues. I am assuming:

1. Your entity has a notion of validity.
2. Establishing the validity of an entity is a long-running process
3. Validity depends on one or more properties which may change while the UI is displayed
4. The validity should be "lazily" established, on an as-need basis.
5. The UI prefers not to display "unknown" validity, and if an entity is displayed whose validity is unknown, it should be established and redisplayed.

I created an enum for ValidationStatus, which has four values:

So Qt doesn't offer this, but you can ask your OS to do it for you.

Assuming you're just looking at Windows, you can change the current keyboard layout in python using pywin32, which lets you easily access the Windows API from your script. Once installed into your Python environment you can import win32api and then use a call like win32api.LoadKeyboardLayout('00000809',1) to set the layout (the values I've put here set it to UK English). The first parameter is a string representing the keyboard layout to use, and the second is a flag. See documentation.

I found this list of KLIDs (Keyboard Layout IDs), which shows two for Tamil keyboards. "00000449" is Tamil, "00020449" is Tamil 99. The 449 at the end means Tamil, and the two digits before set which subtype of Tamil keyboard to use (e.g. 20 for Tamil 99) - I can't find one for Tamil phonetic, but maybe you'll be able to find it.

You can set up your program to call these functions whenever you want it to switch keyboard (for example, when your user activates a specific text input box).

Also, if you want to check the current keyboard layout you can use win32api.GetKeyboardLayout(0) (doc). Maybe you can use this to figure out what the IDs are for each of the Tamil keyboards you want to use. Mind that it returns an int for the locale id rather than a string.

Other useful keyboard related functions are win32api.GetKeyboardLayoutList() (to find all the locales installed on the current machine), win32api.GetKeyboardLayoutName() and win32api.GetKeyboardState - documentation for all these can be found here.

To do store.sync() you need to set values on the record first.

Example is without ViewModel: https://fiddle.sencha.com/#fiddle/3isg&view/editor

The long execution time comes from the fact that each child of a Parent registers a listener with the disabled and treeVisible properties of that Parent. The way JavaFX is currently implemented, these listeners are stored in an array (i.e. a list structure). Adding the listeners is relatively low cost because the new listener is simply inserted at the end of the array, with an occasional resize of the array. However, when you remove a child from its Parent and the listeners are removed, the array needs to be linearly searched so that the correct listener is found and removed. This happens for each removed child individually.

So, when you clear the children list of the Group you are triggering 1,000,000 linear searches for both properties, resulting in a total of 2,000,000 linear searches. And to make things worse, the listener to be removed is either--depending on the order the children are removed--always at the end of the array, in which case there's 2,000,000 worst case linear searches, or always at the start of the array, in which case there's 2,000,000 best case linear searches, but where each individual removal results in all remaining elements having to be shifted over by one.

There are at least two solutions/workarounds:

1. Don't display 1,000,000 nodes. If you can, try to only display nodes for the data that can actually be seen by the user. For example, the virtualized controls such as ListView and TableView only display about 1-20 cells at any given time.

2. Don't clear the children of the Group. Instead, just replace the old Group with a new Group. If needed, you can prepare the new Group in a background thread.

   Doing it that way, it took 3.5 seconds on my computer to create another Group with 1,000,000 children and then replace the old Group with the new Group. However, there was still a bit of a lag spike due to all the new nodes that needed to be rendered at once.

   If you don't need to populate the new Group then you don't even need a thread. In that case, the swap took about 0.27 seconds on my computer.

I don't know AnimateFX, but using the standard libraries you can add animations to a SequentialTransition.

For example, to animate each node but starting at a later time, add PauseTransitions of increasing duration and the desired animation to SequentialTransitions, and play the SequentialTransitions.

As I said, I'm not familiar with the library you're using, but I think it would look like this:

The short answer is use applyCss():

Generate a layout pass before setting the scroll value. To generate a layout pass see:

• Get the height of a node in JavaFX (generate a layout pass)