Java Code Examples for java.awt.Rectangle#intersects()

/**
 * Prepare the entity views for drawing. Must be called only from the event
 * dispatch thread.
 *
 * @param area visible area
 * @param setVisibleArea inform the entities about the visible area. This
 * 	should be only done when the whole screen is drawn
 */
void prepareViews(Rectangle area, boolean setVisibleArea) {
	visibleViews.clear();
	synchronized (views) {
		for (EntityView<IEntity> view : views) {
			view.applyChanges();
			if (area.intersects(view.getArea())) {
				visibleViews.add(view);
				if (setVisibleArea) {
					view.setVisibleScreenArea(area);
				}
			}
		}
	}

	Collections.sort(visibleViews, entityViewComparator);
}
 

/**
 * Paint the sheet.
 */
public void process ()
{
    sigPainter = getSigPainter();

    if (!sheet.getSystems().isEmpty()) {
        for (SystemInfo system : sheet.getSystems()) {
            // Check whether this system is visible
            Rectangle bounds = system.getBounds();

            if ((bounds != null) && ((clip == null) || bounds.intersects(clip))) {
                processSystem(system);
            }
        }
    }
}
 

@Override
public void renderLine (Graphics2D g)
{
    Rectangle clip = g.getClipBounds();

    if ((clip == null) || clip.intersects(getBounds())) {
        checkLine(); // To make sure the line has been computed

        if (line != null) {
            ///g.draw(line);
            g.draw(
                    new Line2D.Double(
                            line.getX1(),
                            line.getY1() + 0.5,
                            line.getX2() + 1,
                            line.getY2() + 0.5));
        }
    }
}
 

void select(int x, int y) {
   Rectangle selection = gp.getDotMarkRectangle();
   GraphNode[] nodes = gp.getModel().nodesArray();
   for(int i = 0; i < nodes.length; i++) {
     Component c = (Component)nodes[i].get(gp.COMPONENT);
     if(selection.intersects(c.getBounds(tmpRect)))
gp.getSelectionModel().add(nodes[i]);
   }
   iiuf.util.graph.GraphEdge[] edges = gp.getModel().edgesArray();
   for(int i = 0; i < edges.length; i++) {
     GraphEdge e = (GraphEdge)edges[i].get(gp.GRAPH_EDGE);
     if(e.intersectsWith(selection))
gp.getSelectionModel().add(edges[i]);      
   }
   gp.setDot(x, y);
   gp.setMark(x, y);
 }
 

/**
 * ���̃X�v���C�g�ƐڐG���Ă��邩
 * @param sprite �X�v���C�g
 */
public boolean isCollision(Sprite sprite) {
    Rectangle playerRect = new Rectangle((int)x, (int)y, width, height);
    Rectangle spriteRect = new Rectangle((int)sprite.getX(), (int)sprite.getY(), sprite.getWidth(), sprite.getHeight());
    // �����̋�`�Ƒ���̋�`���d�Ȃ��Ă��邩���ׂ�
    if (playerRect.intersects(spriteRect)) {
        return true;
    }
    
    return false;
}
 

@Override
public void paintComponent(Graphics g) {
  super.paintComponent(g);
  Graphics2D g2 = (Graphics2D) g;
  Rectangle clip = g2.getClipBounds();
  Rectangle r = new Rectangle(boxSize);
  for (int i = 0; i < elements.size(); i++) {
    r.x = (i % elementsPerRow) * r.width;
    r.y = (i / elementsPerRow) * r.height;
    if (r.intersects(clip)) {
      getThumbElement(i).paint(g2, r);
    }
  }
}
 

/**
 * Render the box area of a glyph, using inverted color.
 *
 * @param glyph the glyph whose area is to be rendered
 * @param g     the graphic context
 */
protected void renderGlyphArea (Glyph glyph,
                                Graphics2D g)
{
    // Check the clipping
    Rectangle box = glyph.getBounds();

    if ((box != null) && box.intersects(g.getClipBounds())) {
        g.fillRect(box.x, box.y, box.width, box.height);
    }
}
 

