Struct ImportStep 

pub struct ImportStep;

Adds every body of the STEP file file — its solids, and its sheets of faces — to the part, where the file has them: the parts of an assembly each where it is placed, in millimetres.

Named import(I,sK) for the K-th body of the file and the operation I, what it is made of import(I,sK,X) after its entity X in the file: vN, eN, fN for the file’s N-th vertex, edge and face, counted as the body has them. A face going all the way round an axis is cut into sectors fN,qM, along meridians fN,mM — one going round a torus’ tube likewise into pieces fN,qM along parallels fN,mM, and a whole torus first into bands fN,bK along parallels fN,mK starting at fN,mK,v, and a strip turning more than once into pieces fN,qM along meridians fN,mM; an edge split where a cut crosses it, or because it closes on itself, into pieces eN,pM at the vertices eN,cM.

The file’s bodies, as read, are the step’s target imported: read once, and again only when the file changes. Where the file disagrees with itself further than the kernel can carry as one point or curve, what is rebuilt from its surfaces — and how far it moved — is kept with its body there (ImportedBody::healed) and shown in the dialog.

Trait Implementations

impl Clone for ImportStep

fn clone(&self) -> ImportStep

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ImportStep

impl Debug for ImportStep

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

Formats the value using the given formatter.

impl Default for ImportStep

fn default() -> ImportStep

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ImportStep

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Editable for ImportStep

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

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

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

Adds the bodies the step read (see imported).

impl Operation for ImportStep

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

The name programs store its steps under.

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

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

No file yet.

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

Reads the file, then adds its bodies.

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

The file: a STEP file of the workspace, chosen in its explorer, or one the user adds from elsewhere, which the front end stores next to the program — and what the import rebuilt, body by body, as the step last read them.

const KIND: &'static str = "import_step"

The name programs store its steps under.

const INFO: OperationInfo

type Args = ImportStepArgs

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 ImportStep

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ImportStep

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 ImportStep