They work on my computer in Yosemite (Intel Mac Pro, early 2009) from ID glyph palette.

Yes, me too — but you can’t directly use the OpenType features to access small caps, old style figures, etc. These features work with Seravek, though, which is also bundled with Yosemite…
I’m lost.

I can open the ttc file in Fontographer will do some research to see what is different between Seravek and Iowan Old Style. (Iowan is a great font and a longtime favorite of mine too

Thank you very much — I tried to open it in FontLab myself, but couldn’t succeed.

I looked at opentype features for Iowan after opening and the regular Roman appears to only have kerning features. Seravek on the other hand is full of opentype features. Iowan thus appears to not have had opentype features added to do what you seek.

OK, so we’re screwed, right? Thank you very much for trying, anyway.

I'm sure that the Yosemite version has AAT features, not OpenType features. So the glyphs are there, but InDesign doesn't recognize the features.

Apple shows no real signs of abandoning AAT; it serves their needs, has some performance advantages, and the compatibility advantages of OpenType don't seem to matter to them.

And obviously there’s no way to change the AAT into an OpenType format? And that doesn’t explain why Seravek.ttc (also bundled with Yosemite) works perfectly fine…

I am still on OS X 10.9 where Seravek is an opentype font. As for Iowan Old Style, it has no lookup except kern. Bangla MN is AAT. I have no tool to check all .ttc files in batch and get statistics.

Correction: Iowan Old Style Black has the following opentype tables: aalt, salt, ornm, smcp, c2sc, onum, pnum, tnum, liga, ordn, frac, sups, sinf, numr, dnom, subs, kern

Iowan Old Style Black Italic and Iowan Old Style Titling also have useful GSUB opentype tables. It is only the four standard fonts that are left with only a kern table.

More precisely, here is the script I executed:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import fontforge,sys

filename=sys.argv[1].decode('utf-8')

def disptable(fnt):
for t in ['gsub', 'gpos']:
lkp = eval("fnt.%s_lookups" % (t))
print("  %s: %s" % \
(t, ', '.join(["%s" % (p[0:6]) for p in lkp])))

lstfonts = fontforge.fontsInFile(filename)
for f in lstfonts:
print "<strong>%s</strong>" %(f)
fnt=fontforge.open("%s(%s)" % (filename,f))
disptable(fnt)

and here is a copy paste of the trace of execution

% lsttables 'Iowan Old Style.ttc' 2>/dev/null
Iowan Old Style Black
  gsub: 'aalt', 'salt', 'ornm', 'smcp', 'c2sc', 'onum', 'pnum', 'tnum', 'liga', 'liga', Single, 'ordn', Single, Single, Single, 'frac', 'sups', 'sinf', 'numr', 'dnom'
  gpos: 'subs', 'kern'
Iowan Old Style Black Italic
  gsub: 'aalt', 'salt', 'ornm', 'smcp', 'c2sc', 'onum', 'pnum', 'tnum', 'liga', 'liga', Single, 'ordn', Single, Single, Single, 'frac', Single, 'sups', 'sinf', 'numr', 'dnom'
  gpos: 'subs', 'kern'
Iowan Old Style Bold
  gsub:
  gpos: 'kern'
Iowan Old Style Bold Italic
  gsub:
  gpos: 'kern'
Iowan Old Style Italic
  gsub:
  gpos: 'kern'
Iowan Old Style Roman
  gsub:
  gpos: 'kern'
Iowan Old Style Titling
  gsub: 'aalt', 'salt', 'ornm', 'tnum', 'pnum', 'frac', Single, 'sups'
  gpos: 'kern'

where Single corresponds to a some bare single substitution table.

Here is a more useful script that lists not only the tags but their associated scripts and languages and that can be used to check for consistency.

#!/usr/bin/env python

import fontforge,sys
filename=sys.argv[1].decode('utf-8')
lstfonts = fontforge.fontsInFile(filename)

def languages(ll):
return '; '.join("%s{%s}" % (s[0], \
', '.join(l for l in s[1])) \
for s in ll)

def disptable(fnt):
for t in ['gsub', 'gpos']:
print " %s:" % (t)
lkp = eval("fnt.%s_lookups" % (t))
for p in lkp:
v = fnt.getLookupInfo(p)[2]
if v:
print " %s: %s" % \
((v[0][0]), languages(v[0][1]))

for f in lstfonts:
print "-----\n%s\n-----" %(f)
fnt=fontforge.open("%s(%s)" % (filename,f))
disptable(fnt)

Let us now come back to what can be done and what may be done.

Importing into the Regular the GSUB features of the black should take a few seconds. Since the black does not contain the Greek alphabet or cyrillic characters, the features (smallcaps, proportional figures etc) would work only for the latin script; getting more than that requires more than a few minutes.

Iowan Old Style is however a Bitstream font and Bitstream's EULA says

No Modifications.
You may not modify, adapt, translate, reverse engineer, decompile, disassemble, or create derivative works based on the Bitstream Product without Bitstream's prior written consent.

The pertinant EULA in this case is Apple's, not Bitstream's, since the font is provided by Apple to the end user, but the effect is the same:

L. No Reverse Engineering. You may not, and you agree not to or enable others to, copy (except as expressly permitted by this License or by the Usage Rules if they are applicable to you), decompile, reverse engineer, disassemble, attempt to derive the source code of, decrypt, modify, or create derivative works of the Apple Software or any services provided by the Apple Software or any part thereof...

Yeah, I thought so. But I’m sure that I’d have been absolutely unable to implement Michel’s script solution anyway… Thanks for the try nonetheless.

I wrote a script that takes as input a font (ttf, otf, ttc and even dfont) and that lists features. I provided no script to modify a font in any way.

In order to "fix" the fonts, you need no script at all.

To copy the GSUB tables, when the EULA allows it, you open the two fonts with FontForge, the one with the missing GSUB tables and the one from which to copy. In the font with the missing GSUB tables you select "Element > Font Info > Lookups" and then "GSUB" and you click "Import". You will then see the lookups from the other font. You select them and then click OK. That is it.

That assumes that the glyph names are the same in the two fonts, which I guess is good practice for a font designer if one font is the regular and the other is the bold or the black.

With a ttc font, you probably need to split before; Apple's ftxsplitter does that.

Sorry, Michel, but I’m a mere user of typefaces — I’m afraid the solutions you’re so kindly suggesting are way beyond my reach…

Opening .ttc files: You can also use the free editor Fontforge.
File in .ttc format can contain several individual files. Open them separately and export separate files which can then be dealt with in FontLab, and other font editors.
Don

That will not work. My old macports version of Fontforge as well as the most recent github version of Fontforge do not see all the glyphs of the regular that way. They miss at least the smallcaps. DTL OT Master light sees those glyphs without problem.

Use breakttc.exe (an old MS tool, 12 kB, lightning fast), http://luc.devroye.org/fonts-29817.html

Surprising that such a small program can do what FontForge can't; it however runs on Windows whereas Iowan is a Mac font; ftxsplitter is 60kB but at least runs on the Mac and does the same job (and gives better names to the fonts than FONT00.TTF, FONT01.TTF etc).

FontForge worked fine for me on Windows.
Don

Unable to get BREAKTTC.EXE to work on Windows Pro 7 64 bit.
Was anyone successful using this OS?
Don

FontForge worked fine for me on Windows.

You are confirming that you can see the letter a.smallcap in the regular with FontForge when opening the ttc file? Which version of FontForge is that? I just tried this Windows FontForge (on XP) and it simply crashed on the regular, just browsing the characters of the regular from the ttc.

As I noted above Fontographer opens tcc files on Mac just fine.

I didn't use FontForge to do anything other than open the individual files in the .ttc separately and to export new independent files, which I then dealt with in FontLab. Version: 13:48 GMT 22-Feb-2011 (20110222-ML-TtfDb-NoPython) running on Win 7 Pro 64 bit. Worked like a charm on every .ttc file I examined.
BTW I find that this version of FontForge is very robust on Win 7 Pro 64 bit. It opens files that crash FontLab.
Don

Version: 13:48 GMT 22-Feb-2011 (20110222-ML-TtfDb-NoPython)

I just downloaded that version of FontForge on XP and opened the Iowan TTC file with it. It does not crash but the small caps are still lost from the roman. You just don't see what you miss when you open it with FontForge.

Let me be more precise: the roman .ttf font as saved by the 2011 PC version of FontForge contains 1859 glyphs; I get the same count with my Macports 2012 version of FontForge. I am far from my computer with the last version of the github Fontforge but I would expect the same count; the Roman .ttf given by ftxsplitter contains 2229 glyphs (in fact I counted glyph names).

The python3 script https://gist.github.com/johnko/6442827 gives me the 2229 glyphs for the regular and appears to do the right job.

Thanks. Life is never simple. More work to do here.....
Don

I just tried AFDKO's otc2otf on the Iowan ttc font and got ttf fonts as output. To compare with the fonts extracted with ttc2ttf.py (that I modified a bit to get the same ttf file names as those given by otc2otf), I used ttx on each ttf file and then compared with the diff command: the ttx files obtained from the ttf files produced by otc2otf and ttc2ttf.py are identical. On the other hand, if I split with Apple's ftxsplitter, the modification date and the checksum differ in the generated ttx, but aside from that the ttx files generated are still the same.

FWIW, ttc2ttf.py seems to work correctly with Python 2.6.9.

Moreover, on OS X, the AFDKO commands otc2otf and otf2otc are simply bash scripts that call the following python scripts:

~/bin/FDK/Tools/SharedData/FDKScripts/otc2otf.py
~/bin/FDK/Tools/SharedData/FDKScripts/otf2otc.py

AFDKO python is currently python 2.7. 1

With FontForge, if instead of opening in the standard way you open with the following script (in the FontForge script window)

import fontforge
fnam=fontforge.openFilename("Open font file:")
f=fontforge.open(fnam,4)

you get all the glyphs. I could not find in the preferences the equivalent of the "4" flag to open .ttc files (and I found that flag only in the old FontForge native scripting documentation).