Update plugin com.android.application to v8.3.2

.github/workflows/build.yml

@@ -23,9 +23,7 @@ jobs:
       contents: write
 
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 
 
       - name: set up secrets
         run: |
@@ -34,6 +32,7 @@ jobs:
           gpg -d --passphrase "${{ secrets.RELEASE_KEYSTORE_PASSWORD }}" --batch keystore.asc > app/keystore.properties
           gpg -d --passphrase "${{ secrets.RELEASE_KEYSTORE_PASSWORD }}" --batch key.asc > app/key.jks          
 
+      - uses: gradle/wrapper-validation-action@v2
 
       - name: create and checkout branch
         if: github.event_name == 'pull_request'
@@ -42,38 +41,17 @@ jobs:
         run: git checkout -B "$BRANCH"
 
       - name: set up JDK
-        uses: actions/setup-java@v6
+        uses: actions/setup-java@v4
         with:
-          java-version: 21
+          java-version: 17
           distribution: "temurin"
-
+          cache: 'gradle'
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6
-
-      - name: Run unit tests
-        run: ./gradlew testDebugUnitTest
 
       - name: Build APK
-        run: |
+        run: ./gradlew assembleSignedRelease
-          VERSION_CODE=$(git rev-list --count HEAD)
-          VERSION_BASE=$(git describe --tags --abbrev=0 | sed 's/^v//')
-          VERSION_DEV=$(git rev-list --count $(git describe --tags --abbrev=0)..HEAD)
-          if [ $VERSION_DEV -gt 0 ]; then
-            VERSION_NAME="${VERSION_BASE}.${VERSION_DEV}"
-          else
-            VERSION_NAME="${VERSION_BASE}"
-          fi
-          ./gradlew assembleSignedRelease -PVERSION_CODE=$VERSION_CODE -PVERSION_NAME=$VERSION_NAME
-
-      - name: Upload APK
-        uses: actions/upload-artifact@v7
-        with:
-          path: app/build/outputs/apk/signedRelease/app-signedRelease.apk
-          compression-level: 0
-          archive: false
 
       - name: Release
-        uses: softprops/action-gh-release@v3
+        uses: softprops/action-gh-release@v2
         if: startsWith(github.ref, 'refs/tags/')
         with:
           files: |

.gitignore

@@ -20,8 +20,8 @@ app/build/
 app/debug/
 app/release/
 captures/
+.externalNativeBuild
+.cxx
 local.properties
 keystore.properties
 key.jks
-# generated map intermediates; the packed .bmap in assets is what ships
-mapdata/*.geojson

LICENSE

@@ -1,674 +0,0 @@
-                    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) 2024  Frédéric Gerber
-
-    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) 2024  Frédéric Gerber
-    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>.

README.md

@@ -5,13 +5,11 @@
   
   <p>A virtual scratchmap of the world</p>
   
-  <a href="https://ko-fi.com/I2I615VP5M"><img src="https://ko-fi.com/img/githubbutton_sm.svg" alt="ko-fi"></a>
-  <br>
   <img src="https://forthebadge.com/images/badges/built-for-android.svg" alt="Built for Android">
   <img src="https://forthebadge.com/images/badges/built-with-love.svg" alt="Built with love">
   <br>
-    <a href="https://github.com/helcel-net/beans/actions/workflows/build.yml">
+    <a href="https://github.com/choelzl/beans/actions/workflows/build.yml">
-    <img src="https://github.com/helcel-net/beans/actions/workflows/build.yml/badge.svg?branch=main" alt="Build Status">
+    <img src="https://github.com/choelzl/beans/actions/workflows/build.yml/badge.svg?branch=main" alt="Build Status">
   </a>
 </div>
 
@@ -20,10 +18,9 @@
 <div align="center">
   <table>
     <tr>
-      <td style="width: 33%; height: 100px;"><img src="./metadata/en-US/images/phoneScreenshots/screenshot01.png" alt="Map" style="width: 100%; height: 100%;"></td>
+      <td style="width: 33%; height: 100px;"><img src="./metadata/en-US/images/phoneScreenshots/launcher.jpg" alt="Launcher" style="width: 100%; height: 100%;"></td>
-      <td style="width: 33%; height: 100px;"><img src="./metadata/en-US/images/phoneScreenshots/screenshot02.png" alt="Edit" style="width: 100%; height: 100%;"></td>
+      <td style="width: 33%; height: 100px;"><img src="./metadata/en-US/images/phoneScreenshots/view.jpg" alt="View" style="width: 100%; height: 100%;"></td>
-      <td style="width: 33%; height: 100px;"><img src="./metadata/en-US/images/phoneScreenshots/screenshot03.png" alt="Statistics" style="width: 100%; height: 100%;"></td>
+      <td style="width: 33%; height: 100px;"><img src="./metadata/en-US/images/phoneScreenshots/edit.jpg" alt="Edit" style="width: 100%; height: 100%;"></td>
-      <td style="width: 33%; height: 100px;"><img src="./metadata/en-US/images/phoneScreenshots/screenshot04.png" alt="Settings" style="width: 100%; height: 100%;"></td>
     </tr>
   </table>
 </div>
@@ -33,26 +30,17 @@
 - Color a map of places based on custom labels
 - Country/State based coloring
 - Single/Multi color modes
-- Different map projections available
 - Small & Fast
 - Statistics (WIP)
-- 100% Free and Open Source software, with no proprietary dependencies
 
 ## 📳 Installation
 
 <div style="display: flex; justify-content: center; align-items: center; flex-direction: row;">
-    <!--<a href="https://f-droid.org/packages/net.helcel.beans/">
+    <a href="https://github.com/choelzl/beans/releases/latest">
-        <img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png" alt="Get it on F-Droid" width="206">
-    </a>-->
-    <a href="https://apt.izzysoft.de/fdroid/index/apk/net.helcel.beans">
-        <img width="200" height="80" alt="Izzy Download" src=".github/images/izzy.png">
-    </a>
-    <a href="https://github.com/helcel-net/beans/releases/latest">
         <img width="200" height="84" alt="APK Download" src=".github/images/apk.png">
     </a>
 </div>
 
-
 ## ⚙️ Permissions
 
 None
@@ -73,18 +61,7 @@ Thanks to all contributors, the developers of our dependencies, and our users.
 ## 📝 License
 
 ```
-Copyright (C) 2026 Helcel & MYDOLI
+Copyright (C) 2024 Helcel
 
-This program is free software: you can redistribute it and/or modify
+Licensed under ???
-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/>.
 ```

app/build.gradle

@@ -1,24 +1,24 @@
 plugins {
     id 'com.android.application'
-    id 'org.jetbrains.kotlin.plugin.serialization' version '2.4.20'
+    id 'org.jetbrains.kotlin.android'
-    id 'org.jetbrains.kotlin.plugin.compose' version '2.4.20'
+    id 'org.jetbrains.kotlin.plugin.serialization' version '1.9.23'
+    id 'com.mikepenz.aboutlibraries.plugin' version '11.1.3'
 }
 
+
 android {
     namespace 'net.helcel.beans'
-    compileSdk = 37
+    compileSdk 34
 
     defaultConfig {
-        buildConfigField("String", "APP_NAME", "\"Beans\"")
-        manifestPlaceholders["APP_NAME"] = "Beans"
         applicationId 'net.helcel.beans'
-        minSdk = 28
+        minSdk 28
-        targetSdk = 37
+        targetSdk 34
-        versionName project.hasProperty('VERSION_NAME') ? project.property('VERSION_NAME') : "1.5"
+        versionCode 1
-        versionCode project.hasProperty('VERSION_CODE') ? project.property('VERSION_CODE').toInteger() : 1
+        versionName "0.1a"
     }
     signingConfigs {
-        register("release") {
+        create("release") {
             try {
                 def keystorePropertiesFile = rootProject.file("app/keystore.properties")
                 def keystoreProperties = new Properties()
@@ -33,18 +33,20 @@ android {
             }
         }
     }
+
+
     buildTypes {
         debug {
             debuggable true
         }
         release {
             minifyEnabled true
-            shrinkResources true
+            shrinkResources false
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
         }
         signedRelease {
             minifyEnabled true
-            shrinkResources true
+            shrinkResources false
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
             signingConfig = signingConfigs.getByName("release")
         }
@@ -52,15 +54,17 @@ android {
     compileOptions {
         coreLibraryDesugaringEnabled true
 
-        sourceCompatibility JavaVersion.VERSION_21
+        sourceCompatibility JavaVersion.VERSION_17
-        targetCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_17
         encoding 'utf-8'
     }
 
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_17
+    }
+
     buildFeatures {
         viewBinding true
-        compose true
-        buildConfig true
     }
 
     dependenciesInfo {
@@ -69,43 +73,19 @@ android {
         // Disables dependency metadata when building Android App Bundles.
         includeInBundle = false
     }
-    composeOptions {
-        kotlinCompilerExtensionVersion = "2.2.20"
-    }
-
-    androidResources {
-        // The app ships English strings only; without this the libraries drag
-        // in some eighty locales of their own.
-        localeFilters += ["en"]
-    }
-
-    lint {
-        disable 'UsingMaterialAndMaterial3Libraries'
-    }
 
 }
+aboutLibraries {
+    exclusionPatterns = [~"androidx.*", ~"com.google.android.*", ~"org.jetbrains.*"]
+}
 
 dependencies {
-    implementation 'androidx.compose.material3:material3:1.4.0'
+    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs_nio:2.0.4'
-    implementation "androidx.compose.material:material:1.12.1"
+    implementation 'androidx.preference:preference-ktx:1.2.1'
-    implementation 'androidx.compose.material:material-icons-extended:1.7.8'
+    implementation 'com.google.android.material:material:1.11.0'
-    implementation 'androidx.navigation:navigation-compose:2.10.1'
+    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3'
-    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs_nio:2.1.5'
 
-    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.11.0'
+    implementation 'com.caverock:androidsvg-aar:1.4'
-
+    implementation 'com.github.chrisbanes:PhotoView:2.3.0'
-    implementation 'androidx.compose.ui:ui'
+    implementation 'com.mikepenz:aboutlibraries:11.1.3'
-    implementation "androidx.activity:activity-ktx:1.13.0"
-
-    implementation 'androidx.compose.ui:ui-tooling-preview'
-
-
-    implementation platform('androidx.compose:compose-bom:2026.08.00')
-    debugImplementation 'androidx.compose.ui:ui-tooling:1.12.0'
-}
-
-tasks.configureEach { task ->
-    if (task.name.startsWith("merge") && task.name.endsWith("Assets")) {
-        task.outputs.upToDateWhen { false }
-    }
 }

app/src/main/AndroidManifest.xml

@@ -1,21 +1,50 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
+
     <application
         android:allowBackup="true"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"
         android:hardwareAccelerated="false"
         android:icon="@mipmap/ic_launcher_round"
-        android:label="${APP_NAME}"
+        android:label="@string/app_name"
-        android:supportsRtl="true">
+        android:supportsRtl="true"
+        android:theme="@style/Theme.Beans"
+        tools:replace="android:allowBackup"
+        tools:targetApi="31">
+        <profileable android:shell="true" />
+
         <activity
-            android:name=".activity.MainScreen"
+            android:name=".activity.MainActivity"
             android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
+        <activity
+            android:name=".activity.EditActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".activity.StatsActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".activity.SettingsActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+            </intent-filter>
+        </activity>
+
     </application>
+
 </manifest>

app/src/main/java/net/helcel/beans/activity/EditActivity.kt

@@ -0,0 +1,71 @@
+package net.helcel.beans.activity
+
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuItem
+import androidx.activity.addCallback
+import androidx.appcompat.app.AppCompatActivity
+import androidx.fragment.app.Fragment
+import com.google.android.material.tabs.TabLayoutMediator
+import net.helcel.beans.R
+import net.helcel.beans.activity.adapter.ViewPagerAdapter
+import net.helcel.beans.activity.fragment.EditGroupAddFragment
+import net.helcel.beans.activity.fragment.EditPlaceColorFragment
+import net.helcel.beans.activity.fragment.EditPlaceFragment
+import net.helcel.beans.countries.World
+import net.helcel.beans.databinding.ActivityEditBinding
+import net.helcel.beans.helper.Data
+import net.helcel.beans.helper.DialogCloser
+import net.helcel.beans.helper.Settings
+import net.helcel.beans.helper.Theme.createActionBar
+
+
+class EditActivity : AppCompatActivity() {
+
+    private lateinit var _binding: ActivityEditBinding
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        _binding = ActivityEditBinding.inflate(layoutInflater)
+
+        setContentView(_binding.root)
+        createActionBar(this, getString(R.string.action_edit))
+
+        val adapter = ViewPagerAdapter(supportFragmentManager, lifecycle, _binding.pager)
+        _binding.pager.adapter = adapter
+        adapter.addFragment(null, EditPlaceFragment(World.WWW, adapter))
+
+        TabLayoutMediator(_binding.tab, _binding.pager) { tab, position ->
+            tab.text = adapter.getLabel(position)
+        }.attach()
+
+        onBackPressedDispatcher.addCallback {
+            if (!adapter.backPressed()) {
+                finish()
+            }
+        }
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        if (Settings.isSingleGroup(this)) {
+            menuInflater.inflate(R.menu.menu_edit, menu)
+        }
+        return true
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        when (item.itemId) {
+            R.id.action_color -> {
+                Data.groups.getUniqueEntry()?.let { group ->
+                    EditGroupAddFragment(group.key, {
+                        (_binding.pager.adapter as ViewPagerAdapter?)?.refreshColors(group.color)
+                    }, {}, false).show(supportFragmentManager, "AddColorDialogFragment")
+                }
+            }
+            else -> finish()
+        }
+        return super.onOptionsItemSelected(item)
+    }
+
+
+}

app/src/main/java/net/helcel/beans/activity/EditScreen.kt

@@ -1,66 +0,0 @@
-package net.helcel.beans.activity
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material.Icon
-import androidx.compose.material.IconButton
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Scaffold
-import androidx.compose.material.Text
-import androidx.compose.material.TopAppBar
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.filled.ArrowBack
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import net.helcel.beans.R
-import net.helcel.beans.activity.sub.EditPlaceScreen
-import net.helcel.beans.countries.World
-
-@Preview
-@Composable
-fun EditScreen(onExit:()->Unit = {}) {
-    SysTheme {
-        Scaffold(
-            topBar = {
-                TopAppBar(
-                    title = { Text(stringResource(R.string.action_edit)) },
-                    navigationIcon = {
-                        IconButton(onClick = onExit) {
-                            Icon(
-                                Icons.AutoMirrored.Filled.ArrowBack,
-                                contentDescription = null
-                            )
-                        }
-                    }
-                )
-            },
-
-            ) { innerPadding ->
-            Box(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .background(MaterialTheme.colors.background)
-                    .padding(innerPadding) // ensures content is below the app bar
-            ) {
-                Column {
-                    Spacer(
-                        modifier = Modifier.height(2.dp).fillMaxWidth()
-                            .background(MaterialTheme.colors.background)
-                    )
-                    EditPlaceScreen(World.WWW, onExit)
-                }
-            }
-        }
-    }
-}
-
-

app/src/main/java/net/helcel/beans/activity/MainActivity.kt

@@ -0,0 +1,77 @@
+package net.helcel.beans.activity
+
+import android.content.Intent
+import android.graphics.drawable.PictureDrawable
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuItem
+import androidx.appcompat.app.AppCompatActivity
+import com.caverock.androidsvg.RenderOptions
+import net.helcel.beans.R
+import net.helcel.beans.countries.GeoLocImporter
+import net.helcel.beans.databinding.ActivityMainBinding
+import net.helcel.beans.helper.Data
+import net.helcel.beans.helper.Settings
+import net.helcel.beans.helper.Theme.colorWrapper
+import net.helcel.beans.svg.CSSWrapper
+import net.helcel.beans.svg.SVGWrapper
+
+
+class MainActivity : AppCompatActivity() {
+    private lateinit var _binding: ActivityMainBinding
+
+    private lateinit var psvg: SVGWrapper
+    private lateinit var css: CSSWrapper
+
+    override fun onRestart() {
+        refreshProjection()
+        refreshMap()
+        super.onRestart()
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.menu_main, menu)
+        return true
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        val d = when (item.itemId) {
+            R.id.action_edit -> EditActivity::class.java
+            R.id.action_stats -> StatsActivity::class.java
+            R.id.action_settings -> SettingsActivity::class.java
+            else -> throw Exception("Non Existent Menu Item")
+        }
+        startActivity(Intent(this@MainActivity, d))
+        return true
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        _binding = ActivityMainBinding.inflate(layoutInflater)
+        Settings.start(this)
+        supportActionBar?.setBackgroundDrawable(colorWrapper(this, android.R.attr.colorPrimary))
+
+        setContentView(_binding.root)
+
+        _binding.photoView.minimumScale = 1f
+        _binding.photoView.maximumScale = 40f
+
+        GeoLocImporter.importStates(this)
+        Data.loadData(this, Int.MIN_VALUE)
+
+        refreshProjection()
+        refreshMap()
+    }
+
+    private fun refreshMap() {
+        val opt: RenderOptions = RenderOptions.create()
+        opt.css(css.get())
+        _binding.photoView.setImageDrawable(PictureDrawable(psvg.get()?.renderToPicture(opt)))
+    }
+
+    fun refreshProjection() {
+        psvg = SVGWrapper(this)
+        css = CSSWrapper(this)
+    }
+
+}

app/src/main/java/net/helcel/beans/activity/MainScreen.kt

@@ -1,203 +0,0 @@
-package net.helcel.beans.activity
-
-import android.os.Bundle
-import androidx.activity.ComponentActivity
-import androidx.activity.compose.setContent
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.navigationBarsPadding
-import androidx.compose.foundation.layout.statusBarsPadding
-import androidx.compose.material.CircularProgressIndicator
-import androidx.compose.material.Icon
-import androidx.compose.material.IconButton
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Scaffold
-import androidx.compose.material.Text
-import androidx.compose.material.TopAppBar
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Edit
-import androidx.compose.material.icons.filled.Percent
-import androidx.compose.material.icons.filled.Settings
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.viewinterop.AndroidView
-import androidx.navigation.NavHostController
-import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
-import androidx.navigation.compose.rememberNavController
-import net.helcel.beans.BuildConfig
-import net.helcel.beans.activity.sub.EditPlaceDialog
-import net.helcel.beans.activity.sub.MapPickDialog
-import net.helcel.beans.activity.sub.applyDirectVisit
-import net.helcel.beans.activity.sub.commitVisitDialog
-import net.helcel.beans.countries.GeoLoc
-import net.helcel.beans.countries.GeoLocImporter
-import net.helcel.beans.countries.GeoLocTree
-import net.helcel.beans.helper.Data
-import net.helcel.beans.helper.Settings
-import net.helcel.beans.map.MapAssets
-import net.helcel.beans.map.MapStyle
-import net.helcel.beans.map.MapView
-import net.helcel.beans.map.MapWorld
-import net.helcel.beans.map.MapReader
-
-
-class MainScreen : ComponentActivity() {
-
-    private var world by mutableStateOf<MapWorld?>(null)
-    private var loadToken = 0
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        actionBar?.hide()
-        Settings.start(this)
-        Data.loadData(this, Int.MIN_VALUE)
-        GeoLocImporter.importStates(this)
-
-        refreshProjection()
-
-        setContent {
-            SysTheme {
-                // Both bars: without the navigation inset the system buttons sit on top of
-                // whatever is at the bottom of a screen, such as the About button.
-                Box(
-                    modifier = Modifier
-                        .fillMaxSize()
-                        .background(MaterialTheme.colors.primary)
-                        .statusBarsPadding()
-                        .navigationBarsPadding(),
-                ) {
-                    AppNavHost()
-                }
-            }
-        }
-    }
-
-    @Composable
-    fun AppNavHost() {
-        val navController = rememberNavController()
-        NavHost(navController, startDestination = "main") {
-            composable("main") { MainScreenC(world, navController) }
-            composable("settings") { SettingsMainScreen { navController.navigate("main") } }
-            composable("edit") { EditScreen { navController.navigate("main") } }
-            composable("stats") { StatsScreen { navController.navigate("main") } }
-        }
-    }
-
-    @Composable
-    fun MainScreenC(world: MapWorld?, nav: NavHostController){
-        SysTheme {
-            Scaffold(
-                topBar = {
-                    TopAppBar(
-                        title = { Text(BuildConfig.APP_NAME) },
-                        actions = {
-                            IconButton(onClick = { nav.navigate("edit") }) {
-                                Icon(Icons.Default.Edit, contentDescription = "Edit")
-                            }
-                            IconButton(onClick = {  nav.navigate("stats") }){
-                                Icon(Icons.Default.Percent, contentDescription = "Stats")
-                            }
-                            IconButton(onClick = { nav.navigate("settings") }) {
-                                Icon(Icons.Default.Settings, contentDescription = "Settings")
-                            }
-                        }
-                    )
-                }
-            ) { innerPadding ->
-                Box(modifier = Modifier.padding(innerPadding).fillMaxSize()) {
-                    if (world == null) LoadingMap() else MapScreen(world)
-                }
-            }
-        }
-    }
-
-    @Composable
-    fun LoadingMap() {
-        Box(
-            modifier = Modifier.fillMaxSize().background(MaterialTheme.colors.background),
-            contentAlignment = Alignment.Center,
-        ) {
-            CircularProgressIndicator(
-                color = MaterialTheme.colors.primary,
-                strokeWidth = 4.dp,
-                modifier = Modifier.size(50.dp),
-            )
-        }
-    }
-
-    @Composable
-    fun MapScreen(world: MapWorld) {
-        val ctx = LocalContext.current
-        val visits by Data.visits.visitsFlow.collectAsState()
-        val groups by Data.groups.groupsFlow.collectAsState()
-        val land = MaterialTheme.colors.onBackground.toArgb()
-        val background = MaterialTheme.colors.background.toArgb()
-        val style = remember(visits, groups, land, background) {
-            MapStyle.build(ctx, land, background)
-        }
-        val touchRadius = Settings.getTouchRadius(ctx)
-
-        var candidates by remember { mutableStateOf<List<GeoLoc>>(emptyList()) }
-        var showColor by remember { mutableStateOf(false) }
-
-        // A place is either applied straight away, or the colour dialog picks
-        // the group for it, exactly as it does from the edit list.
-        fun select(loc: GeoLoc) {
-            if (!applyDirectVisit(ctx, loc)) showColor = true
-        }
-
-        if (candidates.isNotEmpty()) {
-            MapPickDialog(
-                candidates = candidates,
-                onPick = { candidates = emptyList(); select(it) },
-                onDismiss = { candidates = emptyList() },
-            )
-        }
-        if (showColor) {
-            EditPlaceDialog(false) { cleared ->
-                showColor = false
-                commitVisitDialog(cleared)
-            }
-        }
-
-        AndroidView(
-            factory = { MapView(it) },
-            update = { view ->
-                view.world = world
-                view.style = style
-                view.touchRadiusDp = touchRadius
-                // Always the tree, even for a single hit: landing on a region is
-                // just as often a way of reaching the country around it.
-                view.onPick = { picks ->
-                    val locs = picks.mapNotNull { GeoLocTree.find(it.code) }
-                    if (locs.isNotEmpty()) candidates = locs
-                }
-            },
-            modifier = Modifier.fillMaxSize()
-        )
-    }
-
-    /** Reloads the map asset, on a worker thread since it is a few megabytes. */
-    fun refreshProjection() {
-        val asset = MapAssets.assetFor(this)
-        val token = ++loadToken
-        world = null
-        Thread {
-            val parsed = assets.open(asset).use { MapReader.read(it) }
-            runOnUiThread { if (token == loadToken) world = parsed }
-        }.start()
-    }
-}

app/src/main/java/net/helcel/beans/activity/SettingsActivity.kt

