def onDragStart(self, event):
     dt = event.dataTransfer
     target = DOM.eventGetTarget(event)
     target = Widget(Element=target)
     id = target.getID()
     dt.setData("Text", "Dropped %s" % target.getID())
     dt.effectAllowed = 'copy'
     if id == 'imgdrag1':
         parent = self.getParent()
         while not hasattr(parent, 'h2'):
             parent = parent.getParent()
         dt.setDragImage(parent.h2.getElement(), 10, 10)
     elif id == 'imgdrag2':
         dt.setDragImage(doc().getElementById('logo'), 10, 10)
     elif id == 'imgdrag3':
         # OK, it's a bit of a cheat, but the following works on current
         # Opera, IE, Firefox, Safari, Chrome.
         ctx = GWTCanvas(50, 50)
         self.makeCanvasImg(ctx)
         try:
             img = DOM.createImg()
             DOM.setAttribute(img, 'src', ctx.canvas.toDataURL())
             dt.setDragImage(img, 25, 25)
         except:
             dt.setDragImage(ctx.canvas, 25, 25)

    def __init__(self, width=0, height=0):
        Widget.__init__(self)
        self.context = None
        
        self.setElement(DOM.createDiv())
        canvas = DOM.createElement("canvas")
        self.setWidth(width)
        self.setHeight(height)
        
        canvas.width=width
        canvas.height=height
        
        DOM.appendChild(self.getElement(), canvas)
        self.setStyleName("gwt-Canvas")
        
        self.init()
        
        self.context.fillStyle = "black"
        self.context.strokeStyle = "black"

        self.focusable = None
        self.focusable = Focus.createFocusable()
        
        self.focusListeners = []
        self.clickListeners = []
        self.mouseListeners = []
        self.keyboardListeners = []
        
        DOM.appendChild(self.getElement(), self.focusable)
        DOM.sinkEvents(canvas, Event.ONCLICK | Event.MOUSEEVENTS | DOM.getEventsSunk(canvas))
        DOM.sinkEvents(self.focusable, Event.FOCUSEVENTS | Event.KEYEVENTS)

 def __init__(self, **kw):
     if (not hasattr(self, 'attached')) or kw:
         Widget.__init__(self, **kw)
     MouseHandler.__init__(self)
     self.addMouseListener(DNDHelper.dndHelper)
     DragHandler.__init__(self)
     self.addDragListener(self)

 def __init__(self, element, **kwargs):
     self.setElement(element)
     Widget.__init__(self, **kwargs)
     FocusHandler.__init__(self)
     KeyboardHandler.__init__(self)
     ClickHandler.__init__(self)
     MouseHandler.__init__(self)

    def __init__(self, **ka):
        ka['StyleName'] = ka.get('StyleName', "gwt-Tree")

        self.root = None
        self.childWidgets = Set()
        self.curSelection = None
        self.focusable = None
        self.focusListeners = []
        self.mouseListeners = []
        self.imageBase = pygwt.getModuleBaseURL()
        self.keyboardListeners = []
        self.listeners = []
        self.lastEventType = ""

        element = ka.pop('Element', None) or DOM.createDiv()
        self.setElement(element)
        DOM.setStyleAttribute(self.getElement(), "position", "relative")
        self.focusable = Focus.createFocusable()
        # Hide focus outline in Mozilla/Webkit/Opera
        DOM.setStyleAttribute(self.focusable, "outline", "0px")
        # Hide focus outline in IE 6/7
        DOM.setElemAttribute(self.focusable, "hideFocus", "true");

        DOM.setStyleAttribute(self.focusable, "fontSize", "0")
        DOM.setStyleAttribute(self.focusable, "position", "absolute")
        DOM.setIntStyleAttribute(self.focusable, "zIndex", -1)
        DOM.appendChild(self.getElement(), self.focusable)

        self.root = RootTreeItem()
        self.root.setTree(self)

        Widget.__init__(self, **ka)

        self.sinkEvents(Event.ONMOUSEDOWN | Event.ONCLICK | Event.KEYEVENTS)
        DOM.sinkEvents(self.focusable, Event.FOCUSEVENTS)

 def __init__(self, element=None):
     Widget.__init__(self, Element=DOM.createElement('div'))
     self.children = []
     if element is not None:
         clone = cloneElement(element)
         self.addChild(clone)
     self.setStyleAttribute('position', 'absolute')

    def __init__(self, vertical=False, **kwargs):
        self.setVertical(kwargs.pop('Vertical', vertical))
        if 'StyleName' not in kwargs or kwargs['StyleName'] == 'gwt-MenuBar':
            kwargs['StyleName'] = self.getDefaultStyleName()
        self.body = None
        self.items = []
        self.parentMenu = None
        self.popup = None
        self.selectedItem = None
        self.shownChildMenu = None
        self.autoOpen = False

        if kwargs.has_key('Element'):
            table = kwargs.pop('Element')
            fc = DOM.getFirstChild(table)
            if fc:
                self.body = fc
            else:
                self.body = DOM.createTBody()
                DOM.appendChild(table, self.body)
        else:
            table = DOM.createTable()
        self.body = DOM.createTBody()
        DOM.appendChild(table, self.body)

        outer = DOM.createDiv()
        DOM.appendChild(outer, table)
        self.setElement(outer)
        Widget.__init__(self, **kwargs)

 def onBrowserEvent(self, event):
     Widget.onBrowserEvent(self, event)
     event_type = DOM.eventGetType(event)
     if event_type == "click":
         DOM.eventPreventDefault(event)
         if self.targetHistoryToken is not None:
             History.newItem(self.targetHistoryToken)

 def onBrowserEvent(self, event):
     Widget.onBrowserEvent(self, event)
     type = DOM.eventGetType(event)
     if type == "load":
         for listener in self.loadListeners:
             listener.onImageLoad(self)
     elif type == "error":
         for listener in self.loadListeners:
             listener.onImageError(self)

    def __init__(self, width=0, height=0):
        """ Standard initialiser.

            'width' and 'height' are the dimensions to use for this whitespace,
            in pixels.
        """
        Widget.__init__(self)
        self.setElement(DOM.createElement('div'))
        self.setPixelSize(width, height)

 def onDragOver(self, event):
     target = DOM.eventGetTarget(event)
     t = Widget(Element=target)
     dt = event.dataTransfer
     dt.dropEffect = 'copy'
     class_names = t.getStyleName()
     if class_names is not None:
         if 'drophere' in class_names:
             DOM.eventPreventDefault(event)

 def __init__(self, widget=None, **kwargs):
     # this is all a bit awkward!  initialising
     # stuff that really should be done in Widget.__init__
     # allows us to call self.initWidget here and thus
     # have **kwargs applied afterwards.
     self.widget = None
     self.attached = None
     if widget is not None:
         self.initWidget(widget)
     Widget.__init__(self, **kwargs)

    def __init__(self, url="", **kwargs):
        if not kwargs.has_key('StyleName'): kwargs['StyleName']="gwt-Image"
        if url: kwargs['Url'] = url

        self.setElement(kwargs.pop('Element', None) or DOM.createImg())
        Widget.__init__(self, **kwargs)
        MouseHandler.__init__(self)
        ClickHandler.__init__(self)
        self.sinkEvents(Event.ONLOAD | Event.ONERROR)
        self.loadListeners = []

 def onDragLeave(self, event):
     target = DOM.eventGetTarget(event)
     t = Widget(Element=target)
     try:
         class_names = t.getStyleName()
     except:
         class_names = None
     if class_names is not None:
         if 'drophere' in class_names:
             t.removeStyleName('dragover')

 def onDragEnter(self, event):
     target = DOM.eventGetTarget(event)
     t = Widget(Element=target)
     try:
         class_names = t.getStyleName()
     except:
         class_names = None
     if class_names is not None:
         if 'drophere' in class_names:
             t.addStyleName('dragover')
             DOM.eventPreventDefault(event)

 def onDrop(self, event):
     dt = event.dataTransfer
     text = dt.getData('Text')
     target = DOM.eventGetTarget(event)
     t = Widget(Element=target)
     class_names = t.getStyleName()
     if class_names is not None:
         if 'drophere' in class_names:
             self.addMessage('%s onto %s<br>effectAllowed=%s, dropEffect=%s'
             % (text, target.id, dt.effectAllowed, dt.dropEffect))
             DOM.eventPreventDefault(event)

    def onBrowserEvent(self, event):
        etype = DOM.eventGetType(event)

        if etype == "click":
            e = DOM.eventGetTarget(event)
            if not self.shouldTreeDelegateFocusToElement(e) and \
                            self.curSelection is not None:
                self.setFocus(True)
        elif etype in MouseListener.MOUSE_EVENTS:
            if etype == "mousedown":
                self.elementClicked(self.root, DOM.eventGetTarget(event))
            MouseListener.fireMouseEvent(self.mouseListeners, self, event)
        elif etype == "blur" or etype == "focus":
            FocusListener.fireFocusEvent(self.focusListeners, self, event)
        elif etype == "keydown":
            if self.curSelection is None:
                if self.root.getChildCount() > 0:
                    self.onSelection(self.root.getChild(0), True)
                Widget.onBrowserEvent(self, event)
                return

            if self.lastEventType == "keydown":
                return

            keycode = DOM.eventGetKeyCode(event)
            if keycode == KeyboardListener.KEY_UP:
                self.moveSelectionUp(self.curSelection, True)
                DOM.eventPreventDefault(event)
            elif keycode == KeyboardListener.KEY_DOWN:
                self.moveSelectionDown(self.curSelection, True)
                DOM.eventPreventDefault(event)
            elif keycode == KeyboardListener.KEY_LEFT:
                if self.curSelection.getState():
                    self.curSelection.setState(False)
                DOM.eventPreventDefault(event)
            elif keycode == KeyboardListener.KEY_RIGHT:
                if not self.curSelection.getState():
                    self.curSelection.setState(True)
                DOM.eventPreventDefault(event)
        elif etype == "keyup":
            if DOM.eventGetKeyCode(event) == KeyboardListener.KEY_TAB:
                chain = []
                self.collectElementChain(chain, self.getElement(),
                                         DOM.eventGetTarget(event))
                item = self.findItemByChain(chain, 0, self.root)
                if item != self.getSelectedItem():
                    self.setSelectedItem(item, True)
        elif etype == "keypress":
            KeyboardListener.fireKeyboardEvent(self.keyboardListeners,
                                               self, event)

        Widget.onBrowserEvent(self, event)
        self.lastEventType = etype

    def __init__(self, text=None, wordWrap=True, **kwargs):
        kwargs['StyleName'] = kwargs.get('StyleName', "gwt-Label")
        kwargs['WordWrap'] = kwargs.get('WordWrap', wordWrap)
        kwargs['HorizontalAlignment'] = kwargs.get('HorizontalAlignment', "")
        if text:
            kwargs['Text'] = text
        self.setElement(kwargs.pop('Element', None) or DOM.createDiv())
        self.horzAlign = ""

        Widget.__init__(self, **kwargs)
        MouseHandler.__init__(self)
        ClickHandler.__init__(self)

 def __init__(self, Shape, Coords, **kwargs):
     if not kwargs.has_key('Href'):
         kwargs['Href'] = ""
     kwargs['Shape'] = Shape
     kwargs['Coords'] = Coords
     if kwargs.has_key('Element'):
         element = kwargs.pop('Element')
     else:
         element = DOM.createElement("area")
     self.setElement(element)
     Widget.__init__(self, **kwargs)
     MouseHandler.__init__(self, preventDefault=True)
     ClickHandler.__init__(self, preventDefault=True)

    def __init__(self, name=None, value=None, **kwargs):

        name = kwargs.get("Name", name)
        if name is not None:
            kwargs['Name'] = name
        value = kwargs.get("Value", value)
        if value is not None:
            kwargs['Value'] = kwargs.get("Value", value)
        element = kwargs.pop('Element', None) or DOM.createElement("input")
        self.setElement(element)
        DOM.setAttribute(element, "type", "hidden")

        Widget.__init__(self, **kwargs)