Java Code Examples for java.awt.Toolkit

public static void main(String[] args) {
    UIManager.put("swing.boldMetal", Boolean.FALSE);
    JDialog.setDefaultLookAndFeelDecorated(true);
    JFrame.setDefaultLookAndFeelDecorated(true);
    Toolkit.getDefaultToolkit().setDynamicLayout(true);
    System.setProperty("sun.awt.noerasebackground", "true");
    try {
        UIManager.setLookAndFeel(new MetalLookAndFeel());
    } catch (UnsupportedLookAndFeelException e) {
        System.out.println(
                "Metal Look & Feel not supported on this platform. \n"
                + "Program Terminated");
        System.exit(0);
    }
    JFrame frame = new MetalworksFrame();
    frame.setVisible(true);
}
 

private static void testMouseInfoPeer() {
    Toolkit toolkit = Toolkit.getDefaultToolkit();
    if (toolkit instanceof ComponentFactory) {
        ComponentFactory componentFactory = (ComponentFactory) toolkit;

        MouseInfoPeer mouseInfoPeer = componentFactory.getMouseInfoPeer();
        mouseInfoPeer.fillPointWithCoords(new Point());

        Window win = new Window(null);
        win.setSize(300, 300);
        win.setVisible(true);

        mouseInfoPeer.isWindowUnderMouse(win);
        win.dispose();
    }
}
 

/**
 * Instantiates a new JDialog as chart editor .
 *
 * @param dynForm the {@link DynForm}
 * @param startArgIndex the start argument index
 */
public ChartEditorJDialog(DynForm dynForm, int startArgIndex) {
	
	this.dynForm = dynForm;
	this.startArgIndex = startArgIndex;
	
	this.setModal(true);
	this.setSize(600, 450);
	this.setIconImage(imageAgentGUI);
	this.setTitle(Language.translate("Edit Chart", Language.EN));
	
	// --- center dialog --------------------
	Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); 
	int top = (screenSize.height - this.getHeight()) / 2; 
    int left = (screenSize.width - this.getWidth()) / 2; 
    this.setLocation(left, top);	


    this.setContentPane(this.getContentPane());
	this.getContentPane().add(getButtonPane(), BorderLayout.SOUTH);

}
 

@Override
protected void processEvent(AWTEvent evt) {
    int id = evt.getID();
    if (id != KeyEvent.KEY_TYPED) {
        super.processEvent(evt);
        return;
    }

    KeyEvent kevt = (KeyEvent) evt;
    char c = kevt.getKeyChar();

    // Digits, backspace, and delete are okay
    // Note that the minus sign is not allowed (neither is decimal)
    if (Character.isDigit(c) || (c == '\b') || (c == '\u007f')) {
        super.processEvent(evt);
        return;
    }

    Toolkit.getDefaultToolkit().beep();
    kevt.consume();
}
 

/**
 * Ukonanie akcji zwiazanej ze skrotem
 */
public void doAction() {
    // czy jest to skrót do przycisku
    // jeśli tak to wywoływany jest click
    if (button != null && button.isEnabled()) {
        button.doClick();

        // jest to skrót do komponentu
        // a więc ustawienie focuu
    } else if (component != null) {
        if (pane != null) {          // zmienie aktywnej zakladki
            pane.setSelectedIndex(tabIndex);
            Toolkit.getDefaultToolkit().sync();
        }
        component.grabFocus(); // ustawienie focusu
    } else if (action != null) {
        action.doAction(null, -1);
    }
}
 

/**
 * All pixels that have the specified color are rendered transparent.
 *
 * @param img
 *          the img
 * @param color
 *          the color
 * @return the image
 */
public static Image applyAlphaChannel(final Image img, final Color color) {
  if (color == null || img == null) {
    return img;
  }

  final ImageFilter filter = new RGBImageFilter() {

    // the color we are looking for... Alpha bits are set to opaque
    public final int markerRGB = color.getRGB() | 0xFF000000;

    @Override
    public final int filterRGB(final int x, final int y, final int rgb) {
      if ((rgb | 0xFF000000) == this.markerRGB) {
        // Mark the alpha bits as zero - transparent
        return 0x00FFFFFF & rgb;
      } else {
        // nothing to do
        return rgb;
      }
    }
  };

  final ImageProducer ip = new FilteredImageSource(img.getSource(), filter);
  return Toolkit.getDefaultToolkit().createImage(ip);
}
 