@@ -0,0 +1,63 @@
+package net.helcel.beans.activity
+
+import android.os.Bundle
+import android.view.MenuItem
+import androidx.appcompat.app.AppCompatActivity
+import net.helcel.beans.R
+import net.helcel.beans.activity.fragment.AboutFragment
+import net.helcel.beans.activity.fragment.LicenseFragment
+import net.helcel.beans.activity.fragment.SettingsFragment
+import net.helcel.beans.helper.Theme.createActionBar
+
+class SettingsActivity : AppCompatActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        setContentView(R.layout.activity_settings)
+        createActionBar(this, getString(R.string.action_settings))
+
+        // Populate activity with settings fragment
+        supportFragmentManager.beginTransaction()
+            .replace(R.id.fragment_view, SettingsFragment(), getString(R.string.action_settings))
+            .commit()
+
+        // Change title in action bar according to current fragment
+        supportFragmentManager.addFragmentOnAttachListener { _, _ ->
+            supportActionBar?.title =
+                supportFragmentManager.findFragmentById(R.id.fragment_view).let {
+                    when (it) {
+                        is LicenseFragment -> getString(R.string.licenses)
+                        is AboutFragment -> getString(R.string.about)
+                        else -> getString(R.string.action_settings)
+                    }
+                }
+        }
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        // Configure on back pressed
+        supportFragmentManager.findFragmentById(R.id.fragment_view).let {
+            when (it) {
+                is LicenseFragment, is AboutFragment -> {
+                    supportFragmentManager.beginTransaction()
+                        .remove(it)
+                        .commit()
+                    supportFragmentManager.beginTransaction()
+                        .replace(
+                            R.id.fragment_view,
+                            SettingsFragment(),
+                            getString(R.string.action_settings)
+                        )
+                        .commit()
+                    supportActionBar?.title = getString(R.string.action_settings)
+                }
+
+                else -> {
+                    finish()
+                }
+            }
+        }
+        return super.onOptionsItemSelected(item)
+    }
+}

app/src/main/java/net/helcel/beans/activity/SettingsScreen.kt

@@ -1,467 +0,0 @@
-package net.helcel.beans.activity
-
-import android.os.Build
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.shape.CornerSize
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.Button
-import androidx.compose.material.CircularProgressIndicator
-import androidx.compose.material.Colors
-import androidx.compose.material.Icon
-import androidx.compose.material.IconButton
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.RadioButton
-import androidx.compose.material.Scaffold
-import androidx.compose.material.Slider
-import androidx.compose.material.Text
-import androidx.compose.material.TopAppBar
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.filled.ArrowBack
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.darkColorScheme
-import androidx.compose.material3.dynamicDarkColorScheme
-import androidx.compose.material3.dynamicLightColorScheme
-import androidx.compose.material3.lightColorScheme
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.window.Dialog
-import androidx.core.content.edit
-import androidx.navigation.NavHostController
-import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
-import androidx.navigation.compose.rememberNavController
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import net.helcel.beans.R
-import net.helcel.beans.activity.sub.AboutScreen
-import net.helcel.beans.activity.sub.EditPlaceColorDialog
-import net.helcel.beans.countries.GeoLocImporter
-import net.helcel.beans.helper.DEFAULT_TOUCH_RADIUS
-import net.helcel.beans.helper.Data
-import net.helcel.beans.helper.defaultPreferences
-import net.helcel.beans.helper.MAX_TOUCH_RADIUS
-import net.helcel.beans.helper.Settings
-import kotlin.math.roundToInt
-
-@Composable
-fun SysTheme(
-    content: @Composable () -> Unit
-) {
-    val context = LocalContext.current
-    val prefs = defaultPreferences(context)
-    val themeKey = prefs.getString(stringResource(R.string.key_theme), stringResource(R.string.system))
-    val darkTheme = when (themeKey) {
-        stringResource(R.string.system) -> isSystemInDarkTheme()
-        stringResource(R.string.light) -> false
-        stringResource(R.string.dark) -> true
-        else -> isSystemInDarkTheme()
-    }
-    val colorScheme = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-        if(darkTheme) dynamicDarkColorScheme(LocalContext.current ) else dynamicLightColorScheme(LocalContext.current )
-    } else {
-        if(darkTheme) darkColorScheme() else lightColorScheme()
-    }
-    val m2colors = Colors(
-        primary = colorScheme.primary,
-        primaryVariant = colorScheme.primaryContainer,
-        secondary = colorScheme.secondary,
-        background = colorScheme.background,
-        surface = colorScheme.surface,
-        onPrimary = colorScheme.onPrimary,
-        onSecondary = colorScheme.onSecondary,
-        onBackground = colorScheme.onBackground,
-        onSurface = colorScheme.onSurface,
-        secondaryVariant = colorScheme.secondary,
-        error = colorScheme.error,
-        onError = colorScheme.onError,
-        isLight = !darkTheme,
-    )
-
-    // Both, because the app mixes the two: most of it is Material 2, while the
-    // dividers are Material 3 and would otherwise fall back to the default
-    // light scheme.
-    androidx.compose.material3.MaterialTheme(colorScheme = colorScheme) {
-        MaterialTheme(
-            colors = m2colors,
-            content = content
-        )
-    }
-}
-
-
-@Preview
-@Composable
-fun SettingsMainScreen(onExit: ()->Unit = {}) {
-    val nav: NavHostController = rememberNavController()
-    SysTheme {
-        Scaffold(
-            topBar = {
-                TopAppBar(
-                    title = { Text(stringResource(R.string.action_settings)) },
-                    navigationIcon = {
-                        IconButton(onClick = {
-                            if(!nav.popBackStack())
-                                onExit()
-                        }) {
-                            Icon(
-                                Icons.AutoMirrored.Filled.ArrowBack,
-                                contentDescription = null
-                            )
-                        }
-                    }
-                )
-            }
-        ) { innerPadding ->
-            // One host, inside the scaffold. Building it here and again as a
-            // default argument left two of them: settings drawn twice, and
-            // only the inner one ever navigating.
-            Box(modifier = Modifier.padding(innerPadding)) {
-                NavHost(nav, startDestination = "settings") {
-                    composable("settings") { SettingsScreen(nav) }
-                    composable("about") { AboutScreen() }
-                }
-            }
-        }
-    }
-}
-
-@Composable
-fun SettingsScreen(navController: NavHostController) {
-    val context = LocalContext.current
-    val prefs = defaultPreferences(context)
-    val keyTheme = stringResource(R.string.key_theme)
-    val defaultTheme = stringResource(R.string.system)
-    val keyProjection = stringResource(R.string.key_projection)
-    val keyGroup = stringResource(R.string.key_group)
-    val keyRegional = stringResource(R.string.key_regional)
-    val keyCascadeStats = stringResource(R.string.key_cascade_stats)
-    val keyTouchRadius = stringResource(R.string.key_touch_radius)
-    val offString = stringResource(R.string.off)
-    val onString = stringResource(R.string.on)
-
-    var theme by remember { mutableStateOf(prefs.getString(keyTheme, defaultTheme)!!) }
-    var projection by remember { mutableStateOf(prefs.getString(keyProjection, "default")!!) }
-    var groups by remember { mutableStateOf(prefs.getString(keyGroup, offString)!!) }
-    var regional by remember { mutableStateOf(prefs.getString(keyRegional, offString)!!) }
-    var cascadeStats by remember { mutableStateOf(prefs.getString(keyCascadeStats, offString)!!) }
-    var touchRadius by remember {
-        mutableIntStateOf(prefs.getInt(keyTouchRadius, DEFAULT_TOUCH_RADIUS))
-    }
-
-    var showGroupDialog by remember { mutableStateOf(false) }
-    var showRegionalDialog by remember { mutableStateOf(false) }
-    var showLoad by remember { mutableStateOf(false) }
-    val scope = rememberCoroutineScope()
-
-    if (showGroupDialog) {
-        EditPlaceColorDialog(
-            deleteMode = true,
-            onDismiss = {
-                val g = Data.selected_group
-                if (g != null) {
-                    Data.visits.reassignAllVisitedToGroup(g.key)
-                    Data.groups.keepOnly(g.key)
-                    Data.saveData()
-                    groups = offString
-                    prefs.edit { putString(keyGroup, offString) }
-                }
-                showGroupDialog = false
-            })
-    }
-
-    if (showRegionalDialog) {
-        Dialog(
-            content = {
-                Column(
-                    modifier = Modifier
-                        .background(
-                            MaterialTheme.colors.background,
-                            RoundedCornerShape(corner = CornerSize(16.dp))
-                        )
-                        .padding(16.dp),
-                ) {
-                    Text(
-                        style = MaterialTheme.typography.caption,
-                        text = stringResource(R.string.delete_regions)
-                    )
-                    Button(onClick = {
-                        GeoLocImporter.clearStates()
-                        regional = offString
-                        prefs.edit { putString(keyRegional, offString) }
-                        showRegionalDialog = false
-                    }) {
-                        Text(stringResource(R.string.ok))
-                    }
-                }
-            },
-            onDismissRequest = { showRegionalDialog = false }
-        )
-    }
-
-    if (showLoad) {
-        Dialog(
-            content = {
-                CircularProgressIndicator(
-                    color = MaterialTheme.colors.primary,
-                    strokeWidth = 4.dp,
-                    modifier = Modifier.size(50.dp)
-                )
-            },
-            onDismissRequest = {}
-        )
-    }
-
-    LazyColumn(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(16.dp)
-            .background(MaterialTheme.colors.background)
-    ) {
-        item {
-            Text(
-                stringResource(R.string.key_theme),
-                style = MaterialTheme.typography.h6,
-                color = MaterialTheme.colors.onBackground,
-            )
-            MultiPreference(
-                arrayOf(
-                    stringResource(R.string.system),
-                    stringResource(R.string.light),
-                    stringResource(R.string.dark)
-                ), theme
-            ) { newTheme ->
-                theme = newTheme
-                prefs.edit { putString(keyTheme, newTheme) }
-            }
-            HorizontalDivider()
-        }
-        item {
-            Text(
-                stringResource(R.string.key_projection),
-                style = MaterialTheme.typography.h6,
-                color = MaterialTheme.colors.onBackground,
-                modifier = Modifier.padding(top = 16.dp)
-            )
-            MultiPreference(
-                arrayOf(
-                    stringResource(R.string.mercator),
-                    stringResource(R.string.azimuthalequidistant),
-                    stringResource(R.string.loximuthal),
-                ),
-                projection
-            ) { newProj ->
-                projection = newProj
-                prefs.edit { putString(keyProjection, newProj) }
-                Settings.refreshProjection()
-            }
-            HorizontalDivider()
-        }
-        item {
-            SettingSwitch(
-                label = stringResource(R.string.key_group),
-                subtitle = stringResource(R.string.key_group_desc),
-                isChecked = groups == onString,
-                onCheckedChange = { isChecked ->
-                    if (!isChecked) {
-                        Data.selected_group = null
-                        showGroupDialog = true
-                    } else {
-                        groups = onString
-                        prefs.edit { putString(keyGroup, onString) }
-                    }
-                }
-            )
-            HorizontalDivider()
-        }
-        item {
-            SettingSwitch(
-                label = stringResource(R.string.key_regional),
-                subtitle = stringResource(R.string.key_regional_desc),
-                isChecked = regional == onString,
-                onCheckedChange = { isChecked ->
-                    if (isChecked) {
-                        regional = onString
-                        prefs.edit { putString(keyRegional, onString) }
-                        showLoad = true
-                        scope.launch {
-                            withContext(Dispatchers.IO) {
-                                GeoLocImporter.importStates(context, true)
-                            }
-                            showLoad = false
-                        }
-                    } else {
-                        showRegionalDialog = true
-                    }
-                }
-            )
-            HorizontalDivider()
-        }
-        item {
-            SettingSwitch(
-                label = stringResource(R.string.pref_cascade_stats),
-                subtitle = stringResource(R.string.pref_cascade_stats_desc),
-                isChecked = cascadeStats == onString,
-                onCheckedChange = { isChecked ->
-                    cascadeStats = if (isChecked) onString else offString
-                    prefs.edit { putString(keyCascadeStats, cascadeStats) }
-                }
-            )
-            HorizontalDivider()
-        }
-        item {
-            Text(
-                stringResource(R.string.pref_touch_radius),
-                style = MaterialTheme.typography.h6,
-                color = MaterialTheme.colors.onBackground,
-                modifier = Modifier.padding(top = 16.dp)
-            )
-            Text(
-                stringResource(R.string.pref_touch_radius_desc),
-                style = MaterialTheme.typography.body2,
-                color = MaterialTheme.colors.onSurface.copy(alpha = 0.6f)
-            )
-            Row(verticalAlignment = Alignment.CenterVertically) {
-                Slider(
-                    value = touchRadius.toFloat(),
-                    onValueChange = { touchRadius = it.roundToInt() },
-                    onValueChangeFinished = { prefs.edit { putInt(keyTouchRadius, touchRadius) } },
-                    valueRange = 0f..MAX_TOUCH_RADIUS.toFloat(),
-                    steps = MAX_TOUCH_RADIUS - 1,
-                    modifier = Modifier.weight(1f)
-                )
-                Text(
-                    stringResource(R.string.pref_touch_radius_value, touchRadius),
-                    style = MaterialTheme.typography.body1,
-                    color = MaterialTheme.colors.onBackground,
-                    modifier = Modifier.padding(start = 12.dp)
-                )
-            }
-            HorizontalDivider()
-        }
-        item {
-            val launcher = rememberLauncherForActivityResult(
-                contract = ActivityResultContracts.OpenDocument(),
-                onResult = { uri -> Data.doImport(context, uri) }
-            )
-            Row(
-                modifier = Modifier.fillMaxWidth().padding(vertical = 8.dp)
-            ) {
-                Button(
-                    onClick = {
-                        launcher.launch(arrayOf("*/*"))
-                    }, modifier = Modifier
-                        .weight(1f)
-                ) {
-                    Text(stringResource(R.string.action_import))
-                }
-                Spacer(modifier = Modifier.size(16.dp))
-                Button(
-                    onClick = {
-                        Data.doExport(context)
-                    }, modifier = Modifier
-                        .weight(1f)
-                ) {
-                    Text(stringResource(R.string.action_export))
-                }
-            }
-            HorizontalDivider()
-        }
-        item {
-            PreferenceButton(stringResource(R.string.about)) {
-                if (navController.currentDestination?.route != "about")
-                    navController.navigate("about")
-            }
-        }
-    }
-}
-
-@Composable
-fun MultiPreference(list: Array<String>, selected: String, onSelected: (String) -> Unit) {
-    Column(Modifier.padding(vertical = 2.dp)) {
-        list.forEach { value ->
-            Row(
-                verticalAlignment = Alignment.CenterVertically,
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .height(42.dp)
-                    .clickable { onSelected(value) }) {
-                RadioButton(selected = selected == value, onClick = { onSelected(value) })
-                Text(
-                    value, modifier = Modifier.padding(start = 12.dp),
-                    style = MaterialTheme.typography.body1,
-                    color = MaterialTheme.colors.onBackground,
-                )
-            }
-        }
-    }
-}
-
-@Composable
-fun PreferenceButton(text: String, onClick: () -> Unit) {
-    Button(onClick = onClick, modifier = Modifier
-        .fillMaxWidth()
-        .padding(vertical = 8.dp)) {
-        Text(text)
-    }
-}
-
-@Composable
-fun SettingSwitch(
-    label: String,
-    subtitle: String? = null,
-    isChecked: Boolean,
-    onCheckedChange: (Boolean) -> Unit
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .clickable { onCheckedChange(!isChecked) }
-            .padding(vertical = 12.dp),
-        verticalAlignment = Alignment.CenterVertically
-    ) {
-        Column(modifier = Modifier.weight(1f)) {
-            Text(
-                text=label,
-                style = MaterialTheme.typography.h6,
-                color = MaterialTheme.colors.onBackground,
-            )
-            if (subtitle != null) {
-                Text(
-                    text = subtitle,
-                    style = MaterialTheme.typography.body2,
-                    color = MaterialTheme.colors.onSurface.copy(alpha = 0.6f)
-                )
-            }
-        }
-        androidx.compose.material.Switch(
-            checked = isChecked,
-            onCheckedChange = onCheckedChange
-        )
-    }
-}

app/src/main/java/net/helcel/beans/activity/StatsActivity.kt

@@ -1,219 +1,57 @@
 package net.helcel.beans.activity
 
-import androidx.compose.foundation.background
+import android.os.Bundle
-import androidx.compose.foundation.layout.Arrangement
+import android.view.MenuItem
-import androidx.compose.foundation.layout.Column
+import androidx.appcompat.app.AppCompatActivity
-import androidx.compose.foundation.layout.Row
+import androidx.fragment.app.Fragment
-import androidx.compose.foundation.layout.fillMaxSize
+import androidx.recyclerview.widget.LinearLayoutManager
-import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.recyclerview.widget.RecyclerView
-import androidx.compose.foundation.layout.padding
+import androidx.viewpager2.adapter.FragmentStateAdapter
-import androidx.compose.foundation.lazy.LazyColumn
+import androidx.viewpager2.widget.ViewPager2
-import androidx.compose.foundation.lazy.items
+import com.google.android.material.tabs.TabLayoutMediator
-import androidx.compose.material.Button
-import androidx.compose.material.Icon
-import androidx.compose.material.IconButton
-import androidx.compose.material.Scaffold
-import androidx.compose.material.Tab
-import androidx.compose.material.TabRow
-import androidx.compose.material.Text
-import androidx.compose.material.TopAppBar
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.filled.ArrowBack
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
 import net.helcel.beans.R
-import net.helcel.beans.countries.Country
+import net.helcel.beans.activity.adapter.StatsListAdapter
-import net.helcel.beans.countries.GeoLoc
 import net.helcel.beans.countries.GeoLoc.LocType
-import net.helcel.beans.countries.World
+import net.helcel.beans.databinding.ActivityStatBinding
-import net.helcel.beans.helper.AUTO_GROUP
-import net.helcel.beans.helper.Data
-import net.helcel.beans.helper.Groups
-import net.helcel.beans.helper.NO_GROUP
 import net.helcel.beans.helper.Settings
-import net.helcel.beans.helper.Theme.getContrastColor
+import net.helcel.beans.helper.Theme.createActionBar
 
 private val MODE_LIST = listOf(LocType.WORLD, LocType.COUNTRY, LocType.STATE)
 
