public CFFreeSwitchSwingAuditActionAttrJPanel(
      ICFFreeSwitchSwingSchema argSchema, ICFSecurityAuditActionObj argFocus) {
    super();
    JLabel label;
    JComponent compo;
    CFJReferenceEditor reference;
    final String S_ProcName = "construct-schema-focus";
    if (argSchema == null) {
      throw CFLib.getDefaultExceptionFactory()
          .newNullArgumentException(getClass(), S_ProcName, 1, "argSchema");
    }
    // argFocus is optional; focus may be set later during execution as
    // conditions of the runtime change.
    swingSchema = argSchema;
    setSwingFocusAsAuditAction(argFocus);
    final int spacing = 5;
    int y = spacing;
    final int height = 25;
    final int textheight = 80;
    final int vspacing = height + spacing;
    final int textvspacing = textheight + spacing;
    final int labelx = spacing;
    final int labelwidth = 200;
    final int fieldx = labelx + labelwidth + spacing;
    final int fieldwidth = 785;
    final int panelwidth = fieldx + fieldwidth + spacing;
    // temporary -- I think you have to have a panel bigger than the coordinates initially
    setSize(panelwidth, 100000);

    label = getSwingLabelAuditActionId();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorAuditActionId();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelDescription();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorDescription();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    // Now we can set the proper size based on the fields and references populated
    setSize(panelwidth, y);
    Dimension pfsz = new Dimension(panelwidth, y);
    setPreferredSize(pfsz);
    Dimension min = new Dimension(400, y);
    setMinimumSize(min);
    populateFields();
    adjustComponentEnableStates();
    swingIsInitializing = false;
  }
Пример #2
0
    @Override
    public void doLayout() {
      Rectangle bounds = getBounds();
      myBaseDocControl.setBounds(new Rectangle(0, 0, bounds.width, bounds.height));

      int x = bounds.width;
      for (JComponent button : myButtons) {
        Dimension buttonSize = button.getPreferredSize();
        x -= buttonSize.width;
        button.setBounds(x, 0, buttonSize.width, buttonSize.height);
        x -= BUTTON_HGAP;
      }
    }
 /** This moves the <code>JComponent</code> and repaints the damaged areas. */
 public void setBoundsForFrame(JComponent f, int newX, int newY, int newWidth, int newHeight) {
   boolean didResize = (f.getWidth() != newWidth || f.getHeight() != newHeight);
   f.setBounds(newX, newY, newWidth, newHeight);
   if (didResize) {
     f.validate();
   }
 }
 public void doLayout() {
   JComponent compo;
   Dimension sz = getSize();
   compo = getPanelMenuBar();
   compo.setBounds(0, 0, sz.width, 25);
   dataScrollPane.setBounds(0, 25, sz.width, sz.height - 25);
 }
Пример #5
0
    /**
     * Instructs the layout manager to perform the layout for the specified container.
     *
     * @param the Container for which this layout manager is being used
     */
    public void layoutContainer(Container parent) {
      JRootPane root = (JRootPane) parent;
      Rectangle b = root.getBounds();
      Insets i = root.getInsets();
      int nextY = 0;
      int w = b.width - i.right - i.left;
      int h = b.height - i.top - i.bottom;

      if (root.getLayeredPane() != null) {
        root.getLayeredPane().setBounds(i.left, i.top, w, h);
      }
      if (root.getGlassPane() != null) {
        root.getGlassPane().setBounds(i.left, i.top, w, h);
      }
      // Note: This is laying out the children in the layeredPane,
      // technically, these are not our children.
      if (root.getWindowDecorationStyle() != JRootPane.NONE
          && (root.getUI() instanceof RootPaneUI)) {
        JComponent titlePane = ((RootPaneUI) root.getUI()).getTitlePane();
        if (titlePane != null) {
          Dimension tpd = titlePane.getPreferredSize();
          if (tpd != null) {
            int tpHeight = tpd.height;
            titlePane.setBounds(0, 0, w, tpHeight);
            nextY += tpHeight;
          }
        }
      }

      if (root.getContentPane() != null) {

        root.getContentPane().setBounds(0, nextY, w, h < nextY ? 0 : h - nextY);
      }
    }
