Scenario We are a large multinational organisation. We process data, analyse them, and present them...

Question

Scenario We are a large multinational organisation. We process data, analyse them, and present them graphically. We make most of our software available as open source1 . We make most of our media available through Creative Commons2 . We make lots of money from support services and bespoke software enhancements. We expect our employees to be professional, ethical and compliant with the relevant laws, to manage themselves and their relation to others, and to deliver high quality products and services and deliver them on time. You are employees of this organisation… Students referred/deferred to Coursework 2 ONLY This is an individual piece of work. You will work on your own, using (if your wish) the design you have created with your team in semester 2, to implement an application that analyses data related to traffic dataset and present the results graphically to users. The data that you must present is traffic volume recorded on count points on UK roads. The users are interested in the volume of traffic per vehicle type, road type, time of the day, average traffic volume etc. For this work you need to use the traffic dataset that was assigned to your group in semester 2. Coursework description You need to develop a working, stand-alone application, making use of the knowledge you have gained in the modules Object oriented programming and Database Systems. The functionality of the application has two parts: a) login into the system; b) be able to read data from a database that holds the traffic data and display and query the data in a graphical form. In detail your application should include the following functionalities: 1. Allow users of your application to login with username and password, including any additional functionality that you may need for security purposes and complete operation of this function (you can use a manually created database of usernames and passwords). 2. Read traffic data from the data files into appropriate table structures (you can use the ERD from CWK1) – the table can be created using SQLite 3. Allow users to display the data graphically using Java Swing (you can use libraries for the graphical elements, eg JFreeChart) and query the data based on interface elements (eg menu, check box, sliders etc) of your choice.

Ayush · Accepted Answer

New folder/Description.docx
The Project has 3 main Frames.
1. Main: This Jframe is used for login and signup operations. It switches between the 2 operations with buttons provided on left panels. It links with ‘USERS’ table in the database to perform the respective operations.
2. NewJFrame: This JFrame links with ‘Data’ Table in the database. It shows the data as per the query values given. This Frame can also display a child Frame containing the Graphical representation of the data.
3. UpdateUser: This JFrame links with ‘USERS’ Table and is used to update user information.
The 2 classes, CountData and User, are used to store data as per the Queries performed on the 2 tables.
Since there is no Main class for the project, we need to run Main JFrame to start the application.
All the libraries are stored in the root folder of the project. The Database file is stored in root/src/newpackage.
New folder/Project/build.xml
 
     Builds, tests, and runs the project Project.
     
    
