TeamDev Ltd. Syndication Feed

JxCapture 2 Released

Kazmin — Fri, 04 Jun 2010 14:25:08 GMT

TeamDev is happy to announce official release of JxCapture 2, a cross-platform library that provides a comprehensive screen and video capture API for Java applications on Windows and Mac OS X platforms.

With JxCapture 2, you will be able to capture a screen or a screen area activity and save the result to a movie file. The API allows to specify the resulting movie format, size, bitrate, codec, audio source, etc. For the full scope of changes please check out the JxCapture 2 Release Notes.

You can try out the new version online using the WebStart Demo. The JxCapture 2, including demo application and samples, is available for download. Samples in distribution package will demonstrate how you can capture full screen, window or a region, configure capturing options and more.

For any help or feedback related to the use of our product, please use the support forum or e-mail us directly.

JxCapture 2 Release Notes

Kazmin — Fri, 04 Jun 2010 14:15:55 GMT

New Features:

Added audio recording features (WMV and AVI formats only);
Ability to get the collection of audio recording devices (in this version for Windows platforms only);
Ability to select an audio input device to enable video capture with sound;
Ability to specify a required audio codec and its settings;
Added video player Java component (Windows only) which allows to play a video file in Java application;
Added the ability to select audio source and audio codecs for recording (Demo application).

Improvements:

Added ability to specify video bit rate mode (VBR, CBR) for WMV;
Added ability to modify key frame interval for WMV;
Added support of new "Windows Media Video 9 Advanced Profile" (WVC1) video encoder.

Known limitations:

No support of 64-bit JRE on Mac OS X 10.6;
- Solution in this case is to run JRE in 32-bit mode;
No audio recording for Mac OS X (planned to future versions);
No ability to select available audio recording devices on Mac OS X (planned to future versions);
There is no native video playback component on Mac OS X.

JxCapture 2 Early Access

Kazmin — Tue, 20 Apr 2010 19:09:07 GMT

TeamDev is happy to announce the Early Access* for JxCapture 2, a cross-platform library that provides a comprehensive screen and video capture API for Java applications on Windows and Mac OS X platforms.

In this version we have added support of video capturing on Mac OS X and Windows platforms. With JxCapture 2, you will be able to capture a screen or a specified screen area activity and save the result to a movie file. The API allows to specify the resulting movie format, size, bitrate, codec, etc. For the full scope of changes please check out the JxCapture 2 EA Release Notes.

You can try out the new version online using the WebStart Demo. The JxCapture 2 Early Access build, including demo application and samples, is available for download. Note: The Early Access build is bundled with an evaluation license that expires May 30, 2010.

Please feel free to ask for help or just leave feedback at our support forum.

Stay tuned for new versions with more powerful and exciting features!

*Early Access gives you a chance to try the product out before it is officially released. Although we cannot guarantee that there will be no public API changes, or that certain features will be available in the final product, we will do our best to make your Early Access experience useful and future transition to the release version as easy as possible. Early Access - is your opportunity to contribute to the development process and help us shape the product to fit your needs.

JxCapture 2 EA Release Notes

Kazmin — Tue, 20 Apr 2010 18:26:39 GMT

New Features:

New API for Video capturing which allows:
- Capturing different screen areas such as:
- - Desktop;
  - Full screen (effective for multi-monitor desktops);
  - Custom rectangular area (with possibility to change the location of the captured rectangle during video capturing);
  - Specified window (full or a rectangle on the specified window);
- Capturing with or without mouse cursor (in Early Access for Windows platform only);
API for fast resizing of the captured snapshots (in Early Access only for Windows. Mac native resizing coming soon).
Various video encoding features allowing to specify programmatically:
- Output video formats:
- - WMV, AVI for Windows platforms;
  - MP4, MOV for Mac OS X platforms;
  - Custom video formats on Windows platform. *Requires additional third-party codecs.
- Output dimensions;
- Framerate (except AVI format);
- Bitrate (except AVI format).

Improvements:

Improved the performance of image capturing;
Improved the performance of conversion to Java images;
Improved API for capturing images.

Resolved Issues:

Resolved the GDI leak issues.

JxCapture 1.3.1 Released

Kazmin — Tue, 02 Jun 2009 08:25:50 GMT

We are pleased to announce a maintenance release of JxCapture, our cross-platform library that provides a comprehensive Java screen capture API for Java applications.

JxCapture 1.3.1 is focused on resolving the compatibility issues with Mac PPC platform. For the full list of changes, check out the JxCapture 1.3.1 Release Notes page.

The latest version is available for download from the product page of our web site.

For any help or feedback related to the use of this release, please use the support forum or e-mail us directly.

JxCapture 1.3.1 Release Notes

Kazmin — Tue, 02 Jun 2009 07:27:45 GMT

Fixes:

Restored compatibility with Mac OS X 10.4 (Platforms: PPC G4, G5)
Resolved the problem with incorrect colors of taken screenshots (Platforms: PPC G4, G5)

JxCapture 1.3 Released

Kazmin — Fri, 20 Mar 2009 09:40:09 GMT

Today we are pleased to announce a new release of JxCapture, our cross-platform library that provides a comprehensive Java screen capture API for Java applications. JxCapture 1.3 expands the list of supported hardware platforms with support for 64-bit platform of Windows and Mac OS X.

This new version also resolves issues reported to our support center. For the full list of changes, check out the JxCapture 1.3 Release Notes page.

Try online our Web Start Demo that is available for both Windows and Mac. Note: You need Java 1.6 to start JxCapture in 64-bit mode under Mac OS X.

Download the latest version and evaluate it during 30 days.

For any help or feedback related to the use of JxCapture 1.3, please use the support forum or e-mail us directly.

JxCapture 1.3 Release Notes

Kazmin — Fri, 20 Mar 2009 09:47:56 GMT

New Features:

Support for 64-bit platform of Windows and Mac OS X

Fixes:

Fixed issue when the teamdev.jxcapture.events.CaptureListener.complete() event is never invoked if an error occurs during screen capturing
Fixed issue when only the last created Keyboard and Mouse listener recieve the events
Fixed issue when Keyboard doesn't work for the current process on Mac OS X

JxCapture 1.2 Release Notes

IgorShvydkoy — Tue, 02 Dec 2008 12:59:53 GMT

New Features:

Mac OS X 10.5 (Leopard) support
Added the showDesktop() method to the teamdev.jxdesktop.WindowManager class that allows showing desktop
Added the toFront() method to the teamdev.jxdesktop.ui.Window interface that allows setting specified window to front
Added the getIcon() method to the teamdev.jxdesktop.ui.Window interface that allows receiving window icon
Added functionality to the teamdev.jxdesktop.ui.Window interface that allows moving and resizing a window
Added teamdev.jxdesktop.Mouse class that allows listening all mouse events
Added teamdev.jxdesktop.Keyboard class that allows listening all keyboard events

Documentation:

Added the "Listening Mouse and Keyboard events" chapter in JxCapture Programmer's Guide
Added MouseListenerSample example
Added KeyboardListenerSample example

Fixes:

Fixed the issue when the Helper dialog box is not displayed during 'Region Screen Capture' operation (Mac OS X, JxCapture Demo)
Fixed the issues with hot-keys when JxCapture Viewer window is open (JxCapture Demo)
Fixed the issue with IncludeCursor option. Now it works for ActiveWindowCapture operation (Windows OS)
Fixed the issue with wrong cursor position on full screen rectangle capture (Windows OS)
Fixed the issue when JPG files are not displayed in the "Open File" dialog box (JxCapture Demo)
Fixed the issue when Cancel action isn't fired for ScreenObjectCapture operation
Fixed the issue when java.awt.event.MouseEvent cannot be cast to java.awt.event.MouseWheelEvent (Windows OS)
Fixed the issue when modificators are not recognized in keyboard events processing (Mac OS X)
Fixed the issue with black screen in Mac OS X when capturing a region (Mac OS X)

