AHDI paßt sich an

Bereits seit dem Spätsommer 1989 liegt der Atari-Festplattentreiber AHDI in der Version 3.0 vor, die inzwischen durch die Version 4.0, die in erster Linie für die Besitzer des Atari TT interessant ist, ersetzt wurde. Eine besondere Eigenschaft beider Treiber ist der Umstand, daß diese konfiguriert werden können. Leider gehört ein geeignetes Konfigurationsprogramm nicht zum Lieferumfang. Grund genug, selber ein solches Programm zu schreiben.

Konfigurierbare Festplattentreiber sind heute keine Seltenheit mehr. Die meisten Vertreiber von Festplatten für den Atari legen Wert darauf, ihre Platten mit Treiber-Software auszustatten, deren Funktionsumfang dem der Atari-Treiber in der Regel überlegen ist. Dennoch ist der AHDI-Treiber weit verbreitet, was nicht zuletzt daran liegt, daß die TTs und MegaSTEs standardmäßig mit diesem Treiber ausgeliefert werden.

Nun scheint AHDI auf den ersten Blick über keinerlei Möglichkeiten zu verfügen, individuelle Anpassungen an eine bestimmte Arbeitsumgebung vorzunehmen. Ganz so ist es aber nun doch nicht. Ein Blick in [1] zeigt, daß AHDI durchaus gewisse Konfigurationsmöglichkeiten bietet.

Patch-Bereiche

Innerhalb des AHDI-Programmcodes existiert ein für den Benutzer legal zugänglicher Datenbereich, der diverse Parameter enthält. Es handelt sich um eine Struktur, deren Aufbau Sie aus Tabelle 1 entnehmen können.

Was besagen diese Variablen (für die es keine offiziellen Bezeichnungen zu geben scheint) nun im einzelnen? Für TOS-Versionen, die älter als das Blitter-TOS (TOS 1.02) sind, spezifiziert chunk, um wieviele Speicherblöcke der interne Speicher des GEMDOS erweitert werden soll. Diese Erweiterung ist beim TOS 1.00 für einen fehlerfreien Festplattenbetrieb notwendig. Beim Blitter-TOS und neueren TOS-Versionen wird die Angabe in chunk von AHDI nicht mehr ausgewertet.

defbigse legt die maximale logische Sektorgröße fest, für die im Verlauf der Treiberinitialisierung Speicherplatz bereitgehalten wird. AHDI ermittelt diesen Wert beim Programmstart. Partitionen mit größeren Sektoren können vom Treiber anschließend nicht verwaltet werden. Um AHDI mitzuteilen, daß die Sektorgröße einer Partition die beim Booten Vorgefundenen Werte überschreiten kann, muß in defbigse eine maximale Sektorgröße angegeben werden.

Arbeitet man ausschließlich mit Festplatten, so ist defbigse nicht weiter von Bedeutung. Schließlich kann es in diesem Fall nicht Vorkommen, daß nachträglich eine Partition ins System integriert werden soll, die beim Booten noch nicht vorhanden war.

Anders sieht es dagegen aus, wenn man im Besitz einer Wechselplatte ist. Wird hier die Cartridge gewechselt, so ist es durchaus denkbar, daß sich auf dem neu eingelegten Medium eine Partition befindet, die größere Sektoren besitzt als alle bisher vorhandenen Partitionen. Der Inhalt von defbigse muß diesen Maximalwert widerspiegeln, damit alle Partitionen der neuen Cartridge ins System eingebunden werden können. Ist der Wert von defbigse größer als die maximale Sektorgröße, so reservieren sich Cache-Programme für die Festplatte unter Umständen unnötig viel Speicherplatz.

AHDI kann übrigens Sektoren mit einer logischen Sektorgröße von maximal 8192 Bytes verwalten. Die Sektorgröße ist in der Regel von der Kapazität einer Partition abhängig. Es gilt folgende Zuordnung:

Kapazität Sektorgröße
< 16 MByte 512 Bytes
< 32 MByte 1024 Bytes
< 64 MByte 2048 Bytes
< 128 MByte 4096 Bytes
<= 256 MByte 8192 Bytes

