Update fixed build script to shadow csv dependency in dev jar as well

.github/scripts/test-no-crash-reports.sh

@@ -1,9 +0,0 @@
-directory="run/crash-reports"
-if [ -d $directory ]; then
-  echo "Crash reports detected:"
-  cat $directory/*
-  exit 1
-else
-  echo "No crash reports detected"
-  exit 0
-fi

.github/workflows/pull-request.yml

@@ -1,16 +1,14 @@
 # This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
 # For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
 
-name: Build and test
+name: Build pull request
 
 on:
   pull_request:
     branches: [ master, main ]
-  push:
-    branches: [ master, main ]
 
 jobs:
-  build-and-test:
+  build:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
@@ -32,14 +30,3 @@ jobs:
     
     - name: Build the mod
       run: ./gradlew build
-
-    - name: Run server for 1 minute
-      run: |
-        mkdir run
-        echo "eula=true" > run/eula.txt  
-        timeout 10 ./gradlew runServer || true
-
-    - name: Test no crashes happend
-      run: |
-        chmod +x .github/scripts/test-no-crash-reports.sh
-        .github/scripts/test-no-crash-reports.sh

.github/workflows/release-tags.yml

@@ -1,51 +0,0 @@
-# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
-# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
-
-name: Release tagged build
-
-on:
-  push:
-    tags:
-      - '*'
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-
-      - name: Set release version
-        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-
-      - name: Set up JDK 8
-        uses: actions/setup-java@v2
-        with:
-          java-version: '8'
-          distribution: 'adopt'
-          cache: gradle
-
-      - name: Grant execute permission for gradlew
-        run: chmod +x gradlew
-
-      - name: Setup the workspace
-        run: ./gradlew setupCIWorkspace
-
-      - name: Build the mod
-        run: ./gradlew build
-
-      - name: Release under current tag
-        uses: "marvinpinto/action-automatic-releases@latest"
-        with:
-          repo_token: "${{ secrets.GITHUB_TOKEN }}"
-          automatic_release_tag: "${{ env.RELEASE_VERSION }}"
-          prerelease: false
-          title: "${{ env.RELEASE_VERSION }}"
-          files: build/libs/*.jar
-
-      - name: Publish to Maven
-        run: ./gradlew publish
-        env:
-          MAVEN_USER: ${{ secrets.MAVEN_USER }}
-          MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}

.github/workflows/release.yml

@@ -0,0 +1,41 @@
+# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
+
+name: Build and release main branch
+
+on:
+  push:
+    branches: [ master, main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+      with: 
+        fetch-depth: 0
+    
+    - name: Set up JDK 8
+      uses: actions/setup-java@v2
+      with:
+        java-version: '8'
+        distribution: 'adopt'
+        cache: gradle
+        
+    - name: Grant execute permission for gradlew
+      run: chmod +x gradlew
+
+    - name: Setup the workspace
+      run: ./gradlew setupCIWorkspace
+    
+    - name: Build the mod
+      run: ./gradlew build
+        
+    - uses: "marvinpinto/action-automatic-releases@latest"
+      with:
+        repo_token: "${{ secrets.GITHUB_TOKEN }}"
+        automatic_release_tag: "latest"
+        prerelease: true
+        title: "Latest Development Build"
+        files: build/libs/*.jar
+            

.gitignore

@@ -26,4 +26,3 @@ whitelist.json
 *.ipr
 *.iws
 src/main/resources/mixins.*.json
-*.bat

CODEOWNERS

@@ -1,3 +0,0 @@
-# Any Github changes require admin approval
-/.github/** @GTNewHorizons/admin
-

COPYING

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  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
+them 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 prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  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.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey 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;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If 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 convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU 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 that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  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.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+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.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     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
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 3 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, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program 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, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU 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.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.1996

COPYING.LESSER

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  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 that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU 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 as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

LICENSE.txt

@@ -1,165 +1,60 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
+GTNH Modifications:
 
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
+Copyright (c) 2019 mitchej123 
+
+GNU LESSER GENERAL PUBLIC LICENSE - See COPYING & COPYING.LESSER
 
 
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
+-----------------------------------------------------------------------------
 
-  0. Additional Definitions.
+Parts inspired/borrowed/backported from JEI under the MIT License: 
 
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
+ https://github.com/mezz/JustEnoughItems/tree/1.12
+  
+ The MIT License (MIT)
 
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
+ Copyright (c) 2014-2015 mezz
 
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
 
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
+-----------------------------------------------------------------------------
 
-  1. Exception to Section 3 of the GNU GPL.
+Base NEI License:
 
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
+ The MIT License (MIT)
 
-  2. Conveying Modified Versions.
+ Copyright (c) 2014 ChickenBones
 
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  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 that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU 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 as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -2,9 +2,11 @@
 
 A continuation of NotEnoughItems for 1.7.10 by the developers of Gregtech: New Horizons modpack, with features either inspired and/or backported from JustEnoughItems
 
-We've tested this against all of the mods included in GTNH, as well as a limited set of other mods (like Reika's mods). Every effort has been made to maintain backwards compatibility, however the focus is on the mods contained in the GTNH modpack.
+ 
 
-If you have issues with NEI outside of the GTNH modpack you may report them in the [GTNH NEI GitHub](https://github.com/GTNewHorizons/NotEnoughItems).
+We've tested this against all of the mods included in GTNH, as well as a limited set of other mods (like Reika's mods).  Every effort has been made to maintain backwards compatibility, however the focus is on the mods contained in the GTNH modpack.
+
+ 
 
 ## New Features:
 
@@ -24,15 +26,6 @@ If you have issues with NEI outside of the GTNH modpack you may report them in t
 
 ## Other items of note:
 
+* Licensed under LGPL - Use this however you want, but please give back any modifications
 * Remove TMI style
 * Removed inventory Load/Save state
-
-## License
-
-GTNH Modifications Copyright (c) 2019-2022 mitchej123 and the GTNH Team
-
-Licensed under LGPL-3.0 or later - use this however you want, but please give back any modifications
-
-Parts inspired/borrowed/backported from [JEI](https://github.com/mezz/JustEnoughItems/tree/1.12) under the MIT License.
-
-Originial code Copyright (c) 2014-2015 mezz and was licensed under the MIT License.

build.gradle

@@ -1,14 +1,11 @@
-//version: 1644510936
+//version: 1fc864ac9e3945981c864c3492bdd57330f9fe70
 /*
 DO NOT CHANGE THIS FILE!
 
 Also, you may replace this file at any time if there is an update available.
-Please check https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/main/build.gradle for updates.
-*/
+Please check https://github.com/SinTh0r4s/ExampleMod1.7.10/blob/main/build.gradle for updates.
+ */
 
-import org.gradle.internal.logging.text.StyledTextOutput 
-import org.gradle.internal.logging.text.StyledTextOutputFactory
-import org.gradle.internal.logging.text.StyledTextOutput.Style
 
 import com.github.jengelman.gradle.plugins.shadow.tasks.ConfigureShadowRelocation
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
@@ -18,46 +15,35 @@ import java.util.concurrent.TimeUnit
 buildscript {
     repositories {
         maven {
-            name 'forge'
-            url 'https://maven.minecraftforge.net'
+            name = "jitpack"
+            url = "https://jitpack.io"
         }
         maven {
-            name 'sonatype'
-            url 'https://oss.sonatype.org/content/repositories/snapshots/'
+            name = "forge"
+            url = "https://maven.minecraftforge.net"
         }
         maven {
-            name 'Scala CI dependencies'
-            url 'https://repo1.maven.org/maven2/'
+            name = "sonatype"
+            url = "https://oss.sonatype.org/content/repositories/snapshots/"
         }
         maven {
-            name 'jitpack'
-            url 'https://jitpack.io'
+            name = "Scala CI dependencies"
+            url = "https://repo1.maven.org/maven2/"
         }
     }
     dependencies {
-        classpath 'com.github.GTNewHorizons:ForgeGradle:1.2.7'
+        classpath 'com.github.GTNewHorizons:ForgeGradle:1.2.4'
     }
 }
 
 plugins {
-    id 'java-library'
     id 'idea'
-    id 'eclipse'
     id 'scala'
-    id 'maven-publish'
-    id('org.jetbrains.kotlin.jvm') version ('1.6.10') apply false
-    id('org.ajoberstar.grgit') version('4.1.1')
-    id('com.github.johnrengelman.shadow') version('4.0.4')
-    id('com.palantir.git-version') version('0.13.0') apply false
-    id('de.undercouch.download') version('5.0.1')
+    id("org.ajoberstar.grgit") version("3.1.1")
+    id("com.github.johnrengelman.shadow") version("4.0.4")
+    id("com.palantir.git-version") version("0.12.3")
 }
 
-if (project.file('.git/HEAD').isFile()) {
-    apply plugin: 'com.palantir.git-version'
-}
-
-def out = services.get(StyledTextOutputFactory).create("an-output")
-
 apply plugin: 'forge'
 
 def projectJavaVersion = JavaLanguageVersion.of(8)
@@ -76,10 +62,6 @@ idea {
     }
 }
 
-if(JavaVersion.current() != JavaVersion.VERSION_1_8) {
-    throw new GradleException("This project requires Java 8, but it's running on " + JavaVersion.current())
-}
-
 checkPropertyExists("modName")
 checkPropertyExists("modId")
 checkPropertyExists("modGroup")
@@ -101,31 +83,33 @@ checkPropertyExists("containsMixinsAndOrCoreModOnly")
 checkPropertyExists("usesShadowedDependencies")
 checkPropertyExists("developmentEnvironmentUserName")
 
-boolean noPublishedSources = project.findProperty("noPublishedSources") ? project.noPublishedSources.toBoolean() : false
+def checkPropertyExists(String propertyName) {
+    if (project.hasProperty(propertyName) == false) {
+        throw new GradleException("This project requires a property \"" + propertyName + "\"! Please add it your \"gradle.properties\". You can find all properties and their description here: https://github.com/SinTh0r4s/ExampleMod1.7.10/blob/main/gradle.properties")
+    }
+}
+
 
 String javaSourceDir = "src/main/java/"
 String scalaSourceDir = "src/main/scala/"
-String kotlinSourceDir = "src/main/kotlin/"
 
 String targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/")
 String targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/")