@Override
public void renderLine (Graphics2D g,
                        boolean showPoints,
                        double pointWidth)
{
    Rectangle clip = g.getClipBounds();

    if ((clip != null) && !clip.intersects(getBounds())) {
        return;
    }

    // The curved line itself
    if (spline != null) {
        g.draw(spline);
    }

    // Then the absolute defining points?
    if (showPoints && (points != null)) {
        // Point radius
        double r = pointWidth / 2;
        Ellipse2D ellipse = new Ellipse2D.Double();

        for (Point2D p : points) {
            ellipse.setFrame(p.getX() - r, p.getY() - r, 2 * r, 2 * r);

            Color oldColor = null;

            if (p.getClass() != Point2D.Double.class) {
                oldColor = g.getColor();
                g.setColor(Color.red);
            }

            g.fill(ellipse);

            if (oldColor != null) {
                g.setColor(oldColor);
            }
        }
    }
}
 

/**
 * Retrieve the gun at the given location.
 * @param mx the mouse X
 * @param my the mouse Y
 * @return the gun or null if empty
 */
GroundwarGun gunAt(int mx, int my) {
	Rectangle sel = new Rectangle(0, 0, commons.colony().selectionBoxLight.getWidth(), commons.colony().selectionBoxLight.getHeight());
	for (GroundwarGun g : guns) {
		Rectangle r = gunRectangle(g);
		Rectangle drawRect = new Rectangle((int)(r.x + (r.width - sel.getWidth()) / 2) + offsetX,
				(int)(r.y + (r.height - sel.getHeight()) / 2) + offsetY,
				sel.width, sel.height);
		if (drawRect.intersects(new Rectangle(mx, my, 1, 1))) {
			return g;
		}
	}
	return null;
}
 

public boolean visit (SystemInfo systemInfo)
{
    try {
        // Check that this system is visible
        Rectangle bounds = systemInfo.getBounds();

        if ((bounds == null) || !bounds.intersects(oldClip)) {
            return false;
        }

        // Determine proper font size for the system
        musicFont = MusicFont.getFont(scale.getInterline());

        g.setColor(defaultColor);

        // Ledgers
        for (Glyph glyph : systemInfo.getGlyphs()) {
            if ((glyph.getShape() == Shape.LEDGER) && glyph.isActive()) {
                // For very short ledgers, glyph line is not reliable
                renderLedger(g, glyph);
            }
        }

        // Endings
        for (Glyph ending : systemInfo.getEndings()) {
            ending.renderLine(g);
        }
    } catch (ConcurrentModificationException ignored) {
    } catch (Exception ex) {
        logger.warn(
                getClass().getSimpleName() + " Error visiting " + systemInfo,
                ex);
    }

    return true;
}
 

/**
 * ���̃X�v���C�g�ƐڐG���Ă��邩
 * @param sprite �X�v���C�g
 */
public boolean isCollision(Sprite sprite) {
    Rectangle playerRect = new Rectangle((int)x, (int)y, width, height);
    Rectangle spriteRect = new Rectangle((int)sprite.getX(), (int)sprite.getY(), sprite.getWidth(), sprite.getHeight());
    // �����̋�`�Ƒ���̋�`���d�Ȃ��Ă��邩���ׂ�
    if (playerRect.intersects(spriteRect)) {
        return true;
    }
    
    return false;
}
 

/**
 * Merge compatible clusters as much as possible.
 */
private void mergeClusters ()
{
    // Sort clusters according to their ordinate in page
    Collections.sort(clusters, ordinateComparator);

    for (LineCluster current : clusters) {
        LineCluster candidate = current;

        // Keep on working while we do have a candidate to check for merge
        CandidateLoop:
        while (true) {
            Wrapper<Integer> deltaPos = new Wrapper<>();
            Rectangle candidateBox = candidate.getBounds();
            candidateBox.grow(params.clusterXMargin, params.clusterYMargin);

            // Check the candidate vs all clusters until current excluded
            for (LineCluster head : clusters) {
                if (head == current) {
                    break CandidateLoop; // Actual end of sub list
                }

                if ((head == candidate) || (head.getParent() != null)) {
                    continue;
                }

                // Check rough proximity
                Rectangle headBox = head.getBounds();

                if (headBox.intersects(candidateBox)) {
                    // Try a merge
                    if (canMerge(head, candidate, deltaPos)) {
                        logger.debug("Merging {} with {} delta:{}",
                                candidate, head, deltaPos.value);

                        // Do the merge
                        candidate.mergeWith(head, deltaPos.value);

                        break;
                    }
                }
            }
        }
    }

    removeMergedClusters();
    removeMergedFilaments();
}
 