public void show(Point location) {
    Rectangle screenBounds = null;
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice[] gds = ge.getScreenDevices();
    for (GraphicsDevice device : gds) {
        GraphicsConfiguration gc = device.getDefaultConfiguration();
        screenBounds = gc.getBounds();
        if (screenBounds.contains(location)) {
            break;
        }
    }

    // showing the popup tooltip
    cp = new TooltipContentPanel(master.getTextComponent());

    Window w = SwingUtilities.windowForComponent(master.getTextComponent());
    contentWindow = new JWindow(w);
    contentWindow.add(cp);
    contentWindow.pack();
    Dimension dim = contentWindow.getSize();

    if (location.y + dim.height + SCREEN_BORDER > screenBounds.y + screenBounds.height) {
        dim.height = (screenBounds.y + screenBounds.height) - (location.y + SCREEN_BORDER);
    }
    if (location.x + dim.width + SCREEN_BORDER > screenBounds.x + screenBounds.width) {
        dim.width = (screenBounds.x + screenBounds.width) - (location.x + SCREEN_BORDER);
    }

    contentWindow.setSize(dim);

    contentWindow.setLocation(location.x, location.y - 1);  // slight visual adjustment
    contentWindow.setVisible(true);

    Toolkit.getDefaultToolkit().addAWTEventListener(this, AWTEvent.MOUSE_EVENT_MASK | AWTEvent.KEY_EVENT_MASK);
    w.addWindowFocusListener(this);
    contentWindow.addWindowFocusListener(this);
}
 

private void removePopup() {
    Toolkit.getDefaultToolkit().removeAWTEventListener(this);
    if (listPopup != null) {
        closeSubList();
        if( tooltipPopup != null )
            tooltipPopup.hide();
        tooltipPopup = null;
        listPopup.hide();
        if (hintListComponent != null) {
            hintListComponent.getView().removeMouseListener(this);
            hintListComponent.getView().removeMouseMotionListener(this);
        }
        if (errorTooltip != null) {
            errorTooltip.removeMouseListener(this);
        }
        hintListComponent = null;
        errorTooltip = null;
        listPopup = null;
        if (hintIcon != null)
            hintIcon.setToolTipText(NbBundle.getMessage(HintsUI.class, "HINT_Bulb")); // NOI18N
    }
}
 

/**
 * @param args the command line arguments
 * @throws java.awt.AWTException
 * @throws java.lang.InterruptedException
 * @throws java.io.IOException
 */
