Category: Macintosh

Unit Calculator in Objective C

An piece of code I wrote in 2006, which allows you to do mathematical calculations with units from Objective-C. I’ve updated the code to Objective-C with properties and generics. It is not depended on macOS and should work fine on iOS as well.

By default the result will be in SI compatible units, but all units and prefixes (like kg or ms) can be freely defined in a configuration file units.dat. You can also force a specific unit and add variables to the term. It is also trivial to add new functions, even functions which accept a list of values.

A few examples:

((123.45e-1 + sqrt(+4) -4-.69/2)*2^1/5)^2 => 16
 avg(1,2,3,4) => 2.5
 (9*m^2)^0.5 => 3 m
 60 m + 2 mm => 60.002 m
 sqrt(9 m^2) => 3 m
 20 lb requestedUnit: kg => 9.07185 kg
 60 km/h + 12 m/s requestedUnit: km/h => 103.2 km/h
 1 Torr*760 requestedUnit: atm => 1 atm
 68 F requestedUnit: C => 20 C
 0 C + 0 C requestedUnit: C => 273.15 C --- internally temperatures are converted to Kelvin

The project is an Xcode project with a simple NSLog in the app delegate for testing. It also has a bunch of unit tests to make sure the math works out in all cases.

The code can be found on GitHub.

enableATA6

This little kernel extension allows using hard drives with more than 128MB on a Macintosh Cube. It does so by setting the flags for ATA6 inside the driver.

This project is available at GitHub.

enableATA6.h

#include <IOKit/IOService.h>
#include "IOATABlockStorageDriver.h"

class com_sarnau_enableATA6 : public IOATABlockStorageDriver
{
    OSDeclareDefaultStructors ( com_sarnau_enableATA6 )

protected:
    virtual IOReturn    identifyAndConfigureATADevice ( void );
};

enableATA6.cpp

#include "enableATA6.h"

#define super IOATABlockStorageDriver
OSDefineMetaClassAndStructors ( com_sarnau_enableATA6, IOATABlockStorageDriver );

/***
*  This kext overloads the standard IOATABlockStorageDriver (by having a IOProbeScore of 1000)
*
*  We only have to overload the identifyAndConfigureATADevice function and patch a variable
*  to enable LBA support. The problem is the IOATABusInfo class - this class checks the bus
*  interface hardware and detects that the computer is not capable of supporting LBA drives.
*  And so LBA support is disabled in general. There is a good reason to do this, because without
*  this support in the ROM the system can't read the kernel from the drive, if the kernel is
*  beyond the 128MB border. For this reason we should partition a drive and make sure that the
*  boot partition is 127.99 GB or smaller. If we don't boot from this drive, we don't have to
*  partition it.
***/
IOReturn    com_sarnau_enableATA6::identifyAndConfigureATADevice(void)
{
    // call super class (and execute IDENTIFY DEVICE commamd - see ATA6 spec for more information)
    IOReturn    err = super::identifyAndConfigureATADevice();

    // does the drive support the 48 bit command set?
    if(fDeviceIdentifyData[kATAIdentifyCommandSetSupported2] & kATASupports48BitAddressingMask)
    {
        // and is the 48 bit command set really enabled for that drive?
        if(fDeviceIdentifyData[kATAIdentifyCommandsEnabled] & kATASupports48BitAddressingMask)
        {
            // then force the use of the LBA commands in the driver
            fUseExtendedLBA = true;

            // set the "48-bit LBA supported" bit in the "ATA Features" entry in the registry
            // (this seems not to be necessary, but maybe 3rd party software checks the registry)
            fSupportedFeatures |= kIOATAFeature48BitLBA;

            // we don't increase the buffer size, which is normally done by the super class
            // when a LBA drive is recognized. So we are limited to 256 instead of 2048 blocks
            // per read or write.
        }
    }

    return err;
}

Christoph Pagalies 1968-1997

Diese Seite soll an Christoph Pagalies erinnern, der am 31. Mai 1997 nach einem 3/4 Jahr des Leidens an Krebs verstorben ist.

Christoph wurde nur 29 Jahre alt. Er studierte technische Informatik an der FH-Wedel und beendete das Studium nur Tage vor dem Ausbruch der Krankheit erfolgreich als Dipl. Ing. Schon seit seiner Schulzeit beschäftigte er sich mit der Software-Entwicklung, sowohl PD- und Shareware, als auch kommerziell. Viele Projekte haben wir zusammen geschrieben – sowohl zur guten, alten C–64 und Atari-Zeit wie auch auf dem Macintosh und dem Newton. So hat Christoph zusammen mit mir an Midi-Maze II (fast der komplette Editor stammt von Christoph), TurboAss, HyperText, Transfile Mac IQ, u.v.a.m. gearbeitet.

Die Mausefalle

