VSinerva/freesewing
1
0
Fork 0
Code Activity

feat: Flat import of markdown repo

Browse source 
This is a flat (without history) import of (some of) the content
from our markdown module.

We've imported this without history because the repo contains our
blog posts and showcases posts content prior to porting them to strapi.

Since this contains many images, it would balloon the size of this repo
to import the full history.

Instead, please refer to the history of the (archived) markdown repo
at: https://github.com/freesewing/markdown
This commit is contained in:
Joost De Cock 2021-08-25 16:09:31 +02:00
parent 1671a896b5
commit b34a2ee2ed
6132 changed files with 244167 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

60
markdown/dev/tutorials/pattern-design/creating-the-closure/de.md Normal file
View file

@ -0,0 +1,60 @@
---
title: 210|Creating the closure
---
Things are starting to look good, but we can't fit the bib over the baby's head like this. So we must create a closure. We'll let the straps overlap at the end, and put in a snap.
To round the straps, we'll use something new: **a macro**.
Macros are little helpers that automate things that would otherwise get rather tedious. There are macros to add titles to your pattern, or grainline indicators, a scalebox, and there's a macro to round corners. The `round` macro.
Before we can use it, we have to update our `part.shorthand()` call to indicate that we'd also like to make use of macros. Simple add `macro` at the end:
```js
let {
Point,
points,
Path,
paths,
measurements,
options,
macro
} = part.shorthand();
```
We need a half circle here, but the `round` macro works on 90° angles, so you'll use it twice.
As such, let's add some points to guide the macro, and then put it to work:
```js
let strap = points.edgeTop.dy(points.top);
points.tipRight = points.edgeTop.translate(strap / 2, strap / 2);
points.tipRightTop = new Point(points.tipRight.x, points.edgeTop.y);
points.tipRightBottom = new Point(points.tipRight.x, points.top.y);
macro("round", {
from: points.edgeTop,
to: points.tipRight,
via: points.tipRightTop,
prefix: "tipRightTop",
render: true
});
macro("round", {
from: points.tipRight,
to: points.top,
via: points.tipRightBottom,
prefix: "tipRightBottom",
render: true
});
```
<Fixme> Add link to macro/extend docs </Fixme>
<Example pattern="tutorial" part="step7" caption="Pretty good, but how are we going to fit it over the baby's head?" />
Like our neck opening, we've only drawn half since we can simply copy the points to the other side.
However, doing so would make both straps overlap. Which doesn't work for a pattern as it would make it impossible to cut it out of a single piece of fabric. So let's deal with the overlap next.

67
markdown/dev/tutorials/pattern-design/creating-the-closure/en.md Normal file
View file

@ -0,0 +1,67 @@
---
title: Creating the closure
order: 210
---
Things are starting to look good, but we can't fit the bib over the baby's head like this.
So we must create a closure. We'll let the straps overlap at the end, and put in a snap.
To round the straps, we'll use something new: **a macro**.
Macros are little helpers that automate things that would otherwise get rather tedious.
There are macros to add titles to your pattern, or grainline indicators, a scalebox, and
there's a macro to round corners. The `round` macro.
Before we can use it, we have to update our `part.shorthand()` call to indicate that we'd
also like to make use of macros. Simply add `macro` at the end:
```js
let {
Point,
points,
Path,
paths,
measurements,
options,
macro
} = part.shorthand();
```
We need a half circle here, but the `round` macro works on 90° angles, so you'll use it twice.
As such, let's add some points to guide the macro, and then put it to work:
```js
let strap = points.edgeTop.dy(points.top);
points.tipRight = points.edgeTop.translate(strap / 2, strap / 2);
points.tipRightTop = new Point(points.tipRight.x, points.edgeTop.y);
points.tipRightBottom = new Point(points.tipRight.x, points.top.y);
macro("round", {
from: points.edgeTop,
to: points.tipRight,
via: points.tipRightTop,
prefix: "tipRightTop",
render: true
});
macro("round", {
from: points.tipRight,
to: points.top,
via: points.tipRightBottom,
prefix: "tipRightBottom",
render: true
});
```
<Fixme> Add link to macro/extend docs </Fixme>
<Example pattern="tutorial" part="step7" caption="Pretty good, but how are we going to fit it over the baby's head?" />
Like our neck opening, we've only drawn half since we can simply copy the points to the other side.
However, doing so would make both straps overlap. Which doesn't work for a pattern as it would make it
impossible to cut it out of a single piece of fabric. So let's deal with the overlap next.

60
markdown/dev/tutorials/pattern-design/creating-the-closure/es.md Normal file
View file

@ -0,0 +1,60 @@
---
title: 210|Creating the closure
---
Things are starting to look good, but we can't fit the bib over the baby's head like this. So we must create a closure. We'll let the straps overlap at the end, and put in a snap.
To round the straps, we'll use something new: **a macro**.
Macros are little helpers that automate things that would otherwise get rather tedious. There are macros to add titles to your pattern, or grainline indicators, a scalebox, and there's a macro to round corners. The `round` macro.
Before we can use it, we have to update our `part.shorthand()` call to indicate that we'd also like to make use of macros. Simple add `macro` at the end:
```js
let {
Point,
points,
Path,
paths,
measurements,
options,
macro
} = part.shorthand();
```
We need a half circle here, but the `round` macro works on 90° angles, so you'll use it twice.
As such, let's add some points to guide the macro, and then put it to work:
```js
let strap = points.edgeTop.dy(points.top);
points.tipRight = points.edgeTop.translate(strap / 2, strap / 2);
points.tipRightTop = new Point(points.tipRight.x, points.edgeTop.y);
points.tipRightBottom = new Point(points.tipRight.x, points.top.y);
macro("round", {
from: points.edgeTop,
to: points.tipRight,
via: points.tipRightTop,
prefix: "tipRightTop",
render: true
});
macro("round", {
from: points.tipRight,
to: points.top,
via: points.tipRightBottom,
prefix: "tipRightBottom",
render: true
});
```
<Fixme> Add link to macro/extend docs </Fixme>
<Example pattern="tutorial" part="step7" caption="Pretty good, but how are we going to fit it over the baby's head?" />
Like our neck opening, we've only drawn half since we can simply copy the points to the other side.
However, doing so would make both straps overlap. Which doesn't work for a pattern as it would make it impossible to cut it out of a single piece of fabric. So let's deal with the overlap next.

