# SWT: Label vertikal ausrichten



## Vatar (18. Mai 2005)

Moin Moin.
Ist es möglich ein Label im SWT vertikal auszurichten?
Mit 
	
	
	
	





```
Label l = new Label(composite, SWT.VERTICAL)
```
 funktioniert es leider nicht. 

thx.


----------



## thE_29 (18. Mai 2005)

Das AlignMent hat aber nur was mit der Textausrichtung!!

Wenn du das Label vertikal haben musst, musst du die paint Methode für das Objekt überschreiben und entweder kompliziert mit Matrizen Rechnung umrechnen oder einfach umschieben da es sich ja um 90° handelt (Matrizenrechnung bräuchtest du nur wenn du 89° oder so haben willst)

Oder einfach die rotate Methode benutzen (was bei mir meistens nie geklappt hat) von Graphics2D


----------



## Vatar (19. Mai 2005)

Danke, aber...

für ein SWT-Label gibt es keine paint-Methode, nur zwei redraw und diese rufen native Methoden auf die sich um das Zeichnen kümmern (das war ja auch Sinn und Zweck des SWT).
Ich versuche nun gerade den String einfach selber auf der Komponente zu zeichnen.
Habe zwar ein Plugin gefunden (www.hollongate.org) mit dem man die Java2D-API auf dem SWT ausführen kann, allerdings kann man da nur auf einem speziellen Canvas (J2DCanvas) zeichnen und ich möchte das aber gerne auf einer Composite machen.

Also wenn jemand weiß wie man einen String im SWT ausrichten kann, wär ich sehr dankbar.

thx


----------



## thE_29 (19. Mai 2005)

Was bringt einem dieses SWT überhaupt, außer das man noch ne zusätzliche Library braucht damit es läuft...


----------



## Roar (19. Mai 2005)

thE_29 hat gesagt.:
			
		

> Was bringt einem dieses SWT überhaupt, außer das man noch ne zusätzliche Library braucht damit es läuft...


vor und nachteile von swt stehen hier nich zur diskussion :?


----------



## thE_29 (19. Mai 2005)

Na, ich wollt nur wissen ob es vom optischen her oder sonstiges sich viel von Swing/AWT unterscheiden.. (bisi schneller solls ja sein oder sowas in der Art...)

Wenn dies net der Fall is, versteh ichs net :bae:


----------



## Vatar (19. Mai 2005)

:meld: Ich benutze es eigentlich nur zwei Gründen. SWING IST HÄSSLICH UND LANGSAM (ich weiß, es gibt auch ein Windows L&F).  Ich denke damals wollten die von Sun sich einfach sehr stark vom Marktführer (Billy Boy) abheben.
Ich muss aber zugeben, dass die 1.5er Version schon wesentlich besser aussieht.

Wenn ich eine kleines Proggi für einen Standardanwender mit Swing schreib dann kommt zuerst die Frage: "Warum schaut denn das alles so komisch aus?" (weil er/sie nunmal seine Windows/Linux Fensterchen gewöhnt ist).

Da SWT die Zeichenmethoden des OS aufruft sieht ein Java-Proggi mit SWT aus wie ein Standardprogramm dieses Betriebssystems.


----------



## stev.glasow (19. Mai 2005)

Melde einen Paintlistener an und zeichne den Text selber, VERTICALund HORIZONTAL sind nur für die Ausrichtung von SEPARATORen gedacht


----------



## Roar (19. Mai 2005)

Vatar hat gesagt.:
			
		

> SWING IST HÄSSLICH UND LANGSAM



jo das sind wohl das beiden am weitesten verbreiteten unbegründeten vorurteile gegen swing :?
swing ist schnell, und hässlich ist das auch nicht. das gilt nich also nich :bae:

irgendwas wollt ich noch sagen, hab jetz vergessen :?

edit um nich zwei sinnlos posts in einem trhead zu haben: genau :lol:


----------



## stev.glasow (19. Mai 2005)

> irgendwas wollt ich noch sagen, hab jetz vergessen


Dass das subjektiv ist und hier nicht zur Disskusion steht  :wink: Und als schnell würde ich Swing nicht bezeichenn, aber lassen wir das, bitte


----------



## Vatar (20. Mai 2005)