Demo:

New JxCapture Settings dialog box for Mac OS X platform
Improvements and fixes.

"Shoot" at Leopard with JxCapture 1.2

IgorShvydkoy — Tue, 02 Dec 2008 12:58:16 GMT

Today we pleased to announce a new release of JxCapture, our cross-platform library that provides a comprehensive Java screen capture API for Java applications.

As we promised last time, JxCapture 1.2 introduces support of Mac OS X Leopard 10.5. Also in this release you can find the updated Demo application with new improvements. For the full list of new features and improvements, check out the What's New page.

Try online our Web Start Demo that is available for both Windows and Mac.

Download the latest version and evaluate it during 30 days.

For any help or feedback related to the use of JxCapture 1.2, please use the support forum or e-mail us directly.

Experimenting with Swing Application Framework

vladimir.ikryanov — Tue, 10 Jun 2008 14:51:10 GMT

Introduction

The quality and speed of building a Java-based graphic user interface (GUI) have always been high on the agenda. It is no secret that the development of a graphical interface using Swing requires quite a plenty of time. But it's not critical if the developer doesn't have a very deep knowledge of a GUI building. He just needs to write large amounts of code for the creation and adjustment of any graphical component. Sometimes this process becomes quite monotonous and boring and it's great when you can delegate this routine work with component adjustment to anybody else...

Swing Application Framework library is designed to help with the development of desktop applications that contain GUI. It's a small set of Java classes, aka "the framework", that provides a ready-to-use infrastructure for most desktop applications. The use of this library allows to make an application architecture more obvious, and the code "lighter" for understanding and further support. Besides this framework undertakes all the routine operations with the configuration of graphical components, and lets the developer to concentrate on other aspects of application development (realization of business logic etc.).

For each of our products we create a demo application to highlight its major features. For our new product, JxCapture, we also made a small demo application which in fact represents a simple screen capture solution. It's a common Swing application. The functionality of the application is enabled through a menu accessible through a tray icon, providing settings and an image viewer for a captured image.

Initially, we implemented the demo application using a standard Java Swing library. However, we are always on the look for new ways and technologies that can help us make our products better. Keeping track of the development of the Swing Application Framework, that is designed to help with the desktop application development, we decided to try it out and re-write the existing Swing-based application. The purpose of this "experiment" was to research the capabilities of the framework and possibly to further use it in the development of Java-based desktop applications.

So we had a Swing-based application and decided to write exactly the same one but with the Swing Application Framework.

Application Lifecycle

When we started working we noticed at once how convenient application lifecyсle was realized. Swing Application Framework provides a very convenient mechanism for tracking of such events like starting and shutting down an application. For application start we realized all the necessary operations, such as reading of application settings from a configuration file, registration of various listeners, adjustment of graphical components of an application etc.

At application shutdown we carry out all necessary operations required for a correct shutdown: releasingof unused resources, closing streams, removing listeners, saving settings into configuration file.

To launch our application we just needed to inherit the main class of an application from the SingleFrameApplication and to call Application.launch function in the main method. We had no need to wrap the code that launches the application into Event Dispatch Thread. This functionality was already realized in the function Application.launch.

public static void main(String[] args) *throws* Exception {
    launch(JxCaptureDemo.class, args);
}

We were pleasantly surprised that the default look and feel was system-dependant.

Resources

The application framework supports automatically initializing the properties of named components from ResourceBundle resources. That is using "resource injection" we can adjust many parameters of the component simply by naming it! All other parameters that are defined in the appropriate resource file will be set automatically.

We used this mechanism when configuring all graphical components of our application. For example in the dialog "About" we used "resource injection" to adjust most of the components of this dialog. Parameter values for components reside in a special resource file - AboutDialog.properties. This approach is especially convenient for a mixed-language interface. Besides all the data for the graphical components is stored in one place what simplifies the search and replacement of any parameters.