public static void main(String[] args) throws AWTException, InterruptedException, IOException {
    String stringfyCurrent = String.valueOf(System.currentTimeMillis());
    String path = "{path}";
    String name = "capture" + stringfyCurrent;
    String type = ".jpg";
    //--
    File file = new File(path + name + type);
    BufferedImage imagexd = new Robot().createScreenCapture(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ImageIO.write(imagexd, type.replace(".", ""), baos);
    byte[] bytes = baos.toByteArray();

    OutputStream out = new FileOutputStream(file);

    out.write(bytes);
    
}
 

private Dimension getDeviceDimension() {
    Dimension deviceDimension = null;
    try {
        Toolkit tool = Toolkit.getDefaultToolkit();
        deviceDimension = tool.getScreenSize();
    } catch (AWTError e) {
        System.out.println(CLASS_NAME+": ERROR! "+ e.getMessage());
        e.printStackTrace();
    }
    return deviceDimension;
}
 

@Override
public void open() {
    boolean success = false;
    try {
        final FileObject fo = getFileObject();
        if (fo != null) {
            final DataObject d = DataObject.find(fo);
            final EditCookie cake = d.getCookie(EditCookie.class);
            if (cake != null) {
                cake.edit();
                success = true;
            }
        }
    } catch (DataObjectNotFoundException ex) {
        Exceptions.printStackTrace(ex);
    }
    if (!success) {
        Toolkit.getDefaultToolkit().beep();
    }
}
 

private void stop( boolean commitChanges ) {
    Toolkit.getDefaultToolkit().removeAWTEventListener( this );
    TopComponent.getRegistry().removePropertyChangeListener( this );
    try {
        if( commitChanges ) {
            TopComponentDroppable droppable = targets.get( currentIndex );
            Point dropLocation = currentSide.getDropLocation( droppable );
            if( droppable.canDrop( draggable, dropLocation ) ) {
                dndManager.performDrop( dndManager.getController(), droppable, draggable, dropLocation );
            }
        }
    } finally {
        dndManager.dragFinished();
        dndManager.dragFinishedEx();
        if( currentDnd == this )
            currentDnd = null;
    }
}
 

public static void main(String[] args) throws Exception {

       Frame frame = new Frame();
        final Toolkit toolkit = Toolkit.getDefaultToolkit();
        final GraphicsEnvironment graphicsEnvironment =
                GraphicsEnvironment.getLocalGraphicsEnvironment();
        final GraphicsDevice graphicsDevice =
                graphicsEnvironment.getDefaultScreenDevice();

        final Dimension screenSize = toolkit.getScreenSize();
        final Insets screenInsets = toolkit.getScreenInsets(
                graphicsDevice.getDefaultConfiguration());

        final Rectangle availableScreenBounds = new Rectangle(screenSize);

        availableScreenBounds.x += screenInsets.left;
        availableScreenBounds.y += screenInsets.top;
        availableScreenBounds.width -= (screenInsets.left + screenInsets.right);
        availableScreenBounds.height -= (screenInsets.top + screenInsets.bottom);

        frame.setBounds(availableScreenBounds.x, availableScreenBounds.y,
                availableScreenBounds.width, availableScreenBounds.height);
        frame.setVisible(true);

        Rectangle frameBounds = frame.getBounds();
        frame.setExtendedState(Frame.MAXIMIZED_BOTH);
        ((SunToolkit) toolkit).realSync();

        Rectangle maximizedFrameBounds = frame.getBounds();
        if (maximizedFrameBounds.width < frameBounds.width
                || maximizedFrameBounds.height < frameBounds.height) {
            throw new RuntimeException("Maximized frame is smaller than non maximized");
        }
    }
 

private void stop( boolean commitChanges ) {
    Toolkit.getDefaultToolkit().removeAWTEventListener( this );
    TopComponent.getRegistry().removePropertyChangeListener( this );
    if( null != frame ) {
        boolean glassVisible = oldGlass.isVisible();
        frame.setGlassPane( oldGlass);
        oldGlass.setVisible( glassVisible );
    }
    if( !commitChanges ) {
        if( null != parentSplitter ) {
            parentSplitter.finishDraggingTo( originalParentLocation );
        }
        splitter.finishDraggingTo( originalLocation );
    }
    if( currentResizer == this )
        currentResizer = null;
}
 

@Override
public void insertString(int offset, String s, AttributeSet attributeSet) throws BadLocationException
{
	try
	{
		int value = Integer.parseInt(s);
		if( value < 0 )
		{
			Toolkit.getDefaultToolkit().beep();
			return;
		}
	}
	catch( NumberFormatException ex )
	{
		Toolkit.getDefaultToolkit().beep();
		return;
	}

	super.insertString(offset, s, attributeSet);

	if( Integer.parseInt(getText(0, getLength())) > maxNumber )
	{
		Toolkit.getDefaultToolkit().beep();
		super.remove(offset, s.length());
	}
}
 

/** Test that iconResource really works.
 * @see "#26887"
 */
public void testIcons() throws Exception {
    Image i = Toolkit.getDefaultToolkit().getImage(SystemActionTest.class.getResource("data/someicon.gif"));
    int h = imageHash("Control icon", i, 16, 16);
    SystemAction a = SystemAction.get(SystemAction1.class);
    CharSequence log = Log.enable("org.openide.util", Level.WARNING);
    assertEquals("Absolute slash-initial iconResource works (though deprecated)", h, imageHash("icon1", icon2Image(a.getIcon()), 16, 16));
    assertTrue(log.toString(), log.toString().contains("Initial slashes in Utilities.loadImage deprecated"));
    a = SystemAction.get(SystemAction2.class);
    assertEquals("Absolute no-slash-initial iconResource works", h, imageHash("icon2", icon2Image(a.getIcon()), 16, 16));
    a = SystemAction.get(SystemAction3.class);
    assertEquals("Relative iconResource works (though deprecated)", h, imageHash("icon3", icon2Image(a.getIcon()), 16, 16));
    assertTrue(log.toString(), log.toString().contains("Deprecated relative path"));
    a = SystemAction.get(SystemAction4.class);
    a.getIcon();
    assertTrue(log.toString(), log.toString().contains("No such icon"));
}
 

ImageIcon getImage(URL base) {
    if (!loadedImage) {
        synchronized(this) {
            if (!loadedImage) {
                URL url = CSS.getURL(base, svalue);
                loadedImage = true;
                if (url != null) {
                    image = new ImageIcon();
                    Image tmpImg = Toolkit.getDefaultToolkit().createImage(url);
                    if (tmpImg != null) {
                        image.setImage(tmpImg);
                    }
                }
            }
        }
    }
    return image;
}
 

@Override
@SuppressWarnings("deprecation")
public void addNotify() {
    synchronized(getTreeLock()) {
        Container parent = getParent();
        if (parent != null && parent.getPeer() == null) {
            parent.addNotify();
        }

        if (getPeer() == null) {
            ComponentPeer peer = ((WToolkit)Toolkit.getDefaultToolkit()).
                createWPageDialog(this);
            setPeer(peer);
        }
        super.addNotify();
    }
}
 

public static void main(String[] args) throws Exception {
    final SunToolkit toolkit = ((SunToolkit) Toolkit.getDefaultToolkit());

    SwingUtilities.invokeAndWait(new Runnable() {

        @Override
        public void run() {
            setup();
        }
    });
    toolkit.realSync();
    SwingUtilities.invokeAndWait(new Runnable() {

        @Override
        public void run() {
            try {
                verifySingleDefaultButtonModelListener();
                doTest();
                verifySingleDefaultButtonModelListener();
            } finally {
                frame.dispose();
            }
        }
    });
}
 

private void jl_Imagen_ContactsMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_jl_Imagen_ContactsMouseClicked
    // TODO add your handling code here:
    jl_Imagen_Contacts.setText("");

    JFileChooser fc = new JFileChooser();
    FileFilter filtro = new FileNameExtensionFilter("Imagenes", "png", "jpg", "jpeg", "gif");
    fc.setFileFilter(filtro);

    File Archivo;
    int op = fc.showOpenDialog(this);

    if (op == JFileChooser.APPROVE_OPTION) {
        Archivo = fc.getSelectedFile();
        RutaImagen = Archivo.getPath();
        System.out.println(Archivo.getPath());
        Image Img = Toolkit.getDefaultToolkit().createImage(Archivo.getPath()).getScaledInstance(180, 229, 0);
        this.jl_Imagen_Contacts.setIcon(new ImageIcon(Img));
    }
}
 

