
	Where results make sense

Topic: JFace

In the News (Thu 24 Dec 09)

Northern Trust

Marvin Harrison

Peter Chernin

Gary Locke

Match Play

Penelope Cruz

Mickey Rourke

AR Rahman

Danny Boyle

Hugh Jackman

	Using the Eclipse GUI outside the Eclipse Workbench, Part 1: Using JFace and SWT in stand-alone mode (Site not responding. Last check: 2007-11-01)
		JFace is window-system-independent in both its API and implementation, and is designed to work with SWT without hiding it.
		Instead, a JFace window is a helper object that knows about a corresponding SWT Shell object and provides code to help create/edit it, listen to its events, etc. Figure 3 shows the relationship between your code, JFace, and SWT.
		JFace looks at its parent and then the parent's parent, etc. until it reaches a node that is displayed and it then tracks down again until the target node is displayed.
	www.ibm.com /developerworks/opensource/library/os-ecgui1 (2986 words)

	Rich clients with the SWT and JFace
		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.
		JFace covers many areas of UI development that developers encounter over and over, and it provides a clean way to accomplish those tasks.
		For example, JFace viewers, which are model-based content adapters for SWT widgets, provide methods to access the underlying SWT widgets.
	www.javaworld.com /javaworld/jw-04-2004/jw-0426-swtjface.html (1514 words)

	Realsolve - Building an Eclipse Text Editor with JFace Text
		JFace Text is a sophisticated framework which allows an Eclipse plug-in developer to build text editors with advanced features, such as syntax highlighting, basic content assistance and code formatting.
		When you open a document which uses JFace Text, the framework divides the document into partitions, that is, a region of text within the document.
		JFace Text has been neatly separated into parts of the framework which your application will need to provide implementations and parts that don't.
	www.realsolve.co.uk /site/tech/jface-text.php (6674 words)

	tomlauren.com: AWT, Swing, SWT, and JFace: A comparison of Java GUI libraries
		JFace provides a MVC abstraction layer on top of SWT, hiding the details of interacting with low-level widgets from the developer.
		The JFace implementation of HelloWorld improves on the SWT implementation with the removal of a hand-coded event loop.
		Overall, if you don't require native performance and look-and-feel, or don't want to introduce third-party GUI library jar files, deal with lack of native component garbage collection, or deal with the added learning curve for you and/or your developers, then Swing is the safe choice.
	www.tomlauren.com /weblog/archives/000022.html (899 words)

	How to use the JFace Tree Viewer
		JFace also acts as a bridge between low-level SWT widgets and your domain objects.
		JFace viewers consist of an SWT widget (e.g.
		More information about JFace and SWT can be found in the Javadoc for org.eclipse.jface.viewers, org.eclipse.swt.widgets, org.eclipse.swt.custom and JFace viewers.
	www.eclipse.org /articles/Article-TreeViewer/TreeViewerArticle.htm (5576 words)

	The Visual Editor » HOWTO get started with JFace Data Binding
		By far, the largest body of publicly-available examples for using JFace Data Binding is in the test suite.
		This test suite is based off of the scenarios document, which is a list of use-cases that we expect data binding to cover, so it turns out to be a very good starting place for people wanting to learn the library quickly.
		JFace Data Binding is really a generic data synchronization service.
	www.coconut-palm-software.com /the_visual_editor/?p=57 (1699 words)

	Luis de la Rosa: Eclipse JFace tip: How to add column headers to a TableViewer (Site not responding. Last check: 2007-11-01)
		The JFace team wrappers these SWT widgets to let programmers work with them in Model-View-Controller (MVC) way.
		The JFace team is careful not to duplicate any of the SWT work.
		This leads us to the solution to our problem of adding column headers to a JFace TableViewer: You need to get the table (which is playing the View of MVC), add the column headers to it, and also tell it to show its headers.
	www.luisdelarosa.com /blog/2005/01/eclipse_jface_t.html (533 words)

	Developing JFace wizards (Site not responding. Last check: 2007-11-01)
		The JFace toolkit, part of the developing Eclipse project, provides a powerful set of user interface components that developers can easily leverage within a stand-alone application.
		Just like the Eclipse project, both the SWT and JFace libraries were designed from the outset to support a variety of operating systems and environments.
		The Eclipse project provides the JFace and SWT toolkits that were used in this article's source code.
	www-106.ibm.com /developerworks/opensource/library/os-ecjfw (1837 words)

	Amazon.com: The Definitive Guide to SWT and JFACE: Books: Robert Harris,Rob Warner (Site not responding. Last check: 2007-11-01)
		Part of the Eclipse IDE (Eclipse itself is built with this software), SWT and JFace provide for portable Java applications that have native platform performance and native platform appearance.
		JFace, an additional abstraction layer built on SWT, is also described and this book demonstrates how to build applications with JFace with explanation and example code.
		He has used SWT and JFace on several projects, including an executive information system for a religious organization, a password-retrieval Eclipse plug-in, and various other applications and utilities.
	www.amazon.com /Definitive-Guide-SWT-JFACE/dp/1590593251 (2323 words)

	Standard Widget Toolkit - Wikipedia, the free encyclopedia
		This would enable SWT to work on every platform that Swing supports, thus improving SWTs cross-platform support.
		JFace is designed to enable easier, platform independent usage of SWT, wrapping around SWT code and hopefully providing a Swing like level of ease of use.
		JFace is a higher level wrapper around SWT, and it thus provides a cross-platform interface to SWT.
	en.wikipedia.org /wiki/Standard_Widget_Toolkit (1756 words)

	Java book > The Definitive Guide to SWT and JFACE (Site not responding. Last check: 2007-11-01)
		The Definitive Guide to SWT and JFace is indeed definitive and proved to be a nearly perfect choice for starting my journey inside Eclipse's much hyped GUI toolkit(s).
		Demonstrations of building JFace applications are also included and reinforced with thorough explanations and example code.
		This is overall an excellent introduction to SWT and JFace.
	www.javashelf.com /servlet/books/1590593251 (1090 words)

	Creating SWT Applications with Eclipse and JFace - OSNews.com
		In SWT and JFace Part 3 find out how to use tabular tree, canvas, styled text, slider, spinner, scale and other controls, as well as stack layouts.
		In SWT and JFace Part 1 learn how to to create simple SWT GUIs using Eclipse, Java, basic JFace controls and layouts.
		In SWT and JFace Part 2, learn how to use combo, list, table, and tree controls, as well as form layouts and reusable helper methods.
	www.osnews.com /story.php?news_id=12069 (190 words)

	The (J)Face of Eclipse
		SWT and JFace, on the other hand, are the two you will encounter almost everywhere—from simple SWT-based applications (that don't even use the Eclipse runtime), to workbench-based RCP applications, to IDE plug-ins.
		I'll first introduce you to JFace rather than SWT; you will find that it is JFace, rather than SWT, that provides the constructs you will likely end up using the most when developing end-user applications.
		In the Platform Plug-in Developer Guide, JFace is described as "a UI toolkit that provides helper classes for developing UI features that can be tedious to implement." In fact, JFace lets you focus on the end-user functionality you want to implement and avoid the complexities of managing widgets and the underlying OS resources.
	www.developer.com /java/other/article.php/10936_3565006_1 (2057 words)

	Introduction - SWT and JFace, Part 1: A gentle introduction - Developer Fusion, the UK developer community - VB, ASP, ...
		The Standard Widget Toolkit (SWT) and JFace libraries are used to develop graphical user interfaces (GUIs) for the Eclipse environment, and also to develop stand-alone GUI native applications.
		This series, SWT and JFace, includes basic articles describing developing applications using the Standard Widget Toolkit (SWT) and JFace libraries that come with the base Eclipse software development kit (SDK).
		This series concentrates on using SWT and JFace for stand-alone applications.
	www.developerfusion.co.uk /show/5135 (772 words)

	EclipseCon 2006: JFace Data Binding (Site not responding. Last check: 2007-11-01)
		This poster presents the new JFace data binding framework, which allows easy linking between UI elements and models so that users can view or edit the data in the model.
		Boris is the component owner of JFace viewers, and is interested in all things RCP.
		He was a member of the Eclipse Team/CVS team during the 1.0 release cycle and joined the Eclipse team again just before the 3.1 release.
	www.eclipsecon.org /2006/Sub.do?id=515 (194 words)

	JFace application development tutorial
		JFace 3.1 App Building and Deployment Demo and Recommended Guidelines for Win32 Environment
		The libs included in the lib and the Class-Path statement were empirically determined to be the minimum required for this simplistic JFace demo app.
		Getting CLASSPATH stripped down to as little as possible or nothing at all is offered for consideration.
	www.zikal.com /jface/JFace3_1.html (816 words)

	Bookpool: SWT/JFace in Action
		The book also shows how JFace simplifies and organizes the process of GUI design.
		JFace is also vitally necessary for applications that interact with the Eclipse Workbench.
		For experienced developers, this book also presents the finer aspects of GUI development, including using viewers and registries to organize components for more effective operation.
	www.bookpool.com /sm/1932394273 (520 words)

	SWT and JFace, Part I/II: a Gentle Introduction - OSNews.com
		In part I of this series, you get introduced to Eclipse, the Eclipse SWT, and the JFace GUI tool kits to construct Eclipse and stand-alone rich GUIs.
		Part 2 shows you how to create simple Standard Widget Toolkit applications using Java technology, Eclipse, and the SWT and JFace libraries.
		Reproduction of OSNews stories is granted only by explicitly receiving authorization from OSNews and if credit is given to OSNews.
	www.osnews.com /story.php?news_id=11305 (162 words)

	On The Web - SWT, JFace, and RCP (Site not responding. Last check: 2007-11-01)
		I've been playing around with SWT (Standard Widget Toolkit) lately.
		SWT has a bunch of widgets and creating a simple app is not too bad.
		But, to make development a bit easier, there is JFace, which is a set of SWT helper classes.
	www.otweb.com /blog/index.php?p=733&c=1 (228 words)

	Building a Custom Text Editor with JFace Text - Example
		In Chapter 26, Building a Custom Text Editor with JFace Text, you learned how JFace Text provides a framework for creating, displaying, and editing text documents.
		The framework is domain-independent, extensible and rich with support for building editors of syntax-oriented text, such as programming language source, XML, HTML, and SQL.
		It is not surprising, then, that Eclipse’s default text editor and Java editor are built using this framework.
	www.jdg2e.com /ch26.jface.text/doc/index.html (595 words)

	mockobject API - API for mockobject unit tests.
		This tool automatically downloads the jar files you need to work with the mockobject API.
		The mockobject API is found in the jface remote repository on Sourceforge: http://jface.sourceforge.net/maven.
		You have to add this location to your list of remote repositories, for example into your build.properties (see the Maven documentation for more details):
	jface.sourceforge.net /mockobject (308 words)

	SWT/JFace In Action, Matthew Scarpino, Stephen Holder, Stanford Ng, Laurent Mihalkovic - ISBN 1932394273 - ELX.com.au ...
		Obtaining the JFace text packages 88, TextViewer and Document 89, A JFace example 91
		Using fonts with SWT 145, Coding with fonts 148, Improved font management with JFace 150
		Accelerator keys 201, Creating menus in SWT 201, Using JFace actions to add to menus 204
	www.elx.com.au /item/1932394273 (844 words)

	A P R E S S . C O M : The Definitive Guide to SWT and JFace (Site not responding. Last check: 2007-11-01)
		C O M : The Definitive Guide to SWT and JFace
		Apress.com is recovering from system error, as a result, some of its content may be temporarily slightly out of date.
		Sign up to get the latest information on new books, events, and much more!
	www.apress.com /book/bookDisplay.html?bID=351 (391 words)

	Amazon.com: Professional Java Native Interfaces with SWT/JFace (Programmer to Programmer): Books: Jackwind Li Guojie (Site not responding. Last check: 2007-11-01)
		SWT/JFace in Action: GUI Design with Eclipse 3.0 (In Action series) by Matthew Scarpino
		The Definitive Guide to SWT and JFACE by Robert Harris
		This chapter outlines the three main Java user interface (UI) toolkits: AWT, Swing, and JFace.
	www.amazon.com /exec/obidos/tg/detail/-/0470094591?v=glance (1051 words)

Try your search on: Qwika (all wikis)