home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xsw / include / resources.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-09  |  29.4 KB  |  757 lines
  1. /*
  2.  *    @(#) resources.h 12.1 95/05/09 SCOINC
  3.  */
  4. /***************************************************************************
  5.  *
  6.  *    Copyright (c) 1990-1993        The Santa Cruz Operation, Inc.
  7.  *
  8.  *    All rights reserved.  No part of this program or publication may be
  9.  *    reproduced, transmitted, transcribed, stored in a retrieval system,
  10.  *    or translated into any language or computer language, in any form or
  11.  *    by any means, electronic, mechanical, magnetic, optical, chemical,
  12.  *    biological, or otherwise, without the prior written permission of:
  13.  *    
  14.  *        The Santa Cruz Operation , Inc.        (408) 425-7222
  15.  *        400 Encinal St., Santa Cruz, California 95060 USA
  16.  *
  17.  **************************************************************************/
  18. /*
  19.  * Modification History
  20.  *
  21.  * S002, 21-Sep-93, rickra
  22.  *      Added resources for disk space 
  23.  *
  24.  * S001, 27-May-93, rickra
  25.  *      Added resources for MEM window.
  26.  *     Added resources for CALLOUTS NMOUNTS...
  27.  *
  28.  * S000, 30-Sep-92, rickra
  29.  *      Added copyright and modification history
  30.  */
  31.  
  32. typedef struct 
  33. {
  34. /*
  35.     char *geom;
  36. */
  37.     int x;                    /* +-- results                        */
  38.     int y;                    /* |   of XParseGeometry processing   */
  39.     unsigned int width;                /* |   on res.geometry                */
  40.     unsigned int height;                /* +-- and toplevel                  */
  41.     Boolean help;
  42.     Boolean version;
  43.     char *labelColor;    
  44.     char *UsersColor;
  45.     char *TimeOfDayColor;
  46.     char *IntervalColor;
  47.     char *ActualIntervalColor;
  48.     char *ActualIntervalWarningColor;
  49.     char *ActualIntervalAlarmColor;
  50.     char *DisplayMessagesColor;
  51.     char *title_barfgColor;    
  52.     char *title_barbgColor;    
  53.     char *title;
  54.     char *name;
  55.     char *background;
  56.     char *foreground;
  57.     char *font;
  58.     char *userColor;
  59.     char *kernelColor;
  60.     char *breakColor;
  61.     char *ioColor;
  62.     char *pioColor;
  63.     char *swapColor;
  64.  
  65.     char *memUsedColor;
  66.     char *memUsedWarningColor;
  67.     char *memUsedAlarmColor;
  68.     int  memUsedWarningThreshhold;
  69.     int  memUsedAlarmThreshhold;
  70.  
  71.     char *swapUsedColor;
  72.     char *swapUsedWarningColor;
  73.     char *swapUsedAlarmColor;
  74.     int  swapUsedAlarmThreshhold;
  75.     int  swapUsedWarningThreshhold;
  76.  
  77.     char *availSwapUsedColor;
  78.     char *availSwapUsedWarningColor;
  79.     char *availSwapUsedAlarmColor;
  80.     int  availSwapUsedAlarmThreshhold;
  81.     int  availSwapUsedWarningThreshhold;
  82.  
  83.     char *nfileColor;
  84.     char *ninodeColor;    
  85.     char *nprocColor;
  86.     char *nregionColor;
  87.     char *ncblocksColor;
  88.  
  89.     char *ninodeAlarmColor;    
  90.     char *nfileAlarmColor;
  91.     char *nprocAlarmColor;
  92.     char *nregionAlarmColor;
  93.     char *ncblocksAlarmColor;
  94.  
  95.     int ninodeAlarmThreshhold;
  96.     int nfileAlarmThreshhold;
  97.     int nprocAlarmThreshhold;
  98.     int nregionAlarmThreshhold;
  99.     int ncblocksAlarmThreshhold;
  100.  
  101.     char *ninodeWarningColor;    
  102.     char *nfileWarningColor;
  103.     char *nprocWarningColor;
  104.     char *nregionWarningColor;
  105.     char *ncblocksWarningColor;
  106.  
  107.     int ninodeWarningThreshhold;
  108.     int nfileWarningThreshhold;
  109.     int nprocWarningThreshhold;
  110.     int nregionWarningThreshhold;
  111.     int ncblocksWarningThreshhold;
  112.  
  113.     int busyAlarmThreshhold;
  114.     int busyWarningThreshhold;
  115.     int breakAlarmThreshhold;
  116.     int breakWarningThreshhold;
  117.     int waitAlarmThreshhold;
  118.     int waitWarningThreshhold;
  119.     int swapAlarmThreshhold;
  120.     int swapWarningThreshhold;
  121.     int writeCacheAlarmThreshhold;
  122.     int writeCacheWarningThreshhold;
  123.     int readCacheAlarmThreshhold;
  124.     int readCacheWarningThreshhold;
  125.  
  126.     char *cache_write_hit_color;
  127.     char *cache_read_hit_color;
  128.     char *cache_write_miss_color;
  129.     char *cache_read_miss_color;
  130.     char *cache_write_miss_warning_color;
  131.     char *cache_read_miss_warning_color;
  132.     char *cache_write_miss_alarm_color;
  133.     char *cache_read_miss_alarm_color;
  134.  
  135.     char *PS_mem_Color;
  136.     char *PS_mem_growing_Color;
  137.     char *PS_mem_shrinking_Color;
  138.     char *PS_mem_new_Color;
  139.  
  140.     char *PS_cpu_idle_Color;
  141.     char *PS_cpu_active_Color;
  142.     char *PS_cpu_new_Color;
  143.     char *PS_cpu_running_Color;
  144.  
  145.     char *auxButtonOnFG;
  146.     char *auxButtonOnBG;
  147.     char *auxButtonOffFG;
  148.     char *auxButtonOffBG;
  149.  
  150.     char *PS_io_idle_Color;
  151.     char *PS_io_active_Color;
  152.     char *PS_io_new_Color;
  153.  
  154.     char *disk_space_losing_Color;
  155.     char *disk_space_gaining_Color;
  156.     char *disk_space_stable_Color;
  157.  
  158.     char *numericColor;
  159.     char *numericWarningColor;
  160.     char *numericAlarmColor;
  161.  
  162.     char *staticNumericColor;
  163.  
  164.     Cursor  wait_cursor,cursor;
  165.  
  166. } MyResources, *MyResourcesptr;
  167.  
  168. #define offset(field) XtOffset(MyResources *, field)
  169. static XtResource appResources[] =
  170. {
  171. /*
  172.   {"geom", "Geometry", XtRString, sizeof (char *),
  173.    offset (geom), XtRString, (char *) 0},
  174. */
  175.  
  176.   {"help", "Help", XtRBoolean, sizeof (Boolean),
  177.    offset (help), XtRString, "FALSE"},
  178.  
  179.   {"version", "Version", XtRBoolean, sizeof (Boolean),
  180.    offset (version), XtRString, "FALSE"},
  181.  
  182.   {"title", "Title", XtRString, sizeof (char *),
  183.    offset (title), XtRString, (char *) 0},
  184.  
  185.   {"font", "Fontxsw", XtRString, sizeof (char *),
  186.    offset (font), XtRString, "fixed"},
  187.  
  188.   {"labelColor", "LabelColor", XtRString, sizeof (char *),
  189.    offset (labelColor), XtRString, "white"},
  190.  
  191.   {"UsersColor", "UsersColor", XtRString, sizeof (char *),
  192.    offset (UsersColor), XtRString, "white"},
  193.  
  194.   {"TimeOfDayColor", "TimeOfDayColor", XtRString, sizeof (char *),
  195.    offset (TimeOfDayColor), XtRString, "white"},
  196.  
  197.   {"IntervalColor", "IntervalColor", XtRString, sizeof (char *),
  198.    offset (IntervalColor), XtRString, "white"},
  199.  
  200.   {"ActualIntervalColor", "ActualIntervalColor", XtRString, sizeof (char *),
  201.    offset (ActualIntervalColor), XtRString, "white"},
  202.  
  203.   {"ActualIntervalWarningColor", "ActualIntervalWarningColor", 
  204.     XtRString, sizeof (char *),
  205.    offset (ActualIntervalWarningColor), XtRString, "yellow"},
  206.  
  207.   {"ActualIntervalAlarmColor", "ActualIntervalAlarmColor", 
  208.     XtRString, sizeof (char *),
  209.    offset (ActualIntervalAlarmColor), XtRString, "red"},
  210.  
  211.   {"DisplayMessagesColor", "DisplayMessagesColor", XtRString, sizeof (char *),
  212.    offset (DisplayMessagesColor), XtRString, "white"},
  213.  
  214.   {"title_barfgColor", "TitleBarFGColor", XtRString, sizeof (char *),
  215.    offset (title_barfgColor), XtRString, "black"},
  216.  
  217.   {"title_barbgColor", "TitleBarBGColor", XtRString, sizeof (char *),
  218.    offset (title_barbgColor), XtRString, "white"},
  219.  
  220.   {"background", "Back", XtRString, sizeof (char *),
  221.    offset (background), XtRString, "black"},
  222.  
  223.   {"foreground", "Fore", XtRString, sizeof (char *),
  224.    offset (foreground), XtRString, "white"},
  225.  
  226.   {"userColor", "NormalColor", XtRString, sizeof (char *),
  227.    offset (userColor), XtRString, "green"},
  228.  
  229.   {"kernelColor", "WarningColor", XtRString, sizeof (char *),
  230.    offset (kernelColor), XtRString, "yellow"},
  231.  
  232.   {"breakColor", "AlarmColor", XtRString, sizeof (char *),
  233.    offset (breakColor), XtRString, "red"},
  234.  
  235.   {"ioColor", "NormalColor", XtRString, sizeof (char *),
  236.    offset (ioColor), XtRString, "green"},
  237.  
  238.   {"pioColor", "WarningColor", XtRString, sizeof (char *),
  239.    offset (pioColor), XtRString, "yellow"},
  240.  
  241.   {"swapColor", "AlarmColor", XtRString, sizeof (char *),
  242.    offset (swapColor), XtRString, "red"},
  243.  
  244.   {"memUsedColor", "NormalColor", XtRString, sizeof (char *),
  245.    offset (memUsedColor), XtRString, "green"},
  246.  
  247.   {"memUsedWarningColor", "WarningColor", XtRString, sizeof (char *),
  248.    offset (memUsedWarningColor), XtRString, "yellow"},
  249.  
  250.   {"memUsedAlarmColor", "AlarmColor", XtRString, sizeof (char *),
  251.    offset (memUsedAlarmColor), XtRString, "red"},
  252.  
  253.   {"memUsedWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  254.    offset (memUsedWarningThreshhold), XtRString, "80"},
  255.  
  256.   {"memUsedAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  257.    offset (memUsedAlarmThreshhold), XtRString, "90"},
  258.  
  259.   {"swapUsedColor", "NormalColor", XtRString, sizeof (char *),
  260.    offset (swapUsedColor), XtRString, "green"},
  261.  
  262.   {"swapUsedWarningColor", "WarningColor", XtRString, sizeof (char *),
  263.    offset (swapUsedWarningColor), XtRString, "yellow"},
  264.  
  265.   {"swapUsedAlarmColor", "AlarmColor", XtRString, sizeof (char *),
  266.    offset (swapUsedAlarmColor), XtRString, "red"},
  267.  
  268.   {"swapUsedWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  269.    offset (swapUsedWarningThreshhold), XtRString, "80"},
  270.  
  271.   {"swapUsedAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  272.    offset (swapUsedAlarmThreshhold), XtRString, "90"},
  273.  
  274.   {"availSwapUsedColor", "NormalColor", XtRString, sizeof (char *),
  275.    offset (availSwapUsedColor), XtRString, "green"},
  276.  
  277.   {"availSwapUsedWarningColor", "WarningColor", XtRString, sizeof (char *),
  278.    offset (availSwapUsedWarningColor), XtRString, "yellow"},
  279.  
  280.   {"availSwapUsedAlarmColor", "AlarmColor", XtRString, sizeof (char *),
  281.    offset (availSwapUsedAlarmColor), XtRString, "red"},
  282.  
  283.   {"availSwapUsedWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  284.    offset (availSwapUsedWarningThreshhold), XtRString, "80"},
  285.  
  286.   {"availSwapUsedAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  287.    offset (availSwapUsedAlarmThreshhold), XtRString, "90"},
  288.  
  289.   {"busyWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  290.    offset (busyWarningThreshhold), XtRString, "70"},
  291.  
  292.   {"busyAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  293.    offset (busyAlarmThreshhold), XtRString, "90"},
  294.  
  295.   {"breakWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  296.    offset (breakWarningThreshhold), XtRString, "2"},
  297.  
  298.   {"breakAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  299.    offset (breakAlarmThreshhold), XtRString, "5"},
  300.  
  301.   {"waitWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  302.    offset (waitWarningThreshhold), XtRString, "20"},
  303.  
  304.   {"waitAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  305.    offset (waitAlarmThreshhold), XtRString, "50"},
  306.  
  307.   {"swapWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  308.    offset (swapWarningThreshhold), XtRString, "10"},
  309.  
  310.   {"swapAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  311.    offset (swapAlarmThreshhold), XtRString, "20"},
  312.  
  313.   {"writeCacheAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  314.    offset (writeCacheAlarmThreshhold), XtRString, "60"},
  315.  
  316.   {"writeCacheWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  317.    offset (writeCacheWarningThreshhold), XtRString, "85"},
  318.  
  319.   {"readCacheAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  320.    offset (readCacheAlarmThreshhold), XtRString, "60"},
  321.  
  322.   {"readCacheWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  323.    offset (readCacheWarningThreshhold), XtRString, "90"},
  324.  
  325.   {"nfileColor", "NfileColor", XtRString, sizeof (char *),
  326.    offset (nfileColor), XtRString, "green"},
  327.  
  328.   {"ninodeColor", "NinodeColor", XtRString, sizeof (char *),
  329.    offset (ninodeColor), XtRString, "green"},
  330.  
  331.   {"nprocColor", "NprocColor", XtRString, sizeof (char *),
  332.    offset (nprocColor), XtRString, "green"},
  333.  
  334.   {"nregionColor", "NregionColor", XtRString, sizeof (char *),
  335.    offset (nregionColor), XtRString, "green"},
  336.  
  337.   {"ncblocksColor", "NcblocksColor", XtRString, sizeof (char *),
  338.    offset (ncblocksColor), XtRString, "green"},
  339.  
  340.   {"nfileAlarmColor", "NfileAlarmColor", XtRString, sizeof (char *),
  341.    offset (nfileAlarmColor), XtRString, "red"},
  342.  
  343.   {"ninodeAlarmColor", "NinodeAlarmColor", XtRString, sizeof (char *),
  344.    offset (ninodeAlarmColor), XtRString, "red"},
  345.  
  346.   {"nprocAlarmColor", "NprocAlarmColor", XtRString, sizeof (char *),
  347.    offset (nprocAlarmColor), XtRString, "red"},
  348.  
  349.   {"nregionAlarmColor", "NregionAlarmColor", XtRString, sizeof (char *),
  350.    offset (nregionAlarmColor), XtRString, "red"},
  351.  
  352.   {"ncblocksAlarmColor", "NcblocksAlarmColor", XtRString, sizeof (char *),
  353.    offset (ncblocksAlarmColor), XtRString, "red"},
  354.  
  355.   {"nfileWaringColor", "NfileWarningColor", XtRString, sizeof (char *),
  356.    offset (nfileWarningColor), XtRString, "yellow"},
  357.  
  358.   {"ninodeWarningColor", "NinodeWarningColor", XtRString, sizeof (char *),
  359.    offset (ninodeWarningColor), XtRString, "yellow"},
  360.  
  361.   {"nprocWarningColor", "NprocWarningColor", XtRString, sizeof (char *),
  362.    offset (nprocWarningColor), XtRString, "yellow"},
  363.  
  364.   {"nregionWarningColor", "NregionWarningColor", XtRString, sizeof (char *),
  365.    offset (nregionWarningColor), XtRString, "yellow"},
  366.  
  367.   {"ncblocksWarningColor", "NcblocksWarningColor", XtRString, sizeof (char *),
  368.    offset (ncblocksWarningColor), XtRString, "yellow"},
  369.  
  370.   {"nfileWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  371.    offset (nfileWarningThreshhold), XtRString, "80"},
  372.  
  373.   {"ninodeWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  374.    offset (ninodeWarningThreshhold), XtRString, "80"},
  375.  
  376.   {"nprocWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  377.    offset (nprocWarningThreshhold), XtRString, "80"},
  378.  
  379.   {"nregionWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  380.    offset (nregionWarningThreshhold), XtRString, "80"},
  381.  
  382.   {"ncblocksWarningThreshhold", "WarningThreshhold", XtRInt, sizeof (int),
  383.    offset (ncblocksWarningThreshhold), XtRString, "80"},
  384.  
  385.   {"nfileAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  386.    offset (nfileAlarmThreshhold), XtRString, "90"},
  387.  
  388.   {"ninodeAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  389.    offset (ninodeAlarmThreshhold), XtRString, "90"},
  390.  
  391.   {"nprocAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  392.    offset (nprocAlarmThreshhold), XtRString, "90"},
  393.  
  394.   {"nregionAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  395.    offset (nregionAlarmThreshhold), XtRString, "90"},
  396.  
  397.   {"ncblocksAlarmThreshhold", "AlarmThreshhold", XtRInt, sizeof (int),
  398.    offset (ncblocksAlarmThreshhold), XtRString, "90"},
  399.  
  400.   {"cacheWriteHitColor", "CacheWriteHitColor", XtRString, sizeof (char *),
  401.    offset (cache_write_hit_color), XtRString, "white"},
  402.  
  403.   {"cacheReadHitColor", "CacheReadHitColor", XtRString, sizeof (char *),
  404.    offset (cache_read_hit_color), XtRString, "white"},
  405.  
  406.   {"cacheWriteMissColor", "CacheWriteMissColor", XtRString, sizeof (char *),
  407.    offset (cache_write_miss_color), XtRString, "black"},
  408.  
  409.   {"cacheReadMissColor", "CacheReadMissColor", XtRString, sizeof (char *),
  410.    offset (cache_read_miss_color), XtRString, "black"},
  411.  
  412.   {"cacheWriteMissWarningColor", "CacheWriteMissWarningColor", XtRString, sizeof (char *),
  413.    offset (cache_write_miss_warning_color), XtRString, "black"},
  414.  
  415.   {"cacheReadMissWarningColor", "CacheReadMissWarningColor", XtRString, sizeof (char *),
  416.    offset (cache_read_miss_warning_color), XtRString, "black"},
  417.  
  418.   {"cacheWriteMissAlarmColor", "CacheWriteMissAlarmColor", XtRString, sizeof (char *),
  419.    offset (cache_write_miss_alarm_color), XtRString, "black"},
  420.  
  421.   {"cacheReadMissAlarmColor", "CacheReadMissAlarmColor", XtRString, sizeof (char *),
  422.    offset (cache_read_miss_alarm_color), XtRString, "black"},
  423.  
  424.   {"psMemColor", "PS_Mem_Color", XtRString, sizeof (char *),
  425.    offset (PS_mem_Color), XtRString, "black"},
  426.  
  427.   {"psMemGrowingColor", "PSMemGrowingColor", XtRString, sizeof (char *),
  428.    offset (PS_mem_growing_Color), XtRString, "black"},
  429.  
  430.   {"psMemShrinkingColor", "PSMemShrinkingColor", XtRString, sizeof (char *),
  431.    offset (PS_mem_shrinking_Color), XtRString, "black"},
  432.  
  433.   {"psMemNewColor", "PSMemNewColor", XtRString, sizeof (char *),
  434.    offset (PS_mem_new_Color), XtRString, "black"},
  435.  
  436.   {"psCpuIdleColor", "PSCpuIdleColor", XtRString, sizeof (char *),
  437.    offset (PS_cpu_idle_Color), XtRString, "black"},
  438.  
  439.   {"psCpuActiveColor", "PSCpuActiveColor", XtRString, sizeof (char *),
  440.    offset (PS_cpu_active_Color), XtRString, "black"},
  441.  
  442.   {"psCpuNewColor", "PSCpuNewColor", XtRString, sizeof (char *),
  443.    offset (PS_cpu_new_Color), XtRString, "black"},
  444.  
  445.   {"psCpuRunningColor", "PSCpuRunningColor", XtRString, sizeof (char *),
  446.    offset (PS_cpu_running_Color), XtRString, "black"},
  447.  
  448.   {"psIoIdleColor", "PSIoIdleColor", XtRString, sizeof (char *),
  449.    offset (PS_io_idle_Color), XtRString, "black"},
  450.  
  451.   {"psIoActiveColor", "PSIoActiveColor", XtRString, sizeof (char *),
  452.    offset (PS_io_active_Color), XtRString, "black"},
  453.  
  454.   {"psIoNewColor", "PSIoNewColor", XtRString, sizeof (char *),
  455.    offset (PS_io_new_Color), XtRString, "black"},
  456.  
  457.   {"diskspaceLosingColor", "DiskspaceLosingColor", XtRString, sizeof (char *),
  458.    offset (disk_space_losing_Color), XtRString, "red"},
  459.  
  460.   {"diskspaceGainingColor", "DiskspaceGainingColor", XtRString, sizeof (char *),
  461.    offset (disk_space_gaining_Color), XtRString, "blue"},
  462.  
  463.   {"diskspaceStableColor", "DiskspaceStableColor", XtRString, sizeof (char *),
  464.    offset (disk_space_stable_Color), XtRString, "blue"},
  465.  
  466.  
  467.   {"auxButtonOnForeground", "AuxButtonOnForeground", XtRString, sizeof (char *),
  468.    offset (auxButtonOnFG), XtRString, "white"},
  469.  
  470.   {"auxButtonOnBackground", "AuxButtonOnBackground", XtRString, sizeof (char *),
  471.    offset (auxButtonOnBG), XtRString, "black"},
  472.  
  473.   {"auxButtonOffForeground", "AuxButtonOffForeground", XtRString, sizeof (char *),
  474.    offset (auxButtonOffFG), XtRString, "black"},
  475.  
  476.   {"auxButtonOffBackground", "AuxButtonOffBackground", XtRString, sizeof (char *),
  477.    offset (auxButtonOffBG), XtRString, "white"},
  478.  
  479.   {"numericColor", "NumericColor", XtRString, sizeof (char *),
  480.    offset (numericColor), XtRString, "black"},
  481.  
  482.   {"numericWarningColor", "NumericWarningColor", XtRString, sizeof (char *),
  483.    offset (numericWarningColor), XtRString, "black"},
  484.  
  485.   {"numericAlarmColor", "NumericAlarmColor", XtRString, sizeof (char *),
  486.    offset (numericAlarmColor), XtRString, "black"},
  487.  
  488.   {"staticNumericColor", "StaticNumericColor", XtRString, sizeof (char *),
  489.    offset (staticNumericColor), XtRString, "black"},
  490.  
  491.   {"wait_cursor", "Cursor", XtRCursor, sizeof (Cursor),
  492.    offset (wait_cursor), XtRString, "watch"},
  493.  
  494.   {"cursor", "Cursor", XtRCursor, sizeof (Cursor),
  495.    offset (cursor), XtRImmediate, NULL},
  496.  
  497. };
  498. #undef offset
  499.  
  500. static XrmOptionDescRec optionDescList[] =
  501. {
  502. /*
  503.   {"-geom", "*geom", XrmoptionSepArg, (caddr_t) 0},
  504. */
  505.   {"-help", "*help", XrmoptionNoArg, "TRUE"},
  506.   {"-version", "*version", XrmoptionNoArg, "TRUE"},
  507.   {"-fg", "*foreground", XrmoptionSepArg, (caddr_t) 0},
  508.   {"-bg", "*background", XrmoptionSepArg, (caddr_t) 0},
  509.   {"-title", "*title", XrmoptionSepArg, (caddr_t) 0},
  510.   {"-labelc", "*labelColor", XrmoptionSepArg, (caddr_t) 0},
  511.   {"-usersc", "*UsersColor", XrmoptionSepArg, (caddr_t) 0},
  512.   {"-timec", "*TimeOfDayColor", XrmoptionSepArg, (caddr_t) 0},
  513.   {"-intervalc", "*IntervalColor", XrmoptionSepArg, (caddr_t) 0},
  514.   {"-actintervalc", "*ActualIntervalColor", XrmoptionSepArg, (caddr_t) 0},
  515.   {"-actintervalwc", "*ActualIntervalWarningColor", XrmoptionSepArg,
  516.                          (caddr_t) 0},
  517.   {"-actintervalac", "*ActualIntervalAlarmColor", XrmoptionSepArg, 
  518.                          (caddr_t) 0},
  519.   {"-titlebfg", "*title_barfgColor", XrmoptionSepArg, (caddr_t) 0},
  520.   {"-titlebbg", "*title_barbgColor", XrmoptionSepArg, (caddr_t) 0},
  521.   {"-fn", "*font", XrmoptionSepArg, (caddr_t) 0},
  522.   {"-ms", "*pointerColor", XrmoptionSepArg, (caddr_t) 0},
  523.   {"-uc", "*userColor", XrmoptionSepArg, (caddr_t) 0},
  524.   {"-kc", "*kernelColor", XrmoptionSepArg, (caddr_t) 0},
  525.   {"-bc", "*breakColor", XrmoptionSepArg, (caddr_t) 0},
  526.   {"-ic", "*ioColor", XrmoptionSepArg, (caddr_t) 0},
  527.   {"-pc", "*pioColor", XrmoptionSepArg, (caddr_t) 0},
  528.   {"-sc", "*swapColor", XrmoptionSepArg, (caddr_t) 0},
  529.  
  530.   {"-memusedc", "*memUsedColor", XrmoptionSepArg, (caddr_t) 0},
  531.   {"-memusedwc", "*memUsedWarningColor", XrmoptionSepArg, (caddr_t) 0},
  532.   {"-memusedac", "*memUsedAlarmColor", XrmoptionSepArg, (caddr_t) 0},
  533.   {"-muwt", "*memUsedWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  534.   {"-muat", "*memUsedAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  535.   {"-swapusedc", "*swapUsedColor", XrmoptionSepArg, (caddr_t) 0},
  536.   {"-swapusedwc", "*swapUsedWarningColor", XrmoptionSepArg, (caddr_t) 0},
  537.   {"-swapusedac", "*swapUsedAlarmColor", XrmoptionSepArg, (caddr_t) 0},
  538.   {"-suwt", "*swapUsedWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  539.   {"-suat", "*swapUsedAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  540.   {"-availswapusedc", "*availSwapUsedColor", XrmoptionSepArg, (caddr_t) 0},
  541.   {"-availswapusedwc", "*availSwapUsedWarningColor", XrmoptionSepArg, 
  542.                 (caddr_t) 0},
  543.   {"-availswapusedac", "*availSwapUsedAlarmColor", XrmoptionSepArg, 
  544.                 (caddr_t) 0},
  545.   {"-asuwt", "*availSwapUsedWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  546.   {"-asuat", "*availSwapUsedAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  547.  
  548.   {"-bwt", "*busyWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  549.   {"-bat", "*busyAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  550.   {"-Bwt", "*breakWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  551.   {"-Bat", "*breakAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  552.   {"-wwt", "*waitWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  553.   {"-wat", "*waitAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  554.   {"-swt", "*swapWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  555.   {"-sat", "*swapAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  556.   {"-rca", "*readCacheAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  557.   {"-rcw", "*readCacheWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  558.   {"-wca", "*writeCacheAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  559.   {"-wcw", "*writeCacheWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  560.   {"-nfilec", "*nfileColor", XrmoptionSepArg, (caddr_t) 0},
  561.   {"-ninodec", "*ninodeColor", XrmoptionSepArg, (caddr_t) 0},
  562.   {"-nprocc", "*nprocColor", XrmoptionSepArg, (caddr_t) 0},
  563.   {"-nregionc", "*nregionColor", XrmoptionSepArg, (caddr_t) 0},
  564.   {"-ncblocksc", "*ncblocksColor", XrmoptionSepArg, (caddr_t) 0},
  565.   {"-nfileac", "*nfileAlarmColor", XrmoptionSepArg, (caddr_t) 0},
  566.   {"-ninodeac", "*ninodeAlarmColor", XrmoptionSepArg, (caddr_t) 0},
  567.   {"-nprocac", "*nprocAlarmColor", XrmoptionSepArg, (caddr_t) 0},
  568.   {"-nregionac", "*nregionAlarmColor", XrmoptionSepArg, (caddr_t) 0},
  569.   {"-ncblocksac", "*ncblocksAlarmColor", XrmoptionSepArg, (caddr_t) 0},
  570.   {"-nfilewc", "*nfileWarningColor", XrmoptionSepArg, (caddr_t) 0},
  571.   {"-ninodewc", "*ninodeWarningColor", XrmoptionSepArg, (caddr_t) 0},
  572.   {"-nprocwc", "*nprocWarningColor", XrmoptionSepArg, (caddr_t) 0},
  573.   {"-nregionwc", "*nregionWarningColor", XrmoptionSepArg, (caddr_t) 0},
  574.   {"-ncblockswc", "*ncblocksWarningColor", XrmoptionSepArg, (caddr_t) 0},
  575.   {"-nfilewt", "*nfileWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  576.   {"-ninodewt", "*ninodeWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  577.   {"-nprocwt", "*nprocWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  578.   {"-nregionwt", "*nregionWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  579.   {"-ncblockswt", "*ncblocksWarningThreshhold", XrmoptionSepArg, (caddr_t) 0},
  580.   {"-nfileat", "*nfileAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  581.   {"-ninodeat", "*ninodeAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  582.   {"-nprocat", "*nprocAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  583.   {"-nregionat", "*nregionAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  584.   {"-ncblocksat", "*ncblocksAlarmThreshhold", XrmoptionSepArg, (caddr_t) 0},
  585.   {"-cachereadhitc", "*cacheReadHitColor", XrmoptionSepArg, (caddr_t) 0},
  586.   {"-cachewritehitc", "*cacheWriteHitColor", XrmoptionSepArg, (caddr_t) 0},
  587.   {"-cachereadmissc", "*cacheReadMissColor", XrmoptionSepArg, (caddr_t) 0},
  588.   {"-cachewritemissc", "*cacheWriteMissColor", XrmoptionSepArg, (caddr_t) 0},
  589.   {"-cachereadmisswc", "*cacheReadMissWarningColor", XrmoptionSepArg, (caddr_t) 0},
  590.   {"-cachewritemisswc", "*cacheWriteMissWarningColor", XrmoptionSepArg, (caddr_t) 0},
  591.   {"-cachereadmissac", "*cacheReadMissAlarmColor", XrmoptionSepArg, (caddr_t) 0},
  592.   {"-cachewritemissac", "*cacheWriteMissAlarmColor", XrmoptionSepArg, (caddr_t) 0},
  593.  
  594.  
  595.   {"-psmemc", "*psMemColor", XrmoptionSepArg, (caddr_t) 0},
  596.   {"-psmemgrowc", "*psMemGrowingColor", XrmoptionSepArg, (caddr_t) 0},
  597.   {"-psmemshrinkc", "*psMemShrinkingColor", XrmoptionSepArg, (caddr_t) 0},
  598.   {"-psmemnewc", "*psMemNnewColor", XrmoptionSepArg, (caddr_t) 0},
  599.   {"-pscpuidlec", "*psCpuIdleColor", XrmoptionSepArg, (caddr_t) 0},
  600.   {"-pscpuactivec", "*psCpuActiveColor", XrmoptionSepArg, (caddr_t) 0},
  601.   {"-pscpunewc", "*psCpuNewColor", XrmoptionSepArg, (caddr_t) 0},
  602.   {"-pscpurunc", "*psCpuRunColor", XrmoptionSepArg, (caddr_t) 0},
  603.   {"-psioidlec", "*psIoIdleColor", XrmoptionSepArg, (caddr_t) 0},
  604.   {"-psioactivec", "*psIoActiveColor", XrmoptionSepArg, (caddr_t) 0},
  605.   {"-psionewc", "*psIoNewColor", XrmoptionSepArg, (caddr_t) 0},
  606.  
  607.  
  608.   {"-disklosingc", "*diskspaceLosingColor", XrmoptionSepArg, (caddr_t) 0},
  609.   {"-diskgainingc", "*diskspaceGainingColor", XrmoptionSepArg, (caddr_t) 0},
  610.   {"-diskstablec", "*diskspaceStableColor", XrmoptionSepArg, (caddr_t) 0},
  611.  
  612.   {"-auxbtnonbgc", "*auxButtonOnBackground", XrmoptionSepArg, (caddr_t) 0},
  613.   {"-auxbtnonffgc", "*auxButtonOnForeground", XrmoptionSepArg, (caddr_t) 0},
  614.   {"-auxbtnoffbgc", "*auxButtonOffBackground", XrmoptionSepArg, (caddr_t) 0},
  615.   {"-auxbtnofffgc", "*auxButtonOffForeground", XrmoptionSepArg, (caddr_t) 0},
  616.  
  617.   {"-numericc", "*numericColor", XrmoptionSepArg, (caddr_t) 0},
  618.   {"-numericwc", "*numericWarningColor", XrmoptionSepArg, (caddr_t) 0},
  619.   {"-numericac", "*numericAlarmColor", XrmoptionSepArg, (caddr_t) 0},
  620.   {"-snumericc", "*staticNumericColor", XrmoptionSepArg, (caddr_t) 0}
  621.  
  622. };
  623.  
  624.  
  625. typedef struct myusagelist
  626. {
  627.   char           *opt;
  628. }               MyUsageList;
  629.  
  630. /*  NEED TO ADD THE FOLLOWING TO FUCTIONALITY
  631.  
  632.  
  633.   { "-display displayname",  "X server to contact" },
  634.   { "-geometry geom",        "size (in characters) and position" },
  635.   { "-/+rv",                 "turn on/off reverse video" },
  636.   { "-iconic",               "start iconic" },
  637.   { "-bd color",             "border color" },
  638.   { "-bw number",            "border width in pixels" },
  639.  
  640. */
  641.  
  642. static MyUsageList usage_list[] =
  643. {
  644.   {"-help            print out this message"},
  645.   {"-version        display current version identification"},
  646.   {"-server "},
  647.   {"  host:[win,win,..]    specifies a server to connect to and"},
  648.   {"            resource window to pop up. Resource window"},
  649.   {"            can be one of:cpu,wait,cache,other,pscpu,"},
  650.   {"            psio,psmem,streams,nfs,sysinfo,vbt,disk,mem"},
  651.   {"-geometry        size (in characters) and position"},
  652.   {"-title            title for the xsw window"},
  653.   {"-bg color        background color"},
  654.   {"-fg color        foreground color"},
  655.   {"-fn fontname        text font"},
  656.   {"-labelc color        text label color"},
  657.   {"-usersc color        User\'s label color"},
  658.   {"-timec color        Time of Day label color"},
  659.   {"-intervalc color    Current Interval color"},
  660.   {"-actintervalc color    Actual Interval color"},
  661.   {"-actintervalwc color    Actual Interval Warning color"},
  662.   {"-actintervalac color    Actual Interval Alarm color"},
  663.  
  664.   {"-titlebfg color        text background color for window title bars"},
  665.   {"-titlebbg color        text foreground color for window title bars"},
  666.  
  667.   {"-uc color        User CPU percentage scale color"},
  668.   {"-kc color        Kernel CPU percentage scale color"},
  669.   {"-bc color        Break CPU percentage scale color"},
  670.  
  671.   {"-ic color        I/O wait percentage scale color"},
  672.   {"-pc color        Page I/O wait percentage scale color"},
  673.   {"-sc color        Swap I/O wait percentage scale color"},
  674.  
  675.   {"-memusedc        Memory percent used scale color"},
  676.   {"-memusedwc        Memory percent used warning scale color"},
  677.   {"-memusedac        Memory percent used alarm scale color"},
  678.   {"-muwt            Memory Warning percent Threshhold"},
  679.   {"-muat            Memory Alarm percent Threshhold"},
  680.  
  681.   {"-swapusedc        Swap memory percent used scale color"},
  682.   {"-swapusedwc        Swap memory percent used warning scale color"},
  683.   {"-swapusedac        Swap memory percent used alarm scale color"},
  684.   {"-suwt            Swap Warning percent Threshhold"},
  685.   {"-suat            Swap Alarm percent Threshhold"},
  686.  
  687.  
  688.   {"-availswapusedc        Avail. Swap memory percent used scale color"},
  689.   {"-availswapusedwc     Avail. Swap memory percent used warning scale color"},
  690.   {"-availswapusedac    Avail. Swap memory percent used alarm scale color"},
  691.   {"-asuwt            Avail. Swap Warning percent Threshhold"},
  692.   {"-asuat            Avail. Swap Alarm percent Threshhold"},
  693.  
  694.   {"-rca percent        Read Cache Hit alarm percentage"},
  695.   {"-wca percent        Write Cache Hit alarm percentage"},
  696.   {"-rcw percent        Read Cache Hit warning percentage"},
  697.   {"-wcw percent        Write Cache Hit warning percentage"},
  698.  
  699.   {"-nfilec color        NFILE percentage scale color"},
  700.   {"-ninodec color        NINODE percentage scale color"},
  701.   {"-nprocc color        NPROC percentage scale color"},
  702.   {"-nregionc color        NREGION percentage scale color"},
  703.   {"-ncblocksc color    NCBLOCKS percentage scale color"},
  704.  
  705.   {"-nfileac color        NFILE Alarm percentage scale color"},
  706.   {"-ninodeac color        NINODE Alarm percentage scale color"},
  707.   {"-nprocac color        NPROC Alarm percentage scale color"},
  708.   {"-nregionac color    NREGION Alarm percentage scale color"},
  709.   {"-ncblocksac color    NCBLOCKS Alarm percentage scale color"},
  710.  
  711.   {"-nfileat percent    NFILE Alarm percent Threshhold"},
  712.   {"-ninodeat percent    NINODE Alarm percent Threshhold"},
  713.   {"-nprocat percent    NPROC Alarm percent Threshhold"},
  714.   {"-nregionat percent    NREGION Alarm percent Threshhold"},
  715.   {"-nclbocksat percent    NCBLOCKS Alarm percent Threshhold"},
  716.  
  717.   {"-nfilewc color        NFILE Warning percentage scale color"},
  718.   {"-ninodewc color        NINODE Warning percentage scale color"},
  719.   {"-nprocwc color        NPROC Warning percentage scale color"},
  720.   {"-nregionwc color    NREGION Warning percentage scale color"},
  721.   {"-ncblockswc color    NCBLOCKS Warning percentage scale color"},
  722.  
  723.   {"-nfilewt percent    NFILE Warning percent Threshhold"},
  724.   {"-ninodewt percent    NINODE Warning percent Threshhold"},
  725.   {"-nprocwt percent    NPROC Warning percent Threshhold"},
  726.   {"-ncblockswt percent    NCBLOCKS Warning percent Threshhold"},
  727.  
  728.   {"-psmemc color        Memory color"},
  729.   {"-psmemgrowc color    PS Memory growing color"},
  730.   {"-psmemshrinkc color    PS Memory shrinking color"},
  731.   {"-psmemnewc color    PS Memory new color"},
  732.   {"-pscpuidlec color    PS CPU idle color"},
  733.   {"-pscpuactivec color    PS CPU active color"},
  734.   {"-pscpunewc color    PS CPU new color"},
  735.   {"-pscpurunc color    PS CPU running color"},
  736.   {"-psioidlec color    PS IO idle color"},
  737.   {"-psioactivec color    PS IO active color"},
  738.   {"-psionewc color        PS IO new color"},
  739.  
  740.   {"-disklosingc color        Disk Space Losing color"},
  741.   {"-diskgainingc color        Disk Space Stable color"},
  742.   {"-diskstablec color        Disk Space Stable color"},
  743.  
  744.   {"-auxbtnonbgc color    Auxillary Buttons \"ON\" Background"},
  745.   {"-auxbtnonffgc color    Auxillary Buttons \"ON\" Foreground"},
  746.   {"-auxbtnoffbgc color    Auxillary Buttons \"OFF\" Background"},
  747.   {"-auxbtnofffgc color    Auxillary Buttons \"OFF\" Foreground"},
  748.  
  749.   {"-numericc color        Numeric color"},
  750.   {"-numericwc color    Numeric Warning color"},
  751.   {"-numericac color    Numeric Alarm color"},
  752.   {"-snumericc color    Static Numeric color"},
  753.   {(char *) 0}
  754. };
  755.  
  756.  
  757.