/**
 * Detect all cases where 2 Inters actually overlap while being in separate systems.
 *
 * @param aboves the collection of inters to process from system above
 * @param belows the collection of inters to process from system below
 */
private void detectCrossOverlaps (List<Inter> aboves,
                                  List<Inter> belows)
{
    Collections.sort(aboves, Inters.byAbscissa);
    Collections.sort(belows, Inters.byAbscissa);

    NextLeft:
    for (Inter above : aboves) {
        if (above.isRemoved()) {
            continue;
        }

        final Rectangle aboveBox = above.getBounds();

        final double xMax = aboveBox.getMaxX();

        for (Inter below : belows) {
            if (below.isRemoved()) {
                continue;
            }

            Rectangle belowBox = below.getBounds();

            if (aboveBox.intersects(belowBox)) {
                // Have a more precise look
                try {
                    if (above.overlaps(below) && below.overlaps(above)) {
                        Inter removedInter = resolveConflict(above, below);

                        if (removedInter == above) {
                            continue NextLeft;
                        }
                    }
                } catch (DeletedInterException diex) {
                    if (diex.inter == above) {
                        continue NextLeft;
                    }
                }
            } else if (belowBox.x > xMax) {
                break; // Since below list is sorted by abscissa
            }
        }
    }
}
 

/**
 * Paints the specified component.
 *
 * @param context context for the component being painted
 * @param g the {@code Graphics} object used for painting
 * @see #update(Graphics,JComponent)
 */
protected void paint(SynthContext context, Graphics g) {
    Rectangle clip = g.getClipBounds();

    Rectangle bounds = table.getBounds();
    // account for the fact that the graphics has already been translated
    // into the table's bounds
    bounds.x = bounds.y = 0;

    if (table.getRowCount() <= 0 || table.getColumnCount() <= 0 ||
            // this check prevents us from painting the entire table
            // when the clip doesn't intersect our bounds at all
            !bounds.intersects(clip)) {

        paintDropLines(context, g);
        return;
    }

    boolean ltr = table.getComponentOrientation().isLeftToRight();

    Point upperLeft = clip.getLocation();

    Point lowerRight = new Point(clip.x + clip.width - 1,
                                 clip.y + clip.height - 1);

    int rMin = table.rowAtPoint(upperLeft);
    int rMax = table.rowAtPoint(lowerRight);
    // This should never happen (as long as our bounds intersect the clip,
    // which is why we bail above if that is the case).
    if (rMin == -1) {
        rMin = 0;
    }
    // If the table does not have enough rows to fill the view we'll get -1.
    // (We could also get -1 if our bounds don't intersect the clip,
    // which is why we bail above if that is the case).
    // Replace this with the index of the last row.
    if (rMax == -1) {
        rMax = table.getRowCount()-1;
    }

    int cMin = table.columnAtPoint(ltr ? upperLeft : lowerRight);
    int cMax = table.columnAtPoint(ltr ? lowerRight : upperLeft);
    // This should never happen.
    if (cMin == -1) {
        cMin = 0;
    }
    // If the table does not have enough columns to fill the view we'll get -1.
    // Replace this with the index of the last column.
    if (cMax == -1) {
        cMax = table.getColumnCount()-1;
    }

    // Paint the cells.
    paintCells(context, g, rMin, rMax, cMin, cMax);

    // Paint the grid.
    // it is important to paint the grid after the cells, otherwise the grid will be overpainted
    // because in Synth cell renderers are likely to be opaque
    paintGrid(context, g, rMin, rMax, cMin, cMax);

    paintDropLines(context, g);
}
 

