livesashform.java

采用java SWT图形库的特效代码

  }


  private static void drawBevelRect(GC gc, int x, int y, int w, int h, Color topleft, Color bottomright)
  {
    gc.setForeground(bottomright);
    gc.drawLine(x + w, y, x + w, y + h);
    gc.drawLine(x, y + h, x + w, y + h);

    gc.setForeground(topleft);
    gc.drawLine(x, y, x + w - 1, y);
    gc.drawLine(x, y, x, y + h - 1);
  }


  private void onDragSash(Event event)
  {
    Control sash = (Control)event.widget;
    int sashIndex = -1;
    for (int i = 0; i < sashes.length; i++)
    {
      if (sashes[i] == sash)
      {
        sashIndex = i;
        break;
      }
    }
    if (sashIndex == -1) return;

    Control c1 = controls[sashIndex];
    Control c2 = controls[sashIndex + 1];
    int sh1 = shadowSizeForShadow(getChildBorder(c1));
    int sh2 = shadowSizeForShadow(getChildBorder(c2));

    if (event.detail == SWT.DRAG)
    {
      Rectangle area = getClientArea();
      if (orientation == SWT.HORIZONTAL)
      {
        event.x =
          Math.min(Math.max(dragMinimum - sh1, event.x), area.width - dragMinimum - sashWidth - sh1);
      }
      else
      {
        event.y =
          Math.min(Math.max(dragMinimum - sh1, event.y), area.height - dragMinimum - sashWidth - sh1);
      }
      if(!liveUpdate) return;
    }

    Rectangle b1 = c1.getBounds();
    b1 = new Rectangle(b1.x - sh1, b1.y - sh1, b1.width + 2*sh1, b1.height + 2*sh1);
    Rectangle b2 = c2.getBounds();
    b2 = new Rectangle(b2.x - sh2, b2.y - sh2, b2.width + 2*sh2, b2.height + 2*sh2);

    Rectangle sashBounds = sash.getBounds();
    Rectangle area = getClientArea();

    if (orientation == SWT.HORIZONTAL)
    {
      int shift = event.x - sashBounds.x;
      b1.width += shift;
      b2.x += shift;
      b2.width -= shift;

      Long c1new = new Long((((long)b1.width << 16) + area.width - 1) / area.width);

      if(c1new.equals(c1.getData(LAYOUT_RATIO))) return;

      c1.setData(LAYOUT_RATIO, c1new);
      c2.setData(LAYOUT_RATIO, new Long((((long)b2.width << 16) + area.width - 1) / area.width));
    }
    else
    {
      int shift = event.y - sashBounds.y;
      b1.height += shift;
      b2.y += shift;
      b2.height -= shift;

      Long c1new = new Long((((long)b1.height << 16) + area.height - 1) / area.height);

      if(c1new.equals(c1.getData(LAYOUT_RATIO))) return;

      c1.setData(LAYOUT_RATIO, c1new);
      c2.setData(LAYOUT_RATIO, new Long((((long)b2.height << 16) + area.height - 1) / area.height));
    }

    c1.setBounds(b1.x + sh1, b1.y + sh1, b1.width - 2*sh1, b1.height - 2*sh1);
    sash.setBounds(event.x, event.y, event.width, event.height);
    c2.setBounds(b2.x + sh2, b2.y + sh2, b2.width - 2*sh2, b2.height - 2*sh2);
  }


  /**
   * If orientation is SWT.HORIZONTAL, lay the controls in the SashForm 
   * out side by side.  If orientation is SWT.VERTICAL, lay the 
   * controls in the SashForm out top to bottom.
   * 
   * @param orientation SWT.HORIZONTAL or SWT.VERTICAL
   * 
   * @exception SWTException <ul>
   *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
   *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
   *    <li>ERROR_INVALID_ARGUMENT - if the value of orientation is not SWT.HORIZONTAL or SWT.VERTICAL
   * </ul>
   */

  public void setOrientation(int orientation)
  {
    checkWidget();
    if (this.orientation == orientation)
      return;
    if (orientation != SWT.HORIZONTAL && orientation != SWT.VERTICAL)
    {
      SWT.error(SWT.ERROR_INVALID_ARGUMENT);
    }
    this.orientation = orientation;

    for (int i = 0; i < sashes.length; i++)
    {
      sashes[i].dispose();
      sashes[i] = createSash();
    }
    layout();
    redraw();
    weightsChanged();
  }


  public void setBackground(Color color)
  {
    super.setBackground(color);
    background = color;
    for (int i = 0; i < sashes.length; i++)
    {
      sashes[i].setBackground(background);
    }
  }


  public void setForeground(Color color)
  {
    super.setForeground(color);
    foreground = color;
    for (int i = 0; i < sashes.length; i++)
    {
      sashes[i].setForeground(foreground);
    }
  }


  public void setLayout(Layout layout)
  {
    checkWidget();
  }


  /**
   * Specify the control that should take up the entire client area of the SashForm.  
   * If one control has been maximized, and this method is called with a different control, 
   * the previous control will be minimized and the new control will be maximized..
   * if the value of control is null, the SashForm will minimize all controls and return to
   * the default layout where all controls are laid out separated by sashes.
   * 
   * @param control the control to be maximized or null
   * 
   * @exception SWTException <ul>
   *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
   *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
   * </ul>
   */

  public void setMaximizedControl(Control control)
  {
    checkWidget();
    if (control == null)
    {
      if (maxControl != null)
      {
        this.maxControl = null;
        layout();
        redraw();
        weightsChanged();
        for (int i = 0; i < sashes.length; i++)
        {
          sashes[i].setVisible(true);
        }
      }
      return;
    }

    for (int i = 0; i < sashes.length; i++)
    {
      sashes[i].setVisible(false);
    }
    maxControl = control;
    layout();
    redraw();
    weightsChanged();
  }


  /**
   * Specify the relative weight of each child in the SashForm.  This will determine
   * what percent of the total width (if SashForm has Horizontal orientation) or 
   * total height (if SashForm has Vertical orientation) each control will occupy.
   * The weights must be positive values and there must be an entry for each
   * non-sash child of the SashForm.
   * 
   * @param weights the relative weight of each child
   * 
   * @exception SWTException <ul>
   *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
   *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
   *    <li>ERROR_INVALID_ARGUMENT - if the weights value is null or of incorrect length (must match the number of children)</li>
   * </ul>
   */

  public void setWeights(int[] weights)
  {
    checkWidget();
    Control[] cArray = getControls(false);
    if (weights == null || weights.length != cArray.length)
    {
      SWT.error(SWT.ERROR_INVALID_ARGUMENT);
    }

    int total = 0;
    for (int i = 0; i < weights.length; i++)
    {
      if (weights[i] < 0)
      {
        SWT.error(SWT.ERROR_INVALID_ARGUMENT);
      }
      total += weights[i];
    }
    if (total == 0)
    {
      SWT.error(SWT.ERROR_INVALID_ARGUMENT);
    }
    for (int i = 0; i < cArray.length; i++)
    {
      cArray[i].setData(
        LAYOUT_RATIO,
        new Long((((long)weights[i] << 16) + total - 1) / total));
    }

    layout();
    redraw();
    weightsChanged();
  }


  private Control createSash()
  {
    int sashStyle =
      (orientation == SWT.HORIZONTAL) ? SWT.VERTICAL : SWT.HORIZONTAL;

    Control c;
    /*if(liveUpdate) c = new SashCanvas(this, sashStyle);
    else*/ c = new Sash(this, sashStyle);
    final Control sash = c;

    sash.setBackground(background);
    sash.setForeground(foreground);
    sash.addListener(SWT.Selection, sashListener);

    sash.addListener(SWT.Resize, new Listener()
    {
      public void handleEvent(Event event)
      {
        sash.redraw();
      }
    });

    sash.addListener(SWT.Paint, new Listener()
    {
      public void handleEvent(Event event)
      {
        GC gc = new GC(sash);
        
        int sashIndex = -1;
        for (int i = 0; i < sashes.length; i++)
        {
          if (sashes[i] == sash)
          {
            sashIndex = i;
            break;
          }
        }
        if (sashIndex == -1) return;

        Control c1 = controls[sashIndex];
        Control c2 = controls[sashIndex + 1];
        int sh1 = getChildBorder(c1);
        int sh2 = getChildBorder(c2);
    
        boolean vertical = (orientation == SWT.VERTICAL);
        Display disp = getDisplay();
        gc.setLineWidth(1);
        Color shadow = disp.getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW);
        Color highlight = disp.getSystemColor(SWT.COLOR_WIDGET_HIGHLIGHT_SHADOW);
        Point p = sash.getSize();

        switch(sh1)
        {
          case SWT.SHADOW_IN:
            gc.setForeground(highlight);
            if(vertical) gc.drawLine(0, 0, p.x-1, 0);
            else gc.drawLine(0, 0, 0, p.y-1);
            break;
    
          case SWT.SHADOW_OUT:
            gc.setForeground(shadow);
            if(vertical) gc.drawLine(0, 0, p.x-1, 0);
            else gc.drawLine(0, 0, 0, p.y-1);
            break;
    
          case SWT.SHADOW_ETCHED_IN:
            gc.setForeground(highlight);
            if(vertical)
            {
              gc.drawLine(0, 1, p.x-1, 1);
              gc.drawPoint(p.x-1, 0);
              gc.setForeground(shadow);
              gc.drawLine(0, 0, p.x-2, 0);
            }
            else
            {
              gc.drawLine(1, 0, 1, p.y-1);
              gc.drawPoint(0, p.y-1);
              gc.setForeground(shadow);
              gc.drawLine(0, 0, 0, p.y-2);
            }
            break;
    
          case SWT.SHADOW_ETCHED_OUT:
            gc.setForeground(shadow);
            if(vertical)
            {
              gc.drawLine(0, 1, p.x-1, 1);
              gc.drawPoint(p.x-1, 0);
              gc.setForeground(highlight);
              gc.drawLine(0, 0, p.x-2, 0);
            }
            else
            {
              gc.drawLine(1, 0, 1, p.y-1);
              gc.drawPoint(0, p.y-1);
              gc.setForeground(highlight);
              gc.drawLine(0, 0, 0, p.y-2);
            }
            break;
        }

        switch(sh2)
        {
          case SWT.SHADOW_IN:
            gc.setForeground(highlight);
            if(vertical)
            {
              gc.drawPoint(p.x-1, p.y-1);
              gc.setForeground(shadow);
              gc.drawLine(0, p.y-1, p.x-2, p.y-1);
            }
            else
            {
              gc.drawPoint(p.x-1, p.y-1);
              gc.setForeground(shadow);
              gc.drawLine(p.x-1, 0, p.x-1, p.y-2);
            }
            break;
    
          case SWT.SHADOW_OUT:
            gc.setForeground(shadow);
            if(vertical)
            {
              gc.drawPoint(p.x-1, p.y-1);
              gc.setForeground(highlight);
              gc.drawLine(0, p.y-1, p.x-2, p.y-1);
            }
            else
            {
              gc.drawPoint(p.x-1, p.y-1);
              gc.setForeground(highlight);
              gc.drawLine(p.x-1, 0, p.x-1, p.y-2);
            }
            break;
    
          case SWT.SHADOW_ETCHED_IN:
            gc.setForeground(highlight);
            if(vertical)
            {
              gc.drawLine(p.x-1, p.y-2, p.x-1, p.y-1);
              gc.drawLine(1, p.y-1, p.x-3, p.y-1);
              gc.setForeground(shadow);
              gc.drawLine(0, p.y-2, p.x-2, p.y-2);
              gc.drawPoint(0, p.y-1);
              gc.drawPoint(p.x-2, p.y-1);
            }
            else
            {
              gc.drawLine(p.x-2, p.y-1, p.x-1, p.y-1);
              gc.drawLine(p.x-1, 1, p.x-1, p.y-3);
              gc.setForeground(shadow);
              gc.drawLine(p.x-2, 0, p.x-2, p.y-2);
              gc.drawPoint(p.x-1, 0);
              gc.drawPoint(p.x-1, p.y-2);
            }
            break;
    
          case SWT.SHADOW_ETCHED_OUT:
            gc.setForeground(shadow);
            if(vertical)
            {
              gc.drawLine(p.x-1, p.y-2, p.x-1, p.y-1);
              gc.drawLine(1, p.y-1, p.x-3, p.y-1);
              gc.setForeground(highlight);
              gc.drawLine(0, p.y-2, p.x-2, p.y-2);
              gc.drawPoint(0, p.y-1);
              gc.drawPoint(p.x-2, p.y-1);
            }
            else
            {
              gc.drawLine(p.x-2, p.y-1, p.x-1, p.y-1);
              gc.drawLine(p.x-1, 1, p.x-1, p.y-3);
              gc.setForeground(highlight);
              gc.drawLine(p.x-2, 0, p.x-2, p.y-2);
              gc.drawPoint(p.x-1, 0);
              gc.drawPoint(p.x-1, p.y-2);
            }
            break;
        }
        
        gc.dispose();
      }
    });

    return sash;
  }


  /**
   * Set the border for a child control.
   * 
   * @param child The child control for which to set the border.
   * @param shadow One of the SWT shadow constants SHADOW_IN, SHADOW_OUT,
   *   SHADOW_ETCHED_IN, SHADOW_ETCHED_OUT, SHADOW_NONE.
   */  
  
  public void setChildBorder(Control child, int shadow)
  {
    checkWidget();
    if(child == null) return;
    if(shadow == SWT.SHADOW_NONE) child.setData(CHILD_SHADOW, null);
    else child.setData(CHILD_SHADOW, new Integer(shadow));
    layout();
    redraw();
    //weightsChanged();
  }


  /**
   * Get the border for a child control.
   * 
   * @param child The child control for which to get the border.
   * @return One of the SWT shadow constants SHADOW_IN, SHADOW_OUT,
   *   SHADOW_ETCHED_IN, SHADOW_ETCHED_OUT, SHADOW_NONE.
   */

  public int getChildBorder(Control child)
  {
    checkWidget();
    if(child == null) return SWT.SHADOW_NONE;
    Object o = child.getData(CHILD_SHADOW);
    if(o == null) return SWT.SHADOW_NONE;
    else return ((Integer)o).intValue();
  }


  private int shadowSizeForShadow(int shadow)
  {
    switch(shadow)
    {
      case SWT.SHADOW_IN:
      case SWT.SHADOW_OUT:
        return 1;

      case SWT.SHADOW_ETCHED_IN:
      case SWT.SHADOW_ETCHED_OUT:
        return 2;

      default:
        return 0;
    }
  }
}