60
markdown/dev/tutorials/pattern-design/creating-the-closure/fr.md Normal file
View file

@ -0,0 +1,60 @@
---
title: 210|Creating the closure
---
Les choses commencent à prendre forme, mais nous ne pouvons pas passer le bavoir sur la tête du bébé comme ça. Alors nous devons créer un système de fermeture. Nous allons faire chevaucher les attaches à leurs extrémités, et y mettre un bouton pression.
To round the straps, we'll use something new: **a macro**.
Les macros sont de petites assistantes qui automatisent les tâches qui autrement seraient un peu fastidieuses. Il existe des macros pour ajouter des titres à votre patron, ou des indicateurs de droit-fil, une échelle, et il y a une macro pour arrondir les coins. La macro `round`.
Avant de pouvoir l'utiliser, nous devons mettre à jour notre appel à `part.shorthand()` pour indiquer que nous aimerions également utiliser des macros. Ajoutez simplement `macro` à la fin :
```js
let {
Point,
points,
Path,
paths,
measurements,
options,
macro
} = part.shorthand();
```
Nous avons besoin d'un demi cercle ici, mais la macro `round` fonctionne sur des angles à 90°, alors nous allons l'utiliser deux fois.
Ainsi, ajoutons donc quelques points pour guider la macro, puis la laisser faire son travail :
```js
let strap = points.edgeTop.dy(points.top);
points.tipRight = points.edgeTop.translate(strap / 2, strap / 2);
points.tipRightTop = new Point(points.tipRight.x, points.edgeTop.y);
points.tipRightBottom = new Point(points.tipRight.x, points.top.y);
macro("round", {
from: points.edgeTop,
to: points.tipRight,
via: points.tipRightTop,
prefix: "tipRightTop",
render: true
});
macro("round", {
from: points.tipRight,
to: points.top,
via: points.tipRightBottom,
prefix: "tipRightBottom",
render: true
});
```
<Fixme> Add link to macro/extend docs </Fixme>
<Example pattern="tutorial" part="step7" caption="Pretty good, but how are we going to fit it over the baby's head?" />
Comme pour l'encolure, nous avons seulement dessiné la moitié étant donné que nous pouvons copier les points pour l'autre côté.
Toutefois, le faire engendrerait un chevauchement des attaches. Ce qui ne fonctionne pas pour un patron puisque cela rendrait impossible de le couper à partir d'une simple pièce de tissu. Alors occupons-nous ensuite du chevauchement.

60
markdown/dev/tutorials/pattern-design/creating-the-closure/nl.md Normal file
View file

@ -0,0 +1,60 @@
---
title: 210|Creating the closure
---
Het begint er goed uit te zien, maar op deze manier krijgen we het slabbetje niet over baby's hoofdje. We hebben een sluiting nodig. We gaan de bandjes aan het uiteinde laten overlappen en er een drukknoop op zetten.
To round the straps, we'll use something new: **a macro**.
Macro's zijn kleine helpers die dingen automatiseren die anders heel snel heel saai zouden worden. Er zijn macro's om titels toe te voegen aan je patroon, of aanwijzingen van de stofrichting, een schaalkader, ... en er is dus ook een macro om hoeken af te ronden: de `round`-macro.
Voordat we die kunnen gebruiken, moeten we onze `part.shorthand()`-call updaten om aan te geven dat we ook graag macro's willen gebruiken. Voeg gewoon `macro` toe op het einde:
```js
let {
Point,
points,
Path,
paths,
measurements,
options,
macro
} = part.shorthand();
```
We hebben hier een halve cirkel nodig. De `round`-macro werkt met hoeken van 90 graden, dus je gebruikt hem hier twee keer.
We voegen een paar punten toe om de macro te begeleiden, en dan zetten we hem aan het werk:
```js
let strap = points.edgeTop.dy(points.top);
points.tipRight = points.edgeTop.translate(strap / 2, strap / 2);
points.tipRightTop = new Point(points.tipRight.x, points.edgeTop.y);
points.tipRightBottom = new Point(points.tipRight.x, points.top.y);
macro("round", {
from: points.edgeTop,
to: points.tipRight,
via: points.tipRightTop,
prefix: "tipRightTop",
render: true
});
macro("round", {
from: points.tipRight,
to: points.top,
via: points.tipRightBottom,
prefix: "tipRightBottom",
render: true
});
```
<Fixme> Add link to macro/extend docs </Fixme>
<Example pattern="tutorial" part="step7" caption="Pretty good, but how are we going to fit it over the baby's head?" />
Net zoals bij de halsopening hebben we hier maar de helft getekend. We kunnen de punten gewoon kopiëren naar de andere kant.
Probleem: als we dat doen, overlappen de bandjes. En dat werkt niet voor een naaipatroon, want dan krijg je het niet uit één stuk stof geknipt. Dus moeten we de overlapping oplossen.