Try this:

```
SetAttributes[createPrimitive, HoldAll]
createPrimitive[patt_, expr_] :=
Typeset`MakeBoxes[p : patt, fmt_, Graphics] :=
Typeset`MakeBoxes[Interpretation[expr, p], fmt, Graphics]
```

Example:

```
createPrimitive[face[x_: 0.1],
{Circle[{0, 0}, 1], Circle[{-0.3, 0.5}, x],
Circle[{0.3, 0.5}, x], Line[{{-0.4, -0.2}, {0.4, -0.2}}]}]
```

It works as expected in `Graphics`

:

```
g = Graphics[face[]]
```

`face`

has no `DownValues`

so it remains as `face`

in `InputForm`

:

```
InputForm[g]
(* Graphics[face[]] *)
```

```
(* Graphics[face[], ImageSize -> {63., Automatic}] *)
```

It works with `GeometricTransformation`

:

```
Graphics[GeometricTransformation[face[0.2], ShearingTransform[Pi/4, {1, 0}, {0, 1}]]]
```

**A note about colours**

A commenter asked *"How would you rewrite this function to color the different components differently?"* The answer is that colours can be used in the definition of the custom primitive just as in any other graphics expression, but note that the expression that goes into `Typeset`MakeBoxes`

must be something that the Front End understands, e.g. `RGBColor[1,0,0]`

rather than `Red`

. If you want to use named colours like `Red`

you will need to let the kernel evaluate the expression to convert them to `RGBColor`

directives.

So for example you could:

Manually specify the colours as `RGBColor`

directives:

```
createPrimitive[myprim[x_], {RGBColor[1, 0, 0], Circle[{0, 0}, x]}]
```

Use named colours and override the hold attribute with `Evaluate`

:

```
createPrimitive[myprim[x_], Evaluate @ {Red, Circle[{0, 0}, x]}]
```

Or just remove the hold attribute completely:

```
ClearAttributes[createPrimitive, HoldAll];
createPrimitive[myprim[x_], {Red, Circle[{0, 0}, x]}]
```

In the last two cases you should guard against `x`

already having a value, e.g. with `Block`

or by using `\[FormalX]`

instead of `x`

2

`Rectangle`

is a function turning some parameters into a graphics object. Such a function for rounded rectangles can be found in this post: http://mathematica.stackexchange.com/questions/1882/rectangle-with-rounded-edges – C. E. – 2013-06-18T08:19:38.273Suzan, I don't understand what you are looking for in this question. Can you be a bit more explicit about what you are looking for? – bill s – 2013-06-18T10:05:12.087

Are you asking how to define an object that

Mathematicawill treat as a graphic primitive such as`Disk`

or`Circle`

? – m_goldberg – 2013-06-18T10:14:10.923@m_goldberg, yes it can be said this way – Suzan Cioc – 2013-06-18T10:17:21.093

@Anon thanks! didn't knew about this parameter for rectangle; but the general question persists – Suzan Cioc – 2013-06-18T10:18:38.240

So if your geometric object (let's call it

`myShape`

) was defined so that`myShape[]`

was a valid form (as it is for`Circle`

, you would expect evaluating`Graphics[myShape[]]`

to draw it, and not produce the message: "myShape is not a Graphics primitive or directive."? – m_goldberg – 2013-06-18T10:31:03.3371You might want to look into the old packages

`Graphics`Arrow``

or`Graphics`Spline``

to see how they implemented primitives that were once not built-in. – J. M.'s ennui – 2013-06-18T10:49:49.057@0x4A4D how to see the code? :) – Suzan Cioc – 2013-06-18T11:02:00.080

Well, look for the packages in your

Mathematicainstallation... – J. M.'s ennui – 2013-06-18T11:16:57.8201It seems that you are under a common misconception. As far as the kernel is concerned,

`Graphics`

is inert, i.e. it hasno`DownValues`

. It is only in the formatting end of things that it is turned into an image. The same applies to the primitives, like`Rectangle`

, but they are only formatted when found within a`Graphics(3D)`

object. So,`Rectangle`

remains a`Rectangle`

and`GeometricTransformation`

can be applied to it. – rcollyer – 2013-06-18T12:31:59.680