home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / ftp.vapor.com / microdot-1 / md1_src_02.lzx / prefs.c < prev    next >
C/C++ Source or Header  |  2014-05-19  |  28KB  |  1,173 lines
  1. #include <prefs/font.h>
  2.  
  3. #include "microdot.h"
  4.  
  5. #include "ogre.h"
  6. #include "ogre_protos.h"
  7. #include "asyncio.h"
  8.  
  9. static ULONG rgb4to32( ULONG rgb )
  10. {
  11.     ULONG result;
  12.  
  13.     rgb &= 0xf;
  14.     result = rgb;
  15.     result = ( result << 4 ) | rgb;
  16.     result = ( result << 4 ) | rgb;
  17.     result = ( result << 4 ) | rgb;
  18.     result = ( result << 4 ) | rgb;
  19.     result = ( result << 4 ) | rgb;
  20.     result = ( result << 4 ) | rgb;
  21.     result = ( result << 4 ) | rgb;
  22.  
  23.     return( result );
  24. }
  25.  
  26. /* Read Font Prefs */
  27.  
  28. void getwbfonts( void )
  29. {
  30.     struct FontPrefs fp;
  31.     BPTR f;
  32.     ULONG id = 0;
  33.  
  34.     if( !isv37 )
  35.         return;
  36.  
  37.     f = Open( "ENV:SYS/font.prefs", MODE_OLDFILE );
  38.     if( !f )
  39.         return;
  40.  
  41.     for(;;)
  42.     {
  43.         if( FRead( f, ( APTR ) ( ( ( ULONG ) ( &id ) ) + 2 ), 2, 1 ) != 1 )
  44.             break;
  45.         if( id != ID_FONT )
  46.         {
  47.             id = id << 16;
  48.             continue;
  49.         }
  50.         memset( &fp, 0, sizeof( fp ) );
  51.         Seek( f, 4, OFFSET_CURRENT );
  52.         FRead( f, &fp, sizeof( fp ), 1 );
  53.  
  54.         switch( fp.fp_Type )
  55.         {
  56.             case FP_SCREENFONT:
  57.                 strncpy( prefs.screenfontname, fp.fp_Name, 29 );
  58.                 prefs.screenfontheight = fp.fp_TextAttr.ta_YSize;
  59.                 break;
  60.  
  61.             case FP_SYSFONT:
  62.                 strncpy( prefs.fontname, fp.fp_Name, 29 );
  63.                 prefs.fontheight = fp.fp_TextAttr.ta_YSize;
  64.                 break;
  65.         }
  66.     }
  67.     Close( f );
  68. }
  69.  
  70.  
  71. /* Get Colors into prefs */
  72. void getcolors( struct Screen * scr )
  73. {
  74.     int c, numcols = min( ( 1 << scr->RastPort.BitMap->Depth ), 8 );
  75.     UWORD rgb;
  76.  
  77.     if( isv39 )
  78.     {
  79.         GetRGB32( scr->ViewPort.ColorMap, 0, numcols, prefs.colors32 );
  80.         return;
  81.     }
  82.  
  83.     for( c = 0; c < numcols; c ++ )
  84.     {
  85.         rgb = GetRGB4( scr->ViewPort.ColorMap, c );
  86.         prefs.colors32[ ( c * 3 ) + 0 ] = rgb4to32( rgb >> 8 );
  87.         prefs.colors32[ ( c * 3 ) + 1 ] = rgb4to32( rgb >> 4 );
  88.         prefs.colors32[ ( c * 3 ) + 2 ] = rgb4to32( rgb );
  89.     }
  90. }
  91.  
  92. /* Set prefs Colors */
  93. void setcolors( struct Screen *scr )
  94. {
  95.     ULONG table[ 8 * 3 + 2 ];
  96.     ULONG cols = min( 1 << scr->RastPort.BitMap->Depth, 8 );
  97.     int c;
  98.  
  99.     if( isv39 )
  100.     {
  101.         table[ 0 ] = ( cols << 16 );
  102.         memcpy( &table[1], prefs.colors32, 8 * 3 * 4 );
  103.         table[ cols * 3 + 1 ] = 0;
  104.         LoadRGB32( &scr->ViewPort, table );
  105.     }
  106.     else
  107.     {
  108.         for( c = 0; c < cols; c++ )
  109.         {
  110.             SetRGB4( &scr->ViewPort, c,
  111.                  prefs.colors32[ c * 3 ] >> 28,
  112.                  prefs.colors32[ c * 3 + 1 ] >> 28,
  113.                  prefs.colors32[ c * 3 + 2 ] >> 28
  114.             );
  115.         }
  116.  
  117.     }
  118. }
  119.  
  120. void term_getcolors( void )
  121. {
  122.     int c, numcols = min( 1 << scr->RastPort.BitMap->Depth, 8 );
  123.     UWORD rgb;
  124.  
  125.     if( isv39 )
  126.     {
  127.         GetRGB32( scr->ViewPort.ColorMap, 0, numcols, prefs.term_colors );
  128.         return;
  129.     }
  130.  
  131.     for( c = 0; c < numcols; c ++ )
  132.     {
  133.         rgb = GetRGB4( scr->ViewPort.ColorMap, c );
  134.         prefs.term_colors[ ( c * 3 ) + 0 ] = rgb4to32( rgb >> 8 );
  135.         prefs.term_colors[ ( c * 3 ) + 1 ] = rgb4to32( rgb >> 4 );
  136.         prefs.term_colors[ ( c * 3 ) + 2 ] = rgb4to32( rgb );
  137.     }
  138. }
  139.  
  140. /* Set prefs Colors */
  141. extern struct mdtprefs mdtprefs;
  142. void term_setcolors( void )
  143. {
  144.     ULONG table[ 8 * 3 + 2 ];
  145.     ULONG cols = min( 1 << scr->RastPort.BitMap->Depth, 8 );
  146.     int c;
  147.     static UWORD ansicols[]á= {á0x000, 0xd00, 0x0d0, 0xdd0, 0x00d, 0xd0d, 0x0dd, 0xddd };
  148.  
  149.     if( mdtprefs.whichcolors == 2 )
  150.     {
  151.         LoadRGB4( &scr->ViewPort, ansicols, cols );
  152.         return;
  153.     }
  154.  
  155.     if( isv39 )
  156.     {
  157.         table[ 0 ] = ( cols << 16 );
  158.         memcpy( &table[1], prefs.term_colors, 8 * 3 * 4 );
  159.         table[ cols * 3 + 1 ] = 0;
  160.         LoadRGB32( &scr->ViewPort, table );
  161.     }
  162.     else
  163.     {
  164.         for( c = 0; c < cols; c++ )
  165.         {
  166.             SetRGB4( &scr->ViewPort, c,
  167.                  prefs.term_colors[ c * 3 ] >> 28,
  168.                  prefs.term_colors[ c * 3 + 1 ] >> 28,
  169.                  prefs.term_colors[ c * 3 + 2 ] >> 28
  170.             );
  171.         }
  172.  
  173.     }
  174. }
  175.  
  176. void setwbcolors( struct Screen *scr )
  177. {
  178.     ULONG table[ 8 * 3 ];
  179.  
  180.     memcpy( table, prefs.colors32, 8 * 3 * 4 );
  181.     getwbcolors();
  182.     setcolors( scr );
  183.     memcpy( prefs.colors32, table, 8 * 3 * 4 );
  184. }
  185.  
  186. /* Userliste konvertieren */
  187.  
  188. static void convuserlist( void )
  189. {
  190.     struct AsyncFile *f1, *f2;
  191.     struct user new;
  192.     struct olduser old;
  193.  
  194.     if( exists( "microdot.userdb" ) )
  195.         return;
  196.     if( !exists( "microdot.user" ) )
  197.         return;
  198.  
  199.     f1 = OpenAsync( "microdot.user", MODE_READ, sizeof( struct olduser ) * 16 );
  200.     if( !f1 )
  201.         return;
  202.     f2 = OpenAsync( "microdot.userdb", MODE_WRITE, sizeof( struct user ) * 16 );
  203.     if( !f2 )
  204.     {
  205.         CloseAsync( f1 );
  206.         return;        
  207.     }
  208.  
  209.     while( ( ReadAsync( f1, &old, sizeof( old ) ) ) == sizeof( old ) )
  210.     {
  211.         memset( &new, 0, sizeof( new ) );
  212.         memcpy( &new, &old, sizeof( old ) - 4 );
  213.         WriteAsync( f2, &new, sizeof( new ) );
  214.     }
  215.     CloseAsync( f1 );
  216.     CloseAsync( f2 );
  217. }
  218.  
  219.  
  220. void getwbcolors( void )
  221. {
  222.     struct Screen *cmpscr;
  223.  
  224.     if( isv37 )
  225.         cmpscr = LockPubScreen( NULL );
  226.     else
  227.         cmpscr = (struct Screen *) OpenWorkBench();
  228.  
  229.     getcolors( cmpscr );
  230.  
  231.     if( isv37 )
  232.         UnlockPubScreen( NULL, cmpscr );
  233. }
  234.  
  235.  
  236. void doprefsnewinit(void)
  237. {
  238.     int c;
  239.  
  240. ret:
  241.     c=askreq("Willkommen zu ╖ MicroDot ╖\n\nErstkonfiguration per 'microdot.cfg'\neingestelle Parameter:\n\nUsername....: %s (%s)\nPointname...: %s\nBoxname.....: %s%s\nTelefon.....: %s\nSeriell.....: %s, Unit %ld, %lD Baud\nModem-Init..: %s\nModem-Dial..: %s\nModem-Hangup: %s\nPacker......: %s\nEntpacker...: %s\nEditor......: %s\nDatadir.....: %s\nTransferdir.: %s",
  242.         "Akzeptieren|_Point Σndern|_Modem|E_xtern|_Hilfe|Abbruch",
  243.         prefs.username,prefs.userrealname,
  244.         prefs.pointname,
  245.         prefs.boxname,prefs.boxdomain,
  246.         prefs.phone,
  247.         prefs.modemdevice,prefs.modemunit,prefs.modembaud,
  248.         prefs.modeminit,prefs.modemdial,prefs.modemhangup,
  249.         prefs.packer,prefs.unpacker,prefs.editor,
  250.         prefs.datadir,prefs.transferdir);
  251.  
  252.     switch( c )
  253.     {
  254.         case 0:
  255.             exit( 0 );
  256.             break;
  257.  
  258.         case 2:
  259.             dopointcfg();
  260.             goto ret;
  261.  
  262.         case 3:
  263.             doserialcfg();
  264.             goto ret;
  265.  
  266.         case 4:
  267.             doexternprefs();
  268.             goto ret;
  269.  
  270.         case 5:
  271.             showguide( "firstinstall" );
  272.             goto ret;
  273.     }
  274.  
  275.     prefs.flags2 &=~ MDF2_NOPREFS;
  276. }
  277.  
  278. static char *mmdf_name[] = { 
  279.     "MAPS", "MAPS", "MAPS", "MAPS", "AREAFIX", "MAPS", "MAPS" 
  280. };
  281. static char *mmdf_outname[] = { 
  282.     "MAPS", "MAPS", "MAPS", "MAPS", "AREAFIX", "MAPS", "MAPS" 
  283. };
  284. static char *mmdf_add[] = { 
  285.     "ADD", "ADD", "ADD", "ADD", "ADD", "ADD", "ADD" 
  286. };
  287. static char *mmdf_del[] = { 
  288.     "DEL", "DEL", "DEL", "DEL", "DEL", "DEL", "DEL" 
  289. };
  290. static char *mmdf_list[] = { 
  291.     "LIST BRETTER", "LIST BRETTER", "LIST BRETTER *", "LIST BRETTER", "LIST BRETTER", "LIST", "LIST" 
  292. };
  293. static char *mmdf_listv[] = { 
  294.     "LIST BRETTER VERBOSE", "LIST BRETTER VERBOSE", "LIST VERBOSE BRETTER *", "LIST VERBOSE BRETTER", "LIST VERBOSE BRETTER", "LIST", "LIST" 
  295. };
  296. static char *mmdf_help[] = { 
  297.     "HILFE *", "HILFE", "HILFE *", "HILFE *", "HILFE *", "HELP", "HELP" 
  298. };
  299. static char *mmdf_clearpm[] = { 
  300.     "CLEARPM", "--", "PM LOESCHEN", "PM LOESCHEN", "PM LOESCHEN", "DELPM", "CLEARPM" 
  301. };
  302. static char *mmdf_listid[] = { 
  303.     "Re: LIST BRETTER VERBOSE", "BRETTER", "BRETTER", "BRETTER", "BRETTER", "Your LIST", "Your LIST" 
  304. };
  305. static ULONG mmdf_listo[] = {á
  306.     44, 45, 37, 43, 43, 63, 0 
  307. };
  308. static ULONG mmdf_listb[] = {á
  309.     0, 0, 2, 2, 0, 2, 2 
  310. };
  311. static char *mmdf_addpf[] = { 
  312.     "", "", "", "", "ADD ", "", "" 
  313. };
  314. static char *mmdf_delpf[] = { 
  315.     "", "", "", "", "DEL ", "", "" 
  316. };
  317.  
  318. void presetmapsprefs( UBYTE mapstyp )
  319. {
  320.     if( mapstyp < 1 || mapstyp > 7 )
  321.         mapstyp = 1;
  322.     mapstyp--;
  323.  
  324.     strcpy( prefs.mapsname, mmdf_name[ámapstyp ]á);
  325.     strcpy( prefs.mapsoutname, mmdf_outname[ámapstyp ]á);
  326.     strcpy( prefs.maps_add, mmdf_add[ámapstyp ] );
  327.     strcpy( prefs.maps_addprefix, mmdf_addpf[ámapstyp ] );
  328.     strcpy( prefs.maps_delprefix, mmdf_delpf[ámapstyp ] );
  329.     strcpy( prefs.maps_del, mmdf_del[ámapstyp ] );
  330.     strcpy( prefs.maps_list, mmdf_list[ámapstyp ] );
  331.     strcpy( prefs.maps_list_verbose, mmdf_listv[ámapstyp ] );
  332.     strcpy( prefs.maps_help, mmdf_help[ámapstyp ] );
  333.     strcpy( prefs.maps_clearpm, mmdf_clearpm[ámapstyp ] );
  334.     strcpy( prefs.maps_listid, mmdf_listid[ámapstyp ] );
  335.     prefs.maps_list_offs = mmdf_listo[ mapstyp ];
  336.     prefs.maps_list_boffs = mmdf_listb[ mapstyp ];
  337. }
  338.  
  339. static void procitem(char *head,char *data)
  340. {
  341.     if(!stricmp(head,"boxname")) strncpy(prefs.boxname,data,11);
  342.     else if(!stricmp(head,"hostname")) strncpy(prefs.boxname,data,11);
  343.     else if(!stricmp(head,"pointname")) strncpy(prefs.pointname,data,39);
  344.     else if(!stricmp(head,"sysname")) strncpy(prefs.pointname,data,39);
  345.     else if(!stricmp(head,"editor")) strncpy(prefs.editor,data,39);
  346.     else if(!stricmp(head,"username")) strncpy(prefs.username,data,39);
  347.     else if(!stricmp(head,"realname")) strncpy(prefs.userrealname,data,39);
  348.     else if(!stricmp(head,"password")) strncpy(prefs.password,data,39);
  349.     else if(!stricmp(head,"passwort")) strncpy(prefs.password,data,39);
  350.     else if(!stricmp(head,"boxdomain")) strncpy(prefs.boxdomain,data,38);
  351.     else if(!stricmp(head,"domain")) strncpy(prefs.boxdomain,data,38);
  352.     else if(!stricmp(head,"datadir")) strncpy(prefs.datadir,data,127);
  353.     else if(!stricmp(head,"brettdir")) strncpy(prefs.datadir,data,127);
  354.     else if(!stricmp(head,"transferdir")) strncpy(prefs.transferdir,data,127);
  355.     else if(!stricmp(head,"modemdevice")) strncpy(prefs.modemdevice,data,31);
  356.     else if(!stricmp(head,"modemunit")) prefs.modemunit=atoi(data);
  357.     else if(!stricmp(head,"modembaud")) prefs.modembaud=atoi(data);
  358.     else if(!stricmp(head,"dialretries")) prefs.dialretries=atoi(data);
  359.     else if(!stricmp(head,"dialtimeout")) prefs.dialtimeout=atoi(data);
  360.     else if(!stricmp(head,"dialretrydelay")) prefs.retrydelay=atoi(data);
  361.     else if(!stricmp(head,"dialpacktimeout")) prefs.packtimeout=atoi(data);
  362.     else if(!stricmp(head,"modemflags")) prefs.modemflags=atoi(data);
  363.     else if(!stricmp(head,"modeminit")) strncpy(prefs.modeminit,data,39);
  364.     else if(!stricmp(head,"modemdial")) strncpy(prefs.modemdial,data,39);
  365.     else if(!stricmp(head,"modemhangup")) strncpy(prefs.modemhangup,data,39);
  366.     else if(!stricmp(head,"packer")) strncpy(prefs.packer,data,39);
  367.     else if(!stricmp(head,"unpacker")) strncpy(prefs.unpacker,data,39);
  368.     else if(!stricmp(head,"organisation")) strncpy(prefs.organisation,data,79);
  369.     else if(!stricmp(head,"login")) strncpy(prefs.rfc_login,data,255);
  370.     else if(!stricmp(head,"screenmode")) {
  371.         if(!stricmp(data,"interlace")) prefs.flags|=MDF_INTERLACE;
  372.         else prefs.flags&=~MDF_INTERLACE;
  373.     }
  374.     else if(!stricmp(head,"telefon")) strncpy(prefs.phone,data,79);
  375.     else if(!stricmp(head,"phone")) strncpy(prefs.phone,data,79);
  376.     else if(!stricmp(head,"mapsname")) strncpy( prefs.mapsname, data, 39 );
  377.     else if(!stricmp(head,"mapsoutname")) strncpy( prefs.mapsname, data, 39 );
  378.     else if(!stricmp(head,"mapsname")) strncpy( prefs.mapsname, data, 39 );
  379.     else if(!stricmp(head,"mapsoutname")) strncpy( prefs.mapsoutname, data, 39 );
  380.     else if(!stricmp(head,"mapsadd")) strncpy( prefs.maps_add, data, 39 );
  381.     else if(!stricmp(head,"mapsdel")) strncpy( prefs.maps_del, data, 39 );
  382.     else if(!stricmp(head,"mapslist")) strncpy( prefs.maps_list, data, 39 );
  383.     else if(!stricmp(head,"mapslistverbose")) strncpy( prefs.maps_list_verbose, data, 39 );
  384.     else if(!stricmp(head,"mapsclearpm")) strncpy( prefs.maps_clearpm, data, 39 );
  385.     else if(!stricmp(head,"mapshelp")) strncpy( prefs.maps_help, data, 39 );
  386.     else if(!stricmp(head,"mapstype")) presetmapsprefs( atoi( data ) );
  387.     else if(!stricmp(head,"mapstyp")) presetmapsprefs( atoi( data ) );
  388.     else if(!stricmp(head,"mapslistid")) strncpy( prefs.maps_listid, data, 39 );
  389.     else if(!stricmp(head,"mapslistcol")) prefs.maps_list_offs = atoi( data );
  390.     else if(!stricmp(head,"mapslistsubjectcol")) prefs.maps_list_offs = atoi( data );
  391.     else if(!stricmp(head,"mapsliststartcol")) prefs.maps_list_boffs = atoi( data );
  392.     else if(!stricmp(head,"netcallmode"))
  393.     {
  394.         if( !stricmp( data, "n38" ) || !stricmp( data, "z38" ) )
  395.             prefs.mode = MDM_N38;
  396.         else if( !stricmp( data, "rfc" ) || !stricmp( data, "uucp" ) )
  397.             prefs.mode = MDM_RFC;
  398.         else if( !stricmp( data, "janus2" ) )
  399.             prefs.flags2 |= MDF2_JANUS2;
  400.     }
  401.     else {
  402.         char buf[80];
  403.         sprintf(buf,"Fehler in prefs: %s unbekannt\n",head);
  404.         Write(Output(),buf,strlen(buf));
  405.     }
  406.  
  407.     makedospath( prefs.transferdir );
  408.     makedospath( prefs.datadir );
  409. }
  410.  
  411. void freeprefs(void)
  412. {
  413. }
  414.  
  415. #define NEWPREFSID 0x8d0ac01d
  416.  
  417. void saveprefs(char *pf)
  418. {
  419.     BPTR f;
  420.     struct mdprefs *p;
  421.     int prefspacksize = 0;
  422.     ULONG pid = NEWPREFSID;
  423.  
  424.     if( prefs.flags2 & MDF2_NOPREFS )
  425.         return;
  426.     if( !( f = Open( pf, MODE_NEWFILE ) ) )
  427.          return;
  428.  
  429.     p = myAllocVec( sizeof( prefs ) + 512, MEMF_CLEAR );
  430.     if( p )
  431.         prefspacksize = lzw_pack( &prefs, p, sizeof( prefs ), 10 );
  432.     if( !prefspacksize )
  433.     {
  434.         Write( f, &prefs, sizeof(struct mdprefs) );
  435.     }
  436.     else
  437.     {
  438.         Write( f, &pid, 4 );
  439.         Write( f, p, prefspacksize );
  440.     }
  441.     Close( f );
  442.     if( p )
  443.         myFreeVec( p );
  444. }
  445.  
  446. void loadprefs( char *pf )
  447. {
  448.     BPTR f2;
  449.     FILE *f;
  450.     char line[256];
  451.     char *p,*p2,ch;
  452.     int c;
  453.  
  454.     convuserlist();
  455.  
  456.     presetmapsprefs( 0 );
  457.  
  458.     prefs.pens[ PEN_TEXT ]á= 1;
  459.     prefs.pens[ PEN_MARK ]á= 1;
  460.     prefs.pens[ PEN_MARKBOLD ]á= 1;
  461.     prefs.pens[ PEN_SEL  ]á= 3;
  462.     prefs.pens[áPEN_SELBAK ] = 2;
  463.     prefs.pens[ PEN_MARKSEL  ]á= 3;
  464.     prefs.pens[áPEN_MARKSELBAK ] = 2;
  465.     prefs.pens[ PEN_MARKSELBOLD ] = 1;
  466.  
  467.     prefs.pens[ PEN_READ ] = 1;
  468.     prefs.pens[ PEN_QUOTEBOLD ] = 1;
  469.     prefs.pens[ PEN_HEAD ] = 3;
  470.  
  471.     for( c = 0; c < 7; c++ )
  472.         prefs.quotepens[ác ]á= ( c % 3 ) + 1;
  473.  
  474.     prefs.editor_stack = 8192;
  475.     prefs.viewer_stack = 8192;
  476.  
  477.     prefs.auto_ixcreate = TRUE;
  478.     prefs.screendepth = 2;
  479.     prefs.reqpos = REQPOS_CENTERSCR;
  480.     prefs.showboardtree = TRUE;
  481.  
  482.     prefs.zmodembuffer = 32;
  483.  
  484.     strcpy( prefs.username, "Undefiniert" );
  485.     strcpy( prefs.userrealname, "Vorname Nachname" );
  486.  
  487.     if( isv37 )
  488.         strcpy( prefs.console_window, "CON:////%t/CLOSE/AUTO" );
  489.     else
  490.         strcpy( prefs.console_window, "CON:////%t" );
  491.  
  492.     strcpy( prefs.langnames, "Deutsch" );
  493.     strcpy( &prefs.langnames[ 30 ], "English" );
  494.  
  495.     strcpy( prefs.rfc_cicocon, "CON://640/240/MicroDot-UUCP-Transfer/AUTO" );
  496.  
  497.     f2 = Open( pf, MODE_OLDFILE );
  498.     if( f2 )
  499.     {
  500.         ULONG pid, coltest, c;
  501.  
  502.         Read( f2, &pid, 4 );
  503.  
  504.         if( pid == NEWPREFSID )
  505.         {
  506.             APTR b1, b2;
  507.  
  508.             do {
  509.                 b1 = AllocMem( sizeof( struct mdprefs ) * 2, MEMF_CLEAR );
  510.             } while( !b1 );
  511.             do {
  512.                 b2 = AllocMem( sizeof( struct mdprefs ) * 2, MEMF_CLEAR );
  513.             } while( !b2 );
  514.  
  515.             Read( f2, b1, sizeof( prefs ) * 2 );
  516.             lzw_unpack( b1, b2 );
  517.  
  518.             memcpy( &prefs, b2, sizeof( prefs ) );
  519.             FreeMem( b1, sizeof( struct mdprefs ) * 2 );
  520.             FreeMem( b2, sizeof( struct mdprefs ) * 2 );
  521.         }
  522.         else
  523.         {
  524.             Seek( f2, 0, OFFSET_BEGINNING );
  525.             Read( f2, &prefs, sizeof(struct mdprefs) );
  526.         }
  527.         Close( f2 );
  528.  
  529.         /* Umtragen */
  530.         if( !prefs.pointname[0] )
  531.             strcpy( prefs.pointname, prefs.oldpointname );
  532.  
  533.         if( !prefs.boxname[0] )
  534.             strcpy( prefs.boxname, prefs.oldboxname );
  535.  
  536.         if( !prefs.editor[á0 ]á)
  537.             strcpy( prefs.editor, prefs.oldeditor );
  538.  
  539.         for( coltest = 0, c = 0; c < ( 1L << prefs.screendepth ); c++ )
  540.         {
  541.             if( prefs.colors32[ c ]á)
  542.                 coltest |= 1;
  543.             if( prefs.term_colors[ c ]á)
  544.                 coltest |= 2;
  545.         }
  546.  
  547.         if( !prefs.reader_tabsize )
  548.             prefs.reader_tabsize = 8;
  549.  
  550.         if( ! ( coltest & 1 ) )
  551.         {
  552.             getwbcolors();
  553.         }
  554.  
  555.         if( ! ( coltest & 2 ) )
  556.         {
  557.             memcpy( prefs.term_colors, prefs.colors32, 3 * 8 * 4 );
  558.         }
  559.  
  560.         if( !prefs.screendepth )
  561.             prefs.screendepth = 2;
  562.  
  563.         if( !prefs.console_window[á0 ]á)
  564.         {
  565.             if( isv37 )
  566.                 strcpy( prefs.console_window, "CON:////%t/CLOSE/AUTO/%p" );
  567.             else
  568.                 strcpy( prefs.console_window, "CON:////%t" );
  569.         }
  570.  
  571.         prefs.flags2 |= MDF2_PREFSLOADED;
  572.         //prefs.flags &= ~MDF_HIDEDEL;
  573.  
  574.         if( prefs.std_maps_type )
  575.             presetmapsprefs( prefs.std_maps_type );
  576.  
  577.         if( !strchr( prefs.transferdir, ':' ) )
  578.         {
  579.             askreq( "Warnung!\nDas MicroDot-Transferverzeichnis mu▀ absolut\n(d.h. mit Laufwerksangabe) angegeben werden.", "Weiter" );
  580.             if( isv37 )
  581.                 strins( prefs.transferdir, "PROGDIR:" );
  582.         }
  583.  
  584.         if( !strchr( prefs.datadir, ':' ) )
  585.         {
  586.             askreq( "Warnung!\nDas MicroDot-Dataverzeichnis mu▀ absolut\n(d.h. mit Laufwerksangabe) angegeben werden.", "Weiter" );
  587.             if( isv37 )
  588.                 strins( prefs.datadir, "PROGDIR:" );
  589.         }
  590.  
  591.         for( c = 0; c < 7; c++ )
  592.             if( prefs.quotepens[ác ]á)
  593.                 break;
  594.  
  595.         if( c == 7 )
  596.         {
  597.             for( c = 0; c < 7; c++ )
  598.                 prefs.quotepens[ác ]á= ( c % 3 ) + 1;
  599.         }
  600.  
  601.         makedospath( prefs.transferdir );
  602.         makedospath( prefs.datadir );
  603.  
  604.         makexpkpw();
  605.  
  606.         if( !registerinfo.serie )
  607.             prefs.do_packmsg = 0;
  608.  
  609.         return;
  610.     }
  611.  
  612.     getwbcolors();
  613.     getwbfonts();
  614.  
  615.     strcpy( prefs.modemdevice, "serial.device" );
  616.     prefs.modembaud = 19200;
  617.     prefs.oscantype = 0;
  618.     prefs.displayid = HIRES_KEY;
  619.     strcpy( prefs.boxname, "Boxname" );
  620.     strcpy( prefs.boxdomain, ".box.do.main" );
  621.     strcpy( prefs.organisation, "MicroDot-Supportsystem" );
  622.     strcpy( prefs.phone, "1234567890" );
  623.     if( isv37 )
  624.         strcpy(prefs.datadir,"PROGDIR:DATA/");
  625.     else
  626.         strcpy(prefs.datadir,"DATA/");
  627.  
  628.     if( isv37 )
  629.         strcpy(prefs.transferdir,"PROGDIR:TRANSFER/");
  630.     else
  631.         strcpy(prefs.transferdir,"TRANSFER/");
  632.  
  633.     strcpy( prefs.packer, "lha -0 a %s PUFFER" );
  634.     strcpy( prefs.unpacker, "lha x %s" );
  635.     strcpy( prefs.modeminit, "ATZ|~~" );
  636.     strcpy( prefs.modemdial, "ATDP" );
  637.     strcpy( prefs.modemhangup, "~~~+++~~~ATH0|" );
  638.  
  639.     strcpy( prefs.editor, "ed %s" );
  640.  
  641.     if( isv37 )
  642.     {
  643.         GetVar( "EDITOR", prefs.editor, 127, 0 );
  644.     }
  645.  
  646.     strcpy( prefs.pointname, "MDINFO" );
  647.     strcpy( prefs.password, "MDINFO" );
  648.  
  649.     if( isv39 )
  650.         strcpy( prefs.binviewer, "Sys:Utilities/MULTIVIEW %s" );
  651.     else
  652.         strcpy( prefs.binviewer, "Sys:Utilities/Display %s" );
  653.  
  654.     prefs.dialretries=42;
  655.     prefs.dialtimeout=90;
  656.     prefs.retrydelay=5;
  657.     prefs.packtimeout=1200;
  658.     prefs.flags |= MDF_SHOWREAL | MDF_TERM_IBM | MDF_TERM_LOG | MDF_TERM_AUTODL | MDF_TERM_AUTOUL | MDF_EB | MDF_GADGETS | MDF_SORTDATE;
  659.     prefs.flags2 |= MDF2_NOPREFS | MDF2_CRUNCH_DAT | MDF2_SCROLLJUMP | MDF2_TERM_AUTOLOGIN | MDF2_NEXTNEWBOARD | MDF2_NEXTNEWBOARDASK;
  660.  
  661.     prefs.swidth = 640;
  662.     prefs.sheight = 256;
  663.  
  664.     prefs.wz_fm    = 9; prefs.wz_fd = 26;
  665.     prefs.sz_fm = 3; prefs.sz_fd = 28;
  666.     prefs.wz_offs = 1; prefs.sz_offs = 2;
  667.  
  668.     time( &prefs.firstinstalltime );
  669.  
  670.     f=fopen("microdot.cfg","r");
  671.     if( !f )
  672.     {
  673.         makexpkpw();
  674.         return;
  675.     }
  676.  
  677.     for( ;; )
  678.     {
  679.         if(!fgets(line,256,f)) break;
  680.         clnl(line);
  681.         p=stpblk(line);
  682.         if(!p || !*p || *p==';' || *p=='#') continue;
  683.         if(p!=line) strcpy(line,p);
  684.         p=p2=strchr(line,'=');
  685.         if(!p) continue;
  686.         *p++; p=stpblk(p);
  687.         p2--;
  688.         while(*p2==' ')p2--;
  689.         p2++; *p2=0;
  690.         procitem(line,p);
  691.     }
  692.  
  693.     fclose( f );
  694.  
  695.     if(prefs.boxdomain[0]!='.') strins(prefs.boxdomain,".");
  696.     ch=prefs.datadir[strlen(prefs.datadir)-1];
  697.     if(ch!='/'&&ch!=':') strcat(prefs.datadir,"/");
  698.     ch=prefs.transferdir[strlen(prefs.transferdir)-1];
  699.     if(ch!='/'&&ch!=':') strcat(prefs.transferdir,"/");
  700.  
  701.     makexpkpw();
  702. }
  703.  
  704. static void dofontprefs1( char *fontname, int *fontheight )
  705. {
  706.     int rc;
  707.     struct rtFontRequester *fontreq;
  708.     struct TextFont *tf;
  709.  
  710.     fontreq = rtAllocRequest( RT_FONTREQ, NULL );
  711.  
  712.     if( !fontreq )
  713.         return;
  714.  
  715.     rtChangeReqAttr( fontreq,
  716.         RTFO_FontName, fontname,
  717.         RTFO_FontHeight, *fontheight,
  718.         TAG_DONE ); 
  719.  
  720.     rc = rtFontRequest( fontreq,
  721.         "Bitte Text-Font auswΣhlen",
  722.         RTFO_Flags, FREQF_FIXEDWIDTH,
  723.         TAG_DONE );
  724.  
  725.     if( !rc )
  726.     {
  727.         rtFreeRequest( fontreq );
  728.         return;
  729.     }
  730.  
  731.     tf = OpenDiskFont( &fontreq->Attr );
  732.  
  733.     if( !tf )
  734.     {
  735.         displaybeep();
  736.         rtFreeRequest( fontreq );
  737.         return;
  738.     }
  739.  
  740.     strcpy( fontname, fontreq->Attr.ta_Name );
  741.     *fontheight = fontreq->Attr.ta_YSize;
  742.  
  743.     rtFreeRequest( fontreq );
  744. }
  745.  
  746. static void dofontprefs2( char *fontname, int *fontheight, char *title )
  747. {
  748.     struct TextFont *tf;
  749.     struct rtFontRequester *fontreq;
  750.     int rc;
  751.  
  752.     fontreq = rtAllocRequest( RT_FONTREQ, NULL );
  753.  
  754.     if( !fontreq )
  755.         return;
  756.  
  757.     rtChangeReqAttr( fontreq,
  758.         RTFO_FontName, fontname,
  759.         RTFO_FontHeight, *fontheight,
  760.         TAG_DONE ); 
  761.  
  762.     rc = rtFontRequest( fontreq,
  763.         title,
  764.         TAG_DONE );
  765.  
  766.     if( !rc )
  767.     {
  768.         rtFreeRequest( fontreq );
  769.         return;
  770.     }
  771.  
  772.     tf = OpenDiskFont( &fontreq->Attr );
  773.  
  774.     if( !tf )
  775.     {
  776.         displaybeep();
  777.         rtFreeRequest( fontreq );
  778.         return;
  779.     }
  780.  
  781.     strcpy( fontname, fontreq->Attr.ta_Name );
  782.     *fontheight = fontreq->Attr.ta_YSize;
  783.  
  784.     rtFreeRequest( fontreq );
  785. }
  786.  
  787. #define FGI_F1 1
  788. #define FGI_F2 2
  789. #define FGI_S1 3
  790. #define FGI_S2 4
  791. #define FGI_OK 5
  792. #define FGI_CANCEL 6
  793. #define FGI_OWNSCREEN 7
  794. /*#define FGI_PUBSCREEN 8*/
  795. #define FGI_F3 9
  796. #define FGI_S3 10
  797.  
  798. #define FGI_RES 11
  799. #define FGI_RESSEL 12
  800.  
  801. #define FGI_COLACT 13
  802. #define FGI_COLSEL 14
  803.  
  804. #define FGI_CLOCK 15
  805.  
  806. #define FGI_GADGET 16
  807.  
  808. static char *clock_options[] = 
  809. {
  810.      "HH:MM:SS",
  811.      "HH:MM",
  812.      "Keine",
  813.      NULL
  814. };
  815.  
  816. void dofontprefs( void )
  817. {
  818.     struct ogwin *ogw;
  819.     struct Window *iw;
  820.     char    fn1[ 64 ],
  821.             fn2[ 64 ],
  822.             fn3[ 64 ];
  823.     char fp1[ 64 ], fp2[ 64 ], fp3[ 64 ];
  824.     char modebuffer[ 128 ], modestring[ 128 ];
  825.     int fs1 = prefs.fontheight, fs2 = prefs.gadfontheight, fs3 = prefs.screenfontheight;
  826.     struct IntuiMessage *im;
  827.     int rc;
  828.     struct rtScreenModeRequester *smr;
  829.     int Done = FALSE;
  830.  
  831.     smr = rtAllocRequest( RT_SCREENMODEREQ, TAG_DONE );
  832.     if( !smr )
  833.         return;
  834.  
  835.     rtChangeReqAttr( smr,
  836.         RTSC_OverscanType, prefs.oscantype,
  837.         RTSC_ModeFromScreen, scr,
  838.         RTSC_DisplayWidth, prefs.swidth,
  839.         RTSC_DisplayHeight, prefs.sheight,
  840.         RTSC_DisplayDepth, prefs.screendepth,
  841.         TAG_DONE
  842.     );
  843.  
  844.     strcpy( fp1, prefs.fontname );
  845.     strcpy( fp2, prefs.gadfontname );
  846.     strcpy( fp3, prefs.screenfontname );
  847.  
  848.     ogw = ogreInitWindow( scr, WFLG_RMBTRAP, NULL, "Bildschirm-Konfiguration" );
  849.  
  850.     ogreAddGroup( ogw, 0, OGFRAME_OUTLINE, " Fonts " );
  851.     ogreAddText( ogw, 1, "_Text-Font:", FGI_F1, "", 40, TRUE );
  852.     ogreAddText( ogw, 0, "_Gadgetleisten-Font:", FGI_F2, "", 40, TRUE );
  853.     ogreAddButton( ogw, 1 | OGGP_KEEPSIZE, 't', "?", FGI_S1 );
  854.     ogreAddButton( ogw, 0 | OGGP_KEEPSIZE, 'g', "?", FGI_S2 );
  855.     ogreAddText( ogw, 2, "_Bildschirm-Font:", FGI_F3, "", 40, TRUE );
  856.     ogreAddButton( ogw, 2 | OGGP_KEEPSIZE, 'b', "?", FGI_S3 );
  857.  
  858.     ogreAddGroup( ogw, 1, OGFRAME_OUTLINE, " Bildschirm " );
  859.     ogreAddCheckbox( ogw, 0, 'e', "_Eigener Bildschirm", FGI_OWNSCREEN, prefs.flags2 & MDF2_OWNSCREEN );
  860.  
  861. /*    ogreAddCheckbox( ogw, 0, 'p', "Bildschirm _Public?", FGI_PUBSCREEN, prefs.flags2 & MDF2_PUBSCREEN );*/
  862. /*    ogreAddCheckbox( ogw, 1, 'w', "_Workbench-Farben?", FGI_COLACT, !prefs.usecustomcolors );
  863.     ogreAddButton( ogw, 1, 'f', "_Farben einstellen", FGI_COLSEL );*/
  864.  
  865.     ogreAddCheckbox( ogw, 0, 'l', "Gadget-_Leiste", FGI_GADGET, prefs.flags & MDF_GADGETS );
  866.     ogreAddCycle( ogw, 0 , 'u', "_Uhr:", FGI_CLOCK, clock_options, 12, prefs.clockmode );
  867.     ogreAddText( ogw, 1, "Bildschirm-_Modus:", FGI_RES, "", 40, TRUE );
  868.     ogreAddButton( ogw, 1 | OGGP_KEEPSIZE, 'm', "?", FGI_RESSEL );
  869.  
  870.     ogreAddGroup( ogw, 2, OGFRAME_NONE, NULL );
  871.     ogreAddButton( ogw, 0 | OGB_ONENTER, 'o', "_OK", FGI_OK );
  872.     ogreAddHelp( ogw, 0 );
  873.     ogreAddButton( ogw, 0 | OGB_ONESC, 'a', "_Abbruch", FGI_CANCEL  );
  874.  
  875.     ogreEnable( ogw, !wbwindow, FGI_COLSEL, 0 );
  876.  
  877.     iw = ogreOpenWindow( ogw );
  878.     if( !iw)
  879.         return;
  880.  
  881.     while( !Done )
  882.     {
  883.         rc = GetDisplayInfoData(
  884.             NULL,
  885.             modebuffer,
  886.             128,
  887.             DTAG_NAME,
  888.             smr->DisplayID
  889.         );
  890.  
  891.         if( rc < 17 )
  892.             strcpy( &modebuffer[ 16 ], "unbenannt" );
  893.         else
  894.         {
  895.             //modebuffer[árc ] = 0;
  896.         }
  897.  
  898.         sprintf( modestring, "%lD ╫ %lD, %ld Farben, %s",
  899.             smr->DisplayWidth,
  900.             smr->DisplayHeight,
  901.             1 << smr->DisplayDepth,
  902.             &modebuffer[á16 ]
  903.         );
  904.  
  905.         sprintf( fn1, "%s / %ld", fp1, fs1 );
  906.         sprintf( fn2, "%s / %ld", fp2, fs2 );
  907.         sprintf( fn3, "%s / %ld", fp3, fs3 );
  908.  
  909.         ogreSetStringValue( ogw, FGI_F1, fn1 );
  910.         ogreSetStringValue( ogw, FGI_F2, fn2 );
  911.         ogreSetStringValue( ogw, FGI_F3, fn3 );
  912.  
  913.         ogreSetStringValue( ogw, FGI_RES, modestring );
  914.  
  915.         ogreEnable( ogw, ogreValue( ogw, FGI_OWNSCREEN ) && !ogreValue( ogw, FGI_COLACT ), FGI_COLSEL, 0 );
  916.         ogreEnable( ogw, ogreValue( ogw, FGI_OWNSCREEN ), /*FGI_PUBSCREEN,*/ FGI_F3, FGI_S3, FGI_COLACT, FGI_RES, FGI_RESSEL, FGI_CLOCK, /*FGI_GADGET,*/ 0 );
  917.  
  918.         im = ogreWaitIM( ogw );
  919.  
  920.         if( im->Class == IDCMP_GADGETUP )
  921.         {
  922.             switch( im->Code )
  923.             {
  924.                 case FGI_S1:
  925.                     dofontprefs1( fp1, &fs1 );
  926.                     break;
  927.  
  928.                 case FGI_S2:
  929.                     dofontprefs2( fp2, &fs2, "Bitte Gadgetleisten-Font auswΣhlen:" );
  930.                     break;
  931.  
  932.                 case FGI_S3:
  933.                     dofontprefs2( fp3, &fs3, "Bitte Bildschirm-Font auswΣhlen:" );
  934.                     break;
  935.  
  936.                 case FGI_RESSEL:
  937.                     rtScreenModeRequest( smr, "Bildschirmmodus auswΣhlen...",
  938.                         RT_Screen, scr,
  939.                         RT_ReqPos, REQPOS_CENTERSCR,
  940.                         RTSC_Flags, SCREQF_GUIMODES | SCREQF_OVERSCANGAD | SCREQF_SIZEGADS | SCREQF_DEPTHGAD,
  941.                         RTSC_MinWidth, 640, RTSC_MinHeight, 256,
  942.                         RTSC_MinDepth, 1, RTSC_MaxDepth, 3,
  943.                         TAG_DONE
  944.                     );
  945.                     break;
  946.  
  947. /*
  948.                 case FGI_COLSEL:
  949.                     rtPaletteRequest( "Farben einstellen:", NULL, TAG_DONE );
  950.                     break;*/
  951.  
  952.                 case FGI_OK:
  953.                     Done = 1;
  954.                     break;
  955.                 case FGI_CANCEL:
  956.                     Done = 2;
  957.                     break;
  958.             }
  959.         }
  960.         else if( im->Class == IDCMP_GADGETHELP )
  961.             showguidenum( "fontprefs", im->Code );
  962.         ogreIMReply( ogw, im );
  963.     }
  964.  
  965.     if( Done == 1 )
  966.     {
  967.         if( ogreValue( ogw, FGI_OWNSCREEN ) )
  968.             prefs.flags2 |= MDF2_OWNSCREEN;
  969.         else
  970.             prefs.flags2 &= ~MDF2_OWNSCREEN;
  971.  
  972. /*        if( ogreValue( ogw, FGI_PUBSCREEN ) )
  973.             prefs.flags2 |= MDF2_PUBSCREEN;
  974.         else
  975.             prefs.flags2 &= ~MDF2_PUBSCREEN;*/
  976.  
  977.         if( ogreValue( ogw, FGI_GADGET ) )
  978.             prefs.flags |= MDF_GADGETS;
  979.         else
  980.             prefs.flags &= ~MDF_GADGETS;
  981.  
  982. /*        prefs.usecustomcolors = !ogreValue( ogw, FGI_COLACT );*/
  983.  
  984.         prefs.clockmode = ogreValue( ogw, FGI_CLOCK );
  985.  
  986. /*        if( prefs.usecustomcolors && !wbwindow )
  987.             getcolors();*/
  988.     }
  989.  
  990.       ogreExitWindow( ogw );
  991.  
  992.     if( Done == 1 )
  993.     {
  994.         strcpy( prefs.fontname, fp1 );
  995.         strcpy( prefs.gadfontname, fp2 );
  996.         strcpy( prefs.screenfontname, fp3 );
  997.         prefs.fontheight = fs1;
  998.         prefs.gadfontheight = fs2;
  999.         prefs.screenfontheight = fs3;
  1000.  
  1001.         prefs.displayid    = smr->DisplayID;
  1002.         prefs.oscantype    = smr->OverscanType;
  1003.         prefs.swidth     = smr->DisplayWidth;
  1004.         prefs.sheight     = smr->DisplayHeight;
  1005.         prefs.screendepth = smr->DisplayDepth;
  1006.  
  1007.         savemenustate( w->MenuStrip );
  1008.         closegui();
  1009.         opengui();
  1010.         resetmenustate( w->MenuStrip );
  1011.     }
  1012.  
  1013.     rtFreeRequest( smr );
  1014. }
  1015.  
  1016. void dofontprefs13( void )
  1017. {
  1018.     struct ogwin *ogw;
  1019.     struct Window *w;
  1020.     struct IntuiMessage *im;
  1021.     int Done = FALSE;
  1022.  
  1023.     if( isv37 )
  1024.         return;
  1025.  
  1026.     ogw = ogreInitWindow( scr, WFLG_RMBTRAP, NULL, "Bildschirm-Konfiguration" );
  1027.  
  1028.     ogreAddGroup( ogw, 0, OGFRAME_OUTLINE, " Allgemeines " );
  1029.     ogreAddCheckbox( ogw, 0, 'i', "_Interlace?", FGI_OWNSCREEN, prefs.flags & MDF_INTERLACE );
  1030.     ogreAddCheckbox( ogw, 1, 'l', "Gadget-_Leiste", FGI_GADGET, prefs.flags & MDF_GADGETS );
  1031.     ogreAddCycle( ogw, 2 , 'u', "_Uhr:", FGI_CLOCK, clock_options, 12, prefs.clockmode );
  1032.  
  1033.     ogreAddGroup( ogw, 1, OGFRAME_NONE, NULL );
  1034.     ogreAddButton( ogw, 0 | OGB_ONENTER, 'o', "_OK", FGI_OK );
  1035.     ogreAddHelp( ogw, 0 );
  1036.     ogreAddButton( ogw, 0 | OGB_ONESC, 'a', "_Abbruch", FGI_CANCEL  );
  1037.  
  1038.     w = ogreOpenWindow( ogw );
  1039.     if( !w)
  1040.     {
  1041.         displaybeep();
  1042.         return;
  1043.     }
  1044.  
  1045.     while( !Done )
  1046.     {
  1047.         im = ogreWaitIM( ogw );
  1048.  
  1049.         if( im->Class == IDCMP_GADGETUP )
  1050.         {
  1051.             switch( im->Code )
  1052.             {
  1053.                 case FGI_OK:
  1054.                     Done = 1;
  1055.                     break;
  1056.                 case FGI_CANCEL:
  1057.                     Done = 2;
  1058.                     break;
  1059.             }
  1060.         }
  1061.         else if( im->Class == IDCMP_GADGETHELP )
  1062.             showguidenum( "fontprefs13", im->Code );
  1063.         ogreIMReply( ogw, im );
  1064.     }
  1065.  
  1066.     if( Done == 1 )
  1067.     {
  1068.         if( ogreValue( ogw, FGI_OWNSCREEN ) )
  1069.             prefs.flags |= MDF_INTERLACE;
  1070.         else
  1071.             prefs.flags &= ~MDF_INTERLACE;
  1072.  
  1073.         if( ogreValue( ogw, FGI_GADGET ) )
  1074.             prefs.flags |= MDF_GADGETS;
  1075.         else
  1076.             prefs.flags &= ~MDF_GADGETS;
  1077.  
  1078.         prefs.clockmode = ogreValue( ogw, FGI_CLOCK );
  1079.  
  1080.     }
  1081.  
  1082.       ogreExitWindow( ogw );
  1083.  
  1084.     if( Done == 1 )
  1085.     {
  1086.         savemenustate( w->MenuStrip );
  1087.         closegui();
  1088.         opengui();
  1089.         resetmenustate( w->MenuStrip );
  1090.     }
  1091. }
  1092.  
  1093.  
  1094. static ULONG rtgetpw( char *title )
  1095. {
  1096.     UBYTE pwbuf[ 32 ];
  1097.  
  1098.     pwbuf[0]á= 0;
  1099.  
  1100.     if( !rtGetString( pwbuf, 31, NULL, rinfo,
  1101.         RTGS_Invisible, TRUE,
  1102.         RTGS_TextFmt, title,
  1103.         TAG_DONE ) )
  1104.             return( 0 );
  1105.  
  1106.     if( !pwbuf[0] )
  1107.         return( 0 );
  1108.  
  1109.     strlwr( pwbuf );
  1110.     return( crc32( pwbuf, strlen( pwbuf ) ) );
  1111. }
  1112.  
  1113.  
  1114. void docheckpassword( void )
  1115. {
  1116.     ULONG pwcrc;
  1117.  
  1118.     if( !prefs.passwordcrc )
  1119.         return;
  1120.  
  1121.     pwcrc = rtgetpw( "Passwortgeschⁿtzt! Bitte Passwort eingeben:" );
  1122.  
  1123.     if( pwcrc != prefs.passwordcrc )
  1124.     {
  1125.         openlogmsg( "!!! Fehler bei der Passworteingabe !!!" );
  1126.         printlog( "Es erfolgte ein Zugriffsversuch mit falschem Passwort.\n" );
  1127.         closelogmsg();
  1128.         askreq( "Zugang verweigert!", "Beenden" );
  1129.         exit( 10 );
  1130.     }
  1131. }
  1132.  
  1133.  
  1134. /* Change internal Password */
  1135.  
  1136. void dochangepassword( void )
  1137. {
  1138.     ULONG pwcrc;
  1139.  
  1140.     if( prefs.passwordcrc )
  1141.     {
  1142.         pwcrc = rtgetpw( "PASSWORT ─NDERN - Bitte altes Passwort eingeben:" );
  1143.  
  1144.         if( pwcrc != prefs.passwordcrc )
  1145.         {
  1146.             if( pwcrc ) askreq( "Falsches Passwort!", "Abbruch" );
  1147.             return;
  1148.         }
  1149.     }
  1150.  
  1151.     for( ;; )
  1152.     {
  1153.         pwcrc = rtgetpw ( "PASSWORT ─NDERN - Bitte neues Passwort eingeben:" );
  1154.         prefs.passwordcrc = pwcrc;
  1155.         saveprefs( currentprefsname );
  1156.         if( !pwcrc )
  1157.         {
  1158.             makexpkpw();
  1159.             askreq( "Passwort gel÷scht!", "OK" );
  1160.             return;
  1161.         }
  1162.  
  1163.         pwcrc = rtgetpw( "PASSWORT ─NDERN - Bitte neues Passwort bestΣtigen:" );
  1164.         if( pwcrc == prefs.passwordcrc )
  1165.         {
  1166.             makexpkpw();
  1167.             askreq( "Passwort gesetzt.", "OK" );
  1168.             return;
  1169.         }
  1170.         askreq( "Die eingegebenen Passw÷rter\nstimmen nicht ⁿberein!", "Nochmal" );
  1171.     }
  1172. }
  1173.