Как установить windows builder в eclipse

1.Introduction

In this example, we will show you how to develop Java GUI Application using Eclipse WindowBuilder plug-in.

Eclipse WindowBuilder is a powerful and easy to use bi-directional Java GUI designer that makes it very easy to create Java GUI applications without spending a lot of time writing code to display simple forms.

The bi-directional Java GUI designer means the developer can seamlessly move between a Drag n’ Drop designer and the generated code.

Using Eclipse WindowBuilder, the developer will enjoy creating Java GUI based applications. One can create complicated windows in minutes using WindowBuilder.

WYSIWYG (What You See Is What You Get) layout tools in WindowBuilder are used to generate back-end java code by drag-and-drop of components to the container.

2.Simple Java Window Application

Now, we will see how fast a simple Java GUI application can be created uisng Eclipse WindowsBuilder.

2.1 System requirements

Tools required to run this example are:

2.1.1 Eclipse

WindowBuilder is built as a plug-in to Eclipse. ‘Eclipse for RCP and RAP Developers’ is the default IDE bundled with ‘Windows Builder’ plug-in. This IDE has a complete set of tools for developers who want to create Eclipse plug-ins, Rich Client Applications (RCA).

Download ‘Eclipse for RCP and RAP Developers’ from here. Please refer the picture given below to identify the correct IDE.

2.1.2 Java

• Download Java SE 7 or above from here

3. Open New Project

Let us create a new ‘SWT/JFace Java Project’ to see the usage of WindowBuilder for building GUI components. Open ‘File – New – Other’ and then click ‘SWT/JFace Project’ as depicted below

The reason for creating new project as ‘SWT/JFace Java Project’ is to have all the necessary JARs and native libraries included by the IDE itself. Otherwise, you have to add all these dependent JARs and native libraries on your own.

The Standard Widget Toolkit (SWT) is a graphical widget toolkit to be used with the Java platform. It provides a portable graphics API independent of the OS but that relies on the native widgets.

JFace is a UI toolkit with classes for handling many common UI programming tasks. JFace is window-system-independent in both its API and implementation, and is designed to work with SWT without hiding it.

JFace is a higher-level user interface toolkit that uses the raw SWT widgets to provide model-driven widgets, and to some extent some functionality that isn’t available in the Swing libraries, such as advanced editors, dialog boxes, and wizards.

4. New SWT Application

Let us add widget to the project. As a main window, create Application Window as shown below. Right click on the project and select ‘New – Other – Window Builder – SWT Designer – SWT – Application Window’. And then click ‘Next’

Enter Class Name and click ‘Finish’

A basic window application has been created. Window Builder can be used to get your UI up and running quickly. Click ‘Design’ tab as shown below.

Now, you will see the graphical representation (Design View) of your code.

This application can be simply executed like any other java program with main method. Right click on the class name and ‘Run As – Java Application’

As we have not yet added any other elements, you will see a simple window popping-up as a result of the execution.

5. Components in the editor

As shown above, the editor is composed of the following major components:

• Design View – the main visual layout area.
• Source View – write code and review the generated code
• Structure View – composed of the Component Tree and the Property Pane.
• Component Tree – shows the hierarchical relationship between all of the components.
• Property Pane – displays properties and events of the selected components.
• Palette – provides quick access to toolkit-specific components.
• Toolbar – provides access to commonly used commands.
• Context Menu – provides access to commonly used commands.

6. Editor Features

The editor supports the following major features;

• Bi-directional Code Generation – read and write almost any format and reverse-engineer most hand-written code
• Internationalization (i18n) / Localization – externalize component strings, create and manage resource bundles.
• Custom Composites & Panels – create custom, reusable components.
• Factories – create custom factory classes and methods.
• Visual Inheritance – create visual component hierarchies.
• Event Handling – add event handlers to your components.
• Menu Editing – visually create and edit menubars, menu items and popup menus.
• Morphing – convert one component type into another.

7. Layouts in SWT

Layouts are non-visible widgets used to give GUI windows a specific look and it helps to control the position and size of children in a Composite.

To make sure the GUI application developed in one environment works perfect in another platform, Java provides a system of portable layout managers. We use these layout managers to specify rules and constraints for the layout of the UI in a way that will be portable.

Layout managers gives you the advantages as given below,

• Correctly positioned components that are independent of fonts, screen resolutions, and platform differences.
• Intelligent component placement for containers that are dynamically resized at runtime.
• Ease of translation. If a string increases in length after translation, the associated components stay properly aligned.

SWT Designer supports the following layout managers.

8. New UI Page

We will now design a new Login UI page using Window Builder. For this normal size screen, we will continue with the default (absolute) layout. We are going to have an image, two labels, one text field, one password field and a button on the screen.

To display image use CLabel widget. CLabel supports aligned text and/or an image and different border styles.