Пример #6
0
  /** Records a new size. Called by the AWT. */
  public void setBounds(int x, int y, int width, int height) {
    Insets insets = getInsets();
    int w;
    int h;

    if (source == null) {
      w = width;
      h = height;
    } else {
      w = source.getWidth();
      h = source.getHeight();

      if (width < w) {
        w = width;
      }

      if (height < h) {
        h = height;
      }
    }

    componentWidth = w + insets.left + insets.right;
    componentHeight = h + insets.top + insets.bottom;

    super.setBounds(x + shift_x, y + shift_y, componentWidth, componentHeight);
  }
  public void doLayout() {
    JLabel label;
    JComponent compo;
    CFJReferenceEditor reference;
    Dimension dim;
    final int spacing = 5;
    int y = spacing;
    final int height = 25;
    final int textheight = 80;
    final int vspacing = height + spacing;
    final int textvspacing = textheight + spacing;
    final int labelx = spacing;
    final int labelwidth = 200;
    final int fieldx = labelx + labelwidth + spacing;
    final int fieldwidth = 1024;
    Dimension jpsz = getSize();
    int usefieldwidth = jpsz.width - 215;

    label = getSwingLabelOwnerTenant();
    label.setBounds(labelx, y, labelwidth, height);
    reference = getSwingReferenceOwnerTenant();
    reference.setBounds(fieldx, y, usefieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelId();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorId();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelDescription();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorDescription();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;
  }
 private static void validateIfNeeded(final JComponent c, final Rectangle rect) {
   if (!Splitter.isNull(c)) {
     if (!c.getBounds().equals(rect)) {
       c.setBounds(rect);
       c.revalidate();
     }
   } else {
     Splitter.hideNull(c);
   }
 }
Пример #9
0
 private void addRow(String label, JComponent component) {
   JLabel l = new JLabel(label);
   l.setFont(Theme.SMALL_BOLD_FONT);
   l.setBounds(18, y, 400, 18);
   add(l);
   y += 18;
   int componentHeight = (int) component.getPreferredSize().getHeight();
   component.setBounds(16, y, 400, componentHeight);
   y += componentHeight;
   y += 2; // vertical gap
   add(component);
 }
Пример #10
0
 public void setBounds(int x, int y, int width, int height) {
   this.width = width;
   this.height = height;
   if (width > 0 && height > 0) {
     Image newim = createImage(width, height);
     offscreen = newim.getGraphics();
     clearCanvas();
     if (im != null) {
       offscreen.drawImage(im, 0, 0, this);
     }
     im = newim;
   }
   super.setBounds(x, y, width, height);
   repaint();
 }
Пример #11
0
  void test(JComponent c) {
    c.setEnabled(false);
    c.setOpaque(true);
    c.setBackground(TEST_COLOR);
    c.setBorder(null);
    Dimension size = c.getPreferredSize();
    c.setBounds(0, 0, size.width, size.height);

    BufferedImage image = new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_ARGB);
    c.paint(image.getGraphics());

    int rgb = TEST_COLOR.getRGB();
    for (int i = 0; i < size.height; i++) {
      for (int j = 0; j < size.width; j++) {
        if (image.getRGB(j, i) != rgb) {
          throw new RuntimeException(String.format("Color mismatch at [%d, %d]", j, i));
        }
      }
    }
  }
Пример #12
0
  public void doLayout() {
    if (getLayout() != null) {
      // A layout manager has been set, so delegate to it
      super.doLayout();
      return;
    }

    Dimension d = getSize();
    Insets i = getInsets();

    if (collapsed) {
      if (label != null) {
        Dimension p = label.getPreferredSize();
        label.setBounds(
            i.left, i.top + (d.height - i.top - i.bottom - p.height) / 2, p.width, p.height);
      }
    } else {
      if (comp != null) {
        comp.setBounds(i.left, i.top, d.width - i.left - i.right, d.height - i.top - i.bottom);
      }
    }
  }
