Java-ScriptGate.com

How To Get Your PC Computer Repair

admin — Thu, 07 Jul 2011 10:08:32 +0000

If you are live on UK and have a computer, probabilities are that you may require PC computer repair to make persuaded that your computer is running accurately. You be supposed to also looking for computer support so that files that are on your hard drive can be backed up in casing something happens to your computer. It is an excellent thought to reverse up any files that are on your computer hard drive to a explode drive or disc so that you can continue these files in future as per your need.

If incredible happens to your computer, such as a virus, at that time you may consider that you have to replace the computer. This is not essentially correct. You must primary look to PC

Milestone IT -: IT Recruitment/ IT Jobs: Milestone IT Recruitment offers IT employment solutions to help you meet IT employment requirements,IT Jobs and IT employment needs.

computer repair if you are in this region so that the trouble is able to be corrected. If you want to recover files, then request for computer backup so that you be able to get records that were on your hard drive as well. It can be terrifying to have a computer that is not operational, especially if you use it for exertion purpose. You should constantly have some species of backup when it comes to exertion files. This can be provided for you through a backup resource.

Computer repair can necessitate data recovery as well as eliminating virus spy-ware from your computer. As a replacement for of throwing in the wipe when it comes to computer problems, you are enhanced rotten to take your computer to a highly regarded repair store that will be competent to assist you recover data as well as make available you with highly regarded backup. They can also get liberate of any viruses that might be slowing your computer down.

Once your computer is slow, probabilities are that you require cleaning up your hard drive and removing viruses. As an alternative of letting this maintain and the computer consequently moving slower and slower, you are improved off to have the issues addressed. Repairing your computer is much cheaper than replacing it. Regardless of whether you have a desktop computer or a laptop, it can frequently be repaired. Even if you imagine that you have missing records, probability are that the data can be retrieved by those who know how to repair your computer and pull through the computer problem in technique that will have it positive and successively in rejection time dreary.

While you are looking for computer repair, you require to come across a place that is trustworthy, will be talented to repair your computer in an appropriate method and one that is also restricted. Take appear online at a computer repair company that is situated close to where you exist so that you can contract the most excellent service for your computer. At the first sign of any difficulty, you are improved off to look for this service so that you can continue your data in a protected method as well as maintain your computer operation smoothly. For the most part of computers can be repaired and important data retrieved when you apply a company that is well versed when it comes to removing viruses and provided that you with excellent data backup as well as computer repair.

Microsoft office support – VirtualPCConsultants provide online computer support and many technologies and applications online. Which serves our time and facilitate more as Microsoft office support, Online Software support, PC software support and many more .for any query and information you can call or remote access support at any time.

Product Data Management – product data management Solution Company provide the facility of edit and submit new data.

Domainsatcost Coupon – Share,rate,comment the domainsatcost.ca coupon codes and promo codes.They are all live.

Yahoo Coupon – Share,rate,comment the yahoo domain and webhosting coupon codes and promo codes.

Singapore Corporate Secretary – Lccglobal provides full assistance to private companies. As per Singapore company act each must have a Company Secretary. We provide affordable secretarial services.

letterhead printing

Computer Repair winter Park- A+ Computer Fix (407-362-7908) computer company Orlando specializes in Orlando Florida Onsite Computer Repair Services, computer repair Orlando, computer service Orlando, computer networking Orlando, Technical Support for Small Business Computer Networks.

Doteasy Coupon – Share , rate comment the dot easy coupon codes and promo codes.

Instant Payday Loans

cheap printer ink cartridges – Catridgezone.com aims to sell cheap printer ink cartridges. Ifyou are looking for printer and ink cartridges in UK, then you are atright place as we offer quality ink cartridges at low prices.

Link Building Services – We offer link building services and best SEO link building Services. Reciprocal and one way link building services, delivering high (PR) page rank and relevant link building UK. Outsource your link building campaigns to our link building team.

Varmepumper

Search Engine Optimisation North East England – Zine UK offer Website Design & Search Engine Optimisation services covering County Durham, North East England.

Local Search Engine Optimisation

cctv systems

barcelona hostels cheap

Make Unlimited QR Codes Free

