Need help to understand if Flutter can help us.
We are looking at flutter for app development for a rewrite of a js electron for desktop and js webview for mobiles.
It is basically a sophisticated reading app with multiple dictionaries and searching algorithms and other features specific to an Asian language and also English parallel translations.
We want to display Religious books in the native Unicode language with extensive dictionary support.
The books will have some bold and heading text markup (the markup style can be any format but we currently use html styles).
The books will be in a sqlite DB and streamed to the user.
The books will be stored in the db by paragraph.. We need to display this in a built up flow to the user.
The books will have some items which can be displayed or hidden upon user request but we can regenerate the display if needed. (currently it does live through js).
The books will need to communicate if a tap() or Textselect() event has been called (we often tap to select a word and it goes to a custom dictionary).
Searching for strings in the book will be done by paragraph and then we need to 1) highlight the text and bring the user to that text.
We wish to implement infinite scroll or "Lazy load" as the books are very big and often text processing to change the native script font is involved before display.
Conclusion
I think this captures much of what we want to have.
I have done some work in flutter, but i'm very new to it.
It seems that there is a SelectableText.rich widget and perhaps we could connect them together in an infinite scroll list widget from pub.dev
For hiding the page numbers.. and alt readings, it is fine to reload the book and remove those as we feed the widget with text.
There are a few html widgets, but I'm not sure if it gives select and tap events.
Can Flutter do this for us?
Are there packages that I'm not aware of?
Am I heading in the wrong direction?
I have done a test called https://github.com/bksubhuti/mydbtest
It seems to work.. the selecting of texts are off by a few bits, but it is workable..
However, I have found a full app for my purpose already written in flutter with a sqlite philosophy already working. The dev and myself are in touch and the project has been upgraded to null safety. Flutter is awesome. In about a month.. part time.. I have learned flutter and written my first app and submitted it to the play store called Buddhist Sun. (pending approval). I use sqflite and the multiplatform eq for getting cities.. the db search of cities was more of a flutter tutorial for me than purpose.
https://github.com/bksubhuti/buddhist_sun
Flutter will be the language of the future. I'm so amazed at how great it works and all the packages on pub.dev
Currently I am programming the Web Application based on Vaadin. I am quite happy with the learning cycle and the way how easy UI can be designed.
In general pluses of Vaadin are:
"Native" UI programming for Java users (component hierarchy / event listeners / drag & drop / validation).
Out-of-box nice collection of components (tree / table / list / ...).
The minuses are:
Big and complex HTML output. That slows down the browser response time (also mentioned here and there) and leads to some rendering peculiarities from browser to browser.
Difficulties in handling big number of components (see Can CustomLayout handle 5000 components?).
The need to recompile the widget set if you use 3rd party components.
My question to community is:
What Web Framework fits best the following requirements:
Separation of presentation with event/action handlers.
Common components out of box (with advanced features like table column drag&drop, lazy loading).
Layout support (no headache with padding and alignment of components).
Event propagation to server and server-side event processing.
Possibility to generate your HTML (if framework is not HTML-based) and also capture events for it (e.g. mouse clicks).
Possibility to register key stoke callbacks (e.g. Ctrl-S) is a plus.
Short learning curve for Java developer is a plus.
The sensible mix of approaches would fit as well. Please, provide the link for "Hello World" application, implemented based on the framework that you suggest. I am considering Apache Wicket / Echo2 / Tapestry / Click / GWT, but it's difficult to make a choice without playing for couple of months (hopefully with no deep disappointment).
I completely agree with all your mentioned minuses and can not say very much against. Because I'm quite new in GWT I can only share my little experience I have collected other last 2 months.
Separation of presentation with event/action handlers.
I think UiBinder with annotation #UiHandler("closeButton") #UiField in GWT 2.0 and later is exactly for separation HTML form code and handlers. Also MVP pattern with event bus is perfect answer from GWT team.
Short learning curve for Java developer is a plus.
I'm not naive and I don't think that it's possible to get quality result only with java knowledge without understanding WEB technologies.
Most of GWT UI frameworks I have reviewed and read about, introduces more problems than solutions. They somehow manages to and one or few benefits and restrict you from other features which comes in the new releases of GWT. I have chosen not to use vaadin because I felt like It will force me to do webapp development in their way, which I agree is fast easy to understand, but somehow limited. I like to have some freedom by choosing classic GWT without fancy controls.
Also I also feel that GWT UI Components are limited and there is no quality alternatives. Something is wrong here. I think google team have to do something on this part.
Regards RemisB
You can use a Vaadin Table to solve the original problem, more or less like this. The trick is to create a Vaadin Container and put components in it, as data. On the text side, wrap a label in VerticalLayout then add a click listener. This yields the ability to display "paragraphs" of XHTML text, detect clicks on them with relative locations, and still be able to handle large numbers of paragraphs.
You might need to modify your styles.css to allow wrapping of text within a table row, so you'll get ragged rows.
package com.soletta.clickytable;
import com.vaadin.Application;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.event.LayoutEvents.LayoutClickEvent;
import com.vaadin.event.LayoutEvents.LayoutClickListener;
import com.vaadin.terminal.Sizeable;
import com.vaadin.terminal.gwt.server.WebApplicationContext;
import com.vaadin.ui.Button;
import com.vaadin.ui.Label;
import com.vaadin.ui.Table;
import com.vaadin.ui.VerticalLayout;
import com.vaadin.ui.Window;
import com.vaadin.ui.Window.CloseEvent;
import com.vaadin.ui.Window.CloseListener;
public class ClickytableApplication extends Application {
#Override
public void init() {
Window mainWindow = new Window("Clickytable 2 Application");
setMainWindow(mainWindow);
mainWindow.addListener(new CloseListener(){
public void windowClose(CloseEvent e) {
WebApplicationContext context = (WebApplicationContext) getContext();
context.getHttpSession().invalidate();
close();
}});
IndexedContainer container = new IndexedContainer();
container.addContainerProperty("text", VerticalLayout.class, new VerticalLayout());
container.addContainerProperty("edit", Button.class, new Button("Edit"));
for (int i = 0; i < 10; i++) {
final int index = i;
Object item = container.addItem();
Label lbl = new Label("Text Content " + i);
VerticalLayout vl = new VerticalLayout();
vl.setWidth(100, Sizeable.UNITS_PERCENTAGE);
vl.addComponent(lbl);
vl.addListener(new LayoutClickListener() {
public void layoutClick(LayoutClickEvent event) {
System.out.println(String.format("Clicked on text %,d at client(%,d,%,d), relative(%,d %,d)\n", index, event.getClientX(), event.getClientY(), event.getRelativeX(), event.getRelativeY()));
}
});
container.getItem(item).getItemProperty("text").setValue(vl);
container.getItem(item).getItemProperty("edit").setValue(new Button("Button " + i));
}
Table table = new Table("ClickyTable 2", container);
table.setColumnExpandRatio("text", 1);
table.setColumnExpandRatio("edit", 0);
table.setSizeFull();
VerticalLayout fl = new VerticalLayout();
fl.setSizeFull();
fl.addComponent(table);
mainWindow.setContent(fl);
}
}
With some style changes in place, the result can look something like this:
ClickTable Screen Shot http://www.soletta.com/images/ClickyTable.PNG
If you ever find yourself putting hundreds of components on web page in Vaadin, you probably should reconsider your application structure. Why not implement a custom widget for the part of the UI that requires such huge number of widgets? It is just GWT and thus fairly easy. Then you can have the best of the both worlds - simplicity of Vaadin with full control of HTML5 on the client side.
Vaadin Flow
You must have been using the previous generation of Vaadin, versions 6, 7, and 8.
Because of the limitations and incompatibilities of earlier browsers, the long delays in producing CSS 3, and predating HTML5, Vaadin did indeed generate large and complicated pages. Given the relatively poor performance of JavaScript runtimes back then, some elaborate web apps may not have performed as well as you would have liked.
Web Components versus GWT
Fast forward some years now since your Question was posted. Vaadin Flow has arrived. Versions 10 and later are longer based on GWT. Instead they use the open standards that have emerged, collectively known as Web Components.
CSS 3
CSS 3 has finally arrived, and matured. Browsers now offer built-in sophisticated page layout with Flexbox and Grid, in addition to the previous Float. So no longer must page layout be hacked together with abuse of table and crazy assortment of div & span tag soup. Page layout can now be built with short, simple, and clean code.
Modern browsers
Other modern advancements include:
HTML5 designed expressly for building web apps (as opposed to web documents)
The consolidation in browser engines (basically only 2 left standing: WebKit/Chromium & Quantum/Gecko)
Dramatic advances in the performance of JavaScript runtimes, plus important new features of JavaScript 6
Close cooperation between browser makers in writing and implementing web standards with much more consistent behaviors
The "evergreen" rapid-release model of modern browsers
All these taken together mean the burden on Vaadin to deliver high-quality consistent web-app experiences has been greatly decreased. You should see much shorter, simpler, and faster page code.
Give it a try.
For more discussion, see my Answer to the Question, Understanding Vaadin Flow / Vaadin 10.
The minuses are:
Big and complex HTML output. That slows down the browser response time (also mentioned here and there) and leads to some rendering peculiarities from browser to browser.
No longer big and complex, as discussed above, because of modern web technology improving so much.
Difficulties in handling big number of components (see Can CustomLayout handle 5000 components?).
Web Components is an open standard, composed of four specifications.
Many components have been built over the last several years, now available for you to use in your Vaadin Flow web apps.
Most of the UI widgets you knew in Vaadin 6/7/8 have been rebuilt as Web Components (see Comparison Matrix). This means these Vaadin components can be used in other web projects without the Vaadin Flow server-side Java binding.
You can easily wrap other non-Vaadin-specific components built on Web Components to be available to your in your Java code running on the server-side Vaadin Flow framework. See Integrating a Web Component. To get you started, here are a couple thousand to choose from.
You can create your own components.
The need to recompile the widget set if you use 3rd party components.
No more WidgetSet in Vaadin Flow, because there are no more GWT widgets. Supplanted by Web Components as discussed above.
What Web Framework fits best the following requirements:
Vaadin Flow ticks all the boxes you listed in your Question: event handlers, common components with advanced features, sophisticated page layout, user-events propagating from client to server (and the other direction via built-in Push technologies), keyboard shortcuts, and a short learning curve for Java programmers.
Furthermore, from the server-side you can now invoke JavaScript snippets on the browser. And Vaadin 15 this spring brings client-side coding in TypeScript while still integrating with the Java code running server-side in Vaadin Flow.
Web Firm Framework is the best alternative. It's an opensource Java framework under Apache License 2.0. I also had to load heavy components in my application it was smooth with this framework.
It is like a collection of java classes for all HTML5 tags and attributes. Using these classes we can build the UI just like we do using the pure HTML. It can handle heavy HTML because the data coming from the server to client is like a stream through websocket, eg:-
//creates table
Table tableObj = new Table(null,
new Style("width:100%")).give(table -> {
new TBody(table);
});
//finding tbody object in the table
TBody tBody = TagRepository.findOneTagAssignableToTag(TBody.class, tableObj);
for (int i = 0; i < 10; i++) {
int count = i;
Tr trObj = new Tr(null).give(tr -> {
new Th(tr).give(th -> {
new NoTag(th, "Firstname " + count);
});
new Th(tr).give(th1 -> {
new NoTag(th1, "Lastname " + count);
});
new Th(tr).give(th2 -> {
new NoTag(th2, "Age " + count);
});
});
//appending tr in the table
tBody.appendChild(trObj);
}
Whenever trObj is appended it will be immediately available in the UI it will not wait to finish the for loop. Check their demo app which contains a button to stream 1000 rows.
We can handle events without much effort eg:
to handle click event of a button
//This will create a button in the UI.
new Button(null, new Type(Type.BUTTON), new OnClick((data, ev) -> {
System.out.println("Button clicked");
return null;
}));
In this git repo you can find sample projects for it.
We can also try this tool to convert HTML5 to Java/Kotlin code. This video and developers guide will be helpful to understand it better.
I am making an app in GWT. It is like a dashboard and will have out of the widgets.
Now when we ship this out, there is a use case that the customer might want to create their own GWT widget and use this in the dashboard app.
As I understand it, they will not be able to do this since we cannot ship our source code which is needed to compile the whole app again once tag of their widget/module gets into the gwt.xml file of my app.
I cannot use anything other that GWT to make this dashboard. And their widget could be say a flash heapmap, a jquery widget/plugin, another GWT module, a jsp page that renders a visualization from back end.
So far my thoughts have been to provide a widget in my app which is a wrapper in the form of an Iframe and call their main page (they will provide url), and have an api to let my app and their widget talk.
But I would like to know if there are other / better approaches?
This is exactly the problem solved by google's OpenSocial widgets. There are a few opensource implementations: http://shindig.apache.org/ is one. You can look into integrating that in to your app. An added bonus is that you can then display widgets from other applications (such as atlassian jira) that also serve opensocial widgets.
Depending on how closed source your application is (can custom JS/HTML be added to pages?), you could always provide a native Javascript (JSNI) API for some custom dashboard widgets. The simplest solution I'm thinking of would be a JSNI method which your customers could call to set the HTML content of said widget. This method would allow them to use a variety of options such as JQuery widgets, their own GWT widget generated HTML or even an IFrame pointing to their JSP pages etc... You could then provide additional JSNI API methods which would allow them to interact with your app/widget in other ways as well. This would be better than the IFrame method because you wouldn't have to deal with cross domain scripting security issues.
I would like to create a List Box which can provide me suggestions.The exact thing which i need to implement is the browsers navigation widget where we type in the website address.The functionality to implement is like this
when we click on the down arrow ,my list box should provide me the list of previously navigated URLS.
Also when we go ahead and type something,the widget should provide me suggestions.
Any suggestions on how to implement this widget would be really great.
Thanks
My SimpleGWT project's ComboBox widget should be very close to what you describe. However, I would warn you that it was written a couple of years back and hasn't been kept up to date with the latest GWT version. Also, it required a few changes to the SuggestBox class to open up the API that I need. With all that in mind, it is Apache 2 licensed Open Source so it should still be useful to you in implementing your own solution even if you can't use it as it is. Feedback is welcome on the project site.
this simple-gwt can help you but you should develop it on your own
Edited:
to make it scrollable check this.
I need to display data coming from a GWT-RPC service in a paginated datagrid.
The gwt-ext showcase does not provide an example combining gwt-rpc calls and datagrids.
That is too bad because the original javascript Ext grid components offer paging and remote sorting. How to take advantage of these features with GWT ?
I too wanted to do this a few weeks ago, and searched long and hard and found nothing. In the end I wrote my own paged grid that supports RPC/Sorting/Editing/Etc.
It's intended to be generic, and is still a work in progress, but to use it you simply implement the TableSource and TableRenderer interfaces like so:
new PagedTable(new AssetTableSource(), new AssetTableRenderer(), 30);
I have posted the code here:
http://wiki.shiftyjelly.com/index.php/GWT#GWT_RPC_Paged_Table
Feel free to revert the buttons in the PagingControl.java back to normal GWT buttons.