protected static Image readImage24(FileInputStream fs, BitmapHeader bh) throws IOException {
	Image image;
	if (bh.iSizeimage == 0) {
		bh.iSizeimage = ((((bh.iWidth * bh.iBitcount) + 31) & ~31) >> 3);
		bh.iSizeimage *= bh.iHeight;
	}
	final int npad = (bh.iSizeimage / bh.iHeight) - bh.iWidth * 3;
	final int ndata[] = new int[bh.iHeight * bh.iWidth];
	final byte brgb[] = new byte[(bh.iWidth + npad) * 3 * bh.iHeight];
	fs.read(brgb, 0, (bh.iWidth + npad) * 3 * bh.iHeight);
	int nindex = 0;
	for (int j = 0; j < bh.iHeight; j++) {
		for (int i = 0; i < bh.iWidth; i++) {
			ndata[bh.iWidth * (bh.iHeight - j - 1) + i] = constructInt3(brgb, nindex);
			nindex += 3;
		}
		nindex += npad;
	}
	image = Toolkit.getDefaultToolkit()
			.createImage(new MemoryImageSource(bh.iWidth, bh.iHeight, ndata, 0, bh.iWidth));
	fs.close();
	return (image);
}
 

public static Cursor getCursor( int which ) {
	Cursor c = (Cursor) cursorCache.get(new Integer(which));
	if (c != null) return c;

	try {
		ClassLoader loader = org.geomapapp.util.Icons.class.getClassLoader();
		String path = "org/geomapapp/resources/icons/" +names[which];
		java.net.URL url = loader.getResource(path);
		BufferedImage im = ImageIO.read(url);
		String name = names[which].substring(0, names[which].lastIndexOf("."));
		System.out.println(im.getWidth() + "\t" + im.getHeight());
		
		c = Toolkit.getDefaultToolkit().createCustomCursor(im, new Point(hotSpot[which][0],hotSpot[which][1]), name);
		cursorCache.put(new Integer(which), c);
		return c;
	} catch(Exception ex) {
		return Cursor.getDefaultCursor();
	}
}
 

ExecutableInputMethodManager() {

        // set up host adapter locator
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        try {
            if (toolkit instanceof InputMethodSupport) {
                InputMethodDescriptor hostAdapterDescriptor =
                    ((InputMethodSupport)toolkit)
                    .getInputMethodAdapterDescriptor();
                if (hostAdapterDescriptor != null) {
                    hostAdapterLocator = new InputMethodLocator(hostAdapterDescriptor, null, null);
                }
            }
        } catch (AWTException e) {
            // if we can't get a descriptor, we'll just have to do without native input methods
        }

        javaInputMethodLocatorList = new Vector<InputMethodLocator>();
        initializeInputMethodLocatorList();
    }
 

/**
 * Resets this generator.  All document information and content is
 * cleared.
 */
public void reset() {
	fontList.clear();
	colorList.clear();
	document.setLength(0);
	lastWasControlWord = false;
	lastFontIndex = 0;
	lastFGIndex = 0;
	lastBold = false;
	lastItalic = false;
	lastFontSize = DEFAULT_FONT_SIZE;
	screenRes = Toolkit.getDefaultToolkit().getScreenResolution();
}
 

public Image loadImage(String resourceName) {
    if (null == resourceName) {
        return null;
    }
    
    URL file = getClass().getResource(resourceName);
    
    if (file != null) {
        return Toolkit.getDefaultToolkit().createImage(file);
    }
    return null;
}
 

/** Creates a new instance of EyeTarget */
public EyeTarget() {
	super(caps);
	addGLEventListener(this);
	setAutoSwapBufferMode(true);
	glu=new GLU();
	glut=new GLUT();
	Dimension ss=Toolkit.getDefaultToolkit().getScreenSize();
	ss.setSize(ss.width/2,ss.height/2);
	setSize(ss);
	target=new Target();
}
 

public void dispose() {
    disposed = true;
    Toolkit.getDefaultToolkit().removeAWTEventListener(this);
    SwingUtilities.invokeLater(new Runnable() {
        @Override public void run() {
            paintTransparentFrame();
        }
    });
}
 