SEO Company India – SEO Services by W3Origin, a leading SEO Company in India offering professional SEO Services at affordable prices.

Paramount Pest Control -pest control services to Melbourne suburbs – Paramount Pest Control can eradicate termites or deliver the most effective spider treatments, bee and wasp treatments, rat and mouse treatments or any other general pest treatments to make your home pest free.

IT channel marketing

Used Cisco Equipment – USED CISCO EQUIPMENT reseller Data Hardware specializes in used Cisco parts, switches and router models. 1-888-966-2110 Lowest Prices Guaranteed, 90% off, 1 yr Warranty, Free Shipping!

SCSM 2012 – Our insight into the major areas of improvement, new features, and our list of offered Management Packs that will enable a bespoke Microsoft SCSM 2012

Service Manager – System Center Service Manager 2010 (SCSM) is an integrated platform for automating and adapting IT Service Management best practices to resolve incidents

Drain Cleaning Los Angeles

Communication Skills

Mortgage Broker Los Angeles

Link building service india – cheapest SEO Company in India offers free SEO consultation and Search Engine Optimization.

Hyperv server

Online PC support AskPCExperts provides Online Computer Support at reasonable price via remote internet access or phone.

Initial Exploration of Draw2d on GWT/SVG

admin — Sat, 05 Feb 2011 05:21:00 +0000

It’s been some time since I updated this blog. The short story is, I made some progress with Java2Script, and produced a small prototype of SWT GC on HTML Canvas, which you can see here. Unfortunately, when trying to compile the next level of the stack, Draw2d, I ran into low-level compiler bugs. I’m continuing to work with the Java2Script developers on these issues, but I don’t really feel like I’m in a position to fix or work around bugs in the Java2Script compiler, so my mentor and I have been discussing alternative strategies. One such alternative is to start a level higher up the SWT/Draw2d/GEF stack, at the Draw2d layer, and attempt to implement the Draw2d API in terms of SVG or dojox.gfx, and use GWT to compile it. This is very interesting to me for a number of different reasons, so I’ve been drilling down into it. Here is what I have initially determined about the feasibility of this project: The main problem with this strategy is that the architecture of Draw2d encourages the use of an immediate-mode graphics API, exposed by the org.eclipse.draw2d.Graphics class, which is just a thin wrapper over GC’s immediate-mode API. The way Draw2d encourages the use of this API is by way of subclassing the Figure class. Figure subclasses implement, among other things, the paint or paintFigure methods, which get passed a Graphics instance, and use that instance for drawing. I think the whole process is that LightweightSystem sets up UpdateManager, which knows when to call the Figure’s paint method. This is a problem, because if Draw2d is to be implemented in terms of SVG (or some other browser-based, retained-mode graphics API, e.g. VML), it can’t be implemented in terms of an immediate-mode API. In my opinion, this is a limitation in Draw2d’s architecture with regard to our intentions, and I should note that it could have been easily avoided by making Figure protected. This would have forced everything outside of Draw2d to only use the API exposed by Draw2d. Now, however, there’s external code that depends on being able to subclass Figure. Less code than you might think, though. Here are all of the classes in GEF and GEF examples that extend Figure:

org.eclipse.gef.editpolicies - src - org.eclipse.gefSnapFeedbackPolicyFadeInorg.eclipse.gef.examples.flow.figures - src - org.eclipse.gef.examples.flowSubgraphFigureorg.eclipse.gef.examples.flow.parts - src - org.eclipse.gef.examples.flowActivityDiagramPartorg.eclipse.gef.examples.logicdesigner.figures - src - org.eclipse.gef.examples.logicBentCornerFigureNodeFigureorg.eclipse.gef.handles - src - org.eclipse.gefAbstractHandleorg.eclipse.gef.internal.ui.palette.editparts - src - org.eclipse.gefDetailedLabelFigureDrawerFigurePaletteStackEditPartPinnablePaletteStackFigureSeparatorEditPartSeparatorFigureToolbarEditPartorg.eclipse.gef.internal.ui.rulers - src - org.eclipse.gefGuideEditPartGuideLineFigureGuideFigureRulerFigureorg.eclipse.gef.tools - src - org.eclipse.gefMarqueeSelectionToolMarqueeRectangleFigure