-@Composable
+class StatsActivity : AppCompatActivity() {
-fun StatsScreen(
+    private lateinit var _binding: ActivityStatBinding
-    onExit: ()-> Unit
+    private var activeMode = LocType.WORLD
-) {
-    val modes = if (Settings.isRegional(LocalContext.current)) MODE_LIST else MODE_LIST.take(2)
-    var selectedTab by remember { mutableIntStateOf(0) }
-    var countMode by remember { mutableStateOf(true) }
 
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        _binding = ActivityStatBinding.inflate(layoutInflater)
+        setContentView(_binding.root)
+        createActionBar(this, getString(R.string.action_stat))
 
-    SysTheme {
+        _binding.stats.layoutManager =
-        Scaffold(
+            LinearLayoutManager(this, RecyclerView.VERTICAL, false)
-            topBar = {
+        val adapter = StatsListAdapter(_binding.stats, _binding.name)
-                TopAppBar(
+        _binding.groupColor.setOnClickListener { adapter.invertCountMode() }
-                    title = {
+        _binding.stats.adapter = adapter
-                        Row(verticalAlignment = Alignment.CenterVertically){
-                            Text(text=stringResource(R.string.action_stat), modifier = Modifier.weight(1f))
-                            Button(onClick = { countMode = !countMode }) {
-                                Text(if (countMode) "Count" else "Area")
-                            }
-                        }
-                    },
-                    navigationIcon = {
-                        IconButton(onClick = onExit) {
-                            Icon(
-                                Icons.AutoMirrored.Filled.ArrowBack,
-                                contentDescription = null
-                            )
-                        }
-                    },
 
-                )
+        _binding.pager.adapter = object : FragmentStateAdapter(supportFragmentManager, lifecycle) {
-            },
+            override fun getItemCount(): Int = if (Settings.isRegional(applicationContext)) 3 else 2
-        ) { padding ->
+            override fun createFragment(position: Int): Fragment = Fragment()
-            Column(Modifier.padding(padding)) {
-                TabRow(selectedTabIndex = selectedTab) {
-                    modes.forEachIndexed { index, mode ->
-                        Tab(
-                            selected = selectedTab == index,
-                            onClick = { selectedTab = index },
-                            text = { Text(mode.txt) }
-                        )
         }
+        TabLayoutMediator(_binding.tab, _binding.pager) { tab, position ->
+            tab.text = MODE_LIST[position].txt
+        }.attach()
+
+        _binding.pager.registerOnPageChangeCallback(object : ViewPager2.OnPageChangeCallback() {
+            override fun onPageSelected(position: Int) {
+                activeMode = MODE_LIST[position]
+                adapter.refreshMode(activeMode)
+            }
+        })
     }
 
-                Row(
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
-                    modifier = Modifier
+        finish()
-                        .fillMaxWidth()
+        return super.onOptionsItemSelected(item)
-                        .padding(8.dp),
-                    horizontalArrangement = Arrangement.End
-                ) {
-                }
-
-                val activeMode = modes.getOrNull(selectedTab) ?: LocType.WORLD
-                StatsList(activeMode, countMode)
-            }
-        }
-    }
-}
-
-@Composable
-fun StatsList(activeMode: LocType, countMode: Boolean) {
-    val groups = remember { Data.groups.groupsFlow }
-    val unCat = stringResource(R.string.uncategorized)
-
-    LazyColumn(modifier = Modifier.fillMaxSize()) {
-        items(groups.value + listOf(Groups.Group(AUTO_GROUP, unCat))) { group ->
-            StatsRow(group, activeMode, countMode)
-        }
-    }
-}
-
-@Composable
-fun StatsRow(group: Groups.Group, activeMode: LocType, countMode: Boolean) {
-    val context = LocalContext.current
-    val isCascadeStats = remember { Settings.isCascadeStats(context) }
-    val visits by Data.visits.visitsFlow.collectAsState()
-
-    val continents = remember { World.WWW.children.toList() }
-    val countries = remember {
-        World.WWW.children.flatMap {
-            if (it is Country) listOf(it) else it.children
-        }
-    }
-
-    val visitedItems = remember(group, activeMode, isCascadeStats, visits) {
-        val list = when (activeMode) {
-            LocType.WORLD -> continents
-            LocType.COUNTRY -> countries
-            LocType.STATE -> countries.flatMap { it.children }
-            else -> emptyList()
-        }
-
-        fun getExplicitColor(l: GeoLoc): Int? {
-            val c = visits.getOrDefault(l.code, 0)
-            return if (c != NO_GROUP && c != AUTO_GROUP) c else null
-        }
-
-        fun getEffectiveGroup(l: GeoLoc): Int {
-            getExplicitColor(l)?.let { return it }
-
-            if (isCascadeStats) {
-                // Parent -> Child (closest explicit ancestor)
-                val country = countries.find { it.children.contains(l) }
-                val countryColor = country?.let { getExplicitColor(it) }
-                if (countryColor != null) return countryColor
-
-                val continent = continents.find {
-                    it.children.contains(l) || (country != null && it.children.contains(country))
-                }
-                val continentColor = continent?.let { getExplicitColor(it) }
-                if (continentColor != null) return continentColor
-
-                val worldColor = getExplicitColor(World.WWW)
-                if (worldColor != null) return worldColor
-
-                // Child -> Parent (most common explicit descendant)
-                val descendants = mutableListOf<GeoLoc>()
-                fun collect(curr: GeoLoc) {
-                    curr.children.forEach {
-                        descendants.add(it)
-                        collect(it)
-                    }
-                }
-                collect(l)
-                val descendantColors = descendants.mapNotNull { getExplicitColor(it) }
-                if (descendantColors.isNotEmpty()) {
-                    return descendantColors.groupBy { it }.maxByOrNull { it.value.size }?.key ?: AUTO_GROUP
-                }
-            } else {
-                if (l.type == LocType.WORLD || l.type == LocType.COUNTRY) {
-                    val descendants = mutableListOf<GeoLoc>()
-                    fun collect(curr: GeoLoc) {
-                        curr.children.forEach { descendants.add(it); collect(it) }
-                    }
-                    collect(l)
-                    val dc = descendants.mapNotNull { getExplicitColor(it) }
-                    if (dc.isNotEmpty()) return dc.groupBy { it }.maxByOrNull { it.value.size }?.key ?: AUTO_GROUP
-                }
-            }
-
-            return AUTO_GROUP
-        }
-
-        list.filter { getEffectiveGroup(it) == group.key }
-    }
-
-    val count = visitedItems.size
-    val area = visitedItems.sumOf { it.area.toLong() }
-
-    val displayValue = if (countMode) count.toString() else stringResource(R.string.number_with_unit, area.toInt(), "km²")
-
-    val backgroundColor = group.color.color
-    val textColor = getContrastColor(backgroundColor)
-
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .background(Color(backgroundColor))
-            .padding(16.dp),
-        verticalAlignment = Alignment.CenterVertically
-    ) {
-        Text(
-            text=group.name,
-            modifier= Modifier.weight(1f),
-            color = Color(textColor)
-        )
-        Text(text=displayValue,
-            color = Color(textColor)
-        )
     }
 }

app/src/main/java/net/helcel/beans/activity/adapter/GeolocListAdapter.kt

@@ -0,0 +1,193 @@
+package net.helcel.beans.activity.adapter
+
+import android.content.res.ColorStateList
+import android.graphics.Color
+import android.graphics.Typeface
+import android.graphics.drawable.ColorDrawable
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.fragment.app.FragmentActivity
+import androidx.recyclerview.widget.RecyclerView
+import com.google.android.material.checkbox.MaterialCheckBox
+import net.helcel.beans.activity.fragment.EditPlaceColorFragment
+import net.helcel.beans.activity.fragment.EditPlaceFragment
+import net.helcel.beans.countries.GeoLoc
+import net.helcel.beans.databinding.ItemListGeolocBinding
+import net.helcel.beans.helper.*
+import net.helcel.beans.helper.Theme.colorWrapper
+
+class GeolocListAdapter(
+    private val ctx: EditPlaceFragment, private val l: GeoLoc, private val pager: ViewPagerAdapter,
+    private val parentHolder: FoldingListViewHolder?
+) : RecyclerView.Adapter<GeolocListAdapter.FoldingListViewHolder>() {
+
+    private val sortedList = l.children.toList().sortedBy { it.fullName }
+    private val holders: MutableSet<FoldingListViewHolder> = mutableSetOf()
+
+    override fun onCreateViewHolder(viewGroup: ViewGroup, viewType: Int): FoldingListViewHolder {
+        val binding = ItemListGeolocBinding.inflate(
+            LayoutInflater.from(viewGroup.context),
+            viewGroup,
+            false
+        )
+        val holder = FoldingListViewHolder(ctx.requireActivity(), binding, parentHolder, l)
+        holders.add(holder)
+        return holder
+    }
+
+    override fun onBindViewHolder(holder: FoldingListViewHolder, position: Int) {
+        val el = sortedList[position]
+        holder.bind(el)
+        holder.addListeners(el) {
+            if (el.children.isNotEmpty())
+                pager.addFragment(ctx, EditPlaceFragment(el, pager, holder))
+            true
+        }
+    }
+
+    override fun getItemCount(): Int {
+        return l.children.size
+    }
+
+    fun refreshColors(colorDrawable: ColorDrawable) {
+        holders.forEach { it.refreshColor(colorDrawable) }
+    }
+
+    class FoldingListViewHolder(
+        private val ctx: FragmentActivity,
+        private val _binding: ItemListGeolocBinding,
+        private val _parentHolder: FoldingListViewHolder? = null,
+        private val _parentGeoLoc: GeoLoc,
+    ) : RecyclerView.ViewHolder(_binding.root), DialogCloser {
+        private lateinit var el: GeoLoc
+
+        private fun bindGroup(el: GeoLoc) {
+            refreshCount(el)
+            _binding.textView.setTypeface(null, Typeface.BOLD)
+            _binding.textView.backgroundTintList = ColorStateList.valueOf(
+                colorWrapper(
+                    ctx,
+                    android.R.attr.panelColorBackground
+                ).color
+            ).withAlpha(64)
+        }
+
+        fun bind(el: GeoLoc) {
+            this.el = el
+            _binding.textView.text = el.fullName
+            _binding.textView.backgroundTintList =
+                ColorStateList.valueOf(colorWrapper(ctx, android.R.attr.colorBackground).color)
+
+            if (el.children.isNotEmpty())
+                bindGroup(el)
+
+            refreshCheck(el)
+        }
+
+        fun refreshColor(colorDrawable: ColorDrawable) {
+            if (Data.visits.getVisited(el) !in listOf(NO_GROUP, AUTO_GROUP)) {
+                _binding.checkBox.buttonTintList =
+                    ColorStateList.valueOf(colorDrawable.color)
+                refreshCheck(el)
+            }
+        }
+
+        fun addListeners(el: GeoLoc, expandLambda: () -> Boolean) {
+            if (el.children.isNotEmpty()) {
+                _binding.textView.setOnClickListener { expandLambda() }
+            }
+            _binding.checkBox.setOnClickListener {
+                Data.selected_geoloc = el
+                if (Data.groups.size() == 1 && Settings.isSingleGroup(ctx)) {
+                    if (_binding.checkBox.isChecked) {
+                        // If one has just checked the box (assign unique group)
+                        Data.selected_group = Data.groups.getUniqueEntry()
+                        onDialogDismiss(false)
+                    } else {
+                        // If one has just unchecked the box (unassign unique group)
+                        Data.selected_group = null
+                        onDialogDismiss(true)
+                    }
+                } else {
+                    Data.selected_group = null
+                    EditPlaceColorFragment(this).show(
+                        ctx.supportFragmentManager,
+                        "AddColorDialogFragment"
+                    )
+                }
+                _parentHolder?.refresh(_parentGeoLoc)
+            }
+        }
+
+        override fun onDialogDismiss(clear: Boolean) {
+            if (clear) {
+                Data.visits.setVisited(Data.selected_geoloc, NO_GROUP)
+                Data.saveData()
+
+                if (_parentGeoLoc.children.all { Data.visits.getVisited(it) == NO_GROUP }) {
+                    Data.clearing_geoloc = _parentGeoLoc
+                }
+            }
+            if (Data.selected_group != null && Data.selected_geoloc != null) {
+                Data.visits.setVisited(Data.selected_geoloc, Data.selected_group?.key ?: NO_GROUP)
+                Data.saveData()
+            }
+            Data.selected_geoloc?.let { refreshCheck(it) }
+            Data.selected_geoloc = null
+            Data.selected_group = null
+            _parentHolder?.refresh(_parentGeoLoc)
+        }
+
+        private fun refreshCheck(geoLoc: GeoLoc) {
+            _binding.checkBox.checkedState =
+                if (Data.visits.getVisited(geoLoc) !in listOf(NO_GROUP, AUTO_GROUP)) {
+                    MaterialCheckBox.STATE_CHECKED
+                } else if (geoLoc.children.isNotEmpty() &&
+                    geoLoc.children.all {
+                        Data.visits.getVisited(it) !in listOf(NO_GROUP, AUTO_GROUP)
+                    }
+                ) {
+                    Data.visits.setVisited(geoLoc, AUTO_GROUP)
+                    MaterialCheckBox.STATE_CHECKED
+                } else if (geoLoc.children.isEmpty() && Data.visits.getVisited(geoLoc) == AUTO_GROUP) {
+                    MaterialCheckBox.STATE_CHECKED
+                } else if (geoLoc.children.any { Data.visits.getVisited(it) != NO_GROUP }) {
+                    Data.visits.setVisited(geoLoc, AUTO_GROUP)
+                    MaterialCheckBox.STATE_INDETERMINATE
+                } else {
+                    Data.visits.setVisited(geoLoc, NO_GROUP)
+                    if (Data.clearing_geoloc == geoLoc) {
+                        Data.clearing_geoloc = null
+                    }
+                    MaterialCheckBox.STATE_UNCHECKED
+                }
+            Data.saveData()
+
+            var col = Data.groups.getGroupFromKey(Data.visits.getVisited(geoLoc)).color
+            if (Data.visits.getVisited(geoLoc) == AUTO_GROUP) {
+                col = colorWrapper(ctx, android.R.attr.colorPrimary)
+            } else if (col.color == Color.TRANSPARENT) {
+                col = colorWrapper(ctx, android.R.attr.panelColorBackground)
+                col.alpha = 64
+            }
+            _binding.checkBox.buttonTintList = ColorStateList.valueOf(col.color)
+        }
+
+        private fun refreshCount(geoLoc: GeoLoc) {
+            val numerator =
+                geoLoc.children.map { Data.visits.getVisited(it) != NO_GROUP }.count { it }
+            val denominator = geoLoc.children.size
+            _binding.count.text = Settings.getStats(ctx, numerator, denominator)
+        }
+
+        private fun refresh(geoLoc: GeoLoc) {
+            // Refresh
+            refreshCheck(geoLoc)
+            refreshCount(geoLoc)
+
+            // Recursively refresh parent
+            _parentHolder?.refresh(_parentGeoLoc)
+        }
+
+    }
+}

app/src/main/java/net/helcel/beans/activity/adapter/GroupListAdapter.kt

@@ -0,0 +1,78 @@
+package net.helcel.beans.activity.adapter
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.fragment.app.DialogFragment
+import androidx.fragment.app.FragmentActivity
+import androidx.recyclerview.widget.RecyclerView
+import net.helcel.beans.activity.fragment.EditGroupAddFragment
+import net.helcel.beans.databinding.ItemListGroupBinding
+import net.helcel.beans.helper.Data
+import net.helcel.beans.helper.Groups
+import net.helcel.beans.helper.Theme.getContrastColor
+
+class GroupListAdapter(
+    private val activity: FragmentActivity,
+    private val selectDialog: DialogFragment,
+    private val delete: Boolean = false
+) : RecyclerView.Adapter<GroupListAdapter.GroupViewHolder>() {
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): GroupViewHolder {
+        val binding =
+            ItemListGroupBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+        return GroupViewHolder(binding, activity, selectDialog)
+    }
+
+    override fun onBindViewHolder(holder: GroupViewHolder, pos: Int) {
+        holder.bind(Data.groups.getGroupFromPos(pos))
+    }
+
+    override fun getItemCount(): Int {
+        return Data.groups.size()
+    }
+
+    inner class GroupViewHolder(
+        private val _binding: ItemListGroupBinding,
+        private val activity: FragmentActivity,
+        private val selectDialog: DialogFragment
+    ) : RecyclerView.ViewHolder(_binding.root) {
+        private lateinit var dialogFragment: EditGroupAddFragment
+        fun bind(entry: Pair<Int, Groups.Group>) {
+            _binding.groupColor.text = entry.second.name
+            dialogFragment = EditGroupAddFragment(entry.first, {
+                val newEntry = Data.groups.getGroupFromKey(entry.first)
+                _binding.groupColor.text = newEntry.name
+                val newEntryColor = newEntry.color.color
+                val contrastNewEntryColor =
+                    getContrastColor(newEntryColor)
+                _binding.groupColor.setBackgroundColor(newEntryColor)
+                _binding.groupColor.setTextColor(contrastNewEntryColor)
+                _binding.name.setTextColor(contrastNewEntryColor)
+                _binding.name.text = "0"
+            }, {
+                notifyItemRemoved(it)
+            })
+
+            val entryColor = entry.second.color.color
+            val contrastEntryColor = getContrastColor(entryColor)
+            _binding.groupColor.setBackgroundColor(entryColor)
+            _binding.groupColor.setTextColor(contrastEntryColor)
+            _binding.name.setTextColor(contrastEntryColor)
+            _binding.name.text = Data.visits.countVisited(entry.first).toString()
+
+            _binding.groupColor.setOnClickListener {
+                Data.selected_group = entry.second
+                selectDialog.dismiss()
+            }
+            if (!delete) {
+                _binding.groupColor.setOnLongClickListener {
+                    dialogFragment.show(
+                        activity.supportFragmentManager,
+                        "AddColorDialogFragment"
+                    )
+                    true
+                }
+            }
+        }
+    }
+}

app/src/main/java/net/helcel/beans/activity/adapter/StatsListAdapter.kt

@@ -0,0 +1,152 @@
+package net.helcel.beans.activity.adapter
+
+import android.content.Context
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+import com.google.android.material.textview.MaterialTextView
+import net.helcel.beans.R
+import net.helcel.beans.countries.GeoLoc
+import net.helcel.beans.countries.GeoLoc.LocType
+import net.helcel.beans.countries.World
+import net.helcel.beans.databinding.ItemListGroupBinding
+import net.helcel.beans.helper.AUTO_GROUP
+import net.helcel.beans.helper.Data
+import net.helcel.beans.helper.Groups
+import net.helcel.beans.helper.Settings
+import net.helcel.beans.helper.Theme.getContrastColor
+
+class StatsListAdapter(private val stats: RecyclerView, private val total: MaterialTextView) :
+    RecyclerView.Adapter<StatsListAdapter.StatsViewHolder>() {
+    private val unit = "km²"
+
+    private var locMode = LocType.WORLD
+    private lateinit var ctx: Context
+    private var countMode: Boolean = true
+    private var initialSum: Int = 0
+
+    private val wwwTotal: List<GeoLoc> = World.WWW.children.toList()
+    private val countryTotal: List<GeoLoc> = World.WWW.children.flatMap { it.children }
+    private val stateTotal: List<GeoLoc> =
+        World.WWW.children.flatMap { it.children.flatMap { itt -> itt.children } }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): StatsViewHolder {
+        ctx = parent.context
+        val binding =
+            ItemListGroupBinding.inflate(LayoutInflater.from(ctx), parent, false)
+
+        return StatsViewHolder(binding)
+    }
+
+    override fun onBindViewHolder(holder: StatsViewHolder, pos: Int) {
+        initialSum += if (pos == itemCount - 1) {
+            holder.bind(
+                Pair(
+                    AUTO_GROUP,
+                    Groups.Group(AUTO_GROUP, ctx.getString(R.string.uncategorized))
+                )
+            )
+        } else {
+            holder.bind(Data.groups.getGroupFromPos(pos))
+        }
+        val unitNow = if (!countMode) unit else ""
+        total.text = Settings.getStats(ctx, initialSum, getTotal(), unitNow)
+    }
+
+    override fun getItemCount(): Int {
+        return Data.groups.size() + 1
+    }
+
+    private fun getTotal(): Int {
+        return if (countMode) {
+            when (locMode) {
+                LocType.WORLD -> wwwTotal.size
+                LocType.COUNTRY -> countryTotal.size
+                LocType.STATE -> stateTotal.size
+                else -> 0
+            }
+        } else {
+            when (locMode) {
+                LocType.WORLD -> wwwTotal.sumOf { it.area }
+                LocType.COUNTRY -> countryTotal.sumOf { it.area }
+                LocType.STATE -> stateTotal.sumOf { it.area }
+                else -> 0
+            }
+        }
+    }
+
+    fun refreshMode(mode: LocType) {
+        val sum = (0 until itemCount).map {
+            val viewHolder = stats.findViewHolderForAdapterPosition(it) as? StatsViewHolder
+            viewHolder?.refresh(mode)
+        }.reduce { acc, i -> acc?.plus((i ?: 0)) }
+        val unitNow = if (!countMode) unit else ""
+        total.text = Settings.getStats(ctx, sum, getTotal(), unitNow)
+    }
+
+    fun invertCountMode() {
+        countMode = !countMode
+        refreshMode(locMode)
+    }
+
+    inner class StatsViewHolder(
+        private val _binding: ItemListGroupBinding
+    ) : RecyclerView.ViewHolder(_binding.root) {
+
+        private lateinit var data: Pair<Int, Groups.Group>
+
+        private lateinit var wwwCount: List<GeoLoc>
+        private lateinit var countryCount: List<GeoLoc>
+        private lateinit var stateCount: List<GeoLoc>
+
+        fun bind(entry: Pair<Int, Groups.Group>): Int {
+            data = entry
+            _binding.groupColor.text = entry.second.name
+
+            val entryColor = data.second.color.color
+            val contrastEntryColor = getContrastColor(entryColor)
+            _binding.groupColor.setBackgroundColor(entryColor)
+            _binding.groupColor.setTextColor(contrastEntryColor)
+            _binding.name.setTextColor(contrastEntryColor)
+
+            _binding.groupColor.setOnClickListener { invertCountMode() }
+            compute()
+            return refresh(locMode)
+        }
+
+        private fun compute() {
+            val visited = Data.visits.getVisitedByValue(data.first)
+            wwwCount = World.WWW.children.filter { it.code in visited }
+            countryCount =
+                World.WWW.children.map { it.children.filter { itt -> itt.code in visited } }
+                    .flatten()
+            stateCount =
+                World.WWW.children.map { it.children.map { itt -> itt.children.filter { ittt -> ittt.code in visited } } }
+                    .flatten().flatten()
+        }
+
+        fun refresh(mode: LocType): Int {
+            locMode = mode
+            return if (countMode) {
+                val count = when (locMode) {
+                    LocType.WORLD -> wwwCount.size
+                    LocType.COUNTRY -> countryCount.size
+                    LocType.STATE -> stateCount.size
+                    else -> -1
+                }
+                _binding.name.text = count.toString()
+                count
+            } else {
+                val area = when (locMode) {
+                    LocType.WORLD -> wwwCount.sumOf { it.area }
+                    LocType.COUNTRY -> countryCount.sumOf { it.area }
+                    LocType.STATE -> stateCount.sumOf { it.area }
+                    else -> -1
+                }
+                _binding.name.text = ctx.getString(R.string.number_with_unit, area, unit)
+                area
+            }
+        }
+
+    }
+}

app/src/main/java/net/helcel/beans/activity/adapter/ViewPagerAdapter.kt

@@ -0,0 +1,61 @@
+package net.helcel.beans.activity.adapter
+
+import android.graphics.drawable.ColorDrawable
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentManager
+import androidx.lifecycle.Lifecycle
+import androidx.viewpager2.adapter.FragmentStateAdapter
+import androidx.viewpager2.widget.ViewPager2
+import net.helcel.beans.activity.fragment.EditPlaceFragment
+import kotlin.math.max
+
+class ViewPagerAdapter(
+    fragmentManager: FragmentManager,
+    lifecycle: Lifecycle,
+    private val viewPager: ViewPager2
+) :
+    FragmentStateAdapter(fragmentManager, lifecycle) {
+
+    private val fragmentList: MutableList<EditPlaceFragment> = ArrayList()
+
+    fun addFragment(src: EditPlaceFragment?, target: EditPlaceFragment) {
+        val idx = fragmentList.indexOf(src)
+        viewPager.currentItem = max(0, idx)
+        if (src != null && idx >= 0) {
+            fragmentList.subList(idx + 1, fragmentList.size).clear()
+        }
+        fragmentList.add(target)
+        notifyItemRangeChanged(max(0, idx), fragmentList.size)
+        viewPager.currentItem = fragmentList.size - 1
+    }
+
+    override fun getItemCount(): Int {
+        return fragmentList.size
+    }
+
+    fun backPressed(): Boolean {
+        if (viewPager.currentItem == 0) {
+            return false
+        }
+        val target = viewPager.currentItem
+        while (fragmentList.size > target) {
+            fragmentList.removeLast()
+            notifyItemRemoved(fragmentList.size)
+        }
+        return true
+    }
+
+    fun getLabel(pos: Int): String {
+        return fragmentList[pos].loc.fullName
+    }
+
+    override fun createFragment(position: Int): Fragment {
+        return fragmentList[position]
+    }
+
+    fun refreshColors(colorDrawable: ColorDrawable) {
+        fragmentList.forEach{ it.refreshColors(colorDrawable)}
+    }
+}
+
+

app/src/main/java/net/helcel/beans/activity/fragment/AboutFragment.kt

@@ -0,0 +1,21 @@
+package net.helcel.beans.activity.fragment
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import net.helcel.beans.databinding.FragmentAboutBinding
+
+class AboutFragment : Fragment() {
+    private lateinit var _binding: FragmentAboutBinding
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        _binding = FragmentAboutBinding.inflate(inflater, container, false)
+        return _binding.root
+    }
+}

app/src/main/java/net/helcel/beans/activity/fragment/EditGroupAddFragment.kt

@@ -0,0 +1,155 @@
+package net.helcel.beans.activity.fragment
+
+import android.app.Dialog
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import android.os.Bundle
+import android.text.Editable
+import android.text.TextWatcher
+import android.view.View
+import androidx.core.graphics.blue
+import androidx.core.graphics.green
+import androidx.core.graphics.red
+import androidx.fragment.app.DialogFragment
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.slider.Slider
+import com.google.android.material.textfield.TextInputEditText
+import net.helcel.beans.R
+import net.helcel.beans.databinding.FragmentEditGroupsAddBinding
+import net.helcel.beans.helper.Data
+import net.helcel.beans.helper.Groups
+import net.helcel.beans.helper.Theme.colorToHex6
+
+
+class EditGroupAddFragment(
+    private val key: Int = 0,
+    val onAddCb: (Int) -> Unit,
+    val onDelCb: (Int) -> Unit,
+    private val deleteEnabled: Boolean = true
+) : DialogFragment() {
+
+    private lateinit var _binding: FragmentEditGroupsAddBinding
+    private val grp = Data.groups.getGroupFromKey(key)
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val builder = MaterialAlertDialogBuilder(requireContext())
+        _binding = FragmentEditGroupsAddBinding.inflate(layoutInflater)
+
+        setupSlider(_binding.colorR, grp.color.color.red / 255F)
+        setupSlider(_binding.colorG, grp.color.color.green / 255F)
+        setupSlider(_binding.colorB, grp.color.color.blue / 255F)
+        setupText(_binding.groupColor, grp)
+
+        _binding.colorView.background = ColorDrawable(grp.color.color)
+
+
+        if (key == 0 || !deleteEnabled) {
+            _binding.btnDelete.visibility = View.INVISIBLE
+            _binding.btnDelete.isEnabled = false
+        }
+        _binding.btnDelete.setOnClickListener {
+            MaterialAlertDialogBuilder(requireActivity())
+                .setMessage(R.string.delete_group)
+                .setPositiveButton(android.R.string.ok) { _, _ ->
+                    val pos = Data.groups.findGroupPos(key)
+                    // Remove all countries belonging to that group
+                    Data.visits.deleteVisited(key)
+                    // Delete the group
+                    Data.groups.deleteGroup(key)
+                    Data.saveData()
+                    onDelCb(pos)
+                    dialog?.dismiss()
+                }
+                .setNegativeButton(android.R.string.cancel) { _, _ -> }
+                .show()
+        }
+
+        _binding.btnOk.setOnClickListener {
+            val name = _binding.groupName.text.toString()
+            val color = _binding.groupColor.text.toString()
+            val key = (if (key != 0) key else Data.groups.genKey())
+            Data.groups.setGroup(key, name, ColorDrawable(Color.parseColor("#$color")))
+            Data.saveData()
+            onAddCb(key)
+            dialog?.dismiss()
+        }
+
+        _binding.btnCancel.setOnClickListener {
+            dialog?.cancel()
+        }
+
+        _binding.groupName.setText(grp.name)
+        builder.setView(_binding.root)
+        return builder.create()
+    }
+
+    private fun setupText(s: TextInputEditText, grp: Groups.Group?) {
+        s.setText(colorToHex6(ColorDrawable(grp?.color?.color ?: 0)).substring(1))
+        s.addTextChangedListener(
+            EditTextListener(
+                _binding.colorR,
+                _binding.colorG,
+                _binding.colorB,
+                _binding.groupColor,
+                _binding.colorView
+            )
+        )
+    }
+
+    private fun setupSlider(s: Slider, v: Float) {
+        s.valueFrom = 0F
+        s.valueTo = 1F
+        s.value = v
+        s.addOnChangeListener(
+            SliderOnChangeListener(
+                _binding.colorR,
+                _binding.colorG,
+                _binding.colorB,
+                _binding.groupColor,
+                _binding.colorView
+            )
+        )
+    }
+
+}
+
+
+private class EditTextListener(
+    private val colorEditR: Slider,
+    private val colorEditG: Slider,
+    private val colorEditB: Slider,
+    private val colorEditText: TextInputEditText,
+    private val colorView: View
+) : TextWatcher {
+
+    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
+    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
+    override fun afterTextChanged(s: Editable?) {
+        val col: Color
+        try {
+            col = Color.valueOf(Color.parseColor("#${colorEditText.text}"))
+        } catch (e: Exception) {
+            return
+        }
+
+        colorEditR.value = col.red()
+        colorEditG.value = col.green()
+        colorEditB.value = col.blue()
+        colorView.background = ColorDrawable(col.toArgb())
+    }
+}
+
+private class SliderOnChangeListener(
+    private val colorEditR: Slider,
+    private val colorEditG: Slider,
+    private val colorEditB: Slider,
+    private val colorEditText: TextInputEditText,
+    private val colorView: View
+) : Slider.OnChangeListener {
+    override fun onValueChange(slider: Slider, value: Float, fromUser: Boolean) {
+        val rgb =
+            ColorDrawable(Color.argb(1F, colorEditR.value, colorEditG.value, colorEditB.value))
+        colorEditText.setText(colorToHex6(rgb).substring(1))
+        colorView.background = rgb
+    }
+}

app/src/main/java/net/helcel/beans/activity/fragment/EditPlaceColorFragment.kt