Für das Studium mußten wir ein Pascal Praktikum einreichen, so begann Christoph die Mausefalle zu entwickeln. Die Mausefalle ist ein MausTausch-FrontEnd, das heißt, ein Offline-Reader für das [[http://www.maus.net|MausNet]]. Das MausNet ist ein Mailboxnetz, das im deutschsprachigen Raum mit weit über einhundert Mailboxen vertreten ist.

Durch den Maustausch kann mit Mailboxen Nachrichten tauschen und nachher lesen. Dies bietet mehrere Vorteile gegenüber dem konventionellen online-Lesen:

  • Man spart Telefongebühren, weil die Tauschzeit sehr viel kürzer ist als die Zeit, die man zum Lesen benötigt,
  • Die Mailbox wird schneller wieder frei, so daß mehr User die Mailbox frequentieren können, und
  • Man hat mehr Zeit, um sich seine Antworten in Ruhe zu überlegen.

Systemanforderungen

Um mit der Mausefalle arbeiten zu können, benötigt man:

  • Einen Macintosh
  • System 7.0 oder neuer
  • Mindestens 4 MB (eher 6 MB) Hauptspeicher (die Mausefalle selbst benötigt minimal 1 MB) Platz auf einem Volume (Festplatte), um eine Database anzulegen (je nach Lesegewohnheiten um 2 MB–5 MB oder mehr)
  • Ein Modem und ein Terminalprogramm, um mit der Mailbox zu tauschen.

Wie teuer ist die Mausefalle?

Die Mausefalle habe ich in Erinnerung an Christoph frei verfügbar gemacht, wer die Mausefalle jedoch länger als 30 Tage nutzt, muß eine Spende von mindestens 10 Euro an die Deutsche Leukämie-Forschungshilfe – Aktion für krebskranke Kinder e.V. überweisen.

Download

ZAP


Audio files that are compressed with ZAP will unpack as an absolutely bit identical 1:1 copy of the original file. ZAP is the ideal money-saving tool for cost effective archiving of audio data or for sending production quality audio via the Internet. ZAP is extremely easy to use, runs in the background and creates self extracting archives.

Features

  • Supports 16- and 24-Bit-files
  • Supports WAV and AIFF, Mono and Stereo
  • Target format can be chosen prior to compression
  • Typical compression rate: 20–60 %
  • Background Processing
  • Archives with multiple audio files
  • Simple Drag & Drop interface
  • Restores data from corrupted files

Audiowerk8 and VMR

The Audiowerk8 is a PCI recording card with 2 analog inputs, 8 individual outputs, and stereo digital I/O (S/P-DIF). Audiowerk8 is fully compatible with any MacOS or Windows 95 PCI computer. The high quality A/D D/A converters feature bitstream technology (18 bit equivalent) to ensure professional sounding results. The PCI busmaster technology allows for an uninterrupted data transfer to the card independently from the CPU load and therefore optimizes overall system performance.

Audiowerk8 is an integral part of the Logic Audio System. Up to 12 audio tracks are possible with the current versions.

The Audiowerk will ship with VMR, Virtual Multitrack Recorder software. Availability and Price Audiowerk8 with VMR will be available in the 1st Quarter 1997, and will have a suggested retail price of $799.

Download the original CD as a disk image from GitHub (158MB).

Keys 3/97 Audiowerk8 Test

Newton Keyboard Enabler

The Newton Keyboard Enabler (NKE) allows you to connect the Newton keyboard to any Macintosh and use it as a replacement for the big ADB keyboards. Very nice for presentations where space is rare.

The NKE is a system extension, but it does not do any trap patching. To be exact: the NKE is a FBA (faceless background application), that works like a normal application, but without any human interface. The NKE should work on any Macintosh with Mac OS 7 and at least one free serial port. NKE will grab the serial port, so it is not possible for any other application to use the port.

You may quit the NKE with a “Quit” AppleEvent or with the hotkey Control-Option-^. Hold the three keys for about 2 seconds down, if it doesn’t work: retry. If you are lucky, you hear three beeps, then you have to press a key on the Newton keyboard. After that, the NKE has quit.

The Newton Keyboard Enabler is freeware. You may use it as you wish, but need written permission for any commercial distribution!

Configuring the NKE

The configuration is a bit tricky, you have to use ResEdit or Resorcerer!

  • Choose the serial port — Open NKE with ResEdit and open the STR# 128 Resource. For the modem port (the default) enter “.AIn” and “.AOut”; for the printer port enter “.BIn” and “.BOut”. Pay attention to internal modems on PowerBooks etc.
  • Choose the keyboard layout and language — Open the PREF 128 resource (attention: only a Resorcerer template is available, ResEdit users have to use the hex-editor). The resource is 4 bytes long:
    • The last byte is the keyboard language. 3 is default (Germany), you may want to change it to 0 (US-English).
    • The first byte (default: 0 = off) allows you to send different codes for the shift keys of the Newton keyboard (set the value to 1). You should leave this value unchanged.

After installing NKE (dragging it onto the system folder) and connecting the keyboard to the right serial port, restart your Macintosh. If NKE can’t recognize the keyboard, you may have to check the serial port. If the keyboard layout is wrong, you have to change the keyboard language.

Hint: You may change the Filetype of NKE from “appe” to “APPL” and launch NKE directly from your desktop – no restart necessary!

The current version

NKE MacOpen Artikel

Newton Keyboard am Mac

Dieses mal will ich etwas zu dem Anschluß eines Newton Keyboards am Mac schreiben. Das Newton Keyboard ist nämlich durch seine kleinen Abmessungen ideal für Messen etc. zu verwenden.

Der Anschluß

Das Newton Keyboard ist für etwas über 100,- DM im Apple Fachhandel zu erhalten. Das kleine schwarze Keyboard wird inklusiver einer Tasche geliefert. Da es beim Newton an die serielle Schnittstelle angeschlossen wird, kam mir die Idee das Keyboard an einen Mac anzuschließen. Mit Hilfe eines Terminalprogramms habe ich schnell ermitteln können, daß das Keyboard mit 9600 Baud seine Daten an den Rechner sendet – 8 Bits pro Zeichen, keine Parität, ein Stop-Bit. Elektrisch war die Ansteuerung also kein Problem.

Nun mußte ich rausbekommen, was für Daten von der Tastatur gesendet werden. Auch hier: keine Überraschungen. Die Tastatur sendet bei jedem Tastendruck bzw. beim Loslassen einer Taste ein Byte. Unterscheiden kann man das Drücken bzw. Loslassen einer Taste daran, daß beim Loslassen Bit 7 gesetzt wird. Der 7 Bit Scancode entspricht quasi zu 100% denen der normalen Mac-Keyboards.

Sobald die Schnittstelle geöffnet wird, sendet das Keyboard einen String mit Identifikationsdaten. Leider habe ich keine genaueren Informationen über den Aufbau der Daten, es reicht jedoch zur Erkennung der Newton-Tastatur.

Die Software

Die Aufgabe eines Newton Keyboard Treibers ist also recht klar umrissen: Serielle Schnittstelle öffnen, die ersten Bytes ignorieren, dann bei jedem gesendeten Byte entweder das Drücken oder das Loslassen einer Taste melden. So weit so gut. Nur wie macht man das?

Ich wollte versuchen keine Systemerweiterung zu schreiben, die irgendwelche Traps patched, sondern dachte zuerst: das muß ja einfach sein, einfach per PostEvent() das Drücken und Loslassen melden und fertig. Leider ist es “etwas” komplizierter…

Der einfache Teil ist klar: ich schreibe eine “faceless background application” kurz FBA. Ein FBA verhält sich für den normalen Anwender, wie eine Systemerweiterung und wird auch in dem Ordner installiert. Für das MacOS handelt es sich aber um ein ganz normales Mac-Programm mit Event-Loop. FBAs dürfen jedoch – mit Ausnahme des Notification Managers – keine Bildschirmausgaben tätigen. Für einen Tastaturtreiber stellt dies aber kein Problem dar. FBAs erlauben AppleEvents und so kann man sehr elegant kleinere Erweiterungen für viele Programme als FBA implementieren z.B. AppleScript-Erweiterungen für FileMaker Pro.

Die serielle Schnittstelle

Das Öffnen der Schnittstelle mit OpenDriver() ist relativ einfach und klar. Die Namen der Ports habe ich in den Resource-Fork abgelegt, so daß man sie bei Bedarf leicht ändern kann. Besser wäre natürlich ein Kontrollfeld, wo man den Port direkt wählen kann – oder die Möglichkeit den Port automatisch zu ermitteln. Die Baudrate setze ich danach auf 9600 8N1 – ist normalerweise eh Standard, aber sicher ist sicher. Handshaking ist für die Tastatur nicht nötig. Um der Tastatur die Möglichkeit zu geben ihre Identifikation zu senden, wartet der Treiber 1/2 Sekunde und liest dann alle an der seriellen Schnittstelle anliegenden Bytes ein. Welche Bytes erwartet werden, kann man dem Listing entnehmen. Ein kleiner Plausibilitätstest stellt sicher, daß auch wirklich eine Newton Tastatur angeschlossen ist.

Nun kommt aber der Trick: anstatt im Event-Loop die serielle Schnittstelle zu pollen, lese ich asynchron von der Schnittstelle! Dies belastet das MacOS fast gar nicht und bei jedem Byte, das an der Schnittstelle ankommt, wird automatisch eine Callback-Routine von mir aufgerufen. Dort verarbeite ich das gelesene Byte und starte den nächsten Lesevorgang. Einzige Falle ist hier, daß man den Parameterblock und andere Variablen globale halten muß, denn auf dem lokalen Stack würden sie ja beim Verlassen des Unterprogramms gleich gelöscht werden. Abstürze wären die Folge.

In der Testphase hat es sich als nützlich erwiesen, wenn man den Treiber beenden kann. Dazu setzt man den Dateityp nicht auf ‘appe’ (der Filetype von FBAs), sondern ganz normal auf ‘APPL’. Nun kann man den Treiber einfach per Doppelklick starten. Per Hot-Key (Control-Option-^) bzw. Quit-AppleEvent verläßt der Treiber nun den Event-Loop. Nach drei SysBeeps() wartet er auf ein letztes Byte an der serielle Schnittstelle und beendet sich dann selbst. Den Hot-Key muß man etwas länger drücken, denn der Event-Loop wird nur einmal pro Sekunde durchlaufen. Normalerweise braucht der Treiber ja diesen Event-Loop gar nicht und so kostet er wenigstens kaum Rechenzeit.

Die Scancodes

Die Tastatur meldet ja nur ein Byte für einen Tastendruck. Dieses Byte (Scancode genannt) muß nun in einen ASCII-Code umgerechnet werden. Dazu gibt es im MacOS die KMAP- und KCHR-Resourcen. KMAP erlaubt es Scancodes von verschiedenen Tastaturen zu normalisieren, d.h. auf gleiche Scancodes umzurechnen. Jede Tastatur kann ja völlig eigene Scancodes senden. Ferner wird in der KMAP-Resource definiert, bei welchen Tastendrücken die LEDs am erweiterten Keyboard angeschaltet werden. Das Newton Keyboard hat keine LEDs, so erübrigt sich weiterer Aufwand in diese Richtung.

Ebenfalls muß das Verhalten der Capslock-Taste simuliert werden. Beim Newton Keyboard wird sie ja nicht mechanisch blockiert. Man muß also per Software einen Caps-Schalter implementieren.

Den erzeugten normalisierten Keycode muß man nun in die KeyMap-Bitmaske übertragen. Diese Bitmaske erhält man, wenn man die Funktion GetKeys() aufruft. Viele Programme tun dies und wir müssen diese Bitmaske selbst aktualisieren. Hierbei gibt es folgendes zu beachten: es können mehrere Tastaturen angeschlossen sein! Jede Tastatur braucht ihre eigene interne KeyMap, die bei jedem Tastendruck einfach in die KeyMap des Systems kopiert wird.

Ferner müssen noch einige (undokumentierte) globale Variablen richtig gesetzt werden, damit u.a. Auto-Repeat funktioniert. Diese Variablen habe ich durch Analyse des originalen ADB-Treibers von Apple gefunden. Nunja, eine andere Möglichkeit kenne ich nicht und Auto-Repeat ist irgendwie zu witzig, als das man es nicht unterstützt.

Zu guter Letzt wird der Scancode in einen (oder zwei) ASCII-Codes umgerechnet. Dazu braucht man lediglich die Funktion KeyTranslate() aufrufen. Diese Funktion bekommt eine KCHR-Routine übergeben, welche beschreibt, wie man einen Scancode in einen ASCII-Code umrechnet. Unterschiedliche KCHR-Resourcen erlauben es z.B. für verschiedene Sprachen verschiedene Tastaturlayouts zu unterstützen. Die Scancodes sind nämlich – trotz unterschiedlich beschrifteter Tastenkappen – gleich! Es gibt aber noch ein paar Dinge zu beachten: Die Funktion kann zwei ASCII-Codes erzeugen, da einige Tastaturen auf einen realen Tastendruck zwei Tastendrücke simulieren. Ich glaube in Japan ist soetwas nicht unüblich. Ferner muß man den Status “state” global halten. In diesem Status wird zwischen zwei Tastendrücken gespeichert, ob z.B. ein Dead-Key gedrückt wurde. Beispiel: man drückt ein Taste, die ein Akzent einleitet und danach eine Taste, auf welche das Akzent gesetzt werden soll.

Zu guter Letzt wird der Tastendruck als keyDown bzw. keyUp Message an MacOS gepostet. Natürlich nicht ohne vorher noch ein paar undokumentierte Variablen im MacOS zu setzen. Nunja.

Die Kompilierung

Um das Programm zu kompilieren muß lediglich der Source, wie auch die Resource kompiliert werden. Das Programm bekommt als Dateityp ‘appe’ und als Creatorcode ‘NwtK’ zugewiesen. 64k Speicherzuteilung reichen dicke. Lediglich die Flags müssen sorgfältig gesetzt werden (siehe Grafik). Wer will, kann den Dateityp auf ‘APPL’ setzen und den Treiber per Doppelklick bei Bedarf starten.

Um die serielle Schnittstelle zu ändern, muß man lediglich in der STR# 128 Resource die Einträge von “.AIn” und “.AOut” (Modemanschluß) z.B. auf “.BIn” und “.BOut” (Druckeranschluß) ändern.

In der PREF 128 Resource kann man sowohl das Keyboard Layout umschalten: das letzte Byte ist 3 für Deutschland oder 0 für US-Englisch. Weitere Layouts sind möglich, man muß lediglich entsprechende KCHR-Resourcen zur Verfügung stellen. Üblichweise sind seit MacOS 7.5 alle internationalen Keyboard-Layouts bereits im System vorhanden.

Das erste Byte ermöglicht es zwischen der KMAP 0 und KMAP 1 Resource zu wählen. Diese Layouts unterscheiden sich durch die Behandlung der gemeinsamen Shift-Tasten. Üblich ist es, daß beide Shift, Command, etc. Tasten den gleichen Scancode an die Anwenderprogramme melden. Wählt man die KMAP 1 Resource, so werden diese Tasten unterschiedlich gemeldet. Programme können dies zwar per Software umschalten (MagicMac nutzt dies z.B.), aber dies erfordert die direkte Programmierung der ADB-Tastaturen, was bei unserer Newton Tastatur an der seriellen Schnittstelle halt nicht möglich ist.

Die aktuelle Version des Newton Keyboard Enablers findet sich auf http://www.emagic.de/mmm/ – neben vielen anderen Programmen von mir.

########################################
############### LISTINGs ###############
########################################
/***
 *  Newton Keyboard Enabler.c
 *
 *  Erlaubt die Nutzung eines seriellen Newton-
 *  Keyboards an einem Mac. Das Keyboard verhält
 *  sich in fast allen Fällen genau wie ein
 *  originales ADB-Keyboard (Ausnahme: MacsBug
 *  kann es nicht nutzen)
 *
 *  Entwickelt mit dem CodeWarrior 9 von
 *  Metrowerks.
 *
 *  (c)1996 MAXON Computer, Markus Fritze
 ***/

// c_moeller@macopen.com

// true, wenn das Programm beendet werden soll
Boolean gDoQuitFlag;

/***
 *  unsere AppleEvent-Routinen
 *  (schließlich sind wir ein ordentliches
 *  MacOS Programm)
 ***/
static pascal OSErr DoAENoErr(
    const AppleEvent*, AppleEvent*, long)
{
  return noErr;   // AppleEvent ist ok
}

static pascal OSErr DoAEQuitAppl(
    const AppleEvent*, AppleEvent*, long)
{
  gDoQuitFlag = true; // Programm beenden
  return noErr;
}


// einen (hoffentlich) undefinierten Code
// benutzen wir als ID-Code für die Tastatur
#define NEWTON_KEYBOARD_CODE    117L


// Zugriffsfunktionen ähnlich <LowMem.h>
// für den Tastaturtreiber
static inline SInt16 LMGetKeyLast()
        { return *(SInt16*)0x0184; };
static inline void LMSetKeyLast(SInt16 value)
        { *(SInt16*)0x0184 = value; };
static inline SInt16 LMGetHiKeyLast()
        { return *(SInt16*)0x0216; };
static inline void LMSetHiKeyLast(SInt16 value)
        { *(SInt16*)0x0216 = value; };

static inline SInt32 LMGetKeyTime()
        { return *(SInt32*)0x0186; };
static inline void LMSetKeyTime(SInt32 value)
        { *(SInt32*)0x0186 = value; };
static inline SInt32 LMGetKeyRepTime()
        { return *(SInt32*)0x018A; };
static inline void LMSetKeyRepTime(SInt32 value)
        { *(SInt32*)0x018A = value; };

// ohne "inline", wegen eines 68k Compilerbugs
// beim CodeWarrior 9
static /*inline*/ KeyMap *LMGetKeyMapPtr()
        { return (KeyMap*)0x0174; };

// Unsere globalen Variablen für die Tastatur
Handle      gKMAP;
Handle      gKCHR;
UInt8     gKeyMap[16];

/***
 *  Keyboard-Variablen initialisieren
 ***/
static void InitKeyboard()
{
  Handle  thePref =
    ::Get1Resource('PREF', 128);

  // eigener Typ: Newton Keyboard
  gKMAP = ::Get1Resource('KMAP', **thePref);
  if(!gKMAP) ::ExitToShell();
  ::HLockHi(gKMAP);

  // ein deutsches Keyboard:
  gKCHR = ::GetResource('KCHR',
          ((short*)*thePref)[1]);
  if(!gKCHR)
    // ein US-Keyboard:
    gKCHR = ::GetResource('KCHR', 0);
  if(!gKCHR) ::ExitToShell();
  ::HLockHi(gKCHR);

  // eigene Keymap löschen
  for(int i=0; i<sizeof(gKeyMap); i++)
    gKeyMap[i] = 0;

  ::ReleaseResource(thePref);
}

/***
 *  Tastencode senden
 ***/
static void PostKeyMessage(
        UInt8 inKey, UInt8 inKeyCode)
{
  // keine Taste => raus
  if(inKey == 0x00L) return;

  // Message zusammensetzen
  UInt32  theMessage = inKey
        | UInt16(inKeyCode << 8)
        | (NEWTON_KEYBOARD_CODE << 16);

  // Taste gedrückt
  if(!(inKeyCode & 0x80)) {
    SInt32  theTicks = LMGetTicks();
    LMSetKeyTime(theTicks);
    LMSetKeyRepTime(theTicks);
    LMSetKeyLast(theMessage);
    LMSetHiKeyLast(NEWTON_KEYBOARD_CODE);
    ::PostEvent(keyDown, theMessage);

  // Taste losgelassen
  } else {
    // Key-Up-Flag löschen
    theMessage &= 0xFFFF7FFF;
    ::PostEvent(keyUp, theMessage);
  }
}

/***
 *  Tastendruck (bzw. das Loslassen) dem MacOS
 *  melden
 ***/
static void EnterKeycode(UInt8 inCode)
{
  // aktuelle Taste im System löschen
  LMSetKeyLast(0);
  LMSetHiKeyLast(0);

  // true, wenn Taste losgelassen wurde
  Boolean theDownFlag =
                (inCode & 0x80) == 0x80;

  // MacOS-Keycode erzeugen
  UInt8 theKeyCode;
  Ptr   theKMAP = *gKMAP;
  theKeyCode = theKMAP[(inCode & 0x7F) + 4];
  // Sondercode erkannt?
  if(theKeyCode & 0x80) {

    // erstmal das Kennungs-Bit löschen
    theKeyCode &= 0x7F;

    // Anzahl der Sondereinträge
    SInt16  theCount =
      *reinterpret_cast<SInt16*>
            (&theKMAP[0x84]);

    // ab hier geht es mit den Tabellen los
    UInt8 *theKMapP =
      reinterpret_cast<UInt8*>
            (&theKMAP[0x86]);
    while(theCount-- > 0) {
      // Code gefunden?
      if(*theKMapP++ != theKeyCode) {
        // zum nächsten Eintrag
        theKMapP += theKMapP[1] + 2;
        continue;
      }
      if((*theKMapP & 0x0F) == 0x00)
        return;
      break;
    }
  }

  // Capslock Abfrage
  if(theKeyCode == 0x39) {
    if(theDownFlag) { // Taste gedrückt?

      // Caps bereits gesetzt?
      if(gKeyMap[theKeyCode >> 3]
        & (1 << (theKeyCode & 7))) {
        // dann lösen!
        theDownFlag = false;
      }
    } else {  // Taste losgelassen?
      // (das interessiert uns nie!)
      return;
    }
  }

  // in die KeyMap eintragen (vorerst nur in
  // die eigene)
  if(theDownFlag) {
    gKeyMap[theKeyCode >> 3] |=
        1 << (theKeyCode & 7);
  } else {
    gKeyMap[theKeyCode >> 3] &=
        ~(1 << (theKeyCode & 7));

    // Flag für "losgelassen"
    theKeyCode |= 0x80;
  }

  // Tastencodes in globalen Variablen merken
  LMSetKbdLast(theKeyCode);
  LMSetKbdType(NEWTON_KEYBOARD_CODE);

  // globale KeyMap updaten
  ::BlockMoveData(gKeyMap, LMGetKeyMapPtr(),
          sizeof(KeyMap));

  // aktuelle Modifiers für KeyTranslate lesen
  UInt16  theModifiers = *(3 +
          reinterpret_cast<UInt16*>
          (LMGetKeyMapPtr()));

  // ROL.W #1,<ea>
  theModifiers = (theModifiers >> 15)
        | (theModifiers << 1);

  // ASCII-Codes (denkbar: zwei pro
  // Tastendruck!) errechnen
  static UInt32 state = 0;
  UInt32  lStructure = ::KeyTranslate(*gKCHR,
        theKeyCode | (theModifiers << 8),
                    &state);

  // ggf. zwei Tasten posten
  PostKeyMessage(lStructure >> 16, theKeyCode);
  PostKeyMessage(lStructure, theKeyCode);
}

/***
 *  diese asynchrone Routine pollt das Keyboard
 *  an der Seriellen
 ***/
#include <Serial.h>

// UPP für die Callback-Routine
IOCompletionUPP gIOUPP;

// Refnums für Serial ein/aus
SInt16      gSDIn, gSDOut;

// das empfangene Zeichen
UInt8     gInChar;

// der Parameterblock (asynchron!)
ParamBlockRec gParamBlk;

/***
 *  das nächste Byte von der
 *  Tastatur asynchron lesen
 ***/
static void   GetNextByte()
{
  if(gDoQuitFlag) return;
  // Callback setzen
  gParamBlk.ioParam.ioCompletion = gIOUPP;
  // Port lesen
  gParamBlk.ioParam.ioRefNum = gSDIn;
  // Buffer auf unser Byte
  gParamBlk.ioParam.ioBuffer = (Ptr)&gInChar;
    // ein Byte lesen
  gParamBlk.ioParam.ioReqCount = 1L;
  // ab der aktuellen Position
  gParamBlk.ioParam.ioPosMode = fsAtMark;
  // kein Offset...
  gParamBlk.ioParam.ioPosOffset = 0L;
  // Anforderung absetzen
  PBReadAsync(&gParamBlk);
}

/***
 *  Diese Routine wird angesprungen,
 *  wenn ein Byte eingetroffen ist.
 ***/
static void   MyCompletion(
          ParmBlkPtr ioParam : __A0)
{
#pragma unused(ioParam)

  // Byte verarbeiten
  EnterKeycode(gInChar);

  // nächstes Byte anfordern
  GetNextByte();
}

/***
 *  main()
 ***/
void    main()
{
  // 16k anstatt 2k an Stack!
  ::SetApplLimit((Ptr)((UInt32)
          ::GetApplLimit() - 0x4000));

  // Crasht vor MacOS 7.5.4, falls eine zweite
  // FBA ebenfalls MaxApplZone() aufruft:
  // ::MaxApplZone();

  // weitere Init-Calls sind bei FBAs nicht
  // erlaubt
  ::InitGraf(&qd.thePort);

  // AppleEvents installieren (wenn vorhanden)
  long  response;
  if(!::Gestalt(gestaltAppleEventsAttr,
          &response)) {
    if(response &
      (1L<<gestaltAppleEventsPresent)) {

      if(::AEInstallEventHandler(
            kCoreEventClass,
            kAEOpenApplication,
            NewAEEventHandlerProc(DoAENoErr),
            0L, 0))
        return;

      if(::AEInstallEventHandler(
            kCoreEventClass,
            kAEOpenDocuments,
            NewAEEventHandlerProc(DoAENoErr),
            0L, 0))
        return;

      if(::AEInstallEventHandler(
            kCoreEventClass,
            kAEPrintDocuments,
            NewAEEventHandlerProc(DoAENoErr),
            0L, 0))
        return;

      if(::AEInstallEventHandler(
            kCoreEventClass,
            kAEQuitApplication,
            NewAEEventHandlerProc(DoAEQuitAppl),
            0L, 0))
        return;
    }
  }

  // globale Keyboard-Variablen initialisieren
  InitKeyboard();

  // ".AIn" und ".AOut" öffnen
  OSErr theErr;
  Str255  theStr;
  ::GetIndString(theStr, 128, 2);
  theErr = ::OpenDriver(theStr, &gSDOut);
  if(theErr) ::ExitToShell();
  ::GetIndString(theStr, 128, 1);
  theErr = ::OpenDriver(theStr, &gSDIn);
  if(theErr) goto raus;

  // 9600 8N1
  theErr = ::SerReset(gSDOut,
                baud9600+data8+stop10+noParity);
  if(theErr) goto raus;

  // Handshaking ausschalten
  SerShk  theSHandShk;
  theSHandShk.fXOn = 0;
  theSHandShk.fCTS = 0;
  theSHandShk.errs = 0;
  theSHandShk.evts = 0;
  theSHandShk.fInX = 0;
  theSHandShk.fDTR = 0;
  theErr = ::Control(gSDOut, 14, &theSHandShk);
  if(theErr) goto raus;

  long  theTicks;
  // 1/2 Sekunde auf das Keyboard warten
  ::Delay(30, &theTicks);

  // Anzahl der Byte an der Schnittstelle ermitteln
  SInt32  theCount;
  ::SerGetBuf(gSDIn, &theCount);

  // und alle lesen
  Str255  theBuf;
  ::FSRead(gSDIn, &theCount, &theBuf);

  // Daten von der Tastatur zum Rechner, wenn die
  // Schnittstelle angeschaltet wird (9600 8N1):
  //  <0x16><0x10> 0x02,
  //  'd_id', 0x0CL,        // Device-ID?
  //  'kybd','appl', 0x01L,   // Keyboard-Typ
  //  'nofm', 0L, 0x1003dde7L   // ???
  if(reinterpret_cast<long*>(&theBuf)[3]
        != 'ybda')
    goto raus;

  gIOUPP = NewIOCompletionProc(MyCompletion);
  GetNextByte();  // erstes Byte erwarten

  gDoQuitFlag = false;
  while(!gDoQuitFlag) {
    EventRecord theEvent;
    // nur einmal pro Sekunde erwarten wir einen
    // Null-Event!
    ::WaitNextEvent(
            everyEvent, &theEvent, 60, 0L);
    if(theEvent.what == kHighLevelEvent)
      ::AEProcessAppleEvent(&theEvent);

#if DEBUG
    // zum Debuggen: '^' + Control + Option
    // beendet das Programm!
    KeyMap  theMap;
    ::GetKeys(theMap);
    if((theMap[0] & 0x40000) &&
        ((theMap[1] & 0xC) == 0xC)) {
      break;
    }
#endif
  }
  // auf ein letztes Byte warten!
  SysBeep(10); SysBeep(10); SysBeep(10);

  // auf Abschluß des aktuellen Polls warten
  while(gParamBlk.ioParam.ioResult > 0) {}

  // Tastaturstatus zurücksetzen
  LMSetKeyLast(0);
  LMSetHiKeyLast(0);
  for(int i=0; i<sizeof(gKeyMap); i++)
    gKeyMap[i] = 0;
  ::BlockMoveData(gKeyMap, LMGetKeyMapPtr(),
                  sizeof(KeyMap));

raus:
  if(gSDOut) ::KillIO(gSDOut);
  if(gSDIn) ::CloseDriver(gSDIn);
  if(gSDOut) ::CloseDriver(gSDOut);
}


/***
 *  Newton Keyboard.r
 ***/
resource 'KMAP' (0) {
    0,
    0,
    {   0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,
        18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,
        33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
        48,49,50,51,52,53,59,55,56,57,58,59,56,58,59,
        63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,
        78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,
        93,94,95,96,97,98,99,100,101,102,103,104,105,
        106,107,108,109,110,111,112,113,114,115,116,
        117,118,119,120,121,122,123,124,125,126,127
    },
    {
    }
};

resource 'KMAP' (1) {
    0,
    0,
    {   0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,
        18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,
        33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
        48,49,50,51,52,53,59,55,56,57,58,59,60,61,62,
        63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,
        78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,
        93,94,95,96,97,98,99,100,101,102,103,104,105,
        106,107,108,109,110,111,112,113,114,115,116,
        117,118,119,120,121,122,123,124,125,126,127
    },
    {
    }
};

resource 'STR#' (128, "Portnames") {
    {   ".AIn",
        ".AOut"
    }
};

data 'TMPL' (128, "PREF") {
    /* .Different Shift */
    $"1544 6966 6665 7265 6E74 2053 6869 6674"
    /* -Keys?BOOL.Keybo */
    $"2D4B 6579 733F 424F 4F4C 0E4B 6579 626F"
    /* ardregionRGNC */
    $"6172 6472 6567 696F 6E52 474E 43"
};

data 'PREF' (128) {
    $"0000 0003"
};

/***
 *  ab hier: optional!
 ***/
resource 'vers' (1) {
    0x1,
    0x0,
    release,
    0x0,
    verGermany,
    "1.0",
    "1.0, ©1996 MAXON Computer, Markus Fritze"
};

resource 'BNDL' (128) {
    'NwtK',
    0,
    {   'FREF', { 0, 128 },
        'ICN#', { 0, 128 }
    }
};

resource 'FREF' (128) {
    'appe',
    0,
    ""
};

resource 'icl4' (128) {
    $"0FFF FFFF FFFF FFFF FFFF FFFF FFFF 0000"
    $"F000 0000 0000 0000 0000 0000 000C F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"FF0F CCCC CCCC CCCC CCCC CCCC CCCC F0F0"
    $"F0FF CCCC CCCC CCCC CCCC CCCC CCCC FF0F"
    $"000F CC99 9999 9999 9999 9999 99CC F0CF"
    $"000F CC99 9999 9999 9999 9999 99CC CCCF"
    $"000F CC99 C9C9 C9C9 C9C9 C9C9 99CC CCCF"
    $"000F CC99 9999 9999 9999 9999 99CC CCCF"
    $"000F CC99 9C9C 9C9C 9C9C 9C9C 99CC CCCF"
    $"000F CC99 9999 9999 9999 9999 99CC CCCF"
    $"000F CC99 C9C9 C9C9 C9C9 C9C9 99CC CCCF"
    $"000E CC99 9999 9999 9999 9999 99CC CCCF"
    $"000E CC99 9C9C 9CCC CCCC 9C9C 99CC CCCF"
    $"000F CC99 9999 9999 9999 9999 99CC FCCF"
    $"F00F CC99 9999 9999 9999 9999 99CC FFCF"
    $"FF0F CCCC CCCC CCCC CCCC CCCC CCCC F0F0"
    $"F0F0 CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"F0CC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"FCCC CCCC CCCC CCCC CCCC CCCC CCCC F000"
    $"0FFF FFFF FFFF FFFF FFFF FFFF FFFF"
};

resource 'icl8' (128, purgeable) {
    $"00FF FFFF FFFF FFFF FFFF FFFF FFFF FFFF"
    $"FFFF FFFF FFFF FFFF FFFF FFFF 0000 0000"
    $"FF00 0000 0000 0000 0000 0000 0000 0000"
    $"0000 0000 0000 0000 0000 00F6 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FFFF 00FF F8F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 FF00"
    $"FF00 FFFF F8F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FFFF 00FF"
    $"0000 00FF F8F6 A5A5 A5A5 A5A5 A5A5 A5A5"
    $"A5A5 A5A5 A5A5 A5A5 A5A5 F6F8 FF00 F6FF"
    $"0000 00FF F8F6 A5A5 A5A5 A5A5 A5A5 A5A5"
    $"A5A5 A5A5 A5A5 A5A5 A5A5 F6F6 F6F6 F8FF"
    $"0000 00FF F8F6 A5A5 F8A5 F8A5 F8A5 F8A5"
    $"F8A5 F8A5 F8A5 F8A5 A5A5 F6F6 F6F6 F8FF"
    $"0000 00FF F8F6 A5A5 A5A5 A5A5 A5A5 A5A5"
    $"A5A5 A5A5 A5A5 A5A5 A5A5 F6F6 F6F6 F8FF"
    $"0000 00FF F8F6 A5A5 A5F8 A5F8 A5F8 A5F8"
    $"A5F8 A5F8 A5F8 A5F8 A5A5 F6F6 F6F6 F8FF"
    $"0000 00FF F8F6 A5A5 A5A5 A5A5 A5A5 A5A5"
    $"A5A5 A5A5 A5A5 A5A5 A5A5 F6F6 F6F6 F8FF"
    $"0000 00FF F8F6 A5A5 F8A5 F8A5 F8A5 F8A5"
    $"F8A5 F8A5 F8A5 F8A5 A5A5 F6F6 F6F6 F8FF"
    $"0000 00FC F8F6 A5A5 A5A5 A5A5 A5A5 A5A5"
    $"A5A5 A5A5 A5A5 A5A5 A5A5 F6F6 F6F6 F8FF"
    $"0000 00FC F8F6 A5A5 A5F8 A5F8 A5F8 F8F8"
    $"F8F8 F8F8 A5F8 A5F8 A5A5 F6F6 F6F6 F8FF"
    $"0000 00FF F8F6 A5A5 A5A5 A5A5 A5A5 A5A5"
    $"A5A5 A5A5 A5A5 A5A5 A5A5 F6F8 FFF8 F8FF"
    $"FF00 00FF F8F6 A5A5 A5A5 A5A5 A5A5 A5A5"
    $"A5A5 A5A5 A5A5 A5A5 A5A5 F6F8 FFFF F8FF"
    $"FFFF 00FF F8F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 FF00"
    $"FF00 FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FF00 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F6"
    $"F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00 0000"
    $"FFF6 F8F8 F8F8 F8F8 F8F8 F8F8 F8F8 F8F8"
    $"F8F8 F8F8 F8F8 F8F8 F8F8 F8F8 FF00 0000"
    $"00FF FFFF FFFF FFFF FFFF FFFF FFFF FFFF"
    $"FFFF FFFF FFFF FFFF FFFF FFFF"
};

resource 'ICN#' (128) {
    {   $"7FFF FFF0 8000 0008 8000 0008 8000 0008"
        $"8000 0008 8000 0008 8000 0008 8000 0008"
        $"8000 0008 D000 000A B000 000D 13FF FFC9"
        $"13FF FFC1 1355 55C1 13FF FFC1 13AA AAC1"
        $"13FF FFC1 1355 55C1 13FF FFC1 13A8 0AC1"
        $"13FF FFC9 93FF FFCD D000 000A A000 0008"
        $"8000 0008 8000 0008 8000 0008 8000 0008"
        $"8000 0008 8000 0008 8000 0008 7FFF FFF0",

        $"7FFF FFF0 FFFF FFF8 FFFF FFF8 FFFF FFF8"
        $"FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
        $"FFFF FFF8 DFFF FFFA 9FFF FFFF 1FFF FFFF"
        $"1FFF FFFF 1FFF FFFF 1FFF FFFF 1FFF FFFF"
        $"1FFF FFFF 1FFF FFFF 1FFF FFFF 1FFF FFFF"
        $"1FFF FFFF 9FFF FFFF DFFF FFFA FFFF FFF8"
        $"FFFF FFF8 FFFF FFF8 FFFF FFF8 FFFF FFF8"
        $"FFFF FFF8 FFFF FFF8 FFFF FFF8 7FFF FFF0"
    }
};

resource 'ics#' (128) {
    {   $"FFFE 8002 8002 8002 C003 DFFB 5559 5FF9"
        $"5A29 5FF9 DFFB C003 8002 8002 8002 FFFE",

        $"FFFE FFFE FFFE FFFE FFFE FFFF 7FFF 7FFF"
        $"7FFF 7FFF FFFF FFFE FFFE FFFE FFFE FFFE"
    }
};

resource 'ics4' (128) {
    $"FFFF FFFF FFFF FFF0 FCCC CCCC CCCC CCF0"
    $"FCCC CCCC CCCC CCF0 FCCC CCCC CCCC CCF0"
    $"FFCC CCCC CCCC CCFF FFC9 9999 9999 9CFF"
    $"0FC9 D9D9 D9D9 9CCF 0FC9 9999 9999 9CCF"
    $"0FC9 9D9D DD9D 9CCF 0EC9 9999 9999 9CCF"
    $"FFC9 9999 9999 9CFF FFCC CCCC CCCC CCFF"
    $"FCCC CCCC CCCC CCF0 FCCC CCCC CCCC CCF0"
    $"FCCC CCCC CCCC CCF0 FFFF FFFF FFFF FFF0"
};

resource 'ics8' (128) {
    $"FFFF FFFF FFFF FFFF FFFF FFFF FFFF FF00"
    $"FFF6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00"
    $"FFF6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00"
    $"FFF6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00"
    $"FFFF F8F6 F6F6 F6F6 F6F6 F6F6 F6F8 FFFF"
    $"FFFF F8A5 A5A5 A5A5 A5A5 A5A5 A5F8 FFFF"
    $"00FF F8A5 F8A5 F8A5 F8A5 F8A5 A5F6 F6FF"
    $"00FF F8A5 A5A5 A5A5 A5A5 A5A5 A5F6 F6FF"
    $"00FF F8A5 A5F8 A5F8 F8F8 A5F8 A5F6 F6FF"
    $"00FC F8A5 A5A5 A5A5 A5A5 A5A5 A5F6 F6FF"
    $"FFFF F8A5 A5A5 A5A5 A5A5 A5A5 A5F8 FFFF"
    $"FFFF F8F6 F6F6 F6F6 F6F6 F6F6 F6F8 FFFF"
    $"FFF6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00"
    $"FFF6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00"
    $"FFF6 F6F6 F6F6 F6F6 F6F6 F6F6 F6F8 FF00"
    $"FFFF FFFF FFFF FFFF FFFF FFFF FFFF FF"
};

data 'NwtK' (0, "Owner resource") {
    $"00"
};

ISDN Config

ISDN Config ist ein Programm, welches die einfache Konfiguration sämtlicher ISTEC ISDN-Telefonanlagen der Firma Emmerich mit dem Macintosh erlaubt. Ferner kann man – auch automatisch – die Gebühren auslesen und in eine Logbuch-Datei wegschreiben lassen.

Emmerich liefert ja leider nur ein DOS-Programm zur Konfiguration mit und nachdem – nur für die Konfiguration einer ISTEC – ein kompletter 486er mit 17” Monitor fünf Stockwerke geschleppt werden mußte, kam mir die Idee, so ein Programm für meinen PowerBook zu schreiben…

Systemanforderungen

Um ISDN Config einsetzen zu können, benötigt man:

  • einen Macintosh mit 68020 (oder höher) oder PowerPC Prozessor.
  • Mac OS 7.0 oder neuer
  • eine ISTEC Telefonanlage 1003 bzw. 1008 (nunja, ansehen und ausprobieren kann man sich das Programm auch ohne ISTEC), wobei auch alle anderen ISTEC Anlagen unterstützt werden (soweit möglich)
  • Ein Verbindungskabel von der ISTEC zum Mac (eine Anweisung zum Selbstbau ist in der Anleitung von ISDN Config beschrieben)

Support

Bei Problemen mit der ISTEC Telefonanlage wenden Sie sich bitte direkt an Ihren Händler. Da es Emmerich inzwischen nicht mehr gibt, muß man sich an Hörmann Funkwerk Kölleda wenden. Und wie es scheint, haben die die ISTEC auch eingestellt.

Die Version 3.0 der Firmware kann ich leider nicht unterstützen.

Die aktuelle Programmversion

  • ISDN Config 2.1.1 (Neu: Support for die 2.1.3 Firmware der ISTEC, sowie Bugfixes damit die Firmware <2.0 wieder unterstützt wird)

Transfile Mac IQ

Dieses Projekt war die erste Zusammenarbeit von Christoph Pagalies und mir auf dem Macintosh – vorher haben wir ja schon auf dem Atari zusammen programmiert. Hier die Informationstexte von Yellow Computing:

TRANSFILE MAC IQ Grundlagen

Verbindet alle SHARP Organizer IQ–7000 bis 8500 und ZQ–5000 bis 6300 mit Apple Macintosh.

Passend für Sharp

  • IQ–7000, IQ–7100, IQ–7200, IQ–7300
  • IQ–7520
  • IQ–7700, IQ–7720
  • ZQ–5100, ZQ–5300
  • ZQ–6000, ZQ–6100, ZQ–6300
  • IQ–8000, IQ–8100, IQ–8300 und IQ–8500

Leistungsmerkmale

TRANSFILE MAC IQ verbindet die SHARP Organizer der Serien ZQ–5×00, ZQ–6×00, IQ–7×00, IQ–7×20 und IQ–8×00 mit dem Apple Macintosh Schnelle und fehlerfreie Übertragung in beide Richtungen Batteriesparfunktion schont die Batterien Ihres SHARP Organizers Unterstützt verschiedene Datenformate (BASIC, SYLK, Tab, Komma und Serienbrief) zum Datenaustausch mit anderen Programmen wie z.B. 4th Dimension, FileMaker Pro, MS Word usw. Beliebige Anzahl von Dokumenten und Fenstern gleichzeitig darstellbar Spezieller Editor zum Bearbeiten der einzelnen Datenbereiche auf dem Apple Macintosh Länderspezifische, frei einstellbare Datumsformate Leistungsfähige Druckfunktionen Ausführliches deutsches Handbuch und deutsches Programm Lauffähig auf System 6.0 und 7.0 Mindestanforderungen

läuft ab Macintosh Plus oder besser mit System 6.0 oder 7.0. Auf System 7.0 unterstützt Transfile aktive Hilfe für alle Menüpunkte und Fenster.

Lieferumfang

  • Interface-Kabel
  • Software auf 3,5” und 5,25” Diskette
  • Handbuch
  • Sprache (aktuelle Version): Deutsch (1.04) oder Englisch (1.04)

Bestellnummer: 2044 Preis: 199,00 DM *

Update Bestellnummer: 2744 Preis: 49,00 DM *

  • unverbindliche Preisempfehlung

TRANSFILE MAC IQ Flyer

TRANSFILE MAC IQ verbindet die SHARP-Organizer IQ–7000, IQ–7100, IQ–7200, IQ–7300, IQ–7520, IQ–7700, IQ–7720, ZQ–5100, ZQ–5300, ZQ–6000, ZQ–6100, ZQ–6300 sowie IQ–8000, IQ–8100, IQ–8300 und IQ–8500 mit dem Apple Macintosh. Es werden auch die entsprechenden RAM-Karten unterstützt.

Die Übertragung

Mit Transfile ist es möglich, sämtliche Daten der SHARP-Organizer schnell und fehlerfrei auf den Apple Macintosh zu übertragen. Der Datenaustausch wird dabei vollständig vom Macintosh gesteuert, eine Einstellung der Übertragungsparameter ist nicht erforderlich. Die auf dem Macintosh bearbeiteten Daten können natürlich auch wieder in den SHARP-Organizer zurückgeladen werden. Die Übertragung erfolgt nach dem original SHARP-Protokoll über den PC-Link-Modus der Organizer.

Die Batteriesparfunktion von TRANSFILE MAC IQ schaltet auf Wunsch den Organizer nach dem Ende der Datenübertragung automatisch ab.

Das Interfacekabel

Für die Verbindung der beiden Rechner wird das im Lieferumfang enthaltene Interfacekabel verwendet. Der Anschluß des Interfacekabels erfolgt an der Computer-Link-Schnittstelle der SHARP-Organizer. Am Macintosh kann das Interfacekabel an der Drucker- oder Modembuchse angeschlossen werden. Das zur Verbindung mitgelieferte Interfacekabel erhält seinen Strom direkt aus dem Macintosh und benötigt daher keine externe Stromversorgung, keine Batterien und keinen Strom aus dem SHARP-Organizer.

Die Software auf dem Macintosh

Die Daten der einzelnen Datenbereiche (Kalender, Terminplaner, Notizblock, Telefonlisten, Benutzerwörterbuch, Visitenkarten und Outliner) können auf dem Macintosh komfortabel bearbeitet werden. Die leistungsfähigen Funktionen des Programms werden durch das neuartige Konzept der Untermengenauswahl in ihren Anwendungsmöglichkeiten wesentlich verstärkt. Dieses Konzept der Untermengenauswahl gibt dem Anwender die Möglichkeit, bei vielen Funktionen auswählen zu können, ob diese Funktion auf alle, auf die markierten, auf die unmarkierten, auf die gefundenen oder auf die nicht gefundenen Datensätze wirken soll. Somit kann der Anwender bestimmen, welche Untermengen des Datenbestandes angezeigt, durchsucht, bearbeitet, … werden sollen.

Datenbanken und Fenster

Für jeden Datenbereich (Kalender, Terminplaner, Notizblock, Telefonlisten, Visitenkarten, Outliner und Ausgaben) eines Organizer-Dokumentes können eines oder mehrere Fenster geöffnet werden. Somit ist es möglich, mehrere Kalenderfenster zu öffnen, von denen jedes einzelne einen anderen Monat beinhalten kann.

Weiterhin können Sie soviele Organizer-Dokumente neu anlegen oder bereits vorhandene Dokumente öffnen wie es der Arbeitsspeicher Ihres Macintosh zuläßt. Dabei kann das Erscheinungsbild der einzelnen Fenster vom Anwender selbst definiert werden. Er kann für die Datenfelder separat wählen, ob diese im jeweiligen Fenster angezeigt werden sollen oder nicht. Der dabei verwendete Zeichensatz und die Schriftgröße kann unter allen verfügbaren Zeichensätzen ausgewählt werden. Somit sind der übersichtlichen Darstellung nach persönlichen Wünschen keine Grenzen gesetzt.

Der Kalender

Der Kalender der SHARP-Organizer wurde entsprechend in Transfile umgesetzt und verfügt über eine Tages-, Wochen- und Monatsübersicht. Alle Terminarten des Terminplaners können dargestellt werden: einfache Termine, Jahrestage, periodische Termine und tägliche Alarme. Durch Anklicken eines Datums in der Monatsübersicht können Termine für diesen Tag eingegeben werden.

Der Anwender hat die Wahl zwischen den verschiedenen länderspezifischen Formaten der Datums- und Zeiteingabe. Kann sich jemand mit keinem der bereits vordefinierten Formate anfreunden, so kann er sich sein persönliches Format selbst zusammenstellen.

Die Bereichsnamen und Freifelder

Die Bezeichnungen der drei Telefonlisten können frei gewählt werden. Weiterhin sind auch die Bezeichnungen der Freifelder der drei Telefonlisten und der Visitenkarten frei wählbar und können beim IQ–8×00 auch mit übertragen werden.

Der Editor

Zum Editieren der Daten enthält das Programm einen speziellen, auf die Bedürfnisse der SHARP-Organizer zugeschnittenen, sehr leistungsfähigen Editor. Mit einem Doppelklick auf den zu ändernden Datensatz gelangt man direkt in den Editor. Wie auf dem SHARP-Organizer kann hiermit ein Datenfeld mehrzeilig eingegeben werden. Der Editor erweitert das aktuelle Datenfeld dann selbständig um die gewünschte Zeilenanzahl.

Die Bearbeitungsfunktionen

Es stehen folgende Bearbeitungsfunktionen zur Verfügung: Suchen, Suchen/Ersetzen, doppelte Einträge löschen, Markieren, Editieren, Kopieren und Ausschneiden. Die Inhalte aller Datenbereiche sind immer alphabetisch bzw. chronologisch sortiert. Das Ausschneiden und Kopieren der Datensätze ist sowohl zwischen verschiedenen Datenbereichen als auch zwischen verschiedenen Applikationen über die Zwischenablage möglich.

Beim Speichern im Transfile-Format können geheime Daten mit einem Kennwort verschlüsselt abgespeichert und so vor unbefugtem Zugriff geschützt werden.

Der Datenaustausch

Die Daten der SHARP-Datenbankdokumente können von Transfile in den verschiedensten Formaten gespeichert oder gelesen werden. Damit können die Daten schnell und bequem auch in anderen Programmen verwendet werden. Transfile erlaubt das Einlesen oder Abspeichern in den Formaten BASIC, SYLK, Tab, Komma und Serienbrief. Bei den Export- und Importfunktionen kann die Reihenfolge der Datenfelder innerhalb eines Datensatzes beliebig festgelegt werden.

Natürlich können die Daten mit Hilfe der Zwischenablage auch direkt in andere Programme übernommen werden. Mit diesen Import-/Exportfunktionen können die Daten ohne Probleme zwischen FileMaker Pro, 4th Dimension, MS-Word, Hypercard, etc. und dem SHARP-Organizer ausgetauscht werden.

Die Druckfunktionen

Mit Transfile können Sie die Daten der SHARP-Organizer auf jedem beliebigen Drucker in übersichtlicher Form ausgeben. Die Ausgabe kann mehrspaltig mit oder ohne Feldnamen und Seitenüberschriften erfolgen. Der Kalender erzeugt für jeden Monat eine einseitige Druckausgabe mit grafischer Darstellung der vorhandenen Termine.

©1992 Yellow Computing, Bad Friedrichshall

Hans geht zur Post

“Hans geht zur Post” ist ein Programm, welches in Verbindung mit der CTB (Communication Toolbox) aus System 7 den vollautomatischen Tausch mit Mäusen und Quark-Mailboxen ermöglicht.

Es entfällt das Schreiben eines Skripts für ein Terminalprogramm (zumal z. B. ZTerm gar keinen automatischen Tausch-Script ermöglicht).

Üblicherweise wird man “Hans geht zur Post” in Verbindung mit der Mausefalle – als MausTausch Frontend – einsetzen, dies ist jedoch nicht zwangsweise nötig. “Hans geht zur Post” funktioniert übrigens auch bei Maus-Sysops, die in ihrer Mailbox per Nullmodem tauschen.

“Hans geht zur Post” erlaubt zudem beim Tausch mit Mäusen das automatische Packen der Tausch-Files mit dem ARJ-Packer (ist bereits eingebaut – kein externer Packer nötig!)

In Verbindung mit der Mausefalle und ZModem-Modulen wird ein Upload in Mäuse per Tausch unterstützt. Dazu muß “Schnulli” (Saugtausch) in den entsprechenden Mäusen installiert sein! Hierzu bitten beim eigenen Sysop nachfragen.

Ab Version 1.3 von Hans wird zudem ein “Onlinezeit Protokoll” angelegt, welches man sich mit einem beliebigen Textprogramm – z.B. TeachText oder der Mausefalle – ansehen kann. Es enthält alle gebührenpflichten Anrufe von Hans mit Namen der Mailbox, Dauer des Tausches, sowie Datum und Uhrzeit des Logins.

Woher kommt der neue Name für das Programm?

Man sieht der Maus Hans beim Besuch seines örtlichen Postamtes zu, während “Hans geht zur Post” sich in die MAUS einloggt und den MausTausch durchführt.

Systemanforderungen

Um “Hans geht zur Post” einsetzen zu können, benötigt man:

  • Mac OS 7.0 oder neuer
  • Mindestens 2MB Hauptspeicher (4MB empfohlen)
  • Ein Modem
  • CTB-Module für den Aufbau der Verbindung, den Datentransfer und ein Terminalmodul.
  • Vertrieb von “Hans geht zur Post”

Die aktuelle Programmversion