As shown below, click ‘CLabel’ once and keep your cursor on the screen and click. Now, the ‘CLabel’ is placed on the screen.

Let us attach an image with ‘CLabel’. For this, you need to have an image in the folder where your ‘MainWindow’ source file is placed. For this example, I have used eclipse logo.

Click on the ‘CLabel’ and then, in the ‘Properties’ window select ‘image’.

You will now see the Image chooser window pops up. Select ‘Classpath resource’ option and navigate to the image file, select it and then click ‘OK’.

Adjust the field bounds according to the size of the logo so that the image is visible on the screen.

Similarly, add Labels, Text Fields and a Button. Finally the screen will be looking like the one shown below.

To test this design, right click on the window and select ‘Test/Preview’ from the popup menu.

9. Source View

Click ‘Source’ tab to see the code generated by the IDE. Single line of code in this was not written manually.

10. Button Listener

Attach listener with the button to validate field entries. Refer the source code of the main file given below.

MainWindow.java

package com.jcg.rca.main;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.wb.swt.SWTResourceManager;

public class MainWindow {

	protected Shell shlLogin;
	private Text userNameTxt;
	private Text passwordTxt;

	private String userName = null;
	private String password = null;

	/**
	 * Launch the application.
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			MainWindow window = new MainWindow();
			window.open();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * Open the window.
	 */
	public void open() {
		Display display = Display.getDefault();
		createContents();
		shlLogin.open();
		shlLogin.layout();
		while (!shlLogin.isDisposed()) {
			if (!display.readAndDispatch()) {
				display.sleep();
			}
		}
	}

	/**
	 * Create contents of the window.
	 */
	protected void createContents() {
		shlLogin = new Shell(SWT.CLOSE | SWT.TITLE | SWT.MIN);
		shlLogin.setSize(450, 300);
		shlLogin.setText("Login");

		CLabel label = new CLabel(shlLogin, SWT.NONE);
		label.setImage(SWTResourceManager.getImage(MainWindow.class, "/com/jcg/rca/main/eclipse_logo.png"));
		label.setBounds(176, 10, 106, 70);
		label.setText("");

		Label lblUsername = new Label(shlLogin, SWT.NONE);
		lblUsername.setBounds(125, 115, 55, 15);
		lblUsername.setText("Username");

		Label lblPassword = new Label(shlLogin, SWT.NONE);
		lblPassword.setBounds(125, 144, 55, 15);
		lblPassword.setText("Password");

		userNameTxt = new Text(shlLogin, SWT.BORDER);
		userNameTxt.setBounds(206, 109, 173, 21);

		passwordTxt = new Text(shlLogin, SWT.BORDER | SWT.PASSWORD);
		passwordTxt.setBounds(206, 144, 173, 21);

		Button btnLogin = new Button(shlLogin, SWT.NONE);
		btnLogin.setBounds(206, 185, 75, 25);
		btnLogin.setText("Login");

		btnLogin.addListener(SWT.Selection, new Listener() {
			public void handleEvent(Event event) {

				userName = userNameTxt.getText();
				password = passwordTxt.getText();

				if (userName == null || userName.isEmpty() || password == null || password.isEmpty()) {
					String errorMsg = null;
					MessageBox messageBox = new MessageBox(shlLogin, SWT.OK | SWT.ICON_ERROR);

					messageBox.setText("Alert");
					if (userName == null || userName.isEmpty()) {
						errorMsg = "Please enter username";
					} else if (password == null || password.isEmpty()) {
						errorMsg = "Please enter password";
					}
					if (errorMsg != null) {
						messageBox.setMessage(errorMsg);
						messageBox.open();
					}
				} else {
					MessageBox messageBox = new MessageBox(shlLogin, SWT.OK | SWT.ICON_WORKING);
					messageBox.setText("Info");
					messageBox.setMessage("Valid");
					messageBox.open();
				}
			}
		});

	}

}

11. Conclusion

From this example, we learned how quickly a Java GUI application can be developed using Eclipse Window Builder. WindowBuilder Engine provides a rich API for creating UI designers. It supports Java-based UI frameworks such as Swing, SWT/RCP, eRCP, GWT etc. It also supports XML-based UI frameworks like XWT, GWT UiBinder, Android etc.

12. Download the Code Project

This was a Tutorial about Eclipse Window Builder for GUI Creation.

Download
You can download the full source code of this example here: WindowBuilderExample

1. Why Do We Use Java Swing
2. Windows Builder Eclipse Plugin
3. NetBeans Java Swing GUI Builder

A great graphical user interface integrates features such as customization control, split viewing of design code, and an easy-to-use interface and should be clean and lightweight.