@@ -0,0 +1,60 @@
+package net.helcel.beans.activity.fragment
+
+import android.app.Dialog
+import android.content.DialogInterface
+import android.os.Bundle
+import android.view.View
+import androidx.fragment.app.DialogFragment
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import net.helcel.beans.R
+import net.helcel.beans.activity.adapter.GroupListAdapter
+import net.helcel.beans.databinding.FragmentEditPlacesColorsBinding
+import net.helcel.beans.helper.Data
+import net.helcel.beans.helper.DialogCloser
+
+
+class EditPlaceColorFragment(private val parent: DialogCloser, private val delete: Boolean = false) :
+    DialogFragment() {
+
+    private lateinit var _binding: FragmentEditPlacesColorsBinding
+    private lateinit var listAdapt: GroupListAdapter
+    private var clear: Boolean = false
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val ctx = requireContext()
+        val builder = MaterialAlertDialogBuilder(ctx)
+        _binding = FragmentEditPlacesColorsBinding.inflate(layoutInflater)
+        _binding.btnAdd.setOnClickListener {
+            EditGroupAddFragment(0, {
+                listAdapt.notifyItemInserted(Data.groups.findGroupPos(it))
+            }, {}).show(requireActivity().supportFragmentManager, "AddColorDialogFragment")
+        }
+        _binding.btnClear.setOnClickListener {
+            clear = true
+            dialog?.dismiss()
+        }
+
+        val dialog = builder.setView(_binding.root).create()
+        listAdapt = GroupListAdapter(requireActivity(), this, delete)
+        _binding.groupsColor.layoutManager =
+            LinearLayoutManager(ctx, RecyclerView.VERTICAL, false)
+        _binding.groupsColor.adapter = listAdapt
+
+        if (delete) {
+            _binding.btnAdd.visibility = View.GONE
+            _binding.btnClear.text = ctx.getString(R.string.cancel)
+            _binding.warningText.text = ctx.getString(R.string.select_group)
+        } else {
+            _binding.warningText.text = ctx.getString(R.string.edit_group)
+        }
+
+        return dialog
+    }
+
+    override fun onDismiss(dialog: DialogInterface) {
+        super.onDismiss(dialog)
+        parent.onDialogDismiss(clear)
+    }
+}

app/src/main/java/net/helcel/beans/activity/fragment/EditPlaceFragment.kt

@@ -0,0 +1,38 @@
+package net.helcel.beans.activity.fragment
+
+import android.graphics.drawable.ColorDrawable
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import net.helcel.beans.activity.adapter.GeolocListAdapter
+import net.helcel.beans.activity.adapter.GeolocListAdapter.FoldingListViewHolder
+import net.helcel.beans.activity.adapter.ViewPagerAdapter
+import net.helcel.beans.countries.GeoLoc
+import net.helcel.beans.databinding.FragmentEditPlacesBinding
+
+class EditPlaceFragment(val loc: GeoLoc, private val pager: ViewPagerAdapter, private val holder: FoldingListViewHolder? = null) : Fragment() {
+    private lateinit var _binding: FragmentEditPlacesBinding
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        _binding = FragmentEditPlacesBinding.inflate(inflater, container, false)
+
+        _binding.list.setItemViewCacheSize(5)
+        _binding.list.setHasFixedSize(true)
+        _binding.list.layoutManager =
+            LinearLayoutManager(requireContext(), RecyclerView.VERTICAL, false)
+        _binding.list.adapter = GeolocListAdapter(this, loc, pager, holder)
+        return _binding.root
+    }
+
+    fun refreshColors(colorDrawable: ColorDrawable) {
+        (_binding.list.adapter as GeolocListAdapter?)?.refreshColors(colorDrawable)
+    }
+}

app/src/main/java/net/helcel/beans/activity/fragment/LicenseFragment.kt

@@ -0,0 +1,33 @@
+package net.helcel.beans.activity.fragment
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import com.mikepenz.aboutlibraries.LibsBuilder
+import net.helcel.beans.R
+import net.helcel.beans.databinding.FragmentLicenseBinding
+
+class LicenseFragment : Fragment() {
+    private lateinit var _binding: FragmentLicenseBinding
+
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        _binding = FragmentLicenseBinding.inflate(inflater, container, false)
+
+        val librariesFragment = LibsBuilder()
+            .withLicenseShown(true)
+            .supportFragment()
+
+        requireActivity().supportFragmentManager.beginTransaction()
+            .replace(R.id.license_fragment_view, librariesFragment)
+            .commit()
+
+        return _binding.root
+    }
+}

app/src/main/java/net/helcel/beans/activity/fragment/SettingsFragment.kt

@@ -0,0 +1,142 @@
+package net.helcel.beans.activity.fragment
+
+import android.content.Context
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.preference.Preference
+import androidx.preference.PreferenceFragmentCompat
+import androidx.preference.PreferenceManager
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import net.helcel.beans.R
+import net.helcel.beans.countries.GeoLocImporter
+import net.helcel.beans.helper.Data
+import net.helcel.beans.helper.DialogCloser
+import net.helcel.beans.helper.Settings
+
+
+class SettingsFragment : PreferenceFragmentCompat(), DialogCloser {
+    private var savedInstanceState: Bundle? = null
+    private var rootKey: String? = null
+
+    override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
+        this.savedInstanceState = savedInstanceState
+        this.rootKey = rootKey
+
+        setPreferencesFromResource(R.xml.fragment_settings, rootKey)
+        val ctx = requireContext()
+
+        // Select Light/Dark/System Mode
+        findPreference<Preference>(getString(R.string.key_theme))?.setOnPreferenceChangeListener { _, key ->
+            setTheme(ctx, key as String)
+        }
+
+        // Select map projection
+        findPreference<Preference>(getString(R.string.key_projection))?.setOnPreferenceChangeListener { _, key ->
+            Settings.refreshProjection()
+        }
+
+        // Toggle groups
+        findPreference<Preference>(getString(R.string.key_group))?.setOnPreferenceChangeListener { _, key ->
+            if (key as String == ctx.getString(R.string.off)) {
+                val fragment = EditPlaceColorFragment(this, true)
+                fragment.show(
+                    this.parentFragmentManager,
+                    "AddColorDialogFragment"
+                )
+                false
+            } else {
+                true
+            }
+        }
+
+        // Toggle regional geolocs
+        findPreference<Preference>(getString(R.string.key_regional))?.setOnPreferenceChangeListener { _, key ->
+            when (key as String) {
+                ctx.getString(R.string.off) -> {
+                    MaterialAlertDialogBuilder(requireActivity())
+                        .setMessage(R.string.delete_regions)
+                        .setPositiveButton(android.R.string.ok) { _, _ ->
+                            GeoLocImporter.clearStates()
+                            PreferenceManager.getDefaultSharedPreferences(ctx).edit().putString(
+                                ctx.getString(R.string.key_regional),
+                                ctx.getString(R.string.off)
+                            ).apply()
+                            refreshPreferences()
+                        }
+                        .setNegativeButton(android.R.string.cancel) { _, _ -> }
+                        .show()
+                    false
+                }
+
+                ctx.getString(R.string.on) -> {
+                    GeoLocImporter.importStates(ctx, true)
+                    true
+                }
+
+                else -> false
+            }
+        }
+
+
+        // Open license fragment
+        findPreference<Preference>(getString(R.string.licenses))?.setOnPreferenceClickListener {
+            requireActivity().supportFragmentManager.beginTransaction()
+                .replace(R.id.fragment_view, LicenseFragment(), getString(R.string.licenses))
+                .commit()
+            true
+        }
+
+        // Open about fragment
+        findPreference<Preference>(getString(R.string.about))?.setOnPreferenceClickListener {
+            requireActivity().supportFragmentManager.beginTransaction()
+                .replace(R.id.fragment_view, AboutFragment(), getString(R.string.about))
+                .commit()
+            true
+        }
+
+    }
+
+    companion object {
+        fun setTheme(ctx: Context, key: String?): Boolean {
+            AppCompatDelegate.setDefaultNightMode(
+                when (key) {
+                    ctx.getString(R.string.system) -> AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM
+                    ctx.getString(R.string.light) -> AppCompatDelegate.MODE_NIGHT_NO
+                    ctx.getString(R.string.dark) -> AppCompatDelegate.MODE_NIGHT_YES
+                    else -> AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM
+                }
+            )
+            return true
+        }
+    }
+
+    override fun onDialogDismiss(clear: Boolean) {
+        // When turning groups off, select one group to keep and reassign everything
+        Data.selected_group?.let { selectedGroup ->
+            // Reassign all visited that are not to selectedGroup to selectedGroup
+            Data.visits.reassignAllVisitedToGroup(selectedGroup.key)
+
+            // Delete all groups that are not selectedGroup
+            Data.groups.deleteAllExcept(selectedGroup.key)
+
+            // Save and clear global variables
+            Data.saveData()
+            Data.selected_geoloc = null
+            Data.selected_group = null
+
+            // Actually change preference
+            val ctx = requireContext()
+            val sp = PreferenceManager.getDefaultSharedPreferences(ctx)
+            sp.edit().putString(ctx.getString(R.string.key_group), ctx.getString(R.string.off))
+                .apply()
+
+            // Refresh entire preference fragment to reflect changes
+            refreshPreferences()
+        }
+    }
+
+    private fun refreshPreferences() {
+        preferenceScreen.removeAll()
+        onCreatePreferences(savedInstanceState, rootKey)
+    }
+}

app/src/main/java/net/helcel/beans/activity/sub/AboutScreen.kt

@@ -1,78 +0,0 @@
-package net.helcel.beans.activity.sub
-
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalUriHandler
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import net.helcel.beans.R
-import net.helcel.beans.BuildConfig
-
-@Preview
-@Composable
-fun AboutScreen(
-    modifier: Modifier = Modifier
-) {
-    Column(
-        modifier = modifier
-            .fillMaxSize()
-            .padding(top = 20.dp).background(MaterialTheme.colors.background),
-        horizontalAlignment = Alignment.CenterHorizontally,
-    ) {
-        Image(
-            painter = painterResource(id = R.drawable.ic_launcher_foreground),
-            contentDescription = "Logo",
-            modifier = Modifier
-                .size(300.dp)
-        )
-
-        Text(
-            text = BuildConfig.APP_NAME,
-            fontSize = 30.sp,
-            color = MaterialTheme.colors.onBackground,
-            fontWeight = FontWeight.Bold,
-            textAlign = TextAlign.Center,
-            modifier = Modifier.padding(vertical = 15.dp, horizontal = 10.dp)
-        )
-
-        Text(
-            text = BuildConfig.VERSION_NAME,
-            fontSize = 25.sp,
-            color = MaterialTheme.colors.onBackground,
-            textAlign = TextAlign.Center,
-            modifier = Modifier.padding(vertical = 15.dp, horizontal = 10.dp)
-        )
-
-        Text(
-            text = stringResource(R.string.beans_is_foss),
-            textAlign = TextAlign.Center,
-            color = MaterialTheme.colors.onBackground,
-            modifier = Modifier.padding(vertical = 15.dp, horizontal = 10.dp)
-        )
-
-        val uriHandler = LocalUriHandler.current
-        val uri = stringResource(R.string.beans_repo_uri)
-        Text(
-            text = stringResource(id = R.string.beans_repo,uri),
-            textAlign = TextAlign.Center,
-            color = MaterialTheme.colors.onBackground,
-            modifier = Modifier
-                .clickable {
-                    uriHandler.openUri(uri)
-                }
-                .padding(vertical = 15.dp, horizontal = 10.dp)
-        )
-    }
-}

app/src/main/java/net/helcel/beans/activity/sub/EditGroupAddDialog.kt

@@ -1,222 +0,0 @@
-package net.helcel.beans.activity.sub
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.shape.CornerSize
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.Button
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Slider
-import androidx.compose.material.SliderDefaults
-import androidx.compose.material.Text
-import androidx.compose.material.TextButton
-import androidx.compose.material3.OutlinedTextField
-import androidx.compose.material3.OutlinedTextFieldDefaults
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.compose.ui.window.Dialog
-import net.helcel.beans.helper.Data
-import net.helcel.beans.helper.Theme.colorToHex6
-import androidx.core.graphics.drawable.toDrawable
-import androidx.core.graphics.toColorInt
-import net.helcel.beans.R
-
-
-@Preview
-@Composable
-fun EditGroupPreview(){
-    EditGroupDialog(0,true,{},{},{})
-}
-@Composable
-fun EditGroupDialog(
-    key: Int = 0,
-    deleteEnabled: Boolean = true,
-    onAddCb: (Int) -> Unit,
-    onDelCb: (Int) -> Unit,
-    onDismiss: () -> Unit
-) {
-    val group by remember { mutableStateOf(Data.groups.getGroupFromKey(key)) }
-    var name by remember { mutableStateOf(group.name) }
-    var colorHex by remember {
-        mutableStateOf(colorToHex6(group.color.color.toDrawable()).substring(1))
-    }
-
-    // Convert hex to Color safely
-    var color = remember {try {
-        Color("#$colorHex".toColorInt())
-    } catch (_: Exception) {
-        Color.Gray
-    }}
-    var r by remember { mutableIntStateOf((color.red *255).toInt()) }
-    var g by remember { mutableIntStateOf((color.green*255).toInt()) }
-    var b by remember { mutableIntStateOf((color.blue*255).toInt()) }
-
-    fun updateHexFromSliders() {
-        val newColor = Color(r, g, b)
-        colorHex = colorToHex6(newColor.toArgb().toDrawable()).substring(1)
-        color = newColor
-    }
-        Dialog(
-            onDismissRequest = onDismiss,
-            content = {
-                Column(
-                    modifier = Modifier
-                        .background(
-                            MaterialTheme.colors.background,
-                            RoundedCornerShape(corner = CornerSize(16.dp))
-                        )
-                        .padding(16.dp),
-
-                    ) {
-                    Text(
-                        color = MaterialTheme.colors.onBackground,
-                        style = MaterialTheme.typography.h6,
-                        text = if (key == 0) stringResource(R.string.action_add)
-                        else stringResource(R.string.action_edit),
-                    )
-
-                    Spacer(modifier = Modifier.height(16.dp))
-                    Column(
-                        verticalArrangement = Arrangement.spacedBy(12.dp)
-                    ) {
-                        // Group name
-                        OutlinedTextField(
-                            value = name,
-                            onValueChange = { it: String -> name = it },
-                            modifier = Modifier.fillMaxWidth(),
-                            placeholder = { Text(stringResource(R.string.name)) },
-                            colors = OutlinedTextFieldDefaults.colors(
-                                unfocusedTextColor = MaterialTheme.colors.onBackground,
-                                focusedTextColor = MaterialTheme.colors.onBackground,
-                            ),
-                        )
-                        Row(
-                            horizontalArrangement = Arrangement.spacedBy(16.dp),
-                            verticalAlignment = Alignment.CenterVertically
-                        ) {
-
-                            // Color preview
-                            Box(
-                                modifier = Modifier
-                                    .size(96.dp, (96).dp)
-                                    .clip(RoundedCornerShape(8.dp))
-                                    .background(color),
-                                propagateMinConstraints = true,
-
-                                content = {}
-                            )
-                            Column {
-                                ColorSlider(
-                                    r.toFloat(),
-                                    { r = it.toInt(); updateHexFromSliders() },
-                                    Color(255, 0, 0)
-                                )
-                                ColorSlider(
-                                    g.toFloat(),
-                                    { g = it.toInt(); updateHexFromSliders() },
-                                    Color(0, 255, 0)
-                                )
-                                ColorSlider(
-                                    b.toFloat(),
-                                    { b = it.toInt(); updateHexFromSliders() },
-                                    Color(0, 0, 255)
-                                )
-                            }
-                        }
-                        // Hex input
-                        OutlinedTextField(
-                            value = colorHex,
-                            onValueChange = { n:String->
-                                colorHex = n.filter { it.isLetterOrDigit() }
-                            },
-                            label = { Text(text="Color (hex)", color=MaterialTheme.colors.onBackground) },
-                            singleLine = true,
-                            textStyle = TextStyle(
-                                fontSize = 12.sp
-                            ),
-                            modifier = Modifier.fillMaxWidth(),
-                            colors = OutlinedTextFieldDefaults.colors(
-                                unfocusedTextColor =MaterialTheme.colors.onBackground,
-                                focusedTextColor = MaterialTheme.colors.onBackground,
-                            ),
-
-                        )
-                    }
-                    Spacer(modifier = Modifier.height(8.dp))
-
-                    Row(
-                        modifier = Modifier.fillMaxWidth(),
-                        horizontalArrangement = Arrangement.End
-                    ) {
-                        Button(onClick = {
-                            val newKey = if (key != 0) key else Data.groups.genKey()
-                            Data.groups.setGroup(
-                                newKey,
-                                name,
-                                "#$colorHex".toColorInt().toDrawable()
-                            )
-                            Data.saveData()
-                            onAddCb(newKey)
-                            onDismiss()
-                        }, ) {
-                            Text("OK")
-                        }
-                        if (key != 0 && deleteEnabled) {
-                            TextButton(onClick = {
-                                val pos = Data.groups.findGroupPos(key)
-                                Data.visits.deleteVisited(key)
-                                Data.groups.deleteGroup(key)
-                                Data.saveData()
-                                onDelCb(pos)
-                                onDismiss()
-                            }) {
-                                Text("Delete")
-                            }
-                        }
-                        TextButton(onClick = { onDismiss() }) {
-                            Text("Cancel")
-                        }
-
-                    }
-                }
-            },
-        )
-}
-
-@Composable
-fun ColorSlider(v: Float, onChange:(Float)->Unit, c:Color ){
-    Slider(
-        value = v,
-        onValueChange = onChange,
-        valueRange = 0f..255f,
-        steps = 255,
-        modifier = Modifier.height(32.dp),
-        colors = SliderDefaults.colors(
-            thumbColor = c,
-            activeTickColor = c,
-            inactiveTickColor = MaterialTheme.colors.onBackground,
-        )
-    )
-}

app/src/main/java/net/helcel/beans/activity/sub/EditPlaceColorDialog.kt

@@ -1,193 +0,0 @@
-package net.helcel.beans.activity.sub
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.foundation.shape.CornerSize
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.Button
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
-import androidx.compose.material.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.window.Dialog
-import net.helcel.beans.R
-import net.helcel.beans.helper.Data
-import net.helcel.beans.helper.Groups
-import androidx.core.graphics.drawable.toDrawable
-import net.helcel.beans.activity.SysTheme
-
-@Composable
-fun EditPlaceDialog(delete: Boolean, onDialogDismiss: (Boolean)->Unit){
-    SysTheme {
-        var showEditGroupDialog by remember { mutableStateOf(false) }
-        var showEditPlaceColorDialog by remember { mutableStateOf(true) }
-        var showSelectedKey by remember { mutableIntStateOf(-1) }
-        var showDelete by remember { mutableStateOf(false) }
-        if (showEditGroupDialog)
-            EditGroupDialog(
-                key = showSelectedKey,
-                deleteEnabled = showDelete,
-                onAddCb = { },
-                onDelCb = {
-
-                },
-                onDismiss = {
-                    showEditGroupDialog = false
-                },
-            )
-        if (showEditPlaceColorDialog)
-            EditPlaceColorDialog(
-                delete,
-                onAdd = {
-                    showSelectedKey = it
-                    showDelete = false
-                    showEditGroupDialog = true
-                },
-                onDelete = {
-                    showSelectedKey = it
-                    showDelete = true
-                    showEditGroupDialog = true
-                },
-                onClear = {
-                    showEditPlaceColorDialog = false
-                    onDialogDismiss(true)
-                },
-                onDismiss = {
-                    showEditPlaceColorDialog = false
-                    onDialogDismiss(false)
-                }
-            )
-    }
-}
-
-@Preview
-@Composable
-fun GroupListPreview() {
-    Data.groups = Groups(0, HashMap())
-    Data.groups.setGroup(0, "Testing", Color.Red.toArgb().toDrawable())
-    Data.groups.setGroup(1, "Testing", Color.Blue.toArgb().toDrawable())
-    EditPlaceColorDialog(false,{},{},{},{})
-}
-
-@Composable
-fun EditPlaceColorDialog(
-    deleteMode: Boolean = false,
-    onAdd: (Int) -> Unit = {},
-    onDelete: (Int) -> Unit= {},
-    onClear: () -> Unit= {},
-    onDismiss: () -> Unit= {},
-) {
-    val groups by Data.groups.groupsFlow.collectAsState()
-
-    Dialog(
-        onDismissRequest = onDismiss,
-        content = {
-            Column(
-                modifier = Modifier
-                    .background(
-                        MaterialTheme.colors.background,
-                        RoundedCornerShape(corner = CornerSize(16.dp)))
-                    .padding(16.dp)
-                ,
-
-                ) {
-                Text(
-                    style = MaterialTheme.typography.h6,
-                    color=MaterialTheme.colors.onBackground,
-                    text = if (deleteMode) stringResource(R.string.select_group)
-                    else stringResource(R.string.edit_group)
-                )
-                Text(
-                    style = MaterialTheme.typography.caption,
-                    color=MaterialTheme.colors.onBackground,
-                    text = if (deleteMode) stringResource(R.string.select_group_sub)
-                    else stringResource(R.string.edit_group_sub)
-                )
-                Spacer(modifier = Modifier.height(16.dp))
-                Box(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .heightIn(max = 300.dp) // cap dialog growth
-                ) {
-                    LazyColumn(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                        //.weight(1f)
-                    ) {
-                        items(groups, key = { it.key }) { group ->
-                            Row(
-                                modifier = Modifier
-                                    .fillMaxWidth()
-                                    .combinedClickable(
-                                        onClick = { Data.selected_group = group; onDismiss() },
-                                        onLongClick = { onDelete(group.key) })
-                                    .background(
-                                        Color(88, 88, 88, 88),
-                                        RoundedCornerShape(corner = CornerSize(16.dp))
-                                    )
-                                    .padding(8.dp),
-                                verticalAlignment = Alignment.CenterVertically,
-
-                                ) {
-                                Box(
-                                    modifier = Modifier
-                                        .size(24.dp)
-                                        .background(Color(group.color.color), CircleShape)
-                                )
-                                Spacer(modifier = Modifier.width(8.dp))
-                                Text(color=MaterialTheme.colors.onBackground,text=group.name)
-                            }
-                            Spacer(modifier = Modifier.height(8.dp))
-                        }
-                    }
-                }
-                Spacer(modifier = Modifier.height(8.dp))
-
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.End) {
-                    if (!deleteMode) {
-                        Button(onClick = { onAdd(0) }) {
-                            Text(stringResource(R.string.action_add))
-                        }
-                    }
-                    TextButton(onClick = {
-                        if (deleteMode) onDismiss() else onClear()
-                    }) {
-                        Text(
-                            text = if (deleteMode) stringResource(R.string.cancel)
-                            else stringResource(R.string.action_clear)
-                        )
-                    }
-                }
-            }
-        },
-    )
-}

app/src/main/java/net/helcel/beans/activity/sub/EditPlaceScreen.kt