/**
 * Gets called when the mouse was released on a Swing component
 * that has this object as a MouseListener.
 *
 * @param e The event that holds the information about the mouse click.
 */
@Override
public void mouseReleased(MouseEvent e) {
    Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
    Transferable clipData = clipboard.getContents(clipboard);
    if (clipData != null) {
        if (clipData.isDataFlavorSupported(DefaultTransferHandler.flavor)) {
            JComponent comp = (JComponent)e.getSource();
            TransferHandler handler = comp.getTransferHandler();
            handler.importData(comp, clipData);
        }
    }
}
 

/**
 * Return the initial size of the dialog.
 */
@Override
protected Point getInitialSize() {
	container.getShell().layout(true, true);
	Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
	final Point newSize = container.getShell().computeSize(screenSize.width, screenSize.height, true);
	container.getShell().setSize(newSize);
	return newSize;
}
 

@Override
public String getText(final KeyEvent e) {
  if (this.isPressed(KeyEvent.VK_SHIFT) || Toolkit.getDefaultToolkit().getLockingKeyState(KeyEvent.VK_CAPS_LOCK)) {
    return this.getShiftText(e);
  } else if (this.isPressed(KeyEvent.VK_ALT_GRAPH)) {
    return this.getAltText(e);
  } else {
    return this.getNormalText(e);
  }
}
 

private static Cursor load(String name) {
    if (GraphicsEnvironment.isHeadless()) {
        return null;
    }

    try {
        return (Cursor)Toolkit.getDefaultToolkit().getDesktopProperty(name);
    } catch (Exception e) {
        e.printStackTrace();

        throw new RuntimeException("failed to load system cursor: " + name + " : " + e.getMessage());
    }
}
 

public void insertString(FilterBypass fb, int offs, String str, AttributeSet a) throws BadLocationException {
    if (DEBUG) {
        System.out.println("in DocumentSizeFilter's insertString method");
    }

    // This rejects the entire insertion if it would make
    // the contents too long. Another option would be
    // to truncate the inserted string so the contents
    // would be exactly maxCharacters in length.
    if ((fb.getDocument().getLength() + str.length()) <= maxCharacters)
        super.insertString(fb, offs, str, a);
    else
        Toolkit.getDefaultToolkit().beep();
}
 

/**
 * Center {@link Frame} relative to monitor.
 *
 * @param frame
 *            the frame
 */
private void center(Frame frame) {
	Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
	int x = (int) ((dimension.getWidth() - frame.getWidth()) / 2);
	int y = (int) ((dimension.getHeight() - frame.getHeight()) / 2);
	frame.setLocation(x, y);
}
 

public Action getAction (final String action, String containerCtx, final Map context) {
    return new AbstractAction () {
        public void actionPerformed (ActionEvent ae) {
            SimpleInvoker invoker = interp.getInvoker(action);
            System.err.println("Invoker is " + invoker);
            System.err.println("Invoking " + action + " on " + context);
            if (invoker != null) {
                invoker.invoke(context);
            } else {
                Toolkit.getDefaultToolkit().beep();
            }
        }
    };
}
 

/**
 * Closes the window
 */
void shutdown() {
    Toolkit.getDefaultToolkit().removeAWTEventListener(this);
    if (contentWindow != null) {
        contentWindow.getOwner().removeWindowFocusListener(this);
        contentWindow.removeWindowFocusListener(this);
        contentWindow.dispose();
    }
    contentWindow = null;
}
 

/**
 * Return true if the Image has been successfully loaded.
 * <p>
 * @param image Image to check for sucessful loading
 * <p>
 * @return True if the image has been sucessfully loaded.
 */
static public boolean isImageLoaded(
  Image image
  )
{
  Toolkit tk = Toolkit.getDefaultToolkit();
  int status = tk.checkImage(image, -1, -1, null);

  return ((status & (ImageObserver.ALLBITS |ImageObserver.FRAMEBITS)) != 0);
}
 

/**
 * Initialize the contents of the frame.
 */
