Struct FlatPattern 

pub struct FlatPattern;

Unfolds the sheet-metal body named solid into its flat pattern, for the operation P: every bend laid flat as a strip as wide as its developed length (angle * (radius + k_factor * thickness), see crate::SheetMetalRules), every flat face moved with it, the body’s first face where it was. The flat body is the solid flat_pattern(P), and each of its entities is named after the one it is the unfolded copy of, flat_pattern(P,X) for X — so a bend’s faces are flat_pattern(P,X,a) for its faces X,a, and the lines it is bent along the edges between it and its flat faces. The body is replaced by its flat pattern unless keep.

The bend lines — down the middle of each bend’s strip — are also the sketch flat_pattern(P,bend_lines), on the flat pattern’s A side, one line per bend in the order the bends were made; and what each bend is is recorded for the flat body as FlatPatternData (see crate::body::sheets).

Only a body whose bends were recorded as it was built — by a base flange and its flanges — unfolds, and only while it is still made of just the faces they built: a body some other step has changed is refused, naming the faces that are not sheet metal.

Trait Implementations

impl Clone for FlatPattern

fn clone(&self) -> FlatPattern

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for FlatPattern

impl Debug for FlatPattern

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FlatPattern

fn default() -> FlatPattern

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FlatPattern

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Editable for FlatPattern

const INFO: OperationInfo = <FlatPattern as ::geop_core_editor::part_operation::PartOperation>::INFO

type EditingState = FormState<<FlatPattern as PartOperation>::Session>

What the editor keeps about a step while it is edited, beyond its arguments, starting from the default whenever a step is opened.

fn new_args(context: &Context<'_>) -> Self::Args

The arguments of a new step: sensible defaults, taking the part it is inserted into into account.

fn presentation( context: &Context<'_>, args: &Self::Args, editing: &Self::EditingState, ) -> Form

What the editor shows while the step is edited. Never fails: an editor needs the form most exactly when the arguments do not build, so whatever is wrong is said in it.

fn process_user_event( context: &Context<'_>, args: &Self::Args, editing: &Self::EditingState, event: Event, ) -> (Self::Args, Self::EditingState)

The step’s arguments and editing state after event.

impl ModelOperation for FlatPattern

fn build( model: &mut NamedModel, reader: &Reader<'_>, step: &str, _: &FlatPatternArgs, ) -> GeopResult<()>

Builds the step step — what everything it makes is named after — into model, reading whatever else it builds on through reader, so the step is rebuilt when that changes.

impl Operation for FlatPattern

const KIND: &'static str = <FlatPattern as ::geop_core_editor::part_operation::PartOperation>::KIND

The name programs store its steps under.

type Args = <FlatPattern as PartOperation>::Args

What a step of the operation is given. It is saved with the program, so it names targets and elements, never holds their internal ids.

fn run(ctx: &mut StepContext<'_>, args: &Self::Args) -> __GeopResult<()>

Declares what the step produces, through ctx (see StepContext::produce): cheap, since it runs in every run. What takes work is done in the makes, which run only when what they read changed.

impl PartOperation for FlatPattern

fn new_args(context: &Context<'_>) -> FlatPatternArgs

The newest sheet-metal body.

fn run(ctx: &mut StepContext<'_>, args: &FlatPatternArgs) -> GeopResult<()>

Unfolds the body, and draws its bend lines as a sketch.

fn form<'a>( context: &'a Context<'a>, args: &FlatPatternArgs, _: &FormState<()>, ) -> EditForm<'a, FlatPatternArgs>

The body, picked, and whether to keep it.

const KIND: &'static str = "flat_pattern"

The name programs store its steps under.

const INFO: OperationInfo

type Args = FlatPatternArgs

What a step is given. It is saved with the program, so it names targets and elements, never holds their internal ids.

type Session = ()

What the editor keeps while a step is edited besides its arguments and the visuals selected: () for most.

fn begin_event(session: &mut Self::Session)

What the session forgets at the start of every event, before the event is handled: nothing, by default.

fn canvas( context: &Context<'_>, edit: Edit<'_, Self::Args, Self::Session>, event: &CanvasEvent, )

What the pointer or a key did on the canvas: nothing, by default.

impl PartialEq for FlatPattern

fn eq(&self, other: &FlatPattern) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for FlatPattern

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FlatPattern