@@ -1,259 +0,0 @@
-package net.helcel.beans.activity.sub
-
-
-import android.content.Context
-import androidx.activity.compose.BackHandler
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.material.CheckboxDefaults
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Tab
-import androidx.compose.material.TabRow
-import androidx.compose.material.Text
-import androidx.compose.material.TriStateCheckbox
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.SideEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.runtime.snapshots.SnapshotStateList
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.state.ToggleableState
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import net.helcel.beans.countries.GeoLoc
-import net.helcel.beans.countries.Group
-import net.helcel.beans.countries.World
-import net.helcel.beans.helper.AUTO_GROUP
-import net.helcel.beans.helper.Data
-import net.helcel.beans.helper.NO_GROUP
-import net.helcel.beans.helper.Settings
-import kotlin.math.min
-
-@Preview
-@Composable
-fun EditPlaceScreenPreview(){
-    EditPlaceScreen(Group.EEE)
-}
-
-/**
- * Applies a place straight away where a single group makes the choice obvious,
- * as tapping the checkbox does. Returns false when the group still has to be
- * picked from the colour dialog.
- */
-fun applyDirectVisit(ctx: Context, loc: GeoLoc): Boolean {
-    Data.selected_geoloc = loc
-    Data.selected_group = null
-    if (Data.groups.size() != 1 || !Settings.isSingleGroup(ctx)) return false
-    val current = Data.visits.getVisited(loc)
-    Data.visits.setVisited(
-        loc,
-        if (current == NO_GROUP || current == AUTO_GROUP) Data.groups.getUniqueEntry()!!.key
-        else if (loc.children.any { Data.visits.getVisited(it) != NO_GROUP }) AUTO_GROUP
-        else NO_GROUP,
-    )
-    syncVisited()
-    Data.saveData()
-    Data.selected_geoloc = null
-    return true
-}
-
-/** Stores whatever the colour dialog came back with. */
-fun commitVisitDialog(cleared: Boolean) {
-    if (cleared) {
-        Data.visits.setVisited(Data.selected_geoloc, NO_GROUP)
-        syncVisited()
-        Data.saveData()
-    }
-    if (Data.selected_group != null && Data.selected_geoloc != null) {
-        Data.visits.setVisited(Data.selected_geoloc, Data.selected_group!!.key)
-        syncVisited()
-        Data.saveData()
-    }
-    Data.selected_geoloc = null
-    Data.selected_group = null
-}
-
-fun syncVisited(loc: GeoLoc?=World.WWW): Boolean {
-    var changed = false
-    loc?.children?.forEach { tt ->
-        tt.children.forEach {itc->
-            if(Data.visits.getVisited(itc) in listOf(AUTO_GROUP,NO_GROUP)) {
-                val newState = if(itc.children.any { c -> Data.visits.getVisited(c) != NO_GROUP })
-                    AUTO_GROUP
-                else
-                    NO_GROUP
-
-                if (Data.visits.getVisited(itc) != newState) {
-                    Data.visits.setVisited(itc, newState)
-                    changed = true
-                }
-            }
-        }
-        if(Data.visits.getVisited(tt) in listOf(AUTO_GROUP,NO_GROUP)) {
-            val newState = if(tt.children.any { itc -> Data.visits.getVisited(itc) != NO_GROUP })
-                AUTO_GROUP
-            else
-                NO_GROUP
-
-            if (Data.visits.getVisited(tt) != newState) {
-                Data.visits.setVisited(tt, newState)
-                changed = true
-            }
-        }
-    }
-    // Sync World from Continents
-    if (loc != null && Data.visits.getVisited(loc) in listOf(AUTO_GROUP, NO_GROUP)) {
-        val newState = if(loc.children.any { Data.visits.getVisited(it) != NO_GROUP })
-            AUTO_GROUP
-        else
-            NO_GROUP
-        if (Data.visits.getVisited(loc) != newState) {
-            Data.visits.setVisited(loc, newState)
-            changed = true
-        }
-    }
-    return changed
-}
-
-@Composable
-fun EditPlaceScreen(loc: GeoLoc, onExit:()->Unit={}) {
-    val visits by Data.visits.visitsFlow.collectAsState()
-    var showEdit by remember { mutableStateOf(false) }
-    val tabs : SnapshotStateList<GeoLoc> = remember { mutableStateListOf(loc) }
-    val ctx = LocalContext.current
-    var selectedTab by remember { mutableIntStateOf(0) }
-
-    LaunchedEffect(tabs.size) {
-        selectedTab = tabs.lastIndex
-    }
-    SideEffect {
-        // visits is used to trigger sync whenever data changes
-        if (visits.isNotEmpty() || true) {
-            if (syncVisited()) {
-                Data.saveData()
-            }
-        }
-    }
-    BackHandler {
-        if (tabs.size > 1) tabs.removeAt(tabs.lastIndex)
-        else onExit()
-    }
-    if(showEdit)
-        EditPlaceDialog(false) {
-            showEdit = false
-            commitVisitDialog(it)
-        }
-
-    Column {
-        val currentTab = tabs.getOrNull(selectedTab) ?: return@Column
-        TabRow(
-            selectedTabIndex = min(tabs.lastIndex, selectedTab),
-        ) {
-            tabs.forEachIndexed { index, tab ->
-                Tab(
-                    selected = selectedTab == index,
-                    onClick = {
-                        while (tabs.size > index + 1)
-                            tabs.removeAt(tabs.lastIndex)
-                    },
-                    text = { Text(tab.fullName) }
-                )
-            }
-        }
-
-        LazyColumn(
-            modifier = Modifier.fillMaxSize()
-        ) {
-            items(currentTab.children.toList(), key= {it.code}) { loc ->
-
-                GeoLocRow(loc, {
-                        if (loc.children.isNotEmpty()){
-                            tabs.add(loc)
-                        }
-                    }, {
-                        if (!applyDirectVisit(ctx, loc)) showEdit = true
-                    })
-
-            }
-        }
-
-    }
-}
-
-
-@Composable
-fun GeoLocRow(
-    loc: GeoLoc,
-    onClick: () -> Unit,
-    onToggle: () -> Unit,
-) {
-    val visits by Data.visits.visitsFlow.collectAsState()
-    val checked by remember(visits, loc) {
-        derivedStateOf {
-            when (visits.getOrElse(loc.code) { NO_GROUP }) {
-                NO_GROUP -> ToggleableState.Off
-                AUTO_GROUP -> ToggleableState.Indeterminate
-                else -> ToggleableState.On
-            }
-        }
-    }
-
-    val color = if (Data.visits.getVisited(loc) !in listOf(NO_GROUP, AUTO_GROUP))
-        Color(Data.groups.getGroupFromKey(Data.visits.getVisited(loc)).color.color)
-    else MaterialTheme.colors.onBackground
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .height(50.dp)
-            .clickable(onClick = onClick) // whole row clickable
-            .padding(horizontal = 20.dp, vertical = 4.dp),
-        verticalAlignment = Alignment.CenterVertically
-    ) {
-        Text(
-            text = loc.fullName,
-            style = MaterialTheme.typography.body2,
-            color = MaterialTheme.colors.onBackground,
-            modifier = Modifier.weight(1f)
-        )
-
-        Text(
-            text = "",//loc.children.size.toString(),
-            style = MaterialTheme.typography.body2,
-            modifier = Modifier.padding(end = 16.dp)
-        )
-
-        TriStateCheckbox(
-            state = checked,
-            onClick = onToggle,
-            colors = CheckboxDefaults.colors(
-                checkedColor = color,
-            ),
-
-            modifier = Modifier.size(24.dp)
-        )
-    }
-    Spacer(modifier = Modifier
-        .height(2.dp)
-        .fillMaxWidth()
-        .background(MaterialTheme.colors.onBackground))
-}

app/src/main/java/net/helcel/beans/activity/sub/MapPickDialog.kt

@@ -1,157 +0,0 @@
-package net.helcel.beans.activity.sub
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.foundation.shape.CornerSize
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
-import androidx.compose.material.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.window.Dialog
-import net.helcel.beans.R
-import net.helcel.beans.activity.SysTheme
-import net.helcel.beans.countries.GeoLoc
-import net.helcel.beans.countries.GeoLocTree
-import net.helcel.beans.helper.AUTO_GROUP
-import net.helcel.beans.helper.Data
-import net.helcel.beans.helper.NO_GROUP
-
-private class PickRow(val loc: GeoLoc, val depth: Int)
-
-/**
- * Turns the shapes a tap landed near into an indented list.
- *
- * Each candidate brings its continent and country along, so a tap that is
- * ambiguous between two regions can still be answered with "the whole country"
- * or "the whole continent" instead of only the regions themselves.
- */
-private fun rowsFor(candidates: List<GeoLoc>): List<PickRow> {
-    val rows = LinkedHashMap<String, PickRow>()
-    candidates.forEach { candidate ->
-        GeoLocTree.chain(candidate).forEachIndexed { depth, loc ->
-            rows.getOrPut(loc.code) { PickRow(loc, depth) }
-        }
-    }
-    return rows.values.toList()
-}
-
-@Composable
-fun MapPickDialog(
-    candidates: List<GeoLoc>,
-    onPick: (GeoLoc) -> Unit,
-    onDismiss: () -> Unit,
-) {
-    val visits by Data.visits.visitsFlow.collectAsState()
-    val rows = remember(candidates) { rowsFor(candidates) }
-
-    SysTheme {
-        Dialog(
-            onDismissRequest = onDismiss,
-            content = {
-                Column(
-                    modifier = Modifier
-                        .background(
-                            MaterialTheme.colors.background,
-                            RoundedCornerShape(corner = CornerSize(16.dp)),
-                        )
-                        .padding(16.dp),
-                ) {
-                    Text(
-                        style = MaterialTheme.typography.h6,
-                        color = MaterialTheme.colors.onBackground,
-                        text = stringResource(R.string.select_place),
-                    )
-                    Text(
-                        style = MaterialTheme.typography.caption,
-                        color = MaterialTheme.colors.onBackground,
-                        text = stringResource(R.string.select_place_sub),
-                    )
-                    Spacer(modifier = Modifier.height(16.dp))
-                    Box(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .heightIn(max = 360.dp),
-                    ) {
-                        LazyColumn(modifier = Modifier.fillMaxWidth()) {
-                            items(rows, key = { it.loc.code }) { row ->
-                                val group = visits.getOrElse(row.loc.code) { NO_GROUP }
-                                Row(
-                                    modifier = Modifier
-                                        .fillMaxWidth()
-                                        .clickable { onPick(row.loc) }
-                                        .background(
-                                            Color(88, 88, 88, 88),
-                                            RoundedCornerShape(corner = CornerSize(16.dp)),
-                                        )
-                                        .padding(
-                                            start = 8.dp + 16.dp * row.depth,
-                                            top = 8.dp,
-                                            end = 8.dp,
-                                            bottom = 8.dp,
-                                        ),
-                                    verticalAlignment = Alignment.CenterVertically,
-                                ) {
-                                    Box(
-                                        modifier = Modifier
-                                            .size(16.dp)
-                                            .background(
-                                                if (group == NO_GROUP || group == AUTO_GROUP) {
-                                                    MaterialTheme.colors.onBackground
-                                                } else {
-                                                    Color(
-                                                        Data.groups.getGroupFromKey(group).color.color
-                                                    )
-                                                },
-                                                CircleShape,
-                                            ),
-                                    )
-                                    Spacer(modifier = Modifier.width(8.dp))
-                                    Text(
-                                        color = MaterialTheme.colors.onBackground,
-                                        style = MaterialTheme.typography.body2,
-                                        text = row.loc.fullName,
-                                        // Long names wrap inside the row rather
-                                        // than running off the end of it.
-                                        modifier = Modifier.weight(1f),
-                                    )
-                                }
-                                Spacer(modifier = Modifier.height(8.dp))
-                            }
-                        }
-                    }
-                    Row(
-                        modifier = Modifier.fillMaxWidth(),
-                        horizontalArrangement = Arrangement.End,
-                    ) {
-                        TextButton(onClick = onDismiss) {
-                            Text(stringResource(R.string.cancel))
-                        }
-                    }
-                }
-            },
-        )
-    }
-}

app/src/main/java/net/helcel/beans/countries/Country.kt

@@ -5,10 +5,9 @@ enum class Country(
     override val area: Int
 ) : GeoLoc {
     ATA("Antarctica", 14000000),
-
+    HKG("Hong Kong", 1104),
-    //    HKG("Hong Kong", 1104),
+    MAC("Macao", 32),
-    //    MAC("Macao", 32),
+    ANT("Netherlands Antilles", 800),
-    //    ANT("Netherlands Antilles", 800),
     AFG("Afghanistan", 645487),
     XAD("Akrotiri and Dhekelia", 234),
     ALA("Åland", 1483),

app/src/main/java/net/helcel/beans/countries/GeoLoc.kt

@@ -1,9 +1,10 @@
 package net.helcel.beans.countries
 
+
 interface GeoLoc {
 
     enum class LocType(val txt: String) {
-        WORLD("Continents"), GROUP("Groups"), CUSTOM_GROUP("Groups"), COUNTRY("Countries"), STATE("Regions");
+        WORLD("World"), GROUP("Group"), CUSTOM_GROUP("Group"), COUNTRY("Country"), STATE("State");
     }
 
     val code: String
@@ -13,3 +14,5 @@ interface GeoLoc {
     val type: LocType
     val children: Set<GeoLoc>
 }
+
+

app/src/main/java/net/helcel/beans/countries/GeoLocImporter.kt

@@ -12,7 +12,6 @@ object GeoLocImporter {
 
     fun importStates(ctx: Context, force: Boolean = false) {
         if (!Settings.isRegional(ctx) and !force) {
-            GeoLocTree.rebuild()
             return
         }
         val fs = BufferedReader(InputStreamReader(ctx.assets.open("geoloc_state.txt")))
@@ -27,7 +26,6 @@ object GeoLocImporter {
                 }
             }
         }
-        GeoLocTree.rebuild()
     }
 
     fun clearStates() {
@@ -41,7 +39,6 @@ object GeoLocImporter {
             }
             country.children.clear()
         }
-        GeoLocTree.rebuild()
         Data.saveData()
     }
 }

app/src/main/java/net/helcel/beans/countries/GeoLocTree.kt

@@ -1,50 +0,0 @@
-package net.helcel.beans.countries
-
-/**
- * Code to place lookup, plus the chain of parents above a place.
- *
- * Regions only exist once [GeoLocImporter] has read them, so this is rebuilt
- * whenever that set changes rather than derived once and cached forever.
- */
-object GeoLocTree {
-
-    private var index: Map<String, GeoLoc> = emptyMap()
-    private var parents: Map<String, GeoLoc> = emptyMap()
-
-    fun rebuild() {
-        val byCode = HashMap<String, GeoLoc>()
-        val parent = HashMap<String, GeoLoc>()
-        byCode[World.WWW.code] = World.WWW
-        World.WWW.children.forEach { child ->
-            byCode[child.code] = child
-            parent[child.code] = World.WWW
-            child.children.forEach { country ->
-                byCode[country.code] = country
-                parent[country.code] = child
-                country.children.forEach { state ->
-                    byCode[state.code] = state
-                    parent[state.code] = country
-                }
-            }
-        }
-        index = byCode
-        parents = parent
-    }
-
-    fun find(code: String): GeoLoc? {
-        if (index.isEmpty()) rebuild()
-        return index[code]
-    }
-
-    /** [loc] and everything above it, world first, so it reads as a path. */
-    fun chain(loc: GeoLoc): List<GeoLoc> {
-        if (index.isEmpty()) rebuild()
-        val path = ArrayList<GeoLoc>(4)
-        var current: GeoLoc? = loc
-        while (current != null && current != World.WWW) {
-            path.add(current)
-            current = parents[current.code]
-        }
-        return path.reversed()
-    }
-}

app/src/main/java/net/helcel/beans/countries/Group.kt

@@ -2,11 +2,11 @@ package net.helcel.beans.countries
 
 import net.helcel.beans.countries.Country.*
 