So, not that many, and nothing from any of the GEF examples. So implementing Draw2D in terms of SVG may not be a perfect fit, but it might still be OK. Basically, the solution would be to limit usage of the Draw2d API only to those Figures that are declared in Draw2d (e.g. org.eclipse.draw2d.Triangle), and to those that are declared in GEF. Here’s how we would then proceed: Each class that implements Figure would keep a private member which is basically an SVG handle, which maps it into SVG. Or, if we don’t want a direct dependency on SVG, we can make it even more abstract and just create an INativeGraphicsAdapter interface, then implement classes that basically just a wrap around a handle to the native JS object, exposed via JSNI. Unfortunately, dependency injection is not an option here because Draw2d’s figure API doesn’t support it and we can’t change it. Messing with the class hierarchy (specializing for a particular implementation of this interface), is also not an option. So it seems as though we’ll have a strong dependency on some implementation class. I can’t see a way around this right now, unfortunately… But maybe the solution is in GWT’s deferred binding technique. I’ll research this more and see. For the moment, I’ll continue to think in terms of having a direct reference to a wrapped native SVG DOM node handle, because it’s easier to think about. The way it would then work is, for each Figure concrete subclass, either in the constructor, or in some init() method, an SVG DOM node gets created, but does not get added to the Document. The IFigure.add() method would add the node in DOM. IFigure.dispose would remove it. All operations in the IFigure API would then get mapped onto whatever native operations on the SVG DOM node are required. Also note that even though SVG does not natively include a concept of asynchronous updates (where you make a number of updates to a Figure, and it gets applied later on, asynchronously), it would still be possible to make use of this pattern by taking advantage of the fact that we have an extra API wrapping the native SVG. The way this would work is we implement the Command pattern, such that for most operations on IFigure, we create a command and save it in a private queue on each Figure object, and then wait until UpdateManager calls paint to flush all of the operations in the queue. And that’s it. We will also have some SWT requirements to satisfy, but I expect these to be very minimal, and now that I have a deeper understanding of SWT, I feel I should be able to spec these out fairy quickly and easily.

SEO Services - SBR Technologies providing quality SEO services for lead generation through internet marketing. Numerous satisfied clients from all across the world. Social media and reputation management services are also available at affordable price.

SEO services Las Vegas - Reliable SEO services meant to promote online businesses for small and medium scale enterprises in Las Vegas. Our expert services includes Organic SEO for major search engines like Google and Bing, paid positioning, social media marketing, reputation management and many more.

Website Maintenance Services - We-maintain-your-website is a reliable web maintenance service provider in California. Avail quality based web development, designing and regular maintenance services in and across California, USA at affordable price.

SVG Development with GWT 1

admin — Fri, 04 Feb 2011 15:13:00 +0000