Resources can be used for initialization of class fields as well as for adjustment of component parameters. We just needed to mark required fields with annotation @Resource and to set values in the properties file for these fields. After the command ResourceMap.injectFields was executed all the marked fields were initialized automatically. In most cases the fields were of a simple type (String, int etc.). But in the class ApplicationSettings we used this approach for initialization of fields that represent string arrays. For this purpose we only needed to determine in the properties file the following content:

ApplicationSettings.imageFormats[0] = png
ApplicationSettings.imageFormats[1] = jpeg
ApplicationSettings.imageFormats[2] = bmp
ApplicationSettings.imageFormats[3] = gif

And in the class ApplicationSettings we also needed to make initialization that had the following look:

public final class ApplicationSettings {
    @Resource
    private String[] imageFormats;
 
     // ...
 
     private ApplicationSettings() {
        ApplicationContext context = Application.getInstance().getContext();
        ResourceMap resourceMap = context.getResourceMap(ApplicationSettings.class);
        Integer length = resourceMap.getInteger("ApplicationSettings.imageFormats.length")
        imageFormats = new String[length];
        resourceMap.injectFields(this);
    }
 
     // ...
}

As you can see we had to allot memory for the field imageFormats before initializing this field. It's a little bit unhandy, because we have to know the exact number of array components. In our case we decided to store the array length in the resource called "ApplicationSettings.imageFormats.length". Hopefully developers will make memory allotment as a part of the field injection in the future.

Actions

Every desktop application is based on an event model. Using the annotation @Action in SAF we can mark a method that's intended to serve as the implementation of an Action's actionPerformed method. The ApplicationContext getActionMap method creates an ActionMap that contains one Action object for each @Action defined by some class. The annotation @Action in our code lets us make it more obvious and easy for perception. So, for example, the realization of events in the class TrayPopupMenu with SAF has the following look:

public class TrayPopupMenu extends JPopupMenu {
    private ApplicationSettings settings = ApplicationSettings.getInstance();
    private CaptureOperations operations = CaptureOperations.getInstance();
    private boolean captureOperationEnabled = true;
 
     // ...
 
     public boolean isCaptureOperationEnabled() {
        return captureOperationEnabled;
    }
 
     public void setCaptureOperationEnabled(boolean captureOperationEnabled) {
        boolean oldValue = this.captureOperationEnabled;
        this.captureOperationEnabled = captureOperationEnabled;
        firePropertyChange("captureOperationEnabled", oldValue, this.captureOperationEnabled);
    }
 
     @Action (enabledProperty = "captureOperationEnabled")
    public void activeWindowCapture() {
        operations.activeWindowCapture();
    }
 
     @Action (enabledProperty = "captureOperationEnabled")
    public void objectCapture() {
        operations.objectCapture();
    }
 
     // ...
}

The realization of the same class using a standard approach requires 30% more code lines! The parameters for each event we described in the appropriate properties file:

activeWindowCapture.Action.text = Capture active window
activeWindowCapture.Action.icon = images/act_window.png
activeWindowCapture.Action.accelerator = control shift A
 
 objectCapture.Action.text = Capture window / object
objectCapture.Action.icon = images/win_obj.png
objectCapture.Action.accelerator = control shift W
...

These @Actions also introduces the enabledProperty annotation parameter which binds the enabled state of the @Action to the current value of a property. Our application settings allow to set assignable delay before capture operation, so that the user could take some actions before this operation takes place, for example he can open/close some windows. It's advisable to restrict the for the user from performing other operations during this delay. It can be realized for example by disabling them. In our example we have just that case.

The parameter captureOperationEnabled checks if any operation is currently launched. Thanks to the entry @Action (enabledProperty = "captureOperationEnabled") we bind the state of the variable captureOperationEnabled to the state of an event (in our case to the state of all the events that should be disabled when there is already one operation running). It's very convenient and easy!

Unfortunately it's possible to define only the method that determines the realization of Action's actionPerformed method so far. It would be very convenient if we could define parameterized events using annotations. And until then we have only one solution for such cases - to use standard Swing approach which is based on creation of a class that will describe the required event.