New folder/Project/build/built-jar.properties
#Tue, 06 Jul 2021 16:50:03 +0530
C\:\Users\Suchit\Desktop\Project\Project=
New folder/Project/build/classes/newpackage/CountData.class
package newpackage;
public synchronized class CountData {
    public int countID;
    String hour;
    String pedalCycles;
    String twoWheeledMotorVehicles;
    String carAndTaxis;
    String BusesAndCoaches;
    String Igvs;
    String hgvs2RigidAxle;
    String hgvs3RigidAxle;
    String hgvs4OrMoreRigidAxle;
    String hgvs3or4ArticulatedAxle;
    String hgvs5ArticulatedAxle;
    String hgvs6ArticulatedAxle;
    String allHgvs;
    String AllMotorVehicles;
    public String countData;
    public void CountData();
}
New folder/Project/build/classes/newpackage/Main$1.class
package newpackage;
synchronized class Main$1 implements java.awt.event.ActionListener {
    void Main$1(Main);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/Main$2.class
package newpackage;
synchronized class Main$2 implements java.awt.event.ActionListener {
    void Main$2(Main);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/Main$3.class
package newpackage;
synchronized class Main$3 implements java.awt.event.ActionListener {
    void Main$3(Main);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/Main$4.class
package newpackage;
final synchronized class Main$4 implements Runnable {
    void Main$4();
    public void run();
}
New folder/Project/build/classes/newpackage/Main.class
package newpackage;
public synchronized class Main extends javax.swing.JFrame {
    int mode;
    java.sql.Connection c;
    java.sql.PreparedStatement p;
    java.sql.ResultSet r;
    java.util.ArrayList list;
    private javax.swing.JButton jButton1;
    private javax.swing.JButton jButtonLogIn;
    private javax.swing.JButton jButtonSignUp;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JTextField jTextEmail;
    private javax.swing.JTextField jTextName;
    private javax.swing.JPasswordField jTextPassword;
    public void Main();
    private void initComponents();
    private void jButtonLogInActionPerformed(java.awt.event.ActionEvent);
    private void jButtonSignUpActionPerformed(java.awt.event.ActionEvent);
    private void jButton1ActionPerformed(java.awt.event.ActionEvent);
    public static void main(String[]);
}
New folder/Project/build/classes/newpackage/NewJFrame$1.class
package newpackage;
synchronized class NewJFrame$1 implements java.awt.event.ActionListener {
    void NewJFrame$1(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$10.class
package newpackage;
synchronized class NewJFrame$10 implements java.awt.event.ActionListener {
    void NewJFrame$10(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$11.class
package newpackage;
synchronized class NewJFrame$11 implements java.awt.event.ActionListener {
    void NewJFrame$11(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$12.class
package newpackage;
synchronized class NewJFrame$12 implements java.awt.event.ActionListener {
    void NewJFrame$12(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$13.class
package newpackage;
synchronized class NewJFrame$13 implements java.awt.event.ActionListener {
    void NewJFrame$13(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$14.class
package newpackage;
synchronized class NewJFrame$14 implements java.awt.event.ActionListener {
    void NewJFrame$14(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$15.class
package newpackage;
synchronized class NewJFrame$15 implements java.awt.event.ActionListener {
    void NewJFrame$15(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$16.class
package newpackage;
synchronized class NewJFrame$16 implements java.awt.event.ActionListener {
    void NewJFrame$16(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$17.class
package newpackage;
synchronized class NewJFrame$17 implements java.awt.event.ActionListener {
    void NewJFrame$17(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$18.class
package newpackage;
synchronized class NewJFrame$18 implements java.awt.event.ActionListener {
    void NewJFrame$18(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$19.class
package newpackage;
synchronized class NewJFrame$19 implements java.awt.event.ActionListener {
    void NewJFrame$19(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$2.class
package newpackage;
synchronized class NewJFrame$2 implements java.awt.event.ActionListener {
    void NewJFrame$2(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$20.class
package newpackage;
synchronized class NewJFrame$20 implements java.awt.event.ActionListener {
    void NewJFrame$20(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$21.class
package newpackage;
synchronized class NewJFrame$21 implements java.awt.event.ActionListener {
    void NewJFrame$21(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$22.class
package newpackage;
synchronized class NewJFrame$22 implements java.awt.event.ActionListener {
    void NewJFrame$22(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$23.class
package newpackage;
final synchronized class NewJFrame$23 implements Runnable {
    void NewJFrame$23(String);
    public void run();
}
New folder/Project/build/classes/newpackage/NewJFrame$3.class
package newpackage;
synchronized class NewJFrame$3 implements java.awt.event.ActionListener {
    void NewJFrame$3(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$4.class
package newpackage;
synchronized class NewJFrame$4 implements java.awt.event.ActionListener {
    void NewJFrame$4(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$5.class
package newpackage;
synchronized class NewJFrame$5 extends java.awt.event.MouseAdapter {
    void NewJFrame$5(NewJFrame);
    public void mouseClicked(java.awt.event.MouseEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$6.class
package newpackage;
synchronized class NewJFrame$6 implements java.awt.event.ActionListener {
    void NewJFrame$6(NewJFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$7.class
package newpackage;
synchronized class NewJFrame$7 extends java.awt.event.MouseAdapter {
    void NewJFrame$7(NewJFrame);
    public void mouseClicked(java.awt.event.MouseEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$8.class
package newpackage;
synchronized class NewJFrame$8 extends java.awt.event.MouseMotionAdapter {
    void NewJFrame$8(NewJFrame);
    public void mouseMoved(java.awt.event.MouseEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame$9.class
package newpackage;
synchronized class NewJFrame$9 extends java.awt.event.MouseAdapter {
    void NewJFrame$9(NewJFrame);
    public void mouseClicked(java.awt.event.MouseEvent);
}
New folder/Project/build/classes/newpackage/NewJFrame.class
package newpackage;
public synchronized class NewJFrame extends javax.swing.JFrame {
    String id;
    int[] menuList;
    int setAll;
    java.util.ArrayList data;
    private javax.swing.JButton jButton;
    private javax.swing.JButton jButton1;
    private javax.swing.JCheckBoxMenuItem jCheckBoxAll;
    private javax.swing.JCheckBoxMenuItem jCheckBoxBus;
    private javax.swing.JCheckBoxMenuItem jCheckBoxCar;
    private javax.swing.JCheckBoxMenuItem jCheckBoxIgvs;
    private javax.swing.JCheckBoxMenuItem jCheckBoxPedalCycle;
    private javax.swing.JCheckBoxMenuItem jCheckBoxallHgvs;
    private javax.swing.JCheckBoxMenuItem jCheckBoxhgvs2;
    private javax.swing.JCheckBoxMenuItem jCheckBoxhgvs3;
    private javax.swing.JCheckBoxMenuItem jCheckBoxhgvs3or4;
    private javax.swing.JCheckBoxMenuItem jCheckBoxhgvs4OrMore;
    private javax.swing.JCheckBoxMenuItem jCheckBoxhgvs5;
    private javax.swing.JCheckBoxMenuItem jCheckBoxhgvs6;
    private javax.swing.JCheckBoxMenuItem jCheckBoxtwoWheeled;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel10;
    private javax.swing.JLabel jLabel11;
    private javax.swing.JLabel jLabel13;
    private javax.swing.JLabel jLabel14;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JLabel jLabel4;
    private javax.swing.JLabel jLabel5;
    private javax.swing.JLabel jLabel6;
    private javax.swing.JLabel jLabel7;
    private javax.swing.JLabel jLabel8;
    private javax.swing.JLabel jLabel9;
    private javax.swing.JLabel jLabelLoadAll;
    private javax.swing.JLabel jLabelName;
    private javax.swing.JMenu jMenu1;
    private javax.swing.JMenuBar jMenuBar1;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JTable jTable1;
    private javax.swing.JTextField jTextAuthID;
    private javax.swing.JTextField jTextAuthName;
    private javax.swing.JTextField jTextCountID;
    private javax.swing.JTextField jTextDirOfTravel;
    private javax.swing.JTextField jTextEnd;
    private javax.swing.JTextField jTextRegionID;
    private javax.swing.JTextField jTextRegionName;
    private javax.swing.JTextField jTextRoadName;
    private javax.swing.JTextField jTextRoadType;
    private javax.swing.JTextField jTextStart;
    private javax.swing.JTextField jTextYear;
    public void NewJFrame(String);
    public void setName(int);
    public void refreshTable();
    public void initializeTable();
    public void loadAllData();
    private void initComponents();
    private void jTextDirOfTravelActionPerformed(java.awt.event.ActionEvent);
    private void jTextYearActionPerformed(java.awt.event.ActionEvent);
    private void jTextCountIDActionPerformed(java.awt.event.ActionEvent);
    private void jButtonActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxtwoWheeledActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxhgvs3or4ActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxhgvs6ActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxPedalCycleActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxCarActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxBusActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxIgvsActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxhgvs2ActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxhgvs3ActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxhgvs4OrMoreActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxhgvs5ActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxallHgvsActionPerformed(java.awt.event.ActionEvent);
    private void jCheckBoxAllActionPerformed(java.awt.event.ActionEvent);
    private void jLabelLoadAllMouseClicked(java.awt.event.MouseEvent);
    private void jButton1ActionPerformed(java.awt.event.ActionEvent);
    private void jLabel13MouseClicked(java.awt.event.MouseEvent);
    private void jLabel14MouseClicked(java.awt.event.MouseEvent);
    private void jLabel14MouseMoved(java.awt.event.MouseEvent);
    private org.jfree.data.xy.XYDataset createDataset();
    public static void main(String[]);
}
New folder/Project/build/classes/newpackage/UpdateUser$1.class
package newpackage;
synchronized class UpdateUser$1 implements java.awt.event.ActionListener {
    void UpdateUser$1(UpdateUser);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/UpdateUser$2.class
package newpackage;
synchronized class UpdateUser$2 implements java.awt.event.ActionListener {
    void UpdateUser$2(UpdateUser);
    public void actionPerformed(java.awt.event.ActionEvent);
}
New folder/Project/build/classes/newpackage/UpdateUser$3.class
package newpackage;
final synchronized class UpdateUser$3 implements Runnable {
    void UpdateUser$3(String);
    public void run();
}
New folder/Project/build/classes/newpackage/UpdateUser.class
package newpackage;
public synchronized class UpdateUser extends javax.swing.JFrame {
    int id;
    private javax.swing.JButton jButtonCancel;
    private javax.swing.JButton jButtonUpdate;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JLabel jLabel4;
    private javax.swing.JTextField jTextEmail;
    private javax.swing.JTextField jTextID;
    private javax.swing.JTextField jTextName;
    private javax.swing.JPasswordField jTextPassword;
    public void UpdateUser(String);
    public void initialize();
    private void initComponents();
    private void jButtonUpdateActionPerformed(java.awt.event.ActionEvent);
    private void jButtonCancelActionPerformed(java.awt.event.ActionEvent);
    public static void main(String[]);
}
New folder/Project/build/classes/newpackage/User.class
package newpackage;
public synchronized class User {
    int userID;
    String userName;
    String userEmail;
    String userPassword;
    void User(int, String, String, String);
}
New folder/Project/hamcrest-core-1.3.jar
META-INF/MANIFEST.MF
Manifest-Version: 1.0
Ant-Version: Apache Ant 1.8.1
Created-By: 1.6.0_33-b03 (Sun Microsystems Inc.)
Implementation-Title: hamcrest-core
Implementation-Vendor: hamcrest.org
Implementation-Version: 1.3
Built-By: tom
Built-Date: 2012-07-09 19:49:34
LICENSE.txt
BSD License
Copyright (c) 2000-2006, www.hamcrest.org
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of
conditions and the following disclaimer. Redistributions in binary form must reproduce
the above copyright notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
Neither the name of Hamcrest nor the names of its contributors may be used to endorse
or promote products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
org/hamcrest/BaseDescription.class
package org.hamcrest;
public abstract synchronized class BaseDescription implements Description {
    public void BaseDescription();
    public Description appendText(String);
    public Description appendDescriptionOf(SelfDescribing);
    public Description appendValue(Object);
    private String descriptionOf(Object);
    public transient Description appendValueList(String, String, String, Object[]);
    public Description appendValueList(String, String, String, Iterable);
    private Description appendValueList(String, String, String, java.util.Iterator);
    public Description appendList(String, String, String, Iterable);
    private Description appendList(String, String, String, java.util.Iterator);
    protected void append(String);
    protected abstract void append(char);
    private void toJavaSyntax(String);
    private void toJavaSyntax(char);
}
org/hamcrest/BaseMatcher.class
package org.hamcrest;
public abstract synchronized class BaseMatcher implements Matcher {
    public void BaseMatcher();
    public final void _dont_implement_Matcher___instead_extend_BaseMatcher_();
    public void describeMismatch(Object, Description);
    public String toString();
}
org/hamcrest/Condition$1.class
package org.hamcrest;
synchronized class Condition$1 {
}
org/hamcrest/Condition$Matched.class
package org.hamcrest;
final synchronized class Condition$Matched extends Condition {
    private final Object theValue;
    private final Description mismatch;
    private void Condition$Matched(Object, Description);
    public boolean matching(Matcher, String);
    public Condition and(Condition$Step);
}
org/hamcrest/Condition$NotMatched.class
package org.hamcrest;
final synchronized class Condition$NotMatched extends Condition {
    private void Condition$NotMatched();
    public boolean matching(Matcher, String);
    public Condition and(Condition$Step);
}
org/hamcrest/Condition$Step.class
package org.hamcrest;
public abstract interface Condition$Step {
    public abstract Condition apply(Object, Description);
}
org/hamcrest/Condition.class
package org.hamcrest;
public abstract synchronized class Condition {
    public static final Condition$NotMatched NOT_MATCHED;
    private void Condition();
    public abstract boolean matching(Matcher, String);
    public abstract Condition and(Condition$Step);
    public final boolean matching(Matcher);
    public final Condition then(Condition$Step);
    public static Condition notMatched();
    public static Condition matched(Object, Description);
    static void ();
}
org/hamcrest/CoreMatchers.class
package org.hamcrest;
public synchronized class CoreMatchers {
    public void CoreMatchers();
    public static Matcher allOf(Iterable);
    public static transient Matcher allOf(Matcher[]);
    public static Matcher allOf(Matcher, Matcher);
    public static Matcher allOf(Matcher, Matcher, Matcher);
    public static Matcher allOf(Matcher, Matcher, Matcher, Matcher);
    public static Matcher allOf(Matcher, Matcher, Matcher, Matcher, Matcher);
    public static Matcher allOf(Matcher, Matcher, Matcher, Matcher, Matcher, Matcher);
    public static core.AnyOf anyOf(Iterable);
    public static core.AnyOf anyOf(Matcher, Matcher, Matcher);
    public static core.AnyOf anyOf(Matcher, Matcher, Matcher, Matcher);
    public static core.AnyOf anyOf(Matcher, Matcher, Matcher, Matcher, Matcher);
    public static core.AnyOf anyOf(Matcher, Matcher, Matcher, Matcher, Matcher, Matcher);
    public static core.AnyOf anyOf(Matcher, Matcher);
    public static transient core.AnyOf anyOf(Matcher[]);
    public static core.CombinableMatcher$CombinableBothMatcher both(Matcher);
    public static core.CombinableMatcher$CombinableEitherMatcher either(Matcher);
    public static transient Matcher describedAs(String, Matcher, Object[]);
    public static Matcher everyItem(Matcher);
    public static Matcher is(Object);
    public static Matcher is(Matcher);
    public static Matcher is(Class);
    public static Matcher isA(Class);
    public static Matcher anything();
    public static Matcher anything(String);
    public static Matcher hasItem(Object);
    public static Matcher hasItem(Matcher);
    public static transient Matcher hasItems(Object[]);
    public static transient Matcher hasItems(Matcher[]);
    public static Matcher equalTo(Object);
    public static Matcher any(Class);
    public static Matcher instanceOf(Class);
    public static Matcher not(Matcher);
    public static Matcher not(Object);
    public static Matcher nullValue();
    public static Matcher nullValue(Class);
    public static Matcher notNullValue();
    public static Matcher notNullValue(Class);
    public static Matcher sameInstance(Object);
    public static Matcher theInstance(Object);
    public static Matcher containsString(String);
    public static Matcher startsWith(String);
    public static Matcher endsWith(String);
}
org/hamcrest/CustomMatcher.class
package org.hamcrest;
public abstract synchronized class CustomMatcher extends BaseMatcher {
    private final String fixedDescription;
    public void CustomMatcher(String);
    public final void describeTo(Description);
}
org/hamcrest/CustomTypeSafeMatcher.class
package org.hamcrest;
public abstract synchronized class CustomTypeSafeMatcher extends TypeSafeMatcher {
    private final String fixedDescription;
    public void CustomTypeSafeMatcher(String);
    public final void describeTo(Description);
}
org/hamcrest/Description$NullDescription.class
package org.hamcrest;
public final synchronized class Description$NullDescription implements Description {
    public void Description$NullDescription();
    public Description appendDescriptionOf(SelfDescribing);
    public Description appendList(String, String, String, Iterable);
    public Description appendText(String);
    public Description appendValue(Object);
    public transient Description appendValueList(String, String, String, Object[]);
    public Description appendValueList(String, String, String, Iterable);
    public String toString();
}
org/hamcrest/Description.class
package org.hamcrest;
public abstract interface Description {
    public static final Description NONE;
    public abstract Description appendText(String);
    public abstract Description appendDescriptionOf(SelfDescribing);
    public abstract Description appendValue(Object);
    public abstract transient Description appendValueList(String, String, String, Object[]);
    public abstract Description appendValueList(String, String, String, Iterable);
    public abstract Description appendList(String, String, String, Iterable);
    static void ();
}
org/hamcrest/DiagnosingMatcher.class
package org.hamcrest;
public abstract synchronized class DiagnosingMatcher extends BaseMatcher {
    public void DiagnosingMatcher();
    public final boolean matches(Object);
    public final void describeMismatch(Object, Description);
    protected abstract boolean matches(Object, Description);
}
org/hamcrest/Factory.class
package org.hamcrest;
public abstract interface Factory extends annotation.Annotation {
}
org/hamcrest/FeatureMatcher.class
package org.hamcrest;
public abstract synchronized class FeatureMatcher extends TypeSafeDiagnosingMatcher {
    private static final internal.ReflectiveTypeFinder TYPE_FINDER;
    private final Matcher subMatcher;
    private final String featureDescription;
    private final String featureName;
    public void FeatureMatcher(Matcher, String, String);
    protected abstract Object featureValueOf(Object);
    protected boolean matchesSafely(Object, Description);
    public final void describeTo(Description);
    static void ();
}
org/hamcrest/Matcher.class
package org.hamcrest;
public abstract interface Matcher extends SelfDescribing {
    public abstract boolean matches(Object);
    public abstract void describeMismatch(Object, Description);
    public abstract void _dont_implement_Matcher___instead_extend_BaseMatcher_();
}
org/hamcrest/MatcherAssert.class
package org.hamcrest;
public synchronized class MatcherAssert {
    public void MatcherAssert();
    public static void assertThat(Object, Matcher);
    public static void assertThat(String, Object, Matcher);
    public static void assertThat(String, boolean);
}
org/hamcrest/SelfDescribing.class
package org.hamcrest;
public abstract interface SelfDescribing {
    public abstract void describeTo(Description);
}
org/hamcrest/StringDescription.class
package org.hamcrest;
public synchronized class StringDescription extends BaseDescription {
    private final Appendable out;
    public void StringDescription();
    public void StringDescription(Appendable);
    public static String toString(SelfDescribing);
    public static String asString(SelfDescribing);
    protected void append(String);
    protected void append(char);
    public String toString();
}
org/hamcrest/TypeSafeDiagnosingMatcher.class
package org.hamcrest;
public abstract synchronized class TypeSafeDiagnosingMatcher extends BaseMatcher {
    private static final internal.ReflectiveTypeFinder TYPE_FINDER;
    private final Class expectedType;
    protected abstract boolean matchesSafely(Object, Description);
    protected void TypeSafeDiagnosingMatcher(Class);
    protected void TypeSafeDiagnosingMatcher(internal.ReflectiveTypeFinder);
    protected void TypeSafeDiagnosingMatcher();
    public final boolean matches(Object);
    public final void describeMismatch(Object, Description);
    static void ();
}
org/hamcrest/TypeSafeMatcher.class
package org.hamcrest;
public abstract synchronized class TypeSafeMatcher extends BaseMatcher {
    private static final internal.ReflectiveTypeFinder TYPE_FINDER;
    private final Class expectedType;
    protected void TypeSafeMatcher();
    protected void TypeSafeMatcher(Class);
    protected void TypeSafeMatcher(internal.ReflectiveTypeFinder);
    protected abstract boolean matchesSafely(Object);
    protected void describeMismatchSafely(Object, Description);
    public final boolean matches(Object);
    public final void describeMismatch(Object, Description);
    static void ();
}
org/hamcrest/core/AllOf.class
package org.hamcrest.core;
public synchronized class AllOf extends org.hamcrest.DiagnosingMatcher {
    private final Iterable matchers;
    public void AllOf(Iterable);
    public boolean matches(Object, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher allOf(Iterable);
    public static transient org.hamcrest.Matcher allOf(org.hamcrest.Matcher[]);
    public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
}
org/hamcrest/core/AnyOf.class
package org.hamcrest.core;
public synchronized class AnyOf extends ShortcutCombination {
    public void AnyOf(Iterable);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public static AnyOf anyOf(Iterable);
    public static transient AnyOf anyOf(org.hamcrest.Matcher[]);
    public static AnyOf anyOf(org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static AnyOf anyOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static AnyOf anyOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static AnyOf anyOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static AnyOf anyOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
}
org/hamcrest/core/CombinableMatcher$CombinableBothMatcher.class
package org.hamcrest.core;
public final synchronized class CombinableMatcher$CombinableBothMatcher {
    private final org.hamcrest.Matcher first;
    public void CombinableMatcher$CombinableBothMatcher(org.hamcrest.Matcher);
    public CombinableMatcher and(org.hamcrest.Matcher);
}
org/hamcrest/core/CombinableMatcher$CombinableEitherMatcher.class
package org.hamcrest.core;
public final synchronized class CombinableMatcher$CombinableEitherMatcher {
    private final org.hamcrest.Matcher first;
    public void CombinableMatcher$CombinableEitherMatcher(org.hamcrest.Matcher);
    public CombinableMatcher or(org.hamcrest.Matcher);
}
org/hamcrest/core/CombinableMatcher.class
package org.hamcrest.core;
public synchronized class CombinableMatcher extends org.hamcrest.TypeSafeDiagnosingMatcher {
    private final org.hamcrest.Matcher matcher;
    public void CombinableMatcher(org.hamcrest.Matcher);
    protected boolean matchesSafely(Object, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    public CombinableMatcher and(org.hamcrest.Matcher);
    public CombinableMatcher or(org.hamcrest.Matcher);
    private java.util.ArrayList templatedListWith(org.hamcrest.Matcher);
    public static CombinableMatcher$CombinableBothMatcher both(org.hamcrest.Matcher);
    public static CombinableMatcher$CombinableEitherMatcher either(org.hamcrest.Matcher);
}
org/hamcrest/core/DescribedAs.class
package org.hamcrest.core;
public synchronized class DescribedAs extends org.hamcrest.BaseMatcher {
    private final String descriptionTemplate;
    private final org.hamcrest.Matcher matcher;
    private final Object[] values;
    private static final java.util.regex.Pattern ARG_PATTERN;
    public void DescribedAs(String, org.hamcrest.Matcher, Object[]);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public void describeMismatch(Object, org.hamcrest.Description);
    public static transient org.hamcrest.Matcher describedAs(String, org.hamcrest.Matcher, Object[]);
    static void ();
}
org/hamcrest/core/Every.class
package org.hamcrest.core;
public synchronized class Every extends org.hamcrest.TypeSafeDiagnosingMatcher {
    private final org.hamcrest.Matcher matcher;
    public void Every(org.hamcrest.Matcher);
    public boolean matchesSafely(Iterable, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher everyItem(org.hamcrest.Matcher);
}
org/hamcrest/core/Is.class
package org.hamcrest.core;
public synchronized class Is extends org.hamcrest.BaseMatcher {
    private final org.hamcrest.Matcher matcher;
    public void Is(org.hamcrest.Matcher);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public void describeMismatch(Object, org.hamcrest.Description);
    public static org.hamcrest.Matcher is(org.hamcrest.Matcher);
    public static org.hamcrest.Matcher is(Object);
    public static org.hamcrest.Matcher is(Class);
    public static org.hamcrest.Matcher isA(Class);
}
org/hamcrest/core/IsAnything.class
package org.hamcrest.core;
public synchronized class IsAnything extends org.hamcrest.BaseMatcher {
    private final String message;
    public void IsAnything();
    public void IsAnything(String);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher anything();
    public static org.hamcrest.Matcher anything(String);
}
org/hamcrest/core/IsCollectionContaining.class
package org.hamcrest.core;
public synchronized class IsCollectionContaining extends org.hamcrest.TypeSafeDiagnosingMatcher {
    private final org.hamcrest.Matcher elementMatcher;
    public void IsCollectionContaining(org.hamcrest.Matcher);
    protected boolean matchesSafely(Iterable, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher hasItem(org.hamcrest.Matcher);
    public static org.hamcrest.Matcher hasItem(Object);
    public static transient org.hamcrest.Matcher hasItems(org.hamcrest.Matcher[]);
    public static transient org.hamcrest.Matcher hasItems(Object[]);
}
org/hamcrest/core/IsEqual.class
package org.hamcrest.core;
public synchronized class IsEqual extends org.hamcrest.BaseMatcher {
    private final Object expectedValue;
    public void IsEqual(Object);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    private static boolean areEqual(Object, Object);
    private static boolean areArraysEqual(Object, Object);
    private static boolean areArrayLengthsEqual(Object, Object);
    private static boolean areArrayElementsEqual(Object, Object);
    private static boolean isArray(Object);
    public static org.hamcrest.Matcher equalTo(Object);
}
org/hamcrest/core/IsInstanceOf.class
package org.hamcrest.core;
public synchronized class IsInstanceOf extends org.hamcrest.DiagnosingMatcher {
    private final Class expectedClass;
    private final Class matchableClass;
    public void IsInstanceOf(Class);
    private static Class matchableClass(Class);
    protected boolean matches(Object, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher instanceOf(Class);
    public static org.hamcrest.Matcher any(Class);
}
org/hamcrest/core/IsNot.class
package org.hamcrest.core;
public synchronized class IsNot extends org.hamcrest.BaseMatcher {
    private final org.hamcrest.Matcher matcher;
    public void IsNot(org.hamcrest.Matcher);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher not(org.hamcrest.Matcher);
    public static org.hamcrest.Matcher not(Object);
}
org/hamcrest/core/IsNull.class
package org.hamcrest.core;
public synchronized class IsNull extends org.hamcrest.BaseMatcher {
    public void IsNull();
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher nullValue();
    public static org.hamcrest.Matcher notNullValue();
    public static org.hamcrest.Matcher nullValue(Class);
    public static org.hamcrest.Matcher notNullValue(Class);
}
org/hamcrest/core/IsSame.class
package org.hamcrest.core;
public synchronized class IsSame extends org.hamcrest.BaseMatcher {
    private final Object object;
    public void IsSame(Object);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher sameInstance(Object);
    public static org.hamcrest.Matcher theInstance(Object);
}
org/hamcrest/core/ShortcutCombination.class
package org.hamcrest.core;
abstract synchronized class ShortcutCombination extends org.hamcrest.BaseMatcher {
    private final Iterable matchers;
    public void ShortcutCombination(Iterable);
    public abstract boolean matches(Object);
    public abstract void describeTo(org.hamcrest.Description);
    protected boolean matches(Object, boolean);
    public void describeTo(org.hamcrest.Description, String);
}
org/hamcrest/core/StringContains.class
package org.hamcrest.core;
public synchronized class StringContains extends SubstringMatcher {
    public void StringContains(String);
    protected boolean evalSubstringOf(String);
    protected String relationship();
    public static org.hamcrest.Matcher containsString(String);
}
org/hamcrest/core/StringEndsWith.class
package org.hamcrest.core;
public synchronized class StringEndsWith extends SubstringMatcher {
    public void StringEndsWith(String);
    protected boolean evalSubstringOf(String);
    protected String relationship();
    public static org.hamcrest.Matcher endsWith(String);
}
org/hamcrest/core/StringStartsWith.class
package org.hamcrest.core;
public synchronized class StringStartsWith extends SubstringMatcher {
    public void StringStartsWith(String);
    protected boolean evalSubstringOf(String);
    protected String relationship();
    public static org.hamcrest.Matcher startsWith(String);
}
org/hamcrest/core/SubstringMatcher.class
package org.hamcrest.core;
public abstract synchronized class SubstringMatcher extends org.hamcrest.TypeSafeMatcher {
    protected final String substring;
    protected void SubstringMatcher(String);
    public boolean matchesSafely(String);
    public void describeMismatchSafely(String, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    protected abstract boolean evalSubstringOf(String);
    protected abstract String relationship();
}
org/hamcrest/internal/ArrayIterator.class
package org.hamcrest.internal;
public synchronized class ArrayIterator implements java.util.Iterator {
    private final Object array;
    private int currentIndex;
    public void ArrayIterator(Object);
    public boolean hasNext();
    public Object next();
    public void remove();
}
org/hamcrest/internal/ReflectiveTypeFinder.class
package org.hamcrest.internal;
public synchronized class ReflectiveTypeFinder {
    private final String methodName;
    private final int expectedNumberOfParameters;
    private final int typedParameter;
    public void ReflectiveTypeFinder(String, int, int);
    public Class findExpectedType(Class);
    protected boolean canObtainExpectedTypeFrom(reflect.Method);
    protected Class expectedTypeFrom(reflect.Method);
}
org/hamcrest/internal/SelfDescribingValue.class
package org.hamcrest.internal;
public synchronized class SelfDescribingValue implements org.hamcrest.SelfDescribing {
    private Object value;
    public void SelfDescribingValue(Object);
    public void describeTo(org.hamcrest.Description);
}
org/hamcrest/internal/SelfDescribingValueIterator.class
package org.hamcrest.internal;
public synchronized class SelfDescribingValueIterator implements java.util.Iterator {
    private java.util.Iterator values;
    public void SelfDescribingValueIterator(java.util.Iterator);
    public boolean hasNext();
    public org.hamcrest.SelfDescribing next();
    public void remove();
}
New folder/Project/jcommon-1.0.23.jar
META-INF/MANIFEST.MF
Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Created-By: Apache Maven
Built-By: dgilbert
Build-Jdk: 1.8.0_05
com/keypoint/PngEncoder.class
package com.keypoint;
public synchronized class PngEncoder {
    public static final boolean ENCODE_ALPHA = 1;
    public static final boolean NO_ALPHA = 0;
    public static final int FILTER_NONE = 0;
    public static final int FILTER_SUB = 1;
    public static final int FILTER_UP = 2;
    public static final int FILTER_LAST = 2;
    protected static final byte[] IHDR;
    protected static final byte[] IDAT;
    protected static final byte[] IEND;
    protected static final byte[] PHYS;
    protected byte[] pngBytes;
    protected byte[] priorRow;
    protected byte[] leftBytes;
    protected java.awt.Image image;
    protected int width;
    protected int height;
    protected int bytePos;
    protected int maxPos;
    protected java.util.zip.CRC32 crc;
    protected long crcValue;
    protected boolean encodeAlpha;
    protected int filter;
    protected int bytesPerPixel;
    private int xDpi;
    private int yDpi;
    private static float INCH_IN_METER_UNIT;
    protected int compressionLevel;
    public void PngEncoder();
    public void PngEncoder(java.awt.Image);
    public void PngEncoder(java.awt.Image, boolean);
    public void PngEncoder(java.awt.Image, boolean, int);
    public void PngEncoder(java.awt.Image, boolean, int, int);
    public void setImage(java.awt.Image);
    public java.awt.Image getImage();
    public byte[] pngEncode(boolean);
    public byte[] pngEncode();
    public void setEncodeAlpha(boolean);
    public boolean getEncodeAlpha();
    public void setFilter(int);
    public int getFilter();
    public void setCompressionLevel(int);
    public int getCompressionLevel();
    protected byte[] resizeByteArray(byte[], int);
    protected int writeBytes(byte[], int);
    protected int writeBytes(byte[], int, int);
    protected int writeInt2(int, int);
    protected int writeInt4(int, int);
    protected int writeByte(int, int);
    protected void writeHeader();
    protected void filterSub(byte[], int, int);
    protected void filterUp(byte[], int, int);
    protected boolean writeImageData();
    protected void writeEnd();
    public void setXDpi(int);
    public int getXDpi();
    public void setYDpi(int);
    public int getYDpi();
    public void setDpi(int, int);
    protected void writeResolution();
    static void ();
}
org/jfree/base/AbstractBoot.class
package org.jfree.base;
public abstract synchronized class AbstractBoot implements modules.SubSystem {
    private org.jfree.util.ExtendedConfigurationWrapper extWrapper;
    private modules.PackageManager packageManager;
    private org.jfree.util.Configuration globalConfig;
    private boolean bootInProgress;
    private boolean bootDone;
    protected void AbstractBoot();
    public synchronized modules.PackageManager getPackageManager();
    public synchronized org.jfree.util.Configuration getGlobalConfig();
    public final synchronized boolean isBootInProgress();
    public final synchronized boolean isBootDone();
    protected abstract org.jfree.util.Configuration loadConfiguration();
    public final void start();
    protected abstract void performBoot();
    protected abstract BootableProjectInfo getProjectInfo();
    protected AbstractBoot loadBooter(String);
    protected org.jfree.util.Configuration createDefaultHierarchicalConfiguration(String, String, boolean);
    protected org.jfree.util.Configuration createDefaultHierarchicalConfiguration(String, String, boolean, Class);
    public synchronized org.jfree.util.ExtendedConfiguration getExtendedConfig();
}
org/jfree/base/BaseBoot.class
package org.jfree.base;
public synchronized class BaseBoot extends AbstractBoot {
    private static BaseBoot singleton;
    private BootableProjectInfo bootableProjectInfo;
    private void BaseBoot();
    public static config.ModifiableConfiguration getConfiguration();
    protected synchronized org.jfree.util.Configuration loadConfiguration();
    public static synchronized AbstractBoot getInstance();
    protected void performBoot();
    protected BootableProjectInfo getProjectInfo();
}
org/jfree/base/BasicProjectInfo$OptionalLibraryHolder.class
package org.jfree.base;
synchronized class BasicProjectInfo$OptionalLibraryHolder {
    private String libraryClass;
    private transient Library library;
    public void BasicProjectInfo$OptionalLibraryHolder(String);
    public void BasicProjectInfo$OptionalLibraryHolder(Library);
    public String getLibraryClass();
    public Library getLibrary();
    protected Library loadLibrary(String);
}
org/jfree/base/BasicProjectInfo.class
package org.jfree.base;
public synchronized class BasicProjectInfo extends Library {
    private String copyright;
    private java.util.List libraries;
    private java.util.List optionalLibraries;
    public void BasicProjectInfo();
    public void BasicProjectInfo(String, String, String, String);
    public void BasicProjectInfo(String, String, String, String, String);
    public String getCopyright();
    public void setCopyright(String);
    public void setInfo(String);
    public void setLicenceName(String);
    public void setName(String);
    public void setVersion(String);
    public Library[] getLibraries();
    public void addLibrary(Library);
    public Library[] getOptionalLibraries();
    public void addOptionalLibrary(String);
    public void addOptionalLibrary(Library);
}
org/jfree/base/BootableProjectInfo.class
package org.jfree.base;
public synchronized class BootableProjectInfo extends BasicProjectInfo {
    private String bootClass;
    private boolean autoBoot;
    public void BootableProjectInfo();
    public void BootableProjectInfo(String, String, String, String);
    public void BootableProjectInfo(String, String, String, String, String);
    public BootableProjectInfo[] getDependencies();
    public void addDependency(BootableProjectInfo);
    public String getBootClass();
    public void setBootClass(String);
    public boolean isAutoBoot();
    public void setAutoBoot(boolean);
}
org/jfree/base/ClassPathDebugger.class
package org.jfree.base;
public synchronized class ClassPathDebugger {
    public void ClassPathDebugger();
    public static void main(String[]);
}
org/jfree/base/config/HierarchicalConfiguration.class
package org.jfree.base.config;
public synchronized class HierarchicalConfiguration implements ModifiableConfiguration, org.jfree.util.PublicCloneable {
    private java.util.Properties configuration;
    private transient org.jfree.util.Configuration parentConfiguration;
    public void HierarchicalConfiguration();
    public void HierarchicalConfiguration(org.jfree.util.Configuration);
    public String getConfigProperty(String);
    public String getConfigProperty(String, String);
    public void setConfigProperty(String, String);
    private boolean isRootConfig();
    public boolean isLocallyDefined(String);
    protected java.util.Properties getConfiguration();
    public void insertConfiguration(HierarchicalConfiguration);
    protected void setParentConfig(org.jfree.util.Configuration);
    protected org.jfree.util.Configuration getParentConfig();
    public java.util.Enumeration getConfigProperties();
    public java.util.Iterator findPropertyKeys(String);
    private void collectPropertyKeys(String, org.jfree.util.Configuration, java.util.TreeSet);
    protected boolean isParentSaved();
    protected void configurationLoaded();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    public Object clone() throws CloneNotSupportedException;
}
org/jfree/base/config/ModifiableConfiguration.class
package org.jfree.base.config;
public abstract interface ModifiableConfiguration extends org.jfree.util.Configuration {
    public abstract void setConfigProperty(String, String);
    public abstract java.util.Enumeration getConfigProperties();
    public abstract java.util.Iterator findPropertyKeys(String);
}
org/jfree/base/config/PropertyFileConfiguration.class
package org.jfree.base.config;
public synchronized class PropertyFileConfiguration extends HierarchicalConfiguration {
    public void PropertyFileConfiguration();
    public void load(String);
    public void load(String, Class);
    public void load(java.io.InputStream);
}
org/jfree/base/config/SystemPropertyConfiguration.class
package org.jfree.base.config;
public synchronized class SystemPropertyConfiguration extends HierarchicalConfiguration {
    public void SystemPropertyConfiguration();
    public void setConfigProperty(String, String);
    public String getConfigProperty(String, String);
    public boolean isLocallyDefined(String);
    public java.util.Enumeration getConfigProperties();
}
org/jfree/base/jcommon.properties
#
# The minimum loglevel that is logged
org.jfree.base.LogLevel=Debug
#
# Where to log. Give a classname of a  valid LogTarget implementation.
# If the name is invalid, no logging is done.
org.jfree.base.LogTarget=*none*
#
# Do not initialize the logging.
org.jfree.base.LogAutoInit=false
#
# Should the debugging system be disabled by default. This option will suppress all
# output, no single line of debug information will be printed. If you want to remove
# System.out-debugging on the server side, try to switch to a Log4J-LogTarget instead.
org.jfree.base.NoDefaultDebug=false
#
# Which ClassLoader to use for loading external resources and classes.
# One of "ThreadContext" or "CallerContext".
org.jfree.ClassLoader=ThreadContext
#
# Applies a workaround to fix a JDK bug. When the value is set to auto,
# This is enabled if the JDK is not version 1.4 or higher.
org.jfree.text.UseDrawRotatedStringWorkaround=auto
#
# Applies a workaround to fix a JDK bug. When the value is set to auto,
# This is disabled if the JDK is not version 1.4 or higher.
org.jfree.text.UseFontMetricsGetStringBounds=auto
#
# Known extra modules. Do not edit and do not delete the following lines.
#
# That module loading mechanism is not really extensible. A better
# implementation might solve that at a later time.  
org.jfree.jcommon.modules.logger.Log4J.Module=org.jfree.logger.java14.Java14LogModule
org.jfree.jcommon.modules.logger.Java14Logging.Module=org.jfree.logger.log4j.Log4JLogModule
org.jfree.jcommon.modules.logger.JakartaLogging.Module=org.jfree.logger.jcl.JakartaLogModule
org/jfree/base/Library.class
package org.jfree.base;
public synchronized class Library {
    private String name;
    private String version;
    private String licenceName;
    private String info;
    public void Library(String, String, String, String);
    protected void Library();
    public String getName();
    public String getVersion();
    public String getLicenceName();
    public String getInfo();
    protected void setInfo(String);
    protected void setLicenceName(String);
    protected void setName(String);
    protected void setVersion(String);
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/base/log/DefaultLog.class
package org.jfree.base.log;
public synchronized class DefaultLog extends org.jfree.util.Log {
    private static final org.jfree.util.PrintStreamLogTarget DEFAULT_LOG_TARGET;
    private static final DefaultLog defaultLogInstance;
    protected void DefaultLog();
    public void init();
    public synchronized void addTarget(org.jfree.util.LogTarget);
    public static DefaultLog getDefaultLog();
    public static void installDefaultLog();
    static void ();
}
org/jfree/base/log/DefaultLogModule.class
package org.jfree.base.log;
public synchronized class DefaultLogModule extends org.jfree.base.modules.AbstractModule {
    public void DefaultLogModule() throws org.jfree.base.modules.ModuleInitializeException;
    public void initialize(org.jfree.base.modules.SubSystem) throws org.jfree.base.modules.ModuleInitializeException;
}
org/jfree/base/log/LogConfiguration.class
package org.jfree.base.log;
public synchronized class LogConfiguration {
    public static final String DISABLE_LOGGING_DEFAULT = false;
    public static final String LOGLEVEL = org.jfree.base.LogLevel;
    public static final String LOGLEVEL_DEFAULT = Info;
    public static final String LOGTARGET = org.jfree.base.LogTarget;
    public static final String LOGTARGET_DEFAULT;
    public static final String DISABLE_LOGGING = org.jfree.base.NoDefaultDebug;
    private void LogConfiguration();
    public static String getLogTarget();
    public static void setLogTarget(String);
    public static String getLogLevel();
    public static void setLogLevel(String);
    public static boolean isDisableLogging();
    public static void setDisableLogging(boolean);
    static void ();
}
org/jfree/base/log/MemoryUsageMessage.class
package org.jfree.base.log;
public synchronized class MemoryUsageMessage {
    private final String message;
    public void MemoryUsageMessage(String);
    public String toString();
}
org/jfree/base/log/module.properties
#
# Support for logging.
#
module-info:
  name: base-logging-module
  producer: The JFreeChart project - www.jfree.org/jcommon
  description: Initialializer to configure the log system and to provide
               a facility for logging to the System.out stream.
  version.major: 1
  version.minor: 0
  version.patchlevel: 0
  subsystem: logging
org/jfree/base/log/PadMessage.class
package org.jfree.base.log;
public synchronized class PadMessage {
    private final Object text;
    private final int length;
    public void PadMessage(Object, int);
    public String toString();
}
org/jfree/base/modules/AbstractModule$ReaderHelper.class
package org.jfree.base.modules;
synchronized class AbstractModule$ReaderHelper {
    private String buffer;
    private final java.io.BufferedReader reader;
    protected void AbstractModule$ReaderHelper(java.io.BufferedReader);
    public boolean hasNext() throws java.io.IOException;
    public String next();
    public void pushBack(String);
    protected String readLine() throws java.io.IOException;
    public void close() throws java.io.IOException;
}
org/jfree/base/modules/AbstractModule.class
package org.jfree.base.modules;
public abstract synchronized class AbstractModule extends DefaultModuleInfo implements Module {
    private ModuleInfo[] requiredModules;
    private ModuleInfo[] optionalModules;
    private String name;
    private String description;
    private String producer;
    private String subsystem;
    public void AbstractModule();
    protected void loadModuleInfo() throws ModuleInitializeException;
    protected void loadModuleInfo(java.io.InputStream) throws ModuleInitializeException;
    private String readValue(AbstractModule$ReaderHelper, String) throws java.io.IOException;
    private boolean isNextLineValueLine(AbstractModule$ReaderHelper) throws java.io.IOException;
    private void readModuleInfo(AbstractModule$ReaderHelper) throws java.io.IOException;
    private String parseKey(String);
    private String parseValue(String);
    private DefaultModuleInfo readExternalModule(AbstractModule$ReaderHelper) throws java.io.IOException;
    public String getName();
    protected void setName(String);
    public String getDescription();
    protected void setDescription(String);
    public String getProducer();
    protected void setProducer(String);
    public ModuleInfo[] getRequiredModules();
    public ModuleInfo[] getOptionalModules();
    protected void setRequiredModules(ModuleInfo[]);
    public void setOptionalModules(ModuleInfo[]);
    public String toString();
    protected static boolean isClassLoadable(String);
    protected static boolean isClassLoadable(String, Class);
    public void configure(SubSystem);
    protected void performExternalInitialize(String) throws ModuleInitializeException;
    protected void performExternalInitialize(String, Class) throws ModuleInitializeException;
    public String getSubSystem();
    protected void setSubSystem(String);
}
org/jfree/base/modules/DefaultModuleInfo.class
package org.jfree.base.modules;
public synchronized class DefaultModuleInfo implements ModuleInfo {
    private String moduleClass;
    private String majorVersion;
    private String minorVersion;
    private String patchLevel;
    public void DefaultModuleInfo();
    public void DefaultModuleInfo(String, String, String, String);
    public String getModuleClass();
    public void setModuleClass(String);
    public String getMajorVersion();
    public void setMajorVersion(String);
    public String getMinorVersion();
    public void setMinorVersion(String);
    public String getPatchLevel();
    public void setPatchLevel(String);
    public boolean equals(Object);
    public int hashCode();
    public String toString();
}
org/jfree/base/modules/Module.class
package org.jfree.base.modules;
public abstract interface Module extends ModuleInfo {
    public abstract ModuleInfo[] getRequiredModules();
    public abstract ModuleInfo[] getOptionalModules();
    public abstract void initialize(SubSystem) throws ModuleInitializeException;
    public abstract void configure(SubSystem);
    public abstract String getDescription();
    public abstract String getProducer();
    public abstract String getName();
    public abstract String getSubSystem();
}
org/jfree/base/modules/ModuleInfo.class
package org.jfree.base.modules;
public abstract interface ModuleInfo {
    public abstract String getModuleClass();
    public abstract String getMajorVersion();
    public abstract String getMinorVersion();
    public abstract String getPatchLevel();
}
org/jfree/base/modules/ModuleInitializeException.class
package org.jfree.base.modules;
public synchronized class ModuleInitializeException extends org.jfree.util.StackableException {
    public void ModuleInitializeException();
    public void ModuleInitializeException(String, Exception);
    public void ModuleInitializeException(String);
}
org/jfree/base/modules/ModuleInitializer.class
package org.jfree.base.modules;
public abstract interface ModuleInitializer {
    public abstract void performInit() throws ModuleInitializeException;
}
org/jfree/base/modules/PackageManager$PackageConfiguration.class
package org.jfree.base.modules;
public synchronized class PackageManager$PackageConfiguration extends org.jfree.base.config.PropertyFileConfiguration {
    public void PackageManager$PackageConfiguration();
    public void insertConfiguration(org.jfree.base.config.HierarchicalConfiguration);
}
org/jfree/base/modules/PackageManager.class
package org.jfree.base.modules;
public final synchronized class PackageManager {
    private static final int RETURN_MODULE_LOADED = 0;
    private static final int RETURN_MODULE_UNKNOWN = 1;
    private static final int RETURN_MODULE_ERROR = 2;
    private final PackageManager$PackageConfiguration packageConfiguration;
    private final java.util.ArrayList modules;
    private final java.util.ArrayList initSections;
    private org.jfree.base.AbstractBoot booter;
    private static java.util.HashMap instances;
    public static PackageManager createInstance(org.jfree.base.AbstractBoot);
    private void PackageManager(org.jfree.base.AbstractBoot);
    public boolean isModuleAvailable(ModuleInfo);
    public void load(String);
    public synchronized void initializeModules();
    public synchronized void addModule(String);
    private int containsModule(java.util.ArrayList, ModuleInfo);
    private void dropFailedModule(PackageState);
    private boolean loadModule(ModuleInfo, java.util.ArrayList, java.util.ArrayList, boolean);
    private boolean acceptVersion(ModuleInfo, Module);
    private int acceptVersion(String, String);
    public PackageManager$PackageConfiguration getPackageConfiguration();
    public Module[] getAllModules();
    public Module[] getActiveModules();
    public void printUsedModules(java.io.PrintStream);
}
org/jfree/base/modules/PackageSorter$SortModule.class
package org.jfree.base.modules;
synchronized class PackageSorter$SortModule implements Comparable {
    private int position;
    private final PackageState state;
    private java.util.ArrayList dependSubsystems;
    public void PackageSorter$SortModule(PackageState);
    public java.util.ArrayList getDependSubsystems();
    public void setDependSubsystems(java.util.ArrayList);
    public int getPosition();
    public void setPosition(int);
    public PackageState getState();
    public String toString();
    public int compareTo(Object);
}
org/jfree/base/modules/PackageSorter.class
package org.jfree.base.modules;
public final synchronized class PackageSorter {
    private void PackageSorter();
    public static void sort(java.util.List);
    private static int searchModulePosition(PackageSorter$SortModule, java.util.HashMap);
    private static boolean isBaseModule(Module, ModuleInfo);
    private static java.util.ArrayList collectSubsystemModules(Module, java.util.HashMap);
}
org/jfree/base/modules/PackageState.class
package org.jfree.base.modules;
public synchronized class PackageState {
    public static final int STATE_NEW = 0;
    public static final int STATE_CONFIGURED = 1;
    public static final int STATE_INITIALIZED = 2;
    public static final int STATE_ERROR = -2;
    private final Module module;
    private int state;
    public void PackageState(Module);
    public void PackageState(Module, int);
    public boolean configure(SubSystem);
    public Module getModule();
    public int getState();
    public boolean initialize(SubSystem);
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/base/modules/SubSystem.class
package org.jfree.base.modules;
public abstract interface SubSystem {
    public abstract org.jfree.util.Configuration getGlobalConfig();
    public abstract org.jfree.util.ExtendedConfiguration getExtendedConfig();
    public abstract PackageManager getPackageManager();
}
org/jfree/date/AnnualDateRule.class
package org.jfree.date;
public abstract synchronized class AnnualDateRule implements Cloneable {
    protected void AnnualDateRule();
    public abstract SerialDate getDate(int);
    public Object clone() throws CloneNotSupportedException;
}
org/jfree/date/DateUtilities.class
package org.jfree.date;
public synchronized class DateUtilities {
    private static final java.util.Calendar CALENDAR;
    private void DateUtilities();
    public static synchronized java.util.Date createDate(int, int, int);
    public static synchronized java.util.Date createDate(int, int, int, int, int);
    static void ();
}
org/jfree/date/DayAndMonthRule.class
package org.jfree.date;
public synchronized class DayAndMonthRule extends AnnualDateRule {
    private int dayOfMonth;
    private int month;
    public void DayAndMonthRule();
    public void DayAndMonthRule(int, int);
    public int getDayOfMonth();
    public void setDayOfMonth(int);
    public int getMonth();
    public void setMonth(int);
    public SerialDate getDate(int);
}
org/jfree/date/DayOfWeekInMonthRule.class
package org.jfree.date;
public synchronized class DayOfWeekInMonthRule extends AnnualDateRule {
    private int count;
    private int dayOfWeek;
    private int month;
    public void DayOfWeekInMonthRule();
    public void DayOfWeekInMonthRule(int, int, int);
    public int getCount();
    public void setCount(int);
    public int getDayOfWeek();
    public void setDayOfWeek(int);
    public int getMonth();
    public void setMonth(int);
    public SerialDate getDate(int);
}
org/jfree/date/EasterSundayRule.class
package org.jfree.date;
public synchronized class EasterSundayRule extends AnnualDateRule {
    public void EasterSundayRule();
    public SerialDate getDate(int);
}
org/jfree/date/MonthConstants.class
package org.jfree.date;
public abstract interface MonthConstants {
    public static final int JANUARY = 1;
    public static final int FEBRUARY = 2;
    public static final int MARCH = 3;
    public static final int APRIL = 4;
    public static final int MAY = 5;
    public static final int JUNE = 6;
    public static final int JULY = 7;
    public static final int AUGUST = 8;
    public static final int SEPTEMBER = 9;
    public static final int OCTOBER = 10;
    public static final int NOVEMBER = 11;
    public static final int DECEMBER = 12;
}
org/jfree/date/RelativeDayOfWeekRule.class
package org.jfree.date;
public synchronized class RelativeDayOfWeekRule extends AnnualDateRule {
    private AnnualDateRule subrule;
    private int dayOfWeek;
    private int relative;
    public void RelativeDayOfWeekRule();
    public void RelativeDayOfWeekRule(AnnualDateRule, int, int);
    public AnnualDateRule getSubrule();
    public void setSubrule(AnnualDateRule);
    public int getDayOfWeek();
    public void setDayOfWeek(int);
    public int getRelative();
    public void setRelative(int);
    public Object clone() throws CloneNotSupportedException;
    public SerialDate getDate(int);
}
org/jfree/date/SerialDate.class
package org.jfree.date;
public abstract synchronized class SerialDate implements Comparable, java.io.Serializable, MonthConstants {
    private static final long serialVersionUID = -293716040467423637;
    public static final java.text.DateFormatSymbols DATE_FORMAT_SYMBOLS;
    public static final int SERIAL_LOWER_BOUND = 2;
    public static final int SERIAL_UPPER_BOUND = 2958465;
    public static final int MINIMUM_YEAR_SUPPORTED = 1900;
    public static final int MAXIMUM_YEAR_SUPPORTED = 9999;
    public static final int MONDAY = 2;
    public static final int TUESDAY = 3;
    public static final int WEDNESDAY = 4;
    public static final int THURSDAY = 5;
    public static final int FRIDAY = 6;
    public static final int SATURDAY = 7;
    public static final int SUNDAY = 1;
    static final int[] LAST_DAY_OF_MONTH;
    static final int[] AGGREGATE_DAYS_TO_END_OF_MONTH;
    static final int[] AGGREGATE_DAYS_TO_END_OF_PRECEDING_MONTH;
    static final int[] LEAP_YEAR_AGGREGATE_DAYS_TO_END_OF_MONTH;
    static final int[] LEAP_YEAR_AGGREGATE_DAYS_TO_END_OF_PRECEDING_MONTH;
    public static final int FIRST_WEEK_IN_MONTH = 1;
    public static final int SECOND_WEEK_IN_MONTH = 2;
    public static final int THIRD_WEEK_IN_MONTH = 3;
    public static final int FOURTH_WEEK_IN_MONTH = 4;
    public static final int LAST_WEEK_IN_MONTH = 0;
    public static final int INCLUDE_NONE = 0;
    public static final int INCLUDE_FIRST = 1;
    public static final int INCLUDE_SECOND = 2;
    public static final int INCLUDE_BOTH = 3;
    public static final int PRECEDING = -1;
    public static final int NEAREST = 0;
    public static final int FOLLOWING = 1;
    private String description;
    protected void SerialDate();
    public static boolean isValidWeekdayCode(int);
    public static int stringToWeekdayCode(String);
    public static String weekdayCodeToString(int);
    public static String[] getMonths();
    public static String[] getMonths(boolean);
    public static boolean isValidMonthCode(int);
    public static int monthCodeToQuarter(int);
    public static String monthCodeToString(int);
    public static String monthCodeToString(int, boolean);
    public static int stringToMonthCode(String);
    public static boolean isValidWeekInMonthCode(int);
    public static boolean isLeapYear(int);
    public static int leapYearCount(int);
    public static int lastDayOfMonth(int, int);
    public static SerialDate addDays(int, SerialDate);
    public static SerialDate addMonths(int, SerialDate);
    public static SerialDate addYears(int, SerialDate);
    public static SerialDate getPreviousDayOfWeek(int, SerialDate);
    public static SerialDate getFollowingDayOfWeek(int, SerialDate);
    public static SerialDate getNearestDayOfWeek(int, SerialDate);
    public SerialDate getEndOfCurrentMonth(SerialDate);
    public static String weekInMonthToString(int);
    public static String relativeToString(int);
    public static SerialDate createInstance(int, int, int);
    public static SerialDate createInstance(int);
    public static SerialDate createInstance(java.util.Date);
    public abstract int toSerial();
    public abstract java.util.Date toDate();
    public String getDescription();
    public void setDescription(String);
    public String toString();
    public abstract int getYYYY();
    public abstract int getMonth();
    public abstract int getDayOfMonth();
    public abstract int getDayOfWeek();
    public abstract int compare(SerialDate);
    public abstract boolean isOn(SerialDate);
    public abstract boolean isBefore(SerialDate);
    public abstract boolean isOnOrBefore(SerialDate);
    public abstract boolean isAfter(SerialDate);
    public abstract boolean isOnOrAfter(SerialDate);
    public abstract boolean isInRange(SerialDate, SerialDate);
    public abstract boolean isInRange(SerialDate, SerialDate, int);
    public SerialDate getPreviousDayOfWeek(int);
    public SerialDate getFollowingDayOfWeek(int);
    public SerialDate getNearestDayOfWeek(int);
    static void ();
}
org/jfree/date/SerialDateUtilities.class
package org.jfree.date;
public synchronized class SerialDateUtilities {
    private java.text.DateFormatSymbols dateFormatSymbols;
    private String[] weekdays;
    private String[] months;
    public void SerialDateUtilities();
    public String[] getWeekdays();
    public String[] getMonths();
    public int stringToWeekday(String);
    public static int dayCountActual(SerialDate, SerialDate);
    public static int dayCount30(SerialDate, SerialDate);
    public static int dayCount30ISDA(SerialDate, SerialDate);
    public static int dayCount30PSA(SerialDate, SerialDate);
    public static int dayCount30E(SerialDate, SerialDate);
    public static boolean isLastDayOfFebruary(SerialDate);
    public static int countFeb29s(SerialDate, SerialDate);
}
org/jfree/date/SpreadsheetDate.class
package org.jfree.date;
public synchronized class SpreadsheetDate extends SerialDate {
    private static final long serialVersionUID = -2039586705374454461;
    private final int serial;
    private final int day;
    private final int month;
    private final int year;
    public void SpreadsheetDate(int, int, int);
    public void SpreadsheetDate(int);
    public int toSerial();
    public java.util.Date toDate();
    public int getYYYY();
    public int getMonth();
    public int getDayOfMonth();
    public int getDayOfWeek();
    public boolean equals(Object);
    public int hashCode();
    public int compare(SerialDate);
    public int compareTo(Object);
    public boolean isOn(SerialDate);
    public boolean isBefore(SerialDate);
    public boolean isOnOrBefore(SerialDate);
    public boolean isAfter(SerialDate);
    public boolean isOnOrAfter(SerialDate);
    public boolean isInRange(SerialDate, SerialDate);
    public boolean isInRange(SerialDate, SerialDate, int);
    private int calcSerial(int, int, int);
}
org/jfree/io/FileUtilities.class
package org.jfree.io;
public synchronized class FileUtilities {
    private void FileUtilities();
    public static java.io.File findFileOnClassPath(String);
}
org/jfree/io/IOUtils.class
package org.jfree.io;
public synchronized class IOUtils {
    private static IOUtils instance;
    private void IOUtils();
    public static IOUtils getInstance();
    private boolean isFileStyleProtocol(java.net.URL);
    private java.util.List parseName(String);
    private String formatName(java.util.List, String);
    private int startsWithUntil(java.util.List, java.util.List);
    private boolean isSameService(java.net.URL, java.net.URL);
    public String createRelativeURL(java.net.URL, java.net.URL);
    private boolean isPath(java.net.URL);
    private String getQuery(java.net.URL);
    private String getPath(java.net.URL);
    public void copyStreams(java.io.InputStream, java.io.OutputStream) throws java.io.IOException;
    public void copyStreams(java.io.InputStream, java.io.OutputStream, int) throws java.io.IOException;
    public void copyWriter(java.io.Reader, java.io.Writer) throws java.io.IOException;
    public void copyWriter(java.io.Reader, java.io.Writer, int) throws java.io.IOException;
    public String getFileName(java.net.URL);
    public String stripFileExtension(String);
    public String getFileExtension(String);
    public boolean isSubDirectory(java.io.File, java.io.File) throws java.io.IOException;
}
org/jfree/io/SerialUtilities.class
package org.jfree.io;
public synchronized class SerialUtilities {
    private void SerialUtilities();
    public static boolean isSerializable(Class);
    public static java.awt.Paint readPaint(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    public static void writePaint(java.awt.Paint, java.io.ObjectOutputStream) throws java.io.IOException;
    public static java.awt.Stroke readStroke(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    public static void writeStroke(java.awt.Stroke, java.io.ObjectOutputStream) throws java.io.IOException;
    public static java.awt.Composite readComposite(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    public static void writeComposite(java.awt.Composite, java.io.ObjectOutputStream) throws java.io.IOException;
    public static java.awt.Shape readShape(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    public static void writeShape(java.awt.Shape, java.io.ObjectOutputStream) throws java.io.IOException;
    public static java.awt.geom.Point2D readPoint2D(java.io.ObjectInputStream) throws java.io.IOException;
    public static void writePoint2D(java.awt.geom.Point2D, java.io.ObjectOutputStream) throws java.io.IOException;
    public static java.text.AttributedString readAttributedString(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    public static void writeAttributedString(java.text.AttributedString, java.io.ObjectOutputStream) throws java.io.IOException;
}
org/jfree/JCommon.class
package org.jfree;
public final synchronized class JCommon {
    public static final ui.about.ProjectInfo INFO;
    private void JCommon();
    public static void main(String[]);
    static void ();
}
org/jfree/JCommonInfo.class
package org.jfree;
public synchronized class JCommonInfo extends ui.about.ProjectInfo {
    private static JCommonInfo singleton;
    public static synchronized JCommonInfo getInstance();
    private void JCommonInfo();
}
org/jfree/layout/CenterLayout.class
package org.jfree.layout;
public synchronized class CenterLayout implements java.awt.LayoutManager, java.io.Serializable {
    private static final long serialVersionUID = 469319532333015042;
    public void CenterLayout();
    public java.awt.Dimension preferredLayoutSize(java.awt.Container);
    public java.awt.Dimension minimumLayoutSize(java.awt.Container);
    public void layoutContainer(java.awt.Container);
    public void addLayoutComponent(java.awt.Component);
    public void removeLayoutComponent(java.awt.Component);
    public void addLayoutComponent(String, java.awt.Component);
    public void removeLayoutComponent(String, java.awt.Component);
}
org/jfree/layout/FormatLayout.class
package org.jfree.layout;
public synchronized class FormatLayout implements java.awt.LayoutManager, java.io.Serializable {
    private static final long serialVersionUID = 2866692886323930722;
    public static final int C = 1;
    public static final int LC = 2;
    public static final int LCB = 3;
    public static final int LCLC = 4;
    public static final int LCLCB = 5;
    public static final int LCBLC = 6;
    public static final int LCBLCB = 7;
    private int[] rowFormats;
    private int rowGap;
    private int[] columnGaps;
    private int[] rowHeights;
    private int totalHeight;
    private int[] columnWidths;
    private int totalWidth;
    private int columns1and2Width;
    private int columns4and5Width;
    private int columns1to4Width;
    private int columns1to5Width;
    private int columns0to5Width;
    public void FormatLayout(int, int[]);
    public java.awt.Dimension preferredLayoutSize(java.awt.Container);
    public java.awt.Dimension minimumLayoutSize(java.awt.Container);
    public void layoutContainer(java.awt.Container);
    protected void updateC(int, java.awt.Dimension);
    protected void updateLC(int, java.awt.Dimension, java.awt.Dimension);
    protected void updateLCB(int, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension);
    protected void updateLCLC(int, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension);
    protected void updateLCBLC(int, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension);
    protected void updateLCLCB(int, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension);
    protected void updateLCBLCB(int, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension, java.awt.Dimension);
    public void complete();
    private boolean splitLayout();
    public void addLayoutComponent(java.awt.Component);
    public void removeLayoutComponent(java.awt.Component);
    public void addLayoutComponent(String, java.awt.Component);
    public void removeLayoutComponent(String, java.awt.Component);
}
org/jfree/layout/LCBLayout.class
package org.jfree.layout;
public synchronized class LCBLayout implements java.awt.LayoutManager, java.io.Serializable {
    private static final long serialVersionUID = -2531780832406163833;
    private static final int COLUMNS = 3;
    private int[] colWidth;
    private int[] rowHeight;
    private int labelGap;
    private int buttonGap;
    private int vGap;
    public void LCBLayout(int);
    public java.awt.Dimension preferredLayoutSize(java.awt.Container);
    public java.awt.Dimension minimumLayoutSize(java.awt.Container);
    public void layoutContainer(java.awt.Container);
    public void addLayoutComponent(java.awt.Component);
    public void removeLayoutComponent(java.awt.Component);
    public void addLayoutComponent(String, java.awt.Component);
    public void removeLayoutComponent(String, java.awt.Component);
}
org/jfree/layout/RadialLayout.class
package org.jfree.layout;
public synchronized class RadialLayout implements java.awt.LayoutManager, java.io.Serializable {
    private static final long serialVersionUID = -7582156799248315534;
    private int minWidth;
    private int minHeight;
    private int maxCompWidth;
    private int maxCompHeight;
    private int preferredWidth;
    private int preferredHeight;
    private boolean sizeUnknown;
    public void RadialLayout();
    public void addLayoutComponent(java.awt.Component);
    public void removeLayoutComponent(java.awt.Component);
    public void addLayoutComponent(String, java.awt.Component);
    public void removeLayoutComponent(String, java.awt.Component);
    private void setSizes(java.awt.Container);
    public java.awt.Dimension preferredLayoutSize(java.awt.Container);
    public java.awt.Dimension minimumLayoutSize(java.awt.Container);
    public void layoutContainer(java.awt.Container);
    public String toString();
    public static void main(String[]) throws Exception;
}
org/jfree/resources/JCommonResources.class
package org.jfree.resources;
public synchronized class JCommonResources extends java.util.ListResourceBundle {
    private static final Object[][] CONTENTS;
    public void JCommonResources();
    public Object[][] getContents();
    static void ();
}
org/jfree/text/G2TextMeasurer.class
package org.jfree.text;
public synchronized class G2TextMeasurer implements TextMeasurer {
    private java.awt.Graphics2D g2;
    public void G2TextMeasurer(java.awt.Graphics2D);
    public float getStringWidth(String, int, int);
}
org/jfree/text/TextBlock.class
package org.jfree.text;
public synchronized class TextBlock implements java.io.Serializable {
    private static final long serialVersionUID = -4333175719424385526;
    private java.util.List lines;
    private org.jfree.ui.HorizontalAlignment lineAlignment;
    public void TextBlock();
    public org.jfree.ui.HorizontalAlignment getLineAlignment();
    public void setLineAlignment(org.jfree.ui.HorizontalAlignment);
    public void addLine(String, java.awt.Font, java.awt.Paint);
    public void addLine(TextLine);
    public TextLine getLastLine();
    public java.util.List getLines();
    public org.jfree.ui.Size2D calculateDimensions(java.awt.Graphics2D);
    public java.awt.Shape calculateBounds(java.awt.Graphics2D, float, float, TextBlockAnchor, float, float, double);
    public void draw(java.awt.Graphics2D, float, float, TextBlockAnchor);
    public void draw(java.awt.Graphics2D, float, float, TextBlockAnchor, float, float, double);
    private float[] calculateOffsets(TextBlockAnchor, double, double);
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/text/TextBlockAnchor.class
package org.jfree.text;
public final synchronized class TextBlockAnchor implements java.io.Serializable {
    private static final long serialVersionUID = -3045058380983401544;
    public static final TextBlockAnchor TOP_LEFT;
    public static final TextBlockAnchor TOP_CENTER;
    public static final TextBlockAnchor TOP_RIGHT;
    public static final TextBlockAnchor CENTER_LEFT;
    public static final TextBlockAnchor CENTER;
    public static final TextBlockAnchor CENTER_RIGHT;
    public static final TextBlockAnchor BOTTOM_LEFT;
    public static final TextBlockAnchor BOTTOM_CENTER;
    public static final TextBlockAnchor BOTTOM_RIGHT;
    private String name;
    private void TextBlockAnchor(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/text/TextBox.class
package org.jfree.text;
public synchronized class TextBox implements java.io.Serializable {
    private static final long serialVersionUID = 3360220213180203706;
    private transient java.awt.Paint outlinePaint;
    private transient java.awt.Stroke outlineStroke;
    private org.jfree.ui.RectangleInsets interiorGap;
    private transient java.awt.Paint backgroundPaint;
    private transient java.awt.Paint shadowPaint;
    private double shadowXOffset;
    private double shadowYOffset;
    private TextBlock textBlock;
    public void TextBox();
    public void TextBox(String);
    public void TextBox(TextBlock);
    public java.awt.Paint getOutlinePaint();
    public void setOutlinePaint(java.awt.Paint);
    public java.awt.Stroke getOutlineStroke();
    public void setOutlineStroke(java.awt.Stroke);
    public org.jfree.ui.RectangleInsets getInteriorGap();
    public void setInteriorGap(org.jfree.ui.RectangleInsets);
    public java.awt.Paint getBackgroundPaint();
    public void setBackgroundPaint(java.awt.Paint);
    public java.awt.Paint getShadowPaint();
    public void setShadowPaint(java.awt.Paint);
    public double getShadowXOffset();
    public void setShadowXOffset(double);
    public double getShadowYOffset();
    public void setShadowYOffset(double);
    public TextBlock getTextBlock();
    public void setTextBlock(TextBlock);
    public void draw(java.awt.Graphics2D, float, float, org.jfree.ui.RectangleAnchor);
    public double getHeight(java.awt.Graphics2D);
    public boolean equals(Object);
    public int hashCode();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/text/TextFragment.class
package org.jfree.text;
public synchronized class TextFragment implements java.io.Serializable {
    private static final long serialVersionUID = 4465945952903143262;
    public static final java.awt.Font DEFAULT_FONT;
    public static final java.awt.Paint DEFAULT_PAINT;
    private String text;
    private java.awt.Font font;
    private transient java.awt.Paint paint;
    private float baselineOffset;
    protected static final org.jfree.util.LogContext logger;
    public void TextFragment(String);
    public void TextFragment(String, java.awt.Font);
    public void TextFragment(String, java.awt.Font, java.awt.Paint);
    public void TextFragment(String, java.awt.Font, java.awt.Paint, float);
    public String getText();
    public java.awt.Font getFont();
    public java.awt.Paint getPaint();
    public float getBaselineOffset();
    public void draw(java.awt.Graphics2D, float, float, org.jfree.ui.TextAnchor, float, float, double);
    public org.jfree.ui.Size2D calculateDimensions(java.awt.Graphics2D);
    public float calculateBaselineOffset(java.awt.Graphics2D, org.jfree.ui.TextAnchor);
    public boolean equals(Object);
    public int hashCode();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    static void ();
}
org/jfree/text/TextLine.class
package org.jfree.text;
public synchronized class TextLine implements java.io.Serializable {
    private static final long serialVersionUID = 7100085690160465444;
    private java.util.List fragments;
    public void TextLine();
    public void TextLine(String);
    public void TextLine(String, java.awt.Font);
    public void TextLine(String, java.awt.Font, java.awt.Paint);
    public void addFragment(TextFragment);
    public void removeFragment(TextFragment);
    public void draw(java.awt.Graphics2D, float, float, org.jfree.ui.TextAnchor, float, float, double);
    public org.jfree.ui.Size2D calculateDimensions(java.awt.Graphics2D);
    public TextFragment getFirstTextFragment();
    public TextFragment getLastTextFragment();
    private float calculateBaselineOffset(java.awt.Graphics2D, org.jfree.ui.TextAnchor);
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/text/TextMeasurer.class
package org.jfree.text;
public abstract interface TextMeasurer {
    public abstract float getStringWidth(String, int, int);
}
org/jfree/text/TextUtilities.class
package org.jfree.text;
public synchronized class TextUtilities {
    protected static final org.jfree.util.LogContext logger;
    private static boolean drawStringsWithFontAttributes;
    private static boolean useDrawRotatedStringWorkaround;
    private static boolean useFontMetricsGetStringBounds;
    private void TextUtilities();
    public static TextBlock createTextBlock(String, java.awt.Font, java.awt.Paint);
    public static TextBlock createTextBlock(String, java.awt.Font, java.awt.Paint, float, TextMeasurer);
    public static TextBlock createTextBlock(String, java.awt.Font, java.awt.Paint, float, int, TextMeasurer);
    private static int nextLineBreak(String, int, float, java.text.BreakIterator, TextMeasurer);
    public static java.awt.geom.Rectangle2D getTextBounds(String, java.awt.Graphics2D, java.awt.FontMetrics);
    public static java.awt.geom.Rectangle2D drawAlignedString(String, java.awt.Graphics2D, float, float, org.jfree.ui.TextAnchor);
    private static float[] deriveTextBoundsAnchorOffsets(java.awt.Graphics2D, String, org.jfree.ui.TextAnchor, java.awt.geom.Rectangle2D);
    public static void drawRotatedString(String, java.awt.Graphics2D, double, float, float);
    public static void drawRotatedString(String, java.awt.Graphics2D, float, float, double, float, float);
    public static void drawRotatedString(String, java.awt.Graphics2D, float, float, org.jfree.ui.TextAnchor, double, float, float);
    public static void drawRotatedString(String, java.awt.Graphics2D, float, float, org.jfree.ui.TextAnchor, double, org.jfree.ui.TextAnchor);
    public static java.awt.Shape calculateRotatedStringBounds(String, java.awt.Graphics2D, float, float, org.jfree.ui.TextAnchor, double, org.jfree.ui.TextAnchor);
    private static float[] deriveTextBoundsAnchorOffsets(java.awt.Graphics2D, String, org.jfree.ui.TextAnchor);
    private static float[] deriveRotationAnchorOffsets(java.awt.Graphics2D, String, org.jfree.ui.TextAnchor);
    public static java.awt.Shape calculateRotatedStringBounds(String, java.awt.Graphics2D, float, float, double, float, float);
    public static boolean getUseFontMetricsGetStringBounds();
    public static void setUseFontMetricsGetStringBounds(boolean);
    public static boolean isUseDrawRotatedStringWorkaround();
    public static void setUseDrawRotatedStringWorkaround(boolean);
    public static boolean getDrawStringsWithFontAttributes();
    public static void setDrawStringsWithFontAttributes(boolean);
    static void ();
}
org/jfree/threads/ReaderWriterLock$1.class
package org.jfree.threads;
synchronized class ReaderWriterLock$1 {
}
org/jfree/threads/ReaderWriterLock$ReaderWriterNode.class
package org.jfree.threads;
synchronized class ReaderWriterLock$ReaderWriterNode {
    protected static final int READER = 0;
    protected static final int WRITER = 1;
    protected Thread t;
    protected int state;
    protected int nAcquires;
    private void ReaderWriterLock$ReaderWriterNode(Thread, int);
}
org/jfree/threads/ReaderWriterLock.class
package org.jfree.threads;
public synchronized class ReaderWriterLock {
    private java.util.ArrayList waiters;
    public void ReaderWriterLock();
    public synchronized void lockRead();
    public synchronized void lockWrite();
    public synchronized void unlock();
    private int firstWriter();
    private int getIndex(Thread);
}
org/jfree/ui/about/AboutDialog.class
package org.jfree.ui.about;
public synchronized class AboutDialog extends javax.swing.JDialog {
    public static final java.awt.Dimension PREFERRED_SIZE;
    public static final javax.swing.border.Border STANDARD_BORDER;
    private java.util.ResourceBundle resources;
    private String application;
    private String version;
    private String copyright;
    private String info;
    private java.awt.Image logo;
    private java.util.List contributors;
    private String licence;
    public void AboutDialog(String, ProjectInfo);
    public void AboutDialog(java.awt.Frame, String, ProjectInfo);
    public void AboutDialog(java.awt.Dialog, String, ProjectInfo);
    private void init(String, String, String, String, java.awt.Image, String, String, java.util.List, ProjectInfo);
    public java.awt.Dimension getPreferredSize();
    private javax.swing.JTabbedPane createTabs(ProjectInfo);
    private javax.swing.JPanel createAboutPanel(ProjectInfo);
    private javax.swing.JPanel createLicencePanel();
    static void ();
}
org/jfree/ui/about/AboutFrame.class
package org.jfree.ui.about;
public synchronized class AboutFrame extends javax.swing.JFrame {
    public static final java.awt.Dimension PREFERRED_SIZE;
    public static final javax.swing.border.Border STANDARD_BORDER;
    private java.util.ResourceBundle resources;
    private String application;
    private String version;
    private String copyright;
    private String info;
    private java.awt.Image logo;
    private java.util.List contributors;
    private String licence;
    public void AboutFrame(String, ProjectInfo);
    public void AboutFrame(String, String, String, String, java.awt.Image, String, String, java.util.List, ProjectInfo);
    public java.awt.Dimension getPreferredSize();
    private javax.swing.JTabbedPane createTabs(ProjectInfo);
    private javax.swing.JPanel createAboutPanel(ProjectInfo);
    private javax.swing.JPanel createLicencePanel();
    static void ();
}
org/jfree/ui/about/AboutPanel.class
package org.jfree.ui.about;
public synchronized class AboutPanel extends javax.swing.JPanel {
    public void AboutPanel(String, String, String, String);
    public void AboutPanel(String, String, String, String, java.awt.Image);
}
org/jfree/ui/about/Contributor.class
package org.jfree.ui.about;
public synchronized class Contributor {
    private String name;
    private String email;
    public void Contributor(String, String);
    public String getName();
    public String getEmail();
}
org/jfree/ui/about/ContributorsPanel.class
package org.jfree.ui.about;
public synchronized class ContributorsPanel extends javax.swing.JPanel {
    private javax.swing.JTable table;
    private javax.swing.table.TableModel model;
    public void ContributorsPanel(java.util.List);
}
org/jfree/ui/about/ContributorsTableModel.class
package org.jfree.ui.about;
public synchronized class ContributorsTableModel extends javax.swing.table.AbstractTableModel {
    private java.util.List contributors;
    private String nameColumnLabel;
    private String contactColumnLabel;
    public void ContributorsTableModel(java.util.List);
    public int getRowCount();
    public int getColumnCount();
    public String getColumnName(int);
    public Object getValueAt(int, int);
}
org/jfree/ui/about/gpl-2.0.txt
                    GNU GENERAL PUBLIC LICENSE
                       Version 2, June 1991
 Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
                            Preamble
  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.)  You can apply it to
your programs, too.
  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.
  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
  The precise terms and conditions for copying, distribution and
modification follow.
                    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
  1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
  2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
  3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,
    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,
    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
  4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
  5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
  6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
  7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
  8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.
  9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
  10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
                            NO WARRANTY
  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
                     END OF TERMS AND CONDITIONS
            How to Apply These Terms to Your New Programs
  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
    
    Copyright (C)   
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  , 1 April 1989
  Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Lesser General
Public License instead of this License.
org/jfree/ui/about/lgpl-2.1.txt
GNU LESSER GENERAL PUBLIC LICENSE
                       Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.]
                            Preamble
  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
  This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it.  You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
  When we speak of free software, we are referring to freedom of use,
not price.  Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
  To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights.  These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
  For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you.  You must make sure that they, too, receive or can get the source
code.  If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it.  And you must show them these terms so they know their rights.
  We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
  To protect each distributor, we want to make it very clear that
there is no warranty for the free library.  Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
  Finally, software patents pose a constant threat to the existence of
any free program.  We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder.  Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
  Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License.  This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License.  We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
  When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library.  The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom.  The Lesser General
Public License permits more lax criteria for linking other code with
the library.
  We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License.  It also provides other free software developers Less
of an advantage over competing non-free programs.  These disadvantages
are the reason we use the ordinary General Public License for many
libraries.  However, the Lesser license provides advantages in certain
special circumstances.
  For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard.  To achieve this, non-free programs must be
allowed to use the library.  A more frequent case is that a free
library does the same job as widely used non-free libraries.  In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
  In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software.  For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
  Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
  The precise terms and conditions for copying, distribution and
modification follow.  Pay close attention to the difference between a
"work based on the library" and a "work that uses the library".  The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
                  GNU LESSER GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
  A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
  The "Library", below, refers to any such software library or work
which has been distributed under these terms.  A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language.  (Hereinafter, translation is
included without limitation in the term "modification".)
  "Source code" for a work means the preferred form of the work for
making modifications to it.  For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
  Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it).  Whether that is true depends on what the Library does
and what the program that uses the Library does.
  1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
  You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
  2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
    a) The modified work must itself be a software library.
    b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.
    c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.
    d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.
    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)
These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
  3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library.  To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License.  (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.)  Do not make any other change in
these notices.
  Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
  This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
  4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
  If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
  5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library".  Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
  However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library".  The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
  When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library.  The
threshold for this to be true is not precisely defined by law.
  If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work.  (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
  Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
  6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
  You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License.  You must supply a copy of this License.  If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License.  Also, you must do one
of these things:
    a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)
    b) Use a suitable shared library mechanism for linking with the
    Library.  A suitable mechanism is one that (1) uses at run time a
    copy of the library already present on the user's computer system,
    rather than copying library functions into the executable, and (2)
    will operate properly with a modified version of the library, if
    the user installs one, as long as the modified version is
    interface-compatible with the version that the work was made with.
    c) Accompany the work with a written offer, valid for at
    least three years, to give the same user the materials
    specified in Subsection 6a, above, for a charge no more
    than the cost of performing this distribution.
    d) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.
    e) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.
  For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it.  However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
  It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system.  Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
  7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
    a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.
    b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.
  8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License.  Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License.  However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
  9. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Library or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
  10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
  11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all.  For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
  12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded.  In such case, this License incorporates the limitation as if
written in the body of this License.
  13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number.  If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation.  If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
  14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission.  For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this.  Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
                            NO WARRANTY
  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
                     END OF TERMS AND CONDITIONS
           How to Apply These Terms to Your New Libraries
  If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change.  You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
  To apply these terms, attach the following notices to the library.  It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
    JCommon class library (used by JFreeChart 1.0.x)
    Copyright (C) 2013  David Gilbert
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the
  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
  {signature of Ty Coon}, 1 April 1990
  Ty Coon, President of Vice
That's all there is to it!
org/jfree/ui/about/Library.class
package org.jfree.ui.about;
public synchronized class Library extends org.jfree.base.Library {
    public void Library(String, String, String, String);
    public void Library(ProjectInfo);
}
org/jfree/ui/about/LibraryPanel.class
package org.jfree.ui.about;
public synchronized class LibraryPanel extends javax.swing.JPanel {
    private javax.swing.JTable table;
    private LibraryTableModel model;
    public void LibraryPanel(java.util.List);
    public void LibraryPanel(ProjectInfo);
    private static java.util.List getLibraries(ProjectInfo);
    private static void collectLibraries(ProjectInfo, java.util.List);
    public LibraryTableModel getModel();
    protected javax.swing.JTable getTable();
}
org/jfree/ui/about/LibraryTableModel.class
package org.jfree.ui.about;
public synchronized class LibraryTableModel extends javax.swing.table.AbstractTableModel {
    private org.jfree.base.Library[] libraries;
    private String nameColumnLabel;
    private String versionColumnLabel;
    private String licenceColumnLabel;
    private String infoColumnLabel;
    public void LibraryTableModel(java.util.List);
    public int getRowCount();
    public int getColumnCount();
    public String getColumnName(int);
    public Object getValueAt(int, int);
    public org.jfree.base.Library[] getLibraries();
}
org/jfree/ui/about/Licences.class
package org.jfree.ui.about;
public synchronized class Licences {
    public static final String GPL = GNU GENERAL PUBLIC LICENSE
;
    public static final String LGPL = GNU LESSER GENERAL PUBLIC LICENSE
;
    private static Licences singleton;
    public void Licences();
    public static Licences getInstance();
    public String getGPL();
    public String getLGPL();
    private String readStringResource(String);
}
org/jfree/ui/about/ProjectInfo.class
package org.jfree.ui.about;
public synchronized class ProjectInfo extends org.jfree.base.BootableProjectInfo {
    private java.awt.Image logo;
    private String licenceText;
    private java.util.List contributors;
    public void ProjectInfo();
    public void ProjectInfo(String, String, String, java.awt.Image, String, String, String);
    public java.awt.Image getLogo();
    public void setLogo(java.awt.Image);
    public String getLicenceText();
    public void setLicenceText(String);
    public java.util.List getContributors();
    public void setContributors(java.util.List);
    public String toString();
}
org/jfree/ui/about/resources/AboutResources.class
package org.jfree.ui.about.resources;
public synchronized class AboutResources extends java.util.ListResourceBundle {
    private static final Object[][] CONTENTS;
    public void AboutResources();
    public Object[][] getContents();
    static void ();
}
org/jfree/ui/about/resources/AboutResources_de.class
package org.jfree.ui.about.resources;
public synchronized class AboutResources_de extends java.util.ListResourceBundle {
    private static final Object[][] CONTENTS;
    public void AboutResources_de();
    public Object[][] getContents();
    static void ();
}
org/jfree/ui/about/resources/AboutResources_es.class
package org.jfree.ui.about.resources;
public synchronized class AboutResources_es extends java.util.ListResourceBundle {
    private static final Object[][] CONTENTS;
    public void AboutResources_es();
    public Object[][] getContents();
    static void ();
}
org/jfree/ui/about/resources/AboutResources_fr.class
package org.jfree.ui.about.resources;
public synchronized class AboutResources_fr extends java.util.ListResourceBundle {
    private static final Object[][] CONTENTS;
    public void AboutResources_fr();
    public Object[][] getContents();
    static void ();
}
org/jfree/ui/about/resources/AboutResources_pl.class
package org.jfree.ui.about.resources;
public synchronized class AboutResources_pl extends java.util.ListResourceBundle {
    private static final Object[][] CONTENTS;
    public void AboutResources_pl();
    public Object[][] getContents();
    static void ();
}
org/jfree/ui/about/SystemProperties.class
package org.jfree.ui.about;
public synchronized class SystemProperties {
    private void SystemProperties();
    public static org.jfree.ui.SortableTable createSystemPropertiesTable();
}
org/jfree/ui/about/SystemPropertiesFrame.class
package org.jfree.ui.about;
public synchronized class SystemPropertiesFrame extends javax.swing.JFrame implements java.awt.event.ActionListener {
    private static final String COPY_COMMAND = COPY;
    private static final String CLOSE_COMMAND = CLOSE;
    private SystemPropertiesPanel panel;
    public void SystemPropertiesFrame(boolean);
    public void actionPerformed(java.awt.event.ActionEvent);
    private javax.swing.JMenuBar createMenuBar(java.util.ResourceBundle);
}
org/jfree/ui/about/SystemPropertiesPanel$1.class
package org.jfree.ui.about;
synchronized class SystemPropertiesPanel$1 implements java.awt.event.ActionListener {
    void SystemPropertiesPanel$1(SystemPropertiesPanel);
    public void actionPerformed(java.awt.event.ActionEvent);
}
org/jfree/ui/about/SystemPropertiesPanel$PopupListener.class
package org.jfree.ui.about;
synchronized class SystemPropertiesPanel$PopupListener extends java.awt.event.MouseAdapter {
    public void SystemPropertiesPanel$PopupListener(SystemPropertiesPanel);
    public void mousePressed(java.awt.event.MouseEvent);
    public void mouseReleased(java.awt.event.MouseEvent);
    private void maybeShowPopup(java.awt.event.MouseEvent);
}
org/jfree/ui/about/SystemPropertiesPanel.class
package org.jfree.ui.about;
public synchronized class SystemPropertiesPanel extends javax.swing.JPanel {
    private javax.swing.JTable table;
    private javax.swing.JPopupMenu copyPopupMenu;
    private javax.swing.JMenuItem copyMenuItem;
    private SystemPropertiesPanel$PopupListener copyPopupListener;
    public void SystemPropertiesPanel();
    public void copySystemPropertiesToClipboard();
    protected final javax.swing.JPopupMenu getCopyPopupMenu();
    protected final javax.swing.JTable getTable();
}
org/jfree/ui/about/SystemPropertiesTableModel$SystemProperty.class
package org.jfree.ui.about;
public synchronized class SystemPropertiesTableModel$SystemProperty {
    private String name;
    private String value;
    public void SystemPropertiesTableModel$SystemProperty(String, String);
    public String getName();
    public String getValue();
}
org/jfree/ui/about/SystemPropertiesTableModel$SystemPropertyComparator.class
package org.jfree.ui.about;
public synchronized class SystemPropertiesTableModel$SystemPropertyComparator implements java.util.Comparator {
    private boolean ascending;
    public void SystemPropertiesTableModel$SystemPropertyComparator(boolean);
    public int compare(Object, Object);
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/ui/about/SystemPropertiesTableModel.class
package org.jfree.ui.about;
public synchronized class SystemPropertiesTableModel extends org.jfree.ui.SortableTableModel {
    private java.util.List properties;
    private String nameColumnLabel;
    private String valueColumnLabel;
    public void SystemPropertiesTableModel();
    public boolean isSortable(int);
    public int getRowCount();
    public int getColumnCount();
    public String getColumnName(int);
    public Object getValueAt(int, int);
    public void sortByColumn(int, boolean);
}
org/jfree/ui/action/AbstractActionDowngrade.class
package org.jfree.ui.action;
public abstract synchronized class AbstractActionDowngrade extends javax.swing.AbstractAction implements ActionDowngrade {
    public static final String ACCELERATOR_KEY = AcceleratorKey;
    public static final String MNEMONIC_KEY = MnemonicKey;
    protected void AbstractActionDowngrade();
}
org/jfree/ui/action/AbstractFileSelectionAction.class
package org.jfree.ui.action;
public abstract synchronized class AbstractFileSelectionAction extends AbstractActionDowngrade {
    private javax.swing.JFileChooser fileChooser;
    private java.awt.Component parent;
    public void AbstractFileSelectionAction(java.awt.Component);
    protected abstract String getFileExtension();
    protected abstract String getFileDescription();
    protected java.io.File getCurrentDirectory();
    protected java.io.File performSelectFile(java.io.File, int, boolean);
    protected javax.swing.JFileChooser createFileChooser();
}
org/jfree/ui/action/ActionButton$ActionEnablePropertyChangeHandler.class
package org.jfree.ui.action;
synchronized class ActionButton$ActionEnablePropertyChangeHandler implements java.beans.PropertyChangeListener {
    public void ActionButton$ActionEnablePropertyChangeHandler(ActionButton);
    public void propertyChange(java.beans.PropertyChangeEvent);
}
org/jfree/ui/action/ActionButton.class
package org.jfree.ui.action;
public synchronized class ActionButton extends javax.swing.JButton {
    private javax.swing.Action action;
    private ActionButton$ActionEnablePropertyChangeHandler propertyChangeHandler;
    public void ActionButton();
    public void ActionButton(String);
    public void ActionButton(String, javax.swing.Icon);
    public void ActionButton(javax.swing.Icon);
    public void ActionButton(javax.swing.Action);
    public javax.swing.Action getAction();
    private ActionButton$ActionEnablePropertyChangeHandler getPropertyChangeHandler();
    public void setEnabled(boolean);
    public void setAction(javax.swing.Action);
}
org/jfree/ui/action/ActionConcentrator.class
package org.jfree.ui.action;
public synchronized class ActionConcentrator {
    private final java.util.ArrayList actions;
    public void ActionConcentrator();
    public void addAction(javax.swing.Action);
    public void removeAction(javax.swing.Action);
    public void setEnabled(boolean);
    public boolean isEnabled();
}
org/jfree/ui/action/ActionDowngrade.class
package org.jfree.ui.action;
public abstract interface ActionDowngrade extends javax.swing.Action {
    public static final String ACCELERATOR_KEY = AcceleratorKey;
    public static final String MNEMONIC_KEY = MnemonicKey;
}
org/jfree/ui/action/ActionMenuItem$ActionEnablePropertyChangeHandler.class
package org.jfree.ui.action;
synchronized class ActionMenuItem$ActionEnablePropertyChangeHandler implements java.beans.PropertyChangeListener {
    public void ActionMenuItem$ActionEnablePropertyChangeHandler(ActionMenuItem);
    public void propertyChange(java.beans.PropertyChangeEvent);
}
org/jfree/ui/action/ActionMenuItem.class
package org.jfree.ui.action;
public synchronized class ActionMenuItem extends javax.swing.JMenuItem {
    private javax.swing.Action action;
    private ActionMenuItem$ActionEnablePropertyChangeHandler propertyChangeHandler;
    public void ActionMenuItem();
    public void ActionMenuItem(javax.swing.Icon);
    public void ActionMenuItem(String);
    public void ActionMenuItem(String, javax.swing.Icon);
    public void ActionMenuItem(String, int);
    public void ActionMenuItem(javax.swing.Action);
    public javax.swing.Action getAction();
    private ActionMenuItem$ActionEnablePropertyChangeHandler getPropertyChangeHandler();
    public void setEnabled(boolean);
    public void setAction(javax.swing.Action);
}
org/jfree/ui/action/ActionRadioButton$1.class
package org.jfree.ui.action;
synchronized class ActionRadioButton$1 {
}
org/jfree/ui/action/ActionRadioButton$ActionEnablePropertyChangeHandler.class
package org.jfree.ui.action;
synchronized class ActionRadioButton$ActionEnablePropertyChangeHandler implements java.beans.PropertyChangeListener {
    private void ActionRadioButton$ActionEnablePropertyChangeHandler(ActionRadioButton);
    public void propertyChange(java.beans.PropertyChangeEvent);
}
org/jfree/ui/action/ActionRadioButton.class
package org.jfree.ui.action;
public synchronized class ActionRadioButton extends javax.swing.JRadioButton {
    private javax.swing.Action action;
    private ActionRadioButton$ActionEnablePropertyChangeHandler propertyChangeHandler;
    public void ActionRadioButton();
    public void ActionRadioButton(String);
    public void ActionRadioButton(String, javax.swing.Icon);
    public void ActionRadioButton(javax.swing.Icon);
    public void ActionRadioButton(javax.swing.Action);
    public javax.swing.Action getAction();
    private ActionRadioButton$ActionEnablePropertyChangeHandler getPropertyChangeHandler();
    public void setEnabled(boolean);
    public void setAction(javax.swing.Action);
}
org/jfree/ui/action/DowngradeActionMap.class
package org.jfree.ui.action;
public synchronized class DowngradeActionMap {
    private final java.util.HashMap actionMap;
    private final java.util.ArrayList actionList;
    private DowngradeActionMap parent;
    public void DowngradeActionMap();
    public void setParent(DowngradeActionMap);
    public DowngradeActionMap getParent();
    public void put(Object, javax.swing.Action);
    public javax.swing.Action get(Object);
    public void remove(Object);
    public void clear();
    public Object[] keys();
    public int size();
    public Object[] allKeys();
}
org/jfree/ui/Align.class
package org.jfree.ui;
public final synchronized class Align {
    public static final int CENTER = 0;
    public static final int TOP = 1;
    public static final int BOTTOM = 2;
    public static final int LEFT = 4;
    public static final int RIGHT = 8;
    public static final int TOP_LEFT = 5;
    public static final int TOP_RIGHT = 9;
    public static final int BOTTOM_LEFT = 6;
    public static final int BOTTOM_RIGHT = 10;
    public static final int FIT_HORIZONTAL = 12;
    public static final int FIT_VERTICAL = 3;
    public static final int FIT = 15;
    public static final int NORTH = 1;
    public static final int SOUTH = 2;
    public static final int WEST = 4;
    public static final int EAST = 8;
    public static final int NORTH_WEST = 5;
    public static final int NORTH_EAST = 9;
    public static final int SOUTH_WEST = 6;
    public static final int SOUTH_EAST = 10;
    private void Align();
    public static void align(java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, int);
}
org/jfree/ui/ApplicationFrame.class
package org.jfree.ui;
public synchronized class ApplicationFrame extends javax.swing.JFrame implements java.awt.event.WindowListener {
    public void ApplicationFrame(String);
    public void windowClosing(java.awt.event.WindowEvent);
    public void windowClosed(java.awt.event.WindowEvent);
    public void windowActivated(java.awt.event.WindowEvent);
    public void windowDeactivated(java.awt.event.WindowEvent);
    public void windowDeiconified(java.awt.event.WindowEvent);
    public void windowIconified(java.awt.event.WindowEvent);
    public void windowOpened(java.awt.event.WindowEvent);
}
org/jfree/ui/ArrowPanel.class
package org.jfree.ui;
public synchronized class ArrowPanel extends javax.swing.JPanel {
    public static final int UP = 0;
    public static final int DOWN = 1;
    private int type;
    private java.awt.geom.Rectangle2D available;
    public void ArrowPanel(int);
    public void paintComponent(java.awt.Graphics);
    private java.awt.Shape getArrow(int);
    private java.awt.Shape getUpArrow();
    private java.awt.Shape getDownArrow();
}
org/jfree/ui/BevelArrowIcon.class
package org.jfree.ui;
public synchronized class BevelArrowIcon implements javax.swing.Icon {
    public static final int UP = 0;
    public static final int DOWN = 1;
    private static final int DEFAULT_SIZE = 11;
    private java.awt.Color edge1;
    private java.awt.Color edge2;
    private java.awt.Color fill;
    private int size;
    private int direction;
    public void BevelArrowIcon(int, boolean, boolean);
    public void BevelArrowIcon(java.awt.Color, java.awt.Color, java.awt.Color, int, int);
    public void paintIcon(java.awt.Component, java.awt.Graphics, int, int);
    public int getIconWidth();
    public int getIconHeight();
    private void init(java.awt.Color, java.awt.Color, java.awt.Color, int, int);
    private void drawDownArrow(java.awt.Graphics, int, int);
    private void drawUpArrow(java.awt.Graphics, int, int);
}
org/jfree/ui/DateCellRenderer.class
package org.jfree.ui;
public synchronized class DateCellRenderer extends javax.swing.table.DefaultTableCellRenderer {
    private java.text.DateFormat formatter;
    public void DateCellRenderer();
    public void DateCellRenderer(java.text.DateFormat);
    public java.awt.Component getTableCellRendererComponent(javax.swing.JTable, Object, boolean, boolean, int, int);
}
org/jfree/ui/DateChooserPanel.class
package org.jfree.ui;
public synchronized class DateChooserPanel extends javax.swing.JPanel implements java.awt.event.ActionListener {
    private java.util.Calendar chosenDate;
    private java.awt.Color chosenDateButtonColor;
    private java.awt.Color chosenMonthButtonColor;
    private java.awt.Color chosenOtherButtonColor;
    private int firstDayOfWeek;
    private int yearSelectionRange;
    private java.awt.Font dateFont;
    private javax.swing.JComboBox monthSelector;
    private javax.swing.JComboBox yearSelector;
    private javax.swing.JButton todayButton;
    private javax.swing.JButton[] buttons;
    private boolean refreshing;
    private int[] WEEK_DAYS;
    public void DateChooserPanel();
    public void DateChooserPanel(java.util.Calendar, boolean);
    public void setDate(java.util.Date);
    public java.util.Date getDate();
    public void actionPerformed(java.awt.event.ActionEvent);
    private javax.swing.JPanel getCalendarPanel();
    private java.awt.Color getButtonColor(java.util.Calendar);
    private boolean equalDates(java.util.Calendar, java.util.Calendar);
    private java.util.Calendar getFirstVisibleDate();
    private int getFirstDayOfWeek();
    private void refreshButtons();
    private void refreshYearSelector();
    private Integer[] getYears(int);
    private javax.swing.JPanel constructSelectionPanel();
    private javax.swing.JPanel constructControlPanel();
    public java.awt.Color getChosenDateButtonColor();
    public void setChosenDateButtonColor(java.awt.Color);
    public java.awt.Color getChosenMonthButtonColor();
    public void setChosenMonthButtonColor(java.awt.Color);
    public java.awt.Color getChosenOtherButtonColor();
    public void setChosenOtherButtonColor(java.awt.Color);
    public int getYearSelectionRange();
    public void setYearSelectionRange(int);
}
org/jfree/ui/Drawable.class
package org.jfree.ui;
public abstract interface Drawable {
    public abstract void draw(java.awt.Graphics2D, java.awt.geom.Rectangle2D);
}
org/jfree/ui/DrawablePanel.class
package org.jfree.ui;
public synchronized class DrawablePanel extends javax.swing.JPanel {
    private Drawable drawable;
    public void DrawablePanel();
    public Drawable getDrawable();
    public void setDrawable(Drawable);
    public java.awt.Dimension getPreferredSize();
    public java.awt.Dimension getMinimumSize();
    public boolean isOpaque();
    protected void paintComponent(java.awt.Graphics);
}
org/jfree/ui/ExtendedDrawable.class
package org.jfree.ui;
public abstract interface ExtendedDrawable extends Drawable {
    public abstract java.awt.Dimension getPreferredSize();
    public abstract boolean isPreserveAspectRatio();
}
org/jfree/ui/ExtensionFileFilter.class
package org.jfree.ui;
public synchronized class ExtensionFileFilter extends javax.swing.filechooser.FileFilter {
    private String description;
    private String extension;
    public void ExtensionFileFilter(String, String);
    public boolean accept(java.io.File);
    public String getDescription();
}
org/jfree/ui/FilesystemFilter.class
package org.jfree.ui;
public synchronized class FilesystemFilter extends javax.swing.filechooser.FileFilter implements java.io.FilenameFilter {
    private String[] fileext;
    private String descr;
    private boolean accDirs;
    public void FilesystemFilter(String, String);
    public void FilesystemFilter(String, String, boolean);
    public void FilesystemFilter(String[], String, boolean);
    public boolean accept(java.io.File, String);
    public boolean accept(java.io.File);
    public String getDescription();
    public void acceptDirectories(boolean);
    public boolean acceptsDirectories();
}
org/jfree/ui/FloatDimension.class
package org.jfree.ui;
public synchronized class FloatDimension extends java.awt.geom.Dimension2D implements java.io.Serializable {
    private static final long serialVersionUID = 5367882923248086744;
    private float width;
    private float height;
    public void FloatDimension();
    public void FloatDimension(FloatDimension);
    public void FloatDimension(float, float);
    public double getWidth();
    public double getHeight();
    public void setWidth(double);
    public void setHeight(double);
    public void setSize(double, double);
    public Object clone();
    public String toString();
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/ui/FloatingButtonEnabler.class
package org.jfree.ui;
public final synchronized class FloatingButtonEnabler extends java.awt.event.MouseAdapter {
    private static FloatingButtonEnabler singleton;
    private void FloatingButtonEnabler();
    public static FloatingButtonEnabler getInstance();
    public void addButton(javax.swing.AbstractButton);
    public void removeButton(javax.swing.AbstractButton);
    public void mouseEntered(java.awt.event.MouseEvent);
    public void mouseExited(java.awt.event.MouseEvent);
}
org/jfree/ui/FontChooserDialog.class
package org.jfree.ui;
public synchronized class FontChooserDialog extends StandardDialog {
    private FontChooserPanel fontChooserPanel;
    public void FontChooserDialog(java.awt.Dialog, String, boolean, java.awt.Font);
    public void FontChooserDialog(java.awt.Frame, String, boolean, java.awt.Font);
    public java.awt.Font getSelectedFont();
    private javax.swing.JPanel createContent(java.awt.Font);
}
org/jfree/ui/FontChooserPanel.class
package org.jfree.ui;
public synchronized class FontChooserPanel extends javax.swing.JPanel {
    public static final String[] SIZES;
    private javax.swing.JList fontlist;
    private javax.swing.JList sizelist;
    private javax.swing.JCheckBox bold;
    private javax.swing.JCheckBox italic;
    protected static java.util.ResourceBundle localizationResources;
    public void FontChooserPanel(java.awt.Font);
    public java.awt.Font getSelectedFont();
    public String getSelectedName();
    public int getSelectedStyle();
    public int getSelectedSize();
    public void setSelectedFont(java.awt.Font);
    static void ();
}
org/jfree/ui/FontDisplayField.class
package org.jfree.ui;
public synchronized class FontDisplayField extends javax.swing.JTextField {
    private java.awt.Font displayFont;
    protected static final java.util.ResourceBundle localizationResources;
    public void FontDisplayField(java.awt.Font);
    public java.awt.Font getDisplayFont();
    public void setDisplayFont(java.awt.Font);
    private String fontToString(java.awt.Font);
    static void ();
}
org/jfree/ui/GradientPaintTransformer.class
package org.jfree.ui;
public abstract interface GradientPaintTransformer {
    public abstract java.awt.GradientPaint transform(java.awt.GradientPaint, java.awt.Shape);
}
org/jfree/ui/GradientPaintTransformType.class
package org.jfree.ui;
public final synchronized class GradientPaintTransformType implements java.io.Serializable {
    private static final long serialVersionUID = 8331561784933982450;
    public static final GradientPaintTransformType VERTICAL;
    public static final GradientPaintTransformType HORIZONTAL;
    public static final GradientPaintTransformType CENTER_VERTICAL;
    public static final GradientPaintTransformType CENTER_HORIZONTAL;
    private String name;
    private void GradientPaintTransformType(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/ui/HorizontalAlignment.class
package org.jfree.ui;
public final synchronized class HorizontalAlignment implements java.io.Serializable {
    private static final long serialVersionUID = -8249740987565309567;
    public static final HorizontalAlignment LEFT;
    public static final HorizontalAlignment RIGHT;
    public static final HorizontalAlignment CENTER;
    private String name;
    private void HorizontalAlignment(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/ui/InsetsChooserPanel.class
package org.jfree.ui;
public synchronized class InsetsChooserPanel extends javax.swing.JPanel {
    private javax.swing.JTextField topValueEditor;
    private javax.swing.JTextField leftValueEditor;
    private javax.swing.JTextField bottomValueEditor;
    private javax.swing.JTextField rightValueEditor;
    protected static java.util.ResourceBundle localizationResources;
    public void InsetsChooserPanel();
    public void InsetsChooserPanel(java.awt.Insets);
    public java.awt.Insets getInsetsValue();
    protected int stringToInt(String);
    public void removeNotify();
    static void ();
}
org/jfree/ui/InsetsTextField.class
package org.jfree.ui;
public synchronized class InsetsTextField extends javax.swing.JTextField {
    protected static java.util.ResourceBundle localizationResources;
    public void InsetsTextField(java.awt.Insets);
    public String formatInsetsString(java.awt.Insets);
    public void setInsets(java.awt.Insets);
    static void ();
}
org/jfree/ui/IntegerDocument.class
package org.jfree.ui;
public synchronized class IntegerDocument extends javax.swing.text.PlainDocument {
    public void IntegerDocument();
    public void insertString(int, String, javax.swing.text.AttributeSet) throws javax.swing.text.BadLocationException;
}
org/jfree/ui/JTextObserver.class
package org.jfree.ui;
public final synchronized class JTextObserver implements java.awt.event.FocusListener {
    private static JTextObserver singleton;
    private void JTextObserver();
    public static JTextObserver getInstance();
    public void focusGained(java.awt.event.FocusEvent);
    public void focusLost(java.awt.event.FocusEvent);
    public static void addTextComponent(javax.swing.text.JTextComponent);
    public static void removeTextComponent(javax.swing.text.JTextComponent);
}
org/jfree/ui/KeyedComboBoxModel$ComboBoxItemPair.class
package org.jfree.ui;
synchronized class KeyedComboBoxModel$ComboBoxItemPair {
    private Object key;
    private Object value;
    public void KeyedComboBoxModel$ComboBoxItemPair(Object, Object);
    public Object getKey();
    public Object getValue();
    public void setValue(Object);
}
org/jfree/ui/KeyedComboBoxModel.class
package org.jfree.ui;
public synchronized class KeyedComboBoxModel implements javax.swing.ComboBoxModel {
    private int selectedItemIndex;
    private Object selectedItemValue;
    private java.util.ArrayList data;
    private java.util.ArrayList listdatalistener;
    private transient javax.swing.event.ListDataListener[] tempListeners;
    private boolean allowOtherValue;
    public void KeyedComboBoxModel();
    public void KeyedComboBoxModel(Object[], Object[]);
    public void setData(Object[], Object[]);
    protected synchronized void fireListDataEvent(javax.swing.event.ListDataEvent);
    public Object getSelectedItem();
    public void setSelectedKey(Object);
    public void setSelectedItem(Object);
    private boolean isAllowOtherValue();
    public void setAllowOtherValue(boolean);
    public synchronized void addListDataListener(javax.swing.event.ListDataListener);
    public Object getElementAt(int);
    public Object getKeyAt(int);
    public Object getSelectedKey();
    public int getSize();
    public void removeListDataListener(javax.swing.event.ListDataListener);
    private int findDataElementIndex(Object);
    public int findElementIndex(Object);
    public void removeDataElement(Object);
    public void add(Object, Object);
    public void clear();
}
org/jfree/ui/L1R1ButtonPanel.class
package org.jfree.ui;
public synchronized class L1R1ButtonPanel extends javax.swing.JPanel {
    private javax.swing.JButton left;
    private javax.swing.JButton right;
    public void L1R1ButtonPanel(String, String);
    public javax.swing.JButton getLeftButton();
    public javax.swing.JButton getRightButton();
}
org/jfree/ui/L1R2ButtonPanel.class
package org.jfree.ui;
public synchronized class L1R2ButtonPanel extends javax.swing.JPanel {
    private javax.swing.JButton left;
    private javax.swing.JButton right1;
    private javax.swing.JButton right2;
    public void L1R2ButtonPanel(String, String, String);
    public javax.swing.JButton getLeftButton();
    public javax.swing.JButton getRightButton1();
    public javax.swing.JButton getRightButton2();
}
org/jfree/ui/L1R3ButtonPanel.class
package org.jfree.ui;
public synchronized class L1R3ButtonPanel extends javax.swing.JPanel {
    private javax.swing.JButton left;
    private javax.swing.JButton right1;
    private javax.swing.JButton right2;
    private javax.swing.JButton right3;
    public void L1R3ButtonPanel(String, String, String, String);
    public javax.swing.JButton getLeftButton();
    public javax.swing.JButton getRightButton1();
    public javax.swing.JButton getRightButton2();
    public javax.swing.JButton getRightButton3();
}
org/jfree/ui/Layer.class
package org.jfree.ui;
public final synchronized class Layer implements java.io.Serializable {
    private static final long serialVersionUID = -1470104570733183430;
    public static final Layer FOREGROUND;
    public static final Layer BACKGROUND;
    private String name;
    private void Layer(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/ui/LengthAdjustmentType.class
package org.jfree.ui;
public final synchronized class LengthAdjustmentType implements java.io.Serializable {
    private static final long serialVersionUID = -6097408511380545010;
    public static final LengthAdjustmentType NO_CHANGE;
    public static final LengthAdjustmentType EXPAND;
    public static final LengthAdjustmentType CONTRACT;
    private String name;
    private void LengthAdjustmentType(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/ui/LengthLimitingDocument.class
package org.jfree.ui;
public synchronized class LengthLimitingDocument extends javax.swing.text.PlainDocument {
    private int maxlen;
    public void LengthLimitingDocument();
    public void LengthLimitingDocument(int);
    public void setMaxLength(int);
    public int getMaxLength();
    public void insertString(int, String, javax.swing.text.AttributeSet) throws javax.swing.text.BadLocationException;
}
org/jfree/ui/LocalizationBundle.properties
# org.jfree.ui.ui ResourceBundle properties file
# 
# Changes (from 31-Aug-2003)
# --------------------------
# 31-Aug-2003 : Initial version (AL);
#
Attributes=Attributes:
B=B:
Bold=Bold
Bottom=Bottom
Font=Font:
Insets=Insets:
Italic=Italic
L=L: 
Left=Left
No_Font_Selected=No font selected.
R=R: 
Right=Right
Size=Size:
T=T: 
Top=Top
Help=Help
OK=OK
Cancel=Cancel
org/jfree/ui/LocalizationBundle_de.properties
# org.jfree.ui.ui ResourceBundle properties file - german version
# 
# Changes (from 31-Aug-2003)
# --------------------------
# 15-Mar-2004 : Initial version (Christian W. Zuckschwerdt);
#
Attributes=Attribute:
B=U:
Bold=Fett
Bottom=Unten
Font=Schrift:
Insets=R\u00e4nder:
Italic=Kursiv
L=L: 
Left=Links
No_Font_Selected=Keine Schrift gew\u00e4hlt.
R=R: 
Right=Rechts
Size=Gr\u00f6\u00dfe:
T=O: 
Top=Oben
Help=Hilfe
OK=OK
Cancel=Abbrechen
org/jfree/ui/LocalizationBundle_es.properties
# org.jfree.ui.ui ResourceBundle properties file spanish
# 
# Changes (from 31-Aug-2003)
# --------------------------
# 14-Oct-2004 : Initial version: Leopoldo Federico Pértile (Grupo de Procesamiento Digital de Imágenes)
#					   Universidad Tecnológica Nacional - Facultad Regional Resistencia, Argentina
Attributes=Atributos:
B=Inf:
Bold=Negrita
Bottom=Inferior
Font=Fuente:
Insets=Márgenes:
Italic=Cursiva
L=Izq: 
Left=Izquierda
No_Font_Selected=No se seleccion\00F3 ninguna fuente.
R=Der: 
Right=Derecha
Size=Tama\u00f1o:
T=Sup: 
Top=Superior
Help=Ayuda
OK=Aceptar
Cancel=Cancelar
org/jfree/ui/LocalizationBundle_fr.properties
# org.jfree.ui.ui ResourceBundle properties file - french version
# 
# Changes (from 31-Aug-2003)
# --------------------------
# 31-Aug-2003 : Initial version (AL);
#
Attributes=Attributs :
B=B : 
Bold=Gras
Bottom=Bas
Font=Police :
Insets=Position :
Italic=Italique
L=G : 
Left=Gauche
No_Font_Selected=Aucune police n'a \u00E9t\u00E9 s\u00E9lectionn\u00E9e.
R=D : 
Right=Droite
Size=Taille :
T=H : 
Top=Haut
org/jfree/ui/LocalizationBundle_pt_PT.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file - portuguese version
# 
# Changes (from 09-Set-2003)
# --------------------------
# 09-Set-2003 : Initial version (Eduardo Ramalho);
#
Attributes=Atributos:
B=B:
Bold=Negrito
Bottom=Fundo
Font=Fonte:
Insets=Posi\u00e7\u00e3o:
Italic=It\u00e1lico
L=E:
Left=Esquerda
No_Font_Selected=Nenhuma fonte est\u00e1 seleccionada.
R=D:
Right=Direita
Size=Tamanho:
T=T:
Top=Topo
org/jfree/ui/NumberCellRenderer.class
package org.jfree.ui;
public synchronized class NumberCellRenderer extends javax.swing.table.DefaultTableCellRenderer {
    public void NumberCellRenderer();
    public java.awt.Component getTableCellRendererComponent(javax.swing.JTable, Object, boolean, boolean, int, int);
}
org/jfree/ui/OverlayLayout.class
package org.jfree.ui;
public final synchronized class OverlayLayout implements java.awt.LayoutManager {
    private boolean ignoreInvisible;
    public void OverlayLayout(boolean);
    public void OverlayLayout();
    public void addLayoutComponent(String, java.awt.Component);
    public void removeLayoutComponent(java.awt.Component);
    public void layoutContainer(java.awt.Container);
    public java.awt.Dimension minimumLayoutSize(java.awt.Container);
    public java.awt.Dimension preferredLayoutSize(java.awt.Container);
}
org/jfree/ui/PaintSample.class
package org.jfree.ui;
public synchronized class PaintSample extends javax.swing.JComponent {
    private java.awt.Paint paint;
    private java.awt.Dimension preferredSize;
    public void PaintSample(java.awt.Paint);
    public java.awt.Paint getPaint();
    public void setPaint(java.awt.Paint);
    public java.awt.Dimension getPreferredSize();
    public void paintComponent(java.awt.Graphics);
}
org/jfree/ui/RectangleAnchor.class
package org.jfree.ui;
public final synchronized class RectangleAnchor implements java.io.Serializable {
    private static final long serialVersionUID = -2457494205644416327;
    public static final RectangleAnchor CENTER;
    public static final RectangleAnchor TOP;
    public static final RectangleAnchor TOP_LEFT;
    public static final RectangleAnchor TOP_RIGHT;
    public static final RectangleAnchor BOTTOM;
    public static final RectangleAnchor BOTTOM_LEFT;
    public static final RectangleAnchor BOTTOM_RIGHT;
    public static final RectangleAnchor LEFT;
    public static final RectangleAnchor RIGHT;
    private String name;
    private void RectangleAnchor(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    public static java.awt.geom.Point2D coordinates(java.awt.geom.Rectangle2D, RectangleAnchor);
    public static java.awt.geom.Rectangle2D createRectangle(Size2D, double, double, RectangleAnchor);
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/ui/RectangleEdge.class
package org.jfree.ui;
public final synchronized class RectangleEdge implements java.io.Serializable {
    private static final long serialVersionUID = -7400988293691093548;
    public static final RectangleEdge TOP;
    public static final RectangleEdge BOTTOM;
    public static final RectangleEdge LEFT;
    public static final RectangleEdge RIGHT;
    private String name;
    private void RectangleEdge(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    public static boolean isTopOrBottom(RectangleEdge);
    public static boolean isLeftOrRight(RectangleEdge);
    public static RectangleEdge opposite(RectangleEdge);
    public static double coordinate(java.awt.geom.Rectangle2D, RectangleEdge);
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/ui/RectangleInsets.class
package org.jfree.ui;
public synchronized class RectangleInsets implements java.io.Serializable {
    private static final long serialVersionUID = 1902273207559319996;
    public static final RectangleInsets ZERO_INSETS;
    private org.jfree.util.UnitType unitType;
    private double top;
    private double left;
    private double bottom;
    private double right;
    public void RectangleInsets();
    public void RectangleInsets(double, double, double, double);
    public void RectangleInsets(org.jfree.util.UnitType, double, double, double, double);
    public org.jfree.util.UnitType getUnitType();
    public double getTop();
    public double getBottom();
    public double getLeft();
    public double getRight();
    public boolean equals(Object);
    public int hashCode();
    public String toString();
    public java.awt.geom.Rectangle2D createAdjustedRectangle(java.awt.geom.Rectangle2D, LengthAdjustmentType, LengthAdjustmentType);
    public java.awt.geom.Rectangle2D createInsetRectangle(java.awt.geom.Rectangle2D);
    public java.awt.geom.Rectangle2D createInsetRectangle(java.awt.geom.Rectangle2D, boolean, boolean);
    public java.awt.geom.Rectangle2D createOutsetRectangle(java.awt.geom.Rectangle2D);
    public java.awt.geom.Rectangle2D createOutsetRectangle(java.awt.geom.Rectangle2D, boolean, boolean);
    public double calculateTopInset(double);
    public double calculateTopOutset(double);
    public double calculateBottomInset(double);
    public double calculateBottomOutset(double);
    public double calculateLeftInset(double);
    public double calculateLeftOutset(double);
    public double calculateRightInset(double);
    public double calculateRightOutset(double);
    public double trimWidth(double);
    public double extendWidth(double);
    public double trimHeight(double);
    public double extendHeight(double);
    public void trim(java.awt.geom.Rectangle2D);
    static void ();
}
org/jfree/ui/RefineryUtilities.class
package org.jfree.ui;
public synchronized class RefineryUtilities {
    private void RefineryUtilities();
    public static java.awt.Point getCenterPoint();
    public static java.awt.Rectangle getMaximumWindowBounds();
    public static void centerFrameOnScreen(java.awt.Window);
    public static void positionFrameOnScreen(java.awt.Window, double, double);
    public static void positionFrameRandomly(java.awt.Window);
    public static void centerDialogInParent(java.awt.Dialog);
    public static void positionDialogRelativeToParent(java.awt.Dialog, double, double);
    public static javax.swing.JPanel createTablePanel(javax.swing.table.TableModel);
    public static javax.swing.JLabel createJLabel(String, java.awt.Font);
    public static javax.swing.JLabel createJLabel(String, java.awt.Font, java.awt.Color);
    public static javax.swing.JButton createJButton(String, java.awt.Font);
}
org/jfree/ui/SerialDateChooserPanel.class
package org.jfree.ui;
public synchronized class SerialDateChooserPanel extends javax.swing.JPanel implements java.awt.event.ActionListener {
    public static final java.awt.Color DEFAULT_DATE_BUTTON_COLOR;
    public static final java.awt.Color DEFAULT_MONTH_BUTTON_COLOR;
    private org.jfree.date.SerialDate date;
    private java.awt.Color dateButtonColor;
    private java.awt.Color monthButtonColor;
    private java.awt.Color chosenOtherButtonColor;
    private int firstDayOfWeek;
    private int yearSelectionRange;
    private java.awt.Font dateFont;
    private javax.swing.JComboBox monthSelector;
    private javax.swing.JComboBox yearSelector;
    private javax.swing.JButton todayButton;
    private javax.swing.JButton[] buttons;
    private boolean refreshing;
    public void SerialDateChooserPanel();
    public void SerialDateChooserPanel(org.jfree.date.SerialDate, boolean);
    public void SerialDateChooserPanel(org.jfree.date.SerialDate, boolean, java.awt.Color, java.awt.Color);
    public void setDate(org.jfree.date.SerialDate);
    public org.jfree.date.SerialDate getDate();
    public void actionPerformed(java.awt.event.ActionEvent);
    private javax.swing.JPanel getCalendarPanel();
    protected java.awt.Color getButtonColor(org.jfree.date.SerialDate);
    protected org.jfree.date.SerialDate getFirstVisibleDate();
    private int getFirstDayOfWeek();
    protected void refreshButtons();
    private void refreshYearSelector();
    private java.util.Vector getYears(int);
    private javax.swing.JPanel constructSelectionPanel();
    private javax.swing.JPanel constructControlPanel();
    static void ();
}
org/jfree/ui/Size2D.class
package org.jfree.ui;
public synchronized class Size2D implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = 2558191683786418168;
    public double width;
    public double height;
    public void Size2D();
    public void Size2D(double, double);
    public double getWidth();
    public void setWidth(double);
    public double getHeight();
    public void setHeight(double);
    public String toString();
    public boolean equals(Object);
    public Object clone() throws CloneNotSupportedException;
}
org/jfree/ui/SortableTable.class
package org.jfree.ui;
public synchronized class SortableTable extends javax.swing.JTable {
    private SortableTableHeaderListener headerListener;
    public void SortableTable(SortableTableModel);
    public void setSortableModel(SortableTableModel);
}
org/jfree/ui/SortableTableHeaderListener.class
package org.jfree.ui;
public synchronized class SortableTableHeaderListener implements java.awt.event.MouseListener, java.awt.event.MouseMotionListener {
    private SortableTableModel model;
    private SortButtonRenderer renderer;
    private int sortColumnIndex;
    public void SortableTableHeaderListener(SortableTableModel, SortButtonRenderer);
    public void setTableModel(SortableTableModel);
    public void mousePressed(java.awt.event.MouseEvent);
    public void mouseDragged(java.awt.event.MouseEvent);
    public void mouseEntered(java.awt.event.MouseEvent);
    public void mouseClicked(java.awt.event.MouseEvent);
    public void mouseMoved(java.awt.event.MouseEvent);
    public void mouseExited(java.awt.event.MouseEvent);
    public void mouseReleased(java.awt.event.MouseEvent);
}
org/jfree/ui/SortableTableModel.class
package org.jfree.ui;
public abstract synchronized class SortableTableModel extends javax.swing.table.AbstractTableModel {
    private int sortingColumn;
    private boolean ascending;
    public void SortableTableModel();
    public int getSortingColumn();
    public boolean isAscending();
    public void setAscending(boolean);
    public void sortByColumn(int, boolean);
    public boolean isSortable(int);
}
org/jfree/ui/SortButtonRenderer.class
package org.jfree.ui;
public synchronized class SortButtonRenderer implements javax.swing.table.TableCellRenderer {
    public static final int NONE = 0;
    public static final int DOWN = 1;
    public static final int UP = 2;
    private int pressedColumn;
    private javax.swing.JButton normalButton;
    private javax.swing.JButton ascendingButton;
    private javax.swing.JButton descendingButton;
    private boolean useLabels;
    private javax.swing.JLabel normalLabel;
    private javax.swing.JLabel ascendingLabel;
    private javax.swing.JLabel descendingLabel;
    public void SortButtonRenderer();
    public java.awt.Component getTableCellRendererComponent(javax.swing.JTable, Object, boolean, boolean, int, int);
    private javax.swing.JButton getRendererButton(boolean, boolean);
    private javax.swing.JLabel getRendererLabel(boolean, boolean);
    public void setPressedColumn(int);
}
org/jfree/ui/Spinner.class
package org.jfree.ui;
public synchronized class Spinner extends javax.swing.JPanel implements java.awt.event.MouseListener {
    private int value;
    private javax.swing.JTextField textField;
    private javax.swing.JPanel buttonPanel;
    private ArrowPanel upButton;
    private ArrowPanel downButton;
    public void Spinner(int);
    public int getValue();
    public void mouseClicked(java.awt.event.MouseEvent);
    public void mouseEntered(java.awt.event.MouseEvent);
    public void mouseExited(java.awt.event.MouseEvent);
    public void mousePressed(java.awt.event.MouseEvent);
    public void mouseReleased(java.awt.event.MouseEvent);
}
org/jfree/ui/StandardDialog.class
package org.jfree.ui;
public synchronized class StandardDialog extends javax.swing.JDialog implements java.awt.event.ActionListener {
    private boolean cancelled;
    protected static final java.util.ResourceBundle localizationResources;
    public void StandardDialog(java.awt.Frame, String, boolean);
    public void StandardDialog(java.awt.Dialog, String, boolean);
    public boolean isCancelled();
    public void actionPerformed(java.awt.event.ActionEvent);
    protected javax.swing.JPanel createButtonPanel();
    static void ();
}
org/jfree/ui/StandardGradientPaintTransformer.class
package org.jfree.ui;
public synchronized class StandardGradientPaintTransformer implements GradientPaintTransformer, Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = -8155025776964678320;
    private GradientPaintTransformType type;
    public void StandardGradientPaintTransformer();
    public void StandardGradientPaintTransformer(GradientPaintTransformType);
    public GradientPaintTransformType getType();
    public java.awt.GradientPaint transform(java.awt.GradientPaint, java.awt.Shape);
    public boolean equals(Object);
    public Object clone() throws CloneNotSupportedException;
    public int hashCode();
}
org/jfree/ui/StrokeChooserPanel$1.class
package org.jfree.ui;
synchronized class StrokeChooserPanel$1 implements java.awt.event.ActionListener {
    void StrokeChooserPanel$1(StrokeChooserPanel);
    public void actionPerformed(java.awt.event.ActionEvent);
}
org/jfree/ui/StrokeChooserPanel.class
package org.jfree.ui;
public synchronized class StrokeChooserPanel extends javax.swing.JPanel {
    private javax.swing.JComboBox selector;
    public void StrokeChooserPanel(StrokeSample, StrokeSample[]);
    protected final javax.swing.JComboBox getSelector();
    public java.awt.Stroke getSelectedStroke();
}
org/jfree/ui/StrokeSample.class
package org.jfree.ui;
public synchronized class StrokeSample extends javax.swing.JComponent implements javax.swing.ListCellRenderer {
    private java.awt.Stroke stroke;
    private java.awt.Dimension preferredSize;
    public void StrokeSample(java.awt.Stroke);
    public java.awt.Stroke getStroke();
    public void setStroke(java.awt.Stroke);
    public java.awt.Dimension getPreferredSize();
    public void paintComponent(java.awt.Graphics);
    public java.awt.Component getListCellRendererComponent(javax.swing.JList, Object, int, boolean, boolean);
}
org/jfree/ui/tabbedui/AbstractTabbedUI$ExitAction.class
package org.jfree.ui.tabbedui;
public synchronized class AbstractTabbedUI$ExitAction extends javax.swing.AbstractAction {
    public void AbstractTabbedUI$ExitAction(AbstractTabbedUI);
    public void actionPerformed(java.awt.event.ActionEvent);
}
org/jfree/ui/tabbedui/AbstractTabbedUI$TabChangeHandler.class
package org.jfree.ui.tabbedui;
synchronized class AbstractTabbedUI$TabChangeHandler implements javax.swing.event.ChangeListener {
    private final javax.swing.JTabbedPane pane;
    public void AbstractTabbedUI$TabChangeHandler(AbstractTabbedUI, javax.swing.JTabbedPane);
    public void stateChanged(javax.swing.event.ChangeEvent);
}
org/jfree/ui/tabbedui/AbstractTabbedUI$TabEnableChangeListener.class
package org.jfree.ui.tabbedui;
synchronized class AbstractTabbedUI$TabEnableChangeListener implements java.beans.PropertyChangeListener {
    public void AbstractTabbedUI$TabEnableChangeListener(AbstractTabbedUI);
    public void propertyChange(java.beans.PropertyChangeEvent);
}
org/jfree/ui/tabbedui/AbstractTabbedUI.class
package org.jfree.ui.tabbedui;
public abstract synchronized class AbstractTabbedUI extends javax.swing.JComponent {
    public static final String JMENUBAR_PROPERTY = jMenuBar;
    public static final String GLOBAL_MENU_PROPERTY = globalMenu;
    private java.util.ArrayList rootEditors;
    private javax.swing.JTabbedPane tabbedPane;
    private int selectedRootEditor;
    private javax.swing.JComponent currentToolbar;
    private javax.swing.JPanel toolbarContainer;
    private javax.swing.Action closeAction;
    private javax.swing.JMenuBar jMenuBar;
    private boolean globalMenu;
    public void AbstractTabbedUI();
    protected javax.swing.JTabbedPane getTabbedPane();
    public boolean isGlobalMenu();
    public void setGlobalMenu(boolean);
    public javax.swing.JMenuBar getJMenuBar();
    protected void setJMenuBar(javax.swing.JMenuBar);
    protected javax.swing.Action createCloseAction();
    public javax.swing.Action getCloseAction();
    protected abstract javax.swing.JMenu[] getPrefixMenus();
    protected abstract javax.swing.JMenu[] getPostfixMenus();
    private void addMenus(javax.swing.JMenuBar, javax.swing.JMenu[]);
    private javax.swing.JMenuBar updateGlobalMenubar();
    private javax.swing.JMenuBar createEditorMenubar(RootEditor);
    public void addRootEditor(RootEditor);
    public int getRootEditorCount();
    public RootEditor getRootEditor(int);
    public int getSelectedEditor();
    public void setSelectedEditor(int);
    private void closeToolbar();
    protected abstract void attempExit();
    protected void updateRootEditorEnabled(RootEditor);
}
org/jfree/ui/tabbedui/DetailEditor.class
package org.jfree.ui.tabbedui;
public abstract synchronized class DetailEditor extends javax.swing.JComponent {
    private Object object;
    private boolean confirmed;
    public void DetailEditor();
    public void update();
    public Object getObject();
    public void setObject(Object);
    protected static int parseInt(String, int);
    public abstract void clear();
    protected abstract void fillObject();
    protected abstract void updateObject(Object);
    public boolean isConfirmed();
    protected void setConfirmed(boolean);
}
org/jfree/ui/tabbedui/RootEditor.class
package org.jfree.ui.tabbedui;
public abstract interface RootEditor {
    public abstract void setActive(boolean);
    public abstract boolean isActive();
    public abstract String getEditorName();
    public abstract javax.swing.JMenu[] getMenus();
    public abstract javax.swing.JComponent getToolbar();
    public abstract javax.swing.JComponent getMainPanel();
    public abstract boolean isEnabled();
    public abstract void addPropertyChangeListener(String, java.beans.PropertyChangeListener);
    public abstract void removePropertyChangeListener(String, java.beans.PropertyChangeListener);
    public abstract void addPropertyChangeListener(java.beans.PropertyChangeListener);
    public abstract void removePropertyChangeListener(java.beans.PropertyChangeListener);
}
org/jfree/ui/tabbedui/RootPanel.class
package org.jfree.ui.tabbedui;
public abstract synchronized class RootPanel extends javax.swing.JComponent implements RootEditor {
    private boolean active;
    public void RootPanel();
    public final boolean isActive();
    protected void panelActivated();
    protected void panelDeactivated();
    public final void setActive(boolean);
    public javax.swing.JComponent getMainPanel();
    public javax.swing.JComponent getToolbar();
}
org/jfree/ui/tabbedui/TabbedApplet$MenuBarChangeListener.class
package org.jfree.ui.tabbedui;
synchronized class TabbedApplet$MenuBarChangeListener implements java.beans.PropertyChangeListener {
    public void TabbedApplet$MenuBarChangeListener(TabbedApplet);
    public void propertyChange(java.beans.PropertyChangeEvent);
}
org/jfree/ui/tabbedui/TabbedApplet.class
package org.jfree.ui.tabbedui;
public synchronized class TabbedApplet extends javax.swing.JApplet {
    private AbstractTabbedUI tabbedUI;
    public void TabbedApplet();
    protected final AbstractTabbedUI getTabbedUI();
    public void init(AbstractTabbedUI);
}
org/jfree/ui/tabbedui/TabbedDialog$1.class
package org.jfree.ui.tabbedui;
synchronized class TabbedDialog$1 extends java.awt.event.WindowAdapter {
    void TabbedDialog$1(TabbedDialog);
    public void windowClosing(java.awt.event.WindowEvent);
}
org/jfree/ui/tabbedui/TabbedDialog$MenuBarChangeListener.class
package org.jfree.ui.tabbedui;
synchronized class TabbedDialog$MenuBarChangeListener implements java.beans.PropertyChangeListener {
    public void TabbedDialog$MenuBarChangeListener(TabbedDialog);
    public void propertyChange(java.beans.PropertyChangeEvent);
}
org/jfree/ui/tabbedui/TabbedDialog.class
package org.jfree.ui.tabbedui;
public synchronized class TabbedDialog extends javax.swing.JDialog {
    private AbstractTabbedUI tabbedUI;
    public void TabbedDialog();
    public void TabbedDialog(java.awt.Dialog);
    public void TabbedDialog(java.awt.Dialog, boolean);
    public void TabbedDialog(java.awt.Dialog, String);
    public void TabbedDialog(java.awt.Dialog, String, boolean);
    public void TabbedDialog(java.awt.Frame);
    public void TabbedDialog(java.awt.Frame, boolean);
    public void TabbedDialog(java.awt.Frame, String);
    public void TabbedDialog(java.awt.Frame, String, boolean);
    protected final AbstractTabbedUI getTabbedUI();
    public void init(AbstractTabbedUI);
}
org/jfree/ui/tabbedui/TabbedFrame$1.class
package org.jfree.ui.tabbedui;
synchronized class TabbedFrame$1 extends java.awt.event.WindowAdapter {
    void TabbedFrame$1(TabbedFrame);
    public void windowClosing(java.awt.event.WindowEvent);
}
org/jfree/ui/tabbedui/TabbedFrame$MenuBarChangeListener.class
package org.jfree.ui.tabbedui;
synchronized class TabbedFrame$MenuBarChangeListener implements java.beans.PropertyChangeListener {
    public void TabbedFrame$MenuBarChangeListener(TabbedFrame);
    public void propertyChange(java.beans.PropertyChangeEvent);
}
org/jfree/ui/tabbedui/TabbedFrame.class
package org.jfree.ui.tabbedui;
public synchronized class TabbedFrame extends javax.swing.JFrame {
    private AbstractTabbedUI tabbedUI;
    public void TabbedFrame();
    public void TabbedFrame(String);
    protected final AbstractTabbedUI getTabbedUI();
    public void init(AbstractTabbedUI);
}
org/jfree/ui/tabbedui/VerticalLayout.class
package org.jfree.ui.tabbedui;
public synchronized class VerticalLayout implements java.awt.LayoutManager {
    private final boolean useSizeFromParent;
    public void VerticalLayout();
    public void VerticalLayout(boolean);
    public void addLayoutComponent(String, java.awt.Component);
    public void removeLayoutComponent(java.awt.Component);
    public java.awt.Dimension preferredLayoutSize(java.awt.Container);
    public java.awt.Dimension minimumLayoutSize(java.awt.Container);
    public boolean isUseSizeFromParent();
    public void layoutContainer(java.awt.Container);
}
org/jfree/ui/TextAnchor.class
package org.jfree.ui;
public final synchronized class TextAnchor implements java.io.Serializable {
    private static final long serialVersionUID = 8219158940496719660;
    public static final TextAnchor TOP_LEFT;
    public static final TextAnchor TOP_CENTER;
    public static final TextAnchor TOP_RIGHT;
    public static final TextAnchor HALF_ASCENT_LEFT;
    public static final TextAnchor HALF_ASCENT_CENTER;
    public static final TextAnchor HALF_ASCENT_RIGHT;
    public static final TextAnchor CENTER_LEFT;
    public static final TextAnchor CENTER;
    public static final TextAnchor CENTER_RIGHT;
    public static final TextAnchor BASELINE_LEFT;
    public static final TextAnchor BASELINE_CENTER;
    public static final TextAnchor BASELINE_RIGHT;
    public static final TextAnchor BOTTOM_LEFT;
    public static final TextAnchor BOTTOM_CENTER;
    public static final TextAnchor BOTTOM_RIGHT;
    private String name;
    private void TextAnchor(String);
    public boolean isLeft();
    public boolean isRight();
    public boolean isHorizontalCenter();
    public boolean isTop();
    public boolean isBottom();
    public boolean isBaseline();
    public boolean isHalfAscent();
    public boolean isVerticalCenter();
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/ui/UIUtilities.class
package org.jfree.ui;
public synchronized class UIUtilities {
    private void UIUtilities();
    public static void setupUI();
}
org/jfree/ui/VerticalAlignment.class
package org.jfree.ui;
public final synchronized class VerticalAlignment implements java.io.Serializable {
    private static final long serialVersionUID = 7272397034325429853;
    public static final VerticalAlignment TOP;
    public static final VerticalAlignment BOTTOM;
    public static final VerticalAlignment CENTER;
    private String name;
    private void VerticalAlignment(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/ui/WizardDialog.class
package org.jfree.ui;
public synchronized class WizardDialog extends javax.swing.JDialog implements java.awt.event.ActionListener {
    private Object result;
    private int step;
    private WizardPanel currentPanel;
    private java.util.List panels;
    private javax.swing.JButton previousButton;
    private javax.swing.JButton nextButton;
    private javax.swing.JButton finishButton;
    private javax.swing.JButton helpButton;
    public void WizardDialog(javax.swing.JDialog, boolean, String, WizardPanel);
    public void WizardDialog(javax.swing.JFrame, boolean, String, WizardPanel);
    public Object getResult();
    public int getStepCount();
    public boolean canDoPreviousPanel();
    public boolean canDoNextPanel();
    public boolean canFinish();
    public WizardPanel getWizardPanel(int);
    public void actionPerformed(java.awt.event.ActionEvent);
    public void previous();
    public void next();
    public void finish();
    private void enableButtons();
    public boolean isCancelled();
    public javax.swing.JPanel createContent();
}
org/jfree/ui/WizardPanel.class
package org.jfree.ui;
public abstract synchronized class WizardPanel extends javax.swing.JPanel {
    private WizardDialog owner;
    protected void WizardPanel(java.awt.LayoutManager);
    public WizardDialog getOwner();
    public void setOwner(WizardDialog);
    public Object getResult();
    public abstract void returnFromLaterStep();
    public abstract boolean canRedisplayNextPanel();
    public abstract boolean hasNextPanel();
    public abstract boolean canFinish();
    public abstract WizardPanel getNextPanel();
}
org/jfree/util/AbstractObjectList.class
package org.jfree.util;
public synchronized class AbstractObjectList implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 7789833772597351595;
    public static final int DEFAULT_INITIAL_CAPACITY = 8;
    private transient Object[] objects;
    private int size;
    private int increment;
    protected void AbstractObjectList();
    protected void AbstractObjectList(int);
    protected void AbstractObjectList(int, int);
    protected Object get(int);
    protected void set(int, Object);
    public void clear();
    public int size();
    protected int indexOf(Object);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/util/ArrayUtilities.class
package org.jfree.util;
public synchronized class ArrayUtilities {
    private void ArrayUtilities();
    public static float[][] clone(float[][]);
    public static boolean equalReferencesInArrays(Object[], Object[]);
    public static boolean equal(float[][], float[][]);
    public static boolean hasDuplicateItems(Object[]);
    public static int compareVersionArrays(Comparable[], Comparable[]);
}
org/jfree/util/AttributedStringUtilities.class
package org.jfree.util;
public synchronized class AttributedStringUtilities {
    private void AttributedStringUtilities();
    public static boolean equal(java.text.AttributedString, java.text.AttributedString);
}
org/jfree/util/BooleanList.class
package org.jfree.util;
public synchronized class BooleanList extends AbstractObjectList {
    private static final long serialVersionUID = -8543170333219422042;
    public void BooleanList();
    public Boolean getBoolean(int);
    public void setBoolean(int, Boolean);
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/util/BooleanUtilities.class
package org.jfree.util;
public synchronized class BooleanUtilities {
    private void BooleanUtilities();
    public static Boolean valueOf(boolean);
}
org/jfree/util/ClassComparator.class
package org.jfree.util;
public synchronized class ClassComparator implements java.util.Comparator, java.io.Serializable {
    private static final long serialVersionUID = -5225335361837391120;
    public void ClassComparator();
    public int compare(Object, Object);
    public boolean isComparable(Class, Class);
}
org/jfree/util/Configuration.class
package org.jfree.util;
public abstract interface Configuration extends java.io.Serializable, Cloneable {
    public abstract String getConfigProperty(String);
    public abstract String getConfigProperty(String, String);
    public abstract java.util.Iterator findPropertyKeys(String);
    public abstract java.util.Enumeration getConfigProperties();
    public abstract Object clone() throws CloneNotSupportedException;
}
org/jfree/util/DefaultConfiguration.class
package org.jfree.util;
public synchronized class DefaultConfiguration extends java.util.Properties implements org.jfree.base.config.ModifiableConfiguration {
    public void DefaultConfiguration();
    public String getConfigProperty(String);
    public String getConfigProperty(String, String);
    public java.util.Iterator findPropertyKeys(String);
    public java.util.Enumeration getConfigProperties();
    public void setConfigProperty(String, String);
}
org/jfree/util/ExtendedConfiguration.class
package org.jfree.util;
public abstract interface ExtendedConfiguration extends Configuration {
    public abstract boolean isPropertySet(String);
    public abstract int getIntProperty(String);
    public abstract int getIntProperty(String, int);
    public abstract boolean getBoolProperty(String);
    public abstract boolean getBoolProperty(String, boolean);
}
org/jfree/util/ExtendedConfigurationWrapper.class
package org.jfree.util;
public synchronized class ExtendedConfigurationWrapper implements ExtendedConfiguration {
    private Configuration parent;
    public void ExtendedConfigurationWrapper(Configuration);
    public boolean getBoolProperty(String);
    public boolean getBoolProperty(String, boolean);
    public int getIntProperty(String);
    public int getIntProperty(String, int);
    public boolean isPropertySet(String);
    public java.util.Iterator findPropertyKeys(String);
    public String getConfigProperty(String);
    public String getConfigProperty(String, String);
    public java.util.Enumeration getConfigProperties();
    public Object clone() throws CloneNotSupportedException;
}
org/jfree/util/FastStack.class
package org.jfree.util;
public final synchronized class FastStack implements java.io.Serializable, Cloneable {
    private Object[] contents;
    private int size;
    private int initialSize;
    public void FastStack();
    public void FastStack(int);
    public boolean isEmpty();
    public int size();
    public void push(Object);
    public Object peek();
    public Object pop();
    public Object clone();
    public void clear();
    public Object get(int);
}
org/jfree/util/HashNMap$1.class
package org.jfree.util;
synchronized class HashNMap$1 {
}
org/jfree/util/HashNMap$EmptyIterator.class
package org.jfree.util;
final synchronized class HashNMap$EmptyIterator implements java.util.Iterator {
    private void HashNMap$EmptyIterator();
    public boolean hasNext();
    public Object next();
    public void remove();
}
org/jfree/util/HashNMap.class
package org.jfree.util;
public synchronized class HashNMap implements java.io.Serializable, Cloneable {
    private static final long serialVersionUID = -670924844536074826;
    private static final java.util.Iterator EMPTY_ITERATOR;
    private java.util.HashMap table;
    private static final Object[] EMPTY_ARRAY;
    public void HashNMap();
    protected java.util.List createList();
    public boolean put(Object, Object);
    public boolean add(Object, Object);
    public Object getFirst(Object);
    public Object get(Object, int);
    public java.util.Iterator getAll(Object);
    public java.util.Iterator keys();
    public java.util.Set keySet();
    public boolean remove(Object, Object);
    public void removeAll(Object);
    public void clear();
    public boolean containsKey(Object);
    public boolean containsValue(Object);
    public boolean containsValue(Object, Object);
    public boolean contains(Object);
    public Object clone() throws CloneNotSupportedException;
    public Object[] toArray(Object, Object[]);
    public Object[] toArray(Object);
    public int getValueCount(Object);
    static void ();
}
org/jfree/util/LineBreakIterator.class
package org.jfree.util;
public synchronized class LineBreakIterator implements java.util.Iterator {
    public static final int DONE = -1;
    private char[] text;
    private int position;
    public void LineBreakIterator();
    public void LineBreakIterator(String);
    public synchronized int nextPosition();
    public int nextWithEnd();
    public String getText();
    public void setText(String);
    public boolean hasNext();
    public Object next();
    public void remove();
}
org/jfree/util/Log$SimpleMessage.class
package org.jfree.util;
public synchronized class Log$SimpleMessage {
    private String message;
    private Object[] param;
    public void Log$SimpleMessage(String, Object);
    public void Log$SimpleMessage(String, Object, Object);
    public void Log$SimpleMessage(String, Object, Object, Object);
    public void Log$SimpleMessage(String, Object, Object, Object, Object);
    public void Log$SimpleMessage(String, Object[]);
    public String toString();
}
org/jfree/util/Log.class
package org.jfree.util;
public synchronized class Log {
    private int debuglevel;
    private LogTarget[] logTargets;
    private java.util.HashMap logContexts;
    private static Log singleton;
    protected void Log();
    public static synchronized Log getInstance();
    protected static synchronized void defineLog(Log);
    public int getDebuglevel();
    protected void setDebuglevel(int);
    public synchronized void addTarget(LogTarget);
    public synchronized void removeTarget(LogTarget);
    public LogTarget[] getTargets();
    public synchronized void replaceTargets(LogTarget);
    public static void debug(Object);
    public static void debug(Object, Exception);
    public static void info(Object);
    public static void info(Object, Exception);
    public static void warn(Object);
    public static void warn(Object, Exception);
    public static void error(Object);
    public static void error(Object, Exception);
    protected void doLog(int, Object);
    public static void log(int, Object);
    public static void log(int, Object, Exception);
    protected void doLog(int, Object, Exception);
    public void init();
    public static boolean isDebugEnabled();
    public static boolean isInfoEnabled();
    public static boolean isWarningEnabled();
    public static boolean isErrorEnabled();
    public static LogContext createContext(Class);
    public static LogContext createContext(String);
    protected LogContext internalCreateContext(String);
}
org/jfree/util/LogContext.class
package org.jfree.util;
public synchronized class LogContext {
    private String contextPrefix;
    public void LogContext(String);
    public boolean isDebugEnabled();
    public boolean isInfoEnabled();
    public boolean isWarningEnabled();
    public boolean isErrorEnabled();
    public void debug(Object);
    public void debug(Object, Exception);
    public void info(Object);
    public void info(Object, Exception);
    public void warn(Object);
    public void warn(Object, Exception);
    public void error(Object);
    public void error(Object, Exception);
    public void log(int, Object);
    public void log(int, Object, Exception);
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/util/LogTarget.class
package org.jfree.util;
public abstract interface LogTarget {
    public static final int ERROR = 0;
    public static final int WARN = 1;
    public static final int INFO = 2;
    public static final int DEBUG = 3;
    public static final String[] LEVELS;
    public abstract void log(int, Object);
    public abstract void log(int, Object, Exception);
    static void ();
}
org/jfree/util/ObjectList.class
package org.jfree.util;
public synchronized class ObjectList extends AbstractObjectList {
    public void ObjectList();
    public void ObjectList(int);
    public Object get(int);
    public void set(int, Object);
    public int indexOf(Object);
}
org/jfree/util/ObjectTable.class
package org.jfree.util;
public synchronized class ObjectTable implements java.io.Serializable {
    private static final long serialVersionUID = -3968322452944912066;
    private int rows;
    private int columns;
    private transient Object[][] data;
    private int rowIncrement;
    private int columnIncrement;
    public void ObjectTable();
    public void ObjectTable(int);
    public void ObjectTable(int, int);
    public int getColumnIncrement();
    public int getRowIncrement();
    protected void ensureRowCapacity(int);
    public void ensureCapacity(int, int);
    public int getRowCount();
    public int getColumnCount();
    protected Object getObject(int, int);
    protected void setObject(int, int, Object);
    public boolean equals(Object);
    public int hashCode();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    protected void writeSerializedData(java.io.ObjectOutputStream, Object) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    protected Object readSerializedData(java.io.ObjectInputStream) throws ClassNotFoundException, java.io.IOException;
    public void clear();
    protected void copyColumn(int, int);
    protected void copyRow(int, int);
    protected void setData(Object[][], int);
    protected Object[][] getData();
}
org/jfree/util/ObjectUtilities.class
package org.jfree.util;
public final synchronized class ObjectUtilities {
    public static final String THREAD_CONTEXT = ThreadContext;
    public static final String CLASS_CONTEXT = ClassContext;
    private static String classLoaderSource;
    private static ClassLoader classLoader;
    private void ObjectUtilities();
    public static String getClassLoaderSource();
    public static void setClassLoaderSource(String);
    public static boolean equal(Object, Object);
    public static int hashCode(Object);
    public static Object clone(Object) throws CloneNotSupportedException;
    public static java.util.Collection deepClone(java.util.Collection) throws CloneNotSupportedException;
    public static synchronized void setClassLoader(ClassLoader);
    public static ClassLoader getClassLoader();
    public static ClassLoader getClassLoader(Class);
    public static java.net.URL getResource(String, Class);
    public static java.net.URL getResourceRelative(String, Class);
    private static String convertName(String, Class);
    public static java.io.InputStream getResourceAsStream(String, Class);
    public static java.io.InputStream getResourceRelativeAsStream(String, Class);
    public static Object loadAndInstantiate(String, Class);
    public static Object loadAndInstantiate(String, Class, Class);
    public static boolean isJDK14();
    private static String[] parseVersions(String);
    static void ();
}
org/jfree/util/PaintList.class
package org.jfree.util;
public synchronized class PaintList extends AbstractObjectList {
    private static final long serialVersionUID = -708669381577938219;
    public void PaintList();
    public java.awt.Paint getPaint(int);
    public void setPaint(int, java.awt.Paint);
    public boolean equals(Object);
    public int hashCode();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/util/PaintUtilities.class
package org.jfree.util;
public synchronized class PaintUtilities {
    private void PaintUtilities();
    public static boolean equal(java.awt.Paint, java.awt.Paint);
    public static String colorToString(java.awt.Color);
    public static java.awt.Color stringToColor(String);
}
org/jfree/util/PrintStreamLogTarget.class
package org.jfree.util;
public synchronized class PrintStreamLogTarget implements LogTarget, java.io.Serializable {
    private static final long serialVersionUID = 6510564403264504688;
    private java.io.PrintStream printStream;
    public void PrintStreamLogTarget();
    public void PrintStreamLogTarget(java.io.PrintStream);
    public void log(int, Object);
    public void log(int, Object, Exception);
}
org/jfree/util/PublicCloneable.class
package org.jfree.util;
public abstract interface PublicCloneable extends Cloneable {
    public abstract Object clone() throws CloneNotSupportedException;
}
org/jfree/util/ReadOnlyIterator.class
package org.jfree.util;
public synchronized class ReadOnlyIterator implements java.util.Iterator {
    private java.util.Iterator base;
    public void ReadOnlyIterator(java.util.Iterator);
    public boolean hasNext();
    public Object next();
    public void remove();
}
org/jfree/util/ResourceBundleSupport.class
package org.jfree.util;
public synchronized class ResourceBundleSupport {
    private java.util.ResourceBundle resources;
    private java.util.TreeMap cache;
    private java.util.TreeSet lookupPath;
    private String resourceBase;
    private java.util.Locale locale;
    public void ResourceBundleSupport(java.util.Locale, String);
    protected void ResourceBundleSupport(java.util.Locale, java.util.ResourceBundle, String);
    public void ResourceBundleSupport(java.util.Locale, java.util.ResourceBundle);
    public void ResourceBundleSupport(String);
    protected void ResourceBundleSupport(java.util.ResourceBundle, String);
    public void ResourceBundleSupport(java.util.ResourceBundle);
    protected final String getResourceBase();
    public synchronized String getString(String);
    protected String internalGetString(String);
    public javax.swing.Icon getIcon(String, boolean);
    public javax.swing.Icon getIcon(String);
    public Integer getMnemonic(String);
    public Integer getOptionalMnemonic(String);
    public javax.swing.KeyStroke getKeyStroke(String);
    public javax.swing.KeyStroke getOptionalKeyStroke(String);
    public javax.swing.KeyStroke getKeyStroke(String, int);
    public javax.swing.KeyStroke getOptionalKeyStroke(String, int);
    public javax.swing.JMenu createMenu(String);
    public java.net.URL getResourceURL(String);
    private javax.swing.ImageIcon createIcon(String, boolean, boolean);
    private Integer createMnemonic(String);
    private int getMenuKeyMask();
    private java.awt.image.BufferedImage createTransparentImage(int, int);
    public javax.swing.Icon createTransparentIcon(int, int);
    public String formatMessage(String, Object);
    public String formatMessage(String, Object, Object);
    public String formatMessage(String, Object[]);
    public java.util.Locale getLocale();
}
org/jfree/util/ResourceBundleWrapper.class
package org.jfree.util;
public synchronized class ResourceBundleWrapper {
    private static java.net.URLClassLoader noCodeBaseClassLoader;
    private void ResourceBundleWrapper();
    public static void removeCodeBase(java.net.URL, java.net.URLClassLoader);
    public static final java.util.ResourceBundle getBundle(String);
    public static final java.util.ResourceBundle getBundle(String, java.util.Locale);
    public static java.util.ResourceBundle getBundle(String, java.util.Locale, ClassLoader);
}
org/jfree/util/Rotation.class
package org.jfree.util;
public final synchronized class Rotation implements java.io.Serializable {
    private static final long serialVersionUID = -4662815260201591676;
    public static final Rotation CLOCKWISE;
    public static final Rotation ANTICLOCKWISE;
    private String name;
    private double factor;
    private void Rotation(String, double);
    public String toString();
    public double getFactor();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/util/ShapeList.class
package org.jfree.util;
public synchronized class ShapeList extends AbstractObjectList {
    public void ShapeList();
    public java.awt.Shape getShape(int);
    public void setShape(int, java.awt.Shape);
    public Object clone() throws CloneNotSupportedException;
    public boolean equals(Object);
    public int hashCode();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/util/ShapeUtilities.class
package org.jfree.util;
public synchronized class ShapeUtilities {
    private static final float SQRT2;
    private void ShapeUtilities();
    public static java.awt.Shape clone(java.awt.Shape);
    public static boolean equal(java.awt.Shape, java.awt.Shape);
    public static boolean equal(java.awt.geom.Line2D, java.awt.geom.Line2D);
    public static boolean equal(java.awt.geom.Ellipse2D, java.awt.geom.Ellipse2D);
    public static boolean equal(java.awt.geom.Arc2D, java.awt.geom.Arc2D);
    public static boolean equal(java.awt.Polygon, java.awt.Polygon);
    public static boolean equal(java.awt.geom.GeneralPath, java.awt.geom.GeneralPath);
    public static java.awt.Shape createTranslatedShape(java.awt.Shape, double, double);
    public static java.awt.Shape createTranslatedShape(java.awt.Shape, org.jfree.ui.RectangleAnchor, double, double);
    public static java.awt.Shape rotateShape(java.awt.Shape, double, float, float);
    public static void drawRotatedShape(java.awt.Graphics2D, java.awt.Shape, double, float, float);
    public static java.awt.Shape createDiagonalCross(float, float);
    public static java.awt.Shape createRegularCross(float, float);
    public static java.awt.Shape createDiamond(float);
    public static java.awt.Shape createUpTriangle(float);
    public static java.awt.Shape createDownTriangle(float);
    public static java.awt.Shape createLineRegion(java.awt.geom.Line2D, float);
    public static java.awt.geom.Point2D getPointInRectangle(double, double, java.awt.geom.Rectangle2D);
    public static boolean contains(java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D);
    public static boolean intersects(java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D);
    static void ();
}
org/jfree/util/SortedConfigurationWriter.class
package org.jfree.util;
public synchronized class SortedConfigurationWriter {
    private static final int ESCAPE_KEY = 0;
    private static final int ESCAPE_VALUE = 1;
    private static final int ESCAPE_COMMENT = 2;
    private static final String END_OF_LINE;
    private static final char[] HEX_CHARS;
    public void SortedConfigurationWriter();
    protected String getDescription(String);
    public void save(String, Configuration) throws java.io.IOException;
    public void save(java.io.File, Configuration) throws java.io.IOException;
    public void save(java.io.OutputStream, Configuration) throws java.io.IOException;
    private void writeDescription(String, java.io.Writer) throws java.io.IOException;
    private void saveConvert(String, int, java.io.Writer) throws java.io.IOException;
    static void ();
}
org/jfree/util/SortOrder.class
package org.jfree.util;
public final synchronized class SortOrder implements java.io.Serializable {
    private static final long serialVersionUID = -2124469847758108312;
    public static final SortOrder ASCENDING;
    public static final SortOrder DESCENDING;
    private String name;
    private void SortOrder(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/util/StackableException.class
package org.jfree.util;
public abstract synchronized class StackableException extends Exception {
    private Exception parent;
    public void StackableException();
    public void StackableException(String, Exception);
    public void StackableException(String);
    public Exception getParent();
    public void printStackTrace(java.io.PrintStream);
    public void printStackTrace(java.io.PrintWriter);
    public void printStackTrace();
}
org/jfree/util/StackableRuntimeException.class
package org.jfree.util;
public synchronized class StackableRuntimeException extends RuntimeException {
    private Exception parent;
    public void StackableRuntimeException();
    public void StackableRuntimeException(String, Exception);
    public void StackableRuntimeException(String);
    public Exception getParent();
    public void printStackTrace(java.io.PrintStream);
    public void printStackTrace(java.io.PrintWriter);
}
org/jfree/util/StringUtils.class
package org.jfree.util;
public synchronized class StringUtils {
    private void StringUtils();
    public static boolean startsWithIgnoreCase(String, String);
    public static boolean endsWithIgnoreCase(String, String);
    public static String getLineSeparator();
}
org/jfree/util/StrokeList.class
package org.jfree.util;
public synchronized class StrokeList extends AbstractObjectList {
    public void StrokeList();
    public java.awt.Stroke getStroke(int);
    public void setStroke(int, java.awt.Stroke);
    public Object clone() throws CloneNotSupportedException;
    public boolean equals(Object);
    public int hashCode();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/util/TableOrder.class
package org.jfree.util;
public final synchronized class TableOrder implements java.io.Serializable {
    private static final long serialVersionUID = 525193294068177057;
    public static final TableOrder BY_ROW;
    public static final TableOrder BY_COLUMN;
    private String name;
    private void TableOrder(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/util/UnitType.class
package org.jfree.util;
public final synchronized class UnitType implements java.io.Serializable {
    private static final long serialVersionUID = 6531925392288519884;
    public static final UnitType ABSOLUTE;
    public static final UnitType RELATIVE;
    private String name;
    private void UnitType(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/util/WaitingImageObserver.class
package org.jfree.util;
public synchronized class WaitingImageObserver implements java.awt.image.ImageObserver, java.io.Serializable, Cloneable {
    static final long serialVersionUID = -807204410581383550;
    private boolean lock;
    private java.awt.Image image;
    private boolean error;
    public void WaitingImageObserver(java.awt.Image);
    public synchronized boolean imageUpdate(java.awt.Image, int, int, int, int, int);
    public synchronized void waitImageLoaded();
    public Object clone() throws CloneNotSupportedException;
    public boolean isLoadingComplete();
    public boolean isError();
}
org/jfree/xml/generator/attributehandler.properties
#
# Maps the attribute type class to the handler implementation
#
org.jfree.chart.axis.AxisLocation=org.jfree.chart.xml.attributehandlers.AxisLocationAttributeHandler
org.jfree.chart.renderer.ItemLabelAnchor=org.jfree.chart.xml.attributehandlers.ItemLabelAnchorAttributeHandler
org.jfree.chart.plot.PlotOrientation=org.jfree.chart.xml.attributehandlers.PlotOrientationAttributeHandler
org.jfree.ui.TextAnchor=org.jfree.chart.xml.attributehandlers.TextAnchorAttributeHandler
org/jfree/xml/generator/generator.properties
#
# Specifies the directory containing the sources ...
sourcedirectory=C:\Documents and Settings\sony\My Documents\eclipse-SDK-3.0M6-win32\eclipse\workspace\jfreechart-cvs\
#
# Where to generate the definition files ...
targetfile=C:\model.xml
#
# From where to load the attribute handler definitions...
attributedefinition=attributehandler.properties
#
# The list of base classes we ignore when collecting the sources.
# Use this to remove unnecessary references.
ignore.baseclass.0=junit.framework.TestCase
ignore.baseclass.1=java.util.ResourceBundle
ignore.baseclass.2=java.awt.Component
ignore.baseclass.3=org.jfree.chart.ChartColor
ignore.baseclass.4=org.jfree.chart.ChartFactory
ignore.baseclass.5=org.jfree.chart.ChartUtilities
ignore.baseclass.6=java.lang.Throwable
ignore.baseclass.7=java.util.EventObject
ignore.baseclass.8=javax.swing.text.AbstractDocument
#
# The list of packages we ignore.
ignore.package.0=com.keypoint
ignore.package.1=org.jfree.xml
ignore.package.2=org.jfree.threads
ignore.package.3=org.jfree.resources
ignore.package.4=org.jfree.util
ignore.package.5=org.jfree.layout
ignore.package.6=org.jfree.io
ignore.package.7=org.jfree.demo
ignore.package.8=org.jfree.chart.demo
ignore.package.9=org.jfree.chart.event
ignore.package.10=org.jfree.chart.junit
ignore.package.11=org.jfree.chart.resources
ignore.package.12=org.jfree.chart.ui
ignore.package.13=org.jfree.data.xml
ignore.package.14=org.jfree.chart.servlet
ignore.package.15=org.jfree.chart.renderer.junit
ignore.package.16=org.jfree.chart.xml
META-INF/maven/org.jfree/jcommon/pom.xml
 
     4.0.0
     JCommon
     jcommon
     org.jfree
     1.0.23
     jar
    
     
         org.sonatype.oss
         oss-parent
         9
    
     
         JFree.org
         http://www.jfree.org/
    
     2001
     
    JCommon is a free general purpose Java class library that is used in
    several projects at www.jfree.org, including JFreeChart and
    JFreeReport.
    
     http://www.jfree.org/jcommon/
     
         http://sourceforge.net/tracker/?group_id=15494
    
     
         scm:cvs:pserver:anonymous@cvs.sourceforge.net:/cvsroot/jfreechart:jcommon
         http://cvs.sourceforge.net/viewcvs.py/jfreechart/jcommon
    
     
         
             JFreeChart Developer List
             
        jfreechart-dev-request@lists.sourceforge.net?subject=subscribe
            
             
        jfreechart-dev-request@lists.sourceforge.net?subject=unsubscribe
            
             
        http://sourceforge.net/mailarchive/forum.php?forum=jfreechart-dev
            
        
    
     
    
    
     
         
             GNU Lesser General Public Licence
             http://www.gnu.org/licenses/lgpl.txt
             repo
        
    
     
         
             junit
             junit
             3.8.2
             test
        
    
     
       
         ossrh
         https://oss.sonatype.org/content/repositories/snapshots
      
        
    
     
         src/main/java
         src/test/java
         
             
                 src/main/java
                 
                     **/*.properties
                     **/*.txt
                     **/*.
                
            

             
                 org.apache.maven.plugins
                 maven-compiler-plugin
                 3.1
                 
                     ${project.source.level}
                     ${project.target.level}
                     ${project.build.sourceEncoding}
                     
                       org/jfree/demo/**
                       org/jfree/xml/**
                                    
                
            
             
                 org.apache.maven.plugins
                 maven-surefire-plugin
                 2.10
                 
                     
                         **/JCommonTestSuite.java
                         **/*PackageTests.java
                    
                
            
             
                 org.apache.maven.plugins
                 maven-resources-plugin
                 2.6
                 
                     ${project.build.sourceEncoding}
                
            
             
               org.apache.maven.plugins
               maven-gpg-plugin
               1.5
               
                 
                   sign-artifacts
                   verify
                   
                     sign
                  
                
              
            
             
               org.sonatype.plugins
               nexus-staging-maven-plugin
               1.6.2
               true
               
                 ossrh
                 https://oss.sonatype.org/
                 false
              
                        
             
               org.codehaus.mojo
               cobertura-maven-plugin
               2.5.1
            
             
                 org.apache.maven.plugins
                 maven-site-plugin
                 3.4
            
        
    
     
         
             
                 org.apache.maven.plugins
                 maven-javadoc-plugin
                 2.9.1
            
             
                 org.apache.maven.plugins
                 maven-surefire-report-plugin
                 2.8
            
             
                 org.apache.maven.plugins
                 maven-jxr-plugin
                 2.3
            
             
                 org.codehaus.mojo
                 cobertura-maven-plugin
                 2.5.1
            
        
    
     
         UTF-8
         1.6
         1.6
    
    
   
      
       release
       
         
           
             true
             org.apache.maven.plugins
             maven-javadoc-plugin
             2.9.1
             
               
                 attach-javadoc
                 
                   jar
                
              
            
             
               
                 org/jfree/demo/**
                 org/jfree/xml/**
              
            
          
           
             org.apache.maven.plugins
             maven-source-plugin
             2.2.1
             
               
                 attach-sources
                 
                   jar-no-fork
                
              
            
          
        
      
    
  
META-INF/maven/org.jfree/jcommon/pom.properties
#Generated by Maven
#Thu Jul 24 17:35:54 CEST 2014
version=1.0.23
groupId=org.jfree
artifactId=jcommon
New folder/Project/jfreechart-1.0.19.jar
META-INF/MANIFEST.MF
Manifest-Version: 1.0
Ant-Version: Apache Ant 1.8.2
Created-By: 1.8.0_05-b13 (Oracle Corporation)
Specification-Title: JFreeChart
Specification-Version: 1.0.19
Specification-Vendor: jfree.org
Implementation-Title: JFreeChart
Implementation-Version: 1.0.19
Implementation-Vendor: jfree.org
org/jfree/chart/ChartColor.class
package org.jfree.chart;
public synchronized class ChartColor extends java.awt.Color {
    public static final java.awt.Color VERY_DARK_RED;
    public static final java.awt.Color DARK_RED;
    public static final java.awt.Color LIGHT_RED;
    public static final java.awt.Color VERY_LIGHT_RED;
    public static final java.awt.Color VERY_DARK_YELLOW;
    public static final java.awt.Color DARK_YELLOW;
    public static final java.awt.Color LIGHT_YELLOW;
    public static final java.awt.Color VERY_LIGHT_YELLOW;
    public static final java.awt.Color VERY_DARK_GREEN;
    public static final java.awt.Color DARK_GREEN;
    public static final java.awt.Color LIGHT_GREEN;
    public static final java.awt.Color VERY_LIGHT_GREEN;
    public static final java.awt.Color VERY_DARK_CYAN;
    public static final java.awt.Color DARK_CYAN;
    public static final java.awt.Color LIGHT_CYAN;
    public static final java.awt.Color VERY_LIGHT_CYAN;
    public static final java.awt.Color VERY_DARK_BLUE;
    public static final java.awt.Color DARK_BLUE;
    public static final java.awt.Color LIGHT_BLUE;
    public static final java.awt.Color VERY_LIGHT_BLUE;
    public static final java.awt.Color VERY_DARK_MAGENTA;
    public static final java.awt.Color DARK_MAGENTA;
    public static final java.awt.Color LIGHT_MAGENTA;
    public static final java.awt.Color VERY_LIGHT_MAGENTA;
    public void ChartColor(int, int, int);
    public static java.awt.Paint[] createDefaultPaintArray();
    static void ();
}
org/jfree/chart/ChartFactory.class
package org.jfree.chart;
public abstract synchronized class ChartFactory {
    private static ChartTheme currentTheme;
    public void ChartFactory();
    public static ChartTheme getChartTheme();
    public static void setChartTheme(ChartTheme);
    public static JFreeChart createPieChart(String, org.jfree.data.general.PieDataset, boolean, boolean, java.util.Locale);
    public static JFreeChart createPieChart(String, org.jfree.data.general.PieDataset);
    public static JFreeChart createPieChart(String, org.jfree.data.general.PieDataset, boolean, boolean, boolean);
    public static JFreeChart createPieChart(String, org.jfree.data.general.PieDataset, org.jfree.data.general.PieDataset, int, boolean, boolean, boolean, java.util.Locale, boolean, boolean);
    public static JFreeChart createPieChart(String, org.jfree.data.general.PieDataset, org.jfree.data.general.PieDataset, int, boolean, boolean, boolean, boolean, boolean, boolean);
    public static JFreeChart createRingChart(String, org.jfree.data.general.PieDataset, boolean, boolean, java.util.Locale);
    public static JFreeChart createRingChart(String, org.jfree.data.general.PieDataset, boolean, boolean, boolean);
    public static JFreeChart createMultiplePieChart(String, org.jfree.data.category.CategoryDataset, org.jfree.util.TableOrder, boolean, boolean, boolean);
    public static JFreeChart createPieChart3D(String, org.jfree.data.general.PieDataset, boolean, boolean, java.util.Locale);
    public static JFreeChart createPieChart3D(String, org.jfree.data.general.PieDataset);
    public static JFreeChart createPieChart3D(String, org.jfree.data.general.PieDataset, boolean, boolean, boolean);
    public static JFreeChart createMultiplePieChart3D(String, org.jfree.data.category.CategoryDataset, org.jfree.util.TableOrder, boolean, boolean, boolean);
    public static JFreeChart createBarChart(String, String, String, org.jfree.data.category.CategoryDataset);
    public static JFreeChart createBarChart(String, String, String, org.jfree.data.category.CategoryDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createStackedBarChart(String, String, String, org.jfree.data.category.CategoryDataset);
    public static JFreeChart createStackedBarChart(String, String, String, org.jfree.data.category.CategoryDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createBarChart3D(String, String, String, org.jfree.data.category.CategoryDataset);
    public static JFreeChart createBarChart3D(String, String, String, org.jfree.data.category.CategoryDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createStackedBarChart3D(String, String, String, org.jfree.data.category.CategoryDataset);
    public static JFreeChart createStackedBarChart3D(String, String, String, org.jfree.data.category.CategoryDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createAreaChart(String, String, String, org.jfree.data.category.CategoryDataset);
    public static JFreeChart createAreaChart(String, String, String, org.jfree.data.category.CategoryDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createStackedAreaChart(String, String, String, org.jfree.data.category.CategoryDataset);
    public static JFreeChart createStackedAreaChart(String, String, String, org.jfree.data.category.CategoryDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createLineChart(String, String, String, org.jfree.data.category.CategoryDataset);
    public static JFreeChart createLineChart(String, String, String, org.jfree.data.category.CategoryDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createLineChart3D(String, String, String, org.jfree.data.category.CategoryDataset);
    public static JFreeChart createLineChart3D(String, String, String, org.jfree.data.category.CategoryDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createGanttChart(String, String, String, org.jfree.data.category.IntervalCategoryDataset);
    public static JFreeChart createGanttChart(String, String, String, org.jfree.data.category.IntervalCategoryDataset, boolean, boolean, boolean);
    public static JFreeChart createWaterfallChart(String, String, String, org.jfree.data.category.CategoryDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createPolarChart(String, org.jfree.data.xy.XYDataset, boolean, boolean, boolean);
    public static JFreeChart createScatterPlot(String, String, String, org.jfree.data.xy.XYDataset);
    public static JFreeChart createScatterPlot(String, String, String, org.jfree.data.xy.XYDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createXYBarChart(String, String, boolean, String, org.jfree.data.xy.IntervalXYDataset);
    public static JFreeChart createXYBarChart(String, String, boolean, String, org.jfree.data.xy.IntervalXYDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createXYAreaChart(String, String, String, org.jfree.data.xy.XYDataset);
    public static JFreeChart createXYAreaChart(String, String, String, org.jfree.data.xy.XYDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createStackedXYAreaChart(String, String, String, org.jfree.data.xy.TableXYDataset);
    public static JFreeChart createStackedXYAreaChart(String, String, String, org.jfree.data.xy.TableXYDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createXYLineChart(String, String, String, org.jfree.data.xy.XYDataset);
    public static JFreeChart createXYLineChart(String, String, String, org.jfree.data.xy.XYDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createXYStepChart(String, String, String, org.jfree.data.xy.XYDataset);
    public static JFreeChart createXYStepChart(String, String, String, org.jfree.data.xy.XYDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createXYStepAreaChart(String, String, String, org.jfree.data.xy.XYDataset);
    public static JFreeChart createXYStepAreaChart(String, String, String, org.jfree.data.xy.XYDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createTimeSeriesChart(String, String, String, org.jfree.data.xy.XYDataset);
    public static JFreeChart createTimeSeriesChart(String, String, String, org.jfree.data.xy.XYDataset, boolean, boolean, boolean);
    public static JFreeChart createCandlestickChart(String, String, String, org.jfree.data.xy.OHLCDataset, boolean);
    public static JFreeChart createHighLowChart(String, String, String, org.jfree.data.xy.OHLCDataset, boolean);
    public static JFreeChart createHighLowChart(String, String, String, org.jfree.data.xy.OHLCDataset, axis.Timeline, boolean);
    public static JFreeChart createBubbleChart(String, String, String, org.jfree.data.xy.XYZDataset);
    public static JFreeChart createBubbleChart(String, String, String, org.jfree.data.xy.XYZDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createHistogram(String, String, String, org.jfree.data.xy.IntervalXYDataset, plot.PlotOrientation, boolean, boolean, boolean);
    public static JFreeChart createBoxAndWhiskerChart(String, String, String, org.jfree.data.statistics.BoxAndWhiskerCategoryDataset, boolean);
    public static JFreeChart createBoxAndWhiskerChart(String, String, String, org.jfree.data.statistics.BoxAndWhiskerXYDataset, boolean);
    public static JFreeChart createWindPlot(String, String, String, org.jfree.data.xy.WindDataset, boolean, boolean, boolean);
    public static JFreeChart createWaferMapChart(String, org.jfree.data.general.WaferMapDataset, plot.PlotOrientation, boolean, boolean, boolean);
    static void ();
}
org/jfree/chart/ChartFrame.class
package org.jfree.chart;
public synchronized class ChartFrame extends javax.swing.JFrame {
    private ChartPanel chartPanel;
    public void ChartFrame(String, JFreeChart);
    public void ChartFrame(String, JFreeChart, boolean);
    public ChartPanel getChartPanel();
}
org/jfree/chart/ChartHints$Key.class
package org.jfree.chart;
public synchronized class ChartHints$Key extends java.awt.RenderingHints$Key {
    public void ChartHints$Key(int);
    public boolean isCompatibleValue(Object);
}
org/jfree/chart/ChartHints.class
package org.jfree.chart;
public final synchronized class ChartHints {
    public static final ChartHints$Key KEY_BEGIN_ELEMENT;
    public static final ChartHints$Key KEY_END_ELEMENT;
    private void ChartHints();
    static void ();
}
org/jfree/chart/ChartMouseEvent.class
package org.jfree.chart;
public synchronized class ChartMouseEvent extends java.util.EventObject implements java.io.Serializable {
    private static final long serialVersionUID = -682393837314562149;
    private JFreeChart chart;
    private java.awt.event.MouseEvent trigger;
    private entity.ChartEntity entity;
    public void ChartMouseEvent(JFreeChart, java.awt.event.MouseEvent, entity.ChartEntity);
    public JFreeChart getChart();
    public java.awt.event.MouseEvent getTrigger();
    public entity.ChartEntity getEntity();
}
org/jfree/chart/ChartMouseListener.class
package org.jfree.chart;
public abstract interface ChartMouseListener extends java.util.EventListener {
    public abstract void chartMouseClicked(ChartMouseEvent);
    public abstract void chartMouseMoved(ChartMouseEvent);
}
org/jfree/chart/ChartPanel.class
package org.jfree.chart;
public synchronized class ChartPanel extends javax.swing.JPanel implements event.ChartChangeListener, event.ChartProgressListener, java.awt.event.ActionListener, java.awt.event.MouseListener, java.awt.event.MouseMotionListener, event.OverlayChangeListener, java.awt.print.Printable, java.io.Serializable {
    private static final long serialVersionUID = 6046366297214274674;
    public static final boolean DEFAULT_BUFFER_USED = 1;
    public static final int DEFAULT_WIDTH = 680;
    public static final int DEFAULT_HEIGHT = 420;
    public static final int DEFAULT_MINIMUM_DRAW_WIDTH = 300;
    public static final int DEFAULT_MINIMUM_DRAW_HEIGHT = 200;
    public static final int DEFAULT_MAXIMUM_DRAW_WIDTH = 1024;
    public static final int DEFAULT_MAXIMUM_DRAW_HEIGHT = 768;
    public static final int DEFAULT_ZOOM_TRIGGER_DISTANCE = 10;
    public static final String PROPERTIES_COMMAND = PROPERTIES;
    public static final String COPY_COMMAND = COPY;
    public static final String SAVE_COMMAND = SAVE;
    private static final String SAVE_AS_PNG_COMMAND = SAVE_AS_PNG;
    private static final String SAVE_AS_SVG_COMMAND = SAVE_AS_SVG;
    private static final String SAVE_AS_PDF_COMMAND = SAVE_AS_PDF;
    public static final String PRINT_COMMAND = PRINT;
    public static final String ZOOM_IN_BOTH_COMMAND = ZOOM_IN_BOTH;
    public static final String ZOOM_IN_DOMAIN_COMMAND = ZOOM_IN_DOMAIN;
    public static final String ZOOM_IN_RANGE_COMMAND = ZOOM_IN_RANGE;
    public static final String ZOOM_OUT_BOTH_COMMAND = ZOOM_OUT_BOTH;
    public static final String ZOOM_OUT_DOMAIN_COMMAND = ZOOM_DOMAIN_BOTH;
    public static final String ZOOM_OUT_RANGE_COMMAND = ZOOM_RANGE_BOTH;
    public static final String ZOOM_RESET_BOTH_COMMAND = ZOOM_RESET_BOTH;
    public static final String ZOOM_RESET_DOMAIN_COMMAND = ZOOM_RESET_DOMAIN;
    public static final String ZOOM_RESET_RANGE_COMMAND = ZOOM_RESET_RANGE;
    private JFreeChart chart;
    private transient javax.swing.event.EventListenerList chartMouseListeners;
    private boolean useBuffer;
    private boolean refreshBuffer;
    private transient java.awt.Image chartBuffer;
    private int chartBufferHeight;
    private int chartBufferWidth;
    private int minimumDrawWidth;
    private int minimumDrawHeight;
    private int maximumDrawWidth;
    private int maximumDrawHeight;
    private javax.swing.JPopupMenu popup;
    private ChartRenderingInfo info;
    private java.awt.geom.Point2D anchor;
    private double scaleX;
    private double scaleY;
    private plot.PlotOrientation orientation;
    private boolean domainZoomable;
    private boolean rangeZoomable;
    private java.awt.geom.Point2D zoomPoint;
    private transient java.awt.geom.Rectangle2D zoomRectangle;
    private boolean fillZoomRectangle;
    private int zoomTriggerDistance;
    private boolean horizontalAxisTrace;
    private boolean verticalAxisTrace;
    private transient java.awt.geom.Line2D verticalTraceLine;
    private transient java.awt.geom.Line2D horizontalTraceLine;
    private javax.swing.JMenuItem zoomInBothMenuItem;
    private javax.swing.JMenuItem zoomInDomainMenuItem;
    private javax.swing.JMenuItem zoomInRangeMenuItem;
    private javax.swing.JMenuItem zoomOutBothMenuItem;
    private javax.swing.JMenuItem zoomOutDomainMenuItem;
    private javax.swing.JMenuItem zoomOutRangeMenuItem;
    private javax.swing.JMenuItem zoomResetBothMenuItem;
    private javax.swing.JMenuItem zoomResetDomainMenuItem;
    private javax.swing.JMenuItem zoomResetRangeMenuItem;
    private java.io.File defaultDirectoryForSaveAs;
    private boolean enforceFileExtensions;
    private boolean ownToolTipDelaysActive;
    private int originalToolTipInitialDelay;
    private int originalToolTipReshowDelay;
    private int originalToolTipDismissDelay;
    private int ownToolTipInitialDelay;
    private int ownToolTipReshowDelay;
    private int ownToolTipDismissDelay;
    private double zoomInFactor;
    private double zoomOutFactor;
    private boolean zoomAroundAnchor;
    private transient java.awt.Paint zoomOutlinePaint;
    private transient java.awt.Paint zoomFillPaint;
    protected static java.util.ResourceBundle localizationResources;
    private double panW;
    private double panH;
    private java.awt.Point panLast;
    private int panMask;
    private java.util.List overlays;
    private MouseWheelHandler mouseWheelHandler;
    public void ChartPanel(JFreeChart);
    public void ChartPanel(JFreeChart, boolean);
    public void ChartPanel(JFreeChart, boolean, boolean, boolean, boolean, boolean);
    public void ChartPanel(JFreeChart, int, int, int, int, int, int, boolean, boolean, boolean, boolean, boolean, boolean);
    public void ChartPanel(JFreeChart, int, int, int, int, int, int, boolean, boolean, boolean, boolean, boolean, boolean, boolean);
    public JFreeChart getChart();
    public void setChart(JFreeChart);
    public int getMinimumDrawWidth();
    public void setMinimumDrawWidth(int);
    public int getMaximumDrawWidth();
    public void setMaximumDrawWidth(int);
    public int getMinimumDrawHeight();
    public void setMinimumDrawHeight(int);
    public int getMaximumDrawHeight();
    public void setMaximumDrawHeight(int);
    public double getScaleX();
    public double getScaleY();
    public java.awt.geom.Point2D getAnchor();
    protected void setAnchor(java.awt.geom.Point2D);
    public javax.swing.JPopupMenu getPopupMenu();
    public void setPopupMenu(javax.swing.JPopupMenu);
    public ChartRenderingInfo getChartRenderingInfo();
    public void setMouseZoomable(boolean);
    public void setMouseZoomable(boolean, boolean);
    public boolean isDomainZoomable();
    public void setDomainZoomable(boolean);
    public boolean isRangeZoomable();
    public void setRangeZoomable(boolean);
    public boolean getFillZoomRectangle();
    public void setFillZoomRectangle(boolean);
    public int getZoomTriggerDistance();
    public void setZoomTriggerDistance(int);
    public boolean getHorizontalAxisTrace();
    public void setHorizontalAxisTrace(boolean);
    protected java.awt.geom.Line2D getHorizontalTraceLine();
    protected void setHorizontalTraceLine(java.awt.geom.Line2D);
    public boolean getVerticalAxisTrace();
    public void setVerticalAxisTrace(boolean);
    protected java.awt.geom.Line2D getVerticalTraceLine();
    protected void setVerticalTraceLine(java.awt.geom.Line2D);
    public java.io.File getDefaultDirectoryForSaveAs();
    public void setDefaultDirectoryForSaveAs(java.io.File);
    public boolean isEnforceFileExtensions();
    public void setEnforceFileExtensions(boolean);
    public boolean getZoomAroundAnchor();
    public void setZoomAroundAnchor(boolean);
    public java.awt.Paint getZoomFillPaint();
    public void setZoomFillPaint(java.awt.Paint);
    public java.awt.Paint getZoomOutlinePaint();
    public void setZoomOutlinePaint(java.awt.Paint);
    public boolean isMouseWheelEnabled();
    public void setMouseWheelEnabled(boolean);
    public void addOverlay(panel.Overlay);
    public void removeOverlay(panel.Overlay);
    public void overlayChanged(event.OverlayChangeEvent);
    public void setDisplayToolTips(boolean);
    public String getToolTipText(java.awt.event.MouseEvent);
    public java.awt.Point translateJava2DToScreen(java.awt.geom.Point2D);
    public java.awt.geom.Point2D translateScreenToJava2D(java.awt.Point);
    public java.awt.geom.Rectangle2D scale(java.awt.geom.Rectangle2D);
    public entity.ChartEntity getEntityForPoint(int, int);
    public boolean getRefreshBuffer();
    public void setRefreshBuffer(boolean);
    public void paintComponent(java.awt.Graphics);
    public void chartChanged(event.ChartChangeEvent);
    public void chartProgress(event.ChartProgressEvent);
    public void actionPerformed(java.awt.event.ActionEvent);
    public void mouseEntered(java.awt.event.MouseEvent);
    public void mouseExited(java.awt.event.MouseEvent);
    public void mousePressed(java.awt.event.MouseEvent);
    private java.awt.geom.Point2D getPointInRectangle(int, int, java.awt.geom.Rectangle2D);
    public void mouseDragged(java.awt.event.MouseEvent);
    public void mouseReleased(java.awt.event.MouseEvent);
    public void mouseClicked(java.awt.event.MouseEvent);
    public void mouseMoved(java.awt.event.MouseEvent);
    public void zoomInBoth(double, double);
    public void zoomInDomain(double, double);
    public void zoomInRange(double, double);
    public void zoomOutBoth(double, double);
    public void zoomOutDomain(double, double);
    public void zoomOutRange(double, double);
    public void zoom(java.awt.geom.Rectangle2D);
    public void restoreAutoBounds();
    public void restoreAutoDomainBounds();
    public void restoreAutoRangeBounds();
    public java.awt.geom.Rectangle2D getScreenDataArea();
    public java.awt.geom.Rectangle2D getScreenDataArea(int, int);
    public int getInitialDelay();
    public int getReshowDelay();
    public int getDismissDelay();
    public void setInitialDelay(int);
    public void setReshowDelay(int);
    public void setDismissDelay(int);
    public double getZoomInFactor();
    public void setZoomInFactor(double);
    public double getZoomOutFactor();
    public void setZoomOutFactor(double);
    private void drawZoomRectangle(java.awt.Graphics2D, boolean);
    private void drawHorizontalAxisTrace(java.awt.Graphics2D, int);
    private void drawVerticalAxisTrace(java.awt.Graphics2D, int);
    public void doEditChartProperties();
    public void doCopy();
    public void doSaveAs() throws java.io.IOException;
    private void saveAsSVG(java.io.File) throws java.io.IOException;
    private String generateSVG(int, int);
    private java.awt.Graphics2D createSVGGraphics2D(int, int);
    private void saveAsPDF(java.io.File);
    private boolean isOrsonPDFAvailable();
    private void writeAsPDF(java.io.File, int, int);
    public void createChartPrintJob();
    public int print(java.awt.Graphics, java.awt.print.PageFormat, int);
    public void addChartMouseListener(ChartMouseListener);
    public void removeChartMouseListener(ChartMouseListener);
    public java.util.EventListener[] getListeners(Class);
    protected javax.swing.JPopupMenu createPopupMenu(boolean, boolean, boolean, boolean);
    protected javax.swing.JPopupMenu createPopupMenu(boolean, boolean, boolean, boolean, boolean);
    protected void displayPopupMenu(int, int);
    public void updateUI();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    static void ();
}
org/jfree/chart/ChartRenderingInfo.class
package org.jfree.chart;
public synchronized class ChartRenderingInfo implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 2751952018173406822;
    private transient java.awt.geom.Rectangle2D chartArea;
    private plot.PlotRenderingInfo plotInfo;
    private entity.EntityCollection entities;
    public void ChartRenderingInfo();
    public void ChartRenderingInfo(entity.EntityCollection);
    public java.awt.geom.Rectangle2D getChartArea();
    public void setChartArea(java.awt.geom.Rectangle2D);
    public entity.EntityCollection getEntityCollection();
    public void setEntityCollection(entity.EntityCollection);
    public void clear();
    public plot.PlotRenderingInfo getPlotInfo();
    public boolean equals(Object);
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/ChartTheme.class
package org.jfree.chart;
public abstract interface ChartTheme {
    public abstract void apply(JFreeChart);
}
org/jfree/chart/ChartTransferable.class
package org.jfree.chart;
public synchronized class ChartTransferable implements java.awt.datatransfer.Transferable {
    final java.awt.datatransfer.DataFlavor imageFlavor;
    private JFreeChart chart;
    private int width;
    private int height;
    private int minDrawWidth;
    private int minDrawHeight;
    private int maxDrawWidth;
    private int maxDrawHeight;
    public void ChartTransferable(JFreeChart, int, int);
    public void ChartTransferable(JFreeChart, int, int, boolean);
    public void ChartTransferable(JFreeChart, int, int, int, int, int, int, boolean);
    public java.awt.datatransfer.DataFlavor[] getTransferDataFlavors();
    public boolean isDataFlavorSupported(java.awt.datatransfer.DataFlavor);
    public Object getTransferData(java.awt.datatransfer.DataFlavor) throws java.awt.datatransfer.UnsupportedFlavorException, java.io.IOException;
    private java.awt.image.BufferedImage createBufferedImage(JFreeChart, int, int, int, int, int, int);
}
org/jfree/chart/ChartUtilities.class
package org.jfree.chart;
public abstract synchronized class ChartUtilities {
    public void ChartUtilities();
    public static void applyCurrentTheme(JFreeChart);
    public static void writeChartAsPNG(java.io.OutputStream, JFreeChart, int, int) throws java.io.IOException;
    public static void writeChartAsPNG(java.io.OutputStream, JFreeChart, int, int, boolean, int) throws java.io.IOException;
    public static void writeChartAsPNG(java.io.OutputStream, JFreeChart, int, int, ChartRenderingInfo) throws java.io.IOException;
    public static void writeChartAsPNG(java.io.OutputStream, JFreeChart, int, int, ChartRenderingInfo, boolean, int) throws java.io.IOException;
    public static void writeScaledChartAsPNG(java.io.OutputStream, JFreeChart, int, int, int, int) throws java.io.IOException;
    public static void saveChartAsPNG(java.io.File, JFreeChart, int, int) throws java.io.IOException;
    public static void saveChartAsPNG(java.io.File, JFreeChart, int, int, ChartRenderingInfo) throws java.io.IOException;
    public static void saveChartAsPNG(java.io.File, JFreeChart, int, int, ChartRenderingInfo, boolean, int) throws java.io.IOException;
    public static void writeChartAsJPEG(java.io.OutputStream, JFreeChart, int, int) throws java.io.IOException;
    public static void writeChartAsJPEG(java.io.OutputStream, float, JFreeChart, int, int) throws java.io.IOException;
    public static void writeChartAsJPEG(java.io.OutputStream, JFreeChart, int, int, ChartRenderingInfo) throws java.io.IOException;
    public static void writeChartAsJPEG(java.io.OutputStream, float, JFreeChart, int, int, ChartRenderingInfo) throws java.io.IOException;
    public static void saveChartAsJPEG(java.io.File, JFreeChart, int, int) throws java.io.IOException;
    public static void saveChartAsJPEG(java.io.File, float, JFreeChart, int, int) throws java.io.IOException;
    public static void saveChartAsJPEG(java.io.File, JFreeChart, int, int, ChartRenderingInfo) throws java.io.IOException;
    public static void saveChartAsJPEG(java.io.File, float, JFreeChart, int, int, ChartRenderingInfo) throws java.io.IOException;
    public static void writeBufferedImageAsJPEG(java.io.OutputStream, java.awt.image.BufferedImage) throws java.io.IOException;
    public static void writeBufferedImageAsJPEG(java.io.OutputStream, float, java.awt.image.BufferedImage) throws java.io.IOException;
    public static void writeBufferedImageAsPNG(java.io.OutputStream, java.awt.image.BufferedImage) throws java.io.IOException;
    public static void writeBufferedImageAsPNG(java.io.OutputStream, java.awt.image.BufferedImage, boolean, int) throws java.io.IOException;
    public static byte[] encodeAsPNG(java.awt.image.BufferedImage) throws java.io.IOException;
    public static byte[] encodeAsPNG(java.awt.image.BufferedImage, boolean, int) throws java.io.IOException;
    public static void writeImageMap(java.io.PrintWriter, String, ChartRenderingInfo, boolean) throws java.io.IOException;
    public static void writeImageMap(java.io.PrintWriter, String, ChartRenderingInfo, imagemap.ToolTipTagFragmentGenerator, imagemap.URLTagFragmentGenerator) throws java.io.IOException;
    public static String getImageMap(String, ChartRenderingInfo);
    public static String getImageMap(String, ChartRenderingInfo, imagemap.ToolTipTagFragmentGenerator, imagemap.URLTagFragmentGenerator);
}
org/jfree/chart/ClipPath.class
package org.jfree.chart;
public synchronized class ClipPath implements Cloneable {
    private double[] xValue;
    private double[] yValue;
    private boolean clip;
    private boolean drawPath;
    private boolean fillPath;
    private java.awt.Paint fillPaint;
    private java.awt.Paint drawPaint;
    private java.awt.Stroke drawStroke;
    private java.awt.Composite composite;
    public void ClipPath();
    public void ClipPath(double[], double[]);
    public void ClipPath(double[], double[], boolean, boolean, boolean);
    public void ClipPath(double[], double[], boolean, boolean, java.awt.Paint, java.awt.Paint, java.awt.Stroke, java.awt.Composite);
    public java.awt.geom.GeneralPath draw(java.awt.Graphics2D, java.awt.geom.Rectangle2D, axis.ValueAxis, axis.ValueAxis);
    public java.awt.geom.GeneralPath generateClipPath(java.awt.geom.Rectangle2D, axis.ValueAxis, axis.ValueAxis);
    public java.awt.Composite getComposite();
    public java.awt.Paint getDrawPaint();
    public boolean isDrawPath();
    public java.awt.Stroke getDrawStroke();
    public java.awt.Paint getFillPaint();
    public boolean isFillPath();
    public double[] getXValue();
    public double[] getYValue();
    public void setComposite(java.awt.Composite);
    public void setDrawPaint(java.awt.Paint);
    public void setDrawPath(boolean);
    public void setDrawStroke(java.awt.Stroke);
    public void setFillPaint(java.awt.Paint);
    public void setFillPath(boolean);
    public void setXValue(double[]);
    public void setYValue(double[]);
    public boolean isClip();
    public void setClip(boolean);
    public Object clone() throws CloneNotSupportedException;
}
org/jfree/chart/DrawableLegendItem.class
package org.jfree.chart;
public synchronized class DrawableLegendItem {
    private LegendItem item;
    private double x;
    private double y;
    private double width;
    private double height;
    private java.awt.Shape marker;
    private java.awt.geom.Line2D line;
    private java.awt.geom.Point2D labelPosition;
    public void DrawableLegendItem(LegendItem);
    public LegendItem getItem();
    public double getX();
    public void setX(double);
    public double getY();
    public void setY(double);
    public double getWidth();
    public double getHeight();
    public double getMaxX();
    public double getMaxY();
    public java.awt.Shape getMarker();
    public void setMarker(java.awt.Shape);
    public void setLine(java.awt.geom.Line2D);
    public java.awt.geom.Line2D getLine();
    public java.awt.geom.Point2D getLabelPosition();
    public void setLabelPosition(java.awt.geom.Point2D);
    public void setBounds(double, double, double, double);
}
org/jfree/chart/Effect3D.class
package org.jfree.chart;
public abstract interface Effect3D {
    public abstract double getXOffset();
    public abstract double getYOffset();
}
org/jfree/chart/HashUtilities.class
package org.jfree.chart;
public synchronized class HashUtilities {
    public void HashUtilities();
    public static int hashCodeForPaint(java.awt.Paint);
    public static int hashCodeForDoubleArray(double[]);
    public static int hashCode(int, boolean);
    public static int hashCode(int, int);
    public static int hashCode(int, double);
    public static int hashCode(int, java.awt.Paint);
    public static int hashCode(int, java.awt.Stroke);
    public static int hashCode(int, String);
    public static int hashCode(int, Comparable);
    public static int hashCode(int, Object);
    public static int hashCode(int, org.jfree.util.BooleanList);
    public static int hashCode(int, org.jfree.util.PaintList);
    public static int hashCode(int, org.jfree.util.StrokeList);
}
org/jfree/chart/JFreeChart$1.class
package org.jfree.chart;
final synchronized class JFreeChart$1 extends java.awt.RenderingHints$Key {
    void JFreeChart$1(int);
    public boolean isCompatibleValue(Object);
}
org/jfree/chart/JFreeChart.class
package org.jfree.chart;
public synchronized class JFreeChart implements org.jfree.ui.Drawable, event.TitleChangeListener, event.PlotChangeListener, java.io.Serializable, Cloneable {
    private static final long serialVersionUID = -3470703747817429120;
    public static final org.jfree.ui.about.ProjectInfo INFO;
    public static final java.awt.Font DEFAULT_TITLE_FONT;
    public static final java.awt.Paint DEFAULT_BACKGROUND_PAINT;
    public static final java.awt.Image DEFAULT_BACKGROUND_IMAGE;
    public static final int DEFAULT_BACKGROUND_IMAGE_ALIGNMENT = 15;
    public static final float DEFAULT_BACKGROUND_IMAGE_ALPHA = 0.5;
    public static final java.awt.RenderingHints$Key KEY_SUPPRESS_SHADOW_GENERATION;
    private transient java.awt.RenderingHints renderingHints;
    private boolean borderVisible;
    private transient java.awt.Stroke borderStroke;
    private transient java.awt.Paint borderPaint;
    private org.jfree.ui.RectangleInsets padding;
    private title.TextTitle title;
    private java.util.List subtitles;
    private plot.Plot plot;
    private transient java.awt.Paint backgroundPaint;
    private transient java.awt.Image backgroundImage;
    private int backgroundImageAlignment;
    private float backgroundImageAlpha;
    private transient javax.swing.event.EventListenerList changeListeners;
    private transient javax.swing.event.EventListenerList progressListeners;
    private boolean notify;
    public void JFreeChart(plot.Plot);
    public void JFreeChart(String, plot.Plot);
    public void JFreeChart(String, java.awt.Font, plot.Plot, boolean);
    public java.awt.RenderingHints getRenderingHints();
    public void setRenderingHints(java.awt.RenderingHints);
    public boolean isBorderVisible();
    public void setBorderVisible(boolean);
    public java.awt.Stroke getBorderStroke();
    public void setBorderStroke(java.awt.Stroke);
    public java.awt.Paint getBorderPaint();
    public void setBorderPaint(java.awt.Paint);
    public org.jfree.ui.RectangleInsets getPadding();
    public void setPadding(org.jfree.ui.RectangleInsets);
    public title.TextTitle getTitle();
    public void setTitle(title.TextTitle);
    public void setTitle(String);
    public void addLegend(title.LegendTitle);
    public title.LegendTitle getLegend();
    public title.LegendTitle getLegend(int);
    public void removeLegend();
    public java.util.List getSubtitles();
    public void setSubtitles(java.util.List);
    public int getSubtitleCount();
    public title.Title getSubtitle(int);
    public void addSubtitle(title.Title);
    public void addSubtitle(int, title.Title);
    public void clearSubtitles();
    public void removeSubtitle(title.Title);
    public plot.Plot getPlot();
    public plot.CategoryPlot getCategoryPlot();
    public plot.XYPlot getXYPlot();
    public boolean getAntiAlias();
    public void setAntiAlias(boolean);
    public Object getTextAntiAlias();
    public void setTextAntiAlias(boolean);
    public void setTextAntiAlias(Object);
    public java.awt.Paint getBackgroundPaint();
    public void setBackgroundPaint(java.awt.Paint);
    public java.awt.Image getBackgroundImage();
    public void setBackgroundImage(java.awt.Image);
    public int getBackgroundImageAlignment();
    public void setBackgroundImageAlignment(int);
    public float getBackgroundImageAlpha();
    public void setBackgroundImageAlpha(float);
    public boolean isNotify();
    public void setNotify(boolean);
    public void draw(java.awt.Graphics2D, java.awt.geom.Rectangle2D);
    public void draw(java.awt.Graphics2D, java.awt.geom.Rectangle2D, ChartRenderingInfo);
    public void draw(java.awt.Graphics2D, java.awt.geom.Rectangle2D, java.awt.geom.Point2D, ChartRenderingInfo);
    private java.awt.geom.Rectangle2D createAlignedRectangle2D(org.jfree.ui.Size2D, java.awt.geom.Rectangle2D, org.jfree.ui.HorizontalAlignment, org.jfree.ui.VerticalAlignment);
    protected entity.EntityCollection drawTitle(title.Title, java.awt.Graphics2D, java.awt.geom.Rectangle2D, boolean);
    public java.awt.image.BufferedImage createBufferedImage(int, int);
    public java.awt.image.BufferedImage createBufferedImage(int, int, ChartRenderingInfo);
    public java.awt.image.BufferedImage createBufferedImage(int, int, int, ChartRenderingInfo);
    public java.awt.image.BufferedImage createBufferedImage(int, int, double, double, ChartRenderingInfo);
    public void handleClick(int, int, ChartRenderingInfo);
    public void addChangeListener(event.ChartChangeListener);
    public void removeChangeListener(event.ChartChangeListener);
    public void fireChartChanged();
    protected void notifyListeners(event.ChartChangeEvent);
    public void addProgressListener(event.ChartProgressListener);
    public void removeProgressListener(event.ChartProgressListener);
    protected void notifyListeners(event.ChartProgressEvent);
    public void titleChanged(event.TitleChangeEvent);
    public void plotChanged(event.PlotChangeEvent);
    public boolean equals(Object);
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    public static void main(String[]);
    public Object clone() throws CloneNotSupportedException;
    static void ();
}
org/jfree/chart/JFreeChartInfo.class
package org.jfree.chart;
synchronized class JFreeChartInfo extends org.jfree.ui.about.ProjectInfo {
    public void JFreeChartInfo();
    public java.awt.Image getLogo();
}
org/jfree/chart/LegendItem.class
package org.jfree.chart;
public synchronized class LegendItem implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = -797214582948827144;
    private org.jfree.data.general.Dataset dataset;
    private Comparable seriesKey;
    private int datasetIndex;
    private int series;
    private String label;
    private java.awt.Font labelFont;
    private transient java.awt.Paint labelPaint;
    private transient java.text.AttributedString attributedLabel;
    private String description;
    private String toolTipText;
    private String urlText;
    private boolean shapeVisible;
    private transient java.awt.Shape shape;
    private boolean shapeFilled;
    private transient java.awt.Paint fillPaint;
    private org.jfree.ui.GradientPaintTransformer fillPaintTransformer;
    private boolean shapeOutlineVisible;
    private transient java.awt.Paint outlinePaint;
    private transient java.awt.Stroke outlineStroke;
    private boolean lineVisible;
    private transient java.awt.Shape line;
    private transient java.awt.Stroke lineStroke;
    private transient java.awt.Paint linePaint;
    private static final java.awt.Shape UNUSED_SHAPE;
    private static final java.awt.Stroke UNUSED_STROKE;
    public void LegendItem(String);
    public void LegendItem(String, java.awt.Paint);
    public void LegendItem(String, String, String, String, java.awt.Shape, java.awt.Paint);
    public void LegendItem(String, String, String, String, java.awt.Shape, java.awt.Paint, java.awt.Stroke, java.awt.Paint);
    public void LegendItem(String, String, String, String, java.awt.Shape, java.awt.Stroke, java.awt.Paint);
    public void LegendItem(String, String, String, String, boolean, java.awt.Shape, boolean, java.awt.Paint, boolean, java.awt.Paint, java.awt.Stroke, boolean, java.awt.Shape, java.awt.Stroke, java.awt.Paint);
    public void LegendItem(java.text.AttributedString, String, String, String, java.awt.Shape, java.awt.Paint);
    public void LegendItem(java.text.AttributedString, String, String, String, java.awt.Shape, java.awt.Paint, java.awt.Stroke, java.awt.Paint);
    public void LegendItem(java.text.AttributedString, String, String, String, java.awt.Shape, java.awt.Stroke, java.awt.Paint);
    public void LegendItem(java.text.AttributedString, String, String, String, boolean, java.awt.Shape, boolean, java.awt.Paint, boolean, java.awt.Paint, java.awt.Stroke, boolean, java.awt.Shape, java.awt.Stroke, java.awt.Paint);
    private String characterIteratorToString(java.text.CharacterIterator);
    public org.jfree.data.general.Dataset getDataset();
    public void setDataset(org.jfree.data.general.Dataset);
    public int getDatasetIndex();
    public void setDatasetIndex(int);
    public Comparable getSeriesKey();
    public void setSeriesKey(Comparable);
    public int getSeriesIndex();
    public void setSeriesIndex(int);
    public String getLabel();
    public java.awt.Font getLabelFont();
    public void setLabelFont(java.awt.Font);
    public java.awt.Paint getLabelPaint();
    public void setLabelPaint(java.awt.Paint);
    public java.text.AttributedString getAttributedLabel();
    public String getDescription();
    public void setDescription(String);
    public String getToolTipText();
    public void setToolTipText(String);
    public String getURLText();
    public void setURLText(String);
    public boolean isShapeVisible();
    public void setShapeVisible(boolean);
    public java.awt.Shape getShape();
    public void setShape(java.awt.Shape);
    public boolean isShapeFilled();
    public java.awt.Paint getFillPaint();
    public void setFillPaint(java.awt.Paint);
    public boolean isShapeOutlineVisible();
    public java.awt.Stroke getLineStroke();
    public void setLineStroke(java.awt.Stroke);
    public java.awt.Paint getLinePaint();
    public void setLinePaint(java.awt.Paint);
    public java.awt.Paint getOutlinePaint();
    public void setOutlinePaint(java.awt.Paint);
    public java.awt.Stroke getOutlineStroke();
    public void setOutlineStroke(java.awt.Stroke);
    public boolean isLineVisible();
    public void setLineVisible(boolean);
    public java.awt.Shape getLine();
    public void setLine(java.awt.Shape);
    public org.jfree.ui.GradientPaintTransformer getFillPaintTransformer();
    public void setFillPaintTransformer(org.jfree.ui.GradientPaintTransformer);
    public boolean equals(Object);
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    static void ();
}
org/jfree/chart/LegendItemCollection.class
package org.jfree.chart;
public synchronized class LegendItemCollection implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 1365215565589815953;
    private java.util.List items;
    public void LegendItemCollection();
    public void add(LegendItem);
    public void addAll(LegendItemCollection);
    public LegendItem get(int);
    public int getItemCount();
    public java.util.Iterator iterator();
    public boolean equals(Object);
    public Object clone() throws CloneNotSupportedException;
}
org/jfree/chart/LegendItemSource.class
package org.jfree.chart;
public abstract interface LegendItemSource {
    public abstract LegendItemCollection getLegendItems();
}
org/jfree/chart/LegendRenderingOrder.class
package org.jfree.chart;
public final synchronized class LegendRenderingOrder implements java.io.Serializable {
    private static final long serialVersionUID = -3832486612685808616;
    public static final LegendRenderingOrder STANDARD;
    public static final LegendRenderingOrder REVERSE;
    private String name;
    private void LegendRenderingOrder(String);
    public String toString();
    public boolean equals(Object);
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/chart/LocalizationBundle.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file
# 
# Changes (from 31-Aug-2003)
# --------------------------
# 31-Aug-2003 : Initial version (AL);
# 27-Nov-2013 : Added PNG..., PDF..., Save_as and SVG... (DG)
#
Auto_Range=Auto Range
All_Axes=Both Axes
Chart=Chart
Chart_Properties=Chart Properties
Copy=Copy
Domain_Axis=Domain Axis
FILE_EXISTS_CONFIRM_OVERWRITE=The file already exists, are you sure you want to overwrite it?
PNG...=PNG...
PNG_Image_Files=PNG Image Files
PDF...=PDF...
PDF_Files=PDF Files
Print...=Print...
Properties...=Properties...
Range_Axis=Range Axis
Save_as=Save as
Save_as...=Save as...
SVG...=SVG...
SVG_Files=SVG Files
Zoom_In=Zoom In
Zoom_Out=Zoom Out
org/jfree/chart/LocalizationBundle_cs.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file
# 
# Changes (from 31-Aug-2003)
# --------------------------
# 31-Aug-2003 : Initial version (AL);
# 20-Mar-2010 : Czech translation;
#
Auto_Range=Auto rozm\u011br
All_Axes=Ob\u011b osy
Chart=Chart
Chart_Properties=Vlastnosti grafu
Copy=Kop\u00edrovat
Domain_Axis=Osa oblasti
PNG_Image_Files=Obr\u00e1zky PNG
Print...=Tisk...
Properties...=Vlastnosti...
Save_as...=Ulo\u017eit jako...
Range_Axis=Osa rozsahu
Zoom_In=P\u0159ibl\u00ed\u017eit
Zoom_Out=Odd\u00e1lit
org/jfree/chart/LocalizationBundle_de.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file - german version
# 
# Changes (from 31-Aug-2003)
# --------------------------
# 31-Aug-2003 : Initial version (AL);
# 15-Mar-2004 : Revised version (Christian W. Zuckschwerdt);
#
Auto_Range=Autojustage
All_Axes=Beide Achsen
Chart=Diagramm
Chart_Properties=Diagramm-Eigenschaften
Copy=Kopieren
Domain_Axis=Horizontale Achse
PNG_Image_Files=PNG Datei (Portable Network Graphics) (*.png)
Print...=Drucken...
Properties...=Eigenschaften...
Save_as...=Speichern unter...
Range_Axis=Vertikale Achse
Zoom_In=Hineinzoomen
Zoom_Out=Herauszoomen
org/jfree/chart/LocalizationBundle_es.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file - spanish version
#
# Changes (from 16-Dec-2003)
# --------------------------
# 16-Dec-2003 : Initial Version: Complejo Hospitalario Universitario Juan Canalejo
#
Auto_Range=Escala autom\u00E1tica
All_Axes=Todos los ejes
Chart=Chart
Chart_Properties=Propiedades del gr\u00E1fico
Copy=Copiar
Domain_Axis=Eje horizontal
PNG_Image_Files=Formato PNG (Portable Network Graphics) (*.png)
Print...=Imprimir...
Properties...=Propiedades...
Save_as...=Grabar como...
Range_Axis=Eje vertical
Zoom_In=Acercar
Zoom_Out=Alejar
org/jfree/chart/LocalizationBundle_fr.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file - french version
# 
# Changes (from 31-Aug-2003)
# --------------------------
# 31-Aug-2003 : Initial version (AL);
#
Auto_Range=Echelle automatique
All_Axes=Les deux axes
Chart=Chart
Chart_Properties=Propri\u00E9t\u00E9s du graphique
Copy=Copier
Domain_Axis=Axe horizontal
PNG_Image_Files=Format PNG (Portable Network Graphics) (*.png)
Print...=Imprimer...
Properties...=Propri\u00E9t\u00E9s...
Save_as...=Enregistrer sous...
Range_Axis=Axe vertical
Zoom_In=Zoom avant
Zoom_Out=Zoom arri\u00E8re
org/jfree/chart/LocalizationBundle_it.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file - italian version
Auto_Range=Dimensiona Automaticamente
All_Axes=Entrambi gli Assi
Chart=Chart
Chart_Properties=Propriet\u00E0 del Grafico
Copy=Copia
Domain_Axis=Asse Orizzontale
PNG_Image_Files=Immagine PNG
Print...=Stampa...
Properties...=Propriet\u00E0...
Save_as...=Salva Come...
Range_Axis=Asse Verticale
Zoom_In=Ingrandisci
Zoom_Out=Rimpicciolisci
org/jfree/chart/LocalizationBundle_ja.properties
All_Axes=\u4e21\u8ef8
Auto_Range=\u81ea\u52d5\u30b5\u30a4\u30b8\u30f3\u30b0
Chart=\u30c1\u30e3\u30fc\u30c8
Chart_Properties=\u30c1\u30e3\u30fc\u30c8 \u30d7\u30ed\u30d1\u30c6\u30a3
Copy=\u30b3\u30d4\u30fc
Domain_Axis=\u5206\u985e\u8ef8
PNG_Image_Files=PNG \u30a4\u30e1\u30fc\u30b8\u30d5\u30a1\u30a4\u30eb
Print...=\u5370\u5237...
Properties...=\u30d7\u30ed\u30d1\u30c6\u30a3...
Range_Axis=\u6570\u5024\u8ef8
Save_as...=\u5225\u540d\u3067\u4fdd\u5b58...
Zoom_In=\u30ba\u30fc\u30e0\u30a4\u30f3
Zoom_Out=\u30ba\u30fc\u30e0\u30a2\u30a6\u30c8
org/jfree/chart/LocalizationBundle_nl.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file
# 
# Changes (from 31-Aug-2003)
# --------------------------
# 24-Mar-2003 : Translated into Dutch
# 31-Aug-2003 : Initial version (AL);
#
Auto_Range=Automatisch bereik
All_Axes=Beide assen
Chart=Chart
Chart_Properties=Eigenschappen
Copy=Kopi\u00EBren
Domain_Axis=Horizontale As
PNG_Image_Files=PNG afbeelding
Print...=Afdrukken...
Properties...=Eigenschappen...
Save_as...=Opslaan als...
Range_Axis=Verticale As
Zoom_In=Inzoomen
Zoom_Out=Uitzoomen
org/jfree/chart/LocalizationBundle_pl.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file
# 
# Changes (from 15-Mar-2004)
# --------------------------
# 15-Mar-2004 : Initial version (Kuba Duda);
#
Auto_Range=Automatyczny zakres
All_Axes=Obie osie
Chart=Chart
Chart_Properties=W\u0142a\u015bciwo\u015bci wykresu
Copy=Kopiuj
Domain_Axis=O\u015b pozioma 
PNG_Image_Files=Pliki graficzne PNG
Print...=Drukuj...
Properties...=W\u0142a\u015bciwo\u015bci...
Save_as...=Zapisz jako...
Range_Axis=O\u015b pionowa
Zoom_In=Powi\u0119ksz
Zoom_Out=Pomniejsz
org/jfree/chart/LocalizationBundle_pt_BR.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file - portuguese version
#
# Changes (from 24-May-2007)
# --------------------------
# 24-May-2007 : Initial version (Leonardo Alves Machado);
#
Auto_Range=Escala autom\u00E1tica
All_Axes=Todos os eixos
Chart=Chart
Chart_Properties=Propriedades do gr\u00E1fico
Copy=Copiar
Domain_Axis=Eixo horizontal
PNG_Image_Files=Formato PNG (Portable Network Graphics) (*.png)
Print...=Imprimir...
Properties...=Propriedades...
Save_as...=Salvar como...
Range_Axis=Eixo vertical
Zoom_In=Ampliar
Zoom_Out=Reduzir
org/jfree/chart/LocalizationBundle_pt_PT.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file - portuguese version
# 
# Changes (from 09-Set-2003)
# --------------------------
# 09-Set-2003 : Initial version (ER);
#
Auto_Range=Escala autom\u00E1tica
All_Axes=Todos os eixos
Chart=Chart
Chart_Properties=Propriedades do gr\u00E1fico
Copy=Copiar
Domain_Axis=Eixo horizontal
PNG_Image_Files=Formato PNG (Portable Network Graphics) (*.png)
Print...=Imprimir...
Properties...=Propriedades...
Save_as...=Gravar como...
Range_Axis=Eixo vertical
Zoom_In=Aproximar
Zoom_Out=Afastar
org/jfree/chart/LocalizationBundle_ru.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file
# 
# Changes (from 10-Nov-2003)
# --------------------------
# 10-Nov-2003 : Initial version (AL);
#
Auto_Range=\u0410\u0432\u0442\u043e\u043c\u0430\u0441\u0448\u0442\u0430\u0431\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u0435
All_Axes=\u041f\u043e \u0432\u0441\u0435\u043c \u043e\u0441\u044f\u043c
Chart=Chart
Chart_Properties=\u041d\u0430\u0441\u0442\u0440\u043e\u0439\u043a\u0438 \u0433\u0440\u0430\u0444\u0438\u043a\u0430
Copy=\u041a\u043e\u043f\u0438\u0440\u043e\u0432\u0430\u0442\u044c
Domain_Axis=\u041f\u043e \u0433\u043e\u0440\u0438\u0437\u043e\u043d\u0442\u0430\u043b\u044c\u043d\u043e\u0439 \u043e\u0441\u0438
PNG_Image_Files=PNG \u0444\u0430\u0439\u043b
Print...=\u041f\u0435\u0447\u0430\u0442\u044c...
Properties...=\u041d\u0430\u0441\u0442\u0440\u043e\u0439\u043a\u0438...
Save_as...=\u0421\u043e\u0445\u0440\u0430\u043d\u0438\u0442\u044c \u043a\u0430\u043a...
Range_Axis=\u041f\u043e \u0432\u0435\u0440\u0442\u0438\u043a\u0430\u043b\u044c\u043d\u043e\u0439 \u043e\u0441\u0438
Zoom_In=\u041f\u0440\u0438\u0431\u043b\u0438\u0437\u0438\u0442\u044c
Zoom_Out=\u041e\u0442\u0434\u0430\u043b\u0438\u0442\u044c
org/jfree/chart/LocalizationBundle_zh_CN.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file
#
# Changes
# -------
# 29-Jun-2005 : Initial version, see: http://www.jfree.org/phpBB2/viewtopic.php?t=13495;
#
Auto_Range=\u81ea\u52a8\u8c03\u6574
All_Axes=\u6240\u6709\u8f74
Chart=Chart
Chart_Properties=\u56fe\u8868\u5c5e\u6027
Copy=\u590d\u5236
Domain_Axis=\u6c34\u5e73\u8f74
PNG_Image_Files=PNG \u683c\u5f0f\u7684\u56fe\u50cf
Print...=\u6253\u5370
Properties...=\u5c5e\u6027
Save_as...=\u53e6\u5b58\u4e3a
Range_Axis=\u5782\u76f4\u8f74
Zoom_In=\u653e\u5927
Zoom_Out=\u7f29\u5c0f 
org/jfree/chart/LocalizationBundle_zh_TW.properties
# org.jfree.chart.ChartPanel ResourceBundle properties file
# 
# Changes (from 31-Aug-2003)
# --------------------------
# 31-Aug-2003 : Initial version (AL);
#
Auto_Range=\u81ea\u52d5\u8abf\u6574
All_Axes=\u6240\u6709\u8ef8
Chart=Chart
Chart_Properties=\u5716\u8868\u5167\u5bb9
Copy=\u8907\u88fd
Domain_Axis=\u6a6b\u8ef8
PNG_Image_Files=PNG\u5716\u6a94
Print...=\u5217\u5370
Properties...=\u5167\u5bb9
Save_as...=\u53e6\u5b58\u65b0\u6a94
Range_Axis=\u7e31\u8ef8
Zoom_In=\u653e\u5927
Zoom_Out=\u7e2e\u5c0f
org/jfree/chart/MouseWheelHandler.class
package org.jfree.chart;
synchronized class MouseWheelHandler implements java.awt.event.MouseWheelListener, java.io.Serializable {
    private ChartPanel chartPanel;
    double zoomFactor;
    public void MouseWheelHandler(ChartPanel);
    public double getZoomFactor();
    public void setZoomFactor(double);
    public void mouseWheelMoved(java.awt.event.MouseWheelEvent);
    private void handleZoomable(plot.Zoomable, java.awt.event.MouseWheelEvent);
}
org/jfree/chart/PaintMap.class
package org.jfree.chart;
public synchronized class PaintMap implements Cloneable, java.io.Serializable {
    static final long serialVersionUID = -4639833772123069274;
    private transient java.util.Map store;
    public void PaintMap();
    public java.awt.Paint getPaint(Comparable);
    public boolean containsKey(Comparable);
    public void put(Comparable, java.awt.Paint);
    public void clear();
    public boolean equals(Object);
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/PolarChartPanel.class
package org.jfree.chart;
public synchronized class PolarChartPanel extends ChartPanel {
    private static final String POLAR_ZOOM_IN_ACTION_COMMAND = Polar Zoom In;
    private static final String POLAR_ZOOM_OUT_ACTION_COMMAND = Polar Zoom Out;
    private static final String POLAR_AUTO_RANGE_ACTION_COMMAND = Polar Auto Range;
    public void PolarChartPanel(JFreeChart);
    public void PolarChartPanel(JFreeChart, boolean);
    public void setChart(JFreeChart);
    protected javax.swing.JPopupMenu createPopupMenu(boolean, boolean, boolean, boolean);
    public void actionPerformed(java.awt.event.ActionEvent);
    private void checkChart(JFreeChart);
    private int getPopupMenuItem(javax.swing.JPopupMenu, String);
}
org/jfree/chart/StandardChartTheme$1.class
package org.jfree.chart;
final synchronized class StandardChartTheme$1 extends StandardChartTheme {
    void StandardChartTheme$1(String);
    public void apply(JFreeChart);
}
org/jfree/chart/StandardChartTheme.class
package org.jfree.chart;
public synchronized class StandardChartTheme implements ChartTheme, Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private String name;
    private java.awt.Font extraLargeFont;
    private java.awt.Font largeFont;
    private java.awt.Font regularFont;
    private java.awt.Font smallFont;
    private transient java.awt.Paint titlePaint;
    private transient java.awt.Paint subtitlePaint;
    private transient java.awt.Paint chartBackgroundPaint;
    private transient java.awt.Paint legendBackgroundPaint;
    private transient java.awt.Paint legendItemPaint;
    private plot.DrawingSupplier drawingSupplier;
    private transient java.awt.Paint plotBackgroundPaint;
    private transient java.awt.Paint plotOutlinePaint;
    private plot.PieLabelLinkStyle labelLinkStyle;
    private transient java.awt.Paint labelLinkPaint;
    private transient java.awt.Paint domainGridlinePaint;
    private transient java.awt.Paint rangeGridlinePaint;
    private transient java.awt.Paint baselinePaint;
    private transient java.awt.Paint crosshairPaint;
    private org.jfree.ui.RectangleInsets axisOffset;
    private transient java.awt.Paint axisLabelPaint;
    private transient java.awt.Paint tickLabelPaint;
    private transient java.awt.Paint itemLabelPaint;
    private boolean shadowVisible;
    private transient java.awt.Paint shadowPaint;
    private renderer.category.BarPainter barPainter;
    private renderer.xy.XYBarPainter xyBarPainter;
    private transient java.awt.Paint thermometerPaint;
    private transient java.awt.Paint wallPaint;
    private transient java.awt.Paint errorIndicatorPaint;
    private transient java.awt.Paint gridBandPaint;
    private transient java.awt.Paint gridBandAlternatePaint;
    private util.ShadowGenerator shadowGenerator;
    public static ChartTheme createJFreeTheme();
    public static ChartTheme createDarknessTheme();
    public static ChartTheme createLegacyTheme();
    public void StandardChartTheme(String);
    public void StandardChartTheme(String, boolean);
    public java.awt.Font getExtraLargeFont();
    public void setExtraLargeFont(java.awt.Font);
    public java.awt.Font getLargeFont();
    public void setLargeFont(java.awt.Font);
    public java.awt.Font getRegularFont();
    public void setRegularFont(java.awt.Font);
    public java.awt.Font getSmallFont();
    public void setSmallFont(java.awt.Font);
    public java.awt.Paint getTitlePaint();
    public void setTitlePaint(java.awt.Paint);
    public java.awt.Paint getSubtitlePaint();
    public void setSubtitlePaint(java.awt.Paint);
    public java.awt.Paint getChartBackgroundPaint();
    public void setChartBackgroundPaint(java.awt.Paint);
    public java.awt.Paint getLegendBackgroundPaint();
    public void setLegendBackgroundPaint(java.awt.Paint);
    public java.awt.Paint getLegendItemPaint();
    public void setLegendItemPaint(java.awt.Paint);
    public java.awt.Paint getPlotBackgroundPaint();
    public void setPlotBackgroundPaint(java.awt.Paint);
    public java.awt.Paint getPlotOutlinePaint();
    public void setPlotOutlinePaint(java.awt.Paint);
    public plot.PieLabelLinkStyle getLabelLinkStyle();
    public void setLabelLinkStyle(plot.PieLabelLinkStyle);
    public java.awt.Paint getLabelLinkPaint();
    public void setLabelLinkPaint(java.awt.Paint);
    public java.awt.Paint getDomainGridlinePaint();
    public void setDomainGridlinePaint(java.awt.Paint);
    public java.awt.Paint getRangeGridlinePaint();
    public void setRangeGridlinePaint(java.awt.Paint);
    public java.awt.Paint getBaselinePaint();
    public void setBaselinePaint(java.awt.Paint);
    public java.awt.Paint getCrosshairPaint();
    public void setCrosshairPaint(java.awt.Paint);
    public org.jfree.ui.RectangleInsets getAxisOffset();
    public void setAxisOffset(org.jfree.ui.RectangleInsets);
    public java.awt.Paint getAxisLabelPaint();
    public void setAxisLabelPaint(java.awt.Paint);
    public java.awt.Paint getTickLabelPaint();
    public void setTickLabelPaint(java.awt.Paint);
    public java.awt.Paint getItemLabelPaint();
    public void setItemLabelPaint(java.awt.Paint);
    public boolean isShadowVisible();
    public void setShadowVisible(boolean);
    public java.awt.Paint getShadowPaint();
    public void setShadowPaint(java.awt.Paint);
    public renderer.category.BarPainter getBarPainter();
    public void setBarPainter(renderer.category.BarPainter);
    public renderer.xy.XYBarPainter getXYBarPainter();
    public void setXYBarPainter(renderer.xy.XYBarPainter);
    public java.awt.Paint getThermometerPaint();
    public void setThermometerPaint(java.awt.Paint);
    public java.awt.Paint getWallPaint();
    public void setWallPaint(java.awt.Paint);
    public java.awt.Paint getErrorIndicatorPaint();
    public void setErrorIndicatorPaint(java.awt.Paint);
    public java.awt.Paint getGridBandPaint();
    public void setGridBandPaint(java.awt.Paint);
    public java.awt.Paint getGridBandAlternatePaint();
    public void setGridBandAlternatePaint(java.awt.Paint);
    public String getName();
    public plot.DrawingSupplier getDrawingSupplier();
    public void setDrawingSupplier(plot.DrawingSupplier);
    public void apply(JFreeChart);
    protected void applyToTitle(title.Title);
    protected void applyToBlockContainer(block.BlockContainer);
    protected void applyToBlock(block.Block);
    protected void applyToPlot(plot.Plot);
    protected void applyToPiePlot(plot.PiePlot);
    protected void applyToMultiplePiePlot(plot.MultiplePiePlot);
    protected void applyToCategoryPlot(plot.CategoryPlot);
    protected void applyToXYPlot(plot.XYPlot);
    protected void applyToFastScatterPlot(plot.FastScatterPlot);
    protected void applyToPolarPlot(plot.PolarPlot);
    protected void applyToSpiderWebPlot(plot.SpiderWebPlot);
    protected void applyToMeterPlot(plot.MeterPlot);
    protected void applyToThermometerPlot(plot.ThermometerPlot);
    protected void applyToCategoryAxis(axis.CategoryAxis);
    protected void applyToValueAxis(axis.ValueAxis);
    protected void applyToSymbolAxis(axis.SymbolAxis);
    protected void applyToPeriodAxis(axis.PeriodAxis);
    protected void applyToAbstractRenderer(renderer.AbstractRenderer);
    protected void applyToCategoryItemRenderer(renderer.category.CategoryItemRenderer);
    protected void applyToXYItemRenderer(renderer.xy.XYItemRenderer);
    protected void applyToXYAnnotation(annotations.XYAnnotation);
    public boolean equals(Object);
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/StrokeMap.class
package org.jfree.chart;
public synchronized class StrokeMap implements Cloneable, java.io.Serializable {
    static final long serialVersionUID = -8148916785963525169;
    private transient java.util.Map store;
    public void StrokeMap();
    public java.awt.Stroke getStroke(Comparable);
    public boolean containsKey(Comparable);
    public void put(Comparable, java.awt.Stroke);
    public void clear();
    public boolean equals(Object);
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/annotations/AbstractAnnotation.class
package org.jfree.chart.annotations;
public abstract synchronized class AbstractAnnotation implements Annotation, Cloneable, java.io.Serializable {
    private transient javax.swing.event.EventListenerList listenerList;
    private boolean notify;
    protected void AbstractAnnotation();
    public void addChangeListener(org.jfree.chart.event.AnnotationChangeListener);
    public void removeChangeListener(org.jfree.chart.event.AnnotationChangeListener);
    public boolean hasListener(java.util.EventListener);
    protected void fireAnnotationChanged();
    protected void notifyListeners(org.jfree.chart.event.AnnotationChangeEvent);
    public boolean getNotify();
    public void setNotify(boolean);
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/annotations/AbstractXYAnnotation.class
package org.jfree.chart.annotations;
public abstract synchronized class AbstractXYAnnotation extends AbstractAnnotation implements XYAnnotation {
    private String toolTipText;
    private String url;
    protected void AbstractXYAnnotation();
    public String getToolTipText();
    public void setToolTipText(String);
    public String getURL();
    public void setURL(String);
    public abstract void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
    protected void addEntity(org.jfree.chart.plot.PlotRenderingInfo, java.awt.Shape, int, String, String);
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/chart/annotations/Annotation.class
package org.jfree.chart.annotations;
public abstract interface Annotation {
    public abstract void addChangeListener(org.jfree.chart.event.AnnotationChangeListener);
    public abstract void removeChangeListener(org.jfree.chart.event.AnnotationChangeListener);
}
org/jfree/chart/annotations/CategoryAnnotation.class
package org.jfree.chart.annotations;
public abstract interface CategoryAnnotation extends Annotation {
    public abstract void draw(java.awt.Graphics2D, org.jfree.chart.plot.CategoryPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.CategoryAxis, org.jfree.chart.axis.ValueAxis);
}
org/jfree/chart/annotations/CategoryLineAnnotation.class
package org.jfree.chart.annotations;
public synchronized class CategoryLineAnnotation extends AbstractAnnotation implements CategoryAnnotation, Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    static final long serialVersionUID = 3477740483341587984;
    private Comparable category1;
    private double value1;
    private Comparable category2;
    private double value2;
    private transient java.awt.Paint paint;
    private transient java.awt.Stroke stroke;
    public void CategoryLineAnnotation(Comparable, double, Comparable, double, java.awt.Paint, java.awt.Stroke);
    public Comparable getCategory1();
    public void setCategory1(Comparable);
    public double getValue1();
    public void setValue1(double);
    public Comparable getCategory2();
    public void setCategory2(Comparable);
    public double getValue2();
    public void setValue2(double);
    public java.awt.Paint getPaint();
    public void setPaint(java.awt.Paint);
    public java.awt.Stroke getStroke();
    public void setStroke(java.awt.Stroke);
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.CategoryPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.CategoryAxis, org.jfree.chart.axis.ValueAxis);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/annotations/CategoryPointerAnnotation.class
package org.jfree.chart.annotations;
public synchronized class CategoryPointerAnnotation extends CategoryTextAnnotation implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = -4031161445009858551;
    public static final double DEFAULT_TIP_RADIUS = 10.0;
    public static final double DEFAULT_BASE_RADIUS = 30.0;
    public static final double DEFAULT_LABEL_OFFSET = 3.0;
    public static final double DEFAULT_ARROW_LENGTH = 5.0;
    public static final double DEFAULT_ARROW_WIDTH = 3.0;
    private double angle;
    private double tipRadius;
    private double baseRadius;
    private double arrowLength;
    private double arrowWidth;
    private transient java.awt.Stroke arrowStroke;
    private transient java.awt.Paint arrowPaint;
    private double labelOffset;
    public void CategoryPointerAnnotation(String, Comparable, double, double);
    public double getAngle();
    public void setAngle(double);
    public double getTipRadius();
    public void setTipRadius(double);
    public double getBaseRadius();
    public void setBaseRadius(double);
    public double getLabelOffset();
    public void setLabelOffset(double);
    public double getArrowLength();
    public void setArrowLength(double);
    public double getArrowWidth();
    public void setArrowWidth(double);
    public java.awt.Stroke getArrowStroke();
    public void setArrowStroke(java.awt.Stroke);
    public java.awt.Paint getArrowPaint();
    public void setArrowPaint(java.awt.Paint);
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.CategoryPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.CategoryAxis, org.jfree.chart.axis.ValueAxis);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/annotations/CategoryTextAnnotation.class
package org.jfree.chart.annotations;
public synchronized class CategoryTextAnnotation extends TextAnnotation implements CategoryAnnotation, Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = 3333360090781320147;
    private Comparable category;
    private org.jfree.chart.axis.CategoryAnchor categoryAnchor;
    private double value;
    public void CategoryTextAnnotation(String, Comparable, double);
    public Comparable getCategory();
    public void setCategory(Comparable);
    public org.jfree.chart.axis.CategoryAnchor getCategoryAnchor();
    public void setCategoryAnchor(org.jfree.chart.axis.CategoryAnchor);
    public double getValue();
    public void setValue(double);
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.CategoryPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.CategoryAxis, org.jfree.chart.axis.ValueAxis);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
}
org/jfree/chart/annotations/TextAnnotation.class
package org.jfree.chart.annotations;
public synchronized class TextAnnotation extends AbstractAnnotation implements java.io.Serializable {
    private static final long serialVersionUID = 7008912287533127432;
    public static final java.awt.Font DEFAULT_FONT;
    public static final java.awt.Paint DEFAULT_PAINT;
    public static final org.jfree.ui.TextAnchor DEFAULT_TEXT_ANCHOR;
    public static final org.jfree.ui.TextAnchor DEFAULT_ROTATION_ANCHOR;
    public static final double DEFAULT_ROTATION_ANGLE = 0.0;
    private String text;
    private java.awt.Font font;
    private transient java.awt.Paint paint;
    private org.jfree.ui.TextAnchor textAnchor;
    private org.jfree.ui.TextAnchor rotationAnchor;
    private double rotationAngle;
    protected void TextAnnotation(String);
    public String getText();
    public void setText(String);
    public java.awt.Font getFont();
    public void setFont(java.awt.Font);
    public java.awt.Paint getPaint();
    public void setPaint(java.awt.Paint);
    public org.jfree.ui.TextAnchor getTextAnchor();
    public void setTextAnchor(org.jfree.ui.TextAnchor);
    public org.jfree.ui.TextAnchor getRotationAnchor();
    public void setRotationAnchor(org.jfree.ui.TextAnchor);
    public double getRotationAngle();
    public void setRotationAngle(double);
    public boolean equals(Object);
    public int hashCode();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    static void ();
}
org/jfree/chart/annotations/XYAnnotation.class
package org.jfree.chart.annotations;
public abstract interface XYAnnotation extends Annotation {
    public abstract void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
}
org/jfree/chart/annotations/XYAnnotationBoundsInfo.class
package org.jfree.chart.annotations;
public abstract interface XYAnnotationBoundsInfo {
    public abstract boolean getIncludeInDataBounds();
    public abstract org.jfree.data.Range getXRange();
    public abstract org.jfree.data.Range getYRange();
}
org/jfree/chart/annotations/XYBoxAnnotation.class
package org.jfree.chart.annotations;
public synchronized class XYBoxAnnotation extends AbstractXYAnnotation implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = 6764703772526757457;
    private double x0;
    private double y0;
    private double x1;
    private double y1;
    private transient java.awt.Stroke stroke;
    private transient java.awt.Paint outlinePaint;
    private transient java.awt.Paint fillPaint;
    public void XYBoxAnnotation(double, double, double, double);
    public void XYBoxAnnotation(double, double, double, double, java.awt.Stroke, java.awt.Paint);
    public void XYBoxAnnotation(double, double, double, double, java.awt.Stroke, java.awt.Paint, java.awt.Paint);
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/annotations/XYDataImageAnnotation.class
package org.jfree.chart.annotations;
public synchronized class XYDataImageAnnotation extends AbstractXYAnnotation implements Cloneable, org.jfree.util.PublicCloneable, XYAnnotationBoundsInfo {
    private transient java.awt.Image image;
    private double x;
    private double y;
    private double w;
    private double h;
    private boolean includeInDataBounds;
    public void XYDataImageAnnotation(java.awt.Image, double, double, double, double);
    public void XYDataImageAnnotation(java.awt.Image, double, double, double, double, boolean);
    public java.awt.Image getImage();
    public double getX();
    public double getY();
    public double getWidth();
    public double getHeight();
    public boolean getIncludeInDataBounds();
    public org.jfree.data.Range getXRange();
    public org.jfree.data.Range getYRange();
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/annotations/XYDrawableAnnotation.class
package org.jfree.chart.annotations;
public synchronized class XYDrawableAnnotation extends AbstractXYAnnotation implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = -6540812859722691020;
    private double drawScaleFactor;
    private double x;
    private double y;
    private double displayWidth;
    private double displayHeight;
    private org.jfree.ui.Drawable drawable;
    public void XYDrawableAnnotation(double, double, double, double, org.jfree.ui.Drawable);
    public void XYDrawableAnnotation(double, double, double, double, double, org.jfree.ui.Drawable);
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
}
org/jfree/chart/annotations/XYImageAnnotation.class
package org.jfree.chart.annotations;
public synchronized class XYImageAnnotation extends AbstractXYAnnotation implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = -4364694501921559958;
    private double x;
    private double y;
    private transient java.awt.Image image;
    private org.jfree.ui.RectangleAnchor anchor;
    public void XYImageAnnotation(double, double, java.awt.Image);
    public void XYImageAnnotation(double, double, java.awt.Image, org.jfree.ui.RectangleAnchor);
    public double getX();
    public double getY();
    public java.awt.Image getImage();
    public org.jfree.ui.RectangleAnchor getImageAnchor();
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/annotations/XYLineAnnotation.class
package org.jfree.chart.annotations;
public synchronized class XYLineAnnotation extends AbstractXYAnnotation implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = -80535465244091334;
    private double x1;
    private double y1;
    private double x2;
    private double y2;
    private transient java.awt.Stroke stroke;
    private transient java.awt.Paint paint;
    public void XYLineAnnotation(double, double, double, double);
    public void XYLineAnnotation(double, double, double, double, java.awt.Stroke, java.awt.Paint);
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/annotations/XYPointerAnnotation.class
package org.jfree.chart.annotations;
public synchronized class XYPointerAnnotation extends XYTextAnnotation implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = -4031161445009858551;
    public static final double DEFAULT_TIP_RADIUS = 10.0;
    public static final double DEFAULT_BASE_RADIUS = 30.0;
    public static final double DEFAULT_LABEL_OFFSET = 3.0;
    public static final double DEFAULT_ARROW_LENGTH = 5.0;
    public static final double DEFAULT_ARROW_WIDTH = 3.0;
    private double angle;
    private double tipRadius;
    private double baseRadius;
    private double arrowLength;
    private double arrowWidth;
    private transient java.awt.Stroke arrowStroke;
    private transient java.awt.Paint arrowPaint;
    private double labelOffset;
    public void XYPointerAnnotation(String, double, double, double);
    public double getAngle();
    public void setAngle(double);
    public double getTipRadius();
    public void setTipRadius(double);
    public double getBaseRadius();
    public void setBaseRadius(double);
    public double getLabelOffset();
    public void setLabelOffset(double);
    public double getArrowLength();
    public void setArrowLength(double);
    public double getArrowWidth();
    public void setArrowWidth(double);
    public java.awt.Stroke getArrowStroke();
    public void setArrowStroke(java.awt.Stroke);
    public java.awt.Paint getArrowPaint();
    public void setArrowPaint(java.awt.Paint);
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/annotations/XYPolygonAnnotation.class
package org.jfree.chart.annotations;
public synchronized class XYPolygonAnnotation extends AbstractXYAnnotation implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = -6984203651995900036;
    private double[] polygon;
    private transient java.awt.Stroke stroke;
    private transient java.awt.Paint outlinePaint;
    private transient java.awt.Paint fillPaint;
    public void XYPolygonAnnotation(double[]);
    public void XYPolygonAnnotation(double[], java.awt.Stroke, java.awt.Paint);
    public void XYPolygonAnnotation(double[], java.awt.Stroke, java.awt.Paint, java.awt.Paint);
    public double[] getPolygonCoordinates();
    public java.awt.Paint getFillPaint();
    public java.awt.Stroke getOutlineStroke();
    public java.awt.Paint getOutlinePaint();
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/annotations/XYShapeAnnotation.class
package org.jfree.chart.annotations;
public synchronized class XYShapeAnnotation extends AbstractXYAnnotation implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = -8553218317600684041;
    private transient java.awt.Shape shape;
    private transient java.awt.Stroke stroke;
    private transient java.awt.Paint outlinePaint;
    private transient java.awt.Paint fillPaint;
    public void XYShapeAnnotation(java.awt.Shape);
    public void XYShapeAnnotation(java.awt.Shape, java.awt.Stroke, java.awt.Paint);
    public void XYShapeAnnotation(java.awt.Shape, java.awt.Stroke, java.awt.Paint, java.awt.Paint);
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/annotations/XYTextAnnotation.class
package org.jfree.chart.annotations;
public synchronized class XYTextAnnotation extends AbstractXYAnnotation implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = -2946063342782506328;
    public static final java.awt.Font DEFAULT_FONT;
    public static final java.awt.Paint DEFAULT_PAINT;
    public static final org.jfree.ui.TextAnchor DEFAULT_TEXT_ANCHOR;
    public static final org.jfree.ui.TextAnchor DEFAULT_ROTATION_ANCHOR;
    public static final double DEFAULT_ROTATION_ANGLE = 0.0;
    private String text;
    private java.awt.Font font;
    private transient java.awt.Paint paint;
    private double x;
    private double y;
    private org.jfree.ui.TextAnchor textAnchor;
    private org.jfree.ui.TextAnchor rotationAnchor;
    private double rotationAngle;
    private transient java.awt.Paint backgroundPaint;
    private boolean outlineVisible;
    private transient java.awt.Paint outlinePaint;
    private transient java.awt.Stroke outlineStroke;
    public void XYTextAnnotation(String, double, double);
    public String getText();
    public void setText(String);
    public java.awt.Font getFont();
    public void setFont(java.awt.Font);
    public java.awt.Paint getPaint();
    public void setPaint(java.awt.Paint);
    public org.jfree.ui.TextAnchor getTextAnchor();
    public void setTextAnchor(org.jfree.ui.TextAnchor);
    public org.jfree.ui.TextAnchor getRotationAnchor();
    public void setRotationAnchor(org.jfree.ui.TextAnchor);
    public double getRotationAngle();
    public void setRotationAngle(double);
    public double getX();
    public void setX(double);
    public double getY();
    public void setY(double);
    public java.awt.Paint getBackgroundPaint();
    public void setBackgroundPaint(java.awt.Paint);
    public java.awt.Paint getOutlinePaint();
    public void setOutlinePaint(java.awt.Paint);
    public java.awt.Stroke getOutlineStroke();
    public void setOutlineStroke(java.awt.Stroke);
    public boolean isOutlineVisible();
    public void setOutlineVisible(boolean);
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    static void ();
}
org/jfree/chart/annotations/XYTitleAnnotation.class
package org.jfree.chart.annotations;
public synchronized class XYTitleAnnotation extends AbstractXYAnnotation implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = -4364694501921559958;
    private org.jfree.chart.util.XYCoordinateType coordinateType;
    private double x;
    private double y;
    private double maxWidth;
    private double maxHeight;
    private org.jfree.chart.title.Title title;
    private org.jfree.ui.RectangleAnchor anchor;
    public void XYTitleAnnotation(double, double, org.jfree.chart.title.Title);
    public void XYTitleAnnotation(double, double, org.jfree.chart.title.Title, org.jfree.ui.RectangleAnchor);
    public org.jfree.chart.util.XYCoordinateType getCoordinateType();
    public double getX();
    public double getY();
    public org.jfree.chart.title.Title getTitle();
    public org.jfree.ui.RectangleAnchor getTitleAnchor();
    public double getMaxWidth();
    public void setMaxWidth(double);
    public double getMaxHeight();
    public void setMaxHeight(double);
    public void draw(java.awt.Graphics2D, org.jfree.chart.plot.XYPlot, java.awt.geom.Rectangle2D, org.jfree.chart.axis.ValueAxis, org.jfree.chart.axis.ValueAxis, int, org.jfree.chart.plot.PlotRenderingInfo);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
}
org/jfree/chart/axis/Axis.class
package org.jfree.chart.axis;
public abstract synchronized class Axis implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 7719289504573298271;
    public static final boolean DEFAULT_AXIS_VISIBLE = 1;
    public static final java.awt.Font DEFAULT_AXIS_LABEL_FONT;
    public static final java.awt.Paint DEFAULT_AXIS_LABEL_PAINT;
    public static final org.jfree.ui.RectangleInsets DEFAULT_AXIS_LABEL_INSETS;
    public static final java.awt.Paint DEFAULT_AXIS_LINE_PAINT;
    public static final java.awt.Stroke DEFAULT_AXIS_LINE_STROKE;
    public static final boolean DEFAULT_TICK_LABELS_VISIBLE = 1;
    public static final java.awt.Font DEFAULT_TICK_LABEL_FONT;
    public static final java.awt.Paint DEFAULT_TICK_LABEL_PAINT;
    public static final org.jfree.ui.RectangleInsets DEFAULT_TICK_LABEL_INSETS;
    public static final boolean DEFAULT_TICK_MARKS_VISIBLE = 1;
    public static final java.awt.Stroke DEFAULT_TICK_MARK_STROKE;
    public static final java.awt.Paint DEFAULT_TICK_MARK_PAINT;
    public static final float DEFAULT_TICK_MARK_INSIDE_LENGTH = 0.0;
    public static final float DEFAULT_TICK_MARK_OUTSIDE_LENGTH = 2.0;
    private boolean visible;
    private String label;
    private transient java.text.AttributedString attributedLabel;
    private java.awt.Font labelFont;
    private transient java.awt.Paint labelPaint;
    private org.jfree.ui.RectangleInsets labelInsets;
    private double labelAngle;
    private AxisLabelLocation labelLocation;
    private boolean axisLineVisible;
    private transient java.awt.Stroke axisLineStroke;
    private transient java.awt.Paint axisLinePaint;
    private boolean tickLabelsVisible;
    private java.awt.Font tickLabelFont;
    private transient java.awt.Paint tickLabelPaint;
    private org.jfree.ui.RectangleInsets tickLabelInsets;
    private boolean tickMarksVisible;
    private float tickMarkInsideLength;
    private float tickMarkOutsideLength;
    private boolean minorTickMarksVisible;
    private float minorTickMarkInsideLength;
    private float minorTickMarkOutsideLength;
    private transient java.awt.Stroke tickMarkStroke;
    private transient java.awt.Paint tickMarkPaint;
    private double fixedDimension;
    private transient org.jfree.chart.plot.Plot plot;
    private transient javax.swing.event.EventListenerList listenerList;
    protected void Axis(String);
    public boolean isVisible();
    public void setVisible(boolean);
    public String getLabel();
    public void setLabel(String);
    public java.text.AttributedString getAttributedLabel();
    public void setAttributedLabel(String);
    public void setAttributedLabel(java.text.AttributedString);
    public java.text.AttributedString createAttributedLabel(String);
    public java.awt.Font getLabelFont();
    public void setLabelFont(java.awt.Font);
    public java.awt.Paint getLabelPaint();
    public void setLabelPaint(java.awt.Paint);
    public org.jfree.ui.RectangleInsets getLabelInsets();
    public void setLabelInsets(org.jfree.ui.RectangleInsets);
    public void setLabelInsets(org.jfree.ui.RectangleInsets, boolean);
    public double getLabelAngle();
    public void setLabelAngle(double);
    public AxisLabelLocation getLabelLocation();
    public void setLabelLocation(AxisLabelLocation);
    public boolean isAxisLineVisible();
    public void setAxisLineVisible(boolean);
    public java.awt.Paint getAxisLinePaint();
    public void setAxisLinePaint(java.awt.Paint);
    public java.awt.Stroke getAxisLineStroke();
    public void setAxisLineStroke(java.awt.Stroke);
    public boolean isTickLabelsVisible();
    public void setTickLabelsVisible(boolean);
    public boolean isMinorTickMarksVisible();
    public void setMinorTickMarksVisible(boolean);
    public java.awt.Font getTickLabelFont();
    public void setTickLabelFont(java.awt.Font);
    public java.awt.Paint getTickLabelPaint();
    public void setTickLabelPaint(java.awt.Paint);
    public org.jfree.ui.RectangleInsets getTickLabelInsets();
    public void setTickLabelInsets(org.jfree.ui.RectangleInsets);
    public boolean isTickMarksVisible();
    public void setTickMarksVisible(boolean);
    public float getTickMarkInsideLength();
    public void setTickMarkInsideLength(float);
    public float getTickMarkOutsideLength();
    public void setTickMarkOutsideLength(float);
    public java.awt.Stroke getTickMarkStroke();
    public void setTickMarkStroke(java.awt.Stroke);
    public java.awt.Paint getTickMarkPaint();
    public void setTickMarkPaint(java.awt.Paint);
    public float getMinorTickMarkInsideLength();
    public void setMinorTickMarkInsideLength(float);
    public float getMinorTickMarkOutsideLength();
    public void setMinorTickMarkOutsideLength(float);
    public org.jfree.chart.plot.Plot getPlot();
    public void setPlot(org.jfree.chart.plot.Plot);
    public double getFixedDimension();
    public void setFixedDimension(double);
    public abstract void configure();
    public abstract AxisSpace reserveSpace(java.awt.Graphics2D, org.jfree.chart.plot.Plot, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, AxisSpace);
    public abstract AxisState draw(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, org.jfree.chart.plot.PlotRenderingInfo);
    public abstract java.util.List refreshTicks(java.awt.Graphics2D, AxisState, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void createAndAddEntity(double, AxisState, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, org.jfree.chart.plot.PlotRenderingInfo);
    public void addChangeListener(org.jfree.chart.event.AxisChangeListener);
    public void removeChangeListener(org.jfree.chart.event.AxisChangeListener);
    public boolean hasListener(java.util.EventListener);
    protected void notifyListeners(org.jfree.chart.event.AxisChangeEvent);
    protected void fireChangeEvent();
    protected java.awt.geom.Rectangle2D getLabelEnclosure(java.awt.Graphics2D, org.jfree.ui.RectangleEdge);
    protected double labelLocationX(AxisLabelLocation, java.awt.geom.Rectangle2D);
    protected double labelLocationY(AxisLabelLocation, java.awt.geom.Rectangle2D);
    protected org.jfree.ui.TextAnchor labelAnchorH(AxisLabelLocation);
    protected org.jfree.ui.TextAnchor labelAnchorV(AxisLabelLocation);
    protected AxisState drawLabel(String, java.awt.Graphics2D, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, AxisState);
    protected AxisState drawAttributedLabel(java.text.AttributedString, java.awt.Graphics2D, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, AxisState);
    protected void drawAxisLine(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public Object clone() throws CloneNotSupportedException;
    public boolean equals(Object);
    public int hashCode();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    static void ();
}
org/jfree/chart/axis/AxisCollection.class
package org.jfree.chart.axis;
public synchronized class AxisCollection {
    private java.util.List axesAtTop;
    private java.util.List axesAtBottom;
    private java.util.List axesAtLeft;
    private java.util.List axesAtRight;
    public void AxisCollection();
    public java.util.List getAxesAtTop();
    public java.util.List getAxesAtBottom();
    public java.util.List getAxesAtLeft();
    public java.util.List getAxesAtRight();
    public void add(Axis, org.jfree.ui.RectangleEdge);
}
org/jfree/chart/axis/AxisLabelLocation.class
package org.jfree.chart.axis;
public final synchronized class AxisLabelLocation implements java.io.Serializable {
    private static final long serialVersionUID = 1;
    public static final AxisLabelLocation HIGH_END;
    public static final AxisLabelLocation MIDDLE;
    public static final AxisLabelLocation LOW_END;
    private String name;
    private void AxisLabelLocation(String);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/chart/axis/AxisLocation.class
package org.jfree.chart.axis;
public final synchronized class AxisLocation implements java.io.Serializable {
    private static final long serialVersionUID = -3276922179323563410;
    public static final AxisLocation TOP_OR_LEFT;
    public static final AxisLocation TOP_OR_RIGHT;
    public static final AxisLocation BOTTOM_OR_LEFT;
    public static final AxisLocation BOTTOM_OR_RIGHT;
    private String name;
    private void AxisLocation(String);
    public AxisLocation getOpposite();
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    public static AxisLocation getOpposite(AxisLocation);
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/chart/axis/AxisSpace.class
package org.jfree.chart.axis;
public synchronized class AxisSpace implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = -2490732595134766305;
    private double top;
    private double bottom;
    private double left;
    private double right;
    public void AxisSpace();
    public double getTop();
    public void setTop(double);
    public double getBottom();
    public void setBottom(double);
    public double getLeft();
    public void setLeft(double);
    public double getRight();
    public void setRight(double);
    public void add(double, org.jfree.ui.RectangleEdge);
    public void ensureAtLeast(AxisSpace);
    public void ensureAtLeast(double, org.jfree.ui.RectangleEdge);
    public java.awt.geom.Rectangle2D shrink(java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D);
    public java.awt.geom.Rectangle2D expand(java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D);
    public java.awt.geom.Rectangle2D reserved(java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public Object clone() throws CloneNotSupportedException;
    public boolean equals(Object);
    public int hashCode();
    public String toString();
}
org/jfree/chart/axis/AxisState.class
package org.jfree.chart.axis;
public synchronized class AxisState {
    private double cursor;
    private java.util.List ticks;
    private double max;
    public void AxisState();
    public void AxisState(double);
    public double getCursor();
    public void setCursor(double);
    public void moveCursor(double, org.jfree.ui.RectangleEdge);
    public void cursorUp(double);
    public void cursorDown(double);
    public void cursorLeft(double);
    public void cursorRight(double);
    public java.util.List getTicks();
    public void setTicks(java.util.List);
    public double getMax();
    public void setMax(double);
}
org/jfree/chart/axis/CategoryAnchor.class
package org.jfree.chart.axis;
public final synchronized class CategoryAnchor implements java.io.Serializable {
    private static final long serialVersionUID = -2604142742210173810;
    public static final CategoryAnchor START;
    public static final CategoryAnchor MIDDLE;
    public static final CategoryAnchor END;
    private String name;
    private void CategoryAnchor(String);
    public String toString();
    public boolean equals(Object);
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/chart/axis/CategoryAxis.class
package org.jfree.chart.axis;
public synchronized class CategoryAxis extends Axis implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 5886554608114265863;
    public static final double DEFAULT_AXIS_MARGIN = 0.05;
    public static final double DEFAULT_CATEGORY_MARGIN = 0.2;
    private double lowerMargin;
    private double upperMargin;
    private double categoryMargin;
    private int maximumCategoryLabelLines;
    private float maximumCategoryLabelWidthRatio;
    private int categoryLabelPositionOffset;
    private CategoryLabelPositions categoryLabelPositions;
    private java.util.Map tickLabelFontMap;
    private transient java.util.Map tickLabelPaintMap;
    private java.util.Map categoryLabelToolTips;
    private java.util.Map categoryLabelURLs;
    public void CategoryAxis();
    public void CategoryAxis(String);
    public double getLowerMargin();
    public void setLowerMargin(double);
    public double getUpperMargin();
    public void setUpperMargin(double);
    public double getCategoryMargin();
    public void setCategoryMargin(double);
    public int getMaximumCategoryLabelLines();
    public void setMaximumCategoryLabelLines(int);
    public float getMaximumCategoryLabelWidthRatio();
    public void setMaximumCategoryLabelWidthRatio(float);
    public int getCategoryLabelPositionOffset();
    public void setCategoryLabelPositionOffset(int);
    public CategoryLabelPositions getCategoryLabelPositions();
    public void setCategoryLabelPositions(CategoryLabelPositions);
    public java.awt.Font getTickLabelFont(Comparable);
    public void setTickLabelFont(Comparable, java.awt.Font);
    public java.awt.Paint getTickLabelPaint(Comparable);
    public void setTickLabelPaint(Comparable, java.awt.Paint);
    public void addCategoryLabelToolTip(Comparable, String);
    public String getCategoryLabelToolTip(Comparable);
    public void removeCategoryLabelToolTip(Comparable);
    public void clearCategoryLabelToolTips();
    public void addCategoryLabelURL(Comparable, String);
    public String getCategoryLabelURL(Comparable);
    public void removeCategoryLabelURL(Comparable);
    public void clearCategoryLabelURLs();
    public double getCategoryJava2DCoordinate(CategoryAnchor, int, int, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double getCategoryStart(int, int, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double getCategoryMiddle(int, int, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double getCategoryEnd(int, int, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double getCategoryMiddle(Comparable, java.util.List, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double getCategorySeriesMiddle(Comparable, Comparable, org.jfree.data.category.CategoryDataset, double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double getCategorySeriesMiddle(int, int, int, int, double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected double calculateCategorySize(int, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected double calculateCategoryGapSize(int, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public AxisSpace reserveSpace(java.awt.Graphics2D, org.jfree.chart.plot.Plot, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, AxisSpace);
    public void configure();
    public AxisState draw(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, org.jfree.chart.plot.PlotRenderingInfo);
    protected AxisState drawCategoryLabels(java.awt.Graphics2D, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, AxisState, org.jfree.chart.plot.PlotRenderingInfo);
    public java.util.List refreshTicks(java.awt.Graphics2D, AxisState, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public void drawTickMarks(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, AxisState);
    protected org.jfree.text.TextBlock createLabel(Comparable, float, org.jfree.ui.RectangleEdge, java.awt.Graphics2D);
    protected double calculateTextBlockWidth(org.jfree.text.TextBlock, CategoryLabelPosition, java.awt.Graphics2D);
    protected double calculateTextBlockHeight(org.jfree.text.TextBlock, CategoryLabelPosition, java.awt.Graphics2D);
    public Object clone() throws CloneNotSupportedException;
    public boolean equals(Object);
    public int hashCode();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    private java.util.Map readPaintMap(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    private void writePaintMap(java.util.Map, java.io.ObjectOutputStream) throws java.io.IOException;
    private boolean equalPaintMaps(java.util.Map, java.util.Map);
    protected AxisState drawCategoryLabels(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, AxisState, org.jfree.chart.plot.PlotRenderingInfo);
}
org/jfree/chart/axis/CategoryAxis3D.class
package org.jfree.chart.axis;
public synchronized class CategoryAxis3D extends CategoryAxis implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 4114732251353700972;
    public void CategoryAxis3D();
    public void CategoryAxis3D(String);
    public AxisState draw(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, org.jfree.chart.plot.PlotRenderingInfo);
    public double getCategoryJava2DCoordinate(CategoryAnchor, int, int, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public Object clone() throws CloneNotSupportedException;
}
org/jfree/chart/axis/CategoryLabelPosition.class
package org.jfree.chart.axis;
public synchronized class CategoryLabelPosition implements java.io.Serializable {
    private static final long serialVersionUID = 5168681143844183864;
    private org.jfree.ui.RectangleAnchor categoryAnchor;
    private org.jfree.text.TextBlockAnchor labelAnchor;
    private org.jfree.ui.TextAnchor rotationAnchor;
    private double angle;
    private CategoryLabelWidthType widthType;
    private float widthRatio;
    public void CategoryLabelPosition();
    public void CategoryLabelPosition(org.jfree.ui.RectangleAnchor, org.jfree.text.TextBlockAnchor);
    public void CategoryLabelPosition(org.jfree.ui.RectangleAnchor, org.jfree.text.TextBlockAnchor, CategoryLabelWidthType, float);
    public void CategoryLabelPosition(org.jfree.ui.RectangleAnchor, org.jfree.text.TextBlockAnchor, org.jfree.ui.TextAnchor, double, CategoryLabelWidthType, float);
    public org.jfree.ui.RectangleAnchor getCategoryAnchor();
    public org.jfree.text.TextBlockAnchor getLabelAnchor();
    public org.jfree.ui.TextAnchor getRotationAnchor();
    public double getAngle();
    public CategoryLabelWidthType getWidthType();
    public float getWidthRatio();
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/chart/axis/CategoryLabelPositions.class
package org.jfree.chart.axis;
public synchronized class CategoryLabelPositions implements java.io.Serializable {
    private static final long serialVersionUID = -8999557901920364580;
    public static final CategoryLabelPositions STANDARD;
    public static final CategoryLabelPositions UP_90;
    public static final CategoryLabelPositions DOWN_90;
    public static final CategoryLabelPositions UP_45;
    public static final CategoryLabelPositions DOWN_45;
    private CategoryLabelPosition positionForAxisAtTop;
    private CategoryLabelPosition positionForAxisAtBottom;
    private CategoryLabelPosition positionForAxisAtLeft;
    private CategoryLabelPosition positionForAxisAtRight;
    public static CategoryLabelPositions createUpRotationLabelPositions(double);
    public static CategoryLabelPositions createDownRotationLabelPositions(double);
    public void CategoryLabelPositions();
    public void CategoryLabelPositions(CategoryLabelPosition, CategoryLabelPosition, CategoryLabelPosition, CategoryLabelPosition);
    public CategoryLabelPosition getLabelPosition(org.jfree.ui.RectangleEdge);
    public static CategoryLabelPositions replaceTopPosition(CategoryLabelPositions, CategoryLabelPosition);
    public static CategoryLabelPositions replaceBottomPosition(CategoryLabelPositions, CategoryLabelPosition);
    public static CategoryLabelPositions replaceLeftPosition(CategoryLabelPositions, CategoryLabelPosition);
    public static CategoryLabelPositions replaceRightPosition(CategoryLabelPositions, CategoryLabelPosition);
    public boolean equals(Object);
    public int hashCode();
    static void ();
}
org/jfree/chart/axis/CategoryLabelWidthType.class
package org.jfree.chart.axis;
public final synchronized class CategoryLabelWidthType implements java.io.Serializable {
    private static final long serialVersionUID = -6976024792582949656;
    public static final CategoryLabelWidthType CATEGORY;
    public static final CategoryLabelWidthType RANGE;
    private String name;
    private void CategoryLabelWidthType(String);
    public String toString();
    public boolean equals(Object);
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/chart/axis/CategoryTick.class
package org.jfree.chart.axis;
public synchronized class CategoryTick extends Tick {
    private Comparable category;
    private org.jfree.text.TextBlock label;
    private org.jfree.text.TextBlockAnchor labelAnchor;
    public void CategoryTick(Comparable, org.jfree.text.TextBlock, org.jfree.text.TextBlockAnchor, org.jfree.ui.TextAnchor, double);
    public Comparable getCategory();
    public org.jfree.text.TextBlock getLabel();
    public org.jfree.text.TextBlockAnchor getLabelAnchor();
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/chart/axis/ColorBar.class
package org.jfree.chart.axis;
public synchronized class ColorBar implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = -2101776212647268103;
    public static final int DEFAULT_COLORBAR_THICKNESS = 0;
    public static final double DEFAULT_COLORBAR_THICKNESS_PERCENT = 0.1;
    public static final int DEFAULT_OUTERGAP = 2;
    private ValueAxis axis;
    private int colorBarThickness;
    private double colorBarThicknessPercent;
    private org.jfree.chart.plot.ColorPalette colorPalette;
    private int colorBarLength;
    private int outerGap;
    public void ColorBar(String);
    public void configure(org.jfree.chart.plot.ContourPlot);
    public ValueAxis getAxis();
    public void setAxis(ValueAxis);
    public void autoAdjustRange();
    public double draw(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public void drawColorBar(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public org.jfree.chart.plot.ColorPalette getColorPalette();
    public java.awt.Paint getPaint(double);
    public void setColorPalette(org.jfree.chart.plot.ColorPalette);
    public void setMaximumValue(double);
    public void setMinimumValue(double);
    public AxisSpace reserveSpace(java.awt.Graphics2D, org.jfree.chart.plot.Plot, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, AxisSpace);
    private double calculateBarThickness(java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public Object clone() throws CloneNotSupportedException;
    public boolean equals(Object);
    public int hashCode();
    static void ();
}
org/jfree/chart/axis/CompassFormat.class
package org.jfree.chart.axis;
public synchronized class CompassFormat extends java.text.NumberFormat {
    public final String[] directions;
    public void CompassFormat();
    public void CompassFormat(String, String, String, String);
    public void CompassFormat(String[]);
    public String getDirectionCode(double);
    public StringBuffer format(double, StringBuffer, java.text.FieldPosition);
    public StringBuffer format(long, StringBuffer, java.text.FieldPosition);
    public Number parse(String, java.text.ParsePosition);
}
org/jfree/chart/axis/CyclicNumberAxis$CycleBoundTick.class
package org.jfree.chart.axis;
public synchronized class CyclicNumberAxis$CycleBoundTick extends NumberTick {
    public boolean mapToLastCycle;
    public void CyclicNumberAxis$CycleBoundTick(boolean, Number, String, org.jfree.ui.TextAnchor, org.jfree.ui.TextAnchor, double);
}
org/jfree/chart/axis/CyclicNumberAxis.class
package org.jfree.chart.axis;
public synchronized class CyclicNumberAxis extends NumberAxis {
    static final long serialVersionUID = -7514160997164582554;
    public static java.awt.Stroke DEFAULT_ADVANCE_LINE_STROKE;
    public static final java.awt.Paint DEFAULT_ADVANCE_LINE_PAINT;
    protected double offset;
    protected double period;
    protected boolean boundMappedToLastCycle;
    protected boolean advanceLineVisible;
    protected transient java.awt.Stroke advanceLineStroke;
    protected transient java.awt.Paint advanceLinePaint;
    private transient boolean internalMarkerWhenTicksOverlap;
    private transient Tick internalMarkerCycleBoundTick;
    public void CyclicNumberAxis(double);
    public void CyclicNumberAxis(double, double);
    public void CyclicNumberAxis(double, String);
    public void CyclicNumberAxis(double, double, String);
    public boolean isAdvanceLineVisible();
    public void setAdvanceLineVisible(boolean);
    public java.awt.Paint getAdvanceLinePaint();
    public void setAdvanceLinePaint(java.awt.Paint);
    public java.awt.Stroke getAdvanceLineStroke();
    public void setAdvanceLineStroke(java.awt.Stroke);
    public boolean isBoundMappedToLastCycle();
    public void setBoundMappedToLastCycle(boolean);
    protected void selectHorizontalAutoTickUnit(java.awt.Graphics2D, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void selectVerticalAutoTickUnit(java.awt.Graphics2D, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected float[] calculateAnchorPoint(ValueTick, double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected java.util.List refreshTicksHorizontal(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected java.util.List refreshVerticalTicks(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double java2DToValue(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double valueToJava2D(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public void centerRange(double);
    public void setAutoRangeMinimumSize(double, boolean);
    public void setFixedAutoRange(double);
    public void setRange(org.jfree.data.Range, boolean, boolean);
    public double getCycleBound();
    public double getOffset();
    public void setOffset(double);
    public double getPeriod();
    public void setPeriod(double);
    protected AxisState drawTickMarksAndLabels(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public AxisState draw(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, org.jfree.chart.plot.PlotRenderingInfo);
    public AxisSpace reserveSpace(java.awt.Graphics2D, org.jfree.chart.plot.Plot, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, AxisSpace);
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    public boolean equals(Object);
    static void ();
}
org/jfree/chart/axis/DateAxis$1.class
package org.jfree.chart.axis;
synchronized class DateAxis$1 {
}
org/jfree/chart/axis/DateAxis$DefaultTimeline.class
package org.jfree.chart.axis;
synchronized class DateAxis$DefaultTimeline implements Timeline, java.io.Serializable {
    private void DateAxis$DefaultTimeline();
    public long toTimelineValue(long);
    public long toTimelineValue(java.util.Date);
    public long toMillisecond(long);
    public boolean containsDomainValue(long);
    public boolean containsDomainValue(java.util.Date);
    public boolean containsDomainRange(long, long);
    public boolean containsDomainRange(java.util.Date, java.util.Date);
    public boolean equals(Object);
}
org/jfree/chart/axis/DateAxis.class
package org.jfree.chart.axis;
public synchronized class DateAxis extends ValueAxis implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = -1013460999649007604;
    public static final org.jfree.data.time.DateRange DEFAULT_DATE_RANGE;
    public static final double DEFAULT_AUTO_RANGE_MINIMUM_SIZE_IN_MILLISECONDS = 2.0;
    public static final DateTickUnit DEFAULT_DATE_TICK_UNIT;
    public static final java.util.Date DEFAULT_ANCHOR_DATE;
    private DateTickUnit tickUnit;
    private java.text.DateFormat dateFormatOverride;
    private DateTickMarkPosition tickMarkPosition;
    private static final Timeline DEFAULT_TIMELINE;
    private java.util.TimeZone timeZone;
    private java.util.Locale locale;
    private Timeline timeline;
    public void DateAxis();
    public void DateAxis(String);
    public void DateAxis(String, java.util.TimeZone);
    public void DateAxis(String, java.util.TimeZone, java.util.Locale);
    public java.util.TimeZone getTimeZone();
    public void setTimeZone(java.util.TimeZone);
    public java.util.Locale getLocale();
    public void setLocale(java.util.Locale);
    public Timeline getTimeline();
    public void setTimeline(Timeline);
    public DateTickUnit getTickUnit();
    public void setTickUnit(DateTickUnit);
    public void setTickUnit(DateTickUnit, boolean, boolean);
    public java.text.DateFormat getDateFormatOverride();
    public void setDateFormatOverride(java.text.DateFormat);
    public void setRange(org.jfree.data.Range);
    public void setRange(org.jfree.data.Range, boolean, boolean);
    public void setRange(java.util.Date, java.util.Date);
    public void setRange(double, double);
    public java.util.Date getMinimumDate();
    public void setMinimumDate(java.util.Date);
    public java.util.Date getMaximumDate();
    public void setMaximumDate(java.util.Date);
    public DateTickMarkPosition getTickMarkPosition();
    public void setTickMarkPosition(DateTickMarkPosition);
    public void configure();
    public boolean isHiddenValue(long);
    public double valueToJava2D(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double dateToJava2D(java.util.Date, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double java2DToValue(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public java.util.Date calculateLowestVisibleTickValue(DateTickUnit);
    public java.util.Date calculateHighestVisibleTickValue(DateTickUnit);
    protected java.util.Date previousStandardDate(java.util.Date, DateTickUnit);
    private java.util.Date calculateDateForPosition(org.jfree.data.time.RegularTimePeriod, DateTickMarkPosition);
    protected java.util.Date nextStandardDate(java.util.Date, DateTickUnit);
    public static TickUnitSource createStandardDateTickUnits();
    public static TickUnitSource createStandardDateTickUnits(java.util.TimeZone, java.util.Locale);
    protected void autoAdjustRange();
    protected void selectAutoTickUnit(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void selectHorizontalAutoTickUnit(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void selectVerticalAutoTickUnit(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    private double estimateMaximumTickLabelWidth(java.awt.Graphics2D, DateTickUnit);
    private double estimateMaximumTickLabelHeight(java.awt.Graphics2D, DateTickUnit);
    public java.util.List refreshTicks(java.awt.Graphics2D, AxisState, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    private java.util.Date correctTickDateForPosition(java.util.Date, DateTickUnit, DateTickMarkPosition);
    protected java.util.List refreshTicksHorizontal(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected java.util.List refreshTicksVertical(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public AxisState draw(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, org.jfree.chart.plot.PlotRenderingInfo);
    public void zoomRange(double, double);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    public static TickUnitSource createStandardDateTickUnits(java.util.TimeZone);
    static void ();
}
org/jfree/chart/axis/DateTick.class
package org.jfree.chart.axis;
public synchronized class DateTick extends ValueTick {
    private java.util.Date date;
    public void DateTick(java.util.Date, String, org.jfree.ui.TextAnchor, org.jfree.ui.TextAnchor, double);
    public void DateTick(TickType, java.util.Date, String, org.jfree.ui.TextAnchor, org.jfree.ui.TextAnchor, double);
    public java.util.Date getDate();
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/chart/axis/DateTickMarkPosition.class
package org.jfree.chart.axis;
public final synchronized class DateTickMarkPosition implements java.io.Serializable {
    private static final long serialVersionUID = 2540750672764537240;
    public static final DateTickMarkPosition START;
    public static final DateTickMarkPosition MIDDLE;
    public static final DateTickMarkPosition END;
    private String name;
    private void DateTickMarkPosition(String);
    public String toString();
    public boolean equals(Object);
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/chart/axis/DateTickUnit.class
package org.jfree.chart.axis;
public synchronized class DateTickUnit extends TickUnit implements java.io.Serializable {
    private static final long serialVersionUID = -7289292157229621901;
    private DateTickUnitType unitType;
    private int count;
    private DateTickUnitType rollUnitType;
    private int rollCount;
    private java.text.DateFormat formatter;
    public static final int YEAR = 0;
    public static final int MONTH = 1;
    public static final int DAY = 2;
    public static final int HOUR = 3;
    public static final int MINUTE = 4;
    public static final int SECOND = 5;
    public static final int MILLISECOND = 6;
    private int unit;
    private int rollUnit;
    public void DateTickUnit(DateTickUnitType, int);
    public void DateTickUnit(DateTickUnitType, int, java.text.DateFormat);
    public void DateTickUnit(DateTickUnitType, int, DateTickUnitType, int, java.text.DateFormat);
    public DateTickUnitType getUnitType();
    public int getMultiple();
    public DateTickUnitType getRollUnitType();
    public int getRollMultiple();
    public String valueToString(double);
    public String dateToString(java.util.Date);
    public java.util.Date addToDate(java.util.Date, java.util.TimeZone);
    public java.util.Date rollDate(java.util.Date);
    public java.util.Date rollDate(java.util.Date, java.util.TimeZone);
    public int getCalendarField();
    private static long getMillisecondCount(DateTickUnitType, int);
    private static DateTickUnitType intToUnitType(int);
    private static int unitTypeToInt(DateTickUnitType);
    private static java.text.DateFormat notNull(java.text.DateFormat);
    public boolean equals(Object);
    public int hashCode();
    public String toString();
    public void DateTickUnit(int, int, java.text.DateFormat);
    public void DateTickUnit(int, int);
    public void DateTickUnit(int, int, int, int, java.text.DateFormat);
    public int getUnit();
    public int getCount();
    public int getRollUnit();
    public int getRollCount();
    public java.util.Date addToDate(java.util.Date);
}
org/jfree/chart/axis/DateTickUnitType.class
package org.jfree.chart.axis;
public synchronized class DateTickUnitType implements java.io.Serializable {
    public static final DateTickUnitType YEAR;
    public static final DateTickUnitType MONTH;
    public static final DateTickUnitType DAY;
    public static final DateTickUnitType HOUR;
    public static final DateTickUnitType MINUTE;
    public static final DateTickUnitType SECOND;
    public static final DateTickUnitType MILLISECOND;
    private String name;
    private int calendarField;
    private void DateTickUnitType(String, int);
    public int getCalendarField();
    public String toString();
    public boolean equals(Object);
    private Object readResolve() throws java.io.ObjectStreamException;
    static void ();
}
org/jfree/chart/axis/ExtendedCategoryAxis.class
package org.jfree.chart.axis;
public synchronized class ExtendedCategoryAxis extends CategoryAxis {
    static final long serialVersionUID = -3004429093959826567;
    private java.util.Map sublabels;
    private java.awt.Font sublabelFont;
    private transient java.awt.Paint sublabelPaint;
    public void ExtendedCategoryAxis(String);
    public java.awt.Font getSubLabelFont();
    public void setSubLabelFont(java.awt.Font);
    public java.awt.Paint getSubLabelPaint();
    public void setSubLabelPaint(java.awt.Paint);
    public void addSubLabel(Comparable, String);
    protected org.jfree.text.TextBlock createLabel(Comparable, float, org.jfree.ui.RectangleEdge, java.awt.Graphics2D);
    public boolean equals(Object);
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/axis/LogAxis.class
package org.jfree.chart.axis;
public synchronized class LogAxis extends ValueAxis {
    private double base;
    private double baseLog;
    private String baseSymbol;
    private java.text.Format baseFormatter;
    private double smallestValue;
    private NumberTickUnit tickUnit;
    private java.text.NumberFormat numberFormatOverride;
    public void LogAxis();
    public void LogAxis(String);
    public double getBase();
    public void setBase(double);
    public String getBaseSymbol();
    public void setBaseSymbol(String);
    public java.text.Format getBaseFormatter();
    public void setBaseFormatter(java.text.Format);
    public double getSmallestValue();
    public void setSmallestValue(double);
    public NumberTickUnit getTickUnit();
    public void setTickUnit(NumberTickUnit);
    public void setTickUnit(NumberTickUnit, boolean, boolean);
    public java.text.NumberFormat getNumberFormatOverride();
    public void setNumberFormatOverride(java.text.NumberFormat);
    public double calculateLog(double);
    public double calculateValue(double);
    private double calculateValueNoINF(double);
    public double java2DToValue(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double valueToJava2D(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public void configure();
    protected void autoAdjustRange();
    public AxisState draw(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, org.jfree.chart.plot.PlotRenderingInfo);
    public java.util.List refreshTicks(java.awt.Graphics2D, AxisState, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected java.util.List refreshTicksHorizontal(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected java.util.List refreshTicksVertical(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void selectAutoTickUnit(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void selectHorizontalAutoTickUnit(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double exponentLengthToJava2D(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void selectVerticalAutoTickUnit(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected java.text.AttributedString createTickLabel(double);
    protected double estimateMaximumTickLabelHeight(java.awt.Graphics2D);
    protected double estimateMaximumTickLabelWidth(java.awt.Graphics2D, TickUnit);
    public void zoomRange(double, double);
    public void pan(double);
    public void resizeRange(double);
    public void resizeRange(double, double);
    public void resizeRange2(double, double);
    public boolean equals(Object);
    public int hashCode();
    public static TickUnitSource createLogTickUnits(java.util.Locale);
}
org/jfree/chart/axis/LogTick.class
package org.jfree.chart.axis;
public synchronized class LogTick extends ValueTick {
    java.text.AttributedString attributedLabel;
    public void LogTick(TickType, double, java.text.AttributedString, org.jfree.ui.TextAnchor);
    public java.text.AttributedString getAttributedLabel();
}
org/jfree/chart/axis/LogarithmicAxis.class
package org.jfree.chart.axis;
public synchronized class LogarithmicAxis extends NumberAxis {
    private static final long serialVersionUID = 2502918599004103054;
    public static final double LOG10_VALUE;
    public static final double SMALL_LOG_VALUE = 1.0E-100;
    protected boolean allowNegativesFlag;
    protected boolean strictValuesFlag;
    protected final java.text.NumberFormat numberFormatterObj;
    protected boolean expTickLabelsFlag;
    protected boolean log10TickLabelsFlag;
    protected boolean autoRangeNextLogFlag;
    protected boolean smallLogFlag;
    public void LogarithmicAxis(String);
    public void setAllowNegativesFlag(boolean);
    public boolean getAllowNegativesFlag();
    public void setStrictValuesFlag(boolean);
    public boolean getStrictValuesFlag();
    public void setExpTickLabelsFlag(boolean);
    public boolean getExpTickLabelsFlag();
    public void setLog10TickLabelsFlag(boolean);
    public boolean getLog10TickLabelsFlag();
    public void setAutoRangeNextLogFlag(boolean);
    public boolean getAutoRangeNextLogFlag();
    public void setRange(org.jfree.data.Range);
    protected void setupSmallLogFlag();
    protected void setupNumberFmtObj();
    protected double switchedLog10(double);
    public double switchedPow10(double);
    public double adjustedLog10(double);
    public double adjustedPow10(double);
    protected double computeLogFloor(double);
    protected double computeLogCeil(double);
    public void autoAdjustRange();
    public double valueToJava2D(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double java2DToValue(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public void zoomRange(double, double);
    protected java.util.List refreshTicksHorizontal(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected java.util.List refreshTicksVertical(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected String makeTickLabel(double, boolean);
    protected String makeTickLabel(double);
    static void ();
}
org/jfree/chart/axis/MarkerAxisBand.class
package org.jfree.chart.axis;
public synchronized class MarkerAxisBand implements java.io.Serializable {
    private static final long serialVersionUID = -1729482413886398919;
    private NumberAxis axis;
    private double topOuterGap;
    private double topInnerGap;
    private double bottomOuterGap;
    private double bottomInnerGap;
    private java.awt.Font font;
    private java.util.List markers;
    public void MarkerAxisBand(NumberAxis, double, double, double, double, java.awt.Font);
    public void addMarker(org.jfree.chart.plot.IntervalMarker);
    public double getHeight(java.awt.Graphics2D);
    private void drawStringInRect(java.awt.Graphics2D, java.awt.geom.Rectangle2D, java.awt.Font, String);
    public void draw(java.awt.Graphics2D, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, double, double);
    public boolean equals(Object);
    public int hashCode();
}
org/jfree/chart/axis/ModuloAxis.class
package org.jfree.chart.axis;
public synchronized class ModuloAxis extends NumberAxis {
    private org.jfree.data.Range fixedRange;
    private double displayStart;
    private double displayEnd;
    public void ModuloAxis(String, org.jfree.data.Range);
    public double getDisplayStart();
    public double getDisplayEnd();
    public void setDisplayRange(double, double);
    protected void autoAdjustRange();
    public double valueToJava2D(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    private double trans(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    private double transStart(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, double, double);
    private double transEnd(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, double, double);
    private double mapValueToFixedRange(double);
    public double java2DToValue(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    private double getDisplayLength();
    private double getDisplayCentralValue();
    public void resizeRange(double);
    public void resizeRange(double, double);
    public double lengthToJava2D(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public boolean equals(Object);
}
org/jfree/chart/axis/MonthDateFormat.class
package org.jfree.chart.axis;
public synchronized class MonthDateFormat extends java.text.DateFormat {
    private String[] months;
    private boolean[] showYear;
    private java.text.DateFormat yearFormatter;
    public void MonthDateFormat();
    public void MonthDateFormat(java.util.TimeZone);
    public void MonthDateFormat(java.util.Locale);
    public void MonthDateFormat(java.util.TimeZone, int);
    public void MonthDateFormat(java.util.Locale, int);
    public void MonthDateFormat(java.util.TimeZone, java.util.Locale, int, boolean, boolean);
    public void MonthDateFormat(java.util.TimeZone, java.util.Locale, int, boolean[], java.text.DateFormat);
    public StringBuffer format(java.util.Date, StringBuffer, java.text.FieldPosition);
    public java.util.Date parse(String, java.text.ParsePosition);
    public boolean equals(Object);
}
org/jfree/chart/axis/NumberAxis.class
package org.jfree.chart.axis;
public synchronized class NumberAxis extends ValueAxis implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 2805933088476185789;
    public static final boolean DEFAULT_AUTO_RANGE_INCLUDES_ZERO = 1;
    public static final boolean DEFAULT_AUTO_RANGE_STICKY_ZERO = 1;
    public static final NumberTickUnit DEFAULT_TICK_UNIT;
    public static final boolean DEFAULT_VERTICAL_TICK_LABELS = 0;
    private org.jfree.data.RangeType rangeType;
    private boolean autoRangeIncludesZero;
    private boolean autoRangeStickyZero;
    private NumberTickUnit tickUnit;
    private java.text.NumberFormat numberFormatOverride;
    private MarkerAxisBand markerBand;
    public void NumberAxis();
    public void NumberAxis(String);
    public org.jfree.data.RangeType getRangeType();
    public void setRangeType(org.jfree.data.RangeType);
    public boolean getAutoRangeIncludesZero();
    public void setAutoRangeIncludesZero(boolean);
    public boolean getAutoRangeStickyZero();
    public void setAutoRangeStickyZero(boolean);
    public NumberTickUnit getTickUnit();
    public void setTickUnit(NumberTickUnit);
    public void setTickUnit(NumberTickUnit, boolean, boolean);
    public java.text.NumberFormat getNumberFormatOverride();
    public void setNumberFormatOverride(java.text.NumberFormat);
    public MarkerAxisBand getMarkerBand();
    public void setMarkerBand(MarkerAxisBand);
    public void configure();
    protected void autoAdjustRange();
    public double valueToJava2D(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double java2DToValue(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected double calculateLowestVisibleTickValue();
    protected double calculateHighestVisibleTickValue();
    protected int calculateVisibleTickCount();
    public AxisState draw(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, org.jfree.chart.plot.PlotRenderingInfo);
    public static TickUnitSource createStandardTickUnits();
    public static TickUnitSource createIntegerTickUnits();
    public static TickUnitSource createStandardTickUnits(java.util.Locale);
    public static TickUnitSource createIntegerTickUnits(java.util.Locale);
    protected double estimateMaximumTickLabelHeight(java.awt.Graphics2D);
    protected double estimateMaximumTickLabelWidth(java.awt.Graphics2D, TickUnit);
    protected void selectAutoTickUnit(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void selectHorizontalAutoTickUnit(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void selectVerticalAutoTickUnit(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public java.util.List refreshTicks(java.awt.Graphics2D, AxisState, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected java.util.List refreshTicksHorizontal(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected java.util.List refreshTicksVertical(java.awt.Graphics2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public Object clone() throws CloneNotSupportedException;
    public boolean equals(Object);
    public int hashCode();
    static void ();
}
org/jfree/chart/axis/NumberAxis3D.class
package org.jfree.chart.axis;
public synchronized class NumberAxis3D extends NumberAxis implements java.io.Serializable {
    private static final long serialVersionUID = -1790205852569123512;
    public void NumberAxis3D();
    public void NumberAxis3D(String);
    public AxisState draw(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, org.jfree.chart.plot.PlotRenderingInfo);
}
org/jfree/chart/axis/NumberTick.class
package org.jfree.chart.axis;
public synchronized class NumberTick extends ValueTick {
    private Number number;
    public void NumberTick(Number, String, org.jfree.ui.TextAnchor, org.jfree.ui.TextAnchor, double);
    public void NumberTick(TickType, double, String, org.jfree.ui.TextAnchor, org.jfree.ui.TextAnchor, double);
    public Number getNumber();
}
org/jfree/chart/axis/NumberTickUnit.class
package org.jfree.chart.axis;
public synchronized class NumberTickUnit extends TickUnit implements java.io.Serializable {
    private static final long serialVersionUID = 3849459506627654442;
    private java.text.NumberFormat formatter;
    public void NumberTickUnit(double);
    public void NumberTickUnit(double, java.text.NumberFormat);
    public void NumberTickUnit(double, java.text.NumberFormat, int);
    public String valueToString(double);
    public boolean equals(Object);
    public String toString();
    public int hashCode();
}
org/jfree/chart/axis/NumberTickUnitSource.class
package org.jfree.chart.axis;
public synchronized class NumberTickUnitSource implements TickUnitSource, java.io.Serializable {
    private boolean integers;
    private int power;
    private int factor;
    private java.text.NumberFormat formatter;
    private java.text.DecimalFormat dfNeg4;
    private java.text.DecimalFormat dfNeg3;
    private java.text.DecimalFormat dfNeg2;
    private java.text.DecimalFormat dfNeg1;
    private java.text.DecimalFormat df0;
    private java.text.DecimalFormat df;
    public void NumberTickUnitSource();
    public void NumberTickUnitSource(boolean);
    public void NumberTickUnitSource(boolean, java.text.NumberFormat);
    public TickUnit getLargerTickUnit(TickUnit);
    public TickUnit getCeilingTickUnit(TickUnit);
    public TickUnit getCeilingTickUnit(double);
    private boolean next();
    private boolean previous();
    private double getTickSize();
    private java.text.NumberFormat getTickLabelFormat();
    private int getMinorTickCount();
    public boolean equals(Object);
}
org/jfree/chart/axis/PeriodAxis.class
package org.jfree.chart.axis;
public synchronized class PeriodAxis extends ValueAxis implements Cloneable, org.jfree.util.PublicCloneable, java.io.Serializable {
    private static final long serialVersionUID = 8353295532075872069;
    private org.jfree.data.time.RegularTimePeriod first;
    private org.jfree.data.time.RegularTimePeriod last;
    private java.util.TimeZone timeZone;
    private java.util.Locale locale;
    private java.util.Calendar calendar;
    private Class autoRangeTimePeriodClass;
    private Class majorTickTimePeriodClass;
    private boolean minorTickMarksVisible;
    private Class minorTickTimePeriodClass;
    private float minorTickMarkInsideLength;
    private float minorTickMarkOutsideLength;
    private transient java.awt.Stroke minorTickMarkStroke;
    private transient java.awt.Paint minorTickMarkPaint;
    private PeriodAxisLabelInfo[] labelInfo;
    public void PeriodAxis(String);
    public void PeriodAxis(String, org.jfree.data.time.RegularTimePeriod, org.jfree.data.time.RegularTimePeriod);
    public void PeriodAxis(String, org.jfree.data.time.RegularTimePeriod, org.jfree.data.time.RegularTimePeriod, java.util.TimeZone);
    public void PeriodAxis(String, org.jfree.data.time.RegularTimePeriod, org.jfree.data.time.RegularTimePeriod, java.util.TimeZone, java.util.Locale);
    public org.jfree.data.time.RegularTimePeriod getFirst();
    public void setFirst(org.jfree.data.time.RegularTimePeriod);
    public org.jfree.data.time.RegularTimePeriod getLast();
    public void setLast(org.jfree.data.time.RegularTimePeriod);
    public java.util.TimeZone getTimeZone();
    public void setTimeZone(java.util.TimeZone);
    public java.util.Locale getLocale();
    public Class getAutoRangeTimePeriodClass();
    public void setAutoRangeTimePeriodClass(Class);
    public Class getMajorTickTimePeriodClass();
    public void setMajorTickTimePeriodClass(Class);
    public boolean isMinorTickMarksVisible();
    public void setMinorTickMarksVisible(boolean);
    public Class getMinorTickTimePeriodClass();
    public void setMinorTickTimePeriodClass(Class);
    public java.awt.Stroke getMinorTickMarkStroke();
    public void setMinorTickMarkStroke(java.awt.Stroke);
    public java.awt.Paint getMinorTickMarkPaint();
    public void setMinorTickMarkPaint(java.awt.Paint);
    public float getMinorTickMarkInsideLength();
    public void setMinorTickMarkInsideLength(float);
    public float getMinorTickMarkOutsideLength();
    public void setMinorTickMarkOutsideLength(float);
    public PeriodAxisLabelInfo[] getLabelInfo();
    public void setLabelInfo(PeriodAxisLabelInfo[]);
    public void setRange(org.jfree.data.Range, boolean, boolean);
    public void configure();
    public AxisSpace reserveSpace(java.awt.Graphics2D, org.jfree.chart.plot.Plot, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, AxisSpace);
    public AxisState draw(java.awt.Graphics2D, double, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge, org.jfree.chart.plot.PlotRenderingInfo);
    protected void drawTickMarks(java.awt.Graphics2D, AxisState, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void drawTickMarksHorizontal(java.awt.Graphics2D, AxisState, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void drawTickMarksVertical(java.awt.Graphics2D, AxisState, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected AxisState drawTickLabels(int, java.awt.Graphics2D, AxisState, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public java.util.List refreshTicks(java.awt.Graphics2D, AxisState, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double valueToJava2D(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    public double java2DToValue(double, java.awt.geom.Rectangle2D, org.jfree.ui.RectangleEdge);
    protected void autoAdjustRange();
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private org.jfree.data.time.RegularTimePeriod createInstance(Class, java.util.Date, java.util.TimeZone, java.util.Locale);
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
}
org/jfree/chart/axis/PeriodAxisLabelInfo.class
package org.jfree.chart.axis;
public synchronized class PeriodAxisLabelInfo implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 5710451740920277357;
    public static final org.jfree.ui.RectangleInsets DEFAULT_INSETS;
    public static final java.awt.Font DEFAULT_FONT;
    public static final java.awt.Paint DEFAULT_LABEL_PAINT;
    public static final java.awt.Stroke DEFAULT_DIVIDER_STROKE;
    public static final java.awt.Paint DEFAULT_DIVIDER_PAINT;
    private Class periodClass;
    private org.jfree.ui.RectangleInsets padding;
    private java.text.DateFormat dateFormat;
    private java.awt.Font labelFont;
    private transient java.awt.Paint labelPaint;
    private boolean drawDividers;
    private transient java.awt.Stroke dividerStroke;
    private transient java.awt.Paint dividerPaint;
    public void PeriodAxisLabelInfo(Class, java.text.DateFormat);
    public void PeriodAxisLabelInfo(Class, java.text.DateFormat, org.jfree.ui.RectangleInsets, java.awt.Font, java.awt.Paint, boolean, java.awt.Stroke, java.awt.Paint);
    public Class getPeriodClass();
    public java.text.DateFormat getDateFormat();
    public org.jfree.ui.RectangleInsets getPadding();
    public java.awt.Font getLabelFont();
    public java.awt.Paint getLabelPaint();
    public boolean getDrawDividers();
    public java.awt.Stroke getDividerStroke();
    public java.awt.Paint getDividerPaint();
    public org.jfree.data.time.RegularTimePeriod createInstance(java.util.Date, java.util.TimeZone);
    public org.jfree.data.time.RegularTimePeriod createInstance(java.util.Date, java.util.TimeZone, java.util.Locale);
    public boolean equals(Object);
    public int hashCode();
    public Object clone() throws CloneNotSupportedException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    static void ();
}
org/jfree/chart/axis/QuarterDateFormat.class
package org.jfree.chart.axis;
public synchronized class QuarterDateFormat extends java.text.DateFormat implements Cloneable, java.io.Serializable {
    private static final long serialVersionUID = -6738465248529797176;
    public static final String[] REGULAR_QUARTERS;
    public static final String[] ROMAN_QUARTERS;
    public static final String[] GREEK_QUARTERS;
    private String[] quarters;
    private boolean quarterFirst;
    public void QuarterDateFormat();
    public void QuarterDateFormat(java.util.TimeZone);
    public void QuarterDateFormat(java.util.TimeZone, String[]);
    public void QuarterDateFormat(java.util.TimeZone, String[], boolean);
    public StringBuffer format(java.util.Date, StringBuffer, java.text.FieldPosition);
    public java.util.Date parse(String, java.text.ParsePosition);
    public boolean equals(Object);
    static void ();
}
org/jfree/chart/axis/SegmentedTimeline$BaseTimelineSegmentRange.class
package org.jfree.chart.axis;
public synchronized class SegmentedTimeline$BaseTimelineSegmentRange extends SegmentedTimeline$SegmentRange {
    public void SegmentedTimeline$BaseTimelineSegmentRange(SegmentedTimeline, long, long);
}
org/jfree/chart/axis/SegmentedTimeline$Segment.class
package org.jfree.chart.axis;
public synchronized class SegmentedTimeline$Segment implements Comparable, Cloneable, java.io.Serializable {
    protected long segmentNumber;
    protected long segmentStart;
    protected long segmentEnd;
    protected long millisecond;
    protected void SegmentedTimeline$Segment(SegmentedTimeline);
    protected void SegmentedTimeline$Segment(SegmentedTimeline, long);
    public long calculateSegmentNumber(long);
    public long getSegmentNumber();
    public long getSegmentCount();
    public long getSegmentStart();
    public long getSegmentEnd();
    public long getMillisecond();
    public java.util.Date getDate();
    public boolean contains(long);
    public boolean contains(long, long);
    public boolean contains(SegmentedTimeline$Segment);
    public boolean contained(long, long);
    public SegmentedTimeline$Segment intersect(long, long);
    public boolean before(SegmentedTimeline$Segment);
    public boolean after(SegmentedTimeline$Segment);
    public boolean equals(Object);
    public SegmentedTimeline$Segment copy();
    public int compareTo(Object);
    public boolean inIncludeSegments();
    public boolean inExcludeSegments();
    private long getSegmentNumberRelativeToGroup();
    public boolean inExceptionSegments();
    public void inc(long);
    public void inc();
    public void dec(long);
    public void dec();
    public void moveIndexToStart();
    public void moveIndexToEnd();
}
org/jfree/chart/axis/SegmentedTimeline$SegmentRange.class
package org.jfree.chart.axis;

Scenario We are a large multinational organisation. We process data, analyse them, and present them graphically. We make most of our software available as open source1 . We make most of our media...

Answer To: Scenario We are a large multinational organisation. We process data, analyse them, and present them...

Answer To This Question Is Available To Download

Related Questions & Answers

Submit New Assignment