In order for me to fulfill my project’s goal of implementing the retained-mode graphics API of Draw2d in terms of the retained-mode API of SVG, I need to be able to develop SVG using GWT. I remain confident that this is feasible, but it has been nontrivial to set up. I was originally going to use a GWT library called Tatami, the role of which is to expose much of the functionality of the Dojo JavaScript toolkit to Java, including the excellent, cross-browser dojox.gfx retained-mode graphics API. Unfortunately, Tatami turned out to be unsuitable right out of the gate, as its graphics API does not allow the developer to assign event listeners to individual objects, only to the top-level canvas. I have no idea why they chose to impose this restriction, as setting event listeners on individual objects is an extremely common pattern in retained-mode graphics API’s (certainly in Draw2d), and, from a technical standpoint, dojox.gfx allows event listeners to be attached to individual canvas objects, so there shouldn’t have been any massive technical barriers to implementing it. In any case, this restriction made Tatami unsuitable for this project out of the box, and so I began investigating alternatives. I’ve since been investigating the feasibility of scripting pure SVG using GWT. The first possibility I looked into was using GWT’s DOM API to manipulate SVG. The initial consideration was what kind of document would I use to deliver the SVG content? There roughly three possibilities for displaying SVG on the web today, and they are: 1. Via a pure SVG document 2. XHTML document with inline SVG; or an XHTML document with SVG embedded via the object or iframe tags 3. HTML4 document with embedded SVG via the object or iframe tags HTML5 documents will also allow SVG inlining (without even needing to use XML namespaces!), but I don’t think that there are any browsers that currently support this, so I didn’t consider this. What I found was that options 1 and 2 were not feasible, as GWT threw JavaScript exceptions while being loaded in these documents, so that left only option 3. Option 3 proved to be problematic as well. In principal, what should have occurred was to have the object tag reference an SVG document in its data attribute, and then set an onload event listener on the object tag. Once the object tag has finished loading, then it would be possible to script its DOM via the object tag’s contentDocument property. Setting a load listener on a document before scripting its DOM is a very common pattern in web front-end programming, and so I assumed that this would be straightforward to implement with GWT. Not so. GWT, unfortunately, doesn’t support setting event listeners on DOM nodes! I couldn’t believe this, because it is such a basic, fundamental feature of HTML DOM, but it’s true. I think the motivation for this is that GWT would prefer that you use its built-in widgets rather than low-level DOM. In any case, the effect of this is that it is not possible to listen for an onload event on a document simply using GWT’s implemnetation of DOM, so I couldn’t script the SVG DOM inside the object tag out of the box with GWT. I found other problems with GWT’s DOM implementation as well. To begin, it does not implement the standard Java interfaces published by the W3C (distributed by the Apache XML Commons). This is problematic because SVG has its own DOM, and while it is not necessary to use it (you can script everything in terms of the standard XML DOM), it would be beneficial to use the SVG DOM in development. Because of the way GWT’s DOM has been implemented, it cannot be easily extended to make use of the standard W3C interfaces for SVG. With these two shortcomings in mind, it seemed that the solution was to actually create a full DOM implementation for GWT in a way that used the standard W3C interfaces. The gwt-dom project started to do this back in 2007, but stopped development after GWT 1.5 included a DOM implementation. On the project page, they say that the project has been made “completely obsolete” by GWT 1.5, but I disagree, as there is still a need for a standards-compliant DOM implementation in GWT, at the very least in order to fulfill the needs of this project. Still, it makes sense to reuse as much of GWT’s DOM implementation as possible: it’s less work for me to implement and maintain. To achieve this, my solution has been to use the Adapter Pattern as follows: create DOM implementation classes that extend the standard w3c.dom.* interfaces; these DOMImpl classes compose a type object, and the DOMImpl classes delegate to this object whenever possible; where not possible, they use JSNI. In this manner, it is mostly possible to delegate to GWT DOM, while exposing a standards-compliant API to DOM that uses w3c interfaces, and I don’t have to hack on the GWT core. The gwt-dom project actually has provided a good foundation for this work, as it uses a similar pattern to achieve. One improvement that I have made to gwt-dom is to use Java 5 type annotations so that, rather than simply having each DOM implementation class compose a JavaScriptObject, the wrapped object is a and thus may be specified as far as is practical (for example to a com.google.gwt.core.client.Element), and thus we can have fairly deep integration with GWT. But, overall, I have been able to reuse most of the code in gwt-dom. There have been some problems so far with this approach so far, but I think this is mostly me tripping over the me tripping over Java’s type system. I often need to convert between arbitrary objects that implement DOM interfaces, and GWT DOM objects, and this can be a bit tricky. I have a solution, but it’s an ugly one, and I’m hoping to find a better way. I’ll post more about this later. So, my status is as follows: I have HTML DOM scripting working, and I’m now hooking up events. After that, it should be possible to test scripting of SVG content, and I will hopefully be able to start programming against it with respect to Draw2d very soon. I’m not to sure where this work is going to live when I’m done… upstream in the now-defunct gwt-dom project? I may try to contact the author and see what he thinks.

Recomended Sites

admin — Fri, 04 Feb 2011 05:59:52 +0000

SEO Company India – SEO Services by W3Origin, a leading SEO Company in India offering professional SEO Services at affordable prices.

norton 360 download

Online Colleges in Texas Discover online education applications from residence and search your finest online schools in texas

norton 360 download

1and1 Coupon – Share,rate,comment the 1and1 domain promo codes and coupons.