Wie man sieht, kann AHDI Partitionen mit bis zu 256 Megabyte (= 1/4 Gigabyte) Kapazität verwalten. Bleibt noch anzumerken, daß es sich bei den obigen Werten um logische Angaben handelt. In Wirklichkeit arbeiten Festplatten für den ST oder TT stets mit 512 Bytes pro Sektor. Bei großen Partitionen werden mehrere dieser physikalischen Sektoren zu einem logischen Sektor zusammengefaßt.

struct
{
    unsigned int magic;     /* $F0AD, falls konfigurierbar */
    unsigned int version;   /* Treiberversion, z.B. $0300 */
    int chunk;              /* zusätzliche Ordner */
    int defbigse;           /* maximale Sektorgröße */
    int acsi_devs;          /* Zahl der ACSI-Platten (8) */
    char acsi_def_ndrv[acsi_devs]; /* reservierte ACSI-Partitionen */ 
    int scsi_devs;          /* Zahl der SCSI-Platten (8) */
    char scsi_def_ndrv[scsi_devs]; /* reservierte SCSI-Partitionen */ 
} ahdi_vars;

Tabelle 1

Wechselhaft

Auch die restlichen Variablen des AHDI-Treibers sind in erster Linie für Besitzer von Wechselplatten interessant. Nicht nur die Sektorgrößen können auf verschiedenen Cartridges variieren, auch die Zahl der Partitionen pro Cartridge kann unterschiedlich sein. Liegt beim Start von AHDI ein Medium mit nur einer Partition im Laufwerk, und legt man anschließend eine Platte mit zwei Partitionen ein, so darf man sich nicht wundern, wenn von diesen beiden Partitionen nur die erste angesprochen werden kann.

Die Felder acsi_def_ndrv und scsi_def_ndrv erlauben es, für jedes angeschlossene Wechselplattenlaufwerk festzulegen, für wieviele Partitionen Laufwerkskennungen (also C: bis P:) reserviert werden sollen. Hier muß sinnvollerweise ein Wert angegeben werden, der der maximalen Zahl der Partitionen entspricht, die auf einer Cartridge Vorkommen können. Der Standardwert liegt für alle Geräte bei 1. Diese Werte werden vom Treiber nur dann verwendet, wenn es sich bei einem Laufwerk um eine Wechselplatte handelt.

Was scsi_def_ndrv betrifft, so existieren über dieses Feld keine offiziellen Angaben von Atari. Betrachtet man sich den Variablenbereich von AHDI 4.0, stellt man jedoch fest, daß die für AHDI 3.0 beschriebene Anordnung von acsi_devs und acsi_def_ndrv in analoger Weise auch für Platten am SCSI-Bus des TT eingeführt wurde.

Konfiguration per Programm

Alle für AHDI beschriebenen Konfigurationsdaten können mit dem abgedruckten Programm AHDICONF den eigenen Bedürfnissen entsprechend eingestellt werden. Hierzu muß zunächst die zu konfigurierende Treiberdatei (AHDI.PRG bzw. SHDRIVER.SYS) im Fileselector aufge-sucht werden. Handelt es sich hierbei tatsächlich um AHDI 3.0 oder 4.0, so erscheint anschließend eine Dialogbox, die eine Neukonfigurierung erlaubt (Bild).

Für jedes Laufwerk kann die Zahl der zu reservierenden Partitionen getrennt angegeben werden. Handelt es sich bei der Treiberdatei um AHDI 3.0, lassen sich nur Angaben zu den ACSI-Platten machen, da der SCSI-Bus erst ab AHDI 4.0 unterstützt wird. Nachdem die Konfigurierung erfolgreich abgeschlossen wurde, muß der Treiber neu gestartet bzw. das System neu gebootet werden, damit die geänderten Angaben wirksam werden.

Beim Compilieren des Programms muß darauf geachtet werden, daß der C-Com-piler Strings gleichen Inhalts nicht zu einem einzigen String zusammenlegt. Eventuell muß dies über eine Compiler-Option gesteuert werden.

US

Literatur:
[1] „AHDI 3.00 Release Notes", Atari Corp.

Listing 1: Der C-Quelltext zu AHDICONF

/**************************/
/* AHDICONF               */
/*                        */
/* zur Konfiguration von  */
/*                        */
/* AUDI V3.0 oder V4.0    */
/* (c) 1991 MAXON Computer*/
/* by Uwe Seimet          */
/**************************/

#define EXTERN extern

