WIP

Clicking a parent path changes the root project directory.

.cargo/config.toml

@@ -1,3 +1,6 @@
-
 [build]
 rustflags = [ "-C", "link-arg=-fuse-ld=lld", ]
+
+[env]
+QMAKE="/opt/Qt/6.7.3/gcc_64/bin/qmake6"
+LD_LIBRARY_PATH="/opt/Qt/6.7.3/gcc_64/lib"

.qmllint.ini

@@ -0,0 +1,33 @@
+[General]
+DisableDefaultImports=false
+
+[Warnings]
+AccessSingletonViaObject=warning
+AttachedPropertyReuse=disable
+BadSignalHandlerParameters=warning
+CompilerWarnings=disable
+Deprecated=warning
+DuplicatePropertyBinding=warning
+DuplicatedName=warning
+ImportFailure=warning
+IncompatibleType=warning
+InheritanceCycle=warning
+InvalidLintDirective=warning
+LintPluginWarnings=disable
+MissingProperty=warning
+MissingType=warning
+MultilineStrings=info
+NonListProperty=warning
+PrefixedImportType=warning
+PropertyAliasCycles=warning
+ReadOnlyProperty=warning
+RequiredProperty=warning
+RestrictedType=warning
+TopLevelComponent=warning
+UncreatableType=warning
+UnqualifiedAccess=warning
+UnresolvedType=warning
+UnusedImports=info
+UseProperFunction=warning
+VarUsedBeforeDeclaration=warning
+WithStatement=warning

Cargo.lock