Service Manager – System Center Service Manager 2010 (SCSM) is an integrated platform for automating and adapting IT Service Management best practices to resolve incidents

Online Reputation Management ReputationHead offers online reputation management service using professional brand management techniques. We handle online reputation management with proven strategies that helps to set up and monitor reputation or brand image through online

TORONTO WEB DESIGN ACE is a Toronto web design firm that creates HTML, JAVA, CSS PHP websites that make the phone ring Call 1 888 586 2860 for a no obligation consultation

bluehost coupons codes

SEO Company India – SEO Service India by SEO Company India. TheSeoz #1 SEO Services Company India offer Guaranteed SEO Services. Contact us Today for Affordable SEO Services.

webbutveckling

Forensic Psychology Degree Discover about career in Forensic Psychology Degree and discover your finest Forensic Psychology Degree applications online.

Master of Science in Management Find out about career in Master of Science in Management as well as find your most effective online Master of Science in Management Schools.

Laptop Charger

Physiotherapy Vaughan

Sql backup Trying to restore your database to a particular point in time? Idera’s SQL safe backup solution and its trademarked IntelliRestore technology can help.

Internet For Libraries : Hughes Government Solutions are designed to meet the growing broadband needs of libraries. Hughes offers a range of speeds and affordable service plans.

high speed satellite internet :HughesNet high speed satellite internet is the solution to your company’s connectivity, broadband backup,private network security challenges. HughesNet also provides dish satellite network, satellite connection, cheapest satellite internet service with virtual private network.

Intrusion Defense: Firewalls protect networks from the outside-in. However, over 80% of successful cybercrime and hacker attacks happen behind firewalls, on the inside of networks. NACwalls protects networks from the inside-out. Designed for SMBs to protect their internal, headquarters, branch and remote office networks with 25 network devices up to 100,000 included wired and wireless, NACwalls provide enterprise-class functions that are easy to deploy, cost effective and help SMBs secure their internal networks at a fraction of the cost of competition.

Zoom h4n

Web Hosting India BrainPulse is leading web hosting company India offer Web Host Services on Linux/windows hosting Platform. Host website on VPS web hosting solutions, dedicated server Solutions India, reseller hosting on cpanel and Plesk hosting control panels with best quality at affordable Web Hosting Solutions from BrainPulse India.

Security Surveillance Systems : We design and install security systems for your business or home – based on your needs and budget. If you are interested in video/CCTV, burglar alarm, access control, audio/intercom, or a combination of these systems, we have the technical expertise and experience to design and install the right solution for you. All of our systems can be accessed remotely as long as you have an internet connection, computer, or smart phone.

Security Systems : For almost 10 years, Security Surveillance System™ has been installing and servicing surveillance systems all over the front range of Colorado. We are locally owned and operated and know security is an important factor in creating a long-term healthy business. We were founded on the simple idea that everyone deserves to feel safe and protected.

HMI With Built In PLC – Automation Technology Concepts offers PLC, HMI, Industrial automation, HMI with built in PLC and Machine automation in California.

sälja sitt företag

Web Development Sydney – Batish Technologies is a Sydney NSW based Website Design Company providing Graphic Design, Web Design, Ecommerce Website Design, Iphone App Development, Search Engine Optimisation, Search Engine Marketing and Sharepoint Development to its clients. To hire Sydney Based Web Designer or Graphic Designer, visit BatishTechnologies.com.

SEO India – Simplifying Internet Marketing with effective services position at Google with SeoSolvent.

structural steel detailing

Managed VPS Hosting

casino blackjack blog

247-casino-gambling-diary

know casino cardgames

141 bingo

casino pokerrooms

Logo USB drives – When it comes to desiging, creating and delivering unique custom flash drives, very few can come close to the experience that we have in this field.Our most instantly recognizable strength is our ability to create innovated, custom designed USB unique custom flash drives at low minimum order sizes and at price comparable to in stock USB flash drives.

Online Regnskabsprogram-Online Regnskabsprogram

Liquor inventory management We provide all the data entry, calculations, analysis is performed by professionals which allows you to concentrate on the things which helps to running your business and managing your staff better