#include "ahdiconf.rsh"
#include "ahdiconf.rh"
#include <vdi.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ext.h>

/* Offset des Parameterbereichs */
/* zum Beginn der AHDI-Programmdatei */ 
#define PARSTART 40

/* 42 Parameterbytes bei AHDI 4.0 */
#define PARLEN 42

#define TRUE 1 
#define FALSE 0

typedef enum _bool boolean;

int contrl[11], 
    intin[80], 
    intout[45], 
    ptsin[32],
    ptsout[32];

int work_in[12], 
    work_out[57];

int g_handle;

int gl_hchar, 
    gl_wchar;

char ahdiname[150];

/* Konfigurations-Variablen */ 
struct 
    {
    unsigned int magic; 
    unsigned int version; 
    int          chunk;
    int          defbigse;
    int          acsi_devs;
    char         acsi_def_ndrv[8];
    int          scsi_devs;
    char         scsi_def_ndrv[8];
    } ahdi_vars;

/* Funktions-Prototypen */ 
boolean open_vwork(void); 
boolean open_driver(void);
boolean close_driver(void); 
void get_par(void); 
void put_par(void); 
boolean do_dialog(void); 
void rsrc_init(void);


int main()
{
    if ((appl_init())!=-1)
    {
        if (open_vwork())
        {
            /* Treiberdatei öffnen */ 
            if (open_driver())
            {
                /* Parameter auswerten */ 
                get_par();
                /* Resource-Daten umrechnen */ 
                rsrc_init();
                /* Eingaben sind erwünscht */ 
                if (do_dialog())
                {
                    /* Parameter auswerten */ 
                    put_par();
                    /* Treiber konfigurieren */ 
                    close_driver();
                }
            }
            v_clsvwk(g_handle);
        }
    }
    appl_exit(); 
    return(0);
}

/* Workstation öffnen */ 
boolean open_vwork()
{
    int gl_wbox,gl_hbox; 

    register int i;

    for(i=1; i<10; work_in[i++]=0); 
    work_in[10]=2;
    g_handle=graf_handle(&gl_wchar,&gl_hchar,&gl_wbox,&gl_hbox);
    work_in[0]=g_handle;
    v_opnvwk(work_in,&g_handle,work_out); 
    if (!g_handle) return(FALSE); 
    return(TRUE);
}


/* Dialog führen */ 
boolean do_dialog()
{
    int fo_cx,fo_cy,fo_cw,fo_ch; 
    int index; 
    int exit;

    /* SCSI-Parameter nur ab AHDI V4.0 */ 
    if (ahdi_vars.version<0x0400)
    {
        rs_trindex[DIALOG][SCSI].ob_flags |= HIDETREE; 
        for (index=SCSINUM; index<SCSINUM+8; index++)
            rs_trindex[DIALOG][index].ob_flags &= ~EDITABLE,
    }

    form_center(rs_trindex[DIALOG],&fo_cx,&fo_cy,&fo_cw,&fo_ch); 
    form_dial(FMD_START,fo_cx,fo_cy,fo_cw, fo_ch,fo_cx,fo_cy,fo_cw,fo_ch); 
    objc_draw(rs_trindex[DIALOG],0,3,fo_cx,fo_cy,fo_cw,fo_ch); 
    graf_mouse(ARROW,NULL);
    exit=form_do(rs_trindex[DIALOG].CHUNK);
    form_dial(FMD_FINISH, fo_cx, fo_cy, fo_cw, fo_ch, fo_cx, fo_cy, fo_cw, fo_ch); 
    return(exit!=ABORT);
}


/* Parameter aus Treiber holen */ 
void get_par()
{
    int index; 
    char *te_ptext;

    te_ptext=rs_trindex[DIALOG][CHUNK].ob_spec.tedinfo->te_ptext;

    /* Zahl der zusätzlichen Ordner */ 
    itoa(ahdi_vars.chunk,te_ptext,10),

    /* Maximale Sektorgröße */ 
    index=ahdi_vars.defbigse/512-1; 
    rs_trindex[DIALOG][DEFBIGSE+index].ob_state |= SELECTED;

    /* Default-Partitionen für ACSI */ 
    for (index=0; index<ahdi_vars.acsi_devs; index++)
    {
        te_ptext=rs_trindex[DIALOG][ACSINUM+index].ob_spec.tedinfo->te_ptext; 
        te_ptext[0]=ahdi_vars.acsi_def_ndrv[index]+'0';
    }

    /* dto für SCSI */ 
    if (ahdi_vars.version>=0x0400)
    {
        for (index=0;index<ahdi_vars.scsi_devs;index++)
        {
            te_ptext=rs_trindex[DIALOG][SCSINUM+index].ob_spec.tedinfo->te_ptext; 
            te_ptext[0]=ahdi_vars.scsi_def_ndrv[index]+'0';
        }
    }
}

