The screenshot below is about Montecatini Pro by Louise Fili, I would like to make something similar to my typeface, especially with letter O and I as you can see on Fo, To and Ti.
I noticed that she has just O and I as “small caps” (I don’t think they are small caps because there are only these two with same proportions) and they become of those proportions when they have the T before and after or when you have FOT and FIT (except when you have other ligatures in between).
So my question is: Did she make new glyphs like TO, FO, OT, TI, FI and so on and then contextualized with Open Type?
I don’t think that pair of letters are small caps, it wouldn’t make sense to do it for just two letters…
Maybe you can code “put that O or I when I have T or F before and after”? It’s just a suppose, I’m not an expert of Open Type… Any suggestions?
This is best done using contextual substitutions which is done with code. For example:
Feature calt:
sub F O' T by O.small;
sub T O' R by O.small;
sub R O' L by O.centerSmall;
sub L O' T by O.centerSmall;
sub T I' by I.small;
The single quote ' after a glyph name defines which glyph gets substituted. Optionally, write a sequence of context glyph names before or after it, like in the code above.
Use classes to match a broader context. Classes are added in the Class section of the Features tab and references using @ClassName or written directly using square brackets. For example:
@SomeClass = [R V Y];
sub [F T V W] O' @SomeClass by O.small;
If I use the feature calt code you wrote, writing all combinations of letters, how can I set my letter O? You wrote O.small, do you set it as small caps or stylistic set?
Montecatini was done almost exclusively with contextual alternates. This has nothing to do with small caps.
Probably best to make yourself familiar with feature code. Otherwise you won’t be able to do anything like this. In the tutorials, look for the Features topic.
O.small is just an example name. Duplicate your normal O glyph, give it a name like O.small, O.mini, O.sc, or something similar. That is the name that appeals to the right of the by keyword in the code.
If your font already has a glyph that you can reuse, that is fine, too. For example, if you font already had small caps named A.sc, B.sc, …, then you can reuse those glyphs for the calt feature.
I tried your suggestions and I reached my goals! Thank you!
I have another question: I made some alt and small glyphs to make dlig, if I want to add all diacritic letters to my ligatures what is the easiest way? Better work with your Open Type suggestions and then adjust them with kerning (as I did for TO-FO-FI-TI) or making new dlig for every diacritics letters?
If I want to make ligatures (i.e. EA-LK-RO etc…) where both letters change, how can I code them? I tried making classes and when just a letter change it works, but what if both change? (like in my orange dlig examples)
sub [E Eacute Egrave]' [A Adieresis] by [E.alt Eacute.alt Egrave.alt];
sub [E.alt Eacute.alt Egrave.alt] [A Adieresis]' by [A.longtail Adieresis.longtail];
This way, you can substitute any combination of diacritics to contextual alternates.
This can be better organised by giving each group a name like this:
@E.alt_0 = [E Eacute Egrave];
@E.alt_1 = [E.alt Eacute.alt Egrave.alt];
@A.longtail_0 = [A Adieresis];
@A.longtail_1 = [A.longtail Adieresis.longtail];
sub @E.alt_0' @A.longtail_0 by @E.alt_1;
sub @E.alt_1 @A.longtail_0' by @A.longtail_1;
I was trying to type some words but some of them “collide” each other (especially R-K-any vowels and L-L-any vowels).
In example below I’m ok with KA ligature but before K I want a default R, in case I have a word finishing with RK . In the word BELLO, first L is not a default L, maybe because I have a calt L-L and it can’t read it.
How can I fix those issues with code?
In such cases, you can use “ignore” statement. And once you start doing this, it is probably good idea to separate each case into a lookup. Then, the ignore statement only affects only within the lookup and not others.
lookup R_K {
ignore sub R' @K.alt_0 [@A.alt_0 @I.alt_0 @O.alt_0 @U.alt_0];
sub @R.alt_0' @K.alt_0 by @R.alt_1
} R_K;
The “ignore” line states the case you don’t want R to be substituted.
Tip 1: you need the asterisk. Tip 2: you can group the groups using the square brackets. In this example, RKA, RKI, RKO, RKU cases are checked and ignored.
I tried to type your code but it doesn’t work… I think I did something wrong. @R.DEF_01 is the group where I put default R’s (different from R.DEFAULT because I need it for short-legged R), I didn’t group K’s because there are only two of them.
I guess because something else had happened by that point of lookup? The line 81 & 82 look suspicious because the RK context is met and both change already. The lookup need to kick in earlier in the code; to give a more general advice, I advise you put longer context substitutions at the top of the code.
Also, the two K group need to be in the square brackets. Otherwise the ignore statement checks for 4 letter case of R’s, K.alt, Kcommaaccent.alt, then A/I/O’s, instead of 3.
