I'm developing a Java ME app & need pointers to some really good UI libraries. I did see a few such as Java ME Polish. Are there any more out there? For e.g. ebuddy's java ME app has an amazing UI and so is gmail's java ME app. What libraries would they have been using or would have they have developed it on their own?
Sun recently released and opensourced their solution to crappy looking lcdui. It is called LIghtweight UI Toolkit and can be found on lwuit.dev.java.net
We have been trying lately on kuix.. So far so good and more light weight than LWUIT
code.http://code.google.com/p/kuix
eSWT would be available for MIDlets on the latest J9 VM, as used by the Series60 3rd Edition feature Pack 2 handsets (Nokia N78, 6210, N96...) but we're mainly talking about nicer looking UI controls. Basically, a MIDlet can look much more like a native application now.
Sun has recently open-sourced LWUIT.That could also be worth a look.
Nothing beats drawing your own images on a Canvas,though. Generic layout managers in any kind of library will only get you so far. You should only look at the available technologies once you have a good idea of how many different kind of screens your application should have and what they look like.
Most of the apps with amazing UIs (Opera Mini, Gmail, any game from an AAA developer) use custom UIs developed in-house. These developers take the task of developing an UI as one more in their projects and give it personality, involving professional graphic designers. Going with a packaged library would quickly accomplish the task but it would make the application look generic and bland (less bland that with the default UI, but still bland and limited).
In short, go with a packaged UI for quick development, but don't expect the level of quality to be near the apps you mentioned.
I'm facing a similar dilemma right now. We're currently using the default, high-level LCDUI framework for the speed of development, but its severely limiting what we can do. I had thought our best option would be to use a third-party UI framework, but I'm now coninced that if we're serious about the application we should write our own. Its like anything in software, if its mission critical to your application you should write it yourself, even if it that means re-inventing the wheel.
Digitalapes has developed a framework for J2ME application development that includes a high level UI library.
The library is lightweight and well documented, you can get have a look at the Gear framework page for more information, or you can directly download the JAR and javadoc from Gear's sourceforge page.
Digitalapes blog includes also a series of tutorial about how to use the framework.
Polish has really nice set of UI components, which are skinable with css style comments.
It also features a device database for compatibility purposes.
Some tipps if you decide to go with polish (as i did):
Use eclipse and the mepose plugin. The netbeans integration is really nerve wracking.
The bulletin board is dead, so by all means !use the mailing list!.
If you are not familiar with the ant building system, you better start now.
The J2ME Polish book is not worth its money. (My opinion). The documentation on their website and the sample coded are enough to give you a solid start.
I've used SWT when deploying to a full profile J2ME (IBM J9 on PocketPC), I don't know if it is usable by MIDlets however. It's quite a nice GUI library in its own way, and far better than AWT.
Unfortunately companies usually end up designing their own GUI's when it comes to mobile development. It's the only way to have full control over your interfaces, but you should consider if it's worth the additional development time, and you're also on your own when it comes to device compatibility issues / handset bugs - of which there are plenty.
If you are happy with a less flexible interface, you can go with one of the existing libraries. I currently use J2ME GUI from http://www.garcer.com/. We get the same flexibility as with desktop development and it also features custom styling, so with a little extra effort you can make it look the way you want it to.
You can use LWUIT for the UI development in J2ME framework.
Related
I have experience in designing UIs with qml and had a good experience creating fluid UIs in almost no time.
I wanted to know if there is a similar toolkit available for Java which could match qml in terms of-
Ease of use.
Rich 'look and feel' which qml offers.
Rapid development
JavaFX is the closest match
Somewhere on the Internet I even read about QtQuick (QML+Javascript) being JavaFX supposedly 'done right'. This is because the syntax of the original JavaFX Language is very similar. Also there are tools like the Scene Builder that are similar to Qt Quick Designer. Beware JavaFX is kind of dead. And also the new JavaFX is not JSON-based but XML-based and more similar to XAML.
Android SDK is another choice
With all the momentum Android has gained you are very safe with choosing it's whole suite to design. And Android needs no further explanation, Android Studio has lot's of things to ease development.
I recently wrote an article on GUI libraries for embedded and came across TotalCross. It uses a Java API which is quite versatile and modern. They're planning to release a tool to port UIs in Android XML to TotalCross. This will make it easier to prototype UIs using Android Studio. Their VM is quite optimised and is even deployed on embedded platforms like Toradex. It's dual-licensed under LGPLv2.1 and commercial licenses.
Most popular Java UI frameworks SWT and Swing are similar to Qt Widgets. I know the only one which brings declarative style of UI development in the Java World - E4/XWT. But it looks more like Microsoft WPF than Qt QML and I did not try it in commercial projects.
There is no such tool (at least I don't know for it).
Only solution I see here is to use JNI and combine QML with Java.
I am working on this open source project to use Android XML to build GUI apps to run on iOS, Android, raspberry pi, etc, using totalcross as the engine to render the XML on the device.
https://github.com/TotalCross/KnowCodeXML
Similar questions to this are asked periodically, but many of these answers are outdated.
I need to build a cross-platform desktop application in Java with a GUI of comparable quality to contemporary desktop apps.
Swing is the default choice, but I have yet to encounter a Swing application that didn't look, at the very least, quite dated and clunky (subjective, I know, but with GUIs it's hard to avoid aesthetic judgements).
I notice that the new Bitcoin client now uses QT with Java bindings, and does have an attractive user interface, but this has the disadvantage that it is no-longer pure Java.
So much of what I find when I search for Swing-related libraries is 5 years old or older, even though the aesthetics of desktop applications have evolved significantly since then.
If you needed to build a Java desktop application from scratch, what would you use for its GUI?
I can also offer you a new LaF to look into - WebLaF. I'am currently working on it to bring a lot of UI features and make work with Swing much easier for anyone by just using WebLaF library basic features.
A few examples showing how some of WebLaF components look like:
Some of main goals i am targeting:
Great and modern-looking L&F with support for all Swing components
An extensive set of additional components which you won't find in standard Swing
A big set of Utility classes to assist you with writing the code
WebLaF library also suggests a few other advantages and unique features:
It is an open-source project (GPLv3 licensed)
Easy components styling using painters system (specifically with 9-patch files)
Quick and easy customization of the default "Web" style
Lots of features to accelerate and simplify Swing application interface creation
You can try the demo-app to see if it is modern and simple enough :)
Have you looked into JavaFX 2.0? It is designed to interop easily with Swing, and has many modern 'good looking' controls.
Also, as lrAndroid mentions, a Swing app can look like a native app if you set the system look and feel with:
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
Look into changing the Look and Feel of your Java program. This allows you to customize the overall "theme" of your program.
Here is information on changing the LAF.
I've had good experiences with FlatLaf.
It's easy to install, it's cross-platform, it has no external dependency, it's open-source (Apache license), it includes dark modes and there are tons of themes.
After adding :
UIManager.setLookAndFeel( new FlatLightLaf() );
your app looks like it was written during the last decade, and not during the previous millenium.
It also has one high-contrast theme, for accessibility.
Modern Javascript frameworks (ExtJS, Dojo, etc...) offer the same widgets richness or more (Excel like grids for instance), a wider variety of L&F and usually fit better with the OS of the user.
Users are also very comfortable with their browsers and, hey, "modern stuff" is on the web, and the modern web today is HTML+Javascript.
The overhead of converting an app to "web like" is minimal. An embedded Jetty can remain really small and disk space has become much less of an issue.
There are additional benefits going down this route for the future evolutions of the application.
Suddenly, the desktop app becomes a server app, which can be accessed from another desktop. We were able top promote a desktop app to 'portal' in a matter of weeks.
Rewriting the app in terms of (Ajax) web services provides an easy transition to creating a full REST (or SOAP...) services stack. The app can then be integrated to other applications, easily monitored externally, etc...
Support of other devices (smart phones, tablets,...) becomes much easier, by concentrating on the UI layer only
As the app grows, separation of concerns is cleaner; developers working on the UI do not have to mess with low level code.
There are a lot of excellent JS/HTML designers and developers that do not program in Java.
EDIT
3 years later this has become extremely easy thanks to Electron
Try one of these:
JTattoo
JGoodies
Quaqua
What about Nimbus look and feel? Oracle Link
Also take a look at SO-Question
I know this question is old, but if you don't want to use FX and still want to use Swing, then try MacWidgets, i've used it on a couple projects. It's very light, and looks great. Below is an old project i was working on, over time i've perfected using macwidgets and now use it internally in my company.
http://www.digitalhand.net/projects/jdataanalyzer/mainGUI.png
QT is quite extensive but also very big (bloated) and complex. There is also the SWT library being used by open office for instance. SWT uses native UI widgets for buttons, tables etc where as Swing emulates them.
However, the trend is clearly towards writing rich client applications for the browser using HTML and Javascript. Both of these have made huge strides in the past few years.
HTML5 specifically targets rich client applications with features such as better forms and local database to support disconnected scenarios (note that this last feature is not standardized yet but it is implemented by all latest browsers).
Javascript has now powerful libraries with jQuery and its many plugins. There are even languages like Coffeescript which can be used to produce Javascript with a simpler and more powerful syntax.
There's also no need for such apps to connect to an outside server. Small footprint local servers (eg: jetty, node.js, ...) and databases (SQLite, H2,...) can be installed on the client to make a completely self contained application.
Swing is good (stable, documented, supported until 2026). The problem is that it relies on the LookAndFeel system that provide a very limited number of boilerplate choices. It should be easy to change the appearance of each component individually and then unleash its creativity. Unfortunately it is painful. IMHO frameworks should be built on top of Swing to make it possible instead of creating JavaFX.
Take a look at https://github.com/dotxyteam/ReflectionUI.
Ex GUI: http://javacollection.net/reflectionui/wp-content/uploads/2017/08/general.png
Go for Jetpack Compose for Desktop. It's a super modern reactive UI which is nice to work with. It also works the same as it would for Android with very few exceptions. It's Kotlin though instead of Java, but these are both JVM based and it's very easy to make the jump.
I want to know which is the best tool which can be used to make GUI . Currently I'm working on VC++ 6.0 and I can't give a good look(Vista Look) in that.
So can anyone help me which one will be more suitable for GUI .. Java or any other tool(.net WPF) and if you can give the reason then it is very helpful.
Thanks
I would recommend WPF .. It has the new markup language which suits well the UI development, supported by code behind.
Check some examples http://blog.trivadis.com/blogs/manuelmeyer/archive/2008/06/12/cool-wpf-samples.aspx
Java is designed to work well across multiple systems.
.NET underlies Windows.
If you're trying to imitate Vista's look and feel as closely as possible, go with the framework that was written by the same company that also made your operating system.
Any of the above are capable of a good "Vista" look (including VC++). You just need to opt-in to the new visual control styles with a manifest. WPF will have the most options for a "sexy" Windows UI, and won't need the manifest.
You can use WPF for serving your purpose. WPF lets you
edit the opacity of the elements : so that you can create transparency effect as in Vista
create storyboards for your animations
change the look and feel of existing controls using styles, so it can be easy to create Vista style controls
apply bitmap effects such as Outerglow, Dropshadow, etc.
Although WPF is not limited to the above features, but it is the partial list of features for which you can use WPF to achieve your desired effect.
If you do decide to go down the Java route, take a look at the JGoodies libraries. They take a lot of the pain out of writing Swing apps by providing (amongst other things) a much more usable layout manager, a data binding framework, and some some Windows like look & feels.
Take a look at this to see why you don't want to use one of Swing's standard layout managers directly...
Depends on what you mean by "best" tool.
In Java you are most likely looking at Swing to develop your application as far as frameworks go. If you are looking for a complete RCP, you could take a look at the Netbeans Platform or Eclipse RCP. The Netbeans IDE also has a nice GUI editor that can be used for generating Swing GUIs (if you don't mind working with generated code and the Netbeans IDE).
WPF is very nice but has quite a large learning curve.
Swing is a bit chunky.
7 years ago at least Delphi was a really really polished and good way to produce a windows GUI, since then Delphi has moved to be a .net laungage. So I would recommend at least looking into Delphi
The tool decision should follow your requirements.
Do you need a GUI for a stand-alone Application or a client-server architecture? If it's stand-alone, do you need it for a single operating system or you need it portable? If it's client-server, do you want a thin client ('webapplication') or a rich client, if it's a rich client, you want the user to install it or shall it be provided by a webservice?
Do you want to hardcode the GUI or declare it? Do you have some expert knowledge on a certain programming language or a certain framework or do you want to use the project to learn on or the other (or both)?
I think, it's much easier to recommend something when we have some more background information.
From the few things I know I suggest:
Upgrade your visual c++ environment and keep working with the tools and frameworks you already know. Microsoft products should be the best solutions to develop applications for Microsoft operating systems.
I would recommend Flex with Adobe AIR - it's nice! adobe flex
I have a DVD cataloging application that I wrote a few years ago with MFC. Records are saved in a sqlite database, so basically it's a CRUD app. UI-wise, it has a tree view on the left, a list view (grid) on the top right, and an HTML view (embedded IE) on the bottom right. Nothing fancy.
I wanted to update the app with more features, but I've been using Java EE for the past couple of years and I realized that I wasn't productive at all with MFC. So I'm thinking maybe I should use something else to boost my productivity. Cross-platform would be a big bonus, but it's not absolutely required.
Here are the options based on my research:
Java / Swing: I can utilize my Java knowledge; great third party libraries (such as Spring for IoC and Hibernate for ORM); cross-platform. Downside is, JRE required for users; Swing seems to be in the "maintanence" mode and it's not getting much attention from Sun.
C++ / Qt: native application;
cross-platform. But I'm new to Qt so
I have to learn it first.
C# / WPF: WPF seems to be the future
of Windows GUI development and I'm
impressed by some WPF sample apps. I
have some experience with C# but I
need learn WPF. Downside is, Windows
only; .NET 3.5 runtime required.
So what would you use if you were in my situation? Thanks in advance for any suggestions.
If you want to learn some new skills while developing this application, then C# / WPF, and LINQ in C# 3.0 is really great if you didn't have it in Java.
If you just want to get on speed, then you already answer your own question, Java / Swing. It is what you are good at.
I'm actually a big C# fan, but since you said that cross-platform would be a huge bonus, I think that Qt might actually be better for that. C# can be cross-platform via Mono, but I've had better results with Qt in that respect. They also have real good documentation in QtAssistant to get you started.
Consider PyQt + Python as well if your productivity is a big issue. Trust me when I say the learning curve for Qt is well worth it, and not as hard as it may seem at first.
Sqlite support is in both the Python standard libraries and the QSql module in Qt if you prefer to use that.
PyQt + Python is a cross-platform option as well, since Python is available for many platforms and Qt's cross-platform to begin with.
The controls you mentioned you used in your application are all available in Qt.
The only other tool apart from raw C++ is Delphi. Period.
With other tools you will have problems in the deployment.
With Delphi you will produce native exes, self-contained. Also, the database connectivity is great.
You never will be dissapointed by lack of controls or 3d party tools, a lot with source code and with free/commercial toolset.
And the compiling times are the fastest in this galaxy ;)
So, if you are serious in provide no-hasle app for your customers, and that customers are not tech-oriented like developers so could be confused because which one of the 4 .NET runtimes install, want minimal support, easy downloads, click-click-install-go, apps that work instanly like Skype,TopStyle (made with Delphi) and others,then Delphi/C++ is are your only option. Seriously. The ONLY options.
If you want a cross-plataform solution, then FreePascal/Lazarus could work if your GUI is minimalist.
In most cases, as long as the scope of the project is reasonably small, and the computational needs are modest, I tend to favor using TCL/Tk. I have not yet learned a gui api in which I'm more productive than tk (not to say that there isn't one, just that I've tried several and found them slower). TCL is not the most wonderful language to program in, to be sure, although there are a number of add-ons that help a lot, specifically [incr tcl] and tcllib.
The reason I choose this instead of other systems, I prefer coding in python, for instance, is because deployment with tcl/tk is close to unbeatable. With Starkit, you end up with a single file double clickable application that requires no installer, and is trivially portable.
Well if you really want a class platform type of application, I would convert it into a web application and host it. That way if one user uploads dvd information or a dvd cover picture another user could take advantage of that information already input into the system.
If your going to develop for the desktop try to make feel like its an application made for that platform by utilizing the OS UI tools. And for windows, pick your 3rd option C# /WPF.
If you have some non UI code in your MFC app that you would like to reuse then consider QT. Otherwise pick whatever you prefer to learn.
Instead of C#/WPF you could give Silverlight a look. You app seems simple enough that it would not take a lot to get up and running. Similar to the demos that are shown off at conferences.
Once you get the basics down it will be fairly easy to add some cool features like animations, movie clips, album art, coverflow like interface etc.
You will be able to target Windows/Mac users and possibly Linux with Moonlight. But I haven't looked at Linux in the past 8 years so I really can't say much about it.
With Eclipse RCP, you get Java, cross-platform development (see Delta Pack), native look (via SWT) and a great framework collection for desktop development (declarative UI, plugin management etc.). You should definitely give that a try.
I went the C++/wxWidgets (but you could do Qt) route a few months back when presented with almost the exact same scenario (upgrade an app with a SQLite db). wxWidgets was fairly easy to pick up, had everything I needed, and was way easier than MFC. The best part was I found a good C++ wrapper for SQLite on CodeProject (e.g., CPPSQLite) and had the whole thing up an running in no time... The project sold me on wxWidgetss, in case you couldn't tell.
I would actually look very closely at something like adobe air. It is cross platform and can be html/javascript based so chances are you won't have a heck of a lot to learn except maybe a javascript library or two. It has the ability to talk to a local datastore or over the interweb to a webservice or RESTFUL service. Development is free with aptana. Check out some of the stuff written in it:
http://www.adobe.com/products/air/showcase/
I'm working on some Flex spike in my company. We are basically evaluating different scenarios etc. What solution would you recommend for embedding Flex components into Java app? Flex <-> Java communication is not (yet...) an issue, just embedding swf into JFrame.
I've done it with EasyJCom. It's pretty straight forward as long as you're using one of the standard Java windowing libraries (Swing, awt). You can see an example (From the EZJCom site) here: http://www.ezjcom.com/FlashTest.java.txt
The people responsible for EasyJCom are also very responsive, and even though we ended up not using their product (Switching platforms), I'd recommend them.
I haven't used JFlashPlayer, but did take a look at the docs, it seems to be adequate as well. I think their license requires you to obfuscate your code. I thought it was a little odd, but maybe I mis-understood the license.
It gets quite a bit more complicated if you don't want to use Com, or if you need to embed in another type of window.
If you need to embed flash cross platform, you may be stuck rolling your own Jini library for the Mozilla plugin. At that point... Maybe it's worth just switching platforms if you aren't too far in. ;)
Haven't tested this, but it looks like JFlashPlayer will do the job. http://www.jpackages.com/jflashplayer/
None of these supports Linux or MacOS. So much for the cross-platform Java and Flash.
I think the best way to do something like this would be to embed something like xulrunner into your java app then have the java app interact with flash via the xulrunner interfaces.