docs: Minor fixes

Author: gpeairs

CHANGELOG.md

@@ -8,6 +8,10 @@ The format of this changelog is based on
 
   - Added `set_periodic!` to `SolidModels` to enable periodic meshes.
 
+### Fixed
+
+  - `DecoratedStyle` and `CompoundStyle` are no longer missing any of the methods `width`, `trace`, or `gap` (forwarded to the underlying style)
+
 ## 1.2.0 (2025-04-28)
 
   - Composite components can define `_build_subcomponents` to return a `NamedTuple` with keys that differ from component names

README.md

@@ -24,14 +24,14 @@ DeviceLayout.jl provides functionality for 2D/2.5D device CAD, including generat
 
 ## Installation
 
-Julia can be downloaded [here](https://julialang.org/downloads/). We support Julia v1.10 or later.
+You can follow [these instructions](https://julialang.org/install/) to install Julia. We support Julia v1.10 or later.
 
-From Julia, install DeviceLayout.jl using the built-in package manager:
+From Julia, install DeviceLayout.jl using the built-in package manager, [Pkg.jl](https://pkgdocs.julialang.org/v1/getting-started/):
 
-```julia
-import Pkg
-Pkg.activate(".") # Activates an environment in the current directory
-Pkg.add("DeviceLayout")
+```r
+julia> ] # Pressing ] in the Julia REPL activates the Pkg REPL mode
+pkg> activate . # Activates an environment in the current directory
+pkg> add DeviceLayout # Adds DeviceLayout.jl to the environment
 ```
 
 We recommend [using an environment for each project](https://julialang.github.io/Pkg.jl/v1/environments/) rather than installing packages in the default environment.
@@ -47,15 +47,16 @@ The recommended IDE for Julia is [Visual Studio Code](https://code.visualstudio.
 with the [Julia for Visual Studio Code extension](https://www.julia-vscode.org/).
 
 Since Julia has a just-in-time compiler, the first time code is executed may take much
-longer than any other times. This means that a lot of time will be wasted repeating
-compilations if you run DeviceLayout.jl in a script like you would in other languages. For
-readability, it is best to split up your CAD code into functions that have clearly named
-inputs and perform a well-defined task.
+longer than subsequent times in the same Julia session. This means that a lot of time will be wasted repeating
+compilations if you run your DeviceLayout.jl code by calling a script from the command line each time,
+like you might in other languages.
 
-It is also best to avoid writing statements in global scope. In other words, put most of
-your code in a function. Your CAD script should ideally look like the following:
+For readability, it is best to split up your CAD code into functions that have clearly named
+inputs and perform a well-defined task. It is also best to avoid writing statements in global scope.
+In other words, put most of your code in a function. Your CAD script should ideally look like the following:
 
 ```julia
+# mycad.jl
 using DeviceLayout, DeviceLayout.PreferredUnits, FileIO
 
 function subroutine1()

docs/src/examples/singletransmon.md

@@ -109,7 +109,7 @@ mesh to disk as `single_transmon.msh2` in the Gmsh 2.2 mesh format, and
 `single_transmon.gds`. Finally, there's a `mesh_order` keyword that sets the element
 order for the generated mesh.
 
-The schematic design is significantly simplied compared to that of the [quantum processor
+The schematic design is significantly simplified compared to that of the [quantum processor
 example](qpu17.md), but has the same general structure. The three components are
 added to the schematic graph and attached to each other before being placed by `plan` into a floorplan,
 which is then furnished with air bridges.

docs/src/geometry.md

@@ -6,7 +6,7 @@ Any `AbstractGeometry` subtype will have a bounding box and associated methods.
     DeviceLayout.AbstractGeometry
     coordinatetype
     bounds(::DeviceLayout.AbstractGeometry)
-    center
+    center(::DeviceLayout.AbstractGeometry)
     lowerleft
     upperright
     footprint

docs/src/geometrylevel.md

@@ -26,9 +26,7 @@ dogbone = union2d([r, r2, r3]) # Boolean union of the three rectangles as a sing
 rounded_dogbone = Rounded(4μm)(dogbone) # Apply the Rounded style
 ```
 
-It's a bit hard to read, but the result is a `StyledEntity{T,U,S}` with three type parameters: the coordinate type `T = typeof(1.0μm}`, the underlying entity type `U = ClippedPolygon{T}`, and the style `S = Rounded{T}`—that is, it is a `GeometryEntity` that composes the result of a polygon clipping (Boolean) operation with a `GeometryEntityStyle` specifying rules for rounding that entity.
-
-What's notable here is that `rounded_dogbone` only describes the vertices of the dogbone polygon and the rounding radius—in particular, it has not done any calculations to find a discretization of the rounded corners.
+The printed output above is a bit hard to read, and it's not necessary to understand it in detail to get started. The most important information here is that `rounded_dogbone` is a certain kind of `GeometryEntity` that only describes the vertices of the dogbone polygon and the rounding radius—in particular, we have not discretized the rounded corners to represent the result as a polygon. In more detail, `rounded_dogbone` is a `StyledEntity{T,U,S}` with three type parameters: the coordinate type `T = typeof(1.0μm}`, the underlying entity type `U = ClippedPolygon{T}`, and the style `S = Rounded{T}`—that is, it is a `GeometryEntity` that composes the result of a polygon clipping (Boolean) operation with a `GeometryEntityStyle` specifying rules for rounding that entity.
 
 ## Cells and Rendering
 

docs/src/index.md

@@ -27,14 +27,14 @@ This documentation includes some examples of what you can do with DeviceLayout.j
 
 ## Installation
 
-Julia can be downloaded [here](https://julialang.org/downloads/). We support Julia v1.10 or later.
+You can follow [these instructions](https://julialang.org/install/) to install Julia. We support Julia v1.10 or later.
 
-From Julia, install DeviceLayout.jl using the built-in package manager:
+From Julia, install DeviceLayout.jl using the built-in package manager, [Pkg.jl](https://pkgdocs.julialang.org/v1/getting-started/):
 
-```julia
-import Pkg
-Pkg.activate(".") # Activates an environment in the current directory
-Pkg.add("DeviceLayout")
+```r
+julia> ] # Pressing ] in the Julia REPL activates the Pkg REPL mode
+pkg> activate . # Activates an environment in the current directory
+pkg> add DeviceLayout # Adds DeviceLayout.jl to the environment
 ```
 
 We recommend [using an environment for each project](https://julialang.github.io/Pkg.jl/v1/environments/) rather than installing packages in the default environment.
@@ -125,15 +125,16 @@ its open files for changes, making it easy to use as a fast previewer alongside
 The recommended IDE for Julia is [Visual Studio Code](https://code.visualstudio.com/) with the [Julia for Visual Studio Code extension](https://www.julia-vscode.org/).
 
 Since Julia has a just-in-time compiler, the first time code is executed may take much
-longer than any other times. This means that a lot of time will be wasted repeating
-compilations if you run DeviceLayout.jl in a script like you would in other languages. For
-readability, it is best to split up your CAD code into functions that have clearly named
-inputs and perform a well-defined task.
+longer than subsequent times in the same Julia session. This means that a lot of time will be wasted repeating
+compilations if you run your DeviceLayout.jl code by calling a script from the command line each time,
+like you might in other languages.
 
-It is also best to avoid writing statements in global scope. In other words, put most of
-your code in a function. Your CAD script should ideally look like the following:
+For readability, it is best to split up your CAD code into functions that have clearly named
+inputs and perform a well-defined task. It is also best to avoid writing statements in global scope.
+In other words, put most of your code in a function. Your CAD script should ideally look like the following:
 
 ```julia
+# mycad.jl
 using DeviceLayout, DeviceLayout.PreferredUnits, FileIO
 
 function subroutine1()

src/DeviceLayout.jl

@@ -346,7 +346,7 @@ export GDSMeta,
     abstract type AbstractPolygon{T} <: GeometryEntity{T} end
 
 Anything you could call a polygon regardless of the underlying representation.
-Currently only `Rectangle` or `Polygon` are concrete subtypes, but one could
+Currently only `Rectangle`, `Polygon`, and `ClippedPolygon` are concrete subtypes, but one could
 imagine further subtypes to represent specific shapes that appear in highly
 optimized pattern formats. Examples include the OASIS format (which has 25
 implementations of trapezoids) or e-beam lithography pattern files like the Raith

src/entities.jl

@@ -91,6 +91,7 @@ bounds(geo0::AbstractGeometry, geo1::AbstractGeometry, geo::AbstractGeometry...)
     center(geos)
 
 Return the center of the bounding rectangle [`bounds(geo)`](@ref) or `bounds(geos)`.
+Note that this point doesn't have to be in `ent`.
 
 Will not throw an `InexactError` even if `geo` has integer coordinates, but instead return
 floating point coordinates.

src/polygons.jl

@@ -414,31 +414,10 @@ function DeviceLayout.transform(c::ClippedPolygon, f::Transformation)
     return ClippedPolygon(t)
 end
 
-"""
-    lowerleft(x::Polygon)
-
-Return the lower-left-most corner of a rectangle bounding polygon `x`.
-Note that this point doesn't have to be in the polygon.
-"""
 DeviceLayout.lowerleft(x::Polygon) = lowerleft(x.p)
-
-"""
-    upperright(x::Polygon)
-
-Return the upper-right-most corner of a rectangle bounding polygon `x`.
-Note that this point doesn't have to be in the polygon.
-"""
 DeviceLayout.upperright(x::Polygon) = upperright(x.p)
-
 DeviceLayout.footprint(x::Polygon) = x
 
-@doc """
-    center(p::Polygon)
-
-Return the center of a polygon's bounding box (`Point` object).
-Note that this point doesn't have to be in the polygon.
-""" center(p::Polygon)
-
 function convert(::Type{Polygon{T}}, s::Rectangle) where {T}
     ll = convert(Point{T}, s.ll)
     ur = convert(Point{T}, s.ur)

src/references.jl

@@ -257,8 +257,8 @@ coordinate system of `d` to the coordinate system of `c`.
 If the *same exact* `GeometryReference` (as in `===`, same address in
 memory) is included multiple times in the tree of references, then the resulting
 transform will be based on the first time it is encountered. The tree is
-traversed one level at a time to find the reference (optimized for shallow
-references).
+traversed using a depth-first search (but checking all references of a
+structure before looking inside each reference).
 
 Example: You want to translate (2.0,3.0) in the coordinate system of the
 referenced coordinate system `d` to the coordinate system of `c`:

src/transform.jl

@@ -185,7 +185,7 @@ rotation(f::Union{Translation, IdentityTransformation}; α0=0) = 0
 """
     preserves_angles(f::Transformation)
 
-Return `true` if `f`` is angle-preserving (has equal-magnitude eigenvalues) and `false` otherwise.
+Return `true` if `f` is angle-preserving (has equal-magnitude eigenvalues) and `false` otherwise.
 
 Uses approximate equality to allow for floating point imprecision.
 """