Vista Cloud Backup We Provide Unlimited remote data backup and recovery service, no matter how much your data grow we always provide a speedy backup. Our services may be cheap, but our technology is first class. Try Penny Backup for 30 days – for free! No obligations, no hidden conditions.

How to Use Foxit PDF Reader 3.0 on Ubuntu 8.04 under Wine

admin — Thu, 03 Feb 2011 15:35:00 +0000

I figured out how to set up and run Foxit PDF Reader on Ubuntu 8.04 a little while ago, and I’m just now writing it down. Foxit works extraordinarily well under Wine: displaying documents, editing PDF form fields, annotating documents, and printing to a USB printer all worked for me out of the box. There are certain tricky things involved in setting it up, though, hence this How To blog post. First, download Foxit. The Foxit Windows installer didn’t work for me, but fortunately Foxit offers a .zip which contains the application frozen into a single Windows executable. Here’s a direct link at the time of this writing: http://mirrors.foxitsoftware.com/pub/foxit/reader/desktop/win/3.x/3.0/enu/FoxitReader30_enu.zip Unzip the executable and put it somewhere in your home directory where it won’t be touched, for example, ~/apps/. You’re now going to make a small shell script to run Foxit under Wine. Copy the following text into a file on your PATH, and make the file executable. I put it in /usr/bin/foxit.

#!/bin/sh

#got code to test whether path is absolute, here:#http://www.unix.com/shell-programming-scripting/38018-test-whether-absolute-path-variable.html

PATH_TO_FOXIT="/home/jacob/apps/Foxit Reader.exe"

