Struct EdgeFlange 

pub struct EdgeFlange;

Bends a flange up from the straight edge edge of a sheet-metal body, for the operation F: the body is consumed and rebuilt as edge_flange(F), every face, edge and vertex it had keeping its name except the edge, which the flange replaces.

edge is an edge of a flat face of the body on its outline (where the face meets a wall across the thickness), and the flange turns angle degrees towards that face’s side, length long as reference says, with its bend’s inner radius radius (the body’s own by default), set as position says. It runs along the edge from offset_start after the edge’s start to offset_end before its end (the edge running with its face on its left, seen from outside); where it is narrower than the edge, the body’s relief is cut beside the bend. An end of the edge that meets a bend already there keeps the body’s corner gap from it — or, with a closed corner, its flat reaches on to the other flange.

What it builds is named edge_flange(F,...): the bend bend, the flange’s flat face flange with its edges flange,line where the bend ends, flange,side0, flange,end and flange,side1 — and where a closed corner carries its flat past its bend, flange,corner0 or flange,corner1 on from its line; where the bend starts on the body line, the rest of the edge before and after, and the reliefs relief0,in, relief0,across, relief0,out (and relief1,...) — each a face’s name with a/b added, an edge’s or a wall’s as crate::thicken says.

Trait Implementations

impl Clone for EdgeFlange

fn clone(&self) -> EdgeFlange

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for EdgeFlange

impl Debug for EdgeFlange

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

Formats the value using the given formatter.

impl Default for EdgeFlange

fn default() -> EdgeFlange

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EdgeFlange

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Editable for EdgeFlange

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

type EditingState = FormState<<EdgeFlange 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 EdgeFlange

fn build( model: &mut NamedModel, reader: &Reader<'_>, step: &str, _: &EdgeFlangeArgs, ) -> 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 EdgeFlange

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

The name programs store its steps under.

type Args = <EdgeFlange 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 EdgeFlange

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

No edge yet: a right angle, half a unit long, material inside.

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

The edge, picked; angle and length; what the length is measured from and where the bend sits; the radius, if its own; and how far in from the edge’s ends.

const KIND: &'static str = "edge_flange"

The name programs store its steps under.

const INFO: OperationInfo

type Args = EdgeFlangeArgs

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 run(ctx: &mut StepContext<'_>, args: &EdgeFlangeArgs) -> GeopResult<()>

Declares what the step produces, through ctx (see StepContext::produce).

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 EdgeFlange

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for EdgeFlange

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 EdgeFlange