Moved jitpack

.git-blame-ignore-revs

@@ -1,2 +0,0 @@
-# Ignore spotlessApply reformat
-f106b5e7665df6341ae8539f74dc391a7efc98b1

.gitattributes

@@ -1,44 +0,0 @@
-* text eol=lf
-
-*.[jJ][aA][rR]          binary
-
-*.[pP][nN][gG]          binary
-*.[jJ][pP][gG]          binary
-*.[jJ][pP][eE][gG]      binary
-*.[gG][iI][fF]          binary
-*.[tT][iI][fF]          binary
-*.[tT][iI][fF][fF]      binary
-*.[iI][cC][oO]          binary
-*.[sS][vV][gG]          text
-*.[eE][pP][sS]          binary
-*.[xX][cC][fF]          binary
-
-*.[kK][aA][rR]          binary
-*.[mM]4[aA]             binary
-*.[mM][iI][dD]          binary
-*.[mM][iI][dD][iI]      binary
-*.[mM][pP]3             binary
-*.[oO][gG][gG]          binary
-*.[rR][aA]              binary
-
-*.7[zZ]                 binary
-*.[gG][zZ]              binary
-*.[tT][aA][rR]          binary
-*.[tT][gG][zZ]          binary
-*.[zZ][iI][pP]          binary
-
-*.[tT][cC][nN]          binary
-*.[sS][oO]              binary
-*.[dD][lL][lL]          binary
-*.[dD][yY][lL][iI][bB]  binary
-*.[pP][sS][dD]          binary
-*.[tT][tT][fF]          binary
-*.[oO][tT][fF]          binary
-
-*.[pP][aA][tT][cC][hH]  -text
-
-*.[bB][aA][tT]          text eol=crlf
-*.[cC][mM][dD]          text eol=crlf
-*.[pP][sS]1             text eol=crlf
-
-*[aA][uU][tT][oO][gG][eE][nN][eE][rR][aA][tT][eE][dD]* binary

.github/workflows/build-and-test.yml

@@ -1,13 +0,0 @@
-
-name: Build and test
-
-on:
-  pull_request:
-    branches: [ master, main ]
-  push:
-    branches: [ master, main ]
-
-jobs:
-  build-and-test:
-    uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/build-and-test.yml@master
-    secrets: inherit

.github/workflows/pull-request.yml

@@ -0,0 +1,32 @@
+# 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 pull request
+
+on:
+  pull_request:
+    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

.github/workflows/release-tags.yml

@@ -1,14 +0,0 @@
-
-name: Release tagged build
-
-on:
-  push:
-    tags: [ '*' ]
-
-permissions:
-  contents: write
-
-jobs:
-  release-tags:
-    uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/release-tags.yml@master
-    secrets: inherit

.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,5 +26,3 @@ whitelist.json
 *.ipr
 *.iws
 src/main/resources/mixins.*.json
-*.bat
-.DS_Store

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,44 +2,30 @@
 
 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:
 
-* Speed
+* Speed 
   - Uses a parallel stream to search the item list over multiple cores, resulting in 2-6x faster searches on average
-  - Loads the recipe handlers in parallel
+  - Loads the recipe handlers in parallel 
 * A textbox for search with most of the features you'd expect - moving forward, backwards, selection, etc
 * Bookmarks!  What are you in the process of crafting? Bookmark it using either 'A' or configure your own key.
 * Toggle bookmark pane.  Default shortcut key `B`.  Item Subsets menu is only available if bookmarks are not visible.
 * Utility/Cheat buttons line up and wrap based on GUI size
 * ItemList is no longer regenerated from the ItemRegistry on every inventory load
-* JEI (Or Creative) Style tabs [Optional]  Note: Requires explicit support to be added for an ItemStack to render, otherwise falls back to the first two letters of the handler name.
+* JEI (Or Creative) Style tabs [Optional]  Note: Requires explicit support to be added for an ItemStack to render, otherwise falls back to the first two letters of the handler name.  
 * Tabs/Handlers are loaded from a CSV config in the JAR (or optionally from the config folder).  NBT IMCEvents `registerHandlerInfo` and `removeHandlerInfo` are available for mod authors to add handler information, using the same fields as the CSV file
 * `@[Mod]->[item]` searching.  ex: `@Mod.gregtech->iron ingot`
-* Cycle between Recipe, Utility, and Cheat mode by ctrl clicking on the Wrench Icon
+* Cycle between Recipe, Utility, and Cheat mode by ctrl clicking on the Wrench Icon 
 * GT5u Tools/Items and GT6 tools should now properly work with the Overlay Recipe Transfer
 
 ## 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
-
-## Development
-Before launching, you need to add 
-```
--Dfml.coreMods.load=codechicken.nei.asm.NEICorePlugin
-``` 
-as a command line argument to the VM.
-
-## 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.

addon.gradle

@@ -1,3 +0,0 @@
-compileJava {
-    options.encoding = "UTF-8"
-}

dependencies.gradle

@@ -1,7 +1,7 @@
 // Add your dependencies here
 
 dependencies {
-    api('com.github.GTNewHorizons:CodeChickenLib:1.1.6:dev')
-    api('com.github.GTNewHorizons:CodeChickenCore:1.1.10:dev')
-    shadowImplementation('org.apache.commons:commons-csv:1.9.0')
+    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,37 +15,29 @@ 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
-# Generate a class with String fields for the mod id, name, version and group name named with the fields below
-generateGradleTokenClass = codechicken.nei.Tags
-gradleTokenModId = MODID
-gradleTokenModName = MODNAME
-gradleTokenVersion = VERSION
-gradleTokenGroupName = GROUPNAME
-# [DEPRECATED]
-# Multiple source files can be defined here by providing a comma-seperated list: Class1.java,Class2.java,Class3.java
-# 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
-# version in @Mod([...], version = VERSION, [...])
-# Leave these properties empty to skip individual token replacements
-replaceGradleTokenInFile =
+replaceGradleTokenInFile = NEIModContainer.java
+gradleTokenModId = GRADLETOKEN_MODID
+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
 
@@ -56,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
@@ -66,33 +58,3 @@ containsMixinsAndOrCoreModOnly = true
 # If enabled, you may use 'shadowImplementation' for dependencies. They will be integrated in your jar. It is your
 # responsibility check the licence and request permission for distribution, if required.
 usesShadowedDependencies = true
-
-# Publishing to CurseForge requires you to set the CURSEFORGE_TOKEN environment variable to one of your CurseForge API tokens.
-
-# The project's numeric ID on CurseForge. You can find this in the About Project box.
-# Leave this empty if you don't want to publish on CurseForge.
-curseForgeProjectId = 358228
-
-# The project's relations on CurseForge. You can use this to refer to other projects on CurseForge.
-# Syntax: type1:name1;type2:name2;...
-# Where type can be one of [requiredDependency, embeddedLibrary, optionalDependency, tool, incompatible],
-#       and the name is the CurseForge project id of the other mod.
-curseForgeRelations = requiredDependency:codechickencore-unofficial;requiredDependency:codechickenlib-unofficial
-
-
-# Publishing to modrinth requires you to set the MODRINTH_TOKEN environment variable to your current modrinth API token.
-
-# The project's ID on Modrinth. Can be either the slug or the ID.
-# Leave this empty if you don't want to publish on Modrinth.
-
-modrinthProjectId = notenoughitems-unofficial
-
-# The project's relations on Modrinth. You can use this to refer to other projects on Modrinth.
-# Syntax: scope1-type1:name1;scope2-type2:name2;...
-# Where scope can be one of [required, optional, incompatible, embedded],
-#       type can be one of [project, version],
-#       and the name is the Modrinth project or version slug/id of the other mod.
-
-modrinthRelations = required-project:codechickenlib-unofficial;required-project:codechickencore-unofficial
-
-

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.1-bin.zip
-networkTimeout=10000
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.9.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
-#!/bin/sh
+#!/usr/bin/env sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# Copyright 2015 the original author or authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,113 +17,78 @@
 #
 
 ##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
+##
+##  Gradle start up script for UN*X
+##
 ##############################################################################
 
 # Attempt to set APP_HOME
-
 # Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
 done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
 
-# This is normally unused
-# shellcheck disable=SC2034
-APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
+MAX_FD="maximum"
 
 warn () {
     echo "$*"
-} >&2
+}
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-} >&2
+}
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
-
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
+        JAVACMD="$JAVA_HOME/jre/sh/java"
     else
-        JAVACMD=$JAVA_HOME/bin/java
+        JAVACMD="$JAVA_HOME/bin/java"
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -132,7 +97,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD=java
+    JAVACMD="java"
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -140,105 +105,84 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045 
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045 
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
 fi
 
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
 
 # For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
     done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
 fi
 
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
 
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
 fi
 
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -14,7 +14,7 @@
 @rem limitations under the License.
 @rem
 
-@if "%DEBUG%"=="" @echo off
+@if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,14 +25,10 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%"=="" set DIRNAME=.
-@rem This is normally unused
+if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
@@ -41,7 +37,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
+if "%ERRORLEVEL%" == "0" goto init
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -55,7 +51,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto execute
+if exist "%JAVA_EXE%" goto init
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -65,26 +61,38 @@ echo location of your Java installation.
 
 goto fail
 
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
-
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
 
 :end
 @rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
+if "%ERRORLEVEL%"=="0" goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

repositories.gradle

@@ -3,13 +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'
-        }
+        url = "https://jitpack.io"
     }
 }

settings.gradle

@@ -1,28 +0,0 @@
-
-pluginManagement {
-    repositories {
-        maven {
-            // RetroFuturaGradle
-            name "GTNH Maven"
-            url "http://jenkins.usrv.eu:8081/nexus/content/groups/public/"
-            allowInsecureProtocol = true
-            mavenContent {
-                includeGroup("com.gtnewhorizons.retrofuturagradle")
-            }
-        }
-        gradlePluginPortal()
-        mavenCentral()
-        mavenLocal()
-    }
-}
-
-plugins {
-    id 'com.diffplug.blowdryerSetup' version '1.6.0'
-    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.4.0' // Provides java toolchains
-}
-
-blowdryerSetup {
-    repoSubfolder 'gtnhShared'
-    github('GTNewHorizons/ExampleMod1.7.10', 'tag', '0.2.0')
-    //devLocal '.' // Use this when testing config updates locally
-}

src/main/java/codechicken/nei/Button.java

@@ -1,11 +1,11 @@
 package codechicken.nei;
 
-import static codechicken.lib.gui.GuiDraw.getStringWidth;
-
 import java.util.List;
 
-public abstract class Button extends Widget {
+import static codechicken.lib.gui.GuiDraw.getStringWidth;
 
+public abstract class Button extends Widget
+{
     public Button(String s) {
         label = s;
     }
@@ -25,7 +25,9 @@ public abstract class Button extends Widget {
 
     @Override
     public boolean handleClick(int mx, int my, int button) {
-        if (button == 1 || button == 0) if (onButtonPress(button == 1)) NEIClientUtils.playClickSound();
+        if (button == 1 || button == 0)
+            if (onButtonPress(button == 1))
+                NEIClientUtils.playClickSound();
         return true;
     }
 
@@ -37,21 +39,23 @@ public abstract class Button extends Widget {
 
     @Override
     public List<String> handleTooltip(int mx, int my, List<String> tooltip) {
-        if (!contains(mx, my)) return tooltip;
+        if (!contains(mx, my))
+            return tooltip;
 
         final String tip = getButtonTip();
-        if (tip != null) tooltip.add(tip);
-
+        if (tip != null)
+            tooltip.add(tip);
+        
         addTooltips(tooltip);
-
+        
         return tooltip;
     }
 
     public String getButtonTip() {
         return null;
     }
-
-    public void addTooltips(List<String> tooltip) {}
+    
+    public void addTooltips(List<String> tooltip) {} 
 
     public String getRenderLabel() {
         return label;
@@ -61,7 +65,10 @@ public abstract class Button extends Widget {
     public Image icon;
 
     /**
-     * 0x4 = state flag, as opposed to 1 click 0 = normal 1 = on 2 = disabled
+     * 0x4 = state flag, as opposed to 1 click
+     * 0 = normal
+     * 1 = on
+     * 2 = disabled
      */
     public int state;
 }

src/main/java/codechicken/nei/ButtonCycled.java

@@ -1,21 +1,20 @@
 package codechicken.nei;
 
-public abstract class ButtonCycled extends Button {
-
+public abstract class ButtonCycled extends Button
+{    
     public ButtonCycled() {}
 
     public ButtonCycled(int num) {
         icons = new Image[num];
         init();
     }
-
     @Override
-    public Image getRenderIcon() {
+    public Image getRenderIcon()
+    {
         return icons[index];
     }
 
     public void init() {}
-
     public int index;
     public Image[] icons;
 }

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

@@ -1,5 +1,36 @@
 package codechicken.nei;
 
+import codechicken.core.ClientUtils;
+import codechicken.core.GuiModListScroll;
+import codechicken.lib.packet.PacketCustom;
+import codechicken.nei.api.API;
+import codechicken.nei.api.ItemInfo;
+import codechicken.nei.recipe.GuiRecipeTab;
+import com.google.common.collect.Lists;
+import cpw.mods.fml.client.CustomModLoadingErrorDisplayException;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
+import cpw.mods.fml.common.gameevent.TickEvent.Phase;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.gui.GuiErrorScreen;
+import net.minecraft.client.gui.GuiMainMenu;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.GuiSelectWorld;
+import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.world.World;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.common.MinecraftForge;
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVRecord;
+import org.apache.commons.io.IOUtils;
+
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
@@ -15,60 +46,27 @@ 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;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.entity.EntityPlayerSP;
-import net.minecraft.client.gui.FontRenderer;
-import net.minecraft.client.gui.GuiErrorScreen;
-import net.minecraft.client.gui.GuiMainMenu;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.gui.GuiSelectWorld;
-import net.minecraft.client.multiplayer.WorldClient;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.item.EntityItem;
-import net.minecraft.world.World;
-import net.minecraftforge.client.event.RenderWorldLastEvent;
-import net.minecraftforge.common.MinecraftForge;
-
-import org.apache.commons.csv.CSVFormat;
-import org.apache.commons.csv.CSVParser;
-import org.apache.commons.csv.CSVRecord;
-import org.apache.commons.io.IOUtils;
-
-import codechicken.core.ClientUtils;
-import codechicken.core.GuiModListScroll;
-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;
-import cpw.mods.fml.common.Loader;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
-import cpw.mods.fml.common.gameevent.TickEvent;
-import cpw.mods.fml.common.gameevent.TickEvent.Phase;
-
-public class ClientHandler {
 
+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.*", };
+        "WayofTime.alchemicalWizardry.client.nei.NEIAlchemyRecipeHandler"
+    };
+    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.",
             "# Ordering lines are <handler ID>,<ordering number>.",
             "# Handlers will be sorted in order of number ascending, so smaller numbers first.",
-            "# Any handlers that are missing from this file will be assigned to 0.", "# Negative numbers are fine.",
-            "# If you delete this file, it will be regenerated with all registered handler IDs.", };
+            "# Any handlers that are missing from this file will be assigned to 0.",
+            "# Negative numbers are fine.",
+            "# If you delete this file, it will be regenerated with all registered handler IDs.",
+    };
     private static ClientHandler instance;
 
     private ArrayList<EntityItem> SMPmagneticItems = new ArrayList<>();
@@ -98,11 +96,9 @@ public class ClientHandler {
         if (world.isRemote) {
             items = SMPmagneticItems;
         } else {
-            items = world.getEntitiesWithinAABB(
-                    EntityItem.class,
-                    player.boundingBox.expand(distancexz, distancey, distancexz));
+            items = world.getEntitiesWithinAABB(EntityItem.class, player.boundingBox.expand(distancexz, distancey, distancexz));
         }
-        for (Iterator<EntityItem> iterator = items.iterator(); iterator.hasNext();) {
+        for (Iterator<EntityItem> iterator = items.iterator(); iterator.hasNext(); ) {
             EntityItem item = iterator.next();
 
             if (item.delayBeforeCanPickup > 0) continue;
@@ -158,16 +154,14 @@ public class ClientHandler {
         loadSerialHandlers();
         loadHeightHackHandlers();
         ItemInfo.preInit();
-        StackInfo.loadGuidFilters();
     }
-
+    
     public static void loadSerialHandlers() {
         File file = NEIClientConfig.serialHandlersFile;
-        if (!file.exists()) {
-            try (FileWriter writer = new FileWriter(file)) {
+        if(!file.exists()) {
+            try(FileWriter writer = new FileWriter(file)) {
                 NEIClientConfig.logger.info("Creating default serial handlers list {}", file);
-                Collection<String> toSave = Loader.isModLoaded("dreamcraft") ? Collections.singletonList("")
-                        : Arrays.asList(defaultSerialHandlers);
+                Collection<String> toSave = Loader.isModLoaded("dreamcraft") ? Collections.singletonList("") : Arrays.asList(defaultSerialHandlers);
                 IOUtils.writeLines(toSave, "\n", writer);
             } catch (IOException e) {
                 NEIClientConfig.logger.error("Failed to save default serial handlers list to file {}", file, e);
@@ -186,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);
@@ -195,8 +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);
         }
@@ -226,7 +219,8 @@ public class ClientHandler {
                 NEIClientConfig.logger.info("Creating default handler ordering CSV {}", file);
 
                 List<String> toWrite = Lists.newArrayList(defaultHandlerOrdering);
-                GuiRecipeTab.handlerMap.keySet().stream().sorted()
+                GuiRecipeTab.handlerMap.keySet().stream()
+                        .sorted()
                         .forEach(handlerId -> toWrite.add(String.format("%s,0", handlerId)));
 
                 IOUtils.writeLines(toWrite, "\n", writer);
@@ -268,44 +262,49 @@ public class ClientHandler {
 
     @SubscribeEvent
     public void tickEvent(TickEvent.ClientTickEvent event) {
-        if (event.phase == Phase.END) return;
+        if(event.phase == Phase.END)
+            return;
 
         Minecraft mc = Minecraft.getMinecraft();
-        if (mc.theWorld != null) {
+        if(mc.theWorld != null) {
             loadWorld(mc.theWorld, false);
 
-            if (!NEIClientConfig.isEnabled()) return;
+            if (!NEIClientConfig.isEnabled())
+                return;
 
             KeyManager.tickKeyStates();
 
             NEIController.updateUnlimitedItems(mc.thePlayer.inventory);
-            if (mc.currentScreen == null) NEIController.processCreativeCycling(mc.thePlayer.inventory);
+            if (mc.currentScreen == null)
+                NEIController.processCreativeCycling(mc.thePlayer.inventory);
 
             updateMagnetMode(mc.theWorld, mc.thePlayer);
         }
 
         GuiScreen gui = mc.currentScreen;
         if (gui != lastGui) {
-            if (gui instanceof GuiMainMenu) lastworld = null;
-            else if (gui instanceof GuiSelectWorld) NEIClientConfig.reloadSaves();
-            else if (gui == null) {
-                /* prevent WorldClient reference being held in the Gui */
-                NEIController.manager = null;
-            }
+            if (gui instanceof GuiMainMenu)
+                lastworld = null;
+            else if (gui instanceof GuiSelectWorld)
+                NEIClientConfig.reloadSaves();
         }
         lastGui = gui;
     }
 
     @SubscribeEvent
     public void tickEvent(TickEvent.RenderTickEvent event) {
-        if (event.phase == Phase.END && NEIClientConfig.isEnabled()) HUDRenderer.renderOverlay();
+        if(event.phase == Phase.END && NEIClientConfig.isEnabled())
+            HUDRenderer.renderOverlay();
     }
 
+
     @SubscribeEvent
     public void renderLastEvent(RenderWorldLastEvent event) {
-        if (NEIClientConfig.isEnabled()) WorldOverlayRenderer.render(event.partialTicks);
+        if (NEIClientConfig.isEnabled())
+            WorldOverlayRenderer.render(event.partialTicks);
     }
 
+
     public void loadWorld(World world, boolean fromServer) {
         if (world != lastworld) {
             SMPmagneticItems.clear();
@@ -315,10 +314,8 @@ public class ClientHandler {
                 NEIClientConfig.setHasSMPCounterPart(false);
                 NEIClientConfig.setInternalEnabled(false);
 
-                if (!Minecraft.getMinecraft().isSingleplayer()) // wait for server to initiate in singleplayer
+                if (!Minecraft.getMinecraft().isSingleplayer())//wait for server to initiate in singleplayer
                     NEIClientConfig.loadWorld("remote/" + ClientUtils.getServerIP().replace(':', '~'));
-
-                ItemMobSpawner.clearEntityReferences(world);
             }
 
             lastworld = world;
@@ -330,8 +327,8 @@ public class ClientHandler {
     }
 
     public static RuntimeException throwCME(final String message) {
-        final GuiScreen errorGui = new GuiErrorScreen(null, null) {
-
+        final GuiScreen errorGui = new GuiErrorScreen(null, null)
+        {
             @Override
             public void handleMouseInput() {}
 
@@ -348,16 +345,15 @@ public class ClientHandler {
         };
 
         @SuppressWarnings("serial")
-        CustomModLoadingErrorDisplayException e = new CustomModLoadingErrorDisplayException() {
-
+        CustomModLoadingErrorDisplayException e = new CustomModLoadingErrorDisplayException()
+        {
             @Override
             public void initGui(GuiErrorScreen errorScreen, FontRenderer fontRenderer) {
                 Minecraft.getMinecraft().displayGuiScreen(errorGui);
             }
 
             @Override
-            public void drawScreen(GuiErrorScreen errorScreen, FontRenderer fontRenderer, int mouseRelX, int mouseRelY,
-                    float tickTime) {}
+            public void drawScreen(GuiErrorScreen errorScreen, FontRenderer fontRenderer, int mouseRelX, int mouseRelY, float tickTime) {}
         };
         throw e;
     }

src/main/java/codechicken/nei/ContainerCreativeInv.java

@@ -1,5 +1,7 @@
 package codechicken.nei;
 
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.inventory.Container;
@@ -9,13 +11,10 @@ import net.minecraft.item.ItemArmor;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.IIcon;
 
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-public class ContainerCreativeInv extends Container {
-
-    private class SlotArmor extends Slot {
-
+public class ContainerCreativeInv extends Container
+{
+    private class SlotArmor extends Slot
+    {
         final int armorType;
 
         public SlotArmor(IInventory inv, int x, int y, int slot, int armor) {
@@ -40,16 +39,15 @@ public class ContainerCreativeInv extends Container {
         }
     }
 
-    private class SlotBlockArmor extends SlotArmor {
-
+    private class SlotBlockArmor extends SlotArmor
+    {
         public SlotBlockArmor(IInventory inv, int x, int y, int slot, int armor) {
             super(inv, x, y, slot, armor);
         }
 
         @Override
         public boolean isItemValid(ItemStack stack) {
-            return super.isItemValid(stack) || stack != null; // && Block.getBlockFromItem(stack.getItem()) !=
-                                                              // Blocks.air;
+            return super.isItemValid(stack) || stack != null;// && Block.getBlockFromItem(stack.getItem()) != Blocks.air;
         }
     }
 
@@ -58,22 +56,20 @@ public class ContainerCreativeInv extends Container {
     public ContainerCreativeInv(EntityPlayer player, ExtendedCreativeInv extraInv) {
         this.player = player;
         InventoryPlayer invPlayer = player.inventory;
-        for (int row = 0; row < 6; row++) for (int col = 0; col < 9; col++)
-            addSlotToContainer(new Slot(extraInv, col + row * 9, 8 + col * 18, 5 + row * 18));
+        for (int row = 0; row < 6; row++)
+            for (int col = 0; col < 9; col++)
+                addSlotToContainer(new Slot(extraInv, col + row * 9, 8 + col * 18, 5 + row * 18));
 
-        for (int row = 0; row < 3; ++row) for (int col = 0; col < 9; ++col)
-            addSlotToContainer(new Slot(invPlayer, col + row * 9 + 9, 8 + col * 18, 118 + row * 18));
+        for (int row = 0; row < 3; ++row)
+            for (int col = 0; col < 9; ++col)
+                addSlotToContainer(new Slot(invPlayer, col + row * 9 + 9, 8 + col * 18, 118 + row * 18));
 
-        for (int col = 0; col < 9; ++col) addSlotToContainer(new Slot(invPlayer, col, 8 + col * 18, 176));
+        for (int col = 0; col < 9; ++col)
+            addSlotToContainer(new Slot(invPlayer, col, 8 + col * 18, 176));
 
         addSlotToContainer(new SlotBlockArmor(invPlayer, invPlayer.getSizeInventory() - 1, -15, 23, 0));
-        for (int armorType = 1; armorType < 4; armorType++) addSlotToContainer(
-                new SlotArmor(
-                        invPlayer,
-                        invPlayer.getSizeInventory() - 1 - armorType,
-                        -15,
-                        23 + armorType * 18,
-                        armorType));
+        for (int armorType = 1; armorType < 4; armorType++)
+            addSlotToContainer(new SlotArmor(invPlayer, invPlayer.getSizeInventory() - 1 - armorType, -15, 23 + armorType * 18, armorType));
     }
 
     @Override
@@ -95,13 +91,16 @@ public class ContainerCreativeInv extends Container {
             }
 
             if (slotIndex < 54) {
-                if (!this.mergeItemStack(stack, 54, 90, true)) return null;
+                if (!this.mergeItemStack(stack, 54, 90, true))
+                    return null;
             } else if (!this.mergeItemStack(stack, 0, 54, false)) {
                 return null;
             }
 
-            if (stack.stackSize == 0) slot.putStack(null);
-            else slot.onSlotChanged();
+            if (stack.stackSize == 0)
+                slot.putStack(null);
+            else
+                slot.onSlotChanged();
         }
 
         return transferredStack;

src/main/java/codechicken/nei/ContainerEnchantmentModifier.java

@@ -1,7 +1,6 @@
 package codechicken.nei;
 
-import java.util.ArrayList;
-
+import codechicken.lib.render.CCRenderState;
 import net.minecraft.client.gui.Gui;
 import net.minecraft.enchantment.Enchantment;
 import net.minecraft.entity.player.EntityPlayer;
@@ -13,18 +12,17 @@ import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagList;
 import net.minecraft.world.World;
-
 import org.lwjgl.opengl.GL11;
 
-import codechicken.lib.render.CCRenderState;
+import java.util.ArrayList;
 
 /**
  * This is crap code, don't ever do this.
  */
-public class ContainerEnchantmentModifier extends ContainerEnchantment {
-
-    public static class EnchantmentHash {
-
+public class ContainerEnchantmentModifier extends ContainerEnchantment
+{
+    public static class EnchantmentHash
+    {
         public EnchantmentHash(Enchantment e, int i, int l) {
             enchantment = e;
             state = i;
@@ -106,11 +104,10 @@ public class ContainerEnchantmentModifier extends ContainerEnchantment {
         int barempty = height - getScrollBarHeight();
         int sbary = rely + (int) (barempty * percentscrolled + 0.5);
 
-        if (button == 0 && getScrollBarHeight() < height && // the scroll bar can move (not full length)
-                mousex >= relx + cwidth
-                && mousex < relx + cwidth + getScrollBarWidth()
-                && mousey >= rely
-                && mousey < rely + height) // in the scroll pane
+        if (button == 0 &&
+                getScrollBarHeight() < height && //the scroll bar can move (not full length)
+                mousex >= relx + cwidth && mousex < relx + cwidth + getScrollBarWidth() &&
+                mousey >= rely && mousey < rely + height)//in the scroll pane
         {
             if (mousey < sbary) {
                 percentscrolled = (mousey - rely) / (float) barempty;
@@ -129,7 +126,7 @@ public class ContainerEnchantmentModifier extends ContainerEnchantment {
     }
 
     public void mouseUp(int mousex, int mousey, int button) {
-        if (scrollclicky >= 0 && button == 0) // we were scrolling and we released mouse
+        if (scrollclicky >= 0 && button == 0)//we were scrolling and we released mouse
         {
             scrollclicky = -1;
         }
@@ -138,7 +135,8 @@ public class ContainerEnchantmentModifier extends ContainerEnchantment {
     public boolean clickButton(int mousex, int mousey, int button) {
         mousex -= parentscreen.guiLeft;
         mousey -= parentscreen.guiTop;
-        if (mousex >= relx && mousex < relx + cwidth && mousey >= rely && mousey <= rely + height) // in the box
+        if (mousex >= relx && mousex < relx + cwidth &&
+                mousey >= rely && mousey <= rely + height)//in the box
         {
             int slot = getClickedSlot(mousey);
             if (slot >= getNumSlots()) return false;
@@ -178,8 +176,10 @@ public class ContainerEnchantmentModifier extends ContainerEnchantment {
                 int ID = nbttaglist.getCompoundTagAt(i).getShort("id");
                 if (ID == e) {
                     nbttaglist.removeTag(i);
-                    if (nbttaglist.tagCount() == 0) stack.getTagCompound().removeTag("ench");
-                    if (stack.getTagCompound().hasNoTags()) stack.setTagCompound(null);
+                    if (nbttaglist.tagCount() == 0)
+                        stack.getTagCompound().removeTag("ench");
+                    if (stack.getTagCompound().hasNoTags())
+                        stack.setTagCompound(null);
                     return;
                 }
             }
@@ -191,7 +191,8 @@ public class ContainerEnchantmentModifier extends ContainerEnchantment {
     }
 
     public void onCraftMatrixChanged(IInventory iinventory) {
-        if (parentscreen != null) updateEnchantmentOptions(GuiEnchantmentModifier.validateEnchantments());
+        if (parentscreen != null)
+            updateEnchantmentOptions(GuiEnchantmentModifier.validateEnchantments());
     }
 
     public void updateEnchantmentOptions(boolean validate) {
@@ -220,10 +221,9 @@ public class ContainerEnchantmentModifier extends ContainerEnchantment {
             if (NEIServerUtils.stackHasEnchantment(toolstack, e.effectId)) {
                 state = 2;
                 level = NEIServerUtils.getEnchantmentLevel(toolstack, e.effectId);
-            } else
-                if (NEIServerUtils.doesEnchantmentConflict(NEIServerUtils.getEnchantments(toolstack), e) && validate) {
-                    state = 1;
-                }
+            } else if (NEIServerUtils.doesEnchantmentConflict(NEIServerUtils.getEnchantments(toolstack), e) && validate) {
+                state = 1;
+            }
             slotEnchantment.add(new EnchantmentHash(e, state, level));
         }
         if (numoptions != slotEnchantment.size()) {
@@ -257,28 +257,10 @@ public class ContainerEnchantmentModifier extends ContainerEnchantment {
             CCRenderState.changeTexture("textures/gui/container/enchanting_table.png");
             GL11.glColor3f(1, 1, 1);
             if (hasScrollBar()) {
-                gui.drawTexturedModalRect(
-                        relx,
-                        rely + slot * slotheight,
-                        0,
-                        gui.ySize + slotheight * shade,
-                        cwidth - 30,
-                        slotheight);
-                gui.drawTexturedModalRect(
-                        relx + cwidth - 30,
-                        rely + slot * slotheight,
-                        cwidth - 23,
-                        gui.ySize + slotheight * shade,
-                        30,
-                        slotheight);
+                gui.drawTexturedModalRect(relx, rely + slot * slotheight, 0, gui.ySize + slotheight * shade, cwidth - 30, slotheight);
+                gui.drawTexturedModalRect(relx + cwidth - 30, rely + slot * slotheight, cwidth - 23, gui.ySize + slotheight * shade, 30, slotheight);
             } else {
-                gui.drawTexturedModalRect(
-                        relx,
-                        rely + slot * slotheight,
-                        0,
-                        gui.ySize + slotheight * shade,
-                        cwidth + 7,
-                        slotheight);
+                gui.drawTexturedModalRect(relx, rely + slot * slotheight, 0, gui.ySize + slotheight * shade, cwidth + 7, slotheight);
             }
 
             gui.getFontRenderer().drawString(text, relx + 4, rely + slot * slotheight + 5, textColourFromState(shade));
@@ -295,32 +277,18 @@ public class ContainerEnchantmentModifier extends ContainerEnchantment {
         int sbary = rely + (int) ((height - getScrollBarHeight()) * percentscrolled + 0.5);
         int sbarx = relx + cwidth;
 
-        Gui.drawRect(sbarx, rely, sbarx + getScrollBarWidth(), rely + height, 0xFF202020); // background
-        Gui.drawRect(sbarx, sbary, sbarx + getScrollBarWidth(), sbary + getScrollBarHeight(), 0xFF8B8B8B); // corners
-        Gui.drawRect(sbarx, sbary, sbarx + getScrollBarWidth() - 1, sbary + getScrollBarHeight() - 1, 0xFFF0F0F0); // topleft
-                                                                                                                   // up
-        Gui.drawRect(
-                sbarx + 1,
-                sbary + 1,
-                sbarx + getScrollBarWidth() - 1,
-                sbary + getScrollBarHeight() - 1,
-                0xFF555555); // bottom right down
-        Gui.drawRect(
-                sbarx + 1,
-                sbary + 1,
-                sbarx + getScrollBarWidth() - 2,
-                sbary + getScrollBarHeight() - 2,
-                0xFFC6C6C6); // scrollbar
+        Gui.drawRect(sbarx, rely, sbarx + getScrollBarWidth(), rely + height, 0xFF202020);//background
+        Gui.drawRect(sbarx, sbary, sbarx + getScrollBarWidth(), sbary + getScrollBarHeight(), 0xFF8B8B8B);//corners
+        Gui.drawRect(sbarx, sbary, sbarx + getScrollBarWidth() - 1, sbary + getScrollBarHeight() - 1, 0xFFF0F0F0);//topleft up
+        Gui.drawRect(sbarx + 1, sbary + 1, sbarx + getScrollBarWidth() - 1, sbary + getScrollBarHeight() - 1, 0xFF555555);//bottom right down
+        Gui.drawRect(sbarx + 1, sbary + 1, sbarx + getScrollBarWidth() - 2, sbary + getScrollBarHeight() - 2, 0xFFC6C6C6);//scrollbar
     }
 
     private int textColourFromState(int shade) {
-        switch (shade) {
-            case 0:
-                return 0x685e4a;
-            case 1:
-                return 0x407f10;
-            default:
-                return 0xffff80;
+        switch(shade) {
+            case 0: return 0x685e4a;
+            case 1: return 0x407f10;
+            default: return 0xffff80;
         }
     }
 

src/main/java/codechicken/nei/ContainerPotionCreator.java

@@ -1,5 +1,10 @@
 package codechicken.nei;
 
+import codechicken.lib.inventory.ContainerExtended;
+import codechicken.lib.inventory.InventoryNBT;
+import codechicken.lib.inventory.InventoryUtils;
+import codechicken.lib.inventory.SlotHandleClicks;
+import codechicken.lib.packet.PacketCustom;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.inventory.IInventory;
@@ -11,16 +16,10 @@ import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTTagList;
 import net.minecraft.potion.PotionEffect;
 
-import codechicken.lib.inventory.ContainerExtended;
-import codechicken.lib.inventory.InventoryNBT;
-import codechicken.lib.inventory.InventoryUtils;
-import codechicken.lib.inventory.SlotHandleClicks;
-import codechicken.lib.packet.PacketCustom;
-
-public class ContainerPotionCreator extends ContainerExtended {
-
-    public class SlotPotion extends Slot {
-
+public class ContainerPotionCreator extends ContainerExtended
+{
+    public class SlotPotion extends Slot
+    {
         public SlotPotion(IInventory inv, int slotIndex, int x, int y) {
             super(inv, slotIndex, x, y);
         }
@@ -35,15 +34,16 @@ public class ContainerPotionCreator extends ContainerExtended {
             super.onSlotChanged();
             if (getHasStack()) {
                 ItemStack stack = getStack();
-                if (!stack.hasTagCompound()) stack.setTagCompound(new NBTTagCompound());
+                if (!stack.hasTagCompound())
+                    stack.setTagCompound(new NBTTagCompound());
                 if (!stack.getTagCompound().hasKey("CustomPotionEffects"))
                     stack.getTagCompound().setTag("CustomPotionEffects", new NBTTagList());
             }
         }
     }
 
-    public class SlotPotionStore extends SlotHandleClicks {
-
+    public class SlotPotionStore extends SlotHandleClicks
+    {
         public SlotPotionStore(IInventory inv, int slotIndex, int x, int y) {
             super(inv, slotIndex, x, y);
         }
@@ -60,7 +60,8 @@ public class ContainerPotionCreator extends ContainerExtended {
                     putStack(InventoryUtils.copyStack(held, 1));
                     player.inventory.setItemStack(null);
                 }
-            } else if (getHasStack()) player.inventory.setItemStack(getStack());
+            } else if (getHasStack())
+                player.inventory.setItemStack(getStack());
 
             return null;
         }
@@ -71,8 +72,8 @@ public class ContainerPotionCreator extends ContainerExtended {
         }
     }
 
-    public static class InventoryPotionStore extends InventoryNBT {
-
+    public static class InventoryPotionStore extends InventoryNBT
+    {
         public InventoryPotionStore() {
             super(9, NEIClientConfig.global.nbt.getCompoundTag("potionStore"));
         }
@@ -95,13 +96,15 @@ public class ContainerPotionCreator extends ContainerExtended {
         this.potionStoreInv = potionStoreInv;
 
         addSlotToContainer(new SlotPotion(potionInv, 0, 25, 102));
-        for (int i = 0; i < 9; i++) addSlotToContainer(new SlotPotionStore(potionStoreInv, i, 8 + i * 18, 14));
+        for (int i = 0; i < 9; i++)
+            addSlotToContainer(new SlotPotionStore(potionStoreInv, i, 8 + i * 18, 14));
         bindPlayerInventory(inventoryPlayer, 8, 125);
     }
 
     @Override
     public boolean doMergeStackAreas(int slotIndex, ItemStack stack) {
-        if (slotIndex < 10) return mergeItemStack(stack, 10, 46, true);
+        if (slotIndex < 10)
+            return mergeItemStack(stack, 10, 46, true);
         return mergeItemStack(stack, 0, 1, false);
     }
 
@@ -114,28 +117,30 @@ public class ContainerPotionCreator extends ContainerExtended {
     public void onContainerClosed(EntityPlayer player) {
         super.onContainerClosed(player);
 
-        if (!player.worldObj.isRemote) InventoryUtils.dropOnClose(player, potionInv);
+        if (!player.worldObj.isRemote)
+            InventoryUtils.dropOnClose(player, potionInv);
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public void handleServerPacket(PacketCustom packet) {
         ItemStack potion = potionInv.getStackInSlot(0);
-        if (potion == null) return;
+        if (potion == null)
+            return;
 
         boolean add = packet.getType() == 3;
         int effectID = packet.readUByte();
 
         NBTTagList effects = potion.getTagCompound().getTagList("CustomPotionEffects", 10);
         NBTTagList newEffects = new NBTTagList();
-        for (int i = 0; i < effects.tagCount(); i++) {
+        for(int i = 0; i < effects.tagCount(); i++) {
             NBTTagCompound tag = effects.getCompoundTagAt(i);
             PotionEffect e = PotionEffect.readCustomPotionEffectFromNBT(tag);
-            if (e.getPotionID() != effectID) newEffects.appendTag(tag);
+            if(e.getPotionID() != effectID)
+                newEffects.appendTag(tag);
         }
-        if (add) newEffects.appendTag(
-                new PotionEffect(effectID, packet.readInt(), packet.readUByte())
-                        .writeCustomPotionEffectToNBT(new NBTTagCompound()));
+        if(add)
+            newEffects.appendTag(new PotionEffect(effectID, packet.readInt(), packet.readUByte()).writeCustomPotionEffectToNBT(new NBTTagCompound()));
         potion.getTagCompound().setTag("CustomPotionEffects", newEffects);
     }
 
@@ -152,4 +157,4 @@ public class ContainerPotionCreator extends ContainerExtended {
         packet.writeByte(effectID);
         packet.sendToServer();
     }
-}
+}

src/main/java/codechicken/nei/DefaultHighlightHandler.java

@@ -1,34 +1,35 @@
 package codechicken.nei;
 
-import java.util.List;
-
+import codechicken.nei.api.IHighlightHandler;
+import codechicken.nei.api.ItemInfo;
+import codechicken.nei.guihook.GuiContainerManager;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.MovingObjectPosition;
 import net.minecraft.world.World;
 
-import codechicken.nei.api.IHighlightHandler;
-import codechicken.nei.api.ItemInfo;
-import codechicken.nei.guihook.GuiContainerManager;
-
-public class DefaultHighlightHandler implements IHighlightHandler {
+import java.util.List;
 
+public class DefaultHighlightHandler implements IHighlightHandler
+{
     @Override
-    public List<String> handleTextData(ItemStack stack, World world, EntityPlayer player, MovingObjectPosition mop,
-            List<String> currenttip, ItemInfo.Layout layout) {
+    public List<String> handleTextData(ItemStack stack, World world, EntityPlayer player, MovingObjectPosition mop, List<String> currenttip, ItemInfo.Layout layout) {
         String name = null;
         try {
             String s = GuiContainerManager.itemDisplayNameShort(stack);
-            if (s != null && !s.endsWith("Unnamed")) name = s;
+            if (s != null && !s.endsWith("Unnamed"))
+                name = s;
 
-            if (name != null) currenttip.add(name);
+            if (name != null)
+                currenttip.add(name);
         } catch (Exception ignored) {}
 
         if (name != null && stack.getItem() == Items.redstone) {
             int md = world.getBlockMetadata(mop.blockX, mop.blockY, mop.blockZ);
             String s = "" + md;
-            if (s.length() < 2) s = " " + s;
+            if (s.length() < 2)
+                s = " " + s;
             currenttip.set(currenttip.size() - 1, name + " " + s);
         }
 

src/main/java/codechicken/nei/DoubleFilteredFilter.java

@@ -1,22 +1,20 @@
 package codechicken.nei;
 
+import codechicken.nei.api.ItemFilter;
 import net.minecraft.item.ItemStack;
 
-import codechicken.nei.api.ItemFilter;
-
 public class DoubleFilteredFilter implements ItemFilter {
-
     private ItemFilter filter;
     private ItemList.PatternItemFilter patternFilter;
-
+    
     public DoubleFilteredFilter(ItemFilter filter, String itemFilter) {
-        this.filter = filter;
+        this.filter = filter; 
         this.patternFilter = new ItemList.PatternItemFilter(SearchField.getPattern(itemFilter));
     }
 
     @Override
     public boolean matches(ItemStack item) {
-        if (filter.matches(item)) {
+        if(filter.matches(item)) {
             return patternFilter.matches(item);
         }
         return false;

src/main/java/codechicken/nei/ExtendedCreativeInv.java

@@ -1,13 +1,12 @@
 package codechicken.nei;
 
+import cpw.mods.fml.relauncher.Side;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.IInventory;
 import net.minecraft.item.ItemStack;
 
-import cpw.mods.fml.relauncher.Side;
-
-public class ExtendedCreativeInv implements IInventory {
-
+public class ExtendedCreativeInv implements IInventory
+{
     final PlayerSave playerSave;
     final Side side;
 
@@ -23,7 +22,8 @@ public class ExtendedCreativeInv implements IInventory {
 
     @Override
     public ItemStack getStackInSlot(int slot) {
-        if (side.isClient()) return NEIClientConfig.creativeInv[slot];
+        if (side.isClient())
+            return NEIClientConfig.creativeInv[slot];
         return playerSave.creativeInv[slot];
     }
 
@@ -58,8 +58,10 @@ public class ExtendedCreativeInv implements IInventory {
 
     @Override
     public void setInventorySlotContents(int slot, ItemStack stack) {
-        if (side.isClient()) NEIClientConfig.creativeInv[slot] = stack;
-        else playerSave.creativeInv[slot] = stack;
+        if (side.isClient())
+            NEIClientConfig.creativeInv[slot] = stack;
+        else
+            playerSave.creativeInv[slot] = stack;
 
         markDirty();
     }
@@ -76,7 +78,8 @@ public class ExtendedCreativeInv implements IInventory {
 
     @Override
     public void markDirty() {
-        if (side.isServer()) playerSave.setCreativeDirty();
+        if (side.isServer())
+            playerSave.setCreativeDirty();
     }
 
     @Override
@@ -85,10 +88,12 @@ public class ExtendedCreativeInv implements IInventory {
     }
 
     @Override
-    public void openInventory() {}
+    public void openInventory() {
+    }
 
     @Override
-    public void closeInventory() {}
+    public void closeInventory() {
+    }
 
     @Override
     public boolean isItemValidForSlot(int slot, ItemStack stack) {
@@ -99,4 +104,5 @@ public class ExtendedCreativeInv implements IInventory {
     public boolean hasCustomInventoryName() {
         return true;
     }
+
 }

src/main/java/codechicken/nei/FastTransferManager.java

@@ -1,28 +1,27 @@
 package codechicken.nei;
 
-import static codechicken.nei.NEIServerUtils.areStacksIdentical;
-import static codechicken.nei.NEIServerUtils.areStacksSameType;
-import static codechicken.nei.NEIServerUtils.copyStack;
+import codechicken.nei.guihook.GuiContainerManager;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
 
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.inventory.Container;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-
-import codechicken.nei.guihook.GuiContainerManager;
-
-public class FastTransferManager {
+import static codechicken.nei.NEIServerUtils.areStacksIdentical;
+import static codechicken.nei.NEIServerUtils.areStacksSameType;
+import static codechicken.nei.NEIServerUtils.copyStack;
 
+public class FastTransferManager
+{
     /**
      * Based on the general assumption that we want to fill top to bottom, left to right
      */
-    public static class SlotPositionComparator implements Comparator<Integer> {
-
+    public static class SlotPositionComparator implements Comparator<Integer>
+    {
         final Container container;
 
         public SlotPositionComparator(Container c) {
@@ -48,7 +47,8 @@ public class FastTransferManager {
         stack.stackSize = 1;
 
         for (int slotNo = 0; slotNo < container.inventorySlots.size(); slotNo++) {
-            if (slotZoneMap.containsKey(slotNo) || !container.getSlot(slotNo).isItemValid(stack)) continue;
+            if (slotZoneMap.containsKey(slotNo) || !container.getSlot(slotNo).isItemValid(stack))
+                continue;
 
             HashSet<Integer> connectedSlots = new HashSet<>();
             findConnectedSlots(container, slotNo, connectedSlots);
@@ -69,11 +69,11 @@ public class FastTransferManager {
         final int threshold = 18;
 
         for (int i = 0; i < container.inventorySlots.size(); i++) {
-            if (connectedSlots.contains(i)) continue;
+            if (connectedSlots.contains(i))
+                continue;
 
             Slot slot1 = container.getSlot(i);
-            if (Math.abs(slot.xDisplayPosition - slot1.xDisplayPosition) <= threshold
-                    && Math.abs(slot.yDisplayPosition - slot1.yDisplayPosition) <= threshold) {
+            if (Math.abs(slot.xDisplayPosition - slot1.xDisplayPosition) <= threshold && Math.abs(slot.yDisplayPosition - slot1.yDisplayPosition) <= threshold) {
                 findConnectedSlots(container, i, connectedSlots);
             }
         }
@@ -82,7 +82,8 @@ public class FastTransferManager {
     public static int findSlotWithItem(Container container, ItemStack teststack) {
         for (int slotNo = 0; slotNo < container.inventorySlots.size(); slotNo++) {
             ItemStack stack = container.getSlot(slotNo).getStack();
-            if (areStacksSameType(stack, teststack)) return slotNo;
+            if (areStacksSameType(stack, teststack))
+                return slotNo;
         }
         return -1;
     }
@@ -98,16 +99,20 @@ public class FastTransferManager {
         Integer fromZone = slotZoneMap.get(fromSlot);
         Integer toZone = slotZoneMap.get(toSlot);
 
-        if (fromZone == null || toZone == null || fromZone.equals(toZone)) return;
+        if (fromZone == null || toZone == null || fromZone.equals(toZone))
+            return;
 
-        if (NEIClientUtils.getHeldItem() != null && !areStacksSameType(heldStack, NEIClientUtils.getHeldItem())) return;
+        if (NEIClientUtils.getHeldItem() != null && !areStacksSameType(heldStack, NEIClientUtils.getHeldItem()))
+            return;
 
-        if (!fillZoneWithHeldItem(window, toZone)) return;
+        if (!fillZoneWithHeldItem(window, toZone))
+            return;
 
         for (int transferFrom : slotZones.get(fromZone)) {
             ItemStack transferStack = window.inventorySlots.getSlot(transferFrom).getStack();
 
-            if (!areStacksSameType(heldStack, transferStack)) continue;
+            if (!areStacksSameType(heldStack, transferStack))
+                continue;
 
             clickSlot(window, transferFrom);
             if (!fillZoneWithHeldItem(window, toZone)) {
@@ -125,7 +130,8 @@ public class FastTransferManager {
 
         Slot slot = container.getSlot(fromSlot);
         ItemStack stack = slot.getStack();
-        if (stack == null) return -1;
+        if (stack == null)
+            return -1;
 
         stack.stackSize = 1;
         slot.putStack(stack.copy());
@@ -135,19 +141,19 @@ public class FastTransferManager {
         LinkedList<ItemStack> compareAfter = saveContainer(container);
 
         try {
-            // if(compareAfter.get(fromSlot) != null)//transfer failed
-            // return -1;
+            //if(compareAfter.get(fromSlot) != null)//transfer failed
+            //return -1;
 
             for (int i = 0; i < compareBefore.size(); i++) {
-                if (i == fromSlot) continue;
+                if (i == fromSlot)
+                    continue;
 
                 ItemStack before = compareBefore.get(i);
                 ItemStack after = compareAfter.get(i);
 
                 if (!areStacksIdentical(before, after) && after != null)
-                    if (before == null ? areStacksSameType(stack, after) : // transfered into this empty slot
-                            areStacksSameType(stack, after) && after.stackSize - before.stackSize > 0) // it added to
-                                                                                                       // this stack
+                    if (before == null ? areStacksSameType(stack, after) ://transfered into this empty slot
+                            areStacksSameType(stack, after) && after.stackSize - before.stackSize > 0)//it added to this stack
                         return i;
             }
 
@@ -175,42 +181,45 @@ public class FastTransferManager {
 
     public void transferItem(GuiContainer window, int fromSlot) {
         int toSlot = findShiftClickDestinationSlot(window.inventorySlots, fromSlot);
-        if (toSlot == -1) return;
+        if (toSlot == -1)
+            return;
 
         Slot from = window.inventorySlots.getSlot(fromSlot);
 
-        if (from.isItemValid(from.getStack())) moveOneItem(window, fromSlot, toSlot);
-        else // slots that you can't put stuff in
+        if (from.isItemValid(from.getStack()))
+            moveOneItem(window, fromSlot, toSlot);
+        else//slots that you can't put stuff in
             moveOutputSet(window, fromSlot, toSlot);
     }
 
     public void moveOutputSet(GuiContainer window, int fromSlot, int toSlot) {
-        if (NEIClientUtils.getHeldItem() != null) return;
-
-        clickSlot(window, fromSlot); // pickup fromSlot
-        if (NEIClientUtils.getHeldItem() == null) // maybe this container does auto transfers. No need to pick up the
-                                                  // final item
+        if (NEIClientUtils.getHeldItem() != null)
             return;
-        clickSlot(window, toSlot); // place one in toSlot
+
+        clickSlot(window, fromSlot);//pickup fromSlot
+        if (NEIClientUtils.getHeldItem() == null)//maybe this container does auto transfers. No need to pick up the final item
+            return;
+        clickSlot(window, toSlot);//place one in toSlot
     }
 
     public void moveOneItem(GuiContainer window, int fromSlot, int toSlot) {
-        clickSlot(window, fromSlot); // pickup fromSlot
-        clickSlot(window, toSlot, 1); // place one in toSlot
-        clickSlot(window, fromSlot); // place down in fromSlot
+        clickSlot(window, fromSlot);//pickup fromSlot
+        clickSlot(window, toSlot, 1);//place one in toSlot
+        clickSlot(window, fromSlot);//place down in fromSlot
     }
 
     public void retrieveItem(GuiContainer window, int toSlot) {
         Slot slot = window.inventorySlots.getSlot(toSlot);
         ItemStack slotStack = slot.getStack();
-        if (slotStack == null || slotStack.stackSize == slot.getSlotStackLimit()
-                || slotStack.stackSize == slotStack.getMaxStackSize())
+        if (slotStack == null ||
+                slotStack.stackSize == slot.getSlotStackLimit() ||
+                slotStack.stackSize == slotStack.getMaxStackSize())
             return;
 
         generateSlotMap(window.inventorySlots, slotStack);
 
         Integer destZone = slotZoneMap.get(toSlot);
-        if (destZone == null) // slots that don't accept
+        if (destZone == null)//slots that don't accept
             return;
 
         int firstZoneSlot = findShiftClickDestinationSlot(window.inventorySlots, toSlot);
@@ -219,14 +228,17 @@ public class FastTransferManager {
             Integer integer = slotZoneMap.get(firstZoneSlot);
             if (integer != null) {
                 firstZone = integer;
-                if (retrieveItemFromZone(window, firstZone, toSlot)) return;
+                if (retrieveItemFromZone(window, firstZone, toSlot))
+                    return;
             }
         }
 
         for (int zone = 0; zone < slotZones.size(); zone++) {
-            if (zone == destZone || zone == firstZone) continue;
+            if (zone == destZone || zone == firstZone)
+                continue;
 
-            if (retrieveItemFromZone(window, zone, toSlot)) return;
+            if (retrieveItemFromZone(window, zone, toSlot))
+                return;
         }
 
         retrieveItemFromZone(window, destZone, toSlot);
@@ -235,14 +247,14 @@ public class FastTransferManager {
     private boolean retrieveItemFromZone(GuiContainer window, int zone, int toSlot) {
         ItemStack stack = window.inventorySlots.getSlot(toSlot).getStack();
         for (int i : slotZones.get(zone)) {
-            if (i == toSlot) continue;
+            if (i == toSlot)
+                continue;
 
             Slot slot = window.inventorySlots.getSlot(i);
             ItemStack stack1 = slot.getStack();
 
-            if (areStacksSameType(stack, stack1) && stack1.stackSize != slot.getSlotStackLimit() && // get from full
-                                                                                                    // stacks on second
-                                                                                                    // pass
+            if (areStacksSameType(stack, stack1) &&
+                    stack1.stackSize != slot.getSlotStackLimit() && //get from full stacks on second pass
                     stack1.stackSize != stack1.getMaxStackSize()) {
                 moveOneItem(window, i, toSlot);
                 return true;
@@ -250,7 +262,8 @@ public class FastTransferManager {
         }
 
         for (int i : slotZones.get(zone)) {
-            if (i == toSlot) continue;
+            if (i == toSlot)
+                continue;
 
             Slot slot = window.inventorySlots.getSlot(i);
             ItemStack stack1 = slot.getStack();
@@ -279,24 +292,28 @@ public class FastTransferManager {
         for (int transferTo : slotZones.get(zoneIndex)) {
             ItemStack held = NEIClientUtils.getHeldItem();
 
-            if (held == null) break;
+            if (held == null)
+                break;
 
             ItemStack inToSlot = window.inventorySlots.getSlot(transferTo).getStack();
 
-            if (!areStacksSameType(inToSlot, held)) continue;
+            if (!areStacksSameType(inToSlot, held))
+                continue;
 
             clickSlot(window, transferTo);
         }
 
-        for (int transferTo : slotZones.get(zoneIndex)) // repeat on empty slots
+        for (int transferTo : slotZones.get(zoneIndex))//repeat on empty slots
         {
             ItemStack held = NEIClientUtils.getHeldItem();
 
-            if (held == null) break;
+            if (held == null)
+                break;
 
             ItemStack inToSlot = window.inventorySlots.getSlot(transferTo).getStack();
 
-            if (inToSlot != null) continue;
+            if (inToSlot != null)
+                continue;
 
             clickSlot(window, transferTo);
         }
@@ -306,13 +323,14 @@ public class FastTransferManager {
 
     public void throwAll(GuiContainer window, int pickedUpFromSlot) {
         ItemStack held = NEIClientUtils.getHeldItem();
-        if (held == null) return;
+        if (held == null)
+            return;
 
         clickSlot(window, -999);
 
         generateSlotMap(window.inventorySlots, held);
         Integer zone = slotZoneMap.get(pickedUpFromSlot);
-        if (zone == null) // something went wrong and we can't work out where the item was picked up from
+        if(zone == null) //something went wrong and we can't work out where the item was picked up from
             return;
 
         for (int slotIndex : slotZones.get(zone)) {

src/main/java/codechicken/nei/GuiEnchantmentModifier.java

@@ -1,19 +1,17 @@
 package codechicken.nei;
 
-import static codechicken.nei.NEIClientUtils.translate;
-
+import codechicken.lib.render.CCRenderState;
 import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.world.World;
-
 import org.lwjgl.opengl.GL11;
 
-import codechicken.lib.render.CCRenderState;
-
-public class GuiEnchantmentModifier extends GuiContainer {
+import static codechicken.nei.NEIClientUtils.translate;
 
+public class GuiEnchantmentModifier extends GuiContainer
+{
     final ContainerEnchantmentModifier container;
 
     public GuiEnchantmentModifier(InventoryPlayer inventoryplayer, World world, int i, int j, int k) {

src/main/java/codechicken/nei/GuiExtendedCreativeInv.java

@@ -1,22 +1,18 @@
 package codechicken.nei;
 
+import codechicken.lib.render.CCRenderState;
+import codechicken.nei.api.INEIGuiHandler;
+import codechicken.nei.api.TaggedInventoryArea;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.inventory.Container;
+import net.minecraft.item.ItemStack;
+import org.lwjgl.opengl.GL11;
+
 import java.util.Collections;
 import java.util.List;
 
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.inventory.Container;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-
-import org.lwjgl.opengl.GL11;
-
-import codechicken.lib.render.CCRenderState;
-import codechicken.lib.vec.Rectangle4i;
-import codechicken.nei.api.INEIGuiHandler;
-import codechicken.nei.api.TaggedInventoryArea;
-
-public class GuiExtendedCreativeInv extends GuiContainer implements INEIGuiHandler {
-
+public class GuiExtendedCreativeInv extends GuiContainer implements INEIGuiHandler
+{
     public GuiExtendedCreativeInv(Container par1Container) {
         super(par1Container);
         ySize = 198;
@@ -55,17 +51,6 @@ public class GuiExtendedCreativeInv extends GuiContainer implements INEIGuiHandl
 
     @Override
     public boolean hideItemPanelSlot(GuiContainer gui, int x, int y, int w, int h) {
-        return (new Rectangle4i(guiLeft - 15, guiTop + 18, 18, 18 * 4 + 4)).intersects(new Rectangle4i(x, y, w, h));
-    }
-
-    @Override
-    protected void handleMouseClick(Slot p_146984_1_, int p_146984_2_, int p_146984_3_, int p_146984_4_) {
-
-        // Hack for armor slots, because they are outside the container
-        if (p_146984_1_ != null && p_146984_4_ == 4 && p_146984_1_.xDisplayPosition < 0) {
-            p_146984_4_ = 0;
-        }
-
-        super.handleMouseClick(p_146984_1_, p_146984_2_, p_146984_3_, p_146984_4_);
+        return false;
     }
 }

src/main/java/codechicken/nei/GuiNEIButton.java

@@ -4,61 +4,38 @@ import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.util.ResourceLocation;
-
 import org.lwjgl.opengl.GL11;
 
-public class GuiNEIButton extends GuiButton {
-
+public class GuiNEIButton extends GuiButton
+{
     protected static final ResourceLocation guiTex = new ResourceLocation("textures/gui/widgets.png");
-
-    public GuiNEIButton(int i, int j, int k, int l, int i1, String s) {
+    
+    public GuiNEIButton(int i, int j, int k, int l, int i1, String s)
+    {
         super(i, j, k, l, i1, s);
     }
-
-    public void drawButton(Minecraft minecraft, int i, int j) {
-        if (!visible) return;
+    
+    public void drawButton(Minecraft minecraft, int i, int j)
+    {
+        if(!visible)
+            return;
 
         FontRenderer fontrenderer = minecraft.fontRenderer;
         minecraft.renderEngine.bindTexture(guiTex);
         GL11.glColor4f(1, 1, 1, 1);
         boolean flag = i >= xPosition && j >= yPosition && i < xPosition + width && j < yPosition + height;
         int k = getHoverState(flag);
-        drawTexturedModalRect(xPosition, yPosition, 0, 46 + k * 20, width / 2, height / 2); // top left
-        drawTexturedModalRect(xPosition + width / 2, yPosition, 200 - width / 2, 46 + k * 20, width / 2, height / 2); // top
-                                                                                                                      // right
-        drawTexturedModalRect(
-                xPosition,
-                yPosition + height / 2,
-                0,
-                46 + k * 20 + 20 - height / 2,
-                width / 2,
-                height / 2); // bottom left
-        drawTexturedModalRect(
-                xPosition + width / 2,
-                yPosition + height / 2,
-                200 - width / 2,
-                46 + k * 20 + 20 - height / 2,
-                width / 2,
-                height / 2); // bottom right
+        drawTexturedModalRect(xPosition, yPosition, 0, 46 + k * 20, width / 2, height / 2);//top left
+        drawTexturedModalRect(xPosition + width / 2, yPosition, 200 - width / 2, 46 + k * 20, width / 2, height / 2);//top right
+        drawTexturedModalRect(xPosition, yPosition + height / 2, 0, 46 + k * 20 + 20 - height / 2, width / 2, height / 2);//bottom left
+        drawTexturedModalRect(xPosition + width / 2, yPosition + height / 2, 200 - width / 2, 46 + k * 20 + 20 - height / 2, width / 2, height / 2);//bottom right
         mouseDragged(minecraft, i, j);
-
-        if (!enabled) drawCenteredString(
-                fontrenderer,
-                displayString,
-                xPosition + width / 2,
-                yPosition + (height - 8) / 2,
-                0xffa0a0a0);
-        else if (flag) drawCenteredString(
-                fontrenderer,
-                displayString,
-                xPosition + width / 2,
-                yPosition + (height - 8) / 2,
-                0xffffa0);
-        else drawCenteredString(
-                fontrenderer,
-                displayString,
-                xPosition + width / 2,
-                yPosition + (height - 8) / 2,
-                0xe0e0e0);
+        
+        if(!enabled)
+            drawCenteredString(fontrenderer, displayString, xPosition + width / 2, yPosition + (height - 8) / 2, 0xffa0a0a0);
+        else if(flag)
+            drawCenteredString(fontrenderer, displayString, xPosition + width / 2, yPosition + (height - 8) / 2, 0xffffa0);
+        else
+            drawCenteredString(fontrenderer, displayString, xPosition + width / 2, yPosition + (height - 8) / 2, 0xe0e0e0);
     }
 }

src/main/java/codechicken/nei/GuiPotionCreator.java

@@ -1,37 +1,37 @@
 package codechicken.nei;
 
-import static codechicken.nei.NEIClientUtils.translate;
-
-import java.awt.Dimension;
-import java.util.ArrayList;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagList;
-import net.minecraft.potion.Potion;
-import net.minecraft.potion.PotionEffect;
-import net.minecraft.util.StatCollector;
-
-import org.lwjgl.opengl.GL11;
-
 import codechicken.core.gui.GuiCCButton;
 import codechicken.core.gui.GuiCCTextField;
 import codechicken.core.gui.GuiScrollSlot;
 import codechicken.core.inventory.GuiContainerWidget;
 import codechicken.lib.render.CCRenderState;
 import codechicken.lib.render.FontUtils;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.StatCollector;
+import org.lwjgl.opengl.GL11;
 
-public class GuiPotionCreator extends GuiContainerWidget {
+import java.awt.Dimension;
+import java.util.ArrayList;
 
-    public class GuiSlotPotionEffects extends GuiScrollSlot {
+import static codechicken.nei.NEIClientUtils.translate;
 
+public class GuiPotionCreator extends GuiContainerWidget
+{
+    public class GuiSlotPotionEffects extends GuiScrollSlot
+    {
         public int selectedslot = -1;
         public boolean enabled = true;
         private final ArrayList<Potion> validPotions = new ArrayList<>();
 
         public GuiSlotPotionEffects(int x, int y) {
             super(x, y, 108, 76);
-            for (Potion p : Potion.potionTypes) if (p != null) validPotions.add(p);
+            for (Potion p : Potion.potionTypes)
+                if (p != null)
+                    validPotions.add(p);
             setSmoothScroll(false);
             setMargins(0, 0, 0, 0);
         }
@@ -48,7 +48,8 @@ public class GuiPotionCreator extends GuiContainerWidget {
         }
 
         @Override
-        public void drawOverlay(float frame) {}
+        public void drawOverlay(float frame) {
+        }
 
         @Override
         public int scrollbarGuideAlignment() {
@@ -68,18 +69,13 @@ public class GuiPotionCreator extends GuiContainerWidget {
             Potion potion = validPotions.get(slot);
             PotionEffect effect = getEffect(potion.id);
             boolean blank = effect == null;
-            if (effect == null) effect = new PotionEffect(potion.id, 1200, 0);
+            if (effect == null)
+                effect = new PotionEffect(potion.id, 1200, 0);
             int shade = selectedslot == slot ? 2 : blank ? 1 : 0;
 
             CCRenderState.changeTexture("textures/gui/container/enchanting_table.png");
             drawTexturedModalRect(x, y, 0, 166 + getSlotHeight(slot) * shade, width - 30, getSlotHeight(slot));
-            drawTexturedModalRect(
-                    x + width - 30,
-                    y,
-                    width - 23,
-                    166 + getSlotHeight(slot) * shade,
-                    30,
-                    getSlotHeight(slot));
+            drawTexturedModalRect(x + width - 30, y, width - 23, 166 + getSlotHeight(slot) * shade, 30, getSlotHeight(slot));
 
             if (potion.hasStatusIcon()) {
                 CCRenderState.changeTexture("textures/gui/container/inventory.png");
@@ -108,7 +104,8 @@ public class GuiPotionCreator extends GuiContainerWidget {
                 NBTTagList potionTagList = potion.getTagCompound().getTagList("CustomPotionEffects", 10);
                 for (int i = 0; i < potionTagList.tagCount(); i++) {
                     PotionEffect effect = PotionEffect.readCustomPotionEffectFromNBT(potionTagList.getCompoundTagAt(i));
-                    if (effect.getPotionID() == id) return effect;
+                    if (effect.getPotionID() == id)
+                        return effect;
                 }
             }
             return null;
@@ -121,7 +118,8 @@ public class GuiPotionCreator extends GuiContainerWidget {
 
         @Override
         protected void slotClicked(int slot, int button, int mx, int my, int count) {
-            if (!enabled) return;
+            if (!enabled)
+                return;
 
             if (button == 0) {
                 select(slot);
@@ -147,16 +145,19 @@ public class GuiPotionCreator extends GuiContainerWidget {
         }
 
         public void setEnabled(boolean b) {
-            if (b == enabled) return;
+            if (b == enabled)
+                return;
             enabled = b;
-            if (!enabled) deselect();
+            if (!enabled)
+                deselect();
         }
 
         private void select(int slot) {
             selectedslot = slot;
             durationField.setEnabled(true);
             PotionEffect effect = getEffect(validPotions.get(slot).id);
-            if (effect == null) effect = new PotionEffect(validPotions.get(slot).id, 1200, 0);
+            if (effect == null)
+                effect = new PotionEffect(validPotions.get(slot).id, 1200, 0);
             durationField.setDurationTicks(effect.getDuration());
             amplifier = effect.getAmplifier();
             validateInputButtons();
@@ -174,8 +175,8 @@ public class GuiPotionCreator extends GuiContainerWidget {
         }
     }
 
-    public class GuiDurationField extends GuiCCTextField {
-
+    public class GuiDurationField extends GuiCCTextField
+    {
         private String baseValue;
 
         public GuiDurationField(int x, int y, int width, int height) {
@@ -189,22 +190,27 @@ public class GuiPotionCreator extends GuiContainerWidget {
             i /= 20;
             String minutes = Integer.toString(i / 60);
             String seconds = Integer.toString(i % 60);
-            if (seconds.length() == 1) seconds = '0' + seconds;
+            if (seconds.length() == 1)
+                seconds = '0' + seconds;
             setText(minutes + seconds);
         }
 
         @Override
         public void setEnabled(boolean b) {
             super.setEnabled(b);
-            if (!isEnabled()) setText("100");
+            if (!isEnabled())
+                setText("100");
         }
 
         @Override
         public void onFocusChanged() {
-            if (isFocused()) baseValue = getText();
+            if (isFocused())
+                baseValue = getText();
             else {
-                if (!validateValue()) setText(baseValue);
-                else applyEffect();
+                if (!validateValue())
+                    setText(baseValue);
+                else
+                    applyEffect();
             }
         }
 
@@ -225,8 +231,7 @@ public class GuiPotionCreator extends GuiContainerWidget {
         @Override
         public void drawText() {
             String s = getText();
-            String seconds = s
-                    .substring(Math.max(0, s.length() - 2), Math.max(0, s.length() - 2) + Math.min(s.length(), 2));
+            String seconds = s.substring(Math.max(0, s.length() - 2), Math.max(0, s.length() - 2) + Math.min(s.length(), 2));
             String minutes = s.length() < 3 ? "" : s.substring(0, s.length() - 2);
             int ty = y + height / 2 - 4;
             int tcolour = getTextColour();
@@ -311,8 +316,10 @@ public class GuiPotionCreator extends GuiContainerWidget {
 
     @Override
     public void actionPerformed(String ident, Object... params) {
-        if (ident.equals("ampDown")) amplifier--;
-        else if (ident.equals("ampUp")) amplifier++;
+        if (ident.equals("ampDown"))
+            amplifier--;
+        else if (ident.equals("ampUp"))
+            amplifier++;
         applyEffect();
         validateInputButtons();
     }

src/main/java/codechicken/nei/HUDRenderer.java

@@ -1,31 +1,29 @@
 package codechicken.nei;
 
+import codechicken.lib.config.ConfigTag;
+import codechicken.nei.KeyManager.IKeyStateTracker;
+import codechicken.nei.api.ItemInfo;
+import codechicken.nei.guihook.GuiContainerManager;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.MovingObjectPosition.MovingObjectType;
+import net.minecraft.world.World;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+import java.awt.Dimension;
+import java.awt.Point;
+import java.util.ArrayList;
+import java.util.List;
+
 import static codechicken.lib.gui.GuiDraw.displaySize;
 import static codechicken.lib.gui.GuiDraw.drawString;
 import static codechicken.lib.gui.GuiDraw.drawTooltipBox;
 import static codechicken.lib.gui.GuiDraw.getStringWidth;
 
-import java.awt.Dimension;
-import java.awt.Point;
-import java.util.List;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.RenderHelper;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.MovingObjectPosition.MovingObjectType;
-import net.minecraft.world.World;
-
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL12;
-
-import codechicken.lib.config.ConfigTag;
-import codechicken.nei.KeyManager.IKeyStateTracker;
-import codechicken.nei.api.ItemInfo;
-import codechicken.nei.guihook.GuiContainerManager;
-import codechicken.nei.recipe.StackInfo;
-
-public class HUDRenderer implements IKeyStateTracker {
-
+public class HUDRenderer implements IKeyStateTracker
+{
     @Override
     public void tickKeyStates() {
         if (KeyManager.keyStates.get("world.highlight_tips").down) {
@@ -36,28 +34,37 @@ public class HUDRenderer implements IKeyStateTracker {
 
     public static void renderOverlay() {
         Minecraft mc = Minecraft.getMinecraft();
-        if (mc.currentScreen == null && mc.theWorld != null
-                && !mc.gameSettings.keyBindPlayerList.getIsKeyPressed()
-                && NEIClientConfig.getBooleanSetting("world.highlight_tips")
-                && mc.objectMouseOver != null
-                && mc.objectMouseOver.typeOfHit == MovingObjectType.BLOCK) {
+        if (mc.currentScreen == null &&
+                mc.theWorld != null &&
+                !mc.gameSettings.keyBindPlayerList.getIsKeyPressed() &&
+                NEIClientConfig.getBooleanSetting("world.highlight_tips") &&
+                mc.objectMouseOver != null &&
+                mc.objectMouseOver.typeOfHit == MovingObjectType.BLOCK) {
             World world = mc.theWorld;
-            ItemStack[] items = ItemInfo.getIdentifierItems(world, mc.thePlayer, mc.objectMouseOver)
-                    .toArray(new ItemStack[0]);
+            ArrayList<ItemStack> items = ItemInfo.getIdentifierItems(world, mc.thePlayer, mc.objectMouseOver);
+            if (items.isEmpty())
+                return;
 
-            if (items.length == 0) return;
-
-            ItemStack stack = StackInfo.getItemStackWithMinimumDamage(items);
+            int minDamage = Integer.MAX_VALUE;
+            ItemStack stack = null;
+            for(ItemStack astack : items) {
+                if(astack.getItem() != null && astack.getItemDamage() < minDamage) {
+                    stack = astack;
+                    minDamage = stack.getItemDamage();
+                }
+            }
 
             renderOverlay(stack, ItemInfo.getText(stack, world, mc.thePlayer, mc.objectMouseOver), getPositioning());
         }
     }
 
     public static void renderOverlay(ItemStack stack, List<String> textData, Point pos) {
-        if ((stack == null || stack.getItem() == null) && textData.isEmpty()) return;
+        if((stack == null || stack.getItem() == null) && textData.isEmpty())
+            return;
 
         int w = 0;
-        for (String s : textData) w = Math.max(w, getStringWidth(s) + 29);
+        for (String s : textData)
+            w = Math.max(w, getStringWidth(s) + 29);
         int h = Math.max(24, 10 + 10 * textData.size());
 
         Dimension size = displaySize();
@@ -78,7 +85,8 @@ public class HUDRenderer implements IKeyStateTracker {
         RenderHelper.enableGUIStandardItemLighting();
         GL11.glEnable(GL12.GL_RESCALE_NORMAL);
 
-        if (stack != null && stack.getItem() != null) GuiContainerManager.drawItem(x + 5, y + h / 2 - 8, stack);
+        if (stack != null && stack.getItem() != null)
+            GuiContainerManager.drawItem(x + 5, y + h / 2 - 8, stack);
     }
 
     private static Point getPositioning() {
@@ -90,4 +98,4 @@ public class HUDRenderer implements IKeyStateTracker {
     public static void load() {
         KeyManager.trackers.add(new HUDRenderer());
     }
-}
+}

src/main/java/codechicken/nei/Image.java

@@ -1,13 +1,14 @@
 package codechicken.nei;
 
-public class Image {
-
+public class Image
+{
     public int x;
     public int y;
     public int width;
     public int height;
 
-    public Image(int x, int y, int w, int h) {
+    public Image(int x, int y, int w, int h)
+    {
         this.x = x;
         this.y = y;
         width = w;

src/main/java/codechicken/nei/InfiniteStackSizeHandler.java

@@ -1,47 +1,55 @@
 package codechicken.nei;
 
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-
 import codechicken.lib.inventory.InventoryUtils;
 import codechicken.nei.api.IInfiniteItemHandler;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
 
-public class InfiniteStackSizeHandler implements IInfiniteItemHandler {
-
+public class InfiniteStackSizeHandler implements IInfiniteItemHandler
+{
     @Override
-    public void onPickup(ItemStack heldItem) {
+    public void onPickup(ItemStack heldItem)
+    {
         heldItem.stackSize = 1;
     }
 
     @Override
-    public void onPlaceInfinite(ItemStack heldItem) {
+    public void onPlaceInfinite(ItemStack heldItem)
+    {
         heldItem.stackSize = 111;
     }
 
     @Override
-    public boolean canHandleItem(ItemStack stack) {
+    public boolean canHandleItem(ItemStack stack)
+    {
         return !stack.isItemStackDamageable();
     }
 
     @Override
-    public boolean isItemInfinite(ItemStack stack) {
+    public boolean isItemInfinite(ItemStack stack)
+    {
         return stack.stackSize == -1 || stack.stackSize > 100;
     }
 
     @Override
-    public void replenishInfiniteStack(InventoryPlayer inv, int slotNo) {
+    public void replenishInfiniteStack(InventoryPlayer inv, int slotNo)
+    {
         ItemStack stack = inv.getStackInSlot(slotNo);
         stack.stackSize = 111;
-
-        for (int i = 0; i < inv.getSizeInventory(); i++) {
-            if (i == slotNo) continue;
-
-            if (NEIServerUtils.areStacksSameType(stack, inv.getStackInSlot(i))) inv.setInventorySlotContents(i, null);
+        
+        for(int i = 0; i < inv.getSizeInventory(); i++)
+        {
+            if(i == slotNo)
+                continue;
+            
+            if(NEIServerUtils.areStacksSameType(stack, inv.getStackInSlot(i)))
+                inv.setInventorySlotContents(i, null);
         }
     }
 
     @Override
-    public ItemStack getInfiniteItem(ItemStack typeStack) {
+    public ItemStack getInfiniteItem(ItemStack typeStack)
+    {
         return InventoryUtils.copyStack(typeStack, -1);
     }
 }

src/main/java/codechicken/nei/InfiniteToolHandler.java

@@ -1,12 +1,11 @@
 package codechicken.nei;
 
+import codechicken.nei.api.IInfiniteItemHandler;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 
-import codechicken.nei.api.IInfiniteItemHandler;
-
-public class InfiniteToolHandler implements IInfiniteItemHandler {
-
+public class InfiniteToolHandler implements IInfiniteItemHandler
+{
     @Override
     public void onPickup(ItemStack heldItem) {
         heldItem.setItemDamage(0);

src/main/java/codechicken/nei/InventoryCraftingDummy.java

@@ -4,13 +4,15 @@ import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Container;
 import net.minecraft.inventory.InventoryCrafting;
 
-public class InventoryCraftingDummy extends InventoryCrafting {
-
-    public InventoryCraftingDummy() {
-        super(new Container() {
-
+public class InventoryCraftingDummy extends InventoryCrafting
+{
+    public InventoryCraftingDummy()
+    {
+        super(new Container()
+        {
             @Override
-            public boolean canInteractWith(EntityPlayer entityplayer) {
+            public boolean canInteractWith(EntityPlayer entityplayer)
+            {
                 return true;
             }
         }, 3, 3);

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

@@ -1,5 +1,16 @@
 package codechicken.nei;
 
+import codechicken.nei.ThreadOperationTimer.TimeoutException;
+import codechicken.nei.api.ItemFilter;
+import codechicken.nei.api.ItemFilter.ItemFilterProvider;
+import codechicken.nei.api.ItemInfo;
+import codechicken.nei.guihook.GuiContainerManager;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.ListMultimap;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.LinkedList;
@@ -9,25 +20,12 @@ import java.util.concurrent.ForkJoinPool;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.IIcon;
-
-import codechicken.nei.ThreadOperationTimer.TimeoutException;
-import codechicken.nei.api.ItemFilter;
-import codechicken.nei.api.ItemFilter.ItemFilterProvider;
-import codechicken.nei.api.ItemInfo;
-import codechicken.nei.guihook.GuiContainerManager;
-
-import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.ListMultimap;
-
-public class ItemList {
-
+public class ItemList
+{
     /**
      * Fields are replaced atomically and contents never modified.
      */
-    public static volatile List<ItemStack> items = new ArrayList<>();
+    public static volatile List<ItemStack>  items = new ArrayList<>();
     /**
      * Fields are replaced atomically and contents never modified.
      */
@@ -36,34 +34,29 @@ public class ItemList {
      * Updates to this should be synchronised on this
      */
     public static final List<ItemFilterProvider> itemFilterers = new LinkedList<>();
-
     public static final List<ItemsLoadedCallback> loadCallbacks = new LinkedList<>();
 
     private static final HashSet<Item> erroredItems = new HashSet<>();
     private static final HashSet<String> stackTraces = new HashSet<>();
-    /**
-     * Unlike {@link LayoutManager#itemsLoaded}, this indicates whether item loading is actually finished or not.
-     */
-    public static boolean loadFinished;
-
-    public static class EverythingItemFilter implements ItemFilter {
 
+    public static class EverythingItemFilter implements ItemFilter
+    {
         @Override
         public boolean matches(ItemStack item) {
             return true;
         }
     }
 
-    public static class NothingItemFilter implements ItemFilter {
-
+    public static class NothingItemFilter implements ItemFilter
+    {
         @Override
         public boolean matches(ItemStack item) {
             return false;
         }
     }
 
-    public static class PatternItemFilter implements ItemFilter {
-
+    public static class PatternItemFilter implements ItemFilter
+    {
         public Pattern pattern;
 
         public PatternItemFilter(Pattern pattern) {
@@ -76,8 +69,8 @@ public class ItemList {
         }
     }
 
-    public static class AllMultiItemFilter implements ItemFilter {
-
+    public static class AllMultiItemFilter implements ItemFilter
+    {
         public List<ItemFilter> filters;
 
         public AllMultiItemFilter(List<ItemFilter> filters) {
@@ -90,18 +83,19 @@ public class ItemList {
 
         @Override
         public boolean matches(ItemStack item) {
-            for (ItemFilter filter : filters) try {
-                if (!filter.matches(item)) return false;
-            } catch (Exception e) {
-                NEIClientConfig.logger.error("Exception filtering " + item + " with " + filter, e);
-            }
+            for(ItemFilter filter : filters)
+                try {
+                    if (!filter.matches(item)) return false;
+                } catch (Exception e) {
+                    NEIClientConfig.logger.error("Exception filtering "+item+" with "+filter, e);
+                }
 
             return true;
         }
     }
 
-    public static class AnyMultiItemFilter implements ItemFilter {
-
+    public static class AnyMultiItemFilter implements ItemFilter
+    {
         public List<ItemFilter> filters;
 
         public AnyMultiItemFilter(List<ItemFilter> filters) {
@@ -114,27 +108,29 @@ public class ItemList {
 
         @Override
         public boolean matches(ItemStack item) {
-            for (ItemFilter filter : filters) try {
-                if (filter.matches(item)) return true;
-            } catch (Exception e) {
-                NEIClientConfig.logger.error("Exception filtering " + item + " with " + filter, e);
-            }
+            for(ItemFilter filter : filters)
+                try {
+                    if (filter.matches(item)) return true;
+                } catch (Exception e) {
+                    NEIClientConfig.logger.error("Exception filtering "+item+" with "+filter, e);
+                }
 
             return false;
         }
     }
 
-    public static interface ItemsLoadedCallback {
-
+    public static interface ItemsLoadedCallback
+    {
         public void itemsLoaded();
     }
 
     public static boolean itemMatchesAll(ItemStack item, List<ItemFilter> filters) {
-        for (ItemFilter filter : filters) {
+        for(ItemFilter filter : filters) {
             try {
-                if (!filter.matches(item)) return false;
+                if (!filter.matches(item))
+                    return false;
             } catch (Exception e) {
-                NEIClientConfig.logger.error("Exception filtering " + item + " with " + filter, e);
+                NEIClientConfig.logger.error("Exception filtering "+item+" with "+filter, e);
             }
         }
 
@@ -142,7 +138,7 @@ public class ItemList {
     }
 
     /**
-     * @deprecated use getItemListFilter().matches(item)
+     * @deprecated  use getItemListFilter().matches(item)
      */
     @Deprecated
     public static boolean itemMatches(ItemStack item) {
@@ -156,51 +152,51 @@ public class ItemList {
     public static List<ItemFilter> getItemFilters() {
         LinkedList<ItemFilter> filters = new LinkedList<>();
         synchronized (itemFilterers) {
-            for (ItemFilterProvider p : itemFilterers) filters.add(p.getFilter());
+            for(ItemFilterProvider p : itemFilterers)
+                filters.add(p.getFilter());
         }
         return filters;
     }
 
-    public static final RestartableTask loadItems = new RestartableTask("NEI Item Loading") {
-
+    public static final RestartableTask loadItems = new RestartableTask("NEI Item Loading")
+    {
         private void damageSearch(Item item, List<ItemStack> permutations) {
             HashSet<String> damageIconSet = new HashSet<>();
-            for (int damage = 0; damage < 16; damage++) try {
-                ItemStack itemstack = new ItemStack(item, 1, damage);
-                IIcon icon = item.getIconIndex(itemstack);
-                String name = GuiContainerManager.concatenatedDisplayName(itemstack, false);
-                String s = name + "@" + (icon == null ? 0 : icon.hashCode());
-                if (!damageIconSet.contains(s)) {
-                    damageIconSet.add(s);
-                    permutations.add(itemstack);
+            for (int damage = 0; damage < 16; damage++)
+                try {
+                    ItemStack itemstack = new ItemStack(item, 1, damage);
+                    IIcon icon = item.getIconIndex(itemstack);
+                    String name = GuiContainerManager.concatenatedDisplayName(itemstack, false);
+                    String s = name + "@" + (icon == null ? 0 : icon.hashCode());
+                    if (!damageIconSet.contains(s)) {
+                        damageIconSet.add(s);
+                        permutations.add(itemstack);
+                    }
+                }
+                catch(TimeoutException t) {
+                    throw t;
+                }
+                catch(Throwable t) {
+                    NEIServerUtils.logOnce(t, stackTraces, "Ommiting "+item+":"+damage+" "+item.getClass().getSimpleName(), item.toString());
                 }
-            } catch (TimeoutException t) {
-                throw t;
-            } catch (Throwable t) {
-                NEIServerUtils.logOnce(
-                        t,
-                        stackTraces,
-                        "Ommiting " + item + ":" + damage + " " + item.getClass().getSimpleName(),
-                        item.toString());
-            }
         }
 
         @Override
         @SuppressWarnings("unchecked")
         public void execute() {
             // System.out.println("Executing NEI Item Loading");
-            ThreadOperationTimer timer = getTimer(NEIClientConfig.getItemLoadingTimeout());
-            loadFinished = false;
+            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;
 
-                if (item == null || erroredItems.contains(item)) continue;
+                if (item == null || erroredItems.contains(item))
+                    continue;
 
                 try {
                     timer.reset(item);
@@ -208,9 +204,11 @@ public class ItemList {
                     permutations.clear();
                     permutations.addAll(ItemInfo.itemOverrides.get(item));
 
-                    if (permutations.isEmpty()) item.getSubItems(item, null, permutations);
+                    if (permutations.isEmpty())
+                        item.getSubItems(item, null, permutations);
 
-                    if (permutations.isEmpty()) damageSearch(item, permutations);
+                    if (permutations.isEmpty())
+                        damageSearch(item, permutations);
 
                     permutations.addAll(ItemInfo.itemVariants.get(item));
 
@@ -224,19 +222,19 @@ public class ItemList {
                 }
             }
 
-            if (interrupted()) return;
+            if(interrupted()) return;
             ItemList.items = items;
             ItemList.itemMap = itemMap;
-            for (ItemsLoadedCallback callback : loadCallbacks) callback.itemsLoaded();
+            for(ItemsLoadedCallback callback : loadCallbacks)
+                callback.itemsLoaded();
 
             updateFilter.restart();
-
-            loadFinished = true;
         }
     };
 
     public static ForkJoinPool getPool(int poolSize) {
-        if (poolSize < 1) poolSize = 1;
+        if(poolSize < 1)
+            poolSize = 1;
 
         return new ForkJoinPool(poolSize);
     }
@@ -244,8 +242,8 @@ public class ItemList {
     public static final int numProcessors = Runtime.getRuntime().availableProcessors();
     public static ForkJoinPool forkJoinPool = getPool(numProcessors * 2 / 3);
 
-    public static final RestartableTask updateFilter = new RestartableTask("NEI Item Filtering") {
-
+    public static final RestartableTask updateFilter = new RestartableTask("NEI Item Filtering")
+    {
         @Override
         public void execute() {
             // System.out.println("Executing NEI Item Filtering");
@@ -253,19 +251,18 @@ public class ItemList {
             ItemFilter filter = getItemListFilter();
 
             try {
-                filtered = ItemList.forkJoinPool.submit(
-                        () -> items.parallelStream().filter(PresetsWidget::matches).filter(filter::matches)
-                                .collect(Collectors.toCollection(ArrayList::new)))
-                        .get();
+                filtered = ItemList.forkJoinPool.submit(() -> items.parallelStream()
+                    .filter(filter::matches)
+                    .collect(Collectors.toCollection(ArrayList::new))).get();
             } catch (InterruptedException | ExecutionException e) {
                 filtered = new ArrayList<>();
                 e.printStackTrace();
                 stop();
             }
 
-            if (interrupted()) return;
+            if(interrupted()) return;
             ItemSorter.sort(filtered);
-            if (interrupted()) return;
+            if(interrupted()) return;
             ItemPanel.updateItemList(filtered);
         }
     };

src/main/java/codechicken/nei/ItemMobSpawner.java

@@ -1,9 +1,5 @@
 package codechicken.nei;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityList;
@@ -20,8 +16,12 @@ import net.minecraft.util.IIcon;
 import net.minecraft.world.World;
 import net.minecraftforge.client.MinecraftForgeClient;
 
-public class ItemMobSpawner extends ItemBlock {
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
+public class ItemMobSpawner extends ItemBlock
+{
     private static Map<Integer, EntityLiving> entityHashMap;
     private static Map<Integer, String> IDtoNameMap;
     public static int idPig;
@@ -41,7 +41,6 @@ public class ItemMobSpawner extends ItemBlock {
      * These are ASM translated from BlockMobSpawner
      */
     public static int placedX;
-
     public static int placedY;
     public static int placedZ;
 
@@ -50,11 +49,9 @@ public class ItemMobSpawner extends ItemBlock {
         return Blocks.mob_spawner.getBlockTextureFromSide(0);
     }
 
-    public boolean onItemUse(ItemStack itemstack, EntityPlayer entityplayer, World world, int x, int y, int z, int par7,
-            float par8, float par9, float par10) {
+    public boolean onItemUse(ItemStack itemstack, EntityPlayer entityplayer, World world, int x, int y, int z, int par7, float par8, float par9, float par10) {
         if (super.onItemUse(itemstack, entityplayer, world, x, y, z, par7, par8, par9, par10) && world.isRemote) {
-            TileEntityMobSpawner tileentitymobspawner = (TileEntityMobSpawner) world
-                    .getTileEntity(placedX, placedY, placedZ);
+            TileEntityMobSpawner tileentitymobspawner = (TileEntityMobSpawner) world.getTileEntity(placedX, placedY, placedZ);
             if (tileentitymobspawner != null) {
                 setDefaultTag(itemstack);
                 String mobtype = IDtoNameMap.get(itemstack.getItemDamage());
@@ -86,11 +83,12 @@ public class ItemMobSpawner extends ItemBlock {
             loadSpawners(world);
             Class<?> clazz = (Class<?>) EntityList.IDtoClassMapping.get(ID);
             try {
-                e = (EntityLiving) clazz.getConstructor(new Class[] { World.class }).newInstance(world);
+                e = (EntityLiving) clazz.getConstructor(new Class[]{World.class}).newInstance(world);
             } catch (Throwable t) {
-                if (clazz == null)
-                    NEIClientConfig.logger.error("Null class for entity (" + ID + ", " + IDtoNameMap.get(ID));
-                else NEIClientConfig.logger.error("Error creating instance of entity: " + clazz.getName(), t);
+                if(clazz == null)
+                    NEIClientConfig.logger.error("Null class for entity ("+ID+", "+IDtoNameMap.get(ID));
+                else
+                    NEIClientConfig.logger.error("Error creating instance of entity: " + clazz.getName(), t);
                 e = getEntity(idPig);
             }
             entityHashMap.put(ID, e);
@@ -98,12 +96,9 @@ public class ItemMobSpawner extends ItemBlock {
         return e;
     }
 
-    public static void clearEntityReferences(World newWorld) {
-        entityHashMap.values().removeIf(e -> e.worldObj != newWorld);
-    }
-
     private void setDefaultTag(ItemStack itemstack) {
-        if (!IDtoNameMap.containsKey(itemstack.getItemDamage())) itemstack.setItemDamage(idPig);
+        if (!IDtoNameMap.containsKey(itemstack.getItemDamage()))
+            itemstack.setItemDamage(idPig);
     }
 
     public static void loadSpawners(World world) {
@@ -112,30 +107,35 @@ public class ItemMobSpawner extends ItemBlock {
         HashMap<Class<Entity>, String> classToStringMapping = (HashMap<Class<Entity>, String>) EntityList.classToStringMapping;
         HashMap<Class<Entity>, Integer> classToIDMapping = (HashMap<Class<Entity>, Integer>) EntityList.classToIDMapping;
         for (Class<Entity> eclass : classToStringMapping.keySet()) {
-            if (!EntityLiving.class.isAssignableFrom(eclass)) continue;
+            if (!EntityLiving.class.isAssignableFrom(eclass))
+                continue;
             try {
-                EntityLiving entityliving = (EntityLiving) eclass.getConstructor(new Class[] { World.class })
-                        .newInstance(world);
+                EntityLiving entityliving = (EntityLiving) eclass.getConstructor(new Class[]{World.class}).newInstance(world);
                 entityliving.isChild();
 
                 int id = classToIDMapping.get(eclass);
                 String name = classToStringMapping.get(eclass);
 
-                if (name.equals("EnderDragon")) continue;
+                if (name.equals("EnderDragon"))
+                    continue;
 
                 IDtoNameMap.put(id, name);
 
-                if (name.equals("Pig")) idPig = id;
-            } catch (Throwable ignored) {}
+                if (name.equals("Pig"))
+                    idPig = id;
+            } catch (Throwable ignored) {
+            }
         }
 
-        IDtoNameMap.entrySet()
-                .removeIf(e -> getEntity(e.getKey()).getClass() == EntityPig.class && !e.getValue().equals("Pig"));
+        IDtoNameMap.entrySet().removeIf(e -> getEntity(e.getKey()).getClass() == EntityPig.class && !e.getValue().equals("Pig"));
     }
 
     @Override
     public void getSubItems(Item item, CreativeTabs tab, List list) {
-        if (!NEIClientConfig.hasSMPCounterPart()) list.add(new ItemStack(item));
-        else for (int i : IDtoNameMap.keySet()) list.add(new ItemStack(item, 1, i));
+        if(!NEIClientConfig.hasSMPCounterPart())
+            list.add(new ItemStack(item));
+        else
+            for(int i : IDtoNameMap.keySet())
+                list.add(new ItemStack(item, 1, i));
     }
 }

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

@@ -1,212 +1,489 @@
 package codechicken.nei;
 
-import static codechicken.lib.gui.GuiDraw.drawRect;
+import codechicken.lib.vec.Rectangle4i;
+import codechicken.nei.api.GuiInfo;
+import codechicken.nei.api.INEIGuiHandler;
+import codechicken.nei.guihook.GuiContainerManager;
+import codechicken.nei.recipe.GuiCraftingRecipe;
+import codechicken.nei.recipe.GuiRecipe;
+import codechicken.nei.recipe.GuiUsageRecipe;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
 
 import java.util.ArrayList;
 
-import javax.annotation.Nullable;
-
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.item.ItemStack;
-
-import codechicken.lib.vec.Rectangle4i;
-
-public class ItemPanel extends PanelWidget {
+import static codechicken.lib.gui.GuiDraw.drawRect;
+import static codechicken.nei.NEIClientConfig.canPerformAction;
 
+public class ItemPanel extends Widget {
     /**
-     * Backwards compat :-/
+     *  Backwards compat :-/
      */
-    @SuppressWarnings("unused")
-    @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;
 
-    public ItemStack getStackMouseOver(int mousex, int mousey) {
-        // *looks angrily at AppleCore*
-        return super.getStackMouseOver(mousex, mousey);
-    }
-
-    public Button more;
-    public Button less;
-    public ItemQuantityField quantity;
-
-    public static class ItemPanelSlot {
-
-        public ItemStack item;
-        public int slotIndex;
-
-        public ItemPanelSlot(int idx, ItemStack stack) {
-            slotIndex = idx;
-            item = stack;
-        }
-
-        @Deprecated
-        public ItemPanelSlot(int idx) {
-            this(idx, ItemPanels.itemPanel.getGrid().getItem(idx));
-        }
-    }
-
-    protected static class ItemPanelGrid extends ItemsGrid {
-
-        public ArrayList<ItemStack> newItems;
-
-        public void setItems(ArrayList<ItemStack> items) {
-            newItems = items;
-        }
-
-        public void refresh(GuiContainer gui) {
-
-            if (newItems != null) {
-                realItems = newItems;
-                newItems = null;
-                onGridChanged();
-            }
-
-            super.refresh(gui);
-        }
-
-        @Override
-        protected void drawSlotOutline(@Nullable ItemPanelSlot focused, int slotIdx, Rectangle4i rect) {
-            if (PresetsWidget.inEditMode()) {
-                if (!PresetsWidget.isHidden(getItem(slotIdx))) drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);
-            } else {
-                super.drawSlotOutline(focused, slotIdx, rect);
-            }
-        }
-
-        @Override
-        public String getMessageOnEmpty() {
-            return ItemList.loadFinished ? null : NEIClientUtils.translate("itempanel.loading");
-        }
-    }
-
-    public ItemPanel() {
-        grid = new ItemPanelGrid();
+    public ArrayList<ItemStack> getItems() {
+        return realItems;
     }
 
     public static void updateItemList(ArrayList<ItemStack> newItems) {
-        ((ItemPanelGrid) ItemPanels.itemPanel.getGrid()).setItems(newItems);
-        ItemPanels.itemPanel.realItems = newItems;
+        ItemPanels.itemPanel._items = newItems;
     }
 
-    @Override
+    public class ItemPanelSlot
+    {
+        public ItemStack item;
+        public int slotIndex;
+
+        public ItemPanelSlot(int index) {
+            item = realItems.get(index);
+            slotIndex = index;
+        }
+    }
+
+    public ItemStack draggedStack;
+    public int mouseDownSlot = -1;
+
+    public Button prev;
+    public Button next;
+    public Label pageLabel;
+
+
+    private int marginLeft;
+    private int marginTop;
+    private int rows;
+    private int columns;
+
+    private boolean[] validSlotMap;
+    private int firstIndex;
+    private int itemsPerPage;
+
+    private int page;
+    private int numPages;
+
+
+
     public void init() {
-        super.init();
+        pageLabel = new Label("(0/0)", true);
 
-        more = new Button("+") {
+        prev = new Button("Prev")
+        {
+            public boolean onButtonPress(boolean rightclick) {
+                if (!rightclick) {
+                    scroll(-1);
+                    return true;
+                }
+                return false;
+            }
 
             @Override
-            public boolean onButtonPress(boolean rightclick) {
-                if (rightclick) return false;
-
-                int modifier = NEIClientUtils.controlKey() ? 64 : NEIClientUtils.shiftKey() ? 10 : 1;
-                int quantity = NEIClientConfig.getItemQuantity() + modifier;
-
-                if (quantity < 0) {
-                    quantity = 0;
-                }
-
-                ItemPanels.itemPanel.quantity.setText(Integer.toString(quantity));
-                return true;
+            public String getRenderLabel() {
+                return "<";
             }
         };
-        less = new Button("-") {
+        next = new Button("Next")
+        {
+            public boolean onButtonPress(boolean rightclick) {
+                if (!rightclick) {
+                    scroll(1);
+                    return true;
+                }
+                return false;
+            }
 
             @Override
-            public boolean onButtonPress(boolean rightclick) {
-                if (rightclick) return false;
-
-                int modifier = NEIClientUtils.controlKey() ? -64 : NEIClientUtils.shiftKey() ? -10 : -1;
-                int quantity = NEIClientConfig.getItemQuantity() + modifier;
-
-                if (quantity < 0) {
-                    quantity = 0;
-                }
-
-                ItemPanels.itemPanel.quantity.setText(Integer.toString(quantity));
-                return true;
+            public String getRenderLabel() {
+                return ">";
             }
         };
-
-        quantity = new ItemQuantityField("quantity");
     }
 
-    @Deprecated
-    public void scroll(int i) {
-        grid.shiftPage(i);
+    public int getX(GuiContainer gui) {
+        return (gui.xSize + gui.width) / 2 + 3;
     }
 
-    public String getLabelText() {
-        return String.format("(%d/%d)", getPage(), Math.max(1, getNumPages()));
+    public int getMarginLeft() {
+        return x + (w % 18) / 2;
     }
 
-    protected String getPositioningSettingName() {
-        return "world.panels.items";
+    public int getMarginTop() {
+        return y + (h % 18) / 2;
     }
 
-    public int getMarginLeft(GuiContainer gui) {
-        return (gui.width + gui.xSize) / 2 + PADDING;
+    public int getButtonTop() {
+        return 2;
     }
 
-    public int getMarginTop(GuiContainer gui) {
-        return PADDING;
+    public int getNextX(GuiContainer gui) {
+        return gui.width - prev.w - 2;
     }
 
-    public int getWidth(GuiContainer gui) {
-        return gui.width - (gui.xSize + gui.width) / 2 - PADDING * 2;
+    public int getPrevX(GuiContainer gui) {
+        return (gui.xSize + gui.width) / 2 + 2;
+    }
+
+    public int getPageX(GuiContainer gui) {
+        return gui.guiLeft * 3 / 2 + gui.xSize + 1;
     }
 
     public int getHeight(GuiContainer gui) {
-        return gui.height - getMarginTop(gui) - PADDING;
+        return gui.height - 15 - y;
     }
 
-    protected int resizeFooter(GuiContainer gui) {
-        if (!NEIClientConfig.showItemQuantityWidget()) return 0;
+    public int getWidth(GuiContainer gui) {
+        return LayoutManager.getSideWidth(gui) - x;
+    }
 
-        final int BUTTON_SIZE = 16;
+    public String getLabelText() {
+        return pageLabel.text = "(" + getPage() + "/" + getNumPages() + ")";
+    }
 
-        more.w = less.w = BUTTON_SIZE;
-        more.h = less.h = quantity.h = BUTTON_SIZE;
+    protected void setItems() {
+        realItems = _items;
 
-        less.x = x;
-        more.x = x + w - BUTTON_SIZE;
-        more.y = less.y = quantity.y = y + h - BUTTON_SIZE;
+        // Backwards compat
+        ItemPanels.itemPanel._items = _items;
+    }
 
-        quantity.x = x + BUTTON_SIZE + 2;
-        quantity.w = more.x - quantity.x - 2;
+    public void resize(GuiContainer gui) {
+        setItems();
+        final int buttonHeight = 16;
+        final int buttonWidth = 16;
 
-        return BUTTON_SIZE + 2;
+        prev.x = getPrevX(gui);
+        prev.y = getButtonTop();
+        prev.h = buttonHeight;
+        prev.w = buttonWidth;
+
+        next.x = getNextX(gui);
+        next.y = getButtonTop();
+        next.h = buttonHeight;
+        next.w = buttonWidth;
+
+        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);
+
+        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();
+    }
+
+    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 setVisible() {
-        super.setVisible();
+    public void draw(int mousex, int mousey) {
+        if (itemsPerPage == 0)
+            return;
 
-        if (grid.getPerPage() > 0 && NEIClientConfig.showItemQuantityWidget()) {
-            LayoutManager.addWidget(more);
-            LayoutManager.addWidget(less);
-            LayoutManager.addWidget(quantity);
+        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);
+            GuiContainerManager.drawItems.zLevel -= 100;
         }
     }
 
-    protected ItemStack getDraggedStackWithQuantity(int mouseDownSlot) {
-        ItemStack stack = grid.getItem(mouseDownSlot);
+    @Override
+    public void mouseDragged(int mousex, int mousey, int button, long heldTime) {
+        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 (stack != null) {
-            int amount = NEIClientConfig.showItemQuantityWidget() ? NEIClientConfig.getItemQuantity() : 0;
+                draggedStack = NEIServerUtils.copyStack(stack, amount);
+            }
+        }
+    }
 
-            if (amount == 0) {
-                amount = stack.getMaxStackSize();
+    @Override
+    public boolean handleClick(int mousex, int mousey, int button) {
+        if (handleDraggedClick(mousex, mousey, button))
+            return true;
+
+        if (NEIClientUtils.getHeldItem() != null) {
+            try {
+                GuiInfo.readLock.lock();
+                if (GuiInfo.guiHandlers.stream().anyMatch(handler -> handler.hideItemPanelSlot(NEIClientUtils.getGuiContainer(), mousex, mousey, 1, 1)))
+                    return false;
+            } finally {
+                GuiInfo.readLock.unlock();
             }
 
-            return NEIServerUtils.copyStack(stack, amount);
+            if (NEIClientConfig.canPerformAction("delete") && NEIClientConfig.canPerformAction("item"))
+                if (button == 1)
+                    NEIClientUtils.decreaseSlotStack(-999);
+                else
+                    NEIClientUtils.deleteHeldItem();
+            else
+                NEIClientUtils.dropHeldItem();
+
+            return true;
         }
 
+        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();
+
+                    draggedStack = NEIServerUtils.copyStack(stack, amount);
+                }
+            } else {
+                mouseDownSlot = hoverSlot.slotIndex;
+            }
+            return true;
+        }
+        return false;
+    }
+
+    private boolean handleDraggedClick(int mousex, int mousey, int button) {
+        if (draggedStack == null)
+            return false;
+
+        GuiContainer gui = NEIClientUtils.getGuiContainer();
+        boolean handled = false;
+        try {
+            GuiInfo.readLock.lock();
+            for (INEIGuiHandler handler : GuiInfo.guiHandlers) {
+                if (handler.handleDragNDrop(gui, mousex, mousey, draggedStack, button)) {
+                    handled = true;
+                    if (draggedStack.stackSize == 0) {
+                        draggedStack = null;
+                        return true;
+                    }
+                }
+            }
+        } finally {
+            GuiInfo.readLock.unlock();
+        }
+        
+        if (handled)
+            return true;
+
+        Slot overSlot = gui.getSlotAtPosition(mousex, mousey);
+        if (overSlot != null && overSlot.isItemValid(draggedStack)) {
+            if (NEIClientConfig.canCheatItem(draggedStack)) {
+                int contents = overSlot.getHasStack() ? overSlot.getStack().stackSize : 0;
+                int add = button == 0 ? draggedStack.stackSize : 1;
+                if (overSlot.getHasStack() && !NEIServerUtils.areStacksSameType(draggedStack, overSlot.getStack()))
+                    contents = 0;
+                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)
+                    draggedStack = null;
+            } else {
+                draggedStack = null;
+            }
+        } else if (mousex < gui.guiLeft || mousey < gui.guiTop || mousex >= gui.guiLeft + gui.xSize || mousey >= gui.guiTop + gui.ySize) {
+            draggedStack = null;
+        }
+
+        return true;
+    }
+
+    @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(item, button, -1);
+        }
+
+        mouseDownSlot = -1;
+    }
+
+    @Override
+    public boolean onMouseWheel(int i, int mousex, int mousey) {
+        if (!contains(mousex, mousey))
+            return false;
+
+        scroll(-i);
+        return true;
+    }
+
+    @Override
+    public boolean handleKeyPress(int keyID, char keyChar) {
+        if (keyID == NEIClientConfig.getKeyBinding("gui.next")) {
+            scroll(1);
+            return true;
+        }
+        if (keyID == NEIClientConfig.getKeyBinding("gui.prev")) {
+            scroll(-1);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public ItemStack getStackMouseOver(int mousex, int mousey) {
+        ItemPanelSlot slot = getSlotMouseOver(mousex, mousey);
+        return slot == null ? null : slot.item;
+    }
+
+    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 page;
+    }
+
+    public int getNumPages() {
+        return numPages;
+    }
+
+    @Override
+    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/ItemPanels.java

@@ -1,7 +1,6 @@
 package codechicken.nei;
 
 public class ItemPanels {
-
     public static final ItemPanel itemPanel = new ItemPanel();
     public static final BookmarkPanel bookmarkPanel = new BookmarkPanel();
 }

src/main/java/codechicken/nei/ItemQuantityField.java

@@ -1,13 +1,10 @@
 package codechicken.nei;
 
-import static codechicken.nei.NEIClientUtils.translate;
-
-public class ItemQuantityField extends TextField {
-
+public class ItemQuantityField extends TextField
+{
     public ItemQuantityField(String ident) {
         super(ident);
         centered = true;
-        field.setDisabledTextColour(0xFF303030);
     }
 
     public int intValue() {
@@ -38,18 +35,4 @@ public class ItemQuantityField extends TextField {
     public void onTextChange(String oldText) {
         NEIClientUtils.setItemQuantity(intValue());
     }
-
-    @Override
-    public void draw(int mousex, int mousey) {
-
-        if (!focused() && intValue() == 0) {
-            field.setText(translate("itempanel.quantity.default"));
-            field.setEnabled(false);
-            super.draw(mousex, mousey);
-            field.setEnabled(true);
-            field.setText("0");
-        } else {
-            super.draw(mousex, mousey);
-        }
-    }
 }

src/main/java/codechicken/nei/ItemSorter.java

@@ -1,25 +1,24 @@
 package codechicken.nei;
 
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.StatCollector;
-
 import codechicken.lib.config.ConfigTagParent;
 import codechicken.nei.ItemList.ItemsLoadedCallback;
 import codechicken.nei.api.API;
 import codechicken.nei.api.ItemInfo;
 import codechicken.nei.config.GuiItemSorter;
 import codechicken.nei.config.OptionOpenGui;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.StatCollector;
 
-public class ItemSorter implements Comparator<ItemStack>, ItemsLoadedCallback {
-
-    public static class SortEntry {
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
 
+public class ItemSorter implements Comparator<ItemStack>, ItemsLoadedCallback
+{
+    public static class SortEntry
+    {
         public final String name;
         public final Comparator<ItemStack> comparator;
 
@@ -33,7 +32,7 @@ public class ItemSorter implements Comparator<ItemStack>, ItemsLoadedCallback {
         }
 
         public String getTooltip() {
-            String tipname = name + ".tip";
+            String tipname = name+".tip";
             String tip = StatCollector.translateToLocal(tipname);
             return !tip.equals(tipname) ? tip : null;
         }
@@ -43,13 +42,12 @@ public class ItemSorter implements Comparator<ItemStack>, ItemsLoadedCallback {
     public static ArrayList<SortEntry> list = new ArrayList<>();
     public static final ItemSorter instance = new ItemSorter();
 
-    // optimisations
+    //optimisations
     public HashMap<ItemStack, Integer> ordering = null;
 
     public static void sort(ArrayList<ItemStack> items) {
         try {
-            // items = (ArrayList<ItemStack>)
-            // items.parallelStream().sorted(instance).collect(Collectors.toList());
+//            items = (ArrayList<ItemStack>) items.parallelStream().sorted(instance).collect(Collectors.toList());
             items.sort(instance);
         } catch (Exception e) {
             NEIClientConfig.logger.error("Exception sorting item list", e);
@@ -58,9 +56,9 @@ public class ItemSorter implements Comparator<ItemStack>, ItemsLoadedCallback {
 
     @Override
     public int compare(ItemStack o1, ItemStack o2) {
-        for (SortEntry e : list) {
+        for(SortEntry e : list) {
             int c = e.comparator.compare(o1, o2);
-            if (c != 0) return c;
+            if(c != 0) return c;
         }
         return 0;
     }
@@ -69,12 +67,15 @@ public class ItemSorter implements Comparator<ItemStack>, ItemsLoadedCallback {
     public void itemsLoaded() {
         HashMap<ItemStack, Integer> newMap = new HashMap<>();
         int i = 0;
-        for (ItemStack stack : ItemList.items) newMap.put(stack, i++);
+        for(ItemStack stack : ItemList.items)
+            newMap.put(stack, i++);
         ordering = newMap;
     }
 
     public static SortEntry find(String name) {
-        for (SortEntry e : entries) if (e.name.equals(name)) return e;
+        for(SortEntry e : entries)
+            if(e.name.equals(name))
+                return e;
 
         return null;
     }
@@ -88,11 +89,11 @@ public class ItemSorter implements Comparator<ItemStack>, ItemsLoadedCallback {
         entries.add(e);
         ArrayList<SortEntry> nlist = new ArrayList<>(list);
         nlist.add(e);
-        list = nlist; // concurrency
+        list = nlist;//concurrency
     }
 
     public static void initConfig(ConfigTagParent tag) {
-        // minecraft, mod, id, default, meta, name
+        //minecraft, mod, id, default, meta, name
         API.addSortOption("nei.itemsort.minecraft", (o1, o2) -> {
             boolean m1 = "minecraft".equals(ItemInfo.itemOwners.get(o1.getItem()));
             boolean m2 = "minecraft".equals(ItemInfo.itemOwners.get(o2.getItem()));
@@ -101,8 +102,8 @@ public class ItemSorter implements Comparator<ItemStack>, ItemsLoadedCallback {
         API.addSortOption("nei.itemsort.mod", (o1, o2) -> {
             String mod1 = ItemInfo.itemOwners.get(o1.getItem());
             String mod2 = ItemInfo.itemOwners.get(o2.getItem());
-            if (mod1 == null) return mod2 == null ? 0 : 1;
-            if (mod2 == null) return -1;
+            if(mod1 == null) return mod2 == null ? 0 : 1;
+            if(mod2 == null) return -1;
             return mod1.compareTo(mod2);
         });
         API.addSortOption("nei.itemsort.id", (o1, o2) -> {
@@ -113,8 +114,8 @@ public class ItemSorter implements Comparator<ItemStack>, ItemsLoadedCallback {
         API.addSortOption("nei.itemsort.default", (o1, o2) -> {
             Integer order1 = instance.ordering.get(o1);
             Integer order2 = instance.ordering.get(o2);
-            if (order1 == null) return order2 == null ? 0 : 1;
-            if (order2 == null) return -1;
+            if(order1 == null) return order2 == null ? 0 : 1;
+            if(order2 == null) return -1;
             return compareInt(order1, order2);
         });
         API.addSortOption("nei.itemsort.damage", (o1, o2) -> {
@@ -129,7 +130,6 @@ public class ItemSorter implements Comparator<ItemStack>, ItemsLoadedCallback {
         });
         tag.getTag("inventory.itemsort").setDefaultValue(getSaveString(list));
         API.addOption(new OptionOpenGui("inventory.itemsort", GuiItemSorter.class) {
-
             @Override
             public void useGlobals() {
                 super.useGlobals();
@@ -141,22 +141,27 @@ public class ItemSorter implements Comparator<ItemStack>, ItemsLoadedCallback {
 
     public static String getSaveString(List<SortEntry> list) {
         StringBuilder sb = new StringBuilder();
-        for (SortEntry e : list) {
-            if (sb.length() > 0) sb.append(',');
+        for(SortEntry e : list) {
+            if(sb.length() > 0)
+                sb.append(',');
             sb.append(e.name);
         }
         return sb.toString();
     }
 
     public static ArrayList<SortEntry> fromSaveString(String s) {
-        if (s == null) return new ArrayList<>(entries);
+        if(s == null)
+            return new ArrayList<>(entries);
 
         ArrayList<SortEntry> list = new ArrayList<>();
-        for (String s2 : s.split(",")) {
+        for(String s2 : s.split(",")) {
             SortEntry e = find(s2.trim());
-            if (e != null) list.add(e);
+            if(e != null)
+                list.add(e);
         }
-        for (SortEntry e : entries) if (!list.contains(e)) list.add(e);
+        for(SortEntry e : entries)
+            if(!list.contains(e))
+                list.add(e);
 
         return list;
     }

src/main/java/codechicken/nei/ItemStackMap.java

@@ -1,27 +1,26 @@
 package codechicken.nei;
 
-import static codechicken.lib.inventory.InventoryUtils.actualDamage;
-import static codechicken.lib.inventory.InventoryUtils.newItemStack;
-import static net.minecraftforge.oredict.OreDictionary.WILDCARD_VALUE;
+import com.google.common.base.Objects;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
 
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-
-import com.google.common.base.Objects;
+import static codechicken.lib.inventory.InventoryUtils.actualDamage;
+import static codechicken.lib.inventory.InventoryUtils.newItemStack;
+import static net.minecraftforge.oredict.OreDictionary.WILDCARD_VALUE;
 
 /**
  * A maplike class for ItemStack keys with wildcard damage/NBT. Optimised for lookup
  */
-public class ItemStackMap<T> {
-
-    public static class StackMetaKey {
-
+public class ItemStackMap<T>
+{
+    public static class StackMetaKey
+    {
         public final int damage;
         public final NBTTagCompound tag;
 
@@ -39,14 +38,15 @@ public class ItemStackMap<T> {
         }
 
         public boolean equals(Object o) {
-            if (!(o instanceof StackMetaKey)) return false;
+            if (!(o instanceof StackMetaKey))
+                return false;
             StackMetaKey t = (StackMetaKey) o;
             return damage == t.damage && Objects.equal(tag, t.tag);
         }
     }
 
-    public static class Entry<T> {
-
+    public static class Entry<T>
+    {
         public final ItemStack key;
         public final T value;
 
@@ -56,8 +56,8 @@ public class ItemStackMap<T> {
         }
     }
 
-    public class DetailMap {
-
+    public class DetailMap
+    {
         private boolean hasWildcard;
         private T wildcard;
         private HashMap<Integer, T> damageMap;
@@ -66,7 +66,8 @@ public class ItemStackMap<T> {
         private int size;
 
         public T get(ItemStack key) {
-            if (wildcard != null) return wildcard;
+            if (wildcard != null)
+                return wildcard;
 
             if (damageMap != null) {
                 final T ret = damageMap.get(actualDamage(key));
@@ -76,7 +77,8 @@ public class ItemStackMap<T> {
                 final T ret = tagMap.get(key.stackTagCompound);
                 if (ret != null) return ret;
             }
-            if (metaMap != null) return metaMap.get(new StackMetaKey(key));
+            if (metaMap != null)
+                return metaMap.get(new StackMetaKey(key));
 
             return null;
         }
@@ -127,50 +129,63 @@ public class ItemStackMap<T> {
         }
 
         private void updateSize() {
-            int newSize = (hasWildcard ? 1 : 0) + (metaMap != null ? metaMap.size() : 0)
-                    + (tagMap != null ? tagMap.size() : 0)
-                    + (damageMap != null ? damageMap.size() : 0);
+            int newSize = (hasWildcard ? 1 : 0) +
+                    (metaMap != null ? metaMap.size() : 0) +
+                    (tagMap != null ? tagMap.size() : 0) +
+                    (damageMap != null ? damageMap.size() : 0);
 
-            if (newSize != size) {
-                ItemStackMap.this.size += newSize - size;
+            if(newSize != size) {
+                ItemStackMap.this.size += newSize-size;
                 size = newSize;
             }
         }
 
         public void addKeys(Item item, List<ItemStack> list) {
-            if (wildcard != null) list.add(wildcard(item));
+            if (wildcard != null)
+                list.add(wildcard(item));
             if (damageMap != null)
-                for (int damage : damageMap.keySet()) list.add(newItemStack(item, 1, damage, WILDCARD_TAG));
+                for (int damage : damageMap.keySet())
+                    list.add(newItemStack(item, 1, damage, WILDCARD_TAG));
             if (tagMap != null)
-                for (NBTTagCompound tag : tagMap.keySet()) list.add(newItemStack(item, 1, WILDCARD_VALUE, tag));
+                for (NBTTagCompound tag : tagMap.keySet())
+                    list.add(newItemStack(item, 1, WILDCARD_VALUE, tag));
             if (metaMap != null)
-                for (StackMetaKey key : metaMap.keySet()) list.add(newItemStack(item, 1, key.damage, key.tag));
+                for (StackMetaKey key : metaMap.keySet())
+                    list.add(newItemStack(item, 1, key.damage, key.tag));
         }
 
         public void addValues(List<T> list) {
-            if (wildcard != null) list.add(wildcard);
-            if (damageMap != null) list.addAll(damageMap.values());
-            if (tagMap != null) list.addAll(tagMap.values());
-            if (metaMap != null) list.addAll(metaMap.values());
+            if (wildcard != null)
+                list.add(wildcard);
+            if (damageMap != null)
+                list.addAll(damageMap.values());
+            if (tagMap != null)
+                list.addAll(tagMap.values());
+            if (metaMap != null)
+                list.addAll(metaMap.values());
         }
 
         public void addEntries(Item item, List<Entry<T>> list) {
-            if (wildcard != null) list.add(new Entry<>(newItemStack(item, 1, WILDCARD_VALUE, WILDCARD_TAG), wildcard));
-            if (damageMap != null) for (Map.Entry<Integer, T> entry : damageMap.entrySet())
-                list.add(new Entry<>(newItemStack(item, 1, entry.getKey(), WILDCARD_TAG), entry.getValue()));
-            if (tagMap != null) for (Map.Entry<NBTTagCompound, T> entry : tagMap.entrySet())
-                list.add(new Entry<>(newItemStack(item, 1, WILDCARD_VALUE, entry.getKey()), entry.getValue()));
-            if (metaMap != null) for (Map.Entry<StackMetaKey, T> entry : metaMap.entrySet()) list.add(
-                    new Entry<>(newItemStack(item, 1, entry.getKey().damage, entry.getKey().tag), entry.getValue()));
+            if (wildcard != null)
+                list.add(new Entry<>(newItemStack(item, 1, WILDCARD_VALUE, WILDCARD_TAG), wildcard));
+            if (damageMap != null)
+                for (Map.Entry<Integer, T> entry : damageMap.entrySet())
+                    list.add(new Entry<>(newItemStack(item, 1, entry.getKey(), WILDCARD_TAG), entry.getValue()));
+            if (tagMap != null)
+                for (Map.Entry<NBTTagCompound, T> entry : tagMap.entrySet())
+                    list.add(new Entry<>(newItemStack(item, 1, WILDCARD_VALUE, entry.getKey()), entry.getValue()));
+            if (metaMap != null)
+                for (Map.Entry<StackMetaKey, T> entry : metaMap.entrySet())
+                    list.add(new Entry<>(newItemStack(item, 1, entry.getKey().damage, entry.getKey().tag), entry.getValue()));
         }
     }
 
     public static int getKeyType(int damage, NBTTagCompound tag) {
-        int i = 0;
-        if (isWildcard(damage)) i = 1;
-        if (isWildcard(tag)) i |= 2;
-        return i;
-    }
+             int i = 0;
+             if (isWildcard(damage)) i = 1;
+             if (isWildcard(tag)) i |= 2;
+             return i;
+         }
 
     public static ItemStack wildcard(Item item) {
         return newItemStack(item, 1, WILDCARD_VALUE, WILDCARD_TAG);
@@ -204,10 +219,12 @@ public class ItemStackMap<T> {
     }
 
     public void put(ItemStack key, T value) {
-        if (key == null || key.getItem() == null) return;
+        if (key == null || key.getItem() == null)
+            return;
 
         DetailMap map = itemMap.get(key.getItem());
-        if (map == null) itemMap.put(key.getItem(), map = new DetailMap());
+        if (map == null)
+            itemMap.put(key.getItem(), map = new DetailMap());
         map.put(key, value);
     }
 
@@ -216,7 +233,8 @@ public class ItemStackMap<T> {
     }
 
     public T remove(ItemStack key) {
-        if (key == null || key.getItem() == null) return null;
+        if (key == null || key.getItem() == null)
+            return null;
 
         DetailMap map = itemMap.get(key.getItem());
         return map == null ? null : map.remove(key);
@@ -224,19 +242,22 @@ public class ItemStackMap<T> {
 
     public List<ItemStack> keys() {
         LinkedList<ItemStack> list = new LinkedList<>();
-        for (Map.Entry<Item, DetailMap> entry : itemMap.entrySet()) entry.getValue().addKeys(entry.getKey(), list);
+        for (Map.Entry<Item, DetailMap> entry : itemMap.entrySet())
+            entry.getValue().addKeys(entry.getKey(), list);
         return list;
     }
 
     public List<T> values() {
         LinkedList<T> list = new LinkedList<>();
-        for (DetailMap map : itemMap.values()) map.addValues(list);
+        for (DetailMap map : itemMap.values())
+            map.addValues(list);
         return list;
     }
 
     public List<Entry<T>> entries() {
         LinkedList<Entry<T>> list = new LinkedList<>();
-        for (Map.Entry<Item, DetailMap> entry : itemMap.entrySet()) entry.getValue().addEntries(entry.getKey(), list);
+        for (Map.Entry<Item, DetailMap> entry : itemMap.entrySet())
+            entry.getValue().addEntries(entry.getKey(), list);
         return list;
     }
 

src/main/java/codechicken/nei/ItemStackSet.java

@@ -1,25 +1,27 @@
 package codechicken.nei;
 
+import codechicken.nei.api.ItemFilter;
 import net.minecraft.block.Block;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 
-import codechicken.nei.api.ItemFilter;
-
-public class ItemStackSet extends ItemStackMap<ItemStack> implements ItemFilter {
-
+public class ItemStackSet extends ItemStackMap<ItemStack> implements ItemFilter
+{
     public ItemStackSet with(ItemStack... items) {
-        for (ItemStack item : items) add(item);
+        for(ItemStack item : items)
+            add(item);
         return this;
     }
 
     public ItemStackSet with(Item... items) {
-        for (Item item : items) add(ItemStackMap.wildcard(item));
+        for(Item item : items)
+            add(ItemStackMap.wildcard(item));
         return this;
     }
 
     public ItemStackSet with(Block... blocks) {
-        for (Block block : blocks) add(ItemStackMap.wildcard(Item.getItemFromBlock(block)));
+        for(Block block : blocks)
+            add(ItemStackMap.wildcard(Item.getItemFromBlock(block)));
         return this;
     }
 

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

@@ -1,382 +0,0 @@
-package codechicken.nei;
-
-import static codechicken.lib.gui.GuiDraw.drawRect;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import javax.annotation.Nullable;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.ScaledResolution;
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.client.renderer.OpenGlHelper;
-import net.minecraft.client.renderer.Tessellator;
-import net.minecraft.client.shader.Framebuffer;
-import net.minecraft.item.ItemStack;
-
-import org.lwjgl.opengl.GL11;
-
-import codechicken.lib.vec.Rectangle4i;
-import codechicken.nei.ItemPanel.ItemPanelSlot;
-import codechicken.nei.api.GuiInfo;
-import codechicken.nei.guihook.GuiContainerManager;
-import codechicken.nei.recipe.StackInfo;
-
-public class ItemsGrid {
-
-    public static final int SLOT_SIZE = 18;
-
-    protected int width;
-    protected int height;
-
-    protected int marginLeft;
-    protected int marginTop;
-
-    protected int paddingLeft;
-
-    protected ArrayList<ItemStack> realItems = new ArrayList<>();
-
-    protected int page;
-    protected int perPage;
-
-    protected int rows;
-    protected int columns;
-
-    protected boolean[] invalidSlotMap;
-
-    protected Label messageLabel = new Label(getMessageOnEmpty(), true);
-
-    @Nullable
-    private Framebuffer framebuffer = null;
-
-    protected boolean refreshBuffer = true;
-
-    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, getItem(idx), useNBT)) {
-                return idx;
-            }
-        }
-
-        return -1;
-    }
-
-    public void setPage(int page) {
-        this.page = Math.max(0, Math.min(page, getNumPages() - 1));
-        onGridChanged();
-    }
-
-    public int getPage() {
-        return page + 1;
-    }
-
-    public int getPerPage() {
-        return perPage;
-    }
-
-    public int getNumPages() {
-        if (perPage > 0) {
-            return (int) Math.ceil((float) realItems.size() / (float) perPage);
-        }
-
-        return 0;
-    }
-
-    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;
-
-        paddingLeft = (width % SLOT_SIZE) / 2;
-
-        messageLabel.x = marginLeft + width / 2;
-        messageLabel.y = marginTop + height / 2;
-    }
-
-    public void shiftPage(int shift) {
-        if (perPage == 0) {
-            page = 0;
-            return;
-        }
-
-        final int numPages = getNumPages();
-        final int oldPage = page;
-        page += shift;
-
-        if (page >= numPages) {
-            page = page - numPages;
-        }
-
-        if (page < 0) {
-            page = numPages + page;
-        }
-
-        page = Math.max(0, Math.min(page, numPages - 1));
-
-        if (page != oldPage) {
-            onGridChanged();
-        }
-    }
-
-    protected void onGridChanged() {
-        refreshBuffer = true;
-    }
-
-    public void refresh(GuiContainer gui) {
-        updateGuiOverlapSlots(gui);
-        shiftPage(0);
-    }
-
-    protected void updateGuiOverlapSlots(GuiContainer gui) {
-        final boolean[] oldSlotMap = invalidSlotMap;
-        final int oldRows = rows;
-        final int oldColumns = columns;
-
-        invalidSlotMap = new boolean[rows * columns];
-        perPage = columns * rows;
-
-        if (NEIClientConfig.optimizeGuiOverlapComputation()) {
-            checkGuiOverlap(gui, 0, columns - 2, 1);
-            checkGuiOverlap(gui, columns - 1, 1, -1);
-        } else {
-            checkGuiOverlap(gui, 0, columns, 1);
-        }
-
-        if (oldRows != rows || oldColumns != columns || !Arrays.equals(oldSlotMap, invalidSlotMap)) {
-            onGridChanged();
-        }
-    }
-
-    private void checkGuiOverlap(GuiContainer gui, int start, int end, int dir) {
-        boolean validColumn = false;
-
-        for (int c = start; c != end && (!NEIClientConfig.optimizeGuiOverlapComputation() || !validColumn); c += dir) {
-            validColumn = true;
-
-            for (int r = 0; r < rows; r++) {
-                final int idx = columns * r + c;
-                if (GuiInfo.hideItemPanelSlot(gui, getSlotRect(r, c)) && idx >= 0
-                        && idx < invalidSlotMap.length
-                        && !invalidSlotMap[idx]) {
-                    invalidSlotMap[idx] = true;
-                    validColumn = false;
-                    perPage--;
-                }
-            }
-        }
-    }
-
-    public Rectangle4i getItemRect(int idx) {
-        final List<Integer> mask = getMask();
-
-        for (int i = 0; i < mask.size(); i++) {
-            if (mask.get(i) != null && idx == mask.get(i)) {
-                return getSlotRect(i);
-            }
-        }
-
-        return null;
-    }
-
-    public Rectangle4i getSlotRect(int i) {
-        return getSlotRect(i / columns, i % columns);
-    }
-
-    public Rectangle4i getSlotRect(int row, int column) {
-        return new Rectangle4i(
-                marginLeft + paddingLeft + column * SLOT_SIZE,
-                marginTop + row * SLOT_SIZE,
-                SLOT_SIZE,
-                SLOT_SIZE);
-    }
-
-    public boolean isInvalidSlot(int index) {
-        return invalidSlotMap[index];
-    }
-
-    protected List<Integer> getMask() {
-        List<Integer> mask = new ArrayList<>();
-
-        int idx = page * perPage;
-        for (int i = 0; i < rows * columns && idx < size(); i++) {
-            mask.add(isInvalidSlot(i) ? null : idx++);
-        }
-
-        return mask;
-    }
-
-    private void drawSlotOutlines(int mousex, int mousey) {
-        ItemPanelSlot focused = getSlotMouseOver(mousex, mousey);
-        final List<Integer> mask = getMask();
-
-        for (int i = 0; i < mask.size(); i++) {
-            if (mask.get(i) != null) {
-                drawSlotOutline(focused, mask.get(i), getSlotRect(i));
-            }
-        }
-    }
-
-    protected void drawSlotOutline(@Nullable ItemPanelSlot focused, int slotIdx, Rectangle4i rect) {
-        if (focused != null && focused.slotIndex == slotIdx) {
-            drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555); // highlight
-        }
-    }
-
-    private void blitExistingBuffer() {
-        Minecraft minecraft = Minecraft.getMinecraft();
-        GL11.glEnable(GL11.GL_BLEND);
-        OpenGlHelper.glBlendFunc(GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
-        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-        getFrameBuffer().bindFramebufferTexture();
-        GL11.glEnable(GL11.GL_TEXTURE_2D);
-        ScaledResolution res = new ScaledResolution(minecraft, minecraft.displayWidth, minecraft.displayHeight);
-        Tessellator tessellator = Tessellator.instance;
-        tessellator.startDrawingQuads();
-        tessellator.addVertexWithUV(0, res.getScaledHeight_double(), 0.0, 0, 0);
-        tessellator.addVertexWithUV(res.getScaledWidth_double(), res.getScaledHeight_double(), 0.0, 1, 0);
-        tessellator.addVertexWithUV(res.getScaledWidth_double(), 0, 0.0, 1, 1);
-        tessellator.addVertexWithUV(0, 0, 0, 0, 1);
-        tessellator.draw();
-        OpenGlHelper.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
-    }
-
-    private Framebuffer getFrameBuffer() {
-
-        if (framebuffer == null) {
-            framebuffer = new Framebuffer(1, 1, true);
-            framebuffer.setFramebufferColor(0.0F, 0.0F, 0.0F, 0.0F);
-        }
-
-        return framebuffer;
-    }
-
-    private void drawItems() {
-        GuiContainerManager.enableMatrixStackLogging();
-
-        final List<Integer> mask = getMask();
-        for (int i = 0; i < mask.size(); i++) {
-            if (mask.get(i) != null) {
-                drawItem(getSlotRect(i), mask.get(i));
-            }
-        }
-
-        GuiContainerManager.disableMatrixStackLogging();
-    }
-
-    public void draw(int mousex, int mousey) {
-        if (getPerPage() == 0) {
-            return;
-        }
-
-        if (NEIClientConfig.shouldCacheItemRendering()) {
-
-            if (refreshBuffer) {
-                Minecraft minecraft = Minecraft.getMinecraft();
-                Framebuffer framebuffer = getFrameBuffer();
-                framebuffer.createBindFramebuffer(minecraft.displayWidth, minecraft.displayHeight);
-                framebuffer.framebufferClear();
-                framebuffer.bindFramebuffer(false);
-
-                /* Set up some rendering state needed for items to work correctly */
-                GL11.glDisable(GL11.GL_BLEND);
-                GL11.glDepthMask(true);
-                OpenGlHelper.glBlendFunc(
-                        GL11.GL_SRC_ALPHA,
-                        GL11.GL_ONE_MINUS_SRC_ALPHA,
-                        GL11.GL_SRC_ALPHA,
-                        GL11.GL_ONE_MINUS_SRC_ALPHA);
-                GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-
-                drawItems();
-
-                Minecraft.getMinecraft().getFramebuffer().bindFramebuffer(false);
-                refreshBuffer = false;
-            }
-
-            drawSlotOutlines(mousex, mousey);
-            blitExistingBuffer();
-        } else {
-            drawSlotOutlines(mousex, mousey);
-            drawItems();
-        }
-    }
-
-    public void setVisible() {
-        if (getItems().isEmpty() && getMessageOnEmpty() != null) {
-            LayoutManager.addWidget(messageLabel);
-        }
-    }
-
-    protected void drawItem(Rectangle4i rect, int idx) {
-        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 - paddingLeft) / SLOT_SIZE);
-        final int slt = columns * overRow + overColumn;
-
-        if (overRow >= rows || overColumn >= columns) {
-            return null;
-        }
-
-        final List<Integer> mask = getMask();
-
-        if (mask.size() > slt && mask.get(slt) != null) {
-            final int idx = mask.get(slt);
-
-            return new ItemPanelSlot(idx, getItem(idx));
-        }
-
-        return null;
-    }
-
-    public boolean contains(int px, int py) {
-
-        if (!(new Rectangle4i(marginLeft + paddingLeft, marginTop, columns * SLOT_SIZE, height)).contains(px, py)) {
-            return false;
-        }
-
-        final int r = (int) ((py - marginTop) / SLOT_SIZE);
-        final int c = (int) ((px - marginLeft - paddingLeft) / SLOT_SIZE);
-        final int slt = columns * r + c;
-
-        return r >= rows || c >= columns || !isInvalidSlot(slt);
-    }
-
-    public String getMessageOnEmpty() {
-        return null;
-    }
-}

src/main/java/codechicken/nei/KeyManager.java

@@ -1,5 +1,7 @@
 package codechicken.nei;
 
+import org.lwjgl.input.Keyboard;
+
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.Map.Entry;
@@ -7,39 +9,44 @@ import java.util.Map.Entry;
 /**
  * Good old down/held/up keystate tracker
  */
-public class KeyManager {
-
-    public static interface IKeyStateTracker {
-
+public class KeyManager
+{
+    public static interface IKeyStateTracker
+    {
         public void tickKeyStates();
     }
-
-    public static class KeyState {
-
+    
+    public static class KeyState
+    {
         public boolean down;
         public boolean held;
         public boolean up;
     }
-
+    
     public static HashMap<String, KeyState> keyStates = new HashMap<>();
     public static LinkedList<IKeyStateTracker> trackers = new LinkedList<>();
-
-    public static void tickKeyStates() {
-        for (Entry<String, KeyState> entry : keyStates.entrySet()) {
-            final boolean down = NEIClientConfig.isKeyHashDown(entry.getKey());
-            final KeyState state = entry.getValue();
-
-            if (down) {
+    
+    public static void tickKeyStates()
+    {
+        for(Entry<String, KeyState> entry : keyStates.entrySet())
+        {
+            int keyCode = NEIClientConfig.getKeyBinding(entry.getKey());
+            boolean down = keyCode != 0 && Keyboard.isKeyDown(keyCode);
+            KeyState state = entry.getValue();
+            if(down)
+            {
                 state.down = !state.held;
                 state.up = false;
-            } else {
+            }
+            else
+            {
                 state.up = state.held;
                 state.down = false;
             }
-
             state.held = down;
         }
-
-        for (IKeyStateTracker tracker : trackers) tracker.tickKeyStates();
+        
+        for(IKeyStateTracker tracker : trackers)
+            tracker.tickKeyStates();
     }
 }

src/main/java/codechicken/nei/Label.java

@@ -3,25 +3,30 @@ package codechicken.nei;
 import static codechicken.lib.gui.GuiDraw.drawString;
 import static codechicken.lib.gui.GuiDraw.drawStringC;
 
-public class Label extends Widget {
-
+public class Label extends Widget
+{
     final boolean centered;
     final int colour;
     public String text;
-
-    public Label(String s, boolean center, int color) {
+    
+    public Label(String s, boolean center, int color)
+    {
         text = s;
         centered = center;
         colour = color;
     }
-
-    public Label(String s, boolean center) {
+    
+    public Label(String s, boolean center)
+    {
         this(s, center, 0xFFFFFFFF);
     }
-
+    
     @Override
-    public void draw(int mousex, int mousey) {
-        if (centered) drawStringC(text, x, y, colour);
-        else drawString(text, x, y, colour);
+    public void draw(int mousex, int mousey)
+    {
+        if(centered)
+            drawStringC(text, x, y, colour);
+        else
+            drawString(text, x, y, colour);
     }
 }

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

@@ -1,10 +1,45 @@
 package codechicken.nei;
 
+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;
+import codechicken.nei.drawable.DrawableBuilder;
+import codechicken.nei.drawable.DrawableResource;
+import codechicken.nei.guihook.GuiContainerManager;
+import codechicken.nei.guihook.IContainerDrawHandler;
+import codechicken.nei.guihook.IContainerInputHandler;
+import codechicken.nei.guihook.IContainerObjectHandler;
+import codechicken.nei.guihook.IContainerTooltipHandler;
+import codechicken.nei.recipe.GuiRecipeTab;
+import cpw.mods.fml.common.Loader;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.client.gui.inventory.GuiContainerCreative;
+import net.minecraft.client.renderer.InventoryEffectRenderer;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.opengl.GL11;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.TreeSet;
+
 import static codechicken.lib.gui.GuiDraw.changeTexture;
 import static codechicken.lib.gui.GuiDraw.drawRect;
 import static codechicken.lib.gui.GuiDraw.drawTexturedModalRect;
 import static codechicken.nei.NEIClientConfig.canPerformAction;
 import static codechicken.nei.NEIClientConfig.disabledActions;
+import static codechicken.nei.NEIClientConfig.getItemQuantity;
+import static codechicken.nei.NEIClientConfig.getKeyBinding;
 import static codechicken.nei.NEIClientConfig.getOptionList;
 import static codechicken.nei.NEIClientConfig.getSearchExpression;
 import static codechicken.nei.NEIClientConfig.hasSMPCounterPart;
@@ -15,6 +50,7 @@ import static codechicken.nei.NEIClientConfig.isHidden;
 import static codechicken.nei.NEIClientConfig.showIDs;
 import static codechicken.nei.NEIClientConfig.toggleBooleanSetting;
 import static codechicken.nei.NEIClientConfig.world;
+import static codechicken.nei.NEIClientUtils.controlKey;
 import static codechicken.nei.NEIClientUtils.cycleGamemode;
 import static codechicken.nei.NEIClientUtils.decreaseSlotStack;
 import static codechicken.nei.NEIClientUtils.deleteEverything;
@@ -27,48 +63,14 @@ 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;
 import static codechicken.nei.NEIClientUtils.translate;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.TreeSet;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.client.gui.inventory.GuiContainerCreative;
-import net.minecraft.client.renderer.InventoryEffectRenderer;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.EnumChatFormatting;
-
-import org.lwjgl.input.Keyboard;
-import org.lwjgl.opengl.GL11;
-
-import codechicken.lib.gui.GuiDraw;
-import codechicken.nei.KeyManager.IKeyStateTracker;
-import codechicken.nei.api.API;
-import codechicken.nei.api.GuiInfo;
-import codechicken.nei.api.IRecipeOverlayRenderer;
-import codechicken.nei.api.ItemInfo;
-import codechicken.nei.api.LayoutStyle;
-import codechicken.nei.drawable.DrawableBuilder;
-import codechicken.nei.drawable.DrawableResource;
-import codechicken.nei.guihook.GuiContainerManager;
-import codechicken.nei.guihook.IContainerDrawHandler;
-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;
-
-public class LayoutManager implements IContainerInputHandler, IContainerTooltipHandler, IContainerDrawHandler,
-        IContainerObjectHandler, IKeyStateTracker {
-
+public class LayoutManager implements IContainerInputHandler, IContainerTooltipHandler, IContainerDrawHandler, IContainerObjectHandler, IKeyStateTracker
+{
     private static LayoutManager instance;
 
     /** Note: this variable isn't actually used by this mod, but NEI add-ons might need it. */
@@ -77,28 +79,22 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
     /**
      * Sorted bottom first
      */
-    private static TreeSet<Widget> drawWidgets = new TreeSet<>(new WidgetZOrder(false));
+    private static TreeSet<Widget> drawWidgets;
     /**
      * Sorted top first
      */
-    private static TreeSet<Widget> controlWidgets = new TreeSet<>(new WidgetZOrder(true));
+    private static TreeSet<Widget> controlWidgets;
 
     public static ItemPanel itemPanel;
     public static BookmarkPanel bookmarkPanel;
     public static SubsetWidget dropDown;
-    public static PresetsWidget presetsPanel;
-    public static SearchField searchField;
+    public static TextField searchField;
 
     public static ButtonCycled options;
     public static ButtonCycled bookmarksButton;
 
-    @Deprecated
     public static Button more;
-
-    @Deprecated
     public static Button less;
-
-    @Deprecated
     public static ItemQuantityField quantity;
 
     public static Button delete;
@@ -112,11 +108,6 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
 
     public static HashMap<Integer, LayoutStyle> layoutStyles = new HashMap<>();
 
-    /**
-     * This is set to true immediately after item loading thread is started, to prevent duplicated loading thread from
-     * being executed. If you want to know if item list is actually finished loading, Use {@link ItemList#loadFinished}
-     * instead.
-     */
     public static boolean itemsLoaded = false;
 
     /**
@@ -138,9 +129,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
 
     @Override
     public void onPreDraw(GuiContainer gui) {
-        if (!isHidden() && isEnabled() && gui instanceof InventoryEffectRenderer) // Reset the gui to the center of the
-                                                                                  // screen, for potion effect offsets
-        // etc
+        if (!isHidden() && isEnabled() && gui instanceof InventoryEffectRenderer)//Reset the gui to the center of the screen, for potion effect offsets etc
         {
             gui.guiLeft = (gui.width - gui.xSize) / 2;
             gui.guiTop = (gui.height - gui.ySize) / 2;
@@ -154,33 +143,33 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         }
     }
 
-    @Deprecated
     public static int getSideWidth(GuiContainer gui) {
         return gui.width - 3;
     }
-
-    @Deprecated
     public static int getLeftSize(GuiContainer gui) {
         return getSideWidth(gui);
     }
 
     @Override
     public void onMouseClicked(GuiContainer gui, int mousex, int mousey, int button) {
-        if (isHidden()) return;
+        if (isHidden())
+            return;
 
-        for (Widget widget : controlWidgets) widget.onGuiClick(mousex, mousey);
+        for (Widget widget : controlWidgets)
+            widget.onGuiClick(mousex, mousey);
     }
 
     @Override
     public boolean mouseClicked(GuiContainer gui, int mousex, int mousey, int button) {
-        if (isHidden()) return false;
+        if (isHidden())
+            return false;
 
-        if (!isEnabled()) return options.contains(mousex, mousey) && options.handleClick(mousex, mousey, button);
+        if (!isEnabled())
+            return options.contains(mousex, mousey) && options.handleClick(mousex, mousey, button);
 
         for (Widget widget : controlWidgets) {
             widget.onGuiClick(mousex, mousey);
-            if (widget.contains(mousex, mousey) ? widget.handleClick(mousex, mousey, button)
-                    : widget.handleClickExt(mousex, mousey, button))
+            if (widget.contains(mousex, mousey) ? widget.handleClick(mousex, mousey, button) : widget.handleClickExt(mousex, mousey, button))
                 return true;
         }
 
@@ -190,68 +179,71 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
     @Override
     public boolean objectUnderMouse(GuiContainer gui, int mousex, int mousey) {
         if (!isHidden() && isEnabled())
-            for (Widget widget : drawWidgets) if (widget.contains(mousex, mousey)) return true;
+            for (Widget widget : controlWidgets)
+                if (widget.contains(mousex, mousey))
+                    return true;
 
         return false;
     }
 
     public boolean keyTyped(GuiContainer gui, char keyChar, int keyID) {
         if (isEnabled() && !isHidden()) {
-            if (inputFocused != null) return inputFocused.handleKeyPress(keyID, keyChar);
+            if (inputFocused != null)
+                return inputFocused.handleKeyPress(keyID, keyChar);
 
-            for (Widget widget : controlWidgets) if (widget.handleKeyPress(keyID, keyChar)) return true;
+            for (Widget widget : controlWidgets)
+                if (widget.handleKeyPress(keyID, keyChar))
+                    return true;
         }
 
         return false;
     }
 
     @Override
-    public void onKeyTyped(GuiContainer gui, char keyChar, int keyID) {}
+    public void onKeyTyped(GuiContainer gui, char keyChar, int keyID) {
+    }
 
     @Override
     public boolean lastKeyTyped(GuiContainer gui, char keyChar, int keyID) {
-
-        if (NEIClientConfig.isKeyHashDown("gui.hide")) {
+        if (keyID == getKeyBinding("gui.hide")) {
             toggleBooleanSetting("inventory.hidden");
             return true;
         }
-
-        if (NEIClientConfig.isKeyHashDown("gui.hide_bookmarks")) {
+        if (keyID == getKeyBinding("gui.hide_bookmarks")) {
             toggleBooleanSetting("inventory.bookmarksEnabled");
             return true;
         }
 
-        if (NEIClientConfig.isKeyHashDown("gui.next_tooltip")) {
-            GuiContainerManager.incrementTooltipPage();
-            return true;
-        }
-
         if (isEnabled() && !isHidden()) {
-            for (Widget widget : controlWidgets) if (inputFocused == null) widget.lastKeyTyped(keyID, keyChar);
+            for (Widget widget : controlWidgets)
+                if (inputFocused == null)
+                    widget.lastKeyTyped(keyID, keyChar);
         }
-
         return false;
     }
 
     public void onMouseUp(GuiContainer gui, int mx, int my, int button) {
         if (!isHidden() && isEnabled()) {
-            for (Widget widget : controlWidgets) widget.mouseUp(mx, my, button);
+            for (Widget widget : controlWidgets)
+                widget.mouseUp(mx, my, button);
         }
     }
 
     @Override
     public void onMouseDragged(GuiContainer gui, int mx, int my, int button, long heldTime) {
         if (!isHidden() && isEnabled()) {
-            for (Widget widget : controlWidgets) widget.mouseDragged(mx, my, button, heldTime);
+            for (Widget widget : controlWidgets)
+                widget.mouseDragged(mx, my, button, heldTime);
         }
     }
 
     @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;
+                if (stack != null)
+                    return stack;
             }
         }
         return null;
@@ -262,7 +254,8 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
             layout(gui);
             if (isEnabled()) {
                 getLayoutStyle().drawBackground(GuiContainerManager.getManager(gui));
-                for (Widget widget : drawWidgets) widget.draw(mousex, mousey);
+                for (Widget widget : drawWidgets)
+                    widget.draw(mousex, mousey);
             } else {
                 options.draw(mousex, mousey);
                 bookmarksButton.draw(mousex, mousey);
@@ -272,18 +265,20 @@ 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()) {
-            for (Widget widget : drawWidgets) widget.postDraw(mousex, mousey);
+            for (Widget widget : drawWidgets)
+                widget.postDraw(mousex, mousey);
         }
     }
 
     @Override
     public List<String> handleTooltip(GuiContainer gui, int mousex, int mousey, List<String> currenttip) {
         if (!isHidden() && isEnabled() && GuiContainerManager.shouldShowTooltip(gui)) {
-            for (Widget widget : drawWidgets) currenttip = widget.handleTooltip(mousex, mousey, currenttip);
+            for (Widget widget : controlWidgets)
+                currenttip = widget.handleTooltip(mousex, mousey, currenttip);
         }
         return currenttip;
     }
@@ -291,12 +286,14 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
     @Override
     public List<String> handleItemDisplayName(GuiContainer gui, ItemStack stack, List<String> currenttip) {
         String overridename = ItemInfo.getNameOverride(stack);
-        if (overridename != null) currenttip.set(0, overridename);
+        if (overridename != null)
+            currenttip.set(0, overridename);
 
         String mainname = currenttip.get(0);
         if (showIDs()) {
             mainname += " " + Item.getIdFromItem(stack.getItem());
-            if (stack.getItemDamage() != 0) mainname += ":" + stack.getItemDamage();
+            if (stack.getItemDamage() != 0)
+                mainname += ":" + stack.getItemDamage();
 
             currenttip.set(0, mainname);
         }
@@ -305,33 +302,30 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
     }
 
     @Override
-    public List<String> handleItemTooltip(GuiContainer gui, ItemStack itemstack, int mousex, int mousey,
-            List<String> currenttip) {
+    public List<String> handleItemTooltip(GuiContainer gui, ItemStack itemstack, int mousex, int mousey, List<String> currenttip) {
         return currenttip;
     }
 
     public static void layout(GuiContainer gui) {
         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;
-
+        if (isHidden())
+            visiblity.showNEI = false;
+        
+        if (isBookmarkPanelHidden())
+            visiblity.showBookmarkPanel = false;
+        
+        if (gui.height - gui.ySize <= 40)
+            visiblity.showSearchSection = false;
+        
+        if (gui.guiLeft - 4 < 76)
+            visiblity.showWidgets = false;
         try {
             GuiInfo.readLock.lock();
             GuiInfo.guiHandlers.forEach(handler -> handler.modifyVisiblity(gui, visiblity));
         } finally {
             GuiInfo.readLock.unlock();
         }
-
+        
         visiblity.translateDependancies();
 
         getLayoutStyle().layout(gui, visiblity);
@@ -347,36 +341,25 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         bookmarkPanel.init();
 
         dropDown = new SubsetWidget();
-        presetsPanel = new PresetsWidget();
         searchField = new SearchField("search");
 
-        options = new ButtonCycled(3) {
-
+        options = new ButtonCycled(3)
+        {
             @Override
             public void init() {
                 this.icons[0] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 32, 0, 16, 16).build();
                 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();
             }
-
-            private boolean getIsAccessibleControlEventKey() {
-                if (Minecraft.isRunningOnMac) {
-                    return Keyboard.getEventKey() == Keyboard.KEY_LMETA || Keyboard.getEventKey() == Keyboard.KEY_RMETA;
-                }
-                return Keyboard.getEventKey() == Keyboard.KEY_LCONTROL
-                        || Keyboard.getEventKey() == Keyboard.KEY_RCONTROL;
-            }
-
+            
             @Override
             public boolean onButtonPress(boolean rightclick) {
                 if (!rightclick) {
-                    if (Keyboard.getEventKeyState() && getIsAccessibleControlEventKey()) {
+                    if (Keyboard.getEventKeyState() && (Keyboard.getEventKey() == Keyboard.KEY_LCONTROL || Keyboard.getEventKey() == Keyboard.KEY_RCONTROL)) {
                         NEIClientConfig.cycleSetting("inventory.cheatmode", 3);
                     } else {
-                        if (Keyboard.getEventKeyState() && (Keyboard.getEventKey() == Keyboard.KEY_LSHIFT
-                                || Keyboard.getEventKey() == Keyboard.KEY_RSHIFT)) {
+                        if (Keyboard.getEventKeyState() && (Keyboard.getEventKey() == Keyboard.KEY_LSHIFT || Keyboard.getEventKey() == Keyboard.KEY_RSHIFT)) {
                             GuiRecipeTab.loadHandlerInfo();
-                            RecipeCatalysts.loadCatalystInfo();
                         }
                         getOptionList().openGui(getGuiContainer(), false);
                     }
@@ -384,33 +367,36 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
                 }
                 return false;
             }
-
+            
             @Override
             public void addTooltips(List<String> tooltip) {
                 tooltip.add(translate("inventory.options.tip"));
                 String modeColor = "";
                 final int cheatMode = NEIClientConfig.getCheatMode();
-                if (cheatMode == 1) modeColor = EnumChatFormatting.GOLD.toString();
-                else if (cheatMode == 2) modeColor = EnumChatFormatting.RED.toString();
+                if (cheatMode == 1)
+                    modeColor = EnumChatFormatting.GOLD.toString();
+                else if (cheatMode == 2)
+                    modeColor = EnumChatFormatting.RED.toString();
                 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");
             }
         };
 
-        bookmarksButton = new ButtonCycled(2) {
-
+        bookmarksButton = new ButtonCycled(2)
+        {
             @Override
             public void init() {
                 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");
@@ -426,49 +412,85 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
                 return translate("bookmark.toggle");
             }
         };
-
-        more = ItemPanels.itemPanel.more;
-        less = ItemPanels.itemPanel.less;
-        quantity = ItemPanels.itemPanel.quantity;
-        delete = new Button() {
-
+        more = new Button("+")
+        {
             @Override
             public boolean onButtonPress(boolean rightclick) {
-                if ((state & 0x3) == 2) return false;
+                if (rightclick)
+                    return false;
+
+                int modifier = controlKey() ? 64 : shiftKey() ? 10 : 1;
+
+                int quantity = getItemQuantity() + modifier;
+                if (quantity < 0)
+                    quantity = 0;
+
+                LayoutManager.quantity.setText(Integer.toString(quantity));
+                return true;
+            }
+        };
+        less = new Button("-")
+        {
+            @Override
+            public boolean onButtonPress(boolean rightclick) {
+                if (rightclick)
+                    return false;
+
+                int modifier = controlKey() ? -64 : shiftKey() ? -10 : -1;
+
+                int quantity = getItemQuantity() + modifier;
+                if (quantity < 0)
+                    quantity = 0;
+
+                LayoutManager.quantity.setText(Integer.toString(quantity));
+                return true;
+            }
+        };
+        quantity = new ItemQuantityField("quantity");
+
+
+        delete = new Button()
+        {
+            @Override
+            public boolean onButtonPress(boolean rightclick) {
+                if ((state & 0x3) == 2)
+                    return false;
 
                 ItemStack held = getHeldItem();
                 if (held != null) {
                     if (shiftKey()) {
                         deleteHeldItem();
                         deleteItemsOfType(held);
-                    } else if (rightclick) decreaseSlotStack(-999);
-                    else deleteHeldItem();
-                } else if (shiftKey()) deleteEverything();
-                else NEIController.toggleDeleteMode();
+                    } else if (rightclick)
+                        decreaseSlotStack(-999);
+                    else
+                        deleteHeldItem();
+                } else if (shiftKey())
+                    deleteEverything();
+                else
+                    NEIController.toggleDeleteMode();
 
                 return true;
             }
 
             public String getButtonTip() {
                 if ((state & 0x3) != 2) {
-                    if (shiftKey()) return translate("inventory.delete.inv");
-                    if (NEIController.canUseDeleteMode()) return getStateTip("delete", state);
+                    if (shiftKey())
+                        return translate("inventory.delete.inv");
+                    if (NEIController.canUseDeleteMode())
+                        return getStateTip("delete", state);
                 }
                 return null;
             }
 
             @Override
             public void postDraw(int mousex, int mousey) {
-                if (contains(mousex, mousey) && getHeldItem() != null && (state & 0x3) != 2) GuiDraw.drawTip(
-                        mousex + 9,
-                        mousey,
-                        translate(
-                                "inventory.delete." + (shiftKey() ? "all" : "one"),
-                                GuiContainerManager.itemDisplayNameShort(getHeldItem())));
+                if(contains(mousex, mousey) && getHeldItem() != null && (state & 0x3) != 2)
+                    GuiDraw.drawTip(mousex + 9, mousey, translate("inventory.delete." + (shiftKey() ? "all" : "one"), GuiContainerManager.itemDisplayNameShort(getHeldItem())));
             }
         };
-        gamemode = new ButtonCycled(3) {
-
+        gamemode = new ButtonCycled(3)
+        {
             @Override
             public boolean onButtonPress(boolean rightclick) {
                 if (!rightclick) {
@@ -477,17 +499,18 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
                 }
                 return false;
             }
-
             public void addTooltips(List<String> tooltip) {
                 tooltip.add(translate("inventory.current.gamemode." + getGamemode()));
                 tooltip.add(EnumChatFormatting.GRAY + translate("inventory.gamemode." + getNextGamemode()));
             }
-        };
-        rain = new Button() {
 
+        };
+        rain = new Button()
+        {
             @Override
             public boolean onButtonPress(boolean rightclick) {
-                if (handleDisabledButtonPress("rain", rightclick)) return true;
+                if (handleDisabledButtonPress("rain", rightclick))
+                    return true;
 
                 if (!rightclick) {
                     toggleRaining();
@@ -500,8 +523,8 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
                 return getStateTip("rain", state);
             }
         };
-        magnet = new Button() {
-
+        magnet = new Button()
+        {
             @Override
             public boolean onButtonPress(boolean rightclick) {
                 if (!rightclick) {
@@ -517,11 +540,12 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         };
         for (int i = 0; i < 4; i++) {
             final int zone = i;
-            timeButtons[i] = new Button() {
-
+            timeButtons[i] = new Button()
+            {
                 @Override
                 public boolean onButtonPress(boolean rightclick) {
-                    if (handleDisabledButtonPress(NEIActions.timeZones[zone], rightclick)) return true;
+                    if (handleDisabledButtonPress(NEIActions.timeZones[zone], rightclick))
+                        return true;
 
                     if (!rightclick) {
                         setHourForward(zone * 6);
@@ -534,10 +558,11 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
                 public String getButtonTip() {
                     return getTimeTip(NEIActions.timeZones[zone], state);
                 }
+
             };
         }
-        heal = new Button() {
-
+        heal = new Button()
+        {
             @Override
             public boolean onButtonPress(boolean rightclick) {
                 if (!rightclick) {
@@ -560,7 +585,8 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
     }
 
     private static String getStateTip(String name, int state) {
-        String sfx = (state & 0x3) == 2 ? "enable" : (state & 0x3) == 1 ? "0" : "1";
+        String sfx = (state & 0x3) == 2 ? "enable" :
+                (state & 0x3) == 1 ? "0" : "1";
 
         return translate("inventory." + name + "." + sfx);
     }
@@ -571,8 +597,10 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
     }
 
     private static boolean handleDisabledButtonPress(String ident, boolean rightclick) {
-        if (!NEIActions.canDisable.contains(ident)) return false;
-        if (rightclick != disabledActions.contains(ident)) return setPropertyDisabled(ident, rightclick);
+        if (!NEIActions.canDisable.contains(ident))
+            return false;
+        if (rightclick != disabledActions.contains(ident))
+            return setPropertyDisabled(ident, rightclick);
         return false;
     }
 
@@ -580,15 +608,18 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         if (disable && NEIActions.base(ident).equals("time")) {
             int count = 0;
             for (int i = 0; i < 4; i++) {
-                if (disabledActions.contains(NEIActions.timeZones[i])) count++;
+                if (disabledActions.contains(NEIActions.timeZones[i]))
+                    count++;
             }
-            if (count == 3) return false;
+            if (count == 3)
+                return false;
         }
-        if (hasSMPCounterPart()) NEICPH.sendSetPropertyDisabled(ident, disable);
+        if (hasSMPCounterPart())
+            NEICPH.sendSetPropertyDisabled(ident, disable);
 
         return true;
     }
-
+    
     public static void markItemsDirty() {
         // If anything has modified data this depends on, we'll need to reload the item list
         itemsLoaded = false;
@@ -599,7 +630,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         if (isEnabled()) {
             setInputFocused(null);
 
-            if (!itemsLoaded) {
+            if(!itemsLoaded) {
                 ItemList.loadItems.restart();
                 itemsLoaded = true;
             }
@@ -611,13 +642,13 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
 
         NEIController.load(gui);
 
-        if (checkCreativeInv(gui) && gui.mc.currentScreen instanceof GuiContainerCreative) // override creative with
-                                                                                           // creative+
-            gui.mc.displayGuiScreen(null); // close the screen and wait for the server to open it for us
+        if (checkCreativeInv(gui) && gui.mc.currentScreen instanceof GuiContainerCreative)//override creative with creative+
+            gui.mc.displayGuiScreen(null);//close the screen and wait for the server to open it for us
     }
 
     @Override
-    public void refresh(GuiContainer gui) {}
+    public void refresh(GuiContainer gui) {
+    }
 
     public boolean checkCreativeInv(GuiContainer gui) {
         if (gui instanceof GuiContainerCreative && invCreativeMode()) {
@@ -634,56 +665,60 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         drawWidgets = new TreeSet<>(new WidgetZOrder(false));
         controlWidgets = new TreeSet<>(new WidgetZOrder(true));
 
-        if (!visiblity.showNEI) return;
+        if (!visiblity.showNEI)
+            return;
+
 
         addWidget(options);
         addWidget(bookmarksButton);
         if (visiblity.showItemPanel) {
-
-            if (PresetsWidget.inEditMode()) {
-                drawWidgets.add(itemPanel);
-            } else {
-                addWidget(itemPanel);
-            }
-
+            addWidget(itemPanel);
             itemPanel.setVisible();
+
+            addWidget(more);
+            addWidget(less);
+            addWidget(quantity);
         }
 
         if (visiblity.showBookmarkPanel) {
             addWidget(bookmarkPanel);
             bookmarkPanel.setVisible();
-        }
+        } 
 
-        if (visiblity.showPresetsDropdown) {
-            addWidget(presetsPanel);
-        }
-
-        searchField.setVisible(visiblity.showSearchSection);
         if (visiblity.showSearchSection) {
             addWidget(searchField);
         }
 
         if (visiblity.showUtilityButtons) {
             if (canPerformAction("time")) {
-                for (int i = 0; i < 4; i++) addWidget(timeButtons[i]);
+                for (int i = 0; i < 4; i++)
+                    addWidget(timeButtons[i]);
             }
-            if (canPerformAction("rain")) addWidget(rain);
-            if (canPerformAction("heal")) addWidget(heal);
-            if (canPerformAction("magnet")) addWidget(magnet);
-            if (isValidGamemode("creative") || isValidGamemode("creative+") || isValidGamemode("adventure"))
+            if (canPerformAction("rain"))
+                addWidget(rain);
+            if (canPerformAction("heal"))
+                addWidget(heal);
+            if (canPerformAction("magnet"))
+                addWidget(magnet);
+            if (isValidGamemode("creative") ||
+                    isValidGamemode("creative+") ||
+                    isValidGamemode("adventure"))
                 addWidget(gamemode);
-            if (canPerformAction("delete")) addWidget(delete);
+            if (canPerformAction("delete"))
+                addWidget(delete);
         }
-
-        if (visiblity.showSubsetDropdown) {
+        
+        if (!visiblity.showBookmarkPanel) {
             // Bookmarks or Subset/dropdown
             addWidget(dropDown);
         }
     }
 
+
     public static LayoutStyle getLayoutStyle(int id) {
         LayoutStyle style = layoutStyles.get(id);
-        if (style == null) style = layoutStyles.get(0);
+        if (style == null)
+            style = layoutStyles.get(0);
         return style;
     }
 
@@ -698,28 +733,35 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
 
     @Override
     public void guiTick(GuiContainer gui) {
-        if (checkCreativeInv(gui)) return;
+        if (checkCreativeInv(gui))
+            return;
 
-        if (!isEnabled()) return;
+        if (!isEnabled())
+            return;
 
-        for (Widget widget : drawWidgets) widget.update();
+        for (Widget widget : controlWidgets)
+            widget.update();
     }
 
     @Override
     public boolean mouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {
-        if (isHidden() || !isEnabled()) return false;
+        if (isHidden() || !isEnabled())
+            return false;
 
-        for (Widget widget : drawWidgets) if (widget.onMouseWheel(scrolled, mousex, mousey)) return true;
+        for (Widget widget : controlWidgets)
+            if (widget.onMouseWheel(scrolled, mousex, mousey))
+                return true;
 
         return false;
     }
 
     @Override
-    public void onMouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {}
+    public void onMouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {
+    }
 
     @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. */
@@ -729,48 +771,51 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
 
     /** Note: this method isn't actually used by this mod, but NEI add-ons might need it. */
     public static void setInputFocused(Widget widget) {
-        if (inputFocused != null) inputFocused.loseFocus();
+        if (inputFocused != null)
+            inputFocused.loseFocus();
 
         inputFocused = widget;
-        if (inputFocused != null) inputFocused.gainFocus();
+        if (inputFocused != null)
+            inputFocused.gainFocus();
     }
 
     @Override
     public void renderSlotUnderlay(GuiContainer gui, Slot slot) {
-        if (overlayRenderer != null) overlayRenderer.renderOverlay(GuiContainerManager.getManager(gui), slot);
+        if (overlayRenderer != null)
+            overlayRenderer.renderOverlay(GuiContainerManager.getManager(gui), slot);
     }
 
     @Override
     public void renderSlotOverlay(GuiContainer window, Slot slot) {
         ItemStack item = slot.getStack();
-        if (world.nbt.getBoolean("searchinventories") && (item == null ? !getSearchExpression().equals("")
-                : !((SearchField) searchField).getFilter().matches(item))) {
+        if (world.nbt.getBoolean("searchinventories") && (item == null ? !getSearchExpression().equals("") : !ItemList.getItemListFilter().matches(item))) {
             GL11.glDisable(GL11.GL_LIGHTING);
-            GL11.glDisable(GL11.GL_DEPTH_TEST);
             GL11.glTranslatef(0, 0, 150);
             drawRect(slot.xDisplayPosition, slot.yDisplayPosition, 16, 16, 0x80000000);
             GL11.glTranslatef(0, 0, -150);
             GL11.glEnable(GL11.GL_LIGHTING);
-            GL11.glEnable(GL11.GL_DEPTH_TEST);
         }
     }
 
     public static void drawIcon(int x, int y, Image image) {
         final boolean isDrawableResource = image instanceof DrawableResource;
-
-        if (!isDrawableResource) changeTexture("nei:textures/nei_sprites.png");
-
+        
+        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((DrawableResource) image).draw(x, y);
+        if(!isDrawableResource)
+            drawTexturedModalRect(x, y, image.x, image.y, image.width, image.height);
+        else 
+            ((DrawableResource)image).draw(x, y);
         GL11.glDisable(GL11.GL_BLEND);
     }
 
     public static void drawButtonBackground(int x, int y, int w, int h, boolean edges, int type) {
         int wTiles = 0;
-        int ew = w; // end width
+        int ew = w;//end width
         if (w / 2 > 100) {
             wTiles = (w - 200) / 50 + 1;
             ew = 200;
@@ -785,27 +830,27 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
         final int y2 = y + h - h2;
 
         final int ty = 46 + type * 20;
-        final int te = (edges ? 0 : 1); // tex edges
+        final int te = (edges ? 0 : 1);//tex edges
 
         final int ty1 = ty + te;
         final int tx1 = te;
         final int tx3 = 75;
-        // halfway the 1 is for odd number adjustment
+        //halfway the 1 is for odd number adjustment
         final int ty2 = ty + 20 - h2 - te;
         final int tx2 = 200 - w2 - te;
 
         changeTexture("textures/gui/widgets.png");
-        drawTexturedModalRect(x, y, tx1, ty1, w1, h1); // top left
-        drawTexturedModalRect(x, y2, tx1, ty2, w1, h2); // bottom left
+        drawTexturedModalRect(x, y, tx1, ty1, w1, h1);//top left
+        drawTexturedModalRect(x, y2, tx1, ty2, w1, h2);//bottom left
 
         for (int tile = 0; tile < wTiles; tile++) {
             final int tileX = x + w1 + 50 * tile;
-            drawTexturedModalRect(tileX, y, tx3, ty1, 50, h1); // top
-            drawTexturedModalRect(tileX, y2, tx3, ty2, 50, h2); // bottom
+            drawTexturedModalRect(tileX, y, tx3, ty1, 50, h1);//top
+            drawTexturedModalRect(tileX, y2, tx3, ty2, 50, h2);//bottom
         }
 
-        drawTexturedModalRect(x2, y, tx2, ty1, w2, h1); // top right
-        drawTexturedModalRect(x2, y2, tx2, ty2, w2, h2); // bottom right
+        drawTexturedModalRect(x2, y, tx2, ty1, w2, h1);//top right
+        drawTexturedModalRect(x2, y2, tx2, ty2, w2, h2);//bottom right
     }
 
     public static void drawItemPresenceOverlay(int slotX, int slotY, boolean isPresent) {
@@ -819,14 +864,24 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
 
     @Override
     public void tickKeyStates() {
-        if (Minecraft.getMinecraft().currentScreen != null) return;
+        if (Minecraft.getMinecraft().currentScreen != null)
+            return;
 
-        if (KeyManager.keyStates.get("world.dawn").down) timeButtons[0].onButtonPress(false);
-        if (KeyManager.keyStates.get("world.noon").down) timeButtons[1].onButtonPress(false);
-        if (KeyManager.keyStates.get("world.dusk").down) timeButtons[2].onButtonPress(false);
-        if (KeyManager.keyStates.get("world.midnight").down) timeButtons[3].onButtonPress(false);
-        if (KeyManager.keyStates.get("world.rain").down) rain.onButtonPress(false);
-        if (KeyManager.keyStates.get("world.heal").down) heal.onButtonPress(false);
-        if (KeyManager.keyStates.get("world.creative").down) gamemode.onButtonPress(false);
+        if (KeyManager.keyStates.get("world.dawn").down)
+            timeButtons[0].onButtonPress(false);
+        if (KeyManager.keyStates.get("world.noon").down)
+            timeButtons[1].onButtonPress(false);
+        if (KeyManager.keyStates.get("world.dusk").down)
+            timeButtons[2].onButtonPress(false);
+        if (KeyManager.keyStates.get("world.midnight").down)
+            timeButtons[3].onButtonPress(false);
+        if (KeyManager.keyStates.get("world.rain").down)
+            rain.onButtonPress(false);
+        if (KeyManager.keyStates.get("world.heal").down)
+            heal.onButtonPress(false);
+        if (KeyManager.keyStates.get("world.creative").down)
+            gamemode.onButtonPress(false);
     }
+
 }
+

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

@@ -1,5 +1,10 @@
 package codechicken.nei;
 
+import codechicken.nei.api.LayoutStyle;
+import codechicken.nei.drawable.DrawableBuilder;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import org.lwjgl.opengl.GL11;
+
 import static codechicken.lib.gui.GuiDraw.drawStringC;
 import static codechicken.nei.LayoutManager.bookmarkPanel;
 import static codechicken.nei.LayoutManager.bookmarksButton;
@@ -9,9 +14,11 @@ import static codechicken.nei.LayoutManager.gamemode;
 import static codechicken.nei.LayoutManager.heal;
 import static codechicken.nei.LayoutManager.itemPanel;
 import static codechicken.nei.LayoutManager.itemPresenceOverlays;
+import static codechicken.nei.LayoutManager.less;
 import static codechicken.nei.LayoutManager.magnet;
+import static codechicken.nei.LayoutManager.more;
 import static codechicken.nei.LayoutManager.options;
-import static codechicken.nei.LayoutManager.presetsPanel;
+import static codechicken.nei.LayoutManager.quantity;
 import static codechicken.nei.LayoutManager.rain;
 import static codechicken.nei.LayoutManager.searchField;
 import static codechicken.nei.LayoutManager.timeButtons;
@@ -20,15 +27,8 @@ import static codechicken.nei.NEIClientConfig.disabledActions;
 import static codechicken.nei.NEIClientConfig.getMagnetMode;
 import static codechicken.nei.NEIClientConfig.isEnabled;
 
-import net.minecraft.client.gui.inventory.GuiContainer;
-
-import org.lwjgl.opengl.GL11;
-
-import codechicken.nei.api.LayoutStyle;
-import codechicken.nei.drawable.DrawableBuilder;
-
-public class LayoutStyleMinecraft extends LayoutStyle {
-
+public class LayoutStyleMinecraft extends LayoutStyle
+{
     public int buttonCount;
     public int leftSize;
     public int numButtons;
@@ -68,44 +68,66 @@ public class LayoutStyleMinecraft extends LayoutStyle {
         numButtons = Math.max(leftSize / 18, 1);
 
         delete.state = 0x4;
-        if (NEIController.getDeleteMode()) delete.state |= 1;
-        else if (!visiblity.enableDeleteMode) delete.state |= 2;
+        if (NEIController.getDeleteMode())
+            delete.state |= 1;
+        else if (!visiblity.enableDeleteMode)
+            delete.state |= 2;
 
         rain.state = 0x4;
-        if (disabledActions.contains("rain")) rain.state |= 2;
-        else if (NEIClientUtils.isRaining()) rain.state |= 1;
+        if (disabledActions.contains("rain"))
+            rain.state |= 2;
+        else if (NEIClientUtils.isRaining())
+            rain.state |= 1;
 
         gamemode.state = 0x4;
         if (NEIClientUtils.getGamemode() != 0) {
             gamemode.state |= 0x1;
             gamemode.index = NEIClientUtils.getGamemode() - 1;
         } else {
-            if (NEIClientUtils.isValidGamemode("creative")) gamemode.index = 0;
-            else if (NEIClientUtils.isValidGamemode("creative+")) gamemode.index = 1;
-            else if (NEIClientUtils.isValidGamemode("adventure")) gamemode.index = 2;
+            if (NEIClientUtils.isValidGamemode("creative"))
+                gamemode.index = 0;
+            else if (NEIClientUtils.isValidGamemode("creative+"))
+                gamemode.index = 1;
+            else if (NEIClientUtils.isValidGamemode("adventure"))
+                gamemode.index = 2;
         }
         bookmarksButton.index = NEIClientConfig.isBookmarkPanelHidden() ? 0 : 1;
         options.index = NEIClientConfig.getCheatMode();
 
         magnet.state = 0x4 | (getMagnetMode() ? 1 : 0);
 
-        if (canPerformAction("delete")) layoutButton(delete);
-        if (canPerformAction("rain")) layoutButton(rain);
-        if (NEIClientUtils.isValidGamemode("creative") || NEIClientUtils.isValidGamemode("creative+")
-                || NEIClientUtils.isValidGamemode("adventure"))
+        if (canPerformAction("delete"))
+            layoutButton(delete);
+        if (canPerformAction("rain"))
+            layoutButton(rain);
+        if (NEIClientUtils.isValidGamemode("creative") ||
+            NEIClientUtils.isValidGamemode("creative+") ||
+            NEIClientUtils.isValidGamemode("adventure"))
             layoutButton(gamemode);
-        if (canPerformAction("magnet")) layoutButton(magnet);
+        if (canPerformAction("magnet"))
+            layoutButton(magnet);
         if (canPerformAction("time")) {
             for (int i = 0; i < 4; i++) {
                 timeButtons[i].state = disabledActions.contains(NEIActions.timeZones[i]) ? 2 : 0;
                 layoutButton(timeButtons[i]);
             }
         }
-        if (canPerformAction("heal")) layoutButton(heal);
+        if (canPerformAction("heal"))
+            layoutButton(heal);
 
         itemPanel.resize(gui);
         bookmarkPanel.resize(gui);
 
+        more.w = more.h = less.w = less.h = 16;
+        less.x = itemPanel.prev.x;
+        more.x = gui.width - less.w - 2;
+        more.y = less.y = gui.height - more.h - 2;
+
+        quantity.x = less.x + less.w + 2;
+        quantity.y = less.y;
+        quantity.w = more.x - quantity.x - 2;
+        quantity.h = less.h;
+
         options.x = isEnabled() ? 0 : 6;
         options.y = isEnabled() ? gui.height - 22 : gui.height - 28;
         options.w = 22;
@@ -116,29 +138,25 @@ public class LayoutStyleMinecraft extends LayoutStyle {
         bookmarksButton.w = 22;
         bookmarksButton.h = 22;
 
-        dropDown.h = 18;
-        dropDown.w = 150;
-        dropDown.y = 0;
-        dropDown.x = (gui.width - gui.xSize) / 2 + gui.xSize - dropDown.w;
-
-        presetsPanel.h = 16;
-        presetsPanel.w = 150;
-        presetsPanel.y = 2;
-        presetsPanel.x = (gui.width - gui.xSize) / 2 + gui.xSize - presetsPanel.w;
+        searchField.y = gui.height - searchField.h - 2;
 
+        dropDown.x = Math.min(numButtons, buttonCount) * 20 + 3;
+        dropDown.h = 20;
+        dropDown.w = itemPanel.x - dropDown.x - 3;
+        
         searchField.h = 20;
         searchField.w = 150;
         searchField.x = (gui.width - searchField.w) / 2;
-        searchField.y = gui.height - searchField.h - 2;
 
         if (!visiblity.showItemSection) {
             searchField.setFocus(false);
         }
+
     }
 
     public void layoutButton(Button button) {
-        button.x = 2 + (buttonCount % numButtons) * 19;
-        button.y = 2 + (buttonCount / numButtons) * 18;
+        button.x = 2 + (buttonCount % numButtons) * 20;
+        button.y = (buttonCount / numButtons) * 18;
 
         button.h = 17;
         button.w = button.contentWidth() + 6;
@@ -152,11 +170,13 @@ public class LayoutStyleMinecraft extends LayoutStyle {
         GL11.glColor4f(1, 1, 1, 1);
 
         int tex;
-        if ((b.state & 0x3) == 2) tex = 0;
-        else if ((b.state & 0x4) == 0 && b.contains(mousex, mousey) || // not a state button and mouseover
-                (b.state & 0x3) == 1) // state active
+        if ((b.state & 0x3) == 2)
+            tex = 0;
+        else if ((b.state & 0x4) == 0 && b.contains(mousex, mousey) ||//not a state button and mouseover
+            (b.state & 0x3) == 1)//state active
             tex = 2;
-        else tex = 1;
+        else
+            tex = 1;
         LayoutManager.drawButtonBackground(b.x, b.y, b.w, b.h, true, tex);
 
         Image icon = b.getRenderIcon();
@@ -176,9 +196,12 @@ public class LayoutStyleMinecraft extends LayoutStyle {
 
     @Override
     public void drawSubsetTag(String text, int x, int y, int w, int h, int state, boolean mouseover) {
-        if (state == 1) GL11.glColor4f(0.65F, 0.65F, 0.65F, 1.0F);
-        else GL11.glColor4f(1, 1, 1, 1);
+        if(state == 1)
+            GL11.glColor4f(0.65F, 0.65F, 0.65F, 1.0F);
+        else
+            GL11.glColor4f(1, 1, 1, 1);
         LayoutManager.drawButtonBackground(x, y, w, h, false, state == 0 ? 0 : 1);
-        if (text != null) drawStringC(text, x, y, w, h, state == 2 ? 0xFFE0E0E0 : 0xFFA0A0A0);
+        if(text != null)
+            drawStringC(text, x, y, w, h, state == 2 ? 0xFFE0E0E0 : 0xFFA0A0A0);
     }
 }

src/main/java/codechicken/nei/NEIActions.java

@@ -5,40 +5,47 @@ import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 
-public class NEIActions {
-
+public class NEIActions
+{
     public static final int protocol = 0;
-
+    
     public static HashMap<String, NEIActions> nameActionMap = new HashMap<>();
     public static HashSet<String> canDisable = new HashSet<>();
 
-    public static void addAction(String name, String base, boolean smpreq) {
+    public static void addAction(String name, String base, boolean smpreq)
+    {
         NEIActions action = new NEIActions(name, base, smpreq);
         nameActionMap.put(name, action);
     }
-
-    private static void addAction(String name, String base) {
+    
+    private static void addAction(String name, String base)
+    {
         addAction(name, base, false);
     }
 
-    public static void addAction(String name) {
+    public static void addAction(String name)
+    {
         addAction(name, name);
     }
 
-    private static void addAction(String name, boolean smpreq) {
+    private static void addAction(String name, boolean smpreq)
+    {
         addAction(name, name, smpreq);
     }
-
-    public static String base(String name) {
+    
+    public static String base(String name)
+    {
         NEIActions action = nameActionMap.get(name);
         return action == null ? name : action.base;
     }
 
-    public static boolean smpRequired(String name) {
+    public static boolean smpRequired(String name)
+    {
         return nameActionMap.get(name).smpreq;
     }
-
-    public static void init() {
+    
+    public static void init()
+    {
         addAction("time");
         addAction("dawn", "time");
         addAction("noon", "time");
@@ -61,23 +68,27 @@ public class NEIActions {
         canDisable.add("midnight");
         canDisable.add("rain");
     }
-
-    public static final String[] timeZones = new String[] { "dawn", "noon", "dusk", "midnight" };
-    public static final String[] gameModes = new String[] { "survival", "creative", "creative+", "adventure" };
+    
+    public static final String[] timeZones = new String[]{"dawn", "noon", "dusk", "midnight"};
+    public static final String[] gameModes = new String[]{"survival", "creative", "creative+", "adventure"};
 
     public String name;
     public String base;
     public boolean smpreq;
-
-    public NEIActions(String name, String base, boolean smpreq) {
+    
+    public NEIActions(String name, String base, boolean smpreq)
+    {
         this.name = name;
         this.base = base;
         this.smpreq = smpreq;
     }
 
-    public static List<String> baseActions() {
+    public static List<String> baseActions()
+    {
         List<String> list = new LinkedList<>();
-        for (NEIActions a : nameActionMap.values()) if (a.base.equals(a.name)) list.add(a.name);
+        for(NEIActions a : nameActionMap.values())
+            if(a.base.equals(a.name))
+                list.add(a.name);
         return list;
     }
 }

src/main/java/codechicken/nei/NEICPH.java

@@ -1,5 +1,10 @@
 package codechicken.nei;
 
+import codechicken.core.ClientUtils;
+import codechicken.lib.inventory.InventoryUtils;
+import codechicken.lib.packet.PacketCustom;
+import codechicken.lib.packet.PacketCustom.IClientPacketHandler;
+import cpw.mods.fml.relauncher.Side;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.inventory.GuiInventory;
 import net.minecraft.item.ItemStack;
@@ -7,14 +12,8 @@ import net.minecraft.network.play.INetHandlerPlayClient;
 import net.minecraft.util.ChatComponentTranslation;
 import net.minecraft.world.World;
 
-import codechicken.core.ClientUtils;
-import codechicken.lib.inventory.InventoryUtils;
-import codechicken.lib.packet.PacketCustom;
-import codechicken.lib.packet.PacketCustom.IClientPacketHandler;
-import cpw.mods.fml.relauncher.Side;
-
-public class NEICPH implements IClientPacketHandler {
-
+public class NEICPH implements IClientPacketHandler
+{
     public static final String channel = "NEI";
 
     @Override
@@ -39,16 +38,13 @@ public class NEICPH implements IClientPacketHandler {
                 handleGamemode(mc, packet.readUByte());
                 break;
             case 21:
-                ClientUtils.openSMPGui(
-                        packet.readUByte(),
-                        new GuiEnchantmentModifier(mc.thePlayer.inventory, mc.theWorld, 0, 0, 0));
+                ClientUtils.openSMPGui(packet.readUByte(), new GuiEnchantmentModifier(mc.thePlayer.inventory, mc.theWorld, 0, 0, 0));
                 break;
             case 23:
-                if (packet.readBoolean()) ClientUtils.openSMPGui(
-                        packet.readUByte(),
-                        new GuiExtendedCreativeInv(
-                                new ContainerCreativeInv(mc.thePlayer, new ExtendedCreativeInv(null, Side.CLIENT))));
-                else mc.displayGuiScreen(new GuiInventory(mc.thePlayer));
+                if (packet.readBoolean())
+                    ClientUtils.openSMPGui(packet.readUByte(), new GuiExtendedCreativeInv(new ContainerCreativeInv(mc.thePlayer, new ExtendedCreativeInv(null, Side.CLIENT))));
+                else
+                    mc.displayGuiScreen(new GuiInventory(mc.thePlayer));
                 break;
             case 24:
                 ClientUtils.openSMPGui(packet.readUByte(), new GuiPotionCreator(mc.thePlayer.inventory));
@@ -62,32 +58,40 @@ public class NEICPH implements IClientPacketHandler {
 
     private void handleActionEnabled(PacketCustom packet) {
         String name = packet.readString();
-        if (packet.readBoolean()) NEIClientConfig.enabledActions.add(name);
-        else NEIClientConfig.enabledActions.remove(name);
+        if (packet.readBoolean())
+            NEIClientConfig.enabledActions.add(name);
+        else
+            NEIClientConfig.enabledActions.remove(name);
     }
 
     private void handleActionDisabled(PacketCustom packet) {
         String name = packet.readString();
-        if (packet.readBoolean()) NEIClientConfig.disabledActions.add(name);
-        else NEIClientConfig.disabledActions.remove(name);
+        if (packet.readBoolean())
+            NEIClientConfig.disabledActions.add(name);
+        else
+            NEIClientConfig.disabledActions.remove(name);
     }
 
     private void handleLoginState(PacketCustom packet) {
         NEIClientConfig.permissableActions.clear();
         int num = packet.readUByte();
-        for (int i = 0; i < num; i++) NEIClientConfig.permissableActions.add(packet.readString());
+        for (int i = 0; i < num; i++)
+            NEIClientConfig.permissableActions.add(packet.readString());
 
         NEIClientConfig.disabledActions.clear();
         num = packet.readUByte();
-        for (int i = 0; i < num; i++) NEIClientConfig.disabledActions.add(packet.readString());
+        for (int i = 0; i < num; i++)
+            NEIClientConfig.disabledActions.add(packet.readString());
 
         NEIClientConfig.enabledActions.clear();
         num = packet.readUByte();
-        for (int i = 0; i < num; i++) NEIClientConfig.enabledActions.add(packet.readString());
+        for (int i = 0; i < num; i++)
+            NEIClientConfig.enabledActions.add(packet.readString());
 
         NEIClientConfig.bannedBlocks.clear();
         num = packet.readInt();
-        for (int i = 0; i < num; i++) NEIClientConfig.bannedBlocks.add(packet.readItemStack());
+        for(int i = 0; i < num; i++)
+            NEIClientConfig.bannedBlocks.add(packet.readItemStack());
 
         if (NEIClientUtils.getGuiContainer() != null)
             LayoutManager.instance().refresh(NEIClientUtils.getGuiContainer());
@@ -111,7 +115,8 @@ public class NEICPH implements IClientPacketHandler {
     }
 
     private static String getSaveName(String worldName) {
-        if (Minecraft.getMinecraft().isSingleplayer()) return "local/" + ClientUtils.getWorldSaveName();
+        if (Minecraft.getMinecraft().isSingleplayer())
+            return "local/" + ClientUtils.getWorldSaveName();
 
         return "remote/" + ClientUtils.getServerIP().replace(':', '~') + "/" + worldName;
     }
@@ -143,12 +148,6 @@ public class NEICPH implements IClientPacketHandler {
         packet.sendToServer();
     }
 
-    public static void sendRequestContainer() {
-        PacketCustom packet = new PacketCustom(channel, 16);
-        packet.writeInt(Minecraft.getMinecraft().thePlayer.openContainer.getInventory().size());
-        packet.sendToServer();
-    }
-
     public static void sendSetSlot(int slot, ItemStack stack, boolean container) {
         PacketCustom packet = new PacketCustom(channel, 5);
         packet.writeBoolean(container);
@@ -204,7 +203,9 @@ public class NEICPH implements IClientPacketHandler {
     }
 
     public static void sendGamemode(int mode) {
-        new PacketCustom(channel, 13).writeByte(mode).sendToServer();
+        new PacketCustom(channel, 13)
+                .writeByte(mode)
+                .sendToServer();
     }
 
     public static void sendCreativeInv(boolean open) {
@@ -228,11 +229,10 @@ public class NEICPH implements IClientPacketHandler {
 
     public static void sendOpenPotionWindow() {
         ItemStack[] potionStore = new ItemStack[9];
-        InventoryUtils.readItemStacksFromTag(
-                potionStore,
-                NEIClientConfig.global.nbt.getCompoundTag("potionStore").getTagList("items", 10));
+        InventoryUtils.readItemStacksFromTag(potionStore, NEIClientConfig.global.nbt.getCompoundTag("potionStore").getTagList("items", 10));
         PacketCustom packet = new PacketCustom(channel, 24);
-        for (ItemStack stack : potionStore) packet.writeItemStack(stack);
+        for (ItemStack stack : potionStore)
+            packet.writeItemStack(stack);
         packet.sendToServer();
     }
 

src/main/java/codechicken/nei/NEIChestGuiHandler.java

@@ -1,18 +1,17 @@
 package codechicken.nei;
 
-import java.util.Collections;
-import java.util.List;
-
+import codechicken.nei.api.INEIGuiAdapter;
+import codechicken.nei.api.TaggedInventoryArea;
 import net.minecraft.client.gui.inventory.GuiChest;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.inventory.ContainerChest;
 import net.minecraft.item.ItemStack;
 
-import codechicken.nei.api.INEIGuiAdapter;
-import codechicken.nei.api.TaggedInventoryArea;
-
-public class NEIChestGuiHandler extends INEIGuiAdapter {
+import java.util.Collections;
+import java.util.List;
 
+public class NEIChestGuiHandler extends INEIGuiAdapter
+{
     public int chestSize(GuiContainer gui) {
         return ((ContainerChest) gui.inventorySlots).getLowerChestInventory().getSizeInventory();
     }
@@ -24,8 +23,6 @@ public class NEIChestGuiHandler extends INEIGuiAdapter {
 
     @Override
     public List<TaggedInventoryArea> getInventoryAreas(GuiContainer gui) {
-        return gui instanceof GuiChest
-                ? Collections.singletonList(new TaggedInventoryArea("Chest", 0, chestSize(gui), gui.inventorySlots))
-                : null;
+        return gui instanceof GuiChest ? Collections.singletonList(new TaggedInventoryArea("Chest", 0, chestSize(gui), gui.inventorySlots)) : null;
     }
 }

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

@@ -1,26 +1,5 @@
 package codechicken.nei;
 
-import java.io.File;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.function.Function;
-import java.util.regex.Pattern;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.renderer.OpenGlHelper;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.world.World;
-import net.minecraft.world.storage.SaveFormatComparator;
-import net.minecraftforge.common.MinecraftForge;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.lwjgl.input.Keyboard;
-
 import codechicken.core.CCUpdateChecker;
 import codechicken.core.ClassDiscoverer;
 import codechicken.core.ClientUtils;
@@ -37,7 +16,6 @@ import codechicken.nei.config.ConfigSet;
 import codechicken.nei.config.GuiHighlightTips;
 import codechicken.nei.config.GuiNEIOptionList;
 import codechicken.nei.config.GuiOptionList;
-import codechicken.nei.config.GuiPanelSettings;
 import codechicken.nei.config.OptionCycled;
 import codechicken.nei.config.OptionGamemodes;
 import codechicken.nei.config.OptionList;
@@ -49,17 +27,31 @@ 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;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import net.minecraft.world.storage.SaveFormatComparator;
+import net.minecraftforge.common.MinecraftForge;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.lwjgl.input.Keyboard;
+
+import java.io.File;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.function.Function;
 
 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/");
@@ -67,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.
@@ -90,22 +78,19 @@ 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());
-
-    public static int getHandlerOrder(IRecipeHandler handler) {
-        if (handlerOrdering.get(handler.getOverlayIdentifier()) != null) {
-            return handlerOrdering.get(handler.getOverlayIdentifier());
-        }
-        if (handlerOrdering.get(handler.getHandlerId()) != null) {
-            return handlerOrdering.get(handler.getHandlerId());
-        }
-        return 0;
-    }
+    public static final Function<IRecipeHandler, String> HANDLER_ID_FUNCTION =
+            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 = Comparator
-            .comparingInt(NEIClientConfig::getHandlerOrder);
+    public static final Comparator<IRecipeHandler> HANDLER_COMPARATOR =
+            Comparator.comparingInt(
+                    handler -> handlerOrdering.getOrDefault(
+                            HANDLER_ID_FUNCTION.apply(handler), 0));
+
 
     public static ItemStack[] creativeInv;
 
@@ -117,30 +102,27 @@ public class NEIClientConfig {
     public static ItemStackSet bannedBlocks = new ItemStackSet();
 
     static {
-        if (global.config.getTag("checkUpdates").getBooleanValue(true)) CCUpdateChecker.updateCheck("NotEnoughItems");
+        if (global.config.getTag("checkUpdates").getBooleanValue(true))
+            CCUpdateChecker.updateCheck("NotEnoughItems");
         linkOptionList();
         setDefaults();
     }
 
     private static void setDefaults() {
         ConfigTagParent tag = global.config;
-        tag.setComment(
-                "Main configuration of NEI.\nMost of these options can be changed ingame.\nDeleting any element will restore it to it's default value");
+        tag.setComment("Main configuration of NEI.\nMost of these options can be changed ingame.\nDeleting any element will restore it to it's default value");
 
-        tag.getTag("command").useBraces().setComment(
-                "Change these options if you have a different mod installed on the server that handles the commands differently, Eg. Bukkit Essentials");
+        tag.getTag("command").useBraces().setComment("Change these options if you have a different mod installed on the server that handles the commands differently, Eg. Bukkit Essentials");
         tag.setNewLineMode(1);
 
         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);
-        API.addOption(new OptionCycled("inventory.cheatmode", 3) {
-
+        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);
+        API.addOption(new OptionCycled("inventory.cheatmode", 3)
+        {
             @Override
             public boolean optionValid(int index) {
                 return getLockedMode() == -1 || getLockedMode() == index && NEIInfo.isValidMode(index);
@@ -154,6 +136,7 @@ public class NEIClientConfig {
         tag.getTag("inventory.gamemodes").setDefaultValue("creative, creative+, adventure");
         API.addOption(new OptionGamemodes("inventory.gamemodes"));
 
+
         ItemSorter.initConfig(tag);
 
         tag.getTag("inventory.itemIDs").getIntValue(1);
@@ -167,18 +150,6 @@ public class NEIClientConfig {
         tag.getTag("world.highlight_tips.y").getIntValue(100);
         API.addOption(new OptionOpenGui("world.highlight_tips", GuiHighlightTips.class));
 
-        tag.getTag("world.panels.bookmarks.left").getIntValue(0);
-        tag.getTag("world.panels.bookmarks.right").getIntValue(0);
-        tag.getTag("world.panels.bookmarks.top").getIntValue(0);
-        tag.getTag("world.panels.bookmarks.bottom").getIntValue(0);
-
-        tag.getTag("world.panels.items.left").getIntValue(0);
-        tag.getTag("world.panels.items.right").getIntValue(0);
-        tag.getTag("world.panels.items.top").getIntValue(0);
-        tag.getTag("world.panels.items.bottom").getIntValue(0);
-
-        API.addOption(new OptionOpenGui("world.panels", GuiPanelSettings.class));
-
         tag.getTag("inventory.profileRecipes").getBooleanValue(false);
         API.addOption(new OptionToggleButton("inventory.profileRecipes", true));
 
@@ -187,18 +158,12 @@ public class NEIClientConfig {
 
         tag.getTag("inventory.invertMouseScrollTransfer").getBooleanValue(false);
         API.addOption(new OptionToggleButton("inventory.invertMouseScrollTransfer", true) {
-
             @Override
             public boolean isEnabled() {
                 return isMouseScrollTransferEnabled();
             }
         });
 
-        tag.getTag("inventory.cacheItemRendering").getBooleanValue(false);
-        API.addOption(new OptionToggleButton("inventory.cacheItemRendering", true));
-
-        tag.getTag("itemLoadingTimeout").getIntValue(500);
-
         tag.getTag("command.creative").setDefaultValue("/gamemode {0} {1}");
         API.addOption(new OptionTextField("command.creative"));
         tag.getTag("command.item").setDefaultValue("/give {0} {1} {2} {3} {4}");
@@ -209,76 +174,19 @@ 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.useNBTInBookmarks").setComment("Use NBT in Bookmarks").getBooleanValue(true);
-        API.addOption(new OptionToggleButton("inventory.useNBTInBookmarks", true));
-        tag.getTag("inventory.bookmarksAnimationEnabled").setComment("REI Style Animation in Bookmarks")
-                .getBooleanValue(true);
-        API.addOption(new OptionToggleButton("inventory.bookmarksAnimationEnabled", true));
-        tag.getTag("inventory.showRecipeMarker").setComment("Show Recipe Marker").getBooleanValue(false);
-        API.addOption(new OptionToggleButton("inventory.showRecipeMarker", true));
-
-        tag.getTag("inventory.showItemQuantityWidget").setComment("Show Item Quantity Widget").getBooleanValue(true);
-        API.addOption(new OptionToggleButton("inventory.showItemQuantityWidget", 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);
+        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));
 
-        tag.getTag("inventory.ignore_potion_overlap").setComment("Ignore overlap with potion effect HUD")
-                .getBooleanValue(false);
-        API.addOption(new OptionToggleButton("inventory.ignore_potion_overlap", true));
-
-        tag.getTag("inventory.optimize_gui_overlap_computation").setComment("Optimize computation for GUI overlap")
-                .getBooleanValue(false);
-        API.addOption(new OptionToggleButton("inventory.optimize_gui_overlap_computation", true));
-
-        tag.getTag("inventory.jei_style_cycled_ingredients").setComment("JEI styled cycled ingredients")
-                .getBooleanValue(true);
-        API.addOption(new OptionToggleButton("inventory.jei_style_cycled_ingredients", true));
-
-        tag.getTag("inventory.shift_overlay_recipe")
-                .setComment("Require holding shift to move items when overlaying recipe").getBooleanValue(true);
-        API.addOption(new OptionToggleButton("inventory.shift_overlay_recipe", true));
-
-        tag.getTag("tools.handler_load_from_config").setComment("ADVANCED: Load handlers from config")
-                .getBooleanValue(false);
+        tag.getTag("tools.handler_load_from_config").setComment("ADVANCED: Load handlers from config").getBooleanValue(false);
         API.addOption(new OptionToggleButton("tools.handler_load_from_config", true) {
-
             @Override
             public boolean onClick(int button) {
                 super.onClick(button);
@@ -286,25 +194,12 @@ 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();
     }
 
     private static void linkOptionList() {
-        OptionList.setOptionList(new OptionList("nei.options") {
-
+        OptionList.setOptionList(new OptionList("nei.options")
+        {
             @Override
             public ConfigSet globalConfigSet() {
                 return global;
@@ -328,33 +223,21 @@ public class NEIClientConfig {
     }
 
     private static void setDefaultKeyBindings() {
-        API.addHashBind("gui.recipe", Keyboard.KEY_R);
-        API.addHashBind("gui.usage", Keyboard.KEY_U);
+        API.addKeyBind("gui.recipe", Keyboard.KEY_R);
+        API.addKeyBind("gui.usage", Keyboard.KEY_U);
         API.addKeyBind("gui.back", Keyboard.KEY_BACK);
-        API.addHashBind("gui.enchant", Keyboard.KEY_X);
-        API.addHashBind("gui.potion", Keyboard.KEY_P);
+        API.addKeyBind("gui.enchant", Keyboard.KEY_X);
+        API.addKeyBind("gui.potion", Keyboard.KEY_P);
         API.addKeyBind("gui.prev", Keyboard.KEY_PRIOR);
         API.addKeyBind("gui.next", Keyboard.KEY_NEXT);
         API.addKeyBind("gui.prev_machine", Keyboard.KEY_UP);
         API.addKeyBind("gui.next_machine", Keyboard.KEY_DOWN);
         API.addKeyBind("gui.prev_recipe", Keyboard.KEY_LEFT);
         API.addKeyBind("gui.next_recipe", Keyboard.KEY_RIGHT);
-        API.addHashBind("gui.hide", Keyboard.KEY_O);
-        API.addHashBind("gui.search", Keyboard.KEY_F);
-        API.addHashBind("gui.bookmark", Keyboard.KEY_A);
-        API.addHashBind("gui.bookmark_recipe", Keyboard.KEY_A + NEIClientUtils.SHIFT_HASH);
-        API.addHashBind("gui.bookmark_count", Keyboard.KEY_A + NEIClientUtils.CTRL_HASH);
-        API.addHashBind(
-                "gui.bookmark_recipe_count",
-                Keyboard.KEY_A + NEIClientUtils.SHIFT_HASH + NEIClientUtils.CTRL_HASH);
-        API.addHashBind("gui.overlay", Keyboard.KEY_S);
-        API.addHashBind("gui.overlay_use", Keyboard.KEY_S + NEIClientUtils.SHIFT_HASH);
-        API.addHashBind("gui.overlay_hide", Keyboard.KEY_S + NEIClientUtils.CTRL_HASH);
-        API.addHashBind("gui.hide_bookmarks", Keyboard.KEY_B);
-        API.addKeyBind("gui.getprevioussearch", Keyboard.KEY_UP);
-        API.addKeyBind("gui.getnextsearch", Keyboard.KEY_DOWN);
-        API.addHashBind("gui.next_tooltip", Keyboard.KEY_Z);
-
+        API.addKeyBind("gui.hide", Keyboard.KEY_O);
+        API.addKeyBind("gui.search", Keyboard.KEY_F);
+        API.addKeyBind("gui.bookmark", Keyboard.KEY_A);
+        API.addKeyBind("gui.hide_bookmarks", Keyboard.KEY_B);
         API.addKeyBind("world.chunkoverlay", Keyboard.KEY_F9);
         API.addKeyBind("world.moboverlay", Keyboard.KEY_F7);
         API.addKeyBind("world.highlight_tips", Keyboard.KEY_NUMPAD0);
@@ -371,38 +254,31 @@ 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");
+        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);
     }
 
     private static void onWorldLoad(boolean newWorld) {
-        world.config.setComment(
-                "World based configuration of NEI.\nMost of these options can be changed ingame.\nDeleting any element will restore it to it's default value");
+        world.config.setComment("World based configuration of NEI.\nMost of these options can be changed ingame.\nDeleting any element will restore it to it's default value");
 
         setWorldDefaults();
         creativeInv = new ItemStack[54];
         LayoutManager.searchField.setText(getSearchExpression());
-        ItemPanels.itemPanel.quantity.setText(Integer.toString(getItemQuantity()));
+        LayoutManager.quantity.setText(Integer.toString(getItemQuantity()));
         SubsetWidget.loadHidden();
 
-        if (newWorld && Minecraft.getMinecraft().isSingleplayer()) world.config.getTag("inventory.cheatmode")
-                .setIntValue(NEIClientUtils.mc().playerController.isInCreativeMode() ? 2 : 0);
+        if (newWorld && Minecraft.getMinecraft().isSingleplayer())
+            world.config.getTag("inventory.cheatmode").setIntValue(NEIClientUtils.mc().playerController.isInCreativeMode() ? 2 : 0);
 
         NEIInfo.load(ClientUtils.getWorld());
     }
@@ -417,67 +293,30 @@ public class NEIClientConfig {
     }
 
     public static int getKeyBinding(String string) {
-        return getSetting("keys." + string).getIntValue(Keyboard.KEY_NONE);
+        return getSetting("keys." + string).getIntValue();
     }
 
     public static void setDefaultKeyBinding(String string, int key) {
         getSetting("keys." + string).getIntValue(key);
     }
 
-    public static boolean isKeyHashDown(String string) {
-        final int hash = getKeyBinding(string);
-        return hash != Keyboard.CHAR_NONE && hash == NEIClientUtils.getKeyHash();
-    }
-
-    public static String getKeyName(int keyBind, boolean useHash) {
-        return getKeyName(keyBind, useHash, false);
-    }
-
-    public static String getKeyName(int keyBind, boolean useHash, boolean showOnlyHash) {
-        String keyText = "";
-
-        if (useHash) {
-            final String DELIMITER = " + ";
-            if ((keyBind & NEIClientUtils.CTRL_HASH) != 0) {
-                keyText += NEIClientUtils.translate(Minecraft.isRunningOnMac ? "key.ctrl.mac" : "key.ctrl") + DELIMITER;
-            }
-            if ((keyBind & NEIClientUtils.SHIFT_HASH) != 0) {
-                keyText += "SHIFT" + DELIMITER;
-            }
-            if ((keyBind & NEIClientUtils.ALT_HASH) != 0) {
-                keyText += "ALT" + DELIMITER;
-            }
-        }
-
-        if (!showOnlyHash) {
-            keyText += Keyboard.getKeyName(unHashKey(keyBind));
-        }
-        return keyText;
-    }
-
-    public static int unHashKey(int keyBind) {
-        return keyBind & ~(NEIClientUtils.CTRL_HASH | NEIClientUtils.SHIFT_HASH | NEIClientUtils.ALT_HASH);
-    }
-
     public static void bootNEI(World world) {
-        if (configLoaded) return;
+        if (configLoaded)
+            return;
 
         ItemInfo.load(world);
         GuiInfo.load();
         RecipeInfo.load();
         LayoutManager.load();
+        ItemPanels.bookmarkPanel.loadBookmarks();
         NEIController.load();
-        RecipeCatalysts.loadCatalystInfo();
 
         configLoaded = true;
 
         new Thread("NEI Plugin Loader") {
-
             @Override
             public void run() {
-                ClassDiscoverer classDiscoverer = new ClassDiscoverer(
-                        test -> test.startsWith("NEI") && test.endsWith("Config.class"),
-                        IConfigureNEI.class);
+                ClassDiscoverer classDiscoverer = new ClassDiscoverer(test -> test.startsWith("NEI") && test.endsWith("Config.class"), IConfigureNEI.class);
 
                 classDiscoverer.findClasses();
 
@@ -498,26 +337,8 @@ 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;
+        if(world == null) return false;
         ConfigTag tag = world.config.getTag(setting, false);
         return tag != null && tag.value != null;
     }
@@ -533,69 +354,23 @@ public class NEIClientConfig {
     public static boolean isHidden() {
         return !enabledOverride || getBooleanSetting("inventory.hidden");
     }
-
     public static boolean isBookmarkPanelHidden() {
         return !getBooleanSetting("inventory.bookmarksEnabled");
     }
-
-    public static boolean useNBTInBookmarks() {
-        return getBooleanSetting("inventory.useNBTInBookmarks");
-    }
-
-    public static boolean areBookmarksAnimated() {
-        return getBooleanSetting("inventory.bookmarksAnimationEnabled");
-    }
-
-    public static boolean showRecipeMarker() {
-        return getBooleanSetting("inventory.showRecipeMarker");
-    }
-
-    public static boolean showItemQuantityWidget() {
-        return getBooleanSetting("inventory.showItemQuantityWidget");
-    }
-
     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");
     }
-
-    public static boolean ignorePotionOverlap() {
-        return getBooleanSetting("inventory.ignore_potion_overlap");
-    }
-
-    public static boolean optimizeGuiOverlapComputation() {
-        return getBooleanSetting("inventory.optimize_gui_overlap_computation");
-    }
-
-    public static boolean useJEIStyledCycledIngredients() {
-        return getBooleanSetting("inventory.jei_style_cycled_ingredients");
-    }
-
-    public static boolean requireShiftForOverlayRecipe() {
-        return getBooleanSetting("inventory.shift_overlay_recipe");
-    }
-
     public static boolean isEnabled() {
         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) {
@@ -611,7 +386,8 @@ public class NEIClientConfig {
     }
 
     private static void checkCheatMode() {
-        if (getLockedMode() != -1) setIntSetting("inventory.cheatmode", getLockedMode());
+        if (getLockedMode() != -1)
+            setIntSetting("inventory.cheatmode", getLockedMode());
     }
 
     public static int getLockedMode() {
@@ -631,10 +407,6 @@ public class NEIClientConfig {
         return i == 2 || (i == 1 && isEnabled() && !isHidden());
     }
 
-    public static int getItemLoadingTimeout() {
-        return getIntSetting("itemLoadingTimeout");
-    }
-
     public static void toggleBooleanSetting(String setting) {
         ConfigTag tag = getSetting(setting);
         tag.setBooleanValue(!tag.getBooleanValue());
@@ -669,11 +441,7 @@ public class NEIClientConfig {
     public static boolean shouldInvertMouseScrollTransfer() {
         return !getBooleanSetting("inventory.invertMouseScrollTransfer");
     }
-
-    public static boolean shouldCacheItemRendering() {
-        return getBooleanSetting("inventory.cacheItemRendering") && OpenGlHelper.framebufferSupported;
-    }
-
+    
     public static boolean getMagnetMode() {
         return enabledActions.contains("magnet");
     }
@@ -703,14 +471,18 @@ public class NEIClientConfig {
     }
 
     public static boolean canPerformAction(String name) {
-        if (!isEnabled()) return false;
+        if (!isEnabled())
+            return false;
 
-        if (!modePermitsAction(name)) return false;
+        if (!modePermitsAction(name))
+            return false;
 
         String base = NEIActions.base(name);
-        if (hasSMPCounterpart) return permissableActions.contains(base);
+        if (hasSMPCounterpart)
+            return permissableActions.contains(base);
 
-        if (NEIActions.smpRequired(name)) return false;
+        if (NEIActions.smpRequired(name))
+            return false;
 
         String cmd = getStringSetting("command." + base);
         return cmd != null && cmd.startsWith("/");
@@ -721,7 +493,9 @@ public class NEIClientConfig {
         if (getCheatMode() == 2) return true;
 
         String[] actions = getStringArrSetting("inventory.utilities");
-        for (String action : actions) if (action.equalsIgnoreCase(name)) return true;
+        for (String action : actions)
+            if (action.equalsIgnoreCase(name))
+                return true;
 
         return false;
     }
@@ -736,7 +510,8 @@ public class NEIClientConfig {
 
     public static void reloadSaves() {
         File saveDir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/local");
-        if (!saveDir.exists()) return;
+        if (!saveDir.exists())
+            return;
 
         List<SaveFormatComparator> saves;
         try {
@@ -746,9 +521,12 @@ public class NEIClientConfig {
             return;
         }
         HashSet<String> saveFileNames = new HashSet<>();
-        for (SaveFormatComparator save : saves) saveFileNames.add(save.getFileName());
+        for (SaveFormatComparator save : saves)
+            saveFileNames.add(save.getFileName());
 
         for (File file : saveDir.listFiles())
-            if (file.isDirectory() && !saveFileNames.contains(file.getName())) ObfuscationRun.deleteDir(file, true);
+            if (file.isDirectory() && !saveFileNames.contains(file.getName()))
+                ObfuscationRun.deleteDir(file, true);
     }
+    
 }

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

@@ -1,68 +1,47 @@
 package codechicken.nei;
 
-import static codechicken.nei.NEIClientConfig.canCheatItem;
-import static codechicken.nei.NEIClientConfig.canPerformAction;
-import static codechicken.nei.NEIClientConfig.getStringArrSetting;
-import static codechicken.nei.NEIClientConfig.getStringSetting;
-import static codechicken.nei.NEIClientConfig.hasSMPCounterPart;
-import static codechicken.nei.NEIClientConfig.invCreativeMode;
-import static codechicken.nei.NEIClientConfig.world;
-
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.math.BigInteger;
-import java.math.RoundingMode;
-import java.text.DecimalFormat;
-import java.text.DecimalFormatSymbols;
-import java.text.MessageFormat;
-import java.text.NumberFormat;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.audio.PositionedSoundRecord;
-import net.minecraft.client.gui.FontRenderer;
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.Container;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.ChatComponentTranslation;
-import net.minecraft.util.EnumChatFormatting;
-import net.minecraft.util.IChatComponent;
-import net.minecraft.util.ResourceLocation;
-
-import org.lwjgl.input.Keyboard;
-
 import codechicken.lib.inventory.InventoryRange;
 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;
+import net.minecraft.client.audio.PositionedSoundRecord;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IChatComponent;
+import net.minecraft.util.ResourceLocation;
+import org.lwjgl.input.Keyboard;
 
-public class NEIClientUtils extends NEIServerUtils {
+import java.text.MessageFormat;
+import java.text.NumberFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
 
+import static codechicken.nei.NEIClientConfig.canCheatItem;
+import static codechicken.nei.NEIClientConfig.canPerformAction;
+import static codechicken.nei.NEIClientConfig.getItemQuantity;
+import static codechicken.nei.NEIClientConfig.getStringArrSetting;
+import static codechicken.nei.NEIClientConfig.getStringSetting;
+import static codechicken.nei.NEIClientConfig.hasSMPCounterPart;
+import static codechicken.nei.NEIClientConfig.invCreativeMode;
+import static codechicken.nei.NEIClientConfig.world;
+
+public class NEIClientUtils extends NEIServerUtils
+{
     public static LangProxy lang = new LangProxy("nei");
 
-    /** Formats a number with group separator and at most 2 fraction digits. */
-    private static final Map<Locale, DecimalFormat> decimalFormatters = new HashMap<>();
-
-    public static final int ALT_HASH = 1 << 27;
-    public static final int SHIFT_HASH = 1 << 26;
-    public static final int CTRL_HASH = 1 << 25;
-
     public static Minecraft mc() {
         return Minecraft.getMinecraft();
     }
@@ -72,33 +51,8 @@ public class NEIClientUtils extends NEIServerUtils {
     }
 
     public static void printChatMessage(IChatComponent msg) {
-        if (mc().ingameGUI != null) mc().ingameGUI.getChatGUI().printChatMessage(msg);
-    }
-
-    private static DecimalFormat getDecimalFormat() {
-        return decimalFormatters.computeIfAbsent(Locale.getDefault(Locale.Category.FORMAT), locale -> {
-            DecimalFormat numberFormat = new DecimalFormat(); // uses the necessary locale inside anyway
-            numberFormat.setGroupingUsed(true);
-            numberFormat.setMaximumFractionDigits(2);
-            numberFormat.setRoundingMode(RoundingMode.HALF_UP);
-            DecimalFormatSymbols decimalFormatSymbols = numberFormat.getDecimalFormatSymbols();
-            decimalFormatSymbols.setGroupingSeparator(','); // Use sensible separator for best clarity.
-            numberFormat.setDecimalFormatSymbols(decimalFormatSymbols);
-
-            return numberFormat;
-        });
-    }
-
-    public static String formatNumbers(BigInteger aNumber) {
-        return getDecimalFormat().format(aNumber);
-    }
-
-    public static String formatNumbers(long aNumber) {
-        return getDecimalFormat().format(aNumber);
-    }
-
-    public static String formatNumbers(double aNumber) {
-        return getDecimalFormat().format(aNumber);
+        if (mc().ingameGUI != null)
+            mc().ingameGUI.getChatGUI().printChatMessage(msg);
     }
 
     public static void deleteHeldItem() {
@@ -106,8 +60,7 @@ public class NEIClientUtils extends NEIServerUtils {
     }
 
     public static void dropHeldItem() {
-        mc().playerController
-                .windowClick(((GuiContainer) mc().currentScreen).inventorySlots.windowId, -999, 0, 0, mc().thePlayer);
+        mc().playerController.windowClick(((GuiContainer) mc().currentScreen).inventorySlots.windowId, -999, 0, 0, mc().thePlayer);
     }
 
     public static void deleteSlotStack(int slotNumber) {
@@ -115,11 +68,12 @@ public class NEIClientUtils extends NEIServerUtils {
     }
 
     public static void decreaseSlotStack(int slotNumber) {
-        ItemStack stack = slotNumber == -999 ? getHeldItem()
-                : mc().thePlayer.openContainer.getSlot(slotNumber).getStack();
-        if (stack == null) return;
+        ItemStack stack = slotNumber == -999 ? getHeldItem() : mc().thePlayer.openContainer.getSlot(slotNumber).getStack();
+        if (stack == null)
+            return;
 
-        if (stack.stackSize == 1) deleteSlotStack(slotNumber);
+        if (stack.stackSize == 1)
+            deleteSlotStack(slotNumber);
         else {
             stack = stack.copy();
             stack.stackSize--;
@@ -135,7 +89,8 @@ public class NEIClientUtils extends NEIServerUtils {
         Container c = getGuiContainer().inventorySlots;
         for (int i = 0; i < c.inventorySlots.size(); i++) {
             Slot slot = c.getSlot(i);
-            if (slot == null) continue;
+            if (slot == null)
+                continue;
 
             ItemStack stack = slot.getStack();
             if (stack != null && stack.getItem() == type.getItem() && stack.getItemDamage() == type.getItemDamage()) {
@@ -152,18 +107,21 @@ public class NEIClientUtils extends NEIServerUtils {
     public static void setSlotContents(int slot, ItemStack item, boolean containerInv) {
         NEICPH.sendSetSlot(slot, item, containerInv);
 
-        if (slot == -999) mc().thePlayer.inventory.setItemStack(item);
+        if (slot == -999)
+            mc().thePlayer.inventory.setItemStack(item);
     }
 
     /**
-     * @param mode -1 = normal cheats, 0 = no infinites, 1 = replenish stack
+     * @param mode      -1 = normal cheats, 0 = no infinites, 1 = replenish stack
      */
     public static void cheatItem(ItemStack stack, int button, int mode) {
-        if (!canCheatItem(stack)) return;
+        if (!canCheatItem(stack))
+            return;
 
         if (mode == -1 && button == 0 && shiftKey() && NEIClientConfig.hasSMPCounterPart()) {
             for (IInfiniteItemHandler handler : ItemInfo.infiniteHandlers) {
-                if (!handler.canHandleItem(stack)) continue;
+                if (!handler.canHandleItem(stack))
+                    continue;
 
                 ItemStack inf = handler.getInfiniteItem(stack);
                 if (inf != null) {
@@ -178,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);
             }
         }
     }
@@ -195,24 +156,22 @@ public class NEIClientUtils extends NEIServerUtils {
         ItemStack stack = copyStack(base, i);
         if (hasSMPCounterPart()) {
             ItemStack typestack = copyStack(stack, 1);
-            if (!infinite && !canItemFitInInventory(mc().thePlayer, stack)
-                    && (mc().currentScreen instanceof GuiContainer)) {
+            if (!infinite && !canItemFitInInventory(mc().thePlayer, stack) && (mc().currentScreen instanceof GuiContainer)) {
                 GuiContainer gui = getGuiContainer();
                 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();
                 }
 
                 int increment = typestack.getMaxStackSize();
                 int given = 0;
-                for (int slotNo : Iterables.concat(handlerSlots)) {
+                for(int slotNo : Iterables.concat(handlerSlots)) {
                     Slot slot = gui.inventorySlots.getSlot(slotNo);
-                    if (!slot.isItemValid(typestack) || !InventoryUtils.canStack(slot.getStack(), typestack)) continue;
+                    if(!slot.isItemValid(typestack) || !InventoryUtils.canStack(slot.getStack(), typestack))
+                        continue;
 
                     int qty = Math.min(stack.stackSize - given, increment);
                     int current = slot.getHasStack() ? slot.getStack().stackSize : 0;
@@ -222,15 +181,17 @@ public class NEIClientUtils extends NEIServerUtils {
                     slot.putStack(newStack);
                     setSlotContents(slotNo, newStack, true);
                     given += qty;
-                    if (given >= stack.stackSize) break;
+                    if(given >= stack.stackSize)
+                        break;
                 }
-                if (given > 0) NEICPH.sendGiveItem(copyStack(typestack, given), false, false);
-            } else NEICPH.sendGiveItem(stack, infinite, true);
+                if(given > 0)
+                    NEICPH.sendGiveItem(copyStack(typestack, given), false, false);
+            } else
+                NEICPH.sendGiveItem(stack, infinite, true);
         } else {
-            for (int given = 0; given < stack.stackSize;) {
+            for (int given = 0; given < stack.stackSize; ) {
                 int qty = Math.min(stack.stackSize - given, stack.getMaxStackSize());
-                sendCommand(
-                        getStringSetting("command.item"),
+                sendCommand(getStringSetting("command.item"),
                         mc().thePlayer.getCommandSenderName(),
                         Item.getIdFromItem(stack.getItem()),
                         qty,
@@ -251,22 +212,24 @@ public class NEIClientUtils extends NEIServerUtils {
     }
 
     public static boolean controlKey() {
-        if (Minecraft.isRunningOnMac) {
-            return Keyboard.isKeyDown(Keyboard.KEY_LMETA) || Keyboard.isKeyDown(Keyboard.KEY_RMETA);
-        }
         return Keyboard.isKeyDown(Keyboard.KEY_LCONTROL) || Keyboard.isKeyDown(Keyboard.KEY_RCONTROL);
     }
 
     public static int getGamemode() {
-        if (invCreativeMode()) return 2;
-        else if (mc().playerController.isInCreativeMode()) return 1;
-        else if (mc().playerController.currentGameType.isAdventure()) return 3;
-        else return 0;
+        if (invCreativeMode())
+            return 2;
+        else if (mc().playerController.isInCreativeMode())
+            return 1;
+        else if (mc().playerController.currentGameType.isAdventure())
+            return 3;
+        else
+            return 0;
     }
 
     public static boolean isValidGamemode(String s) {
-        return s.equals("survival")
-                || canPerformAction(s) && Arrays.asList(getStringArrSetting("inventory.gamemodes")).contains(s);
+        return s.equals("survival") ||
+                canPerformAction(s) &&
+                        Arrays.asList(getStringArrSetting("inventory.gamemodes")).contains(s);
     }
 
     public static int getNextGamemode() {
@@ -274,7 +237,8 @@ public class NEIClientUtils extends NEIServerUtils {
         int nmode = mode;
         while (true) {
             nmode = (nmode + 1) % NEIActions.gameModes.length;
-            if (nmode == mode || isValidGamemode(NEIActions.gameModes[nmode])) break;
+            if (nmode == mode || isValidGamemode(NEIActions.gameModes[nmode]))
+                break;
         }
         return nmode;
     }
@@ -282,13 +246,13 @@ public class NEIClientUtils extends NEIServerUtils {
     public static void cycleGamemode() {
         int mode = getGamemode();
         int nmode = getNextGamemode();
-        if (mode == nmode) return;
+        if (mode == nmode)
+            return;
 
-        if (hasSMPCounterPart()) NEICPH.sendGamemode(nmode);
-        else sendCommand(
-                getStringSetting("command.creative"),
-                getGameType(nmode),
-                mc().thePlayer.getCommandSenderName());
+        if (hasSMPCounterPart())
+            NEICPH.sendGamemode(nmode);
+        else
+            sendCommand(getStringSetting("command.creative"), getGameType(nmode), mc().thePlayer.getCommandSenderName());
     }
 
     public static long getTime() {
@@ -303,18 +267,22 @@ public class NEIClientUtils extends NEIServerUtils {
         long day = (getTime() / 24000L) * 24000L;
         long newTime = day + 24000L + hour * 1000;
 
-        if (hasSMPCounterPart()) NEICPH.sendSetTime(hour);
-        else sendCommand(getStringSetting("command.time"), newTime);
+        if (hasSMPCounterPart())
+            NEICPH.sendSetTime(hour);
+        else
+            sendCommand(getStringSetting("command.time"), newTime);
     }
 
     public static void sendCommand(String command, Object... args) {
-        if (command.length() == 0) return;
+        if (command.length() == 0)
+            return;
 
         NumberFormat numberformat = NumberFormat.getIntegerInstance();
         numberformat.setGroupingUsed(false);
         MessageFormat messageformat = new MessageFormat(command);
-        for (int i = 0; i < args.length; i++) if (args[i] instanceof Integer || args[i] instanceof Long)
-            messageformat.setFormatByArgumentIndex(i, numberformat);
+        for (int i = 0; i < args.length; i++)
+            if (args[i] instanceof Integer || args[i] instanceof Long)
+                messageformat.setFormatByArgumentIndex(i, numberformat);
 
         mc().thePlayer.sendChatMessage(messageformat.format(args));
     }
@@ -324,17 +292,22 @@ public class NEIClientUtils extends NEIServerUtils {
     }
 
     public static void toggleRaining() {
-        if (hasSMPCounterPart()) NEICPH.sendToggleRain();
-        else sendCommand(getStringSetting("command.rain"), isRaining() ? 0 : 1);
+        if (hasSMPCounterPart())
+            NEICPH.sendToggleRain();
+        else
+            sendCommand(getStringSetting("command.rain"), isRaining() ? 0 : 1);
     }
 
     public static void healPlayer() {
-        if (hasSMPCounterPart()) NEICPH.sendHeal();
-        else sendCommand(getStringSetting("command.heal"), mc().thePlayer.getCommandSenderName());
+        if (hasSMPCounterPart())
+            NEICPH.sendHeal();
+        else
+            sendCommand(getStringSetting("command.heal"), mc().thePlayer.getCommandSenderName());
     }
 
     public static void toggleMagnetMode() {
-        if (hasSMPCounterPart()) NEICPH.sendToggleMagnetMode();
+        if (hasSMPCounterPart())
+            NEICPH.sendToggleMagnetMode();
     }
 
     public static ArrayList<int[]> concatIntegersToRanges(List<Integer> damages) {
@@ -350,40 +323,24 @@ public class NEIClientUtils extends NEIServerUtils {
                 continue;
             }
             if (next + 1 != i) {
-                ranges.add(new int[] { start, next });
+                ranges.add(new int[]{start, next});
                 start = next = i;
                 continue;
             }
             next = i;
         }
-        ranges.add(new int[] { start, next });
+        ranges.add(new int[]{start, next});
         return ranges;
     }
 
     public static ArrayList<int[]> addIntegersToRanges(List<int[]> ranges, List<Integer> damages) {
-        for (int[] range : ranges) for (int integer = range[0]; integer <= range[1]; integer++) damages.add(integer);
+        for (int[] range : ranges)
+            for (int integer = range[0]; integer <= range[1]; integer++)
+                damages.add(integer);
 
         return concatIntegersToRanges(damages);
     }
 
-    public static String cropText(FontRenderer fontRenderer, String text, int containerWidth) {
-
-        int textWidth = fontRenderer.getStringWidth(text);
-
-        if (textWidth > containerWidth) {
-            textWidth += fontRenderer.getStringWidth("...");
-
-            while (textWidth > containerWidth) {
-                textWidth -= fontRenderer.getCharWidth(text.charAt(text.length() - 1));
-                text = text.substring(0, text.length() - 1);
-            }
-
-            return text + "...";
-        }
-
-        return text;
-    }
-
     public static boolean safeKeyDown(int keyCode) {
         try {
             return Keyboard.isKeyDown(keyCode);
@@ -398,7 +355,8 @@ public class NEIClientUtils extends NEIServerUtils {
     }
 
     public static GuiContainer getGuiContainer() {
-        if (mc().currentScreen instanceof GuiContainer) return (GuiContainer) mc().currentScreen;
+        if (mc().currentScreen instanceof GuiContainer)
+            return (GuiContainer) mc().currentScreen;
 
         return null;
     }
@@ -407,73 +365,7 @@ public class NEIClientUtils extends NEIServerUtils {
         return Keyboard.isKeyDown(Keyboard.KEY_LMENU) || Keyboard.isKeyDown(Keyboard.KEY_RMENU);
     }
 
-    public static int getMetaHash() {
-        if (Keyboard.getEventKeyState()) {
-            int hash = 0;
-
-            if (altKey()) {
-                hash = hash | ALT_HASH;
-            }
-
-            if (shiftKey()) {
-                hash = hash | SHIFT_HASH;
-            }
-
-            if (controlKey()) {
-                hash = hash | CTRL_HASH;
-            }
-
-            return hash;
-        }
-
-        return 0;
-    }
-
-    public static int getKeyHash() {
-
-        if (Keyboard.getEventKeyState()) {
-            final int keycode = Keyboard.getEventKey();
-
-            if (keycode != Keyboard.KEY_LSHIFT && keycode != Keyboard.KEY_RSHIFT
-                    && keycode != Keyboard.KEY_LCONTROL
-                    && keycode != Keyboard.KEY_RCONTROL
-                    && keycode != Keyboard.KEY_LMENU
-                    && keycode != Keyboard.KEY_RMENU) {
-                return getMetaHash() + keycode;
-            }
-        }
-
-        return Keyboard.CHAR_NONE;
-    }
-
     public static void playClickSound() {
-        mc().getSoundHandler()
-                .playSound(PositionedSoundRecord.func_147674_a(new ResourceLocation("gui.button.press"), 1.0F));
-    }
-
-    public static void reportErrorBuffered(Throwable e, Set<String> buffer, String cause) {
-        StringWriter sw = new StringWriter();
-        e.printStackTrace(new PrintWriter(sw));
-        String stackTrace = cause + sw;
-        if (buffer.contains(stackTrace)) return;
-
-        System.err.println("Error while rendering: " + cause);
-        e.printStackTrace();
-        buffer.add(stackTrace);
-
-        EntityPlayer player = Minecraft.getMinecraft().thePlayer;
-        if (player != null) {
-            IChatComponent chat = new ChatComponentTranslation("nei.chat.render.error");
-            chat.getChatStyle().setColor(EnumChatFormatting.RED);
-            player.addChatComponentMessage(chat);
-        }
-    }
-
-    public static void reportErrorBuffered(Throwable e, Set<String> buffer, ItemStack cause) {
-        if (cause != null) {
-            reportErrorBuffered(e, buffer, cause.toString());
-        } else {
-            reportErrorBuffered(e, buffer, "null");
-        }
+        mc().getSoundHandler().playSound(PositionedSoundRecord.func_147674_a(new ResourceLocation("gui.button.press"), 1.0F));
     }
 }

src/main/java/codechicken/nei/NEICompatibility.java

@@ -1,4 +1,5 @@
 package codechicken.nei;
 
-public class NEICompatibility {
+public class NEICompatibility
+{    
 }

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

@@ -1,17 +1,5 @@
 package codechicken.nei;
 
-import static codechicken.lib.gui.GuiDraw.getMousePosition;
-
-import java.awt.Point;
-import java.util.LinkedList;
-
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.client.gui.inventory.GuiContainerCreative;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Slot;
-import net.minecraft.inventory.SlotCrafting;
-import net.minecraft.item.ItemStack;
-
 import codechicken.nei.api.API;
 import codechicken.nei.api.GuiInfo;
 import codechicken.nei.api.IInfiniteItemHandler;
@@ -20,10 +8,20 @@ import codechicken.nei.api.ItemInfo;
 import codechicken.nei.guihook.GuiContainerManager;
 import codechicken.nei.guihook.IContainerInputHandler;
 import codechicken.nei.guihook.IContainerSlotClickHandler;
-import codechicken.nei.recipe.GuiRecipe;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.client.gui.inventory.GuiContainerCreative;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Slot;
+import net.minecraft.inventory.SlotCrafting;
+import net.minecraft.item.ItemStack;
 
-public class NEIController implements IContainerSlotClickHandler, IContainerInputHandler {
+import java.awt.Point;
+import java.util.LinkedList;
 
+import static codechicken.lib.gui.GuiDraw.getMousePosition;
+
+public class NEIController implements IContainerSlotClickHandler, IContainerInputHandler
+{
     private static final NEIController instance = new NEIController();
 
     public static GuiContainerManager manager;
@@ -46,10 +44,12 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
         deleteMode = false;
         GuiInfo.clearGuiHandlers();
         fastTransferManager = null;
-        if (!NEIClientConfig.isEnabled()) return;
+        if (!NEIClientConfig.isEnabled())
+            return;
 
         fastTransferManager = new FastTransferManager();
-        if (gui instanceof INEIGuiHandler) API.registerNEIGuiHandler((INEIGuiHandler) gui);
+        if (gui instanceof INEIGuiHandler)
+            API.registerNEIGuiHandler((INEIGuiHandler) gui);
     }
 
     public static boolean isSpreading(GuiContainer gui) {
@@ -57,7 +57,8 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
     }
 
     public static void updateUnlimitedItems(InventoryPlayer inventory) {
-        if (!NEIClientConfig.canPerformAction("item") || !NEIClientConfig.hasSMPCounterPart()) return;
+        if (!NEIClientConfig.canPerformAction("item") || !NEIClientConfig.hasSMPCounterPart())
+            return;
 
         LinkedList<ItemStack> beforeStacks = new LinkedList<>();
         for (int i = 0; i < inventory.getSizeInventory(); i++)
@@ -65,7 +66,8 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
 
         for (int i = 0; i < inventory.getSizeInventory(); i++) {
             ItemStack stack = inventory.getStackInSlot(i);
-            if (stack == null) continue;
+            if (stack == null)
+                continue;
 
             for (IInfiniteItemHandler handler : ItemInfo.infiniteHandlers)
                 if (handler.canHandleItem(stack) && handler.isItemInfinite(stack))
@@ -76,8 +78,8 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
             ItemStack newstack = inventory.getStackInSlot(i);
 
             if (!NEIServerUtils.areStacksIdentical(beforeStacks.get(i), newstack)) {
-                inventory.setInventorySlotContents(i, beforeStacks.get(i)); // restore in case of SMP fail
-                NEIClientUtils.setSlotContents(i, newstack, false); // sends via SMP handler ;)
+                inventory.setInventorySlotContents(i, beforeStacks.get(i));//restore in case of SMP fail
+                NEIClientUtils.setSlotContents(i, newstack, false);//sends via SMP handler ;)
             }
         }
     }
@@ -85,15 +87,14 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
     public static void processCreativeCycling(InventoryPlayer inventory) {
         if (NEIClientConfig.invCreativeMode() && NEIClientUtils.controlKey()) {
             if (selectedItem != inventory.currentItem) {
-                if (inventory.currentItem == selectedItem + 1 || (inventory.currentItem == 0 && selectedItem == 8)) // foward
+                if (inventory.currentItem == selectedItem + 1 || (inventory.currentItem == 0 && selectedItem == 8))//foward
                 {
                     NEICPH.sendCreativeScroll(1);
                     inventory.currentItem = selectedItem;
-                } else if (inventory.currentItem == selectedItem - 1
-                        || (inventory.currentItem == 8 && selectedItem == 0)) {
-                            NEICPH.sendCreativeScroll(-1);
-                            inventory.currentItem = selectedItem;
-                        }
+                } else if (inventory.currentItem == selectedItem - 1 || (inventory.currentItem == 8 && selectedItem == 0)) {
+                    NEICPH.sendCreativeScroll(-1);
+                    inventory.currentItem = selectedItem;
+                }
             }
         }
 
@@ -102,47 +103,50 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
 
     @Override
     public void beforeSlotClick(GuiContainer gui, int slotIndex, int button, Slot slot, int modifier) {
-        if (!NEIClientConfig.isEnabled()) return;
+        if (!NEIClientConfig.isEnabled())
+            return;
 
         firstheld = NEIClientUtils.getHeldItem();
     }
 
     @Override
-    public boolean handleSlotClick(GuiContainer gui, int slotIndex, int button, Slot slot, int modifier,
-            boolean eventconsumed) {
-        if (eventconsumed || !NEIClientConfig.isEnabled() || isSpreading(gui)) return eventconsumed;
+    public boolean handleSlotClick(GuiContainer gui, int slotIndex, int button, Slot slot, int modifier, boolean eventconsumed) {
+        if (eventconsumed ||
+                !NEIClientConfig.isEnabled() ||
+                isSpreading(gui))
+            return eventconsumed;
 
         if (deleteMode && slotIndex >= 0 && slot != null) {
             if (NEIClientUtils.shiftKey() && button == 0) {
                 ItemStack itemstack1 = slot.getStack();
-                if (itemstack1 != null) NEIClientUtils.deleteItemsOfType(itemstack1);
+                if (itemstack1 != null)
+                    NEIClientUtils.deleteItemsOfType(itemstack1);
 
-            } else if (button == 1) NEIClientUtils.decreaseSlotStack(slot.slotNumber);
-            else NEIClientUtils.deleteSlotStack(slot.slotNumber);
+            } else if (button == 1)
+                NEIClientUtils.decreaseSlotStack(slot.slotNumber);
+            else
+                NEIClientUtils.deleteSlotStack(slot.slotNumber);
             return true;
         }
 
-        if (button == 1 && slot instanceof SlotCrafting) // right click
+        if (button == 1 && slot instanceof SlotCrafting)//right click
         {
-            for (int i1 = 0; i1 < 64; i1++) // click this slot 64 times
+            for (int i1 = 0; i1 < 64; i1++)//click this slot 64 times
                 manager.handleSlotClick(slot.slotNumber, button, 0);
             return true;
         }
 
-        if (NEIClientUtils.controlKey() && modifier != 4 // Drop key pressed:
-                                                         // net.minecraft.client.gui.inventory.GuiContainer.keyTyped
-                && slot != null
-                && slot.getStack() != null
+        if (NEIClientUtils.controlKey()
+                && slot != null && slot.getStack() != null
                 && slot.isItemValid(slot.getStack())) {
             NEIClientUtils.cheatItem(slot.getStack(), button, 1);
             return true;
         }
 
-        if (GuiInfo.hasCustomSlots(gui)) return false;
+        if(GuiInfo.hasCustomSlots(gui))
+            return false;
 
-        if (slotIndex >= 0 && NEIClientUtils.shiftKey()
-                && NEIClientUtils.getHeldItem() != null
-                && !slot.getHasStack()) {
+        if (slotIndex >= 0 && NEIClientUtils.shiftKey() && NEIClientUtils.getHeldItem() != null && !slot.getHasStack()) {
             ItemStack held = NEIClientUtils.getHeldItem();
             manager.handleSlotClick(slot.slotNumber, button, 0);
             if (slot.isItemValid(held) && !ItemInfo.fastTransferExemptions.contains(slot.getClass()))
@@ -161,15 +165,16 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
 
     @Override
     public void afterSlotClick(GuiContainer gui, int slotIndex, int button, Slot slot, int modifier) {
-        if (!NEIClientConfig.isEnabled()) return;
+        if (!NEIClientConfig.isEnabled())
+            return;
 
         ItemStack nowHeld = NEIClientUtils.getHeldItem();
 
-        if (firstheld != nowHeld) pickedUpFromSlot = slotIndex;
+        if (firstheld != nowHeld)
+            pickedUpFromSlot = slotIndex;
 
         if (NEIClientConfig.canPerformAction("item") && NEIClientConfig.hasSMPCounterPart()) {
-            if (heldStackInfinite != null && slot != null
-                    && slot.inventory == NEIClientUtils.mc().thePlayer.inventory) {
+            if (heldStackInfinite != null && slot != null && slot.inventory == NEIClientUtils.mc().thePlayer.inventory) {
                 ItemStack stack = slot.getStack();
                 if (stack != null) {
                     heldStackInfinite.onPlaceInfinite(stack);
@@ -177,7 +182,8 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
                 NEIClientUtils.setSlotContents(slotIndex, stack, true);
             }
 
-            if (firstheld != nowHeld) heldStackInfinite = null;
+            if (firstheld != nowHeld)
+                heldStackInfinite = null;
 
             if (firstheld != nowHeld && nowHeld != null) {
                 for (IInfiniteItemHandler handler : ItemInfo.infiniteHandlers) {
@@ -194,10 +200,14 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
 
     @Override
     public boolean lastKeyTyped(GuiContainer gui, char keyChar, int keyCode) {
-        if (!NEIClientConfig.isEnabled() || GuiInfo.hasCustomSlots(gui) || isSpreading(gui)) return false;
+        if (!NEIClientConfig.isEnabled() ||
+                GuiInfo.hasCustomSlots(gui) ||
+                isSpreading(gui))
+            return false;
 
         Slot slot = GuiContainerManager.getSlotMouseOver(gui);
-        if (slot == null) return false;
+        if (slot == null)
+            return false;
 
         int slotIndex = slot.slotNumber;
 
@@ -214,22 +224,19 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
 
     @Override
     public boolean mouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {
-        if (!NEIClientConfig.isEnabled() || GuiInfo.hasCustomSlots(gui)
-                || !NEIClientConfig.isMouseScrollTransferEnabled())
+        if (!NEIClientConfig.isEnabled() || GuiInfo.hasCustomSlots(gui) || !NEIClientConfig.isMouseScrollTransferEnabled())
             return false;
 
-        // slot in GuiRecipe does not contain actual stack
-        // and scroll should be handled by GuiRecipe, not here
-        if (gui instanceof GuiRecipe) return false;
-
         Point mousePos = getMousePosition();
         Slot mouseover = manager.window.getSlotAtPosition(mousePos.x, mousePos.y);
         if (mouseover != null && mouseover.getHasStack()) {
-            if (NEIClientConfig.shouldInvertMouseScrollTransfer()) {
+            if(NEIClientConfig.shouldInvertMouseScrollTransfer()) {
                 scrolled = -scrolled;
             }
-            if (scrolled > 0) fastTransferManager.transferItem(manager.window, mouseover.slotNumber);
-            else fastTransferManager.retrieveItem(manager.window, mouseover.slotNumber);
+            if (scrolled > 0)
+                fastTransferManager.transferItem(manager.window, mouseover.slotNumber);
+            else
+                fastTransferManager.retrieveItem(manager.window, mouseover.slotNumber);
             return true;
         }
         return false;
@@ -246,26 +253,32 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
     }
 
     @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 onMouseDragged(GuiContainer gui, int mousex, int mousey, int button, long heldTime) {}
+    public void onMouseDragged(GuiContainer gui, int mousex, int mousey, int button, long heldTime) {
+    }
 
     @Override
-    public void onMouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {}
+    public void onMouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {
+    }
 
     @Override
-    public void onMouseUp(GuiContainer gui, int mousex, int mousey, int button) {}
+    public void onMouseUp(GuiContainer gui, int mousex, int mousey, int button) {
+    }
 
     public static boolean canUseDeleteMode() {
         return !(NEIClientUtils.getGuiContainer() instanceof GuiContainerCreative);
     }
 
     public static void toggleDeleteMode() {
-        if (canUseDeleteMode()) deleteMode = !deleteMode;
+        if(canUseDeleteMode())
+            deleteMode = !deleteMode;
     }
 
     public static boolean getDeleteMode() {

src/main/java/codechicken/nei/NEICreativeGuiHandler.java

@@ -1,20 +1,22 @@
 package codechicken.nei;
 
+import codechicken.nei.api.INEIGuiAdapter;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.client.gui.inventory.GuiContainerCreative;
 import net.minecraft.creativetab.CreativeTabs;
 
-import codechicken.nei.api.INEIGuiAdapter;
-
-public class NEICreativeGuiHandler extends INEIGuiAdapter {
-
+public class NEICreativeGuiHandler extends INEIGuiAdapter
+{
     @Override
-    public VisiblityData modifyVisiblity(GuiContainer gui, VisiblityData currentVisibility) {
-        if (!(gui instanceof GuiContainerCreative)) return currentVisibility;
-
-        if (((GuiContainerCreative) gui).func_147056_g() != CreativeTabs.tabInventory.getTabIndex())
+    public VisiblityData modifyVisiblity(GuiContainer gui, VisiblityData currentVisibility)
+    {
+        if(!(gui instanceof GuiContainerCreative))
+            return currentVisibility;
+        
+        if(((GuiContainerCreative)gui).func_147056_g() != CreativeTabs.tabInventory.getTabIndex())
             currentVisibility.showItemSection = currentVisibility.enableDeleteMode = false;
 
         return currentVisibility;
     }
+
 }

src/main/java/codechicken/nei/NEIDummySlotHandler.java

@@ -1,21 +1,21 @@
 package codechicken.nei;
 
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-
 import codechicken.lib.inventory.ContainerExtended;
 import codechicken.lib.inventory.SlotDummy;
 import codechicken.nei.api.INEIGuiAdapter;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
 
-public class NEIDummySlotHandler extends INEIGuiAdapter {
-
+public class NEIDummySlotHandler extends INEIGuiAdapter
+{
     @Override
-    public boolean handleDragNDrop(GuiContainer gui, int mousex, int mousey, ItemStack draggedStack, int button) {
+    public boolean handleDragNDrop(GuiContainer gui, int mousex, int mousey, ItemStack draggedStack, int button)
+    {
         Slot slot = gui.getSlotAtPosition(mousex, mousey);
-        if (slot instanceof SlotDummy && slot.isItemValid(draggedStack)
-                && gui.inventorySlots instanceof ContainerExtended) {
-            ((SlotDummy) slot).slotClick(draggedStack, button, NEIClientUtils.shiftKey());
+        if(slot instanceof SlotDummy && slot.isItemValid(draggedStack) && gui.inventorySlots instanceof ContainerExtended)
+        {
+            ((SlotDummy)slot).slotClick(draggedStack, button, NEIClientUtils.shiftKey());
             NEICPH.sendDummySlotSet(slot.slotNumber, slot.getStack());
             return true;
         }

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

@@ -1,25 +1,18 @@
 package codechicken.nei;
 
-import java.io.File;
-import java.util.*;
-
-import net.minecraft.util.EnumChatFormatting;
-
 import codechicken.core.CommonUtils;
 import codechicken.core.launch.CodeChickenCorePlugin;
 import codechicken.nei.api.IConfigureNEI;
 import codechicken.nei.asm.NEICorePlugin;
 import codechicken.nei.config.IMCHandler;
 import codechicken.nei.recipe.GuiRecipeTab;
-
 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;
@@ -28,13 +21,18 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import cpw.mods.fml.common.versioning.ArtifactVersion;
 import cpw.mods.fml.common.versioning.VersionParser;
 import cpw.mods.fml.common.versioning.VersionRange;
+import net.minecraft.util.EnumChatFormatting;
 
-public class NEIModContainer extends DummyModContainer {
+import java.io.File;
+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();
@@ -42,23 +40,16 @@ public class NEIModContainer extends DummyModContainer {
 
     private static ModMetadata getModMetadata() {
         final ModMetadata modMetadata = new ModMetadata();
-        modMetadata.name = "NotEnoughItems";
-        modMetadata.modId = "NotEnoughItems";
-        modMetadata.version = Tags.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.";
+        modMetadata.name = "GRADLETOKEN_MODNAME";
+        modMetadata.modId = "GRADLETOKEN_MODID";
+        modMetadata.version = "GRADLETOKEN_VERSION";
         return modMetadata;
     }
 
-    public static boolean isGT5Loaded() {
-        return gregTech5Loaded;
-    }
-
     @Override
     public Set<ArtifactVersion> getRequirements() {
         Set<ArtifactVersion> deps = new HashSet<>();
-        deps.add(VersionParser.parseVersionReference("CodeChickenCore@[" + CodeChickenCorePlugin.version + ",)"));
+        deps.add(VersionParser.parseVersionReference("CodeChickenCore@["+CodeChickenCorePlugin.version+",)"));
         return deps;
     }
 
@@ -68,9 +59,8 @@ public class NEIModContainer extends DummyModContainer {
     }
 
     private String description;
-
     private void loadMetadata() {
-        description = super.getMetadata().description.replace("Supporters:", EnumChatFormatting.AQUA + "Supporters:");
+        description = super.getMetadata().description.replace("Supporters:", EnumChatFormatting.AQUA+"Supporters:");
     }
 
     @Override
@@ -81,7 +71,8 @@ public class NEIModContainer extends DummyModContainer {
         } else {
             s_plugins.append(EnumChatFormatting.GREEN).append("Installed plugins: ");
             for (int i = 0; i < plugins.size(); i++) {
-                if (i > 0) s_plugins.append(", ");
+                if (i > 0)
+                    s_plugins.append(", ");
                 IConfigureNEI plugin = plugins.get(i);
                 s_plugins.append(plugin.getName()).append(" ").append(plugin.getVersion());
             }
@@ -101,17 +92,17 @@ public class NEIModContainer extends DummyModContainer {
 
     @Subscribe
     public void preInit(FMLPreInitializationEvent event) {
-        gregTech5Loaded = Loader.isModLoaded("gregtech") && !Loader.isModLoaded("gregapi_post");
-        if (CommonUtils.isClient()) ClientHandler.preInit();
+        if (CommonUtils.isClient())
+            ClientHandler.preInit();
     }
 
     @Subscribe
     public void init(FMLInitializationEvent event) {
-        if (CommonUtils.isClient()) ClientHandler.load();
+        if (CommonUtils.isClient())
+            ClientHandler.load();
 
         ServerHandler.load();
     }
-
     @Subscribe
     public void postInit(FMLPostInitializationEvent event) {
         if (CommonUtils.isClient()) {

src/main/java/codechicken/nei/NEIPotionGuiHandler.java

@@ -1,53 +0,0 @@
-package codechicken.nei;
-
-import java.util.Collection;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.entity.EntityPlayerSP;
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.client.renderer.InventoryEffectRenderer;
-import net.minecraft.potion.PotionEffect;
-
-import codechicken.lib.vec.Rectangle4i;
-import codechicken.nei.api.INEIGuiAdapter;
-
-/**
- * Inspired by InventoryEffectRendererGuiHandler.java in JEI
- */
-public class NEIPotionGuiHandler extends INEIGuiAdapter {
-
-    @Override
-    public boolean hideItemPanelSlot(GuiContainer guiContainer, int slotX, int slotY, int slotW, int slotH) {
-        if (NEIClientConfig.ignorePotionOverlap()) {
-            return false;
-        }
-
-        if (guiContainer instanceof InventoryEffectRenderer) {
-            int x = guiContainer.guiLeft - 124;
-            int y = guiContainer.guiTop;
-            Minecraft minecraft = guiContainer.mc;
-            if (minecraft == null) {
-                return false;
-            }
-            EntityPlayerSP player = minecraft.thePlayer;
-            if (player == null) {
-                return false;
-            }
-            Collection<PotionEffect> activePotionEffects = player.getActivePotionEffects();
-            if (activePotionEffects.isEmpty()) {
-                return false;
-            }
-            int height = 33;
-            if (activePotionEffects.size() > 5) {
-                height = 132 / (activePotionEffects.size() - 1);
-            }
-            Rectangle4i slotRect = new Rectangle4i(slotX, slotY, slotW, slotH);
-            for (PotionEffect potioneffect : activePotionEffects) {
-                Rectangle4i box = new Rectangle4i(x, y, 140, 32);
-                if (box.intersects(slotRect)) return true;
-                y += height;
-            }
-        }
-        return false;
-    }
-}

src/main/java/codechicken/nei/NEISPH.java

@@ -1,8 +1,12 @@
 package codechicken.nei;
 
-import java.util.LinkedList;
-import java.util.Set;
-
+import codechicken.core.CommonUtils;
+import codechicken.core.ServerUtils;
+import codechicken.lib.inventory.SlotDummy;
+import codechicken.lib.packet.PacketCustom;
+import codechicken.lib.packet.PacketCustom.IServerPacketHandler;
+import codechicken.lib.vec.BlockCoord;
+import cpw.mods.fml.relauncher.Side;
 import net.minecraft.entity.item.EntityItem;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.inventory.InventoryBasic;
@@ -13,19 +17,15 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraft.tileentity.TileEntityMobSpawner;
 import net.minecraft.world.World;
 
-import codechicken.core.CommonUtils;
-import codechicken.core.ServerUtils;
-import codechicken.lib.inventory.SlotDummy;
-import codechicken.lib.packet.PacketCustom;
-import codechicken.lib.packet.PacketCustom.IServerPacketHandler;
-import codechicken.lib.vec.BlockCoord;
-import cpw.mods.fml.relauncher.Side;
-
-public class NEISPH implements IServerPacketHandler {
+import java.util.LinkedList;
+import java.util.Set;
 
+public class NEISPH implements IServerPacketHandler
+{
     @Override
     public void handlePacket(PacketCustom packet, EntityPlayerMP sender, INetHandlerPlayServer netHandler) {
-        if (!NEIServerConfig.authenticatePacket(sender, packet)) return;
+        if (!NEIServerConfig.authenticatePacket(sender, packet))
+            return;
 
         switch (packet.getType()) {
             case 1:
@@ -67,9 +67,6 @@ public class NEISPH implements IServerPacketHandler {
             case 15:
                 handleMobSpawnerID(sender.worldObj, packet.readCoord(), packet.readString());
                 break;
-            case 16:
-                handleRequestContainer(sender, packet.readInt());
-                break;
             case 21:
                 openEnchantmentGui(sender);
                 break;
@@ -93,7 +90,8 @@ public class NEISPH implements IServerPacketHandler {
         ItemStack stack = packet.readItemStack(true);
 
         Slot slot = sender.openContainer.getSlot(slotNumber);
-        if (slot instanceof SlotDummy) slot.putStack(stack);
+        if (slot instanceof SlotDummy)
+            slot.putStack(stack);
     }
 
     private void handleMobSpawnerID(World world, BlockCoord coord, String mobtype) {
@@ -105,11 +103,6 @@ public class NEISPH implements IServerPacketHandler {
         }
     }
 
-    private void handleRequestContainer(EntityPlayerMP sender, int containerSize) {
-        if (sender.openContainer.getInventory().size() != containerSize) return;
-        sender.sendContainerToPlayer(sender.openContainer);
-    }
-
     private void handlePropertyChange(EntityPlayerMP sender, PacketCustom packet) {
         String name = packet.readString();
         if (NEIServerConfig.canPlayerPerformAction(sender.getCommandSenderName(), name))
@@ -118,19 +111,12 @@ public class NEISPH implements IServerPacketHandler {
 
     public static void processCreativeInv(EntityPlayerMP sender, boolean open) {
         if (open) {
-            ServerUtils.openSMPContainer(
-                    sender,
-                    new ContainerCreativeInv(
-                            sender,
-                            new ExtendedCreativeInv(
-                                    NEIServerConfig.forPlayer(sender.getCommandSenderName()),
-                                    Side.SERVER)),
-                    (player, windowId) -> {
-                        PacketCustom packet = new PacketCustom(channel, 23);
-                        packet.writeBoolean(true);
-                        packet.writeByte(windowId);
-                        packet.sendToPlayer(player);
-                    });
+            ServerUtils.openSMPContainer(sender, new ContainerCreativeInv(sender, new ExtendedCreativeInv(NEIServerConfig.forPlayer(sender.getCommandSenderName()), Side.SERVER)), (player, windowId) -> {
+                PacketCustom packet = new PacketCustom(channel, 23);
+                packet.writeBoolean(true);
+                packet.writeByte(windowId);
+                packet.sendToPlayer(player);
+            });
         } else {
             sender.closeContainer();
             PacketCustom packet = new PacketCustom(channel, 23);
@@ -149,8 +135,7 @@ public class NEISPH implements IServerPacketHandler {
         ItemStack item = packet.readItemStack();
 
         ItemStack old = NEIServerUtils.getSlotContents(player, slot, container);
-        boolean deleting = item == null
-                || old != null && NEIServerUtils.areStacksSameType(item, old) && item.stackSize < old.stackSize;
+        boolean deleting = item == null || old != null && NEIServerUtils.areStacksSameType(item, old) && item.stackSize < old.stackSize;
         if (NEIServerConfig.canPlayerPerformAction(player.getCommandSenderName(), deleting ? "delete" : "item"))
             NEIServerUtils.setSlotContents(player, slot, item, container);
     }
@@ -165,19 +150,17 @@ public class NEISPH implements IServerPacketHandler {
     }
 
     private void openEnchantmentGui(EntityPlayerMP player) {
-        ServerUtils.openSMPContainer(
-                player,
-                new ContainerEnchantmentModifier(player.inventory, player.worldObj, 0, 0, 0),
-                (player1, windowId) -> {
-                    PacketCustom packet = new PacketCustom(channel, 21);
-                    packet.writeByte(windowId);
-                    packet.sendToPlayer(player1);
-                });
+        ServerUtils.openSMPContainer(player, new ContainerEnchantmentModifier(player.inventory, player.worldObj, 0, 0, 0), (player1, windowId) -> {
+            PacketCustom packet = new PacketCustom(channel, 21);
+            packet.writeByte(windowId);
+            packet.sendToPlayer(player1);
+        });
     }
 
     private void openPotionGui(EntityPlayerMP player, PacketCustom packet) {
         InventoryBasic b = new InventoryBasic("potionStore", true, 9);
-        for (int i = 0; i < b.getSizeInventory(); i++) b.setInventorySlotContents(i, packet.readItemStack());
+        for (int i = 0; i < b.getSizeInventory(); i++)
+            b.setInventorySlotContents(i, packet.readItemStack());
         ServerUtils.openSMPContainer(player, new ContainerPotionCreator(player.inventory, b), (player1, windowId) -> {
             PacketCustom packet1 = new PacketCustom(channel, 24);
             packet1.writeByte(windowId);
@@ -186,11 +169,17 @@ public class NEISPH implements IServerPacketHandler {
     }
 
     public static void sendActionDisabled(int dim, String name, boolean disable) {
-        new PacketCustom(channel, 11).writeString(name).writeBoolean(disable).sendToDimension(dim);
+        new PacketCustom(channel, 11)
+                .writeString(name)
+                .writeBoolean(disable)
+                .sendToDimension(dim);
     }
 
     public static void sendActionEnabled(EntityPlayerMP player, String name, boolean enable) {
-        new PacketCustom(channel, 12).writeString(name).writeBoolean(enable).sendToPlayer(player);
+        new PacketCustom(channel, 12)
+                .writeString(name)
+                .writeBoolean(enable)
+                .sendToPlayer(player);
     }
 
     private void sendLoginState(EntityPlayerMP player) {
@@ -201,9 +190,12 @@ public class NEISPH implements IServerPacketHandler {
         PlayerSave playerSave = NEIServerConfig.forPlayer(player.getCommandSenderName());
 
         for (String name : NEIActions.nameActionMap.keySet()) {
-            if (NEIServerConfig.canPlayerPerformAction(player.getCommandSenderName(), name)) actions.add(name);
-            if (NEIServerConfig.isActionDisabled(player.dimension, name)) disabled.add(name);
-            if (playerSave.isActionEnabled(name)) enabled.add(name);
+            if (NEIServerConfig.canPlayerPerformAction(player.getCommandSenderName(), name))
+                actions.add(name);
+            if (NEIServerConfig.isActionDisabled(player.dimension, name))
+                disabled.add(name);
+            if (playerSave.isActionEnabled(name))
+                enabled.add(name);
         }
         for (ItemStackMap.Entry<Set<String>> entry : NEIServerConfig.bannedItems.entries())
             if (!NEIServerConfig.isPlayerInList(player.getCommandSenderName(), entry.value, true))
@@ -212,16 +204,20 @@ public class NEISPH implements IServerPacketHandler {
         PacketCustom packet = new PacketCustom(channel, 10);
 
         packet.writeByte(actions.size());
-        for (String s : actions) packet.writeString(s);
+        for (String s : actions)
+            packet.writeString(s);
 
         packet.writeByte(disabled.size());
-        for (String s : disabled) packet.writeString(s);
+        for (String s : disabled)
+            packet.writeString(s);
 
         packet.writeByte(enabled.size());
-        for (String s : enabled) packet.writeString(s);
+        for (String s : enabled)
+            packet.writeString(s);
 
         packet.writeInt(bannedItems.size());
-        for (ItemStack stack : bannedItems) packet.writeItemStack(stack);
+        for (ItemStack stack : bannedItems)
+            packet.writeItemStack(stack);
 
         packet.sendToPlayer(player);
     }

src/main/java/codechicken/nei/NEIServerConfig.java

@@ -1,5 +1,23 @@
 package codechicken.nei;
 
+import codechicken.core.CommonUtils;
+import codechicken.core.ServerUtils;
+import codechicken.lib.config.ConfigFile;
+import codechicken.lib.inventory.InventoryUtils;
+import codechicken.lib.packet.PacketCustom;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.JsonToNBT;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.World;
+import net.minecraftforge.common.DimensionManager;
+import org.apache.commons.io.IOUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
 import java.io.File;
 import java.io.FileReader;
 import java.io.PrintWriter;
@@ -12,29 +30,8 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.init.Blocks;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.JsonToNBT;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.world.World;
-import net.minecraftforge.common.DimensionManager;
-
-import org.apache.commons.io.FileUtils;
-import org.apache.commons.io.IOUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import codechicken.core.CommonUtils;
-import codechicken.core.ServerUtils;
-import codechicken.lib.config.ConfigFile;
-import codechicken.lib.inventory.InventoryUtils;
-import codechicken.lib.packet.PacketCustom;
-
-public class NEIServerConfig {
-
+public class NEIServerConfig
+{
     private static MinecraftServer server;
 
     public static Logger logger = LogManager.getLogger("NotEnoughItems");
@@ -65,7 +62,7 @@ public class NEIServerConfig {
         try {
             File file = new File(getSaveDir(world), "world.dat");
             NBTTagCompound tag = NEIServerUtils.readNBT(file);
-            if (tag == null) tag = new NBTTagCompound();
+            if(tag == null) tag = new NBTTagCompound();
             dimTags.put(CommonUtils.getDimension(world), tag);
         } catch (Exception e) {
             throw new RuntimeException(e);
@@ -78,8 +75,7 @@ public class NEIServerConfig {
 
         serverConfig.setNewLineMode(1);
         serverConfig.getTag("permissions").useBraces();
-        serverConfig.getTag("permissions")
-                .setComment("List of players who can use these features.\nEg. time=CodeChicken, Friend1");
+        serverConfig.getTag("permissions").setComment("List of players who can use these features.\nEg. time=CodeChicken, Friend1");
 
         setDefaultFeature("time");
         setDefaultFeature("rain");
@@ -97,11 +93,13 @@ public class NEIServerConfig {
     }
 
     private static void setDefaultFeature(String featurename, String... names) {
-        if (names.length == 0) names = new String[] { "OP" };
+        if (names.length == 0)
+            names = new String[]{"OP"};
 
         StringBuilder list = new StringBuilder();
         for (int i = 0; i < names.length; i++) {
-            if (i >= 1) list.append(", ");
+            if (i >= 1)
+                list.append(", ");
             list.append(names[i]);
         }
         serverConfig.getTag("permissions." + featurename).setDefaultValue(list.toString());
@@ -109,11 +107,7 @@ public class NEIServerConfig {
 
     private static void saveWorld(int dim) {
         try {
-            final File saveDir = getSaveDir(DimensionManager.getWorld(dim));
-            if (!saveDir.isDirectory()) {
-                FileUtils.forceMkdir(saveDir);
-            }
-            File file = new File(saveDir, "world.dat");
+            File file = new File(getSaveDir(DimensionManager.getWorld(dim)), "world.dat");
             NEIServerUtils.writeNBT(dimTags.get(dim), file);
         } catch (Exception e) {
             throw new RuntimeException(e);
@@ -125,12 +119,14 @@ public class NEIServerConfig {
     }
 
     public static boolean isPlayerInList(String playername, Set<String> list, boolean allowCards) {
-        if (playername.equals("CONSOLE")) return list.contains(playername);
+        if (playername.equals("CONSOLE"))
+            return list.contains(playername);
 
         playername = playername.toLowerCase();
 
         if (allowCards) {
-            if (list.contains("ALL")) return true;
+            if (list.contains("ALL"))
+                return true;
             if ((ServerUtils.isPlayerOP(playername) || ServerUtils.isPlayerOwner(playername)) && list.contains("OP"))
                 return true;
         }
@@ -177,7 +173,8 @@ public class NEIServerConfig {
         StringBuilder sb = new StringBuilder();
         int i = 0;
         for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); i++) {
-            if (i != 0) sb.append(", ");
+            if (i != 0)
+                sb.append(", ");
 
             sb.append(iterator.next());
         }
@@ -188,7 +185,7 @@ public class NEIServerConfig {
     private static void loadBannedItems() {
         bannedItems.clear();
         File file = new File(saveDir, "banneditems.cfg");
-        if (!file.exists()) {
+        if(!file.exists()) {
             bannedItems.put(new ItemStack(Blocks.command_block), new HashSet<>(Collections.singletonList("NONE")));
             saveBannedItems();
             return;
@@ -196,20 +193,22 @@ public class NEIServerConfig {
         try {
             FileReader r = new FileReader(file);
             int line = 0;
-            for (String s : IOUtils.readLines(r)) {
-                if (s.charAt(0) == '#' || s.trim().length() == 0) continue;
+            for(String s : IOUtils.readLines(r)) {
+                if(s.charAt(0) == '#' || s.trim().length() == 0)
+                    continue;
                 int delim = s.lastIndexOf('=');
-                if (delim < 0) {
-                    logger.error("line " + line + ": Missing =");
+                if(delim < 0) {
+                    logger.error("line "+line+": Missing =");
                     continue;
                 }
                 try {
                     NBTTagCompound key = (NBTTagCompound) JsonToNBT.func_150315_a(s.substring(0, delim));
                     Set<String> values = new HashSet<>();
-                    for (String s2 : s.substring(delim + 1).split(",")) values.add(s2.trim());
+                    for(String s2 : s.substring(delim+1).split(","))
+                        values.add(s2.trim());
                     bannedItems.put(InventoryUtils.loadPersistant(key), values);
                 } catch (Exception e) {
-                    logger.error("line " + line + ": " + e.getMessage());
+                    logger.error("line "+line+": "+e.getMessage());
                 }
             }
             r.close();
@@ -221,22 +220,22 @@ public class NEIServerConfig {
     public static void saveBannedItems() {
         File file = new File(saveDir, "banneditems.cfg");
         try {
-            if (!file.exists()) file.createNewFile();
+            if(!file.exists())
+                file.createNewFile();
 
             PrintWriter p = new PrintWriter(file);
-            p.println(
-                    "#Saved in this format for external editing. The format isn't that hard to figure out. If you think you're up to it, modify it here!");
+            p.println("#Saved in this format for external editing. The format isn't that hard to figure out. If you think you're up to it, modify it here!");
 
             for (ItemStackMap.Entry<Set<String>> entry : bannedItems.entries()) {
                 NBTTagCompound key = InventoryUtils.savePersistant(entry.key, new NBTTagCompound());
                 key.removeTag("Count");
-                if (key.getByte("Damage") == 0) key.removeTag("Damage");
+                if(key.getByte("Damage") == 0) key.removeTag("Damage");
 
                 p.print(key.toString());
                 p.print("=[");
                 int i = 0;
                 for (String s : entry.value) {
-                    if (i++ != 0) p.print(", ");
+                    if(i++ != 0) p.print(", ");
                     p.print(s);
                 }
                 p.println("]");
@@ -253,15 +252,14 @@ public class NEIServerConfig {
 
     public static void loadPlayer(EntityPlayer player) {
         logger.debug("Loading Player: " + player.getGameProfile().getName());
-        playerSaves.put(
-                player.getCommandSenderName(),
-                new PlayerSave(player.getCommandSenderName(), new File(saveDir, "players")));
+        playerSaves.put(player.getCommandSenderName(), new PlayerSave(player.getCommandSenderName(), new File(saveDir, "players")));
     }
 
     public static void unloadPlayer(EntityPlayer player) {
         logger.debug("Unloading Player: " + player.getCommandSenderName());
         PlayerSave playerSave = playerSaves.remove(player.getCommandSenderName());
-        if (playerSave != null) playerSave.save();
+        if (playerSave != null)
+            playerSave.save();
     }
 
     public static boolean authenticatePacket(EntityPlayerMP sender, PacketCustom packet) {

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

@@ -1,5 +1,30 @@
 package codechicken.nei;
 
+import codechicken.core.CommonUtils;
+import codechicken.core.ServerUtils;
+import codechicken.lib.inventory.InventoryRange;
+import codechicken.lib.inventory.InventoryUtils;
+import codechicken.lib.packet.PacketCustom;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompressedStreamTools;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.ChatComponentTranslation;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IChatComponent;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldServer;
+import net.minecraft.world.WorldSettings.GameType;
+import net.minecraftforge.oredict.OreDictionary;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
@@ -12,51 +37,18 @@ import java.util.List;
 import java.util.Set;
 import java.util.zip.ZipException;
 
-import net.minecraft.command.ICommandSender;
-import net.minecraft.enchantment.Enchantment;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.entity.player.InventoryPlayer;
-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;
-import net.minecraft.util.ChatComponentTranslation;
-import net.minecraft.util.EnumChatFormatting;
-import net.minecraft.util.IChatComponent;
-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 codechicken.core.CommonUtils;
-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;
-
-public class NEIServerUtils {
-
+public class NEIServerUtils
+{
     public static boolean isRaining(World world) {
         return world.getWorldInfo().isRaining();
     }
 
     public static void toggleRaining(World world, boolean notify) {
         boolean raining = !world.isRaining();
-        if (!raining) // turn off
+        if (!raining)//turn off
             ((WorldServer) world).provider.resetRainAndThunder();
-        else world.getWorldInfo().setRaining(!isRaining(world));
+        else
+            world.getWorldInfo().setRaining(!isRaining(world));
 
         if (notify)
             ServerUtils.sendChatToAll(new ChatComponentTranslation("nei.chat.rain." + (raining ? "on" : "off")));
@@ -77,20 +69,27 @@ public class NEIServerUtils {
     }
 
     public static void setSlotContents(EntityPlayer player, int slot, ItemStack item, boolean containerInv) {
-        if (slot == -999) player.inventory.setItemStack(item);
-        else if (containerInv) player.openContainer.putStackInSlot(slot, item);
-        else player.inventory.setInventorySlotContents(slot, item);
+        if (slot == -999)
+            player.inventory.setItemStack(item);
+        else if (containerInv)
+            player.openContainer.putStackInSlot(slot, item);
+        else
+            player.inventory.setInventorySlotContents(slot, item);
     }
 
     public static ItemStack getSlotContents(EntityPlayer player, int slot, boolean containerInv) {
-        if (slot == -999) return player.inventory.getItemStack();
-        else if (containerInv) return player.openContainer.getSlot(slot).getStack();
-        else return player.inventory.getStackInSlot(slot);
+        if (slot == -999)
+            return player.inventory.getItemStack();
+        else if (containerInv)
+            return player.openContainer.getSlot(slot).getStack();
+        else
+            return player.inventory.getStackInSlot(slot);
     }
 
     @SuppressWarnings("unchecked")
     public static void deleteAllItems(EntityPlayerMP player) {
-        for (Slot slot : (List<Slot>) player.openContainer.inventorySlots) slot.putStack(null);
+        for (Slot slot : (List<Slot>) player.openContainer.inventorySlots)
+            slot.putStack(null);
 
         player.sendContainerAndContentsToPlayer(player.openContainer, player.openContainer.getInventory());
     }
@@ -110,7 +109,8 @@ public class NEIServerUtils {
         while (NEIServerConfig.isActionDisabled(dim, NEIActions.timeZones[newhour / 6]))
             newhour = ((newhour / 6 + 1) % 4) * 6;
 
-        if (newhour != hour) setHourForward(world, newhour, false);
+        if (newhour != hour)
+            setHourForward(world, newhour, false);
     }
 
     public static boolean canItemFitInInventory(EntityPlayer player, ItemStack itemstack) {
@@ -118,18 +118,17 @@ public class NEIServerUtils {
     }
 
     public static void sendNotice(ICommandSender sender, IChatComponent msg, String permission) {
-        ChatComponentTranslation notice = new ChatComponentTranslation(
-                "chat.type.admin",
-                sender.getCommandSenderName(),
-                msg.createCopy());
+        ChatComponentTranslation notice = new ChatComponentTranslation("chat.type.admin", sender.getCommandSenderName(), msg.createCopy());
         notice.getChatStyle().setColor(EnumChatFormatting.GRAY).setItalic(true);
 
         if (NEIServerConfig.canPlayerPerformAction("CONSOLE", permission))
             MinecraftServer.getServer().addChatMessage(notice);
 
-        for (EntityPlayer p : ServerUtils.getPlayers()) if (p == sender) p.addChatComponentMessage(msg);
-        else if (NEIServerConfig.canPlayerPerformAction(p.getCommandSenderName(), permission))
-            p.addChatComponentMessage(notice);
+        for (EntityPlayer p : ServerUtils.getPlayers())
+            if(p == sender)
+                p.addChatComponentMessage(msg);
+            else if (NEIServerConfig.canPlayerPerformAction(p.getCommandSenderName(), permission))
+                p.addChatComponentMessage(notice);
     }
 
     /**
@@ -138,58 +137,23 @@ public class NEIServerUtils {
      * @return whether the two items are the same in terms of damage and itemID.
      */
     public static boolean areStacksSameType(ItemStack stack1, ItemStack stack2) {
-        return stack1 != null && stack2 != null
-                && (stack1.getItem() == stack2.getItem()
-                        && (!stack2.getHasSubtypes() || stack2.getItemDamage() == stack1.getItemDamage())
-                        && ItemStack.areItemStackTagsEqual(stack2, stack1));
+        return stack1 != null && stack2 != null &&
+                (stack1.getItem() == stack2.getItem() &&
+                (!stack2.getHasSubtypes() || stack2.getItemDamage() == stack1.getItemDamage()) &&
+                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.
+     * {@link ItemStack}s with damage -1 are wildcards allowing all damages. Eg all colours of wool are allowed to create Beds.
      *
      * @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 areStacksSameTypeCrafting(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());
-    }
-
-    /**
-     * 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());
+        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());
     }
 
     /**
@@ -200,10 +164,9 @@ public class NEIServerUtils {
      * @return The ordering of stack1 relative to stack2.
      */
     public static int compareStacks(ItemStack stack1, ItemStack stack2) {
-        if (stack1 == stack2) return 0; // catches both null
-        if (stack1 == null || stack2 == null) return stack1 == null ? -1 : 1; // null stack goes first
-        if (stack1.getItem() != stack2.getItem())
-            return Item.getIdFromItem(stack1.getItem()) - Item.getIdFromItem(stack2.getItem());
+        if (stack1 == stack2) return 0;//catches both null
+        if (stack1 == null || stack2 == null) return stack1 == null ? -1 : 1;//null stack goes first
+        if (stack1.getItem() != stack2.getItem()) return Item.getIdFromItem(stack1.getItem()) - Item.getIdFromItem(stack2.getItem());
         if (stack1.stackSize != stack2.stackSize) return stack1.stackSize - stack2.stackSize;
         return stack1.getItemDamage() - stack2.getItemDamage();
     }
@@ -219,37 +182,33 @@ public class NEIServerUtils {
 
     public static void givePlayerItem(EntityPlayerMP player, ItemStack stack, boolean infinite, boolean doGive) {
         if (stack.getItem() == null) {
-            player.addChatComponentMessage(
-                    setColour(new ChatComponentTranslation("nei.chat.give.noitem"), EnumChatFormatting.WHITE));
+            player.addChatComponentMessage(setColour(new ChatComponentTranslation("nei.chat.give.noitem"), EnumChatFormatting.WHITE));
             return;
         }
 
         int given = stack.stackSize;
-        if (doGive) {
-            if (infinite) player.inventory.addItemStackToInventory(stack);
-            else given -= InventoryUtils.insertItem(player.inventory, stack, false);
+        if(doGive) {
+            if (infinite)
+                player.inventory.addItemStackToInventory(stack);
+            else
+                given -= InventoryUtils.insertItem(player.inventory, stack, false);
         }
 
-        sendNotice(
-                player,
-                new ChatComponentTranslation(
-                        "commands.give.success",
-                        stack.func_151000_E(),
-                        infinite ? "\u221E" : Integer.toString(given),
-                        player.getCommandSenderName()),
-                "notify-item");
+        sendNotice(player, new ChatComponentTranslation("commands.give.success", stack.func_151000_E(), infinite ? "\u221E" : Integer.toString(given), player.getCommandSenderName()), "notify-item");
         player.openContainer.detectAndSendChanges();
     }
 
     public static ItemStack copyStack(ItemStack itemstack, int i) {
-        if (itemstack == null) return null;
+        if (itemstack == null)
+            return null;
 
         itemstack.stackSize += i;
         return itemstack.splitStack(i);
     }
 
     public static ItemStack copyStack(ItemStack itemstack) {
-        if (itemstack == null) return null;
+        if (itemstack == null)
+            return null;
 
         return copyStack(itemstack, itemstack.stackSize);
     }
@@ -260,10 +219,14 @@ public class NEIServerUtils {
     }
 
     public static int getCreativeMode(EntityPlayerMP player) {
-        if (NEIServerConfig.forPlayer(player.getCommandSenderName()).isActionEnabled("creative+")) return 2;
-        else if (player.theItemInWorldManager.isCreative()) return 1;
-        else if (player.theItemInWorldManager.getGameType().isAdventure()) return 3;
-        else return 0;
+        if (NEIServerConfig.forPlayer(player.getCommandSenderName()).isActionEnabled("creative+"))
+            return 2;
+        else if (player.theItemInWorldManager.isCreative())
+            return 1;
+        else if (player.theItemInWorldManager.getGameType().isAdventure())
+            return 3;
+        else
+            return 0;
     }
 
     public static GameType getGameType(int mode) {
@@ -280,21 +243,20 @@ public class NEIServerUtils {
     }
 
     public static void setGamemode(EntityPlayerMP player, int mode) {
-        if (mode < 0 || mode >= NEIActions.gameModes.length
-                || NEIActions.nameActionMap.containsKey(NEIActions.gameModes[mode]) && !NEIServerConfig
-                        .canPlayerPerformAction(player.getCommandSenderName(), NEIActions.gameModes[mode]))
+        if (mode < 0 || mode >= NEIActions.gameModes.length ||
+                NEIActions.nameActionMap.containsKey(NEIActions.gameModes[mode]) &&
+                        !NEIServerConfig.canPlayerPerformAction(player.getCommandSenderName(), NEIActions.gameModes[mode]))
             return;
 
-        // creative+
+        //creative+
         NEIServerConfig.forPlayer(player.getCommandSenderName()).enableAction("creative+", mode == 2);
-        if (mode == 2 && !(player.openContainer instanceof ContainerCreativeInv)) // open the container immediately for
-                                                                                  // the client
+        if(mode == 2 && !(player.openContainer instanceof ContainerCreativeInv))//open the container immediately for the client
             NEISPH.processCreativeInv(player, true);
 
-        // change it on the server
+        //change it on the server
         player.theItemInWorldManager.setGameType(getGameType(mode));
 
-        // tell the client to change it
+        //tell the client to change it
         new PacketCustom(NEISPH.channel, 14).writeByte(mode).sendToPlayer(player);
         player.addChatMessage(new ChatComponentTranslation("nei.chat.gamemode." + mode));
     }
@@ -302,29 +264,32 @@ public class NEIServerUtils {
     public static void cycleCreativeInv(EntityPlayerMP player, int steps) {
         InventoryPlayer inventory = player.inventory;
 
-        // top down [row][col]
+        //top down [row][col]
         ItemStack[][] slots = new ItemStack[10][9];
         PlayerSave playerSave = NEIServerConfig.forPlayer(player.getCommandSenderName());
 
-        // get
+        //get
         System.arraycopy(inventory.mainInventory, 0, slots[9], 0, 9);
 
         for (int row = 0; row < 3; row++)
             System.arraycopy(inventory.mainInventory, (row + 1) * 9, slots[row + 6], 0, 9);
 
-        for (int row = 0; row < 6; row++) System.arraycopy(playerSave.creativeInv, row * 9, slots[row], 0, 9);
+        for (int row = 0; row < 6; row++)
+            System.arraycopy(playerSave.creativeInv, row * 9, slots[row], 0, 9);
 
         ItemStack[][] newslots = new ItemStack[10][];
 
-        // put back
-        for (int row = 0; row < 10; row++) newslots[(row + steps + 10) % 10] = slots[row];
+        //put back
+        for (int row = 0; row < 10; row++)
+            newslots[(row + steps + 10) % 10] = slots[row];
 
         System.arraycopy(newslots[9], 0, inventory.mainInventory, 0, 9);
 
         for (int row = 0; row < 3; row++)
             System.arraycopy(newslots[row + 6], 0, inventory.mainInventory, (row + 1) * 9, 9);
 
-        for (int row = 0; row < 6; row++) System.arraycopy(newslots[row], 0, playerSave.creativeInv, row * 9, 9);
+        for (int row = 0; row < 6; row++)
+            System.arraycopy(newslots[row], 0, playerSave.creativeInv, row * 9, 9);
 
         playerSave.setDirty();
     }
@@ -333,66 +298,78 @@ public class NEIServerUtils {
         ArrayList<int[]> arraylist = new ArrayList<>();
         if (itemstack != null) {
             NBTTagList nbttaglist = itemstack.getEnchantmentTagList();
-            if (nbttaglist != null) for (int i = 0; i < nbttaglist.tagCount(); i++) {
-                NBTTagCompound tag = nbttaglist.getCompoundTagAt(i);
-                arraylist.add(new int[] { tag.getShort("id"), tag.getShort("lvl") });
-            }
+            if (nbttaglist != null)
+                for (int i = 0; i < nbttaglist.tagCount(); i++) {
+                    NBTTagCompound tag = nbttaglist.getCompoundTagAt(i);
+                    arraylist.add(new int[]{tag.getShort("id"), tag.getShort("lvl")});
+                }
         }
         return arraylist;
     }
 
     public static boolean stackHasEnchantment(ItemStack itemstack, int e) {
         List<int[]> allenchantments = getEnchantments(itemstack);
-        for (int[] ai : allenchantments) if (ai[0] == e) return true;
+        for (int[] ai : allenchantments)
+            if (ai[0] == e)
+                return true;
 
         return false;
     }
 
     public static int getEnchantmentLevel(ItemStack itemstack, int e) {
         List<int[]> allenchantments = getEnchantments(itemstack);
-        for (int[] ai : allenchantments) if (ai[0] == e) return ai[1];
+        for (int[] ai : allenchantments)
+            if (ai[0] == e)
+                return ai[1];
 
         return -1;
     }
 
     public static boolean doesEnchantmentConflict(List<int[]> enchantments, Enchantment e) {
-        for (int[] ai : enchantments) if (!e.canApplyTogether(Enchantment.enchantmentsList[ai[0]])) return true;
+        for (int[] ai : enchantments)
+            if (!e.canApplyTogether(Enchantment.enchantmentsList[ai[0]]))
+                return true;
 
         return false;
     }
 
     public static RuntimeException throwCME(String msg) {
-        if (CommonUtils.isClient()) return ClientHandler.throwCME(msg);
+        if (CommonUtils.isClient())
+            return ClientHandler.throwCME(msg);
 
         throw new RuntimeException(msg);
     }
 
     @SuppressWarnings("unchecked")
     public static ItemStack[] extractRecipeItems(Object obj) {
-        if (obj instanceof ItemStack) return new ItemStack[] { (ItemStack) obj };
-        if (obj instanceof ItemStack[]) return (ItemStack[]) obj;
-        if (obj instanceof List) return ((List<ItemStack>) obj).toArray(new ItemStack[0]);
+        if (obj instanceof ItemStack)
+            return new ItemStack[]{(ItemStack) obj};
+        if (obj instanceof ItemStack[])
+            return (ItemStack[]) obj;
+        if (obj instanceof List)
+            return ((List<ItemStack>) obj).toArray(new ItemStack[0]);
 
-        throw new ClassCastException(obj + " not an ItemStack, ItemStack[] or List<ItemStack?");
+        throw new ClassCastException(obj+" not an ItemStack, ItemStack[] or List<ItemStack?");
     }
 
     public static List<Integer> getRange(final int start, final int end) {
-        return new AbstractList<Integer>() {
-
+        return new AbstractList<Integer>()
+        {
             @Override
             public Integer get(int index) {
-                return start + index;
+                return start+index;
             }
 
             @Override
             public int size() {
-                return end - start;
+                return end-start;
             }
         };
     }
 
     public static StringBuilder fixTrailingCommaList(StringBuilder sb) {
-        if (sb.charAt(sb.length() - 1) == ',') sb.deleteCharAt(sb.length() - 1);
+        if(sb.charAt(sb.length()-1) == ',')
+            sb.deleteCharAt(sb.length()-1);
         return sb;
     }
 
@@ -410,60 +387,17 @@ 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;
+        if(!file.exists()) return null;
         FileInputStream in = new FileInputStream(file);
         NBTTagCompound tag;
         try {
             tag = CompressedStreamTools.readCompressed(in);
-        } catch (ZipException e) {
-            if (e.getMessage().equals("Not in GZIP format")) tag = CompressedStreamTools.read(file);
-            else throw e;
+        } catch(ZipException e) {
+            if(e.getMessage().equals("Not in GZIP format"))
+                tag = CompressedStreamTools.read(file);
+            else
+                throw e;
         }
         in.close();
         return tag;
@@ -474,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/OffsetPositioner.java

@@ -1,25 +1,28 @@
 package codechicken.nei;
 
-import java.util.ArrayList;
-
 import codechicken.nei.api.IStackPositioner;
 
-public class OffsetPositioner implements IStackPositioner {
+import java.util.ArrayList;
 
-    public OffsetPositioner(int x, int y) {
+public class OffsetPositioner implements IStackPositioner
+{
+    public OffsetPositioner(int x, int y)
+    {
         offsetx = x;
         offsety = y;
     }
-
+    
     @Override
-    public ArrayList<PositionedStack> positionStacks(ArrayList<PositionedStack> ai) {
-        for (PositionedStack stack : ai) {
-            stack.relx += offsetx;
-            stack.rely += offsety;
+    public ArrayList<PositionedStack> positionStacks(ArrayList<PositionedStack> ai)
+    {
+        for(PositionedStack stack : ai)
+        {
+            stack.relx+=offsetx;
+            stack.rely+=offsety;
         }
         return ai;
     }
-
+    
     public int offsetx;
     public int offsety;
 }

src/main/java/codechicken/nei/PanelWidget.java

@@ -1,386 +0,0 @@
-package codechicken.nei;
-
-import java.util.ArrayList;
-
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.item.ItemStack;
-
-import codechicken.lib.vec.Rectangle4i;
-import codechicken.nei.ItemPanel.ItemPanelSlot;
-import codechicken.nei.api.GuiInfo;
-import codechicken.nei.api.INEIGuiHandler;
-import codechicken.nei.guihook.GuiContainerManager;
-import codechicken.nei.recipe.GuiCraftingRecipe;
-import codechicken.nei.recipe.GuiRecipe;
-import codechicken.nei.recipe.GuiUsageRecipe;
-
-public abstract class PanelWidget extends Widget {
-
-    protected static final int PADDING = 2;
-
-    public ItemStack draggedStack;
-    public int mouseDownSlot = -1;
-
-    public Button pagePrev;
-    public Button pageNext;
-    public Label pageLabel;
-
-    protected ItemsGrid grid;
-
-    public ArrayList<ItemStack> getItems() {
-        return grid.getItems();
-    }
-
-    public ItemsGrid getGrid() {
-        return grid;
-    }
-
-    public void init() {
-        pageLabel = new Label("0/0", true);
-
-        pagePrev = new Button("Prev") {
-
-            public boolean onButtonPress(boolean rightclick) {
-                if (!rightclick) {
-                    grid.shiftPage(-1);
-                    return true;
-                }
-                return false;
-            }
-
-            @Override
-            public String getRenderLabel() {
-                return "<";
-            }
-        };
-        pageNext = new Button("Next") {
-
-            public boolean onButtonPress(boolean rightclick) {
-                if (!rightclick) {
-                    grid.shiftPage(1);
-                    return true;
-                }
-                return false;
-            }
-
-            @Override
-            public String getRenderLabel() {
-                return ">";
-            }
-        };
-    }
-
-    public abstract String getLabelText();
-
-    protected abstract String getPositioningSettingName();
-
-    public abstract int getMarginLeft(GuiContainer gui);
-
-    public abstract int getMarginTop(GuiContainer gui);
-
-    public abstract int getWidth(GuiContainer gui);
-
-    public abstract int getHeight(GuiContainer gui);
-
-    public void resize(GuiContainer gui) {
-        final Rectangle4i margin = new Rectangle4i(
-                getMarginLeft(gui),
-                getMarginTop(gui),
-                getWidth(gui),
-                getHeight(gui));
-
-        final int minWidth = 5 * ItemsGrid.SLOT_SIZE;
-        final int minHeight = 9 * ItemsGrid.SLOT_SIZE;
-
-        final String settingName = getPositioningSettingName();
-        int paddingLeft = (int) Math
-                .ceil(margin.w * NEIClientConfig.getSetting(settingName + ".left").getIntValue() / 100000.0);
-        int paddingTop = (int) Math
-                .ceil(margin.h * NEIClientConfig.getSetting(settingName + ".top").getIntValue() / 100000.0);
-        int paddingRight = (int) Math
-                .ceil(margin.w * NEIClientConfig.getSetting(settingName + ".right").getIntValue() / 100000.0);
-        int paddingBottom = (int) Math
-                .ceil(margin.h * NEIClientConfig.getSetting(settingName + ".bottom").getIntValue() / 100000.0);
-
-        int deltaHeight = Math.min(0, margin.h - paddingTop - paddingBottom - minHeight) / 2;
-
-        paddingLeft = Math.min(paddingLeft, Math.max(0, margin.w - paddingRight - minWidth));
-        paddingRight = Math.min(paddingRight, Math.max(0, margin.w - paddingLeft - minWidth));
-        paddingTop = Math.min(margin.h - minHeight, Math.max(0, paddingTop + deltaHeight));
-        paddingBottom = Math.min(margin.h - paddingTop - minHeight, Math.max(0, paddingBottom - deltaHeight));
-
-        x = margin.x + paddingLeft;
-        y = margin.y + paddingTop;
-        w = margin.w - paddingLeft - paddingRight;
-        h = margin.h - paddingTop - paddingBottom;
-
-        final int header = resizeHeader(gui);
-        final int footer = resizeFooter(gui);
-
-        grid.setGridSize(x, y + header, w, h - header - footer);
-        grid.refresh(gui);
-    }
-
-    protected int resizeHeader(GuiContainer gui) {
-        final int BUTTON_SIZE = 16;
-        int paddingLeft = 0;
-        int paddingRight = 0;
-
-        while (paddingLeft < w && GuiInfo.hideItemPanelSlot(
-                gui,
-                new Rectangle4i(x + paddingLeft, y, ItemsGrid.SLOT_SIZE, ItemsGrid.SLOT_SIZE))) {
-            paddingLeft += ItemsGrid.SLOT_SIZE;
-        }
-
-        while (paddingRight < w && GuiInfo.hideItemPanelSlot(
-                gui,
-                new Rectangle4i(
-                        x + w - paddingRight - ItemsGrid.SLOT_SIZE,
-                        y,
-                        ItemsGrid.SLOT_SIZE,
-                        ItemsGrid.SLOT_SIZE))) {
-            paddingRight += ItemsGrid.SLOT_SIZE;
-        }
-
-        if (paddingLeft + paddingRight >= w) {
-            return 0;
-        }
-
-        pagePrev.w = pageNext.w = BUTTON_SIZE;
-        pagePrev.h = pageNext.h = BUTTON_SIZE;
-        pagePrev.y = pageNext.y = y;
-
-        pagePrev.x = x + paddingLeft;
-        pageNext.x = x + w - pageNext.w - paddingRight;
-
-        pageLabel.x = x + paddingLeft + (w - paddingLeft - paddingRight) / 2;
-        pageLabel.y = y + 5;
-        pageLabel.text = getLabelText();
-
-        return BUTTON_SIZE + 2;
-    }
-
-    protected abstract int resizeFooter(GuiContainer gui);
-
-    public void setVisible() {
-        if (grid.getPerPage() > 0) {
-            LayoutManager.addWidget(pagePrev);
-            LayoutManager.addWidget(pageNext);
-            LayoutManager.addWidget(pageLabel);
-            grid.setVisible();
-        }
-    }
-
-    @Override
-    public void draw(int mousex, int mousey) {
-        grid.draw(mousex, mousey);
-    }
-
-    @Override
-    public void postDraw(int mousex, int mousey) {
-        if (draggedStack != null) {
-            GuiContainerManager.drawItems.zLevel += 100;
-            GuiContainerManager.drawItem(mousex - 8, mousey - 8, draggedStack);
-            GuiContainerManager.drawItems.zLevel -= 100;
-        }
-    }
-
-    @Override
-    public void mouseDragged(int mousex, int mousey, int button, long heldTime) {
-        if (mouseDownSlot >= 0 && draggedStack == null
-                && NEIClientUtils.getHeldItem() == null
-                && NEIClientConfig.hasSMPCounterPart()) {
-            ItemPanelSlot mouseOverSlot = getSlotMouseOver(mousex, mousey);
-
-            if (mouseOverSlot == null || mouseOverSlot.slotIndex != mouseDownSlot || heldTime > 500) {
-                draggedStack = getDraggedStackWithQuantity(mouseDownSlot);
-                mouseDownSlot = -1;
-            }
-        }
-    }
-
-    protected abstract ItemStack getDraggedStackWithQuantity(int mouseDownSlot);
-
-    @Override
-    public boolean handleClick(int mousex, int mousey, int button) {
-
-        if (handleClickExt(mousex, mousey, button)) return true;
-
-        if (NEIClientUtils.getHeldItem() != null) {
-
-            if (!grid.contains(mousex, mousey)) {
-                return false;
-            }
-
-            if (NEIClientConfig.canPerformAction("delete") && NEIClientConfig.canPerformAction("item")) {
-                if (button == 1) {
-                    NEIClientUtils.decreaseSlotStack(-999);
-                } else {
-                    NEIClientUtils.deleteHeldItem();
-                }
-            } else {
-                NEIClientUtils.dropHeldItem();
-            }
-
-            return true;
-        }
-
-        ItemPanelSlot hoverSlot = getSlotMouseOver(mousex, mousey);
-        if (hoverSlot != null) {
-
-            if (button == 2) {
-
-                if (hoverSlot.item != null) {
-                    draggedStack = getDraggedStackWithQuantity(hoverSlot.slotIndex);
-                }
-
-            } else {
-                mouseDownSlot = hoverSlot.slotIndex;
-            }
-
-            return true;
-        }
-
-        return false;
-    }
-
-    @Override
-    public boolean handleClickExt(int mouseX, int mouseY, int button) {
-
-        if (ItemPanels.itemPanel.draggedStack != null && ItemPanels.bookmarkPanel.contains(mouseX, mouseY)) {
-            ItemPanels.bookmarkPanel.addOrRemoveItem(ItemPanels.itemPanel.draggedStack, null, null, false, true);
-            ItemPanels.itemPanel.draggedStack = null;
-            return true;
-        }
-
-        if (ItemPanels.itemPanel.draggedStack != null) {
-            return ItemPanels.itemPanel.handleDraggedClick(mouseX, mouseY, button);
-        }
-
-        if (ItemPanels.bookmarkPanel.draggedStack != null) {
-            return ItemPanels.bookmarkPanel.handleDraggedClick(mouseX, mouseY, button);
-        }
-
-        if (NEIClientUtils.getHeldItem() != null) {
-            final ItemStack draggedStack = NEIClientUtils.getHeldItem().copy();
-            return handleGUIContainerClick(draggedStack, mouseX, mouseY, button);
-        }
-
-        return false;
-    }
-
-    protected boolean handleDraggedClick(int mouseX, int mouseY, int button) {
-        if (draggedStack == null) {
-            return false;
-        }
-
-        if (handleGUIContainerClick(draggedStack, mouseX, mouseY, button)) {
-
-            if (draggedStack.stackSize == 0) {
-                draggedStack = null;
-            }
-
-            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 handleGUIContainerClick(final ItemStack draggedStack, int mouseX, int mouseY, int button) {
-        final GuiContainer gui = NEIClientUtils.getGuiContainer();
-        boolean handled = false;
-
-        try {
-            GuiInfo.readLock.lock();
-            for (INEIGuiHandler handler : GuiInfo.guiHandlers) {
-                if (handler.handleDragNDrop(gui, mouseX, mouseY, draggedStack, button)) {
-                    handled = true;
-                    break;
-                }
-            }
-        } finally {
-            GuiInfo.readLock.unlock();
-        }
-
-        return handled;
-    }
-
-    @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);
-                }
-
-                mouseDownSlot = -1;
-                return;
-            }
-
-            NEIClientUtils.cheatItem(getDraggedStackWithQuantity(hoverSlot.slotIndex), button, -1);
-        }
-
-        mouseDownSlot = -1;
-    }
-
-    @Override
-    public boolean onMouseWheel(int i, int mousex, int mousey) {
-        if (!contains(mousex, mousey)) return false;
-
-        grid.shiftPage(-i);
-        return true;
-    }
-
-    @Override
-    public boolean handleKeyPress(int keyID, char keyChar) {
-
-        if (NEIClientConfig.isKeyHashDown("gui.next")) {
-            grid.shiftPage(1);
-            return true;
-        }
-
-        if (NEIClientConfig.isKeyHashDown("gui.prev")) {
-            grid.shiftPage(-1);
-            return true;
-        }
-
-        return false;
-    }
-
-    @Override
-    public ItemStack getStackMouseOver(int mousex, int mousey) {
-        ItemPanelSlot slot = getSlotMouseOver(mousex, mousey);
-        return slot == null ? null : slot.item;
-    }
-
-    public ItemPanelSlot getSlotMouseOver(int mousex, int mousey) {
-        return grid.getSlotMouseOver(mousex, mousey);
-    }
-
-    public int getPage() {
-        return grid.getPage();
-    }
-
-    public int getNumPages() {
-        return grid.getNumPages();
-    }
-
-    @Override
-    public boolean contains(int px, int py) {
-        return grid.contains(px, py);
-    }
-}

src/main/java/codechicken/nei/PlayerSave.java

@@ -1,17 +1,16 @@
 package codechicken.nei;
 
-import java.io.File;
-
+import codechicken.core.ServerUtils;
+import codechicken.lib.inventory.InventoryUtils;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTTagList;
 
-import codechicken.core.ServerUtils;
-import codechicken.lib.inventory.InventoryUtils;
-
-public class PlayerSave {
+import java.io.File;
 
+public class PlayerSave
+{
     public String username;
 
     private File saveFile;
@@ -28,17 +27,20 @@ public class PlayerSave {
         wasOp = ServerUtils.isPlayerOP(playername);
 
         saveFile = new File(saveLocation, username + ".dat");
-        if (!saveFile.getParentFile().exists()) saveFile.getParentFile().mkdirs();
+        if (!saveFile.getParentFile().exists())
+            saveFile.getParentFile().mkdirs();
         load();
     }
 
     private void load() {
         nbt = new NBTTagCompound();
         try {
-            if (!saveFile.exists()) saveFile.createNewFile();
-            if (saveFile.length() > 0) nbt = NEIServerUtils.readNBT(saveFile);
+            if (!saveFile.exists())
+                saveFile.createNewFile();
+            if (saveFile.length() > 0)
+                nbt = NEIServerUtils.readNBT(saveFile);
         } catch (Exception e) {
-            NEIClientConfig.logger.error("Error loading player save: " + username, e);
+            NEIClientConfig.logger.error("Error loading player save: "+username, e);
         }
 
         loadCreativeInv();
@@ -47,19 +49,22 @@ public class PlayerSave {
     private void loadCreativeInv() {
         creativeInv = new ItemStack[54];
         NBTTagList itemList = nbt.getTagList("creativeitems", 10);
-        if (itemList != null) InventoryUtils.readItemStacksFromTag(creativeInv, itemList);
+        if (itemList != null)
+            InventoryUtils.readItemStacksFromTag(creativeInv, itemList);
     }
 
     public void save() {
-        if (!isDirty) return;
+        if (!isDirty)
+            return;
 
-        if (creativeInvDirty) saveCreativeInv();
+        if (creativeInvDirty)
+            saveCreativeInv();
 
         try {
             NEIServerUtils.writeNBT(nbt, saveFile);
             isDirty = false;
         } catch (Exception e) {
-            NEIClientConfig.logger.error("Error saving player: " + username, e);
+            NEIClientConfig.logger.error("Error saving player: "+username, e);
         }
     }
 
@@ -92,7 +97,8 @@ public class PlayerSave {
 
     private NBTTagCompound getEnabledActions() {
         NBTTagCompound tag = nbt.getCompoundTag("enabledActions");
-        if (!nbt.hasKey("enabledActions")) nbt.setTag("enabledActions", tag);
+        if (!nbt.hasKey("enabledActions"))
+            nbt.setTag("enabledActions", tag);
         return tag;
     }
 

src/main/java/codechicken/nei/PopupInputHandler.java

@@ -1,56 +1,69 @@
 package codechicken.nei;
 
-import static codechicken.nei.NEIClientConfig.canPerformAction;
-
+import codechicken.nei.guihook.IContainerInputHandler;
 import net.minecraft.client.gui.inventory.GuiContainer;
 
-import codechicken.nei.guihook.IContainerInputHandler;
-
-public class PopupInputHandler implements IContainerInputHandler {
+import static codechicken.nei.NEIClientConfig.canPerformAction;
+import static codechicken.nei.NEIClientConfig.getKeyBinding;
 
+public class PopupInputHandler implements IContainerInputHandler
+{
     @Override
-    public boolean keyTyped(GuiContainer gui, char keyChar, int keyCode) {
+    public boolean keyTyped(GuiContainer gui, char keyChar, int keyCode)
+    {
         return false;
     }
 
     @Override
-    public boolean mouseClicked(GuiContainer gui, int mousex, int mousey, int button) {
+    public boolean mouseClicked(GuiContainer gui, int mousex, int mousey, int button)
+    {
         return false;
     }
 
     @Override
-    public void onKeyTyped(GuiContainer gui, char keyChar, int keyID) {}
+    public void onKeyTyped(GuiContainer gui, char keyChar, int keyID)
+    {
+    }
 
     @Override
-    public boolean lastKeyTyped(GuiContainer gui, char keyChar, int keyID) {
-
-        if (NEIClientConfig.isKeyHashDown("gui.enchant") && canPerformAction("enchant")) {
+    public boolean lastKeyTyped(GuiContainer gui, char keyChar, int keyID)
+    {
+        if(keyID == getKeyBinding("gui.enchant") && canPerformAction("enchant"))
+        {
             NEICPH.sendOpenEnchantmentWindow();
             return true;
         }
-
-        if (NEIClientConfig.isKeyHashDown("gui.potion") && canPerformAction("potion")) {
+        if(keyID == getKeyBinding("gui.potion") && canPerformAction("potion"))
+        {
             NEICPH.sendOpenPotionWindow();
             return true;
         }
-
         return false;
     }
 
     @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)
+    {
+    }
 
     @Override
-    public boolean mouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {
+    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) {}
-
+    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) {}
+    public void onMouseDragged(GuiContainer gui, int mousex, int mousey, int button, long heldTime)
+    {
+    }
 }

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

@@ -1,109 +1,111 @@
 package codechicken.nei;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import net.minecraft.init.Blocks;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.oredict.OreDictionary;
 
-/**
- * Simply an {@link ItemStack} with position. Mainly used in the recipe handlers.
- */
-public class PositionedStack {
+import java.util.ArrayList;
+import java.util.List;
 
+/**
+ * Simply an {@link ItemStack} with position.
+ * Mainly used in the recipe handlers.
+ */
+public class PositionedStack
+{    
     public int relx;
     public int rely;
     public ItemStack[] items;
-    // compatibility dummy
+    //compatibility dummy
     public ItemStack item;
-
+    
     private boolean permutated = false;
-
+    
     public PositionedStack(Object object, int x, int y, boolean genPerms) {
         items = NEIServerUtils.extractRecipeItems(object);
         relx = x;
         rely = y;
-
-        if (genPerms) generatePermutations();
-        else setPermutationToRender(0);
+        
+        if(genPerms)
+            generatePermutations();
+        else
+            setPermutationToRender(0);
     }
-
-    public PositionedStack(Object object, int x, int y) {
+    
+    public PositionedStack(Object object, int x, int y)
+    {
         this(object, x, y, true);
     }
 
     public void generatePermutations() {
-        if (permutated) return;
-
+        if(permutated)
+            return;
+        
         ArrayList<ItemStack> stacks = new ArrayList<>();
-        for (ItemStack item : items) {
-            if (item == null || item.getItem() == null) continue;
-
-            if (item.getItemDamage() == Short.MAX_VALUE) {
+        for(ItemStack item : items) {
+            if(item == null || item.getItem() == null)
+                continue;
+            
+            if(item.getItemDamage() == Short.MAX_VALUE) {
                 List<ItemStack> permutations = ItemList.itemMap.get(item.getItem());
-                if (!permutations.isEmpty()) {
-                    for (ItemStack stack : permutations) {
-                        ItemStack toAdd = stack.copy();
-                        toAdd.stackSize = item.stackSize;
-                        stacks.add(toAdd);
-                    }
-                } else {
+                if(!permutations.isEmpty()) {
+                    for(ItemStack stack : permutations)
+                        stacks.add(stack.copy());
+                }
+                else {
                     ItemStack base = new ItemStack(item.getItem(), item.stackSize);
                     base.stackTagCompound = item.stackTagCompound;
                     stacks.add(base);
                 }
                 continue;
             }
-
+            
             stacks.add(item.copy());
         }
         items = stacks.toArray(new ItemStack[0]);
 
-        if (items.length == 0) items = new ItemStack[] { new ItemStack(Blocks.fire) };
-
+        if(items.length == 0)
+            items = new ItemStack[]{new ItemStack(Blocks.fire)};
+        
         permutated = true;
         setPermutationToRender(0);
     }
 
     public void setMaxSize(int i) {
-        for (ItemStack item : items) if (item.stackSize > i) item.stackSize = i;
+        for(ItemStack item : items)
+            if(item.stackSize > i)
+                item.stackSize = i;
     }
-
+    
     public PositionedStack copy() {
         return new PositionedStack(items, relx, rely);
     }
-
+    
     public void setPermutationToRender(int index) {
         item = items[index].copy();
-        if (item.getItem() == null) item = new ItemStack(Blocks.fire);
-        else if (item.getItemDamage() == OreDictionary.WILDCARD_VALUE && item.getItem() != null
-                && item.getItem().isRepairable())
+        if(item.getItem() == null)
+            item = new ItemStack(Blocks.fire);
+        else if(item.getItemDamage() == OreDictionary.WILDCARD_VALUE && item.getItem() != null && item.getItem().isRepairable())
             item.setItemDamage(0);
     }
 
     public boolean contains(ItemStack ingredient) {
-        for (ItemStack item : items) if (NEIServerUtils.areStacksSameTypeCrafting(item, ingredient)) return true;
-
-        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;
-
+        for(ItemStack item : items)
+            if(NEIServerUtils.areStacksSameTypeCrafting(item, ingredient))
+                return true;
+        
         return false;
     }
 
     public boolean contains(Item ingred) {
-        for (ItemStack item : items) if (item.getItem() == ingred) return true;
-
+        for(ItemStack item : items)
+            if(item.getItem() == ingred)
+                return true;
+        
         return false;
     }
-
+    
     @Override
     public String toString() {
         return "PositionedStack(output='" + item.toString() + "')";

src/main/java/codechicken/nei/PresetsWidget.java

@@ -1,922 +0,0 @@
-package codechicken.nei;
-
-import static codechicken.nei.NEIClientUtils.translate;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.stream.Collectors;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.FontRenderer;
-import net.minecraft.item.ItemStack;
-
-import org.apache.commons.io.IOUtils;
-import org.lwjgl.input.Keyboard;
-
-import codechicken.core.CommonUtils;
-import codechicken.core.gui.GuiScrollSlot;
-import codechicken.lib.gui.GuiDraw;
-import codechicken.lib.vec.Rectangle4i;
-import codechicken.nei.ItemPanel.ItemPanelSlot;
-import codechicken.nei.api.ItemFilter;
-import codechicken.nei.recipe.GuiRecipe;
-import codechicken.nei.recipe.StackInfo;
-import codechicken.nei.util.NBTJson;
-
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
-import com.google.gson.JsonPrimitive;
-import com.google.gson.JsonSyntaxException;
-import cpw.mods.fml.common.registry.GameRegistry;
-
-public class PresetsWidget extends Widget {
-
-    public static class PresetTag implements ItemFilter {
-
-        public String filename = null;
-        public String displayName = "";
-        public boolean whitelist = true;
-        public HashSet<String> items;
-
-        public PresetTag(String displayName) {
-            this(displayName, new HashSet<>(), false, null);
-        }
-
-        public PresetTag(String displayName, HashSet<String> items) {
-            this(displayName, items, true, null);
-        }
-
-        public PresetTag(String displayName, HashSet<String> items, boolean whitelist, String filename) {
-            this.displayName = displayName;
-            this.items = items != null ? items : new HashSet<>();
-            this.whitelist = whitelist;
-            this.filename = filename;
-        }
-
-        public boolean matches(final ItemStack stack) {
-            return items.contains(StackInfo.getItemStackGUID(stack)) == whitelist;
-        }
-
-        public static PresetTag loadFromFile(File file) {
-            if (!file.isFile() || !file.exists() || file.getName().equals("selected.ini")) {
-                return null;
-            }
-
-            try {
-
-                List<String> itemStrings;
-                try (FileInputStream input = new FileInputStream(file)) {
-                    NEIClientConfig.logger.info("Loading presets from file {}", file);
-                    itemStrings = IOUtils.readLines(input, "UTF-8");
-                } catch (IOException e) {
-                    NEIClientConfig.logger.error("Failed to load presets from file {}", file, e);
-                    return null;
-                }
-
-                final JsonParser parser = new JsonParser();
-                final JsonObject metaObject = parser.parse(itemStrings.remove(0)).getAsJsonObject();
-                final String displayName = metaObject.get("displayName").getAsString();
-                final boolean whitelist = metaObject.get("whitelist").getAsBoolean();
-                final HashSet<String> items = new HashSet<>();
-
-                for (String itemStr : itemStrings) {
-                    items.add(itemStr);
-                }
-
-                return new PresetTag(displayName, items, whitelist, file.getName());
-            } catch (Throwable th) {
-                NEIClientConfig.logger.error("Failed to load presets ItemStack from file", file);
-            }
-
-            return null;
-        }
-
-        public void deleteFile() {
-            if (presetsDir == null || filename == null) return;
-            final File tagFile = new File(presetsDir, filename);
-
-            if (tagFile.exists()) {
-                tagFile.delete();
-            }
-        }
-
-        public void saveToFile() {
-            if (presetsDir == null) return;
-
-            if (filename == null) {
-                final String sanitized = displayName.replaceAll("[^_\\-.0-9a-zA-Z]", "_");
-                int index = 1;
-
-                filename = sanitized + ".ini";
-
-                while ((new File(presetsDir, filename)).exists() || filename.equals("selected.ini")) {
-                    filename = sanitized + " (" + index + ").ini";
-                    index++;
-                }
-            }
-
-            final List<String> strings = new ArrayList<>();
-            final JsonObject row = new JsonObject();
-
-            row.add("displayName", new JsonPrimitive(displayName));
-            row.add("whitelist", new JsonPrimitive(whitelist));
-
-            strings.add(NBTJson.toJson(row));
-
-            try {
-                strings.addAll(items);
-            } catch (JsonSyntaxException e) {
-                NEIClientConfig.logger.error("Failed to stringify presets ItemStack to json string");
-            }
-
-            final File tagFile = new File(presetsDir, filename);
-
-            try (FileOutputStream output = new FileOutputStream(tagFile)) {
-                IOUtils.writeLines(strings, "\n", output, "UTF-8");
-            } catch (IOException e) {
-                NEIClientConfig.logger.error("Filed to save presets list to file {}", tagFile, e);
-            }
-        }
-
-        @SuppressWarnings("unchecked")
-        public PresetTag copy() {
-            return new PresetTag(displayName, (HashSet) items.clone(), whitelist, null);
-        }
-    }
-
-    protected static class SubsetListBox extends GuiScrollSlot {
-
-        protected final List<PresetTag> presets = new ArrayList<>();
-        protected final List<PresetTag> selected = new ArrayList<>();
-        protected int lastSelectedIndex = 0;
-
-        public SubsetListBox(File presetsDir) {
-            super(0, 0, 0, 0);
-            setSmoothScroll(false);
-
-            try {
-
-                presets.addAll(
-                        ItemList.forkJoinPool.submit(
-                                () -> Arrays.asList(presetsDir.listFiles()).parallelStream()
-                                        .map(f -> PresetTag.loadFromFile(f)).filter(p -> p != null)
-                                        .collect(Collectors.toCollection(ArrayList::new)))
-                                .get());
-
-            } catch (InterruptedException | ExecutionException e) {
-                e.printStackTrace();
-                return;
-            }
-
-            selected.addAll(loadSelFromFile(presetsDir, presets));
-            sort();
-        }
-
-        public SubsetListBox() {
-            super(0, 0, 0, 0);
-            setSmoothScroll(false);
-        }
-
-        public void addTag(final PresetTag tag, boolean sel) {
-            presets.add(tag);
-
-            if (sel) {
-                selected.add(tag);
-            }
-        }
-
-        protected List<PresetTag> getPresets() {
-            return presets;
-        }
-
-        protected List<PresetTag> getSelected() {
-            return selected;
-        }
-
-        public void replaceSeleted(final PresetTag tag) {
-
-            if (selected.size() == 1) {
-                selected.get(0).deleteFile();
-                presets.set(presets.indexOf(selected.get(0)), tag);
-                selected.set(0, tag);
-            } else {
-                presets.add(tag);
-                selected.add(tag);
-            }
-
-            tag.saveToFile();
-            saveSelToFile();
-            sort();
-        }
-
-        public void sort() {
-            presets.sort((o1, o2) -> o1.displayName.compareTo(o2.displayName));
-        }
-
-        public void clear() {
-            presets.clear();
-            selected.clear();
-        }
-
-        @Override
-        public int getSlotHeight(int slot) {
-            return 18;
-        }
-
-        @Override
-        protected int getNumSlots() {
-            return presets.size();
-        }
-
-        @Override
-        protected void slotClicked(int slot, int button, int mx, int my, int count) {
-
-            if (slot >= presets.size()) {
-                return;
-            }
-
-            final PresetTag tag = presets.get(slot);
-            final int width = windowBounds().width;
-
-            final Rectangle4i direction = new Rectangle4i(0, 0, 18, 18);
-            final Rectangle4i delete = new Rectangle4i(width - 18, 0, 18, 18);
-            final Rectangle4i option = new Rectangle4i(18, 0, width - 18 - 18, 18);
-
-            if (option.contains(mx, my)) {
-                final boolean sel = selected.contains(tag);
-
-                if (NEIClientUtils.controlKey()) {
-
-                    if (sel) {
-                        selected.remove(tag);
-                    } else {
-                        selected.add(tag);
-                    }
-
-                } else if (NEIClientUtils.shiftKey()) {
-                    selected.clear();
-
-                    for (int i = Math.min(lastSelectedIndex, slot); i <= Math.max(lastSelectedIndex, slot); i++) {
-                        if (!selected.contains(presets.get(i))) {
-                            selected.add(presets.get(i));
-                        }
-                    }
-
-                } else {
-                    final int size = selected.size();
-                    selected.clear();
-
-                    if (!sel || size > 1) {
-                        selected.add(tag);
-                    }
-                }
-
-                if (selected.isEmpty()) {
-                    lastSelectedIndex = 0;
-                } else if (!NEIClientUtils.shiftKey()) {
-                    lastSelectedIndex = slot;
-                }
-
-            } else if (delete.contains(mx, my)) {
-                presets.remove(tag);
-                selected.remove(tag);
-                tag.deleteFile();
-            } else if (direction.contains(mx, my)) {
-                tag.whitelist = !tag.whitelist;
-                tag.saveToFile();
-            }
-
-            saveSelToFile();
-            PresetsWidget.edit = null;
-            PresetsWidget.openListBox = !presets.isEmpty()
-                    && (NEIClientUtils.controlKey() || NEIClientUtils.shiftKey() || !option.contains(mx, my));
-            ItemList.updateFilter.restart();
-        }
-
-        @Override
-        protected void drawSlot(int slot, int x, int y, int mx, int my, float frame) {
-            if (slot >= presets.size()) {
-                return;
-            }
-
-            final int width = windowBounds().width;
-            final Rectangle4i direction = new Rectangle4i(x, y, 18, 18);
-            final Rectangle4i delete = new Rectangle4i(x + width - 18, y, 18, 18);
-            final Rectangle4i option = new Rectangle4i(x + 18, y, width - 18 - 18, 18);
-            final PresetTag tag = presets.get(slot);
-
-            final int optionState = selected.contains(tag) ? 0 : option.contains(x + mx, y + my) ? 1 : 2;
-            final int directionState = direction.contains(x + mx, y + my) ? 1 : 2;
-            final int deleteState = delete.contains(x + mx, y + my) ? 1 : 2;
-
-            final String displayName = NEIClientUtils
-                    .cropText(PresetsWidget.fontRenderer, tag.displayName, option.w - 6);
-            final String dirName = tag.whitelist ? translate("presets.whitelist.label")
-                    : translate("presets.blacklist.label");
-
-            // blacklist or whitelist
-            LayoutManager.getLayoutStyle()
-                    .drawSubsetTag(null, direction.x, direction.y, direction.w, direction.h, directionState, false);
-            GuiDraw.drawString(dirName, direction.x + 6, direction.y + 5, directionState == 2 ? 0xFFE0E0E0 : 0xFFFFA0);
-
-            // option name
-            LayoutManager.getLayoutStyle()
-                    .drawSubsetTag(null, option.x, option.y, option.w, option.h, optionState, false);
-            GuiDraw.drawString(displayName, option.x + 3, option.y + 5, optionState == 2 ? 0xFFE0E0E0 : 0xFFFFA0);
-
-            // remove icon
-            LayoutManager.getLayoutStyle()
-                    .drawSubsetTag(null, delete.x, delete.y, delete.w, delete.h, deleteState, false);
-            GuiDraw.drawString("✕", delete.x + 6, delete.y + 5, deleteState == 2 ? 0xFFE0E0E0 : 0x601010);
-        }
-
-        @Override
-        public void drawOverlay(float frame) {}
-
-        @Override
-        public void drawBackground(float frame) {
-            drawRect(x, y, x + width, y + height, 0xFF202020);
-        }
-
-        @Override
-        public void drawScrollbar(float frame) {
-            if (hasScrollbar()) {
-                super.drawScrollbar(frame);
-            }
-        }
-
-        @Override
-        public int scrollbarGuideAlignment() {
-            return 0;
-        }
-
-        protected List<PresetTag> loadSelFromFile(File presetsDir, List<PresetTag> presets) {
-            final File file = new File(presetsDir, "selected.ini");
-            List<PresetTag> selected = new ArrayList<>();
-
-            if (file.exists()) {
-
-                try {
-
-                    List<String> itemStrings;
-                    try (FileInputStream input = new FileInputStream(file)) {
-                        NEIClientConfig.logger.info("Loading presets selected from file {}", file);
-                        itemStrings = IOUtils.readLines(input, "UTF-8");
-                    } catch (IOException e) {
-                        NEIClientConfig.logger.error("Failed to load presets selected from file {}", file, e);
-                        return selected;
-                    }
-
-                    final HashMap<String, PresetTag> map = new HashMap<>();
-
-                    for (PresetTag tag : presets) {
-                        map.put(tag.filename, tag);
-                    }
-
-                    for (String filename : itemStrings) {
-                        if (map.containsKey(filename)) {
-                            selected.add(map.get(filename));
-                        }
-                    }
-
-                } catch (Throwable th) {
-                    NEIClientConfig.logger.error("Failed to load presets selected from file", file);
-                }
-            }
-
-            return selected;
-        }
-
-        public void saveSelToFile() {
-
-            final File file = new File(presetsDir, "selected.ini");
-            final List<String> list = new ArrayList<>();
-
-            for (final PresetTag tag : selected) {
-                list.add(tag.filename);
-            }
-
-            try (FileOutputStream output = new FileOutputStream(file)) {
-                IOUtils.writeLines(list, "\n", output, "UTF-8");
-            } catch (IOException e) {
-                NEIClientConfig.logger.error("Filed to save presets selected list to file {}", file, e);
-            }
-        }
-    }
-
-    protected static class MouseSelection {
-
-        public int startX = -1;
-        public int startY = -1;
-        public int startIndex = -1;
-        public int endIndex = -1;
-        public HashSet<ItemStack> items = new HashSet<>();
-        public boolean append = true;
-
-        public MouseSelection(int slotIndex, boolean append) {
-            final ItemsGrid grid = ItemPanels.itemPanel.getGrid();
-            final Rectangle4i rec = grid.getItemRect(slotIndex);
-
-            this.append = append;
-            endIndex = slotIndex;
-            startIndex = slotIndex;
-            startX = rec.x;
-            startY = rec.y;
-        }
-    }
-
-    protected static final FontRenderer fontRenderer = Minecraft.getMinecraft().fontRenderer;
-    protected static SubsetListBox listbox = new SubsetListBox();
-    protected static File presetsDir;
-
-    protected static boolean openListBox = false;
-    protected static PresetTag edit;
-    protected long lastclicktime;
-    protected static MouseSelection mouseSelection;
-
-    protected static final Button dropdown = new Button() {
-
-        public boolean onButtonPress(boolean rightclick) {
-            if (!rightclick) {
-                openListBox = !openListBox;
-                return true;
-            }
-
-            return false;
-        }
-
-        @Override
-        public String getRenderLabel() {
-            return "...";
-        }
-    };
-
-    protected static final Label selectedValue = new Label("", false) {
-
-        @Override
-        public void draw(int mousex, int mousey) {
-            final String text = NEIClientUtils.cropText(fontRenderer, this.text, w);
-
-            if (text.equals(this.text)) {
-                GuiDraw.drawString(text, x + w - fontRenderer.getStringWidth(text), y + (h - 8) / 2, colour);
-            } else {
-                GuiDraw.drawString(text, x, y + (h - 8) / 2, colour);
-            }
-        }
-
-        @Override
-        public List<String> handleTooltip(int mx, int my, List<String> tooltip) {
-            if (contains(mx, my) && listbox.getSelected().size() <= 1) {
-                tooltip.add(translate("presets.label.tooltip"));
-            }
-
-            return tooltip;
-        }
-    };
-
-    protected static final TextField selectedDisplayName = new TextField("") {
-
-        public void onTextChange(String oldText) {
-            if (edit != null) {
-                edit.displayName = text();
-            }
-        }
-
-        @Override
-        public void draw(int mousex, int mousey) {
-            super.draw(mousex, mousey);
-
-            if (text().isEmpty()) {
-                GuiDraw.drawGradientRect(x - 1, y - 1, 1, h + 2, 0xFFcc3300, 0xFFcc3300); // Left
-                GuiDraw.drawGradientRect(x - 1, y - 1, w + 2, 1, 0xFFcc3300, 0xFFcc3300); // Top
-                GuiDraw.drawGradientRect(x + w, y - 1, 1, h + 2, 0xFFcc3300, 0xFFcc3300); // Left
-                GuiDraw.drawGradientRect(x - 1, y + h, w + 2, 1, 0xFFcc3300, 0xFFcc3300); // Bottom
-            }
-        }
-
-        @Override
-        public List<String> handleTooltip(int mx, int my, List<String> tooltip) {
-            if (contains(mx, my) && listbox.getSelected().size() <= 1) {
-                tooltip.add(translate("presets.textfield.tooltip.1"));
-                tooltip.add(translate("presets.textfield.tooltip.2"));
-            }
-
-            return tooltip;
-        }
-    };
-
-    protected static final Button selectedState = new Button("B") {
-
-        public boolean onButtonPress(boolean rightclick) {
-            if (!rightclick && edit != null) {
-                edit.whitelist = !edit.whitelist;
-                return true;
-            }
-
-            return false;
-        }
-
-        @Override
-        public String getRenderLabel() {
-            return edit != null && edit.whitelist ? translate("presets.whitelist.label")
-                    : translate("presets.blacklist.label");
-        }
-
-        @Override
-        public void addTooltips(List<String> tooltip) {
-            if (edit != null) {
-                tooltip.add(
-                        edit.whitelist ? translate("presets.whitelist.tooltip")
-                                : translate("presets.blacklist.tooltip"));
-            }
-        }
-    };
-
-    protected static void setEditedTag(final PresetTag tag) {
-        edit = tag;
-        openListBox = false;
-        selectedDisplayName.setText(tag != null ? tag.displayName : "");
-        ItemList.updateFilter.restart();
-    }
-
-    public static void addTag(final PresetTag tag) {
-        addTag(tag, false);
-    }
-
-    public static void addTag(final PresetTag tag, boolean sel) {
-        listbox.addTag(tag, sel);
-    }
-
-    public static boolean inEditMode() {
-        return edit != null;
-    }
-
-    public static boolean isHidden(final ItemStack item) {
-
-        if (edit != null) {
-
-            if (mouseSelection != null && mouseSelection.items.contains(item)) {
-                return mouseSelection.append != edit.whitelist;
-            }
-
-            return !edit.matches(item);
-        }
-
-        if (!listbox.getSelected().isEmpty()) {
-            final List<PresetTag> selected = listbox.getSelected();
-
-            for (int idx = 0; idx < selected.size(); idx++) {
-                if (!selected.get(idx).matches(item)) {
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    }
-
-    public static void setHidden(final ItemStack stack, final boolean append) {
-        if (edit == null) {
-            return;
-        }
-
-        if (NEIClientUtils.shiftKey()) {
-            final ArrayList<ItemStack> items = ItemPanels.itemPanel.getItems();
-
-            for (int i = 0; i < items.size(); i++) {
-                if (stack.getItem().equals(items.get(i).getItem())) {
-                    hideItem(items.get(i), append);
-                }
-            }
-
-        } else if (NEIClientUtils.controlKey()) {
-            final String modId = getModId(stack);
-
-            if (modId == null) {
-                hideItem(stack, append);
-            } else {
-                final ArrayList<ItemStack> items = ItemPanels.itemPanel.getItems();
-
-                for (int i = 0; i < items.size(); i++) {
-                    final String mod = getModId(items.get(i));
-                    if (mod != null && mod.equals(modId)) {
-                        hideItem(items.get(i), append);
-                    }
-                }
-            }
-
-        } else {
-            hideItem(stack, append);
-        }
-    }
-
-    protected static void hideItem(final ItemStack stack, boolean append) {
-        final String guid = StackInfo.getItemStackGUID(stack);
-
-        if (append) {
-            edit.items.add(guid);
-        } else {
-            edit.items.remove(guid);
-        }
-    }
-
-    protected static String getModId(final ItemStack stack) {
-        try {
-            return GameRegistry.findUniqueIdentifierFor(stack.getItem()).modId;
-        } catch (Exception ignored) {}
-
-        return null;
-    }
-
-    public static void loadPresets(final String worldPath) {
-        final File dir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + worldPath);
-        presetsDir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + worldPath + "/presets");
-
-        if (!dir.exists()) {
-            dir.mkdirs();
-        }
-
-        if (!presetsDir.exists()) {
-            presetsDir.mkdirs();
-        }
-
-        listbox = new SubsetListBox(presetsDir);
-
-        edit = null;
-        openListBox = false;
-        selectedDisplayName.setText("");
-
-        ItemList.updateFilter.restart();
-    }
-
-    @Override
-    public void draw(int mx, int my) {
-
-        if (edit != null) {
-
-            selectedState.x = x;
-            selectedState.y = y;
-            selectedState.w = selectedState.h = h;
-            selectedState.draw(mx, my);
-
-            selectedDisplayName.y = y;
-            selectedDisplayName.h = h;
-            selectedDisplayName.x = selectedState.x + selectedState.w + 1;
-            selectedDisplayName.w = w - h * 2 - 5;
-            selectedDisplayName.draw(mx, my);
-
-        } else {
-            final List<PresetTag> selected = listbox.getSelected();
-            final int size = selected.size();
-
-            selectedValue.text = size > 1 ? translate("presets.label.selected", size)
-                    : (size == 1 ? selected.get(0).displayName : "");
-            selectedValue.y = y;
-            selectedValue.h = h;
-            selectedValue.w = w - h - 4;
-            selectedValue.x = x;
-
-            selectedValue.draw(mx, my);
-        }
-
-        dropdown.y = y;
-        dropdown.w = dropdown.h = h;
-        dropdown.x = x + w - dropdown.w;
-        dropdown.state = edit != null || listbox.getNumSlots() == 0 ? 2 : 0;
-        dropdown.draw(mx, my);
-
-        if (openListBox) {
-            final int scrollbarWidth = listbox.hasScrollbar() ? listbox.scrollbarDim().width : 0;
-
-            listbox.setSize(
-                    x,
-                    y + h + 1,
-                    w,
-                    Math.min(((LayoutManager.searchField.y - h - y) / 18) * 18, listbox.contentHeight()));
-
-            listbox.setMargins(0, 0, scrollbarWidth, 0);
-            listbox.draw(mx, my, 0);
-        }
-    }
-
-    @Override
-    public boolean contains(int px, int py) {
-        return super.contains(px, py) || openListBox && listbox.contains(px, py);
-    }
-
-    @Override
-    public boolean handleClick(int mx, int my, int button) {
-
-        if (openListBox && listbox.contains(mx, my)) {
-            listbox.mouseClicked(mx, my, button);
-            return true;
-        }
-
-        if (edit != null) {
-
-            if (selectedState.contains(mx, my)) {
-                selectedState.handleClick(mx, my, button);
-                return true;
-            }
-
-            if (selectedDisplayName.contains(mx, my)) {
-                selectedDisplayName.handleClick(mx, my, button);
-                return true;
-            }
-
-        } else {
-
-            if (button == 0 && dropdown.contains(mx, my)) {
-                openListBox = !openListBox;
-                return true;
-            }
-
-            openListBox = false;
-
-            if (button == 0 && selectedValue.contains(mx, my)) {
-
-                if (System.currentTimeMillis() - lastclicktime < 400) { // double click
-                    final List<PresetTag> selected = listbox.getSelected();
-                    final int size = selected.size();
-
-                    if (size <= 1) {
-                        setEditedTag(size == 1 ? selected.get(0).copy() : new PresetTag(""));
-                    }
-                }
-
-                lastclicktime = System.currentTimeMillis();
-            }
-        }
-
-        return contains(mx, my);
-    }
-
-    @Override
-    public boolean handleClickExt(int mx, int my, int button) {
-
-        if (edit != null && mouseSelection == null) {
-            ItemPanelSlot slot = ItemPanels.itemPanel.getSlotMouseOver(mx, my);
-
-            if (slot != null && button != 2) {
-                mouseSelection = new MouseSelection(slot.slotIndex, button == 0);
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    @Override
-    public boolean handleKeyPress(int keyID, char keyChar) {
-        if (keyID == Keyboard.KEY_ESCAPE) {
-            openListBox = false;
-        }
-
-        if (edit == null) {
-            return false;
-        }
-
-        if (selectedDisplayName.focused() && (keyID == Keyboard.KEY_RETURN || keyID == Keyboard.KEY_NUMPADENTER)
-                && !selectedDisplayName.text().isEmpty()) {
-            selectedDisplayName.handleKeyPress(keyID, keyChar);
-            selectedDisplayName.setFocus(false);
-            listbox.replaceSeleted(edit);
-            setEditedTag(null);
-            return true;
-        } else if (selectedDisplayName.focused()) {
-            return selectedDisplayName.handleKeyPress(keyID, keyChar);
-        } else if (keyID == Keyboard.KEY_ESCAPE && !(NEIClientUtils.mc().currentScreen instanceof GuiRecipe)) {
-            setEditedTag(null);
-            return true;
-        }
-
-        return false;
-    }
-
-    @Override
-    public void mouseDragged(int mx, int my, int button, long heldTime) {
-
-        if (openListBox) {
-            listbox.mouseDragged(mx, my, button, heldTime);
-        }
-
-        if (edit != null && button != 2 && mouseSelection != null) {
-            final ItemPanelSlot slot = ItemPanels.itemPanel.getSlotMouseOver(mx, my);
-
-            if (slot != null && slot.slotIndex != mouseSelection.endIndex) {
-                final ItemsGrid grid = ItemPanels.itemPanel.getGrid();
-                mouseSelection.endIndex = slot.slotIndex;
-                mouseSelection.items.clear();
-
-                final Rectangle4i rec = grid.getItemRect(slot.slotIndex);
-                final Rectangle4i sel = new Rectangle4i(
-                        Math.min(rec.x, mouseSelection.startX),
-                        Math.min(rec.y, mouseSelection.startY),
-                        Math.max(rec.x, mouseSelection.startX) - Math.min(rec.x, mouseSelection.startX),
-                        Math.max(rec.y, mouseSelection.startY) - Math.min(rec.y, mouseSelection.startY));
-
-                for (int x = sel.x; x <= sel.x + sel.w; x += ItemsGrid.SLOT_SIZE) {
-                    for (int y = sel.y; y <= sel.y + sel.h; y += ItemsGrid.SLOT_SIZE) {
-                        ItemStack stack = ItemPanels.itemPanel.getStackMouseOver(x, y);
-
-                        if (stack != null) {
-                            mouseSelection.items.add(stack);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    @Override
-    public void mouseUp(int mx, int my, int button) {
-
-        if (openListBox) {
-            listbox.mouseMovedOrUp(mx, my, button);
-        }
-
-        if (edit != null && mouseSelection != null) {
-            ItemPanelSlot hoverSlot = ItemPanels.itemPanel.getSlotMouseOver(mx, my);
-
-            if (hoverSlot != null && hoverSlot.slotIndex == mouseSelection.startIndex) {
-                setHidden(hoverSlot.item, button == 0);
-            } else if (!mouseSelection.items.isEmpty()) {
-
-                for (ItemStack stack : mouseSelection.items) {
-                    hideItem(stack, mouseSelection.append);
-                }
-            }
-
-            mouseSelection = null;
-        }
-    }
-
-    @Override
-    public boolean onMouseWheel(int i, int mx, int my) {
-
-        if (openListBox && listbox.hasScrollbar() && listbox.contains(mx, my)) {
-            listbox.scroll(-i);
-            return true;
-        }
-
-        return false;
-    }
-
-    @Override
-    public void onGuiClick(int mx, int my) {
-
-        if (!contains(mx, my)) {
-            openListBox = false;
-        }
-
-        selectedDisplayName.onGuiClick(mx, my);
-    }
-
-    @Override
-    public List<String> handleTooltip(int mx, int my, List<String> tooltip) {
-
-        if (edit != null) {
-
-            if (selectedState.contains(mx, my)) {
-                return selectedState.handleTooltip(mx, my, tooltip);
-            }
-
-            if (selectedDisplayName.contains(mx, my)) {
-                return selectedDisplayName.handleTooltip(mx, my, tooltip);
-            }
-
-        } else {
-
-            if (selectedValue.contains(mx, my)) {
-                return selectedValue.handleTooltip(mx, my, tooltip);
-            }
-        }
-
-        return tooltip;
-    }
-
-    public static boolean matches(ItemStack stack) {
-
-        if (edit != null) {
-            return true;
-        }
-
-        final List<PresetTag> selected = listbox.getSelected();
-
-        for (int idx = 0; idx < selected.size(); idx++) {
-            if (!selected.get(idx).matches(stack)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-}

src/main/java/codechicken/nei/RestartableTask.java

@@ -1,7 +1,7 @@
 package codechicken.nei;
 
-public abstract class RestartableTask {
-
+public abstract class RestartableTask
+{
     public final String name;
     private Thread thread;
     private volatile boolean restart;
@@ -15,22 +15,21 @@ public abstract class RestartableTask {
 
     private void start() {
         thread = new Thread(name) {
-
             @Override
             public void run() {
                 do {
-                    while (stopped) try {
-                        Thread.sleep(1);
-                    } catch (InterruptedException ignored) {}
-                    if (!restart) execute();
-                } while (!finish());
+                    while(stopped)
+                        try { Thread.sleep(1); } catch (InterruptedException ignored) {}
+                    if(!restart)
+                        execute();
+                } while(!finish());
             }
         };
         thread.start();
     }
 
     private synchronized boolean finish() {
-        if (restart) {
+        if(restart) {
             restart = false;
             return false;
         } else {
@@ -45,18 +44,19 @@ public abstract class RestartableTask {
     }
 
     public synchronized void restart() {
-        if (thread != null) {
+        if(thread != null) {
             stopped = false;
             restart = true;
-        } else start();
+        }
+        else
+            start();
     }
 
     /**
-     * Stops execution until restart is called. If a thread is running, the restart flag will be set, and the thread
-     * will be paused once the execute method exits.
+     * Stops execution until restart is called. If a thread is running, the restart flag will be set, and the thread will be paused once the execute method exits.
      */
     public synchronized void stop() {
-        if (thread != null) {
+        if(thread != null) {
             stopped = true;
             restart = true;
         }

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

@@ -1,14 +1,5 @@
 package codechicken.nei;
 
-import static codechicken.nei.NEIClientConfig.world;
-
-import java.util.LinkedList;
-import java.util.List;
-import java.util.regex.Pattern;
-import java.util.regex.PatternSyntaxException;
-
-import net.minecraft.util.EnumChatFormatting;
-
 import codechicken.lib.gui.GuiDraw;
 import codechicken.nei.ItemList.AnyMultiItemFilter;
 import codechicken.nei.ItemList.EverythingItemFilter;
@@ -16,15 +7,22 @@ import codechicken.nei.ItemList.PatternItemFilter;
 import codechicken.nei.api.API;
 import codechicken.nei.api.ItemFilter;
 import codechicken.nei.api.ItemFilter.ItemFilterProvider;
-import codechicken.nei.util.TextHistory;
+import net.minecraft.util.EnumChatFormatting;
 
-public class SearchField extends TextField implements ItemFilterProvider {
+import java.util.LinkedList;
+import java.util.List;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
 
+import static codechicken.nei.NEIClientConfig.world;
+
+public class SearchField extends TextField implements ItemFilterProvider
+{
     /**
      * Interface for returning a custom filter based on search field text
      */
-    public static interface ISearchProvider {
-
+    public static interface ISearchProvider
+    {
         /**
          * @return false if this filter should only be used if no other non-default filters match the search string
          */
@@ -36,8 +34,8 @@ public class SearchField extends TextField implements ItemFilterProvider {
         public ItemFilter getFilter(String searchText);
     }
 
-    private static class DefaultSearchProvider implements ISearchProvider {
-
+    private static class DefaultSearchProvider implements ISearchProvider
+    {
         @Override
         public boolean isPrimary() {
             return false;
@@ -51,8 +49,6 @@ public class SearchField extends TextField implements ItemFilterProvider {
     }
 
     public static List<ISearchProvider> searchProviders = new LinkedList<>();
-    private static final TextHistory history = new TextHistory();
-    private boolean isVisible = true;
 
     long lastclicktime;
 
@@ -66,17 +62,9 @@ public class SearchField extends TextField implements ItemFilterProvider {
         return world.nbt.getBoolean("searchinventories");
     }
 
-    public boolean isVisible() {
-        return isVisible;
-    }
-
-    public void setVisible(boolean visible) {
-        isVisible = visible;
-    }
-
     @Override
     public int getTextColour() {
-        if (ItemPanels.itemPanel.getItems().isEmpty()) {
+        if(ItemPanels.itemPanel.realItems.size() == 0) {
             return focused() ? 0xFFcc3300 : 0xFF993300;
         } else {
             return focused() ? 0xFFE0E0E0 : 0xFF909090;
@@ -89,17 +77,18 @@ public class SearchField extends TextField implements ItemFilterProvider {
         super.draw(mousex, mousey);
 
         if (searchInventories()) {
-            GuiDraw.drawGradientRect(x - 1, y - 1, 1, h + 2, 0xFFFFFF00, 0xFFC0B000); // Left
-            GuiDraw.drawGradientRect(x - 1, y - 1, w + 2, 1, 0xFFFFFF00, 0xFFC0B000); // Top
-            GuiDraw.drawGradientRect(x + w, y - 1, 1, h + 2, 0xFFFFFF00, 0xFFC0B000); // Left
-            GuiDraw.drawGradientRect(x - 1, y + h, w + 2, 1, 0xFFFFFF00, 0xFFC0B000); // Bottom
+            GuiDraw.drawGradientRect(x - 1, y - 1, 1, h + 2, 0xFFFFFF00, 0xFFC0B000); //Left
+            GuiDraw.drawGradientRect(x - 1, y - 1, w + 2, 1, 0xFFFFFF00, 0xFFC0B000); //Top
+            GuiDraw.drawGradientRect(x + w, y - 1, 1, h + 2, 0xFFFFFF00, 0xFFC0B000); //Left
+            GuiDraw.drawGradientRect(x - 1, y + h, w + 2, 1, 0xFFFFFF00, 0xFFC0B000); //Bottom
         }
+
     }
 
     @Override
     public boolean handleClick(int mousex, int mousey, int button) {
         if (button == 0) {
-            if (focused() && (System.currentTimeMillis() - lastclicktime < 400)) { // double click
+            if (focused() && (System.currentTimeMillis() - lastclicktime < 400)) { //double click
                 NEIClientConfig.world.nbt.setBoolean("searchinventories", !searchInventories());
                 NEIClientConfig.world.saveNBT();
             }
@@ -111,7 +100,8 @@ public class SearchField extends TextField implements ItemFilterProvider {
     @Override
     public void onTextChange(String oldText) {
         final String newText = text();
-        if (newText.length() > 0) NEIClientConfig.logger.debug("Searching for " + text());
+        if( newText.length() > 0)
+            NEIClientConfig.logger.debug("Searching for " + text());
 
         NEIClientConfig.setSearchExpression(newText);
         ItemList.updateFilter.restart();
@@ -119,17 +109,8 @@ public class SearchField extends TextField implements ItemFilterProvider {
 
     @Override
     public void lastKeyTyped(int keyID, char keyChar) {
-
-        if (isVisible() && NEIClientConfig.isKeyHashDown("gui.search")) {
+        if (keyID == NEIClientConfig.getKeyBinding("gui.search"))
             setFocus(true);
-        }
-        if (NEIClientConfig.isKeyHashDown("gui.getprevioussearch") && focused()) {
-            handleNavigateHistory(TextHistory.Direction.PREVIOUS);
-        }
-
-        if (NEIClientConfig.isKeyHashDown("gui.getnextsearch") && focused()) {
-            handleNavigateHistory(TextHistory.Direction.NEXT);
-        }
     }
 
     @Override
@@ -139,11 +120,14 @@ public class SearchField extends TextField implements ItemFilterProvider {
 
     public static Pattern getPattern(String search) {
         switch (NEIClientConfig.getIntSetting("inventory.searchmode")) {
-            case 0: // plain
+            case 0://plain
                 search = "\\Q" + search + "\\E";
                 break;
             case 1:
-                search = search.replace(".", "").replace("?", ".").replace("*", ".+?");
+                search = search
+                        .replace(".", "")
+                        .replace("?", ".")
+                        .replace("*", ".+?");
                 break;
         }
 
@@ -162,31 +146,12 @@ public class SearchField extends TextField implements ItemFilterProvider {
         List<ItemFilter> secondary = new LinkedList<>();
         for (ISearchProvider p : searchProviders) {
             ItemFilter filter = p.getFilter(s_filter);
-            if (filter != null) (p.isPrimary() ? primary : secondary).add(filter);
+            if (filter != null)
+                (p.isPrimary() ? primary : secondary).add(filter);
         }
 
         if (!primary.isEmpty()) return new AnyMultiItemFilter(primary);
         if (!secondary.isEmpty()) return new AnyMultiItemFilter(secondary);
         return new EverythingItemFilter();
     }
-
-    @Override
-    public void setFocus(boolean focus) {
-        final boolean previousFocus = field.isFocused();
-
-        if (previousFocus != focus) {
-            history.add(text());
-        }
-        super.setFocus(focus);
-    }
-
-    private boolean handleNavigateHistory(TextHistory.Direction direction) {
-        if (focused()) {
-            return history.get(direction, text()).map(newText -> {
-                setText(newText);
-                return true;
-            }).orElse(false);
-        }
-        return false;
-    }
 }

src/main/java/codechicken/nei/ServerHandler.java

@@ -1,13 +1,5 @@
 package codechicken.nei;
 
-import java.util.List;
-
-import net.minecraft.entity.item.EntityItem;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.world.World;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.event.world.WorldEvent;
-
 import codechicken.core.CommonUtils;
 import codechicken.lib.packet.PacketCustom;
 import cpw.mods.fml.common.FMLCommonHandler;
@@ -18,9 +10,16 @@ import cpw.mods.fml.common.gameevent.PlayerEvent.PlayerLoggedOutEvent;
 import cpw.mods.fml.common.gameevent.PlayerEvent.PlayerRespawnEvent;
 import cpw.mods.fml.common.gameevent.TickEvent;
 import cpw.mods.fml.common.gameevent.TickEvent.Phase;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.world.WorldEvent;
 
-public class ServerHandler {
+import java.util.List;
 
+public class ServerHandler
+{
     private static ServerHandler instance;
 
     public static void load() {
@@ -35,15 +34,15 @@ public class ServerHandler {
 
     @SubscribeEvent
     public void tickEvent(TickEvent.WorldTickEvent event) {
-        if (event.phase == Phase.START && !event.world.isRemote
-                && NEIServerConfig.dimTags.containsKey(CommonUtils.getDimension(event.world))) // fake worlds that don't
-                                                                                               // call Load
+        if (event.phase == Phase.START && !event.world.isRemote &&
+                NEIServerConfig.dimTags.containsKey(CommonUtils.getDimension(event.world)))//fake worlds that don't call Load
             processDisabledProperties(event.world);
     }
 
     @SubscribeEvent
     public void loadEvent(WorldEvent.Load event) {
-        if (!event.world.isRemote) NEIServerConfig.load(event.world);
+        if(!event.world.isRemote)
+            NEIServerConfig.load(event.world);
     }
 
     @SubscribeEvent
@@ -51,7 +50,8 @@ public class ServerHandler {
         if (event.phase == Phase.START && event.player instanceof EntityPlayerMP) {
             EntityPlayerMP player = (EntityPlayerMP) event.player;
             PlayerSave save = NEIServerConfig.forPlayer(player.getCommandSenderName());
-            if (save == null) return;
+            if (save == null)
+                return;
             updateMagneticPlayer(player, save);
             save.updateOpChange(player);
             save.save();
@@ -60,13 +60,13 @@ public class ServerHandler {
 
     private void processDisabledProperties(World world) {
         NEIServerUtils.advanceDisabledTimes(world);
-        if (NEIServerUtils.isRaining(world)
-                && NEIServerConfig.isActionDisabled(CommonUtils.getDimension(world), "rain"))
+        if (NEIServerUtils.isRaining(world) && NEIServerConfig.isActionDisabled(CommonUtils.getDimension(world), "rain"))
             NEIServerUtils.toggleRaining(world, false);
     }
 
     private void updateMagneticPlayer(EntityPlayerMP player, PlayerSave save) {
-        if (!save.isActionEnabled("magnet") || player.isDead) return;
+        if (!save.isActionEnabled("magnet") || player.isDead)
+            return;
 
         float distancexz = 16;
         float distancey = 8;
@@ -74,8 +74,7 @@ public class ServerHandler {
         double maxspeedy = 0.5;
         double speedxz = 0.05;
         double speedy = 0.07;
-        List<EntityItem> items = player.worldObj
-                .getEntitiesWithinAABB(EntityItem.class, player.boundingBox.expand(distancexz, distancey, distancexz));
+        List<EntityItem> items = player.worldObj.getEntitiesWithinAABB(EntityItem.class, player.boundingBox.expand(distancexz, distancey, distancexz));
         for (EntityItem item : items) {
             if (item.delayBeforeCanPickup > 0) continue;
             if (!NEIServerUtils.canItemFitInInventory(player, item.getEntityItem())) continue;

src/main/java/codechicken/nei/SlotOP.java

@@ -1,10 +1,10 @@
 package codechicken.nei;
 
-public abstract class SlotOP {
-
+public abstract class SlotOP
+{
     public abstract String getDescription();
-
+    
     public abstract int[] getKeyBind();
-
+    
     public abstract void operate();
 }

src/main/java/codechicken/nei/SpawnerRenderer.java

@@ -1,5 +1,7 @@
 package codechicken.nei;
 
+import codechicken.core.ClientUtils;
+import codechicken.lib.render.CCRenderState;
 import net.minecraft.client.renderer.OpenGlHelper;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.client.renderer.Tessellator;
@@ -11,75 +13,82 @@ import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
 import net.minecraftforge.client.IItemRenderer;
-
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;
 
-import codechicken.core.ClientUtils;
-import codechicken.lib.render.CCRenderState;
-
-public class SpawnerRenderer implements IItemRenderer {
-
+public class SpawnerRenderer implements IItemRenderer
+{
     @Override
-    public boolean handleRenderType(ItemStack item, ItemRenderType type) {
+    public boolean handleRenderType(ItemStack item, ItemRenderType type)
+    {
         return true;
     }
-
-    public void renderInventoryItem(RenderBlocks render, ItemStack item) {
+    
+    public void renderInventoryItem(RenderBlocks render, ItemStack item)
+    {
         int meta = item.getItemDamage();
-
-        if (meta == 0) meta = ItemMobSpawner.idPig;
+        
+        if(meta == 0)
+            meta = ItemMobSpawner.idPig;
 
         String bossName = BossStatus.bossName;
         int bossTimeout = BossStatus.statusBarTime;
         boolean bossHasColorModifier = BossStatus.hasColorModifier;
-        try {
+        try
+        {
             World world = NEIClientUtils.mc().theWorld;
             ItemMobSpawner.loadSpawners(world);
             CCRenderState.changeTexture(TextureMap.locationBlocksTexture);
             render.renderBlockAsItem(Blocks.mob_spawner, 0, 1F);
             GL11.glPushMatrix();
-
+            
             Entity entity = ItemMobSpawner.getEntity(meta);
             entity.setWorld(world);
             float f1 = 0.4375F;
-            if (entity.getShadowSize() > 1.5) f1 = 0.1F;
-            GL11.glRotatef((float) (ClientUtils.getRenderTime() * 10), 0.0F, 1.0F, 0.0F);
+            if(entity.getShadowSize() > 1.5)
+                f1 = 0.1F;
+            GL11.glRotatef((float) (ClientUtils.getRenderTime()*10), 0.0F, 1.0F, 0.0F);
             GL11.glRotatef(-20F, 1.0F, 0.0F, 0.0F);
             GL11.glTranslatef(0.0F, -0.4F, 0.0F);
             GL11.glScalef(f1, f1, f1);
             entity.setLocationAndAngles(0, 0, 0, 0.0F, 0.0F);
             RenderManager.instance.renderEntityWithPosYaw(entity, 0.0D, 0.0D, 0.0D, 0.0F, 0);
             GL11.glPopMatrix();
-
+    
             GL11.glEnable(GL12.GL_RESCALE_NORMAL);
             OpenGlHelper.setActiveTexture(OpenGlHelper.lightmapTexUnit);
             GL11.glDisable(GL11.GL_TEXTURE_2D);
             OpenGlHelper.setActiveTexture(OpenGlHelper.defaultTexUnit);
-        } catch (Exception e) {
-            if (Tessellator.instance.isDrawing) Tessellator.instance.draw();
+        }
+        catch(Exception e)
+        {
+            if(Tessellator.instance.isDrawing)
+                Tessellator.instance.draw();
         }
         BossStatus.bossName = bossName;
         BossStatus.statusBarTime = bossTimeout;
         BossStatus.hasColorModifier = bossHasColorModifier;
     }
-
+    
     @SuppressWarnings("incomplete-switch")
     @Override
-    public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
-        switch (type) {
+    public void renderItem(ItemRenderType type, ItemStack item, Object... data)
+    {
+        switch(type)
+        {
             case EQUIPPED:
             case EQUIPPED_FIRST_PERSON:
                 GL11.glTranslatef(0.5F, 0.5F, 0.5F);
             case INVENTORY:
             case ENTITY:
-                renderInventoryItem((RenderBlocks) data[0], item);
-                break;
+                renderInventoryItem((RenderBlocks)data[0], item);
+            break;
         }
     }
-
+    
     @Override
-    public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
+    public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper)
+    {
         return true;
-    }
+    }    
 }

src/main/java/codechicken/nei/SubsetWidget.java

@@ -1,6 +1,22 @@
 package codechicken.nei;
 
-import static codechicken.nei.NEIClientUtils.translate;
+import codechicken.core.gui.GuiScrollSlot;
+import codechicken.lib.gui.GuiDraw;
+import codechicken.lib.vec.Rectangle4i;
+import codechicken.nei.ItemList.AnyMultiItemFilter;
+import codechicken.nei.ItemList.ItemsLoadedCallback;
+import codechicken.nei.ItemList.NothingItemFilter;
+import codechicken.nei.SearchField.ISearchProvider;
+import codechicken.nei.api.API;
+import codechicken.nei.api.ItemFilter;
+import codechicken.nei.api.ItemFilter.ItemFilterProvider;
+import codechicken.nei.api.ItemInfo;
+import codechicken.nei.guihook.GuiContainerManager;
+import net.minecraft.client.Minecraft;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.EnumChatFormatting;
 
 import java.awt.Point;
 import java.util.ArrayList;
@@ -16,41 +32,24 @@ import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.regex.Pattern;
 
-import net.minecraft.client.Minecraft;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.nbt.NBTTagList;
-import net.minecraft.util.EnumChatFormatting;
-
-import codechicken.core.gui.GuiScrollSlot;
-import codechicken.lib.gui.GuiDraw;
-import codechicken.lib.vec.Rectangle4i;
-import codechicken.nei.ItemList.AnyMultiItemFilter;
-import codechicken.nei.ItemList.ItemsLoadedCallback;
-import codechicken.nei.ItemList.NothingItemFilter;
-import codechicken.nei.SearchField.ISearchProvider;
-import codechicken.nei.api.API;
-import codechicken.nei.api.ItemFilter;
-import codechicken.nei.api.ItemFilter.ItemFilterProvider;
-import codechicken.nei.api.ItemInfo;
-import codechicken.nei.guihook.GuiContainerManager;
-
-public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoadedCallback, ISearchProvider {
+import static codechicken.nei.NEIClientUtils.translate;
 
+public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoadedCallback, ISearchProvider
+{
     public static ReentrantReadWriteLock hiddenItemLock = new ReentrantReadWriteLock();
     public static Lock writeLock = hiddenItemLock.writeLock();
     public static Lock readLock = hiddenItemLock.readLock();
-
-    public static class SubsetState {
-
+    
+    public static class SubsetState
+    {
         int state = 2;
         ArrayList<ItemStack> items = new ArrayList<>();
     }
 
-    public static class SubsetTag {
-
-        protected class SubsetSlot extends GuiScrollSlot {
-
+    public static class SubsetTag
+    {
+        protected class SubsetSlot extends GuiScrollSlot
+        {
             public SubsetSlot() {
                 super(0, 0, 0, 0);
                 setSmoothScroll(false);
@@ -63,21 +62,25 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
             @Override
             protected int getNumSlots() {
-                return children.size() + state.items.size();
+                return children.size()+state.items.size();
             }
 
             @Override
             protected void slotClicked(int slot, int button, int mx, int my, int count) {
-                if (slot < sorted.size()) {
+                if(slot < sorted.size()) {
                     SubsetTag tag = sorted.get(slot);
                     if (NEIClientUtils.shiftKey())
                         codechicken.nei.LayoutManager.searchField.setText("@" + tag.fullname);
-                    else if (button == 0 && count >= 2) SubsetWidget.showOnly(tag);
-                    else SubsetWidget.setHidden(tag, button == 1);
+                    else if (button == 0 && count >= 2)
+                        SubsetWidget.showOnly(tag);
+                    else
+                        SubsetWidget.setHidden(tag, button == 1);
                 } else {
-                    ItemStack item = state.items.get(slot - sorted.size());
-                    if (NEIClientUtils.controlKey()) NEIClientUtils.cheatItem(item, button, -1);
-                    else SubsetWidget.setHidden(state.items.get(slot - sorted.size()), button == 1);
+                    ItemStack item = state.items.get(slot-sorted.size());
+                    if(NEIClientUtils.controlKey())
+                        NEIClientUtils.cheatItem(item, button, -1);
+                    else
+                        SubsetWidget.setHidden(state.items.get(slot-sorted.size()), button == 1);
                 }
             }
 
@@ -85,31 +88,32 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
             protected void drawSlot(int slot, int x, int y, int mx, int my, float frame) {
                 int w = windowBounds().width;
                 Rectangle4i r = new Rectangle4i(x, y, w, getSlotHeight(slot));
-                if (slot < sorted.size()) {
+                if(slot < sorted.size()) {
                     SubsetTag tag = sorted.get(slot);
-                    codechicken.nei.LayoutManager.getLayoutStyle()
-                            .drawSubsetTag(tag.displayName(), x, y, r.w, r.h, tag.state.state, r.contains(mx, my));
-                } else {
-                    ItemStack stack = state.items.get(slot - sorted.size());
+                    codechicken.nei.LayoutManager.getLayoutStyle().drawSubsetTag(tag.displayName(), x, y, r.w, r.h, tag.state.state, r.contains(mx, my));
+                }
+                else {
+                    ItemStack stack = state.items.get(slot-sorted.size());
                     boolean hidden = SubsetWidget.isHidden(stack);
 
-                    int itemx = w / 2 - 8;
+                    int itemx = w/2-8;
                     int itemy = 1;
 
-                    codechicken.nei.LayoutManager.getLayoutStyle()
-                            .drawSubsetTag(null, x, y, r.w, r.h, hidden ? 0 : 2, false);
+                    codechicken.nei.LayoutManager.getLayoutStyle().drawSubsetTag(null, x, y, r.w, r.h, hidden ? 0 : 2, false);
 
-                    GuiContainerManager.drawItem(x + itemx, y + itemy, stack);
-                    if (new Rectangle4i(itemx, itemy, 16, 16).contains(mx, my)) SubsetWidget.hoverStack = stack;
+                    GuiContainerManager.drawItem(x+itemx, y+itemy, stack);
+                    if(new Rectangle4i(itemx, itemy, 16, 16).contains(mx, my))
+                        SubsetWidget.hoverStack = stack;
                 }
             }
 
             @Override
-            public void drawOverlay(float frame) {}
+            public void drawOverlay(float frame) {
+            }
 
             @Override
             public void drawBackground(float frame) {
-                drawRect(x, y, x + width, y + height, 0xFF202020);
+                drawRect(x, y, x+width, y+height, 0xFF202020);
             }
 
             @Override
@@ -119,7 +123,8 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
             @Override
             public void drawScrollbar(float frame) {
-                if (hasScrollbar()) super.drawScrollbar(frame);
+                if(hasScrollbar())
+                    super.drawScrollbar(frame);
             }
 
             @Override
@@ -150,8 +155,9 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
         }
 
         public String displayName() {
-            String translated = translate("subsets." + fullname);
-            if (!translated.startsWith("nei.")) return translated;
+            String translated = translate("subsets."+fullname);
+            if(!translated.startsWith("nei."))
+                return translated;
 
             int idx = fullname.lastIndexOf('.');
             return idx < 0 ? fullname : fullname.substring(idx + 1);
@@ -159,7 +165,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
         public String name() {
             int idx = fullname.indexOf('.');
-            return idx < 0 ? fullname : fullname.substring(idx + 1);
+            return idx < 0 ? fullname : fullname.substring(idx+1);
         }
 
         public String parent() {
@@ -171,34 +177,36 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
             int idx = name.indexOf('.');
             String childname = idx > 0 ? name.substring(0, idx) : name;
             SubsetTag child = children.get(childname.toLowerCase());
-            if (child == null) return null;
+            if(child == null)
+                return null;
 
-            return idx > 0 ? child.getTag(name.substring(idx + 1)) : child;
+            return idx > 0 ? child.getTag(name.substring(idx+1)) : child;
         }
 
         private void recacheChildren() {
             sorted = new ArrayList<>(children.values());
             childwidth = 0;
-            for (SubsetTag tag : sorted) childwidth = Math.max(childwidth, tag.nameWidth() + 2);
+            for(SubsetTag tag : sorted)
+                childwidth = Math.max(childwidth, tag.nameWidth()+2);
         }
 
         private void addTag(SubsetTag tag) {
-            String name = fullname == null ? tag.fullname : tag.fullname.substring(fullname.length() + 1);
+            String name = fullname == null ? tag.fullname : tag.fullname.substring(fullname.length()+1);
             int idx = name.indexOf('.');
 
-            if (idx < 0) { // add or replace tag
+            if(idx < 0) {//add or replace tag
                 SubsetTag prev = children.put(name.toLowerCase(), tag);
-                if (prev != null) { // replaced, load children
+                if(prev != null) {//replaced, load children
                     tag.children = prev.children;
                     tag.sorted = prev.sorted;
                 }
                 recacheChildren();
-            } else {
+            }
+            else {
                 String childname = name.substring(0, idx);
                 SubsetTag child = children.get(childname.toLowerCase());
-                if (child == null) children.put(
-                        childname.toLowerCase(),
-                        child = new SubsetTag(fullname == null ? childname : fullname + '.' + childname));
+                if(child == null)
+                    children.put(childname.toLowerCase(), child = new SubsetTag(fullname == null ? childname : fullname+'.'+childname));
                 recacheChildren();
                 child.addTag(tag);
             }
@@ -206,42 +214,51 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
         protected void cacheState() {
             state = SubsetWidget.getState(this);
-            for (SubsetTag tag : sorted) tag.cacheState();
+            for(SubsetTag tag : sorted)
+                tag.cacheState();
         }
-
         public void addFiltersWithItem(List<ItemFilter> filters, String itemSearch) {
-            if (itemSearch == null) {
+            if(itemSearch == null) {
                 addFilters(filters);
             } else {
-                if (filter != null) filters.add(new DoubleFilteredFilter(filter, itemSearch));
+                if(filter != null)
+                    filters.add(new DoubleFilteredFilter(filter, itemSearch));
 
-                for (SubsetTag child : sorted) child.addFiltersWithItem(filters, itemSearch);
+                for(SubsetTag child : sorted)
+                    child.addFiltersWithItem(filters, itemSearch);
+                
             }
         }
-
         public void addFilters(List<ItemFilter> filters) {
-            if (filter != null) filters.add(filter);
+            if(filter != null)
+                filters.add(filter);
 
-            for (SubsetTag child : sorted) child.addFilters(filters);
+            for(SubsetTag child : sorted)
+                child.addFilters(filters);
         }
 
         public void search(List<SubsetTag> tags, Pattern p) {
-            if (fullname != null && p.matcher(fullname.toLowerCase()).find()) tags.add(this);
-            else for (SubsetTag child : sorted) child.search(tags, p);
+            if(fullname != null && p.matcher(fullname.toLowerCase()).find())
+                tags.add(this);
+            else
+                for(SubsetTag child : sorted)
+                    child.search(tags, p);
         }
 
         public void updateVisiblity(int mx, int my) {
-            if (selectedChild != null) {
+            if(selectedChild != null) {
                 selectedChild.updateVisiblity(mx, my);
-                if (!selectedChild.isVisible()) selectedChild = null;
+                if(!selectedChild.isVisible())
+                    selectedChild = null;
             }
 
-            if (slot.contains(mx, my) && (selectedChild == null || !selectedChild.contains(mx, my))) {
+            if(slot.contains(mx, my) && (selectedChild == null || !selectedChild.contains(mx, my))) {
                 int mslot = slot.getClickedSlot(my);
-                if (mslot >= 0 && mslot < sorted.size()) {
+                if(mslot >= 0 && mslot < sorted.size()) {
                     SubsetTag mtag = sorted.get(mslot);
-                    if (mtag != null) {
-                        if (mtag != selectedChild && selectedChild != null) selectedChild.setHidden();
+                    if(mtag != null) {
+                        if(mtag != selectedChild && selectedChild != null)
+                            selectedChild.setHidden();
                         selectedChild = mtag;
                         selectedChild.setVisible();
                     }
@@ -250,13 +267,14 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
                 setVisible();
             }
 
-            if (selectedChild == null) countdownVisible();
+            if(selectedChild == null)
+                countdownVisible();
         }
 
         public void setHidden() {
             visible = 0;
-            slot.mouseMovedOrUp(0, 0, 0); // cancel any scrolling
-            if (selectedChild != null) {
+            slot.mouseMovedOrUp(0, 0, 0);//cancel any scrolling
+            if(selectedChild != null) {
                 selectedChild.setHidden();
                 selectedChild = null;
             }
@@ -268,37 +286,41 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
         }
 
         private void countdownVisible() {
-            if (visible > 0 && --visible == 0) setHidden();
+            if(visible > 0 && --visible == 0)
+                setHidden();
         }
 
         public void resize(int x, int pwidth, int y) {
             int mheight = area.h;
-            int dheight = area.y2() - y;
+            int dheight = area.y2()-y;
             int cheight = slot.contentHeight();
             int height = cheight;
-            if (cheight > mheight) {
+            if(cheight > mheight) {
                 y = area.y;
                 height = mheight;
-            } else if (cheight > dheight) {
+            } else if(cheight > dheight) {
                 y = area.y2() - cheight;
             }
 
-            height = height / slot.getSlotHeight(0) * slot.getSlotHeight(0); // floor to a multiple of slot height
+            height = height/slot.getSlotHeight(0)*slot.getSlotHeight(0);//floor to a multiple of slot height
 
             int width = childwidth;
-            if (!state.items.isEmpty()) width = Math.max(childwidth, 18);
-            if (slot.contentHeight() > height) width += slot.scrollbarDim().width;
+            if(!state.items.isEmpty())
+                width = Math.max(childwidth, 18);
+            if(slot.contentHeight() > height)
+                width+=slot.scrollbarDim().width;
 
-            boolean fitLeft = x - width >= area.x1();
-            boolean fitRight = x + width + pwidth <= area.x2();
-            if (pwidth >= 0 ? !fitRight && fitLeft : !fitLeft) pwidth *= -1; // swap
+            boolean fitLeft = x-width >= area.x1();
+            boolean fitRight = x+width+pwidth <= area.x2();
+            if(pwidth >= 0 ? !fitRight && fitLeft : !fitLeft)
+                pwidth*=-1;//swap
             x += pwidth >= 0 ? pwidth : -width;
 
             slot.setSize(x, y, width, height);
             slot.setMargins(slot.hasScrollbar() ? slot.scrollbarDim().width : 0, 0, 0, 0);
 
-            if (selectedChild != null) {
-                y = slot.getSlotY(sorted.indexOf(selectedChild)) - slot.scrolledPixels() + slot.y;
+            if(selectedChild != null) {
+                y = slot.getSlotY(sorted.indexOf(selectedChild))-slot.scrolledPixels()+slot.y;
                 selectedChild.resize(x, pwidth >= 0 ? width : -width, y);
             }
         }
@@ -313,37 +335,44 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
         public void draw(int mx, int my) {
             slot.draw(mx, my, 0);
-            if (selectedChild != null) selectedChild.draw(mx, my);
+            if(selectedChild != null)
+                selectedChild.draw(mx, my);
         }
 
         public boolean contains(int px, int py) {
-            return slot.contains(px, py) || selectedChild != null && selectedChild.contains(px, py);
+            return slot.contains(px, py) ||
+                    selectedChild != null && selectedChild.contains(px, py);
         }
 
         public void mouseClicked(int mx, int my, int button) {
-            if (selectedChild != null && selectedChild.contains(mx, my)) selectedChild.mouseClicked(mx, my, button);
-            else if (slot.contains(mx, my)) slot.mouseClicked(mx, my, button);
+            if(selectedChild != null && selectedChild.contains(mx, my))
+                selectedChild.mouseClicked(mx, my, button);
+            else if(slot.contains(mx, my))
+                slot.mouseClicked(mx, my, button);
         }
 
         public void mouseDragged(int mx, int my, int button, long heldTime) {
             slot.mouseDragged(mx, my, button, heldTime);
-            if (selectedChild != null) selectedChild.mouseDragged(mx, my, button, heldTime);
+            if(selectedChild != null)
+                selectedChild.mouseDragged(mx, my, button, heldTime);
         }
 
         public void mouseUp(int mx, int my, int button) {
             slot.mouseMovedOrUp(mx, my, button);
-            if (selectedChild != null) selectedChild.mouseUp(mx, my, button);
+            if(selectedChild != null)
+                selectedChild.mouseUp(mx, my, button);
         }
 
         public boolean mouseScrolled(int mx, int my, int scroll) {
-            if (slot.hasScrollbar() && slot.contains(mx, my)) {
+            if(slot.hasScrollbar() && slot.contains(mx, my)) {
                 slot.scroll(scroll);
                 return true;
             }
 
-            if (selectedChild != null && selectedChild.mouseScrolled(mx, my, scroll)) return true;
+            if(selectedChild != null && selectedChild.mouseScrolled(mx, my, scroll))
+                return true;
 
-            if (slot.hasScrollbar() && !contains(mx, my)) {
+            if(slot.hasScrollbar() && !contains(mx, my)) {
                 slot.scroll(scroll);
                 return true;
             }
@@ -352,7 +381,8 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
         }
 
         public boolean isScrolling() {
-            return slot.isScrolling() || selectedChild != null && selectedChild.isScrolling();
+            return slot.isScrolling() ||
+                    selectedChild != null && selectedChild.isScrolling();
         }
     }
 
@@ -365,7 +395,6 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
      * All operations on this variable should be synchronised.
      */
     private static final ItemStackSet hiddenItems = new ItemStackSet();
-
     private static final AtomicReference<NBTTagList> dirtyHiddenItems = new AtomicReference<>();
 
     public static SubsetState getState(SubsetTag tag) {
@@ -387,7 +416,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
     public static boolean isHidden(ItemStack item) {
         try {
-            if (readLock.tryLock(5, TimeUnit.SECONDS)) {
+            if(readLock.tryLock(5, TimeUnit.SECONDS)) {
                 try {
                     return hiddenItems.contains(item);
                 } finally {
@@ -403,22 +432,27 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
     }
 
     private static void _setHidden(SubsetTag tag, boolean hidden) {
-        for (ItemStack item : getState(tag).items) _setHidden(item, hidden);
-        for (SubsetTag child : tag.sorted) _setHidden(child, hidden);
+        for(ItemStack item : getState(tag).items)
+            _setHidden(item, hidden);
+        for(SubsetTag child : tag.sorted)
+            _setHidden(child, hidden);
     }
 
     private static void _setHidden(ItemStack item, boolean hidden) {
         if (hiddenItemLock.isWriteLockedByCurrentThread()) {
-            if (hidden) hiddenItems.add(item);
-            else hiddenItems.remove(item);
+            if (hidden)
+                hiddenItems.add(item);
+            else
+                hiddenItems.remove(item);
         }
     }
 
     public static void showOnly(SubsetTag tag) {
         try {
-            if (writeLock.tryLock(5, TimeUnit.SECONDS)) {
+            if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
                 try {
-                    for (ItemStack item : ItemList.items) _setHidden(item, true);
+                    for (ItemStack item : ItemList.items)
+                        _setHidden(item, true);
                     setHidden(tag, false);
                 } finally {
                     writeLock.unlock();
@@ -433,7 +467,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
     public static void setHidden(SubsetTag tag, boolean hidden) {
         try {
-            if (writeLock.tryLock(5, TimeUnit.SECONDS)) {
+            if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
                 try {
                     _setHidden(tag, hidden);
                     updateHiddenItems();
@@ -450,7 +484,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
     public static void setHidden(ItemStack item, boolean hidden) {
         try {
-            if (writeLock.tryLock(5, TimeUnit.SECONDS)) {
+            if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
                 try {
                     _setHidden(item, hidden);
                     updateHiddenItems();
@@ -467,7 +501,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
     public static void unhideAll() {
         try {
-            if (writeLock.tryLock(5, TimeUnit.SECONDS)) {
+            if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
                 try {
                     hiddenItems.clear();
                     updateHiddenItems();
@@ -489,7 +523,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
     public static void loadHidden() {
         try {
-            if (writeLock.tryLock(5, TimeUnit.SECONDS)) {
+            if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
                 try {
                     hiddenItems.clear();
                 } finally {
@@ -506,17 +540,19 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
         List<ItemStack> itemList = new LinkedList<>();
         try {
             NBTTagList list = NEIClientConfig.world.nbt.getTagList("hiddenItems", 10);
-            for (int i = 0; i < list.tagCount(); i++)
+            for(int i = 0; i < list.tagCount(); i++)
                 itemList.add(ItemStack.loadItemStackFromNBT(list.getCompoundTagAt(i)));
-        } catch (Exception e) {
+        }
+        catch (Exception e) {
             NEIClientConfig.logger.error("Error loading hiddenItems", e);
             return;
         }
 
         try {
-            if (writeLock.tryLock(5, TimeUnit.SECONDS)) {
+            if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
                 try {
-                    for (ItemStack item : itemList) hiddenItems.add(item);
+                    for (ItemStack item : itemList)
+                        hiddenItems.add(item);
                 } finally {
                     writeLock.unlock();
                 }
@@ -531,17 +567,17 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
     private static void saveHidden() {
         NBTTagList list = dirtyHiddenItems.getAndSet(null);
-        if (list != null) {
+        if(list != null) {
             NEIClientConfig.world.nbt.setTag("hiddenItems", list);
             NEIClientConfig.world.saveNBT();
         }
     }
 
-    private static final RestartableTask prepareDirtyHiddenItems = new RestartableTask("NEI Subset Save Thread") {
-
+    private static final RestartableTask prepareDirtyHiddenItems = new RestartableTask("NEI Subset Save Thread")
+    {
         private List<ItemStack> getList() {
             try {
-                if (readLock.tryLock(5, TimeUnit.SECONDS)) {
+                if(readLock.tryLock(5, TimeUnit.SECONDS)) {
                     try {
                         return hiddenItems.values();
                     } finally {
@@ -559,8 +595,8 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
         @Override
         public void execute() {
             NBTTagList list = new NBTTagList();
-            for (ItemStack item : getList()) {
-                if (interrupted()) return;
+            for(ItemStack item : getList()) {
+                if(interrupted()) return;
                 NBTTagCompound tag = new NBTTagCompound();
                 item.writeToNBT(tag);
                 list.appendTag(tag);
@@ -570,9 +606,8 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
     };
 
     private static final UpdateStateTask updateState = new UpdateStateTask();
-
-    private static class UpdateStateTask extends RestartableTask {
-
+    private static class UpdateStateTask extends RestartableTask
+    {
         private volatile boolean reallocate;
 
         public UpdateStateTask() {
@@ -599,20 +634,22 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
             List<SubsetTag> tags = new LinkedList<>();
             synchronized (root) {
                 cloneStates(root, tags, state);
-                if (interrupted()) return;
+                if(interrupted()) return;
             }
 
-            if (reallocate) {
+            if(reallocate) {
                 for (ItemStack item : ItemList.items) {
-                    if (interrupted()) return;
-                    if (ItemInfo.isHidden(item)) continue;
-                    for (SubsetTag tag : tags) if (tag.filter.matches(item)) state.get(tag.fullname).items.add(item);
+                    if(interrupted()) return;
+                    if(ItemInfo.isHidden(item)) continue;
+                    for (SubsetTag tag : tags)
+                        if (tag.filter.matches(item))
+                            state.get(tag.fullname).items.add(item);
                 }
             }
 
             synchronized (root) {
                 calculateVisibility(root, state);
-                if (interrupted()) return;
+                if(interrupted()) return;
             }
 
             subsetState = state;
@@ -620,38 +657,44 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
         }
 
         private void cloneStates(SubsetTag tag, List<SubsetTag> tags, HashMap<String, SubsetState> state) {
-            for (SubsetTag child : tag.sorted) {
-                if (interrupted()) return;
+            for(SubsetTag child : tag.sorted) {
+                if(interrupted()) return;
                 cloneStates(child, tags, state);
             }
 
             tags.add(tag);
             SubsetState sstate = new SubsetState();
-            if (!reallocate) sstate.items = SubsetWidget.getState(tag).items;
+            if(!reallocate)
+                sstate.items = SubsetWidget.getState(tag).items;
             state.put(tag.fullname, sstate);
         }
 
         private void calculateVisibility(SubsetTag tag, Map<String, SubsetState> state) {
             SubsetState sstate = state.get(tag.fullname);
             int hidden = 0;
-            for (SubsetTag child : tag.sorted) {
-                if (interrupted()) return;
+            for(SubsetTag child : tag.sorted) {
+                if(interrupted()) return;
                 calculateVisibility(child, state);
                 int cstate = state.get(child.fullname).state;
-                if (cstate == 1) sstate.state = 1;
-                else if (cstate == 0) hidden++;
+                if(cstate == 1)
+                    sstate.state = 1;
+                else if(cstate == 0)
+                    hidden++;
             }
 
-            if (sstate.state == 1) return;
+            if(sstate.state == 1) return;
 
             List<ItemStack> items = sstate.items;
-            for (ItemStack item : items) {
-                if (interrupted()) return;
-                if (isHidden(item)) hidden++;
+            for(ItemStack item : items) {
+                if(interrupted()) return;
+                if (isHidden(item))
+                    hidden++;
             }
 
-            if (hidden == tag.sorted.size() + items.size()) sstate.state = 0;
-            else if (hidden > 0) sstate.state = 1;
+            if(hidden == tag.sorted.size()+items.size())
+                sstate.state = 0;
+            else if(hidden > 0)
+                sstate.state = 1;
         }
     }
 
@@ -673,7 +716,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
     public void draw(int mx, int my) {
         super.draw(mx, my);
 
-        area.set(x, y + h, w, LayoutManager.searchField.y - h - y); // 23 for the search box
+        area.set(x, y + h, w, LayoutManager.searchField.y - h - y); //23 for the search box
 
         hoverStack = null;
         if (root.isVisible()) {
@@ -691,28 +734,33 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
     }
 
     private void updateVisiblity(int mx, int my) {
-        if (!root.isVisible() || root.isScrolling()) return;
+        if(!root.isVisible() || root.isScrolling())
+            return;
 
         root.updateVisiblity(mx, my);
 
-        if (!root.isVisible() && bounds().contains(mx, my)) root.setVisible();
+        if(!root.isVisible() && bounds().contains(mx, my))
+            root.setVisible();
     }
 
     @Override
     public boolean contains(int px, int py) {
-        return super.contains(px, py) || root.isVisible() && root.contains(px, py);
+        return super.contains(px, py) ||
+                root.isVisible() && root.contains(px, py);
     }
 
     @Override
     public boolean handleClick(int mx, int my, int button) {
-        if (root.isVisible() && root.contains(mx, my)) {
+        if(root.isVisible() && root.contains(mx, my)) {
             root.mouseClicked(mx, my, button);
             return true;
         }
 
-        if (button == 0) {
-            if (System.currentTimeMillis() - lastclicktime < 500) unhideAll();
-            else root.setVisible();
+        if(button == 0) {
+            if(System.currentTimeMillis() - lastclicktime < 500)
+                unhideAll();
+            else
+                root.setVisible();
 
             NEIClientUtils.playClickSound();
             lastclicktime = System.currentTimeMillis();
@@ -731,12 +779,14 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
     @Override
     public void mouseDragged(int mx, int my, int button, long heldTime) {
-        if (root.isVisible()) root.mouseDragged(mx, my, button, heldTime);
+        if(root.isVisible())
+            root.mouseDragged(mx, my, button, heldTime);
     }
 
     @Override
     public void mouseUp(int mx, int my, int button) {
-        if (root.isVisible()) root.mouseUp(mx, my, button);
+        if(root.isVisible())
+            root.mouseUp(mx, my, button);
     }
 
     @Override
@@ -746,7 +796,8 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
     @Override
     public void onGuiClick(int mx, int my) {
-        if (!contains(mx, my)) root.setHidden();
+        if(!contains(mx, my))
+            root.setHidden();
     }
 
     @Override
@@ -756,10 +807,10 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
     @Override
     public ItemFilter getFilter() {
-        // synchronise access on hiddenItems
+        //synchronise access on hiddenItems
         return item -> {
             try {
-                if (readLock.tryLock(5, TimeUnit.SECONDS)) {
+                if(readLock.tryLock(5, TimeUnit.SECONDS)) {
                     try {
                         return !hiddenItems.matches(item);
                     } finally {
@@ -782,34 +833,36 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
 
     @Override
     public ItemFilter getFilter(String searchText) {
-        if (!searchText.startsWith("@")) return null;
+        if(!searchText.startsWith("@"))
+            return null;
 
         searchText = searchText.substring(1);
         String itemSearch = null;
-        if (searchText.contains("->")) {
+        if(searchText.contains("->")) {
             String[] split = searchText.split("->");
             searchText = split[0];
-            if (split.length > 1) itemSearch = split[1];
+            if(split.length > 1) itemSearch = split[1];
         }
-
+        
         AnyMultiItemFilter filter = new AnyMultiItemFilter();
         SubsetTag tag = getTag(searchText);
-        if (tag != null) {
+        if(tag != null) {
             // We've got an exact match
             tag.addFiltersWithItem(filter.filters, itemSearch);
-        } else {
+        }
+        else {
             // Try searching for a substring
             Pattern p = SearchField.getPattern(searchText);
-            if (p == null) return null;
+            if(p == null) return null;
 
             List<SubsetTag> matching = new LinkedList<>();
             root.search(matching, p);
-            if (matching.isEmpty()) return null;
-            for (SubsetTag tag2 : matching) {
+            if(matching.isEmpty()) return null;
+            for(SubsetTag tag2 : matching) {
                 tag2.addFiltersWithItem(filter.filters, itemSearch);
             }
         }
-
+        
         return filter;
     }
 

src/main/java/codechicken/nei/TextField.java

@@ -2,11 +2,10 @@ package codechicken.nei;
 
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiTextField;
-
 import org.lwjgl.input.Keyboard;
 
-public abstract class TextField extends Widget {
-
+public abstract class TextField extends Widget
+{
     protected GuiTextField field;
 
     private static final int maxSearchLength = 256;
@@ -25,7 +24,7 @@ public abstract class TextField extends Widget {
     public TextField(String ident) {
         identifier = ident;
         initInternalTextField();
-        // Keyboard.enableRepeatEvents(true);
+//        Keyboard.enableRepeatEvents(true);
     }
 
     public int getTextColour() {
@@ -45,7 +44,7 @@ public abstract class TextField extends Widget {
         try {
             setDimensionsAndColor();
             field.drawTextBox();
-        } catch (NullPointerException npe) {
+        } catch(NullPointerException npe) {
             // Hack to deal with a null font renderer... recreate the field and it should work
             GuiTextField oldField = field;
 
@@ -59,43 +58,49 @@ public abstract class TextField extends Widget {
 
     @Override
     public void onGuiClick(int mousex, int mousey) {
-        if (!contains(mousex, mousey)) setFocus(false);
+        if (!contains(mousex, mousey))
+            setFocus(false);
     }
 
     @Override
     public boolean handleClick(int mousex, int mousey, int button) {
         setFocus(true);
 
-        if (button == 1) setText("");
-        else field.mouseClicked(mousex, mousey, button);
+        if (button == 1)
+            setText("");
+        else
+            field.mouseClicked(mousex, mousey, button);
 
         return true;
     }
 
     @Override
     public boolean handleKeyPress(int keyID, char keyChar) {
-        if (!focused()) return false;
+        if (!focused())
+            return false;
 
         String oldText = text();
         boolean handled = field.textboxKeyTyped(keyChar, keyID);
-        if (!handled) {
+        if(!handled) {
             if (keyID == Keyboard.KEY_RETURN || keyID == Keyboard.KEY_NUMPADENTER || keyID == Keyboard.KEY_ESCAPE) {
                 setFocus(false);
                 handled = true;
             }
         }
 
-        if (handled) {
+        if(handled) {
             onTextChange(oldText);
         }
 
         return handled;
+
     }
 
     public abstract void onTextChange(String oldText);
 
     @Override
-    public void update() {}
+    public void update() {
+    }
 
     public void setText(String s) {
         String oldText = text();
@@ -121,6 +126,7 @@ public abstract class TextField extends Widget {
                 Keyboard.enableRepeatEvents(previousKeyboardRepeatEnabled);
                 loseFocus();
             }
+
         }
     }
 
@@ -131,4 +137,5 @@ public abstract class TextField extends Widget {
     public String text() {
         return field.getText();
     }
+
 }

src/main/java/codechicken/nei/ThreadOperationTimer.java

@@ -3,11 +3,11 @@ package codechicken.nei;
 import com.google.common.base.Objects;
 import cpw.mods.fml.common.FMLCommonHandler;
 
-public class ThreadOperationTimer extends Thread {
-
+public class ThreadOperationTimer extends Thread
+{
     @SuppressWarnings("serial")
-    public static class TimeoutException extends RuntimeException {
-
+    public static class TimeoutException extends RuntimeException
+    {
         public final Object operation;
 
         public TimeoutException(String msg, Object op) {
@@ -22,7 +22,7 @@ public class ThreadOperationTimer extends Thread {
     private long limit;
 
     private ThreadOperationTimer(Thread thread, int limit) {
-        super(thread.getName() + " Operation Timer");
+        super(thread.getName()+" Operation Timer");
         this.thread = thread;
         this.limit = limit;
     }
@@ -41,7 +41,7 @@ public class ThreadOperationTimer extends Thread {
     }
 
     public synchronized void update(Object op) {
-        if (!Objects.equal(operation, op)) {
+        if(!Objects.equal(operation, op)) {
             operation = op;
             opTime = System.currentTimeMillis();
         }
@@ -50,19 +50,14 @@ public class ThreadOperationTimer extends Thread {
     @SuppressWarnings("deprecation")
     @Override
     public void run() {
-        if (FMLCommonHandler.instance().findContainerFor("NotEnoughItems").getVersion().contains("$")) return; // don't
-                                                                                                               // run
-                                                                                                               // this
-                                                                                                               // thread
-                                                                                                               // in a
-                                                                                                               // source
-                                                                                                               // environment
+        if(FMLCommonHandler.instance().findContainerFor("NotEnoughItems").getVersion().contains("$"))
+            return;//don't run this thread in a source environment
 
         while (thread.isAlive()) {
             synchronized (this) {
                 if (operation != null && System.currentTimeMillis() - opTime > limit) {
                     // Thread.stop(Throwable) is hard-deprecated and IntelliJ complains about it.
-                    // thread.stop(new TimeoutException("Operation took too long", operation));
+                    //thread.stop(new TimeoutException("Operation took too long", operation));
                     thread.stop();
                 }
             }
@@ -77,4 +72,4 @@ public class ThreadOperationTimer extends Thread {
         t.start();
         return t;
     }
-}
+}

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

@@ -1,7 +1,7 @@
 package codechicken.nei;
 
-public class VisiblityData {
-
+public class VisiblityData
+{
     public boolean showUtilityButtons = true;
     /**
      * Item panel and associated buttons
@@ -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
      */
@@ -35,16 +27,19 @@ public class VisiblityData {
      * The entire NEI interface, aka hidden
      */
     public boolean showNEI = true;
-
     public boolean enableDeleteMode = true;
 
+    
     // Deprecated -- left in for campatability with other mods that mess with this
     public boolean showStateButtons = false;
 
-    public void translateDependancies() {
-        if (!showNEI) showWidgets = false;
-        if (!showWidgets) showItemSection = showUtilityButtons = false;
-        if (!showItemSection)
-            showBookmarkPanel = showSubsetDropdown = showPresetsDropdown = showSearchSection = showItemPanel = false;
+    public void translateDependancies()
+    {
+        if(!showNEI)
+            showWidgets = false;
+        if(!showWidgets)
+            showItemSection = showUtilityButtons = false;
+        if(!showItemSection)
+            showBookmarkPanel = showSearchSection = showItemPanel = false;
     }
 }

src/main/java/codechicken/nei/Widget.java

@@ -1,32 +1,37 @@
 package codechicken.nei;
 
+import codechicken.lib.vec.Rectangle4i;
+import net.minecraft.item.ItemStack;
+
 import java.util.List;
 
-import net.minecraft.item.ItemStack;
-
-import codechicken.lib.vec.Rectangle4i;
-
-public abstract class Widget {
-
-    public Widget() {}
+public abstract class Widget
+{
+    public Widget() {
+    }
 
     public abstract void draw(int mx, int my);
 
-    public void postDraw(int mx, int my) {}
+    public void postDraw(int mx, int my) {
+    }
 
     public boolean handleClick(int mx, int my, int button) {
         return true;
     }
 
-    public void onGuiClick(int mx, int my) {}
+    public void onGuiClick(int mx, int my) {
+    }
 
-    public void mouseUp(int mx, int my, int button) {}
+    public void mouseUp(int mx, int my, int button) {
+
+    }
 
     public boolean handleKeyPress(int keyID, char keyChar) {
         return false;
     }
 
-    public void lastKeyTyped(int keyID, char keyChar) {}
+    public void lastKeyTyped(int keyID, char keyChar) {
+    }
 
     public boolean handleClickExt(int mx, int my, int button) {
         return false;
@@ -36,7 +41,8 @@ public abstract class Widget {
         return false;
     }
 
-    public void update() {}
+    public void update() {
+    }
 
     public Rectangle4i bounds() {
         return new Rectangle4i(x, y, w, h);
@@ -50,15 +56,18 @@ public abstract class Widget {
         return null;
     }
 
-    public void mouseDragged(int mx, int my, int button, long heldTime) {}
+    public void mouseDragged(int mx, int my, int button, long heldTime) {
+    }
 
     public List<String> handleTooltip(int mx, int my, List<String> tooltip) {
         return tooltip;
     }
 
-    public void loseFocus() {}
+    public void loseFocus() {
+    }
 
-    public void gainFocus() {}
+    public void gainFocus() {
+    }
 
     public int x;
     public int y;

src/main/java/codechicken/nei/WidgetZOrder.java

@@ -2,15 +2,17 @@ package codechicken.nei;
 
 import java.util.Comparator;
 
-public class WidgetZOrder implements Comparator<Widget> {
-
+public class WidgetZOrder
+    implements Comparator<Widget>
+{
     final boolean topfirst;
-
-    public WidgetZOrder(boolean topfirst) {
+    public WidgetZOrder(boolean topfirst)
+    {
         this.topfirst = topfirst;
     }
 
-    public int compare(Widget w1, Widget w2) {
+    public int compare(Widget w1, Widget w2)
+    {
         return w1.z != w2.z ? ((topfirst ? w1.z > w2.z : w1.z < w2.z) ? 1 : -1) : 1;
     }
 }

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

@@ -1,7 +1,9 @@
 package codechicken.nei;
 
+import codechicken.lib.math.MathHelper;
+import codechicken.lib.render.RenderUtils;
+import codechicken.nei.KeyManager.IKeyStateTracker;
 import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EnumCreatureType;
 import net.minecraft.entity.passive.EntityPig;
@@ -11,19 +13,12 @@ import net.minecraft.world.SpawnerAnimals;
 import net.minecraft.world.World;
 import net.minecraft.world.biome.BiomeGenBase;
 import net.minecraft.world.chunk.Chunk;
-
 import org.lwjgl.opengl.GL11;
 
-import codechicken.lib.math.MathHelper;
-import codechicken.nei.KeyManager.IKeyStateTracker;
-
-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;
@@ -32,163 +27,28 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
 
     @Override
     public void tickKeyStates() {
-        if (Minecraft.getMinecraft().currentScreen != null) return;
+        if (Minecraft.getMinecraft().currentScreen != null)
+            return;
 
-        if (KeyManager.keyStates.get("world.moboverlay").down) mobOverlay = (mobOverlay + 1) % 2;
+        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) {
         GL11.glPushMatrix();
         Entity entity = Minecraft.getMinecraft().renderViewEntity;
+        RenderUtils.translateToWorldCoords(entity, frame);
 
-        double interpPosX = entity.lastTickPosX + (entity.posX - entity.lastTickPosX) * frame;
-        double interpPosY = entity.lastTickPosY + (entity.posY - entity.lastTickPosY) * frame;
-        double interpPosZ = entity.lastTickPosZ + (entity.posZ - entity.lastTickPosZ) * frame;
-
-        int intOffsetX = (int) interpPosX;
-        int intOffsetY = (int) interpPosY;
-        int intOffsetZ = (int) interpPosZ;
-
-        GL11.glTranslated(-interpPosX + intOffsetX, -interpPosY + intOffsetY, -interpPosZ + intOffsetZ);
-
-        renderChunkBounds(entity, intOffsetX, intOffsetY, intOffsetZ);
-        renderMobSpawnOverlay(entity, intOffsetX, intOffsetY, intOffsetZ);
+        renderChunkBounds(entity);
+        renderMobSpawnOverlay(entity);
         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, int intOffsetX, int intOffsetY, int intOffsetZ) {
-        if (mobOverlay == 0) {
-            if (mobSpawnCache != null) {
-                mobSpawnCache = null;
-            }
+    private static void renderMobSpawnOverlay(Entity entity) {
+        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);
-        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-        GL11.glDisable(GL11.GL_LIGHTING);
-        GL11.glLineWidth(1.5F);
-
-        int curSpawnMode = 2;
-
-        World world = entity.worldObj;
-        int x1 = (int) entity.posX - intOffsetX;
-        int z1 = (int) entity.posZ - intOffsetZ;
-        int y1 = (int) MathHelper.clip(entity.posY, 16, world.getHeight() - 16) - intOffsetY;
-
-        final Tessellator tess = Tessellator.instance;
-        tess.startDrawing(GL11.GL_LINES);
-        tess.setColorOpaque(255, 0, 0);
-
-        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 k = 0; k <= 32; k++) {
-                    int y = y1 - 16 + k;
-                    int spawnMode = mobSpawnCache[cacheIndex + k];
-                    if (spawnMode == 0) {
-                        continue;
-                    } else if (spawnMode == -1) {
-                        break;
-                    }
-
-                    if (spawnMode != curSpawnMode) {
-                        if (spawnMode == 1) {
-                            tess.setColorOpaque(255, 255, 0);
-                        } else {
-                            tess.setColorOpaque(255, 0, 0);
-                        }
-                        curSpawnMode = spawnMode;
-                    }
-
-                    tess.addVertex(x, y + 0.02, z);
-                    tess.addVertex(x + 1, y + 0.02, z + 1);
-                    tess.addVertex(x + 1, y + 0.02, z);
-                    tess.addVertex(x, y + 0.02, z + 1);
-                }
-            }
-        }
-
-        tess.draw();
-        GL11.glEnable(GL11.GL_LIGHTING);
-        GL11.glEnable(GL11.GL_TEXTURE_2D);
-        GL11.glDisable(GL11.GL_BLEND);
-    }
-
-    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) {
-        if (chunk.getSavedLightValue(EnumSkyBlock.Block, x & 15, y, z & 15) >= 8
-                || !SpawnerAnimals.canCreatureTypeSpawnAtLocation(EnumCreatureType.monster, chunk.worldObj, x, y, z)) {
-            return 0;
-        }
-
-        aabb.minX = x + 0.2;
-        aabb.maxX = x + 0.8;
-        aabb.minY = y + 0.01;
-        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)) {
-            return 0;
-        }
-
-        return (byte) (chunk.getSavedLightValue(EnumSkyBlock.Sky, x & 15, y, z & 15) >= 8 ? 1 : 2);
-    }
-
-    private static void renderChunkBounds(Entity entity, int intOffsetX, int intOffsetY, int intOffsetZ) {
-        if (chunkOverlay == 0) return;
 
         GL11.glDisable(GL11.GL_TEXTURE_2D);
         GL11.glEnable(GL11.GL_BLEND);
@@ -197,50 +57,122 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
         GL11.glLineWidth(1.5F);
         GL11.glBegin(GL11.GL_LINES);
 
-        for (int cx = -4; cx <= 4; cx++) for (int cz = -4; cz <= 4; cz++) {
-            double x1 = ((entity.chunkCoordX + cx) << 4) - intOffsetX;
-            double z1 = ((entity.chunkCoordZ + cz) << 4) - intOffsetZ;
-            double x2 = x1 + 16;
-            double z2 = z1 + 16;
+        GL11.glColor4f(1, 0, 0, 1);
+        int curSpawnMode = 2;
 
-            double dy = 128;
-            double y1 = Math.floor(entity.posY - dy / 2);
-            double y2 = y1 + dy;
-            if (y1 < 0) {
-                y1 = 0;
-                y2 = dy;
+        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 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 y = y1 - 16; y < y1 + 16; y++) {
+                    int spawnMode = getSpawnMode(chunk, x, y, z);
+                    if (spawnMode == 0)
+                        continue;
+
+                    if (spawnMode != curSpawnMode) {
+                        if (spawnMode == 1)
+                            GL11.glColor4f(1, 1, 0, 1);
+                        else
+                            GL11.glColor4f(1, 0, 0, 1);
+                        curSpawnMode = spawnMode;
+                    }
+
+                    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);
+                }
             }
 
-            if (y1 > entity.worldObj.getHeight()) {
-                y2 = entity.worldObj.getHeight();
-                y1 = y2 - dy;
-            }
+        GL11.glEnd();
+        GL11.glEnable(GL11.GL_LIGHTING);
+        GL11.glEnable(GL11.GL_TEXTURE_2D);
+        GL11.glDisable(GL11.GL_BLEND);
+    }
 
-            y1 -= intOffsetY;
-            y2 -= intOffsetY;
+    private static final Entity dummyEntity = new EntityPig(null);
+    private static final AxisAlignedBB aabb = AxisAlignedBB.getBoundingBox(0, 0, 0, 0, 0, 0);
+    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)
+            return 0;
 
-            double dist = Math.pow(1.5, -(cx * cx + cz * cz));
+        aabb.minX = x + 0.2;
+        aabb.maxX = x + 0.8;
+        aabb.minY = y + 0.01;
+        aabb.maxY = y + 1.8;
+        aabb.minZ = z + 0.2;
+        aabb.maxZ = z + 0.8;
+        if (!chunk.worldObj.checkNoEntityCollision(aabb) ||
+                !chunk.worldObj.getCollidingBoundingBoxes(dummyEntity, aabb).isEmpty() ||
+                chunk.worldObj.isAnyLiquid(aabb))
+            return 0;
 
-            GL11.glColor4d(0.9, 0, 0, dist);
-            if (cx >= 0 && cz >= 0) {
-                GL11.glVertex3d(x2, y1, z2);
-                GL11.glVertex3d(x2, y2, z2);
-            }
-            if (cx >= 0 && cz <= 0) {
-                GL11.glVertex3d(x2, y1, z1);
-                GL11.glVertex3d(x2, y2, z1);
-            }
-            if (cx <= 0 && cz >= 0) {
-                GL11.glVertex3d(x1, y1, z2);
-                GL11.glVertex3d(x1, y2, z2);
-            }
-            if (cx <= 0 && cz <= 0) {
-                GL11.glVertex3d(x1, y1, z1);
-                GL11.glVertex3d(x1, y2, z1);
-            }
+        if (chunk.getSavedLightValue(EnumSkyBlock.Sky, x & 15, y, z & 15) >= 8)
+            return 1;
+        return 2;
+    }
 
-            if (cx == 0 && cz == 0) {
-                if (chunkOverlay == 2) {
+    private static void renderChunkBounds(Entity entity) {
+        if (chunkOverlay == 0)
+            return;
+
+        GL11.glDisable(GL11.GL_TEXTURE_2D);
+        GL11.glEnable(GL11.GL_BLEND);
+        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        GL11.glDisable(GL11.GL_LIGHTING);
+        GL11.glLineWidth(1.5F);
+        GL11.glBegin(GL11.GL_LINES);
+
+        for (int cx = -4; cx <= 4; cx++)
+            for (int cz = -4; cz <= 4; cz++) {
+                double x1 = (entity.chunkCoordX + cx) << 4;
+                double z1 = (entity.chunkCoordZ + cz) << 4;
+                double x2 = x1 + 16;
+                double z2 = z1 + 16;
+
+                double dy = 128;
+                double y1 = Math.floor(entity.posY - dy / 2);
+                double y2 = y1 + dy;
+                if (y1 < 0) {
+                    y1 = 0;
+                    y2 = dy;
+                }
+
+                if (y1 > entity.worldObj.getHeight()) {
+                    y2 = entity.worldObj.getHeight();
+                    y1 = y2 - dy;
+                }
+
+                double dist = Math.pow(1.5, -(cx * cx + cz * cz));
+
+                GL11.glColor4d(0.9, 0, 0, dist);
+                if (cx >= 0 && cz >= 0) {
+                    GL11.glVertex3d(x2, y1, z2);
+                    GL11.glVertex3d(x2, y2, z2);
+                }
+                if (cx >= 0 && cz <= 0) {
+                    GL11.glVertex3d(x2, y1, z1);
+                    GL11.glVertex3d(x2, y2, z1);
+                }
+                if (cx <= 0 && cz >= 0) {
+                    GL11.glVertex3d(x1, y1, z2);
+                    GL11.glVertex3d(x1, y2, z2);
+                }
+                if (cx <= 0 && cz <= 0) {
+                    GL11.glVertex3d(x1, y1, z1);
+                    GL11.glVertex3d(x1, y2, z1);
+                }
+
+                if (chunkOverlay == 2 && cx == 0 && cz == 0) {
                     dy = 32;
                     y1 = Math.floor(entity.posY - dy / 2);
                     y2 = y1 + dy;
@@ -254,9 +186,6 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
                         y1 = y2 - dy;
                     }
 
-                    y1 -= intOffsetY;
-                    y2 -= intOffsetY;
-
                     GL11.glColor4d(0, 0.9, 0, 0.4);
                     for (double y = (int) y1; y <= y2; y++) {
                         GL11.glVertex3d(x2, y, z1);
@@ -278,62 +207,8 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
                         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)
-                            - intOffsetX;
-                    int gz1 = (((entity.chunkCoordZ < 0 ? entity.chunkCoordZ - 3 : entity.chunkCoordZ) / 3 * 3) << 4)
-                            - intOffsetZ;
-                    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.glEnd();
         GL11.glEnable(GL11.GL_LIGHTING);

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

@@ -1,17 +1,5 @@
 package codechicken.nei.api;
 
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
-import net.minecraft.block.Block;
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-
-import org.lwjgl.input.Keyboard;
-
 import codechicken.nei.ItemList;
 import codechicken.nei.ItemSorter;
 import codechicken.nei.ItemStackSet;
@@ -27,24 +15,28 @@ 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;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import org.lwjgl.input.Keyboard;
 
-import com.google.common.collect.Sets;
+import java.util.Collections;
+import java.util.Comparator;
 
 /**
- * This is the main class that handles item property configuration. WARNING: DO NOT access this class until the world
- * has been loaded These methods should be called from INEIConfig implementors
+ * This is the main class that handles item property configuration.
+ * WARNING: DO NOT access this class until the world has been loaded
+ * These methods should be called from INEIConfig implementors
  */
-public class API {
-
+public class API
+{
     /**
      * Register a new Crafting Recipe handler;
      *
@@ -67,7 +59,8 @@ public class API {
      * Add a gui to the default overlay renderer with the default position
      *
      * @param classz The class of your gui
-     * @param ident  The identification string, currently {crafting, crafting2x2, smelting, fuel, brewing}
+     * @param ident  The identification string, currently
+     *               {crafting, crafting2x2, smelting, fuel, brewing}
      */
     public static void registerGuiOverlay(Class<? extends GuiContainer> classz, String ident) {
         registerGuiOverlay(classz, ident, 5, 11);
@@ -77,7 +70,8 @@ public class API {
      * Add a gui to the default overlay renderer with an offset
      *
      * @param classz The class of your gui
-     * @param ident  The identification string, currently {crafting, crafting2x2, smelting, fuel, brewing}
+     * @param ident  The identification string, currently
+     *               {crafting, crafting2x2, smelting, fuel, brewing}
      * @param x      x-offset
      * @param y      y-offset
      */
@@ -89,11 +83,11 @@ public class API {
      * Add a gui to the default overlay renderer
      *
      * @param classz     The class of your gui
-     * @param ident      The identification string, currently {crafting, crafting2x2, smelting, fuel, brewing}
+     * @param ident      The identification string, currently
+     *                   {crafting, crafting2x2, smelting, fuel, brewing}
      * @param positioner A Stack Repositioner for moving the items to the right place
      */
-    public static void registerGuiOverlay(Class<? extends GuiContainer> classz, String ident,
-            IStackPositioner positioner) {
+    public static void registerGuiOverlay(Class<? extends GuiContainer> classz, String ident, IStackPositioner positioner) {
         RecipeInfo.registerGuiOverlay(classz, ident, positioner);
     }
 
@@ -102,22 +96,12 @@ public class API {
      * @param handler The handler to register
      * @param ident   The recipe identification string
      */
-    public static void registerGuiOverlayHandler(Class<? extends GuiContainer> classz, IOverlayHandler handler,
-            String ident) {
+    public static void registerGuiOverlayHandler(Class<? extends GuiContainer> classz, IOverlayHandler handler, String ident) {
         RecipeInfo.registerOverlayHandler(classz, handler, ident);
     }
 
     /**
-     * @param classz The class of your gui
-     * @param ident  The recipe identification string
-     */
-    public static boolean hasGuiOverlayHandler(Class<? extends GuiContainer> classz, String ident) {
-        return RecipeInfo.hasOverlayHandler(classz, ident);
-    }
-
-    /**
-     * Set the offset to be added to items to translate them into recipe coords on the actual gui, default is 5, 11.
-     * Primarily RecipeTransferRects
+     * Set the offset to be added to items to translate them into recipe coords on the actual gui, default is 5, 11. Primarily RecipeTransferRects
      *
      * @param classz The class of your gui
      * @param x
@@ -137,52 +121,43 @@ public class API {
     }
 
     /**
-     * Hide an item from the item panel Damage values of OreDictionary.WILDCARD_VALUE and ItemStackMap.WILDCARD_TAG tags
-     * function as wildcards for their respective variables
+     * Hide an item from the item panel
+     * Damage values of OreDictionary.WILDCARD_VALUE and ItemStackMap.WILDCARD_TAG tags function as wildcards for their respective variables
      */
     public static void hideItem(ItemStack item) {
-        if (!ItemInfo.hiddenItems.contains(item)) {
-            ItemInfo.hiddenItems.add(item);
-            LayoutManager.markItemsDirty();
-        }
+        ItemInfo.hiddenItems.add(item);
+        LayoutManager.markItemsDirty();
     }
 
     /**
      * Add or replace the name normally shown on the item tooltip
      */
     public static void setOverrideName(ItemStack item, String name) {
-        if (!name.equals(ItemInfo.nameOverrides.get(item))) {
-            ItemInfo.nameOverrides.put(item, name);
-            LayoutManager.markItemsDirty();
-        }
+        ItemInfo.nameOverrides.put(item, name);
+        LayoutManager.markItemsDirty();
     }
 
     /**
      * Adds an item to the item panel. Any items added using this function will override the default search pattern.
-     * 
      * @param item an item with data
      */
     public static void addItemListEntry(ItemStack item) {
-        if (!ItemInfo.itemOverrides.containsEntry(item.getItem(), item)) {
-            ItemInfo.itemOverrides.put(item.getItem(), item);
-            LayoutManager.markItemsDirty();
-        }
+        ItemInfo.itemOverrides.put(item.getItem(), item);
+        LayoutManager.markItemsDirty();
     }
 
     /**
      * Sets the item variants to appear in the item panel, overriding the default search pattern for a given item
      */
     public static void setItemListEntries(Item item, Iterable<ItemStack> items) {
-        if (items == null) items = Collections.emptyList();
-        if (!Sets.newHashSet(items).equals(Sets.newHashSet(ItemInfo.itemOverrides.get(item)))) {
-            ItemInfo.itemOverrides.replaceValues(item, items);
-            LayoutManager.markItemsDirty();
-        }
+        if(items == null)
+            items = Collections.emptyList();
+        ItemInfo.itemOverrides.replaceValues(item, items);
+        LayoutManager.markItemsDirty();
     }
 
     /**
      * Add a custom KeyBinding to be configured in the Controls menu.
-     * 
      * @param ident      An identifier for your key, eg "shoot"
      * @param defaultKey The default value, commonly obtained from {@link Keyboard}
      */
@@ -192,24 +167,12 @@ public class API {
         addOption(new OptionKeyBind(ident));
     }
 
-    /**
-     * Add a custom KeyBinding to be configured in the Controls menu.
-     * 
-     * @param ident      An identifier for your key, eg "shoot"
-     * @param defaultKey The default value, commonly obtained from {@link Keyboard}
-     */
-    public static void addHashBind(String ident, int defaultKey) {
-        NEIClientConfig.setDefaultKeyBinding(ident, defaultKey);
-        addOption(new OptionKeyBind(ident, true));
-    }
-
     public static void addOption(Option option) {
         NEIClientConfig.getOptionList().addOption(option);
     }
 
     /**
      * Add a new Layout Style for the NEI interface
-     * 
      * @param styleID The Unique ID to be used for storing your style in the config and cycling through avaliable styles
      * @param style   The style to add.
      */
@@ -219,7 +182,6 @@ public class API {
 
     /**
      * Registers a new Infinite Item Handler.
-     * 
      * @param handler The handler to be registered.
      */
     public static void addInfiniteItemHandler(IInfiniteItemHandler handler) {
@@ -228,7 +190,6 @@ public class API {
 
     /**
      * Registers a new Infinite Item Handler.
-     * 
      * @param block   The block to handle, null for all.
      * @param handler The handler to be registered.
      */
@@ -238,7 +199,6 @@ public class API {
 
     /**
      * Tells NEI not to perform any Fast Transfer operations on slots of a particular class
-     * 
      * @param slotClass The class of slot to be exempted
      */
     public static void addFastTransferExemptSlot(Class<? extends Slot> slotClass) {
@@ -247,10 +207,8 @@ public class API {
 
     /**
      * Register a new text handler for the block highlight tooltip with a layout specification (HEADER, BODY or FOOTER).
-     * 
      * @param handler The handler to be registered.
-     * @param layout  A HUDAugmenterRegistry.Layout entry. HEADER is displayed before BODY which is displayed before
-     *                FOOTER.
+     * @param layout  A HUDAugmenterRegistry.Layout entry. HEADER is displayed before BODY which is displayed before FOOTER.
      */
     public static void registerHighlightHandler(IHighlightHandler handler, ItemInfo.Layout... layout) {
         ItemInfo.registerHighlightHandler(handler, layout);
@@ -258,7 +216,6 @@ public class API {
 
     /**
      * Register a mode handler for overriding NEI recipe/utility/cheat mode settings.
-     * 
      * @param handler The handler to be registered.
      */
     public static void registerModeHandler(INEIModeHandler handler) {
@@ -267,7 +224,6 @@ public class API {
 
     /**
      * Register a filter provider for the item panel.
-     * 
      * @param filterProvider The filter provider to be registered.
      */
     public static void addItemFilter(ItemFilterProvider filterProvider) {
@@ -278,8 +234,7 @@ public class API {
 
     /**
      * Adds a new tag to the item subset dropdown.
-     * 
-     * @param name   The fully qualified name, Eg Blocks.MobSpawners. NOT case sensitive
+     * @param name The fully qualified name, Eg Blocks.MobSpawners. NOT case sensitive
      * @param filter A filter for matching items that fit in this subset
      */
     public static void addSubset(String name, ItemFilter filter) {
@@ -288,13 +243,13 @@ public class API {
 
     /**
      * Adds a new tag to the item subset dropdown.
-     * 
-     * @param name  The fully qualified name, Eg Blocks.MobSpawners. NOT case sensitive
+     * @param name The fully qualified name, Eg Blocks.MobSpawners. NOT case sensitive
      * @param items An iterable of itemstacks to be added as a subset
      */
     public static void addSubset(String name, Iterable<ItemStack> items) {
         ItemStackSet filter = new ItemStackSet();
-        for (ItemStack item : items) filter.add(item);
+        for(ItemStack item : items)
+            filter.add(item);
         addSubset(new SubsetTag(name, filter));
     }
 
@@ -314,99 +269,19 @@ public class API {
 
     /**
      * Adds a new sorting option to the item panel sort menu
-     * 
-     * @param name A unique id for this sort option. Will be used in the config for saving and translated in the options
-     *             gui. Note that if the translation key name.tip exists, it will be used for a tooltip
+     * @param name A unique id for this sort option. Will be used in the config for saving and translated in the options gui. Note that if the translation key name.tip exists, it will be used for a tooltip
      */
     public static void addSortOption(String name, Comparator<ItemStack> comparator) {
         ItemSorter.add(name, comparator);
     }
 
     /**
-     * Adds an additional item list entry for an item, sorted after the rest of the items are found through the normal
-     * process
-     * 
-     * @param item    The item to add the variant for
+     * Adds an additional item list entry for an item, sorted after the rest of the items are found through the normal process
+     * @param item The item to add the variant for
      * @param variant The stack to appear in the item panel
      */
     public static void addItemVariant(Item item, ItemStack variant) {
-        if (!ItemInfo.itemVariants.containsEntry(item, variant)) {
-            ItemInfo.itemVariants.put(item, variant);
-            LayoutManager.markItemsDirty();
-        }
+        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/DefaultOverlayRenderer.java

@@ -1,42 +1,44 @@
 package codechicken.nei.api;
 
+import codechicken.nei.PositionedStack;
+import codechicken.nei.guihook.GuiContainerManager;
+import net.minecraft.inventory.Slot;
+import org.lwjgl.opengl.GL11;
+
 import java.util.ArrayList;
 import java.util.List;
 
-import net.minecraft.inventory.Slot;
-
-import org.lwjgl.opengl.GL11;
-
-import codechicken.nei.PositionedStack;
-import codechicken.nei.guihook.GuiContainerManager;
-
-public class DefaultOverlayRenderer implements IRecipeOverlayRenderer {
-
-    public DefaultOverlayRenderer(List<PositionedStack> ai, IStackPositioner positioner) {
+public class DefaultOverlayRenderer implements IRecipeOverlayRenderer
+{    
+    public DefaultOverlayRenderer(List<PositionedStack> ai, IStackPositioner positioner)
+    {
         positioner = this.positioner = positioner;
         ingreds = new ArrayList<>();
-        for (PositionedStack stack : ai) ingreds.add(stack.copy());
+        for(PositionedStack stack : ai)
+            ingreds.add(stack.copy());
         ingreds = positioner.positionStacks(ingreds);
     }
-
+    
     @Override
-    public void renderOverlay(GuiContainerManager gui, Slot slot) {
+    public void renderOverlay(GuiContainerManager gui, Slot slot)
+    {
         GL11.glEnable(GL11.GL_BLEND);
         GL11.glBlendFunc(770, 1);
         GL11.glColor4d(0.6, 0.6, 0.6, 0.7);
-
+        
         GuiContainerManager.setColouredItemRender(true);
-        for (PositionedStack stack : ingreds) {
-            if (stack.relx == slot.xDisplayPosition && stack.rely == slot.yDisplayPosition)
+        for(PositionedStack stack : ingreds)
+        {
+            if(stack.relx == slot.xDisplayPosition && stack.rely == slot.yDisplayPosition)
                 GuiContainerManager.drawItem(stack.relx, stack.rely, stack.item);
         }
         GuiContainerManager.setColouredItemRender(false);
-
+        
         GL11.glColor4f(1, 1, 1, 1);
         GL11.glDisable(GL11.GL_BLEND);
         GL11.glEnable(GL11.GL_LIGHTING);
     }
-
+    
     final IStackPositioner positioner;
     ArrayList<PositionedStack> ingreds;
 }

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

@@ -1,41 +1,29 @@
 package codechicken.nei.api;
 
+import codechicken.nei.NEIChestGuiHandler;
+import codechicken.nei.NEICreativeGuiHandler;
+import codechicken.nei.NEIDummySlotHandler;
+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;
 
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.client.gui.inventory.GuiContainerCreative;
-
-import codechicken.lib.vec.Rectangle4i;
-import codechicken.nei.NEIChestGuiHandler;
-import codechicken.nei.NEICreativeGuiHandler;
-import codechicken.nei.NEIDummySlotHandler;
-import codechicken.nei.NEIPotionGuiHandler;
-import codechicken.nei.recipe.CheatItemHandler;
-import codechicken.nei.recipe.FillFluidContainerHandler;
-import codechicken.nei.recipe.GuiRecipeCatalyst;
-import codechicken.nei.recipe.SearchInputDropHandler;
-
 public class GuiInfo {
-
     public static final LinkedList<INEIGuiHandler> guiHandlers = new LinkedList<>();
     public static final HashSet<Class<? extends GuiContainer>> customSlotGuis = new HashSet<>();
     public static ReentrantReadWriteLock guiHandlersLock = new ReentrantReadWriteLock();
     public static Lock writeLock = guiHandlersLock.writeLock();
     public static Lock readLock = guiHandlersLock.readLock();
 
+
     public static void load() {
         API.registerNEIGuiHandler(new NEICreativeGuiHandler());
         API.registerNEIGuiHandler(new NEIChestGuiHandler());
         API.registerNEIGuiHandler(new NEIDummySlotHandler());
-        API.registerNEIGuiHandler(new GuiRecipeCatalyst(null));
-        API.registerNEIGuiHandler(new SearchInputDropHandler());
-        API.registerNEIGuiHandler(new FillFluidContainerHandler());
-        API.registerNEIGuiHandler(new CheatItemHandler());
-        API.registerNEIGuiHandler(new NEIPotionGuiHandler());
         customSlotGuis.add(GuiContainerCreative.class);
     }
 
@@ -51,26 +39,4 @@ public class GuiInfo {
     public static boolean hasCustomSlots(GuiContainer gui) {
         return customSlotGuis.contains(gui.getClass());
     }
-
-    public static boolean hideItemPanelSlot(GuiContainer gui, Rectangle4i rect) {
-        try {
-            readLock.lock();
-            if (guiHandlers.stream()
-                    .anyMatch(handler -> handler.hideItemPanelSlot(gui, rect.x, rect.y, rect.w, rect.h))) {
-                return true;
-            }
-        } finally {
-            readLock.unlock();
-        }
-
-        for (Object item : gui.buttonList) {
-            GuiButton button = (GuiButton) item;
-
-            if ((new Rectangle4i(button.xPosition, button.yPosition, button.width, button.height)).intersects(rect)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
 }

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

@@ -1,14 +1,13 @@
 package codechicken.nei.api;
 
 /**
- * An nei configuration entry point should implement this class and have name "NEI<someting>Config" loadConfig will only
- * be called when NEI is installed.
+ * An nei configuration entry point should implement this class and have name "NEI<someting>Config"
+ * loadConfig will only be called when NEI is installed.
  */
-public interface IConfigureNEI {
-
+public interface IConfigureNEI
+{
     public void loadConfig();
-
+    
     public String getName();
-
     public String getVersion();
 }

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

@@ -1,13 +1,8 @@
 package codechicken.nei.api;
 
-import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.client.gui.inventory.GuiContainer;
 
-public interface IGuiContainerOverlay {
-
-    GuiContainer getFirstScreen();
-
-    default GuiScreen getFirstScreenGeneral() {
-        return getFirstScreen();
-    }
+public interface IGuiContainerOverlay
+{
+    public GuiContainer getFirstScreen();
 }

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

@@ -1,16 +1,15 @@
 package codechicken.nei.api;
 
-import java.util.List;
-
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.MovingObjectPosition;
 import net.minecraft.world.World;
 
-public interface IHighlightHandler {
+import java.util.List;
 
+public interface IHighlightHandler
+{
     public ItemStack identifyHighlight(World world, EntityPlayer player, MovingObjectPosition mop);
 
-    public List<String> handleTextData(ItemStack itemStack, World world, EntityPlayer player, MovingObjectPosition mop,
-            List<String> currenttip, ItemInfo.Layout layout);
+    public List<String> handleTextData(ItemStack itemStack, World world, EntityPlayer player, MovingObjectPosition mop, List<String> currenttip, ItemInfo.Layout layout);
 }

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

@@ -3,17 +3,14 @@ package codechicken.nei.api;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 
-public interface IInfiniteItemHandler {
-
+public interface IInfiniteItemHandler
+{
     void onPickup(ItemStack heldItem);
-
     void onPlaceInfinite(ItemStack heldItem);
-
+    
     boolean canHandleItem(ItemStack stack);
-
     boolean isItemInfinite(ItemStack stack);
-
+    
     public void replenishInfiniteStack(InventoryPlayer inventory, int slotNo);
-
     public ItemStack getInfiniteItem(ItemStack typeStack);
 }

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

@@ -1,24 +1,20 @@
 package codechicken.nei.api;
 
+import codechicken.nei.VisiblityData;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.item.ItemStack;
+
 import java.util.Collections;
 import java.util.List;
-import java.util.regex.Pattern;
-
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.EnumChatFormatting;
-
-import codechicken.nei.VisiblityData;
 
 /**
  * Lets you just override those things you want to
  */
-public class INEIGuiAdapter implements INEIGuiHandler {
-
-    static final Pattern SPECIAL_REGEX_CHARS = Pattern.compile("[{}()\\[\\].+*?^$\\\\|]");
-
+public class INEIGuiAdapter implements INEIGuiHandler
+{
     @Override
-    public VisiblityData modifyVisiblity(GuiContainer gui, VisiblityData currentVisibility) {
+    public VisiblityData modifyVisiblity(GuiContainer gui, VisiblityData currentVisibility)
+    {
         return currentVisibility;
     }
 
@@ -28,22 +24,20 @@ public class INEIGuiAdapter implements INEIGuiHandler {
     }
 
     @Override
-    public List<TaggedInventoryArea> getInventoryAreas(GuiContainer gui) {
+    public List<TaggedInventoryArea> getInventoryAreas(GuiContainer gui)
+    {
         return null;
     }
 
     @Override
-    public boolean handleDragNDrop(GuiContainer gui, int mousex, int mousey, ItemStack draggedStack, int button) {
+    public boolean handleDragNDrop(GuiContainer gui, int mousex, int mousey, ItemStack draggedStack, int button)
+    {
         return false;
     }
-
+    
     @Override
-    public boolean hideItemPanelSlot(GuiContainer gui, int x, int y, int w, int h) {
-        return false;
-    }
-
-    protected String formattingText(String displayName) {
-        return SPECIAL_REGEX_CHARS.matcher(EnumChatFormatting.getTextWithoutFormattingCodes(displayName))
-                .replaceAll("\\\\$0");
+    public boolean hideItemPanelSlot(GuiContainer gui, int x, int y, int w, int h)
+    {
+    	return false;
     }
 }

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

@@ -1,49 +1,44 @@
 package codechicken.nei.api;
 
-import java.util.List;
-
+import codechicken.nei.VisiblityData;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.item.ItemStack;
 
-import codechicken.nei.VisiblityData;
+import java.util.List;
 
 /**
  * If this is implemented on a gui, it will be automatically registered
  */
-public interface INEIGuiHandler {
-
+public interface INEIGuiHandler
+{
     public VisiblityData modifyVisiblity(GuiContainer gui, VisiblityData currentVisibility);
-
+    
     /**
-     * NEI will give the specified item to the InventoryRange returned if the player's inventory is full. Should not
-     * return null, just an empty list
+     * NEI will give the specified item to the InventoryRange returned if the player's inventory is full.
+     * Should not return null, just an empty list
      */
     public Iterable<Integer> getItemSpawnSlots(GuiContainer gui, ItemStack item);
-
+    
     /**
      * @return A list of TaggedInventoryAreas that will be used with the savestates.
      */
     public List<TaggedInventoryArea> getInventoryAreas(GuiContainer gui);
-
+    
     /**
-     * Handles clicks while an itemstack has been dragged from the item panel. Use this to set configurable slots and
-     * the like. Changes made to the stackSize of the dragged stack will be kept
-     * 
-     * @param gui          The current gui instance
-     * @param mousex       The x position of the mouse
-     * @param mousey       The y position of the mouse
+     * Handles clicks while an itemstack has been dragged from the item panel. Use this to set configurable slots and the like. 
+     * Changes made to the stackSize of the dragged stack will be kept
+     * @param gui The current gui instance
+     * @param mousex The x position of the mouse
+     * @param mousey The y position of the mouse
      * @param draggedStack The stack being dragged from the item panel
-     * @param button       The button presed
-     * @return True if the drag n drop was handled. False to resume processing through other routes. The held stack will
-     *         be deleted if draggedStack.stackSize == 0
+     * @param button The button presed
+     * @return True if the drag n drop was handled. False to resume processing through other routes. The held stack will be deleted if draggedStack.stackSize == 0
      */
     public boolean handleDragNDrop(GuiContainer gui, int mousex, int mousey, ItemStack draggedStack, int button);
-
+    
     /**
-     * Used to prevent the item panel from drawing on top of other gui elements. This function will also be called with
-     * a 1x1 size rectangle on the mouse position for determining if the given coordinate should override item panel
-     * functions such as scrolling
-     * 
+     * Used to prevent the item panel from drawing on top of other gui elements.
+     * This function will also be called with a 1x1 size rectangle on the mouse position for determining if the given coordinate should override item panel functions such as scrolling
      * @param x The x coordinate of the rectangle bounding the slot
      * @param y The y coordinate of the rectangle bounding the slot
      * @param w The w coordinate of the rectangle bounding the slot

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

@@ -1,6 +1,6 @@
 package codechicken.nei.api;
 
-public interface INEIModeHandler {
-
+public interface INEIModeHandler
+{
     public boolean isModeValid(int mode);
 }

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

@@ -1,10 +1,9 @@
 package codechicken.nei.api;
 
+import codechicken.nei.recipe.IRecipeHandler;
 import net.minecraft.client.gui.inventory.GuiContainer;
 
-import codechicken.nei.recipe.IRecipeHandler;
-
-public interface IOverlayHandler {
-
-    void overlayRecipe(GuiContainer firstGui, IRecipeHandler recipe, int recipeIndex, boolean shift);
+public interface IOverlayHandler
+{
+    public void overlayRecipe(GuiContainer firstGui, IRecipeHandler recipe, int recipeIndex, boolean shift);
 }

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

@@ -1,10 +1,9 @@
 package codechicken.nei.api;
 
+import codechicken.nei.guihook.GuiContainerManager;
 import net.minecraft.inventory.Slot;
 
-import codechicken.nei.guihook.GuiContainerManager;
-
-public interface IRecipeOverlayRenderer {
-
+public interface IRecipeOverlayRenderer
+{
     public void renderOverlay(GuiContainerManager gui, Slot slot);
 }

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

@@ -1,14 +1,14 @@
 package codechicken.nei.api;
 
-import java.util.ArrayList;
-
 import codechicken.nei.PositionedStack;
 
+import java.util.ArrayList;
+
 /**
  * For repositioning recipes in overlay renderers.
- *
+ * 
  */
-public interface IStackPositioner {
-
+public interface IStackPositioner
+{
     public ArrayList<PositionedStack> positionStacks(ArrayList<PositionedStack> ai);
 }