Examples of org.eclipse.swt.graphics.GC

org.eclipse.swt.graphics.GC
se.org/swt/snippets/#gc">GC snippets @see SWT Examples: GraphicsExample, PaintExample @see Sample code and further information

        buffer_image = draw( bounds );
      }


      if ( buffer_image != null ){
        
        GC gc = new GC( canvas );
  
        gc.drawImage( buffer_image, bounds.x, bounds.y );
  
        gc.dispose();   
      }
    }

View Full Code Here

      int usable_width   = bounds.width - PAD_LEFT - PAD_RIGHT;
      int usable_height  = bounds.height - PAD_TOP - PAD_BOTTOM;


      Image image = new Image( canvas.getDisplay(), bounds );


      GC gc = new GC( image );


      try {
        gc.setAntialias( SWT.ON );
      } catch (Exception e) {
        // Ignore ERROR_NO_GRAPHICS_LIBRARY error or any others
      }


      int font_height   = gc.getFontMetrics().getHeight();
      int char_width   = gc.getFontMetrics().getAverageCharWidth();




      Color[] colours = plot_views[0].plotGraph.getColours();


      int  max_x     = 0;
      int  max_y     = 0;


      if ( zones.length > 0 ){
       
        int  max_metric  = 0;
  
        for (int i=0;i<zones.length;i++){
  
          SpeedManagerPingZone zone = zones[i];
  
          int  metric   = zone.getMetric();
  
          if ( metric > 0 ){
  
            max_metric = Math.max( max_metric, metric );
  
            max_x = Math.max( max_x, zone.getUploadEndBytesPerSec());
            max_y = Math.max( max_y, zone.getDownloadEndBytesPerSec());
          }
        }


        if ( max_x > 0 && max_y > 0 ){
        
          double x_ratio = (double)usable_width/max_x;
          double y_ratio = (double)usable_height/max_y;
          
          List  texts = new ArrayList();
          
          for (int i=0;i<zones.length;i++){
    
            SpeedManagerPingZone zone = zones[i];
    
            int  metric   = zone.getMetric();
            int  x1    = zone.getUploadStartBytesPerSec();
            int  y1     = zone.getDownloadStartBytesPerSec();
            int  x2     = zone.getUploadEndBytesPerSec();
            int  y2    = zone.getDownloadEndBytesPerSec();
                
            if ( metric > 0 ){
    
              int  colour_index = (int)((float)metric*colours.length/max_metric);
    
              if ( colour_index >= colours.length ){
    
                colour_index = colours.length-1;
              }
    
              gc.setBackground( colours[colour_index] );
    
              int  x     = PAD_LEFT + (int)(x1*x_ratio);
              int  y     = PAD_TOP  + (int)(y1*y_ratio);
              int  width   = (int)Math.ceil((x2-x1+1)*x_ratio);
              int  height  = (int)Math.ceil((y2-y1+1)*y_ratio );
              
              int  y_draw = usable_height + PAD_TOP + PAD_TOP - y - height;
              
              gc.fillRectangle( x, y_draw, width, height );
                  
              int  text_metric = zone.getMetric();
              
              String text = String.valueOf( metric );
                
              int  text_width = text.length()*char_width + 4;
              
              if ( width >= text_width && height >= font_height ){
                


                Rectangle text_rect = 
                new Rectangle(
                    x + ((width-text_width)/2), 
                    y_draw + ((height-font_height)/2), 
                    text_width, font_height );
                  
                  // check for overlap with existing and delete older
                
                Iterator it = texts.iterator();
                
                while( it.hasNext()){
                  
                  Object[]  old = (Object[])it.next();
                  
                  Rectangle old_coords = (Rectangle)old[1];
                  
                  if ( old_coords.intersects( text_rect )){
                  
                    it.remove();
                  }
                }
                
                texts.add( new Object[]{ new Integer( text_metric ), text_rect });  
              }
            }
          }
          
            // only do the last 100 texts as things get a little cluttered
          
          int  text_num = texts.size();
          
          for (int i=(text_num>100?(text_num-100):0);i<text_num;i++){
            
            Object[]  entry = (Object[])texts.get(i);
            
            String  str = String.valueOf(entry[0]);
            
            Rectangle  rect = (Rectangle)entry[1];
            
            gc.drawText(str, rect.x, rect.y, SWT.DRAW_TRANSPARENT );
          }
        }
      }
      
        // x axis


      int x_axis_left_x = PAD_LEFT;
      int x_axis_left_y = usable_height + PAD_TOP;


      int x_axis_right_x = PAD_LEFT + usable_width;
      int x_axis_right_y = x_axis_left_y;




      gc.drawLine( x_axis_left_x, x_axis_left_y, x_axis_right_x, x_axis_right_y );
      gc.drawLine( usable_width, x_axis_right_y - 4, x_axis_right_x, x_axis_right_y );
      gc.drawLine( usable_width, x_axis_right_y + 4, x_axis_right_x, x_axis_right_y );


      for (int i=1;i<10;i++){
        
        int  x = x_axis_left_x + ( x_axis_right_x - x_axis_left_x )*i/10;
        
        gc.drawLine( x, x_axis_left_y, x, x_axis_left_y+4 );
      }
      
      SpeedManagerLimitEstimate le = mapper.getEstimatedUploadLimit( false );
      
      if ( le != null ){
        
        gc.setForeground(Colors.grey );
        
        int[][] segs = le.getSegments();
        
        if ( segs.length > 0 ){
          
          int  max_metric   = 0;
          int  max_pos    = 0;
          
          for (int i=0;i<segs.length;i++){
            
            int[]  seg = segs[i];
            
            max_metric   = Math.max( max_metric, seg[0] );
            max_pos     = Math.max( max_pos, seg[2] );
          }
          
          double  metric_ratio   = max_metric==0?1:((float)50/max_metric);
          double  pos_ratio     = max_pos==0?1:((float)usable_width/max_pos);
          
          int  prev_x  = 1;
          int  prev_y  = 1;
          
          for (int i=0;i<segs.length;i++){
            
            int[]  seg = segs[i];
            
            int  next_x   = (int)((seg[1] + (seg[2]-seg[1])/2)*pos_ratio) + 1;
            int  next_y  = (int)((seg[0])*metric_ratio) + 1;
            
            gc.drawLine(
                x_axis_left_x + prev_x,
                x_axis_left_y - prev_y,
                x_axis_left_x + next_x,
                x_axis_left_y - next_y );
                            
            prev_x = next_x;
            prev_y = next_y;
          }
        }
        
        gc.setForeground( Colors.black );
      }
      
      SpeedManagerLimitEstimate[] bad_up = mapper.getBadUploadHistory();
      
      if ( bad_up.length > 0 ){
        
        gc.setLineWidth( 3 );
        
        gc.setForeground( Colors.red );


        for (int i=0;i<bad_up.length;i++){
          
          int speed = bad_up[i].getBytesPerSec();
          
          int  x = max_x == 0?0:(speed * usable_width / max_x);
        
          gc.drawLine(
              x_axis_left_x + x,
              x_axis_left_y - 0,
              x_axis_left_x + x,
              x_axis_left_y - 10 );


        }
        
        gc.setForeground( Colors.black );
        
        gc.setLineWidth( 1 );
      }
      
      String x_text = labels[0] + " - " + formatters[0].format( max_x+1 );


      gc.drawText(   x_text, 
              x_axis_right_x - 20 - x_text.length()*char_width, 
              x_axis_right_y - font_height - 2, 
              SWT.DRAW_TRANSPARENT );


        // y axis


      int y_axis_bottom_x = PAD_LEFT;
      int y_axis_bottom_y = usable_height + PAD_TOP;


      int y_axis_top_x   = PAD_LEFT;
      int y_axis_top_y   = PAD_TOP;


      gc.drawLine( y_axis_bottom_x, y_axis_bottom_y, y_axis_top_x, y_axis_top_y );


      gc.drawLine( y_axis_top_x-4, y_axis_top_y+PAD_TOP,  y_axis_top_x, y_axis_top_y );
      gc.drawLine( y_axis_top_x+4, y_axis_top_y+PAD_TOP,  y_axis_top_x, y_axis_top_y );


      for (int i=1;i<10;i++){
        
        int  y = y_axis_bottom_y + ( y_axis_top_y - y_axis_bottom_y )*i/10;
        
        gc.drawLine( y_axis_bottom_x, y, y_axis_bottom_x-4, y );
      }
      
      le = mapper.getEstimatedDownloadLimit( false );
      
      if ( le != null ){
        
        gc.setForeground(Colors.grey );
        
        int[][] segs = le.getSegments();
        
        if ( segs.length > 0 ){
          
          int  max_metric   = 0;
          int  max_pos    = 0;
          
          for (int i=0;i<segs.length;i++){
            
            int[]  seg = segs[i];
            
            max_metric   = Math.max( max_metric, seg[0] );
            max_pos     = Math.max( max_pos, seg[2] );
          }
          
          double  metric_ratio   = max_metric==0?1:((float)50/max_metric);
          double  pos_ratio     = max_pos==0?1:((float)usable_height/max_pos);
          
          int  prev_x  = 1;
          int  prev_y  = 1;
          
          for (int i=0;i<segs.length;i++){
            
            int[]  seg = segs[i];
            
            int  next_x  = (int)((seg[0])*metric_ratio) + 1;
            int  next_y   = (int)((seg[1] + (seg[2]-seg[1])/2)*pos_ratio) + 1;
            
            gc.drawLine(
              y_axis_bottom_x + prev_x,
              y_axis_bottom_y - prev_y,
              y_axis_bottom_x + next_x,
              y_axis_bottom_y - next_y );
                            
            prev_x = next_x;
            prev_y = next_y;
          }
        }
        
        gc.setForeground( Colors.black );
      }
      
      SpeedManagerLimitEstimate[] bad_down = mapper.getBadDownloadHistory();
      
      if ( bad_down.length > 0 ){
        
        gc.setForeground( Colors.red );


        gc.setLineWidth( 3 );
        
        for (int i=0;i<bad_down.length;i++){
          
          int speed = bad_down[i].getBytesPerSec();
          
          int  y = max_y==0?0:( speed * usable_height / max_y );
        
          gc.drawLine(
                y_axis_bottom_x + 0,
                y_axis_bottom_y - y,
              y_axis_bottom_x + 10,
              y_axis_bottom_y - y );
        }
        
        gc.setForeground( Colors.black );
        
        gc.setLineWidth( 1 );
      }
      
      String  y_text = labels[1] + " - " + formatters[1].format( max_y+1 );


      gc.drawText( y_text, y_axis_top_x+4, y_axis_top_y + 2, SWT.DRAW_TRANSPARENT );


      gc.drawText( title, ( bounds.width - title.length()*char_width )/2, 1, SWT.DRAW_TRANSPARENT );
      
      gc.dispose();


      return( image );
    }