@@ -295,6 +295,7 @@ dependencies = [
  "cxx-qt",
  "cxx-qt-build",
  "cxx-qt-lib",
+ "devicons",
  "dirs",
  "edtui",
  "log",
@@ -303,6 +304,7 @@ dependencies = [
  "syntect",
  "tui-logger",
  "tui-tree-widget",
+ "uuid",
 ]
 
 [[package]]
@@ -666,6 +668,15 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "devicons"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830e47e2f330cf4fdd5a958dcef921b9523ffc21ab6713aa5e77ba2cce03904b"
+dependencies = [
+ "lazy_static",
+]
+
 [[package]]
 name = "digest"
 version = "0.10.7"

Cargo.toml

@@ -17,6 +17,8 @@ tui-tree-widget = "0.24.0"
 tui-logger = "0.18.1"
 edtui = "0.11.1"
 strum = "0.27.2"
+uuid = { version = "1.19.0", features = ["v4"] }
+devicons = "0.6.12"
 
 [build-dependencies]
 # The link_qt_object_files feature is required for statically linking Qt 6.

LICENSE

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

README.md

@@ -19,6 +19,31 @@ And of course, [Rust](https://www.rust-lang.org/tools/install).
 curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 ```
 
+This project requires at least Qt 6.7.3 To check your Qt version
+
+```bash
+qmake6 -query QT_VERSION
+```
+
+Use the [Qt Installer](https://www.qt.io/development/download) to download and install the Qt version of your choice.
+If the installer is run with `sudo`, the default install location is `/opt/Qt`, otherwise Qt will be installed into your home directory.
+
+**You must set the QMAKE variable before building clide**. This should be a path to `qmake6` binary installed on your system.
+The following export is the default installation path for Qt 6.7 on Ubuntu 24.04
+
+```bash
+export QMAKE=$HOME/Qt/6.7.3/gcc_64/bin/qmake6
+export LD_LIBRARY_PATH=$HOME/Qt/6.7.3/gcc_64/lib
+```
+
+Though environment variables set using `export` will take precedence, these can also be set in [.cargo/config.toml](./.cargo/config.toml) for conveinence
+
+```toml
+[env]
+QMAKE="/opt/Qt/6.7.3/gcc_64/bin/qmake6"
+LD_LIBRARY_PATH="/opt/Qt/6.7.3/gcc_64/lib"
+```
+
 ## Usage 
 
 To install and run clide
@@ -29,7 +54,8 @@ cd clide
 cargo install --path .
 ```
 
-After installation `clide` can be used directly
+After installation `clide` can be used directly.
+A path can optionally be provided to open a specific directory with `clide /path/to/project`.
 
 ```bash
 clide --help
@@ -125,6 +151,7 @@ Some helpful links for reading up on QML if you're just getting started.
 * [All QML Controls Types](https://doc.qt.io/qt-6/qtquick-controls-qmlmodule.html)
 * [KDAB CXX-Qt Book](https://kdab.github.io/cxx-qt/book/)
 * [github.com/KDAB/cxx-qt](https://github.com/KDAB/cxx-qt)
+* [QML and C++ Intergration](https://doc.qt.io/qt-6/qtqml-cppintegration-overview.html)
 
 
 ### Plugins

build.rs

@@ -7,7 +7,15 @@ fn main() {
         "qml/ClideTreeView.qml",
         "qml/ClideProjectView.qml",
         "qml/ClideEditor.qml",
+        "qml/ClideEditorView.qml",
         "qml/ClideMenuBar.qml",
+        "qml/ClideLogger.qml",
+        "qml/Components/ClideScrollBar.qml",
+        "qml/Components/ClideHandle.qml",
+        "qml/Components/ClideMenu.qml",
+        "qml/Components/ClideMenuItem.qml",
+        "qml/Components/ClideBreadCrumbs.qml",
+        "qml/Logger/Logger.qml",
     ]))
     // Link Qt's Network library
     // - Qt Core is always linked
@@ -18,6 +26,7 @@ fn main() {
     .qt_module("Gui")
     .qt_module("Svg")
     .qt_module("Xml")
+    .qrc("./resources.qrc")
     .files(["src/gui/colors.rs", "src/gui/filesystem.rs"])
     .build();
 }

qml/ClideAboutWindow.qml

@@ -1,21 +1,27 @@
-// TODO: Header
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
 
 import QtQuick
 import QtQuick.Controls.Basic
 
 import clide.module 1.0
+import Logger 1.0
 
 ApplicationWindow {
     id: root
-    width: 450
+
-    height: 350
-    // Create the window with no frame and keep it on top.
-    flags: Qt.Window | Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint
     color: RustColors.gutter
+    // Create the window with no frame and keep it on top.
+    flags: Qt.Tool | Qt.FramelessWindowHint
+    height: 350
+    width: 450
+    visible: root.active
 
     // Hide the window when it loses focus.
     onActiveChanged: {
-        if (!active) {
+        Logger.debug("Setting active: " + root.active)
+        if (!root.active) {
             root.visible = false;
         }
     }
@@ -25,48 +31,38 @@ ApplicationWindow {
         id: logo
 
         anchors.left: parent.left
+        anchors.margins: 20
         anchors.right: parent.right
         anchors.top: parent.top
-        anchors.margins: 20
-
-        source: "../icons/kilroy-256.png"
-        sourceSize.width: 80
-        sourceSize.height: 80
-        fillMode: Image.PreserveAspectFit
-
-        smooth: true
         antialiasing: true
         asynchronous: true
+        fillMode: Image.PreserveAspectFit
+        smooth: true
+        source: "qrc:/images/kilroy.png"
+        sourceSize.height: 80
+        sourceSize.width: 80
     }
-
     ScrollView {
-        anchors.top: logo.bottom
-        anchors.left: parent.left
-        anchors.right: parent.right
         anchors.bottom: parent.bottom
+        anchors.left: parent.left
         anchors.margins: 20
+        anchors.right: parent.right
+        anchors.top: logo.bottom
 
         TextArea {
-            selectedTextColor: RustColors.editor_highlighted_text
-            selectionColor: RustColors.editor_highlight
-            horizontalAlignment: Text.AlignHCenter
-            textFormat: Text.RichText
-
-            text: qsTr("<h3>About CLIDE</h3>"
-                + "<p>A simple text editor written in Rust and QML using CXX-Qt.</p>"
-                + "<p>Personal website <a href=\"http://shaunreed.com\">shaunreed.com</a></p>"
-                + "<p>Project notes <a href=\"http://knoats.com\">knoats.com</a></p>"
-                + "<p>This project is developed at <a href=\"http://git.shaunreed.com/shaunrd0/clide\">git.shaunreed.com</a></p>"
-                + "<p><a href=\"https://github.com/KDAB/cxx-qt\">KDAB CXX-Qt repository</a></p>"
-                + "<p>Copyright (C) 2025 Shaun Reed, all rights reserved.</p>")
-            color: RustColors.editor_text
-            wrapMode: Text.WordWrap
-            readOnly: true
             antialiasing: true
             background: null
+            color: RustColors.editor_text
+            horizontalAlignment: Text.AlignHCenter
+            readOnly: true
+            selectedTextColor: RustColors.editor_highlighted_text
+            selectionColor: RustColors.editor_highlight
+            text: qsTr("<h3>About CLIDE</h3>" + "<p>A simple text editor written in Rust and QML using CXX-Qt.</p>" + "<p>Personal website <a href=\"http://shaunreed.com\">shaunreed.com</a></p>" + "<p>Project notes <a href=\"http://knoats.com\">knoats.com</a></p>" + "<p>This project is developed at <a href=\"http://git.shaunreed.com/shaunrd0/clide\">git.shaunreed.com</a></p>" + "<p><a href=\"https://github.com/KDAB/cxx-qt\">KDAB CXX-Qt repository</a></p>" + "<p>Copyright (C) 2026 Shaun Reed, all rights reserved.</p>")
+            textFormat: Text.RichText
+            wrapMode: Text.WordWrap
 
             onLinkActivated: function (link) {
-                Qt.openUrlExternally(link)
+                Qt.openUrlExternally(link);
             }
         }
     }

qml/ClideEditor.qml

@@ -1,206 +1,136 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 import QtQuick
 import QtQuick.Controls
 import QtQuick.Layouts
 
 import clide.module 1.0
+import Logger 1.0
 
-SplitView {
+RowLayout {
-    id: root
+    // We use a flickable to synchronize the position of the editor and
-    Layout.fillHeight: true
+    // the line numbers. This is necessary because the line numbers can
-    Layout.fillWidth: true
+    // extend the available height.
-    orientation: Qt.Vertical
+    Flickable {
+        id: lineNumbers
 
-    // The path to the file to show in the text editor.
+        Layout.fillHeight: true
-    // This is updated by a signal caught within ClideProjectView.
+        Layout.fillWidth: false
-    // Initialized by the Default trait for the Rust QML singleton FileSystem.
+        // Calculating the width correctly is important as the number grows.
-    required property string filePath;
+        // We need to ensure space required to show N line number digits.
+        // We use log10 to find how many digits are needed in a line number.
+        // log10(9) ~= .95; log10(10) = 1.0; log10(100) = 2.0  ...etc
+        // We +1 to ensure space for at least 1 digit, as floor(1.95) = 1.
+        // The +10 is additional spacing and can be adjusted.
+        Layout.preferredWidth: fontMetrics.averageCharacterWidth * (Math.floor(Math.log10(textArea.lineCount)) + 1) + 10
+        contentY: editorFlickable.contentY
+        interactive: false
 
-    // Customized handle to drag between the Editor and the Console.
+        Column {
-    handle: Rectangle {
+            anchors.fill: parent
-        border.color: SplitHandle.pressed ? RustColors.pressed : SplitHandle.hovered ? RustColors.hovered : RustColors.gutter
+            topPadding: textArea.topPadding
-        color: SplitHandle.pressed ? RustColors.pressed : SplitHandle.hovered ? RustColors.hovered : RustColors.gutter
-        implicitHeight: 8
-        radius: 2.5
 
-        // Execute these behaviors when the color is changed.
+            Repeater {
-        Behavior on color {
+                id: repeatedLineNumbers
-            ColorAnimation {
-                duration: 400
-            }
-        }
-    }
-    RowLayout {
-        // We use a flickable to synchronize the position of the editor and
-        // the line numbers. This is necessary because the line numbers can
-        // extend the available height.
-        Flickable {
-            id: lineNumbers
-            Layout.fillHeight: true
-            Layout.fillWidth: false
-            // Calculating the width correctly is important as the number grows.
-            // We need to ensure space required to show N line number digits.
-            // We use log10 to find how many digits are needed in a line number.
-            // log10(9) ~= .95; log10(10) = 1.0; log10(100) = 2.0  ...etc
-            // We +1 to ensure space for at least 1 digit, as floor(1.95) = 1.
-            // The +10 is additional spacing and can be adjusted.
-            Layout.preferredWidth: fontMetrics.averageCharacterWidth * (Math.floor(Math.log10(textArea.lineCount)) + 1) + 10
-            contentY: editorFlickable.contentY
-            interactive: false
 
-            Column {
+                // TODO: Bug where text wrapping shows as new line number.
-                anchors.fill: parent
+                model: textArea.lineCount
-                topPadding: textArea.topPadding
 
-                Repeater {
+                // This Item is used for each line number in the gutter.
-                    id: repeatedLineNumbers
+                delegate: Item {
-                    // TODO: Bug where text wrapping shows as new line number.
+                    required property int index
-                    model: textArea.lineCount
 
-                    // This Item is used for each line number in the gutter.
+                    // Calculates the height of each line in the text area.
-                    delegate: Item {
+                    height: textArea.contentHeight / textArea.lineCount
-                        // Calculates the height of each line in the text area.
+                    width: parent.width
-                        height: textArea.contentHeight / textArea.lineCount
-                        width: parent.width
 
-                        required property int index
+                    // Show the line number.
+                    Label {
+                        id: numbers
 
-                        // Show the line number.
+                        color: RustColors.linenumber
-                        Label {
+                        font: textArea.font
-                            id: numbers
+                        height: parent.height
-                            color: RustColors.linenumber
+                        horizontalAlignment: Text.AlignLeft
-                            font: textArea.font
+                        text: parent.index + 1
-                            height: parent.height
+                        verticalAlignment: Text.AlignVCenter
-                            horizontalAlignment: Text.AlignLeft
+                        width: parent.width - indicator.width
-                            text: parent.index + 1
+
-                            verticalAlignment: Text.AlignVCenter
+                        background: Rectangle {
-                            width: parent.width - indicator.width
+                            color: RustColors.terminal_background
-                        }
-                        // Draw edge along the right side of the line number.
-                        Rectangle {
-                            id: indicator
-                            anchors.left: numbers.right
-                            color: RustColors.linenumber
-                            height: parent.height
-                            width: 1
                         }
                     }
+                    // Draw edge along the right side of the line number.
+                    Rectangle {
+                        id: indicator
+
+                        anchors.left: numbers.right
+                        color: RustColors.linenumber
+                        height: parent.height
+                        width: 1
+                    }
                 }
             }
         }
-        Flickable {
-            id: editorFlickable
-            Layout.fillHeight: true
-            Layout.fillWidth: true
-            boundsBehavior: Flickable.StopAtBounds
-            height: 650
-
-            ScrollBar.horizontal: MyScrollBar {
-            }
-            ScrollBar.vertical: MyScrollBar {
-            }
-
-            TextArea.flickable: TextArea {
-                id: textArea
-                focus: true
-                persistentSelection: true
-                antialiasing: true
-                selectByMouse: true
-                selectionColor: RustColors.editor_highlight
-                selectedTextColor: RustColors.editor_highlighted_text
-                textFormat: Qt.AutoText
-                wrapMode: TextArea.Wrap
-                text: FileSystem.readFile(root.filePath)
-
-                onLinkActivated: function (link) {
-                    Qt.openUrlExternally(link);
-                }
-
-                // TODO: Handle saving
-                // Component.onCompleted: {
-                //     if (Qt.application.arguments.length === 2)
-                //         textDocument.source = "file:" + Qt.application.arguments[1]
-                //     else
-                //         textDocument.source = "qrc:/texteditor.html"
-                // }
-                // textDocument.onStatusChanged: {
-                //     // a message lookup table using computed properties:
-                //     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer
-                //     const statusMessages = {
-                //         [ TextDocument.ReadError ]: qsTr("Failed to load “%1”"),
-                //         [ TextDocument.WriteError ]: qsTr("Failed to save “%1”"),
-                //         [ TextDocument.NonLocalFileError ]: qsTr("Not a local file: “%1”"),
-                //     }
-                //     const err = statusMessages[textDocument.status]
-                //     if (err) {
-                //         errorDialog.text = err.arg(textDocument.source)
-                //         errorDialog.open()
-                //     }
-                // }
-            }
-
-            FontMetrics {
-                id: fontMetrics
-
-                font: textArea.font
-            }
-        }
     }
-    TextArea {
+    Flickable {
-        id: areaConsole
+        id: editorFlickable
 
-        height: 100
+        Layout.fillHeight: true
-        placeholderText: qsTr("Placeholder for bash terminal.")
+        Layout.fillWidth: true
-        placeholderTextColor: "white"
+        boundsBehavior: Flickable.StopAtBounds
-        readOnly: true
+        height: 650
-        wrapMode: TextArea.Wrap
+
-        background: Rectangle {
+        ScrollBar.horizontal: ClideScrollBar {
-            color: RustColors.editor_background
-            implicitHeight: 100
-            // border.color: control.enabled ? RustColors.active : RustColors.inactive
         }
-    }
+        ScrollBar.vertical: ClideScrollBar {
+        }
+        TextArea.flickable: TextArea {
+            id: textArea
 
-    // We use an inline component to customize the horizontal and vertical
+            antialiasing: true
-    // scroll-bars. This is convenient when the component is only used in one file.
+            focus: true
-    component MyScrollBar: ScrollBar {
+            persistentSelection: true
-        id: scrollBar
+            selectByMouse: true
+            selectedTextColor: RustColors.editor_highlighted_text
+            selectionColor: RustColors.editor_highlight
+            text: FileSystem.readFile(root.filePath)
+            textFormat: Qt.AutoText
+            wrapMode: TextArea.Wrap
 
-        // Scroll bar gutter
+            onLinkActivated: function (link) {
-        background: Rectangle {
+                Qt.openUrlExternally(link);
-            implicitHeight: scrollBar.interactive ? 8 : 4
-            implicitWidth: scrollBar.interactive ? 8 : 4
-            color: RustColors.scrollbar_gutter
-
-            // Fade the scrollbar gutter when inactive.
-            opacity: scrollBar.active && scrollBar.size < 1.0 ? 1.0 : 0.2
-            Behavior on opacity {
-                OpacityAnimator {
-                    duration: 500
-                }
             }
+
+            // TODO: Handle saving
+            // Component.onCompleted: {
+            //     if (Qt.application.arguments.length === 2)
+            //         textDocument.source = "file:" + Qt.application.arguments[1]
+            //     else
+            //         textDocument.source = "qrc:/texteditor.html"
+            // }
+            // textDocument.onStatusChanged: {
+            //     // a message lookup table using computed properties:
+            //     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer
+            //     const statusMessages = {
+            //         [ TextDocument.ReadError ]: qsTr("Failed to load “%1”"),
+            //         [ TextDocument.WriteError ]: qsTr("Failed to save “%1”"),
+            //         [ TextDocument.NonLocalFileError ]: qsTr("Not a local file: “%1”"),
+            //     }
+            //     const err = statusMessages[textDocument.status]
+            //     if (err) {
+            //         errorDialog.text = err.arg(textDocument.source)
+            //         errorDialog.open()
+            //     }
+            // }
         }
 
-        // Scroll bar
+        FontMetrics {
-        contentItem: Rectangle {
+            id: fontMetrics
-            implicitHeight: scrollBar.interactive ? 8 : 4
-            implicitWidth: scrollBar.interactive ? 8 : 4
 
-            // If we don't need a scrollbar, fallback to the gutter color.
+            font: textArea.font
-            // If the scrollbar is required change it's color based on activity.
-            color: scrollBar.size < 1.0 ? scrollBar.active ? RustColors.scrollbar_active : RustColors.scrollbar : RustColors.scrollbar_gutter
-            // Smooth transition between color changes based on the state above.
-            Behavior on color {
-                ColorAnimation {
-                    duration: 1000
-                }
-            }
-            // Fade the scrollbar when inactive.
-            opacity: scrollBar.active && scrollBar.size < 1.0 ? 1.0 : 0.35
-            Behavior on opacity {
-                OpacityAnimator {
-                    duration: 500
-                }
-            }
         }
     }
 }

qml/ClideEditorView.qml

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Layouts
+
+import clide.module 1.0
+import Logger 1.0
+
+SplitView {
+    id: root
+
+    // The path to the file to show in the text editor.
+    // This is updated by a signal caught within ClideProjectView.
+    // Initialized by the Default trait for the Rust QML singleton FileSystem.
+    required property string filePath
+
+    Layout.fillHeight: true
+    Layout.fillWidth: true
+    orientation: Qt.Vertical
+
+    // Customized handle to drag between the Editor and the Console.
+    handle: ClideHandle {
+        pressed: SplitHandle.pressed
+        hovered: SplitHandle.hovered
+    }
+
+    Component.onCompleted: {
+        // Show logging is working.
+        Logger.info("Info logs");
+        Logger.warn("Warning logs");
+        Logger.debug("Debug logs");
+        Logger.error("Error logs");
+        Logger.trace("Trace logs");
+    }
+
+    ClideEditor{
+        id: clideEditor
+    }
+    ClideLogger {
+        id: areaConsole
+
+    }
+}

qml/ClideLogger.qml

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+import QtQuick
+import QtQuick.Controls
+
+import clide.module 1.0
+import Logger 1.0
+
+Item {
+    ListModel {
+        id: model
+
+    }
+    Rectangle {
+        anchors.fill: parent
+        color: "#111"
+    }
+    ListView {
+        id: listView
+
+        function getLogColor(level) {
+            switch (level) {
+            case "INFO":
+                return RustColors.info_log;
+            case "DEBUG":
+                return RustColors.debug_log;
+            case "WARN":
+                return RustColors.warn_log;
+            case "ERROR":
+                return RustColors.error_log;
+            case "TRACE":
+                return RustColors.trace_log;
+            default:
+                return RustColors.info_log;
+            }
+        }
+
+        anchors.fill: parent
+        clip: true
+        model: model
+
+        delegate: Text {
+            color: listView.getLogColor(level)
+            font.family: "monospace"
+            text: `[${level}] ${message}`
+        }
+
+        onCountChanged: Qt.callLater(positionViewAtEnd)
+    }
+    Connections {
+        function onLogged(level, message) {
+            model.append({
+                level,
+                message
+            });
+        }
+
+        target: Logger
+    }
+}

qml/ClideMenuBar.qml

@@ -1,157 +1,126 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 import QtQuick
 import QtQuick.Controls
 
 import clide.module 1.0
 
 MenuBar {
-    // Base settings for each Menu.
-    component ClideMenu : Menu {
-        background: Rectangle {
-            color: RustColors.menubar
-            implicitWidth: 100
-            radius: 2
-        }
-    }
-
-    // Base settings for each MenuItem.
-    component ClideMenuItem : MenuItem {
-        id: root
-
-        background: Rectangle {
-            color: root.hovered ? RustColors.hovered : RustColors.unhovered
-            radius: 2.5
-        }
-        contentItem: IconLabel {
-            color: "black"
-            font.family: "Helvetica"
-            text: root.text
-        }
-    }
-
     // Background for this MenuBar.
     background: Rectangle {
         color: RustColors.menubar
-        border.color: RustColors.menubar_border
+        radius: 20.0
     }
 
-
     //
     // File Menu
-    Action {
-        id: actionNewProject
-
-        text: qsTr("&New Project...")
-    }
-    Action {
-        id: actionOpen
-
-        text: qsTr("&Open...")
-    }
-    Action {
-        id: actionSave
-
-        text: qsTr("&Save")
-    }
-    Action {
-        id: actionExit
-
-        text: qsTr("&Exit")
-
-        onTriggered: Qt.quit()
-    }
     ClideMenu {
         title: qsTr("&File")
 
         ClideMenuItem {
-            action: actionNewProject
+            action: Action {
+                id: actionNewProject
+
+                text: qsTr("&New Project...")
+            }
         }
         ClideMenuItem {
-            action: actionOpen
+            action: Action {
+                id: actionOpen
+
+                text: qsTr("&Open...")
+            }
+
             onTriggered: FileSystem.setDirectory(FileSystem.filePath)
         }
         ClideMenuItem {
-            action: actionSave
+            action: Action {
+                id: actionSave
+
+                text: qsTr("&Save")
+            }
         }
         MenuSeparator {
             background: Rectangle {
                 border.color: color
-                color: RustColors.menubar_border
+                color: Qt.darker(RustColors.menubar, 1)
                 implicitHeight: 3
                 implicitWidth: 200
             }
         }
         ClideMenuItem {
-            action: actionExit
+            action: Action {
+                id: actionExit
+
+                text: qsTr("&Exit")
+
+                onTriggered: Qt.quit()
+            }
         }
     }
 
     //
     // Edit Menu
-    Action {
-        id: actionUndo
-
-        text: qsTr("&Undo")
-    }
-    Action {
-        id: actionRedo
-
-        text: qsTr("&Redo")
-    }
-    Action {
-        id: actionCut
-
-        text: qsTr("&Cut")
-    }
-    Action {
-        id: actionCopy
-
-        text: qsTr("&Copy")
-    }
-    Action {
-        id: actionPaste
-
-        text: qsTr("&Paste")
-    }
     ClideMenu {
         title: qsTr("&Edit")
 
         ClideMenuItem {
-            action: actionUndo
+            action: Action {
+                id: actionUndo
+
+                text: qsTr("&Undo")
+            }
         }
         ClideMenuItem {
-            action: actionRedo
+            action: Action {
+                id: actionRedo
+
+                text: qsTr("&Redo")
+            }
         }
         ClideMenuItem {
-            action: actionCut
+            action: Action {
+                id: actionCut
+
+                text: qsTr("&Cut")
+            }
         }
         ClideMenuItem {
-            action: actionCopy
+            action: Action {
+                id: actionCopy
+
+                text: qsTr("&Copy")
+            }
         }
         ClideMenuItem {
-            action: actionPaste
+            action: Action {
+                id: actionPaste
+
+                text: qsTr("&Paste")
+            }
         }
     }
 
     //
     // View Menu
-    Action {
-        id: actionToolWindows
-
-        text: qsTr("&Tool Windows")
-    }
-    Action {
-        id: actionAppearance
-
-        text: qsTr("&Appearance")
-    }
     ClideMenu {
         title: qsTr("&View")
 
         ClideMenuItem {
-            action: actionToolWindows
+            action: Action {
+                id: actionAppearance
+
+                text: qsTr("&Appearance")
+            }
         }
         ClideMenuItem {
-            action: actionAppearance
+            action: Action {
+                id: actionToolWindows
+
+                text: qsTr("&Tool Windows")
+            }
         }
     }
 
@@ -159,28 +128,27 @@ MenuBar {
     // Help Menu
     ClideAboutWindow {
         id: clideAbout
-    }
 
-    Action {
-        id: actionDocumentation
-
-        text: qsTr("&Documentation")
-    }
-    Action {
-        id: actionAbout
-        // Toggle the about window with the menu item is clicked.
-        onTriggered: clideAbout.visible = !clideAbout.visible
-
-        text: qsTr("&About")
     }
     ClideMenu {
         title: qsTr("&Help")
 
         ClideMenuItem {
-            action: actionDocumentation
+            action: Action {
+                id: actionDocumentation
+
+                text: qsTr("&Documentation")
+            }
         }
         ClideMenuItem {
-            action: actionAbout
+            action: Action {
+                id: actionAbout
+
+                text: qsTr("&About")
+
+                // Toggle the about window with the menu item is clicked.
+                onTriggered: clideAbout.visible = !clideAbout.visible
+            }
         }
     }
 }

qml/ClideProjectView.qml

@@ -1,14 +1,19 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 import QtQuick
 import QtQuick.Controls
 import QtQuick.Layouts
 
 import clide.module 1.0
+import Logger 1.0
 
 SplitView {
     id: root
 
-    // Path to the file selected in the tree view.
+    // Path to the directory of the project opened in clide.
-    default property string selectedFilePath: FileSystem.filePath;
+    required property string projectDir
 
     Layout.fillHeight: true
     Layout.fillWidth: true
@@ -17,6 +22,7 @@ SplitView {
     // Customized handle to drag between the Navigation and the Editor.
     handle: Rectangle {
         id: verticalSplitHandle
+
         border.color: SplitHandle.pressed ? RustColors.pressed : SplitHandle.hovered ? RustColors.hovered : RustColors.gutter
         color: SplitHandle.pressed ? RustColors.pressed : SplitHandle.hovered ? RustColors.hovered : RustColors.gutter
         implicitWidth: 8
@@ -32,24 +38,55 @@ SplitView {
 
     Rectangle {
         id: navigationView
-        color: RustColors.explorer_background
 
         SplitView.fillHeight: true
+        SplitView.maximumWidth: 250
         SplitView.minimumWidth: 0
         SplitView.preferredWidth: 200
-        SplitView.maximumWidth: 250
+        color: RustColors.explorer_background
+        radius: 20
 
-        StackLayout {
+        ColumnLayout {
-            anchors.fill: parent
+            spacing: 2
+
+            ClideBreadCrumbs {
+                id: breadCrumb
+
+                Layout.bottomMargin: 5
+                Layout.leftMargin: 15
+                Layout.topMargin: 5
+                path: clideTreeView.rootDirectory
+
+                onCrumbClicked: path => {
+                    Logger.trace("Crumb clicked: " + path);
+                    clideTreeView.rootDirectory = path;
+                }
+            }
             ClideTreeView {
                 id: clideTreeView
-                onFileClicked: path => root.selectedFilePath = path
+
+                height: navigationView.height
+
+                // Path to the directory opened in the file explorer.
+                originalRootDirectory: root.projectDir
+                rootDirectory: root.projectDir
+                width: navigationView.width
+
+                onFileClicked: path => clideEditor.filePath = path
+                onRootDirectoryChanged: {
+                    Logger.log("Setting root directory: " + clideTreeView.rootDirectory);
+                    breadCrumb.path = clideTreeView.rootDirectory;
+                }
             }
         }
     }
-    ClideEditor {
+    ClideEditorView {
+        id: clideEditor
+
         SplitView.fillWidth: true
-        // Initialize using the Default trait in Rust QML singleton FileSystem.
+
-        filePath: root.selectedFilePath
+        // Provide a path to the file currently open in the text editor.
+        // Initialized using the Default trait in Rust QML singleton FileSystem.
+        filePath: FileSystem.filePath
     }
 }

qml/ClideTreeView.qml

@@ -1,150 +1,167 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 import QtQuick
+import QtQuick.Effects
 import QtQuick.Controls
-import QtQuick.Layouts
 
 import clide.module 1.0
+import Logger 1.0
 
-Rectangle {
+TreeView {
-    id: root
+    id: fileSystemTreeView
-    color: RustColors.explorer_background
+
+    property int lastIndex: -1
+    required property string originalRootDirectory
+    property string rootDirectory
 
     signal fileClicked(string filePath)
 
-    TreeView {
+    boundsBehavior: Flickable.StopAtBounds
-        id: fileSystemTreeView
+    boundsMovement: Flickable.StopAtBounds
-        anchors.margins: 15
+    clip: true
+    leftMargin: 25
+    model: FileSystem
+    rootIndex: FileSystem.setDirectory(fileSystemTreeView.rootDirectory)
 
-        // rootIndex: FileSystem.rootIndex
+    // Provide our own custom ScrollIndicator for the TreeView.
-        property int lastIndex: -1
+    ScrollIndicator.vertical: ScrollIndicator {
+        active: true
+        implicitWidth: 15
 
-        model: FileSystem
+        contentItem: Rectangle {
-        anchors.fill: parent
+            color: RustColors.scrollbar
-        boundsBehavior: Flickable.StopAtBounds
+            implicitHeight: 6
-        boundsMovement: Flickable.StopAtBounds
+            implicitWidth: 6
-        clip: true
+            opacity: fileSystemTreeView.movingVertically ? 0.5 : 0.0
 
-        Component.onCompleted: {
+            Behavior on opacity {
-            FileSystem.setDirectory(FileSystem.filePath)
+                OpacityAnimator {
-            fileSystemTreeView.expandRecursively(0, 4)
+                    duration: 500
+                }
+            }
+        }
+    }
+
+    // The delegate represents a single entry in the filesystem.
+    delegate: TreeViewDelegate {
+        id: treeDelegate
+
+        required property string fileName
+        required property url filePath
+        required property int index
+
+        implicitHeight: 25
+        implicitWidth: fileSystemTreeView.width > 0 ? fileSystemTreeView.width : 250
+        indentation: 12
+
+        background: Rectangle {
+            color: current ? RustColors.explorer_folder_open : "transparent"
+            radius: 2.5
+        }
+        contentItem: Text {
+            anchors.left: directoryIcon.right
+            anchors.leftMargin: 5
+            color: RustColors.explorer_text
+            text: treeDelegate.fileName
+        }
+        indicator: Label {
+            id: directoryIcon
+
+            anchors.verticalCenter: parent.verticalCenter
+            antialiasing: true
+            font.family: localFont.font.family
+            font.pixelSize: 18
+            smooth: true
+            text: fileSystemTreeView.model.icon(filePath)
+            x: treeDelegate.leftMargin + (treeDelegate.depth * treeDelegate.indentation) + (indicator.visible ? indicator.width : 0)
         }
 
-        // The delegate represents a single entry in the filesystem.
+        FontLoader {
-        delegate: TreeViewDelegate {
+            id: localFont
-            id: treeDelegate
-            indentation: 8
-            implicitWidth: fileSystemTreeView.width > 0 ? fileSystemTreeView.width : 250
-            implicitHeight: 25
 
-            required property int index
+            source: "qrc:/fonts/saucecodepro-xlight.ttf"
-            required property url filePath
+        }
-            required property string fileName
+        Label {
+            id: indicator
 
-            indicator: Image {
+            anchors.verticalCenter: parent.verticalCenter
-                id: directoryIcon
+            font.family: localFont.font.family
+            font.pixelSize: 10
+            font.weight: localFont.font.weight
+            text: expanded ? "⮟" : "⮞"
+            visible: isTreeNode && hasChildren
+            x: padding + (depth * indentation)
+        }
+        MultiEffect {
+            id: iconOverlay
 
-                x: treeDelegate.leftMargin + (treeDelegate.depth * treeDelegate.indentation)
+            anchors.fill: directoryIcon
-                anchors.verticalCenter: parent.verticalCenter
+            brightness: 1.0
-                source: {
+            colorization: 1.0
-                    let folderOpen = "data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 576 512\"><!--!Font Awesome Free 6.7.2 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2025 Fonticons, Inc.--><path d=\"M88.7 223.8L0 375.8 0 96C0 60.7 28.7 32 64 32l117.5 0c17 0 33.3 6.7 45.3 18.7l26.5 26.5c12 12 28.3 18.7 45.3 18.7L416 96c35.3 0 64 28.7 64 64l0 32-336 0c-22.8 0-43.8 12.1-55.3 31.8zm27.6 16.1C122.1 230 132.6 224 144 224l400 0c11.5 0 22 6.1 27.7 16.1s5.7 22.2-.1 32.1l-112 192C453.9 474 443.4 480 432 480L32 480c-11.5 0-22-6.1-27.7-16.1s-5.7-22.2 .1-32.1l112-192z\"/></svg>";
+            colorizationColor: {
-                    let folderClosed = "data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 512 512\"><!--!Font Awesome Free 6.7.2 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2025 Fonticons, Inc.--><path d=\"M64 480H448c35.3 0 64-28.7 64-64V160c0-35.3-28.7-64-64-64H288c-10.1 0-19.6-4.7-25.6-12.8L243.2 57.6C231.1 41.5 212.1 32 192 32H64C28.7 32 0 60.7 0 96V416c0 35.3 28.7 64 64 64z\"/></svg>";
+                const isFile = !treeDelegate.hasChildren;
-                    let file = "data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 384 512\"><!--!Font Awesome Free 6.7.2 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2025 Fonticons, Inc.--><path d=\"M0 64C0 28.7 28.7 0 64 0L224 0l0 128c0 17.7 14.3 32 32 32l128 0 0 288c0 35.3-28.7 64-64 64L64 512c-35.3 0-64-28.7-64-64L0 64zm384 64l-128 0L256 0 384 128z\"/></svg>";
+                if (isFile)
-                    // If the item has children, it's a directory.
+                    return Qt.lighter(RustColors.explorer_folder, 2);
+                const isExpandedFolder = treeDelegate.expanded && treeDelegate.hasChildren;
+                if (isExpandedFolder)
+                    return Qt.darker(RustColors.explorer_folder, 2);
+                else
+                    return RustColors.explorer_folder;
+            }
+            source: directoryIcon
+        }
+        HoverHandler {
+            id: hoverHandler
+
+            acceptedDevices: PointerDevice.Mouse
+        }
+        TapHandler {
+            acceptedButtons: Qt.LeftButton | Qt.RightButton
+
+            onSingleTapped: (eventPoint, button) => {
+                switch (button) {
+                case Qt.LeftButton:
                     if (treeDelegate.hasChildren) {
-                        return treeDelegate.expanded ?
+                        fileSystemTreeView.toggleExpanded(treeDelegate.row);
-                            folderOpen : folderClosed;
                     } else {
-                        return file
+                        // If this model item doesn't have children, it means it's representing a file.
-                    }
+                        fileSystemTreeView.fileClicked(treeDelegate.filePath);
-                }
-                sourceSize.width: 15
-                sourceSize.height: 15
-                fillMode: Image.PreserveAspectFit
-
-                smooth: true
-                antialiasing: true
-                asynchronous: true
-            }
-
-            contentItem: Text {
-                text: treeDelegate.fileName
-                color: RustColors.explorer_text
-            }
-
-            background: Rectangle {
-                // TODO: Fix flickering from color transition on states here.
-                color: (treeDelegate.index === fileSystemTreeView.lastIndex)
-                    ? RustColors.explorer_text_selected
-                    : (hoverHandler.hovered ? RustColors.explorer_hovered : "transparent")
-                radius: 2.5
-                opacity: hoverHandler.hovered ? 0.75 : 1.0
-
-                Behavior on color {
-                    ColorAnimation {
-                        duration: 300
-                    }
-                }
-            }
-
-            HoverHandler {
-                id: hoverHandler
-            }
-
-            TapHandler {
-                acceptedButtons: Qt.LeftButton | Qt.RightButton
-                onSingleTapped: (eventPoint, button) => {
-                    switch (button) {
-                        case Qt.LeftButton:
-                            fileSystemTreeView.toggleExpanded(treeDelegate.row)
-                            fileSystemTreeView.lastIndex = treeDelegate.index
-                            // If this model item doesn't have children, it means it's
-                            // representing a file.
-                            if (!treeDelegate.hasChildren)
-                                root.fileClicked(treeDelegate.filePath)
-                            break;
-                        case Qt.RightButton:
-                            if (treeDelegate.hasChildren)
-                                contextMenu.popup();
-                            break;
-                    }
-                }
-            }
-
-            Menu {
-                id: contextMenu
-                Action {
-                    text: qsTr("Set as root index")
-                    onTriggered: {
-                        console.log("Setting directory: " + treeDelegate.filePath)
-                        FileSystem.setDirectory(treeDelegate.filePath)
-                    }
-                }
-                Action {
-                    text: qsTr("Reset root index")
-                    onTriggered: {
-                        FileSystem.setDirectory("")
                     }
+                    break;
+                case Qt.RightButton:
+                    contextMenu.popup();
+                    break;
                 }
             }
         }
+        ClideMenu {
+            id: contextMenu
 
-        // Provide our own custom ScrollIndicator for the TreeView.
+            ClideMenuItem {
-        ScrollIndicator.vertical: ScrollIndicator {
+                action: Action {
-            active: true
+                    enabled: treeDelegate.hasChildren
-            implicitWidth: 15
+                    text: qsTr("Set root")
 
-            contentItem: Rectangle {
+                    onTriggered: {
-                implicitWidth: 6
+                        Logger.debug("Setting new root directory: " + treeDelegate.filePath);
-                implicitHeight: 6
+                        fileSystemTreeView.rootDirectory = treeDelegate.filePath;
+                    }
+                }
+            }
+            ClideMenuItem {
+                action: Action {
+                    text: qsTr("Reset root")
 
-                color: RustColors.scrollbar
+                    onTriggered: {
-                opacity: fileSystemTreeView.movingVertically ? 0.5 : 0.0
+                        Logger.log("Resetting root directory: " + fileSystemTreeView.originalRootDirectory);
-
+                        fileSystemTreeView.rootDirectory = fileSystemTreeView.originalRootDirectory;
-                Behavior on opacity {
-                    OpacityAnimator {
-                        duration: 500
                     }
                 }
             }
         }
     }
+    selectionModel: ItemSelectionModel {
+    }
 }

qml/Components/ClideBreadCrumbs.qml

@@ -0,0 +1,109 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+import QtQuick.Layouts 1.15
+
+import clide.module 1.0
+import Logger 1.0
+
+Item {
+    id: root
+
+    property var fullPaths: []
+    required property string path
+    property var segments: []
+
+    signal crumbClicked(string path)
+
+    function rebuildSegments() {
+        var cleaned = path;
+        if (cleaned.endsWith("/"))
+            cleaned = cleaned.slice(0, -1);
+        var parts = cleaned.split("/");
+        root.segments = [];
+        root.fullPaths = [];
+        var current = "";
+        Logger.trace("Building segments for path: " + cleaned);
+        for (var i = 0; i < parts.length; ++i) {
+            if (parts[i] === "") {
+                current = "/";
+                root.segments.push("/");
+                root.fullPaths.push("/");
+            } else {
+                if (current === "/")
+                    current += parts[i];
+                else
+                    current += "/" + parts[i];
+                Logger.trace("Pushing path: " + parts[i] + " Current: " + current);
+                root.segments.push(parts[i]);
+                root.fullPaths.push(current);
+            }
+        }
+        rep.model = root.segments;
+    }
+
+    anchors.leftMargin: 20
+    height: breadcrumbRow.implicitHeight
+    width: parent.width
+
+    Component.onCompleted: rebuildSegments()
+    onPathChanged: rebuildSegments()
+
+    Flow {
+        id: breadcrumbRow
+
+        Repeater {
+            id: rep
+
+            model: root.segments
+
+            delegate: Text {
+                id: linkText
+
+                required property string modelData
+
+                function getText() {
+                    if (modelData === "/") {
+                        return modelData;
+                    }
+                    Logger.trace("Getting valid text:" + modelData);
+                    return modelData + "/";
+                }
+
+                color: mouseArea.containsMouse ? "#2a7fff" : RustColors.explorer_text
+                font.underline: mouseArea.containsMouse
+                text: getText()
+
+                MouseArea {
+                    id: mouseArea
+
+                    anchors.fill: parent
+                    hoverEnabled: true
+
+                    onClicked: {
+                        console.log("Breadcrumb clicked:", root.fullPaths[root.segments.indexOf(modelData)]);
+                        root.crumbClicked(root.fullPaths[root.segments.indexOf(modelData)]);
+                    }
+                }
+            }
+        }
+    }
+    TapHandler {
+        acceptedButtons: Qt.RightButton
+
+        onSingleTapped: (eventPoint, button) => contextMenu.popup()
+    }
+    ClideMenu {
+        id: contextMenu
+
+        ClideMenuItem {
+            action: Action {
+                text: qsTr("Reset root")
+
+                onTriggered: {
+                    Logger.log("Resetting root directory: " + clideTreeView.originalRootDirectory);
+                    clideTreeView.rootDirectory = clideTreeView.originalRootDirectory;
+                }
+            }
+        }
+    }
+}

qml/Components/ClideHandle.qml

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+import QtQuick
+import QtQuick.Controls
+
+import clide.module 1.0
+
+Rectangle {
+    id: root
+
+    readonly property color currentColor: {
+        if (pressed) {
+            return RustColors.pressed;
+        } else if (hovered) {
+            return RustColors.hovered;
+        } else {
+            return "black";
+        }
+    }
+    required property bool hovered
+    required property bool pressed
+
+    border.color: currentColor
+    color: currentColor
+    implicitHeight: 8
+    radius: 2.5
+    opacity: root.hovered ? 1.0 : 0.0
+
+    // Execute these behaviors when the color is changed.
+    Behavior on color {
+        ColorAnimation {
+            duration: 500
+        }
+    }
+
+    Behavior on opacity {
+        OpacityAnimator {
+            duration: 500
+        }
+    }
+}

qml/Components/ClideMenu.qml

@@ -0,0 +1,14 @@
+import QtQuick
+import QtQuick.Controls.Basic
+
+import clide.module 1.0
+
+Menu {
+    background: Rectangle {
+        border.color: RustColors.hovered
+        border.width: 10
+        color: RustColors.menubar
+        implicitWidth: 100
+        radius: 5
+    }
+}

qml/Components/ClideMenuItem.qml

@@ -0,0 +1,18 @@
+import QtQuick
+import QtQuick.Controls.Basic
+
+import clide.module 1.0
+
+MenuItem {
+    id: root
+
+    background: Rectangle {
+        color: root.hovered ? RustColors.hovered : RustColors.unhovered
+        radius: 1.0
+    }
+    contentItem: IconLabel {
+        color: "black"
+        font.family: "Helvetica"
+        text: root.text
+    }
+}

qml/Components/ClideScrollBar.qml

@@ -0,0 +1,71 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+import QtQuick
+import QtQuick.Controls
+
+import clide.module 1.0
+
+ScrollBar {
+    id: scrollBar
+
+    // Height, opacitiy, width
+    property int h: scrollBar.interactive ? 4 * 2 : 4
+    property int o: scrollBar.active && scrollBar.size < 1.0 ? 1.0 : 0.0
+    property int w: scrollBar.interactive ? 4 * 2 : 4
+
+    // Scroll bar gutter
+    background: Rectangle {
+        id: gutter
+
+        color: RustColors.scrollbar_gutter
+        implicitHeight: scrollBar.h
+        implicitWidth: scrollBar.w
+
+        // Fade the scrollbar gutter when inactive.
+        opacity: scrollBar.o
+
+        Behavior on opacity {
+            OpacityAnimator {
+                duration: 500
+            }
+        }
+    }
+
+    // Scroll bar
+    contentItem: Rectangle {
+        readonly property color barColor: {
+            if (scrollBar.size < 1.0) {
+                // If the scrollbar is required change it's color based on activity.
+                if (scrollBar.active) {
+                    return RustColors.scrollbar_active;
+                } else {
+                    return RustColors.scrollbar;
+                }
+            } else {
+                // If we don't need a scrollbar, fallback to the gutter color.
+                return gutter.color;
+            }
+        }
+
+        color: barColor
+        implicitHeight: scrollBar.h
+        implicitWidth: scrollBar.w
+
+        // Fade the scrollbar when inactive.
+        opacity: scrollBar.o
+
+        // Smooth transition between color changes based on the state above.
+        Behavior on color {
+            ColorAnimation {
+                duration: 1000
+            }
+        }
+        Behavior on opacity {
+            OpacityAnimator {
+                duration: 1000
+            }
+        }
+    }
+}

qml/Components/qmldir

@@ -0,0 +1,5 @@
+ClideScrollBar ClideScrollBar.qml
+ClideHandle ClideHandle.qml
+ClideMenu ClideMenu.qml
+ClideMenuItem ClideMenuItem.qml
+ClideBreadCrumbs ClideBreadCrumbs.qml

qml/Logger/Logger.qml

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+pragma Singleton
+import QtQuick
+
+QtObject {
+    signal logged(string level, string message)
+
+    function debug(msg) {
+        console.log(msg);
+        logged("DEBUG", msg);
+    }
+    function error(msg) {
+        console.error(msg);
+        logged("ERROR", msg);
+    }
+    function info(msg) {
+        console.log(msg);
+        logged("INFO", msg);
+    }
+    function log(msg) {
+        console.log(msg);
+        logged("INFO", msg);
+    }
+    function trace(msg) {
+        console.log(msg);
+        logged("TRACE", msg);
+    }
+    function warn(msg) {
+        console.warn(msg);
+        logged("WARN", msg);
+    }
+}

qml/Logger/qmldir

@@ -0,0 +1 @@
+singleton Logger 1.0 Logger.qml

qml/main.qml

@@ -1,3 +1,7 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 import QtQuick
 import QtQuick.Controls
 import QtQuick.Layouts
@@ -8,6 +12,8 @@ import clide.module 1.0
 ApplicationWindow {
     id: appWindow
 
+    required property string appContextPath
+
     height: 800
     title: "CLIDE"
     visible: true
@@ -16,17 +22,15 @@ ApplicationWindow {
     menuBar: ClideMenuBar {
     }
 
-    Rectangle {
-        anchors.fill: parent
-        color: RustColors.gutter
-    }
-
     MessageDialog {
         id: errorDialog
 
         title: qsTr("Error")
     }
     ClideProjectView {
+        id: clideProjectView
+
+        projectDir: appWindow.appContextPath
     }
 }
 

resources.qrc

@@ -0,0 +1,10 @@
+<RCC>
+    <qresource prefix="/images">
+        <file alias="kilroy.png">resources/images/kilroy-256.png</file>
+    </qresource>
+    <qresource prefix="/fonts">
+        <file alias="saucecodepro.ttf">resources/SauceCodeProNerdFont-Black.ttf</file>
+        <file alias="saucecodepro-light.ttf">resources/SauceCodeProNerdFont-Light.ttf</file>
+        <file alias="saucecodepro-xlight.ttf">resources/SauceCodeProNerdFont-ExtraLight.ttf</file>
+    </qresource>
+</RCC>

src/gui.rs

@@ -1,18 +1,29 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+use crate::AppContext;
 use anyhow::Result;
-use cxx_qt_lib::QString;
+use cxx_qt_lib::{QMapPair, QMapPair_QString_QVariant, QString, QVariant};
 use log::trace;
 
 pub mod colors;
 pub mod filesystem;
 
-pub fn run(root_path: std::path::PathBuf) -> Result<()> {
+pub fn run(app_context: AppContext) -> Result<()> {
-    trace!(target:"gui::run()", "Starting the GUI editor at {root_path:?}");
+    trace!(target:"gui::run()", "Starting the GUI editor at {:?}", app_context.path);
 
     use cxx_qt_lib::{QGuiApplication, QQmlApplicationEngine, QUrl};
 
     let mut app = QGuiApplication::new();
     let mut engine = QQmlApplicationEngine::new();
 
+    // Set QML property for the directory provided to the CLI.
+    let path = QString::from(app_context.path.to_string_lossy().to_string());
+    let mut map = QMapPair_QString_QVariant::default();
+    map.insert(QString::from("appContextPath"), QVariant::from(&path));
+    engine.as_mut().unwrap().set_initial_properties(&map);
+
     if let Some(engine) = engine.as_mut() {
         engine.add_import_path(&QString::from("qml/"));
     }

src/gui/colors.rs

@@ -1,4 +1,9 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 #[cxx_qt::bridge]
+
 pub mod qobject {
     unsafe extern "C++" {
         include!("cxx-qt-lib/qcolor.h");
@@ -31,6 +36,12 @@ pub mod qobject {
         #[qproperty(QColor, explorer_background)]
         #[qproperty(QColor, explorer_folder)]
         #[qproperty(QColor, explorer_folder_open)]
+        #[qproperty(QColor, terminal_background)]
+        #[qproperty(QColor, info_log)]
+        #[qproperty(QColor, debug_log)]
+        #[qproperty(QColor, warn_log)]
+        #[qproperty(QColor, error_log)]
+        #[qproperty(QColor, trace_log)]
         type RustColors = super::RustColorsImpl;
     }
 }
@@ -60,6 +71,12 @@ pub struct RustColorsImpl {
     explorer_background: QColor,
     explorer_folder: QColor,
     explorer_folder_open: QColor,
+    terminal_background: QColor,
+    info_log: QColor,
+    debug_log: QColor,
+    warn_log: QColor,
+    error_log: QColor,
+    trace_log: QColor,
 }
 
 impl Default for RustColorsImpl {
@@ -68,7 +85,7 @@ impl Default for RustColorsImpl {
             hovered: QColor::try_from("#303234").unwrap(),
             unhovered: QColor::try_from("#3c3f41").unwrap(),
             pressed: QColor::try_from("#4b4f51").unwrap(),
-            menubar: QColor::try_from("#3c3f41").unwrap(),
+            menubar: QColor::try_from("#262626").unwrap(),
             menubar_border: QColor::try_from("#575757").unwrap(),
             scrollbar: QColor::try_from("#4b4f51").unwrap(),
             scrollbar_active: QColor::try_from("#4b4f51").unwrap(),
@@ -76,17 +93,23 @@ impl Default for RustColorsImpl {
             linenumber: QColor::try_from("#94989b").unwrap(),
             active: QColor::try_from("#a9acb0").unwrap(),
             inactive: QColor::try_from("#FFF").unwrap(),
-            editor_background: QColor::try_from("#2b2b2b").unwrap(),
+            editor_background: QColor::try_from("#111111").unwrap(),
             editor_text: QColor::try_from("#acaea3").unwrap(),
             editor_highlighted_text: QColor::try_from("#ccced3").unwrap(),
             editor_highlight: QColor::try_from("#ccced3").unwrap(),
             gutter: QColor::try_from("#1e1f22").unwrap(),
             explorer_hovered: QColor::try_from("#4c5053").unwrap(),
-            explorer_text: QColor::try_from("#3b3b3b").unwrap(),
+            explorer_text: QColor::try_from("#FFF").unwrap(),
-            explorer_text_selected: QColor::try_from("#8b8b8b").unwrap(),
+            explorer_text_selected: QColor::try_from("#262626").unwrap(),
-            explorer_background: QColor::try_from("#676c70").unwrap(),
+            explorer_background: QColor::try_from("#1E1F22").unwrap(),
             explorer_folder: QColor::try_from("#54585b").unwrap(),
-            explorer_folder_open: QColor::try_from("#FFF").unwrap(),
+            explorer_folder_open: QColor::try_from("#393B40").unwrap(),
+            terminal_background: QColor::try_from("#111111").unwrap(),
+            info_log: QColor::try_from("#C4FFFF").unwrap(),
+            debug_log: QColor::try_from("#9148AF").unwrap(),
+            warn_log: QColor::try_from("#C4A958").unwrap(),
+            error_log: QColor::try_from("#ff5555").unwrap(),
+            trace_log: QColor::try_from("#ffaa00").unwrap(),
         }
     }
 }

src/gui/filesystem.rs

@@ -1,3 +1,21 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+use cxx_qt_lib::{QModelIndex, QString};
+use devicons::FileIcon;
+use dirs;
+use log::warn;
+use std::fs;
+use std::path::Path;
+use syntect::easy::HighlightLines;
+use syntect::highlighting::ThemeSet;
+use syntect::html::{
+    IncludeBackground, append_highlighted_html_for_styled_line, start_highlighted_html_snippet,
+};
+use syntect::parsing::SyntaxSet;
+use syntect::util::LinesWithEndings;
+
 #[cxx_qt::bridge]
 pub mod qobject {
     unsafe extern "C++" {
@@ -17,7 +35,6 @@ pub mod qobject {
         #[qml_element]
         #[qml_singleton]
         #[qproperty(QString, file_path, cxx_name = "filePath")]
-        #[qproperty(QModelIndex, root_index, cxx_name = "rootIndex")]
         type FileSystem = super::FileSystemImpl;
 
         #[inherit]
@@ -36,25 +53,15 @@ pub mod qobject {
         #[qinvokable]
         #[cxx_name = "setDirectory"]
         fn set_directory(self: Pin<&mut FileSystem>, path: &QString) -> QModelIndex;
+
+        #[qinvokable]
+        fn icon(self: Pin<&mut FileSystem>, path: &QString) -> QString;
     }
 }
 
-use cxx_qt_lib::{QModelIndex, QString};
+// TODO: Implement a provider for QFileSystemModel::setIconProvider for icons.
-use dirs;
-use log::warn;
-use std::fs;
-use std::io::BufRead;
-use syntect::easy::HighlightFile;
-use syntect::highlighting::ThemeSet;
-use syntect::html::{
-    IncludeBackground, append_highlighted_html_for_styled_line, start_highlighted_html_snippet,
-};
-use syntect::parsing::SyntaxSet;
-
-// TODO: Impleent a provider for QFileSystemModel::setIconProvider for icons.
 pub struct FileSystemImpl {
     file_path: QString,
-    root_index: QModelIndex,
 }
 
 // Default is explicit to make the editor open this source file initially.
@@ -62,7 +69,6 @@ impl Default for FileSystemImpl {
     fn default() -> Self {
         Self {
             file_path: QString::from(file!()),
-            root_index: Default::default(),
         }
     }
 }
@@ -72,42 +78,46 @@ impl qobject::FileSystem {
         if path.is_empty() {
             return QString::default();
         }
-        if !fs::metadata(path.to_string())
+        let meta = fs::metadata(path.to_string())
-            .expect(format!("Failed to get file metadata {path:?}").as_str())
+            .expect(format!("Failed to get file metadata {path:?}").as_str());
-            .is_file()
+        if !meta.is_file() {
-        {
             warn!(target:"FileSystem", "Attempted to open file {path:?} that is not a valid file");
             return QString::default();
         }
-        let ss = SyntaxSet::load_defaults_nonewlines();
+        let path_str = path.to_string();
-        let ts = ThemeSet::load_defaults();
+        if let Ok(lines) = fs::read_to_string(path_str.as_str()) {
-        let theme = &ts.themes["base16-ocean.dark"];
+            let ss = SyntaxSet::load_defaults_nonewlines();
+            let ts = ThemeSet::load_defaults();
+            let theme = &ts.themes["base16-ocean.dark"];
+            let lang = ss
+                .find_syntax_by_extension(
+                    Path::new(path_str.as_str())
+                        .extension()
+                        .map(|s| s.to_str())
+                        .unwrap_or_else(|| Some("md"))
+                        .expect("Failed to get file extension"),
+                )
+                .unwrap_or_else(|| ss.find_syntax_plain_text());
+            let mut highlighter = HighlightLines::new(lang, theme);
+            let (mut output, _bg) = start_highlighted_html_snippet(theme);
+            for line in LinesWithEndings::from(lines.as_str()) {
+                let regions = highlighter
+                    .highlight_line(line, &ss)
+                    .expect("Failed to highlight");
 
-        let mut highlighter =
+                append_highlighted_html_for_styled_line(
-            HighlightFile::new(path.to_string(), &ss, theme).expect("Failed to create highlighter");
+                    &regions[..],
-        let (mut output, _bg) = start_highlighted_html_snippet(theme);
+                    IncludeBackground::No,
-        let mut line = String::new();
+                    &mut output,
-        while highlighter
+                )
-            .reader
+                .expect("Failed to insert highlighted html");
-            .read_line(&mut line)
+            }
-            .expect("Failed to read file.")
-            > 0
-        {
-            let regions = highlighter
-                .highlight_lines
-                .highlight_line(&line, &ss)
-                .expect("Failed to highlight");
 
-            append_highlighted_html_for_styled_line(
+            output.push_str("</pre>\n");
-                &regions[..],
+            QString::from(output)
-                IncludeBackground::Yes,
+        } else {
-                &mut output,
+            return QString::default();
-            )
-            .expect("Failed to insert highlighted html");
-            line.clear();
         }
-        output.push_str("</pre>\n");
-        QString::from(output)
     }
 
     // There will never be more than one column.
@@ -124,14 +134,24 @@ impl qobject::FileSystem {
             self.set_root_path(path)
         } else {
             // If the initial directory can't be opened, attempt to find the home directory.
-            self.set_root_path(&QString::from(
+            let homedir = dirs::home_dir()
-                dirs::home_dir()
+                .expect("Failed to get home directory")
-                    .expect("Failed to get home directory")
+                .as_path()
-                    .as_path()
+                .to_str()
-                    .to_str()
+                .unwrap()
-                    .unwrap()
+                .to_string();
-                    .to_string(),
+            self.set_root_path(&QString::from(homedir))
-            ))
         }
     }
+
+    fn icon(self: std::pin::Pin<&mut Self>, path: &QString) -> QString {
+        let str = path.to_string();
+        if Path::new(&str).is_dir() {
+            // Ensures directories are given a folder icon and not mistakenly resolved to a language.
+            // For example, a directory named `cpp` would otherwise return a C++ icon.
+            return QString::from(FileIcon::from("dir/").to_string())
+        }
+        let icon = FileIcon::from(str);
+        QString::from(icon.to_string())
+    }
 }

src/main.rs

@@ -1,5 +1,8 @@
-use crate::tui::Tui;
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
-use anyhow::{Context, Result};
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+use anyhow::{Context, Result, anyhow};
 use clap::Parser;
 use log::{info, trace};
 use std::process::{Command, Stdio};
@@ -25,41 +28,67 @@ struct Cli {
     pub gui: bool,
 }
 
-fn main() -> Result<()> {
+impl Cli {
-    let args = Cli::parse();
+    fn run_mode(&self) -> Result<RunMode> {
-
+        let mut modes = Vec::new();
-    let root_path = match args.path {
+        self.tui.then(|| modes.push(RunMode::Tui));
-        // If the CLI was provided a directory, convert it to absolute.
+        self.gui.then(|| modes.push(RunMode::GuiAttached));
-        Some(path) => std::path::absolute(path)?,
+        match &modes[..] {
-        // If no path was provided, use the current directory.
+            [] => Ok(RunMode::Gui),
-        None => std::env::current_dir().unwrap_or(
+            [mode] => Ok(*mode),
-            // If we can't find the CWD, attempt to open the home directory.
+            multiple => Err(anyhow!(
-            dirs::home_dir().context("Failed to obtain home directory")?,
+                "More than one run mode found {multiple:?} please select one."
-        ),
+            )),
-    };
+        }
-    info!(target:"main()", "Root path detected: {root_path:?}");
+    }
-
+}
-    match args.gui {
+
-        true => {
+pub struct AppContext {
-            trace!(target:"main()", "Starting GUI");
+    pub path: std::path::PathBuf,
-            gui::run(root_path)
+    pub run_mode: RunMode,
+}
+
+impl AppContext {
+    fn new(cli: Cli) -> Result<Self> {
+        let path = match &cli.path {
+            // If the CLI was provided a directory, convert it to absolute.
+            Some(path) => std::path::absolute(path)?,
+            // If no path was provided, use the current directory.
+            None => std::env::current_dir().context("Failed to obtain current directory")?,
+        };
+        info!(target:"main()", "Root path detected: {path:?}");
+
+        Ok(Self {
+            path,
+            run_mode: cli.run_mode()?,
+        })
+    }
+}
+
+#[derive(Copy, Clone, Debug, Default)]
+pub enum RunMode {
+    #[default]
+    Gui,
+    GuiAttached,
+    Tui,
+}
+
+fn main() -> Result<()> {
+    let args = Cli::parse();
+    let app_context = AppContext::new(args)?;
+    match app_context.run_mode {
+        RunMode::GuiAttached => gui::run(app_context),
+        RunMode::Tui => tui::run(app_context),
+        RunMode::Gui => {
+            trace!(target:"main()", "Starting GUI in a new process");
+            Command::new(std::env::current_exe()?)
+                .args(&["--gui", app_context.path.to_str().unwrap()])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .stdin(Stdio::null())
+                .spawn()
+                .context("Failed to start GUI")
+                .map(|_| ())
         }
-        false => match args.tui {
-            // Open the TUI editor if requested, otherwise use the QML GUI by default.
-            true => {
-                trace!(target:"main()", "Starting TUI");
-                Ok(Tui::new(root_path)?.start()?)
-            }
-            false => {
-                trace!(target:"main()", "Starting GUI in a new process");
-                Command::new(std::env::current_exe()?)
-                    .args(&["--gui", root_path.to_str().unwrap()])
-                    .stdout(Stdio::null())
-                    .stderr(Stdio::null())
-                    .stdin(Stdio::null())
-                    .spawn()?;
-                Ok(())
-            }
-        },
     }
 }

src/tui.rs

@@ -1,3 +1,7 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 mod about;
 mod app;
 mod component;
@@ -7,6 +11,7 @@ mod explorer;
 mod logger;
 mod menu_bar;
 
+use crate::AppContext;
 use anyhow::{Context, Result};
 use log::{LevelFilter, debug, info, trace};
 use ratatui::Terminal;
@@ -23,21 +28,24 @@ use tui_logger::{
     TuiLoggerFile, TuiLoggerLevelOutput, init_logger, set_default_level, set_log_file,
 };
 
-pub struct Tui {
+struct Tui {
     terminal: Terminal<CrosstermBackend<Stdout>>,
     root_path: std::path::PathBuf,
 }
 
-impl Tui {
+pub fn run(app_context: AppContext) -> Result<()> {
-    pub fn id() -> &'static str {
+    trace!(target:Tui::ID, "Starting TUI");
-        "Tui"
+    Tui::new(app_context)?.start()
-    }
+}
 
-    pub fn new(root_path: std::path::PathBuf) -> Result<Self> {
+impl Tui {
-        trace!(target:Self::id(), "Building {}", Self::id());
+    pub const ID: &str = "Tui";
+
+    fn new(app_context: AppContext) -> Result<Self> {
+        trace!(target:Self::ID, "Building {}", Self::ID);
         init_logger(LevelFilter::Trace)?;
         set_default_level(LevelFilter::Trace);
-        debug!(target:Self::id(), "Logging initialized");
+        debug!(target:Self::ID, "Logging initialized");
 
         let mut dir = env::temp_dir();
         dir.push("clide.log");
@@ -49,16 +57,16 @@ impl Tui {
         .output_file(false)
         .output_separator(':');
         set_log_file(file_options);
-        debug!(target:Self::id(), "Logging to file: {dir:?}");
+        debug!(target:Self::ID, "Logging to file: {dir:?}");
 
         Ok(Self {
             terminal: Terminal::new(CrosstermBackend::new(stdout()))?,
-            root_path,
+            root_path: app_context.path,
         })
     }
 
-    pub fn start(self) -> Result<()> {
+    fn start(self) -> Result<()> {
-        info!(target:Self::id(), "Starting the TUI editor at {:?}", self.root_path);
+        info!(target:Self::ID, "Starting the TUI editor at {:?}", self.root_path);
         ratatui::crossterm::execute!(
             stdout(),
             EnterAlternateScreen,
@@ -75,7 +83,7 @@ impl Tui {
     }
 
     fn stop() -> Result<()> {
-        info!(target:Self::id(), "Stopping the TUI editor");
+        info!(target:Self::ID, "Stopping the TUI editor");
         disable_raw_mode()?;
         ratatui::crossterm::execute!(
             stdout(),

src/tui/about.rs

@@ -1,6 +1,9 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 use ratatui::buffer::Buffer;
 use ratatui::layout::{Constraint, Direction, Layout, Rect};
-use ratatui::style::{Modifier, Style};
 use ratatui::text::{Line, Span};
 use ratatui::widgets::{Block, Borders, Clear, Padding, Paragraph, Widget, Wrap};
 
@@ -8,9 +11,7 @@ pub struct About {}
 
 impl About {
     #[allow(unused)]
-    pub fn id() -> &'static str {
+    pub const ID: &str = "About";
-        "About"
-    }
 
     pub fn new() -> Self {
         // trace!(target:Self::id(), "Building {}", Self::id());
@@ -23,54 +24,61 @@ impl Widget for About {
     where
         Self: Sized,
     {
-        Clear::default().render(area, buf);
-        // Split main area
         let chunks = Layout::default()
             .direction(Direction::Vertical)
             .constraints([
-                Constraint::Fill(2), // image column
+                Constraint::Fill(1), // Image Layout
-                Constraint::Fill(1), // image column
+                Constraint::Fill(2), // Description
-                Constraint::Fill(2), // text column
             ])
             .split(area);
-
+        let kilroy = [
-        let top_chunks = Layout::default()
+            "    *         ",
-            .direction(Direction::Horizontal)
+            "    |.===.    ",
-            .constraints([
+            "    {}o o{}   ",
-                Constraint::Fill(1),
+            "-ooO--(_)--Ooo",
-                Constraint::Fill(3),
+            "CLIDE WAS HERE",
-                Constraint::Fill(1),
-            ])
-            .split(chunks[1]);
-
-        let bottom_chunks = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([
-                Constraint::Fill(1),
-                Constraint::Fill(3),
-                Constraint::Fill(1),
-            ])
-            .split(chunks[2]);
-
-        // ---------- IMAGE ----------
-        let kilroy_art = [
-            "                          *                                    ",
-            "                          |.===.                               ",
-            "                          {}o o{}                              ",
-            "-----------------------ooO--(_)--Ooo---------------------------",
-            "#                                                             #",
-            "#                     CLIDE WAS HERE                          #",
-            "#                                                             #",
-            "#          https://git.shaunreed.com/shaunred/clide           #",
-            "#          https://shaunreed.com/shaunred/clide               #",
-            "#                                                             #",
         ];
+        let kilroy_rect = Rect {
+            x: chunks[1].x,
+            y: chunks[1].y - kilroy.len() as u16 + 2,
+            width: area.width,
+            height: kilroy.len() as u16,
+        };
+        // info!(target: About::ID, "Created rect: {kilroy_rect:?}");
 
-        let kilroy_lines: Vec<Line> = kilroy_art
+        let kilroy_lines: Vec<Line> = kilroy.iter().map(|l| Line::from(Span::raw(*l))).collect();
+        let about_text = [
+            "Clide",
+            "",
+            "Author: Shaun Reed",
+            "Email: shaunrd0@gmail.com",
+            "URL: https://git.shaunreed.com/shaunrd0/clide",
+            "Blog: https://shaunreed.com",
+            "",
+            "Description:",
+            concat!(
+                "CLIDE is an extendable command-line driven development environment written in Rust",
+                " using the Qt UI framework that supports both full and headless Linux environments.",
+                " The GUI is written in QML compiled through Rust using the cxx-qt crate, while the",
+                " TUI was implemented using the ratatui crate.",
+            ),
+        ];
+        let about_lines: Vec<Line> = about_text
             .iter()
             .map(|l| Line::from(Span::raw(*l)))
             .collect();
 
+        Clear::default().render(kilroy_rect, buf);
+        Clear::default().render(chunks[1], buf);
+        Paragraph::new(about_lines)
+            .block(
+                Block::default()
+                    .title("About")
+                    .borders(Borders::ALL)
+                    .padding(Padding::top(0)),
+            )
+            .wrap(Wrap { trim: false })
+            .render(chunks[1], buf);
         Paragraph::new(kilroy_lines)
             .block(
                 Block::default()
@@ -79,60 +87,6 @@ impl Widget for About {
             )
             .wrap(Wrap { trim: false })
             .centered()
-            .render(top_chunks[1], buf);
+            .render(kilroy_rect, buf);
-
-        // ---------- TEXT ----------
-        let about_text = vec![
-            Line::from(vec![Span::styled(
-                "clide\n",
-                Style::default().add_modifier(Modifier::BOLD),
-            )])
-            .centered(),
-            Line::from(""),
-            Line::from(vec![
-                Span::styled("Author: ", Style::default().add_modifier(Modifier::BOLD)),
-                Span::raw("Shaun Reed"),
-            ])
-            .left_aligned(),
-            Line::from(vec![
-                Span::styled("Email:  ", Style::default().add_modifier(Modifier::BOLD)),
-                Span::raw("shaunrd0@gmail.com"),
-            ])
-            .left_aligned(),
-            Line::from(vec![
-                Span::styled("URL:    ", Style::default().add_modifier(Modifier::BOLD)),
-                Span::raw("https://git.shaunreed.com/shaunrd0/clide"),
-            ])
-            .left_aligned(),
-            Line::from(vec![
-                Span::styled("Blog:   ", Style::default().add_modifier(Modifier::BOLD)),
-                Span::raw("https://shaunreed.com"),
-            ])
-            .left_aligned(),
-            Line::from(""),
-            Line::from(vec![Span::styled(
-                "Description\n",
-                Style::default().add_modifier(Modifier::BOLD),
-            )])
-            .left_aligned(),
-            Line::from(concat!(
-                "CLIDE is an extendable command-line driven development environment written in Rust using the Qt UI framework that supports both full and headless Linux environments. ",
-                "The GUI is written in QML compiled through Rust using the cxx-qt crate, while the TUI was implemented using the ratatui crate. ",
-            ))
-            .style(Style::default())
-            .left_aligned(),
-        ];
-        Block::bordered().render(area, buf);
-
-        let paragraph = Paragraph::new(about_text)
-            .block(
-                Block::default()
-                    .title("About")
-                    .borders(Borders::ALL)
-                    .padding(Padding::top(0)),
-            )
-            .wrap(Wrap { trim: true });
-
-        paragraph.render(bottom_chunks[1], buf);
     }
 }

src/tui/app.rs

@@ -1,3 +1,7 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 use crate::tui::about::About;
 use crate::tui::app::AppComponent::{AppEditor, AppExplorer, AppLogger};
 use crate::tui::component::{Action, Component, Focus, FocusState, Visibility, VisibleState};
@@ -17,7 +21,7 @@ use ratatui::crossterm::event::{
 use ratatui::layout::{Constraint, Direction, Layout, Rect};
 use ratatui::prelude::{Color, Widget};
 use ratatui::widgets::{Paragraph, Wrap};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::time::Duration;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -29,7 +33,7 @@ pub enum AppComponent {
 }
 
 pub struct App<'a> {
-    editor_tabs: EditorTab,
+    editor_tab: EditorTab,
     explorer: Explorer<'a>,
     logger: Logger,
     menu_bar: MenuBar,
@@ -38,14 +42,12 @@ pub struct App<'a> {
 }
 
 impl<'a> App<'a> {
-    pub fn id() -> &'static str {
+    pub const ID: &'static str = "App";
-        "App"
-    }
 
     pub fn new(root_path: PathBuf) -> Result<Self> {
-        trace!(target:Self::id(), "Building {}", Self::id());
+        trace!(target:Self::ID, "Building {}", Self::ID);
         let app = Self {
-            editor_tabs: EditorTab::new(None),
+            editor_tab: EditorTab::new(),
             explorer: Explorer::new(&root_path)?,
             logger: Logger::new(),
             menu_bar: MenuBar::new(),
@@ -57,13 +59,13 @@ impl<'a> App<'a> {
 
     /// Logic that should be executed once on application startup.
     pub fn start(&mut self) -> Result<()> {
-        trace!(target:Self::id(), "Starting App");
+        trace!(target:Self::ID, "Starting App");
         Ok(())
     }
 
     pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
         self.start()?;
-        trace!(target:Self::id(), "Entering App run loop");
+        trace!(target:Self::ID, "Entering App run loop");
         loop {
             terminal.draw(|f| {
                 f.render_widget(&mut self, f.area());
@@ -85,11 +87,11 @@ impl<'a> App<'a> {
     fn draw_bottom_status(&self, area: Rect, buf: &mut Buffer) {
         // Determine help text from the most recently focused component.
         let help = match self.last_active {
-            AppEditor => match self.editor_tabs.current_editor() {
+            AppEditor => match self.editor_tab.current_editor() {
                 Some(editor) => editor.component_state.help_text.clone(),
                 None => {
-                    if !self.editor_tabs.is_empty() {
+                    if !self.editor_tab.is_empty() {
-                        error!(target:Self::id(), "Failed to get Editor while drawing bottom status bar");
+                        error!(target:Self::ID, "Failed to get Editor while drawing bottom status bar");
                     }
                     "Failed to get current Editor while getting widget help text".to_string()
                 }
@@ -113,26 +115,26 @@ impl<'a> App<'a> {
     }
 
     fn clear_focus(&mut self) {
-        info!(target:Self::id(), "Clearing all widget focus");
+        info!(target:Self::ID, "Clearing all widget focus");
         self.explorer.component_state.set_focus(Focus::Inactive);
         self.explorer.component_state.set_focus(Focus::Inactive);
         self.logger.component_state.set_focus(Focus::Inactive);
         self.menu_bar.component_state.set_focus(Focus::Inactive);
-        match self.editor_tabs.current_editor_mut() {
+        match self.editor_tab.current_editor_mut() {
             None => {
-                error!(target:Self::id(), "Failed to get current Editor while clearing focus")
+                error!(target:Self::ID, "Failed to get current Editor while clearing focus")
             }
             Some(editor) => editor.component_state.set_focus(Focus::Inactive),
         }
     }
 
     fn change_focus(&mut self, focus: AppComponent) {
-        info!(target:Self::id(), "Changing widget focus to {:?}", focus);
+        info!(target:Self::ID, "Changing widget focus to {:?}", focus);
         self.clear_focus();
         match focus {
-            AppEditor => match self.editor_tabs.current_editor_mut() {
+            AppEditor => match self.editor_tab.current_editor_mut() {
                 None => {
-                    error!(target:Self::id(), "Failed to get current Editor while changing focus")
+                    error!(target:Self::ID, "Failed to get current Editor while changing focus")
                 }
                 Some(editor) => editor.component_state.set_focus(Focus::Active),
             },
@@ -142,32 +144,6 @@ impl<'a> App<'a> {
         }
         self.last_active = focus;
     }
-
-    /// Refresh the contents of the editor to match the selected TreeItem in the file Explorer.
-    /// If the selected item is not a file, this does nothing.
-    #[allow(unused)]
-    fn refresh_editor_contents(&mut self) -> Result<()> {
-        // TODO: This may be useful for a preview mode of the selected file prior to opening a tab.
-        // Use the currently selected TreeItem or get an absolute path to this source file.
-        // let selected_pathbuf = match self.explorer.selected() {
-        //     Ok(path) => PathBuf::from(path),
-        //     Err(_) => PathBuf::from(std::path::absolute(file!())?.to_string_lossy().to_string()),
-        // };
-        // match self.editor_tabs.current_editor_mut() {
-        //     None => bail!("Failed to get current Editor while refreshing editor contents"),
-        //     Some(editor) => {
-        //         let current_file_path = editor
-        //             .file_path
-        //             .clone()
-        //             .context("Failed to get Editor current file_path")?;
-        //         if selected_pathbuf == current_file_path || !selected_pathbuf.is_file() {
-        //             return Ok(());
-        //         }
-        //         editor.set_contents(&selected_pathbuf)
-        //     }
-        // }
-        Ok(())
-    }
 }
 
 impl<'a> Widget for &mut App<'a> {
@@ -225,7 +201,7 @@ impl<'a> Widget for &mut App<'a> {
                         Constraint::Fill(1),   // Editor contents.
                     ])
                     .split(horizontal[1]);
-                self.editor_tabs
+                self.editor_tab
                     .render(editor_layout[0], editor_layout[1], buf);
                 self.explorer.render(horizontal[0], buf);
             }
@@ -237,7 +213,7 @@ impl<'a> Widget for &mut App<'a> {
                         Constraint::Fill(1),   // Editor contents.
                     ])
                     .split(horizontal[0]);
-                self.editor_tabs
+                self.editor_tab
                     .render(editor_layout[0], editor_layout[1], buf);
             }
         }
@@ -258,7 +234,7 @@ impl<'a> Widget for &mut App<'a> {
         }
 
         if self.about {
-            let about_area = area.centered(Constraint::Percentage(50), Constraint::Percentage(45));
+            let about_area = area.centered(Constraint::Percentage(40), Constraint::Percentage(50));
             About::new().render(about_area, buf);
         }
     }
@@ -279,7 +255,7 @@ impl<'a> Component for App<'a> {
         }
         // Handle events for all components.
         let action = match self.last_active {
-            AppEditor => self.editor_tabs.handle_event(event.clone())?,
+            AppEditor => self.editor_tab.handle_event(event.clone())?,
             AppExplorer => self.explorer.handle_event(event.clone())?,
             AppLogger => self.logger.handle_event(event.clone())?,
             AppMenuBar => self.menu_bar.handle_event(event.clone())?,
@@ -288,7 +264,7 @@ impl<'a> Component for App<'a> {
         // Components should always handle mouse events for click interaction.
         if let Some(mouse) = event.as_mouse_event() {
             if mouse.kind == MouseEventKind::Down(MouseButton::Left) {
-                if let Some(editor) = self.editor_tabs.current_editor_mut() {
+                if let Some(editor) = self.editor_tab.current_editor_mut() {
                     editor.handle_mouse_events(mouse)?;
                 }
                 self.explorer.handle_mouse_events(mouse)?;
@@ -299,50 +275,50 @@ impl<'a> Component for App<'a> {
         // Handle actions returned from widgets that may need context on other widgets or app state.
         match action {
             Action::Quit | Action::Handled => Ok(action),
-            Action::Save => match self.editor_tabs.current_editor_mut() {
+            Action::Save => match self.editor_tab.current_editor_mut() {
                 None => {
-                    error!(target:Self::id(), "Failed to get current editor while handling App Action::Save");
+                    error!(target:Self::ID, "Failed to get current editor while handling App Action::Save");
                     Ok(Action::Noop)
                 }
                 Some(editor) => match editor.save() {
                     Ok(_) => Ok(Action::Handled),
                     Err(e) => {
-                        error!(target:Self::id(), "Failed to save editor contents: {e}");
+                        error!(target:Self::ID, "Failed to save editor contents: {e}");
                         Ok(Action::Noop)
                     }
                 },
             },
             Action::OpenTab => {
                 if let Ok(path) = self.explorer.selected() {
-                    let path_buf = PathBuf::from(path);
+                    let path_buf = Path::new(&path);
-                    self.editor_tabs.open_tab(&path_buf)?;
+                    self.editor_tab.open_tab(path_buf)?;
                     Ok(Action::Handled)
                 } else {
                     Ok(Action::Noop)
                 }
             }
-            Action::CloseTab => match self.editor_tabs.close_current_tab() {
+            Action::CloseTab => match self.editor_tab.close_current_tab() {
                 Ok(_) => Ok(Action::Handled),
                 Err(_) => Ok(Action::Noop),
             },
             Action::ReloadFile => {
-                trace!(target:Self::id(), "Reloading file for current editor");
+                trace!(target:Self::ID, "Reloading file for current editor");
-                if let Some(editor) = self.editor_tabs.current_editor_mut() {
+                if let Some(editor) = self.editor_tab.current_editor_mut() {
                     editor
                         .reload_contents()
                         .map(|_| Action::Handled)
                         .context("Failed to handle Action::ReloadFile")
                 } else {
-                    error!(target:Self::id(), "Failed to get current editor while handling App Action::ReloadFile");
+                    error!(target:Self::ID, "Failed to get current editor while handling App Action::ReloadFile");
                     Ok(Action::Noop)
                 }
             }
             Action::ShowHideLogger => {
-                self.logger.component_state.togget_visible();
+                self.logger.component_state.toggle_visible();
                 Ok(Action::Handled)
             }
             Action::ShowHideExplorer => {
-                self.explorer.component_state.togget_visible();
+                self.explorer.component_state.toggle_visible();
                 Ok(Action::Handled)
             }
             Action::ShowHideAbout => {

src/tui/component.rs

@@ -1,3 +1,7 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 #![allow(dead_code, unused_variables)]
 
 use crate::tui::component::Focus::Inactive;
@@ -111,7 +115,7 @@ impl FocusState for ComponentState {
     fn with_focus(self, focus: Focus) -> Self {
         Self {
             focus,
-            vis: Visibility::Visible,
+            vis: self.vis,
             help_text: self.help_text,
         }
     }
@@ -142,7 +146,7 @@ pub enum Visibility {
 pub trait VisibleState {
     fn with_visible(self, vis: Visibility) -> Self;
     fn set_visible(&mut self, vis: Visibility);
-    fn togget_visible(&mut self);
+    fn toggle_visible(&mut self);
 }
 
 impl VisibleState for ComponentState {
@@ -158,7 +162,7 @@ impl VisibleState for ComponentState {
         self.vis = vis;
     }
 
-    fn togget_visible(&mut self) {
+    fn toggle_visible(&mut self) {
         match self.vis {
             Visibility::Visible => self.set_visible(Visibility::Hidden),
             Visibility::Hidden => self.set_visible(Visibility::Visible),

src/tui/editor.rs

@@ -1,3 +1,7 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 use crate::tui::component::{Action, Component, ComponentState, Focus, FocusState};
 use anyhow::{Context, Result, bail};
 use edtui::{
@@ -9,6 +13,7 @@ use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
 use ratatui::layout::{Alignment, Rect};
 use ratatui::prelude::{Color, Style};
 use ratatui::widgets::{Block, Borders, Padding, Widget};
+use std::path::PathBuf;
 use syntect::parsing::SyntaxSet;
 
 pub struct Editor {
@@ -20,12 +25,10 @@ pub struct Editor {
 }
 
 impl Editor {
-    pub fn id() -> &'static str {
+    pub const ID: &str = "Editor";
-        "Editor"
-    }
 
-    pub fn new(path: &std::path::PathBuf) -> Self {
+    pub fn new(path: &std::path::Path) -> Self {
-        trace!(target:Self::id(), "Building {}", Self::id());
+        trace!(target:Self::ID, "Building {}", Self::ID);
         Editor {
             state: EditorState::default(),
             event_handler: EditorEventHandler::default(),
@@ -39,24 +42,24 @@ impl Editor {
     }
 
     pub fn reload_contents(&mut self) -> Result<()> {
-        trace!(target:Self::id(), "Reloading editor file contents {:?}", self.file_path);
+        trace!(target:Self::ID, "Reloading editor file contents {:?}", self.file_path);
         match self.file_path.clone() {
             None => {
-                error!(target:Self::id(), "Failed to reload editor contents with None file_path");
+                error!(target:Self::ID, "Failed to reload editor contents with None file_path");
                 bail!("Failed to reload editor contents with None file_path")
             }
             Some(path) => self.set_contents(&path),
         }
     }
 
-    pub fn set_contents(&mut self, path: &std::path::PathBuf) -> Result<()> {
+    pub fn set_contents(&mut self, path: &std::path::Path) -> Result<()> {
-        trace!(target:Self::id(), "Setting Editor contents from path {:?}", path);
+        trace!(target:Self::ID, "Setting Editor contents from path {:?}", path);
         if let Ok(contents) = std::fs::read_to_string(path) {
             let lines: Vec<_> = contents
                 .lines()
                 .map(|line| line.chars().collect::<Vec<char>>())
                 .collect();
-            self.file_path = Some(path.clone());
+            self.file_path = Some(PathBuf::from(path));
             self.state.lines = Lines::new(lines);
             self.state.cursor.row = 0;
             self.state.cursor.col = 0;
@@ -66,10 +69,10 @@ impl Editor {
 
     pub fn save(&self) -> Result<()> {
         if let Some(path) = &self.file_path {
-            trace!(target:Self::id(), "Saving Editor contents {:?}", path);
+            trace!(target:Self::ID, "Saving Editor contents {:?}", path);
             return std::fs::write(path, self.state.lines.to_string()).map_err(|e| e.into());
         };
-        error!(target:Self::id(), "Failed saving Editor contents; file_path was None");
+        error!(target:Self::ID, "Failed saving Editor contents; file_path was None");
         bail!("File not saved. No file path set.")
     }
 }
@@ -86,7 +89,7 @@ impl Widget for &mut Editor {
             .syntax_set
             .find_syntax_by_extension(lang)
             .map(|s| s.name.to_string())
-            .unwrap_or("Unknown".to_string());
+            .unwrap_or_else(|| String::from("Unknown"));
 
         EditorView::new(&mut self.state)
             .wrap(true)

src/tui/editor_tab.rs

@@ -1,3 +1,7 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 use crate::tui::component::{Action, Component, Focus, FocusState};
 use crate::tui::editor::Editor;
 use anyhow::{Context, Result, anyhow};
@@ -19,35 +23,20 @@ pub struct EditorTab {
 }
 
 impl EditorTab {
-    fn id() -> &'static str {
+    pub const ID: &str = "EditorTab";
-        "EditorTab"
-    }
 
-    pub fn new(path: Option<&std::path::PathBuf>) -> Self {
+    pub fn new() -> Self {
-        trace!(target:Self::id(), "Building EditorTab with path {path:?}");
+        trace!(target:Self::ID, "Building {}", Self::ID);
-        match path {
+        Self {
-            None => Self {
+            editors: HashMap::new(),
-                editors: HashMap::new(),
+            tab_order: Vec::new(),
-                tab_order: Vec::new(),
+            current_editor: 0,
-                current_editor: 0,
-            },
-            Some(path) => {
-                let tab_order = vec![path.to_string_lossy().to_string()];
-                Self {
-                    editors: HashMap::from([(
-                        tab_order.first().unwrap().to_owned(),
-                        Editor::new(path),
-                    )]),
-                    tab_order,
-                    current_editor: 0,
-                }
-            }
         }
     }
 
     pub fn next_editor(&mut self) {
         let next = (self.current_editor + 1) % self.tab_order.len();
-        trace!(target:Self::id(), "Moving from {} to next editor tab at {}", self.current_editor, next);
+        trace!(target:Self::ID, "Moving from {} to next editor tab at {}", self.current_editor, next);
         self.set_tab_focus(Focus::Active, next);
         self.current_editor = next;
     }
@@ -57,7 +46,7 @@ impl EditorTab {
             .current_editor
             .checked_sub(1)
             .unwrap_or(self.tab_order.len() - 1);
-        trace!(target:Self::id(), "Moving from {} to previous editor tab at {}", self.current_editor, prev);
+        trace!(target:Self::ID, "Moving from {} to previous editor tab at {}", self.current_editor, prev);
         self.set_tab_focus(Focus::Active, prev);
         self.current_editor = prev;
     }
@@ -66,7 +55,7 @@ impl EditorTab {
         match self.tab_order.get(index) {
             None => {
                 if !self.tab_order.is_empty() {
-                    error!(target:Self::id(), "Failed to get editor tab key with invalid index {index}");
+                    error!(target:Self::ID, "Failed to get editor tab key with invalid index {index}");
                 }
                 None
             }
@@ -84,16 +73,16 @@ impl EditorTab {
     }
 
     pub fn set_current_tab_focus(&mut self, focus: Focus) {
-        trace!(target:Self::id(), "Setting current tab {} focus to {:?}", self.current_editor, focus);
+        trace!(target:Self::ID, "Setting current tab {} focus to {:?}", self.current_editor, focus);
         self.set_tab_focus(focus, self.current_editor)
     }
 
     pub fn set_tab_focus(&mut self, focus: Focus, index: usize) {
-        trace!(target:Self::id(), "Setting tab {} focus to {:?}", index, focus);
+        trace!(target:Self::ID, "Setting tab {} focus to {:?}", index, focus);
         if focus == Focus::Active && index != self.current_editor {
             // If we are setting another tab to active, disable the current one.
             trace!(
-                target:Self::id(),
+                target:Self::ID,
                 "New tab {} focus set to Active; Setting current tab {} to Inactive",
                 index,
                 self.current_editor
@@ -102,12 +91,12 @@ impl EditorTab {
         }
         match self.get_editor_key(index) {
             None => {
-                error!(target:Self::id(), "Failed setting tab focus for invalid key {index}");
+                error!(target:Self::ID, "Failed setting tab focus for invalid key {index}");
             }
             Some(key) => match self.editors.get_mut(&key) {
                 None => {
                     error!(
-                        target:Self::id(),
+                        target:Self::ID,
                         "Failed to update tab focus at index {} with invalid key: {}",
                         self.current_editor,
                         self.tab_order[self.current_editor]
@@ -118,13 +107,13 @@ impl EditorTab {
         }
     }
 
-    pub fn open_tab(&mut self, path: &std::path::PathBuf) -> Result<()> {
+    pub fn open_tab(&mut self, path: &std::path::Path) -> Result<()> {
-        trace!(target:Self::id(), "Opening new EditorTab with path {:?}", path);
+        trace!(target:Self::ID, "Opening new EditorTab with path {:?}", path);
         if self
             .editors
             .contains_key(&path.to_string_lossy().to_string())
         {
-            warn!(target:Self::id(), "EditorTab already opened with this file");
+            warn!(target:Self::ID, "EditorTab already opened with this file");
             return Ok(());
         }
 
@@ -145,18 +134,16 @@ impl EditorTab {
         let key = self
             .tab_order
             .get(index)
-            .ok_or(anyhow!(
+            .ok_or_else(|| anyhow!("Failed to get tab order with invalid index {index}"))?
-                "Failed to get tab order with invalid index {index}"
-            ))?
             .to_owned();
         match self.editors.remove(&key) {
             None => {
-                error!(target:Self::id(), "Failed to remove editor tab {key} with invalid index {index}")
+                error!(target:Self::ID, "Failed to remove editor tab {key} with invalid index {index}")
             }
             Some(_) => {
                 self.prev_editor();
                 self.tab_order.remove(index);
-                info!(target:Self::id(), "Closed editor tab {key} at index {index}")
+                info!(target:Self::ID, "Closed editor tab {key} at index {index}")
             }
         }
         Ok(())
@@ -170,10 +157,10 @@ impl EditorTab {
         // TODO: Only file name is displayed in tab title, so files with the same name in different
         //    directories will appear confusing.
         let tab_titles = self.tab_order.iter().map(|t| {
-            std::path::PathBuf::from(t)
+            std::path::Path::new(t)
                 .file_name()
                 .map(|f| f.to_string_lossy().to_string())
-                .unwrap_or("Unknown".to_string())
+                .unwrap_or_else(|| String::from("Unknown"))
         });
         // Don't set border color based on ComponentState::focus, the Editor renders the border.
         Tabs::new(tab_titles)

src/tui/explorer.rs

@@ -1,3 +1,7 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 use crate::tui::component::{Action, Component, ComponentState, Focus, FocusState};
 use anyhow::{Context, Result, bail};
 use log::trace;
@@ -7,8 +11,9 @@ use ratatui::layout::{Alignment, Position, Rect};
 use ratatui::prelude::Style;
 use ratatui::style::{Color, Modifier};
 use ratatui::widgets::{Block, Borders, StatefulWidget, Widget};
+use std::ffi::OsStr;
 use std::fs;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use tui_tree_widget::{Tree, TreeItem, TreeState};
 
 #[derive(Debug)]
@@ -20,12 +25,10 @@ pub struct Explorer<'a> {
 }
 
 impl<'a> Explorer<'a> {
-    pub fn id() -> &'static str {
+    pub const ID: &'static str = "Explorer";
-        "Explorer"
-    }
 
     pub fn new(path: &PathBuf) -> Result<Self> {
-        trace!(target:Self::id(), "Building {}", Self::id());
+        trace!(target:Self::ID, "Building {}", Self::ID);
         let explorer = Explorer {
             root_path: path.to_owned(),
             tree_items: Self::build_tree_from_path(path.to_owned())?,
@@ -40,23 +43,24 @@ impl<'a> Explorer<'a> {
 
     fn build_tree_from_path(path: PathBuf) -> Result<TreeItem<'static, String>> {
         let mut children = vec![];
-        if let Ok(entries) = fs::read_dir(&path) {
+        let clean_path = fs::canonicalize(path)?;
+        if let Ok(entries) = fs::read_dir(&clean_path) {
             let mut paths = entries
                 .map(|res| res.map(|e| e.path()))
                 .collect::<Result<Vec<_>, std::io::Error>>()
                 .context(format!(
                     "Failed to build vector of paths under directory: {:?}",
-                    path
+                    clean_path
                 ))?;
             paths.sort();
             for path in paths {
                 if path.is_dir() {
                     children.push(Self::build_tree_from_path(path)?);
                 } else {
-                    if let Ok(path) = std::path::absolute(&path) {
+                    if let Ok(path) = fs::canonicalize(&path) {
                         let path_str = path.to_string_lossy().to_string();
                         children.push(TreeItem::new_leaf(
-                            path_str,
+                            path_str + uuid::Uuid::new_v4().to_string().as_str(),
                             path.file_name()
                                 .context("Failed to get file name from path.")?
                                 .to_string_lossy()
@@ -67,22 +71,16 @@ impl<'a> Explorer<'a> {
             }
         }
 
-        let abs = std::path::absolute(&path)
-            .context(format!(
-                "Failed to find absolute path for TreeItem: {:?}",
-                path
-            ))?
-            .to_string_lossy()
-            .to_string();
         TreeItem::new(
-            abs,
+            clean_path.to_string_lossy().to_string() + uuid::Uuid::new_v4().to_string().as_str(),
-            path.file_name()
+            clean_path
-                .expect("Failed to get file name from path.")
+                .file_name()
+                .context(format!("Failed to get file name from path: {clean_path:?}"))?
                 .to_string_lossy()
                 .to_string(),
             children,
         )
-        .context("Failed to build tree from path.")
+        .context(format!("Failed to build tree from path: {clean_path:?}"))
     }
 
     pub fn selected(&self) -> Result<String> {
@@ -99,7 +97,10 @@ impl<'a> Explorer<'a> {
 impl<'a> Widget for &mut Explorer<'a> {
     fn render(self, area: Rect, buf: &mut Buffer) {
         if let Ok(tree) = Tree::new(&self.tree_items.children()) {
-            let file_name = self.root_path.file_name().unwrap_or("Unknown".as_ref());
+            let file_name = self
+                .root_path
+                .file_name()
+                .unwrap_or_else(|| OsStr::new("Unknown"));
             StatefulWidget::render(
                 tree.block(
                     Block::default()
@@ -145,7 +146,7 @@ impl<'a> Component for Explorer<'a> {
     fn handle_key_events(&mut self, key: KeyEvent) -> Result<Action> {
         if key.code == KeyCode::Enter {
             if let Ok(selected) = self.selected() {
-                if PathBuf::from(&selected).is_file() {
+                if Path::new(&selected).is_file() {
                     return Ok(Action::OpenTab);
                 }
             }

src/tui/logger.rs

@@ -1,3 +1,7 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 use crate::tui::component::{Action, Component, ComponentState, Focus, FocusState};
 use log::{LevelFilter, trace};
 use ratatui::buffer::Buffer;
@@ -15,12 +19,10 @@ pub struct Logger {
 }
 
 impl Logger {
-    pub fn id() -> &'static str {
+    pub const ID: &str = "Logger";
-        "Logger"
-    }
 
     pub fn new() -> Self {
-        trace!(target:Self::id(), "Building {}", Self::id());
+        trace!(target:Self::ID, "Building {}", Self::ID);
         let state = TuiWidgetState::new();
         state.transition(TuiWidgetEvent::HideKey);
         Self {

src/tui/menu_bar.rs

@@ -1,7 +1,12 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 use crate::tui::component::{Action, Component, ComponentState, FocusState};
 use crate::tui::menu_bar::MenuBarItemOption::{
     About, CloseTab, Exit, Reload, Save, ShowHideExplorer, ShowHideLogger,
 };
+use anyhow::Context;
 use log::trace;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{KeyCode, KeyEvent};
@@ -83,13 +88,11 @@ pub struct MenuBar {
 }
 
 impl MenuBar {
-    pub fn id() -> &'static str {
+    pub const ID: &str = "MenuBar";
-        "MenuBar"
-    }
 
     const DEFAULT_HELP: &str = "(←/h)/(→/l): Select option | Enter: Choose selection";
     pub fn new() -> Self {
-        trace!(target:Self::id(), "Building {}", Self::id());
+        trace!(target:Self::ID, "Building {}", Self::ID);
         Self {
             selected: MenuBarItem::File,
             opened: None,
@@ -154,7 +157,7 @@ impl MenuBar {
             height,
         };
         // TODO: X offset for item option? It's fine as-is, but it might look nicer.
-        // trace!(target:Self::id(), "Building Rect under MenuBar popup {}", rect);
+        // trace!(target:Self::ID, "Building Rect under MenuBar popup {}", rect);
         rect
     }
 }
@@ -192,7 +195,11 @@ impl Component for MenuBar {
                 }
                 KeyCode::Enter => {
                     if let Some(selected) = self.list_state.selected() {
-                        let selection = self.selected.options()[selected];
+                        let selection = self
+                            .selected
+                            .options()
+                            .get(selected)
+                            .context("Failed to get selected MenuBar option")?;
                         return match selection {
                             Save => Ok(Action::Save),
                             Exit => Ok(Action::Quit),