/**
 * Paints the specified component.
 *
 * @param context context for the component being painted
 * @param g the {@code Graphics} object used for painting
 * @see #update(Graphics,JComponent)
 */
protected void paint(SynthContext context, Graphics g) {
    Rectangle clip = g.getClipBounds();

    Rectangle bounds = table.getBounds();
    // account for the fact that the graphics has already been translated
    // into the table's bounds
    bounds.x = bounds.y = 0;

    if (table.getRowCount() <= 0 || table.getColumnCount() <= 0 ||
            // this check prevents us from painting the entire table
            // when the clip doesn't intersect our bounds at all
            !bounds.intersects(clip)) {

        paintDropLines(context, g);
        return;
    }

    boolean ltr = table.getComponentOrientation().isLeftToRight();

    Point upperLeft = clip.getLocation();

    Point lowerRight = new Point(clip.x + clip.width - 1,
                                 clip.y + clip.height - 1);

    int rMin = table.rowAtPoint(upperLeft);
    int rMax = table.rowAtPoint(lowerRight);
    // This should never happen (as long as our bounds intersect the clip,
    // which is why we bail above if that is the case).
    if (rMin == -1) {
        rMin = 0;
    }
    // If the table does not have enough rows to fill the view we'll get -1.
    // (We could also get -1 if our bounds don't intersect the clip,
    // which is why we bail above if that is the case).
    // Replace this with the index of the last row.
    if (rMax == -1) {
        rMax = table.getRowCount()-1;
    }

    int cMin = table.columnAtPoint(ltr ? upperLeft : lowerRight);
    int cMax = table.columnAtPoint(ltr ? lowerRight : upperLeft);
    // This should never happen.
    if (cMin == -1) {
        cMin = 0;
    }
    // If the table does not have enough columns to fill the view we'll get -1.
    // Replace this with the index of the last column.
    if (cMax == -1) {
        cMax = table.getColumnCount()-1;
    }

    // Paint the cells.
    paintCells(context, g, rMin, rMax, cMin, cMax);

    // Paint the grid.
    // it is important to paint the grid after the cells, otherwise the grid will be overpainted
    // because in Synth cell renderers are likely to be opaque
    paintGrid(context, g, rMin, rMax, cMin, cMax);

    paintDropLines(context, g);
}
 

/**
 * Paints the specified component.
 *
 * @param context context for the component being painted
 * @param g the {@code Graphics} object used for painting
 * @see #update(Graphics,JComponent)
 */
protected void paint(SynthContext context, Graphics g) {
    Rectangle clip = g.getClipBounds();

    Rectangle bounds = table.getBounds();
    // account for the fact that the graphics has already been translated
    // into the table's bounds
    bounds.x = bounds.y = 0;

    if (table.getRowCount() <= 0 || table.getColumnCount() <= 0 ||
            // this check prevents us from painting the entire table
            // when the clip doesn't intersect our bounds at all
            !bounds.intersects(clip)) {

        paintDropLines(context, g);
        return;
    }

    boolean ltr = table.getComponentOrientation().isLeftToRight();

    Point upperLeft = clip.getLocation();

    Point lowerRight = new Point(clip.x + clip.width - 1,
                                 clip.y + clip.height - 1);

    int rMin = table.rowAtPoint(upperLeft);
    int rMax = table.rowAtPoint(lowerRight);
    // This should never happen (as long as our bounds intersect the clip,
    // which is why we bail above if that is the case).
    if (rMin == -1) {
        rMin = 0;
    }
    // If the table does not have enough rows to fill the view we'll get -1.
    // (We could also get -1 if our bounds don't intersect the clip,
    // which is why we bail above if that is the case).
    // Replace this with the index of the last row.
    if (rMax == -1) {
        rMax = table.getRowCount()-1;
    }

    int cMin = table.columnAtPoint(ltr ? upperLeft : lowerRight);
    int cMax = table.columnAtPoint(ltr ? lowerRight : upperLeft);
    // This should never happen.
    if (cMin == -1) {
        cMin = 0;
    }
    // If the table does not have enough columns to fill the view we'll get -1.
    // Replace this with the index of the last column.
    if (cMax == -1) {
        cMax = table.getColumnCount()-1;
    }

    // Paint the cells.
    paintCells(context, g, rMin, rMax, cMin, cMax);

    // Paint the grid.
    // it is important to paint the grid after the cells, otherwise the grid will be overpainted
    // because in Synth cell renderers are likely to be opaque
    paintGrid(context, g, rMin, rMax, cMin, cMax);

    paintDropLines(context, g);
}
 