stevg hat gesagt.:
			
		

> Melde einen Paintlistener an und zeichne den Text selber, VERTICALund HORIZONTAL sind nur für die Ausrichtung von SEPARATORen gedacht



Hab ich schon gemacht, aber ich hab keine Ahnung wie ich den String vertikal zeichnen kann. Hab auch nichts gefunden wie ich das im GC einstellen kann (aber irgendwie muss es ja gehen).


----------



## Vatar (20. Mai 2005)

Hab in den tiefen des Netzes noch etwas gefunden.

Hilfsklasse GraphicsUtils

```
import org.eclipse.swt.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.Display;

/**
 * This class contains utility methods for drawing graphics
 */
public class GraphicsUtils {
  /**
   * Draws text vertically (rotates plus or minus 90 degrees). Uses the current
   * font, color, and background.
   * <dl>
   * <dt>[b]Styles: [/b]</dt>
   * <dd>UP, DOWN</dd>
   * </dl>
   * 
   * @param string the text to draw
   * @param x the x coordinate of the top left corner of the drawing rectangle
   * @param y the y coordinate of the top left corner of the drawing rectangle
   * @param gc the GC on which to draw the text
   * @param style the style (SWT.UP or SWT.DOWN)
   *          


   *          Note: Only one of the style UP or DOWN may be specified.
   *          </p>
   */
  public static void drawVerticalText(String string, int x, int y, GC gc,
      int style) {
    // Get the current display
    Display display = Display.getCurrent();
    if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);

    // Determine string's dimensions
    FontMetrics fm = gc.getFontMetrics();
    Point pt = gc.textExtent(string);

    // Create an image the same size as the string
    Image stringImage = new Image(display, pt.x, pt.y);

    // Create a GC so we can draw the image
    GC stringGc = new GC(stringImage);

    // Set attributes from the original GC to the new GC
    stringGc.setForeground(gc.getForeground());
    stringGc.setBackground(gc.getBackground());
    stringGc.setFont(gc.getFont());

    // Draw the text onto the image
    stringGc.drawText(string, 0, 0);

    // Draw the image vertically onto the original GC
    drawVerticalImage(stringImage, x, y, gc, style);

    // Dispose the new GC
    stringGc.dispose();

    // Dispose the image
    stringImage.dispose();
  }

  /**
   * Draws an image vertically (rotates plus or minus 90 degrees)
   * <dl>
   * <dt>[b]Styles: [/b]</dt>
   * <dd>UP, DOWN</dd>
   * </dl>
   * 
   * @param image the image to draw
   * @param x the x coordinate of the top left corner of the drawing rectangle
   * @param y the y coordinate of the top left corner of the drawing rectangle
   * @param gc the GC on which to draw the image
   * @param style the style (SWT.UP or SWT.DOWN)
   *          


   *          Note: Only one of the style UP or DOWN may be specified.
   *          </p>
   */
  public static void drawVerticalImage(Image image, int x, int y, GC gc, int style) {
    // Get the current display
    Display display = Display.getCurrent();
    if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);

    // Use the image's data to create a rotated image's data
    ImageData sd = image.getImageData();
    ImageData dd = new ImageData(sd.height, sd.width, sd.depth, sd.palette);

    // Determine which way to rotate, depending on up or down
    boolean up = (style & SWT.UP) == SWT.UP;

    // Run through the horizontal pixels
    for (int sx = 0; sx < sd.width; sx++) {
      // Run through the vertical pixels
      for (int sy = 0; sy < sd.height; sy++) {
        // Determine where to move pixel to in destination image data
        int dx = up ? sy : sd.height - sy - 1;
        int dy = up ? sd.width - sx - 1 : sx;

        // Swap the x, y source data to y, x in the destination
        dd.setPixel(dx, dy, sd.getPixel(sx, sy));
      }
    }

    // Create the vertical image
    Image vertical = new Image(display, dd);

    // Draw the vertical image onto the original GC
    gc.drawImage(vertical, x, y);

    // Dispose the vertical image
    vertical.dispose();
  }

  /**
   * Creates an image containing the specified text, rotated either plus or minus
   * 90 degrees.
   * <dl>
   * <dt>[b]Styles: [/b]</dt>
   * <dd>UP, DOWN</dd>
   * </dl>
   * 
   * @param text the text to rotate
   * @param font the font to use
   * @param foreground the color for the text
   * @param background the background color
   * @param style direction to rotate (up or down)
   * @return Image
   *         


   *         Note: Only one of the style UP or DOWN may be specified.
   *         </p>
   */
  public static Image createRotatedText(String text, Font font, Color foreground,
      Color background, int style) {// Get the current display
    Display display = Display.getCurrent();
    if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);

    // Create a GC to calculate font's dimensions
    GC gc = new GC(display);
    gc.setFont(font);

    // Determine string's dimensions
    FontMetrics fm = gc.getFontMetrics();
    Point pt = gc.textExtent(text);

    // Dispose that gc
    gc.dispose();

    // Create an image the same size as the string
    Image stringImage = new Image(display, pt.x, pt.y);

    // Create a gc for the image
    gc = new GC(stringImage);
    gc.setFont(font);
    gc.setForeground(foreground);
    gc.setBackground(background);

    // Draw the text onto the image
    gc.drawText(text, 0, 0);

    // Draw the image vertically onto the original GC
    Image image = createRotatedImage(stringImage, style);

    // Dispose the new GC
    gc.dispose();

    // Dispose the horizontal image
    stringImage.dispose();

    // Return the rotated image
    return image;
  }

  /**
   * Creates a rotated image (plus or minus 90 degrees)
   * <dl>
   * <dt>[b]Styles: [/b]</dt>
   * <dd>UP, DOWN</dd>
   * </dl>
   * 
   * @param image the image to rotate
   * @param style direction to rotate (up or down)
   * @return Image
   *         


   *         Note: Only one of the style UP or DOWN may be specified.
   *         </p>
   */
  public static Image createRotatedImage(Image image, int style) {
    // Get the current display
    Display display = Display.getCurrent();
    if (display == null) SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);

    // Use the image's data to create a rotated image's data
    ImageData sd = image.getImageData();
    ImageData dd = new ImageData(sd.height, sd.width, sd.depth, sd.palette);

    // Determine which way to rotate, depending on up or down
    boolean up = (style & SWT.UP) == SWT.UP;

    // Run through the horizontal pixels
    for (int sx = 0; sx < sd.width; sx++) {
      // Run through the vertical pixels
      for (int sy = 0; sy < sd.height; sy++) {    // Determine where to move pixel to in destination image data
        int dx = up ? sy : sd.height - sy - 1;
        int dy = up ? sd.width - sx - 1 : sx;

        // Swap the x, y source data to y, x in the destination
        dd.setPixel(dx, dy, sd.getPixel(sx, sy));
      }
    }

    // Create the vertical image
    return new Image(display, dd);
  }
}
```
Und noch mein PaintListener