View Full Code Here

      img.dispose();
    }
    
    img = new Image(display,size);
    
    GC gc = new GC(img);    
    
    gc.setForeground(white);
    gc.setBackground(white);
    
    gc.fillRectangle(size);
    
    if(SWT.getVersion() >= 3138 && antiAliasingAvailable) {
      try {
        //gc.setTextAntialias(SWT.ON);
        //gc.setAntialias(SWT.ON);
      } catch(Exception e) {
        antiAliasingAvailable = false;
      }
    }
    
    
    gc.setForeground(blue);
    gc.setBackground(white);     
    
    DHTNetworkPosition _ownPosition = self.getNetworkPosition(DHTNetworkPosition.POSITION_TYPE_VIVALDI_V1);


    if ( _ownPosition == null ){
      return;
    }
    
    VivaldiPosition ownPosition = (VivaldiPosition)_ownPosition;
    float ownErrorEstimate = ownPosition.getErrorEstimate();
    HeightCoordinatesImpl ownCoords =
      (HeightCoordinatesImpl) ownPosition.getCoordinates();
    
    gc.drawText("Our error: " + ownErrorEstimate,10,10);
    
    Color black = ColorCache.getColor(display, 0, 0, 0);
    gc.setBackground(black); // Color of the squares


    // Draw all known positions of other contacts
    Iterator iter = contacts.iterator();
    while(iter.hasNext()) {
      DHTControlContact contact = (DHTControlContact) iter.next();
      DHTNetworkPosition _position = contact.getTransportContact().getNetworkPosition(DHTNetworkPosition.POSITION_TYPE_VIVALDI_V1);
      if ( _position == null ){
        continue;
      }
      VivaldiPosition position = (VivaldiPosition)_position;
      HeightCoordinatesImpl coord = (HeightCoordinatesImpl) position.getCoordinates();
      if(coord.isValid()) {
        draw(gc,coord.getX(),coord.getY(),coord.getH(),contact,(int)ownCoords.distance(coord),position.getErrorEstimate());
      }
    }
    
    // Mark our own position
    Color red = ColorCache.getColor(display, 255, 0, 0);
    gc.setForeground(red);
    drawSelf(gc, ownCoords.getX(), ownCoords.getY(),
             ownCoords.getH(), ownErrorEstimate);
    
    
    gc.dispose();
    
    canvas.redraw();
  }

