GWT Schaltfläche "Schließen" in der Titelleiste der DialogBox

Question

Gibt es eine nicht JSNI-Methode zum Hinzufügen einer Schließschaltfläche zum Titelleistenbereich einer DialogBox?

Answer 1

Eine einfachere Lösung ist GWT-ext (http://code.google.com/p/gwt-ext/) zu verwenden. Es ist kostenlos und einfach zu bedienen und zu integrieren. Sie können ihre Vitrine http://www.gwt-ext.com/demo/ sehen. Ich denke, dass was Sie wollen, ist die MessageBox oder Layout-Fenster (sie sind in der Windows-Kategorie der Vitrine).

Grüße.

Answer 2

Ja, es gibt

Nein, es ist nicht - zumindest nicht mit GWT DialogBox Klasse ohne das Hantieren selbst oder durch die DialogBox mit gemeinsamen Widgets neu zu erstellen. Dies ist ein bekanntes Problem in GWT, aka issue 1405 (Stern es um Ihr Interesse zu zeigen).

Jedoch; DialogBox gibt uns nicht die Werkzeuge, dies zu tun, so dass wir es erweitern müssen - Edit:dies funktioniert nicht.

Wenn Sie einen Drop-In-Ersatz für DialogBox erstellen möchten, können Sie Ihre Klasse DialogBox benennen und sie anstelle des in GWT enthaltenen importieren. This thread auf dem GWT-Forum gibt bessere Details, wie dies getan werden kann (veraltet, verwendet Listener) Veraltet, die Interna von DialogBox wurden seit diesem Thread sehr geändert - es funktioniert nicht.

Hier ist ein Code, den ich gehackt habe, um die gleichen Ergebnisse zu erhalten (verwendet den verknüpften Thread als Richtlinie). Dies funktioniert nicht:

MyDialogBox:

import com.google.gwt.event.dom.client.ClickEvent; 
import com.google.gwt.event.dom.client.ClickHandler; 
import com.google.gwt.event.dom.client.MouseOutEvent; 
import com.google.gwt.event.dom.client.MouseOutHandler; 
import com.google.gwt.event.dom.client.MouseOverEvent; 
import com.google.gwt.event.dom.client.MouseOverHandler; 
import com.google.gwt.user.client.DOM; 
import com.google.gwt.user.client.Element; 
import com.google.gwt.user.client.Window; 
import com.google.gwt.user.client.ui.DialogBox; 
import com.google.gwt.user.client.ui.HTML; 
import com.google.gwt.user.client.ui.HorizontalPanel; 
import com.google.gwt.user.client.ui.Label; 
import com.google.gwt.user.client.ui.Widget; 

public class MyDialogBox extends DialogBox { 

    private class crossHandler implements ClickHandler, MouseOverHandler, MouseOutHandler 
    { 

     @Override 
     public void onClick(ClickEvent event) { 
      hide(); 
      Window.alert("Click!"); 
     } 

     @Override 
     public void onMouseOver(MouseOverEvent event) { 
      DOM.setStyleAttribute(cross.getElement(), "font-weight", "bold"); 

     } 

     @Override 
     public void onMouseOut(MouseOutEvent event) { 
      DOM.setStyleAttribute(cross.getElement(), "font-weight", "normal"); 

     } 


    } 

    Label cross = new Label("X"); // The close button 
    crossHandler crosshandler = new crossHandler(); 
    HTML caption = new HTML(); // The caption aka title 
    HorizontalPanel captionPanel = new HorizontalPanel(); // Contains caption and cross 


     /** 
     * Creates an empty dialog box. It should not be shown until its child widget 
     * has been added using {@link #add(Widget)}. 
     */ 
    public MyDialogBox() 
    { 
     this(false); 
    } 

    /** 
    * Creates an empty dialog box specifying its "auto-hide" property. It should 
    * not be shown until its child widget has been added using 
    * {@link #add(Widget)}. 
    * 
    * @param autoHide <code>true</code> if the dialog should be automatically 
    *   hidden when the user clicks outside of it 
    */ 
    public MyDialogBox(boolean autoHide) { 
      this(autoHide, true); 
      } 

    /** 
    * Creates an empty dialog box specifying its "auto-hide" property. It should 
    * not be shown until its child widget has been added using 
    * {@link #add(Widget)}. 
    * 
    * @param autoHide <code>true</code> if the dialog should be automatically 
    *   hidden when the user clicks outside of it 
    * @param modal <code>true</code> if keyboard and mouse events for widgets not 
    *   contained by the dialog should be ignored 
    */ 
    public MyDialogBox(boolean autoHide, boolean modal) 
    { 
     super(autoHide, modal); 

     cross.addClickHandler(crosshandler); 
     cross.addMouseOutHandler(crosshandler); 
     cross.addMouseOverHandler(crosshandler); 

     captionPanel.add(caption); 
     captionPanel.add(cross); 
     captionPanel.setStyleName("caption"); 

     Element td = getCellElement(0, 1); // Get the cell element that holds the caption 
     td.setInnerHTML(""); // Remove the old caption 
     td.appendChild(captionPanel.getElement()); 



    } 

    @Override 
    public void setText(String text) 
    { 
     caption.setText(text); 
    } 

    public String getText() 
    { 
     return caption.getText(); 
    } 

    public void setHtml(String html) 
    { 
     caption.setHTML(html); 
    } 

    public String getHtml() 
    { 
     return caption.getHTML(); 
    } 

Hinweis: Dieser Code funktioniert nicht. Das ClickEvent wird nicht von cross, sondern von MyDialogBox gesendet, unabhängig davon, ob Sie ClickHandlers zum cross hinzufügen oder nicht, IOW die MyDialogBox ist der Absender/Quelle und daher nicht möglich, gegen cross zu überprüfen. Wenn das Kreuz angeklickt wird, wird das ClickEvent aus bestimmten Gründen nicht ausgelöst.

Edit: Es scheint dies nicht ohne Hacks, wenn Sie getan werden kann, entweder eigene DialogBox (fast) von Grund auf neu schreiben oder beheben Ausgabe 1405. Natürlich gibt es Anzahl der vorhandenen Bibliotheken, die dieses Problem bereits gelöst haben, dh SmartGWT und GWT-Ext, aber ihre Implementierung wird meist von Grund auf neu gemacht.

So Ihre Frage in einem Satz zu beantworten: Ja, es ist ein Weg, aber du wirst nicht wie es :)

Answer 3

Sie können die schließbare Dialogbox in Google Code unter dem Projekt synthfuljava finden. Es wird tatsächlich Scroll-Dialogfeld mit einem Schließen X-Taste bei der Beschriftung aufgerufen.

Die folgenden Blog erklärt die Hindernisse, die überwunden werden mussten, um das Click-Ereignis zu hören, um für thecaption X-Taste, um der Lage zu sein, sie arbeiten zu lassen:

http://h2g2java.blessedgeek.com/2009/07/gwt-useable-closeable-scrollable.html

Answer 4

Wir haben GWT-ext aus der Anfang in unserem Projekt. Es war eine schlechte Idee. Sie haben viele coole Widgets, aber sie sind keine GWT Widgets UND sie sind nicht kompatibel mit GWT Widgets. Sobald Sie sich für GWT-Ext entschieden haben, muss alles, auch der Event-Mechanismus, auf GWT-Ext-Art und nicht auf GWT-Art erfolgen. Diese Bibliothek wird nicht für die neueste Version von GWT aktualisiert, da die Javascript-Bibliothek Ext nicht mehr kostenlos ist. Wir entfernen GWT-Ext jetzt von unserem Projekt.

Es ist nicht möglich, ein anderes Widget in der GWT DialogBox-Beschriftung hinzuzufügen, aber Sie können "DecoratedPanel" erweitern (es ist das übergeordnete DialogfeldBox). Sehen Sie sich die DialogBox-Quelle an, um die Techniken zu lernen, insbesondere, wie das Caption-Objekt zum Panel hinzugefügt wird und wie der Fensterwiderstand implementiert wird.

Das haben wir hier gemacht, und es funktioniert sehr gut. Wir haben unsere eigene Caption-Klasse erstellt, die FocusablePanel erweitert (ein SimplePanel, das alle Mausereignisse erfasst) und wir haben ein HorizontalPanel mit Schaltflächen und Text hinzugefügt. Wir mussten OnAttach() und OnDetach() nur durch den Aufruf der Super-Methode (sie sind geschützt) überschreiben.

Ich glaube, ich darf unseren Quellcode hier nicht eingeben, also kann ich Ihnen nur diese Tipps geben.

Answer 5

Sie können es tun, indem Sie einen Knopf an der Mitteltafel des DialogBox Zugabe:

Image closeButton = new Image(""); 
closeButton.addClickHandler(new ClickHandler() { 
    public void onClick(ClickEvent event) { 
     registerBox.hide();    
    } 
}); 

closeButton.setStyleName("TopRight"); 

Dann ist es mit CSS positionieren:

.TopRight { 
    float:right; 
    margin-top:-22px; 
    width:16px; 
    height:16px; 
    display:block; 
    background-image: url(images/cancel_16.png); 
} 

Answer 6

Schauen Sie sich das aktive Projekt: http://code.google.com/p/gwt-mosaic/

Ihr edles Ziel ist, wie auf ihrer Seite erwähnt:

Ziel ist es, einen vollständigen Widget-Satz bereitzustellen, indem die API so nah wie möglich an der Standard-Widgets-API des GWT gehalten wird.

Wurden im GXT-Wirbel gefangen. Ganz und gar kein Fan davon, wie sie von den Nutzern verlangen, dass sie für Hörer, etc. völlig unterschiedliche APIs verwenden. Dies ist wiederum sinnvoll. Schließlich ist GXT nur ein Port ihrer vorhandenen Javascript-Bibliotheken. Aber ich habe zu lange nach diesem MOSAIC-Projekt gesucht ...

Answer 7

Mit nur GWT und keine externen Bibliotheken können Sie die Klickereignisse auf dem Titelelement abfangen und einen Treffer-Test durchführen, um zu sehen, ob die x, y Maus coord befindet sich innerhalb der Grenzen des Ankerelements (oder eines anderen Elements, das Sie als ClickHandler verwenden).

// Create anchor we want to accept click events 
final Anchor myAnchor = new Anchor("My Anchor"); 

// Add handler to anchor 
myAnchor.addClickHandler(new ClickHandler() { 
    @Override 
    public void onClick(ClickEvent event) { 
    Window.alert("Anchor was clicked"); 
    } 
}); 

// Create dialog 
final DialogBox myDialog = new DialogBox(); 
myDialog.setText("My Dialog"); 

// Get caption element 
final HTML caption = ((HTML)myDialog.getCaption()); 

// Add anchor to caption 
caption.getElement().appendChild(myAnchor.getElement()); 

// Add click handler to caption 
caption.addClickHandler(new ClickHandler() { 
    @Override 
    public void onClick(ClickEvent event) { 
    // Get x,y caption click relative to the anchor 
    final int x = event.getRelativeX(myAnchor.getElement()); 
    final int y = event.getRelativeY(myAnchor.getElement()); 

    // Check click was within bounds of anchor 
    if(x >= 0 && y >= 0 && 
     x <= myAnchor.getOffsetWidth() && 
     y <= myAnchor.getOffsetHeight()) { 
     // Raise event on anchor 
     myAnchor.fireEvent(event); 
    } 
    } 
}); 

// Show the dialog 
myDialog.show(); 

Answer 8

Ich weiß, das lächerlich alt ist, aber man kann nur die absolute Positionierung mit oben und rechts von 0 verwenden, um ein Widget in der oberen rechten Ecke zu bekommen. Das Dialogfeld selbst ist absolut positioniert, sodass die Positionierung Ihres Widgets dagegen ist.

Answer 9

können Sie versuchen, diese aus, leicht verbesserte Lösung von fungus1487:

import com.google.gwt.dom.client.EventTarget; 
import com.google.gwt.event.dom.client.ClickEvent; 
import com.google.gwt.event.dom.client.ClickHandler; 
import com.google.gwt.i18n.client.HasDirection; 
import com.google.gwt.user.client.Element; 
import com.google.gwt.user.client.ui.*; 

/** 
* @author Andrey Talnikov 
*/ 
public class ClosablePopup extends DialogBox { 

    private Anchor closeAnchor; 

    /** 
    * Instantiates new closable popup. 
    * 
    * @param title  the title 
    * @param defaultClose it {@code true}, hide popup on 'x' click 
    */ 
    public ClosablePopup(String title, boolean defaultClose) { 
     super(true); 

     closeAnchor = new Anchor("x"); 

     FlexTable captionLayoutTable = new FlexTable(); 
     captionLayoutTable.setWidth("100%"); 
     captionLayoutTable.setText(0, 0, title); 
     captionLayoutTable.setWidget(0, 1, closeAnchor); 
     captionLayoutTable.getCellFormatter().setHorizontalAlignment(0, 1, 
       HasHorizontalAlignment.HorizontalAlignmentConstant.endOf(HasDirection.Direction.LTR)); 

     HTML caption = (HTML) getCaption(); 
     caption.getElement().appendChild(captionLayoutTable.getElement()); 

     caption.addClickHandler(new ClickHandler() { 
      @Override 
      public void onClick(ClickEvent event) { 
       EventTarget target = event.getNativeEvent().getEventTarget(); 
       Element targetElement = (Element) target.cast(); 

       if (targetElement == closeAnchor.getElement()) { 
        closeAnchor.fireEvent(event); 
       } 
      } 
     }); 

     if (defaultClose) { 
      addCloseHandler(new ClickHandler() { 
       @Override 
       public void onClick(ClickEvent event) { 
        hide(); 
       } 
      }); 
     } 
    } 

    public void addCloseHandler(ClickHandler handler) { 
     closeAnchor.addClickHandler(handler); 
    } 
} 

Answer 10

ich diese Beschriftung Klasse erstellt:

public class DialogBoxCaptionWithCancel extends Composite 
    implements Caption, HasClickHandlers { 

@UiField 
HTMLPanel mainPanel; 
@UiField 
HTML captionLabel; 
@UiField 
PushButton cancelButton; 

private HandlerManager handlerManager = null; 

private static final Binder binder = GWT.create(Binder.class); 

interface Binder extends UiBinder<Widget, DialogBoxCaptionWithCancel> { 
} 

public DialogBoxCaptionWithCancel() { 
    initWidget(binder.createAndBindUi(this)); 

    mainPanel.setStyleName("Caption"); 
    Image upImage = new Image("images/closeWindow.png"); 
    Image hoverImage = new Image("images/closeWindowFocus.png"); 
    cancelButton.getUpFace().setImage(upImage); 
    cancelButton.getUpHoveringFace().setImage(hoverImage); 
    cancelButton.setStylePrimaryName("none"); 
} 

/* 
* (non-Javadoc) 
* 
* @see com.google.gwt.user.client.ui.Widget#onLoad() 
*/ 
@Override 
protected void onLoad() { 
    super.onLoad(); 

    handlerManager = new HandlerManager(this); 
} 

@UiHandler("cancelButton") 
public void cancelButtonOnClick(ClickEvent event) { 
    handlerManager.fireEvent(event); 
} 

@Override 
public HandlerRegistration addMouseDownHandler(MouseDownHandler handler) { 
    return handlerManager.addHandler(MouseDownEvent.getType(), handler); 
} 

@Override 
public HandlerRegistration addMouseUpHandler(MouseUpHandler handler) { 
    return handlerManager.addHandler(MouseUpEvent.getType(), handler); 
} 

@Override 
public HandlerRegistration addMouseOutHandler(MouseOutHandler handler) { 
    return handlerManager.addHandler(MouseOutEvent.getType(), handler); 
} 

@Override 
public HandlerRegistration addMouseOverHandler(MouseOverHandler handler) { 
    return handlerManager.addHandler(MouseOverEvent.getType(), handler); 
} 

@Override 
public HandlerRegistration addMouseMoveHandler(MouseMoveHandler handler) { 
    return handlerManager.addHandler(MouseMoveEvent.getType(), handler); 
} 

@Override 
public HandlerRegistration addMouseWheelHandler(MouseWheelHandler handler) { 
    return handlerManager.addHandler(MouseWheelEvent.getType(), handler); 
} 

@Override 
public String getHTML() { 
    return ""; 
} 

@Override 
public void setHTML(String html) { 
} 

@Override 
public String getText() { 
    return this.captionLabel.getText(); 
} 

@Override 
public void setText(String text) { 
    this.captionLabel.setText(text); 
} 

@Override 
public void setHTML(SafeHtml html) { 
} 

@Override 
public HandlerRegistration addClickHandler(ClickHandler handler) { 
    return handlerManager.addHandler(ClickEvent.getType(), handler); 
} 

} 

Die Bilder werden nur aus dem Verhalten von IE8 erfasst, wenn Sie die Maus über die Abbrechen-Taste. Hier

ist der UiBinder Code:

<!DOCTYPE ui:UiBinder SYSTEM "http://dl.google.com/gwt/DTD/xhtml.ent"> 
<ui:UiBinder 
xmlns:ui='urn:ui:com.google.gwt.uibinder' 
xmlns:g='urn:import:com.google.gwt.user.client.ui'> 

<ui:style> 
    .htmlField { 
     width: 100%; 
    } 

    .pushButton { 
     border: none; 
     padding: 0px; 
     width: 49px; 
     height: 21px; 
    } 
</ui:style> 

<g:HTMLPanel ui:field="mainPanel"> 
    <table border="0" cellpadding="0" cellspacing="0" width="100%"> 
     <tr> 
      <td width="100%"> 
       <g:HTML ui:field="captionLabel" addStyleNames="{style.htmlField}"></g:HTML> 
      </td> 
      <td> 
       <g:PushButton ui:field="cancelButton" addStyleNames="{style.pushButton}"></g:PushButton> 
      </td> 
     </tr> 
    </table> 
</g:HTMLPanel> 
</ui:UiBinder> 

Dann ist meine Klasse, die DialogBox erstreckt hat die folgenden:

public class MyDialogBox extends DialogBox implements ClickHandler { 
... 
// instantiate the caption with the cancel button 
private static DialogBoxCaptionWithCancel caption = new DialogBoxCaptionWithCancel(); 
... 
public MyDialogBox() { 
    // construct the dialog box with the custom caption 
    super(false, false, caption); 

    setWidget(binder.createAndBindUi(this)); 

    // set the caption's text 
    caption.setText("My Caption"); 
} 
.... 
protected void onLoad() { 
    super.onLoad(); 

    // let us react to the captions cancel button 
    caption.addClickHandler(this); 
} 
... 
@Override 
public void onClick(ClickEvent event) { 
    // the caption's cancel button was clicked 
    this.hide(); 
} 

Answer 11

Dies funktioniert, wenn Sie nur eine einfache Lösung für die Frage wan't gestellt:

Image button = new Image("images/cancel.png"); 

    button.addClickHandler(new ClickHandler(){ 
     public void onClick(ClickEvent event) { 
      hide(); 
     } 
    }); 
    button.setStyleName("dialog-close"); 

    HorizontalPanel header = new HorizontalPanel(); 
    header.add(new HTML("Example Tool")); 
    header.add(button); 

    setHTML(header.getElement().getInnerHTML()); 

Answer 12

Ich denke, eine einfache Antwort darauf ist, ein Widget zu instanziieren, um den Standard Captio zu ersetzen n Widget von DialogBox. Ich habe eine Beschriftung erstellt, die eine Schaltfläche rechts enthält, und Sie können einen Verweis darauf auswählen. Dann können Sie jedes Klickereignis hinzufügen, das Sie wünschen. 2.4

In GWT habe ich die folgende Lösung:

import com.google.gwt.event.dom.client.MouseDownHandler; 
import com.google.gwt.event.dom.client.MouseMoveHandler; 
import com.google.gwt.event.dom.client.MouseOutHandler; 
import com.google.gwt.event.dom.client.MouseOverHandler; 
import com.google.gwt.event.dom.client.MouseUpHandler; 
import com.google.gwt.event.dom.client.MouseWheelHandler; 
import com.google.gwt.event.shared.HandlerRegistration; 
import com.google.gwt.safehtml.shared.SafeHtml; 
import com.google.gwt.user.client.ui.HorizontalPanel; 
import com.google.gwt.user.client.ui.InlineLabel; 
import com.google.gwt.user.client.ui.PushButton; 
import com.google.gwt.user.client.ui.DialogBox.Caption; 

/** 
* @author Cristiano Sumariva 
*/ 
public class ButtonCaption extends HorizontalPanel implements Caption 
{ 
    protected InlineLabel text; 
    protected PushButton closeDialog; 

    /** 
    * @return the button at caption 
    */ 
    public PushButton getCloseButton() 
    { 
    return closeDialog; 
    } 
    public ButtonCaption(String label) 
    { 
    super(); 
    setWidth("100%"); 
    setStyleName("Caption"); // so you have same styling as standard caption widget 
    closeDialog = new PushButton(); 
    add(text = new InlineLabel(label)); 
    add(closeDialog); 
    setCellWidth(closeDialog, "1px"); // to make button cell minimal enough to it 
    } 
    /* (non-Javadoc) 
    * @see com.google.gwt.event.dom.client.HasMouseDownHandlers#addMouseDownHandler(com.google.gwt.event.dom.client.MouseDownHandler) 
    */ 
    @Override 
    public HandlerRegistration addMouseDownHandler(MouseDownHandler handler) 
    { 
    return addMouseDownHandler(handler); 
    } 

    /* (non-Javadoc) 
    * @see com.google.gwt.event.dom.client.HasMouseUpHandlers#addMouseUpHandler(com.google.gwt.event.dom.client.MouseUpHandler) 
    */ 
    @Override 
    public HandlerRegistration addMouseUpHandler(MouseUpHandler handler) 
    { 
    return addMouseUpHandler(handler); 
    } 

    /* (non-Javadoc) 
    * @see com.google.gwt.event.dom.client.HasMouseOutHandlers#addMouseOutHandler(com.google.gwt.event.dom.client.MouseOutHandler) 
    */ 
    @Override 
    public HandlerRegistration addMouseOutHandler(MouseOutHandler handler) 
    { 
    return addMouseOutHandler(handler); 
    } 

    /* (non-Javadoc) 
    * @see com.google.gwt.event.dom.client.HasMouseOverHandlers#addMouseOverHandler(com.google.gwt.event.dom.client.MouseOverHandler) 
    */ 
    @Override 
    public HandlerRegistration addMouseOverHandler(MouseOverHandler handler) 
    { 
    return addMouseOverHandler(handler); 
    } 

    /* (non-Javadoc) 
    * @see com.google.gwt.event.dom.client.HasMouseMoveHandlers#addMouseMoveHandler(com.google.gwt.event.dom.client.MouseMoveHandler) 
    */ 
    @Override 
    public HandlerRegistration addMouseMoveHandler(MouseMoveHandler handler) 
    { 
    return addMouseMoveHandler(handler); 
    } 

    /* (non-Javadoc) 
    * @see com.google.gwt.event.dom.client.HasMouseWheelHandlers#addMouseWheelHandler(com.google.gwt.event.dom.client.MouseWheelHandler) 
    */ 
    @Override 
    public HandlerRegistration addMouseWheelHandler(MouseWheelHandler handler) 
    { 
    return addMouseWheelHandler(handler); 
    } 

    /* (non-Javadoc) 
    * @see com.google.gwt.user.client.ui.HasHTML#getHTML() 
    */ 
    @Override 
    public String getHTML() 
    { 
    return getElement().getInnerHTML(); 
    } 

    /* (non-Javadoc) 
    * @see com.google.gwt.user.client.ui.HasHTML#setHTML(java.lang.String) 
    */ 
    @Override 
    public void setHTML(String html) 
    { 
    remove(text); 
    insert(text, 1); 
    } 

    /* (non-Javadoc) 
    * @see com.google.gwt.user.client.ui.HasText#getText() 
    */ 
    @Override 
    public String getText() 
    { 
    return text.getText(); 
    } 

    /* (non-Javadoc) 
    * @see com.google.gwt.user.client.ui.HasText#setText(java.lang.String) 
    */ 
    @Override 
    public void setText(String text) 
    { 
    this.text.setText(text); 
    } 

    /* (non-Javadoc) 
    * @see com.google.gwt.safehtml.client.HasSafeHtml#setHTML(com.google.gwt.safehtml.shared.SafeHtml) 
    */ 
    @Override 
    public void setHTML(SafeHtml html) 
    { 
    setHTML(html.asString()); 
    } 
} 

Erweitert die DialogBox die neue ButtonCaption verfügbar

class CaptionCloseableDialogBox extends DialogBox 
{ 
    public CaptionCloseableDialogBox() 
    { 
    super(new ButtonCaption("dialog box title")); 
    setAutoHideEnabled(false); 

    ButtonCaption ref = (ButtonCaption) this.getCaption(); 
    PushButton closeButton = ref.getCloseButton(); 
    // apply button face here closeButton; 
    closeButton.addClickHandler(/* attach any click handler here like close this dialog */); 
    } 
} 

Hoffe, es hilft jeder zu verwenden.

Answer 13

Ich denke, die ButtonCaption von Cavila ist die beste Lösung, aber es gibt einen Fehler in der Umsetzung der Beschriftung. Der Aufruf einer der überladenen Methoden verursacht eine Infinitivschleife, da sich die Methode rekursiv selbst aufruft.

Um dies zu verhindern Sie die Methode auf den stattdessen Text InlineLabel anrufen:

@Override 
public HandlerRegistration addMouseDownHandler(MouseDownHandler handler) { 
    return text.addMouseDownHandler(handler); 
} 

Answer 14

Der Dialog GWT Box oberste Ebene DIV absolute Positionierung verfügt, so dass Sie das gleiche mit Ihrer Schließen-Schaltfläche tun. Dadurch können Sie es in den Hauptteil des Dialogfelds einfügen, so weit es das DOM betrifft, aber es muss physisch in der Überschrift erscheinen.

In meinem Beispiel unten platziere ich es genau oben rechts im Dialog und zentriere es mit Padding.

<ui:style> 
    .close { 
     position: absolute; 
     top: 0; 
     right: 0; 
     padding: 3px 3px 1px 3px !important; 
     border-radius: 4px; 
     margin: 5px; 
    } 
</ui:style> 

<g:PushButton ui:field="closeButton" addStyleNames="{style.close}"> 
    <g:upFace image='{closeIcon}'/> 
    <g:downFace image='{closeIcon}'/> 
    <g:upHoveringFace image='{closeIcon}'/> 
    <g:downHoveringFace image='{closeIcon}'/> 
    <g:upDisabledFace image='{closeIcon}'/> 
    <g:downDisabledFace image='{closeIcon}'/> 
</g:PushButton>