private void initialize() {
	frame = new JFrame();
	frame.setIconImage(Toolkit.getDefaultToolkit().getImage("E:\\图片\\u=1829416607,2140971604&fm=21&gp=0.jpg"));
	frame.setType(Type.UTILITY);
	frame.setTitle("网络电影评论情感倾向性分类");
	frame.setBounds(100, 100, 639, 412);
	frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	
	JMenuBar menuBar = new JMenuBar();
	frame.setJMenuBar(menuBar);
	
	JMenu mnNewMenu = new JMenu("数据集自动标注");
	menuBar.add(mnNewMenu);
	
	JMenuItem mntmNewMenuItem_2 = new JMenuItem("自动标注");
	mnNewMenu.add(mntmNewMenuItem_2);
	
	JMenu mnNewMenu_1 = new JMenu("情感分析");
	menuBar.add(mnNewMenu_1);
	
	JMenuItem mntmNewMenuItem_3 = new JMenuItem("朴素贝叶斯算法");
	mnNewMenu_1.add(mntmNewMenuItem_3);
	
	JMenuItem mntmNewMenuItem_4 = new JMenuItem("N-Gram算法");
	mnNewMenu_1.add(mntmNewMenuItem_4);
	
	JMenuItem mntmNewMenuItem_5 = new JMenuItem("支持向量机");
	mnNewMenu_1.add(mntmNewMenuItem_5);
	
	JMenu mnNewMenu_2 = new JMenu("关于");
	menuBar.add(mnNewMenu_2);
	
	JMenuItem mntmNewMenuItem = new JMenuItem("作者");
	mnNewMenu_2.add(mntmNewMenuItem);
	
	JMenuItem mntmNewMenuItem_1 = new JMenuItem("New menu item");
	mnNewMenu_2.add(mntmNewMenuItem_1);
}
 

public static Graphics2D prepareGraphics(Graphics g) {
    Graphics2D g2 = (Graphics2D) g;
    Map rhints = (Map)(Toolkit.getDefaultToolkit().getDesktopProperty("awt.font.desktophints")); //NOI18N
    if( rhints == null && Boolean.getBoolean("swing.aatext") ) { //NOI18N
         g2.setRenderingHint( RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON );
    } else if( rhints != null ) {
        g2.addRenderingHints( rhints );
    }
    return g2;
}
 

/**
 * Construct a new JMenuItem then add it to an existing JMenu.
 * 
 * @param parent - the JMenu to add this JMenuItem into (or null if you
 *            don't want to add it to any JMenu yet)
 * @param label - the text to show on the menu
 * @param attrs - a list of attributes to apply onto the new JMenuItem
 *            <p>
 *            If one positive number a is supplied, we call setMnemonic(a)
 *            <p>
 *            If two positive numbers a and b are supplied, and a!=VK_ALT,
 *            and a!=VK_SHIFT, we call setMnemoic(a) and setAccelerator(b)
 *            <p>
 *            If two positive numbers a and b are supplied, and a==VK_ALT or
 *            a==VK_SHIFT, we call setAccelerator(a | b)
 *            <p>
 *            If an ActionListener is supplied, we call addActionListener(x)
 *            <p>
 *            If an Boolean x is supplied, we call setEnabled(x)
 *            <p>
 *            If an Icon x is supplied, we call setIcon(x)
 */
public static JMenuItem menuItem(JMenu parent, String label, Object... attrs) {
	JMenuItem m = new JMenuItem(label, null);
	int accelMask = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
	boolean hasMnemonic = false;
	for (Object x : attrs) {
		if (x instanceof Character || x instanceof Integer) {
			int k = (x instanceof Character) ? ((int) ((Character) x)) : ((Integer) x).intValue();
			if (k < 0)
				continue;
			if (k == KeyEvent.VK_ALT) {
				hasMnemonic = true;
				accelMask = accelMask | InputEvent.ALT_MASK;
				continue;
			}
			if (k == KeyEvent.VK_SHIFT) {
				hasMnemonic = true;
				accelMask = accelMask | InputEvent.SHIFT_MASK;
				continue;
			}
			if (!hasMnemonic) {
				m.setMnemonic(k);
				hasMnemonic = true;
			} else
				m.setAccelerator(KeyStroke.getKeyStroke(k, accelMask));
		}
		if (x instanceof ActionListener)
			m.addActionListener((ActionListener) x);
		if (x instanceof Icon)
			m.setIcon((Icon) x);
		if (x instanceof Boolean)
			m.setEnabled((Boolean) x);
	}
	if (parent != null)
		parent.add(m);
	return m;
}
 

private void valueTextFieldActionPerformed(final java.awt.event.ActionEvent evt) {// GEN-FIRST:event_valueTextFieldActionPerformed
	// new pots current value entered
	// System.out.println("value field action performed");
	try {
		startEdit();
		pot.setBitValue(Integer.parseInt(valueTextField.getText()));
		endEdit();
	}
	catch (final NumberFormatException e) {
		Toolkit.getDefaultToolkit().beep();
		valueTextField.selectAll();
	}
}
 

public void insertString(FilterBypass fb, int offs, String str, AttributeSet a) throws BadLocationException
{
	Document doc = fb.getDocument();
	StringBuffer s = new StringBuffer(doc.getText(0, doc.getLength()));
	s.insert(offs, str);

       if (verifyString(s.toString()))
           super.insertString(fb, offs, str, a);
       else
           Toolkit.getDefaultToolkit().beep();
   }
 

/**
 * Closes the window
 */
void shutdown() {
    Toolkit.getDefaultToolkit().removeAWTEventListener(this);
    if (contentWindow != null) {
        contentWindow.getOwner().removeWindowFocusListener(this);
        contentWindow.removeWindowFocusListener(this);
        contentWindow.dispose();
    }
    contentWindow = null;
}
 

