Example #1
0
  private Rectangle getDisplayBounds(final Point location) {

    Rectangle displayBounds;
    final Monitor[] allMonitors = _ownerControl.getDisplay().getMonitors();

    if (allMonitors.length > 1) {
      // By default present in the monitor of the control
      displayBounds = _ownerControl.getMonitor().getBounds();
      final Point p = new Point(location.x, location.y);

      // Search on which monitor the event occurred
      Rectangle tmp;
      for (final Monitor element : allMonitors) {
        tmp = element.getBounds();
        if (tmp.contains(p)) {
          displayBounds = tmp;
          break;
        }
      }

    } else {
      displayBounds = _ownerControl.getDisplay().getBounds();
    }

    return displayBounds;
  }
Example #2
0
  private Point fixupDisplayBounds(final Point tipSize, final Point location) {

    final Rectangle displayBounds = getDisplayBounds(location);
    final Point rightBottomBounds = new Point(tipSize.x + location.x, tipSize.y + location.y);

    if (!(displayBounds.contains(location) && displayBounds.contains(rightBottomBounds))) {

      if (rightBottomBounds.x > displayBounds.x + displayBounds.width) {
        location.x -= rightBottomBounds.x - (displayBounds.x + displayBounds.width);
      }

      if (rightBottomBounds.y > displayBounds.y + displayBounds.height) {
        // ignore when tt is below the bottom, force the user to resize the tt
        //				location.y -= rightBottomBounds.y - (displayBounds.y + displayBounds.height);
      }

      if (location.x < displayBounds.x) {
        location.x = displayBounds.x;
      }

      if (location.y < displayBounds.y) {
        location.y = displayBounds.y;
      }
    }

    return location;
  }
Example #3
0
  public void positionWindow(boolean resetToDefault) {
    String mapWindow;

    mapShellBounds = mapShell.getBounds();
    mapWindow = prefs.get(RadarConsts.PREF_KEY_MAP_WINDOW, "");

    if (mapWindow.equals("") || resetToDefault) {
      Rectangle dispBounds, tableBounds;

      dispBounds = ((Display.getCurrent()).getPrimaryMonitor()).getClientArea();
      tableBounds = display.getShells()[1].getBounds();

      mapShellBounds.width = dispBounds.width - tableBounds.width;
      mapShellBounds.height = dispBounds.height;
      mapShellBounds.x = dispBounds.x + tableBounds.width;
      mapShellBounds.y = dispBounds.y;
    } else {
      String[] tokens = mapWindow.split(",");

      mapShellBounds =
          new Rectangle(
              new Integer(tokens[0]), // X value
              new Integer(tokens[1]), // Y value
              new Integer(tokens[2]), // Width
              new Integer(tokens[3]) // Height
              );
    }
    mapShell.setBounds(mapShellBounds);
  }