In this article, first, we will show how to install the Windows builder GUI development plugin for the Java Swing Designer Application in Eclipse. Second, we will also show you how to use NetBeans Java Swing GUI development.

Why Do We Use Java Swing

Java Swing Class is a compact graphical user interface platform that helps reduce the time and effort to repeat tasks. You can navigate/toggle to choose between gadgets, and your code will be generated automatically.  

Classification of Java Swing Class

To understand Java Swing more clearly, please see the following diagram.

Diagram Summary:

The diagram depicts the relationship between a Java object at the top and a JFrame at the bottom.

All of the components we as users frequently interact with, such as Lists, Buttons, Texts, and so on, are inherited by the JComponent class. 

Furthermore, we can see that the containers were added higher with the component and lower with our operating system; these extend on frames and dialogue boxes on the user’s operating system.

All key Swing elements are included in the foundation within one’s graphical user interface app. 

Windows Builder Eclipse Plugin

This Eclipse plugin integrates SWT Designer and Swing Designer into a single package.

You can develop Java GUI apps without wiring code. Its WYSIWYG visual designer, for example, provides you with layout tools to create simple forms for complex windows.

It’s cool since it helps generate the code for you. Furthermore, you can add controls to your settings by using drag-and-drop capabilities, null layouts, and event handling.

You can also use a properties editor to modify the properties of your settings.

Windows Builder Plugin:

Follow These Steps:

Install Windows Builder Plugin From Eclipse Marketplace

The following way to download WB is another simple approach for installing Windows Builder in your Eclipse IDE.

You have to start your Eclipse and see what version it is.

Use Windows Builder for Swing GUI Development

After successfully installing all the resources from the Eclipse marketplace server repository into your local workstation, you should be thinking, how do I create a Java Swing Application using the Windows Builder GUI development platform?

Do the following steps:

Summary:

We demonstrated two simple methods for installing a GUI Builder in your IDE. We also categorized a Java Swing class and talked about the significance of GUI-based Swing development.

NetBeans Java Swing GUI Builder

NetBeans GUI Builder supports the production of sophisticated and elegant graphical user interface applications. The best part is that you don’t have to be a pro to do it.

You also don’t need deep expertise in layout management. Even a beginner can try it out and create an excellent Java application using Jforms or other components from the Java Swing Foundation class.

What does this IDE offer?

1. Open Source
2. Layout Management
3. Container-based lightweight development
4. Availability of Null layouts
5. Powerful customization
6. Drag-and-drop features
7. Easy to use

Are you already excited?

First, you need to download Apache NetBeans IDE if you have not.

1. Download: NetBeans

2. Once downloaded, launch and create a new project.

   

3. After that, type your project name and finish.

4. Once you have created a new project, you need to create a class. Right-click on your project > new > class.

   

public class Demo2 extends javax.swing.JFrame {
  public Demo2() {
    initComponents();
  }
  @SuppressWarnings("unchecked")
  // <editor-fold defaultstate="collapsed" desc="Generated Code">
  private void initComponents() {
    setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
    javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
    getContentPane().setLayout(layout);
    layout.setHorizontalGroup(
      layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
      .addGap(0, 400, Short.MAX_VALUE)
    );
    layout.setVerticalGroup(
      layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
      .addGap(0, 300, Short.MAX_VALUE)
    );
    pack();
  } // </editor-fold>
  public static void main(String args[]) {
    //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
    try {
      for (javax.swing.UIManager.LookAndFeelInfo info: javax.swing.UIManager.getInstalledLookAndFeels()) {
        if ("Nimbus".equals(info.getName())) {
          javax.swing.UIManager.setLookAndFeel(info.getClassName());
          break;
        }
      }
    } catch (ClassNotFoundException ex) {
      java.util.logging.Logger.getLogger(Demo2.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
    } catch (InstantiationException ex) {
      java.util.logging.Logger.getLogger(Demo2.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
    } catch (IllegalAccessException ex) {
      java.util.logging.Logger.getLogger(Demo2.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
    } catch (javax.swing.UnsupportedLookAndFeelException ex) {
      java.util.logging.Logger.getLogger(Demo2.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
    }
    //</editor-fold>
    java.awt.EventQueue.invokeLater(new Runnable() {
      public void run() {
        new Demo2().setVisible(true);
      }
    });
  }
}

Summary:

We’d like you to forget about the code for a moment! It’s just the beauty of GUI builders that you’ll be able to evaluate with more expertise and understanding of the fundamentals.

Can you see the connections now? So it must be a yes.

IDE builders will make your coding more accessible. It is not — however, the best practice for everybody.

Yet, if you can get the job done, custom drag and drop should not compromise your skill sets.

That said, given a few days of continuous effort, you will be able to create essential Windows-based Java Swing apps and others. 

If you’re still confused, here’s how to get started with your first Java Swing project in NetBeans.