static void rand() // 중복되지 않는 랜덤 숫자배열 두개 만들기 { int su = 0; // 난수 발생시 저장할 변수 boolean bDash = false; // 중복여부 확인 for (int i = 0; i < 75; i++) { bDash = true; while (bDash) // 난수발생, 중복 학인 { su = (int) (Math.random() * 75) + 1; // 판 크기+10개(상대가 못맞출 수도 있게)의 난수 입력 bDash = false; for (int j = 0; j < i; j++) { if (numArr1[j] == su) { bDash = true; // 중복이 있으면 멈추고 while문을 다시 수행(랜덤값을 다시 줌) break; } } } numArr1[i] = su; } for (int i = 0; i < 75; i++) { bDash = true; while (bDash) // 난수발생, 중복 학인 { su = (int) (Math.random() * 75) + 1; // 판 크기+10개(상대가 못맞출 수도 있게)의 난수 입력 bDash = false; for (int j = 0; j < i; j++) { if (numArr2[j] == su) { bDash = true; // 중복이 있으면 멈추고 while문을 다시 수행(랜덤값을 다시 줌) break; } } } numArr2[i] = su; } }
/** Start the background thread. */ public void start() { // create a random list of cities cities = new City[TravelingSalesman.CITY_COUNT]; for (int i = 0; i < TravelingSalesman.CITY_COUNT; i++) { cities[i] = new City( (int) (Math.random() * (getBounds().width - 10)), (int) (Math.random() * (getBounds().height - 60))); } // create the initial chromosomes chromosomes = new Chromosome[TravelingSalesman.POPULATION_SIZE]; for (int i = 0; i < TravelingSalesman.POPULATION_SIZE; i++) { chromosomes[i] = new Chromosome(cities); chromosomes[i].setCut(cutLength); chromosomes[i].setMutation(TravelingSalesman.MUTATION_PERCENT); } Chromosome.sortChromosomes(chromosomes, TravelingSalesman.POPULATION_SIZE); // start up the background thread started = true; map.update(map.getGraphics()); generation = 0; if (worker != null) worker = null; worker = new Thread(this); // worker.setPriority(Thread.MIN_PRIORITY); worker.start(); }
// the following method added for LegacyTristateCheckBox protected void drawSquare(Component c, Graphics g, int x, int y) { final int w = Math.min(getIconWidth(), getIconHeight()); final int h = Math.min(getIconWidth(), getIconHeight()); int xMargin = w / 3; int yMargin = h / 3; g.fillRect(x + xMargin, y + yMargin, w - xMargin * 2, h - yMargin * 2); }
public void acceptMinimumSize(Component c) { Dimension minimumSize = getMinimumSize(c); c.setMinimumSize( new Dimension( Math.max(minimumSize.width, c.getMinimumSize().width), Math.max(minimumSize.height, c.getMinimumSize().height))); }
/* * Adjust the width of the scrollpane used by the popup */ protected void popupWider(BasicComboPopup popup) { JList list = popup.getList(); // Determine the maximimum width to use: // a) determine the popup preferred width // b) limit width to the maximum if specified // c) ensure width is not less than the scroll pane width int popupWidth = list.getPreferredSize().width + 5 // make sure horizontal scrollbar doesn't appear + getScrollBarWidth(popup, scrollPane); if (maximumWidth != -1) { popupWidth = Math.min(popupWidth, maximumWidth); } Dimension scrollPaneSize = scrollPane.getPreferredSize(); popupWidth = Math.max(popupWidth, scrollPaneSize.width); // Adjust the width scrollPaneSize.width = popupWidth; scrollPane.setPreferredSize(scrollPaneSize); scrollPane.setMaximumSize(scrollPaneSize); }
/** * Ensures that the specified line and offset is visible by scrolling the text area if necessary. * * @param line The line to scroll to * @param offset The offset in the line to scroll to * @return True if scrolling was actually performed, false if the line and offset was already * visible */ public boolean scrollTo(int line, int offset) { // visibleLines == 0 before the component is realized // we can't do any proper scrolling then, so we have // this hack... if (visibleLines == 0) { setFirstLine(Math.max(0, line - electricScroll)); return true; } int newFirstLine = firstLine; int newHorizontalOffset = horizontalOffset; if (line < firstLine + electricScroll) { newFirstLine = Math.max(0, line - electricScroll); } else if (line + electricScroll >= firstLine + visibleLines) { newFirstLine = (line - visibleLines) + electricScroll + 1; if (newFirstLine + visibleLines >= getLineCount()) newFirstLine = getLineCount() - visibleLines; if (newFirstLine < 0) newFirstLine = 0; } int x = _offsetToX(line, offset); int width = painter.getFontMetrics().charWidth('w'); if (x < 0) { newHorizontalOffset = Math.min(0, horizontalOffset - x + width + 5); } else if (x + width >= painter.getWidth()) { newHorizontalOffset = horizontalOffset + (painter.getWidth() - x) - width - 5; } return setOrigin(newFirstLine, newHorizontalOffset); }
@NotNull private Dimension expandIfNecessary(@NotNull Dimension base) { if (base.width >= myMinWidth && base.height >= myMinHeight) { return base; } return new Dimension(Math.max(myMinWidth, base.width), Math.max(myMinHeight, base.height)); }
public void paint(Graphics gg) { int faceSize = Math.min(getWidth() - 4, getHeight() - 4); if (face == null) face = new PADFaceMapped( Math.max(2, (getWidth() - faceSize) / 2), Math.max(2, (getHeight() - faceSize) / 2), faceSize); if (buffer == null) { im = this.createImage(getWidth(), getHeight()); buffer = im.getGraphics(); } super.paint(buffer); buffer.setColor(new Color(255, 255, 255, 0)); buffer.fillRect(0, 0, im.getWidth(null), im.getHeight(null)); face.setDimensions( Math.max(2, (getWidth() - faceSize) / 2), Math.max(2, (getHeight() - faceSize) / 2), faceSize); face.paint(buffer); // draw buffer to screen gg.drawImage(im, 0, 0, null, null); }
@Override public Dimension getPreferredSize() { Dimension windowSize = DiffUtil.getDefaultDiffWindowSize(); Dimension size = super.getPreferredSize(); return new Dimension( Math.max(windowSize.width, size.width), Math.max(windowSize.height, size.height)); }
/** * the structure function of TetrisUI * * @param none */ public TetrisUI() { Random rdm = new Random(); m_blockStyle = Math.abs(rdm.nextInt()) % 7 + 1; cTetrisBlock = new TetrisBlock(100, 0, m_blockStyle, 0); //// System.out.println("block style " + m_blockStyle); cNextBlockDC = new DrawNextBlockComponent(); rdm = new Random(); // set next block style setBlockStyle(Math.abs(rdm.nextInt()) % 7 + 1); // set the next block game dc getNextBlockDC().setNextBlockStyle(getBlockStyle()); m_blockGrid = new int[GRID_Y][GRID_X]; // the param of control isCoordinateLock = false; isKeyPressed = false; isTransforStart = false; isGameStart = false; isGameOver = false; isNextReady = false; m_userScore = 0; // set text m_lTotalScore.setText(Integer.toString(m_userScore)); m_bGameHalt.setEnabled(false); for (int j = 0; j < GRID_Y; j++) for (int k = 0; k < GRID_X; k++) m_blockGrid[j][k] = 0; isGameHalt = false; }
/** * Stores the position and size of the bouncing box that would be painted for the current * animation index in <code>r</code> and returns <code>r</code>. Subclasses that add to the * painting performed in this class's implementation of <code>paintIndeterminate</code> -- to draw * an outline around the bouncing box, for example -- can use this method to get the location of * the bouncing box that was just painted. By overriding this method, you have complete control * over the size and position of the bouncing box, without having to reimplement <code> * paintIndeterminate</code>. * * @param r the Rectangle instance to be modified; may be <code>null</code> * @return <code>null</code> if no box should be drawn; otherwise, returns the passed-in rectangle * (if non-null) or a new rectangle * @see #setAnimationIndex * @since 1.4 */ protected Rectangle getBox(Rectangle r) { int currentFrame = getAnimationIndex(); int middleFrame = numFrames / 2; if (sizeChanged() || delta == 0.0 || maxPosition == 0.0) { updateSizes(); } r = getGenericBox(r); if (r == null) { return null; } if (middleFrame <= 0) { return null; } // assert currentFrame >= 0 && currentFrame < numFrames if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) { if (currentFrame < middleFrame) { r.x = componentInnards.x + (int) Math.round(delta * (double) currentFrame); } else { r.x = maxPosition - (int) Math.round(delta * (currentFrame - middleFrame)); } } else { // VERTICAL indeterminate progress bar if (currentFrame < middleFrame) { r.y = componentInnards.y + (int) Math.round(delta * currentFrame); } else { r.y = maxPosition - (int) Math.round(delta * (currentFrame - middleFrame)); } } return r; }
private void generateLookupTables() { mySat = new float[myWidth * myHeight]; myHues = new float[myWidth * myHeight]; myAlphas = new int[myWidth * myHeight]; float radius = getRadius(); // blend is used to create a linear alpha gradient of two extra pixels float blend = (radius + 2f) / radius - 1f; // Center of the color wheel circle int cx = myWidth / 2; int cy = myHeight / 2; for (int x = 0; x < myWidth; x++) { int kx = x - cx; // Kartesian coordinates of x int squarekx = kx * kx; // Square of kartesian x for (int y = 0; y < myHeight; y++) { int ky = cy - y; // Kartesian coordinates of y int index = x + y * myWidth; mySat[index] = (float) Math.sqrt(squarekx + ky * ky) / radius; if (mySat[index] <= 1f) { myAlphas[index] = 0xff000000; } else { myAlphas[index] = (int) ((blend - Math.min(blend, mySat[index] - 1f)) * 255 / blend) << 24; mySat[index] = 1f; } if (myAlphas[index] != 0) { myHues[index] = (float) (Math.atan2(ky, kx) / Math.PI / 2d); } } } }
public Dimension getDocumentSize() { float pageViewWidth = 0; float pageViewHeight = 0; if (pagesPanel != null) { int currCompIndex = documentViewController.getCurrentPageIndex(); int numComponents = pagesPanel.getComponentCount(); if (currCompIndex >= 0 && currCompIndex < numComponents) { Component comp = pagesPanel.getComponent(currCompIndex); if (comp instanceof PageViewDecorator) { PageViewDecorator pvd = (PageViewDecorator) comp; Dimension dim = pvd.getPreferredSize(); pageViewWidth = dim.width; pageViewHeight = dim.height; } } } // normalize the dimensions to a zoom level of zero. float currentZoom = documentViewModel.getViewZoom(); pageViewWidth = Math.abs(pageViewWidth / currentZoom); pageViewHeight = Math.abs(pageViewHeight / currentZoom); // add any horizontal padding from layout manager pageViewWidth += AbstractDocumentView.horizontalSpace * 2; pageViewHeight += AbstractDocumentView.verticalSpace * 2; return new Dimension((int) pageViewWidth, (int) pageViewHeight); }
public void mouseClicked(MouseEvent e) { int x; int y; e.consume(); if (mouseEventsEnabled) { x = Math.round(e.getX() / scale); y = Math.round(e.getY() / scale); // allow for the canvas margin y -= margin; // System.out.println("Mouse Click: (" + x + ", " + y + ")"); if (e.getClickCount() < 2) { if (nativeSelectItem(x, y)) { parentFTAFrame.updateFrame(); } } else { if (nativeSelectItem(x, y)) { parentFTAFrame.updateFrame(); } editSelected(); parentFTAFrame.updateFrame(); } if (focusEventsEnabled) { // tell the main Canvas to point to this coordinate parentFTAFrame.setCanvasFocus(x, y); } } }
private long normalizeMax(long l) { int exp = (int) Math.log10((double) l); long multiple = (long) Math.pow(10.0, exp); int i = (int) (l / multiple); l = (i + 1) * multiple; return l; }
/** * Computes and plots correlation functions * * @param tauMax is the maximum time for correlation functions */ public void computeCorrelation(int tauMax) { plotFrame.clearData(); double energyAccumulator = 0, magnetizationAccumulator = 0; double energySquaredAccumulator = 0, magnetizationSquaredAccumulator = 0; for (int t = 0; t < numberOfPoints; t++) { energyAccumulator += energy[t]; magnetizationAccumulator += magnetization[t]; energySquaredAccumulator += energy[t] * energy[t]; magnetizationSquaredAccumulator += magnetization[t] * magnetization[t]; } double averageEnergySquared = Math.pow(energyAccumulator / numberOfPoints, 2); double averageMagnetizationSquared = Math.pow(magnetizationAccumulator / numberOfPoints, 2); // compute normalization factors double normE = (energySquaredAccumulator / numberOfPoints) - averageEnergySquared; double normM = (magnetizationSquaredAccumulator / numberOfPoints) - averageMagnetizationSquared; for (int tau = 1; tau <= tauMax; tau++) { double c_MAccumulator = 0; double c_EAccumulator = 0; int counter = 0; for (int t = 0; t < numberOfPoints - tau; t++) { c_MAccumulator += magnetization[t] * magnetization[t + tau]; c_EAccumulator += energy[t] * energy[t + tau]; counter++; } // correlation function defined so that c(0) = 1 and c(infinity) -> 0 plotFrame.append(0, tau, ((c_MAccumulator / counter) - averageMagnetizationSquared) / normM); plotFrame.append(1, tau, ((c_EAccumulator / counter) - averageEnergySquared) / normE); } plotFrame.setVisible(true); }
/** * Damages the area surrounding the caret to cause it to be repainted in a new location. If * paint() is reimplemented, this method should also be reimplemented. This method should update * the caret bounds (x, y, width, and height). * * @param r the current location of the caret * @see #paint */ @Override protected synchronized void damage(final Rectangle r) { if (r == null || fPainting) return; x = r.x - 4; y = r.y; width = 10; height = r.height; // Don't damage the border area. We can't paint a partial border, so get the // intersection of the caret rectangle and the component less the border, if any. final Rectangle caretRect = new Rectangle(x, y, width, height); final Border border = getComponent().getBorder(); if (border != null) { final Rectangle alloc = getComponent().getBounds(); alloc.x = alloc.y = 0; final Insets borderInsets = border.getBorderInsets(getComponent()); alloc.x += borderInsets.left; alloc.y += borderInsets.top; alloc.width -= borderInsets.left + borderInsets.right; alloc.height -= borderInsets.top + borderInsets.bottom; Rectangle2D.intersect(caretRect, alloc, caretRect); } x = caretRect.x; y = caretRect.y; width = Math.max(caretRect.width, 1); height = Math.max(caretRect.height, 1); repaint(); }
@Override public void actionPerformed(ActionEvent e) { if (firstClick) { firstClick = false; lastIcon = buttons[0][0].getIcon(); buttons[0][0].setIcon(null); for (int i = 0; i < 10000; i++) { int zufallY = (int) ((Math.random() * YY) + 0); int zufallX = (int) ((Math.random() * XX) + 0); switchButton(zufallY, zufallX); } // ToDo: unwiederrufbare Operationen vermeiden? // funktion klären und abfangen /*while(lastButton % XX != 0) switchButton(lastButton-1); while (lastButton != "00") switchButton(lastButton-XX);*/ } else { PuzzButton tmp = (PuzzButton) e.getSource(); int posY = tmp.getPosY(); int posX = tmp.getPosX(); switchButton(posY, posX); if (isDone()) { buttons[0][0].setIcon(lastIcon); firstClick = true; } } }
private void setColumnPreferredSize() { for (int i = 0; i < getColumnCount(); i++) { TableColumn column = getColumnModel().getColumn(i); if (i == AbstractVcsLogTableModel.ROOT_COLUMN) { // thin stripe or nothing int rootWidth = myUI.getColorManager().isMultipleRoots() ? ROOT_INDICATOR_WIDTH : 0; // NB: all further instructions and their order are important, otherwise the minimum size // which is less than 15 won't be applied column.setMinWidth(rootWidth); column.setMaxWidth(rootWidth); column.setPreferredWidth(rootWidth); } else if (i == AbstractVcsLogTableModel .COMMIT_COLUMN) { // let commit message occupy as much as possible column.setPreferredWidth(Short.MAX_VALUE); } else if (i == AbstractVcsLogTableModel.AUTHOR_COLUMN) { // detect author with the longest name // to avoid querying the last row (it would lead to full graph loading) int maxRowsToCheck = Math.min(MAX_ROWS_TO_CALC_WIDTH, getRowCount() - MAX_ROWS_TO_CALC_OFFSET); if (maxRowsToCheck < 0) { // but if the log is small, check all of them maxRowsToCheck = getRowCount(); } int contentWidth = calcMaxContentColumnWidth(i, maxRowsToCheck); column.setMinWidth(Math.min(contentWidth, MAX_DEFAULT_AUTHOR_COLUMN_WIDTH)); column.setWidth(column.getMinWidth()); } else if (i == AbstractVcsLogTableModel.DATE_COLUMN) { // all dates have nearly equal sizes Font tableFont = UIManager.getFont("Table.font"); column.setMinWidth( getFontMetrics(tableFont) .stringWidth("mm" + DateFormatUtil.formatDateTime(new Date()))); column.setWidth(column.getMinWidth()); } } }
/** * Draws an open star with a specified number of points.<br> * The center of this star is specified by centerX,centerY and its size is specified by radius * <br> * (As in the radius of the circle the star would fit inside). <br> * Precondition: points >= 2 <br> * Example: <br> * Expo.drawStar(g,300,200,100,8); <br> * Draws an open star with 8 points and a radius of 100 pixels whose center is located at the * coordinate (300,200). */ public static void drawStar(Graphics g, int centerX, int centerY, int radius, int points) { int halfRadius = getHalfRadius(radius, points); int p = points; points *= 2; int xCoord[] = new int[points]; int yCoord[] = new int[points]; int currentRadius; for (int k = 0; k < points; k++) { if (k % 2 == 0) currentRadius = radius; else currentRadius = halfRadius; xCoord[k] = (int) Math.round(Math.cos(twoPI * k / points - halfPI) * currentRadius) + centerX; yCoord[k] = (int) Math.round(Math.sin(twoPI * k / points - halfPI) * currentRadius) + centerY; } int x = (p - 5) / 2 + 1; if (p >= 5 && p <= 51) switch (p % 4) { case 1: yCoord[x] = yCoord[x + 1] = yCoord[points - x - 1] = yCoord[points - x]; break; case 2: yCoord[x] = yCoord[x + 1] = yCoord[points - x - 1] = yCoord[points - x]; yCoord[x + 3] = yCoord[x + 4] = yCoord[points - x - 4] = yCoord[points - x - 3]; break; case 3: yCoord[x + 2] = yCoord[x + 3] = yCoord[points - x - 3] = yCoord[points - x - 2]; } g.drawPolygon(xCoord, yCoord, points); }
/** * Returns a list of pairs of x coordinates for visual ranges representing given logical range. If * <code>startOffset == endOffset</code>, a pair of equal numbers is returned, corresponding to * target position. Target offsets are supposed to be located on the same visual line. */ private TFloatArrayList logicalRangeToVisualRanges(int startOffset, int endOffset) { assert startOffset <= endOffset; TFloatArrayList result = new TFloatArrayList(); for (VisualLineFragmentsIterator.Fragment fragment : VisualLineFragmentsIterator.create(myView, startOffset, false)) { int minOffset = fragment.getMinOffset(); int maxOffset = fragment.getMaxOffset(); if (startOffset == endOffset) { if (startOffset >= minOffset && startOffset <= maxOffset) { float x = fragment.offsetToX(startOffset); result.add(x); result.add(x); break; } } else if (startOffset < maxOffset && endOffset > minOffset) { float x1 = fragment.offsetToX(Math.max(minOffset, startOffset)); float x2 = fragment.offsetToX(Math.min(maxOffset, endOffset)); if (x1 > x2) { float tmp = x1; x1 = x2; x2 = tmp; } if (result.isEmpty() || x1 > result.get(result.size() - 1)) { result.add(x1); result.add(x2); } else { result.set(result.size() - 1, x2); } } } return result; }
/** * Scroll to the error specified by the given tree path, or do nothing if no error is specified. * * @param treePath the tree path to scroll to. */ private void scrollToError(final TreePath treePath) { final DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) treePath.getLastPathComponent(); if (treeNode == null || !(treeNode.getUserObject() instanceof ResultTreeNode)) { return; } final ResultTreeNode nodeInfo = (ResultTreeNode) treeNode.getUserObject(); if (nodeInfo.getFile() == null || nodeInfo.getProblem() == null) { return; // no problem here :-) } final VirtualFile virtualFile = nodeInfo.getFile().getVirtualFile(); if (virtualFile == null || !virtualFile.exists()) { return; } final FileEditorManager fileEditorManager = FileEditorManager.getInstance(project); final FileEditor[] editor = fileEditorManager.openFile(virtualFile, true); if (editor.length > 0 && editor[0] instanceof TextEditor) { final LogicalPosition problemPos = new LogicalPosition(Math.max(lineFor(nodeInfo) - 1, 0), Math.max(columnFor(nodeInfo), 0)); final Editor textEditor = ((TextEditor) editor[0]).getEditor(); textEditor.getCaretModel().moveToLogicalPosition(problemPos); textEditor.getScrollingModel().scrollToCaret(ScrollType.CENTER); } }
/** * Ensures that the caret is visible by scrolling the text area if necessary. * * @return True if scrolling was actually performed, false if the caret was already visible */ public boolean scrollToCaret() { int line = getCaretLine(); int lineStart = getLineStartOffset(line); int offset = Math.max(0, Math.min(getLineLength(line) - 1, getCaretPosition() - lineStart)); return scrollTo(line, offset); }
/** * Writes the <code>shape</code>, <code>coords</code>, <code>href</code>, * <code>nohref</code> Attribute for the specified figure and ellipse. * * @return Returns true, if the circle is inside of the image bounds. */ private boolean writeCircleAttributes(IXMLElement elem, SVGFigure f, Ellipse2D.Double ellipse) { AffineTransform t = TRANSFORM.getClone(f); if (t == null) { t = drawingTransform; } else { t.preConcatenate(drawingTransform); } if ((t.getType() & (AffineTransform.TYPE_UNIFORM_SCALE | AffineTransform.TYPE_TRANSLATION)) == t.getType() && ellipse.width == ellipse.height ) { Point2D.Double start = new Point2D.Double(ellipse.x, ellipse.y); Point2D.Double end = new Point2D.Double(ellipse.x + ellipse.width, ellipse.y + ellipse.height); t.transform(start, start); t.transform(end, end); ellipse.x = Math.min(start.x, end.x); ellipse.y = Math.min(start.y, end.y); ellipse.width = Math.abs(start.x - end.x); ellipse.height = Math.abs(start.y - end.y); elem.setAttribute("shape", "circle"); elem.setAttribute("coords", (int) (ellipse.x + ellipse.width / 2d)+","+ (int) (ellipse.y + ellipse.height / 2d)+","+ (int) (ellipse.width / 2d) ); writeHrefAttribute(elem, f); return bounds.intersects(ellipse.getBounds()); } else { return writePolyAttributes(elem, f, (Shape) ellipse); } }
/** * Write the given text string in the current font, centered on (x, y) and rotated by the * specified number of degrees * * @param x the center x-coordinate of the text * @param y the center y-coordinate of the text * @param s the text * @param degrees is the number of degrees to rotate counterclockwise */ public static void text(double x, double y, String s, double degrees) { double xs = scaleX(x); double ys = scaleY(y); offscreen.rotate(Math.toRadians(-degrees), xs, ys); text(x, y, s); offscreen.rotate(Math.toRadians(+degrees), xs, ys); }
// Proceso para posicionar las imagenes en el concentrece public void cargarImagenes() { int x, y = 0; int numero = -1; double x1, y1 = 0; ficha = new int[a][b]; // Incializacion de la matriz entera en -1 for (int i = 0; i < getA(); i++) { for (int j = 0; j < getB(); j++) { ficha[i][j] = -1; } } // Proceso de introduccion de imagenes en posiciones aleatorias para // obtener mas variaciones del juego for (int i = 0; i < getA(); i++) { for (int j = 0; j < getB(); j++) { do { x1 = Math.random() * getA(); y1 = Math.random() * getB(); x = (int) x1; y = (int) y1; } while (ficha[x][y] != -1); numero++; if (numero == getC()) { numero = 0; } ficha[x][y] = numero; parejas[i][j].setIcon(vacio); } } }
public int FindRandomSize(int max, int min) { int range = Math.abs(max - min) + 1; int random_number = (int) (Math.random() * range) + (min <= max ? min : max); return random_number; }
/** * Calculates the maximum size dimensions for the specified panal given the components in the * specified parent container. */ public Dimension maximumLayoutSize(Container target) { synchronized (target.getTreeLock()) { Dimension dim = new Dimension(0, 0); int size = actions.size(); if ((grip != null) && grip.isVisible()) { Dimension d = grip.getPreferredSize(); dim.width += d.width; dim.width += hgap; } Component last = null; for (int i = 0; i < size; i++) { Component comp = (Component) actions.elementAt(i); if (comp.isVisible()) { Dimension d = comp.getPreferredSize(); dim.width += d.width; dim.height = Math.max(dim.height, d.height); dim.width += hgap; last = comp; } } if (last != null) { Dimension prefSize = last.getPreferredSize(); Dimension maxSize = last.getMaximumSize(); if (prefSize != maxSize) { dim.width = dim.width - prefSize.width + maxSize.width; dim.height = Math.max(dim.height, maxSize.height); } } Insets insets = target.getInsets(); dim.width += insets.left + insets.right; dim.height += insets.top + insets.bottom; return dim; } }
public Object down(Message msg) { Address dest = msg.getDest(); boolean multicast = dest == null; if (msg.getSrc() == null) msg.setSrc(localAddress()); if (discard_all) { if (dest == null || dest.equals(localAddress())) loopback(msg); return null; } if (!multicast && drop_down_unicasts > 0) { drop_down_unicasts = Math.max(0, drop_down_unicasts - 1); return null; } if (multicast && drop_down_multicasts > 0) { drop_down_multicasts = Math.max(0, drop_down_multicasts - 1); return null; } if (down > 0) { double r = Math.random(); if (r < down) { if (excludeItself && dest != null && dest.equals(localAddress())) { if (log.isTraceEnabled()) log.trace("excluding itself"); } else { log.trace("dropping message"); num_down++; return null; } } } return down_prot.down(msg); }
public void blockgen() { Component temporaryLostComponent = null; pos[0] = 0; pos[1] = 1; rand = (int) (Math.floor(Math.random() * 7 + 1)); centralx = 4; centraly = 0; System.out.print(rand); if ((b[4 + prof[pos[0]][0][rand - 1].x][prof[pos[0]][0][rand - 1].y].getBackground() == Color.DARK_GRAY) && (b[4 + prof[pos[0]][1][rand - 1].x][prof[pos[0]][1][rand - 1].y].getBackground() == Color.DARK_GRAY) && (b[4 + prof[pos[0]][2][rand - 1].x][prof[pos[0]][2][rand - 1].y].getBackground() == Color.DARK_GRAY) && (b[4 + prof[pos[0]][3][rand - 1].x][prof[pos[0]][3][rand - 1].y].getBackground() == Color.DARK_GRAY)) { b[4 + prof[pos[0]][0][rand - 1].x][prof[pos[0]][0][rand - 1].y].setBackground(rnd[rand - 1]); b[4 + prof[pos[0]][1][rand - 1].x][prof[pos[0]][1][rand - 1].y].setBackground(rnd[rand - 1]); b[4 + prof[pos[0]][2][rand - 1].x][prof[pos[0]][2][rand - 1].y].setBackground(rnd[rand - 1]); b[4 + prof[pos[0]][3][rand - 1].x][prof[pos[0]][3][rand - 1].y].setBackground(rnd[rand - 1]); go(); } else { JOptionPane.showMessageDialog( temporaryLostComponent, "Game Over! You cleared " + rowsclrd + " rows, well done!"); System.exit(0); } }