Example #4
0
  protected void drawBottomSpace(GC gc) {
    Rectangle r = getClientArea();
    if (m_Model.getRowCount() > 0) {
      r.y =
          m_Model.getFirstRowHeight()
              + (m_Model.getFixedRowCount() - 1 + m_RowsVisible) * m_Model.getRowHeight()
              + 1;
    }

    gc.setBackground(getBackground());
    gc.fillRectangle(r);
    gc.fillRectangle(getLastColumnRight() + 2, 0, r.width, r.height);

    if (m_Model.getRowCount() > 0) {
      if (flatStyleSpecified)
        // gc.setForeground(this.getBackground());
        gc.setForeground(m_Display.getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
      else gc.setForeground(m_Display.getSystemColor(SWT.COLOR_WIDGET_DARK_SHADOW));
      // Linke Schattenlinie
      gc.drawLine(0, 0, 0, r.y - 1);
    }

    if (!flatStyleSpecified) gc.setForeground(this.getBackground());
    else gc.setForeground(m_Display.getSystemColor(SWT.COLOR_WHITE));
    // Untere Abschlusslinie
    gc.drawLine(0, r.y - 1, getLastColumnRight() + 1, r.y - 1);

    // Rechte Abschlusslinie
    gc.drawLine(getLastColumnRight() + 1, 0, getLastColumnRight() + 1, r.y - 1);
  }
  public void addExpressionRow(String expressionName) {
    RowData rowdata = (RowData) expressionGroup.getLayoutData();
    rowdata.height += 120;
    expressionGroup.setLayoutData(new RowData(rowdata.width, rowdata.height));
    Rectangle rect = expressionGroup.getBounds();
    rect.height += 120;
    expressionGroup.setBounds(rect);
    /*Create a row*/
    ExpressionBean expBean = expressions.get(new Integer(expCount - 1));
    Label previousLabel = expBean.getLabel();
    rect = previousLabel.getBounds();
    Label lblNew = new Label(expressionGroup, SWT.NONE);
    lblNew.setBounds(10, rect.y + 90, 120, 15);
    lblNew.setText(expressionName);
    lblNew.setFocus();

    Text previousText = expBean.getText();
    rect = previousText.getBounds();

    Text newText = new Text(expressionGroup, SWT.BORDER | SWT.WRAP | SWT.V_SCROLL | SWT.MULTI);
    newText.setBounds(135, rect.y + 90, 550, 70);
    expressions.put(new Integer(expCount), new ExpressionBean(lblNew, newText));
    expCount++;
    expScrolledComposite.setMinSize(expressionGroup.computeSize(SWT.DEFAULT, SWT.DEFAULT));
  }
Example #6
0
  /**
   * Scrolls the containing editor to the given offset of the contained editor
   *
   * @param editor
   * @param scrollTo text offset in the embedded editor that should be revealed
   */
  public void revealSelection(ContainedEditorManager editor, int scrollTo) {
    StyledText containedStyledText = (StyledText) editor.getAdapter(StyledText.class);

    // this progression determines the location of the offset in the coordinate system
    // of the containing styledText
    Point containedLoc = containedStyledText.getLocationAtOffset(scrollTo);
    Point displayLoc = containedStyledText.toDisplay(containedLoc);
    Point containingLoc = styledText.toControl(displayLoc);

    // next, we determine if this location is in the visible area.
    Point containingSize = styledText.getSize();
    Rectangle containingBounds = new Rectangle(0, 0, containingSize.x, containingSize.y);
    if (!containingBounds.contains(containingLoc)) {
      // pad a little to the left and a little bit down
      containingLoc.x -= 50;
      containingLoc.y += 100;

      // if not, then perform a scroll.
      styledText.setTopPixel(styledText.getTopPixel() + containingLoc.y - containingSize.y);

      // do the same for horizontal
      styledText.setHorizontalPixel(styledText.getHorizontalPixel() + containingLoc.x);
    }
    paint(ContainingEditor.EMBEDDED_REPAINT);
  }
 public Rectangle getBounds() {
   int minx = Integer.MAX_VALUE;
   int miny = Integer.MAX_VALUE;
   int maxx = Integer.MIN_VALUE;
   int maxy = Integer.MIN_VALUE;
   for (int i = 0; i < pieces.size(); i++) {
     PipAnimateFramePiece piece = pieces.get(i);
     double[][] points = piece.getBounds();
     for (int j = 0; j < 4; j++) {
       int px = (int) points[j][0];
       int py = (int) points[j][1];
       if (px < minx) {
         minx = px;
       }
       if (py < miny) {
         miny = py;
       }
       if (px > maxx) {
         maxx = px;
       }
       if (py > maxy) {
         maxy = py;
       }
     }
   }
   Rectangle rect = new Rectangle(minx, miny, maxx - minx, maxy - miny);
   if (rect.isEmpty()) {
     rect = new Rectangle(0, 0, 16, 16);
   }
   return rect;
 }
Example #8
0
 /**
  * @see ch.post.pf.gui.ocp.wt.ext.dialogs.OcpDialog#showDialogFor(org.eclipse.swt.widgets.Control)
  */
 public int showDialogFor(Control field) {
   create();
   getShell()
       .addShellListener(
           new ShellAdapter() {
             @Override
             public void shellDeactivated(ShellEvent e) {
               close();
             }
           });
   // make sure that the popup fit into the application window.
   Rectangle appBounds = getEnvironment().getDisplay().getBounds();
   Point absPrefPos =
       field.toDisplay(field.getSize().x - getShell().getSize().x, field.getSize().y);
   Rectangle prefBounds =
       new Rectangle(absPrefPos.x, absPrefPos.y, getShell().getSize().x, getShell().getSize().y);
   // horizontal correction
   if (prefBounds.x + prefBounds.width > appBounds.width) {
     prefBounds.x = appBounds.width - prefBounds.width;
   }
   // vertical correciton
   if (prefBounds.y + prefBounds.height > appBounds.height) {
     prefBounds.y = appBounds.height - prefBounds.height;
   }
   getShell().setLocation(prefBounds.x, prefBounds.y);
   int ret = this.open();
   return ret;
 }
    public void handleEvent(final Event event) {
      // only go further if the event has a new time stamp
      if (mayScroll() && acceptEvent(event)) {
        lastEventTime = event.time;
        final Rectangle navigationComponentBounds = getNavigationComponent().getBounds();

        // convert navigation bounds relative to display
        final Point navigationPtAtDisplay = getNavigationComponent().toDisplay(0, 0);
        navigationComponentBounds.x = navigationPtAtDisplay.x;
        navigationComponentBounds.y = navigationPtAtDisplay.y;

        if (event.widget instanceof Control) {
          final Control widget = (Control) event.widget;
          // convert widget event point relative to display
          final Point evtPt = widget.toDisplay(event.getBounds().x, event.getBounds().y);
          // now check if inside navigation
          if (navigationComponentBounds.contains(evtPt.x, evtPt.y)) {
            if (event.count > 0) {
              scrollUp(SCROLLING_STEP);
            } else {
              scrollDown(SCROLLING_STEP);
            }
          }
        }
      }
    }
Example #10
0
 LRESULT WM_MOUSEMOVE(int /*long*/ wParam, int /*long*/ lParam) {
   LRESULT result = super.WM_MOUSEMOVE(wParam, lParam);
   if (OS.COMCTL32_MAJOR < 6) {
     int x = OS.GET_X_LPARAM(lParam);
     int y = OS.GET_Y_LPARAM(lParam);
     if (OS.GetKeyState(OS.VK_LBUTTON) < 0) {
       int oldSelection = selection.y;
       selection.y = layout.getOffset(x, y, null);
       if (selection.y != oldSelection) {
         int newSelection = selection.y;
         if (oldSelection > newSelection) {
           int temp = oldSelection;
           oldSelection = newSelection;
           newSelection = temp;
         }
         Rectangle rect = layout.getBounds(oldSelection, newSelection);
         redraw(rect.x, rect.y, rect.width, rect.height, false);
       }
     } else {
       for (int j = 0; j < offsets.length; j++) {
         Rectangle[] rects = getRectangles(j);
         for (int i = 0; i < rects.length; i++) {
           Rectangle rect = rects[i];
           if (rect.contains(x, y)) {
             setCursor(display.getSystemCursor(SWT.CURSOR_HAND));
             return result;
           }
         }
       }
       setCursor(null);
     }
   }
   return result;
 }
Example #11
0
  /**
   * Draws the current line highlight (over top using theme colors and alpha). If the line highlight
   * is fully opaque, then this method will not do anything and we'll fall back to using the
   * mechanism eclipse does in CursorLinePainter with a little modification.
   */
  public void paintControl(PaintEvent e) {
    // if highlight current line is disabled, don't draw!
    if (!fEnabled) {
      return;
    }
    // If there's no alpha value for the line highlight, then we need to force the bg color of the
    // whole line
    // to the rgb value!
    RGBa lineHighlight = getCurrentTheme().getLineHighlight();
    if (lineHighlight.isFullyOpaque()) {
      return;
    }

    Rectangle rect = new Rectangle(e.x, e.y, e.width, e.height);
    Rectangle lineRect = getLineRectangle(getCurrentLinePosition());
    if (lineRect == null || !lineRect.intersects(rect)) {
      return;
    }

    int previousAlpha = e.gc.getAlpha();
    Color previousBG = e.gc.getBackground();

    e.gc.setAlpha(lineHighlight.getAlpha());
    e.gc.setBackground(getColorManager().getColor(lineHighlight.toRGB()));
    // Only paint the part of lineRect that is contained in rect!
    e.gc.fillRectangle(lineRect.intersection(rect));

    // BUGFIX: need to set alpha and background color back to what they were before or it breaks
    // the painting of pair matching!
    e.gc.setAlpha(previousAlpha);
    e.gc.setBackground(previousBG);
  }
Example #12
0
 private IHyperlink getHyperlink(MouseEvent e) {
   // bug 257868 support image hyperlinks
   if (annotations.isEmpty()) {
     return null;
   }
   Point point = new Point(e.x, e.y);
   for (ImageAnnotation annotation : annotations) {
     if (annotation.getHyperlnkAnnotation() == null) {
       continue;
     }
     Rectangle region = getRegion(annotation);
     if (region != null) {
       if (region.contains(point)) {
         AnnotationHyperlinkDetector detector =
             (AnnotationHyperlinkDetector)
                 viewer.getTextWidget().getData(AnnotationHyperlinkDetector.class.getName());
         if (detector != null) {
           IHyperlink hyperlink =
               detector.createHyperlink(
                   viewer, viewer.getAnnotationModel(), annotation.getHyperlnkAnnotation());
           return hyperlink;
         }
       }
     }
   }
   return null;
 }
  @Override
  public void draw(IBNAView view, ICoordinateMapper cm, GL2 gl, Rectangle clip, IResources r) {

    if (control == null) {
      control = createControl(view, cm);
    }

    // update bounds
    final Rectangle newBounds = getBounds(control, view, cm);
    final Rectangle oldBounds = control.getBounds();
    if (!oldBounds.equals(newBounds)) {
      SWTWidgetUtils.async(
          control,
          new Runnable() {
            @Override
            public void run() {
              if (oldBounds.width != newBounds.width || oldBounds.height != newBounds.height) {
                control.setSize(newBounds.width, newBounds.height);
                if (control instanceof Composite) {
                  ((Composite) control).layout(true, true);
                  control.pack(true);
                }
              }
              control.setLocation(newBounds.x, newBounds.y);
            }
          });
    }
  }
Example #14
0
 /**
  * Hook to compute the menu location if the focus widget is a tree widget.
  *
  * @param tree the tree widget that has the focus
  * @return a widget relative position of the menu to pop up or <code>null</code> if now position
  *     inside the widget can be computed
  */
 protected Point computeMenuLocation(Tree tree) {
   TreeItem[] items = tree.getSelection();
   Rectangle clientArea = tree.getClientArea();
   switch (items.length) {
     case 0:
       return null;
     case 1:
       Rectangle bounds = items[0].getBounds();
       Rectangle intersect = clientArea.intersection(bounds);
       if (intersect != null && intersect.height == bounds.height) {
         return new Point(
             Math.max(0, bounds.x + getAvarageCharWith(tree) * CHAR_INDENT),
             bounds.y + bounds.height);
       } else {
         return null;
       }
     default:
       Rectangle[] rectangles = new Rectangle[items.length];
       for (int i = 0; i < rectangles.length; i++) {
         rectangles[i] = items[i].getBounds();
       }
       Point cursorLocation = tree.getDisplay().getCursorLocation();
       Point result =
           findBestLocation(
               getIncludedPositions(rectangles, clientArea), tree.toControl(cursorLocation));
       if (result != null) result.x = result.x + getAvarageCharWith(tree) * CHAR_INDENT;
       return result;
   }
 }
Example #15
0
  public void addDescriptionRow(String sectionName) {
    RowData rowdata = (RowData) descriptionGroup.getLayoutData();
    rowdata.height += 60;
    descriptionGroup.setLayoutData(new RowData(rowdata.width, rowdata.height));
    Rectangle rect = descriptionGroup.getBounds();
    rect.height += 60;
    descriptionGroup.setBounds(rect);

    /*Add the row*/
    Text prevText = sections.get(new Integer(secCount - 1)).getEndTokens();
    rect = prevText.getBounds();
    Text newText_1 = new Text(descriptionGroup, SWT.BORDER);
    newText_1.setBounds(10, rect.y + 40, 75, 20);
    newText_1.setFocus();

    Label lblNew = new Label(descriptionGroup, SWT.NONE);
    lblNew.setBounds(120, rect.y + 40, 145, 20);
    lblNew.setText(sectionName);

    Text newText_2 = new Text(descriptionGroup, SWT.BORDER);
    newText_2.setBounds(270, rect.y + 40, 115, 20);

    Text newText_3 = new Text(descriptionGroup, SWT.BORDER);
    newText_3.setBounds(420, rect.y + 40, 115, 20);

    Text newText_4 = new Text(descriptionGroup, SWT.BORDER);
    newText_4.setBounds(570, rect.y + 40, 115, 20);
    sections.put(
        new Integer(secCount), new SectionBean(newText_1, lblNew, newText_2, newText_3, newText_4));
    secCount++;

    descScrolledComposite.setMinSize(descriptionGroup.computeSize(SWT.DEFAULT, SWT.DEFAULT));
  }
  /**
   * Handling mouse over event to display hand cursor in case cell contains an URL
   *
   * @param e mouse event
   */
  void handleMouseOver(MouseEvent e) {
    Point pt = new Point(e.x, e.y);
    ViewerCell cell = getViewer().getCell(pt);
    boolean cursorSet = false;

    if (cell != null) {
      int colIndex = cell.getColumnIndex();
      Object element = cell.getElement();
      if (getCellControlType(element, colIndex) == CellControlType.URL) {
        Rectangle cellBounds = cell.getBounds();
        Image img = getImage(element, colIndex);
        if (img != null) {
          cellBounds.x += img.getBounds().width;
        }
        if (cellBounds.contains(pt)) {
          if (getString(element, colIndex) != null) {
            this.control.setCursor(CURSOR_HAND);
            cursorSet = true;
          }
        }
      }
    }

    if (!cursorSet) {
      handleMouseExit(e);
    }
  }
Example #17
0
 private Point computeMenuLocation(Control focus, Menu menu) {
   Point cursorLocation = focus.getDisplay().getCursorLocation();
   Rectangle clientArea = null;
   Point result = null;
   if (focus instanceof StyledText) {
     StyledText styledText = (StyledText) focus;
     clientArea = styledText.getClientArea();
     result = computeMenuLocation(styledText);
   } else if (focus instanceof Tree) {
     Tree tree = (Tree) focus;
     clientArea = tree.getClientArea();
     result = computeMenuLocation(tree);
   } else if (focus instanceof Table) {
     Table table = (Table) focus;
     clientArea = table.getClientArea();
     result = computeMenuLocation(table);
   }
   if (result == null) {
     result = focus.toControl(cursorLocation);
   }
   if (clientArea != null && !clientArea.contains(result)) {
     result = new Point(clientArea.x + clientArea.width / 2, clientArea.y + clientArea.height / 2);
   }
   Rectangle shellArea = focus.getShell().getClientArea();
   if (!shellArea.contains(focus.getShell().toControl(focus.toDisplay(result)))) {
     result = new Point(shellArea.x + shellArea.width / 2, shellArea.y + shellArea.height / 2);
   }
   return focus.toDisplay(result);
 }
Example #18
0
  protected void mouseMoveSelectMode(MouseEvent e) {
    switch (dragging) {
      case DRAG_OBJECT:
        if (!draggedAway
            && (Math.abs(e.x - dragPoint.x) >= 5 || Math.abs(e.y - dragPoint.y) >= 5)) {
          draggedAway = true;
          startDraggingSelectedObjects();
        }
        if (draggedAway) {
          dragSelectedObjectsBy(e.x - dragPoint.x, e.y - dragPoint.y);
        }
        break;

      case DRAG_SELECTIONRECTANGLE:
        if (!draggedAway
            && (Math.abs(e.x - dragPoint.x) >= 5 || Math.abs(e.y - dragPoint.y) >= 5)) {
          draggedAway = true;
        }
        if (draggedAway) {
          Rectangle r = new Rectangle(0, 0, 0, 0);
          r.x = Math.min(dragPoint.x, e.x);
          r.y = Math.min(dragPoint.y, e.y);
          r.width = Math.max(dragPoint.x, e.x) - r.x;
          r.height = Math.max(dragPoint.y, e.y) - r.y;
          setSelectionRectangle(r);
        }
        break;
    }
  }
    @Override
    protected void paint(Event event, Object element) {

      ITerminoOntoAnnotation annotation = (ITerminoOntoAnnotation) element;
      ITerminoOntoAnnotationType annotationType = annotation.getTerminoOntoAnnotationType();
      Image img = null;

      if (annotationType.getLabel().compareTo(DatabaseAdapter.LABEL_EN_ANNOTATION) == 0) {
        img =
            org.dafoe.terminoontologiclevel.ui.Activator.getDefault()
                .getImageRegistry()
                .get(org.dafoe.terminoontologiclevel.ui.Activator.US_FLAG_IMG_ID);
      } else if (annotationType.getLabel().compareTo(DatabaseAdapter.LABEL_SP_ANNOTATION) == 0) {
        img =
            org.dafoe.terminoontologiclevel.ui.Activator.getDefault()
                .getImageRegistry()
                .get(org.dafoe.terminoontologiclevel.ui.Activator.SP_FLAG_IMG_ID);
      }

      if (img != null) {
        Rectangle bounds = ((TableItem) event.item).getBounds(event.index);
        Rectangle imgBounds = img.getBounds();
        bounds.width /= 2;
        bounds.width -= imgBounds.width / 2;
        bounds.height /= 2;
        bounds.height -= imgBounds.height / 2;

        int x = bounds.width > 0 ? bounds.x + bounds.width : bounds.x;
        int y = bounds.height > 0 ? bounds.y + bounds.height : bounds.y;

        event.gc.drawImage(img, x, y);
      }
    }
Example #20
0
 /**
  * Sets the clipping to the intersection of the current clip region and the specified rectangle.
  *
  * @param x the x-coordinate.
  * @param y the y-coordinate.
  * @param width the width.
  * @param height the height.
  */
 @Override
 public void clipRect(int x, int y, int width, int height) {
   org.eclipse.swt.graphics.Rectangle clip = this.gc.getClipping();
   org.eclipse.swt.graphics.Rectangle r =
       new org.eclipse.swt.graphics.Rectangle(x, y, width, height);
   clip.intersect(r);
   this.gc.setClipping(clip);
 }
  /*
   * (non-Javadoc)
   *
   * @see org.eclipse.swt.widgets.Control#computeSize(int, int, boolean)
   */
  public Point computeSize(int arg0, int arg1, boolean arg2) {
    checkWidget();
    if (getExpanded()) return super.computeSize(arg0, arg1, arg2);

    Rectangle trim = strategy.computeTrim(0, 0, 0, 0);
    trim.width = super.computeSize(arg0, arg1, arg2).x;
    return new Point(trim.width, Math.max(trim.height, arg1));
  }
    private synchronized void calcPaddings(int width, int height) {
      Point canvasSize = getSize();

      mPadding.x = (canvasSize.x - width) / 2;
      mPadding.y = (canvasSize.y - height) / 2;

      mPadding.width = width;
      mPadding.height = height;
    }
Example #23
0
  private Rectangle getDrawBounds(TableCellSWT cell) {
    Rectangle bounds = cell.getBounds();
    bounds.height -= 12;
    bounds.y += 6;
    bounds.x += 4;
    bounds.width -= 4;

    return bounds;
  }
Example #24
0
 private void setHoverLocation(
     org.eclipse.swt.widgets.Shell shell, org.eclipse.swt.graphics.Point position) {
   org.eclipse.swt.graphics.Rectangle displayBounds = shell.getDisplay().getBounds();
   org.eclipse.swt.graphics.Rectangle shellBounds = shell.getBounds();
   shellBounds.x = Math.max(Math.min(position.x, displayBounds.width - shellBounds.width), 0);
   shellBounds.y =
       Math.max(Math.min(position.y + 16, displayBounds.height - shellBounds.height), 0);
   shell.setBounds(shellBounds);
 }
Example #25
0
 private static Rectangle calculateRulerTrim(Canvas canvas) {
   if ("carbon".equals(SWT.getPlatform())) { // $NON-NLS-1$
     Rectangle trim = canvas.computeTrim(0, 0, 0, 0);
     trim.width = 0 - trim.x * 2;
     trim.height = 0 - trim.y * 2;
     return trim;
   }
   return new Rectangle(0, 0, 0, 0);
 }
Example #26
0
 /**
  * Scrolls the content so that the given revision is visible.
  *
  * @param revision the revision to scroll the client area to.
  */
 private void scrollToRevision(Revision revision) {
   Rectangle revBounds = revision.getBounds();
   Rectangle clientArea = getClientArea();
   clientArea.x = getOrigin().x;
   clientArea.y = getOrigin().y;
   if (!clientArea.contains(revBounds.x, revBounds.y)
       && !clientArea.contains(revBounds.x + revBounds.width, revBounds.y + revBounds.height)) {
     setOrigin(revBounds.x, revBounds.y);
   }
 }
Example #27
0
 private Rectangle computeShellBounds() {
   Rectangle result = new Rectangle(0, 0, 0, 0);
   Point preferredSize = shell.computeSize(SWT.DEFAULT, SWT.DEFAULT);
   Rectangle displaySize = parent.getDisplay().getBounds();
   result.x = (displaySize.width - preferredSize.x) / 2 + displaySize.x;
   result.y = (displaySize.height - preferredSize.y) / 2 + displaySize.y;
   result.width = Math.min(preferredSize.x, MAX_WIDTH);
   result.height = preferredSize.y;
   return result;
 }
Example #28
0
 @Override
 protected Rectangle getConstrainedShellBounds(Rectangle preferredSize) {
   decideShellSize(getShell());
   Rectangle rect = getShell().getDisplay().getClientArea();
   rect.x = rect.width - shellWidth;
   rect.y = rect.height - shellHeight;
   rect.width = shellWidth;
   rect.height = shellHeight;
   return rect;
 }
Example #29
0
 public static int getColumnAtPos(TreeItem item, int x, int y) {
   int columnCount = item.getParent().getColumnCount();
   for (int i = 0; i < columnCount; i++) {
     Rectangle rect = item.getBounds(i);
     if (rect.contains(x, y)) {
       return i;
     }
   }
   return -1;
 }
 private void refreshProposalSize() {
   if (contentProposalAdapter != null) {
     Rectangle maxSize =
         new Rectangle(0, 0, MAX_WIDTH_PROPOSAL_STYLED_TEXT, MAX_HEIGHT_PROPOSAL_STYLED_TEXT);
     Rectangle boundsStyledText = StyledTextHandler.this.getStyledText().getBounds();
     Rectangle intersect = boundsStyledText.intersection(maxSize);
     Point sizeProposal = new Point(intersect.width, intersect.height);
     contentProposalAdapter.setPopupSize(sizeProposal);
   }
 }