Add tooltip documentation to the Text node and tidy up node catalog categorization (GraphiteEditor#3645)

* Add more node doc comments

* Tidy up node categories

Author: Keavon

editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs

@@ -1452,7 +1452,7 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 		#[cfg(feature = "gpu")]
 		DocumentNodeDefinition {
 			identifier: "Upload Texture",
-			category: "Debug: GPU",
+			category: "Debug",
 			node_template: NodeTemplate {
 				document_node: DocumentNode {
 					implementation: DocumentNodeImplementation::Network(NodeNetwork {

node-graph/libraries/wgpu-executor/src/texture_conversion.rs

@@ -254,7 +254,7 @@ impl<'i> Convert<Raster<CPU>, &'i WgpuExecutor> for Raster<GPU> {
 	}
 }
 
-/// Uploads an raster texture from the CPU to the GPU. This Is now deprecated and the Convert node should be used in the future.
+/// Uploads an raster texture from the CPU to the GPU. This is now deprecated and the Convert node should be used in the future.
 ///
 /// Accepts either individual raster data or a table of raster elements and converts it to the GPU format using the WgpuExecutor's device and queue.
 #[node_macro::node(category(""))]

node-graph/nodes/brush/src/brush.rs

@@ -60,7 +60,7 @@ impl<P: Pixel + Alpha> Sample for BrushStampGenerator<P> {
 /// Controls the brush shape with diameter and hardness, plus color and opacity (via flow).
 /// The feather exponent is calculated from hardness to determine edge softness.
 /// Used internally to create the brush texture before stamping it repeatedly along a stroke path.
-#[node_macro::node(skip_impl)]
+#[node_macro::node(category(""), skip_impl)]
 fn brush_stamp_generator(#[unit(" px")] diameter: f64, color: Color, hardness: f64, flow: f64) -> BrushStampGenerator<Color> {
 	// Diameter
 	let radius = diameter / 2.;
@@ -80,7 +80,7 @@ fn brush_stamp_generator(#[unit(" px")] diameter: f64, color: Color, hardness: f
 }
 
 /// Used to efficiently paint brush strokes. Applies the same texture repeatedly at different positions with proper blending and boundary handling.
-#[node_macro::node(skip_impl)]
+#[node_macro::node(category(""), skip_impl)]
 fn blit<BlendFn>(mut target: Table<Raster<CPU>>, texture: Raster<CPU>, positions: Vec<DVec2>, blend_mode: BlendFn) -> Table<Raster<CPU>>
 where
 	BlendFn: for<'any_input> Node<'any_input, (Color, Color), Output = Color>,

node-graph/nodes/gcore/src/context_modification.rs

@@ -10,7 +10,7 @@ use raster_types::{CPU, GPU, Raster};
 
 /// Filters out what should be unused components of the context based on the specified requirements.
 /// This node is inserted by the compiler to "zero out" unused context components.
-#[node_macro::node(category("Internal"))]
+#[node_macro::node(category(""))]
 async fn context_modification<T>(
 	ctx: impl Ctx + CloneVarArgs + ExtractAll,
 	/// The data to pass through, evaluated with the stripped down context.

node-graph/nodes/gcore/src/ops.rs

@@ -7,17 +7,17 @@ pub use core_types::ops::TypeNode;
 // TODO: Rename to "Passthrough" and make this the node that users use, not the one defined in document_node_definitions.rs
 /// Passes-through the input value without changing it.
 /// This is useful for rerouting wires for organization purposes.
-#[node_macro::node(skip_impl)]
+#[node_macro::node(category(""), skip_impl)]
 fn identity<'i, T: 'i + Send>(value: T) -> T {
 	value
 }
 
-#[node_macro::node(skip_impl)]
+#[node_macro::node(category(""), skip_impl)]
 fn into<'i, T: 'i + Send + Into<O>, O: 'i + Send>(_: impl Ctx, value: T, _out_ty: PhantomData<O>) -> O {
 	value.into()
 }
 
-#[node_macro::node(skip_impl)]
+#[node_macro::node(category(""), skip_impl)]
 async fn convert<'i, T: 'i + Send + Convert<O, C>, O: 'i + Send, C: 'i + Send>(ctx: impl Ctx + ExtractFootprint, value: T, converter: C, _out_ty: PhantomData<O>) -> O {
 	value.convert(*ctx.try_footprint().unwrap_or(&Footprint::DEFAULT), converter).await
 }

node-graph/nodes/gstd/src/text.rs

@@ -3,41 +3,63 @@ use graph_craft::wasm_application_io::WasmEditorApi;
 use graphic_types::Vector;
 pub use text_nodes::*;
 
+/// Draws a text string as vector geometry with a choice of font and styling.
 #[node_macro::node(category("Text"))]
 fn text<'i: 'n>(
 	_: impl Ctx,
-	#[scope("editor-api")] editor_resources: &'i WasmEditorApi,
+	/// The Graphite editor's source for global font resources.
+	#[scope("editor-api")]
+	editor_resources: &'i WasmEditorApi,
+	/// The text content to be drawn.
 	#[widget(ParsedWidgetOverride::Custom = "text_area")]
 	#[default("Lorem ipsum")]
 	text: String,
-	#[widget(ParsedWidgetOverride::Custom = "text_font")] font: Font,
+	/// The typeface used to draw the text.
+	#[widget(ParsedWidgetOverride::Custom = "text_font")]
+	font: Font,
+	/// The font size used to draw the text.
 	#[unit(" px")]
 	#[default(24.)]
 	#[hard_min(1.)]
 	size: f64,
+	/// The line height ratio, relative to the font size. Each line is drawn lower than its previous line by the distance of *Size* × *Line Height*.
+	///
+	/// 0 means all lines overlap. 1 means all lines are spaced by just the font size. 1.2 is a common default for readable text. 2 means double-spaced text.
 	#[unit("x")]
 	#[hard_min(0.)]
 	#[step(0.1)]
 	#[default(1.2)]
 	line_height: f64,
+	/// Additional spacing, in pixels, added between each character.
 	#[unit(" px")]
 	#[step(0.1)]
 	character_spacing: f64,
-	#[widget(ParsedWidgetOverride::Hidden)] has_max_width: bool,
+	/// Whether the *Max Width* property is enabled so that lines can wrap to fit its specified block width.
+	#[widget(ParsedWidgetOverride::Hidden)]
+	has_max_width: bool,
+	/// The maximum width that the text block can occupy before wrapping to a new line. Otherwise, lines do not wrap.
 	#[unit(" px")]
 	#[hard_min(1.)]
 	#[widget(ParsedWidgetOverride::Custom = "optional_f64")]
 	max_width: f64,
-	#[widget(ParsedWidgetOverride::Hidden)] has_max_height: bool,
+	/// Whether the *Max Height* property is enabled so that lines beyond it are not drawn.
+	#[widget(ParsedWidgetOverride::Hidden)]
+	has_max_height: bool,
+	/// The maximum height that the text block can occupy. Excess lines are not drawn.
 	#[unit(" px")]
 	#[hard_min(1.)]
 	#[widget(ParsedWidgetOverride::Custom = "optional_f64")]
 	max_height: f64,
+	/// The angle of faux italic slant applied to each glyph.
 	#[unit("°")]
 	#[hard_min(-85.)]
 	#[hard_max(85.)]
 	tilt: f64,
-	#[widget(ParsedWidgetOverride::Custom = "text_align")] align: TextAlign,
+	/// The horizontal alignment of each line of text within its surrounding box.
+	/// To have an effect on a single line of text, *Max Width* must be set.
+	#[widget(ParsedWidgetOverride::Custom = "text_align")]
+	align: TextAlign,
+	/// Whether to split every letterform into its own vector path element. Otherwise, a single compound path is produced.
 	separate_glyph_elements: bool,
 ) -> Table<Vector> {
 	let typesetting = TypesettingConfig {

node-graph/nodes/gstd/src/wasm_application_io.rs

@@ -29,7 +29,7 @@ use web_sys::{CanvasRenderingContext2d, HtmlCanvasElement};
 
 /// Allocates GPU memory and a rendering context for vector-to-raster conversion.
 #[cfg(feature = "wgpu")]
-#[node_macro::node(category("Debug: GPU"))]
+#[node_macro::node(category(""))]
 async fn create_surface<'a: 'n>(_: impl Ctx, editor: &'a WasmEditorApi) -> Arc<WasmSurfaceHandle> {
 	Arc::new(editor.application_io.as_ref().unwrap().create_window())
 }

node-graph/nodes/math/src/lib.rs

@@ -758,7 +758,7 @@ fn vec2_value(_: impl Ctx, _primary: (), x: f64, y: f64) -> DVec2 {
 
 /// Constructs a color value which may be set to any color, or no color.
 #[node_macro::node(category("Value"))]
-fn color_value(_: impl Ctx, _primary: (), #[default(Color::RED)] color: Table<Color>) -> Table<Color> {
+fn color_value(_: impl Ctx, _primary: (), #[default(Color::BLACK)] color: Table<Color>) -> Table<Color> {
 	color
 }
 

node-graph/nodes/raster/src/std_nodes.rs

@@ -29,7 +29,7 @@ impl From<std::io::Error> for Error {
 	}
 }
 
-#[node_macro::node(category("Debug: Raster"))]
+#[node_macro::node(category("Debug"))]
 pub fn sample_image(ctx: impl ExtractFootprint + Clone + Send, image_frame: Table<Raster<CPU>>) -> Table<Raster<CPU>> {
 	image_frame
 		.into_iter()
@@ -279,7 +279,7 @@ pub fn extend_image_to_bounds(_: impl Ctx, image: Table<Raster<CPU>>, bounds: DA
 		.collect()
 }
 
-#[node_macro::node(category("Debug: Raster"))]
+#[node_macro::node(category("Debug"))]
 pub fn empty_image(_: impl Ctx, transform: DAffine2, color: Table<Color>) -> Table<Raster<CPU>> {
 	let width = transform.transform_vector2(DVec2::new(1., 0.)).length() as u32;
 	let height = transform.transform_vector2(DVec2::new(0., 1.)).length() as u32;

node-graph/nodes/vector/src/vector_nodes.rs

@@ -176,7 +176,7 @@ async fn stroke<V, L: IntoF64Vec>(
 	/// The stroke color.
 	#[default(Color::BLACK)]
 	color: Table<Color>,
-	/// The stroke weight.
+	/// The stroke thickness.
 	#[unit(" px")]
 	#[default(2.)]
 	weight: f64,