Imaging Experts

Patents, Trojan Horses, and Time Bombs

Many of our engineering customers, when comparing products such as ours, concentrate on features and performance. What organizations often overlook is the need to go beyond the technical features when determining requirements of a product and consider additional risk factors.

Companies need to find out that the product they are planning to purchase:

• Doesn’t have embedded code that infringes upon a patent or copyright
• Doesn’t contain a Trojan horse
• Has been tested and examined for embedded viruses or time bombs
• Contains certified-safe third-party code if it embeds any external libraries or open source code

We understand these concerns because we provide products and services to a great number of high profile, security conscious organizations in the financial services, insurance, document management, and health records arenas. These companies are entrusted with highly confidential information that must be stored and processed securely. They also typically serve thousands, if not millions, of people who are dependent upon their information being reliably accessible as well as private.

When these companies embed imaging technology into their products in order to view and manipulate documents and images, they need to have absolute confidence that their applications and data will remain safe. Unlike many others, we can verify the safety and security and ownership of all the code within our products. We perform our development within the confines of our own offices in order to assure that security. To many of our customers, this assurance is as important as the features and power of our imaging solutions.

-Simon

Using AWT Dependent Imaging Routines in SWT

For many years, Java programmers have been building GUI's with AWT, the "Abstract Window Toolkit". This was Java's first stab at creating a widget library for buttons, windows, text fields etc. AWT has it's many shortcomings, since it generally relies on every operating system having a corresponding native component. Sun soon came out with Swing, which many people saw as being far more flexible, since it did not rely on native OS components for its implementation.

More recently, a newer component toolkit has gained popularity. SWT, the "Standard Widget Toolkit", is the fundamental component library upon which Eclipse is built. More and more developers are adopting SWT, as Eclipse is becoming the universal standard for Java development environments.

I recently faced a challenge. If I had code that relied heavily on its interaction with the AWT-based Java2D drawing routines, how could I port that over to a new SWT-based program?

After some searching, I found an excellent article and some sample code at IBM's DeveloperWorks site. The author provides source for a small utility class, Graphics2DRenderer, that essentially allows you to convert an SWT-based graphics context to a java.awt.Graphics object.

I put this code to work in a very basic sample in an attempt to use Snowbound's RasterMaster for Java in an SWT program. Since Snowbound's painting routines rely on a java.awt.Graphics object, I needed to use the Graphics2DRenderer to generate an instance.

import java.awt.Graphics2D;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import swtgraphics2d.Graphics2DRenderer;
import Snow.Snowbnd;

public class SWTExample
{

    Snowbnd simage ;

    public SWTExample()
    {
        simage = new Snowbnd();
        simage.IMG_decompress_bitmap("c:/imgs/rollsroy.png",0);
        Display display = new Display();
        final Shell shell = new Shell(display);
        FillLayout layout = new FillLayout();
        shell.setLayout(layout);

        Canvas canvas = new Canvas(shell, SWT.CENTER);
        final Graphics2DRenderer renderer = new Graphics2DRenderer();

        canvas.addPaintListener(new PaintListener() {
          public void paintControl(PaintEvent e) {
            Point controlSize = ((Control) e.getSource()).getSize();

            GC gc = e.gc; // gets the SWT graphics context from the event

            renderer.prepareRendering(gc); // prepares the Graphics2D renderer                

            // gets the Graphics2D context
            Graphics2D g2d = renderer.getGraphics2D();

            /*
             * Perform actions on g2d
             */          

            simage.IMG_display_bitmap(g2d, 0,0,controlSize.x, controlSize.y);            

            /*
             * Done with the g2d object
             */

            // now that we are done with Java 2D, renders Graphics2D operation
            // on the SWT graphics context
            renderer.render(gc);

            // now we can continue with pure SWT paint operations
            gc.drawOval(0, 0, controlSize.x, controlSize.y);
          }
        });

        shell.pack();
        shell.open();
        while (!shell.isDisposed())
        {
            if (!display.readAndDispatch())
                display.sleep();
        }
        display.dispose();
    }

    public static void main(String[] args)
    {
        SWTExample swt = new SWTExample();
    }

}

-Alex