Righe di sfondo lampeggianti di TableViewer o TreeViewer in SWT

Question

Ho bisogno della possibilità di avere uno sfondo lampeggiante (rosso, forse più colori) per le righe in un TableViewer/TreeViewer. Quali sono le migliori opzioni?

Potrebbe esserci più di una riga lampeggiante, il DEVE lampeggiante DEVE essere sincronizzato e ho bisogno di due modalità lampeggianti, veloce e lenta.

Answer 1

Si dovrebbe avere una struttura che assomiglia a qualcosa di simile:

LinkedList<Row> rows = new LinkedList<Row>(); 
Thread blinker = null; 

public void start() { 
    blinker = new Thread() { 
     public void run() { 
      while(!this.interrupted()) { 
       try { 
        synchronized (rows) { 
         for (Row row : rows) { 
          row.setForegroundColor(color1); 
         } 
        } 
        Thread.sleep(500); 
        synchronized (rows) { 
         for (Row row : rows) { 
          row.setForegroundColor(color2); 
         } 
        } 
        Thread.sleep(500); 
       } catch (InterruptException e) { 
        break; 
       } 
      } 
     } 
    }; 
    blinker.start(); 
} 

public void stop() { 
    if (blinker != null) { 
     blinker.interrupt(); 
    } 
} 

public void add(Row row) { 
    synchronized (rows) { 
     if (!rows.contains(row)) { 
      rows.add(row); 
     } 
    } 
} 

public void remove(Row row) { 
    synchronized (rows) { 
     rows.remove(row); 
    } 
} 

Quando i Shell display, si dovrebbe chiamare start(). Quando dispone, chiama il numero stop().

Nota che non l'ho ancora testato; è un pseudocodice Java. Se non è possibile impostare il colore della riga con lo setForegroundColor() suggerito sopra, è possibile introdurre un widget e definire un evento paint().

Answer 2

Howdy, questo è un trucco veloce che mostra l'idea, migliorabile in molti modi. Mostro le tre classi facendo il lavoro. Se vuoi, posso fornire un plug-in di esportazione pronto per l'installazione nel tuo workbench di eclipse domani. Qui ci sono le classi principali:

import java.util.TimerTask; 

import org.eclipse.jface.resource.ColorDescriptor; 
import org.eclipse.jface.viewers.IColorProvider; 
import org.eclipse.jface.viewers.ITableLabelProvider; 
import org.eclipse.jface.viewers.LabelProvider; 
import org.eclipse.jface.viewers.TableViewer; 
import org.eclipse.swt.graphics.Color; 
import org.eclipse.swt.graphics.Image; 
import org.eclipse.swt.graphics.RGB; 
import org.eclipse.ui.PlatformUI; 

public class Blinker extends LabelProvider implements ITableLabelProvider, IColorProvider { 

    private final TableViewer viewer; 


    public Blinker(TableViewer viewer){ 
     this.viewer = viewer; 
    } 

    // this is just a lousy way to store blink_on/blink_off... 
    private byte state; 

    // there must be a better way to get a color... 
    final static Color red = ColorDescriptor.createFrom(new RGB(255,0,0)).createColor(PlatformUI.getWorkbench().getDisplay()); 
    final static Color green = ColorDescriptor.createFrom(new RGB(0,255,0)).createColor(PlatformUI.getWorkbench().getDisplay()); 


    private final TimerTask task = new TimerTask(){ 
     @Override 
     public void run() { 
      state++; 
      PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable(){ 
       public void run() { 
        viewer.refresh(); 
       } 
      }); 
     } 
    }; 

    private Timer t; 

    synchronized byte getState(){ 
     return state; 
    } 

    @Override 
    public Image getColumnImage(Object element, int columnIndex) { 
     return null; 
    } 

    @Override 
    public String getColumnText(Object element, int columnIndex) { 
     return ((Element) element).text; 
    } 

    @Override 
    public Color getBackground(Object object) { 
     Element element = (Element) object; 
     if (element.isBlinking()){ 
      return getState() % 2 == 0 ? Blinker.red : Blinker.green; 
     } else { 
      return Blinker.green; 
     } 
    } 

    @Override 
    public Color getForeground(Object element) { 
     return null; 
    } 


    public void start() { 
     t = new Timer(); 
     t.schedule(task, 200, 1000); 
    } 

    public void stop() { 
     t.cancel(); 
     t = null; 
     } 

} 

Questa è una classe del modello campione. Stato Blink è memorizzato all'interno dell'oggetto, ma si potrebbe desiderare di migliorare questo utilizzando una sorta di adattatore:

package com.example.blinker; 

public class Element { 

    private boolean blinking; 
    public final String text; 


    public Element(String string, boolean b) { 
     this.text = string; 
     this.blinking = b; 
    } 


    public synchronized boolean isBlinking(){ 
     return blinking; 
    } 


    public synchronized void setBlinking(boolean b){ 
     this.blinking = b; 
    } 


    public static final Element[] sampledata = new Element[] { 
     new Element("Merkur", false), 
     new Element("Venus", true), 
     new Element("Erde", false), 
     new Element("Mars", true), 
     new Element("Jupiter", false), 
     new Element("Saturn", true), 
     new Element("Uranus", false), 
     new Element("Neptun", true), 
     new Element("Pluto", false), 
    }; 

} 

E infine una TableViewer incorporato in una visualizzazione, facendo uso dei due di cui sopra:

package com.example.blinker.views; 

import org.eclipse.jface.viewers.IStructuredContentProvider; 
import org.eclipse.jface.viewers.TableViewer; 
import org.eclipse.jface.viewers.Viewer; 
import org.eclipse.swt.SWT; 
import org.eclipse.swt.widgets.Composite; 
import org.eclipse.ui.part.ViewPart; 

import com.example.blinker.Blinker; 
import com.example.blinker.Element; 

public class SampleView extends ViewPart { 

    public static final String ID = "com.example.blinker.views.SampleView"; 

    private TableViewer viewer; 
    private Blinker blinker; 

    class ViewContentProvider implements IStructuredContentProvider { 
     public void inputChanged(Viewer v, Object oldInput, Object newInput) {} 
     public void dispose() {} 
     public Object[] getElements(Object parent) { 
      return Element.sampledata; 
     } 
    } 

    public void createPartControl(Composite parent) { 
     viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL); 
     viewer.setContentProvider(new ViewContentProvider()); 
     blinker = new Blinker(viewer); 
     viewer.setLabelProvider(blinker); 
     viewer.setInput(new Object()); 
     blinker.start(); 
    } 

    public void setFocus() { 
     viewer.getControl().setFocus(); 
    } 

    public void dispose() { 
     blinker.stop(); 
    } 
} 

Answer 3

Farei qualcosa di simile a questo. Aggiorna gli elementi di cui hai bisogno per cambiare i colori a intervalli regolari. Ad ogni aggiornamento si alternano i colori a seconda di come si desidera che lampeggino.

void scheduleColorChange(final Color colors[], final int startIndex, final int changeInterval) 
{ 
    getDisplay().timerExec(changeInterval, new Runnable() 
    { 
    public void run() 
    { 
     Object[] elements = getColorChangingElements(); 
     setColorsForFlashingElements(elements, colors[index%colors.length]); 
     getViewer().update(elements); 
     scheduleColorChange(colors, startIndex+1, changeInterval) 
    } 
    }); 
} 

e il provider di etichette che avete implementato IColorProvider.