```
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

import util.GraphicsUtils;



/**
 * @author prakew
 */
public class ControlCompositePaint implements PaintListener {
    
    private final Image choiceText;
    private final Image selectionText;
    private final Font font;
    
    public ControlCompositePaint(Shell shell){
        font = new Font(shell.getDisplay(), new FontData("Arial", 10, SWT.BOLD));
        choiceText = GraphicsUtils.createRotatedText("Vorhandene DataObjects", font,
                shell.getForeground(), shell.getBackground(), SWT.DOWN);
        selectionText = GraphicsUtils.createRotatedText("Ausgewählte DataObjects", font,
                shell.getForeground(), shell.getBackground(), SWT.DOWN);
    }// end Constructor

    
    public void paintControl( PaintEvent event ) {
        // Display aus Ereignis holen
        Display display = event.display;
        // Das Ereignis liefert auch den Grafikkontext
        GC gc = event.gc;
       
        Composite composite = (Composite)event.widget;
        // Alle Controls aus der Composite holen
        Control [] c_array = composite.getChildren();
        
        // linker ListViewer
        Control c1 = c_array[0];
        Point p1 = c1.getLocation();

        // rechter ListViewer
        Control c2 = c_array[1];
        Point p2 = c2.getLocation();
        
              
       gc.drawImage(choiceText, p1.x - 20, p1.y);
       gc.drawImage(selectionText, p2.x - 20, p2.y);
    }// endmethod

}// end Class
```


----------