Пример #13
0
  public void layoutContainer(Container parent) {
    Insets insets = parent.insets();
    int ncomponents = parent.countComponents();
    int nrows = getRows();
    int ncols = getColumns();
    int hgap = getHgap();
    int vgap = getVgap();

    if (nrows > 0) {
      ncols = (ncomponents + nrows - 1) / nrows;
    } else {
      nrows = (ncomponents + ncols - 1) / ncols;
    }

    // Set heights
    int x;
    int y;
    int nFills = 0;
    boolean[] fills = new boolean[nrows];
    int lastFillRow = -1;
    int nComps = parent.getComponentCount();

    y = insets.top;
    for (int row = 0; row < nrows; row++) {
      // Find largest minimum height for this row
      int h = 0;
      for (int col = 0; col < ncols; col++) {
        if (row * ncols + col < nComps) {
          Component c = parent.getComponent(row * ncols + col);
          h = Math.max(h, c.getMinimumSize().height);
        }
      }
      // Set heights for this row
      x = insets.left;
      for (int col = 0; col < ncols; col++) {
        if (row * ncols + col < nComps) {
          JComponent c = (JComponent) parent.getComponent(row * ncols + col);
          int w = c.getWidth();
          c.setBounds(x, y, w, h);
          x += w + hgap;
          if (col == 0 && getFillRow(c)) {
            fills[row] = true;
          }
        }
      }
      y += h + vgap;
      if (fills[row]) {
        nFills++;
        lastFillRow = row;
      }
    }

    // Fill heights
    if (nFills > 0 && y < parent.getHeight()) {
      // How much height to add
      int hAdd = (parent.getHeight() - y) / nFills;
      int hAdded = 0;
      for (int row = 0; row < nrows; row++) {
        if (fills[row]) {
          if (row == lastFillRow) {
            // Compensate for rounding error
            hAdd = parent.getHeight() - (y + hAdded);
          }
          for (int col = 0; col < ncols; col++) {
            if (row * ncols + col < nComps) {
              Component c = parent.getComponent(row * ncols + col);
              Rectangle b = c.getBounds();
              c.setBounds(b.x, b.y + hAdded, b.width, b.height + hAdd);
            }
          }
          hAdded += hAdd;
        }
      }
    }

    // Set widths
    nFills = 0;
    fills = new boolean[ncols];
    int lastFillCol = -1;

    x = insets.left;
    for (int col = 0; col < ncols; col++) {
      // Find largest minimum width for this column
      int w = 0;
      for (int row = 0; row < nrows; row++) {
        if (row * ncols + col < nComps) {
          Component c = parent.getComponent(row * ncols + col);
          w = Math.max(w, c.getMinimumSize().width);
        }
      }
      // Set widths for this column
      y = insets.top;
      for (int row = 0; row < nrows; row++) {
        if (row * ncols + col < nComps) {
          JComponent c = (JComponent) parent.getComponent(row * ncols + col);
          int h = c.getHeight();
          c.setBounds(x, y, w, h);
          y += h + vgap;
          if (row == 0 && getFillColumn(c)) {
            fills[col] = true;
          }
        }
      }
      x += w + hgap;
      if (fills[col]) {
        nFills++;
        lastFillCol = col;
      }
    }

    // Fill widths
    if (nFills > 0 && x < parent.getWidth()) {
      // How much width to add
      int wAdd = (parent.getWidth() - x) / nFills;
      int wAdded = 0;
      for (int col = 0; col < ncols; col++) {
        if (fills[col]) {
          if (col == lastFillCol) {
            wAdd = parent.getWidth() - (x + wAdded);
          }
          for (int row = 0; row < nrows; row++) {
            if (row * ncols + col < nComps) {
              Component c = parent.getComponent(row * ncols + col);
              Rectangle b = c.getBounds();
              c.setBounds(b.x + wAdded, b.y, b.width + wAdd, b.height);
            }
          }
          wAdded += wAdd;
        }
      }
    }
  }
  protected void layout1024() {

    // 640x480, Creative camera for layout1024
    size_x = 1024;
    size_y = 768;
    sizeCaptureWindow_x = 680;
    sizeCaptureWindow_y = 480;
    cwLocation_x = cwLocation_y = 0;

    // Borders in relation to a normal screen (not the rotated)
    int border_top, border_left, border_right, border_bottom;
    border_top = border_bottom = border_left = 50 * 2; // Top, left, right when rotated
    border_right = 80 * 2; // Bottom when rotated

    txt_location_x = border_left;
    txt_location_y = border_top;
    txt_size_x = 18;
    txt_size_y = size_y - border_bottom - txt_location_y;

    imagepanels = new WebcamCaptureAndFadeImagePanel[1];
    imagepanels[0] =
        new WebcamCaptureAndFadeImagePanel(
            1,
            1,
            // Size of each image frame in x direction
            size_x - border_left - border_right,
            // Size of each image frame in y direction
            size_y - border_top - border_bottom);

    // setSize(size_x, size_y);

    setLayout(null);

    JComponent jcomp =
        new JComponent() {

          /** */
          private static final long serialVersionUID = 1L;

          @Override
          protected void paintComponent(Graphics g) {

            Graphics2D g2 = (Graphics2D) g;

            g2.setColor(Color.white);
            g2.fillRect(0, 0, size_x, size_y);

            super.paintComponent(g);
          }
        };
    datetext = new rotatedText2("");

    add(datetext);
    datetext.setBounds(size_x - 35, 10, 40, 100);

    add(jcomp);
    jcomp.setBounds(0, 0, size_x, size_y);

    add(imagepanels[0]);
    imagepanels[0].setBounds(
        border_top,
        border_left,
        size_x - border_right - border_left,
        size_y - border_top - border_bottom);

    enable_datetext = true;
    enable_forceNewImage = true;
    captureWindow = true;
    number_of_frames_redborder = -1;

    // Set capture window at center of the screen
    cwLocation_x = (size_x / 2) - (sizeCaptureWindow_x / 2);
    cwLocation_y = (size_y / 2) - (sizeCaptureWindow_y / 2);

    setSize(size_x, size_y);
    setBounds(0, 0, 200, 200);
    setPreferredSize(new Dimension(size_x, size_y));
  }