/**
 * Paints the specified component.
 *
 * @param context context for the component being painted
 * @param g the {@code Graphics} object used for painting
 * @see #update(Graphics,JComponent)
 */
protected void paint(SynthContext context, Graphics g) {
    Rectangle clip = g.getClipBounds();

    Rectangle bounds = table.getBounds();
    // account for the fact that the graphics has already been translated
    // into the table's bounds
    bounds.x = bounds.y = 0;

    if (table.getRowCount() <= 0 || table.getColumnCount() <= 0 ||
            // this check prevents us from painting the entire table
            // when the clip doesn't intersect our bounds at all
            !bounds.intersects(clip)) {

        paintDropLines(context, g);
        return;
    }

    boolean ltr = table.getComponentOrientation().isLeftToRight();

    Point upperLeft = clip.getLocation();

    Point lowerRight = new Point(clip.x + clip.width - 1,
                                 clip.y + clip.height - 1);

    int rMin = table.rowAtPoint(upperLeft);
    int rMax = table.rowAtPoint(lowerRight);
    // This should never happen (as long as our bounds intersect the clip,
    // which is why we bail above if that is the case).
    if (rMin == -1) {
        rMin = 0;
    }
    // If the table does not have enough rows to fill the view we'll get -1.
    // (We could also get -1 if our bounds don't intersect the clip,
    // which is why we bail above if that is the case).
    // Replace this with the index of the last row.
    if (rMax == -1) {
        rMax = table.getRowCount()-1;
    }

    int cMin = table.columnAtPoint(ltr ? upperLeft : lowerRight);
    int cMax = table.columnAtPoint(ltr ? lowerRight : upperLeft);
    // This should never happen.
    if (cMin == -1) {
        cMin = 0;
    }
    // If the table does not have enough columns to fill the view we'll get -1.
    // Replace this with the index of the last column.
    if (cMax == -1) {
        cMax = table.getColumnCount()-1;
    }

    // Paint the cells.
    paintCells(context, g, rMin, rMax, cMin, cMax);

    // Paint the grid.
    // it is important to paint the grid after the cells, otherwise the grid will be overpainted
    // because in Synth cell renderers are likely to be opaque
    paintGrid(context, g, rMin, rMax, cMin, cMax);

    paintDropLines(context, g);
}
 

/**
 * Create a bunch of Note instances for one note pack glyph.
 * A note pack is a glyph whose shape "contains" several notes, just like
 * a NOTEHEAD_BLACK_3 shape represents a vertical sequence of 3 heads.
 * Within a pack, notes are numbered by their vertical top down index,
 * counted from 0.
 *
 * <p>If we have 0 or 1 stem attached to the provided glyph, no specific
 * test is needed, all the note instances are created on the provided chord.
 * </p>
 *
 * <p>When the underlying glyph is stuck to 2 stems, we have to decide
 * which notes go to one stem (the left chord), which notes go to the other
 * (the right chord) and which notes go to both.
 * Every stem gets at least the vertically closest note.
 * At the end, to make sure that all notes from the initial pack are
 * actually assigned, we force the unassigned notes to the stem at hand.
 * </p>
 *
 * <p>(On the diagram below with a note pack of 3, the two upper notes
 * will go to the right stem, and the third note will go to the left stem).
 * </p>
 * <img src="doc-files/Note-Pack.png" alt="Pack of 3">
 *
 * <p>(On the diagram below with a note pack of 1, the "mirrored" note is
 * duplicated, one instance goes to the left stem and the other to the
 * right stem).
 * </p>
 * <img src="doc-files/Note-Pack-both.png" alt="Shared note">
 *
 * @param chord      the containing chord
 * @param glyph      the underlying glyph of the note pack
 * @param assigned   (input/output) the set of note indices assigned so far
 * @param completing true if all unassigned notes must be assigned now
 */