View Full Code Here

    if (img != null && !img.isDisposed()) {
      img.dispose();
    }
    
    img = new Image(display,size);
    GC gc = new GC(img);
    
    Color white = ColorCache.getColor(display,255,255,255);
    gc.setForeground(white);
    gc.setBackground(white);
    gc.fillRectangle(size);
    
    Color blue = ColorCache.getColor(display,66,87,104);
    gc.setForeground(blue);
    gc.setBackground(blue);
    
    
    
    Iterator iter = vivaldiPositions.iterator();
    while(iter.hasNext()) {
      VivaldiPosition position  = (VivaldiPosition)iter.next();
      HeightCoordinatesImpl coord = (HeightCoordinatesImpl) position.getCoordinates();
      
      float error = position.getErrorEstimate() - VivaldiPosition.ERROR_MIN;
      if(error < 0) error = 0;
      if(error > 1) error = 1;
      int blueComponent = (int) (255 - error * 255);
      int redComponent = (int) (255*error);
      // Don't use ColorCache, as our color creation is temporary and
      // varying
      Color drawColor = new Color(display,redComponent,50,blueComponent);      
      gc.setForeground(drawColor);
      draw(gc,coord.getX(),coord.getY(),coord.getH());
      drawColor.dispose();
    }
    
    gc.dispose();
    
    canvas.redraw();
  }