/* Neue Parameterdaten erzeugen */ 
void put_par()
{
    int index=0; 
    char *te_ptext;

    while (!(rs_trindex[DIALOG][DEFBIGSE+index].ob_state && SELECTED)) index++; 
    ahdi_vars.defbigse=(index+1)*512; 
    te_ptext=rs_trindex[DIALOG][CHUNK].ob_spec.tedinfo->te_ptext; 
    ahdi_vars.chunk=atoi(te_ptext); 
    for (index=0; mdex<ahdi_vars.acsi_devs;index++)
    {
        te_ptext=rs_trindex[DIALOG][ACSINUM+index].ob_spec.tedinfo->te_ptext;
        ahdi_vars.acsi_def_ndrv[index]=te_ptext[0]-'0';
    }
    if (ahdi_vars.version>=0x0400)
    {
        for (index=0;index<ahdi_vars.scsi_devs;index++)
        {
            te_ptext=rs_trindex[DIALOG][SCSINUM+index].ob_spec.tedinfo->te_ptext; 
            ahdi_vars.scsi_def_ndrv[index]=te_ptext[0]-'0';
        }
    }
}

/* Treiberdatei öffnen, Parameter lesen */ 
boolean open_driver()
{
    char *dummy; 
    int handle; 
    int button;
    char filename[]="SHDRIVER.SYS";

    getcwd(ahdiname,MAXPATH); 
    fsel_input(ahdiname,filename,&button); 
    if (!button) return(FALSE);

    /* Zugriffspfad zusammensetzen */ 
    dummy=strrchr(ahdiname,'\\'); 
    if (dummy==NULL) return(FALSE); 
    graf_mouse(BUSYBEE,NULL); 
    strcpy(dummy+1,filename);

    handle=open(ahdiname,O_RDONLY); 
    if (handle<0) return(FALSE); 
    lseek (handle,(size_t)(PARSTART),SEEK_SET); 
    if (read(handle,&ahdi_vars,(size_t)(PARLEN))<=0)
    {
        close(handle); 
        return(FALSE);
    }
    close(handle);

    /* Korrekte Treiberversion? */ 
    if (ahdi_vars.magic!=0xf0ad) return(FALSE); 
    return(TRUE);
}

/* Parameter zurückschreiben */ 
boolean close_driver()
{
    int handle;
    int parlen=PARLEN;

    graf_mouse(BUSYBEE,NULL);

    /* AHDI 3.0 hat 10 Parameterbytes weniger */ 
    if (ahdi_vars.version<0x400) parlen-=10;

    handle=open(ahdiname,O_WRONLY); 
    lseek(handle,(size_t)(PARSTART), SEEK_SET); 
    if (write(handle,&ahdi_vars,(size_t)(parlen))!=parlen) return(FALSE); 
    close (handle);
    form_alert(1,"[1][Der Treiber wurde|\ neu konfiguriert.][ OK ]"); 
    return(TRUE);
}

/* Objektkoordinaten umrechnen */ 
void rsrc_init()
{
    register int i;

    for(i=0; i<NUM_OBS; i++) rsrc_obfix(rs_trindex[DIALOG],i);
}

Listing 2: Objektdaten für die Dialogbox

/* GEM Resource C Source */

#include <portab.h>
#include <aes.h>
#include "AHDICONF.H"

#if idefined(WHITEBAK) 
#define WHITEBAK 0x0080
#endif
#if !defined(DRAW3D)
#define DRAW3D 0x0040
#endif

#define FLAGS9  0x0200 
#define FLAGS10 0x0400 
#define FLAGS11 0x0800 
#define FLAGS12 0x1000 
#define FLAGS13 0x2000 
#define FLAGS14 0x4000 
#define FLAGS15 0x8000 
#define STATE8  0x0100 
#define STATE9  0x0200