case $1 in        /*) absolute=1 ;;        *) absolute=0 ;;esac

if [ "$absolute" = "1" ]; then        #we assume that root is mounted at Z: as is default on most wine distro        wine "$PATH_TO_FOXIT" "Z:/$1"else        wine "$PATH_TO_FOXIT" "$1"fi

This shell script is smart enough that it will actually take arguments that you pass to it on the command line, and pass it into the Foxit executable. This makes it possible open a PDF in Foxit from the command line, e.g.

jacob@jacob-laptop:~$ foxit Documents/Research/papers_to_read/MDAUML.pdf &

You should now be able to open PDF’s in Nautilus by right-clicking the PDF and choosing Open With -> Open With Other Application -> Use a Custom Command -> {type in “/usr/bin/foxit” and click “Open”}. PDF files should now open automatically in Foxit when you open them from Nautilus. Finally, you can configure Firefox to open PDF’s in Foxit whenever you download a new PDF. Just go to Edit -> Preferences -> Applications -> {type “pdf” into the search bar} -> {under the dropdown menu, select “Use other …”} -> {select file “/usr/bin/foxit” and click “Open”}. Note that this doesn’t fully change the default PDF reader for Firefox, as, for example, when you open a PDF from the Download dialog, it will still open in Evince, the GNOME default. I, unfortunately, haven’t found a way to change this behaviour, and I’d be very grateful for any comments anyone might have on this. Looking for career in web development? Visit Web-Developments.org for details information in web development tips, services, tools and basics

GSoC 2009 Final Report

admin — Wed, 02 Feb 2011 03:04:00 +0000

Today is the last day of GWT, and so I’ve put together a rather long post talking about several different things.

A brief recap of the project
Overview of implementation details of Phase 3
1. What has been implemented
2. What has not been implemented
Most recent dev experience
1. General Approach
2. Problems with SVG Embedding and the SWT API
3. Hacking on SWT API’s confuses GWT
4. Zero-Argument Constructors on Figures
Considerations about future work
1. GWT vs. Java2Script
2. SVG vs. Canvas
3. Where is this being hosted?

A brief recap of the project

The original project goals were to port GMF to the web, which is to say, to create a graphical, web-based diagram editor frontend that would interface with an EMF model living on the server on the backend. I had related experience in this domain, prior to this project, from my work as a researcher for the McGill University Modelling, Simulation, and Deisgn Lab. My research explored the development of modelled, web-based diagram editors, and included the the production of a prototype editor. My hope was that with Google Summer of Code would allow me to extend this work, such that it would be possible to build a web-based diagram editor that would interact with a full meta-modelling kernel (Ecore) hosted on a server. You may see my original project proposal here.

The project proposal was informed by the fact that GMF was built on top of GEF (a generic diagram editor library), and that GEF was built on top of Draw2D (a graphical drawing library).

My project was mentored by e4 committer and Architexa employee Vineet Sinha. Vineet has had experience porting the GEF stack to the web via flash. Limitations in the capabilities of Flash support made us consider a non-Flash based solution for this project. Looking back, I would say that this project has been divided up into about three phases:

Trying to get code already checked into e4 to work. In this phase, we attempted to leverage an existing body of code checked into in the e4 repositories. This code attempted to port the SWT API to GWT, and thus would have made an appropriate foundation for implementing SWT/GC, SWT’s low-level, immediate-mode graphics API, on top of the HTML5 Canvas API. Unfortunately, the result of this was that we spent 1.5 months simply trying to compile the existing code, without success. After this time we focused on starting from scratch in bringing Draw2D into web browsers.
Trying to implement Draw2d on top of SWT/GC by using Java2Script. This was done because Java2Script provided good support for SWT, and was an alternative to GWT, which we had had trouble with in Phase 1. The result was that we found bugs in the Java2Script compiler, and had to return to GWT.
Trying to implement Draw2d on top of SVG by using GWT. This was done because we wanted to use GWT, but decided it would be more productive to start a level higher in the SWT/Draw2d/GEF stack.

As you can see, we ended up trying many different strategies throughout this project, and therefore, the work that I am doing now is the third time I’ve started over from scratch. This may be understandable, given the experimental nature of the project and the methods by which were attempting to achieve the project’s goals (using a Java-to-JavaScript cross-compiler, etc).

Overview of implementation details of Phase 3

We use an adapter pattern: each org.eclipse.draw2d.Figure class composes an handle object native to the environment, which is in this case an org.w3c.dom.svg.SVGElement instance. Then internally, the Figure’s API is implemented in terms of this native DOM object. Here’s a snippet that should clarify what this means:

public class Figure implements IFigure { //in this implementation, Figure is no longer lightweight protected T handle; public Figure(){ //create the handle handle = (T) DOM.getDocument().createElementNS(SVGConstants.SVG_NAMESPACE_URI, SVGConstants.SVG_G_TAG); }

…

} There are three interesting things to note in the above snippet:

Figure composes a handle of type . SVGElement is a subclass of org.w3c.Node and the parent class of all SVG elements.
The type of handle can be further specified using Java 5 syntax. This is useful, because a Draw2d Rect shape may want the compose a SVGRectElement rather than a generic SVGElement. Adding a generic parameter to Figure is thus useful, and has the additional advantage of extending the API without breaking compatibility with existing code.
Figure is not abstract, and may be instantiated to contain other Draw2d elements. It is therefore roughly analogous to the SVGGElement, and this is what is instantiated in the constructor using the statically exposed method DOM.getDocument() and standard SVG DOM API’s.

Implementing Draw2d in terms of SVG is theoretically achievable because the Draw2d API is attempting to achieve roughly the same thing as the SVG DOM API, namely, providing a retained-mode graphics API. Nevertheless, there are architectural and conceptual differences between the two. Here are few that I’ve noticed:

SVG lacks a concept of connectors and layout, which Draw2d has.
Draw2d provides access to an immediate-mode API to its Figures through the Graphics object. SVG does not provide access to such an API
In many Draw2d examples, it is common to see a class inheriting from Figure. While it might be sometimes possible to do the same thing in SVG, it is more common to see composition used, rather than inheritance.
SVG hides paint events from its user. In Draw2d, you can force a manual refresh of the scene graph.
Draw2d allows fine control over updates in the scene graph, while SVG will in general always update its scene graph synchronously, whenever you change a value in DOM.

It’s also worth noting that, by implementing Draw2d in terms of SVG, the org.eclipse.draw2d.LightweightSystem class is no longer really a Lightweight System, as it’s composing a System-native handle, which, among other things, can handle its own event dispatching. This means that, rather than having events be dispatched through a single source, the LightweightSystem, inner DOM node handles should instead be connected to the proper interfaces on their host Figure when the Figures are instantiated. Figures will also have to handle tearing down the DOM node when they are destroyed.

What has been implemented

Everything required to get org.eclipse.draw2d.HelloWorld to work. Here’s a snippet that should illustrate this: public static void main(String[] args) {

Display d = new Display();
Shell shell = new Shell(d);
shell.setLayout(new FillLayout());

FigureCanvas canvas = new FigureCanvas(shell);
canvas.setContents(new Label(“Hello World”));

shell.setText(“draw2d”);
shell.open();
while (!shell.isDisposed())
while (!d.readAndDispatch())
d.sleep();
}

GWT-compatible classes have been created for Display, Shell, FigureCanvas, and Label.
Instantiation of SWT objects, passing parents into the constructor should work in general, as occurs with Shell and FigureCanvas classes. The rest of the SWT API has been stubbed out.
The Figure class and some subclasses, including Label and Rectangle have been created. The API has been completely stubbed out and partially implemented.
The class will create JavaScript code which, when included in an XHTML document, will create a new HTMLDivElement, SVGSVGElement, and SVGTextElement, which will display “Hello World” on the page.

What has not been implemented

Everything else, notably:

Most subclasses of Figure lack implementations.
Most methods of Figure superclass lack implementations.
Connectors
Layout
Colors
Fonts
Event Handling
There are still holes in the gwt-svg library, the library that exposes native SVG and HTML DOM to GWT:
- not every SVGElement has an implementation.
- even those that do, not every element is properly wrapped in SVGElementImpl.wrapElement. So if you’re getting ClassCastExceptions, check to make sure that your element is properly handled in SVGElementImpl.wrapElement
- The whole business of wrapping Elements should probably be cleaned up a bit. It’s currently quite spread out and a bit confusing. Was already a bit crufty when I started using gwt-dom.

Most recent dev experience

General Approach

So the goal of Phase 3 was to implement the Draw2d API in terms of the SVG DOM API by way of GWT. I worked very conservatively, only merging in code that I felt I understood quite well, and would not break the compiler. In that way, I was able to avoid most of the mysterious compiler errors that had occurred for me in Phase 1 of the project.

Problems with SVG Embedding and the SWT API

I did run into a few interesting problems that are worth talking about. Let me set up the problem like this:

Since GWT 1.4, GWT out of the box does not support XHTML or SVG (XML) documents. It only support HTML4 in quirks mode and standards mode.
SVG can be viewed by a web browser in the following ways:
1. As a plain SVG document (image/svg+xml mimetype, usually with a .svg extension).
2. Included in an (X)HTML document in the following ways:
  1. Inline in an XHTML document, in which the SVGSVGElement root element is loaded synchronously with the rest of the page.
  2. Embedded via the object, embed or iframe tags in an XHTML or XML document in which the SVGSVGElement in the embedded SVGDocument is loaded asynchronously, independent of the rest of the page. Basically, to get the SVGSVGRootElement, you need to set a LoadListener, otherwise, the internal contentDocument will simply be null. In general, listening to load events like this is quite common in web programming, and usually not problematic, but you will see that this did cause a problem of competing requirements…
The SWT API requires widgets to be instantiated synchronously. The reason for this is simply that the method calls are synchronous, so for example, new FigureCanvas(shell), does not take a callback.

This system cannot be solved. 1 blocks 2.1 and 2.2.1. On the other hand, 3 blocks 2.2.2. I actually had been using option 2.2.2, with an object tag and the SVG document encoded in a data URI, and I had a first implementation of basic SWT support that used this, and tried to do some tricky things involving managing widgets’ internal state and setting callbacks in order to fake some kind of synchronicity, but it clearly was not going to scale, and I felt that that was not the place spend my effort. So, basically, I had to change one of the assumptions, and the one I decided to change was GWT. This meant going into the GWT core and figuring out what it was doing to break XHTML support. I found most of these answers here and here, and it basically has to do with the fact that they’re using document.write and document.body in the module loading code, neither of which are supported in XHTML DOM. Rather than go into the GWT core to change this, I just fixed it once by hand, and then wrote a little patch which I ran each time I compiled. Here’s the patch, which you can see is not very much:

45c45,47<     $doc_0.write('