-String targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/")
-if(!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
-    throw new GradleException("Could not resolve \"modGroup\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin)
+if((new File(targetPackageJava).exists() || new File(targetPackageScala).exists()) == false) {
+    throw new GradleException("Could not resolve \"modGroup\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
 }
 
 if(apiPackage) {
     targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
     targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
-    targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
-    if(!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
-        throw new GradleException("Could not resolve \"apiPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin)
+    if((new File(targetPackageJava).exists() || new File(targetPackageScala).exists()) == false) {
+        throw new GradleException("Could not resolve \"apiPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
     }
 }
 
 if(accessTransformersFile) {
     String targetFile = "src/main/resources/META-INF/" + accessTransformersFile
-    if(!getFile(targetFile).exists()) {
+    if(new File(targetFile).exists() == false) {
         throw new GradleException("Could not resolve \"accessTransformersFile\"! Could not find " + targetFile)
     }
 }
@@ -137,17 +121,15 @@ if(usesMixins.toBoolean()) {
 
     targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
     targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
-    targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
-    if(!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
-        throw new GradleException("Could not resolve \"mixinsPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala  + " or " + targetPackageKotlin)
+    if((new File(targetPackageJava).exists() || new File(targetPackageScala).exists()) == false) {
+        throw new GradleException("Could not resolve \"mixinsPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
     }
 
     String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
     String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".scala"
     String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
-    String targetFileKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".kt"
-    if(!(getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists() || getFile(targetFileKotlin).exists())) {
-        throw new GradleException("Could not resolve \"mixinPlugin\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava + " or " + targetFileKotlin)
+    if((new File(targetFileJava).exists() || new File(targetFileScala).exists() || new File(targetFileScalaJava).exists()) == false) {
+        throw new GradleException("Could not resolve \"mixinPlugin\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava)
     }
 }
 
@@ -155,9 +137,8 @@ if(coreModClass) {
     String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
     String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".scala"
     String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
-    String targetFileKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".kt"
-    if(!(getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists() || getFile(targetFileKotlin).exists())) {
-        throw new GradleException("Could not resolve \"coreModClass\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava + " or " + targetFileKotlin)
+    if((new File(targetFileJava).exists() || new File(targetFileScala).exists() || new File(targetFileScalaJava).exists()) == false) {
+        throw new GradleException("Could not resolve \"coreModClass\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava)
     }
 }
 
@@ -170,55 +151,11 @@ configurations.all {
 }
 
 // Fix Jenkins' Git: chmod a file should not be detected as a change and append a '.dirty' to the version
-try {
-    'git config core.fileMode false'.execute()
-}
-catch (Exception e) {
-    out.style(Style.Failure).println("git isn't installed at all")
-}
-
-// Pulls version first from the VERSION env and then git tag
-String identifiedVersion
-String versionOverride = System.getenv("VERSION") ?: null
-try {
-    identifiedVersion = versionOverride == null ? gitVersion() : versionOverride
-}
-catch (Exception e) {
-    out.style(Style.Failure).text(
-        'This mod must be version controlled by Git AND the repository must provide at least one tag,\n' +
-        'or the VERSION override must be set! ').style(Style.SuccessHeader).text('(Do NOT download from GitHub using the ZIP option, instead\n' + 
-        'clone the repository, see ').style(Style.Info).text('https://gtnh.miraheze.org/wiki/Development').style(Style.SuccessHeader).println(' for details.)'
-    )
-    versionOverride = 'NO-GIT-TAG-SET'
-    identifiedVersion = versionOverride
-}
-version = minecraftVersion + '-' + identifiedVersion
-String modVersion = identifiedVersion
-
-if( identifiedVersion.equals(versionOverride) ) {
-    out.style(Style.Failure).text('Override version to ').style(Style.Identifier).text(modVersion).style(Style.Failure).println('!\7')
-}
-
+'git config core.fileMode false'.execute()
+// Pulls version from git tag
+version = minecraftVersion + "-" + gitVersion()
 group = modGroup
-if(project.hasProperty("customArchiveBaseName") && customArchiveBaseName) {
-    archivesBaseName = customArchiveBaseName
-}
-else {
-    archivesBaseName = modId
-}
-
-
-def arguments = []
-def jvmArguments = []
-
-if(usesMixins.toBoolean()) {
-    arguments += [
-            "--tweakClass org.spongepowered.asm.launch.MixinTweaker"
-    ]
-    jvmArguments += [
-            "-Dmixin.debug.countInjections=true", "-Dmixin.debug.verbose=true", "-Dmixin.debug.export=true"
-    ]
-}
+archivesBaseName = modId
 
 minecraft {
     version = minecraftVersion + "-" + forgeVersion + "-" + minecraftVersion
@@ -233,26 +170,12 @@ minecraft {
             replace gradleTokenModName, modName
         }
         if(gradleTokenVersion) {
-            replace gradleTokenVersion, modVersion
+            replace gradleTokenVersion, versionDetails().lastTag
         }
         if(gradleTokenGroupName) {
             replace gradleTokenGroupName, modGroup
         }
     }
-
-    clientIntellijRun {
-        args(arguments)
-        jvmArgs(jvmArguments)
-
-        if(developmentEnvironmentUserName) {
-            args("--username", developmentEnvironmentUserName)
-        }
-    }
-
-    serverIntellijRun {
-        args(arguments)
-        jvmArgs(jvmArguments)
-    }
 }
 
 if(file("addon.gradle").exists()) {
@@ -262,55 +185,54 @@ if(file("addon.gradle").exists()) {
 apply from: 'repositories.gradle'
 
 configurations {
-    implementation.extendsFrom(shadowImplementation)  // TODO: remove after all uses are refactored
-    implementation.extendsFrom(shadowCompile)
-    implementation.extendsFrom(shadeCompile)
+    implementation.extendsFrom(shadowImplementation)
 }
 
 repositories {
     maven {
-        name 'Overmind forge repo mirror'
-        url 'https://gregtech.overminddl1.com/'
+        name = "Overmind forge repo mirror"
+        url = "https://gregtech.overminddl1.com/"
     }
     if(usesMixins.toBoolean()) {
         maven {
-            name 'sponge'
-            url 'https://repo.spongepowered.org/repository/maven-public'
+            name = "sponge"
+            url = "https://repo.spongepowered.org/repository/maven-public"
         }
         maven {
-            url 'https://jitpack.io'
+            url = "https://jitpack.io"
         }
     }
 }
 
 dependencies {
     if(usesMixins.toBoolean()) {
-        annotationProcessor('org.ow2.asm:asm-debug-all:5.0.3')
-        annotationProcessor('com.google.guava:guava:24.1.1-jre')
-        annotationProcessor('com.google.code.gson:gson:2.8.6')
-        annotationProcessor('org.spongepowered:mixin:0.8-SNAPSHOT')
+        annotationProcessor("org.ow2.asm:asm-debug-all:5.0.3")
+        annotationProcessor("com.google.guava:guava:24.1.1-jre")
+        annotationProcessor("com.google.code.gson:gson:2.8.6")
+        annotationProcessor("org.spongepowered:mixin:0.8-SNAPSHOT")
         // using 0.8 to workaround a issue in 0.7 which fails mixin application
-        compile('com.github.GTNewHorizons:SpongePoweredMixin:0.7.12-GTNH') {
+        compile("org.spongepowered:mixin:0.7.11-SNAPSHOT") {
             // Mixin includes a lot of dependencies that are too up-to-date
-            exclude module: 'launchwrapper'
-            exclude module: 'guava'
-            exclude module: 'gson'
-            exclude module: 'commons-io'
-            exclude module: 'log4j-core'
+            exclude module: "launchwrapper"
+            exclude module: "guava"
+            exclude module: "gson"
+            exclude module: "commons-io"
+            exclude module: "log4j-core"
         }
-        compile('com.github.GTNewHorizons:SpongeMixins:1.5.0')
+        compile("com.github.GTNewHorizons:SpongeMixins:1.3.3:dev")
     }
 }
 
 apply from: 'dependencies.gradle'
 
+def mixinConfigJson = "mixins." + modId + ".json"
 def mixingConfigRefMap = "mixins." + modId + ".refmap.json"
 def refMap = "${tasks.compileJava.temporaryDir}" + File.separator + mixingConfigRefMap
 def mixinSrg = "${tasks.reobf.temporaryDir}" + File.separator + "mixins.srg"
 
 task generateAssets {
     if(usesMixins.toBoolean()) {
-        getFile("/src/main/resources/mixins." + modId + ".json").text = """{
+        new File(projectDir.toString() + "/src/main/resources/", mixinConfigJson).text = """{
   "required": true,
   "minVersion": "0.7.11",
   "package": "${modGroup}.${mixinsPackage}",
@@ -330,28 +252,16 @@ task relocateShadowJar(type: ConfigureShadowRelocation) {
 }
 
 shadowJar {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
     manifest {
         attributes(getManifestAttributes())
     }
 
     minimize()  // This will only allow shading for actually used classes
-    configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
+    configurations = [project.configurations.shadowImplementation]
     dependsOn(relocateShadowJar)
 }
 
 jar {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
     manifest {
         attributes(getManifestAttributes())
     }
@@ -384,6 +294,15 @@ afterEvaluate {
 }
 
 runClient {
+    def arguments = []
+
+    if(usesMixins.toBoolean()) {
+        arguments += [
+                "--mods=../build/libs/$modId-${version}.jar",
+                "--tweakClass org.spongepowered.asm.launch.MixinTweaker"
+        ]
+    }
+
     if(developmentEnvironmentUserName) {
         arguments += [
                 "--username",
@@ -392,12 +311,19 @@ runClient {
     }
 
     args(arguments)
-    jvmArgs(jvmArguments)
 }
 
 runServer {
+    def arguments = []
+
+    if (usesMixins.toBoolean()) {
+        arguments += [
+                "--mods=../build/libs/$modId-${version}.jar",
+                "--tweakClass org.spongepowered.asm.launch.MixinTweaker"
+        ]
+    }
+
     args(arguments)
-    jvmArgs(jvmArguments)
 }
 
 tasks.withType(JavaExec).configureEach {
@@ -409,35 +335,31 @@ tasks.withType(JavaExec).configureEach {
 }
 
 processResources
-{
-    // this will ensure that this task is redone when the versions change.
-    inputs.property "version", project.version
-    inputs.property "mcversion", project.minecraft.version
-    
-    // replace stuff in mcmod.info, nothing else
-    from(sourceSets.main.resources.srcDirs) {
-        include 'mcmod.info'
+        {
+            // this will ensure that this task is redone when the versions change.
+            inputs.property "version", project.version
+            inputs.property "mcversion", project.minecraft.version
 
-        // replace modVersion and minecraftVersion
-        expand "minecraftVersion": project.minecraft.version,
-            "modVersion": modVersion,
-            "modId": modId,
-            "modName": modName
-    }
+            // replace stuff in mcmod.info, nothing else
+            from(sourceSets.main.resources.srcDirs) {
+                include 'mcmod.info'
 
-    if(usesMixins.toBoolean()) {
-        from refMap
-    }
+                // replace version and mcversion
+                expand "minecraftVersion": project.minecraft.version,
+                        "modVersion": versionDetails().lastTag,
+                        "modId": modId,
+                        "modName": modName
+            }
 
-    // copy everything else that's not the mcmod.info
-    from(sourceSets.main.resources.srcDirs) {
-        exclude 'mcmod.info'
-    }
-}
+            // copy everything else, thats not the mcmod.info
+            from(sourceSets.main.resources.srcDirs) {
+                exclude 'mcmod.info'
+            }
+        }
 
 def getManifestAttributes() {
     def manifestAttributes = [:]
-    if(containsMixinsAndOrCoreModOnly.toBoolean() == false && (usesMixins.toBoolean() || coreModClass)) {
+    if(containsMixinsAndOrCoreModOnly.toBoolean() == false) {
         manifestAttributes += ["FMLCorePluginContainsFMLMod": true]
     }
 
@@ -452,7 +374,7 @@ def getManifestAttributes() {
     if(usesMixins.toBoolean()) {
         manifestAttributes += [
                 "TweakClass" : "org.spongepowered.asm.launch.MixinTweaker",
-                "MixinConfigs" : "mixins." + modId + ".json",
+                "MixinConfigs" : mixinConfigJson,
                 "ForceLoadAsMod" : containsMixinsAndOrCoreModOnly.toBoolean() == false
         ]
     }
@@ -466,12 +388,6 @@ task sourcesJar(type: Jar) {
 }
 
 task shadowDevJar(type: ShadowJar) {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
     from sourceSets.main.output
     getArchiveClassifier().set("dev")
 
@@ -480,27 +396,22 @@ task shadowDevJar(type: ShadowJar) {
     }
 
     minimize()  // This will only allow shading for actually used classes
-    configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
+    configurations = [project.configurations.shadowImplementation]
+    //dependsOn(relocateShadowDevJar)
 }
 
 task relocateShadowDevJar(type: ConfigureShadowRelocation) {
-    target = tasks.shadowDevJar
+    target = tasks.shadowDevJar  //gradle.taskGraph.getAllTasks().find {it.name.equals("shadowDevJar") }  //
     prefix = modGroup + ".shadow"
 }
 
-task circularResolverJar(type: Jar) {
+task feongweosn(type: Jar) {
     dependsOn(relocateShadowDevJar)
     dependsOn(shadowDevJar)
     enabled = false
 }
 
 task devJar(type: Jar) {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
     from sourceSets.main.output
     getArchiveClassifier().set("dev")
 
@@ -509,18 +420,18 @@ task devJar(type: Jar) {
     }
 
     if(usesShadowedDependencies.toBoolean()) {
-        dependsOn(circularResolverJar)
+        dependsOn(shadowDevJar)
         enabled = false
     }
 }
 
 task apiJar(type: Jar) {
     from (sourceSets.main.allJava) {
-        include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
+        include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString() + '/**'
     }
 
     from (sourceSets.main.output) {
-        include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
+        include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString() + '/**'
     }
 
     from (sourceSets.main.resources.srcDirs) {
@@ -531,104 +442,48 @@ task apiJar(type: Jar) {
 }
 
 artifacts {
-    if(!noPublishedSources) {
-        archives sourcesJar
-    }
-    archives devJar
+    archives sourcesJar
+    archives feongweosn
     if(apiPackage) {
         archives apiJar
     }
 }
 
-// The gradle metadata includes all of the additional deps that we disabled from POM generation (including forgeBin with no groupID), 
-// and isn't strictly needed with the POM so just disable it.
-tasks.withType(GenerateModuleMetadata) {
-    enabled = false
-}
-
-publishing {
-    publications {
-        maven(MavenPublication) {
-            from components.java
-            if(usesShadowedDependencies.toBoolean()) {
-                artifact source: shadowJar, classifier: ""
-            }
-            if(!noPublishedSources) {
-                artifact source: sourcesJar, classifier: "src"
-            }
-            artifact source: usesShadowedDependencies.toBoolean() ? shadowDevJar : devJar, classifier: "dev"
-            if (apiPackage) {
-                artifact source: apiJar, classifier: "api"
-            }
-
-            groupId = System.getenv("ARTIFACT_GROUP_ID") ?: "com.github.GTNewHorizons"
-            artifactId = System.getenv("ARTIFACT_ID") ?: project.name
-            // Using the identified version, not project.version as it has the prepended 1.7.10
-            version = System.getenv("RELEASE_VERSION") ?: identifiedVersion
-            
-            // remove extra garbage from who knows where
-            pom.withXml {
-                def badPomGroup = ['net.minecraft', 'com.google.code.findbugs', 'org.ow2.asm', 'com.typesafe.akka', 'com.typesafe', 'org.scala-lang',
-                                   'org.scala-lang.plugins', 'net.sf.jopt-simple', 'lzma', 'com.mojang', 'org.apache.commons', 'org.apache.httpcomponents',
-                                   'commons-logging', 'java3d', 'net.sf.trove4j', 'com.ibm.icu', 'com.paulscode', 'io.netty', 'com.google.guava', 
-                                   'commons-io', 'commons-codec', 'net.java.jinput', 'net.java.jutils', 'com.google.code.gson', 'org.apache.logging.log4j', 
-                                   'org.lwjgl.lwjgl', 'tv.twitch', '']
-                Node pomNode = asNode()
-                pomNode.dependencies.'*'.findAll() {
-                    badPomGroup.contains(it.groupId.text()) 
-                }.each() {
-                    it.parent().remove(it)
-                }
-            }
-        }
-    }
-
-    repositories {
-        maven {
-            url = "http://jenkins.usrv.eu:8081/nexus/content/repositories/releases"
-            credentials {
-                username = System.getenv("MAVEN_USER") ?: "NONE"
-                password = System.getenv("MAVEN_PASSWORD") ?: "NONE"
-            }
-        }
-    }
-}
-
 // Updating
 task updateBuildScript {
     doLast {
-        if (performBuildScriptUpdate(projectDir.toString())) return
+        if (updateBuildScript()) return
 
         print("Build script already up-to-date!")
     }
 }
 
-if (isNewBuildScriptVersionAvailable(projectDir.toString())) {
+if (isNewBuildScriptVersionAvailable()) {
     if (autoUpdateBuildScript.toBoolean()) {
-        performBuildScriptUpdate(projectDir.toString())
+        updateBuildScript()
     } else {
-        out.style(Style.SuccessHeader).println("Build script update available! Run 'gradle updateBuildScript'")
+        println("Build script update available! Run 'gradle updateBuildScript'")
     }
 }
 
 static URL availableBuildScriptUrl() {
-    new URL("https://raw.githubusercontent.com/GTNewHorizons/ExampleMod1.7.10/main/build.gradle")
+    new URL("https://raw.githubusercontent.com/SinTh0r4s/ExampleMod1.7.10/main/build.gradle")
 }
 
-boolean performBuildScriptUpdate(String projectDir) {
-    if (isNewBuildScriptVersionAvailable(projectDir)) {
-        def buildscriptFile = getFile("build.gradle")
+static boolean updateBuildScript() {
+    if (isNewBuildScriptVersionAvailable()) {
+        def buildscriptFile = new File("build.gradle")
         availableBuildScriptUrl().withInputStream { i -> buildscriptFile.withOutputStream { it << i } }
-        out.style(Style.Success).print("Build script updated. Please REIMPORT the project or RESTART your IDE!")
+        print("Build script updated. Please REIMPORT the project or RESTART your IDE!")
         return true
     }
     return false
 }
 
-boolean isNewBuildScriptVersionAvailable(String projectDir) {
+static boolean isNewBuildScriptVersionAvailable() {
     Map parameters = ["connectTimeout": 2000, "readTimeout": 2000]
 
-    String currentBuildScript = getFile("build.gradle").getText()
+    String currentBuildScript = new File("build.gradle").getText()
     String currentBuildScriptHash = getVersionHash(currentBuildScript)
     String availableBuildScript = availableBuildScriptUrl().newInputStream(parameters).getText()
     String availableBuildScriptHash = getVersionHash(availableBuildScript)
@@ -649,81 +504,3 @@ configure(updateBuildScript) {
     group = 'forgegradle'
     description = 'Updates the build script to the latest version'
 }
-
-// Deobfuscation
-
-def deobf(String sourceURL) {
-    try {
-        URL url = new URL(sourceURL)
-        String fileName = url.getFile()
-
-        //get rid of directories:
-        int lastSlash = fileName.lastIndexOf("/")
-        if(lastSlash > 0) {
-            fileName = fileName.substring(lastSlash + 1)
-        }
-        //get rid of extension:
-        if(fileName.endsWith(".jar")) {
-            fileName = fileName.substring(0, fileName.lastIndexOf("."))
-        }
-
-        String hostName = url.getHost()
-        if(hostName.startsWith("www.")) {
-            hostName = hostName.substring(4)
-        }
-        List parts = Arrays.asList(hostName.split("\\."))
-        Collections.reverse(parts)
-        hostName = String.join(".", parts)
-
-        return deobf(sourceURL, hostName + "/" + fileName)
-    } catch(Exception e) {
-        return deobf(sourceURL, "deobf/" + String.valueOf(sourceURL.hashCode()))
-    }
-}
-
-// The method above is to be preferred. Use this method if the filename is not at the end of the URL.
-def deobf(String sourceURL, String fileName) {
-    String cacheDir = System.getProperty("user.home") + "/.gradle/caches/"
-    String bon2Dir = cacheDir + "forge_gradle/deobf"
-    String bon2File  = bon2Dir + "/BON2-2.5.0.jar"
-    String obfFile = cacheDir + "modules-2/files-2.1/" + fileName + ".jar"
-    String deobfFile = cacheDir + "modules-2/files-2.1/" + fileName + "-deobf.jar"
-    
-    if(file(deobfFile).exists()) {
-        return files(deobfFile)
-    }
-
-    download.run {
-        src 'https://github.com/GTNewHorizons/BON2/releases/download/2.5.0/BON2-2.5.0.CUSTOM-all.jar'
-        dest bon2File
-        quiet true
-        overwrite false
-    }
-
-    download.run {
-        src sourceURL
-        dest obfFile
-        quiet true
-        overwrite false
-    }
-
-    exec {
-        commandLine 'java', '-jar', bon2File, '--inputJar', obfFile, '--outputJar', deobfFile, '--mcVer', '1.7.10', '--mappingsVer', 'stable_12', '--notch'
-        workingDir bon2Dir
-        standardOutput = new ByteArrayOutputStream()
-    }
-
-    return files(deobfFile)
-}
-
-// Helper methods
-
-def checkPropertyExists(String propertyName) {
-    if (project.hasProperty(propertyName) == false) {
-        throw new GradleException("This project requires a property \"" + propertyName + "\"! Please add it your \"gradle.properties\". You can find all properties and their description here: https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/main/gradle.properties")
-    }
-}
-
-def getFile(String relativePath) {
-    return new File(projectDir, relativePath)
-}

dependencies.gradle

@@ -1,7 +1,7 @@
 // Add your dependencies here
 
 dependencies {
-    compile('com.github.GTNewHorizons:CodeChickenLib:1.1.5.3:dev')
-    compile('com.github.GTNewHorizons:CodeChickenCore:1.1.3:dev')
-    shadowImplementation('org.apache.commons:commons-csv:1.8')
+    compile("com.github.GTNewHorizons:CodeChickenLib:master-SNAPSHOT:dev")
+    compile("com.github.GTNewHorizons:CodeChickenCore:master-SNAPSHOT:dev")
+    shadowImplementation("org.apache.commons:commons-csv:1.5")
 }

gradle.properties

@@ -15,15 +15,15 @@ autoUpdateBuildScript = false
 minecraftVersion = 1.7.10
 forgeVersion = 10.13.4.1614
 
-# Select a username for testing your mod with breakpoints. You may leave this empty for a random username each time you
+# Select a username for testing your mod with breakpoints. You may leave this empty for a random user name each time you
 # restart Minecraft in development. Choose this dependent on your mod:
 # Do you need consistent player progressing (for example Thaumcraft)? -> Select a name
 # Do you need to test how your custom blocks interacts with a player that is not the owner? -> leave name empty
-developmentEnvironmentUserName = Developer
+developmentEnvironmentUserName = "Developer"
 
 # Define a source file of your project with:
 # public static final String VERSION = "GRADLETOKEN_VERSION";
-# The string's content will be replaced with your mod's version when compiled. You should use this to specify your mod's
+# The string's content will be replaced with your mods version when compiled. You should use this to specify your mod's
 # version in @Mod([...], version = VERSION, [...])
 # Leave these properties empty to skip individual token replacements
 replaceGradleTokenInFile = NEIModContainer.java
@@ -32,12 +32,12 @@ gradleTokenModName = GRADLETOKEN_MODNAME
 gradleTokenVersion = GRADLETOKEN_VERSION
 gradleTokenGroupName =
 
-# In case your mod provides an API for other mods to implement you may declare its package here. Otherwise, you can
+# In case your mod provides an API for other mods to implement you may declare its package here. Otherwise you can
 # leave this property empty.
 # Example value: apiPackage = api + modGroup = com.myname.mymodid -> com.myname.mymodid.api
 apiPackage =
 
-# Specify the configuration file for Forge's access transformers here. It must be placed into /src/main/resources/META-INF/
+# Specify the configuration file for Forge's access transformers here. I must be placed into /src/main/resources/META-INF/
 # Example value: mymodid_at.cfg
 accessTransformersFile = nei_at.cfg
 
@@ -48,7 +48,7 @@ mixinPlugin =
 # Specify the package that contains all of your Mixins. You may only place Mixins in this package or the build will fail!
 mixinsPackage =
 # Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin!
-# This parameter is for legacy compatibility only
+# This parameter is for legacy compatability only
 # Example value: coreModClass = asm.FMLPlugin + modGroup = com.myname.mymodid -> com.myname.mymodid.asm.FMLPlugin
 coreModClass = asm.NEICorePlugin
 # If your project is only a consolidation of mixins or a core mod and does NOT contain a 'normal' mod ( = some class

repositories.gradle

@@ -3,16 +3,6 @@
 repositories {
     mavenCentral()
     maven {
-        name 'GTNH Maven'
-        url 'http://jenkins.usrv.eu:8081/nexus/content/groups/public/'
-    }
-    maven {
-        url 'https://cursemaven.com'
-        content {
-            includeGroup 'curse.maven'
-        }
-    }
-    maven {
-        url 'https://jitpack.io'
+        url = "https://jitpack.io"
     }
 }

src/main/java/codechicken/nei/BookmarkPanel.java

@@ -1,820 +1,174 @@
 package codechicken.nei;
 
-import codechicken.core.CommonUtils;
-import codechicken.lib.vec.Rectangle4i;
 import codechicken.nei.util.NBTJson;
-import codechicken.nei.recipe.StackInfo;
-import codechicken.nei.recipe.BookmarkRecipeId;
-import codechicken.nei.guihook.GuiContainerManager;
 import com.google.gson.JsonParser;
-import com.google.gson.JsonPrimitive;
-import com.google.gson.JsonObject;
 import com.google.gson.JsonSyntaxException;
+import cpw.mods.fml.common.registry.GameData;
 import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import org.apache.commons.io.IOUtils;
 
-import static codechicken.lib.gui.GuiDraw.getMousePosition;
-import static codechicken.lib.gui.GuiDraw.drawRect;
-
-import java.awt.Point;
 import java.io.File;
 import java.io.FileReader;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
+import java.io.FileWriter;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
-import java.util.HashMap;
 
-public class BookmarkPanel extends ItemPanel
-{
+/*
+ * TODO:
+ *   1) Bookmark button to toggle visibility
+ */
+public class BookmarkPanel extends ItemPanel {
 
-    protected File bookmarkFile;
-    protected boolean bookmarksIsLoaded = false;
-    public int sortedStackIndex = -1;
-    public int sortedNamespaceIndex = -1;
-
-
-    public Button namespacePrev;
-    public Button namespaceNext;
-    public Label namespaceLabel;
-
-
-    protected ArrayList<BookmarkGrid> namespaces = new ArrayList<>();
-    public int activeNamespaceIndex = 0;
-
-
-    protected static class BookmarkStackMeta
-    {
-        public int factor;
-        public BookmarkRecipeId recipeId;
-        public boolean ingredient = false;
-
-
-        public BookmarkStackMeta(BookmarkRecipeId recipeId, int count, boolean ingredient)
-        {
-            this.recipeId = recipeId;
-            this.factor = count;
-            this.ingredient = ingredient;
-        }
-
-    }
-
-    protected static class BookmarkGrid extends ItemsGrid
-    {
-        protected List<BookmarkStackMeta> metadata = new ArrayList<>();
-
-        public int indexOf(ItemStack stackA, BookmarkRecipeId recipeId)
-        {
-            final boolean useNBT = NEIClientConfig.useNBTInBookmarks();
-        
-            for (int idx = 0; idx < realItems.size(); idx++) {
-                final BookmarkStackMeta meta = getMetadata(idx);
-                if ((recipeId == null && meta.recipeId == null || recipeId != null && meta.recipeId != null && recipeId.equals(meta.recipeId)) && StackInfo.equalItemAndNBT(stackA, realItems.get(idx), useNBT)) {
-                    return idx;
-                }
-            }
-    
-            return -1;
-        }
-
-        public BookmarkStackMeta getMetadata(int idx)
-        {
-            return metadata.get(idx);
-        }
-        
-        public void addItem(ItemStack stackA, BookmarkStackMeta meta)
-        {
-            realItems.add(stackA);
-            metadata.add(meta);
-        }
-
-        public void replaceItem(int idx, ItemStack stack)
-        {
-            realItems.set(idx, stack);
-        }
-
-        public void removeRecipe(int idx, boolean removeFullRecipe)
-        {
-            final BookmarkStackMeta meta = getMetadata(idx);
-
-            if (removeFullRecipe && meta.recipeId != null) {
-                removeRecipe(meta.recipeId);
-            } else {
-                removeItem(idx);
-            }
-
-        }
-
-        public void removeRecipe(BookmarkRecipeId recipeIdA)
-        {
-            BookmarkRecipeId recipeIdB;
-
-            for (int slotIndex = metadata.size() - 1; slotIndex >= 0; slotIndex--) {
-                recipeIdB = getRecipeId(slotIndex);
-
-                if (recipeIdB != null && recipeIdA.equals(recipeIdB)) {
-                    removeItem(slotIndex);
-                }
-
-            }
-
-        }
-        
-        protected boolean removeItem(int idx)
-        {
-            realItems.remove(idx);
-            metadata.remove(idx);
-            return true;
-        }
-
-        public BookmarkRecipeId getRecipeId(int idx)
-        {
-            return getMetadata(idx).recipeId;
-        }
-
-        public BookmarkRecipeId findRecipeId(ItemStack stackA)
-        {
-            final boolean useNBT = NEIClientConfig.useNBTInBookmarks();
-
-            for (int idx = 0; idx < realItems.size(); idx++) {
-                if (StackInfo.equalItemAndNBT(stackA, getItem(idx), useNBT)) {
-                    return getRecipeId(idx);
-                }
-            }
-            
-            return null;
-        }
-
-        public void moveItem(int src, int dst)
-        {
-            realItems.add(dst, realItems.remove(src));
-            metadata.add(dst, metadata.remove(src));
-        }
-
-        @Override
-        protected void drawItem(Rectangle4i rect, int idx, ItemPanelSlot focus)
-        {
-
-            if (LayoutManager.bookmarkPanel.sortedNamespaceIndex == LayoutManager.bookmarkPanel.activeNamespaceIndex && LayoutManager.bookmarkPanel.sortedStackIndex == idx) {
-                drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);//highlight
-            } else {
-
-                if (focus != null) {
-
-                    if (focus.slotIndex == idx) {
-                        drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);//highlight
-                    } else if (
-                            LayoutManager.bookmarkPanel.sortedStackIndex == -1 && //disabled when sorting
-                            NEIClientUtils.shiftKey() &&  //show only with shift key
-                            getRecipeId(focus.slotIndex) != null && getRecipeId(idx) != null && getRecipeId(focus.slotIndex).equals(getRecipeId(idx))//is some recipeId
-                    ) {
-                        drawRect(rect.x, rect.y, rect.w, rect.h, getMetadata(idx).ingredient? 0x88b3b300: 0x88009933);//highlight recipe
-                    }
-    
-                }
-
-                GuiContainerManager.drawItem(rect.x + 1, rect.y + 1, getItem(idx), true);
-            }
-
-        }
-
-    }
-
-
-    public BookmarkPanel()
-    {
-        grid = new BookmarkGrid();
-    }
-
-    public void init() 
-    {
+    public void init() {
         super.init();
-
-        namespaceLabel = new Label("1", true);
-
-        namespacePrev = new Button("Prev")
-        {
-            public boolean onButtonPress(boolean rightclick)
-            {
-
-                if (rightclick) {
-                    return false;
-                }
-
-                return prevNamespace();
-            }
-
-            @Override
-            public String getRenderLabel()
-            {
-                return "<";
-            }
-        };
-
-        namespaceNext = new Button("Next")
-        {
-            public boolean onButtonPress(boolean rightclick)
-            {
-                if (rightclick) {
-                    return false;
-                }
-
-                return nextNamespace();
-            }
-
-            @Override
-            public String getRenderLabel()
-            {
-                return ">";
-            }
-        };
-
-        namespaces.add(new BookmarkGrid());
-        grid = namespaces.get(activeNamespaceIndex);
     }
 
     @Override
-    public String getLabelText()
-    {
-        return super.getLabelText() + " [" + grid.size() + "]";
+    protected void setItems() {
+        realItems = _items;
     }
 
-    public void addOrRemoveItem(ItemStack stackA)
-    {
-        addOrRemoveItem(stackA, "", null);
+    public String getLabelText() {
+        return super.getLabelText() + " [" + realItems.size() + "]";
     }
 
-    public void addOrRemoveItem(ItemStack stackover, String handlerName, List<PositionedStack> ingredients)
-    {
-        loadBookmarksIfNeeded();
-
-        final Point mousePos =  getMousePosition();
-        final ItemPanelSlot slot = getSlotMouseOver(mousePos.x, mousePos.y);
-        final boolean addFullRecipe = NEIClientUtils.shiftKey();
-        final BookmarkGrid BGrid = (BookmarkGrid) grid;
-
-        if (slot != null && StackInfo.equalItemAndNBT(slot.item, stackover, true)) {
-            BGrid.removeRecipe(slot.slotIndex, addFullRecipe);
-        } else {
-            final boolean saveStackSize = NEIClientUtils.controlKey();
-            final NBTTagCompound nbTagA = StackInfo.itemStackToNBT(stackover, saveStackSize);
-            final ItemStack normalizedA = StackInfo.loadFromNBT(nbTagA);
-            BookmarkRecipeId recipeId = null;
-            
-            if (NEIClientConfig.saveCurrentRecipeInBookmarksEnabled() && handlerName != "" && ingredients != null && ingredients.size() > 0) {
-                recipeId = new BookmarkRecipeId(handlerName, ingredients);
-            }
-
-            final int idx = BGrid.indexOf(normalizedA, recipeId);
-
-            if (idx != -1) {
-                BGrid.removeRecipe(idx, addFullRecipe);
-            } else {
-
-                if (addFullRecipe && handlerName != "" && ingredients != null) {
-                    final Map<NBTTagCompound, Integer> unique = new HashMap<>();
-                    final ArrayList<NBTTagCompound> sorted = new ArrayList<>();
-
-                    BGrid.removeRecipe(recipeId);
-
-                    for (PositionedStack stack : ingredients) { 
-                        final NBTTagCompound nbTag = StackInfo.itemStackToNBT(stack.item, saveStackSize);
-
-                        if (unique.get(nbTag) == null) {
-                            unique.put(nbTag, 1);
-                            sorted.add(nbTag);
-                        } else if (saveStackSize) {
-                            unique.put(nbTag, unique.get(nbTag) + 1);
-                        }
-
-                    }
-
-                    for (NBTTagCompound nbTag : sorted) { 
-                        nbTag.setInteger("Count", nbTag.getInteger("Count") * unique.get(nbTag));
-                        BGrid.addItem(StackInfo.loadFromNBT(nbTag), new BookmarkStackMeta(recipeId, nbTag.getInteger("Count"), true));
-                    }
-
-                }
-
-                BGrid.addItem(normalizedA, new BookmarkStackMeta(recipeId, nbTagA.getInteger("Count"), false));
-            }
-            
-
+    public void addOrRemoveItem(ItemStack item) {
+        ItemStack normalized = normalize(item);
+        if(!remove(normalized)) {
+            _items.add(normalized);
         }
-
-        fixCountOfNamespaces();
         saveBookmarks();
     }
 
-    public BookmarkRecipeId getBookmarkRecipeId(ItemStack stackA)
+    public static NBTTagCompound itemStackToNBT(ItemStack stack, NBTTagCompound nbTag)
     {
+        String strId = Item.itemRegistry.getNameForObject(stack.getItem());
+        nbTag.setString("strId", strId);
+        nbTag.setByte("Count", (byte)stack.stackSize);
+        nbTag.setShort("Damage", (short)stack.getItemDamage());
 
-        final Point mousePos =  getMousePosition();
-        final ItemPanelSlot slot = getSlotMouseOver(mousePos.x, mousePos.y);
-
-        if (slot != null && StackInfo.equalItemAndNBT(slot.item, stackA, true)) {
-            return ((BookmarkGrid) grid).getRecipeId(slot.slotIndex);
+        if (stack.stackTagCompound != null)
+        {
+            nbTag.setTag("tag", stack.stackTagCompound);
         }
 
-        BookmarkRecipeId recipeId = ((BookmarkGrid) grid).findRecipeId(stackA);
+        return nbTag;
+    }
 
-        if (recipeId == null) {
+    public static ItemStack loadFromNBT(NBTTagCompound nbtTag)
+    {
+        if (!nbtTag.hasKey("id")) {
+            final short id = (short)GameData.getItemRegistry().getId(nbtTag.getString("strId"));
+             nbtTag.setShort("id", id);
+        }
+        ItemStack stack = ItemStack.loadItemStackFromNBT(nbtTag);
+        return stack;
+    }
 
-            for (int idx = 0; idx < namespaces.size() && recipeId == null; idx++) {
-                if (idx == activeNamespaceIndex) continue;
-                recipeId = namespaces.get(idx).findRecipeId(stackA);
+    public void saveBookmarks() {
+        List<String> strings = new ArrayList<>();
+        for (ItemStack item:_items) {
+            strings.add(NBTJson.toJson(itemStackToNBT(item, new NBTTagCompound())));
+        }
+        File file = NEIClientConfig.bookmarkFile;
+        if(file != null) {
+            try(FileWriter writer = new FileWriter(file)) {
+                IOUtils.writeLines(strings, "\n", writer);
+            } catch (IOException e) {
+                NEIClientConfig.logger.error("Filed to save bookmarks list to file {}", file, e);
             }
-
         }
-
-        return recipeId;
     }
 
-    protected String getNamespaceLabelText(boolean shortFormat)
-    {
-        String activePage = String.valueOf(activeNamespaceIndex + 1);
-
-        return shortFormat? activePage: (activePage + "/" + fixCountOfNamespaces());
-    }
-
-    protected int fixCountOfNamespaces()
-    {
-
-        if (namespaces.get(namespaces.size() - 1).size() > 0) {
-            namespaces.add(new BookmarkGrid());
-        } else if (activeNamespaceIndex == namespaces.size() - 2 && grid.size() == 0) {
-            namespaces.remove(namespaces.size() - 1);
-        }
-
-        return namespaces.size();
-    }
-
-    protected boolean removeEmptyNamespaces()
-    {
-        
-        if (activeNamespaceIndex != namespaces.size() - 1 && grid.size() == 0) {
-            namespaces.remove(activeNamespaceIndex);
-            grid = namespaces.get(activeNamespaceIndex);
-            return true;
-        }
-
-        return false;
-    }
-
-    protected boolean prevNamespace()
-    {
-        if (!bookmarksIsLoaded) {
-            return false;
-        }
-        
-        fixCountOfNamespaces();
-        removeEmptyNamespaces();
-
-        if (activeNamespaceIndex == 0) {
-            activeNamespaceIndex = namespaces.size() - 1;
-        } else {
-            activeNamespaceIndex --;
-        }
-
-        grid = namespaces.get(activeNamespaceIndex);
-
-        return true;
-    }
-
-    protected boolean nextNamespace()
-    {
-        if (!bookmarksIsLoaded) {
-            return false;
-        }
-
-        if (removeEmptyNamespaces()) {
-            return true;
-        }
-
-        if (activeNamespaceIndex == fixCountOfNamespaces() - 1) {
-            activeNamespaceIndex = 0;
-        } else {
-            activeNamespaceIndex ++;
-        }
-
-        grid = namespaces.get(activeNamespaceIndex);
-
-        return true;
-    }
-
-    public void setBookmarkFile(String worldPath)
-    {
-
-        final File dir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + worldPath);
-
-        if (!dir.exists()) {
-            dir.mkdirs();
-        }
-
-        bookmarkFile = new File(dir, "bookmarks.ini");
-
-        if (!bookmarkFile.exists()) {
-            final File globalBookmarks = new File(CommonUtils.getMinecraftDir(), "saves/NEI/global/bookmarks.ini");
-            final File configBookmarks = new File(NEIClientConfig.configDir, "bookmarks.ini");
-            final File defaultBookmarks = configBookmarks.exists()? configBookmarks: globalBookmarks;
-
-            if (defaultBookmarks.exists()) {
-
-                try {
-                    bookmarkFile.createNewFile();
-
-                    InputStream src = new FileInputStream(defaultBookmarks);
-                    OutputStream dst = new FileOutputStream(bookmarkFile);
-
-                    IOUtils.copy(src, dst);
-
-                    src.close();
-                    dst.close();
-
-                } catch(IOException e) {}
-                
-            }
-
-        }
-
-        bookmarksIsLoaded = false;
-    }
-
-    public void saveBookmarks()
-    {
-
-        if (bookmarkFile == null) {
+    public void loadBookmarks() {
+        File file = NEIClientConfig.bookmarkFile;
+        if (file == null || !file.exists()) {
             return;
         }
-
-        ArrayList<String> strings = new ArrayList<>();
-
-        for (int grpIdx = 0; grpIdx < namespaces.size() - 1; grpIdx++) {
-            final BookmarkGrid grid = namespaces.get(grpIdx);
-
-            if (grpIdx > 0) {
-                strings.add("");//namespace separator; ignore first namespace
-            }
-
-            for (int idx = 0; idx < grid.size(); idx++) {
-
-                try {
-                    final NBTTagCompound nbTag = StackInfo.itemStackToNBT(grid.getItem(idx));
-    
-                    if (nbTag != null) {
-                        JsonObject row = new JsonObject();
-                        BookmarkStackMeta meta = grid.getMetadata(idx);
-    
-                        row.add("item", NBTJson.toJsonObject(nbTag));
-                        row.add("factor", new JsonPrimitive(meta.factor));
-                        row.add("ingredient", new JsonPrimitive(meta.ingredient));
-    
-                        if (meta.recipeId != null) {
-                            row.add("recipeId", meta.recipeId.toJsonObject());
-                        }
-
-                        strings.add(NBTJson.toJson(row));
-                    }
-    
-                } catch (JsonSyntaxException e) {
-                    NEIClientConfig.logger.error("Failed to stringify bookmarked ItemStack to json string");
-                }
-    
-            }
-
-        }
-
-        try (FileOutputStream output = new FileOutputStream(bookmarkFile)) {
-            IOUtils.writeLines(strings, "\n", output, "UTF-8");
-        } catch (IOException e) {
-            NEIClientConfig.logger.error("Filed to save bookmarks list to file {}", bookmarkFile, e);
-        }
-
-    }
-
-    public void loadBookmarksIfNeeded()
-    {
-
-        if (bookmarksIsLoaded) {
-            return;
-        }
-
-        bookmarksIsLoaded = true;
-
-        if (bookmarkFile == null || !bookmarkFile.exists()) {
-            return;
-        }
-
         List<String> itemStrings;
-        try (FileReader reader = new FileReader(bookmarkFile)) {
-            NEIClientConfig.logger.info("Loading bookmarks from file {}", bookmarkFile);
+        try (FileReader reader = new FileReader(file)) {
+            NEIClientConfig.logger.info("Loading bookmarks from file {}", file);
             itemStrings = IOUtils.readLines(reader);
         } catch (IOException e) {
-            NEIClientConfig.logger.error("Failed to load bookmarks from file {}", bookmarkFile, e);
+            NEIClientConfig.logger.error("Failed to load bookmarks from file {}", file, e);
             return;
         }
-
-        namespaces.clear();
-        namespaces.add(new BookmarkGrid());
-        activeNamespaceIndex = 0;
-
-        final JsonParser parser = new JsonParser();
-
+        _items.clear();
+        JsonParser parser = new JsonParser();
         for (String itemStr: itemStrings) {
             try {
-
-                if (itemStr.isEmpty()) {
-
-                    if (namespaces.get(activeNamespaceIndex).size() > 0) {
-                        //do not create empty namespaces
-                        namespaces.add(new BookmarkGrid());
-                        activeNamespaceIndex++;
-                    }
-
-                    continue;
-                }
-
-                JsonObject jsonObject = parser.parse(itemStr).getAsJsonObject();
-                BookmarkRecipeId recipeId = null;
-                NBTTagCompound itemStackNBT;
-
-                if (jsonObject.get("item") != null) {
-                    itemStackNBT = (NBTTagCompound) NBTJson.toNbt(jsonObject.get("item"));
-                } else {// old format
-                    itemStackNBT = (NBTTagCompound) NBTJson.toNbt(jsonObject);
-                }
-
-                if (jsonObject.get("recipeId") != null && jsonObject.get("recipeId") instanceof JsonObject) {
-                    recipeId = new BookmarkRecipeId((JsonObject) jsonObject.get("recipeId"));
-                }
-
-                ItemStack itemStack = StackInfo.loadFromNBT(itemStackNBT);
-
-
+                NBTTagCompound itemStackNBT = (NBTTagCompound) NBTJson.toNbt(parser.parse(itemStr));
+                ItemStack itemStack = loadFromNBT(itemStackNBT);
                 if (itemStack != null) {
-                    namespaces.get(activeNamespaceIndex).addItem(itemStack, new BookmarkStackMeta(
-                        recipeId,
-                        jsonObject.has("factor")? jsonObject.get("factor").getAsInt(): 1,
-                        jsonObject.has("ingredient")? jsonObject.get("ingredient").getAsBoolean(): false
-                    ));
+                    _items.add(itemStack);
                 } else {
                     NEIClientConfig.logger.warn("Failed to load bookmarked ItemStack from json string, the item no longer exists:\n{}", itemStr);
                 }
-
             } catch (IllegalArgumentException | JsonSyntaxException e) {
                 NEIClientConfig.logger.error("Failed to load bookmarked ItemStack from json string:\n{}", itemStr);
             }
         }
+    }
 
-        if (namespaces.get(activeNamespaceIndex).size() == 0) {
-            activeNamespaceIndex = Math.max(activeNamespaceIndex - 1, 0);
+    protected ItemStack normalize(ItemStack item) {
+        ItemStack copy = item.copy();
+        copy.stackSize = 1;
+        return copy;
+    }
+    private boolean remove(ItemStack item) {
+        int i = 0;
+        for (ItemStack existing : _items) {
+            if (existing == item || existing.isItemEqual(item)) {
+                _items.remove(i);
+                return true;
+            }
+            i++;
         }
-
-        grid = namespaces.get(activeNamespaceIndex);
-    }
-
-
-    @Override
-    public void resize(GuiContainer gui) 
-    {
-        loadBookmarksIfNeeded();
-        super.resize(gui);
-
-        final int buttonHeight = 16;
-        final int buttonWidth = 16;
-
-        final int buttonTop = gui.height - buttonHeight - 2;
-        final int leftBorder = LayoutManager.bookmarksButton.x + LayoutManager.bookmarksButton.w + 2;
-        final int rightBorder = x + w;
-        final int center = leftBorder + (rightBorder - leftBorder) / 2;
-        int labelWidth = 2;
-
-        namespacePrev.h = namespaceNext.h = buttonHeight;
-        namespacePrev.w = namespaceNext.w = buttonWidth;
-        namespacePrev.y = namespaceNext.y = buttonTop;
-
-
-        if (rightBorder - leftBorder >= 70) {
-            labelWidth = 36;
-            namespaceLabel.text = getNamespaceLabelText(false);
-        } else {
-            labelWidth = 18;
-            namespaceLabel.text = getNamespaceLabelText(true);
-        }
-
-        namespaceLabel.y = buttonTop + 5;
-        namespaceLabel.x = center;
-
-        namespacePrev.x = center - labelWidth / 2 - 2 - namespacePrev.w;
-        namespaceNext.x = center + labelWidth / 2 + 2;
-
+        return false;
     }
 
     @Override
-    public void setVisible()
-    {
-        super.setVisible();
-
-        LayoutManager.addWidget(namespacePrev);
-        LayoutManager.addWidget(namespaceNext);
-        LayoutManager.addWidget(namespaceLabel);
-    }
-
-    @Override
-    public int getMarginLeft(GuiContainer gui)
-    {
+    public int getX(GuiContainer gui) {
         return 5;
     }
 
     @Override
-    public int getMarginTop(GuiContainer gui)
-    {
+    public int getMarginLeft() {
+        return 5;
+    }
+
+
+    @Override
+    public int getButtonTop() {
         LayoutStyleMinecraft layout = (LayoutStyleMinecraft)LayoutManager.getLayoutStyle();
         return 2 + (((int)Math.ceil((double)layout.buttonCount / layout.numButtons)) * 18);
     }
 
     @Override
-    public int getWidth(GuiContainer gui)
-    {
-        return LayoutManager.getLeftSize(gui) - ((gui.xSize + gui.width) / 2 + 3) - 16;
+    public int getNextX(GuiContainer gui) {
+        return gui.width - prev.w - 2 - ((gui.xSize + gui.width) /2 + 2) - 16;
     }
 
     @Override
-    public int getHeight(GuiContainer gui)
-    {
-        // - 19 = 22 + 1 -> input in bottom
-        return gui.height - getMarginTop(gui) - 23;
-    }
-
-
-    @Override
-    public void mouseDragged(int mousex, int mousey, int button, long heldTime)
-    {
-
-        if (button == 0 && NEIClientUtils.shiftKey() && mouseDownSlot >= 0) {
-            ItemPanelSlot mouseOverSlot = getSlotMouseOver(mousex, mousey);
-
-            if (sortedStackIndex == -1) {
-                final ItemStack stack = grid.getItem(mouseDownSlot);
-
-                if (stack != null && (mouseOverSlot == null || mouseOverSlot.slotIndex != mouseDownSlot || heldTime > 250)) {
-                    sortedNamespaceIndex = activeNamespaceIndex;
-                    sortedStackIndex = mouseDownSlot;
-                }
-
-            } else {
-
-                if (mouseOverSlot == null && sortedNamespaceIndex != activeNamespaceIndex) {
-                    mouseOverSlot = getNextSlot(mousex, mousey);
-                }
-
-                if (mouseOverSlot != null) {
-
-                    if (sortedNamespaceIndex != activeNamespaceIndex) {
-                        BookmarkGrid BGrid = namespaces.get(sortedNamespaceIndex);
-                        BookmarkStackMeta meta = BGrid.getMetadata(sortedStackIndex);
-                        ItemStack stack = BGrid.getItem(sortedStackIndex);
-                        BGrid.removeItem(sortedStackIndex);
-        
-                        ((BookmarkGrid) grid).addItem(stack, meta);
-        
-                        sortedNamespaceIndex = activeNamespaceIndex;
-                        sortedStackIndex = grid.size() - 1;
-                    }
-    
-                    if (mouseOverSlot.slotIndex != sortedStackIndex) {
-                        ((BookmarkGrid) grid).moveItem(sortedStackIndex, mouseOverSlot.slotIndex);
-                        sortedStackIndex = mouseOverSlot.slotIndex;
-                    }
-                    
-                }
-
-            }
-
-            return;
-        }
-
-        super.mouseDragged(mousex, mousey, button, heldTime);
-    }
-
-    private ItemPanelSlot getNextSlot(int mousex, int mousey)
-    {
-        int idx = grid.getPage() * grid.getPerPage() - grid.getPerPage();
-        int gSize = grid.size();
-
-        for (int i = 0; i < grid.getRows() * grid.getColumns() && idx <= gSize; i++) {
-
-            if (!grid.isInvalidSlot(i)) {
-
-                if (idx == gSize && grid.getSlotRect(i).contains(mousex, mousey)) {
-                    return new ItemPanelSlot(idx, null);
-                }
-
-                idx++;
-            }
-
-        }
-
-        return null;
+    public int getPrevX(GuiContainer gui) {
+        return 2;
     }
 
     @Override
-    public void postDraw(int mousex, int mousey)
-    {
-
-        if (sortedStackIndex != -1) {
-            GuiContainerManager.drawItems.zLevel += 100;
-            GuiContainerManager.drawItem(mousex - 8, mousey - 8, namespaces.get(sortedNamespaceIndex).getItem(sortedStackIndex).copy(), true);
-            GuiContainerManager.drawItems.zLevel -= 100;
-        }
-
-        super.postDraw(mousex, mousey);
+    public int getPageX(GuiContainer gui) {
+        return gui.guiLeft * 3 / 2 + gui.xSize + 1 - ((gui.xSize + gui.width) / 2 + 2) - 16;
     }
 
-    @Override
-    protected ItemStack getDraggedStackWithQuantity(int mouseDownSlot)
-    {
-        ItemStack stack = grid.getItem(mouseDownSlot);
-
-        return stack != null? stack.copy(): null;
+    public int getHightAdjustment() {
+        return 0;
     }
 
-    @Override
-    public void mouseUp(int mousex, int mousey, int button)
-    {
-        if (sortedStackIndex != -1) {
-            draggedStack = null;
-            sortedNamespaceIndex = -1;
-            sortedStackIndex = -1;
-            mouseDownSlot = -1;
-            saveBookmarks();
-        } else {
-            super.mouseUp(mousex, mousey, button);
-        }
-    }
-
-    @Override
-    public boolean onMouseWheel(int shift, int mousex, int mousey)
-    {
-
-        if (new Rectangle4i(namespacePrev.x, namespacePrev.y, namespaceNext.x + namespaceNext.w - namespacePrev.x, namespacePrev.h).contains(mousex, mousey)) {
-
-            if (shift > 0) {
-                prevNamespace();
-            } else {
-                nextNamespace();       
-            }
-            
-            return true;
-        }
-
-        if (!contains(mousex, mousey)) {
-            return false;
-        }
-
-        if (NEIClientUtils.controlKey()) {
-            final ItemPanelSlot slot = getSlotMouseOver(mousex, mousey);
-
-            if (slot != null) {
-                final BookmarkGrid BGrid = (BookmarkGrid)grid;
-                final BookmarkRecipeId recipeId = BGrid.getRecipeId(slot.slotIndex);
-                final BookmarkStackMeta meta = BGrid.getMetadata(slot.slotIndex);
-                final boolean addFullRecipe = NEIClientUtils.shiftKey();
-
-                if (addFullRecipe) {
-                    BookmarkStackMeta iMeta;
-
-                    for (int slotIndex = grid.size() - 1; slotIndex >= 0; slotIndex--) {
-                        iMeta = BGrid.getMetadata(slotIndex);
-    
-                        if (iMeta.recipeId != null && iMeta.recipeId.equals(recipeId)) {
-                            NBTTagCompound nbTag = StackInfo.itemStackToNBT(BGrid.getItem(slotIndex), true);
-                            nbTag.setInteger("Count", Math.max(nbTag.getInteger("Count") + iMeta.factor * shift, iMeta.factor));
-                            BGrid.replaceItem(slotIndex, StackInfo.loadFromNBT(nbTag));
-                        }
-    
-                    }
-
-                }
-
-                NBTTagCompound nbTag = StackInfo.itemStackToNBT(slot.item, true);
-                nbTag.setInteger("Count", Math.max(nbTag.getInteger("Count") + meta.factor * shift, meta.factor));
-                BGrid.replaceItem(slot.slotIndex, StackInfo.loadFromNBT(nbTag));
-
-                saveBookmarks();
-
-                return true;
-            }
-
-        }
-
-        return super.onMouseWheel(shift, mousex, mousey);
+    public int getWidth(GuiContainer gui) {
+        return LayoutManager.getLeftSize(gui) - ( (gui.xSize + gui.width) / 2 + 3 ) - 16;
     }
 
 }

src/main/java/codechicken/nei/ClientHandler.java

@@ -6,8 +6,6 @@ import codechicken.lib.packet.PacketCustom;
 import codechicken.nei.api.API;
 import codechicken.nei.api.ItemInfo;
 import codechicken.nei.recipe.GuiRecipeTab;
-import codechicken.nei.recipe.StackInfo;
-
 import com.google.common.collect.Lists;
 import cpw.mods.fml.client.CustomModLoadingErrorDisplayException;
 import cpw.mods.fml.common.FMLCommonHandler;
@@ -48,24 +46,18 @@ import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 
 public class ClientHandler
 {
     private static String[] defaultSerialHandlers = {
         "WayofTime.alchemicalWizardry.client.nei.NEIAlchemyRecipeHandler"
     };
-    private static String[] defaultHeightHackHandlerRegex = {
-            "buildcraft.compat.nei.*",
-            "cofh.thermalexpansion.plugins.nei.handlers.*",
-            "crazypants.enderio.nei.*",
-            "forestry.factory.recipes.nei.*",
-            "ic2.neiIntegration.core.recipehandler.*",
-            "mariculture.plugins.nei.*",
-            "redgear.brewcraft.plugins.nei.*",
-            "tconstruct.plugins.nei.*",
-            "WayofTime.alchemicalWizardry.client.nei.*",
+    private static String[] defaultHeightHackHandlers = {
+            "ic2.neiIntegration.core.recipehandler.FluidCannerRecipeHandler",
+            "tconstruct.plugins.nei.RecipeHandlerAlloying",
+            "tconstruct.plugins.nei.RecipeHandlerCastingBasin",
+            "tconstruct.plugins.nei.RecipeHandlerCastingTable",
+            "tconstruct.plugins.nei.RecipeHandlerMelting",
     };
     private static String[] defaultHandlerOrdering = {
             "# Each line in this file should either be a comment (starts with '#') or an ordering.",
@@ -162,7 +154,6 @@ public class ClientHandler
         loadSerialHandlers();
         loadHeightHackHandlers();
         ItemInfo.preInit();
-        StackInfo.loadGuidFilters();
     }
     
     public static void loadSerialHandlers() {
@@ -189,7 +180,7 @@ public class ClientHandler
         if (!file.exists()) {
             try (FileWriter writer = new FileWriter(file)) {
                 NEIClientConfig.logger.info("Creating default height hack handlers list {}", file);
-                Collection<String> toSave = Arrays.asList(defaultHeightHackHandlerRegex);
+                Collection<String> toSave = Loader.isModLoaded("dreamcraft") ? Collections.singletonList("") : Arrays.asList(defaultHeightHackHandlers);
                 IOUtils.writeLines(toSave, "\n", writer);
             } catch (IOException e) {
                 NEIClientConfig.logger.error("Failed to save default height hack handlers list to file {}", file, e);
@@ -198,10 +189,7 @@ public class ClientHandler
 
         try (FileReader reader = new FileReader(file)) {
             NEIClientConfig.logger.info("Loading height hack handlers from file {}", file);
-            NEIClientConfig.heightHackHandlerRegex =
-                    IOUtils.readLines(reader).stream()
-                            .map(Pattern::compile)
-                            .collect(Collectors.toCollection(HashSet::new));
+            NEIClientConfig.heightHackHandlers = new HashSet<>(IOUtils.readLines(reader));
         } catch (IOException e) {
             NEIClientConfig.logger.error("Failed to load height hack handlers from file {}", file, e);
         }

src/main/java/codechicken/nei/ItemList.java

@@ -185,13 +185,13 @@ public class ItemList
         @SuppressWarnings("unchecked")
         public void execute() {
             // System.out.println("Executing NEI Item Loading");
-            ThreadOperationTimer timer = getTimer(NEIClientConfig.getItemLoadingTimeout());
+            ThreadOperationTimer timer = getTimer(500);
 
             LinkedList<ItemStack> items = new LinkedList<>();
             LinkedList<ItemStack> permutations = new LinkedList<>();
             ListMultimap<Item, ItemStack> itemMap = ArrayListMultimap.create();
 
-            timer.setLimit(NEIClientConfig.getItemLoadingTimeout());
+            timer.setLimit(500);
             for (Item item : (Iterable<Item>) Item.itemRegistry) {
                 if (interrupted()) return;
 
@@ -252,7 +252,6 @@ public class ItemList
 
             try {
                 filtered = ItemList.forkJoinPool.submit(() -> items.parallelStream()
-                    .filter(PresetsWidget::matches)
                     .filter(filter::matches)
                     .collect(Collectors.toCollection(ArrayList::new))).get();
             } catch (InterruptedException | ExecutionException e) {

src/main/java/codechicken/nei/ItemPanel.java

@@ -7,130 +7,79 @@ import codechicken.nei.guihook.GuiContainerManager;
 import codechicken.nei.recipe.GuiCraftingRecipe;
 import codechicken.nei.recipe.GuiRecipe;
 import codechicken.nei.recipe.GuiUsageRecipe;
-import codechicken.nei.recipe.StackInfo;
 import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.client.gui.inventory.GuiContainerCreative;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.EnumChatFormatting;
-import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.fluids.IFluidContainerItem;
-
-import static codechicken.lib.gui.GuiDraw.drawRect;
-import static codechicken.nei.LayoutManager.searchField;
 
 import java.util.ArrayList;
-import java.util.regex.Pattern;
 
-public class ItemPanel extends Widget
-{
-
-    public ItemStack draggedStack;
-    public int mouseDownSlot = -1;
-
-    public Button pagePrev;
-    public Button pageNext;
-    public Label pageLabel;
+import static codechicken.lib.gui.GuiDraw.drawRect;
+import static codechicken.nei.NEIClientConfig.canPerformAction;
 
+public class ItemPanel extends Widget {
     /**
      *  Backwards compat :-/
      */
-    @Deprecated
-    private int itemsPerPage = 0;
-
-    @Deprecated
     public static ArrayList<ItemStack> items = new ArrayList<>();
 
-    @Deprecated
+    /**
+     * Should not be externally modified, use updateItemList
+     */
     public ArrayList<ItemStack> realItems = new ArrayList<>();
+    /**
+     * Swapped into visible items on update
+     */
+    protected ArrayList<ItemStack> _items = realItems;
 
-    protected Pattern SPECIAL_REGEX_CHARS = Pattern.compile("[{}()\\[\\].+*?^$\\\\|]");
+    public ArrayList<ItemStack> getItems() {
+        return realItems;
+    }
 
-    public static class ItemPanelSlot
+    public static void updateItemList(ArrayList<ItemStack> newItems) {
+        ItemPanels.itemPanel._items = newItems;
+    }
+
+    public class ItemPanelSlot
     {
         public ItemStack item;
         public int slotIndex;
 
-        public ItemPanelSlot(int idx, ItemStack stack)
-        {
-            slotIndex = idx;
-            item = stack;
+        public ItemPanelSlot(int index) {
+            item = realItems.get(index);
+            slotIndex = index;
         }
-
-        @Deprecated
-        public ItemPanelSlot(int idx)
-        {
-            this(idx, ItemPanels.itemPanel.getGrid().getItem(idx));
-        }
-
     }
 
-    protected static class ItemPanelGrid extends ItemsGrid
-    {
-        public ArrayList<ItemStack> newItems;
+    public ItemStack draggedStack;
+    public int mouseDownSlot = -1;
 
-        public void setItems(ArrayList<ItemStack> items)
-        {
-            newItems = items;
-        }
-
-        public void refresh(GuiContainer gui)
-        {
-
-            if (newItems != null) {
-                realItems = newItems;
-                newItems = null;
-            }
-
-            super.refresh(gui);
-        }
-
-        @Override
-        protected void drawItem(Rectangle4i rect, int idx, ItemPanelSlot focus)
-        {
-
-            if (PresetsWidget.inEditMode() && !PresetsWidget.isHidden(getItem(idx))) {
-                drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);
-            }
-
-            super.drawItem(rect, idx, PresetsWidget.inEditMode()? null: focus);
-        }
+    public Button prev;
+    public Button next;
+    public Label pageLabel;
 
 
-    }
+    private int marginLeft;
+    private int marginTop;
+    private int rows;
+    private int columns;
 
-    protected ItemsGrid grid = new ItemPanelGrid();
+    private boolean[] validSlotMap;
+    private int firstIndex;
+    private int itemsPerPage;
 
-    public ArrayList<ItemStack> getItems()
-    {
-        return grid.getItems();
-    }
+    private int page;
+    private int numPages;
 
-    public static void updateItemList(ArrayList<ItemStack> newItems)
-    {
-        ((ItemPanelGrid) ItemPanels.itemPanel.getGrid()).setItems(newItems);
-        ItemPanels.itemPanel.realItems = newItems;
-    }
 
-    @Deprecated
-    public void scroll(int i)
-    {
-        grid.shiftPage(i);
-    }
-
-    public ItemsGrid getGrid()
-    {
-        return grid;
-    }
 
     public void init() {
         pageLabel = new Label("(0/0)", true);
 
-        pagePrev = new Button("Prev")
+        prev = new Button("Prev")
         {
             public boolean onButtonPress(boolean rightclick) {
                 if (!rightclick) {
-                    grid.shiftPage(-1);
+                    scroll(-1);
                     return true;
                 }
                 return false;
@@ -141,11 +90,11 @@ public class ItemPanel extends Widget
                 return "<";
             }
         };
-        pageNext = new Button("Next")
+        next = new Button("Next")
         {
             public boolean onButtonPress(boolean rightclick) {
                 if (!rightclick) {
-                    grid.shiftPage(1);
+                    scroll(1);
                     return true;
                 }
                 return false;
@@ -156,89 +105,169 @@ public class ItemPanel extends Widget
                 return ">";
             }
         };
-
     }
 
-    public int getMarginLeft(GuiContainer gui)
-    {
-        if (gui instanceof GuiContainerCreative && NEIClientUtils.getGamemode() == 2) {
-            //then activate creative+ first render creative gui and oly then creative+
-            return (gui.width + 176) / 2  + 2;
-        }
-
-        return (gui.width + gui.xSize) / 2  + 2;
+    public int getX(GuiContainer gui) {
+        return (gui.xSize + gui.width) / 2 + 3;
     }
 
-    public int getMarginTop(GuiContainer gui)
-    {
+    public int getMarginLeft() {
+        return x + (w % 18) / 2;
+    }
+
+    public int getMarginTop() {
+        return y + (h % 18) / 2;
+    }
+
+    public int getButtonTop() {
         return 2;
     }
 
-    public int getWidth(GuiContainer gui)
-    {
-        return LayoutManager.getSideWidth(gui) - getMarginLeft(gui);
+    public int getNextX(GuiContainer gui) {
+        return gui.width - prev.w - 2;
     }
 
-    public int getHeight(GuiContainer gui)
-    {
-        // - 19 = 2 + 16 + 1 -> input in bottom
-        return gui.height - getMarginTop(gui) - 19;
+    public int getPrevX(GuiContainer gui) {
+        return (gui.xSize + gui.width) / 2 + 2;
     }
 
-    public String getLabelText()
-    {
-        return "(" + getPage() + "/" + Math.max(1, getNumPages()) + ")";
+    public int getPageX(GuiContainer gui) {
+        return gui.guiLeft * 3 / 2 + gui.xSize + 1;
     }
 
-    public void resize(GuiContainer gui)
-    {
-        final int marginLeft = getMarginLeft(gui);
-        final int marginTop = getMarginTop(gui);
-        final int width = getWidth(gui);
-        final int height = getHeight(gui);
+    public int getHeight(GuiContainer gui) {
+        return gui.height - 15 - y;
+    }
+
+    public int getWidth(GuiContainer gui) {
+        return LayoutManager.getSideWidth(gui) - x;
+    }
+
+    public String getLabelText() {
+        return pageLabel.text = "(" + getPage() + "/" + getNumPages() + ")";
+    }
+
+    protected void setItems() {
+        realItems = _items;
+
+        // Backwards compat
+        ItemPanels.itemPanel._items = _items;
+    }
+
+    public void resize(GuiContainer gui) {
+        setItems();
         final int buttonHeight = 16;
         final int buttonWidth = 16;
 
-        pagePrev.w = pageNext.w = buttonWidth;
-        pagePrev.h = pageNext.h = buttonHeight;
-        pagePrev.y = pageNext.y = marginTop;
+        prev.x = getPrevX(gui);
+        prev.y = getButtonTop();
+        prev.h = buttonHeight;
+        prev.w = buttonWidth;
 
-        pagePrev.x = marginLeft;
-        pageNext.x = marginLeft + width - buttonWidth;
+        next.x = getNextX(gui);
+        next.y = getButtonTop();
+        next.h = buttonHeight;
+        next.w = buttonWidth;
 
-        pageLabel.x = marginLeft + width / 2;
-        pageLabel.y = marginTop + 5;
+        pageLabel.x = getPageX(gui);
+        pageLabel.y = prev.y + 5;
         pageLabel.text = getLabelText();
 
+        y = prev.h + prev.y;
+        x = getX(gui);
+        w = getWidth(gui);
+        h = getHeight(gui);
 
-        y = marginTop + buttonHeight + 2;
-        x = marginLeft;
-        w = width;
-        h = height - buttonHeight - 2;
-
-        grid.setGridSize(x, y, w, h);
-        grid.refresh(gui);
+        marginLeft = getMarginLeft();
+        marginTop = getMarginTop();
+        columns = w / 18;
+        rows = h / 18;
+        //sometimes width and height can be negative with certain resizing
+        if(rows < 0) rows = 0;
+        if(columns < 0) columns = 0;
 
+        calculatePage();
+        updateValidSlots();
     }
 
-    public void setVisible()
-    {
-        LayoutManager.addWidget(pagePrev);
-        LayoutManager.addWidget(pageNext);
+    private void calculatePage() {
+        if (itemsPerPage == 0)
+            numPages = 0;
+        else
+            numPages = (int) Math.ceil((float) realItems.size() / (float) itemsPerPage);
+
+        if (firstIndex >= realItems.size())
+            firstIndex = 0;
+
+        if (numPages == 0)
+            page = 0;
+        else
+            page = firstIndex / itemsPerPage + 1;
+    }
+
+    public void setVisible() {
+        LayoutManager.addWidget(prev);
+        LayoutManager.addWidget(next);
         LayoutManager.addWidget(pageLabel);
+
+    }
+    private void updateValidSlots() {
+        GuiContainer gui = NEIClientUtils.getGuiContainer();
+        validSlotMap = new boolean[rows * columns];
+        itemsPerPage = 0;
+        for (int i = 0; i < validSlotMap.length; i++)
+            if (slotValid(gui, i)) {
+                validSlotMap[i] = true;
+                itemsPerPage++;
+            }
+    }
+
+    private boolean slotValid(GuiContainer gui, int i) {
+        Rectangle4i rect = getSlotRect(i);
+        try {
+            GuiInfo.readLock.lock();
+            if(GuiInfo.guiHandlers.stream().anyMatch(handler -> handler.hideItemPanelSlot(gui, rect.x, rect.y, rect.w, rect.h)))
+                return false;
+        } finally {
+            GuiInfo.readLock.unlock();
+        }
+        return true;
+    }
+
+    public Rectangle4i getSlotRect(int i) {
+        return getSlotRect(i / columns, i % columns);
+    }
+
+    public Rectangle4i getSlotRect(int row, int column) {
+        return new Rectangle4i(marginLeft + column * 18, marginTop + row * 18, 18, 18);
     }
 
     @Override
-    public void draw(int mousex, int mousey)
-    {
-        grid.draw(mousex, mousey);
+    public void draw(int mousex, int mousey) {
+        if (itemsPerPage == 0)
+            return;
+
+        GuiContainerManager.enableMatrixStackLogging();
+        int index = firstIndex;
+        for (int i = 0; i < rows * columns && index < realItems.size(); i++) {
+            if (validSlotMap[i]) {
+                Rectangle4i rect = getSlotRect(i);
+                if (rect.contains(mousex, mousey))
+                    drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);//highlight
+
+                GuiContainerManager.drawItem(rect.x + 1, rect.y + 1, realItems.get(index));
+
+                index++;
+            }
+        }
+        GuiContainerManager.disableMatrixStackLogging();
     }
 
     @Override
     public void postDraw(int mousex, int mousey) {
         if (draggedStack != null) {
             GuiContainerManager.drawItems.zLevel += 100;
-            GuiContainerManager.drawItem(mousex - 8, mousey - 8, draggedStack, true);
+            GuiContainerManager.drawItem(mousex - 8, mousey - 8, draggedStack);
             GuiContainerManager.drawItems.zLevel -= 100;
         }
     }
@@ -248,43 +277,29 @@ public class ItemPanel extends Widget
         if (mouseDownSlot >= 0 && draggedStack == null && NEIClientUtils.getHeldItem() == null &&
             NEIClientConfig.hasSMPCounterPart() && !GuiInfo.hasCustomSlots(NEIClientUtils.getGuiContainer())) {
             ItemPanelSlot mouseOverSlot = getSlotMouseOver(mousex, mousey);
+            ItemStack stack = new ItemPanelSlot(mouseDownSlot).item;
+            if (stack != null && (mouseOverSlot == null || mouseOverSlot.slotIndex != mouseDownSlot || heldTime > 500)) {
+                int amount = NEIClientConfig.getItemQuantity();
+                if (amount == 0)
+                    amount = stack.getMaxStackSize();
 
-            if (mouseOverSlot == null || mouseOverSlot.slotIndex != mouseDownSlot || heldTime > 500) {
-                draggedStack = getDraggedStackWithQuantity(mouseDownSlot);
-                mouseDownSlot = -1;
+                draggedStack = NEIServerUtils.copyStack(stack, amount);
             }
-
         }
     }
 
-    protected ItemStack getDraggedStackWithQuantity(int mouseDownSlot)
-    {
-        ItemStack stack = grid.getItem(mouseDownSlot);
-
-        if (stack != null) {
-            int amount = NEIClientConfig.getItemQuantity();
-
-            if (amount == 0) {
-                amount = stack.getMaxStackSize();
-            }
-
-            return NEIServerUtils.copyStack(stack, amount);
-        }
-
-        return null;
-    }
-
     @Override
-    public boolean handleClick(int mousex, int mousey, int button)
-    {
-
-        if (handleClickExt(mousex, mousey, button))
+    public boolean handleClick(int mousex, int mousey, int button) {
+        if (handleDraggedClick(mousex, mousey, button))
             return true;
 
         if (NEIClientUtils.getHeldItem() != null) {
-
-            if (!grid.contains(mousex, mousey)) {
-                return false;
+            try {
+                GuiInfo.readLock.lock();
+                if (GuiInfo.guiHandlers.stream().anyMatch(handler -> handler.hideItemPanelSlot(NEIClientUtils.getGuiContainer(), mousex, mousey, 1, 1)))
+                    return false;
+            } finally {
+                GuiInfo.readLock.unlock();
             }
 
             if (NEIClientConfig.canPerformAction("delete") && NEIClientConfig.canPerformAction("item"))
@@ -300,209 +315,95 @@ public class ItemPanel extends Widget
 
         ItemPanelSlot hoverSlot = getSlotMouseOver(mousex, mousey);
         if (hoverSlot != null) {
-
             if (button == 2) {
+                ItemStack stack = hoverSlot.item;
+                if (stack != null) {
+                    int amount = NEIClientConfig.getItemQuantity();
+                    if (amount == 0)
+                        amount = stack.getMaxStackSize();
 
-                if (hoverSlot.item != null) {
-                    draggedStack = getDraggedStackWithQuantity(hoverSlot.slotIndex);
+                    draggedStack = NEIServerUtils.copyStack(stack, amount);
                 }
-
             } else {
                 mouseDownSlot = hoverSlot.slotIndex;
             }
-            
             return true;
         }
         return false;
     }
 
-    @Override
-    public boolean handleClickExt(int mouseX, int mouseY, int button)
-    {
-        if (ItemPanels.itemPanel.draggedStack != null) {
-            return ItemPanels.itemPanel.handleDraggedClick(mouseX, mouseY, button);
-        }
-
-        if (ItemPanels.bookmarkPanel.draggedStack != null) {
-            return ItemPanels.bookmarkPanel.handleDraggedClick(mouseX, mouseY, button);
-        }
-
-        return false;
-    }
-
-    protected boolean handleDraggedClick(int mouseX, int mouseY, int button)
-    {
-        if (draggedStack == null) {
+    private boolean handleDraggedClick(int mousex, int mousey, int button) {
+        if (draggedStack == null)
             return false;
-        }
 
-        if (handleFillFluidContainerClick(mouseX, mouseY, button)) {
-            return true;
-        }
-
-        if (handleSearchInputClick(mouseX, mouseY, button)) {
-            return true;
-        }
-
-        if (handleGUIContainerClick(mouseX, mouseY, button)) {
-            return true;
-        }
-
-        if (handleCheatItemClick(mouseX, mouseY, button)) {
-            return true;
-        }
-
-        final GuiContainer gui = NEIClientUtils.getGuiContainer();
-        if (mouseX < gui.guiLeft || mouseY < gui.guiTop || mouseX >= gui.guiLeft + gui.xSize || mouseY >= gui.guiTop + gui.ySize) {
-            draggedStack = null;
-        }
-
-        return true;
-    }
-
-    protected boolean handleFillFluidContainerClick(int mouseX, int mouseY, int button)
-    {
-
-        if (button == 2) {
-            return false;
-        }
-
-        ItemPanelSlot mouseOverSlot = ItemPanels.itemPanel.getSlotMouseOver(mouseX, mouseY);
-
-        if (mouseOverSlot == null) {
-            mouseOverSlot = ItemPanels.bookmarkPanel.getSlotMouseOver(mouseX, mouseY);
-        }
-
-        if (mouseOverSlot != null && draggedStack.getItem() instanceof IFluidContainerItem) {
-            FluidStack fluidStack = StackInfo.getFluid(mouseOverSlot.item);
-
-            if (fluidStack != null) {
-                final int stackSize = draggedStack.stackSize;
-
-                fluidStack = fluidStack.copy();
-
-                if (fluidStack.amount == 0) {
-                    fluidStack.amount = 1000;
-                }
-
-                if (mouseOverSlot.item.stackSize > 1) {
-                    fluidStack.amount *= mouseOverSlot.item.stackSize;
-                }
-
-                draggedStack.stackSize = 1;
-                ((IFluidContainerItem) draggedStack.getItem()).fill(draggedStack, fluidStack, true);
-                draggedStack.stackSize = stackSize;
-
-                if (button == 1 && ((IFluidContainerItem) draggedStack.getItem()).getFluid(draggedStack) != null) {
-                    ItemPanels.bookmarkPanel.addOrRemoveItem(draggedStack.copy());
-                }
-
-            }
-
-            return true;
-        }
-
-        return false;
-    }
-
-    protected boolean handleGUIContainerClick(int mouseX, int mouseY, int button)
-    {
-        final GuiContainer gui = NEIClientUtils.getGuiContainer();
+        GuiContainer gui = NEIClientUtils.getGuiContainer();
         boolean handled = false;
-
         try {
             GuiInfo.readLock.lock();
             for (INEIGuiHandler handler : GuiInfo.guiHandlers) {
-                if (handler.handleDragNDrop(gui, mouseX, mouseY, draggedStack, button)) {
+                if (handler.handleDragNDrop(gui, mousex, mousey, draggedStack, button)) {
                     handled = true;
-                    break;
+                    if (draggedStack.stackSize == 0) {
+                        draggedStack = null;
+                        return true;
+                    }
                 }
             }
         } finally {
             GuiInfo.readLock.unlock();
         }
+        
+        if (handled)
+            return true;
 
-        if (draggedStack.stackSize == 0) {
-            draggedStack = null;
-        }
-
-        return handled;
-    }
-
-    protected boolean handleCheatItemClick(int mouseX, int mouseY, int button)
-    {
-        final GuiContainer gui = NEIClientUtils.getGuiContainer();
-        final Slot overSlot = gui.getSlotAtPosition(mouseX, mouseY);
-
+        Slot overSlot = gui.getSlotAtPosition(mousex, mousey);
         if (overSlot != null && overSlot.isItemValid(draggedStack)) {
-
             if (NEIClientConfig.canCheatItem(draggedStack)) {
                 int contents = overSlot.getHasStack() ? overSlot.getStack().stackSize : 0;
-                final int add = button == 0 ? draggedStack.stackSize : 1;
-
-                if (overSlot.getHasStack() && !NEIServerUtils.areStacksSameType(draggedStack, overSlot.getStack())) {
+                int add = button == 0 ? draggedStack.stackSize : 1;
+                if (overSlot.getHasStack() && !NEIServerUtils.areStacksSameType(draggedStack, overSlot.getStack()))
                     contents = 0;
-                }        
-
-                final int total = Math.min(contents + add, Math.min(overSlot.getSlotStackLimit(), draggedStack.getMaxStackSize()));
+                int total = Math.min(contents + add, Math.min(overSlot.getSlotStackLimit(), draggedStack.getMaxStackSize()));
 
                 if (total > contents) {
                     NEIClientUtils.setSlotContents(overSlot.slotNumber, NEIServerUtils.copyStack(draggedStack, total), true);
                     NEICPH.sendGiveItem(NEIServerUtils.copyStack(draggedStack, total), false, false);
                     draggedStack.stackSize -= total - contents;
                 }
-
-                if (draggedStack.stackSize == 0) {
+                if (draggedStack.stackSize == 0)
                     draggedStack = null;
-                }
-
             } else {
                 draggedStack = null;
             }
-
-            return true;
+        } else if (mousex < gui.guiLeft || mousey < gui.guiTop || mousex >= gui.guiLeft + gui.xSize || mousey >= gui.guiTop + gui.ySize) {
+            draggedStack = null;
         }
 
-        return false;
+        return true;
     }
 
-    protected boolean handleSearchInputClick(int mouseX, int mouseY, int button)
-    {
-
-        if (searchField.contains(mouseX, mouseY)) {
-            final FluidStack fluidStack = StackInfo.getFluid(draggedStack);
-
-            if (fluidStack != null) {
-                searchField.setText(SPECIAL_REGEX_CHARS.matcher(EnumChatFormatting.getTextWithoutFormattingCodes(fluidStack.getLocalizedName())).replaceAll("\\\\$0"));
-            } else {
-                searchField.setText(SPECIAL_REGEX_CHARS.matcher(EnumChatFormatting.getTextWithoutFormattingCodes(draggedStack.getDisplayName())).replaceAll("\\\\$0"));
-            }
-
-            return true;
-        }
-
-        return false;
+    @Override
+    public boolean handleClickExt(int mousex, int mousey, int button) {
+        return handleDraggedClick(mousex, mousey, button);
     }
 
     @Override
     public void mouseUp(int mousex, int mousey, int button) {
         ItemPanelSlot hoverSlot = getSlotMouseOver(mousex, mousey);
-
         if (hoverSlot != null && hoverSlot.slotIndex == mouseDownSlot && draggedStack == null) {
             ItemStack item = hoverSlot.item;
-
             if (NEIController.manager.window instanceof GuiRecipe || !NEIClientConfig.canCheatItem(item)) {
-
                 if (button == 0)
                     GuiCraftingRecipe.openRecipeGui("item", item);
                 else if (button == 1)
                     GuiUsageRecipe.openRecipeGui("item", item);
 
+                draggedStack = null;
                 mouseDownSlot = -1;
                 return;
             }
 
-            NEIClientUtils.cheatItem(getDraggedStackWithQuantity(hoverSlot.slotIndex), button, -1);
+            NEIClientUtils.cheatItem(item, button, -1);
         }
 
         mouseDownSlot = -1;
@@ -513,23 +414,20 @@ public class ItemPanel extends Widget
         if (!contains(mousex, mousey))
             return false;
 
-        grid.shiftPage(-i);
+        scroll(-i);
         return true;
     }
 
     @Override
     public boolean handleKeyPress(int keyID, char keyChar) {
-
         if (keyID == NEIClientConfig.getKeyBinding("gui.next")) {
-            grid.shiftPage(1);
+            scroll(1);
             return true;
         }
-
         if (keyID == NEIClientConfig.getKeyBinding("gui.prev")) {
-            grid.shiftPage(-1);
+            scroll(-1);
             return true;
         }
-
         return false;
     }
 
@@ -539,23 +437,53 @@ public class ItemPanel extends Widget
         return slot == null ? null : slot.item;
     }
 
-    public ItemPanelSlot getSlotMouseOver(int mousex, int mousey)
-    {
-        return grid.getSlotMouseOver(mousex, mousey);
+    public ItemPanelSlot getSlotMouseOver(int mousex, int mousey) {
+        int index = firstIndex;
+        for (int i = 0; i < rows * columns && index < realItems.size(); i++)
+            if (validSlotMap[i]) {
+                if (getSlotRect(i).contains(mousex, mousey))
+                    return new ItemPanelSlot(index);
+                index++;
+            }
+
+        return null;
+    }
+
+    public void scroll(int i) {
+        if (itemsPerPage != 0) {
+            int oldIndex = firstIndex;
+            firstIndex += i * itemsPerPage;
+            if (firstIndex >= realItems.size())
+                firstIndex = 0;
+            if (firstIndex < 0)
+                if (oldIndex > 0)
+                    firstIndex = 0;
+                else
+                    firstIndex = (realItems.size() - 1) / itemsPerPage * itemsPerPage;
+
+            calculatePage();
+        }
     }
 
     public int getPage() {
-        return grid.page + 1;
+        return page;
     }
 
     public int getNumPages() {
-        return grid.numPages;
+        return numPages;
     }
 
     @Override
-    public boolean contains(int px, int py)
-    {
-        return grid.contains(px, py);
+    public boolean contains(int px, int py) {
+        GuiContainer gui = NEIClientUtils.getGuiContainer();
+        Rectangle4i rect = new Rectangle4i(px, py, 1, 1);
+        try {
+            GuiInfo.readLock.lock();
+            if(GuiInfo.guiHandlers.stream().anyMatch(handler -> handler.hideItemPanelSlot(gui, rect.x, rect.y, rect.w, rect.h)))
+                return false;
+        } finally {
+            GuiInfo.readLock.unlock();
+        }
+        return super.contains(px, py);
     }
-
 }

src/main/java/codechicken/nei/ItemsGrid.java

@@ -1,267 +0,0 @@
-package codechicken.nei;
-
-import codechicken.lib.vec.Rectangle4i;
-import codechicken.nei.api.GuiInfo;
-import codechicken.nei.guihook.GuiContainerManager;
-import codechicken.nei.recipe.StackInfo;
-import codechicken.nei.ItemPanel.ItemPanelSlot;
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.item.ItemStack;
-
-import java.util.ArrayList;
-
-import static codechicken.lib.gui.GuiDraw.drawRect;
-
-public class ItemsGrid
-{
-    public static final int SLOT_SIZE = 18;
-
-    protected int width;
-    protected int height;
-
-    protected int marginLeft;
-    protected int marginTop;
-
-    protected ArrayList<ItemStack> realItems = new ArrayList<>();
-
-    protected int page;
-    protected int perPage;
-
-    protected int firstIndex;
-    protected int numPages;
-
-    protected int rows;
-    protected int columns;
-
-    protected boolean[] validSlotMap;
-    protected boolean[] invalidSlotMap;
-
-    public ArrayList<ItemStack> getItems()
-    {
-        return realItems;
-    }
-
-    public ItemStack getItem(int idx)
-    {
-        return realItems.get(idx);
-    }
-
-    public int size()
-    {
-        return realItems.size();
-    }
-
-    public int indexOf(ItemStack stackA, boolean useNBT)
-    {
-
-        for (int idx = 0; idx < realItems.size(); idx++) {
-            if (StackInfo.equalItemAndNBT(stackA, realItems.get(idx), useNBT)) {
-                return idx;
-            }
-        }
-
-        return -1;
-    }
-
-    public int getPage()
-    {
-        return page + 1;
-    }
-
-    public int getPerPage()
-    {
-        return perPage;
-    }
-
-    public int getNumPages()
-    {
-        return numPages;
-    }
-
-    public int getRows()
-    {
-        return rows;
-    }
-    
-    public int getColumns()
-    {
-        return columns;
-    }
-
-    public void setGridSize(int mleft, int mtop, int w, int h)
-    {
-
-        marginLeft = mleft;
-        marginTop = mtop;
-
-        width = Math.max(0, w);
-        height = Math.max(0, h);
-
-        columns = width / SLOT_SIZE;
-        rows = height / SLOT_SIZE;
-
-    }
-
-    public void shiftPage(int shift)
-    {
-        if (perPage == 0) {
-            numPages = 0;
-            page = 0;
-            return;
-        }
-
-        numPages = (int) Math.ceil((float) realItems.size() / (float) perPage);
-
-        page += shift;
-
-        if (page >= numPages) {
-            page = page - numPages;
-        }
-
-        if (page < 0) {
-            page = numPages + page;
-        }
-
-        page = Math.max(0, Math.min(page, numPages - 1));
-    }
-
-    public void refresh(GuiContainer gui)
-    {
-        updateGuiOverlapSlots(gui);
-        shiftPage(0);
-    }
-
-    private void updateGuiOverlapSlots(GuiContainer gui)
-    {
-        invalidSlotMap = new boolean[rows * columns];
-        perPage = columns * rows;
-
-        checkGuiOverlap(gui, 0, columns - 2, 1);
-        checkGuiOverlap(gui, columns - 1, 1, -1);
-
-    }
-
-    private void checkGuiOverlap(GuiContainer gui, int start, int end, int dir)
-    {
-        boolean validColumn = false;
-
-        for (int c = start; c != end && !validColumn; c += dir) {
-            validColumn = true;
-
-            for (int r = 0; r < rows; r++) {
-                final int idx = columns * r + c;
-                if (!slotValid(gui, r, c) && idx >= 0 && idx < invalidSlotMap.length && !invalidSlotMap[idx]) {
-                    invalidSlotMap[idx] = true;
-                    validColumn = false;
-                    perPage--;
-                }
-
-            }
-
-        }
-
-    }
-
-    private boolean slotValid(GuiContainer gui, int row, int column)
-    {
-        Rectangle4i rect = getSlotRect(row, column);
-        
-        try {
-            GuiInfo.readLock.lock();
-            if (GuiInfo.guiHandlers.stream().anyMatch(handler -> handler.hideItemPanelSlot(gui, rect.x, rect.y, rect.w, rect.h))) {
-                return false;
-            }
-        } finally {
-            GuiInfo.readLock.unlock();
-        }
-
-        return true;
-    }
-
-    public Rectangle4i getSlotRect(int i)
-    {
-        return getSlotRect(i / columns, i % columns);
-    }
-
-    public Rectangle4i getSlotRect(int row, int column)
-    {
-        return new Rectangle4i(marginLeft + (width % SLOT_SIZE) / 2 + column * SLOT_SIZE, marginTop + row * SLOT_SIZE, SLOT_SIZE, SLOT_SIZE);
-    }
-
-    public boolean isInvalidSlot(int idx)
-    {
-        return invalidSlotMap[idx];
-    }
-
-    public void draw(int mousex, int mousey)
-    {
-        if (getPerPage() == 0) {
-            return;
-        }
-
-        ItemPanelSlot slot = getSlotMouseOver(mousex, mousey);
-
-        GuiContainerManager.enableMatrixStackLogging();
-
-        int idx = page * perPage;
-        for (int i = 0; i < rows * columns && idx < size(); i++) {
-
-            if (!invalidSlotMap[i]) {
-                drawItem(getSlotRect(i), idx, slot);
-                idx ++;
-            }
-
-        }
-
-        GuiContainerManager.disableMatrixStackLogging();
-    }
-
-    protected void drawItem(Rectangle4i rect, int idx, ItemPanelSlot focus)
-    {
-
-        if (focus != null && focus.slotIndex == idx) {
-            drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);//highlight
-        }
-
-        GuiContainerManager.drawItem(rect.x + 1, rect.y + 1, getItem(idx));
-    }
-
-    public ItemPanelSlot getSlotMouseOver(int mousex, int mousey)
-    {
-        if (!contains(mousex, mousey)) {
-            return null;
-        }
-
-        final int overRow = (int) ((mousey - marginTop) / SLOT_SIZE);
-        final int overColumn = (int) ((mousex - marginLeft - (width % SLOT_SIZE) / 2) / SLOT_SIZE);
-        final int slt = columns * overRow + overColumn;
-        int idx = page * perPage + slt;
-
-        if (overRow >= rows || overColumn >= columns) {
-            return null;
-        }
-
-        for (int i = 0; i < slt; i++) {
-            if (invalidSlotMap[i]) {
-                idx--;
-            }
-        }
-
-        return idx < size()? new ItemPanelSlot(idx, realItems.get(idx)): null;
-    }
-
-    public boolean contains(int px, int py)
-    {
-
-        if (!(new Rectangle4i(marginLeft, marginTop, width, height)).contains(px, py)) {
-            return false;
-        }
-
-        final int r = (int) ((py - marginTop) / SLOT_SIZE);
-        final int c = (int) ((px - marginLeft - (width % SLOT_SIZE) / 2) / SLOT_SIZE);
-        final int slt = columns * r + c;
-
-        return r >= rows || c >= columns || !invalidSlotMap[slt];
-    }
-
-}

src/main/java/codechicken/nei/LayoutManager.java

@@ -4,6 +4,7 @@ import codechicken.lib.gui.GuiDraw;
 import codechicken.nei.KeyManager.IKeyStateTracker;
 import codechicken.nei.api.API;
 import codechicken.nei.api.GuiInfo;
+import codechicken.nei.api.INEIGuiHandler;
 import codechicken.nei.api.IRecipeOverlayRenderer;
 import codechicken.nei.api.ItemInfo;
 import codechicken.nei.api.LayoutStyle;
@@ -15,7 +16,7 @@ import codechicken.nei.guihook.IContainerInputHandler;
 import codechicken.nei.guihook.IContainerObjectHandler;
 import codechicken.nei.guihook.IContainerTooltipHandler;
 import codechicken.nei.recipe.GuiRecipeTab;
-import codechicken.nei.recipe.RecipeCatalysts;
+import cpw.mods.fml.common.Loader;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.inventory.GuiContainer;
@@ -62,6 +63,7 @@ import static codechicken.nei.NEIClientUtils.getNextGamemode;
 import static codechicken.nei.NEIClientUtils.healPlayer;
 import static codechicken.nei.NEIClientUtils.isValidGamemode;
 import static codechicken.nei.NEIClientUtils.setHourForward;
+import static codechicken.nei.NEIClientUtils.setItemQuantity;
 import static codechicken.nei.NEIClientUtils.shiftKey;
 import static codechicken.nei.NEIClientUtils.toggleMagnetMode;
 import static codechicken.nei.NEIClientUtils.toggleRaining;
@@ -86,7 +88,6 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
     public static ItemPanel itemPanel;
     public static BookmarkPanel bookmarkPanel;
     public static SubsetWidget dropDown;
-    public static PresetsWidget presetsPanel;
     public static TextField searchField;
 
     public static ButtonCycled options;
@@ -178,7 +179,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
     @Override
     public boolean objectUnderMouse(GuiContainer gui, int mousex, int mousey) {
         if (!isHidden() && isEnabled())
-            for (Widget widget : drawWidgets)
+            for (Widget widget : controlWidgets)
                 if (widget.contains(mousex, mousey))
                     return true;
 
@@ -239,7 +240,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
     @Override
     public ItemStack getStackUnderMouse(GuiContainer gui, int mousex, int mousey) {
         if (!isHidden() && isEnabled()) {
-            for (Widget widget : drawWidgets) {
+            for (Widget widget : controlWidgets) {
                 ItemStack stack = widget.getStackMouseOver(mousex, mousey);
                 if (stack != null)
                     return stack;
@@ -264,7 +265,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
             GL11.glEnable(GL11.GL_DEPTH_TEST);
         }
     }
-
+    
     @Override
     public void postRenderObjects(GuiContainer gui, int mousex, int mousey) {
         if (!isHidden() && isEnabled()) {
@@ -276,7 +277,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
     @Override
     public List<String> handleTooltip(GuiContainer gui, int mousex, int mousey, List<String> currenttip) {
         if (!isHidden() && isEnabled() && GuiContainerManager.shouldShowTooltip(gui)) {
-            for (Widget widget : drawWidgets)
+            for (Widget widget : controlWidgets)
                 currenttip = widget.handleTooltip(mousex, mousey, currenttip);
         }
         return currenttip;
@@ -309,19 +310,13 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         VisiblityData visiblity = new VisiblityData();
         if (isHidden())
             visiblity.showNEI = false;
-
+        
         if (isBookmarkPanelHidden())
             visiblity.showBookmarkPanel = false;
-
+        
         if (gui.height - gui.ySize <= 40)
             visiblity.showSearchSection = false;
-
-        if (visiblity.showBookmarkPanel || gui.guiTop <= 20)
-            visiblity.showSubsetDropdown = false;
-
-        if (!visiblity.showBookmarkPanel || gui.guiTop <= 20)
-            visiblity.showPresetsDropdown = false;
-
+        
         if (gui.guiLeft - 4 < 76)
             visiblity.showWidgets = false;
         try {
@@ -330,7 +325,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         } finally {
             GuiInfo.readLock.unlock();
         }
-
+        
         visiblity.translateDependancies();
 
         getLayoutStyle().layout(gui, visiblity);
@@ -346,7 +341,6 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         bookmarkPanel.init();
 
         dropDown = new SubsetWidget();
-        presetsPanel = new PresetsWidget();
         searchField = new SearchField("search");
 
         options = new ButtonCycled(3)
@@ -357,7 +351,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
                 this.icons[1] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 48, 0, 16, 16).build();
                 this.icons[2] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 64, 0, 16, 16).build();
             }
-
+            
             @Override
             public boolean onButtonPress(boolean rightclick) {
                 if (!rightclick) {
@@ -366,7 +360,6 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
                     } else {
                         if (Keyboard.getEventKeyState() && (Keyboard.getEventKey() == Keyboard.KEY_LSHIFT || Keyboard.getEventKey() == Keyboard.KEY_RSHIFT)) {
                             GuiRecipeTab.loadHandlerInfo();
-                            RecipeCatalysts.loadCatalystInfo();
                         }
                         getOptionList().openGui(getGuiContainer(), false);
                     }
@@ -374,7 +367,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
                 }
                 return false;
             }
-
+            
             @Override
             public void addTooltips(List<String> tooltip) {
                 tooltip.add(translate("inventory.options.tip"));
@@ -387,9 +380,9 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
                 String controlKeyLocalization = translate(Minecraft.isRunningOnMac ? "key.ctrl.mac" : "key.ctrl");
                 tooltip.add(modeColor + translate("inventory.options.tip.cheatmode." + cheatMode));
                 tooltip.add(modeColor + translate("inventory.options.tip.cheatmode.disable", controlKeyLocalization));
-
+                
             }
-
+            
             @Override
             public String getRenderLabel() {
                 return translate("inventory.options");
@@ -403,7 +396,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
                 this.icons[0] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 0, 0, 16, 16).build();
                 this.icons[1] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 16, 0, 16, 16).build();
             }
-
+            
             @Override
             public boolean onButtonPress(boolean rightclick) {
                 NEIClientConfig.toggleBooleanSetting("inventory.bookmarksEnabled");
@@ -626,7 +619,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
 
         return true;
     }
-
+    
     public static void markItemsDirty() {
         // If anything has modified data this depends on, we'll need to reload the item list
         itemsLoaded = false;
@@ -679,13 +672,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         addWidget(options);
         addWidget(bookmarksButton);
         if (visiblity.showItemPanel) {
-
-            if (PresetsWidget.inEditMode()) {
-                drawWidgets.add(itemPanel);
-            } else {
-                addWidget(itemPanel);
-            }
-
+            addWidget(itemPanel);
             itemPanel.setVisible();
 
             addWidget(more);
@@ -696,11 +683,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         if (visiblity.showBookmarkPanel) {
             addWidget(bookmarkPanel);
             bookmarkPanel.setVisible();
-        }
-
-        if (visiblity.showPresetsDropdown) {
-            addWidget(presetsPanel);
-        }
+        } 
 
         if (visiblity.showSearchSection) {
             addWidget(searchField);
@@ -724,8 +707,8 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
             if (canPerformAction("delete"))
                 addWidget(delete);
         }
-
-        if (visiblity.showSubsetDropdown) {
+        
+        if (!visiblity.showBookmarkPanel) {
             // Bookmarks or Subset/dropdown
             addWidget(dropDown);
         }
@@ -756,7 +739,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         if (!isEnabled())
             return;
 
-        for (Widget widget : drawWidgets)
+        for (Widget widget : controlWidgets)
             widget.update();
     }
 
@@ -765,7 +748,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         if (isHidden() || !isEnabled())
             return false;
 
-        for (Widget widget : drawWidgets)
+        for (Widget widget : controlWidgets)
             if (widget.onMouseWheel(scrolled, mousex, mousey))
                 return true;
 
@@ -778,7 +761,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
 
     @Override
     public boolean shouldShowTooltip(GuiContainer gui) {
-        return itemPanel.draggedStack == null && bookmarkPanel.sortedStackIndex == -1;
+        return itemPanel.draggedStack == null;
     }
 
     /** Note: this method isn't actually used by this mod, but NEI add-ons might need it. */
@@ -816,16 +799,16 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
 
     public static void drawIcon(int x, int y, Image image) {
         final boolean isDrawableResource = image instanceof DrawableResource;
-
+        
         if (!isDrawableResource)
             changeTexture("nei:textures/nei_sprites.png");
-
+        
         GL11.glColor4f(1, 1, 1, 1);
         GL11.glEnable(GL11.GL_BLEND);
         GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
         if(!isDrawableResource)
             drawTexturedModalRect(x, y, image.x, image.y, image.width, image.height);
-        else
+        else 
             ((DrawableResource)image).draw(x, y);
         GL11.glDisable(GL11.GL_BLEND);
     }
@@ -901,3 +884,4 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
     }
 
 }
+

src/main/java/codechicken/nei/LayoutStyleMinecraft.java

@@ -119,7 +119,7 @@ public class LayoutStyleMinecraft extends LayoutStyle
         bookmarkPanel.resize(gui);
 
         more.w = more.h = less.w = less.h = 16;
-        less.x = itemPanel.pagePrev.x;
+        less.x = itemPanel.prev.x;
         more.x = gui.width - less.w - 2;
         more.y = less.y = gui.height - more.h - 2;
 

src/main/java/codechicken/nei/NEIClientConfig.java

@@ -27,8 +27,8 @@ import codechicken.nei.config.OptionUtilities;
 import codechicken.nei.event.NEIConfigsLoadedEvent;
 import codechicken.nei.recipe.GuiRecipeTab;
 import codechicken.nei.recipe.IRecipeHandler;
-import codechicken.nei.recipe.RecipeCatalysts;
 import codechicken.nei.recipe.RecipeInfo;
+import codechicken.nei.recipe.TemplateRecipeHandler;
 import codechicken.obfuscator.ObfuscationRun;
 import com.google.common.base.Objects;
 import net.minecraft.client.Minecraft;
@@ -48,12 +48,10 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.function.Function;
-import java.util.regex.Pattern;
 
 public class NEIClientConfig {
     private static boolean configLoaded;
     private static boolean enabledOverride;
-    private static String worldPath;
 
     public static Logger logger = LogManager.getLogger("NotEnoughItems");
     public static File configDir = new File(CommonUtils.getMinecraftDir(), "config/NEI/");
@@ -61,21 +59,17 @@ public class NEIClientConfig {
             new File("saves/NEI/client.dat"),
             new ConfigFile(new File(configDir, "client.cfg")));
     public static ConfigSet world;
+    public static final File bookmarkFile = new File(configDir, "bookmarks.ini");
     public static final File handlerFile = new File(configDir, "handlers.csv");
-    public static final File catalystFile = new File(configDir, "catalysts.csv");
     public static final File serialHandlersFile = new File(configDir, "serialhandlers.cfg");
     public static final File heightHackHandlersFile = new File(configDir, "heighthackhandlers.cfg");
     public static final File handlerOrderingFile = new File(configDir, "handlerordering.csv");
 
-    @Deprecated
-    public static File bookmarkFile;
-
     // Set of handlers that need to be run in serial
     public static HashSet<String> serialHandlers = new HashSet<>();
 
-    // Set of regexes matching handler ID of handlers that need the hack in GuiRecipe.startHeightHack().
-    // We use regex here so that we can apply the height hack to entire mods with one entry.
-    public static HashSet<Pattern> heightHackHandlerRegex = new HashSet<>();
+    // Set of handler ID of handlers that need the hack in GuiRecipe.startHeightHack().
+    public static HashSet<String> heightHackHandlers = new HashSet<>();
 
     // Map of handler ID to sort order.
     // Handlers will be sorted in ascending order, so smaller numbers show up earlier.
@@ -85,9 +79,11 @@ public class NEIClientConfig {
     // Function that extracts the handler ID from a handler, with special logic for
     // TemplateRecipeHandler: prefer using the overlay ID if it exists.
     public static final Function<IRecipeHandler, String> HANDLER_ID_FUNCTION =
-            handler -> Objects.firstNonNull(
-                            handler.getOverlayIdentifier(),
-                            handler.getHandlerId());
+            handler -> handler instanceof TemplateRecipeHandler
+                    ? Objects.firstNonNull(
+                            ((TemplateRecipeHandler) handler).getOverlayIdentifier(),
+                            handler.getHandlerId())
+                    : handler.getHandlerId();
 
     // Comparator that compares handlers using the handlerOrdering map.
     public static final Comparator<IRecipeHandler> HANDLER_COMPARATOR =
@@ -121,7 +117,7 @@ public class NEIClientConfig {
 
         tag.getTag("inventory.widgetsenabled").getBooleanValue(true);
         API.addOption(new OptionToggleButton("inventory.widgetsenabled"));
-
+        
         tag.getTag("inventory.hidden").getBooleanValue(false);
         tag.getTag("inventory.cheatmode").getIntValue(2);
         tag.getTag("inventory.lockmode").setComment("For those who can't help themselves.\nSet this to a mode and you will be unable to change it ingame").getIntValue(-1);
@@ -167,8 +163,6 @@ public class NEIClientConfig {
                 return isMouseScrollTransferEnabled();
             }
         });
-        
-        tag.getTag("itemLoadingTimeout").getIntValue(500);
 
         tag.getTag("command.creative").setDefaultValue("/gamemode {0} {1}");
         API.addOption(new OptionTextField("command.creative"));
@@ -180,42 +174,14 @@ public class NEIClientConfig {
         API.addOption(new OptionTextField("command.rain"));
         tag.getTag("command.heal").setDefaultValue("");
         API.addOption(new OptionTextField("command.heal"));
-
-        tag.getTag("inventory.worldSpecificBookmarks").setComment("Global or world specific bookmarks").getBooleanValue(false);
-        API.addOption(new OptionToggleButton("inventory.worldSpecificBookmarks", true) {
-            @Override
-            public boolean onClick(int button) {
-                super.onClick(button);
-                initBookmarkFile(worldPath);
-                return true;
-            }
-        });
-
-        tag.getTag("inventory.worldSpecificPresets").setComment("Global or world specific presets").getBooleanValue(false);
-        API.addOption(new OptionToggleButton("inventory.worldSpecificPresets", true) {
-            @Override
-            public boolean onClick(int button) {
-                super.onClick(button);
-                initPresetsFile(worldPath);
-                return true;
-            }
-        });
-
+        
         tag.getTag("inventory.bookmarksEnabled").setComment("Enable/disable bookmarks").getBooleanValue(true);
         API.addOption(new OptionToggleButton("inventory.bookmarksEnabled", true));
-        tag.getTag("inventory.saveCurrentRecipeInBookmarksEnabled").setComment("Save Current Recipe in Bookmarks").getBooleanValue(true);
-        API.addOption(new OptionToggleButton("inventory.saveCurrentRecipeInBookmarksEnabled", true));
-        tag.getTag("inventory.useNBTInBookmarks").setComment("Use NBT in Bookmarks").getBooleanValue(true);
-        API.addOption(new OptionToggleButton("inventory.useNBTInBookmarks", true));
-
         tag.getTag("inventory.jei_style_tabs").setComment("Enable/disable JEI Style Tabs").getBooleanValue(true);
         API.addOption(new OptionToggleButtonBoubs("inventory.jei_style_tabs", true));
         tag.getTag("inventory.jei_style_item_presence_overlay").setComment("Enable/disable JEI Style item presence overlay on ?-hover").getBooleanValue(true);
         API.addOption(new OptionToggleButton("inventory.jei_style_item_presence_overlay", true));
-        tag.getTag("inventory.jei_style_recipe_catalyst").setComment("Enable/disable JEI Style Recipe Catalysts").getBooleanValue(true);
-        API.addOption(new OptionToggleButton("inventory.jei_style_recipe_catalyst", true));
-
-
+        
         tag.getTag("inventory.creative_tab_style").setComment("Creative or JEI style tabs").getBooleanValue(false);
         API.addOption(new OptionToggleButton("inventory.creative_tab_style", true));
 
@@ -228,17 +194,6 @@ public class NEIClientConfig {
                 return true;
             }
         });
-
-        tag.getTag("tools.catalyst_load_from_config").setComment("ADVANCED: Load catalysts from config").getBooleanValue(false);
-        API.addOption(new OptionToggleButton("tools.catalyst_load_from_config", true) {
-            @Override
-            public boolean onClick(int button) {
-                super.onClick(button);
-                RecipeCatalysts.loadCatalystInfo();
-                return true;
-            }
-        });
-
         setDefaultKeyBindings();
     }
 
@@ -299,23 +254,17 @@ public class NEIClientConfig {
         return OptionList.getOptionList("nei.options");
     }
 
-    public static void loadWorld(String worldPath) {
-        NEIClientConfig.worldPath = worldPath;
-
+    public static void loadWorld(String saveName) {
         setInternalEnabled(true);
         logger.debug("Loading "+(Minecraft.getMinecraft().isSingleplayer() ? "Local" : "Remote")+" World");
         bootNEI(ClientUtils.getWorld());
 
-        final File specificDir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + worldPath);
-        final boolean newWorld = !specificDir.exists();
+        File saveDir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + saveName);
+        boolean newWorld = !saveDir.exists();
+        if (newWorld)
+            saveDir.mkdirs();
 
-        if (newWorld) {
-            specificDir.mkdirs();
-        }
-
-        initBookmarkFile(worldPath);
-        initPresetsFile(worldPath);
-        world = new ConfigSet(new File(specificDir, "NEI.dat"), new ConfigFile(new File(specificDir, "NEI.cfg")));
+        world = new ConfigSet(new File(saveDir, "NEI.dat"), new ConfigFile(new File(saveDir, "NEI.cfg")));
         onWorldLoad(newWorld);
     }
 
@@ -359,8 +308,8 @@ public class NEIClientConfig {
         GuiInfo.load();
         RecipeInfo.load();
         LayoutManager.load();
+        ItemPanels.bookmarkPanel.loadBookmarks();
         NEIController.load();
-        RecipeCatalysts.loadCatalystInfo();
 
         configLoaded = true;
 
@@ -388,26 +337,6 @@ public class NEIClientConfig {
         ItemSorter.loadConfig();
     }
 
-    private static void initBookmarkFile(String worldPath)
-    {
-        
-        if (!global.config.getTag("inventory.worldSpecificBookmarks").getBooleanValue()) {
-            worldPath = "global";
-        }
-
-        ItemPanels.bookmarkPanel.setBookmarkFile(worldPath);
-    }
-
-    private static void initPresetsFile(String worldPath)
-    {
-        
-        if (!global.config.getTag("inventory.worldSpecificPresets").getBooleanValue()) {
-            worldPath = "global";
-        }
-
-        PresetsWidget.loadPresets(worldPath);
-    }
-
     public static boolean isWorldSpecific(String setting) {
         if(world == null) return false;
         ConfigTag tag = world.config.getTag(setting, false);
@@ -428,21 +357,12 @@ public class NEIClientConfig {
     public static boolean isBookmarkPanelHidden() {
         return !getBooleanSetting("inventory.bookmarksEnabled");
     }
-    public static boolean saveCurrentRecipeInBookmarksEnabled() {
-        return getBooleanSetting("inventory.saveCurrentRecipeInBookmarksEnabled");
-    }
-    public static boolean useNBTInBookmarks() {
-        return getBooleanSetting("inventory.useNBTInBookmarks");
-    }
     public static boolean areJEIStyleTabsVisible() {
         return getBooleanSetting("inventory.jei_style_tabs");
     }
     public static boolean isJEIStyleItemPresenceOverlayVisible() {
         return getBooleanSetting("inventory.jei_style_item_presence_overlay");
     }
-    public static boolean areJEIStyleRecipeCatalystsVisible() {
-        return getBooleanSetting("inventory.jei_style_recipe_catalyst");
-    }
     public static boolean useCreativeTabStyle() {
         return getBooleanSetting("inventory.creative_tab_style");
     }
@@ -450,10 +370,7 @@ public class NEIClientConfig {
         return enabledOverride && getBooleanSetting("inventory.widgetsenabled");
     }
     public static boolean loadHandlersFromJar() {
-        return !getBooleanSetting("tools.handler_load_from_config");
-    }
-    public static boolean loadCatalystsFromJar() {
-        return !getBooleanSetting("tools.catalyst_load_from_config");
+        return !getBooleanSetting("tools.handler_load_from_config"); 
     }
 
     public static void setEnabled(boolean flag) {
@@ -489,10 +406,6 @@ public class NEIClientConfig {
         int i = getIntSetting("inventory.itemIDs");
         return i == 2 || (i == 1 && isEnabled() && !isHidden());
     }
-    
-    public static int getItemLoadingTimeout() {
-        return getIntSetting("itemLoadingTimeout");
-    }
 
     public static void toggleBooleanSetting(String setting) {
         ConfigTag tag = getSetting(setting);
@@ -528,7 +441,7 @@ public class NEIClientConfig {
     public static boolean shouldInvertMouseScrollTransfer() {
         return !getBooleanSetting("inventory.invertMouseScrollTransfer");
     }
-
+    
     public static boolean getMagnetMode() {
         return enabledActions.contains("magnet");
     }
@@ -615,5 +528,5 @@ public class NEIClientConfig {
             if (file.isDirectory() && !saveFileNames.contains(file.getName()))
                 ObfuscationRun.deleteDir(file, true);
     }
-
+    
 }

src/main/java/codechicken/nei/NEIClientUtils.java

@@ -5,6 +5,7 @@ import codechicken.lib.inventory.InventoryUtils;
 import codechicken.lib.util.LangProxy;
 import codechicken.nei.api.GuiInfo;
 import codechicken.nei.api.IInfiniteItemHandler;
+import codechicken.nei.api.INEIGuiHandler;
 import codechicken.nei.api.ItemInfo;
 import com.google.common.collect.Iterables;
 import net.minecraft.client.Minecraft;
@@ -135,7 +136,10 @@ public class NEIClientUtils extends NEIServerUtils
             if (mode == 1 && stack.stackSize < stack.getMaxStackSize()) {
                 giveStack(stack, stack.getMaxStackSize() - stack.stackSize);
             } else {
-                giveStack(stack);
+                int amount = getItemQuantity();
+                if (amount == 0)
+                    amount = stack.getMaxStackSize();
+                giveStack(stack, amount);
             }
         }
     }
@@ -157,10 +161,7 @@ public class NEIClientUtils extends NEIServerUtils
                 final List<Iterable<Integer>> handlerSlots;
                 try {
                     GuiInfo.readLock.lock();
-                    handlerSlots = GuiInfo.guiHandlers.stream()
-                        .map(handler -> handler.getItemSpawnSlots(gui, typestack))
-                        .filter(x -> x != null)
-                        .collect(Collectors.toCollection(LinkedList::new));
+                    handlerSlots = GuiInfo.guiHandlers.stream().map(handler -> handler.getItemSpawnSlots(gui, typestack)).collect(Collectors.toCollection(LinkedList::new));
                 } finally {
                     GuiInfo.readLock.unlock();
                 }

src/main/java/codechicken/nei/NEIController.java

@@ -137,7 +137,6 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
         }
 
         if (NEIClientUtils.controlKey()
-                && modifier != 4//Drop key pressed: net.minecraft.client.gui.inventory.GuiContainer.keyTyped
                 && slot != null && slot.getStack() != null
                 && slot.isItemValid(slot.getStack())) {
             NEIClientUtils.cheatItem(slot.getStack(), button, 1);

src/main/java/codechicken/nei/NEIModContainer.java

@@ -6,14 +6,13 @@ import codechicken.nei.api.IConfigureNEI;
 import codechicken.nei.asm.NEICorePlugin;
 import codechicken.nei.config.IMCHandler;
 import codechicken.nei.recipe.GuiRecipeTab;
-import codechicken.nei.recipe.RecipeCatalysts;
 import com.google.common.eventbus.EventBus;
 import com.google.common.eventbus.Subscribe;
 import cpw.mods.fml.client.FMLFileResourcePack;
 import cpw.mods.fml.client.FMLFolderResourcePack;
 import cpw.mods.fml.common.DummyModContainer;
 import cpw.mods.fml.common.LoadController;
-import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.MetadataCollection;
 import cpw.mods.fml.common.ModMetadata;
 import cpw.mods.fml.common.event.FMLInitializationEvent;
 import cpw.mods.fml.common.event.FMLInterModComms;
@@ -25,14 +24,15 @@ import cpw.mods.fml.common.versioning.VersionRange;
 import net.minecraft.util.EnumChatFormatting;
 
 import java.io.File;
-import java.util.*;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
 
 public class NEIModContainer extends DummyModContainer
 {
     public static LinkedList<IConfigureNEI> plugins = new LinkedList<>();
 
-    private static boolean gregTech5Loaded;
-
     public NEIModContainer() {
         super(getModMetadata());
         loadMetadata();
@@ -43,16 +43,9 @@ public class NEIModContainer extends DummyModContainer
         modMetadata.name = "GRADLETOKEN_MODNAME";
         modMetadata.modId = "GRADLETOKEN_MODID";
         modMetadata.version = "GRADLETOKEN_VERSION";
-        modMetadata.authorList = Arrays.asList( "ChickenBones", "mitchej123" );
-        modMetadata.url = "https://github.com/GTNewHorizons/NotEnoughItems";
-        modMetadata.description = "Recipe Viewer, Inventory Manager, Item Spawner, Cheats and more; GTNH Version includes many enhancements.";
         return modMetadata;
     }
 
-    public static boolean isGT5Loaded() {
-        return gregTech5Loaded;
-    }
-
     @Override
     public Set<ArtifactVersion> getRequirements() {
         Set<ArtifactVersion> deps = new HashSet<>();
@@ -99,7 +92,6 @@ public class NEIModContainer extends DummyModContainer
 
     @Subscribe
     public void preInit(FMLPreInitializationEvent event) {
-        gregTech5Loaded = Loader.isModLoaded("gregtech") && !Loader.isModLoaded("gregapi_post");
         if (CommonUtils.isClient())
             ClientHandler.preInit();
     }

src/main/java/codechicken/nei/NEIServerUtils.java

@@ -5,9 +5,6 @@ import codechicken.core.ServerUtils;
 import codechicken.lib.inventory.InventoryRange;
 import codechicken.lib.inventory.InventoryUtils;
 import codechicken.lib.packet.PacketCustom;
-import codechicken.nei.util.NBTHelper;
-import cpw.mods.fml.common.FMLLog;
-import cpw.mods.fml.common.registry.GameRegistry;
 import net.minecraft.command.ICommandSender;
 import net.minecraft.enchantment.Enchantment;
 import net.minecraft.entity.player.EntityPlayer;
@@ -17,9 +14,6 @@ import net.minecraft.inventory.Slot;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.CompressedStreamTools;
-import net.minecraft.nbt.JsonToNBT;
-import net.minecraft.nbt.NBTBase;
-import net.minecraft.nbt.NBTException;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTTagList;
 import net.minecraft.server.MinecraftServer;
@@ -30,7 +24,6 @@ import net.minecraft.world.World;
 import net.minecraft.world.WorldServer;
 import net.minecraft.world.WorldSettings.GameType;
 import net.minecraftforge.oredict.OreDictionary;
-import org.apache.logging.log4j.Level;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -150,19 +143,6 @@ public class NEIServerUtils
                 ItemStack.areItemStackTagsEqual(stack2, stack1));
     }
 
-    /**
-     * NBT-friendly version of {@link #areStacksSameType(ItemStack, ItemStack)}
-     * @param stack1 The {@link ItemStack} being compared.
-     * @param stack2 The {@link ItemStack} to compare to.
-     * @return whether the two items are the same in terms of itemID, damage and NBT.
-     */
-    public static boolean areStacksSameTypeWithNBT(ItemStack stack1, ItemStack stack2) {
-        return stack1 != null && stack2 != null &&
-                stack1.getItem() == stack2.getItem() &&
-                (!stack2.getHasSubtypes() || stack2.getItemDamage() == stack1.getItemDamage()) &&
-                NBTHelper.matchTag(stack1.getTagCompound(), stack2.getTagCompound());
-    }
-
     /**
      * {@link ItemStack}s with damage -1 are wildcards allowing all damages. Eg all colours of wool are allowed to create Beds.
      *
@@ -176,24 +156,6 @@ public class NEIServerUtils
                 (stack1.getItemDamage() == stack2.getItemDamage() || stack1.getItemDamage() == OreDictionary.WILDCARD_VALUE || stack2.getItemDamage() == OreDictionary.WILDCARD_VALUE || stack1.getItem().isDamageable());
     }
 
-    /**
-     * NBT-friendly version of {@link #areStacksSameTypeCrafting(ItemStack, ItemStack)}
-     * @param stack1 The {@link ItemStack} being compared.
-     * @param stack2 The {@link ItemStack} to compare to.
-     * @return whether the two items are the same from the perspective of a crafting inventory.
-     */
-    public static boolean areStacksSameTypeCraftingWithNBT(ItemStack stack1, ItemStack stack2) {
-        return stack1 != null && stack2 != null &&
-                stack1.getItem() == stack2.getItem() &&
-                (
-                    stack1.getItemDamage() == stack2.getItemDamage() ||
-                    stack1.getItemDamage() == OreDictionary.WILDCARD_VALUE ||
-                    stack2.getItemDamage() == OreDictionary.WILDCARD_VALUE ||
-                    stack1.getItem().isDamageable()
-                ) &&
-                NBTHelper.matchTag(stack1.getTagCompound(), stack2.getTagCompound());
-    }
-
     /**
      * A simple function for comparing ItemStacks in a compatible with comparators.
      *
@@ -425,50 +387,6 @@ public class NEIServerUtils
         }
     }
 
-    public static ItemStack getModdedItem(String itemId, String nbtString) {
-        int meta = -1;
-        ItemStack itemStack;
-
-        if (!itemId.contains(":")) {
-            NEIClientConfig.logger.info(String.format("Item ID %s is missing colon", itemId));
-            return null;
-        }
-        final String[] split = itemId.split(":");
-        // ModID:ItemID
-        String itemLookupId = split[0] + ":" + split[1];
-
-        if (split.length >= 3) {
-            int mIdx = -1;
-            if (split[2].matches("\\d+")) {
-                mIdx = 2;
-            } else {
-                itemLookupId += ":" + split[2];
-                if (split.length >= 4) mIdx = 3;
-            }
-            if (mIdx != -1) meta = Integer.parseInt(split[mIdx]);
-        }
-
-        if (meta != -1) {
-            itemStack = GameRegistry.makeItemStack(itemLookupId, meta, 1, nbtString == null ? "" : nbtString);
-        } else {
-            itemStack = GameRegistry.findItemStack(split[0], split[1], 1);
-            if (nbtString != null && !nbtString.isEmpty()) {
-                try {
-                    final NBTBase nbttag = JsonToNBT.func_150315_a(nbtString);
-                    if (!(nbttag instanceof NBTTagCompound)) {
-                        NEIClientConfig.logger.info("Unexpected NBT string - multiple values {}", nbtString);
-                        return null;
-                    }
-                    itemStack.setTagCompound((NBTTagCompound) nbttag);
-                } catch (NBTException e) {
-                    FMLLog.getLogger().log(Level.WARN, "Encountered an exception parsing ItemStack NBT string {}", nbtString, e);
-                    return null;
-                }
-            }
-        }
-        return itemStack;
-    }
-
     public static NBTTagCompound readNBT(File file) throws IOException {
         if(!file.exists()) return null;
         FileInputStream in = new FileInputStream(file);
@@ -490,8 +408,4 @@ public class NEIServerUtils
         CompressedStreamTools.writeCompressed(tag, out);
         out.close();
     }
-
-    public static int divideCeil(int numerator, int denominator) {
-        return (int) Math.ceil((float) numerator / denominator);
-    }
 }

src/main/java/codechicken/nei/PositionedStack.java

@@ -98,17 +98,6 @@ public class PositionedStack
         return false;
     }
 
-    /**
-     * NBT-friendly version of {@link #contains(ItemStack)}
-     */
-    public boolean containsWithNBT(ItemStack ingredient) {
-        for(ItemStack item : items)
-            if(NEIServerUtils.areStacksSameTypeCraftingWithNBT(item, ingredient))
-                return true;
-
-        return false;
-    }
-
     public boolean contains(Item ingred) {
         for(ItemStack item : items)
             if(item.getItem() == ingred)

src/main/java/codechicken/nei/SearchField.java

@@ -63,9 +63,8 @@ public class SearchField extends TextField implements ItemFilterProvider
     }
 
     @Override
-    public int getTextColour()
-    {
-        if (ItemPanels.itemPanel.getItems().isEmpty()) {
+    public int getTextColour() {
+        if(ItemPanels.itemPanel.realItems.size() == 0) {
             return focused() ? 0xFFcc3300 : 0xFF993300;
         } else {
             return focused() ? 0xFFE0E0E0 : 0xFF909090;

src/main/java/codechicken/nei/VisiblityData.java

@@ -11,14 +11,6 @@ public class VisiblityData
      * Bookmark panel and associated buttons
      */
     public boolean showBookmarkPanel = true;
-    /**
-     * Subset dropdown
-     */
-    public boolean showSubsetDropdown = true;
-    /**
-     * Presets dropdown
-     */
-    public boolean showPresetsDropdown = true;
     /**
      * Item and search section
      */
@@ -48,6 +40,6 @@ public class VisiblityData
         if(!showWidgets)
             showItemSection = showUtilityButtons = false;
         if(!showItemSection)
-            showBookmarkPanel = showSubsetDropdown = showPresetsDropdown = showSearchSection = showItemPanel = false;
+            showBookmarkPanel = showSearchSection = showItemPanel = false;
     }
 }

src/main/java/codechicken/nei/WorldOverlayRenderer.java

@@ -15,13 +15,10 @@ import net.minecraft.world.biome.BiomeGenBase;
 import net.minecraft.world.chunk.Chunk;
 import org.lwjgl.opengl.GL11;
 
-public class WorldOverlayRenderer implements IKeyStateTracker {
-
-    public static int chunkOverlay = 0;
-
+public class WorldOverlayRenderer implements IKeyStateTracker
+{
     public static int mobOverlay = 0;
-    private static byte[] mobSpawnCache;
-    private static long mobOverlayUpdateTime;
+    public static int chunkOverlay = 0;
 
     public static void reset() {
         mobOverlay = 0;
@@ -36,7 +33,7 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
         if (KeyManager.keyStates.get("world.moboverlay").down)
             mobOverlay = (mobOverlay + 1) % 2;
         if (KeyManager.keyStates.get("world.chunkoverlay").down)
-            chunkOverlay = (chunkOverlay + 1) % (NEIModContainer.isGT5Loaded() ? 4 : 3);
+            chunkOverlay = (chunkOverlay + 1) % 3;
     }
 
     public static void render(float frame) {
@@ -49,56 +46,9 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
         GL11.glPopMatrix();
     }
 
-    private static void buildMobSpawnOverlay(Entity entity) {
-        if (mobSpawnCache == null) {
-            mobSpawnCache = new byte[33 * 33 * 33]; // 35kB
-        }
-
-        World world = entity.worldObj;
-        int x1 = (int) entity.posX;
-        int z1 = (int) entity.posZ;
-        int y1 = (int) MathHelper.clip(entity.posY, 16, world.getHeight() - 16);
-
-        for (int i = 0; i <= 32; i++) {
-            int x = x1 - 16 + i;
-            for (int j = 0; j <= 32; j++) {
-                int z = z1 - 16 + j;
-                int bufIndex = (i * 33 + j) * 33;
-
-                Chunk chunk = world.getChunkFromBlockCoords(x, z);
-                BiomeGenBase biome = world.getBiomeGenForCoords(x, z);
-                if (biome.getSpawnableList(EnumCreatureType.monster).isEmpty() || biome.getSpawningChance() <= 0) {
-                    mobSpawnCache[bufIndex] = -1;
-                    continue;
-                }
-
-                int maxHeight = chunk.worldObj.getHeightValue(x, z);
-
-                for (int k = 0; k <= 32; k++) {
-                    int y = y1 - 16 + k;
-                    if (y > maxHeight) {
-                        mobSpawnCache[bufIndex + k] = -1;
-                        break;
-                    }
-                    mobSpawnCache[bufIndex + k] = getSpawnMode(chunk, x, y, z);
-                }
-            }
-        }
-    }
-
     private static void renderMobSpawnOverlay(Entity entity) {
-        if (mobOverlay == 0) {
-            if (mobSpawnCache != null) {
-                mobSpawnCache = null;
-            }
+        if (mobOverlay == 0)
             return;
-        }
-
-        long worldTime = entity.worldObj.getTotalWorldTime();
-        if (mobSpawnCache == null || mobOverlayUpdateTime != worldTime) {
-            mobOverlayUpdateTime = worldTime;
-            buildMobSpawnOverlay(entity);
-        }
 
         GL11.glDisable(GL11.GL_TEXTURE_2D);
         GL11.glEnable(GL11.GL_BLEND);
@@ -115,37 +65,32 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
         int z1 = (int) entity.posZ;
         int y1 = (int) MathHelper.clip(entity.posY, 16, world.getHeight() - 16);
 
-        for (int i = 0; i <= 32; i++) {
-            int x = x1 - 16 + i;
-            for (int j = 0; j <= 32; j++) {
-                int z = z1 - 16 + j;
-                int cacheIndex = (i * 33 + j) * 33;
+        for (int x = x1 - 16; x <= x1 + 16; x++)
+            for (int z = z1 - 16; z <= z1 + 16; z++) {
+                Chunk chunk = world.getChunkFromBlockCoords(x, z);
+                BiomeGenBase biome = world.getBiomeGenForCoords(x, z);
+                if (biome.getSpawnableList(EnumCreatureType.monster).isEmpty() || biome.getSpawningChance() <= 0)
+                    continue;
 
-                for (int k = 0; k <= 32; k++) {
-                    int y = y1 - 16 + k;
-                    int spawnMode = mobSpawnCache[cacheIndex + k];
-                    if (spawnMode == 0) {
+                for (int y = y1 - 16; y < y1 + 16; y++) {
+                    int spawnMode = getSpawnMode(chunk, x, y, z);
+                    if (spawnMode == 0)
                         continue;
-                    } else if (spawnMode == -1) {
-                        break;
-                    }
 
                     if (spawnMode != curSpawnMode) {
-                        if (spawnMode == 1) {
+                        if (spawnMode == 1)
                             GL11.glColor4f(1, 1, 0, 1);
-                        } else {
+                        else
                             GL11.glColor4f(1, 0, 0, 1);
-                        }
                         curSpawnMode = spawnMode;
                     }
 
-                    GL11.glVertex3d(x, y + 0.02, z);
-                    GL11.glVertex3d(x + 1, y + 0.02, z + 1);
-                    GL11.glVertex3d(x + 1, y + 0.02, z);
-                    GL11.glVertex3d(x, y + 0.02, z + 1);
+                    GL11.glVertex3d(x, y + 0.004, z);
+                    GL11.glVertex3d(x + 1, y + 0.004, z + 1);
+                    GL11.glVertex3d(x + 1, y + 0.004, z);
+                    GL11.glVertex3d(x, y + 0.004, z + 1);
                 }
             }
-        }
 
         GL11.glEnd();
         GL11.glEnable(GL11.GL_LIGHTING);
@@ -155,12 +100,10 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
 
     private static final Entity dummyEntity = new EntityPig(null);
     private static final AxisAlignedBB aabb = AxisAlignedBB.getBoundingBox(0, 0, 0, 0, 0, 0);
-
-    private static byte getSpawnMode(Chunk chunk, int x, int y, int z) {
+    private static int getSpawnMode(Chunk chunk, int x, int y, int z) {
         if (!SpawnerAnimals.canCreatureTypeSpawnAtLocation(EnumCreatureType.monster, chunk.worldObj, x, y, z) ||
-                chunk.getSavedLightValue(EnumSkyBlock.Block, x & 15, y, z & 15) >= 8) {
+                chunk.getSavedLightValue(EnumSkyBlock.Block, x & 15, y, z & 15) >= 8)
             return 0;
-        }
 
         aabb.minX = x + 0.2;
         aabb.maxX = x + 0.8;
@@ -168,11 +111,14 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
         aabb.maxY = y + 1.8;
         aabb.minZ = z + 0.2;
         aabb.maxZ = z + 0.8;
-        if (!chunk.worldObj.getCollidingBoundingBoxes(dummyEntity, aabb).isEmpty() || chunk.worldObj.isAnyLiquid(aabb)) {
+        if (!chunk.worldObj.checkNoEntityCollision(aabb) ||
+                !chunk.worldObj.getCollidingBoundingBoxes(dummyEntity, aabb).isEmpty() ||
+                chunk.worldObj.isAnyLiquid(aabb))
             return 0;
-        }
 
-        return (byte) (chunk.getSavedLightValue(EnumSkyBlock.Sky, x & 15, y, z & 15) >= 8 ? 1 : 2);
+        if (chunk.getSavedLightValue(EnumSkyBlock.Sky, x & 15, y, z & 15) >= 8)
+            return 1;
+        return 2;
     }
 
     private static void renderChunkBounds(Entity entity) {
@@ -226,93 +172,40 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
                     GL11.glVertex3d(x1, y2, z1);
                 }
 
-                if (cx == 0 && cz == 0) {
-                    if (chunkOverlay == 2) {
-                        dy = 32;
-                        y1 = Math.floor(entity.posY - dy / 2);
-                        y2 = y1 + dy;
-                        if (y1 < 0) {
-                            y1 = 0;
-                            y2 = dy;
-                        }
+                if (chunkOverlay == 2 && cx == 0 && cz == 0) {
+                    dy = 32;
+                    y1 = Math.floor(entity.posY - dy / 2);
+                    y2 = y1 + dy;
+                    if (y1 < 0) {
+                        y1 = 0;
+                        y2 = dy;
+                    }
 
-                        if (y1 > entity.worldObj.getHeight()) {
-                            y2 = entity.worldObj.getHeight();
-                            y1 = y2 - dy;
-                        }
+                    if (y1 > entity.worldObj.getHeight()) {
+                        y2 = entity.worldObj.getHeight();
+                        y1 = y2 - dy;
+                    }
 
-                        GL11.glColor4d(0, 0.9, 0, 0.4);
-                        for (double y = (int) y1; y <= y2; y++) {
-                            GL11.glVertex3d(x2, y, z1);
-                            GL11.glVertex3d(x2, y, z2);
-                            GL11.glVertex3d(x1, y, z1);
-                            GL11.glVertex3d(x1, y, z2);
-                            GL11.glVertex3d(x1, y, z2);
-                            GL11.glVertex3d(x2, y, z2);
-                            GL11.glVertex3d(x1, y, z1);
-                            GL11.glVertex3d(x2, y, z1);
-                        }
-                        for (double h = 1; h <= 15; h++) {
-                            GL11.glVertex3d(x1 + h, y1, z1);
-                            GL11.glVertex3d(x1 + h, y2, z1);
-                            GL11.glVertex3d(x1 + h, y1, z2);
-                            GL11.glVertex3d(x1 + h, y2, z2);
-                            GL11.glVertex3d(x1, y1, z1 + h);
-                            GL11.glVertex3d(x1, y2, z1 + h);
-                            GL11.glVertex3d(x2, y1, z1 + h);
-                            GL11.glVertex3d(x2, y2, z1 + h);
-                        }
-                    } else if (chunkOverlay == 3) {
-                        int gx1 = ((entity.chunkCoordX < 0 ? entity.chunkCoordX - 3 : entity.chunkCoordX) / 3 * 3) << 4;
-                        int gz1 = ((entity.chunkCoordZ < 0 ? entity.chunkCoordZ - 3 : entity.chunkCoordZ) / 3 * 3) << 4;
-                        if (entity.chunkCoordX < 0) {
-                            gx1 += 16;
-                        }
-                        if (entity.chunkCoordZ < 0) {
-                            gz1 += 16;
-                        }
-                        int gx2 = gx1 + 48;
-                        int gz2 = gz1 + 48;
-
-                        GL11.glColor4d(0, 0.9, 0, 0.4);
-                        for (double y = (int) y1; y <= y2; y++) {
-                            GL11.glVertex3d(gx2, y, gz1);
-                            GL11.glVertex3d(gx2, y, gz2);
-                            GL11.glVertex3d(gx1, y, gz1);
-                            GL11.glVertex3d(gx1, y, gz2);
-                            GL11.glVertex3d(gx1, y, gz2);
-                            GL11.glVertex3d(gx2, y, gz2);
-                            GL11.glVertex3d(gx1, y, gz1);
-                            GL11.glVertex3d(gx2, y, gz1);
-                        }
-                        for (double h = 4; h <= 44; h += 4) {
-                            if (h % 16 == 0) {
-                                continue;
-                            }
-                            GL11.glVertex3d(gx1 + h, y1, gz1);
-                            GL11.glVertex3d(gx1 + h, y2, gz1);
-                            GL11.glVertex3d(gx1 + h, y1, gz2);
-                            GL11.glVertex3d(gx1 + h, y2, gz2);
-                            GL11.glVertex3d(gx1, y1, gz1 + h);
-                            GL11.glVertex3d(gx1, y2, gz1 + h);
-                            GL11.glVertex3d(gx2, y1, gz1 + h);
-                            GL11.glVertex3d(gx2, y2, gz1 + h);
-                        }
-
-                        GL11.glColor4d(0, 0, 0.9, 0.4);
-                        gx1 += 23;
-                        gz1 += 23;
-                        gx2 = gx1 + 1;
-                        gz2 = gz1 + 1;
-
-                        GL11.glVertex3d(gx1, y1, gz1);
-                        GL11.glVertex3d(gx1, y2, gz1);
-                        GL11.glVertex3d(gx2, y1, gz1);
-                        GL11.glVertex3d(gx2, y2, gz1);
-                        GL11.glVertex3d(gx1, y1, gz2);
-                        GL11.glVertex3d(gx1, y2, gz2);
-                        GL11.glVertex3d(gx2, y1, gz2);
-                        GL11.glVertex3d(gx2, y2, gz2);
+                    GL11.glColor4d(0, 0.9, 0, 0.4);
+                    for (double y = (int) y1; y <= y2; y++) {
+                        GL11.glVertex3d(x2, y, z1);
+                        GL11.glVertex3d(x2, y, z2);
+                        GL11.glVertex3d(x1, y, z1);
+                        GL11.glVertex3d(x1, y, z2);
+                        GL11.glVertex3d(x1, y, z2);
+                        GL11.glVertex3d(x2, y, z2);
+                        GL11.glVertex3d(x1, y, z1);
+                        GL11.glVertex3d(x2, y, z1);
+                    }
+                    for (double h = 1; h <= 15; h++) {
+                        GL11.glVertex3d(x1 + h, y1, z1);
+                        GL11.glVertex3d(x1 + h, y2, z1);
+                        GL11.glVertex3d(x1 + h, y1, z2);
+                        GL11.glVertex3d(x1 + h, y2, z2);
+                        GL11.glVertex3d(x1, y1, z1 + h);
+                        GL11.glVertex3d(x1, y2, z1 + h);
+                        GL11.glVertex3d(x2, y1, z1 + h);
+                        GL11.glVertex3d(x2, y2, z1 + h);
                     }
                 }
             }

src/main/java/codechicken/nei/api/API.java

@@ -15,15 +15,11 @@ import codechicken.nei.SubsetWidget.SubsetTag;
 import codechicken.nei.api.ItemFilter.ItemFilterProvider;
 import codechicken.nei.config.Option;
 import codechicken.nei.config.OptionKeyBind;
-import codechicken.nei.recipe.CatalystInfo;
 import codechicken.nei.recipe.GuiCraftingRecipe;
 import codechicken.nei.recipe.GuiUsageRecipe;
 import codechicken.nei.recipe.ICraftingHandler;
-import codechicken.nei.recipe.IRecipeHandler;
 import codechicken.nei.recipe.IUsageHandler;
-import codechicken.nei.recipe.RecipeCatalysts;
 import codechicken.nei.recipe.RecipeInfo;
-import codechicken.nei.recipe.StackInfo;
 import net.minecraft.block.Block;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.inventory.Slot;
@@ -33,7 +29,6 @@ import org.lwjgl.input.Keyboard;
 
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.List;
 
 /**
  * This is the main class that handles item property configuration.
@@ -289,78 +284,4 @@ public class API
         ItemInfo.itemVariants.put(item, variant);
         LayoutManager.markItemsDirty();
     }
-
-    public static void registerStackStringifyHandler(IStackStringifyHandler handler)
-    {
-        StackInfo.stackStringifyHandlers.add(handler);
-    }
-
-    /**
-     * Adds an association between an ingredient and what it can craft. (i.e. Furnace ItemStack -> Smelting and Fuel Recipes)
-     * Allows players to see what ingredient they need to craft in order to make recipes from a recipe category.
-     * @param stack the ingredient that can craft recipes (like a furnace or crafting table)
-     * @param handler the recipe category handled by the ingredient
-     * @param priority higher priority comes first, default to 0
-     */
-    public static void addRecipeCatalyst(ItemStack stack, IRecipeHandler handler, int priority) {
-        String handlerID = RecipeCatalysts.getRecipeID(handler);
-        addRecipeCatalyst(stack, handlerID, priority);
-    }
-
-    /**
-     * See {@link API#addRecipeCatalyst(ItemStack, IRecipeHandler, int)}
-     */
-    public static void addRecipeCatalyst(ItemStack stack, IRecipeHandler handler) {
-        addRecipeCatalyst(stack, handler, 0);
-    }
-
-    /**
-     * Adds an association between an ingredient and what it can craft. (i.e. Furnace ItemStack -> Smelting and Fuel Recipes)
-     * Allows players to see what ingredient they need to craft in order to make recipes from a recipe category.
-     * @param stack the ingredient that can craft recipes (like a furnace or crafting table)
-     * @param handlerID recipe category identifier (see also {@link RecipeCatalysts#getRecipeID(IRecipeHandler)})
-     * @param priority higher priority comes first, default to 0
-     */
-    public static void addRecipeCatalyst(ItemStack stack, String handlerID, int priority) {
-        RecipeCatalysts.addRecipeCatalyst(handlerID, new CatalystInfo(stack, priority));
-    }
-
-    /**
-     * See {@link API#addRecipeCatalyst(ItemStack, String, int)}
-     */
-    public static void addRecipeCatalyst(ItemStack stack, String handlerID) {
-        addRecipeCatalyst(stack, handlerID, 0);
-    }
-
-    public static void removeRecipeCatalyst(ItemStack stack, IRecipeHandler handler) {
-        String handlerID = RecipeCatalysts.getRecipeID(handler);
-        removeRecipeCatalyst(stack, handlerID);
-    }
-
-    public static void removeRecipeCatalyst(ItemStack stack, String handlerID) {
-        RecipeCatalysts.removeRecipeCatalyst(handlerID, stack);
-    }
-
-    @Deprecated
-    public static void addRecipeCatalyst(List<ItemStack> stacks, IRecipeHandler handler) {
-        for (ItemStack stack : stacks) {
-            addRecipeCatalyst(stack, handler);
-        }
-    }
-
-    @Deprecated
-    public static void addRecipeCatalyst(List<ItemStack> stacks, String handlerID) {
-        for (ItemStack stack : stacks) {
-            addRecipeCatalyst(stack, handlerID);
-        }
-    }
-
-    @Deprecated
-    public static void addRecipeCatalyst(ItemStack stack, Class<? extends IRecipeHandler> handler) {
-    }
-
-    @Deprecated
-    public static void addRecipeCatalyst(List<ItemStack> stacks, Class<? extends IRecipeHandler> handler) {
-    }
-
 }

src/main/java/codechicken/nei/api/GuiInfo.java

@@ -3,11 +3,11 @@ package codechicken.nei.api;
 import codechicken.nei.NEIChestGuiHandler;
 import codechicken.nei.NEICreativeGuiHandler;
 import codechicken.nei.NEIDummySlotHandler;
-import codechicken.nei.recipe.GuiRecipeCatalyst;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.client.gui.inventory.GuiContainerCreative;
 
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
@@ -24,7 +24,6 @@ public class GuiInfo {
         API.registerNEIGuiHandler(new NEICreativeGuiHandler());
         API.registerNEIGuiHandler(new NEIChestGuiHandler());
         API.registerNEIGuiHandler(new NEIDummySlotHandler());
-        API.registerNEIGuiHandler(new GuiRecipeCatalyst(null));
         customSlotGuis.add(GuiContainerCreative.class);
     }
 

src/main/java/codechicken/nei/api/IStackStringifyHandler.java

@@ -1,16 +0,0 @@
-package codechicken.nei.api;
-
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraftforge.fluids.FluidStack;
-import net.minecraft.item.ItemStack;
-
-public interface IStackStringifyHandler
-{
-
-    public NBTTagCompound convertItemStackToNBT(ItemStack stack, boolean saveStackSize);
-
-    public ItemStack convertNBTToItemStack(NBTTagCompound nbtTag);
-
-    public FluidStack getFluid(ItemStack stack);
-
-}

src/main/java/codechicken/nei/asm/GuiContainerManagerAPITransformer.java

@@ -1,38 +0,0 @@
-package codechicken.nei.asm;
-
-import codechicken.lib.asm.ASMHelper;
-import org.objectweb.asm.ClassVisitor;
-import org.objectweb.asm.MethodVisitor;
-
-import static org.objectweb.asm.Opcodes.POP;
-import static org.objectweb.asm.Opcodes.PUTSTATIC;
-
-public class GuiContainerManagerAPITransformer extends ClassVisitor {
-    private final String tname;
-    private boolean changed = false;
-
-    public GuiContainerManagerAPITransformer(int api, ClassVisitor cv, String tname) {
-        super(api, cv);
-        this.tname = tname;
-    }
-
-    @Override
-    public MethodVisitor visitMethod(int access, String mname, String mdesc, String signature, String[] exceptions) {
-        return new MethodVisitor(api, super.visitMethod(access, mname, mdesc, signature, exceptions)) {
-            @Override
-            public void visitFieldInsn(int opcode, String owner, String name, String desc) {
-                if (opcode == PUTSTATIC && "codechicken/nei/guihook/GuiContainerManager".equals(owner) && name.endsWith("Handlers") && desc.equals("Ljava/util/LinkedList;")) {
-                    ASMHelper.logger.warn("Found suspicious PUTSTATIC {} in {}#{}{}, replacing with POP!", name, tname, mname, mdesc);
-                    changed = true;
-                    super.visitInsn(POP);
-                } else {
-                    super.visitFieldInsn(opcode, owner, name, desc);
-                }
-            }
-        };
-    }
-
-    public boolean isChanged() {
-        return changed;
-    }
-}

src/main/java/codechicken/nei/asm/NEICorePlugin.java

@@ -4,14 +4,12 @@ import codechicken.core.launch.CodeChickenCorePlugin;
 import codechicken.lib.asm.ASMInit;
 import cpw.mods.fml.relauncher.IFMLCallHook;
 import cpw.mods.fml.relauncher.IFMLLoadingPlugin;
-import cpw.mods.fml.relauncher.IFMLLoadingPlugin.MCVersion;
 import cpw.mods.fml.relauncher.IFMLLoadingPlugin.TransformerExclusions;
 
 import java.io.File;
 import java.util.Map;
 
 @TransformerExclusions(value = {"codechicken.nei.asm"})
-@MCVersion( "1.7.10" )
 public class NEICorePlugin implements IFMLLoadingPlugin, IFMLCallHook
 {
     public static File location;

src/main/java/codechicken/nei/asm/NEITransformer.java

@@ -41,7 +41,6 @@ public class NEITransformer implements IClassTransformer
         ASMInit.init();
     }
 
-    private final boolean paranoidMode = Boolean.getBoolean("nei.paranoid");
     private final ModularASMTransformer transformer = new ModularASMTransformer();
     private final Map<String, ASMBlock> asmblocks = ASMReader.loadResource("/assets/nei/asm/blocks.asm");
 
@@ -265,14 +264,6 @@ public class NEITransformer implements IClassTransformer
                 }
                 bytes = transformSubclasses(name, bytes);
             }
-            if (paranoidMode && !tname.startsWith("codechicken.nei")) {
-                ClassReader cr = new ClassReader(bytes);
-                ClassWriter cw = new ClassWriter(0);
-                GuiContainerManagerAPITransformer cv = new GuiContainerManagerAPITransformer(ASM5, cw, tname);
-                cr.accept(cv, ClassReader.SKIP_DEBUG);
-                if (cv.isChanged())
-                    bytes = cw.toByteArray();
-            }
 
             bytes = transformer.transform(name, bytes);
         } catch (Exception e) {

src/main/java/codechicken/nei/config/GuiItemIconDumper.java

@@ -22,7 +22,6 @@ import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;
 
 import javax.imageio.ImageIO;
-import java.util.ArrayList;
 import java.awt.Dimension;
 import java.awt.image.BufferedImage;
 import java.io.File;
@@ -101,12 +100,10 @@ public class GuiItemIconDumper extends GuiScreen
         GL11.glEnable(GL12.GL_RESCALE_NORMAL);
         GL11.glColor4f(1, 1, 1, 1);
 
-        final ArrayList<ItemStack> items = ItemPanels.itemPanel.getItems();
-
-        for (int i = 0; drawIndex < items.size() && i < fit; drawIndex++, i++) {
+        for(int i = 0; drawIndex < ItemPanels.itemPanel.realItems.size() && i < fit; drawIndex++, i++) {
             int x = i%cols * 18;
             int y = i/cols * 18;
-            GuiContainerManager.drawItem(x+1, y+1, items.get(drawIndex));
+            GuiContainerManager.drawItem(x+1, y+1, ItemPanels.itemPanel.realItems.get(drawIndex));
         }
 
         GL11.glFlush();
@@ -117,19 +114,14 @@ public class GuiItemIconDumper extends GuiScreen
         int rows = img.getHeight() / boxSize;
         int cols = img.getWidth() / boxSize;
         int fit = rows*cols;
-        
-        final ArrayList<ItemStack> items = ItemPanels.itemPanel.getItems();
-
-        for(int i = 0; parseIndex < items.size() && i < fit; parseIndex++, i++) {
+        for(int i = 0; parseIndex < ItemPanels.itemPanel.realItems.size() && i < fit; parseIndex++, i++) {
             int x = i%cols * boxSize;
             int y = i/cols * boxSize;
-            exportImage(dir, img.getSubimage(x+borderSize, y+borderSize, iconSize, iconSize), items.get(parseIndex));
+            exportImage(dir, img.getSubimage(x+borderSize, y+borderSize, iconSize, iconSize), ItemPanels.itemPanel.realItems.get(parseIndex));
         }
 
-        if (parseIndex >= items.size()) {
+        if(parseIndex >= ItemPanels.itemPanel.realItems.size())
             returnScreen(new ChatComponentTranslation(opt.fullName()+".icon.dumped", "dumps/itempanel_icons"));
-        }
-
     }
 
     public static String cleanFileName(String name) {

src/main/java/codechicken/nei/config/HandlerDumper.java

@@ -8,13 +8,17 @@ import codechicken.nei.recipe.IRecipeHandler;
 import codechicken.nei.recipe.TemplateRecipeHandler;
 import codechicken.nei.util.NBTJson;
 import com.google.common.base.Objects;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.JsonToNBT;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.ChatComponentTranslation;
 import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.tuple.Pair;
 
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
+import java.io.PrintWriter;
 import java.util.LinkedList;
 
 public class HandlerDumper extends DataDumper

src/main/java/codechicken/nei/config/ItemPanelDumper.java

@@ -36,7 +36,7 @@ public class ItemPanelDumper extends DataDumper
     @Override
     public Iterable<String[]> dump(int mode) {
         LinkedList<String[]> list = new LinkedList<>();
-        for (ItemStack stack : ItemPanels.itemPanel.getItems())
+        for (ItemStack stack : ItemPanels.itemPanel.realItems)
             list.add(new String[]{
                     Item.itemRegistry.getNameForObject(stack.getItem()),
                     Integer.toString(Item.getIdFromItem(stack.getItem())),
@@ -123,7 +123,7 @@ public class ItemPanelDumper extends DataDumper
 
     public void dumpNBT(File file) throws IOException {
         NBTTagList list = new NBTTagList();
-        for (ItemStack stack : ItemPanels.itemPanel.getItems())
+        for (ItemStack stack : ItemPanels.itemPanel.realItems)
             list.appendTag(stack.writeToNBT(new NBTTagCompound()));
 
         NBTTagCompound tag = new NBTTagCompound();
@@ -134,7 +134,7 @@ public class ItemPanelDumper extends DataDumper
 
     public void dumpJson(File file) throws IOException {
         PrintWriter p = new PrintWriter(file);
-        for (ItemStack stack : ItemPanels.itemPanel.getItems()) {
+        for (ItemStack stack : ItemPanels.itemPanel.realItems) {
             NBTTagCompound tag = stack.writeToNBT(new NBTTagCompound());
             tag.removeTag("Count");
             p.println(tag);

src/main/java/codechicken/nei/drawable/GuiElementDuex.java

@@ -1,91 +0,0 @@
-package codechicken.nei.drawable;
-
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.gui.GuiScreen;
-
-/*
- * Taken from Mantle 1.12-1.3.3.49 under the MIT License
- *
- * The MIT License (MIT) Copyright (c) 2013-2014 Slime Knights (mDiyo, fuj1n, Sunstrike, progwml6, pillbox, alexbegt)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
- */
-
-@SideOnly(Side.CLIENT)
-public class GuiElementDuex {
-
-    // this is totally completely ugly but it's a simple solution that doesn't clutter everything too much >_>
-    public static int defaultTexW = 256;
-    public static int defaultTexH = 256;
-
-    public final int x;
-    public final int y;
-    public final int w;
-    public final int h;
-
-    public int texW;
-    public int texH;
-
-    public GuiElementDuex(int x, int y, int w, int h, int texW, int texH) {
-        this(x, y, w, h);
-        setTextureSize(texW, texH);
-
-        defaultTexW = texW;
-        defaultTexH = texH;
-    }
-
-    public GuiElementDuex(int x, int y, int w, int h) {
-        this.x = x;
-        this.y = y;
-        this.w = w;
-        this.h = h;
-        setTextureSize(defaultTexW, defaultTexH);
-    }
-
-    public GuiElementDuex setTextureSize(int w, int h) {
-        texW = w;
-        texH = h;
-
-        return this;
-    }
-
-    public GuiElementDuex shift(int xd, int yd) {
-        return new GuiElementDuex(this.x + xd, this.y + yd, this.w, this.h, this.texW, this.texH);
-    }
-
-    /**
-     * Draws the element at the given x/y coordinates
-     *
-     * @param xPos X-Coordinate on the screen
-     * @param yPos Y-Coordinate on the screen
-     */
-    public int draw(int xPos, int yPos) {
-        // drawModalRectWithCustomSizedTexture
-        GuiScreen.func_146110_a(xPos, yPos, x, y, w, h, texW, texH);
-        return w;
-    }
-
-    public static class Builder {
-
-        public int w;
-        public int h;
-
-        public Builder(int w, int h) {
-            this.w = w;
-            this.h = h;
-        }
-
-        public GuiElementDuex get(int x, int y, int w, int h) {
-            return new GuiElementDuex(x, y, w, h, this.w, this.h);
-        }
-    }
-}

src/main/java/codechicken/nei/drawable/GuiElementScalable.java

@@ -1,92 +0,0 @@
-package codechicken.nei.drawable;
-
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.gui.GuiScreen;
-
-/*
- * Taken from Mantle 1.12-1.3.3.49 under the MIT License
- *
- * The MIT License (MIT) Copyright (c) 2013-2014 Slime Knights (mDiyo, fuj1n, Sunstrike, progwml6, pillbox, alexbegt)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
- */
-
-@SideOnly(Side.CLIENT)
-public class GuiElementScalable extends GuiElementDuex {
-
-    public GuiElementScalable(int x, int y, int w, int h, int texW, int texH) {
-        super(x, y, w, h, texW, texH);
-    }
-
-    public GuiElementScalable(int x, int y, int w, int h) {
-        super(x, y, w, h);
-    }
-
-    public int drawScaledX(int xPos, int yPos, int width) {
-        for(int i = 0; i < width / w; i++) {
-            draw(xPos + i * w, yPos);
-        }
-        // remainder that doesn't fit total width
-        int remainder = width % w;
-        if(remainder > 0) {
-            GuiScreen.func_146110_a(xPos + width - remainder, yPos, x, y, remainder, h, texW, texH);
-        }
-
-        return width;
-    }
-
-    public int drawScaledY(int xPos, int yPos, int height) {
-        for(int i = 0; i < height / h; i++) {
-            draw(xPos, yPos + i * h);
-        }
-        // remainder that doesn't fit total width
-        int remainder = height % h;
-        if(remainder > 0) {
-            // drawModalRectWithCustomSizedTexture
-            GuiScreen.func_146110_a(xPos, yPos + height - remainder, x, y, w, remainder, texW, texH);
-        }
-
-        return w;
-    }
-
-    public int drawScaled(int xPos, int yPos, int width, int height) {
-        // we draw full height row-wise
-        int full = height / this.h;
-        for(int i = 0; i < full; i++) {
-            drawScaledX(xPos, yPos + i * this.h, width);
-        }
-
-        yPos += full * this.h;
-
-        // and the remainder is drawn manually
-        int yRest = height % this.h;
-        // the same as drawScaledX but with the remaining height
-        for(int i = 0; i < width / w; i++) {
-            drawScaledY(xPos + i * w, yPos, yRest);
-        }
-        // remainder that doesn't fit total width
-        int remainder = width % w;
-        if(remainder > 0) {
-            // drawModalRectWithCustomSizedTexture
-            GuiScreen.func_146110_a(xPos + width - remainder, yPos, x, y, remainder, yRest, texW, texH);
-        }
-
-        return width;
-    }
-
-    @Override
-    public GuiElementScalable shift(int xd, int yd) {
-        GuiElementScalable element = new GuiElementScalable(this.x + xd, this.y + yd, this.w, this.h);
-        element.setTextureSize(texW, texH);
-        return element;
-    }
-}

src/main/java/codechicken/nei/guihook/GuiContainerManager.java

@@ -23,7 +23,6 @@ import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.regex.Pattern;
 
 import static codechicken.lib.gui.GuiDraw.drawMultilineTip;
@@ -36,11 +35,11 @@ public class GuiContainerManager
     public GuiContainer window;
 
     public static RenderItem drawItems = new RenderItem();
-    public static final LinkedList<IContainerTooltipHandler> tooltipHandlers = new HideousLinkedList<>(new CopyOnWriteArrayList<>());
-    public static final LinkedList<IContainerInputHandler> inputHandlers = new HideousLinkedList<>(new CopyOnWriteArrayList<>());
-    public static final LinkedList<IContainerDrawHandler> drawHandlers = new HideousLinkedList<>(new CopyOnWriteArrayList<>());
-    public static final LinkedList<IContainerObjectHandler> objectHandlers = new HideousLinkedList<>(new CopyOnWriteArrayList<>());
-    public static final LinkedList<IContainerSlotClickHandler> slotClickHandlers = new HideousLinkedList<>(new CopyOnWriteArrayList<>());
+    public static LinkedList<IContainerTooltipHandler> tooltipHandlers = new LinkedList<>();
+    public static LinkedList<IContainerInputHandler> inputHandlers = new LinkedList<>();
+    public static LinkedList<IContainerDrawHandler> drawHandlers = new LinkedList<>();
+    public static LinkedList<IContainerObjectHandler> objectHandlers = new LinkedList<>();
+    public static LinkedList<IContainerSlotClickHandler> slotClickHandlers = new LinkedList<>();
 
     static {
         addSlotClickHandler(new DefaultSlotClickHandler());
@@ -182,28 +181,15 @@ public class GuiContainerManager
         drawItem(i, j, itemstack, getFontRenderer(itemstack));
     }
 
-    public static void drawItem(int i, int j, ItemStack itemstack, boolean smallAmount) {
-        drawItem(i, j, itemstack, getFontRenderer(itemstack), smallAmount);
-    }
-
-    public static void drawItem(int i, int j, ItemStack itemstack, FontRenderer fontRenderer) {
-        drawItem(i, j, itemstack, fontRenderer, false);
-    }
-
     private static int modelviewDepth = -1;
     private static final HashSet<String> stackTraces = new HashSet<>();
 
-    public static void drawItem(int i, int j, ItemStack itemstack, FontRenderer fontRenderer, boolean smallAmount) {
+    public static void drawItem(int i, int j, ItemStack itemstack, FontRenderer fontRenderer) {
         enable3DRender();
         float zLevel = drawItems.zLevel += 100F;
         try {
             drawItems.renderItemAndEffectIntoGUI(fontRenderer, renderEngine, itemstack, i, j);
-
-            if (!smallAmount) {
-                drawItems.renderItemOverlayIntoGUI(fontRenderer, renderEngine, itemstack, i, j);
-            } else if (itemstack.stackSize > 1) {
-                drawBigStackSize(i, j, itemstack.stackSize);
-            }
+            drawItems.renderItemOverlayIntoGUI(fontRenderer, renderEngine, itemstack, i, j);
 
             if (!checkMatrixStack())
                 throw new IllegalStateException("Modelview matrix stack too deep");
@@ -231,27 +217,6 @@ public class GuiContainerManager
         drawItems.zLevel = zLevel - 100;
     }
 
-    //copy from appeng.client.render.AppEngRenderItem
-    protected static void drawBigStackSize(int offsetX, int offsetY, int amount)
-    {
-        final float scaleFactor = fontRenderer.getUnicodeFlag() ? 0.85f : 0.5f;
-        final float inverseScaleFactor = 1.0f / scaleFactor;
-        final String stackSize = String.valueOf( amount );
-
-        GL11.glDisable(GL11.GL_LIGHTING);
-        GL11.glDisable(GL11.GL_DEPTH_TEST);
-        GL11.glPushMatrix();
-        GL11.glScaled(scaleFactor, scaleFactor, scaleFactor);
-
-        final int X = (int) ( ( (float) offsetX + 16.0f - fontRenderer.getStringWidth( stackSize ) * scaleFactor ) * inverseScaleFactor );
-        final int Y = (int) ( ( (float) offsetY + 16.0f - 7.0f * scaleFactor ) * inverseScaleFactor );
-        fontRenderer.drawStringWithShadow(stackSize, X, Y, 16777215);
-
-        GL11.glPopMatrix();
-        GL11.glEnable(GL11.GL_LIGHTING);
-        GL11.glEnable(GL11.GL_DEPTH_TEST);
-    }
-
     public static void enableMatrixStackLogging() {
         modelviewDepth = GL11.glGetInteger(GL11.GL_MODELVIEW_STACK_DEPTH);
     }

src/main/java/codechicken/nei/guihook/HideousLinkedList.java

@@ -1,271 +0,0 @@
-package codechicken.nei.guihook;
-
-import java.util.*;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
-import java.util.stream.Stream;
-
-/**
- * A hideous LinkedList that is backed by an arbitrary list, for alternative characteristics while preserving
- * binary compatibility...
- * @param <E>
- */
-final class HideousLinkedList<E> extends LinkedList<E> {
-    private final List<E> backing;
-
-    HideousLinkedList(List<E> backing) {
-        this.backing = backing;
-    }
-
-    @Override
-    public int size() {
-        return backing.size();
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return backing.isEmpty();
-    }
-
-    @Override
-    public boolean contains(Object o) {
-        return backing.contains(o);
-    }
-
-    @Override
-    public Iterator<E> iterator() {
-        return backing.iterator();
-    }
-
-    @Override
-    public Object[] toArray() {
-        return backing.toArray();
-    }
-
-    @Override
-    public <T> T[] toArray(T[] a) {
-        return backing.toArray(a);
-    }
-
-    @Override
-    public boolean add(E e) {
-        return backing.add(e);
-    }
-    
-    @Override
-    public void addFirst(E e) {
-        backing.add(0, e);
-    }
-    
-    @Override
-    public E getFirst() {
-        if (backing.size() == 0) throw new NoSuchElementException();
-        return(backing.get(0));
-    }
-    
-    @Override
-    public E removeFirst() {
-        E item = getFirst();
-        backing.remove(0);
-        return item;
-    }
-
-    @Override
-    public void addLast(E e) {
-        backing.add(backing.size(), e);
-    }
-
-    @Override
-    public E getLast() {
-        if (backing.size() == 0) throw new NoSuchElementException();
-        return backing.get(backing.size() - 1);
-    }
-
-    @Override
-    public E removeLast() {
-        E item = getLast();
-        backing.remove(backing.size() - 1);
-        return item;
-    }
-    
-    @Override
-    public E peek() {
-        return backing.size() > 0 ? backing.get(0) : null;
-    }
-    
-    @Override
-    public E peekFirst() {
-        return backing.size() > 0 ? getFirst() : null;
-    }
-    
-    @Override
-    public E peekLast() {
-        return backing.size() > 0 ? getLast() : null;
-    }
-    
-    @Override
-    public E poll() {
-        return backing.size() > 0 ? removeFirst() : null;
-    }
-    
-    @Override
-    public E pollFirst() {
-        return poll();
-    }
-    
-    @Override
-    public E pollLast() {
-        return backing.size() > 0 ? removeLast() : null;
-    }
-    
-    @Override
-    public void push(E e) {
-        addFirst(e);
-    }
-    
-    @Override
-    public E pop() {
-        return removeFirst();
-    }
-
-    @Override
-    public boolean removeFirstOccurrence(Object e) {
-        return remove(e);
-    }
-    
-    @Override
-    public boolean removeLastOccurrence(Object e) {
-        int idx = this.backing.lastIndexOf(e);
-        if (idx != -1) {
-            this.backing.remove(idx);
-            return true;
-        }
-        return false;
-    }
-    
-    @Override
-    public boolean remove(Object o) {
-        return backing.remove(o);
-    }
-
-    @Override
-    public boolean containsAll(Collection<?> c) {
-        return backing.containsAll(c);
-    }
-
-    @Override
-    public boolean addAll(Collection<? extends E> c) {
-        return backing.addAll(c);
-    }
-
-    @Override
-    public boolean addAll(int index, Collection<? extends E> c) {
-        return backing.addAll(index, c);
-    }
-
-    @Override
-    public boolean removeAll(Collection<?> c) {
-        return backing.removeAll(c);
-    }
-
-    @Override
-    public boolean retainAll(Collection<?> c) {
-        return backing.retainAll(c);
-    }
-
-    @Override
-    public void replaceAll(UnaryOperator<E> operator) {
-        backing.replaceAll(operator);
-    }
-
-    @Override
-    public void sort(Comparator<? super E> c) {
-        backing.sort(c);
-    }
-
-    @Override
-    public void clear() {
-        backing.clear();
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        return backing.equals(o);
-    }
-
-    @Override
-    public int hashCode() {
-        return backing.hashCode();
-    }
-
-    @Override
-    public E get(int index) {
-        return backing.get(index);
-    }
-
-    @Override
-    public E set(int index, E element) {
-        return backing.set(index, element);
-    }
-
-    @Override
-    public void add(int index, E element) {
-        backing.add(index, element);
-    }
-
-    @Override
-    public E remove(int index) {
-        return backing.remove(index);
-    }
-
-    @Override
-    public int indexOf(Object o) {
-        return backing.indexOf(o);
-    }
-
-    @Override
-    public int lastIndexOf(Object o) {
-        return backing.lastIndexOf(o);
-    }
-
-    @Override
-    public ListIterator<E> listIterator() {
-        return backing.listIterator();
-    }
-
-    @Override
-    public ListIterator<E> listIterator(int index) {
-        return backing.listIterator(index);
-    }
-
-    @Override
-    public List<E> subList(int fromIndex, int toIndex) {
-        return backing.subList(fromIndex, toIndex);
-    }
-
-    @Override
-    public Spliterator<E> spliterator() {
-        return backing.spliterator();
-    }
-
-    @Override
-    public boolean removeIf(Predicate<? super E> filter) {
-        return backing.removeIf(filter);
-    }
-
-    @Override
-    public Stream<E> stream() {
-        return backing.stream();
-    }
-
-    @Override
-    public Stream<E> parallelStream() {
-        return backing.parallelStream();
-    }
-
-    @Override
-    public void forEach(Consumer<? super E> action) {
-        backing.forEach(action);
-    }
-}

src/main/java/codechicken/nei/recipe/BookmarkRecipeId.java

@@ -1,169 +0,0 @@
-package codechicken.nei.recipe;
-
-import com.google.gson.JsonObject;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonArray;
-import com.google.gson.JsonPrimitive;
-import codechicken.nei.util.NBTJson;
-import codechicken.nei.NEIClientConfig;
-import codechicken.nei.PositionedStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.item.ItemStack;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class BookmarkRecipeId
-{
-
-    public int position = -1;
-
-    public int recipetype = -1;
-
-    public String handlerName = null;
-
-    public List<NBTTagCompound> ingredients = new ArrayList<>();
-
-    
-    public BookmarkRecipeId(String handlerName, List<PositionedStack> stacks)
-    {
-        this.handlerName = handlerName;
-
-        for (PositionedStack pos : stacks) {
-            final NBTTagCompound nbt = StackInfo.itemStackToNBT(getItemStackWithMinimumDamage(pos.items));
-            if (nbt != null) {
-                ingredients.add(nbt);
-            }
-        }
-
-    }
-
-    public BookmarkRecipeId(JsonObject json)
-    {
-
-        if (json.get("handlerName") != null) {
-            handlerName = json.get("handlerName").getAsString();
-        }
-
-        if (json.get("ingredients") != null) {
-            JsonArray arr = (JsonArray) json.get("ingredients");
-            List<NBTTagCompound> ingredients = convertJsonArrayToIngredients(arr);
-
-            if (ingredients != null) {
-                this.ingredients = ingredients;
-            }
-    
-        }
-
-    }
-
-    public boolean equalsIngredients(List<PositionedStack> stacks)
-    {
-
-        if (ingredients.size() != stacks.size()) {
-            return false;
-        }
-
-        Short idx = 0;
-
-        for (PositionedStack pStack : stacks) {
-            final NBTTagCompound tagCompoundA = StackInfo.itemStackToNBT(getItemStackWithMinimumDamage(pStack.items));
-            final NBTTagCompound tagCompoundB = ingredients.get(idx);
-
-            if (tagCompoundB == null || !tagCompoundA.equals(tagCompoundB)) {
-                return false;
-            }
-
-            idx++;
-        }
-
-        return true;
-    }
-
-    public ItemStack getItemStackWithMinimumDamage(ItemStack[] stacks)
-    {
-        int damage = Short.MAX_VALUE;
-        ItemStack result = stacks[0];
-
-        if (stacks.length > 1) {
-            for (ItemStack stack : stacks) {
-                if (stack.getItemDamage() < damage) {
-                    damage = stack.getItemDamage();
-                    result = stack;
-                }
-            }
-        }
-
-        return result.copy();
-    }
-
-    public JsonObject toJsonObject()
-    {
-        JsonObject json = new JsonObject();
-
-        if (handlerName != null) {
-            json.add("handlerName", new JsonPrimitive(handlerName));
-            json.add("ingredients", convertIngredientsToJsonArray(ingredients));
-        }
-
-        return json;
-    }
-
-    protected List<NBTTagCompound> convertJsonArrayToIngredients(JsonArray arr)
-    {
-        List<NBTTagCompound> ingredients = new ArrayList<>();
-
-        for (JsonElement elem : arr) {
-            final NBTTagCompound nbt = (NBTTagCompound) NBTJson.toNbt(elem);
-
-            if (nbt == null) {
-                return null;
-            }
-
-            ingredients.add(nbt);
-        }
-
-        return ingredients;
-    }
-
-    protected JsonArray convertIngredientsToJsonArray(List<NBTTagCompound> ingredients)
-    {
-        JsonArray arr = new JsonArray();
-
-        for (NBTTagCompound nbTag : ingredients) {
-            arr.add(NBTJson.toJsonObject(nbTag));
-        }
-
-        return arr;
-    }
-
-    public boolean equals(Object anObject)
-    {
-        if (this == anObject) {    
-            return true;    
-        }
-
-        if (anObject instanceof BookmarkRecipeId) {
-            final BookmarkRecipeId anRecipeId = (BookmarkRecipeId) anObject;
-
-            if (!handlerName.equals(anRecipeId.handlerName)) {
-                return false;
-            }
-
-            if (ingredients.size() != anRecipeId.ingredients.size()) {
-                return false;
-            }
-
-            for (int idx = 0; idx < ingredients.size(); idx++) {
-                if (!ingredients.get(idx).equals(anRecipeId.ingredients.get(idx))) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        return false;    
-    }
-
-}

src/main/java/codechicken/nei/recipe/CatalystInfo.java

@@ -1,21 +0,0 @@
-package codechicken.nei.recipe;
-
-import net.minecraft.item.ItemStack;
-
-public class CatalystInfo {
-    private final ItemStack stack;
-    private final int priority;
-
-    public CatalystInfo(ItemStack stack, int priority) {
-        this.stack = stack;
-        this.priority = priority;
-    }
-
-    public ItemStack getStack() {
-        return stack;
-    }
-
-    public int getPriority() {
-        return priority;
-    }
-}

src/main/java/codechicken/nei/recipe/CatalystInfoList.java

@@ -1,70 +0,0 @@
-package codechicken.nei.recipe;
-
-import codechicken.nei.NEIClientConfig;
-import codechicken.nei.NEIServerUtils;
-import com.google.common.collect.ForwardingList;
-import net.minecraft.item.ItemStack;
-
-import javax.annotation.Nonnull;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-// Do not directly extend ArrayList, see Effective Java Item 16
-public class CatalystInfoList extends ForwardingList<CatalystInfo> {
-    private final String handlerID;
-    private final List<CatalystInfo> catalystInfoList = new ArrayList<>();
-
-    public CatalystInfoList(String handlerID) {
-        this.handlerID = handlerID;
-    }
-
-    public CatalystInfoList(String handlerID, CatalystInfo catalystInfo) {
-        this(handlerID);
-        add(catalystInfo);
-    }
-
-    @Override
-    protected List<CatalystInfo> delegate() {
-        return catalystInfoList;
-    }
-
-    @Override
-    public boolean add(@Nonnull CatalystInfo catalystInfo) {
-        if (contains(catalystInfo)) {
-            NEIClientConfig.logger.info(String.format("catalyst %s is already registered to handler %s", catalystInfo.getStack().getDisplayName(), handlerID));
-            return false;
-        }
-        super.add(catalystInfo);
-        return true;
-    }
-
-    @Override
-    public boolean contains(Object object) {
-        if (object instanceof CatalystInfo) {
-            ItemStack stack = ((CatalystInfo) object).getStack();
-            return contains(stack);
-        }
-        return false;
-    }
-
-    public boolean contains(ItemStack stack) {
-        return catalystInfoList.stream().anyMatch(c -> NEIServerUtils.areStacksSameTypeCraftingWithNBT(c.getStack(), stack));
-    }
-
-    public boolean remove(ItemStack stack) {
-        Iterator<CatalystInfo> iter = catalystInfoList.iterator();
-        while (iter.hasNext()) {
-            ItemStack next = iter.next().getStack();
-            if (NEIServerUtils.areStacksSameTypeCraftingWithNBT(next, stack)) {
-                iter.remove();
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public void sort() {
-        super.sort((c1, c2) -> c2.getPriority() - c1.getPriority());
-    }
-}

src/main/java/codechicken/nei/recipe/FuelRecipeHandler.java

@@ -2,14 +2,13 @@ package codechicken.nei.recipe;
 
 import codechicken.nei.NEIClientUtils;
 import codechicken.nei.PositionedStack;
-import net.minecraft.client.Minecraft;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.crafting.FurnaceRecipes;
 
-import java.text.NumberFormat;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.stream.Collectors;
 
 import static codechicken.nei.NEIClientUtils.translate;
@@ -79,23 +78,31 @@ public class FuelRecipeHandler extends FurnaceRecipeHandler
 
     }
 
-    @Override
-    public String specifyTransferRect() {
-        return "fuel";
-    }
-
     public String getOverlayIdentifier() {
         return "fuel";
     }
 
     @Override
-    public void drawExtras(int recipe) {
-        super.drawExtras(recipe);
+    public List<String> handleItemTooltip(GuiRecipe gui, ItemStack stack, List<String> currenttip, int recipe) {
         CachedFuelRecipe crecipe = (CachedFuelRecipe) arecipes.get(recipe);
         FuelPair fuel = crecipe.fuel;
-        NumberFormat numberInstance = NumberFormat.getNumberInstance();
-        numberInstance.setMaximumFractionDigits(2);
-        String smeltCount = numberInstance.format(fuel.burnTime / 200f);
-        Minecraft.getMinecraft().fontRenderer.drawString(translate("recipe.fuel.smeltCount", smeltCount), 73, 51, 0xFF000000);
+        float burnTime = fuel.burnTime / 200F;
+
+        if (gui.isMouseOver(fuel.stack, recipe) && burnTime < 1) {
+            burnTime = 1F / burnTime;
+            String s_time = Float.toString(burnTime);
+            if (burnTime == Math.round(burnTime))
+                s_time = Integer.toString((int) burnTime);
+
+            currenttip.add(translate("recipe.fuel.required", s_time));
+        } else if ((gui.isMouseOver(crecipe.getResult(), recipe) || gui.isMouseOver(crecipe.getIngredient(), recipe)) && burnTime > 1) {
+            String s_time = Float.toString(burnTime);
+            if (burnTime == Math.round(burnTime))
+                s_time = Integer.toString((int) burnTime);
+
+            currenttip.add(translate("recipe.fuel." + (gui.isMouseOver(crecipe.getResult(), recipe) ? "produced" : "processed"), s_time));
+        }
+
+        return currenttip;
     }
 }

src/main/java/codechicken/nei/recipe/FurnaceRecipeHandler.java

@@ -115,11 +115,6 @@ public class FurnaceRecipeHandler extends TemplateRecipeHandler
             }
     }
 
-    @Override
-    public String specifyTransferRect() {
-        return "smelting";
-    }
-
     @Override
     public String getGuiTexture() {
         return "textures/gui/container/furnace.png";

src/main/java/codechicken/nei/recipe/GuiCraftingRecipe.java

@@ -6,8 +6,6 @@ import codechicken.nei.NEIClientConfig;
 import codechicken.nei.NEIClientUtils;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.item.ItemStack;
-import codechicken.nei.ItemPanels;
 
 import java.util.ArrayList;
 import java.util.concurrent.ExecutionException;
@@ -48,19 +46,9 @@ public class GuiCraftingRecipe extends GuiRecipe
         handlers.sort(NEIClientConfig.HANDLER_COMPARATOR);
 
         mc.displayGuiScreen(new GuiCraftingRecipe(prevscreen, handlers));
-        
-        if (NEIClientConfig.saveCurrentRecipeInBookmarksEnabled() && !NEIClientUtils.shiftKey() && outputId.equals("item") && mc.currentScreen instanceof GuiRecipe) {
-            GuiCraftingRecipe.openTargetRecipe((GuiRecipe)mc.currentScreen, (ItemStack)results[0]);
-        }
-
         return true;
     }
 
-    protected static void openTargetRecipe(GuiRecipe currentScreen, ItemStack stackover)
-    {
-        currentScreen.openTargetRecipe(ItemPanels.bookmarkPanel.getBookmarkRecipeId(stackover));
-    }
-
     private GuiCraftingRecipe(GuiScreen prevgui, ArrayList<ICraftingHandler> handlers) {
         super(prevgui);
         currenthandlers = handlers;

src/main/java/codechicken/nei/recipe/GuiRecipe.java

@@ -35,7 +35,6 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
-import java.util.regex.Matcher;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -76,7 +75,6 @@ public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOve
     
     private final Rectangle area = new Rectangle();
     private final GuiRecipeTabs recipeTabs;
-    private final GuiRecipeCatalyst guiRecipeCatalyst;
     private IRecipeHandler handler;
     private HandlerInfo handlerInfo;
     
@@ -85,7 +83,6 @@ public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOve
     protected GuiRecipe(GuiScreen prevgui) {
         super(new ContainerRecipe());
         recipeTabs = new GuiRecipeTabs(this);
-        guiRecipeCatalyst = new GuiRecipeCatalyst(this);
         slotcontainer = (ContainerRecipe) inventorySlots;
 
         this.prevGui = prevgui;
@@ -112,11 +109,7 @@ public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOve
         private HeightHack() {
             trueHeight = height;
 
-            boolean applyHeightHack =
-                    NEIClientConfig.heightHackHandlerRegex.stream()
-                            .map(pattern -> pattern.matcher(handler.getHandlerId()))
-                            .anyMatch(Matcher::matches);
-            if (applyHeightHack) {
+            if (NEIClientConfig.heightHackHandlers.contains(handler.getHandlerId())) {
                 // The old mods use the calculation ((height - 166) / 2) to compute the y-value of
                 // the top edge of the NEI window.
                 // guiTop is exactly that: the y-value of the top edge of the NEI window.
@@ -200,101 +193,20 @@ public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOve
         yShift = handlerInfo == null ? 0 : handlerInfo.getYShift();
     }
 
-    public void setRecipePage(int idx) {
-        setRecipePage(idx, 0);
-    }
 
-    public void setRecipePage(int idx, int position) {
+    public void setRecipePage(int idx) {
         recipetype = idx;
         if (recipetype < 0) recipetype = currenthandlers.size() - 1;
         else if (recipetype >= currenthandlers.size()) recipetype = 0;
 
         handler = currenthandlers.get(recipetype);
-        handlerInfo = GuiRecipeTab.getHandlerInfo(handler);
-        page = Math.min(Math.max(0, position), handler.numRecipes() - 1)  / getRecipesPerPage();
+        handlerInfo = getHandlerInfo(handler);
+        page = 0;
         recipeTabs.calcPageNumber();
         checkYShift();
         initOverlayButtons();
     }
 
-    public void openTargetRecipe(BookmarkRecipeId recipeId) 
-    {
-
-        if (recipeId == null) {
-            return;
-        }
-
-        if (recipeId.recipetype == -1 || recipeId.position == -1) {
-            recipeId.recipetype = 0;
-            recipeId.position = 0;
-
-            if (recipeId.handlerName != null) {
-
-                for (int j = 0; j < currenthandlers.size(); j++) {
-                    IRecipeHandler localHandler = currenthandlers.get(j);
-                    HandlerInfo localHandlerInfo = GuiRecipeTab.getHandlerInfo(localHandler);
-        
-                    if (localHandlerInfo.getHandlerName().equals(recipeId.handlerName)) {
-                        recipeId.recipetype = j;
-
-                        if (!recipeId.ingredients.isEmpty()) {
-                            for (int i = 0; i < localHandler.numRecipes(); i++) {
-
-                                if (recipeId.equalsIngredients(localHandler.getIngredientStacks(i))) {
-                                    recipeId.position = i;
-                                    break;
-                                }
-    
-                            }
-                        }
-        
-                        break;
-                    }
-
-                }
-
-            }
-
-        }
-
-        setRecipePage(recipeId.recipetype, recipeId.position);    
-    }
-
-    public List<PositionedStack> getFocusedRecipeIngredients()
-    {
-        final int recipesPerPage = getRecipesPerPage();
-
-        for (int idx = page * recipesPerPage; idx < handler.numRecipes() && idx < (page + 1) * recipesPerPage; idx++) {
-            if (recipeInFocus(idx)) {
-                return handler.getIngredientStacks(idx);
-            }
-        }
-
-        return null;
-    }
-
-    protected boolean recipeInFocus(int idx)
-    {
-        final PositionedStack result = handler.getResultStack(idx);
-        if (result != null && isMouseOver(result, idx)) {
-            return true;
-        }
-
-        final List<PositionedStack> stacks = handler.getOtherStacks(idx);
-        for (PositionedStack stack : stacks) {
-            if (isMouseOver(stack, idx)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    public String getHandlerName()
-    {
-        return handlerInfo.getHandlerName();
-    }
-
     public IRecipeHandler getHandler() {
         return handler;
     }
@@ -307,6 +219,7 @@ public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOve
         return IntStream.range(minIndex, maxIndex).boxed().collect(Collectors.toList());
     }
 
+
     @Override
     public void keyTyped(char c, int i) {
         if (i == Keyboard.KEY_ESCAPE) //esc
@@ -441,6 +354,21 @@ public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOve
         setRecipePage(--recipetype);
     }
 
+    public HandlerInfo getHandlerInfo(IRecipeHandler handler) {
+        final String handlerID;
+        if(handler instanceof TemplateRecipeHandler) {
+            handlerID = (((TemplateRecipeHandler)handler).getOverlayIdentifier());
+        } else {
+            handlerID = null;
+        }
+        HandlerInfo info = GuiRecipeTab.getHandlerInfo(handler.getHandlerId(), handlerID);
+        
+        if (info == null)
+            return GuiRecipeTab.DEFAULT_HANDLER_INFO;
+        
+        return info;
+    }
+
     private void overlayRecipe(int recipe) {
         final IRecipeOverlayRenderer renderer = handler.getOverlayRenderer(firstGui, recipe);
         final IOverlayHandler overlayHandler = handler.getOverlayHandler(firstGui, recipe);
@@ -456,7 +384,6 @@ public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOve
     }
     
     public void refreshPage() {
-        RecipeCatalysts.updatePosition(ySize - BG_TOP_HEIGHT - (GuiRecipeCatalyst.fullBorder * 2));
         refreshSlots();
         final int recipesPerPage = getRecipesPerPage();
         final boolean multiplepages = handler.numRecipes() > recipesPerPage;
@@ -506,13 +433,6 @@ public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOve
             PositionedStack result = handler.getResultStack(i);
             if (result != null)
                 slotcontainer.addSlot(result, p.x, p.y);
-
-            List<PositionedStack> catalysts = RecipeCatalysts.getRecipeCatalysts(handler);
-            for (PositionedStack catalyst : catalysts) {
-                int xOffset = -GuiRecipeCatalyst.ingredientSize + 1;
-                int yOffset = BG_TOP_Y + GuiRecipeCatalyst.fullBorder;
-                slotcontainer.addSlot(catalyst, xOffset, yOffset);
-            }
         }
     }
 
@@ -597,9 +517,6 @@ public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOve
             RenderHelper.enableGUIStandardItemLighting();
             OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240f, 240f);
             recipeTabs.draw(mouseX, mouseY);
-            if (NEIClientConfig.areJEIStyleRecipeCatalystsVisible()) {
-                guiRecipeCatalyst.draw();
-            }
             RenderHelper.disableStandardItemLighting();
         }
 
@@ -662,12 +579,8 @@ public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOve
             return false;
         }
     }
-
-    private int getRecipesPerPage() {
-        return getRecipesPerPage(handlerInfo);
-    }
     
-    private int getRecipesPerPage(HandlerInfo handlerInfo) {
+    private int getRecipesPerPage() {
         if(handlerInfo != null) 
             return Math.max(Math.min(((ySize - (buttonHeight*3)) / handlerInfo.getHeight()), handlerInfo.getMaxRecipesPerPage()), 1);
         else
@@ -705,7 +618,9 @@ public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOve
     @Override
     public boolean hideItemPanelSlot(GuiContainer gui, int x, int y, int w, int h) {
         // Because some of the handlers *cough avaritia* are oversized
-        return area.intersects(x, y, w, h);
+        Rectangle rect = new Rectangle(area);
+
+        return rect.contains(x, y, w, h);
     }
 
 }

src/main/java/codechicken/nei/recipe/GuiRecipeCatalyst.java

@@ -1,107 +0,0 @@
-package codechicken.nei.recipe;
-
-import codechicken.nei.api.INEIGuiAdapter;
-import codechicken.nei.drawable.GuiElementDuex;
-import codechicken.nei.drawable.GuiElementScalable;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.util.ResourceLocation;
-import org.lwjgl.util.Rectangle;
-
-public class GuiRecipeCatalyst extends INEIGuiAdapter {
-    private GuiRecipe guiRecipe;
-    public static final int ingredientSize = 16;
-    public static final int ingredientBorder = 1;
-    public static final int tabBorder = 5;
-    public static final int fullBorder = ingredientBorder + tabBorder;
-
-    private static final Rectangle catalystRect = new Rectangle();
-    private static final Rectangle targetRect = new Rectangle();
-
-    public GuiRecipeCatalyst(GuiRecipe guiRecipe) {
-        this.guiRecipe = guiRecipe;
-    }
-
-    public void draw() {
-        if (guiRecipe == null) return;
-        int catalystsSize = RecipeCatalysts.getRecipeCatalysts(guiRecipe.getHandler()).size();
-        if (catalystsSize == 0) return;
-
-        int availableHeight = RecipeCatalysts.getHeight();
-        int columnCount = RecipeCatalysts.getColumnCount(availableHeight, catalystsSize);
-        int rowCount = RecipeCatalysts.getRowCount(availableHeight, catalystsSize);
-        int width, height, xPos, yPos;
-
-        width = (ingredientBorder * 2) + (tabBorder * 2) + (columnCount * ingredientSize);
-        height = (ingredientBorder * 2) + (tabBorder * 2) + (rowCount * ingredientSize);
-        xPos = guiRecipe.guiLeft - width + tabBorder + 1;
-        yPos = guiRecipe.guiTop;
-        drawBordered("nei:textures/catalyst_tab.png", xPos, yPos, width, height, 28, 28, 6, 6, 6, 6);
-
-        width = (ingredientBorder * 2) + (columnCount * ingredientSize);
-        height = (ingredientBorder * 2) + (rowCount * ingredientSize);
-        xPos = guiRecipe.guiLeft - width + ingredientBorder + 1;
-        yPos = guiRecipe.guiTop + fullBorder - ingredientBorder;
-        drawBordered("nei:textures/slot.png", xPos, yPos, width, height, 18, 18, 1, 1, 1, 1);
-    }
-
-    @Override
-    public boolean hideItemPanelSlot(GuiContainer gui, int x, int y, int w, int h) {
-        if (!(gui instanceof GuiRecipe)) return false;
-        guiRecipe = (GuiRecipe) gui;
-        int catalystsSize = RecipeCatalysts.getRecipeCatalysts(guiRecipe.getHandler()).size();
-        if (catalystsSize == 0) return false;
-
-        int availableHeight = RecipeCatalysts.getHeight();
-        int columnCount = RecipeCatalysts.getColumnCount(availableHeight, catalystsSize);
-        int rowCount = RecipeCatalysts.getRowCount(availableHeight, catalystsSize);
-        int margin = 4;
-
-        int width = (ingredientBorder * 2) + (tabBorder * 2) + (columnCount * ingredientSize) + margin;
-        int height = (ingredientBorder * 2) + (tabBorder * 2) + (rowCount * ingredientSize) + margin;
-        int xOffset = guiRecipe.guiLeft - width + tabBorder;
-        int yOffset = guiRecipe.guiTop;
-        catalystRect.setBounds(xOffset, yOffset, width, height);
-        targetRect.setBounds(x, y, w, h);
-        return targetRect.intersects(catalystRect);
-    }
-
-    private void drawBordered(String location, int xPos, int yPos, int width, int height, int texWidth, int texHeight, int sliceLeft, int sliceRight, int sliceTop, int sliceBottom) {
-        Minecraft.getMinecraft().renderEngine.bindTexture(new ResourceLocation(location));
-
-        GuiElementDuex cornerTopLeft = new GuiElementDuex(0, 0, sliceLeft, sliceTop, texWidth, texHeight);
-        GuiElementDuex cornerTopRight = new GuiElementDuex(texWidth - sliceRight, 0, sliceRight, sliceTop, texWidth, texHeight);
-        GuiElementDuex cornerBottomLeft = new GuiElementDuex(0, texHeight - sliceBottom, sliceLeft, sliceBottom, texWidth, texHeight);
-        GuiElementDuex cornerBottomRight = new GuiElementDuex(texWidth - sliceRight, texHeight - sliceBottom, sliceRight, sliceBottom, texWidth, texHeight);
-
-        GuiElementScalable borderTop = new GuiElementScalable(sliceLeft, 0, texWidth - sliceLeft - sliceRight, sliceTop, texWidth, texHeight);
-        GuiElementScalable borderBottom = new GuiElementScalable(sliceLeft, texHeight - sliceBottom, texWidth - sliceLeft - sliceRight, sliceBottom, texWidth, texHeight);
-        GuiElementScalable borderLeft = new GuiElementScalable(0, sliceTop, sliceLeft, texHeight - sliceTop - sliceBottom, texWidth, texHeight);
-        GuiElementScalable borderRight = new GuiElementScalable(texWidth - sliceRight, sliceTop, sliceRight, texHeight - sliceTop - sliceBottom, texWidth, texHeight);
-        GuiElementScalable center = new GuiElementScalable(sliceLeft, sliceTop, texWidth - sliceLeft - sliceRight, texHeight - sliceTop - sliceBottom, texWidth, texHeight);
-
-        int midW = width - borderLeft.w - borderRight.w;
-        int midH = height - borderTop.h - borderBottom.h;
-
-        // top row
-        int x = xPos;
-        int y = yPos;
-        x += cornerTopLeft.draw(x, y);
-        x += borderTop.drawScaledX(x, y, midW);
-        cornerTopRight.draw(x, y);
-
-        // center row
-        x = xPos;
-        y += borderTop.h;
-        x += borderLeft.drawScaledY(x, y, midH);
-        x += center.drawScaled(x, y, midW, midH);
-        borderRight.drawScaledY(x, y, midH);
-
-        // bottom row
-        x = xPos;
-        y += midH;
-        x += cornerBottomLeft.draw(x, y);
-        x += borderBottom.drawScaledX(x, y, midW);
-        cornerBottomRight.draw(x, y);
-    }
-}

src/main/java/codechicken/nei/recipe/GuiRecipeTab.java

@@ -64,9 +64,9 @@ public abstract class GuiRecipeTab extends Widget {
         this.handlerName = handler.getHandlerId();
         this.guiRecipe = guiRecipe;
         this.selected = false;
-
+        
         if(handler instanceof TemplateRecipeHandler) {
-            handlerID = handler.getOverlayIdentifier();
+            handlerID = (((TemplateRecipeHandler)handler).getOverlayIdentifier());
         } else {
             handlerID = null;
         }
@@ -130,7 +130,7 @@ public abstract class GuiRecipeTab extends Widget {
     }
 
     public void addTooltips(List<String> tooltip) {
-        tooltip.add(handler.getRecipeTabName().trim());
+        tooltip.add(handler.getRecipeName().trim());
         
         String handlerMod = getHandlerMod(handlerName, handlerID);
         tooltip.add(EnumChatFormatting.BLUE + handlerMod);
@@ -157,24 +157,6 @@ public abstract class GuiRecipeTab extends Widget {
         selected = handler == current;
     }
 
-    public static HandlerInfo getHandlerInfo(IRecipeHandler handler)
-    {
-        final String handlerID;
-
-        if (handler instanceof TemplateRecipeHandler) {
-            handlerID = handler.getOverlayIdentifier();
-        } else {
-            handlerID = null;
-        }
-
-        HandlerInfo info = getHandlerInfo(handler.getHandlerId(), handlerID);
-        
-        if (info == null)
-            return GuiRecipeTab.DEFAULT_HANDLER_INFO;
-        
-        return info;
-    }
-
     public static HandlerInfo getHandlerInfo(String name, String name2) {
         HandlerInfo res = handlerMap.get(name);
         if (res == null) res = handlerMap.get(name2);
@@ -207,7 +189,7 @@ public abstract class GuiRecipeTab extends Widget {
         } else {
             File handlerFile = NEIClientConfig.handlerFile;
             if(!handlerFile.exists()) {
-                NEIClientConfig.logger.info("Config file doesn't exist, creating");
+                NEIClientConfig.logger.info("Config file doesn't exit, creating");
                 try {
                     assert handlerUrl != null;
                     ReadableByteChannel readableByteChannel = Channels.newChannel(handlerUrl.openStream());
@@ -272,6 +254,9 @@ public abstract class GuiRecipeTab extends Widget {
                 handlerMap.put(handler, info);
                 NEIClientConfig.logger.info("Loaded " + handler);
             }
+        } catch (IOException e) {
+            NEIClientConfig.logger.info("Error parsing CSV");
+            e.printStackTrace();
         } catch (Exception e) {
             NEIClientConfig.logger.info("Error parsing CSV");
             e.printStackTrace();

src/main/java/codechicken/nei/recipe/GuiUsageRecipe.java

@@ -25,12 +25,12 @@ public class GuiUsageRecipe extends GuiRecipe
 
         profiler.start("recipe.concurrent.usage");
         try {
-            handlers = serialUsageHandlers.stream().map(h -> getUsageOrCatalystHandler(h, inputId, ingredients))
+            handlers = serialUsageHandlers.stream().map(h -> h.getUsageHandler(inputId, ingredients))
                 .filter(h -> h.numRecipes() > 0)
                 .collect(Collectors.toCollection(ArrayList::new));
-
+            
             handlers.addAll(ItemList.forkJoinPool.submit(() -> usagehandlers.parallelStream()
-                .map(h -> getUsageOrCatalystHandler(h, inputId, ingredients))
+                .map(h -> h.getUsageHandler(inputId, ingredients))
                 .filter(h -> h.numRecipes() > 0)
                 .collect(Collectors.toCollection(ArrayList::new))).get());
         } catch (InterruptedException | ExecutionException e) {
@@ -69,15 +69,6 @@ public class GuiUsageRecipe extends GuiRecipe
         return currenthandlers;
     }
 
-    private static IUsageHandler getUsageOrCatalystHandler(IUsageHandler handler, String inputId, Object... ingredients) {
-        boolean skipCatalyst = NEIClientUtils.controlKey();
-        if (NEIClientConfig.areJEIStyleRecipeCatalystsVisible() && !skipCatalyst) {
-            return handler.getUsageAndCatalystHandler(inputId, ingredients);
-        } else {
-            return handler.getUsageHandler(inputId, ingredients);
-        }
-    }
-
     public ArrayList<IUsageHandler> currenthandlers;
 
     public static ArrayList<IUsageHandler> usagehandlers = new ArrayList<>();

src/main/java/codechicken/nei/recipe/HandlerInfo.java

@@ -1,7 +1,6 @@
 package codechicken.nei.recipe;
 
 import codechicken.nei.NEIClientConfig;
-import codechicken.nei.NEIServerUtils;
 import codechicken.nei.drawable.DrawableBuilder;
 import codechicken.nei.drawable.DrawableResource;
 import cpw.mods.fml.common.FMLLog;
@@ -17,7 +16,7 @@ import org.apache.logging.log4j.Level;
 public class HandlerInfo {
     public static int DEFAULT_HEIGHT = 65;
     public static int DEFAULT_WIDTH = 166;
-    public static int DEFAULT_MAX_PER_PAGE = 1;
+    public static int DEFAULT_MAX_PER_PAGE = 2;
     
     private String handlerName;
     
@@ -54,10 +53,48 @@ public class HandlerInfo {
     public boolean setItem(String itemId, String nbtString) {
         if(hasImageOrItem())
             return false;
+        
+        int meta = -1;
+        if (!itemId.contains(":")) {
+            NEIClientConfig.logger.info("Item ID missing colon for handler " + handlerName + " - " + modName);
+            return false;
+        }
+        final String[] split = itemId.split(":");
+        // ModID:ItemID
+        String itemLookupId = split[0] + ":" + split[1];
 
-        itemStack = NEIServerUtils.getModdedItem(itemId, nbtString);
+        if(split.length >= 3) {
+            int mIdx = -1;
+            if (split[2].matches("\\d+")) {
+                mIdx = 2;
+            } else {
+                itemLookupId += ":" + split[2];
+                if (split.length >= 4) mIdx = 3;
+            }
+            if (mIdx != -1) meta = Integer.parseInt(split[mIdx]);
+        }
+
+        if (meta != -1) {
+            itemStack = GameRegistry.makeItemStack(itemLookupId, meta, 1, nbtString == null ? "" : nbtString);
+        } else {
+            itemStack = GameRegistry.findItemStack(split[0], split[1], 1);
+            if (nbtString != null && !nbtString.equals("")) {
+                try {
+                    final NBTBase nbttag = JsonToNBT.func_150315_a(nbtString);
+                    if (!(nbttag instanceof NBTTagCompound)) {
+                        NEIClientConfig.logger.info("Unexpected NBT string - multiple values {}", nbtString);
+                        return false;
+                    }
+
+                    itemStack.setTagCompound((NBTTagCompound) nbttag);
+                } catch (NBTException e) {
+                    FMLLog.getLogger().log(Level.WARN, "Encountered an exception parsing ItemStack NBT string {}", nbtString, e);
+                    return false;
+                }
+            }
+        }
         if (itemStack == null)
-            NEIClientConfig.logger.info("Couldn't find " + modName + " - " + itemId);
+            NEIClientConfig.logger.info("Couldn't find " + modName + " - " + itemLookupId);
         else {
             this.itemId = itemId;
             this.nbtString = nbtString;

src/main/java/codechicken/nei/recipe/IRecipeHandler.java

@@ -29,55 +29,46 @@ public interface IRecipeHandler
      * @return The name of this inventory. 
      * To be displayed at the top of the viewing container.
      */
-    String getRecipeName();
-
-    /**
-     * For legacy compatibility reasons, this method's default implementation returns the recipe name. This is also the expected behavior
-     *
-     * @return The name of this inventory.
-     * To be displayed in the tooltip in the tab at the top of the viewing container.
-     */
-    default String getRecipeTabName() {
-        return getRecipeName();
-    }
-
+    public String getRecipeName();
     /**
      * 
      * @return The number of recipes that this handler contains.
      */
-    int numRecipes();
+    public int numRecipes();
     /**
      * Draw the background of this recipe handler (basically the slot layout image).
+     * @param gui A GuiManager for drawing functions.
      * @param recipe The recipe index to draw at this position.
      */
-    void drawBackground(int recipe);
+    public void drawBackground(int recipe);
     /**
      * Draw the foreground of this recipe handler (for things like progress bars).
+     * @param gui A GuiManager for drawing functions.
      * @param recipe The recipe index to draw at this position.
      */
-    void drawForeground(int recipe);
+    public void drawForeground(int recipe);
     /**
      * 
      * @param recipe The recipe index to get items for.
      * @return A list of the ingredient {@link PositionedStack}s in this recipe relative to the top left corner of your recipe drawing space.
      */
-    List<PositionedStack> getIngredientStacks(int recipe);
+    public List<PositionedStack> getIngredientStacks(int recipe);
     /**
      * 
-     * @param recipetype The recipe index to get items for.
+     * @param recipe The recipe index to get items for.
      * @return A list of the other {@link PositionedStack}s in this recipe relative to the top left corner of your recipe drawing space. For example fuel in furnaces.
      */
-    List<PositionedStack> getOtherStacks(int recipetype);
+    public List<PositionedStack> getOtherStacks(int recipetype);
     /**
      * 
      * @param recipe The recipe index to get the result for.
      * @return The recipe result {@link PositionedStack} relative to the top left corner of your recipe drawing space.
      */
-    PositionedStack getResultStack(int recipe);
+    public PositionedStack getResultStack(int recipe);
     /**
      * A tick function called for updating progress bars and cycling damage items.
      */
-    void onUpdate();
+    public void onUpdate();
     /**
      * 
      * @param recipe The recipe index to check for.
@@ -85,33 +76,24 @@ public interface IRecipeHandler
      * @param container The container of the GUI.
      * @return true if this recipe can render an overlay for the specified type of inventory GUI.
      */
-    boolean hasOverlay(GuiContainer gui, Container container, int recipe);
+    public boolean hasOverlay(GuiContainer gui, Container container, int recipe);    
     /**
      * 
      * @param recipe The recipe index to get the overlay renderer for.
      * @return An instance of {@link IRecipeOverlayRenderer} to be used for rendering the overlay of this specific recipe.
      */
-    IRecipeOverlayRenderer getOverlayRenderer(GuiContainer gui, int recipe);
+    public IRecipeOverlayRenderer getOverlayRenderer(GuiContainer gui, int recipe);
     /**
      * 
      * @param recipe The recipe index to get the overlay renderer for.
      * @return An instance of {@link IOverlayHandler} to be used for rendering the overlay of this specific recipe.
      */
-    IOverlayHandler getOverlayHandler(GuiContainer gui, int recipe);
-    /**
-     * Simply works with the {@link codechicken.nei.api.DefaultOverlayRenderer}
-     * If the current container has been registered with this identifier, the question mark appears and an overlay guide can be drawn.
-     *
-     * @return The overlay identifier of this recipe type.
-     */
-    default String getOverlayIdentifier() {
-        return null;
-    }
+    public IOverlayHandler getOverlayHandler(GuiContainer gui, int recipe);
     /**
      * 
      * @return The number of recipes that can fit on a page in the viewer (1 or 2)
      */
-    int recipiesPerPage();
+    public int recipiesPerPage();
     /**
      * 
      * @param gui An instance of the currentscreen
@@ -119,16 +101,16 @@ public interface IRecipeHandler
      * @param recipe The recipe index being handled
      * @return The modified tooltip. DO NOT return null
      */
-    List<String> handleTooltip(GuiRecipe gui, List<String> currenttip, int recipe);
+    public List<String> handleTooltip(GuiRecipe gui, List<String> currenttip, int recipe);
     /**
      * 
      * @param gui An instance of the currentscreen
-     * @param stack The itemstack currently under the mouse
-     * @param currenttip The current tooltip, will contain item name and info
+     * @param The itemstack currently under the mouse
+     * @param The current tooltip, will contain item name and info
      * @param recipe The recipe index being handled
      * @return The modified tooltip. DO NOT return null
      */
-    List<String> handleItemTooltip(GuiRecipe gui, ItemStack stack, List<String> currenttip, int recipe);
+    public List<String> handleItemTooltip(GuiRecipe gui, ItemStack stack, List<String> currenttip, int recipe);
     
     /**
      * 
@@ -137,7 +119,7 @@ public interface IRecipeHandler
      * @param keyCode The KeyCode as defined in {@link Keyboard}
      * @return true to terminate further processing of this event.
      */
-    boolean keyTyped(GuiRecipe gui, char keyChar, int keyCode, int recipe);
+    public boolean keyTyped(GuiRecipe gui, char keyChar, int keyCode, int recipe);
 
     /**
      * 
@@ -145,7 +127,7 @@ public interface IRecipeHandler
      * @param button The button index being pressed, {0 = Left Click, 1 = Right Click, 2 = Middle Click}
      * @return true to terminate further processing of this event.
      */
-    boolean mouseClicked(GuiRecipe gui, int button, int recipe);
+    public boolean mouseClicked(GuiRecipe gui, int button, int recipe);
 
     /**
      * For legacy compatibility reasons, this method has a do-nothing default implementation.

src/main/java/codechicken/nei/recipe/IUsageHandler.java

@@ -15,12 +15,5 @@ public interface IUsageHandler extends IRecipeHandler
      * @param ingredients Objects representing the ingredients that matching recipes must contain.
      * @return An instance of {@link IUsageHandler} configured with a list of recipes that contain matching input
      */
-    IUsageHandler getUsageHandler(String inputId, Object... ingredients);
-
-    /**
-     * See {@link TemplateRecipeHandler#getUsageAndCatalystHandler} for implementation
-     */
-    default IUsageHandler getUsageAndCatalystHandler(String inputId, Object... ingredients) {
-        return getUsageHandler(inputId, ingredients);
-    }
+    public IUsageHandler getUsageHandler(String inputId, Object... ingredients);
 }

src/main/java/codechicken/nei/recipe/RecipeCatalysts.java

@@ -1,267 +0,0 @@
-package codechicken.nei.recipe;
-
-import codechicken.nei.NEIClientConfig;
-import codechicken.nei.NEIServerUtils;
-import codechicken.nei.PositionedStack;
-import com.google.common.base.Objects;
-import cpw.mods.fml.common.Loader;
-import net.minecraft.item.ItemStack;
-import org.apache.commons.csv.CSVFormat;
-import org.apache.commons.csv.CSVParser;
-import org.apache.commons.csv.CSVRecord;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.nio.channels.Channels;
-import java.nio.channels.FileChannel;
-import java.nio.channels.ReadableByteChannel;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-public class RecipeCatalysts {
-    private static final Map<String, CatalystInfoList> catalystsAdderFromAPI = new HashMap<>();
-    private static final Map<String, List<ItemStack>> catalystsRemoverFromAPI = new HashMap<>();
-    private static final Map<String, CatalystInfoList> recipeCatalystMap = new HashMap<>();
-    private static Map<String, List<PositionedStack>> positionedRecipeCatalystMap = new HashMap<>();
-    private static final List<String> forceClassNameList = new ArrayList<>();
-    private static int heightCache;
-
-    public static void addRecipeCatalyst(String handlerID, CatalystInfo catalystInfo) {
-        if (handlerID == null || handlerID.isEmpty() || catalystInfo.getStack() == null) return;
-        addOrPut(catalystsAdderFromAPI, handlerID, catalystInfo);
-    }
-
-    public static void removeRecipeCatalyst(String handlerID, ItemStack stack) {
-        if (handlerID == null || handlerID.isEmpty() || stack == null) return;
-        if (catalystsRemoverFromAPI.containsKey(handlerID)) {
-            catalystsRemoverFromAPI.get(handlerID).add(stack);
-        } else {
-            catalystsRemoverFromAPI.put(handlerID, new ArrayList<>(Collections.singletonList(stack)));
-        }
-    }
-
-    public static Map<String, List<PositionedStack>> getPositionedRecipeCatalystMap() {
-        return positionedRecipeCatalystMap;
-    }
-
-    public static List<PositionedStack> getRecipeCatalysts(IRecipeHandler handler) {
-        return getRecipeCatalysts(getRecipeID(handler));
-    }
-
-    public static List<PositionedStack> getRecipeCatalysts(String handlerID) {
-        if (!NEIClientConfig.areJEIStyleTabsVisible() || !NEIClientConfig.areJEIStyleRecipeCatalystsVisible()) {
-            return Collections.emptyList();
-        }
-        return positionedRecipeCatalystMap.getOrDefault(handlerID, Collections.emptyList());
-    }
-
-    public static boolean containsCatalyst(IRecipeHandler handler, ItemStack candidate) {
-        return containsCatalyst(getRecipeID(handler), candidate);
-    }
-
-    public static boolean containsCatalyst(String handlerID, ItemStack candidate) {
-        if (recipeCatalystMap.containsKey(handlerID)) {
-            return recipeCatalystMap.get(handlerID).contains(candidate);
-        }
-        return false;
-    }
-
-    public static void updatePosition(int availableHeight, boolean force) {
-        if (availableHeight == heightCache && !force) return;
-
-        Map<String, List<PositionedStack>> newMap = new HashMap<>();
-        for (Map.Entry<String, CatalystInfoList> entry : recipeCatalystMap.entrySet()) {
-            CatalystInfoList catalysts = entry.getValue();
-            catalysts.sort();
-            List<PositionedStack> newStacks = new ArrayList<>();
-            int rowCount = getRowCount(availableHeight, catalysts.size());
-
-            for (int index = 0; index < catalysts.size(); index++) {
-                ItemStack catalyst = catalysts.get(index).getStack();
-                int column = index / rowCount;
-                int row = index % rowCount;
-                newStacks.add(new PositionedStack(catalyst, -column * GuiRecipeCatalyst.ingredientSize, row * GuiRecipeCatalyst.ingredientSize));
-            }
-            newMap.put(entry.getKey(), newStacks);
-        }
-        positionedRecipeCatalystMap = newMap;
-        heightCache = availableHeight;
-    }
-
-    public static void updatePosition(int availableHeight) {
-        updatePosition(availableHeight, false);
-    }
-
-    public static int getHeight() {
-        return heightCache;
-    }
-
-    public static int getColumnCount(int availableHeight, int catalystsSize) {
-        int maxItemsPerColumn = availableHeight / GuiRecipeCatalyst.ingredientSize;
-        return NEIServerUtils.divideCeil(catalystsSize, maxItemsPerColumn);
-    }
-
-    public static int getRowCount(int availableHeight, int catalystsSize) {
-        int columnCount = getColumnCount(availableHeight, catalystsSize);
-        return NEIServerUtils.divideCeil(catalystsSize, columnCount);
-    }
-
-    public static void loadCatalystInfo() {
-        final boolean fromJar = NEIClientConfig.loadCatalystsFromJar();
-        NEIClientConfig.logger.info("Loading catalyst info from " + (fromJar ? "JAR" : "Config"));
-        recipeCatalystMap.clear();
-        URL handlerUrl = Thread.currentThread().getContextClassLoader().getResource("assets/nei/csv/catalysts.csv");
-
-        URL url;
-        if (fromJar) {
-            url = handlerUrl;
-            if (url == null) {
-                NEIClientConfig.logger.warn("Invalid URL for catalysts csv.");
-                return;
-            }
-        } else {
-            File catalystFile = NEIClientConfig.catalystFile;
-            if(!catalystFile.exists()) {
-                NEIClientConfig.logger.info("Config file doesn't exist, creating");
-                try {
-                    assert handlerUrl != null;
-                    ReadableByteChannel readableByteChannel = Channels.newChannel(handlerUrl.openStream());
-                    FileOutputStream fileOutputStream = new FileOutputStream(catalystFile.getAbsoluteFile());
-                    FileChannel fileChannel = fileOutputStream.getChannel();
-                    fileChannel.transferFrom(readableByteChannel, 0, Long.MAX_VALUE);
-                } catch (IOException e) {
-                    e.printStackTrace();
-                    return;
-                }
-            }
-            try {
-                url = NEIClientConfig.catalystFile.toURI().toURL();
-            } catch (MalformedURLException e) {
-                NEIClientConfig.logger.warn("Invalid URL for catalysts csv (via config).");
-                e.printStackTrace();
-                return;
-            }
-        }
-        try (BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()))) {
-            CSVParser csvParser = CSVFormat.EXCEL.withFirstRecordAsHeader().parse(reader);
-            for (CSVRecord record : csvParser) {
-                final String handler = record.get("handler");
-                final String modId = record.get("modId");
-                final boolean requiresMod = Boolean.parseBoolean(record.get("modRequired"));
-                final String excludedModId = record.get("excludedModId");
-                final int priority = intOrDefault(record.get("priority"), 0);
-                // todo
-                final String minVersion = record.get("minVersion");
-                final String maxVersion = record.get("maxVersion");
-                final boolean forceClassName = Boolean.parseBoolean(record.get("forceClassName"));
-
-                if (requiresMod && !Loader.isModLoaded(modId)) continue;
-                if (excludedModId != null && Loader.isModLoaded(excludedModId)) continue;
-
-                String itemName = record.get("itemName");
-                if (itemName == null || itemName.isEmpty()) continue;
-                ItemStack stack = NEIServerUtils.getModdedItem(itemName, record.get("nbtInfo"));
-                if (stack == null) {
-                    NEIClientConfig.logger.warn("Couldn't find ItemStack " + itemName);
-                    continue;
-                }
-                CatalystInfo catalystInfo = new CatalystInfo(stack, priority);
-
-                String handlerID;
-                try {
-                    // gently handling copy&paste from handlers.csv
-                    Class<?> clazz = Class.forName(handler);
-                    Object object = clazz.newInstance();
-                    if (object instanceof IRecipeHandler) {
-                        if (forceClassName) {
-                            forceClassNameList.add(handler);
-                        }
-                        handlerID = getRecipeID((IRecipeHandler) object);
-                    } else {
-                        handlerID = handler;
-                    }
-                } catch (ClassNotFoundException ignored) {
-                    handlerID = handler;
-                } catch (InstantiationException ignored) {
-                    NEIClientConfig.logger.warn("failed to create instance for " + handler);
-                    handlerID = handler;
-                }
-
-                addOrPut(recipeCatalystMap, handlerID, catalystInfo);
-            }
-        } catch (Exception e) {
-            NEIClientConfig.logger.warn("Error parsing CSV");
-            e.printStackTrace();
-        }
-
-        for (Map.Entry<String, CatalystInfoList> entry : catalystsAdderFromAPI.entrySet()) {
-            String handlerID = entry.getKey();
-            for (CatalystInfo catalyst : entry.getValue()) {
-                addOrPut(recipeCatalystMap, handlerID, catalyst);
-            }
-        }
-
-        for (Map.Entry<String, List<ItemStack>> entry : catalystsRemoverFromAPI.entrySet()) {
-            String handlerID = entry.getKey();
-            if (recipeCatalystMap.containsKey(handlerID)) {
-                CatalystInfoList catalysts = recipeCatalystMap.get(handlerID);
-                entry.getValue().forEach(catalysts::remove);
-            }
-        }
-
-        updatePosition(getHeight(), true);
-    }
-
-    /**
-     * Basically {@link NEIClientConfig#HANDLER_ID_FUNCTION}.
-     * Force using {@link IRecipeHandler#getHandlerId()} if specified in catalysts.csv.
-     * In other words, refuse to share handlerID defined in {@link TemplateRecipeHandler#getOverlayIdentifier()}.
-     */
-    public static String getRecipeID(IRecipeHandler handler) {
-        if (forceClassNameList.stream().anyMatch(s -> s.equals(handler.getHandlerId()))) {
-            return handler.getHandlerId();
-        }
-        return Objects.firstNonNull(
-                handler.getOverlayIdentifier(),
-                handler.getHandlerId());
-    }
-
-    private static void addOrPut(Map<String, CatalystInfoList> map, String handlerID, CatalystInfo catalyst) {
-        if (map.containsKey(handlerID)) {
-            map.get(handlerID).add(catalyst);
-        } else {
-            map.put(handlerID, new CatalystInfoList(handlerID, catalyst));
-        }
-    }
-
-    private static int intOrDefault(String str, int defaultValue) {
-        if (str == null || str.equals("")) return defaultValue;
-        try {
-            return Integer.parseInt(str);
-        } catch (NumberFormatException e) {
-            return defaultValue;
-        }
-    }
-
-    @Deprecated
-    public static void addRecipeCatalyst(List<ItemStack> stacks, Class<? extends IRecipeHandler> handler) {
-    }
-
-    @Deprecated
-    public static List<PositionedStack> getRecipeCatalysts(Class<? extends IRecipeHandler> handler) {
-        return Collections.emptyList();
-    }
-
-    @Deprecated
-    public static boolean containsCatalyst(Class<? extends IRecipeHandler> handler, ItemStack candidate) {
-        return false;
-    }
-}

src/main/java/codechicken/nei/recipe/RecipeInfo.java

@@ -120,5 +120,4 @@ public class RecipeInfo
         API.registerRecipeHandler(new ProfilerRecipeHandler(true));
         API.registerUsageHandler(new ProfilerRecipeHandler(false));
     }
-
 }

src/main/java/codechicken/nei/recipe/RecipeItemInputHandler.java

@@ -5,12 +5,9 @@ import codechicken.nei.NEIClientConfig;
 import codechicken.nei.NEIClientUtils;
 import codechicken.nei.guihook.GuiContainerManager;
 import codechicken.nei.guihook.IContainerInputHandler;
-import codechicken.nei.PositionedStack;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.item.ItemStack;
 
-import java.util.List;
-
 public class RecipeItemInputHandler implements IContainerInputHandler
 {
     @Override
@@ -26,17 +23,9 @@ public class RecipeItemInputHandler implements IContainerInputHandler
         if(keyCode == NEIClientConfig.getKeyBinding("gui.usage"))
             return GuiUsageRecipe.openRecipeGui("item", stackover.copy());
 
-        if (keyCode == NEIClientConfig.getKeyBinding("gui.bookmark")) {
+        if(keyCode == NEIClientConfig.getKeyBinding("gui.bookmark")) {
             NEIClientConfig.logger.debug("Adding or removing {} from bookmarks", stackover.getDisplayName());
-            List<PositionedStack> ingredients = null;
-            String handlerName = "";
-
-            if (gui instanceof GuiRecipe && NEIClientConfig.saveCurrentRecipeInBookmarksEnabled()) {
-                ingredients = ((GuiRecipe) gui).getFocusedRecipeIngredients();
-                handlerName = ((GuiRecipe) gui).getHandlerName();
-            }
-
-            ItemPanels.bookmarkPanel.addOrRemoveItem(stackover.copy(), handlerName, ingredients);
+            ItemPanels.bookmarkPanel.addOrRemoveItem(stackover.copy());
         }
 
         return false;
@@ -53,32 +42,27 @@ public class RecipeItemInputHandler implements IContainerInputHandler
         if (!(gui instanceof GuiRecipe))
             return false;
 
-        //disabled open recipe gui if hold shift (player have move recipe)
-        if (button == 0 && ItemPanels.bookmarkPanel.getStackMouseOver(mousex, mousey) != null && NEIClientUtils.shiftKey()) {
-            return false;
-        }
-
         if(button == 0)
             return GuiCraftingRecipe.openRecipeGui("item", stackover.copy());
 
         if(button == 1)
             return GuiUsageRecipe.openRecipeGui("item", stackover.copy());
-
+        
         return false;
     }
 
     @Override
-    public void onKeyTyped(GuiContainer gui, char keyChar, int keyID)
+    public void onKeyTyped(GuiContainer gui, char keyChar, int keyID) 
     {
     }
 
     @Override
-    public void onMouseClicked(GuiContainer gui, int mousex, int mousey, int button)
+    public void onMouseClicked(GuiContainer gui, int mousex, int mousey, int button) 
     {
     }
 
     @Override
-    public void onMouseUp(GuiContainer gui, int mousex, int mousey, int button)
+    public void onMouseUp(GuiContainer gui, int mousex, int mousey, int button) 
     {
     }
 
@@ -87,18 +71,18 @@ public class RecipeItemInputHandler implements IContainerInputHandler
     {
         return false;
     }
-
+    
     @Override
     public boolean mouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled)
     {
         return false;
     }
-
+    
     @Override
     public void onMouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled)
     {
     }
-
+    
     @Override
     public void onMouseDragged(GuiContainer gui, int mousex, int mousey, int button, long heldTime)
     {

src/main/java/codechicken/nei/recipe/StackInfo.java

@@ -1,207 +0,0 @@
-package codechicken.nei.recipe;
-
-import codechicken.nei.NEIClientConfig;
-import codechicken.nei.api.IStackStringifyHandler;
-import codechicken.nei.recipe.stackinfo.DefaultStackStringifyHandler;
-import codechicken.nei.recipe.stackinfo.GTFluidStackStringifyHandler;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTBase;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.nbt.NBTTagList;
-import net.minecraftforge.fluids.FluidStack;
-import org.apache.commons.io.IOUtils;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.WeakHashMap;
-
-public class StackInfo
-{
-
-
-    public static final ArrayList<IStackStringifyHandler> stackStringifyHandlers = new ArrayList<>();
-    private static final HashMap<String, HashMap<String, String[]>> guidfilters = new HashMap<>();
-    private static final WeakHashMap<ItemStack, String> guidcache = new WeakHashMap<>();
-    
-    static {
-        stackStringifyHandlers.add(new DefaultStackStringifyHandler());
-        stackStringifyHandlers.add(new GTFluidStackStringifyHandler());
-    }
-
-    public static NBTTagCompound itemStackToNBT(ItemStack stack)
-    {
-        return itemStackToNBT(stack, true);
-    }
-
-    public static NBTTagCompound itemStackToNBT(ItemStack stack, boolean saveStackSize)
-    {
-        NBTTagCompound nbTag = null;
-
-        for (int i = stackStringifyHandlers.size() - 1; i >= 0 && nbTag == null; i--) {
-            nbTag = stackStringifyHandlers.get(i).convertItemStackToNBT(stack, saveStackSize);
-        }
-
-        return nbTag;
-    }
-
-    public static ItemStack loadFromNBT(NBTTagCompound nbtTag)
-    {
-        ItemStack stack = null;
-
-        for (int i = stackStringifyHandlers.size() - 1; i >= 0 && nbtTag != null && stack == null; i--) {
-            stack = stackStringifyHandlers.get(i).convertNBTToItemStack(nbtTag);
-        }
-
-        return stack;
-    }
-
-    public static boolean equalItemAndNBT(ItemStack stackA, ItemStack stackB, boolean useNBT) 
-    {
-        if (!stackA.isItemEqual(stackB)) {
-            return false;
-        }
-
-        if (useNBT) {
-            NBTTagCompound tagCompoundA = itemStackToNBT(stackA, false);
-            NBTTagCompound tagCompoundB = itemStackToNBT(stackB, false);
-
-            return tagCompoundA == null && tagCompoundB == null || tagCompoundA != null && tagCompoundB != null && tagCompoundA.equals(tagCompoundB);
-        }
-
-        return true;
-    }
-
-    public static FluidStack getFluid(ItemStack stack)
-    {
-        FluidStack fluid = null;
-
-        for (int i = stackStringifyHandlers.size() - 1; i >= 0 && fluid == null; i--) {
-            fluid = stackStringifyHandlers.get(i).getFluid(stack);
-        }
-
-        return fluid;
-    }
-
-    public static String getItemStackGUID(ItemStack stack)
-    {
-        if (!guidcache.containsKey(stack)) {
-
-            final NBTTagCompound nbTag = itemStackToNBT(stack, false);
-
-            if (nbTag == null) {
-                return null;
-            }
-
-            nbTag.removeTag("Count");
-
-            if (nbTag.getShort("Damage") == 0) {
-                nbTag.removeTag("Damage");
-            }
-
-            if (nbTag.hasKey("tag") && nbTag.getCompoundTag("tag").hasNoTags()) {
-                nbTag.removeTag("tag");
-            }
-
-            if (nbTag.hasKey("strId") && guidfilters.containsKey(nbTag.getString("strId"))) {
-                final ArrayList<String> keys = new ArrayList<>();
-                final String strId = nbTag.getString("strId");
-
-                keys.add(strId);
-
-                guidfilters.get(strId).forEach((key, rule) -> {
-                    Object local = nbTag;
-
-                    for (int i = 0; i < rule.length; i++) {
-
-                        try {
-
-                            if (local instanceof NBTTagCompound) {
-                                local = ((NBTTagCompound) local).getTag(rule[i]);
-                            } else if (local instanceof NBTTagList) {
-                                local = ((NBTTagList) local).tagList.get(Integer.parseInt(rule[i]));
-                            } else {
-                                break;
-                            }
-
-                        } catch (Throwable e) {
-                            break;
-                        }
-
-                    }
-
-                    if (local instanceof NBTBase) {
-                        keys.add(((NBTBase)local).toString());
-                    } else if (local != null) {
-                        keys.add(String.valueOf(local));
-                    }
-
-                });
-
-                synchronized (guidcache) {
-                    guidcache.put(stack, keys.toString());
-                }
-            } else {
-                synchronized (guidcache) {
-                    guidcache.put(stack, nbTag.toString());
-                }
-            }
-
-        }
-
-        return guidcache.get(stack);
-    }
-
-    public static void loadGuidFilters()
-    {
-
-        guidfilters.clear();
-
-        final File guidFlitersFile = new File(NEIClientConfig.configDir, "guidfilters.cfg");
-        List<String> itemStrings = new ArrayList<>();
-
-        if (guidFlitersFile.exists()) {
-
-            try (FileReader reader = new FileReader(guidFlitersFile)) {
-                NEIClientConfig.logger.info("Loading guid filters from file {}", guidFlitersFile);
-                itemStrings = IOUtils.readLines(reader);
-            } catch (IOException e) {
-                NEIClientConfig.logger.error("Failed to load bookmarks from file {}", guidFlitersFile, e);
-                e.printStackTrace();
-            }
-
-        } else {
-            final URL filterUrl = Thread.currentThread().getContextClassLoader().getResource("assets/nei/guidfilters.cfg");
-                
-            try (BufferedReader reader = new BufferedReader(new InputStreamReader(filterUrl.openStream()))) {
-                itemStrings = IOUtils.readLines(reader);
-            } catch (IOException e) {
-                NEIClientConfig.logger.info("Error parsing guid filters");
-                e.printStackTrace();
-            } catch (Exception e) {
-                NEIClientConfig.logger.info("Error parsing guid filters");
-                e.printStackTrace();
-            }
-
-        }
-
-        for (String guidStr: itemStrings) {
-            final String[] parts = guidStr.split(",");
-            final HashMap<String, String[]> rules = new HashMap<>();
-
-            for (int j = 1; j < parts.length; j++) {
-                rules.put(parts[j], parts[j].split("\\."));
-            }
-               
-            guidfilters.put(parts[0], rules);
-        }
-
-    }
-
-}

src/main/java/codechicken/nei/recipe/TemplateRecipeHandler.java

@@ -219,17 +219,6 @@ public abstract class TemplateRecipeHandler implements ICraftingHandler, IUsageH
             return false;
         }
 
-        /**
-         * NBT-friendly version of {@link #contains(Collection, ItemStack)}
-         */
-        public boolean containsWithNBT(Collection<PositionedStack> ingredients, ItemStack ingredient) {
-            for (PositionedStack stack : ingredients)
-                if (stack.containsWithNBT(ingredient))
-                    return true;
-
-            return false;
-        }
-
         /**
          * @param ingred
          * @return true if any of the permutations of any of the ingredients contain this stack
@@ -453,7 +442,6 @@ public abstract class TemplateRecipeHandler implements ICraftingHandler, IUsageH
      *
      * @return The overlay identifier of this recipe type.
      */
-    @Override
     public String getOverlayIdentifier() {
         return null;
     }
@@ -562,36 +550,6 @@ public abstract class TemplateRecipeHandler implements ICraftingHandler, IUsageH
         return handler;
     }
 
-    /**
-     * First look up {@link RecipeCatalysts} whether target ingredient is registered for it.
-     * If so, load all recipes for this handler.
-     * Fallback to {@link TemplateRecipeHandler#getUsageHandler}.
-     */
-    public IUsageHandler getUsageAndCatalystHandler(String inputId, Object... ingredients) {
-        TemplateRecipeHandler handler = newInstance();
-        if (inputId.equals("item")) {
-            ItemStack candidate = (ItemStack) ingredients[0];
-            if (RecipeCatalysts.containsCatalyst(handler, candidate)) {
-                for (RecipeTransferRect rect : transferRects) {
-                    if (specifyTransferRect() == null || Objects.equals(rect.outputId, specifyTransferRect())) {
-                        handler.loadCraftingRecipes(rect.outputId, rect.results);
-                        return handler;
-                    }
-                }
-                NEIClientConfig.logger.info("failed to load catalyst handler, implement `loadTransferRects` for your handler " + handler.getClass().getName());
-            }
-        }
-        return this.getUsageHandler(inputId, ingredients);
-    }
-
-    /**
-     * Override this if you have multiple {@link RecipeTransferRect}s.
-     * Used for {@link TemplateRecipeHandler#getUsageAndCatalystHandler}.
-     */
-    public String specifyTransferRect() {
-        return null;
-    }
-
     public int numRecipes() {
         return arecipes.size();
     }

src/main/java/codechicken/nei/recipe/stackinfo/DefaultStackStringifyHandler.java

@@ -1,62 +0,0 @@
-package codechicken.nei.recipe.stackinfo;
-
-import codechicken.nei.api.IStackStringifyHandler;
-import cpw.mods.fml.common.registry.GameData;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraftforge.fluids.FluidContainerRegistry;
-import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.fluids.IFluidContainerItem;
-
-public class DefaultStackStringifyHandler implements IStackStringifyHandler
-{
-
-    public NBTTagCompound convertItemStackToNBT(ItemStack stack, boolean saveStackSize)
-    {
-        final String strId = Item.itemRegistry.getNameForObject(stack.getItem());
-
-        if (strId == null) {
-            return null;
-        }
-
-        final NBTTagCompound nbTag = new NBTTagCompound();
-        nbTag.setString("strId", strId);
-        nbTag.setInteger("Count", Math.max(saveStackSize? stack.stackSize: 1, 1));
-        nbTag.setShort("Damage", (short)stack.getItemDamage());
-      
-        if (stack.hasTagCompound()) {
-            nbTag.setTag("tag", stack.getTagCompound());
-        }
-
-        return nbTag;
-    }
-
-    public ItemStack convertNBTToItemStack(NBTTagCompound nbtTag)
-    {
-        final String strId = nbtTag.getString("strId");
-
-        nbtTag = (NBTTagCompound)nbtTag.copy();
-        nbtTag.setInteger("id", GameData.getItemRegistry().getId(strId)); //getObject
-
-        final ItemStack stack = ItemStack.loadItemStackFromNBT(nbtTag);
-
-        if (stack != null) {
-            stack.stackSize = nbtTag.getInteger("Count");
-        }
-
-        return stack;
-    }
-
-    public FluidStack getFluid(ItemStack stack)
-    {
-        FluidStack fluidStack = FluidContainerRegistry.getFluidForFilledItem(stack);
-
-        if (fluidStack == null && stack.getItem() instanceof IFluidContainerItem) {
-            fluidStack = ((IFluidContainerItem) stack.getItem()).getFluid(stack);
-        }
-
-        return fluidStack;
-    }
-    
-}

src/main/java/codechicken/nei/recipe/stackinfo/GTFluidStackStringifyHandler.java

@@ -1,87 +0,0 @@
-package codechicken.nei.recipe.stackinfo;
-
-import codechicken.nei.api.IStackStringifyHandler;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraftforge.fluids.Fluid;
-import net.minecraftforge.fluids.FluidRegistry;
-import net.minecraftforge.fluids.FluidStack;
-
-import java.lang.reflect.Method;
-
-public class GTFluidStackStringifyHandler implements IStackStringifyHandler
-{
-
-    public static Class GTDisplayFluid = null;
-    public static Method getFluidDisplayStack = null;
-    public static Method getFluidFromDisplayStack = null;
-    
-    static {
-        try {
-            final Class gtUtility = Class.forName("gregtech.api.util.GT_Utility");
-
-            GTDisplayFluid = Class.forName("gregtech.common.items.GT_FluidDisplayItem");
-            getFluidFromDisplayStack = gtUtility.getMethod("getFluidFromDisplayStack", ItemStack.class);
-            getFluidDisplayStack = gtUtility.getMethod("getFluidDisplayStack", FluidStack.class, boolean.class);
-
-        } catch (Exception ignored) { /*Do nothing*/ }
-    }
-
-    public NBTTagCompound convertItemStackToNBT(ItemStack stack, boolean saveStackSize)
-    {
-
-        if (GTDisplayFluid != null && GTDisplayFluid.isInstance(stack.getItem())) {
-            final FluidStack fluidStack = getFluid(stack);
-
-            if (fluidStack != null) {
-                final NBTTagCompound nbTag = new NBTTagCompound();
-                nbTag.setString("gtFluidName", fluidStack.getFluid().getName());
-                nbTag.setInteger("Count", saveStackSize? fluidStack.amount: 1);
-                return nbTag;
-            }
-
-        }
-
-        return null;
-    }
-
-    public ItemStack convertNBTToItemStack(NBTTagCompound nbtTag)
-    {
-
-        if (getFluidDisplayStack != null && nbtTag.hasKey("gtFluidName")) {
-            final String fluidName = nbtTag.getString("gtFluidName");
-            final Fluid fluid = FluidRegistry.getFluid(fluidName);
-            final int amount = nbtTag.getInteger("Count");
-
-            try {
-                final Object obj = getFluidDisplayStack.invoke(null, new FluidStack(fluid, amount), true);
-
-                if (obj != null) {
-                    return (ItemStack) obj;
-                }
-
-            } catch (Exception e) {}
-
-        }
-
-        return null;
-    }
-
-    public FluidStack getFluid(ItemStack stack)
-    {
-
-        if (getFluidFromDisplayStack != null && GTDisplayFluid != null && GTDisplayFluid.isInstance(stack.getItem())) {
-            try {
-                final Object obj = getFluidFromDisplayStack.invoke(null, stack);
-    
-                if (obj != null) {
-                    return (FluidStack) obj;
-                }
-    
-            } catch (Exception e) {}
-        }
-        
-        return null;
-    }
-    
-}

src/main/java/codechicken/nei/util/NBTHelper.java

@@ -1,59 +0,0 @@
-package codechicken.nei.util;
-
-import net.minecraft.nbt.NBTBase;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.nbt.NBTTagEnd;
-import net.minecraft.nbt.NBTTagList;
-
-import javax.annotation.Nullable;
-import java.util.Set;
-
-public class NBTHelper {
-
-    /*
-     * Taken from Botania r1.11-379 by Vazkii under the Botania License
-     * You can obtain one at https://botaniamod.net/license.php
-     */
-
-    /**
-     * Returns true if the `target` tag contains all of the tags and values present in the `template` tag. Recurses into
-     * compound tags and matches all template keys and values; recurses into list tags and matches the template against
-     * the first elements of target. Empty lists and compounds in the template will match target lists and compounds of
-     * any size.
-     */
-    public static boolean matchTag(@Nullable NBTBase template, @Nullable NBTBase target) {
-        if (template instanceof NBTTagCompound && target instanceof NBTTagCompound) {
-            return matchTagCompound((NBTTagCompound) template, (NBTTagCompound) target);
-        } else if (template instanceof NBTTagList && target instanceof NBTTagList) {
-            return matchTagList((NBTTagList) template, (NBTTagList) target);
-        } else {
-            return template == null || (target != null && target.equals(template));
-        }
-    }
-
-    private static boolean matchTagCompound(NBTTagCompound template, NBTTagCompound target) {
-        if (template.tagMap.size() > target.tagMap.size()) return false;
-
-        //noinspection unchecked
-        for (String key : (Set<String>) template.func_150296_c()) {
-            if (!matchTag(template.getTag(key), target.getTag(key))) return false;
-        }
-
-        return true;
-    }
-
-    private static boolean matchTagList(NBTTagList template, NBTTagList target) {
-        if (template.tagCount() > target.tagCount()) return false;
-
-        for (int i = 0; i < template.tagCount(); i++) {
-            if (!matchTag(get(template, i), get(target, i))) return false;
-        }
-
-        return true;
-    }
-
-    private static NBTBase get(NBTTagList tag, int idx)
-    {
-        return idx >= 0 && idx < tag.tagList.size() ? (NBTBase)tag.tagList.get(idx) : null;
-    }
-}

src/main/java/codechicken/nei/util/NBTJson.java

@@ -1,8 +1,11 @@
 package codechicken.nei.util;
 
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
 import com.google.gson.JsonPrimitive;
 import net.minecraft.nbt.NBTBase;
 import net.minecraft.nbt.NBTTagByte;
@@ -17,21 +20,22 @@ import net.minecraft.nbt.NBTTagLong;
 import net.minecraft.nbt.NBTTagShort;
 import net.minecraft.nbt.NBTTagString;
 
+import java.io.ByteArrayOutputStream;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.IntStream;
 
 public class NBTJson {
-    private static final Pattern numberPattern = Pattern.compile("^([-+]?\\d+\\.?\\d*E*\\d*)([bBsSlLfFdD]?)$");
+    private static final Pattern numberPattern = Pattern.compile("^([-+]?[\\d]+\\.?[0-9]*)([bBsSlLfFdD]?)$");
+    private static final JsonParser parser = new JsonParser();
+    private static final Gson gson = new GsonBuilder().create();
 
     public static String toJson(NBTTagCompound tag) {
-        return toJson(toJsonObject(tag));
-    }
-
-    public static String toJson(JsonElement json) {
-        return json.toString();
+        final String jsonString = toJsonObject(tag).toString();
+        return gson.toJson(parser.parse(jsonString));
     }
     
     @SuppressWarnings("unchecked")
@@ -42,30 +46,10 @@ public class NBTJson {
             final Map<String, NBTBase> tagMap = (Map<String, NBTBase>)nbtTagCompound.tagMap;
             
             JsonObject root = new JsonObject();
-
-            for (Map.Entry<String, NBTBase> nbtEntry : tagMap.entrySet()) {
+            for (Map.Entry<String, NBTBase> nbtEntry : tagMap.entrySet() ) {
                 root.add(nbtEntry.getKey(), toJsonObject(nbtEntry.getValue()));
             }
-
             return root;
-        } else if (nbt instanceof NBTTagByte) {
-            // Number (byte)
-            return new JsonPrimitive(Byte.toString(((NBTTagByte) nbt).func_150290_f()) + 'B');
-        } else if (nbt instanceof NBTTagShort) {
-            // Number (short)
-            return new JsonPrimitive(Short.toString(((NBTTagShort) nbt).func_150289_e()) + 'S');
-        } else if (nbt instanceof NBTTagInt) {
-            // Number (int)
-            return new JsonPrimitive(((NBTTagInt) nbt).func_150287_d());
-        } else if (nbt instanceof NBTTagLong) {
-            // Number (long)
-            return new JsonPrimitive(Long.toString(((NBTTagLong) nbt).func_150291_c()) + 'L');
-        } else if (nbt instanceof NBTTagFloat) {
-            // Number (float)
-            return new JsonPrimitive(Float.toString(((NBTTagFloat) nbt).func_150288_h()) + 'F');
-        } else if (nbt instanceof NBTTagDouble) {
-           // Number (double)
-           return new JsonPrimitive(Double.toString(((NBTTagDouble) nbt).func_150286_g()) + 'D');
         } else if (nbt instanceof NBTBase.NBTPrimitive) {
             // Number
             return new JsonPrimitive(((NBTBase.NBTPrimitive) nbt).func_150286_g());
@@ -74,48 +58,23 @@ public class NBTJson {
            return new JsonPrimitive(((NBTTagString) nbt).func_150285_a_());
         } else if (nbt instanceof NBTTagList) {
             // Tag List
-            final NBTTagList list = (NBTTagList) nbt;
-
-            if (list.tagList.isEmpty()) {
-                return createEmptyList(list);
-            } else {
-                JsonArray arr = new JsonArray();
-                list.tagList.forEach(c -> arr.add(toJsonObject((NBTBase) c)));
-                return arr;
-            }
-     
+            JsonArray arr = new JsonArray();
+            ((NBTTagList) nbt).tagList.forEach(c -> arr.add(toJsonObject((NBTBase) c)));
+            return arr;
         } else if (nbt instanceof NBTTagIntArray) {
             // Int Array
-            final NBTTagIntArray list = (NBTTagIntArray) nbt;
-
-            if (list.func_150302_c().length == 0) {
-                return createEmptyList(list);
-            } else {
-                JsonArray arr = new JsonArray();
-
-                for (int i : list.func_150302_c()) {
-                    arr.add(new JsonPrimitive(i));
-                }
-
-                return arr;
+            JsonArray arr = new JsonArray();
+            for(int i : ((NBTTagIntArray) nbt).func_150302_c()) {
+                arr.add(new JsonPrimitive(i));
             }
-
+            return arr;
         } else if (nbt instanceof NBTTagByteArray) {
             // Byte Array
-            final NBTTagByteArray list = (NBTTagByteArray) nbt;
-
-            if (list.func_150292_c().length == 0) {
-                return createEmptyList(list);
-            } else {
-                JsonArray arr = new JsonArray();
-
-                for (byte i : list.func_150292_c()) {
-                    arr.add(new JsonPrimitive(Byte.toString(i) + 'B'));
-                }
-
-                return arr;
+            JsonArray arr = new JsonArray();
+            for(int i : ((NBTTagByteArray) nbt).func_150292_c()) {
+                arr.add(new JsonPrimitive(i));
             }
-
+            return arr;
         } else {
             throw new IllegalArgumentException("Unsupported NBT Tag: " + NBTBase.NBTTypes[nbt.getId()] + " - " + nbt);
         }
@@ -127,7 +86,7 @@ public class NBTJson {
             final JsonPrimitive jsonPrimitive = (JsonPrimitive) jsonElement;
             final String jsonString = jsonPrimitive.getAsString();
             final Matcher m = numberPattern.matcher(jsonString);
-            if (m.find()) {
+            if(m.find()) {
                 // Number
                 final String numberString = m.group(1);
                 if (m.groupCount() == 2 && m.group(2).length() > 0) {
@@ -171,13 +130,7 @@ public class NBTJson {
             if (nbtList.stream().allMatch(n -> n instanceof NBTTagInt)) {
                 return new NBTTagIntArray(nbtList.stream().mapToInt(i -> ((NBTTagInt)i).func_150287_d() ).toArray());
             } else if (nbtList.stream().allMatch(n -> n instanceof NBTTagByte)) {
-                final byte[] abyte = new byte[nbtList.size()];
-
-                for (int i = 0; i < nbtList.size(); i++) {
-                    abyte[i] = ((NBTTagByte) nbtList.get(i)).func_150290_f();
-                }
-                
-                return new NBTTagByteArray(abyte);
+                return new NBTTagByteArray(toByteArray(nbtList.stream().mapToInt(i -> ((NBTTagInt)i).func_150287_d() )));
             } else {
                 NBTTagList nbtTagList = new NBTTagList();
                 nbtList.forEach(nbtTagList::appendTag);
@@ -188,43 +141,18 @@ public class NBTJson {
         } else if (jsonElement instanceof JsonObject) {
             // NBTTagCompound
             final JsonObject jsonObject = (JsonObject) jsonElement;
-            final NBTBase custom = restoreEmptyList(jsonObject);
-
-            if (custom == null) {
-                NBTTagCompound nbtTagCompound = new NBTTagCompound();
-
-                for (Map.Entry<String, JsonElement> jsonEntry : jsonObject.entrySet()) {
-                    nbtTagCompound.setTag(jsonEntry.getKey(), toNbt(jsonEntry.getValue()));
-                }
-    
-                return nbtTagCompound;
-            } else {
-                return custom;
+            NBTTagCompound nbtTagCompound = new NBTTagCompound();
+            for (Map.Entry<String, JsonElement> jsonEntry : jsonObject.entrySet()) {
+                nbtTagCompound.setTag(jsonEntry.getKey(), toNbt(jsonEntry.getValue()));
             }
-
+            return nbtTagCompound;
         }
         
         throw new IllegalArgumentException("Unhandled element " + jsonElement);
     }
-
-    protected static JsonObject createEmptyList(Object obj)
-    {
-        JsonObject empty = new JsonObject();
-        empty.add("__custom_type", new JsonPrimitive(obj.getClass().getName()));
-        return empty;
-    }
-
-    protected static NBTBase restoreEmptyList(JsonObject obj)
-    {
-
-        if (obj.has("__custom_type")) {
-            try {
-                final String className = obj.get("__custom_type").getAsString();
-                return (NBTBase)Class.forName(className).newInstance();
-            } catch (ClassNotFoundException | InstantiationException | IllegalAccessException th) {}
-        }
-
-        return null;
+    public static byte[] toByteArray(IntStream stream) {
+        return stream.collect(ByteArrayOutputStream::new, (baos, i) -> baos.write((byte) i), (baos1, baos2) -> baos1.write(baos2.toByteArray(), 0, baos2.size()))
+            .toByteArray();
     }
     
 }

src/main/resources/assets/nei/csv/handlers.csv

@@ -208,7 +208,6 @@ gtPlusPlus.nei.GT_NEI_FluidReactor,GT++,gregtech:gt.blockmachines:998,,miscutils
 gtPlusPlus.nei.GT_NEI_MillingMachine,GT++,gregtech:gt.blockmachines:31027,,miscutils,TRUE,,,120,,2,,,,,,
 li.cil.oc.integration.nei.CallbackDocHandler,OpenComputers,OpenComputers:item:98,,OpenComputers,TRUE,,,120,,2,,,,,,
 li.cil.oc.integration.nei.ManualUsageHandler,OpenComputers,OpenComputers:item:98,,OpenComputers,TRUE,,,120,,2,,,,,,
-com.pam.harvestcraft.GardenRecipeHandler,Pam's Harvestcraft,harvestcraft:berrygarden,,harvestcraft,TRUE,,,100,,5,,,,,,
 tonius.neiintegration.mods.harvestcraft.RecipeHandlerApiary,Pam's Harvestcraft,harvestcraft:apiary,,harvestcraft,TRUE,,,70,,5,,,,,,There's only 1 though
 tonius.neiintegration.mods.harvestcraft.RecipeHandlerChurn,Pam's Harvestcraft,harvestcraft:churn,,harvestcraft,TRUE,,,65,,5,,,,,,Same as above
 tonius.neiintegration.mods.harvestcraft.RecipeHandlerOven,Pam's Harvestcraft,harvestcraft:oven,,harvestcraft,TRUE,,,65,,5,,,,,,
@@ -355,7 +354,7 @@ vazkii.botania.client.integration.nei.recipe.RecipeHandlerRunicAltar,Botania,Bot
 vazkii.botania.client.integration.nei.recipe.RecipeHandlerManaPool,Botania,Botania:pool,,Botania,TRUE,,,90,137,4,,,,,,
 vazkii.botania.client.integration.nei.recipe.RecipeHandlerElvenTrade,Botania,Botania:alfheimPortal,,Botania,TRUE,,,90,130,4,,,,,,
 vazkii.botania.client.integration.nei.recipe.RecipeHandlerBrewery,Botania,Botania:brewery,,Botania,TRUE,,,,,4,,,,,,
-vazkii.botania.client.integration.nei.recipe.RecipeHandlerPureDaisy,Botania,Botania:specialFlower,"{type:puredaisy}",Botania,TRUE,,,,,4,,,,,,
+vazkii.botania.client.integration.nei.recipe.RecipeHandlerPureDaisy,Botania,Botania:specialFlower,"{""type"": ""puredaisy""}",Botania,TRUE,,,,,4,,,,,,
 vazkii.botania.client.integration.nei.recipe.RecipeHandlerLexicaBotania,Botania,Botania:lexicon,,Botania,TRUE,,,,,,,,,,,
 com.jaquadro.minecraft.storagedrawers.integration.notenoughitems.UpgradeItemRecipeHandler,Storage Drawers,minecraft:crafting_table,,StorageDrawers,TRUE,,,65,166,5,,,,,,
 ieArcFurnace,Immersive Engineering,ImmersiveEngineering:graphiteElectrode,,ImmersiveEngineering,TRUE,,,65,166,5,,,,,,
@@ -411,7 +410,6 @@ mekanism.client.nei.ChemicalOxidizerRecipeHandler,Mekanism,Mekanism:MachineBlock
 mekanism.client.nei.ChemicalWasherRecipeHandler,Mekanism,Mekanism:MachineBlock2:7,,Mekanism,TRUE,,,70,,5,,,,,,
 mekanism.client.nei.CombinerRecipeHandler,Mekanism,Mekanism:MachineBlock:2,,Mekanism,TRUE,,,68,,5,,,,,,
 mekanism.client.nei.CrusherRecipeHandler,Mekanism,Mekanism:MachineBlock:3,,Mekanism,TRUE,,,68,,5,,,,,,
-mekanism.client.nei.EnrichmentChamberRecipeHandler,Mekanism,Mekanism:MachineBlock:0,,Mekanism,TRUE,,,68,,5,,,,,,
 mekanism.client.nei.MetallurgicInfuserRecipeHandler,Mekanism,Mekanism:MachineBlock:8,,Mekanism,TRUE,,,56,,5,,,,,,
 mekanism.client.nei.OsmiumCompressorRecipeHandler,Mekanism,Mekanism:MachineBlock:1,,Mekanism,TRUE,,,68,,5,,,,,,
 mekanism.client.nei.PRCRecipeHandler,Mekanism,Mekanism:MachineBlock2:10,,Mekanism,TRUE,,,68,,5,,,,,,
@@ -451,28 +449,3 @@ neresources.nei.NEIEnchantmentHandler,Not Enough Resources,minecraft:anvil,,nere
 neresources.nei.NEIMobHandler,Not Enough Resources,minecraft:skull:4,,neresources,TRUE,,,130,166,2,,,,,,
 neresources.nei.NEIOreHandler,Not Enough Resources,minecraft:diamond_ore,,neresources,TRUE,,,65,166,5,,,,,,
 neresources.nei.NEIPlantHandler,Not Enough Resources,minecraft:wheat,,neresources,TRUE,,,130,166,2,,,,,,
-wanion.biggercraftingtables.nei.BigShapedRecipeHandler,Bigger Crafting Tables,biggercraftingtables:BiggerCraftingTables,,biggercraftingtables,TRUE,,,130,,2,,,,,,
-wanion.biggercraftingtables.nei.BigShapelessRecipeHandler,Bigger Crafting Tables,biggercraftingtables:BiggerCraftingTables,,biggercraftingtables,TRUE,,,130,,2,,,,,,
-wanion.biggercraftingtables.nei.HugeShapedRecipeHandler,Bigger Crafting Tables,biggercraftingtables:BiggerCraftingTables:1,,biggercraftingtables,TRUE,,,130,,2,,,,,,
-wanion.biggercraftingtables.nei.HugeShapelessRecipeHandler,Bigger Crafting Tables,biggercraftingtables:BiggerCraftingTables:1,,biggercraftingtables,TRUE,,,130,,2,,,,,,
-net.machinemuse.numina.nei.JSONRecipeHandler,Modular Powersuits,powersuits:tile.tinkerTable,,powersuits,TRUE,,,65,166,5,,,,,,
-com.teammetallurgy.metallurgy.nei.CrusherHandler,Metallurgy 4,Metallurgy:crusher,,Metallurgy,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.MetalFurnaceRecipeHandler,NuclearCraft,NuclearCraft:furnaceIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.ElectricFurnaceRecipeHandler,NuclearCraft,NuclearCraft:electricFurnaceIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.NuclearFurnaceRecipeHandler,NuclearCraft,NuclearCraft:nuclearFurnaceIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.FactoryRecipeHandler,NuclearCraft,NuclearCraft:factoryIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.AssemblerRecipeHandler,NuclearCraft,NuclearCraft:assemblerIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.SeparatorRecipeHandler,NuclearCraft,NuclearCraft:separatorIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.HastenerRecipeHandler,NuclearCraft,NuclearCraft:hastenerIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.CollectorRecipeHandler,NuclearCraft,NuclearCraft:collectorIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.OxidiserRecipeHandler,NuclearCraft,NuclearCraft:oxidiserIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.IoniserRecipeHandler,NuclearCraft,NuclearCraft:ioniserIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.IrradiatorRecipeHandler,NuclearCraft,NuclearCraft:irradiatorIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.CoolerRecipeHandler,NuclearCraft,NuclearCraft:coolerIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.HeliumExtractorRecipeHandler,NuclearCraft,NuclearCraft:heliumExtractorIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.RecyclerRecipeHandler,NuclearCraft,NuclearCraft:recyclerIdle,,NuclearCraft,TRUE,,,65,166,5,,,,,,
-nc.crafting.nei.NuclearWorkspaceRecipeHandler,NuclearCraft,NuclearCraft:nuclearWorkspace,,NuclearCraft,TRUE,,,130,,2,,,,,,
-ganymedes01.etfuturum.NEI_EtFuturum_Config$NEI_Recipes_Smoker,EtFuturum Requiem,etfuturum:lit_smoker,,etfuturum,TRUE,,,65,166,5,,,,,,
-ganymedes01.etfuturum.NEI_EtFuturum_Config$NEI_Recipes_BlastFurnace,EtFuturum Requiem,etfuturum:lit_blast_furnace,,etfuturum,TRUE,,,65,166,5,,,,,,
-connor135246.campfirebackport.client.compat.nei.NEICampfireRecipeHandler,Campfire Backport,campfirebackport:campfire,,campfirebackport,TRUE,,,65,166,5,,,,,,
-connor135246.campfirebackport.client.compat.nei.NEICampfireStateChangerHandler,Campfire Backport,campfirebackport:campfire_base,,campfirebackport,TRUE,,,65,166,5,,,,,,

src/main/resources/assets/nei/guidfilters.cfg

@@ -1,56 +0,0 @@
-AdvancedSolarPanel:hybrid_solar_helmet,Damage
-BuildCraft|Transport:pipeFacade
-DraconicEvolution:draconicAxe,tag.Energy
-DraconicEvolution:draconicPickaxe,tag.Energy
-DraconicEvolution:wyvernPickaxe,tag.Energy
-ExtraUtilities:microblocks,Damage
-Forestry:beePrincessGE,tag.Genome.Chromosomes
-ForgeMicroblock:microblock,Damage
-Genetics:serumArray,tag.genes
-GraviSuite:itemPlasmaCell,tag.Fluid.FluidName
-IC2:itemCropSeed,tag.name
-IC2:itemFluidCell,tag.Fluid.FluidName
-NodalMechanics:item.nodalmechanics.matrix,tag.Aspects.0.key
-TConstruct:ArrowAmmo,tag.InfiTool
-TConstruct:BoltAmmo,tag.InfiTool
-TConstruct:Crossbow,tag.InfiTool
-TConstruct:Javelin,tag.InfiTool
-TConstruct:LongBow,tag.InfiTool
-TConstruct:ShortBow,tag.InfiTool
-TConstruct:Shuriken,tag.InfiTool
-TConstruct:ThrowingKnife,tag.InfiTool
-TConstruct:battleaxe,tag.InfiTool
-TConstruct:battlesign,tag.InfiTool
-TConstruct:broadsword,tag.InfiTool
-TConstruct:chisel,tag.InfiTool
-TConstruct:cleaver,tag.InfiTool
-TConstruct:cutlass,tag.InfiTool
-TConstruct:dagger,tag.InfiTool
-TConstruct:excavator,tag.InfiTool
-TConstruct:frypan,tag.InfiTool
-TConstruct:hammer,tag.InfiTool
-TConstruct:hatchet,tag.InfiTool
-TConstruct:longsword,tag.InfiTool
-TConstruct:lumberaxe,tag.InfiTool
-TConstruct:mattock,tag.InfiTool
-TConstruct:pickaxe,tag.InfiTool
-TConstruct:potionLauncher
-TConstruct:rapier,tag.InfiTool
-TConstruct:scythe,tag.InfiTool
-TConstruct:shovel,tag.InfiTool
-Thaumcraft:ItemEssence,tag.Aspects.0.key
-Thaumcraft:ItemWispEssence,tag.Aspects.0.key
-WitchingGadgets:item.WG_InfusedGem,tag.Aspect
-adventurebackpack:adventureBackpack,Damage
-appliedenergistics2:item.ItemFacade
-bartworks:BioLabParts,Damage,tag.Name
-battlegear2:knights_armour.boots
-battlegear2:knights_armour.helmet
-battlegear2:knights_armour.legs
-battlegear2:knights_armour.plate
-miscutils:itemBlueprint
-miscutils:particleIon,Damage
-miscutils:personalHealingDevice
-tectech:item.em.debugContainer,tag.symbols
-tinkersdefense:Heater Shield,tag.InfiTool
-tinkersdefense:Round Shield,tag.InfiTool

src/main/resources/assets/nei/lang/en_US.lang

@@ -108,12 +108,6 @@ nei.options.keys.world.creative=Gamemode
 nei.options.keys.world.creative.tip=Cycle Gamemode
 
 nei.options.inventory=Inventory
-nei.options.inventory.worldSpecificBookmarks=World Specific Bookmarks
-nei.options.inventory.worldSpecificBookmarks.true=Yes
-nei.options.inventory.worldSpecificBookmarks.false=No
-nei.options.inventory.worldSpecificPresets=World Specific Presets
-nei.options.inventory.worldSpecificPresets.true=Yes
-nei.options.inventory.worldSpecificPresets.false=No
 nei.options.inventory.bookmarksEnabled=Bookmarks Panel Visibility
 nei.options.inventory.bookmarksEnabled.true=Visible
 nei.options.inventory.bookmarksEnabled.false=Hidden
@@ -123,15 +117,6 @@ nei.options.inventory.jei_style_tabs.false=No [Weirdo]
 nei.options.inventory.jei_style_item_presence_overlay=JEI Style Item Overlay on ?-Hover
 nei.options.inventory.jei_style_item_presence_overlay.true=Yes
 nei.options.inventory.jei_style_item_presence_overlay.false=No
-nei.options.inventory.jei_style_recipe_catalyst=JEI Style Recipe Catalysts
-nei.options.inventory.jei_style_recipe_catalyst.true=Yes
-nei.options.inventory.jei_style_recipe_catalyst.false=No
-nei.options.inventory.saveCurrentRecipeInBookmarksEnabled=Save Current Recipe in Bookmarks
-nei.options.inventory.saveCurrentRecipeInBookmarksEnabled.true=Enabled
-nei.options.inventory.saveCurrentRecipeInBookmarksEnabled.false=Disabled
-nei.options.inventory.useNBTInBookmarks=Use NBT in Bookmarks
-nei.options.inventory.useNBTInBookmarks.true=Yes
-nei.options.inventory.useNBTInBookmarks.false=No
 nei.options.inventory.creative_tab_style=Creative or JEI tab style
 nei.options.inventory.creative_tab_style.true=Creative
 nei.options.inventory.creative_tab_style.false=JEI
@@ -196,9 +181,6 @@ nei.options.tools=Tools
 nei.options.tools.handler_load_from_config=Load handlers from Config
 nei.options.tools.handler_load_from_config.true=Config
 nei.options.tools.handler_load_from_config.false=JAR
-nei.options.tools.catalyst_load_from_config=Load catalysts from Config
-nei.options.tools.catalyst_load_from_config.true=Config
-nei.options.tools.catalyst_load_from_config.false=JAR
 nei.options.tools.dump=Data Dumps
 nei.options.tools.dump.dump=Dump
 nei.options.tools.dump.dumped=%s IDs dumped to %s
@@ -234,12 +216,8 @@ nei.recipe.shaped=Shaped Crafting
 nei.recipe.shapeless=Shapeless Crafting
 nei.recipe.furnace=Smelting
 nei.recipe.fuel=Fuel
-nei.recipe.fuel.smeltCount=Smelts %s items
-# Deprecated
 nei.recipe.fuel.required=%s required
-# Deprecated
 nei.recipe.fuel.processed=%s processed
-# Deprecated
 nei.recipe.fuel.produced=%s produced
 nei.recipe.firework=Fireworks
 nei.recipe.firework.tooltip0=Dyes add colours to the charges
@@ -284,13 +262,4 @@ nei.subsets.Items.Tools.Shovels=Shovels
 nei.subsets.Items.Weapons=Weapons
 nei.subsets.Items.Weapons.Ranged=Ranged
 nei.subsets.Items.Weapons.Swords=Swords
-nei.subsets.Mod=Mod
-
-nei.presets.blacklist.label=B
-nei.presets.blacklist.tooltip=Blacklist
-nei.presets.whitelist.label=W
-nei.presets.whitelist.tooltip=Whitelist
-nei.presets.textfield.tooltip.1=Enter - save
-nei.presets.textfield.tooltip.2=Escape - cancel
-nei.presets.label.tooltip=Double click to edit
-nei.presets.label.selected=%s Presets
+nei.subsets.Mod=Mod

src/main/resources/assets/nei/lang/zh_CN.lang

@@ -108,9 +108,6 @@ nei.options.keys.world.creative=游戏模式
 nei.options.keys.world.creative.tip=循环游戏模式
 
 nei.options.inventory=物品栏
-nei.options.inventory.worldSpecificBookmarks=书签存储位置
-nei.options.inventory.worldSpecificBookmarks.true=存档内
-nei.options.inventory.worldSpecificBookmarks.false=全局
 nei.options.inventory.bookmarksEnabled=显示/隐藏书签页
 nei.options.inventory.bookmarksEnabled.true=显示
 nei.options.inventory.bookmarksEnabled.false=隐藏
@@ -120,15 +117,6 @@ nei.options.inventory.jei_style_tabs.false=否 [不会吧]
 nei.options.inventory.jei_style_item_presence_overlay=JEI风格物品覆盖?-悬停
 nei.options.inventory.jei_style_item_presence_overlay.true=是
 nei.options.inventory.jei_style_item_presence_overlay.false=否
-nei.options.inventory.jei_style_recipe_catalyst=JEI风格可执行合成表机器显示[测试中]
-nei.options.inventory.jei_style_recipe_catalyst.true=是
-nei.options.inventory.jei_style_recipe_catalyst.false=否
-nei.options.inventory.saveCurrentRecipeInBookmarksEnabled=保存书签中的当前合成表
-nei.options.inventory.saveCurrentRecipeInBookmarksEnabled.true=启用
-nei.options.inventory.saveCurrentRecipeInBookmarksEnabled.false=禁用
-nei.options.inventory.useNBTInBookmarks=在书签中启用NBT
-nei.options.inventory.useNBTInBookmarks.true=是
-nei.options.inventory.useNBTInBookmarks.false=否
 nei.options.inventory.creative_tab_style=创造模式/JEI标签页
 nei.options.inventory.creative_tab_style.true=创造模式
 nei.options.inventory.creative_tab_style.false=JEI

src/main/resources/dependencies.info

@@ -1,7 +0,0 @@
-{
-        "repo": "https://github.com/GTNewHorizons/CodeChickenLib/releases/download/1.1.5.3/",
-        "file": "CodeChickenLib-1.7.10-1.1.5.3.jar",
-        "dev": "CodeChickenLib-1.7.10-1.1.5.3-dev.jar",
-        "class": "codechicken.lib.asm.ASMHelper",
-        "coreLib": true
-}

src/main/resources/mcmod.info

@@ -4,8 +4,13 @@
         "name": "${modName}",
         "version": "${modVersion}",
         "mcversion": "${minecraftVersion}",
-        "description": "Recipe Viewer, Inventory Manager, Item Spawner, Cheats and more; GTNH Version includes many enhancements.",
-        "url": "https://github.com/GTNewHorizons/NotEnoughItems",
+        "description": "Recipe Viewer, Inventory Manager, Item Spawner, Cheats and more; GTNH Version
+
+
+<plugins>
+
+Supporters: EmuCraft Team, Victor Zimmer, lexi85, Ace_Trainer_Tullius, Bacon_Donut, Iarinu",
+        "url": "http://www.minecraftforum.net/topic/909223",
         "credits": "Alexandria - original idea",
         "license": "LGPL-3.0",
         "authorList": [ "ChickenBones", "mitchej123" ],