#define STATE10 0x0400 
#define STATE11 0x0800 
#define STATE12 0x1000 
#define STATE13 0x2000 
#define STATE14 0x4000 
#define STATE15 0x8000

TEDINFO rs_tedinfo[] =
{   "(C) 1991 by Uwe Seimet",
    "",
    "",
    SMALL, 0, TE_LEFT , 0x1180, 0, -1, 23, 1,
    "1",
    "0 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "1 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "2 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "3 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "4 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "5 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "6 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "7 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "0 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "1 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "2 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "3 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "4 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "5 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "6 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "1",
    "7 -> _",
    "9",
    IBM , 0, TE_LEFT , 0x1180, 0, -1, 2, 7,
    "000",
    "Zusatzspeicher: ___",
    "999",
    IBM , 0, TE_CNTR , 0x1180, 0, -1, 4, 20
};

OBJECT rs_object[] =
{
    /******** Tree 0 DIALOG ****************/
    -1, 1, ABORT, G_BOX,        /* Object 0 */
    NONE, OUTLINED, (LONG)0x00021100L,
    0x0003, 0x0005, 0x002F, 0x0812,
    2, -1, -1, G_BUTTON,        /* Object 1 */
    NONE, SELECTED|OUTLINED, (LONG)"AHDI-Konfiguration",
    0x000E, 0x0001, 0x0414, 0x0002,
    3, -1, -1, G_TEXT,          /* Object 2 */
    NONE, NORMAL, (LONG)&rs_tedinfo[0],
    0x0010, 0x0004, 0x0410, 0x0001,
    SCSI, 4, 12, G_BOX,         /* Object 3 */
    NONE, NORMAL, (LONG)0x00FF1101L,
    0x0401, 0x0806, 0x000A, 0x000B,
    ACSINUM, -1, -1, G_STRING,  /* Object 4 */
    NONE, NORMAL. (LONG)"ACSI",
    0x0003, 0x0800, 0x0004, 0x0001,
    6, -1, -1. G_FTEXT,         /* Object 5 ACSINUM */ 
    EDITABLE, NORMAL, (LONG) &rs_tedinfo[1], 
    0x0002, 0x0802, 0x0006, 0x0001,
    7, -1, -1, G_FTEXT,         /* Object 6 */
    EDITABLE. NORMAL, (LONG) &rs_tedinfo[2], 
    0x0002, 0x0803, 0x0006, 0x0001,
    8, -1, -1, G_FTEXT,         /* Object 7 */
    EDITABLE, NORMAL, (LONG) &rs_tedinfo[3], 
    0x0002, 0x0804, 0x0006, 0x0001,
    9, -1, -1, G_FTEXT,         /* Object 8 */
    EDITABLE, NORMAL, (LONG) &rs_tedinfo[4], 
    0x0002, 0x0805, 0x0006, 0x0001,
    10, -1, -1, G_FTEXT,        /* Object 9 */
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[5], 
    0x0002, 0x0806, 0x0006, 0x0001,
    11, -1, -1, G_FTEXT,        /* Object 10 */
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[6], 
    0x0002, 0x0807, 0x0006, 0x0001,
    12, -1, -1, G_FTEXT,        /* Object 11 */
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[7], 
    0x0002, 0x0808, 0x0006, 0x0001,
    3, -1, -1, G_FTEXT,         /* Object 12 */
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[8], 
    0x0002, 0x0809, 0x0006, 0x0001,
    CHUNK, 14, 22, G_BOX,       /* Object 13 SCSI */ 
    NONE, NORMAL, (LONG)0x00FF1101L,
    0x000D, 0x0806, 0x000A, 0x000B,
    SCSINUM, -1, -1, G_STRING,  /* Object 14 */
    NONE, NORMAL, (LONG)"SCSI",
    0x0003, 0x0800, 0x0004, 0x0001,
    16, -1, -1, G_FTEXT,        /* Object 15 SCSINUM */ 
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[9], 
    0x0002, 0x0802, 0x0006, 0x0001,
    17, -1, -1, G_FTEXT,        /* Object 16 */
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[10], 
    0x0002, 0x0803, 0x0006, 0x0001,
    18, -1, -1, G_FTEXT,        /* Object 17 */ 
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[11], 
    0x0002, 0x0804. 0x0006, 0x0001,
    19, -1, -1, G_FTEXT,        /* Object 18 */
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[12], 
    0x0002, 0x0805, 0x0006, 0x0001,
    20, -1, -1, G_FTEXT,        /* Object 19 */
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[13], 
    0x0002, 0x0806, 0x0006, 0x0001,
    21, -1, -1, G_FTEXT,        /* Object 20 */ 
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[14], 
    0x0002, 0x0807, 0x0006, 0x0001,
    22, -1, -1, G_FTEXT,        /* Object 21 */ 
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[15], 
    0x0002, 0x0808, 0x0006, 0x0001,
    SCSI, -1, -1, G_FTEXT,      /* Object 22 */ 
    EDITABLE. NORMAL, (LONG)&rs_tedinfo[16], 
    0x0002, 0x0809, 0x0006, 0x0001,
    24, -1, -1, G_FTEXT,        /* Object 23 CHUNK */ 
    EDITABLE, NORMAL, (LONG)&rs_tedinfo[17], 
    0x0419, 0x0806, 0x0013, 0x0001,
    DEFBIGSE, -1, -1, G_STRING, /* Object 24 */ 
    NONE, NORMAL, (LONG)"Sektormaximum:",
    0x041C, 0x0009, 0x000E, 0x0001,
    26, -1, -1, G_BUTTON,       /* Object 25 DEFBIGSE */ 
    SELECTABLE|RBUTTON, NORMAL, (LONG)"512", 
    0x0019, 0x000B, 0x0006, 0x0001,
    27, -1, -1, G_BUTTON,       /* Object 26 */ 
    SELECTABLE|RBUTTON, NORMAL, (LONG)"1024", 
    0x0020, 0x000B, 0x0006, 0x0001,
    28, -1, -1, G_BUTTON,       /* Object 27 */ 
    SELECTABLE|RBUTTON, NORMAL, (LONG)"2048", 
    0x0027, 0x000B, 0x0006, 0x0001,
    29, -1, -1, G_BUTTON,       /* Object 28 */ 
    SELECTABLE|RBUTTON, NORMAL, (LONG)"4096", 
    0x041C, 0x000D, 0x0006, 0x0001,
    30, -1, -1, G_BUTTON,       /* Object 29 */
    SELECTABLE|RBUTTON, NORMAL, (LONG)"8192",
    0x0423, 0x000D, 0x0006, 0x0001,
    ABORT, -1, -1, G_BUTTON,    /* Object 30 */
    SELECTABLE|DEFAULT|EXIT, NORMAL, (LONG)"OK",
    0x001A, 0x0810, 0x0009, 0x0001,
    0, -1, -1, G_BUTTON,        /* Object 31 ABORT */ 
    SELECTABLE|EXIT|LASTOB, NORMAL, (LONG)"ABBRUCH",
    0x0024, 0x0810, 0x0009, 0x0001,

};

