Struct Hem 

pub struct Hem;

Folds the straight edge edge of a sheet-metal body right back on itself, for the operation H: a bend of half a turn and a flat lying back over the sheet, the fold’s outside where the edge was — the sheet set back by the fold’s outer radius — and the hem length long from there. The body is consumed and rebuilt as hem(H), its entities named as crate::EdgeFlange names a flange’s, hem(H,bend), hem(H,flange), …

edge is an edge of a flat face on the body’s outline, and the hem folds towards that face’s side. kind says how tight (gap is the space between an open hem and the sheet), and offset_start / offset_end how far in from the edge’s ends it runs, the body’s relief beside it where it does not reach them.

Trait Implementations

impl Clone for Hem

fn clone(&self) -> Hem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Hem

impl Debug for Hem

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

Formats the value using the given formatter.

impl Default for Hem

fn default() -> Hem

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Hem

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Editable for Hem

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

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

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

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

The name programs store its steps under.

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

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

No edge yet: a closed hem, a third of a unit long.

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

The edge, picked; how tight, and the gap if open; how long; and how far in from the edge’s ends.

const KIND: &'static str = "hem"

The name programs store its steps under.

const INFO: OperationInfo

type Args = HemArgs

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: &HemArgs) -> 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 Hem

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Hem

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 Hem