Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JRE 8 rt.jar - javax.* Package Source Code
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries. JRE (Java Runtime) 8 is the runtime environment included in JDK 8. JRE 8 rt.jar libraries are divided into 6 packages:
com.* - Internal Oracle and Sun Microsystems libraries java.* - Standard Java API libraries. javax.* - Extended Java API libraries. jdk.* - JDK supporting libraries. org.* - Third party libraries. sun.* - Old libraries developed by Sun Microsystems.
JAR File Information:
Directory of C:\fyicenter\jdk-1.8.0_191\jre\lib 63,596,151 rt.jar
Here is the list of Java classes of the javax.* package in JRE 1.8.0_191 rt.jar. Java source codes are also provided.
✍: FYIcenter
⏎ javax/swing/JLayer.java
/* * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package javax.swing; import sun.awt.AWTAccessor; import javax.swing.plaf.LayerUI; import javax.swing.border.Border; import javax.accessibility.*; import java.awt.*; import java.awt.event.*; import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; import java.io.IOException; import java.io.ObjectInputStream; import java.util.ArrayList; import java.security.AccessController; import java.security.PrivilegedAction; /** * {@code JLayer} is a universal decorator for Swing components * which enables you to implement various advanced painting effects as well as * receive notifications of all {@code AWTEvent}s generated within its borders. * <p> * {@code JLayer} delegates the handling of painting and input events to a * {@link javax.swing.plaf.LayerUI} object, which performs the actual decoration. * <p> * The custom painting implemented in the {@code LayerUI} and events notification * work for the JLayer itself and all its subcomponents. * This combination enables you to enrich existing components * by adding new advanced functionality such as temporary locking of a hierarchy, * data tips for compound components, enhanced mouse scrolling etc and so on. * <p> * {@code JLayer} is a good solution if you only need to do custom painting * over compound component or catch input events from its subcomponents. * <pre> * import javax.swing.*; * import javax.swing.plaf.LayerUI; * import java.awt.*; * * public class JLayerSample { * * private static JLayer<JComponent> createLayer() { * // This custom layerUI will fill the layer with translucent green * // and print out all mouseMotion events generated within its borders * LayerUI<JComponent> layerUI = new LayerUI<JComponent>() { * * public void paint(Graphics g, JComponent c) { * // paint the layer as is * super.paint(g, c); * // fill it with the translucent green * g.setColor(new Color(0, 128, 0, 128)); * g.fillRect(0, 0, c.getWidth(), c.getHeight()); * } * * public void installUI(JComponent c) { * super.installUI(c); * // enable mouse motion events for the layer's subcomponents * ((JLayer) c).setLayerEventMask(AWTEvent.MOUSE_MOTION_EVENT_MASK); * } * * public void uninstallUI(JComponent c) { * super.uninstallUI(c); * // reset the layer event mask * ((JLayer) c).setLayerEventMask(0); * } * * // overridden method which catches MouseMotion events * public void eventDispatched(AWTEvent e, JLayer<? extends JComponent> l) { * System.out.println("AWTEvent detected: " + e); * } * }; * // create a component to be decorated with the layer * JPanel panel = new JPanel(); * panel.add(new JButton("JButton")); * * // create the layer for the panel using our custom layerUI * return new JLayer<JComponent>(panel, layerUI); * } * * private static void createAndShowGUI() { * final JFrame frame = new JFrame(); * frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); * * // work with the layer as with any other Swing component * frame.add(createLayer()); * * frame.setSize(200, 200); * frame.setLocationRelativeTo(null); * frame.setVisible(true); * } * * public static void main(String[] args) throws Exception { * SwingUtilities.invokeAndWait(new Runnable() { * public void run() { * createAndShowGUI(); * } * }); * } * } * </pre> * * <b>Note:</b> {@code JLayer} doesn't support the following methods: * <ul> * <li>{@link Container#add(java.awt.Component)}</li> * <li>{@link Container#add(String, java.awt.Component)}</li> * <li>{@link Container#add(java.awt.Component, int)}</li> * <li>{@link Container#add(java.awt.Component, Object)}</li> * <li>{@link Container#add(java.awt.Component, Object, int)}</li> * </ul> * using any of of them will cause {@code UnsupportedOperationException} to be thrown, * to add a component to {@code JLayer} * use {@link #setView(Component)} or {@link #setGlassPane(JPanel)}. * * @param <V> the type of {@code JLayer}'s view component * * @see #JLayer(Component) * @see #setView(Component) * @see #getView() * @see javax.swing.plaf.LayerUI * @see #JLayer(Component, LayerUI) * @see #setUI(javax.swing.plaf.LayerUI) * @see #getUI() * @since 1.7 * * @author Alexander Potochkin */ public final class JLayer<V extends Component> extends JComponent implements Scrollable, PropertyChangeListener, Accessible { private V view; // this field is necessary because JComponent.ui is transient // when layerUI is serializable private LayerUI<? super V> layerUI; private JPanel glassPane; private long eventMask; private transient boolean isPainting; private transient boolean isPaintingImmediately; private static final LayerEventController eventController = new LayerEventController(); /** * Creates a new {@code JLayer} object with a {@code null} view component * and default {@link javax.swing.plaf.LayerUI}. * * @see #setView * @see #setUI */ public JLayer() { this(null); } /** * Creates a new {@code JLayer} object * with default {@link javax.swing.plaf.LayerUI}. * * @param view the component to be decorated by this {@code JLayer} * * @see #setUI */ public JLayer(V view) { this(view, new LayerUI<V>()); } /** * Creates a new {@code JLayer} object with the specified view component * and {@link javax.swing.plaf.LayerUI} object. * * @param view the component to be decorated * @param ui the {@link javax.swing.plaf.LayerUI} delegate * to be used by this {@code JLayer} */ public JLayer(V view, LayerUI<V> ui) { setGlassPane(createGlassPane()); setView(view); setUI(ui); } /** * Returns the {@code JLayer}'s view component or {@code null}. * <br>This is a bound property. * * @return the {@code JLayer}'s view component * or {@code null} if none exists * * @see #setView(Component) */ public V getView() { return view; } /** * Sets the {@code JLayer}'s view component, which can be {@code null}. * <br>This is a bound property. * * @param view the view component for this {@code JLayer} * * @see #getView() */ public void setView(V view) { Component oldView = getView(); if (oldView != null) { super.remove(oldView); } if (view != null) { super.addImpl(view, null, getComponentCount()); } this.view = view; firePropertyChange("view", oldView, view); revalidate(); repaint(); } /** * Sets the {@link javax.swing.plaf.LayerUI} which will perform painting * and receive input events for this {@code JLayer}. * * @param ui the {@link javax.swing.plaf.LayerUI} for this {@code JLayer} */ public void setUI(LayerUI<? super V> ui) { this.layerUI = ui; super.setUI(ui); } /** * Returns the {@link javax.swing.plaf.LayerUI} for this {@code JLayer}. * * @return the {@code LayerUI} for this {@code JLayer} */ public LayerUI<? super V> getUI() { return layerUI; } /** * Returns the {@code JLayer}'s glassPane component or {@code null}. * <br>This is a bound property. * * @return the {@code JLayer}'s glassPane component * or {@code null} if none exists * * @see #setGlassPane(JPanel) */ public JPanel getGlassPane() { return glassPane; } /** * Sets the {@code JLayer}'s glassPane component, which can be {@code null}. * <br>This is a bound property. * * @param glassPane the glassPane component of this {@code JLayer} * * @see #getGlassPane() */ public void setGlassPane(JPanel glassPane) { Component oldGlassPane = getGlassPane(); boolean isGlassPaneVisible = false; if (oldGlassPane != null) { isGlassPaneVisible = oldGlassPane.isVisible(); super.remove(oldGlassPane); } if (glassPane != null) { AWTAccessor.getComponentAccessor().setMixingCutoutShape(glassPane, new Rectangle()); glassPane.setVisible(isGlassPaneVisible); super.addImpl(glassPane, null, 0); } this.glassPane = glassPane; firePropertyChange("glassPane", oldGlassPane, glassPane); revalidate(); repaint(); } /** * Called by the constructor methods to create a default {@code glassPane}. * By default this method creates a new JPanel with visibility set to true * and opacity set to false. * * @return the default {@code glassPane} */ public JPanel createGlassPane() { return new DefaultLayerGlassPane(); } /** * Sets the layout manager for this container. This method is * overridden to prevent the layout manager from being set. * <p>Note: If {@code mgr} is non-{@code null}, this * method will throw an exception as layout managers are not supported on * a {@code JLayer}. * * @param mgr the specified layout manager * @exception IllegalArgumentException this method is not supported */ public void setLayout(LayoutManager mgr) { if (mgr != null) { throw new IllegalArgumentException("JLayer.setLayout() not supported"); } } /** * A non-{@code null} border, or non-zero insets, isn't supported, to prevent the geometry * of this component from becoming complex enough to inhibit * subclassing of {@code LayerUI} class. To create a {@code JLayer} with a border, * add it to a {@code JPanel} that has a border. * <p>Note: If {@code border} is non-{@code null}, this * method will throw an exception as borders are not supported on * a {@code JLayer}. * * @param border the {@code Border} to set * @exception IllegalArgumentException this method is not supported */ public void setBorder(Border border) { if (border != null) { throw new IllegalArgumentException("JLayer.setBorder() not supported"); } } /** * This method is not supported by {@code JLayer} * and always throws {@code UnsupportedOperationException} * * @throws UnsupportedOperationException this method is not supported * * @see #setView(Component) * @see #setGlassPane(JPanel) */ protected void addImpl(Component comp, Object constraints, int index) { throw new UnsupportedOperationException( "Adding components to JLayer is not supported, " + "use setView() or setGlassPane() instead"); } /** * {@inheritDoc} */ public void remove(Component comp) { if (comp == null) { super.remove(comp); } else if (comp == getView()) { setView(null); } else if (comp == getGlassPane()) { setGlassPane(null); } else { super.remove(comp); } } /** * {@inheritDoc} */ public void removeAll() { if (view != null) { setView(null); } if (glassPane != null) { setGlassPane(null); } } /** * Always returns {@code true} to cause painting to originate from {@code JLayer}, * or one of its ancestors. * * @return true * @see JComponent#isPaintingOrigin() */ protected boolean isPaintingOrigin() { return true; } /** * Delegates its functionality to the * {@link javax.swing.plaf.LayerUI#paintImmediately(int, int, int, int, JLayer)} method, * if {@code LayerUI} is set. * * @param x the x value of the region to be painted * @param y the y value of the region to be painted * @param w the width of the region to be painted * @param h the height of the region to be painted */ public void paintImmediately(int x, int y, int w, int h) { if (!isPaintingImmediately && getUI() != null) { isPaintingImmediately = true; try { getUI().paintImmediately(x, y, w, h, this); } finally { isPaintingImmediately = false; } } else { super.paintImmediately(x, y, w, h); } } /** * Delegates all painting to the {@link javax.swing.plaf.LayerUI} object. * * @param g the {@code Graphics} to render to */ public void paint(Graphics g) { if (!isPainting) { isPainting = true; try { super.paintComponent(g); } finally { isPainting = false; } } else { super.paint(g); } } /** * This method is empty, because all painting is done by * {@link #paint(Graphics)} and * {@link javax.swing.plaf.LayerUI#update(Graphics, JComponent)} methods */ protected void paintComponent(Graphics g) { } /** * The {@code JLayer} overrides the default implementation of * this method (in {@code JComponent}) to return {@code false}. * This ensures * that the drawing machinery will call the {@code JLayer}'s * {@code paint} * implementation rather than messaging the {@code JLayer}'s * children directly. * * @return false */ public boolean isOptimizedDrawingEnabled() { return false; } /** * {@inheritDoc} */ public void propertyChange(PropertyChangeEvent evt) { if (getUI() != null) { getUI().applyPropertyChange(evt, this); } } /** * Enables the events from JLayer and <b>all its descendants</b> * defined by the specified event mask parameter * to be delivered to the * {@link LayerUI#eventDispatched(AWTEvent, JLayer)} method. * <p> * Events are delivered provided that {@code LayerUI} is set * for this {@code JLayer} and the {@code JLayer} * is displayable. * <p> * The following example shows how to correctly use this method * in the {@code LayerUI} implementations: * <pre> * public void installUI(JComponent c) { * super.installUI(c); * JLayer l = (JLayer) c; * // this LayerUI will receive only key and focus events * l.setLayerEventMask(AWTEvent.KEY_EVENT_MASK | AWTEvent.FOCUS_EVENT_MASK); * } * * public void uninstallUI(JComponent c) { * super.uninstallUI(c); * JLayer l = (JLayer) c; * // JLayer must be returned to its initial state * l.setLayerEventMask(0); * } * </pre> * * By default {@code JLayer} receives no events and its event mask is {@code 0}. * * @param layerEventMask the bitmask of event types to receive * * @see #getLayerEventMask() * @see LayerUI#eventDispatched(AWTEvent, JLayer) * @see Component#isDisplayable() */ public void setLayerEventMask(long layerEventMask) { long oldEventMask = getLayerEventMask(); this.eventMask = layerEventMask; firePropertyChange("layerEventMask", oldEventMask, layerEventMask); if (layerEventMask != oldEventMask) { disableEvents(oldEventMask); enableEvents(eventMask); if (isDisplayable()) { eventController.updateAWTEventListener( oldEventMask, layerEventMask); } } } /** * Returns the bitmap of event mask to receive by this {@code JLayer} * and its {@code LayerUI}. * <p> * It means that {@link javax.swing.plaf.LayerUI#eventDispatched(AWTEvent, JLayer)} method * will only receive events that match the event mask. * <p> * By default {@code JLayer} receives no events. * * @return the bitmask of event types to receive for this {@code JLayer} */ public long getLayerEventMask() { return eventMask; } /** * Delegates its functionality to the {@link javax.swing.plaf.LayerUI#updateUI(JLayer)} method, * if {@code LayerUI} is set. */ public void updateUI() { if (getUI() != null) { getUI().updateUI(this); } } /** * Returns the preferred size of the viewport for a view component. * <p> * If the view component of this layer implements {@link Scrollable}, this method delegates its * implementation to the view component. * * @return the preferred size of the viewport for a view component * * @see Scrollable */ public Dimension getPreferredScrollableViewportSize() { if (getView() instanceof Scrollable) { return ((Scrollable)getView()).getPreferredScrollableViewportSize(); } return getPreferredSize(); } /** * Returns a scroll increment, which is required for components * that display logical rows or columns in order to completely expose * one block of rows or columns, depending on the value of orientation. * <p> * If the view component of this layer implements {@link Scrollable}, this method delegates its * implementation to the view component. * * @return the "block" increment for scrolling in the specified direction * * @see Scrollable */ public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) { if (getView() instanceof Scrollable) { return ((Scrollable)getView()).getScrollableBlockIncrement(visibleRect, orientation, direction); } return (orientation == SwingConstants.VERTICAL) ? visibleRect.height : visibleRect.width; } /** * Returns {@code false} to indicate that the height of the viewport does not * determine the height of the layer, unless the preferred height * of the layer is smaller than the height of the viewport. * <p> * If the view component of this layer implements {@link Scrollable}, this method delegates its * implementation to the view component. * * @return whether the layer should track the height of the viewport * * @see Scrollable */ public boolean getScrollableTracksViewportHeight() { if (getView() instanceof Scrollable) { return ((Scrollable)getView()).getScrollableTracksViewportHeight(); } return false; } /** * Returns {@code false} to indicate that the width of the viewport does not * determine the width of the layer, unless the preferred width * of the layer is smaller than the width of the viewport. * <p> * If the view component of this layer implements {@link Scrollable}, this method delegates its * implementation to the view component. * * @return whether the layer should track the width of the viewport * * @see Scrollable */ public boolean getScrollableTracksViewportWidth() { if (getView() instanceof Scrollable) { return ((Scrollable)getView()).getScrollableTracksViewportWidth(); } return false; } /** * Returns a scroll increment, which is required for components * that display logical rows or columns in order to completely expose * one new row or column, depending on the value of orientation. * Ideally, components should handle a partially exposed row or column * by returning the distance required to completely expose the item. * <p> * Scrolling containers, like {@code JScrollPane}, will use this method * each time the user requests a unit scroll. * <p> * If the view component of this layer implements {@link Scrollable}, this method delegates its * implementation to the view component. * * @return The "unit" increment for scrolling in the specified direction. * This value should always be positive. * * @see Scrollable */ public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) { if (getView() instanceof Scrollable) { return ((Scrollable) getView()).getScrollableUnitIncrement( visibleRect, orientation, direction); } return 1; } private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { s.defaultReadObject(); if (layerUI != null) { setUI(layerUI); } if (eventMask != 0) { eventController.updateAWTEventListener(0, eventMask); } } /** * {@inheritDoc} */ public void addNotify() { super.addNotify(); eventController.updateAWTEventListener(0, eventMask); } /** * {@inheritDoc} */ public void removeNotify() { super.removeNotify(); eventController.updateAWTEventListener(eventMask, 0); } /** * Delegates its functionality to the {@link javax.swing.plaf.LayerUI#doLayout(JLayer)} method, * if {@code LayerUI} is set. */ public void doLayout() { if (getUI() != null) { getUI().doLayout(this); } } /** * Gets the AccessibleContext associated with this {@code JLayer}. * * @return the AccessibleContext associated with this {@code JLayer}. */ public AccessibleContext getAccessibleContext() { if (accessibleContext == null) { accessibleContext = new AccessibleJComponent() { public AccessibleRole getAccessibleRole() { return AccessibleRole.PANEL; } }; } return accessibleContext; } /** * static AWTEventListener to be shared with all AbstractLayerUIs */ private static class LayerEventController implements AWTEventListener { private ArrayList<Long> layerMaskList = new ArrayList<Long>(); private long currentEventMask; private static final long ACCEPTED_EVENTS = AWTEvent.COMPONENT_EVENT_MASK | AWTEvent.CONTAINER_EVENT_MASK | AWTEvent.FOCUS_EVENT_MASK | AWTEvent.KEY_EVENT_MASK | AWTEvent.MOUSE_WHEEL_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK | AWTEvent.MOUSE_EVENT_MASK | AWTEvent.INPUT_METHOD_EVENT_MASK | AWTEvent.HIERARCHY_EVENT_MASK | AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK; @SuppressWarnings("unchecked") public void eventDispatched(AWTEvent event) { Object source = event.getSource(); if (source instanceof Component) { Component component = (Component) source; while (component != null) { if (component instanceof JLayer) { JLayer l = (JLayer) component; LayerUI ui = l.getUI(); if (ui != null && isEventEnabled(l.getLayerEventMask(), event.getID()) && (!(event instanceof InputEvent) || !((InputEvent)event).isConsumed())) { ui.eventDispatched(event, l); } } component = component.getParent(); } } } private void updateAWTEventListener(long oldEventMask, long newEventMask) { if (oldEventMask != 0) { layerMaskList.remove(oldEventMask); } if (newEventMask != 0) { layerMaskList.add(newEventMask); } long combinedMask = 0; for (Long mask : layerMaskList) { combinedMask |= mask; } // filter out all unaccepted events combinedMask &= ACCEPTED_EVENTS; if (combinedMask == 0) { removeAWTEventListener(); } else if (getCurrentEventMask() != combinedMask) { removeAWTEventListener(); addAWTEventListener(combinedMask); } currentEventMask = combinedMask; } private long getCurrentEventMask() { return currentEventMask; } private void addAWTEventListener(final long eventMask) { AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { Toolkit.getDefaultToolkit(). addAWTEventListener(LayerEventController.this, eventMask); return null; } }); } private void removeAWTEventListener() { AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { Toolkit.getDefaultToolkit(). removeAWTEventListener(LayerEventController.this); return null; } }); } private boolean isEventEnabled(long eventMask, int id) { return (((eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0 && id >= ComponentEvent.COMPONENT_FIRST && id <= ComponentEvent.COMPONENT_LAST) || ((eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 && id >= ContainerEvent.CONTAINER_FIRST && id <= ContainerEvent.CONTAINER_LAST) || ((eventMask & AWTEvent.FOCUS_EVENT_MASK) != 0 && id >= FocusEvent.FOCUS_FIRST && id <= FocusEvent.FOCUS_LAST) || ((eventMask & AWTEvent.KEY_EVENT_MASK) != 0 && id >= KeyEvent.KEY_FIRST && id <= KeyEvent.KEY_LAST) || ((eventMask & AWTEvent.MOUSE_WHEEL_EVENT_MASK) != 0 && id == MouseEvent.MOUSE_WHEEL) || ((eventMask & AWTEvent.MOUSE_MOTION_EVENT_MASK) != 0 && (id == MouseEvent.MOUSE_MOVED || id == MouseEvent.MOUSE_DRAGGED)) || ((eventMask & AWTEvent.MOUSE_EVENT_MASK) != 0 && id != MouseEvent.MOUSE_MOVED && id != MouseEvent.MOUSE_DRAGGED && id != MouseEvent.MOUSE_WHEEL && id >= MouseEvent.MOUSE_FIRST && id <= MouseEvent.MOUSE_LAST) || ((eventMask & AWTEvent.INPUT_METHOD_EVENT_MASK) != 0 && id >= InputMethodEvent.INPUT_METHOD_FIRST && id <= InputMethodEvent.INPUT_METHOD_LAST) || ((eventMask & AWTEvent.HIERARCHY_EVENT_MASK) != 0 && id == HierarchyEvent.HIERARCHY_CHANGED) || ((eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0 && (id == HierarchyEvent.ANCESTOR_MOVED || id == HierarchyEvent.ANCESTOR_RESIZED))); } } /** * The default glassPane for the {@link javax.swing.JLayer}. * It is a subclass of {@code JPanel} which is non opaque by default. */ private static class DefaultLayerGlassPane extends JPanel { /** * Creates a new {@link DefaultLayerGlassPane} */ public DefaultLayerGlassPane() { setOpaque(false); } /** * First, implementation of this method iterates through * glassPane's child components and returns {@code true} * if any of them is visible and contains passed x,y point. * After that it checks if no mouseListeners is attached to this component * and no mouse cursor is set, then it returns {@code false}, * otherwise calls the super implementation of this method. * * @param x the <i>x</i> coordinate of the point * @param y the <i>y</i> coordinate of the point * @return true if this component logically contains x,y */ public boolean contains(int x, int y) { for (int i = 0; i < getComponentCount(); i++) { Component c = getComponent(i); Point point = SwingUtilities.convertPoint(this, new Point(x, y), c); if(c.isVisible() && c.contains(point)){ return true; } } if (getMouseListeners().length == 0 && getMouseMotionListeners().length == 0 && getMouseWheelListeners().length == 0 && !isCursorSet()) { return false; } return super.contains(x, y); } } }
⏎ javax/swing/JLayer.java
Or download all of them as a single archive file:
File name: jre-rt-javax-1.8.0_191-src.zip File size: 5381005 bytes Release date: 2018-10-28 Download
⇒ JRE 8 rt.jar - org.* Package Source Code
2024-03-15, 212762👍, 6💬
Popular Posts:
maven-compat-3.8.6.jar is the JAR file for Apache Maven 3.8.6 Compact module. The JAR file name may ...
layout.jar is a component in iText Java library to provide layout functionalities. iText Java librar...
What Is activation.jar? I heard it's related to JAF (JavaBeans Activation Framework) 1.0.2? The if y...
Jackson is "the Java JSON library" or "the best JSON parser for Java". Or simply as "JSON for Java"....
JDK 11 jdk.compiler.jmod is the JMOD file for JDK 11 Compiler tool, which can be invoked by the "jav...