Struct SheetCut 

pub struct SheetCut;

Cuts through a sheet-metal body along a sketch, for the operation C: the body is consumed and rebuilt as sheet_cut(C), every face, edge and vertex it had keeping its name except those the cut splits or takes away.

Every area of sketch is projected onto the flat face face, along its normal, and cut out straight through the sheet: a hole where it lies inside the face, a notch where it reaches over the face’s outline, and where it reaches past the face into a bend — and on into the next flat — it is cut through the bend as the bend lies unrolled, so that the flat pattern shows it exactly as drawn. The cut is recorded with the body’s bends: the body still unfolds.

The edges the cut makes are named after the sketch’s pieces: piece X of sketch K gives sheet_cut(C,K,X) — ...,0, ...,1 along it where the body’s edges split it — with its edges ...,a and ...,b and its wall as crate::thicken says. An edge of the body the cut splits becomes E,0, E,1, … along it.

Refused, by name: a sketch not parallel to the face, an area with a hole in it (whose island would fall out), a cut that crosses an edge at its end, touches one or runs along one, crosses a curve that is no line or arc, splits a face in two or takes one away, or misses the sheet.

Trait Implementations

impl Clone for SheetCut

fn clone(&self) -> SheetCut

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SheetCut

impl Debug for SheetCut

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

Formats the value using the given formatter.

impl Default for SheetCut

fn default() -> SheetCut

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SheetCut

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Editable for SheetCut

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

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

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

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

The name programs store its steps under.

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

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

The newest sketch, on the face it lies on.

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

The sketch, picked, and the face, if not the one the sketch lies on.

const KIND: &'static str = "sheet_cut"

The name programs store its steps under.

const INFO: OperationInfo

type Args = SheetCutArgs

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: &SheetCutArgs) -> 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 SheetCut

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for SheetCut

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 SheetCut