public static void createPack (Chord chord,
                               Glyph glyph,
                               Set<Integer> assigned,
                               boolean completing)
{
    // Number of "notes" to create (not counting the duplicates)
    final int card = packCardOf(glyph.getShape());

    final Glyph stem = chord.getStem();
    Rectangle stemBox = null;
    Scale scale = chord.getScale();

    // Variable stemSir exists only when we have a dual stem situation.
    // It gives the direction of the stem at hand (-1:down, +1:up)
    Integer stemDir = null;

    if (glyph.getStemNumber() >= 2) {
        stemBox = stem.getBounds();
        stemBox.grow(
                scale.toPixels(constants.maxStemDx),
                scale.toPixels(constants.maxMultiStemDy));
        stemDir = Integer.signum(glyph.getAreaCenter().y - stem.getAreaCenter().y);
    }

    // Index goes from top to bottom
    for (int i = 0; i < card; i++) {
        Rectangle itemBox = getItemBox(glyph, i, scale.getInterline());

        if (stemDir != null) {
            // Apply the stem test, except on the item closest to the stem
            if ((stemDir == 1 && i > 0)
                || (stemDir == -1 && i < card - 1)) {
                if (!itemBox.intersects(stemBox)) {
                    // Stem check failed.
                    // Force assignment if unassigned and this is the end.
                    if (assigned.contains(i) || !completing) {
                        continue;
                    }
                }
            }
        }

        Point center = new Point(
                itemBox.x + (itemBox.width / 2),
                itemBox.y + (itemBox.height / 2));
        glyph.addTranslation(new Note(chord, glyph, center, card, i));
        assigned.add(i);
    }
}
 

/** If needed, visually rearrange dialogViewer and dlg on screen.
 * If they overlap, try to make them not overlap.
 * @param dlg the visible modal dialog
 * @param dialogOrFrameViewer The viewer, a dialog of a frame.
 */
private void rearrange(Dialog dlg, Window dialogOrFrameViewer) {
    Rectangle r1 = dlg.getBounds();
    Rectangle r2 = dialogOrFrameViewer.getBounds();
    if (r1.intersects(r2)) {
        Installer.log.fine("modal dialog and dialog viewer overlap");
        Dimension s = Toolkit.getDefaultToolkit().getScreenSize();
        int xExtra = s.width - r1.width - r2.width;
        int yExtra = s.height - r1.height - r2.height;
        if(xExtra >= yExtra){
            //compare y axes of r1 and r2 to know how to relocate them - horizontal relocation
            int r1Yaxis = r1.x + (r1.width/2);
            int r2Yaxis = r2.x + (r2.width/2);
            if(r1Yaxis <= r2Yaxis) {
                Installer.log.fine(" send help to the right");
                if((r1.x + r1.width + r2.width) <= s.width) {
                    Installer.log.fine("there is enough place fo help");
                    r2.x = r1.x + r1.width;
                } else {
                    Installer.log.fine("there is not enough place");
                    if((r1.width + r2.width) < s.width) {
                        Installer.log.fine("relocate both");
                        r2.x = s.width - r2.width;
                        r1.x = r2.x - r1.width;
                    } else {
                        Installer.log.fine("relocate both and resize help");
                        r1.x = 0;
                        r2.x = r1.width;
                        r2.width = s.width - r1.width;
                    }
                }
            } else {
                Installer.log.fine("send help to the left");
                if((r1.x - r2.width) > 0) {
                    Installer.log.fine("there is enough place for help");
                    r2.x = r1.x - r2.width;
                } else {
                    Installer.log.fine("there is not enough place");
                    if((r1.width + r2.width) < s.width){
                        Installer.log.fine("relocate both");
                        r2.x = 0;
                        r1.x = r2.width;
                    } else {
                        Installer.log.fine("relocate both and resize help");
                        r1.x = s.width - r1.width;
                        r2.x = 0;
                        r2.width = r1.x;
                    }
                }
            }
        } else {
            //compare x axes of r1 and r2 to know how to relocate them
            int r1Xaxis = r1.y + (r1.height/2);
            int r2Xaxis = r2.y + (r2.height/2);
            if(r1Xaxis <= r2Xaxis) {
                Installer.log.fine(" send help to the bottom");
                if((r1.y + r1.height + r2.height) <= s.height) {
                    Installer.log.fine("there is enough place fo help");
                    r2.y = r1.y + r1.height;
                } else {
                    Installer.log.fine("there is not enough place");
                    if((r1.height + r2.height) < s.height) {
                        Installer.log.fine("relocate both");
                        r2.y = s.height - r2.height;
                        r1.y = r2.y - r1.height;
                    } else {
                        Installer.log.fine("relocate both and resize help");
                        r1.y = 0;
                        r2.y = r1.height;
                        r2.height = s.height - r1.height;
                    }
                }
            } else {
                Installer.log.fine("send help to the top");
                if((r1.y - r2.height) > 0){
                    Installer.log.fine("there is enough place for help");
                    r2.y = r1.y - r2.height;
                } else {
                    Installer.log.fine("there is not enough place");
                    if((r1.height + r2.height) < s.height) {
                        Installer.log.fine("relocate both");
                        r2.y = 0;
                        r1.y = r2.height;
                    } else {
                        Installer.log.fine("relocate both and resize help");
                        r1.y = s.height - r1.height;
                        r2.y = 0;  //or with -1
                        r2.height = r1.y;
                    }
                }
            }
        }
        dlg.setBounds(r1);
        dialogOrFrameViewer.setBounds(r2);
    }
}
 