/**
 * This is a utility method to help in loading icon images. It takes the
 * name of a resource file associated with the current object's class file
 * and loads an image object from that file. Typically images will be GIFs.
 *
 * @param  resourceName A pathname relative to the directory holding the
 *         class file of the current class. For example, "wombat.gif".
 * @return an image object or null if the resource is not found or the
 *         resource could not be loaded as an Image
 */
public Image loadImage(final String resourceName) {
    try {
        final URL url = getClass().getResource(resourceName);
        if (url != null) {
            final ImageProducer ip = (ImageProducer) url.getContent();
            if (ip != null) {
                return Toolkit.getDefaultToolkit().createImage(ip);
            }
        }
    } catch (final Exception ignored) {
    }
    return null;
}
 

public static final LookAndFeelType getLAF() {
    if(lookAndFeelType==null) {
        try {
            initializeLookAndFeel();
        } catch (InitializationException e) {
            LogManager.log(e);
        }
        lookAndFeelType = LookAndFeelType.DEFAULT;

        if (!uiUnavailable && UiMode.getCurrentUiMode() == UiMode.SWING) {
            LookAndFeel laf = UIManager.getLookAndFeel();
            if (laf != null) {
                String id = laf.getID();
                for (LookAndFeelType type : LookAndFeelType.values()) {
                    if (id.equals(LookAndFeelType.WINDOWS_XP.getId()) ||
                            id.equals(LookAndFeelType.WINDOWS_CLASSIC.getId())) {
                        final Object object = Toolkit.getDefaultToolkit().
                                getDesktopProperty(WINDOWS_XP_THEME_MARKER_PROPERTY);
                        boolean xpThemeActive = false;
                        if (object != null) {
                            xpThemeActive = (Boolean) object;
                        }
                        lookAndFeelType = (xpThemeActive) ? LookAndFeelType.WINDOWS_XP : LookAndFeelType.WINDOWS_CLASSIC;
                        break;
                    } else if (id.equals(type.getId())) {
                        lookAndFeelType = type;
                        break;
                    }
                }
            }
        }
    }
    return lookAndFeelType;
}
 

@Override public byte[] getScreenShot() throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    try {
        BufferedImage bufferedImage;
        Dimension windowSize = Toolkit.getDefaultToolkit().getScreenSize();
        bufferedImage = new Robot().createScreenCapture(new Rectangle(0, 0, windowSize.width, windowSize.height));
        ImageIO.write(bufferedImage, "png", baos);
    } catch (AWTException e) {
        e.printStackTrace();
    }
    return baos.toByteArray();
}
 

/**
 * @see java.awt.im.spi.InputMethodDescriptor#getInputMethodDisplayName
 */
@Override
public synchronized String getInputMethodDisplayName(Locale inputLocale, Locale displayLanguage) {
    // We ignore the input locale.
    // When displaying for the default locale, rely on the localized AWT properties;
    // for any other locale, fall back to English.
    String name = "System Input Methods";
    if (Locale.getDefault().equals(displayLanguage)) {
        name = Toolkit.getProperty("AWT.HostInputMethodDisplayName", name);
    }
    return name;
}
 

public void ReconocedorSearch(JTextField TextFieldActual) {
    Palabra = TextFieldActual.getText();
    if (!"".equals(Palabra)) {
        int answer = JOptionPane.showConfirmDialog(jd_User, "¿Quieres buscar a " + Palabra + "?");

        for (int i = 0; i < ListaContactos.size(); i++) {
            if (ListaContactos.get(i).getName().equals(Palabra) && answer == JOptionPane.YES_OPTION) {
                LlenarCamposContacts(ListaContactos.get(i));
                
                jl_Imagen_VoiceCall.setText("");
                
                File Archivo = new File(ListaContactos.get(i).getRutaImagen());
                Image Img = Toolkit.getDefaultToolkit().createImage(Archivo.getPath()).getScaledInstance(180, 229, 0);
                jl_Imagen_VoiceCall.setIcon(new ImageIcon(Img));
                jl_Imagen_Contacts.setIcon(new ImageIcon(Img));
            }
        }

        Palabra = "";
        PalabraAnterior = "";
        GPalabra.setGst("");
    } else {
        Palabra = "";
        PalabraAnterior = "";
        GPalabra.setGst("");
    }
}
 

public static BufferedImage takeAShot() throws AWTException, IOException {
    Robot robot = new Robot();
    Rectangle screenRect = new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());
    BufferedImage output = robot.createScreenCapture(screenRect);
    return output;
}
 

/**
 * Load the given image file from an accompanying JAR file, and return it as
 * an Icon object.
 */
public static Icon loadIcon(String pathname) {
	URL url = OurUtil.class.getClassLoader().getResource(pathname);
	if (url != null)
		return new ImageIcon(Toolkit.getDefaultToolkit().createImage(url));
	return new ImageIcon(new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB));
}
 