Summary

In our application we had no need to use other features of this framework, such as:

Persistent session state: support for automatically and selectively saving GUI state, like top level window geometry, from one run of an application to the next.
Actions that swap background tasks.

But I'm sure these features will be useful in most desktop applications. This framework is certainly worth using in development of large applications. In most cases Swing Application Framework contains everything that experienced developers may need for their complex applications (application lifecycle, task service or resource management). And even if there's missing something here, you can always use standard approach.

In whole in spite of some shortcomings mentioned above (or peculiarities if we can say so ), it was very interesting and easy to re-write with Swing Application Framework an application primarily written using Swing. This framework has a lot of really convenient and practical things. Sometimes its approaches seem to be so obvious that it's strange that nobody has implemented it earlier. So, long live developers of this framework! They managed to enhance the development process for desktop applications in Java and to make it more interesting and convenient.

Useful Links

Swing Application Framework site
JxCapture Demo: SAF and Swing versions
JxCapture Demo sources: SAF and Swing version

JxCapture 1.1

IgorShvydkoy — Thu, 20 Dec 2007 12:59:59 GMT

New Features:

Mac OS X 10.4 support (PPC and Intel)
Capture hidden windows/objects (available for Windows platform).
Added teamdev.jxdesktop.ui.Window interface that represents a top-level window with title and border.

Improvements:

Removed the getGraphics() method from the UIElement interface.
Renamed ObjectOnScreenCapture class to ScreenObjectCapture.

Demo:

Added Mac OS X demo.
Demo can be started by executing jxcapturedemo.jar.
Other improvements and fixes.

JxCapture 1.1 Featuring Mac OS X Support

IgorShvydkoy — Thu, 20 Dec 2007 12:58:48 GMT

Just as we announced previously we now make version 1.1 release of JxCapture introducing Mac OS X support.

The 1.1 release works on both Intel and PPC machines and requires Mac OS X 10.4 to work. In the next update we are planning to add full support for the newest Leopard Max OS X operating system from Apple.

Please note that if you already purchased JxCapture you can use the Mac OS X version as you license includes this platform already.

Download the latest version and evaluate it during 30 days.

Do not miss our Web Start demo that is available for both Windows and Mac now.

JxCapture 1.0

IgorShvydkoy — Thu, 20 Sep 2007 12:59:59 GMT

API changes:

Added findWindow() method to WindowManager class.
The set- and getCaptureTransparentWindow() method added in CaptureSettings.

Documentation:

Added JxCapture Programmer's Guide.

Demo:

Added new implementation of JxCapture Demo application based on Swing Application Framework.
Added Demo settings storing and reading on program start.
The 'Copy to Clipboard' functionality added in the viewer.
Added 'Open File...' option to tray menu.

Other:

Windows XP 64bit support added.
Minor improvements.

JxCapture Commercially Available

IgorShvydkoy — Thu, 20 Sep 2007 12:58:32 GMT

JxCapture is our new library that will allow you easily add different screen capturing abilities to your software. With our powers to speak platforms' languages it was easy to introduce several capture operations and gain outstanding performance even for high resolutions and multiple monitors.

JxCapture leaves Early Access state and is now available for commercial usage.

Right now JxCapture is only available on Microsoft Windows platform, but we are already working on Mac OS X and Linux is on its way.

Special offer: if you purchase JxCapture for Windows now, you will receive licenses for Mac OS X and Linux free of charge. The offer is valid until the end of this year. The version for Mac OS will be available in December 2007.

To try JxCapture, run one of its Web Start demos that contain all needed screen capture abilities (full-screen, region, active window, UI element capture, etc).

You'll notice two demos. They have same functionality but they are implemented using different technologies. We've been intrigued by the new Swing Application Framework and wanted to get our hands on it on a real application. You can try it and see the code of both demos to compare.

Evaluate full-featured JxCapture for 30 days and let us know what you think.