OBJECT *rs_trindex[] =
{ &rs_object[0],    /* Tree 0 DIALOG */
};

/* Resource Datei Indizes fur AHDICONF */ #define DIALOG 0 /* Formular/Dialog */ #define ACSINUM 5 /* FTEXT in Baum DIALOG */ #define SCSI 13 /* BOX in Baum DIALOG */ #define SCSINUM 15 /* FTEXT in Baum DIALOG */ #define CHUNK 23 /* FTEXT in Baum DIALOG */ #define DEFBIGSE 25 /* BUTTON in Baum DIALOG */ #define ABORT 31 /* BUTTON in Baum DIALOG */

/* GEM C Source Header Datei */ EXTERN TEDINFO rs_tedinfo[]; EXTERN ICONBLK rs_iconblk[]; EXTERN BITBLK rs_bitblk[]; EXTERN BYTE *rs_frstr[]; EXTERN BITBLK *rs_frimg[]; EXTERN OBJECT rs_object[]; EXTERN OBJECT *rs_trindex[]; #define NUM_OBS 32 #define NUM_TREE 1

Listings 3 & 4: Die Header-Dateien


Uwe Seimet
Links

Copyright-Bestimmungen: siehe Über diese Seite
Classic Computer Magazines
[ Join Now | Ring Hub | Random | << Prev | Next >> ]