View Full Code Here

    layout_data.heightHint = TOP_GRADIENT_HEIGHT;
    window_top.setLayoutData(layout_data);
    window_top.addPaintListener(new PaintListener() {
      public void paintControl(PaintEvent arg0) {
        Rectangle rect = shell.getClientArea ();
        GC gc = arg0.gc;
        gc.setForeground (GRADIENT_COLOR_2);
        gc.setBackground (GRADIENT_COLOR_1);
        gc.fillGradientRectangle (rect.x, rect.y, rect.width, rect.height, false);
        Image image = SWTImageRepository.getImage(logo_image);
        gc.drawImage(image, rect.width - image.getImageData().width - 10, 5);
        
        gc.setForeground(new Color(SWTThread.getDisplay(),0,0,0));
        Font font = new Font(display,"Arial",14,SWT.NONE ); 
        gc.setFont(font);
        gc.drawText(JMConstants.JMULE_NAME, 20, TOP_GRADIENT_HEIGHT / 2 - 15,true);
        
        gc.setForeground(new Color(SWTThread.getDisplay(),0,0,0));
        font = new Font(display,"Arial",10,SWT.NONE ); 
        gc.setFont(font);
        gc.drawText("Version : " + JMConstants.JMULE_VERSION, 17, TOP_GRADIENT_HEIGHT / 2 + 5,true);
      }
    });
    
    Composite window_content = new Composite(shell,SWT.NONE);
    window_content.setLayoutData(new GridData(GridData.FILL_BOTH));

View Full Code Here

  private int getY() {
    return pointer_height;
  }
  
  private void draw() {
    GC gc = new GC(this);
    
    int x = getX();
    int y = getY();
    int height = getBarHeight();
    int width = getBarWidth(); 
    
    gc.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
    gc.fillRectangle(0, y-pointer_height, getClientArea().width, pointer_height*2 + bar_height);
    
    // draw bar
    gc.setBackground(barBackgroundColor);
    gc.fillRectangle(x - bar_margin, y,width + bar_margin*2,height);
    
    // draw used segment
    gc.setBackground(barUsedSegmentColor);
    int up_coord = getUpCoord();
    int down_coord = getDownCoord();
    gc.fillPolygon(new int[] { up_coord,y,down_coord,y,down_coord,y + bar_height, up_coord, y + bar_height});
    
    // draw pointers
    gc.setBackground(pointerColor);
    gc.fillPolygon(new int[] { up_coord, y, up_coord + pointer_width, y - pointer_height, up_coord - pointer_width, y - pointer_height});
    int y2 = y + bar_height;
    gc.fillPolygon(new int[] { down_coord, y2, down_coord + pointer_width, y2 + pointer_height, down_coord - pointer_width, y2 + pointer_height});
    gc.dispose();
  }

View Full Code Here

        //System.out.println("doPaint() sizewrong #"+row.getIndex()+ ".  Image="+imageBounds +";us="+bounds);