protected boolean canDirectlyAccessGraphics() {
        // TODO: what about popup windows / tooltips???

        // TODO: some of the queries could be cached instead of polling,
        // for example isShowing(), isOpaque(), getParent() etc.

//////        // Shouldn't access graphics - no buffering would cause flickering
//////        if (bufferType == BUFFER_NONE) return false;

        // Cannot access graphics - there are some child components
        if (getComponentCount() != 0) return false;

        // Cannot access graphics - component doesn't fully control its area
        if (!isOpaque()) return false;

        // Cannot access graphics - not in Swing tree
        if (!(getParent() instanceof JComponent)) return false;

        // Cannot access graphics - component not showing, doesn't make sense
        if (!isShowing()) return false;

        // Cannot access graphics - component area is not up-to-date
        Rectangle dirtyRegion = RepaintManager.currentManager(this).
                                getDirtyRegion((JComponent)getParent());
        if (dirtyRegion != null && dirtyRegion.width > 0 &&
            dirtyRegion.height > 0) return false;

        // --- Reused from JViewport -------------------------------------------

        Rectangle clip = new Rectangle(0, 0, getWidth(), getHeight());
        Rectangle oldClip = new Rectangle();
        Rectangle tmp2 = null;
        Container parent;
        Component lastParent = null;
        int x, y, w, h;

        for (parent = this; parent != null && isLightweightComponent(parent); parent = parent.getParent()) {
            x = parent.getX();
            y = parent.getY();
            w = parent.getWidth();
            h = parent.getHeight();

            oldClip.setBounds(clip);
            SwingUtilities.computeIntersection(0, 0, w, h, clip);
            if (!clip.equals(oldClip)) return false;

            if (lastParent != null && parent instanceof JComponent &&
               !((JComponent)parent).isOptimizedDrawingEnabled()) {
                Component comps[] = parent.getComponents();
                int index = 0;

                for (int i = comps.length - 1 ;i >= 0; i--) {
                    if (comps[i] == lastParent) {
                    index = i - 1;
                    break;
                    }
                }

                while (index >= 0) {
                    tmp2 = comps[index].getBounds(tmp2);
                    if (tmp2.intersects(clip)) return false;
                    index--;
                }
            }
            clip.x += x;
            clip.y += y;
            lastParent = parent;
        }

        // No Window parent.
        if (parent == null) return false;

        return true;
    }