public void performClickAction(Document doc, int offset, HyperlinkType type) {
    EditCookie ec = getEditorCookie(doc, offset);
    if (ec != null) {
        ec.edit();
    } else {
        Toolkit.getDefaultToolkit().beep();
    }
}
 

private void init(Runnable run) {
    this.run = run;
    JComponent c = ProgressHandleFactory.createProgressComponent(progressHandle);
    c.setPreferredSize(new Dimension(3 * c.getPreferredSize().width, 3 * c.getPreferredSize().height));
    c.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
    getContentPane().add(c);
    progressHandle.start();
    getAccessibleContext().setAccessibleDescription(NbBundle.getMessage(JavaHelp.class, "ACSD_Loading_Dialog"));  //NOI18N
    pack();
    Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
    Dimension me = getSize();
    setLocation((screen.width - me.width) / 2, (screen.height - me.height) / 2);
}
 

private void menuItemIdActionPerformed(
    java.awt.event.ActionEvent evt) {//GEN-FIRST:event_menuItemIdActionPerformed
    if (JOptionPane.showInputDialog(this, "User ID from database:", "ID", 1, null, null,
        user.getId().toString()) != null) {
        final StringSelection stringSelection = new StringSelection(user.getId().toString());
        final Clipboard clpbrd = Toolkit.getDefaultToolkit().getSystemClipboard();
        clpbrd.setContents(stringSelection, null);
    }
}
 

/**
 * Sets size of this window and centers it on the page taking into account
 * the specified offset from the center
 * @param width width of the window
 * @param height height of the window
 * @param xOffsetFromCenter the offset from the center on the x coordinate
 * @param yOffsetFromCenter the offset from the center on the y coordinate
 */
public void centerWindowWithOffset(int width, int height, int xOffsetFromCenter, int yOffsetFromCenter) {
	Toolkit tk = Toolkit.getDefaultToolkit();
	//gets dimensions of the screen to center window.
	int xOffset = ((int) tk.getScreenSize().getWidth() - width) / 2;
	int yOffset = ((int) tk.getScreenSize().getHeight() - height) / 2;

	//add the offset from the center
	xOffset += xOffsetFromCenter;
	yOffset += yOffsetFromCenter;

	setBounds(xOffset, yOffset, width, height);
}
 

private static int getMenuShortcutKeyMask() {
    // #152050 - work in headless environment too
    try {
        if (!GraphicsEnvironment.isHeadless()) {
            return Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
        }
    } catch (Throwable ex) {
        // OK, just assume we are headless
    }
    return Event.CTRL_MASK;
}
 

/**
 * Creates new form Opcion
 */
public Opcion() {
    initComponents();
    setTitle("Obten tu horoscopo");
    Image icon = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/img/nana.jpg"));
    setIconImage(icon);
}
 

void realUngrabWindow() {
    Toolkit tk = Toolkit.getDefaultToolkit();
    if(grabbedWindow != null) {
        if(tk instanceof sun.awt.SunToolkit) {
            ((sun.awt.SunToolkit)tk).ungrab(grabbedWindow);
        } else {
            grabbedWindow.removeComponentListener(this);
            grabbedWindow.removeWindowListener(this);
        }
        grabbedWindow = null;
    }
}
 

private void fineBiasTextFieldActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_fineBiasTextFieldActionPerformed
        try {
            float v = engFormat.parseFloat(fineBiasTextField.getText());
            startEdit();
            fineBiasTextField.setText(engFormat.format(pot.setFineCurrent(v)));
            endEdit();
        } catch (NumberFormatException e) {
            Toolkit.getDefaultToolkit().beep();
            fineBiasTextField.selectAll();
        }
}
 

@Override
public void actionPerformed(ActionEvent e) {
    try {
        int p = Integer.parseInt(pageField.getText()) - 1;
        if (setPage(p)) {
            setActionEnabled();                
        } else {
            Toolkit.getDefaultToolkit().beep();                
        }
    } catch (Exception ex) {
        Toolkit.getDefaultToolkit().beep();
    }
}
 

/**
 * Sets the font for this component. This is overridden to update the cached font metrics and to
 * recalculate which lines are visible.
 * 
 * @param font
 *            The font
 */
@Override
@SuppressWarnings("deprecation")
public void setFont(Font font) {
	super.setFont(font);
	fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
	textArea.recalculateVisibleLines();
}
 

public static Image makeColorTransparent(Image image, final Color color) {
	ImageFilter filter = new RGBImageFilter() {
		public int markerRGB = color.getRGB()|0xFF000000;
		@Override
		public final int filterRGB(int x, int y, int rgb) {
			if((rgb|0xFF000000)==markerRGB)
				return 0x00FFFFFF & rgb;
			else return rgb;
		}
	};
	return Toolkit.getDefaultToolkit().createImage(new FilteredImageSource(image.getSource(), filter));
}