home *** CD-ROM | disk | FTP | other *** search
/ Nebula 2 / Nebula Two.iso / SourceCode / MiscKit1.7.1 / MiscKit / Examples / ScrollDir / Defaults.m < prev    next >
Encoding:
Text File  |  1996-02-08  |  11.2 KB  |  418 lines
  1. //=============================================================================
  2. //
  3. //        Copyright (C) 1995,1996 by Paul S. McCarthy and Eric Sunshine.
  4. //                Written by Paul S. McCarthy and Eric Sunshine.
  5. //                            All Rights Reserved.
  6. //
  7. //        This notice may not be removed from this source code.
  8. //
  9. //        This object is included in the MiscKit by permission from the authors
  10. //        and its use is governed by the MiscKit license, found in the file
  11. //        "License.rtf" in the MiscKit disibution.  Please refer to that file
  12. //        for a list of all applicable permissions and resictions.
  13. //
  14. //=============================================================================
  15. //-----------------------------------------------------------------------------
  16. // Defaults.m
  17. //
  18. //        Simplified interface to NeXT defaults system.
  19. //
  20. //-----------------------------------------------------------------------------
  21. //-----------------------------------------------------------------------------
  22. // $Id$
  23. // $Log$
  24. //-----------------------------------------------------------------------------
  25. #import "Defaults.h"
  26. #import <appkit/Application.h>
  27. #import <appkit/Font.h>
  28. #import <defaults/defaults.h>
  29. #import <assert.h>
  30. #import <ctype.h>
  31. #import <limits.h>
  32. #import <string.h>
  33.  
  34.  
  35. //-----------------------------------------------------------------------------
  36. // moduleName
  37. //-----------------------------------------------------------------------------
  38. static inline char const* moduleName( void )
  39.     {
  40.     static char const* name = 0;
  41.     if (name == 0)
  42.         name = [NXApp appName];
  43.     return name;
  44.     }
  45.  
  46.  
  47.  
  48. //=============================================================================
  49. // IMPLEMENTATION
  50. //=============================================================================
  51. @implementation Defaults
  52.  
  53. //-----------------------------------------------------------------------------
  54. // set:str:
  55. //-----------------------------------------------------------------------------
  56. + (void) set:(char const*)def str:(char const*)s
  57.     {
  58.     assert( def != 0 );
  59.     NXWriteDefault( moduleName(), def, s );
  60.     }
  61.  
  62.  
  63. //-----------------------------------------------------------------------------
  64. // getStr:fallback:
  65. //-----------------------------------------------------------------------------
  66. + (char const*) getStr:(char const*)def fallback:(char const*)fallback
  67.     {
  68.     char const* s;
  69.     assert( def != 0 );
  70.     s = NXGetDefaultValue( moduleName(), def );
  71.     if (s == 0)
  72.         s = fallback;
  73.     return s;
  74.     }
  75.  
  76.  
  77. //-----------------------------------------------------------------------------
  78. // set:int:
  79. //-----------------------------------------------------------------------------
  80. + (void) set:(char const*)def int:(int)i
  81.     {
  82.     char buf[ 32 ];
  83.     sprintf( buf, "%d", i );
  84.     assert( def != 0 );
  85.     NXWriteDefault( moduleName(), def, buf );
  86.     }
  87.  
  88.  
  89. //-----------------------------------------------------------------------------
  90. // getInt:fallback:
  91. //-----------------------------------------------------------------------------
  92. + (int) getInt:(char const*)def fallback:(int)fallback
  93.     {
  94.     int value;
  95.     char const* s;
  96.     assert( def != 0 );
  97.  
  98.     value = fallback;
  99.     if ((s = NXGetDefaultValue( moduleName(), def )) != 0)
  100.         {
  101.         int x;
  102.         if (sscanf( s, "%d", &x ) == 1)
  103.             value = x;
  104.         else
  105.             fprintf( stderr, "%s/%s has a bad integer default value (%s)\n",
  106.                                 moduleName(), def, s );
  107.         }
  108.     return value;
  109.     }
  110.  
  111.  
  112. //-----------------------------------------------------------------------------
  113. // getInt:fallback:min:max:
  114. //-----------------------------------------------------------------------------
  115. + (int) getInt:(char const*)def fallback:(int)f min:(int)imin max:(int)imax
  116.     {
  117.     int ret;
  118.     assert( imin <= imax );
  119.     ret = [self getInt:def fallback:f];
  120.     if (ret < imin)
  121.         ret = imin;
  122.     else if (ret > imax)
  123.         ret = imax;
  124.     return ret;
  125.     }
  126.  
  127.  
  128. //-----------------------------------------------------------------------------
  129. // getInt:fallback:min:
  130. //-----------------------------------------------------------------------------
  131. + (int) getInt:(char const*)def fallback:(int)fallback min:(int)imin
  132.     {
  133.     return [self getInt:def fallback:fallback min:imin max:INT_MAX];
  134.     }
  135.  
  136.  
  137. //-----------------------------------------------------------------------------
  138. // set:float:
  139. //-----------------------------------------------------------------------------
  140. + (void) set:(char const*)def float:(float)f
  141.     {
  142.     char buf[ 32 ];
  143.     sprintf( buf, "%g", f );
  144.     assert( def != 0 );
  145.     NXWriteDefault( moduleName(), def, buf );
  146.     }
  147.  
  148.  
  149. //-----------------------------------------------------------------------------
  150. // getFloat:fallback:
  151. //-----------------------------------------------------------------------------
  152. + (float) getFloat:(char const*)def fallback:(float)fallback
  153.     {
  154.     float value;
  155.     char const* s;
  156.     assert( def != 0 );
  157.  
  158.     value = fallback;
  159.     if ((s = NXGetDefaultValue( moduleName(), def )) != 0)
  160.         {
  161.         float x;
  162.         if (sscanf( s, "%f", &x ) == 1)
  163.             value = x;
  164.         else
  165.             fprintf( stderr, "%s/%s has a bad float default value (%s)\n",
  166.                                 moduleName(), def, s );
  167.         }
  168.     return value;
  169.     }
  170.  
  171.  
  172. //-----------------------------------------------------------------------------
  173. // set:color:
  174. //-----------------------------------------------------------------------------
  175. + (void) set:(char const*)def color:(NXColor)c
  176.     {
  177.     char buf[ 64 ];
  178.     sprintf( buf, "%g %g %g",
  179.                 NXRedComponent(c), NXGreenComponent(c), NXBlueComponent(c) );
  180.     assert( def != 0 );
  181.     NXWriteDefault( moduleName(), def, buf );
  182.     }
  183.  
  184.  
  185. //-----------------------------------------------------------------------------
  186. // getColor:fallback:
  187. //-----------------------------------------------------------------------------
  188. + (NXColor) getColor:(char const*)def fallback:(NXColor)fallback
  189.     {
  190.     NXColor color;
  191.     char const* s;
  192.     assert( def != 0 );
  193.  
  194.     color = fallback;
  195.     if ((s = NXGetDefaultValue( moduleName(), def )) != 0)
  196.         {
  197.         float r,g,b;
  198.         if (sscanf( s, "%f %f %f", &r, &g, &b ) == 3)
  199.             color = NXConvertRGBToColor( r, g, b );
  200.         else
  201.             fprintf( stderr, "%s/%s has a bad RGB default value (%s)\n",
  202.                                 moduleName(), def, s );
  203.         }
  204.     return color;
  205.     }
  206.  
  207.  
  208. //-----------------------------------------------------------------------------
  209. // set:bool:
  210. //-----------------------------------------------------------------------------
  211. + (void) set:(char const*)def bool: (BOOL)b
  212.     {
  213.     assert( def != 0 );
  214.     NXWriteDefault( moduleName(), def, (b ? "Yes" : "No") );
  215.     }
  216.  
  217.  
  218. //-----------------------------------------------------------------------------
  219. // getBool:fallback:
  220. //-----------------------------------------------------------------------------
  221. + (BOOL) getBool: (char const*)def fallback:(BOOL)fallback
  222.     {
  223.     BOOL flag;
  224.     char const* s;
  225.     assert( def != 0 );
  226.  
  227.     flag = fallback;
  228.     if ((s = NXGetDefaultValue( moduleName(), def )) != 0)
  229.         {
  230.         char c = toupper( *s );
  231.         if ((c == 'Y') || (c == 'N'))
  232.             flag = (c == 'Y');
  233.         else
  234.             fprintf( stderr, "%s/%s has a bad boolean default value (%s)\n",
  235.                                 moduleName(), def, s );
  236.         }
  237.     return flag;
  238.     }
  239.  
  240.  
  241. //-----------------------------------------------------------------------------
  242. // sizeParam -- caller must free returned value
  243. //-----------------------------------------------------------------------------
  244. static char* sizeParam( char const* def )
  245.     {
  246.     static char const SIZE_STR[] = "Size";
  247.     char* p;
  248.     assert( def != 0 );
  249.     p = (char*)malloc( strlen(def) + sizeof(SIZE_STR) ); // include null
  250.     strcat( strcpy( p, def ), SIZE_STR );
  251.     return p;
  252.     }
  253.  
  254.  
  255. //-----------------------------------------------------------------------------
  256. // set:font:
  257. //-----------------------------------------------------------------------------
  258. + (void) set:(char const*)def font:(Font*)f
  259.     {
  260.     char* p;
  261.     assert( f != 0 );
  262.     assert( def != 0 );
  263.     NXWriteDefault( moduleName(), def, [f name] );
  264.     p = sizeParam( def );
  265.     [self set:p float:[f pointSize]];
  266.     free( p );
  267.     }
  268.  
  269.  
  270. //-----------------------------------------------------------------------------
  271. // getFont:fallback:
  272. //-----------------------------------------------------------------------------
  273. + (Font*) getFont: (char const*)def fallback:(Font*)fallback
  274.     {
  275.     Font* font;
  276.     char const* name;
  277.     assert( def != 0 );
  278.     assert( fallback != 0 );
  279.  
  280.     font = fallback;
  281.     if ((name = NXGetDefaultValue( moduleName(), def )) != 0)
  282.         {
  283.         Font* new_font;
  284.         char* p = sizeParam( def );
  285.         float const size = [self getFloat:p fallback:[fallback pointSize]];
  286.  
  287.         new_font = [Font newFont:name size:size];
  288.         if (new_font != 0)
  289.             font = new_font;
  290.         else
  291.             fprintf( stderr, "%s/%s has a bad font default value (%s)\n",
  292.                                 moduleName(), def, p );
  293.         free( p );
  294.         }
  295.  
  296.     assert( font != 0 );
  297.     return font;
  298.     }
  299.  
  300.  
  301. //-----------------------------------------------------------------------------
  302. // set:size:
  303. //-----------------------------------------------------------------------------
  304. + (void) set:(char const*)def size:(NXSize)s
  305.     {
  306.     char buf[ 64 ];
  307.     sprintf( buf, "%g %g", s.width, s.height );
  308.     assert( def != 0 );
  309.     NXWriteDefault( moduleName(), def, buf );
  310.     }
  311.  
  312.  
  313. //-----------------------------------------------------------------------------
  314. // getSize:fallback:
  315. //-----------------------------------------------------------------------------
  316. + (NXSize) getSize: (char const*)def fallback:(NXSize)fallback
  317.     {
  318.     NXSize size;
  319.     char const* s;
  320.     assert( def != 0 );
  321.  
  322.     size = fallback;
  323.     if ((s = NXGetDefaultValue( moduleName(), def )) != 0)
  324.         {
  325.         NXCoord w,h;
  326.         if (sscanf( s, "%f %f", &w, &h ) == 2)
  327.             {
  328.             size.width = w;
  329.             size.height = h;
  330.             }
  331.         else
  332.             fprintf( stderr, "%s/%s has a bad size default value (%s)\n",
  333.                                 moduleName(), def, s );
  334.         }
  335.     return size;
  336.     }
  337.  
  338.  
  339. //-----------------------------------------------------------------------------
  340. // set:point:
  341. //-----------------------------------------------------------------------------
  342. + (void) set:(char const*)def point:(NXPoint)p
  343.     {
  344.     char buf[ 64 ];
  345.     sprintf( buf, "%g %g", p.x, p.y );
  346.     assert( def != 0 );
  347.     NXWriteDefault( moduleName(), def, buf );
  348.     }
  349.  
  350.  
  351. //-----------------------------------------------------------------------------
  352. // getPoint:fallback:
  353. //-----------------------------------------------------------------------------
  354. + (NXPoint) getPoint:(char const*)def fallback:(NXPoint)fallback
  355.     {
  356.     NXPoint point;
  357.     char const* s;
  358.     assert( def != 0 );
  359.  
  360.     point = fallback;
  361.     if ((s = NXGetDefaultValue( moduleName(), def )) != 0)
  362.         {
  363.         NXCoord x,y;
  364.         if (sscanf( s, "%f %f", &x, &y ) == 2)
  365.             {
  366.             point.x = x;
  367.             point.y = y;
  368.             }
  369.         else
  370.             fprintf( stderr, "%s/%s has a bad point default value (%s)\n",
  371.                                 moduleName(), def, s );
  372.         }
  373.     return point;
  374.     }
  375.  
  376.  
  377. //-----------------------------------------------------------------------------
  378. // set:rect:
  379. //-----------------------------------------------------------------------------
  380. + (void) set:(char const*)def rect:(NXRect)r
  381.     {
  382.     char buf[ 128 ];
  383.     sprintf( buf, "%g %g %g %g", r.origin.x, r.origin.y,
  384.                         r.size.width, r.size.height );
  385.     assert( def != 0 );
  386.     NXWriteDefault( moduleName(), def, buf );
  387.     }
  388.  
  389.  
  390. //-----------------------------------------------------------------------------
  391. // getRect:fallback:
  392. //-----------------------------------------------------------------------------
  393. + (NXRect) getRect: (char const*)def fallback:(NXRect)fallback
  394.     {
  395.     NXRect rect;
  396.     char const* s;
  397.     assert( def != 0 );
  398.  
  399.     rect = fallback;
  400.     if ((s = NXGetDefaultValue( moduleName(), def )) != 0)
  401.         {
  402.         NXCoord x,y,w,h;
  403.         if (sscanf( s, "%f %f %f %f", &x, &y, &w, &h ) == 4)
  404.             {
  405.             rect.origin.x = x;
  406.             rect.origin.y = y;
  407.             rect.size.width = w;
  408.             rect.size.height = h;
  409.             }
  410.         else
  411.             fprintf( stderr, "%s/%s has a bad rect default value (%s)\n",
  412.                                 moduleName(), def, s );
  413.         }
  414.     return rect;
  415.     }
  416.  
  417. @end
  418.