/**/
        // Enable this for semi-fast visual update with some flicker
        boolean ourGC = (gc == null);
        if (ourGC)
          gc = new GC(table);
        if (gc != null) {
          int iAdj = VerticalAligner.getTableAdjustVerticalBy(table);
          bounds.y += iAdj;
          iAdj = VerticalAligner.getTableAdjustHorizontallyBy(table);
          bounds.x += iAdj;


          gc.drawImage(image, 0, 0, imageBounds.width, imageBounds.height, 
                       bounds.x, bounds.y, bounds.width, bounds.height);
          if (ourGC)
            gc.dispose();
        }
        // _OR_ enable refresh() for slower visual update with lots of flicker
        //refresh();
        
        // OR, disable both and image will be updated on next graphic bar update
        
        // TODO: make config option to choose
/**/
        invalidate();
        return;
      }
    } else {
      if (imageBounds.width < bounds.width) {
        if (orientation == SWT.CENTER)
          bounds.x += (bounds.width - imageBounds.width) / 2;
        else if (orientation == SWT.RIGHT)
          bounds.x = (bounds.x + bounds.width) - imageBounds.width;
      }


      if (imageBounds.height < bounds.height) {
        bounds.y += (bounds.height - imageBounds.height) / 2;
      }
    }
    
    Rectangle clipping = new Rectangle(bounds.x, bounds.y, 
                                       bounds.width, 
                                       bounds.height);
    int iMinY = table.getHeaderHeight() + tableBounds.y;
    if (clipping.y < iMinY) {
      clipping.height -= iMinY - clipping.y;
      clipping.y = iMinY;
    }
    int iMaxY = tableBounds.height + tableBounds.y;
    if (clipping.y + clipping.height > iMaxY)
      clipping.height = iMaxY - clipping.y + 1;


    if (clipping.width <= 0 || clipping.height <= 0) {
      //System.out.println(row.getIndex() + " clipping="+clipping + ";" + iMinY + ";" + iMaxY + ";tca=" + tableBounds);
      return;
    }


    // See Eclipse Bug 42416
    // "[Platform Inconsistency] GC(Table) has wrong origin"
    // Notes/Questions:
    // - GTK's "new GC(table)" starts under header, instead of above
    //   -- so, adjust bounds up
    // - Appears to apply to new GC(table) AND GC passed by PaintEvent from a Table PaintListener
    // - Q) .height may be effected (smaller than it should be).  How does this effect clipping?
    // - Q) At what version does this bug start appearing?
    //   A) Reports suggest at least 2.1.1
    int iAdj = VerticalAligner.getTableAdjustVerticalBy(table);
    bounds.y += iAdj;
    clipping.y += iAdj;
    // New: GTK M8+ has a bounds.x bug.. works fine in M7, but assume people have M8 or higher (3.0final)
    iAdj = VerticalAligner.getTableAdjustHorizontallyBy(table);
    bounds.x += iAdj;
    clipping.x += iAdj;


    boolean ourGC = (gc == null);
    if (ourGC) {
      gc = new GC(table);
      if (gc == null) {
        return;
      }
    }