-@Suppress("RedundantSuppression", "SpellCheckingInspection", "unused")
 enum class Group(override val fullName: String, override val children: Set<GeoLoc>) : GeoLoc {
 
     EEE(
         "Europe", setOf(
+            XAD,
             ALA,// Åland Islands: an autonomous region of Finland, but not a member of the EU or UN
             ALB,
             AND,
@@ -16,6 +16,7 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
             BIH,
             BGR,
             HRV,
+            CYP,
             CZE,
             DNK,
             EST,
@@ -25,7 +26,6 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
             DEU,
             GIB, // Gibraltar: a British overseas territory located at the southern tip of the Iberian Peninsula
             GRC,
-            GRL,
             GGY, // Guernsey: a British Crown dependency in the English Channel
             HUN,
             ISL,
@@ -33,6 +33,7 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
             IMN, // Isle of Man: a British Crown dependency located in the Irish Sea
             ITA,
             JEY, // Jersey: a British Crown dependency located in the English Channel
+            KAZ,
             XKO,
             LVA,
             LIE,
@@ -64,7 +65,6 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
     ),
     ABB(
         "Asia", setOf(
-            XAD,
             AFG,
             ARM,
             AZE,
@@ -77,9 +77,8 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
             CCK, // Cocos (Keeling) Islands: an Australian external territory in the Indian Ocean
             CHN,
             CXR, // Christmas Island: an Australian external territory in the Indian Ocean
-            CYP,
             GEO,
-            //HKG,
+            HKG,
             IND,
             IDN,
             IRN,
@@ -87,12 +86,11 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
             ISR,
             JPN,
             JOR,
-            KAZ,
             KWT,
             KGZ,
             LAO,
             LBN,
-            //MAC,
+            MAC,
             MYS,
             MDV,
             MNG,
@@ -129,7 +127,6 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
             BDI,
             BEN,
             BWA,
-            BVT, // Bouvet Island: an uninhabited territory of Norway in the South Atlantic
             BFA,
             BDI,
             CPV,
@@ -151,7 +148,6 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
             GHA,
             GIN,
             GNB,
-            HMD, // Heard Island and McDonald Islands: an uninhabited Australian external territory in the southern Indian Ocean
             KEN,
             LSO,
             LBR,
@@ -210,6 +206,7 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
             DMA,
             DOM,
             SLV,
+            GRL,
             GRD,
             GLP,
             GTM,
@@ -219,7 +216,7 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
             MTQ,
             MEX,
             MSR,
-            //ANT,
+            ANT,
             CUW,
             NIC,
             PAN,
@@ -251,7 +248,6 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
             GUY,
             PRY,
             PER,
-            SGS, // South Georgia and the South Sandwich Islands: a British overseas territory in the southern Atlantic Ocean
             SUR,
             URY,
             VEN,
@@ -288,8 +284,11 @@ enum class Group(override val fullName: String, override val children: Set<GeoLo
     ),
 
     XXX(
-        "Other", setOf(
+        "Others", setOf(
-           
+            ATA, // Antarctica: not in any other region
+            BVT, // Bouvet Island: an uninhabited territory of Norway in the South Atlantic
+            HMD, // Heard Island and McDonald Islands: an uninhabited Australian external territory in the southern Indian Ocean
+            SGS, // South Georgia and the South Sandwich Islands: a British overseas territory in the southern Atlantic Ocean
         )
     ),
 

app/src/main/java/net/helcel/beans/countries/World.kt

@@ -6,8 +6,7 @@ enum class World(override val fullName: String, override val children: Set<GeoLo
 
     WWW(
         "World", setOf(
-            EEE, ABB, FFF, NNN, SRR, UUU, Country.ATA,
+            EEE, ABB, FFF, NNN, SRR, UUU, XXX
-
         )
     );
 

app/src/main/java/net/helcel/beans/helper/Data.kt

@@ -1,20 +1,13 @@
 package net.helcel.beans.helper
 
-import android.content.ContentValues
 import android.content.Context
 import android.content.SharedPreferences
-import android.net.Uri
+import android.graphics.drawable.ColorDrawable
-import android.os.Build
-import android.os.Environment
-import android.provider.MediaStore
 import androidx.core.content.ContextCompat
+import androidx.preference.PreferenceManager
 import net.helcel.beans.R
 import net.helcel.beans.countries.GeoLoc
 import java.util.HashMap
-import androidx.core.graphics.drawable.toDrawable
-import androidx.core.content.edit
-import android.content.Intent
-import java.io.File
 
 object Data {
     var visits : Visits = Visits(0, HashMap())
@@ -22,6 +15,7 @@ object Data {
 
     var selected_group : Groups.Group? = null
     var selected_geoloc: GeoLoc? = null
+    var clearing_geoloc: GeoLoc? = null
 
     private val groupsSerial = Groups.GroupsSerializer()
     private val visitsSerial = Visits.VisitsSerializer()
@@ -29,7 +23,7 @@ object Data {
     private lateinit var sharedPreferences: SharedPreferences
 
     fun loadData(ctx: Context, id:Int) {
-        sharedPreferences = defaultPreferences(ctx)
+        sharedPreferences = PreferenceManager.getDefaultSharedPreferences(ctx)
 
         val groupsString = sharedPreferences.getString("groups_$id",null)
         val visitsString = sharedPreferences.getString("visits_$id",null)
@@ -39,82 +33,17 @@ object Data {
 
         // Add default group "Visited" with app's color if there is no group already
         if (groups.size() == 0) {
-            groups.setGroup(DEFAULT_GROUP, "Visited",
+            groups.setGroup(DEFAULT_GROUP, "Visited", ColorDrawable(ContextCompat.getColor(ctx, R.color.blue)))
-                ContextCompat.getColor(ctx, R.color.blue).toDrawable())
-        }
             saveData()
         }
+    }
 
     fun saveData() {
         if(groups.id != visits.id) return
         val id = groups.id
-        sharedPreferences.edit(commit=true) {
+        val editor = sharedPreferences.edit()
-            putString("groups_$id", groupsSerial.writeTo(groups))
+        editor.putString("groups_$id", groupsSerial.writeTo(groups))
-            putString("visits_$id", visitsSerial.writeTo(visits))
+        editor.putString("visits_$id", visitsSerial.writeTo(visits))
-        }
+        editor.apply()
-    }
-
-    fun exportData(ctx: Context, filepath: Uri){
-        val groupsJson = groupsSerial.writeTo(groups)
-        val visitsJson = visitsSerial.writeTo(visits)
-        val outputStream = ctx.contentResolver.openOutputStream(filepath)
-        outputStream?.write(
-            buildString {
-                append(groupsJson)
-                append("\n---\n") // optional separator
-                append(visitsJson)
-            }.toByteArray())
-        outputStream?.flush()
-        outputStream?.close()
-    }
-
-
-    fun importData(ctx: Context, filePath: Uri) {
-        val inputStream = ctx.contentResolver.openInputStream(filePath)
-        val data = inputStream?.bufferedReader().use { it?.readText() }
-        if(data==null) return
-        val lines = data.split("\n---\n")
-        val groupsJson = lines[0]
-        val visitsJson = lines[1]
-
-        groups = if(groupsJson.isNotEmpty()) groupsSerial.readFrom(groupsJson.byteInputStream()) else groupsSerial.defaultValue
-        visits = if(visitsJson.isNotEmpty()) visitsSerial.readFrom(visitsJson.byteInputStream()) else visitsSerial.defaultValue
-
-        // Add default group "Visited" with app's color if there is no group already
-        if (groups.size() == 0) {
-            groups.setGroup(DEFAULT_GROUP, "Visited",
-                ContextCompat.getColor(ctx, R.color.blue).toDrawable())
-        }
-        saveData()
-    }
-
-    fun doImport(ctx: Context, file: Uri?){
-        if(file!=null) {
-            importData(ctx, file)
-            val intent = ctx.packageManager
-                .getLaunchIntentForPackage(ctx.packageName)?.apply {
-                    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK or Intent.FLAG_ACTIVITY_NEW_TASK)
-                }
-            ctx.startActivity(intent)
-        }
-    }
-
-    fun doExport(ctx: Context){
-        val fileName = "beans_backup.json"
-        val resolver = ctx.contentResolver
-        val contentValues = ContentValues().apply {
-            put(MediaStore.Downloads.DISPLAY_NAME, fileName) // "backup.json"
-            put(MediaStore.Downloads.MIME_TYPE, "text/*")
-            put(MediaStore.Downloads.RELATIVE_PATH, Environment.DIRECTORY_DOWNLOADS)
-        }
-        val uri = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            resolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, contentValues)
-        } else {
-            val downloadsDir =
-                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
-            val file = File(downloadsDir, fileName)
-            Uri.fromFile(file)
-        }
-        if(uri!=null) exportData(ctx, uri)
     }
 }

app/src/main/java/net/helcel/beans/helper/DialogCloser.kt

@@ -0,0 +1,5 @@
+package net.helcel.beans.helper
+
+interface DialogCloser {
+    fun onDialogDismiss(clear: Boolean)
+}

app/src/main/java/net/helcel/beans/helper/Groups.kt

@@ -2,17 +2,15 @@ package net.helcel.beans.helper
 
 import android.graphics.Color
 import android.graphics.drawable.ColorDrawable
+import androidx.core.content.ContextCompat
 import kotlinx.serialization.ExperimentalSerializationApi
-import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Serializer
 import kotlinx.serialization.json.Json
+import net.helcel.beans.R
 import java.io.InputStream
+import kotlin.coroutines.coroutineContext
 import kotlin.random.Random
-import androidx.core.graphics.drawable.toDrawable
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
 
 
 private const val randSeed = 0
@@ -22,69 +20,52 @@ const val NO_GROUP = 0
 const val DEFAULT_GROUP = 1
 const val AUTO_GROUP = -1
 
-
-
 @Serializable
-class Groups(val id: Int, @SerialName("grps") private val groups: HashMap<Int, Group>) {
+class Groups(val id: Int, private val grps: HashMap<Int, Group>) {
-    @kotlinx.serialization.Transient
-    private val _groupsFlow = MutableStateFlow<List<Group>>(groups.values.toList())
-    @kotlinx.serialization.Transient
-    val groupsFlow: StateFlow<List<Group>> = _groupsFlow.asStateFlow()
 
     fun setGroup(key: Int, name: String, col: ColorDrawable) {
-        val old = groups[key]
+        grps[key] = Group(key, name, col)
-        if (old != null && old.name == name && old.color.color == col.color) return
-        groups[key] = Group(key, name, col)
-        updateFlow()
     }
 
     fun deleteGroup(key: Int) {
-        groups.remove(key)
+        grps.remove(key)
-        updateFlow()
     }
 
-    fun keepOnly(key: Int) {
+    fun deleteAllExcept(grp: Int) {
-        val keep = groups[key] ?: return
+        val keysToDelete = grps.keys.filter { it != grp }
-        groups.clear()
+        keysToDelete.forEach { grps.remove(it) }
-        groups[key] = keep
-        updateFlow()
-    }
-
-    private fun updateFlow() {
-        _groupsFlow.value = groups.values.toList()
     }
 
     fun getGroupFromKey(key: Int): Group {
-        return groups.getOrDefault(key, EmptyGroup())
+        return grps.getOrDefault(key, EmptyGroup())
     }
 
     fun genKey(): Int {
         val key = rnd.nextInt()
-        if (groups.containsKey(key) || key in listOf(NO_GROUP, DEFAULT_GROUP, AUTO_GROUP)) return genKey()
+        if (grps.containsKey(key) || key in listOf(NO_GROUP, DEFAULT_GROUP, AUTO_GROUP)) return genKey()
         return key
     }
 
     fun size(): Int {
-        return groups.size
+        return grps.size
     }
 
     fun getUniqueEntry(): Group? {
         assert(size() == 1)
-        return if (groups.size == 1) {
+        return if (grps.size == 1) {
-            groups[groups.keys.first()]
+            grps[grps.keys.first()]
         } else {
             null
         }
     }
 
     fun getGroupFromPos(pos: Int): Pair<Int, Group> {
-        if(groups.keys.isEmpty()) return Pair(NO_GROUP,Group(NO_GROUP,"-"))
+        val key = grps.keys.toList()[pos]
-        val key = groups.keys.toList()[pos]
         return Pair(key, getGroupFromKey(key))
     }
 
     fun findGroupPos(key: Int): Int {
-        return groups.keys.toList().indexOf(key)
+        return grps.keys.toList().indexOf(key)
     }
 
     class EmptyGroup : Group(0, "")
@@ -93,7 +74,9 @@ class Groups(val id: Int, @SerialName("grps") private val groups: HashMap<Int, G
     open class Group(
         val key: Int,
         val name: String,
-        @Serializable(with = Theme.ColorDrawableSerializer::class) val color: ColorDrawable = Color.GRAY.toDrawable()
+        @Serializable(with = Theme.ColorDrawableSerializer::class) val color: ColorDrawable = ColorDrawable(
+            Color.GRAY
+        )
     )
 
     @OptIn(ExperimentalSerializationApi::class)

app/src/main/java/net/helcel/beans/helper/Prefs.kt

@@ -1,12 +0,0 @@
-package net.helcel.beans.helper
-
-import android.content.Context
-import android.content.SharedPreferences
-
-/**
- * The preference file opened directly, under the name and mode androidx's
- * PreferenceManager used. Settings written by earlier versions still load, and
- * the app no longer pulls in the preference UI framework for one call.
- */
-fun defaultPreferences(ctx: Context): SharedPreferences =
-    ctx.getSharedPreferences(ctx.packageName + "_preferences", Context.MODE_PRIVATE)

app/src/main/java/net/helcel/beans/helper/Settings.kt

@@ -2,26 +2,21 @@ package net.helcel.beans.helper
 
 import android.content.Context
 import android.content.SharedPreferences
+import androidx.preference.PreferenceManager
 import net.helcel.beans.R
-import net.helcel.beans.activity.MainScreen
+import net.helcel.beans.activity.MainActivity
-
+import net.helcel.beans.activity.fragment.SettingsFragment
-/**
- * Default distance, in dp, around a tap that still counts as hitting a place.
- * Kept small because the radius is measured on screen: zoomed out to the whole
- * world, even a few dp reach across several countries.
- */
-const val DEFAULT_TOUCH_RADIUS = 4
-
-/** Largest tap radius the setting offers. */
-const val MAX_TOUCH_RADIUS = 48
 
 object Settings {
 
     private lateinit var sp: SharedPreferences
-    private lateinit var mainActivity: MainScreen
+    private lateinit var mainActivity: MainActivity
-    fun start(ctx: MainScreen) {
+    fun start(ctx: MainActivity) {
         mainActivity = ctx
-        sp = defaultPreferences(ctx)
+        sp = PreferenceManager.getDefaultSharedPreferences(ctx)
+        SettingsFragment.setTheme(
+            ctx, sp.getString(ctx.getString(R.string.key_theme), ctx.getString(R.string.system))
+        )
     }
 
     fun isSingleGroup(ctx: Context): Boolean {
@@ -38,21 +33,6 @@ object Settings {
         )
     }
 
-    /**
-     * How far around a tap, in dp, the map looks for other places. Anything
-     * within it is offered as a candidate instead of painting straight away.
-     */
-    fun getTouchRadius(ctx: Context): Float {
-        return sp.getInt(ctx.getString(R.string.key_touch_radius), DEFAULT_TOUCH_RADIUS).toFloat()
-    }
-
-    fun isCascadeStats(ctx: Context): Boolean {
-        return getBooleanValue(
-            ctx,
-            sp.getString(ctx.getString(R.string.key_cascade_stats), ctx.getString(R.string.off))
-        )
-    }
-
     fun getStatPref(ctx: Context): String? {
         return sp.getString(
             ctx.getString(R.string.key_stats),
@@ -61,7 +41,7 @@ object Settings {
     }
 
     fun refreshProjection(): Boolean {
-        (mainActivity).refreshProjection()
+        mainActivity.refreshProjection()
         return true
     }
 

app/src/main/java/net/helcel/beans/helper/Theme.kt

@@ -1,16 +1,23 @@
 package net.helcel.beans.helper
 
+import android.content.Context
 import android.graphics.Color
 import android.graphics.drawable.ColorDrawable
+import android.util.TypedValue
+import androidx.appcompat.app.AppCompatActivity
 import androidx.core.graphics.ColorUtils
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.descriptors.PrimitiveKind
 import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
-import androidx.core.graphics.drawable.toDrawable
 
 object Theme {
+    fun colorWrapper(ctx: Context, res: Int): ColorDrawable {
+        val colorPrimaryTyped = TypedValue()
+        ctx.theme.resolveAttribute(res, colorPrimaryTyped, true)
+        return ColorDrawable(colorPrimaryTyped.data)
+    }
 
     fun colorToHex6(c: ColorDrawable): String {
         return '#' + colorToHex8(c).substring(3)
@@ -21,6 +28,12 @@ object Theme {
         return '#' + c.color.toHexString()
     }
 
+    fun createActionBar(ctx: AppCompatActivity, title: String) {
+        ctx.supportActionBar?.setBackgroundDrawable(colorWrapper(ctx, android.R.attr.colorPrimary))
+        ctx.supportActionBar?.title = title
+        ctx.supportActionBar?.setDisplayHomeAsUpEnabled(true)
+    }
+
     fun getContrastColor(color: Int): Int {
         val whiteContrast = ColorUtils.calculateContrast(Color.WHITE, color)
         val blackContrast = ColorUtils.calculateContrast(Color.BLACK, color)
@@ -31,7 +44,7 @@ object Theme {
         override val descriptor = PrimitiveSerialDescriptor("ColorDrawable", PrimitiveKind.INT)
 
         override fun deserialize(decoder: Decoder): ColorDrawable {
-            return decoder.decodeInt().toDrawable()
+            return ColorDrawable(decoder.decodeInt())
         }
 
         override fun serialize(encoder: Encoder, value: ColorDrawable) {

app/src/main/java/net/helcel/beans/helper/Visits.kt

@@ -1,7 +1,5 @@
 package net.helcel.beans.helper
 
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Serializer
@@ -13,31 +11,19 @@ import java.io.InputStream
 @Serializable
 class Visits(val id: Int, private val locs: HashMap<String, Int>) {
 
-    @kotlinx.serialization.Transient
-    private val _visitsFlow = MutableStateFlow<Map<String,Int>>(locs.toMutableMap())
-    @kotlinx.serialization.Transient
-    val visitsFlow: StateFlow<Map<String,Int>> = _visitsFlow
-
     fun setVisited(key: GeoLoc?, b: Int) {
-        if (key == null || locs[key.code] == b)
+        if (key == null)
             return
         locs[key.code] = b
-        updateFlow()
-    }
-
-    private fun updateFlow() {
-        _visitsFlow.value = locs.toMap()
     }
 
     fun deleteVisited(key: Int) {
         val keysToDelete = locs
             .filter { it.value == key }
             .map { it.key }
-        if (keysToDelete.isEmpty()) return
         keysToDelete.forEach {
             locs.remove(it)
         }
-        updateFlow()
     }
 
     fun getVisited(key: GeoLoc): Int {
@@ -61,18 +47,11 @@ class Visits(val id: Int, private val locs: HashMap<String, Int>) {
     }
 
     fun reassignAllVisitedToGroup(group: Int) {
-        var changed = false
         val keys = locs.filter { (_, grp) ->
             grp !in listOf(NO_GROUP, AUTO_GROUP)
         }.keys
         keys.forEach {
-            if (locs[it] != group) {
             locs[it] = group
-                changed = true
-            }
-        }
-        if (changed) {
-            updateFlow()
         }
     }
 

app/src/main/java/net/helcel/beans/map/MapAssets.kt

@@ -1,23 +0,0 @@
-package net.helcel.beans.map
-
-import android.content.Context
-import net.helcel.beans.R
-import net.helcel.beans.helper.defaultPreferences
-
-/** Picks the map asset matching the projection the user chose. */
-object MapAssets {
-
-    fun assetFor(ctx: Context): String {
-        val preferences = defaultPreferences(ctx)
-        return when (
-            preferences.getString(
-                ctx.getString(R.string.key_projection),
-                ctx.getString(R.string.mercator),
-            )
-        ) {
-            ctx.getString(R.string.azimuthalequidistant) -> "aeqd01.bmap"
-            ctx.getString(R.string.loximuthal) -> "loxim01.bmap"
-            else -> "webmercator01.bmap"
-        }
-    }
-}

app/src/main/java/net/helcel/beans/map/MapReader.kt

@@ -1,133 +0,0 @@
-package net.helcel.beans.map
-
-import android.graphics.Path
-import android.graphics.RectF
-import java.io.InputStream
-
-private const val VERSION = 2
-
-/**
- * Reads the packed map assets produced by `packmap.js`.
- *
- * The maps used to ship as SVG, which spends around four megabytes per
- * projection spelling coordinates out in decimal ASCII inside XML. The packed
- * form says the same thing in a fraction of that, and reading it is a straight
- * scan over a byte array instead of an XML parse with a float scanner on top.
- *
- * The format is documented in `packmap.js`; the two have to agree.
- */
-object MapReader {
-
-    fun read(input: InputStream): MapWorld {
-        val reader = ByteReader(input.readBytes())
-        reader.readHeader()
-        val width = reader.unsigned() * reader.scale
-        val height = reader.unsigned() * reader.scale
-        val count = reader.unsigned()
-        val shapes = ArrayList<MapShape>(count)
-        repeat(count) { shapes.add(reader.shape()) }
-        return MapWorld(width, height, shapes)
-    }
-}
-
-private class ByteReader(private val data: ByteArray) {
-
-    private var pos = 0
-
-    /** One grid step in user units, read from the header. */
-    var scale = 1f
-        private set
-
-    fun readHeader() {
-        require(
-            data.size > 5 &&
-                data[0] == 'B'.code.toByte() && data[1] == 'M'.code.toByte() &&
-                data[2] == 'A'.code.toByte() && data[3] == 'P'.code.toByte()
-        ) { "not a packed map" }
-        require(data[4].toInt() == VERSION) { "unsupported packed map version ${data[4]}" }
-        pos = 5
-        scale = 1f / unsigned()
-    }
-
-    fun unsigned(): Int {
-        var result = 0
-        var shift = 0
-        while (true) {
-            val byte = data[pos++].toInt()
-            result = result or ((byte and 0x7F) shl shift)
-            if (byte and 0x80 == 0) return result
-            shift += 7
-        }
-    }
-
-    /** Zigzag, because deltas run both ways and are almost always tiny. */
-    fun signed(): Int {
-        val value = unsigned()
-        return if (value and 1 == 1) -((value ushr 1) + 1) else value ushr 1
-    }
-
-    fun flag(): Boolean = data[pos++].toInt() != 0
-
-    fun text(): String {
-        val length = unsigned()
-        val value = String(data, pos, length, Charsets.UTF_8)
-        pos += length
-        return value
-    }
-
-    fun shape(): MapShape {
-        val code = text()
-        val isState = flag()
-        val ringCount = unsigned()
-
-        val rings = ArrayList<FloatArray>(ringCount)
-        var nonZero: Path? = null
-        var evenOdd: Path? = null
-        var minX = Float.MAX_VALUE
-        var minY = Float.MAX_VALUE
-        var maxX = -Float.MAX_VALUE
-        var maxY = -Float.MAX_VALUE
-
-        repeat(ringCount) {
-            val points = unsigned()
-            val useEvenOdd = flag()
-            val ring = FloatArray(points * 2)
-            // Each point is a delta from the one before it, the first from the
-            // origin, so the whole ring decodes in one pass.
-            var x = 0
-            var y = 0
-            for (i in 0 until points) {
-                x += signed()
-                y += signed()
-                val fx = x * scale
-                val fy = y * scale
-                ring[i * 2] = fx
-                ring[i * 2 + 1] = fy
-                if (fx < minX) minX = fx
-                if (fx > maxX) maxX = fx
-                if (fy < minY) minY = fy
-                if (fy > maxY) maxY = fy
-            }
-            rings.add(ring)
-
-            val path = if (useEvenOdd) {
-                evenOdd ?: Path().also { it.fillType = Path.FillType.EVEN_ODD; evenOdd = it }
-            } else {
-                nonZero ?: Path().also { nonZero = it }
-            }
-            path.moveTo(ring[0], ring[1])
-            var i = 2
-            while (i < ring.size) {
-                path.lineTo(ring[i], ring[i + 1])
-                i += 2
-            }
-            path.close()
-        }
-
-        return MapShape(
-            code, isState, rings,
-            RectF(minX, minY, maxX, maxY),
-            nonZero, evenOdd,
-        )
-    }
-}

app/src/main/java/net/helcel/beans/map/MapRenderer.kt

@@ -1,103 +0,0 @@
-package net.helcel.beans.map
-
-import android.graphics.Canvas
-import android.graphics.Matrix
-import android.graphics.Paint
-import android.graphics.Path
-import android.graphics.PorterDuff
-import android.graphics.RectF
-import kotlin.math.min
-import kotlin.math.roundToInt
-
-/** Draws a [MapWorld] onto a canvas through a pan/zoom transform. */
-class MapRenderer(private val map: MapWorld) {
-
-    private val fill = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-        style = Paint.Style.FILL
-    }
-    private val stroke = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-        style = Paint.Style.STROKE
-        strokeCap = Paint.Cap.ROUND
-        strokeJoin = Paint.Join.ROUND
-    }
-    private val inverse = Matrix()
-    private val values = FloatArray(9)
-    private val visible = RectF()
-
-    /** False when the border is too faint to be worth a draw call at all. */
-    private var strokeVisible = true
-
-    /**
-     * Paints the map into [canvas], mapping user units through [transform].
-     * Shapes outside the canvas are skipped, which is what makes drawing cheap
-     * once the map is zoomed in.
-     */
-    fun draw(canvas: Canvas, transform: Matrix, style: MapStyle) {
-        // SRC rather than blended: the bitmap is reused between renders.
-        canvas.drawColor(style.background, PorterDuff.Mode.SRC)
-        if (!transform.invert(inverse)) return
-        visible.set(0f, 0f, canvas.width.toFloat(), canvas.height.toFloat())
-        inverse.mapRect(visible)
-
-        // Widths are given in device pixels, so undo the zoom the canvas is
-        // about to apply to them, then let them grow slowly with it.
-        transform.getValues(values)
-        val scale = values[Matrix.MSCALE_X]
-        val perPixel = 1f / scale
-        val fitted = min(canvas.width / map.width, canvas.height / map.height)
-        val zoom = (scale / fitted).coerceAtLeast(1f)
-        val regionPx = strokeWidthAt(zoom, REGION_STROKE_STOPS)
-        val countryPx = strokeWidthAt(zoom, COUNTRY_STROKE_STOPS)
-
-        canvas.save()
-        canvas.concat(transform)
-        setStroke(style.background, if (style.regional) regionPx else countryPx, perPixel)
-        for ((code, color) in style.fills) {
-            val shape = map.byCode[code] ?: continue
-            if (!RectF.intersects(shape.bounds, visible)) continue
-            fill.color = color
-            drawShape(canvas, shape.nonZero, true)
-            drawShape(canvas, shape.evenOdd, true)
-        }
-
-        // With regions on, the country outlines come back on top as the thicker
-        // borders between them.
-        if (style.regional) {
-            setStroke(style.background, countryPx, perPixel)
-            for (shape in map.countries) {
-                if (!RectF.intersects(shape.bounds, visible)) continue
-                drawShape(canvas, shape.nonZero, false)
-                drawShape(canvas, shape.evenOdd, false)
-            }
-        }
-        canvas.restore()
-    }
-
-    /**
-     * Sets a border width given in device pixels.
-     *
-     * Anything thinner than a pixel cannot be drawn as such: the rasteriser
-     * turns it into a one pixel hairline at full strength, which is why every
-     * border below that width used to come out the same weight no matter how
-     * far out the map was. Below a pixel the width is carried as opacity
-     * instead, so a quarter-pixel border reads as a quarter as dark.
-     */
-    private fun setStroke(color: Int, devicePx: Float, perPixel: Float) {
-        strokeVisible = devicePx > 0.004f
-        if (!strokeVisible) return
-        stroke.color = color
-        if (devicePx < 1f) {
-            stroke.strokeWidth = perPixel
-            stroke.alpha = (devicePx * 255f).roundToInt().coerceIn(0, 255)
-        } else {
-            stroke.strokeWidth = perPixel * devicePx
-            stroke.alpha = 255
-        }
-    }
-
-    private fun drawShape(canvas: Canvas, path: Path?, filled: Boolean) {
-        if (path == null) return
-        if (filled) canvas.drawPath(path, fill)
-        if (strokeVisible) canvas.drawPath(path, stroke)
-    }
-}

app/src/main/java/net/helcel/beans/map/MapStyle.kt

@@ -1,115 +0,0 @@
-package net.helcel.beans.map
-
-import android.content.Context
-import net.helcel.beans.countries.GeoLoc
-import net.helcel.beans.countries.World
-import net.helcel.beans.helper.AUTO_GROUP
-import net.helcel.beans.helper.Data
-import net.helcel.beans.helper.NO_GROUP
-import net.helcel.beans.helper.Settings
-import kotlin.math.ln
-
-/**
- * Border width in device pixels at each zoom, interpolated in between.
- *
- * Zoom counts how far in the map is from its fitted size, so 1 is the whole
- * world on screen and 64 is as far in as it goes. The stops step by fours and
- * are interpolated on a log axis, so the weight changes evenly as you pinch
- * rather than in a rush at one end.
- *
- * Region borders start at nothing on purpose: a sub-national border says very
- * little with the whole world in view, and drawing three and a half thousand of
- * them only muddies the land.
- *
- *   zoom     1x     4x    16x    64x
- *   region  0.0    0.5    1.0    2.0
- *   country 1.0    1.5    3.0    6.0
- */
-val STROKE_ZOOM_STOPS = floatArrayOf(1f, 4f, 16f, 64f)
-
-val REGION_STROKE_STOPS = floatArrayOf(0f, 0.5f, 1f, 2f)
-
-val COUNTRY_STROKE_STOPS = floatArrayOf(1f, 1.5f, 3f, 6f)
-
-/** The width for [zoom], straight-line between the stops on a log axis. */
-fun strokeWidthAt(zoom: Float, widths: FloatArray): Float {
-    if (zoom <= STROKE_ZOOM_STOPS.first()) return widths.first()
-    for (i in 1 until STROKE_ZOOM_STOPS.size) {
-        if (zoom <= STROKE_ZOOM_STOPS[i]) {
-            val low = STROKE_ZOOM_STOPS[i - 1]
-            val t = ln(zoom / low) / ln(STROKE_ZOOM_STOPS[i] / low)
-            return widths[i - 1] + t * (widths[i] - widths[i - 1])
-        }
-    }
-    return widths.last()
-}
-
-/**
- * The colour every shape is drawn with, resolved once per render.
- *
- * This replaces the stylesheet the map used to be rendered through. A place
- * inherits the colour of its parent, so painting a whole continent still shows
- * up on each country inside it, and [fills] ends up holding exactly the shapes
- * that get drawn — which is also exactly what a tap may land on.
- */
-class MapStyle(
-    val regional: Boolean,
-    val land: Int,
-    val background: Int,
-    val fills: Map<String, Int>,
-) {
-
-    companion object {
-
-        fun build(ctx: Context, land: Int, background: Int): MapStyle {
-            val regional = Settings.isRegional(ctx)
-            val fills = HashMap<String, Int>()
-            World.WWW.children.forEach { child ->
-                if (child.type == GeoLoc.LocType.COUNTRY) {
-                    // A country hanging straight off the world, such as Antarctica.
-                    addCountry(fills, child, colorOf(World.WWW, regional), regional, land)
-                } else {
-                    val continent = colorOf(child, regional) ?: colorOf(World.WWW, regional)
-                    child.children.forEach { addCountry(fills, it, continent, regional, land) }
-                }
-            }
-            return MapStyle(regional, land, background, fills)
-        }
-
-        private fun addCountry(
-            fills: HashMap<String, Int>,
-            country: GeoLoc,
-            inherited: Int?,
-            regional: Boolean,
-            land: Int,
-        ) {
-            val color = colorOf(country, regional) ?: inherited
-            // Regions are only drawn for countries that actually have some; the
-            // rest keep their outline filled so the map stays complete.
-            if (regional && country.children.isNotEmpty()) {
-                country.children.forEach { state ->
-                    fills[state.code] = colorOf(state, regional) ?: color ?: land
-                }
-            } else {
-                fills[country.code] = color ?: land
-            }
-        }
-
-        /** The group colour assigned to [loc], or `null` when it has none of its own. */
-        private fun colorOf(loc: GeoLoc, regional: Boolean): Int? {
-            val key = Data.visits.getVisited(loc)
-            val group = Data.groups.getGroupFromKey(key)
-            if (group.key != NO_GROUP) return group.color.color
-            // A place marked automatically stands in for its children. That only
-            // needs a colour of its own where the children are not drawn, and
-            // never on a continent, which would swallow the whole map.
-            val isParent = loc.type == GeoLoc.LocType.GROUP ||
-                    loc.type == GeoLoc.LocType.CUSTOM_GROUP ||
-                    loc.type == GeoLoc.LocType.WORLD
-            if (key == AUTO_GROUP && !regional && !isParent) {
-                return Data.groups.getGroupFromPos(0).second.color.color
-            }
-            return null
-        }
-    }
-}

app/src/main/java/net/helcel/beans/map/MapView.kt

@@ -1,345 +0,0 @@
-package net.helcel.beans.map
-
-import android.annotation.SuppressLint
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.Canvas
-import android.graphics.Matrix
-import android.graphics.Paint
-import android.os.Handler
-import android.os.HandlerThread
-import android.os.SystemClock
-import android.view.GestureDetector
-import android.view.MotionEvent
-import android.view.ScaleGestureDetector
-import android.view.View
-import android.widget.OverScroller
-import androidx.core.graphics.createBitmap
-import kotlin.math.min
-
-/** A shape a tap landed on or near, with how far away it was in user units. */
-class MapPick(val code: String, val distance: Float)
-
-/** How far past the fitted map a pinch may zoom in. */
-private const val MAX_ZOOM = 64f
-
-/** How much a double tap zooms in by. */
-private const val DOUBLE_TAP_ZOOM = 3f
-
-/** Time a gesture has to settle before the map is redrawn sharp again. */
-private const val RENDER_DELAY_MS = 80L
-
-/** How long the map may stay stretched while a gesture keeps going. */
-private const val MAX_STALE_MS = 500L
-
-/**
- * Most candidates a single tap will offer. A wide radius over a crowded part of
- * the map can reach dozens of places, which is more of a list than anyone wants
- * to read; the nearest few are what the tap was plausibly aiming at.
- */
-private const val MAX_CANDIDATES = 16
-
-/**
- * The map itself: pan, pinch and tap over a [MapWorld].
- *
- * Drawing every country as vectors costs far too much to do on each frame, so a
- * render lands in an off-screen bitmap on a worker thread and gestures just move
- * that bitmap around. Once the gesture settles the map is drawn again at the new
- * zoom, which is what keeps it sharp all the way in.
- */
-@SuppressLint("ViewConstructor")
-class MapView(context: Context) : View(context) {
-
-    var world: MapWorld? = null
-        set(value) {
-            if (field === value) return
-            field = value
-            renderer = value?.let(::MapRenderer)
-            fitToView()
-            requestRender(0L)
-        }
-
-    @Volatile
-    var style: MapStyle? = null
-        set(value) {
-            if (field === value) return
-            field = value
-            requestRender(0L)
-        }
-
-    /** How far from a tap, in dp, other shapes still count as candidates. */
-    var touchRadiusDp: Float = 4f
-
-    /** Called on a tap with every nearby shape, nearest first. */
-    var onPick: ((List<MapPick>) -> Unit)? = null
-
-    @Volatile
-    private var renderer: MapRenderer? = null
-
-    private val scroller = OverScroller(context)
-
-    private val transform = Matrix()
-    private val inverse = Matrix()
-    private val values = FloatArray(9)
-    private val point = FloatArray(2)
-    private var minScale = 1f
-    private var maxScale = 1f
-
-    private val blitPaint = Paint(Paint.FILTER_BITMAP_FLAG)
-    private val blit = Matrix()
-
-    private val lock = Any()
-    private var front: Bitmap? = null
-    private var back: Bitmap? = null
-    private val frontMatrix = Matrix()
-    private val frontValues = FloatArray(9)
-    private val pendingMatrix = Matrix()
-    private var pendingWidth = 0
-    private var pendingHeight = 0
-    @Volatile private var lastRenderAt = 0L
-
-    private val renderThread = HandlerThread("map-render").apply { start() }
-    private val renderHandler = Handler(renderThread.looper)
-    private val renderTask = Runnable { render() }
-
-    private val scaleDetector = ScaleGestureDetector(
-        context,
-        object : ScaleGestureDetector.SimpleOnScaleGestureListener() {
-            override fun onScale(detector: ScaleGestureDetector): Boolean {
-                val scale = currentScale()
-                val target = (scale * detector.scaleFactor).coerceIn(minScale, maxScale)
-                transform.postScale(target / scale, target / scale, detector.focusX, detector.focusY)
-                clamp()
-                invalidate()
-                return true
-            }
-        },
-    )
-
-    private val gestureDetector = GestureDetector(
-        context,
-        object : GestureDetector.SimpleOnGestureListener() {
-            override fun onDown(e: MotionEvent): Boolean {
-                scroller.forceFinished(true)
-                return true
-            }
-
-            override fun onFling(
-                e1: MotionEvent?,
-                e2: MotionEvent,
-                velocityX: Float,
-                velocityY: Float,
-            ): Boolean {
-                val map = world ?: return false
-                transform.getValues(values)
-                val scale = values[Matrix.MSCALE_X]
-                val x = values[Matrix.MTRANS_X].toInt()
-                val y = values[Matrix.MTRANS_Y].toInt()
-                val w = map.width * scale
-                val h = map.height * scale
-                scroller.forceFinished(true)
-                scroller.fling(
-                    x, y, velocityX.toInt(), velocityY.toInt(),
-                    if (w > width) (width - w).toInt() else x, if (w > width) 0 else x,
-                    if (h > height) (height - h).toInt() else y, if (h > height) 0 else y,
-                )
-                postInvalidateOnAnimation()
-                return true
-            }
-
-            override fun onScroll(
-                e1: MotionEvent?,
-                e2: MotionEvent,
-                distanceX: Float,
-                distanceY: Float,
-            ): Boolean {
-                transform.postTranslate(-distanceX, -distanceY)
-                clamp()
-                invalidate()
-                return true
-            }
-
-            override fun onSingleTapConfirmed(e: MotionEvent): Boolean {
-                pick(e.x, e.y)
-                return true
-            }
-
-            override fun onDoubleTap(e: MotionEvent): Boolean {
-                val scale = currentScale()
-                val target = if (scale >= maxScale * 0.99f) {
-                    minScale
-                } else {
-                    min(scale * DOUBLE_TAP_ZOOM, maxScale)
-                }
-                transform.postScale(target / scale, target / scale, e.x, e.y)
-                clamp()
-                invalidate()
-                return true
-            }
-        },
-    )
-
-    @SuppressLint("ClickableViewAccessibility")
-    override fun onTouchEvent(event: MotionEvent): Boolean {
-        scaleDetector.onTouchEvent(event)
-        gestureDetector.onTouchEvent(event)
-        return true
-    }
-
-    override fun computeScroll() {
-        if (!scroller.computeScrollOffset()) return
-        transform.getValues(values)
-        values[Matrix.MTRANS_X] = scroller.currX.toFloat()
-        values[Matrix.MTRANS_Y] = scroller.currY.toFloat()
-        transform.setValues(values)
-        postInvalidateOnAnimation()
-    }
-
-    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
-        super.onSizeChanged(w, h, oldw, oldh)
-        fitToView()
-        requestRender(0L)
-    }
-
-    override fun onDraw(canvas: Canvas) {
-        val current = style
-        canvas.drawColor(current?.background ?: 0)
-
-        var stale = true
-        synchronized(lock) {
-            val bitmap = front
-            if (bitmap != null && !bitmap.isRecycled && frontMatrix.invert(blit)) {
-                blit.postConcat(transform)
-                canvas.drawBitmap(bitmap, blit, blitPaint)
-                transform.getValues(values)
-                stale = !values.contentEquals(frontValues)
-            }
-        }
-        // Scheduling only ever happens from here or from a setter, both on the
-        // main thread, so a render never starts while its bitmap is on screen.
-        if (stale) {
-            val overdue = SystemClock.uptimeMillis() - lastRenderAt > MAX_STALE_MS
-            requestRender(if (overdue) 0L else RENDER_DELAY_MS)
-        }
-    }
-
-    override fun onDetachedFromWindow() {
-        super.onDetachedFromWindow()
-        scroller.forceFinished(true)
-        renderHandler.removeCallbacks(renderTask)
-        renderThread.quitSafely()
-        // Dropped rather than recycled: a render may still be part way through
-        // one of them, and the collector is happy to take them from here.
-        synchronized(lock) {
-            front = null
-            back = null
-        }
-    }
-
-    /** Centres the map in the view and works out how far it may be zoomed. */
-    private fun fitToView() {
-        val map = world ?: return
-        if (width == 0 || height == 0 || map.width <= 0f || map.height <= 0f) return
-        val scale = min(width / map.width, height / map.height)
-        minScale = scale
-        maxScale = scale * MAX_ZOOM
-        transform.setScale(scale, scale)
-        transform.postTranslate(
-            (width - map.width * scale) / 2f,
-            (height - map.height * scale) / 2f,
-        )
-    }
-
-    private fun currentScale(): Float {
-        transform.getValues(values)
-        return values[Matrix.MSCALE_X]
-    }
-
-    /** Keeps the map from being dragged away from the viewport. */
-    private fun clamp() {
-        val map = world ?: return
-        transform.getValues(values)
-        val scale = values[Matrix.MSCALE_X]
-        val w = map.width * scale
-        val h = map.height * scale
-        values[Matrix.MTRANS_X] = if (w <= width) {
-            (width - w) / 2f
-        } else {
-            values[Matrix.MTRANS_X].coerceIn(width - w, 0f)
-        }
-        values[Matrix.MTRANS_Y] = if (h <= height) {
-            (height - h) / 2f
-        } else {
-            values[Matrix.MTRANS_Y].coerceIn(height - h, 0f)
-        }
-        transform.setValues(values)
-    }
-
-    private fun requestRender(delay: Long) {
-        if (width == 0 || height == 0 || renderer == null || style == null) return
-        synchronized(lock) {
-            pendingMatrix.set(transform)
-            pendingWidth = width
-            pendingHeight = height
-        }
-        renderHandler.removeCallbacks(renderTask)
-        renderHandler.postDelayed(renderTask, delay)
-    }
-
-    private fun render() {
-        val matrix = Matrix()
-        val w: Int
-        val h: Int
-        synchronized(lock) {
-            matrix.set(pendingMatrix)
-            w = pendingWidth
-            h = pendingHeight
-        }
-        if (w <= 0 || h <= 0) return
-        val current = renderer ?: return
-        val currentStyle = style ?: return
-
-        var target = back
-        if (target == null || target.width != w || target.height != h) {
-            target?.recycle()
-            target = createBitmap(w, h)
-            back = target
-        }
-        current.draw(Canvas(target), matrix, currentStyle)
-
-        synchronized(lock) {
-            back = front
-            front = target
-            frontMatrix.set(matrix)
-            matrix.getValues(frontValues)
-        }
-        lastRenderAt = SystemClock.uptimeMillis()
-        postInvalidate()
-    }
-
-    /** Reports every shape within the tap radius of ([x], [y]), nearest first. */
-    private fun pick(x: Float, y: Float) {
-        val map = world ?: return
-        val current = style ?: return
-        val callback = onPick ?: return
-        if (!transform.invert(inverse)) return
-
-        point[0] = x
-        point[1] = y
-        inverse.mapPoints(point)
-        val radius = touchRadiusDp * resources.displayMetrics.density / currentScale()
-
-        val picks = ArrayList<MapPick>()
-        for (code in current.fills.keys) {
-            val shape = map.byCode[code] ?: continue
-            val bounds = shape.bounds
-            if (point[0] < bounds.left - radius || point[0] > bounds.right + radius) continue
-            if (point[1] < bounds.top - radius || point[1] > bounds.bottom + radius) continue
-            val distance = shape.distanceTo(point[0], point[1])
-            if (distance <= radius) picks.add(MapPick(code, distance))
-        }
-        if (picks.isEmpty()) return
-        picks.sortBy { it.distance }
-        callback(if (picks.size > MAX_CANDIDATES) picks.subList(0, MAX_CANDIDATES) else picks)
-    }
-}

app/src/main/java/net/helcel/beans/map/MapWorld.kt

@@ -1,86 +0,0 @@
-package net.helcel.beans.map
-
-import android.graphics.Path
-import android.graphics.RectF
-import kotlin.math.sqrt
-
-/**
- * One named piece of map geometry: a country outline or a single region.
- *
- * The geometry is kept twice on purpose. [nonZero] and [evenOdd] are what the
- * renderer hands to the canvas, while [rings] keeps the raw points because
- * hit testing needs the distance to an edge, which a [Path] cannot give us.
- */
-class MapShape(
-    val code: String,
-    val isState: Boolean,
-    val rings: List<FloatArray>,
-    val bounds: RectF,
-    val nonZero: Path?,
-    val evenOdd: Path?,
-) {
-
-    /** True when ([x], [y]) falls inside the shape. Holes and lakes count as outside. */
-    fun contains(x: Float, y: Float): Boolean {
-        if (x < bounds.left || x > bounds.right || y < bounds.top || y > bounds.bottom) return false
-        // Even-odd crossing count over every ring at once: rings never overlap, so
-        // an island still reads as inside and a hole still reads as outside.
-        var inside = false
-        for (ring in rings) {
-            var j = ring.size - 2
-            var i = 0
-            while (i < ring.size) {
-                val yi = ring[i + 1]
-                val yj = ring[j + 1]
-                if ((yi > y) != (yj > y)) {
-                    val xi = ring[i]
-                    val xj = ring[j]
-                    if (x < xi + (y - yi) * (xj - xi) / (yj - yi)) inside = !inside
-                }
-                j = i
-                i += 2
-            }
-        }
-        return inside
-    }
-
-    /** Distance from ([x], [y]) to the shape, `0` when the point is inside it. */
-    fun distanceTo(x: Float, y: Float): Float {
-        if (contains(x, y)) return 0f
-        var best = Float.MAX_VALUE
-        for (ring in rings) {
-            var j = ring.size - 2
-            var i = 0
-            while (i < ring.size) {
-                val d = segmentDistanceSq(x, y, ring[j], ring[j + 1], ring[i], ring[i + 1])
-                if (d < best) best = d
-                j = i
-                i += 2
-            }
-        }
-        return if (best == Float.MAX_VALUE) Float.MAX_VALUE else sqrt(best)
-    }
-
-    private fun segmentDistanceSq(
-        px: Float, py: Float,
-        ax: Float, ay: Float,
-        bx: Float, by: Float,
-    ): Float {
-        val dx = bx - ax
-        val dy = by - ay
-        val len = dx * dx + dy * dy
-        val t = if (len <= 0f) 0f else (((px - ax) * dx + (py - ay) * dy) / len).coerceIn(0f, 1f)
-        val cx = px - (ax + t * dx)
-        val cy = py - (ay + t * dy)
-        return cx * cx + cy * cy
-    }
-}
-
-/** The whole map, in SVG user units, as a flat set of named shapes. */
-class MapWorld(val width: Float, val height: Float, val shapes: List<MapShape>) {
-
-    val byCode: Map<String, MapShape> = shapes.associateBy { it.code }
-
-    /** Country outlines, keyed by ISO code. Drawn as borders when regions are on. */
-    val countries: List<MapShape> = shapes.filter { !it.isState }
-}

app/src/main/java/net/helcel/beans/svg/CSSWrapper.kt

@@ -0,0 +1,65 @@
+package net.helcel.beans.svg
+
+import android.content.Context
+import net.helcel.beans.countries.World
+import net.helcel.beans.helper.AUTO_GROUP
+import net.helcel.beans.helper.Data.groups
+import net.helcel.beans.helper.Data.visits
+import net.helcel.beans.helper.NO_GROUP
+import net.helcel.beans.helper.Settings
+import net.helcel.beans.helper.Theme.colorToHex6
+import net.helcel.beans.helper.Theme.colorWrapper
+
+class CSSWrapper(private val ctx: Context) {
+
+    private val colorForeground: String =
+        colorToHex6(colorWrapper(ctx, android.R.attr.panelColorBackground))
+    private val colorBackground: String =
+        colorToHex6(colorWrapper(ctx, android.R.attr.colorBackground))
+
+    private val continents: String = World.WWW.children.joinToString(",") { "#${it.code}2" }
+    private val countries: String = World.WWW.children.joinToString(",") { itt ->
+        itt.children.joinToString(",") { "#${it.code}2" }
+    }
+    private val regional: String = World.WWW.children.joinToString(",") { itt ->
+        itt.children.joinToString(",") { "#${it.code}1" }
+    }
+    private val countryOnlyCSS: String =
+        "svg{fill:$colorForeground;stroke:$colorBackground;stroke-width:0.1;}" +
+                "${regional}{display:none;}"
+    private val countryRegionalCSS: String =
+        "svg{fill:$colorForeground;stroke:$colorBackground;stroke-width:0.01;}" +
+                "$continents,$countries{fill:none;stroke:$colorBackground;stroke-width:0.1;}"
+    private var customCSS: String = ""
+
+    init {
+        refresh()
+    }
+
+    private fun refresh() {
+        val id = if (Settings.isRegional(ctx)) "1" else "2"
+        customCSS = visits.getVisitedByValue().map { (k, v) ->
+            if (groups.getGroupFromKey(k).key != NO_GROUP || (!Settings.isRegional(ctx) && k == AUTO_GROUP)) {
+                v.joinToString(",") { "#${it}$id,#${it}" } + "{fill:${
+                    colorToHex6(
+                        if (k == AUTO_GROUP)
+                            colorWrapper(ctx, android.R.attr.colorPrimary)
+                        else groups.getGroupFromKey(k).color
+                    )
+                };}"
+            } else {
+                ""
+            }
+        }.joinToString("")
+    }
+
+    fun get(): String {
+        refresh()
+        return if (Settings.isRegional(ctx)) {
+            countryRegionalCSS + customCSS
+        } else {
+            countryOnlyCSS + customCSS
+        }
+    }
+
+}

app/src/main/java/net/helcel/beans/svg/SVGWrapper.kt

@@ -0,0 +1,26 @@
+package net.helcel.beans.svg
+
+import android.content.Context
+import androidx.preference.PreferenceManager
+import com.caverock.androidsvg.SVG
+import net.helcel.beans.R
+
+class SVGWrapper(ctx: Context) {
+
+    val sharedPreferences = PreferenceManager.getDefaultSharedPreferences(ctx)
+    private val svgFile = when (sharedPreferences.getString(
+        ctx.getString(R.string.key_projection),
+        ctx.getString(R.string.mercator)
+    )) {
+        ctx.getString(R.string.azimuthalequidistant) -> "aeqd01.svg"
+        ctx.getString(R.string.loximuthal) -> "loxim01.svg"
+        ctx.getString(R.string.mercator) -> "webmercator01.svg"
+        else -> "webmercator01.svg"
+    }
+
+    private var svg: SVG? = SVG.getFromAsset(ctx.assets, svgFile)
+
+    fun get(): SVG? {
+        return svg
+    }
+}

app/src/main/res/drawable/about.xml

@@ -0,0 +1,13 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+android:width="24dp"
+android:height="24dp"
+android:viewportWidth="960"
+android:viewportHeight="960">
+<path
+    android:fillColor="?attr/colorOnBackground"
+    android:pathData="M80,160Q80,127 103.5,103.5Q127,80 160,80L800,80Q833,80 856.5,103.5Q880,127 880,160L880,640Q880,673 856.5,696.5Q833,720 800,720L240,720L80,880ZM206,640L800,640Q800,640 800,640Q800,640 800,640L800,160Q800,160 800,160Q800,160 800,160L160,160Q160,160 160,160Q160,160 160,160L160,685L206,640ZM160,640L160,640L160,160Q160,160 160,160Q160,160 160,160L160,160Q160,160 160,160Q160,160 160,160L160,640Q160,640 160,640Q160,640 160,640L160,640Z" />
+
+<path
+    android:fillColor="?attr/colorPrimary"
+    android:pathData="M480,280Q497,280 508.5,268.5Q520,257 520,240Q520,223 508.5,211.5Q497,200 480,200Q463,200 451.5,211.5Q440,223 440,240Q440,257 451.5,268.5Q463,280 480,280ZM440,600L520,600L520,360L440,360L440,600ZM80,880L80,160" />
+</vector>

app/src/main/res/drawable/add.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+android:width="24dp"
+android:height="24dp"
+android:viewportWidth="24"
+android:viewportHeight="24">
+<path
+    android:fillColor="?attr/colorOnBackground"
+    android:pathData="M19,13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z" />
+</vector>

app/src/main/res/drawable/color.xml

@@ -0,0 +1,10 @@
+<vector
+    android:height="24dp"
+    android:viewportHeight="960"
+    android:viewportWidth="960"
+    android:width="24dp"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+<path
+    android:fillColor="?attr/colorOnBackground"
+    android:pathData="M346,820L100,574Q90,564 85,552Q80,540 80,527Q80,514 85,502Q90,490 100,480L330,251L224,145L286,80L686,480Q696,490 700.5,502Q705,514 705,527Q705,540 700.5,552Q696,564 686,574L440,820Q430,830 418,835Q406,840 393,840Q380,840 368,835Q356,830 346,820ZM393,314L179,528Q179,528 179,528Q179,528 179,528L607,528Q607,528 607,528Q607,528 607,528L393,314ZM792,840Q756,840 731,814.5Q706,789 706,752Q706,725 719.5,701Q733,677 750,654L792,600L836,654Q852,677 866,701Q880,725 880,752Q880,789 854,814.5Q828,840 792,840Z"/>
+</vector>

app/src/main/res/drawable/delete.xml

@@ -0,0 +1,41 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="72dp"
+    android:height="72dp"
+    android:viewportWidth="72"
+    android:viewportHeight="72">
+  <path
+      android:pathData="M31,16l0,-4l10,0l0,4"
+      android:strokeLineJoin="round"
+      android:strokeWidth="4"
+      android:fillColor="#00000000"
+      android:strokeColor="?attr/colorOnBackground"
+      android:strokeLineCap="round"/>
+  <path
+      android:pathData="M51,25v31c0,2.209 -1.791,4 -4,4H25c-2.209,0 -4,-1.791 -4,-4V25"
+      android:strokeLineJoin="round"
+      android:strokeWidth="4"
+      android:fillColor="#00000000"
+      android:strokeColor="?attr/colorOnBackground"
+      android:strokeLineCap="round"/>
+  <path
+      android:pathData="M17,16h38v4h-38z"
+      android:strokeLineJoin="round"
+      android:strokeWidth="4"
+      android:fillColor="#00000000"
+      android:strokeColor="?attr/colorOnBackground"
+      android:strokeLineCap="round"/>
+  <path
+      android:pathData="M41,28.25L41,55"
+      android:strokeLineJoin="round"
+      android:strokeWidth="4"
+      android:fillColor="#00000000"
+      android:strokeColor="?attr/colorOnBackground"
+      android:strokeLineCap="round"/>
+  <path
+      android:pathData="M31,28.25L31,55"
+      android:strokeLineJoin="round"
+      android:strokeWidth="4"
+      android:fillColor="#00000000"
+      android:strokeColor="?attr/colorOnBackground"
+      android:strokeLineCap="round"/>
+</vector>

app/src/main/res/drawable/edit.xml

@@ -0,0 +1,10 @@
+<vector
+    android:height="24dp"
+    android:viewportHeight="24"
+    android:viewportWidth="24"
+    android:width="24dp"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+    <path
+        android:fillColor="?attr/colorOnBackground"
+        android:pathData="M3,17.25V21h3.75L17.81,9.94l-3.75,-3.75L3,17.25zM20.71,7.04c0.39,-0.39 0.39,-1.02 0,-1.41l-2.34,-2.34c-0.39,-0.39 -1.02,-0.39 -1.41,0l-1.83,1.83 3.75,3.75 1.83,-1.83z"/>
+</vector>

app/src/main/res/drawable/group.xml

@@ -0,0 +1,16 @@
+<vector
+android:height="24dp"
+android:viewportHeight="24"
+android:viewportWidth="24"
+android:width="24dp"
+xmlns:android="http://schemas.android.com/apk/res/android" >
+
+<path android:fillColor="?attr/colorOnBackground" android:pathData="M12,2C6.48,2 2,6.48 2,12s4.48,10 10,10 10,-4.48 10,-10S17.52,2 12,2zM12,20c-4.41,0 -8,-3.59 -8,-8s3.59,-8 8,-8 8,3.59 8,8 -3.59,8 -8,8z"/>
+
+<path android:fillColor="?attr/colorPrimary" android:pathData="M8,14m-2,0a2,2 0,1 1,4 0a2,2 0,1 1,-4 0"/>
+
+<path android:fillColor="?attr/colorPrimary" android:pathData="M12,8m-2,0a2,2 0,1 1,4 0a2,2 0,1 1,-4 0"/>
+
+<path android:fillColor="?attr/colorPrimary" android:pathData="M16,14m-2,0a2,2 0,1 1,4 0a2,2 0,1 1,-4 0"/>
+
+</vector>

app/src/main/res/drawable/ic_launcher_monochrome.xml

@@ -1,35 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="128"
-    android:viewportHeight="128">
-    <group android:scaleX="0.8918919"
-        android:scaleY="0.8918919"
-        android:translateX="6.918919"
-        android:translateY="6.918919">
-        <group
-            android:scaleX="1.25"
-            android:scaleY="1.25"
-            android:translateX="18"
-            android:translateY="18">
-            <path
-                android:pathData="M56.803,45.75c0.599,-0.299 1.157,-0.672 1.663,-1.11 0.804,-0.698 1.463,-1.546 1.94,-2.497 0.599,-1.303 0.883,-2.728 0.829,-4.161 0.034,-1.498 -0.154,-2.994 -0.558,-4.437 -0.451,-1.645 -1.104,-3.229 -1.944,-4.714 -0.967,-2.141 -2.28,-4.108 -3.887,-5.822 -1.242,-1.326 -2.757,-2.366 -4.44,-3.048 -0.877,-0.372 -1.821,-0.56 -2.774,-0.553 -1.402,0.074 -2.729,0.697 -3.882,1.389 -1.285,0.81 -2.244,1.735 -2.771,3.053 -0.739,2.362 0.827,4.821 1.113,5.269 0.003,0.005 0.187,0.281 0.555,0.832 1.512,2.264 1.589,2.358 1.666,2.495 0.646,1.221 1.114,2.528 1.389,3.882 1.043,4.001 1.565,6.001 2.223,6.932 1.208,1.71 3.455,3.414 5.826,3.325 1.059,-0.088 2.093,-0.371 3.05,-0.835Z"
-                android:strokeWidth="2"
-                android:fillColor="@color/white"
-                android:strokeColor="#000000"
-                android:strokeLineCap="round"/>
-            <path
-                android:pathData="M22,41c-1.54,0.554 -2.83,1.642 -3.636,3.066 -0.714,1.365 -0.957,2.928 -0.693,4.445 0.178,1.247 0.632,2.439 1.329,3.488 2.032,3.228 5.383,4.423 7,5 1.613,0.561 3.295,0.897 5,1 2.387,0.205 6.923,0.535 11,-2 1.287,-0.665 2.335,-1.713 3,-3 0.661,-1.601 0.661,-3.399 0,-5 -0.389,-1.156 -1.121,-2.165 -2.099,-2.894 -0.919,-0.599 -1.974,-0.956 -3.069,-1.039 -2.057,-0.313 -2.756,0.139 -5.014,0.057 -1.271,-0.019 -2.534,-0.214 -3.753,-0.577 -3.036,-0.95 -3.33,-2.457 -5.889,-2.829 -1.066,-0.158 -2.155,-0.061 -3.177,0.282Z"
-                android:strokeWidth="2"
-                android:fillColor="@color/white"
-                android:strokeColor="#000000"
-                android:strokeLineCap="round"/>
-            <path
-                android:pathData="M12.7,26.975c1.758,-3.604 5.311,-3.191 9.58,-7.091 2.701,-2.469 2.858,-4.078 5.613,-5.202 1.407,-0.644 2.984,-0.819 4.498,-0.5 2.053,0.475 3.761,1.891 4.61,3.819 1.116,2.742 -0.314,5.437 -1.398,7.482 -0.951,1.689 -2.167,3.215 -3.602,4.518 -1.479,1.552 -3.161,2.898 -5,4 -2.629,1.541 -6.332,3.711 -9.989,2.43 -1.481,-0.548 -2.768,-1.521 -3.699,-2.796 -1.496,-1.906 -1.735,-4.512 -0.612,-6.659Z"
-                android:strokeWidth="2"
-                android:fillColor="@color/white"
-                android:strokeColor="#000000"
-                android:strokeLineCap="round"/>
-        </group>
-    </group>
-</vector>

app/src/main/res/drawable/licenses.xml

@@ -0,0 +1,18 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+android:width="24dp"
+android:height="24dp"
+android:viewportWidth="24.0"
+android:viewportHeight="24.0">
+
+<path
+    android:fillColor="?attr/colorOnBackground"
+    android:pathData="M22,7h-9v2h9V7zM22,15h-9v2h9V15z"/>
+
+<path
+    android:fillColor="?attr/colorPrimary"
+    android:pathData="M5.54,11L2,7.46l1.41,-1.41l2.12,2.12l4.24,-4.24l1.41,1.41L5.54,11z"/>
+
+<path
+    android:fillColor="?attr/colorPrimary"
+    android:pathData="M5.54,19L2,15.46l1.41,-1.41l2.12,2.12l4.24,-4.24l1.41,1.41L5.54,19z"/>
+</vector>

app/src/main/res/drawable/map.xml

@@ -0,0 +1,16 @@
+<vector
+    android:height="24dp"
+    android:viewportHeight="24"
+    android:viewportWidth="24"
+    android:width="24dp"
+    xmlns:android="http://schemas.android.com/apk/res/android" >
+
+    <path
+        android:fillColor="?attr/colorOnBackground"
+        android:pathData="M20.5,3l-0.16,0.03L15,5.1 9,3 3.36,4.9c-0.21,0.07 -0.36,0.25 -0.36,0.48L3,20.5c0,0.28 0.22,0.5 0.5,0.5l0.16,-0.03L9,18.9l6,2.1 5.64,-1.9c0.21,-0.07 0.36,-0.25 0.36,-0.48L21,3.5c0,-0.28 -0.22,-0.5 -0.5,-0.5zM10,5.47l4,1.4v11.66l-4,-1.4L10,5.47zM5,6.46l3,-1.01v11.7l-3,1.16L5,6.46zM19,17.54l-3,1.01L16,6.86l3,-1.16v11.84z" />
+
+    <path
+        android:fillColor="?attr/colorPrimary"
+        android:pathData="M15,18.89l-6,-2.11L9,5.11l6,2.11v11.67z"/>
+
+</vector>

app/src/main/res/drawable/palette.xml

@@ -0,0 +1,14 @@
+<vector
+    android:height="24dp"
+    android:viewportHeight="24"
+    android:viewportWidth="24"
+    android:width="24dp"
+    xmlns:android="http://schemas.android.com/apk/res/android" >
+
+    <path
+        android:fillColor="?attr/colorOnBackground"
+        android:pathData="M12,22C6.49,22 2,17.51 2,12S6.49,2 12,2s10,4.04 10,9c0,3.31 -2.69,6 -6,6h-1.77c-0.28,0 -0.5,0.22 -0.5,0.5c0,0.12 0.05,0.23 0.13,0.33c0.41,0.47 0.64,1.06 0.64,1.67C14.5,20.88 13.38,22 12,22zM12,4c-4.41,0 -8,3.59 -8,8s3.59,8 8,8c0.28,0 0.5,-0.22 0.5,-0.5c0,-0.16 -0.08,-0.28 -0.14,-0.35c-0.41,-0.46 -0.63,-1.05 -0.63,-1.65c0,-1.38 1.12,-2.5 2.5,-2.5H16c2.21,0 4,-1.79 4,-4C20,7.14 16.41,4 12,4z" />
+    <path
+        android:fillColor="?attr/colorPrimary"
+        android:pathData="M17.5,13c-0.83,0 -1.5,-0.67 -1.5,-1.5c0,-0.83 0.67,-1.5 1.5,-1.5s1.5,0.67 1.5,1.5C19,12.33 18.33,13 17.5,13zM14.5,9C13.67,9 13,8.33 13,7.5C13,6.67 13.67,6 14.5,6S16,6.67 16,7.5C16,8.33 15.33,9 14.5,9zM5,11.5C5,10.67 5.67,10 6.5,10S8,10.67 8,11.5C8,12.33 7.33,13 6.5,13S5,12.33 5,11.5zM11,7.5C11,8.33 10.33,9 9.5,9S8,8.33 8,7.5C8,6.67 8.67,6 9.5,6S11,6.67 11,7.5z" />
+</vector>

app/src/main/res/drawable/stats.xml

@@ -0,0 +1,14 @@
+<vector
+android:height="24dp"
+android:viewportHeight="960"
+android:viewportWidth="960"
+android:width="24dp"
+xmlns:android="http://schemas.android.com/apk/res/android" >
+
+<path
+    android:fillColor="?attr/colorOnBackground"
+    android:pathData="M105,727L40,680L240,360L360,500L520,240L629,403Q606,404 585.5,408.5Q565,413 545,421L523,388L371,635L250,494L105,727ZM732,423Q713,415 692.5,410Q672,405 650,404L855,80L920,127L732,423Z" />
+<path
+    android:fillColor="?attr/colorPrimary"
+    android:pathData="M863,920L738,795Q718,809 693.5,816Q669,823 643,823Q568,823 515.5,770.5Q463,718 463,643Q463,568 515.5,515.5Q568,463 643,463Q718,463 770.5,515.5Q823,568 823,643Q823,669 816,693.5Q809,718 795,739L920,863L863,920ZM643,743Q685,743 714,714Q743,685 743,643Q743,601 714,572Q685,543 643,543Q601,543 572,572Q543,601 543,643Q543,685 572,714Q601,743 643,743Z" />
+</vector>

app/src/main/res/drawable/zoomin.xml

@@ -0,0 +1,12 @@
+<vector
+android:height="24dp"
+android:viewportHeight="24"
+android:viewportWidth="24"
+android:width="24dp"
+xmlns:android="http://schemas.android.com/apk/res/android" >
+
+<path android:fillColor="?attr/colorOnBackground" android:pathData="M15.5,14h-0.79l-0.28,-0.27C15.41,12.59 16,11.11 16,9.5 16,5.91 13.09,3 9.5,3S3,5.91 3,9.5 5.91,16 9.5,16c1.61,0 3.09,-0.59 4.23,-1.57l0.27,0.28v0.79l5,4.99L20.49,19l-4.99,-5zM9.5,14C7.01,14 5,11.99 5,9.5S7.01,5 9.5,5 14,7.01 14,9.5 11.99,14 9.5,14z"/>
+
+<path android:fillColor="?attr/colorPrimary" android:pathData="M12,10h-2v2H9v-2H7V9h2V7h1v2h2v1z"/>
+
+</vector>

app/src/main/res/layout/activity_edit.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    android:theme="@style/Theme.Beans"
+    tools:context=".activity.EditActivity">
+
+    <com.google.android.material.tabs.TabLayout
+        android:id="@+id/tab"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+    <androidx.viewpager2.widget.ViewPager2
+        android:id="@+id/pager"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1" />
+
+</LinearLayout>

app/src/main/res/layout/activity_main.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    android:theme="@style/Theme.Beans"
+    tools:context=".activity.MainActivity">
+    
+    <com.github.chrisbanes.photoview.PhotoView
+        android:id="@+id/photo_view"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+</LinearLayout>

app/src/main/res/layout/activity_settings.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:orientation="vertical"
+    android:theme="@style/Theme.Beans"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".activity.SettingsActivity">
+
+<androidx.fragment.app.FragmentContainerView
+    android:id="@+id/fragment_view"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" />
+
+</LinearLayout>

app/src/main/res/layout/activity_stat.xml

@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    android:theme="@style/Theme.Beans"
+    tools:context=".activity.StatsActivity">
+
+    <com.google.android.material.tabs.TabLayout
+        android:id="@+id/tab"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+    <androidx.viewpager2.widget.ViewPager2
+        android:id="@+id/pager"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1"
+        android:visibility="gone" />
+
+    <androidx.constraintlayout.widget.ConstraintLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:paddingBottom="10dp">
+
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/group_color"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="2dp"
+            android:layout_marginBottom="2dp"
+            android:paddingStart="56dp"
+            android:text="@string/total"
+            android:textAlignment="textStart"
+            android:textColor="?attr/colorOnPrimary"
+            app:cornerRadius="0dp"
+            app:layout_constraintBottom_toBottomOf="parent"
+            app:layout_constraintEnd_toEndOf="parent"
+            app:layout_constraintStart_toStartOf="parent"
+            app:layout_constraintTop_toTopOf="parent"
+            tools:ignore="RtlSymmetry" />
+
+        <com.google.android.material.textview.MaterialTextView
+            android:id="@+id/name"
+            android:layout_width="wrap_content"
+            android:layout_height="50dp"
+            android:gravity="start|center_vertical"
+            android:paddingStart="20dp"
+            android:paddingEnd="52dp"
+            android:text=""
+            android:textColor="?attr/colorOnPrimary"
+            app:layout_constraintBottom_toBottomOf="@id/group_color"
+            app:layout_constraintEnd_toEndOf="@id/group_color"
+            app:layout_constraintTop_toTopOf="@id/group_color" />
+
+    </androidx.constraintlayout.widget.ConstraintLayout>
+
+
+    <androidx.recyclerview.widget.RecyclerView
+        android:id="@+id/stats"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+</LinearLayout>

app/src/main/res/layout/fragment_about.xml

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".activity.fragment.AboutFragment">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:gravity="center_horizontal"
+        android:orientation="vertical">
+
+        <com.google.android.material.imageview.ShapeableImageView
+            android:layout_width="300dp"
+            android:layout_height="300dp"
+            android:layout_marginTop="20dp"
+            android:contentDescription="@string/logo"
+            android:src="@drawable/ic_launcher_foreground" />
+
+        <com.google.android.material.textview.MaterialTextView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="10dp"
+            android:layout_marginTop="15dp"
+            android:layout_marginEnd="10dp"
+            android:layout_marginBottom="10dp"
+            android:text="@string/app_name"
+            android:textAlignment="center"
+            android:textSize="30sp"
+            android:textStyle="bold" />
+
+        <com.google.android.material.textview.MaterialTextView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="10dp"
+            android:layout_marginTop="0dp"
+            android:layout_marginEnd="10dp"
+            android:layout_marginBottom="15dp"
+            android:text="@string/app_version"
+            android:textAlignment="center"
+            android:textSize="25sp" />
+
+        <com.google.android.material.textview.MaterialTextView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="10dp"
+            android:layout_marginTop="15dp"
+            android:layout_marginEnd="10dp"
+            android:layout_marginBottom="15dp"
+            android:text="@string/beans_is_foss"
+            android:textAlignment="center" />
+
+        <com.google.android.material.textview.MaterialTextView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="10dp"
+            android:layout_marginTop="15dp"
+            android:layout_marginEnd="10dp"
+            android:layout_marginBottom="15dp"
+            android:autoLink="web"
+            android:text="@string/beans_repo"
+            android:textAlignment="center" />
+
+    </LinearLayout>
+
+</androidx.constraintlayout.widget.ConstraintLayout>

app/src/main/res/layout/fragment_edit_groups_add.xml

@@ -0,0 +1,137 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="16dp"
+    tools:context=".activity.fragment.EditGroupAddFragment">
+
+
+    <com.google.android.material.textfield.TextInputEditText
+        android:id="@+id/group_name"
+        android:layout_width="match_parent"
+        android:layout_height="48dp"
+        android:autofillHints=""
+        android:hint="@string/name"
+        android:inputType="text" />
+
+    <androidx.constraintlayout.widget.ConstraintLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent">
+
+        <View
+            android:id="@+id/colorView"
+            android:layout_width="0dp"
+            android:layout_height="0dp"
+            android:background="@color/black"
+            app:layout_constraintBottom_toBottomOf="parent"
+            app:layout_constraintEnd_toStartOf="@+id/colorR"
+            app:layout_constraintStart_toStartOf="parent"
+            app:layout_constraintTop_toTopOf="parent" />
+
+
+        <com.google.android.material.slider.Slider
+            android:id="@+id/colorR"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            app:layout_constraintBottom_toTopOf="@id/colorG"
+            app:layout_constraintEnd_toEndOf="parent"
+            app:layout_constraintStart_toEndOf="@id/colorView"
+            app:layout_constraintTop_toTopOf="parent"
+            app:thumbColor="@color/red"
+            app:trackColorActive="@color/red" />
+
+        <com.google.android.material.slider.Slider
+            android:id="@+id/colorG"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:foregroundTint="#FF0000"
+            app:layout_constraintBottom_toTopOf="@id/colorB"
+            app:layout_constraintEnd_toEndOf="parent"
+            app:layout_constraintStart_toEndOf="@id/colorView"
+            app:layout_constraintTop_toBottomOf="@id/colorR"
+            app:thumbColor="@color/green"
+            app:trackColorActive="@color/green" />
+
+        <com.google.android.material.slider.Slider
+            android:id="@+id/colorB"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            app:layout_constraintBottom_toBottomOf="parent"
+            app:layout_constraintEnd_toEndOf="parent"
+            app:layout_constraintStart_toEndOf="@id/colorView"
+            app:layout_constraintTop_toBottomOf="@id/colorG"
+            app:thumbColor="@color/blue"
+            app:trackColorActive="@color/blue" />
+
+    </androidx.constraintlayout.widget.ConstraintLayout>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent">
+
+        <com.google.android.material.textview.MaterialTextView
+            android:id="@+id/textView"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:labelFor="@id/group_color"
+            android:text="@string/hashtag" />
+
+        <com.google.android.material.textfield.TextInputEditText
+            android:id="@+id/group_color"
+            android:layout_width="wrap_content"
+            android:layout_height="48dp"
+            android:autofillHints=""
+            android:hint="@string/color_rrggbb"
+            android:inputType="text"
+            android:maxLength="6" />
+    </LinearLayout>
+
+    <androidx.constraintlayout.widget.ConstraintLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:layout_marginTop="10dp">
+
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/btnDelete"
+            android:layout_width="52dp"
+            android:layout_height="wrap_content"
+            android:paddingLeft="6dp"
+            android:paddingRight="6dp"
+            android:tooltipText="@string/delete"
+            app:icon="@drawable/delete"
+            app:iconGravity="textStart"
+            app:iconPadding="0dp"
+            app:layout_constraintBottom_toBottomOf="parent"
+            app:layout_constraintStart_toStartOf="parent"
+            app:layout_constraintTop_toTopOf="parent" />
+
+
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/btnCancel"
+            android:layout_width="80dp"
+            android:layout_height="wrap_content"
+            android:layout_marginEnd="6dp"
+            android:paddingLeft="6dp"
+            android:paddingRight="6dp"
+            android:text="@string/cancel"
+            app:layout_constraintBottom_toBottomOf="parent"
+            app:layout_constraintEnd_toStartOf="@+id/btnOk"
+            app:layout_constraintTop_toTopOf="parent" />
+
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/btnOk"
+            android:layout_width="52dp"
+            android:layout_height="wrap_content"
+            android:paddingLeft="6dp"
+            android:paddingRight="6dp"
+            android:text="@string/ok"
+            app:layout_constraintBottom_toBottomOf="parent"
+            app:layout_constraintEnd_toEndOf="parent"
+            app:layout_constraintTop_toTopOf="parent" />
+
+    </androidx.constraintlayout.widget.ConstraintLayout>
+
+</LinearLayout>

app/src/main/res/layout/fragment_edit_places.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".activity.fragment.EditPlaceFragment">
+
+
+    <androidx.core.widget.NestedScrollView
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:scrollbars="vertical"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent">
+
+        <androidx.recyclerview.widget.RecyclerView
+            android:id="@+id/list"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:nestedScrollingEnabled="false"
+            android:scrollbars="vertical" />
+    </androidx.core.widget.NestedScrollView>
+</androidx.constraintlayout.widget.ConstraintLayout>

app/src/main/res/layout/fragment_edit_places_colors.xml

@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="16dp">
+
+    <TextView
+        android:id="@+id/warning_text"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginBottom="10dp" />
+
+    <ScrollView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:padding="4dp">
+
+        <androidx.recyclerview.widget.RecyclerView
+            android:id="@+id/groups_color"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content" />
+    </ScrollView>
+
+
+    <androidx.constraintlayout.widget.ConstraintLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="10dp">
+
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/btnAdd"
+            android:layout_width="64dp"
+            android:layout_height="wrap_content"
+            android:paddingLeft="6dp"
+            android:paddingRight="6dp"
+            android:text="@string/add"
+            app:layout_constraintBottom_toBottomOf="parent"
+            app:layout_constraintStart_toStartOf="parent"
+            app:layout_constraintTop_toTopOf="parent" />
+
+
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/btnClear"
+            android:layout_width="64dp"
+            android:layout_height="wrap_content"
+            android:paddingLeft="6dp"
+            android:paddingRight="6dp"
+            android:text="@string/clear"
+            app:layout_constraintBottom_toBottomOf="parent"
+            app:layout_constraintEnd_toEndOf="parent"
+            app:layout_constraintTop_toTopOf="parent" />
+
+    </androidx.constraintlayout.widget.ConstraintLayout>
+
+</LinearLayout>
+

app/src/main/res/layout/fragment_license.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".activity.fragment.LicenseFragment">
+
+    <androidx.fragment.app.FragmentContainerView
+        android:id="@+id/license_fragment_view"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+
+</androidx.constraintlayout.widget.ConstraintLayout>

app/src/main/res/layout/item_list_geoloc.xml

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content">
+
+    <com.google.android.material.button.MaterialButton
+        android:id="@+id/textView"
+        android:layout_width="0dp"
+        android:layout_height="50dp"
+        android:clickable="true"
+        android:focusable="true"
+        android:gravity="start|center_vertical"
+        android:insetTop="4dp"
+        android:insetBottom="4dp"
+        android:paddingStart="20dp"
+        android:paddingEnd="20dp"
+        android:textAllCaps="false"
+        android:textAppearance="?attr/textAppearanceBody2"
+        android:textColor="?attr/colorOnBackground"
+
+        app:cornerRadius="4dp"
+        app:layout_constraintBottom_toBottomOf="@id/checkBox"
+        app:layout_constraintEnd_toStartOf="@id/checkBox"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+
+    <com.google.android.material.textview.MaterialTextView
+        android:id="@+id/count"
+        android:layout_width="wrap_content"
+        android:layout_height="50dp"
+        android:gravity="start|center_vertical"
+        android:paddingStart="20dp"
+        android:paddingEnd="20dp"
+        app:layout_constraintBottom_toBottomOf="@id/checkBox"
+        app:layout_constraintEnd_toStartOf="@id/checkBox"
+        app:layout_constraintTop_toTopOf="parent" />
+
+    <com.google.android.material.checkbox.MaterialCheckBox
+        android:id="@+id/checkBox"
+        android:layout_width="50dp"
+        android:layout_height="50dp"
+        app:checkedState="indeterminate"
+        app:layout_constraintBottom_toBottomOf="@id/textView"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintHorizontal_bias="1"
+        app:layout_constraintStart_toEndOf="@id/textView"
+        app:layout_constraintTop_toTopOf="@id/textView"
+        app:layout_constraintVertical_bias="0.5" />
+
+</androidx.constraintlayout.widget.ConstraintLayout>

app/src/main/res/layout/item_list_group.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content">
+
+    <com.google.android.material.button.MaterialButton
+        android:id="@+id/group_color"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_marginStart="32dp"
+        android:layout_marginTop="2dp"
+        android:layout_marginEnd="32dp"
+        android:layout_marginBottom="2dp"
+        android:textAlignment="textStart"
+        android:textColor="?attr/colorOnPrimary"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+
+    <com.google.android.material.textview.MaterialTextView
+        android:id="@+id/name"
+        android:layout_width="wrap_content"
+        android:layout_height="50dp"
+        android:gravity="start|center_vertical"
+        android:paddingStart="20dp"
+        android:paddingEnd="20dp"
+        android:textColor="?attr/colorOnPrimary"
+        app:layout_constraintBottom_toBottomOf="@id/group_color"
+        app:layout_constraintEnd_toEndOf="@id/group_color"
+        app:layout_constraintTop_toTopOf="@id/group_color" />
+
+</androidx.constraintlayout.widget.ConstraintLayout>

app/src/main/res/menu/menu_edit.xml

@@ -0,0 +1,13 @@
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    tools:context="net.helcel.beans.activity.EditActivity" >
+
+    <item
+        android:id="@+id/action_color"
+        android:orderInCategory="100"
+        android:icon="@drawable/color"
+        android:title="@string/action_color"
+        app:showAsAction="ifRoom" />
+
+</menu>

app/src/main/res/menu/menu_main.xml

@@ -0,0 +1,25 @@
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    tools:context="net.helcel.beans.activity.MainActivity" >
+
+    <item
+        android:id="@+id/action_edit"
+        android:orderInCategory="100"
+        android:icon="@drawable/edit"
+        android:title="@string/action_edit"
+        app:showAsAction="ifRoom" />
+    <item
+        android:id="@+id/action_stats"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orderInCategory="100"
+        android:title="@string/action_stat"
+        app:showAsAction="never" />
+    <item
+        android:id="@+id/action_settings"
+        android:orderInCategory="100"
+        android:title="@string/action_settings"
+        app:showAsAction="never" />
+
+</menu>

app/src/main/res/mipmap-anydpi/ic_launcher_round.xml

@@ -2,5 +2,4 @@
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
     <background android:drawable="@drawable/ic_launcher_background"/>
     <foreground android:drawable="@drawable/ic_launcher_foreground"/>
-    <monochrome android:drawable="@drawable/ic_launcher_monochrome"/>
 </adaptive-icon>

app/src/main/res/values-night/themes.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <style name="Theme.Beans" parent="android:Theme.Material.NoActionBar">
-        <!-- Status bar color in dark mode -->
-        <item name="android:statusBarColor">@color/blue</item>
-        <!-- Window background in dark mode -->
-        <item name="android:windowBackground">@color/darkgray</item>
-        <item name="android:windowLightStatusBar">false</item>
-        <item name="android:windowDrawsSystemBarBackgrounds">true</item>
-
-    </style>
-</resources>

app/src/main/res/values-v21/themes.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <style name="Theme.Beans" parent="android:Theme.Material.Light.NoActionBar">
-        <item name="android:statusBarColor">@color/blue</item>
-        <item name="android:windowBackground">@color/blue</item>
-    </style>
-</resources>