Пример #15
0
 /**
  * Reshape the receiver. The offscreen Image is destroyed, the component is laid out and
  * repainted.
  *
  * @see java.awt.Component
  * @see layoutComponent
  */
 public void setBounds(int x, int y, int width, int height) {
   super.setBounds(x, y, width, height);
   layoutComponent();
   repaint();
 }
Пример #16
0
 @Override
 public void setBounds(int x, int y, int width, int height) {
   super.setBounds(x, y, width, height);
   relayout();
 }
  private void dragFrameFaster(JComponent f, int newX, int newY) {

    Rectangle previousBounds =
        new Rectangle(currentBounds.x, currentBounds.y, currentBounds.width, currentBounds.height);

    // move the frame
    currentBounds.x = newX;
    currentBounds.y = newY;

    if (didDrag) {
      // Only initiate cleanup if we have actually done a drag.
      emergencyCleanup(f);
    } else {
      didDrag = true;
      // We reset the danger field as until now we haven't actually
      // moved the internal frame so we don't need to initiate repaint.
      ((JInternalFrame) f).danger = false;
    }

    boolean floaterCollision = isFloaterCollision(previousBounds, currentBounds);

    // System.out.println(previousBounds);
    JComponent parent = (JComponent) f.getParent();
    Rectangle visBounds = previousBounds.intersection(desktopBounds);
    //  System.out.println(previousBounds);

    // System.out.println(visBounds);

    RepaintManager currentManager = RepaintManager.currentManager(f);

    currentManager.beginPaint();
    try {
      if (!floaterCollision) {
        currentManager.copyArea(
            parent,
            desktopGraphics,
            visBounds.x,
            visBounds.y,
            visBounds.width,
            visBounds.height,
            newX - previousBounds.x,
            newY - previousBounds.y,
            true);
      }

      f.setBounds(currentBounds);

      if (floaterCollision) {
        // since we couldn't blit we just redraw as fast as possible
        // the isDragging mucking is to avoid activating emergency
        // cleanup
        ((JInternalFrame) f).isDragging = false;
        parent.paintImmediately(currentBounds);
        ((JInternalFrame) f).isDragging = true;
      }

      // fake out the repaint manager.  We'll take care of everything

      currentManager.markCompletelyClean(parent);
      currentManager.markCompletelyClean(f);

      // compute the minimal newly exposed area
      // if the rects intersect then we use computeDifference.  Otherwise
      // we'll repaint the entire previous bounds
      Rectangle[] dirtyRects = null;
      if (previousBounds.intersects(currentBounds)) {
        dirtyRects = SwingUtilities.computeDifference(previousBounds, currentBounds);
      } else {
        dirtyRects = new Rectangle[1];
        dirtyRects[0] = previousBounds;
        //  System.out.println("no intersection");
      }
      ;

      // Fix the damage
      for (int i = 0; i < dirtyRects.length; i++) {
        parent.paintImmediately(dirtyRects[i]);
      }

      // new areas of blit were exposed
      if (!(visBounds.equals(previousBounds))) {
        dirtyRects = SwingUtilities.computeDifference(previousBounds, desktopBounds);
        for (int i = 0; i < dirtyRects.length; i++) {
          dirtyRects[i].x += newX - previousBounds.x;
          dirtyRects[i].y += newY - previousBounds.y;
          ((JInternalFrame) f).isDragging = false;

          parent.paintImmediately(dirtyRects[i]);
          ((JInternalFrame) f).isDragging = true;

          // System.out.println(dirtyRects[i]);
        }
      }
    } finally {
      currentManager.endPaint();
    }

    // update window if it's non-opaque
    Window topLevel = SwingUtilities.getWindowAncestor(f);
    Toolkit tk = Toolkit.getDefaultToolkit();
    if (!AWTAccessor.getWindowAccessor().isOpaque(topLevel)
        && (tk instanceof SunToolkit)
        && ((SunToolkit) tk).needUpdateWindow()) {
      AWTAccessor.getWindowAccessor().updateWindow(topLevel);
    }
  }
  public CFFreeSwitchSwingPbxIvrMenuAttrJPanel(
      ICFFreeSwitchSwingSchema argSchema, ICFFreeSwitchPbxIvrMenuObj argFocus) {
    super();
    JLabel label;
    JComponent compo;
    CFJReferenceEditor reference;
    final String S_ProcName = "construct-schema-focus";
    if (argSchema == null) {
      throw CFLib.getDefaultExceptionFactory()
          .newNullArgumentException(getClass(), S_ProcName, 1, "argSchema");
    }
    // argFocus is optional; focus may be set later during execution as
    // conditions of the runtime change.
    swingSchema = argSchema;
    setSwingFocusAsPbxIvrMenu(argFocus);
    final int spacing = 5;
    int y = spacing;
    final int height = 25;
    final int textheight = 80;
    final int vspacing = height + spacing;
    final int textvspacing = textheight + spacing;
    final int labelx = spacing;
    final int labelwidth = 200;
    final int fieldx = labelx + labelwidth + spacing;
    final int fieldwidth = 785;
    final int panelwidth = fieldx + fieldwidth + spacing;
    // temporary -- I think you have to have a panel bigger than the coordinates initially
    setSize(panelwidth, 100000);

    label = getSwingLabelContainerTenant();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    reference = getSwingReferenceContainerTenant();
    add(reference);
    reference.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelMenuId();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorMenuId();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelName();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorName();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelGreetLong();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorGreetLong();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelGreetShort();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorGreetShort();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelInvalidSound();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorInvalidSound();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelExitSound();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorExitSound();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelTimeout();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorTimeout();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelInterDigitTimeout();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorInterDigitTimeout();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelMaxFailures();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorMaxFailures();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelMaxTimeouts();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorMaxTimeouts();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelDigitLen();
    add(label);
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorDigitLen();
    add(compo);
    compo.setBounds(fieldx, y, fieldwidth, height);
    y = y + vspacing;

    // Now we can set the proper size based on the fields and references populated
    setSize(panelwidth, y);
    Dimension pfsz = new Dimension(panelwidth, y);
    setPreferredSize(pfsz);
    Dimension min = new Dimension(400, y);
    setMinimumSize(min);
    populateFields();
    adjustComponentEnableStates();
    swingIsInitializing = false;
  }
  public void doLayout() {
    JLabel label;
    JComponent compo;
    CFJReferenceEditor reference;
    Dimension dim;
    final int spacing = 5;
    int y = spacing;
    final int height = 25;
    final int textheight = 80;
    final int vspacing = height + spacing;
    final int textvspacing = textheight + spacing;
    final int labelx = spacing;
    final int labelwidth = 200;
    final int fieldx = labelx + labelwidth + spacing;
    final int fieldwidth = 1024;
    Dimension jpsz = getSize();
    int usefieldwidth = jpsz.width - 215;

    label = getSwingLabelContainerTenant();
    label.setBounds(labelx, y, labelwidth, height);
    reference = getSwingReferenceContainerTenant();
    reference.setBounds(fieldx, y, usefieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelMenuId();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorMenuId();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelName();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorName();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelGreetLong();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorGreetLong();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelGreetShort();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorGreetShort();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelInvalidSound();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorInvalidSound();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelExitSound();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorExitSound();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelTimeout();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorTimeout();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelInterDigitTimeout();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorInterDigitTimeout();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelMaxFailures();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorMaxFailures();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelMaxTimeouts();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorMaxTimeouts();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelDigitLen();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorDigitLen();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;
  }
  /**
   * Shows the hint in the layered pane. Coordinates <code>x</code> and <code>y</code> are in <code>
   * parentComponent</code> coordinate system. Note that the component appears on 250 layer.
   */
  @Override
  public void show(
      @NotNull final JComponent parentComponent,
      final int x,
      final int y,
      final JComponent focusBackComponent,
      @NotNull final HintHint hintHint) {
    myParentComponent = parentComponent;
    myHintHint = hintHint;

    myFocusBackComponent = focusBackComponent;

    LOG.assertTrue(myParentComponent.isShowing());
    myEscListener = new MyEscListener();
    myComponent.registerKeyboardAction(
        myEscListener,
        KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0),
        JComponent.WHEN_IN_FOCUSED_WINDOW);
    myComponent.registerKeyboardAction(
        myEscListener, KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), JComponent.WHEN_FOCUSED);
    final JLayeredPane layeredPane = parentComponent.getRootPane().getLayeredPane();

    myComponent.validate();

    if (!myForceShowAsPopup
        && (myForceLightweightPopup
            || fitsLayeredPane(
                layeredPane,
                myComponent,
                new RelativePoint(parentComponent, new Point(x, y)),
                hintHint))) {
      beforeShow();
      final Dimension preferredSize = myComponent.getPreferredSize();

      if (hintHint.isAwtTooltip()) {
        IdeTooltip tooltip =
            new IdeTooltip(
                hintHint.getOriginalComponent(),
                hintHint.getOriginalPoint(),
                myComponent,
                hintHint,
                myComponent) {
              @Override
              protected boolean canAutohideOn(TooltipEvent event) {
                if (event.getInputEvent() instanceof MouseEvent) {
                  return !(hintHint.isContentActive() && event.isIsEventInsideBalloon());
                } else if (event.getAction() != null) {
                  return false;
                } else {
                  return true;
                }
              }

              @Override
              protected void onHidden() {
                fireHintHidden();
                TooltipController.getInstance().resetCurrent();
              }

              @Override
              public boolean canBeDismissedOnTimeout() {
                return false;
              }
            }.setToCenterIfSmall(hintHint.isMayCenterTooltip())
                .setPreferredPosition(hintHint.getPreferredPosition())
                .setHighlighterType(hintHint.isHighlighterType())
                .setTextForeground(hintHint.getTextForeground())
                .setTextBackground(hintHint.getTextBackground())
                .setBorderColor(hintHint.getBorderColor())
                .setBorderInsets(hintHint.getBorderInsets())
                .setFont(hintHint.getTextFont())
                .setCalloutShift(hintHint.getCalloutShift())
                .setPositionChangeShift(
                    hintHint.getPositionChangeX(), hintHint.getPositionChangeY())
                .setExplicitClose(hintHint.isExplicitClose())
                .setHint(true);
        myComponent.validate();
        myCurrentIdeTooltip =
            IdeTooltipManager.getInstance()
                .show(tooltip, hintHint.isShowImmediately(), hintHint.isAnimationEnabled());
      } else {
        final Point layeredPanePoint =
            SwingUtilities.convertPoint(parentComponent, x, y, layeredPane);
        myComponent.setBounds(
            layeredPanePoint.x, layeredPanePoint.y, preferredSize.width, preferredSize.height);
        layeredPane.add(myComponent, JLayeredPane.POPUP_LAYER);

        myComponent.validate();
        myComponent.repaint();
      }
    } else {
      myIsRealPopup = true;
      Point actualPoint = new Point(x, y);
      JComponent actualComponent = new OpaquePanel(new BorderLayout());
      actualComponent.add(myComponent, BorderLayout.CENTER);
      if (isAwtTooltip()) {
        fixActualPoint(actualPoint);

        int inset = BalloonImpl.getNormalInset();
        actualComponent.setBorder(new LineBorder(hintHint.getTextBackground(), inset));
        actualComponent.setBackground(hintHint.getTextBackground());
        actualComponent.validate();
      }

      myPopup =
          JBPopupFactory.getInstance()
              .createComponentPopupBuilder(actualComponent, myFocusRequestor)
              .setRequestFocus(myFocusRequestor != null)
              .setFocusable(myFocusRequestor != null)
              .setResizable(myResizable)
              .setMovable(myTitle != null)
              .setTitle(myTitle)
              .setModalContext(false)
              .setShowShadow(isRealPopup() && !isForceHideShadow())
              .setCancelKeyEnabled(false)
              .setCancelOnClickOutside(myCancelOnClickOutside)
              .setCancelCallback(
                  new Computable<Boolean>() {
                    @Override
                    public Boolean compute() {
                      onPopupCancel();
                      return true;
                    }
                  })
              .setCancelOnOtherWindowOpen(myCancelOnOtherWindowOpen)
              .createPopup();

      beforeShow();
      myPopup.show(new RelativePoint(myParentComponent, new Point(actualPoint.x, actualPoint.y)));
    }
  }
 private void shakeEditor(JComponent parent, int dx, int dy, boolean dir) {
   final Rectangle bounds = parent.getBounds();
   parent.setBounds(
       bounds.x + (dir ? -dx : dx), bounds.y + (dir ? -dy : dy), bounds.width, bounds.height);
 }
  public void doLayout() {
    JLabel label;
    JComponent compo;
    CFJReferenceEditor reference;
    Dimension dim;
    final int spacing = 5;
    int y = spacing;
    final int height = 25;
    final int textheight = 80;
    final int vspacing = height + spacing;
    final int textvspacing = textheight + spacing;
    final int labelx = spacing;
    final int labelwidth = 200;
    final int fieldx = labelx + labelwidth + spacing;
    final int fieldwidth = 1024;
    Dimension jpsz = getSize();
    int usefieldwidth = jpsz.width - 215;

    label = getSwingLabelId();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorId();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelISOCode();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorISOCode();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelName();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorName();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelUnitSymbol();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorUnitSymbol();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelFracSymbol();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorFracSymbol();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelPrecis();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorPrecis();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;
  }
  public void doLayout() {
    JLabel label;
    JComponent compo;
    CFJReferenceEditor reference;
    Dimension dim;
    final int spacing = 5;
    int y = spacing;
    final int height = 25;
    final int textheight = 80;
    final int vspacing = height + spacing;
    final int textvspacing = textheight + spacing;
    final int labelx = spacing;
    final int labelwidth = 200;
    final int fieldx = labelx + labelwidth + spacing;
    final int fieldwidth = 1024;
    Dimension jpsz = getSize();
    int usefieldwidth = jpsz.width - 215;

    label = getSwingLabelContainerSecUser();
    label.setBounds(labelx, y, labelwidth, height);
    reference = getSwingReferenceContainerSecUser();
    reference.setBounds(fieldx, y, usefieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelParentSecProxy();
    label.setBounds(labelx, y, labelwidth, height);
    reference = getSwingReferenceParentSecProxy();
    reference.setBounds(fieldx, y, usefieldwidth, height);
    y = y + vspacing;

    label = getSwingLabelSecSessionId();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorSecSessionId();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelSecDevName();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorSecDevName();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelStart();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorStart();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;

    label = getSwingLabelFinish();
    label.setBounds(labelx, y, labelwidth, height);
    compo = getSwingEditorFinish();
    dim = compo.getMaximumSize();
    if (dim.width < usefieldwidth) {
      compo.setBounds(fieldx, y, dim.width, height);
    } else {
      compo.setBounds(fieldx, y, fieldwidth, height);
    }
    y = y + vspacing;
  }
Пример #24
0
  public static void main(String args[]) {
    JComponent ch = new JComponent() {};
    ch.getAccessibleContext();
    ch.isFocusTraversable();
    ch.setEnabled(false);
    ch.setEnabled(true);
    ch.requestFocus();
    ch.requestFocusInWindow();
    ch.getPreferredSize();
    ch.getMaximumSize();
    ch.getMinimumSize();
    ch.contains(1, 2);
    Component c1 = ch.add(new Component() {});
    Component c2 = ch.add(new Component() {});
    Component c3 = ch.add(new Component() {});
    Insets ins = ch.getInsets();
    ch.getAlignmentY();
    ch.getAlignmentX();
    ch.getGraphics();
    ch.setVisible(false);
    ch.setVisible(true);
    ch.setForeground(Color.red);
    ch.setBackground(Color.red);
    for (String font : Toolkit.getDefaultToolkit().getFontList()) {
      for (int j = 8; j < 17; j++) {
        Font f1 = new Font(font, Font.PLAIN, j);
        Font f2 = new Font(font, Font.BOLD, j);
        Font f3 = new Font(font, Font.ITALIC, j);
        Font f4 = new Font(font, Font.BOLD | Font.ITALIC, j);

        ch.setFont(f1);
        ch.setFont(f2);
        ch.setFont(f3);
        ch.setFont(f4);

        ch.getFontMetrics(f1);
        ch.getFontMetrics(f2);
        ch.getFontMetrics(f3);
        ch.getFontMetrics(f4);
      }
    }
    ch.enable();
    ch.disable();
    ch.reshape(10, 10, 10, 10);
    ch.getBounds(new Rectangle(1, 1, 1, 1));
    ch.getSize(new Dimension(1, 2));
    ch.getLocation(new Point(1, 2));
    ch.getX();
    ch.getY();
    ch.getWidth();
    ch.getHeight();
    ch.isOpaque();
    ch.isValidateRoot();
    ch.isOptimizedDrawingEnabled();
    ch.isDoubleBuffered();
    ch.getComponentCount();
    ch.countComponents();
    ch.getComponent(1);
    ch.getComponent(2);
    Component[] cs = ch.getComponents();
    ch.getLayout();
    ch.setLayout(new FlowLayout());
    ch.doLayout();
    ch.layout();
    ch.invalidate();
    ch.validate();
    ch.remove(0);
    ch.remove(c2);
    ch.removeAll();
    ch.preferredSize();
    ch.minimumSize();
    ch.getComponentAt(1, 2);
    ch.locate(1, 2);
    ch.getComponentAt(new Point(1, 2));
    ch.isFocusCycleRoot(new Container());
    ch.transferFocusBackward();
    ch.setName("goober");
    ch.getName();
    ch.getParent();
    ch.getGraphicsConfiguration();
    ch.getTreeLock();
    ch.getToolkit();
    ch.isValid();
    ch.isDisplayable();
    ch.isVisible();
    ch.isShowing();
    ch.isEnabled();
    ch.enable(false);
    ch.enable(true);
    ch.enableInputMethods(false);
    ch.enableInputMethods(true);
    ch.show();
    ch.show(false);
    ch.show(true);
    ch.hide();
    ch.getForeground();
    ch.isForegroundSet();
    ch.getBackground();
    ch.isBackgroundSet();
    ch.getFont();
    ch.isFontSet();
    Container c = new Container();
    c.add(ch);
    ch.getLocale();
    for (Locale locale : Locale.getAvailableLocales()) ch.setLocale(locale);

    ch.getColorModel();
    ch.getLocation();

    boolean exceptions = false;
    try {
      ch.getLocationOnScreen();
    } catch (IllegalComponentStateException e) {
      exceptions = true;
    }
    if (!exceptions)
      throw new RuntimeException("IllegalComponentStateException did not occur when expected");

    ch.location();
    ch.setLocation(1, 2);
    ch.move(1, 2);
    ch.setLocation(new Point(1, 2));
    ch.getSize();
    ch.size();
    ch.setSize(1, 32);
    ch.resize(1, 32);
    ch.setSize(new Dimension(1, 32));
    ch.resize(new Dimension(1, 32));
    ch.getBounds();
    ch.bounds();
    ch.setBounds(10, 10, 10, 10);
    ch.setBounds(new Rectangle(10, 10, 10, 10));
    ch.isLightweight();
    ch.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
    ch.getCursor();
    ch.isCursorSet();
    ch.inside(1, 2);
    ch.contains(new Point(1, 2));
    ch.isFocusable();
    ch.setFocusable(true);
    ch.setFocusable(false);
    ch.transferFocus();
    ch.getFocusCycleRootAncestor();
    ch.nextFocus();
    ch.transferFocusUpCycle();
    ch.hasFocus();
    ch.isFocusOwner();
    ch.toString();
    ch.setComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT);
    ch.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
    ch.setComponentOrientation(ComponentOrientation.UNKNOWN);
    ch.getComponentOrientation();
  }