View Full Code Here

      Rectangle imageBounds = image.getBounds();
      if (imageBounds.width != bounds.width ||
          imageBounds.height != bounds.height) {
        // Enable this for semi-fast visual update with some flicker
        cBlockView.setSize(bounds.width, bounds.height);
        GC gc = new GC(cBlockView);
        if (gc == null) {
          return;
        }
        gc.drawImage(image, 0, 0, imageBounds.width, imageBounds.height, 
                     0, 0, bounds.width, bounds.height);
        gc.dispose();
/*
        // _OR_ enable refresh() for slower visual update with lots of flicker
        //refresh();
        
        // OR, disable both and image will be updated on next graphic bar update
        
        // TODO: make config option to choose
*/
        invalidate();
        return;
      }
    }
    
    if (clipping == null) {
      clipping = new Rectangle(0, 0, bounds.width, bounds.height);
    }
    Rectangle tableBounds = table.getClientArea();
    if (tableBounds.y < table.getHeaderHeight()) {
      tableBounds.y = table.getHeaderHeight();
    }
    //debugOut("doPaint() tableBounds="+tableBounds+";canvasBounds="+canvasBounds+";clipping="+clipping, false);
    tableBounds.x -= canvasBounds.x;
    tableBounds.y -= canvasBounds.y;
    clipping = clipping.intersection(tableBounds);
    //debugOut("doPaint() clipping="+clipping, false);


    if (clipping.x + clipping.width <= 0 && clipping.y + clipping.height <= 0) {
      return;
    }
    


    GC gc = new GC(cBlockView);
    if (gc == null) {
      return;
    }
    if (orientation == SWT.FILL) {
      gc.setClipping(clipping);
      gc.drawImage(image, 0, 0);
    } else {
/*
      // Grab a pixel beside the cell and draw that as our background
      // Advantage: paints correct color when hilighted and not in focus
      // Disadvatage: doesn't always work!
      GC gc2 = new GC(table);
      Image i = new Image(table.getDisplay(), 1, 1);
      gc2.copyArea(i, bounds.x + bounds.width + 1, bounds.y + (bounds.width / 2));
      gc2.dispose();
      
      gc.drawImage(i, 0, 0, 1, 1, 
                   0,0, rBlockViewBounds.width, rBlockViewBounds.height);
*/      


      lastBackColor = getRowBackground(table);
      gc.setBackground(lastBackColor);
      gc.fillRectangle(clipping);
/*      
      Rectangle imageBounds = image.getBounds();
      Rectangle r = canvasBounds.intersection(tableBounds);
      int x = (r.width - imageBounds.width) / 2;
      if (x <= 0)
        x = 0;
      clipping.x += x;
*/
      int x = 0;
      gc.setClipping(clipping);
      gc.drawImage(image, x, 0);
    }
    gc.dispose();
  }

View Full Code Here

        TableItem item = table.getItem(p);
        if (item == null)
          return;
    
        Rectangle bounds = item.getBounds(0);
        GC gc = new GC(table);
        gc.setBackground(blue);
        gc.fillRectangle(oldPoint.x,oldPoint.y,bounds.width,2);
        gc.dispose();
      }
    });


    shell.pack();
    Point p = shell.getSize();

View Full Code Here

      eraseGroup(event, (EntityGroup) element);
  }


  private void eraseNews(Event event, INews news) {
    final Scrollable scrollable = (Scrollable) event.widget;
    GC gc = event.gc;


    /* Handle selected News (Linux: Note Bug 444) */
    if ((event.detail & SWT.SELECTED) != 0) {


      /* Some conditions under which we don't override the selection color */
      if (news.getLabels().isEmpty() || !scrollable.isFocusControl())
        return;


      ILabel label = news.getLabels().iterator().next();
      if (isInvalidLabelColor(label))
        return;


      Rectangle clArea = scrollable.getClientArea();
      Rectangle itemRect = event.getBounds();


      /* Paint the selection beyond the end of last column */
      expandRegion(event, scrollable, gc, clArea);


      /* Draw Rectangle */
      Color oldBackground = gc.getBackground();
      gc.setBackground(OwlUI.getColor(fResources, label));
      gc.fillRectangle(0, itemRect.y, clArea.width, itemRect.height);
      gc.setBackground(oldBackground);
      gc.setForeground(scrollable.getDisplay().getSystemColor(SWT.COLOR_WHITE));


      /* Mark as Selected being handled */
      event.detail &= ~SWT.SELECTED;
    }


    /* Handle Non-Selected flagged News */
    else if (news.isFlagged()) {
      Rectangle clArea = scrollable.getClientArea();
      Rectangle itemRect = event.getBounds();


      /* Paint the selection beyond the end of last column */
      expandRegion(event, scrollable, gc, clArea);


      /* Draw Rectangle */
      Color oldBackground = gc.getBackground();
      gc.setBackground(fStickyBgColor);
      gc.fillRectangle(0, itemRect.y, clArea.width, itemRect.height);
      gc.setBackground(oldBackground);


      /* Mark as Background being handled */
      event.detail &= ~SWT.BACKGROUND;
    }
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.eclipse.swt.graphics.GC

br.com.visualmidia.aTest.GetEmployeeTable

br.com.visualmidia.aTest.GetStudentTable

br.com.visualmidia.aTest.GetUsersTable

br.com.visualmidia.system.GDSleak

br.com.visualmidia.tools.GraphicsUtils

br.com.visualmidia.ui.controlcenter.ExpendituresAndImcomingControlCenter

br.com.visualmidia.ui.controlcenter.FlowBankAccountControlCenter

br.com.visualmidia.ui.controlcenter.HomeControlCenter

br.com.visualmidia.ui.controlcenter.RegisterMachineControlCenter

br.com.visualmidia.ui.controlcenter.table.CashFlowTable

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.