static XrmDatabase
InitDefaults(
Display *dpy) /* display for defaults.... */
{
XrmDatabase userdb;
XrmDatabase xdb;
char fname[PATH_MAX]; /* longer than any conceivable size */
char *xenv;
XrmInitialize();
/*
* See lib/Xt/Initialize.c
*
* First, get the defaults from the server; if none, then load from
* ~/.Xdefaults. Next, if there is an XENVIRONMENT environment variable,
* then load that file.
*/
if (dpy->xdefaults == NULL) {
#ifdef _MSC_VER
const char *slashDotXdefaults = ".Xdefaults";
#else
const char *slashDotXdefaults = "/.Xdefaults";
#endif
(void) GetHomeDir (fname, PATH_MAX - strlen (slashDotXdefaults) - 1);
(void) strcat (fname, slashDotXdefaults);
xdb = XrmGetFileDatabase (fname);
} else {
xdb = XrmGetStringDatabase(dpy->xdefaults);
}
if (!(xenv = getenv ("XENVIRONMENT"))) {
#ifdef _MSC_VER
const char *slashDotXdefaultsDash = ".Xdefaults-";
#else
const char *slashDotXdefaultsDash = "/.Xdefaults-";
#endif
int len;
(void) GetHomeDir (fname, PATH_MAX - strlen (slashDotXdefaultsDash) - 1);
(void) strcat (fname, slashDotXdefaultsDash);
len = strlen (fname);
(void) _XGetHostname (fname+len, PATH_MAX-len);
xenv = fname;
}
userdb = XrmGetFileDatabase (xenv);
XrmMergeDatabases (userdb, &xdb);
return (xdb);
#ifdef old
if (fname[0] != '\0') userdb = XrmGetFileDatabase(fname);
xdb = XrmGetStringDatabase(dpy->xdefaults);
XrmMergeDatabases(userdb, &xdb);
return xdb;
#endif
}
static int
FindXDPSNXInXrmDatabase(
Display *dpy,
char **host,
int *transport,
int *port)
{
XrmDatabase rDB = NULL; /* for merged database */
XrmDatabase serverDB;
char filenamebuf[1024];
char *filename = &filenamebuf[0];
char *env, *str_type;
char name[255];
XrmValue value;
int retVal = !Success;
XrmInitialize();
(void) strcpy(name, "/usr/lib/X11/app-defaults/");
(void) strcat(name, XDPSNX_X_CLASS_NAME);
/* try to get application defaults file, if there is any */
XrmMergeDatabases(XrmGetFileDatabase(name), &rDB);
/* try to merge the server defaults. if not defined then use .Xdefaults */
if (XResourceManagerString(dpy) != NULL) {
serverDB = XrmGetStringDatabase(XResourceManagerString(dpy));
} else { /* use the .Xdefaults */
(void) getHomeDir(filename);
(void) strcat(filename, "/.Xdefaults");
serverDB = XrmGetFileDatabase(filename);
}
XrmMergeDatabases(serverDB, &rDB);
/* try the XENVIRONMENT file, or if not defined, then .Xdefaults */
if ((env = getenv("XENVIRONMENT")) == NULL) {
int len;
env = getHomeDir(filename);
(void) strcat(filename, "/.Xdefaults-");
len = strlen(env);
(void) gethostname(env+len, 1024-len);
}
XrmMergeDatabases(XrmGetFileDatabase(env), &rDB);
/* Now that the database is built, try to extract the values we want. */
if (XrmGetResource(rDB, XDPSNX_X_RESOURCE, XDPSNX_X_CLASS_NAME, &str_type,
&value) == True) {
retVal = ParseAgentString((char *) value.addr, host, transport, port);
}
(void) XrmDestroyDatabase(rDB);
return(retVal);
}
void wxXMergeDatabases (wxApp * theApp, Display * display)
{
XrmDatabase homeDB, serverDB, applicationDB;
char filenamebuf[1024];
char *filename = &filenamebuf[0];
char *environment;
wxString classname = theApp->GetClassName();
char name[256];
(void) strcpy (name, "/usr/lib/X11/app-defaults/");
(void) strcat (name, classname.c_str());
/* Get application defaults file, if any */
applicationDB = XrmGetFileDatabase (name);
(void) XrmMergeDatabases (applicationDB, &wxResourceDatabase);
/* Merge server defaults, created by xrdb, loaded as a property of the root
* window when the server initializes and loaded into the display
* structure on XOpenDisplay;
* if not defined, use .Xdefaults
*/
if (XResourceManagerString (display) != NULL)
{
serverDB = XrmGetStringDatabase (XResourceManagerString (display));
}
else
{
(void) GetIniFile (filename, NULL);
serverDB = XrmGetFileDatabase (filename);
}
XrmMergeDatabases (serverDB, &wxResourceDatabase);
/* Open XENVIRONMENT file, or if not defined, the .Xdefaults,
* and merge into existing database
*/
if ((environment = getenv ("XENVIRONMENT")) == NULL)
{
size_t len;
environment = GetIniFile (filename, NULL);
len = strlen (environment);
wxString hostname = wxGetHostName();
if ( !!hostname )
strncat(environment, hostname, 1024 - len);
}
homeDB = XrmGetFileDatabase (environment);
XrmMergeDatabases (homeDB, &wxResourceDatabase);
}
// Return a database of default settings
XrmDatabase app_defaults(Display *display)
{
static XrmDatabase db = NULL;
if (db != NULL)
return db;
// Add builtin fallback defaults.
int i = 0;
while (ddd_fallback_resources[i] != 0)
XrmPutLineResource(&db, ddd_fallback_resources[i++]);
// Add app-defaults file, overriding fallback defaults.
static String app_name = 0;
static String app_class = 0;
if (app_name == 0)
XtGetApplicationNameAndClass(display, &app_name, &app_class);
String app_defaults_file =
XtResolvePathname(display, NULL, app_class, NULL, NULL, NULL, 0, NULL);
if (app_defaults_file != NULL)
{
XrmDatabase db2 = XrmGetFileDatabase(app_defaults_file);
if (db2 != 0)
XrmMergeDatabases(db2, &db);
}
return db;
}
void Blackbox::timeout(bt::Timer *) {
XrmDatabase new_blackboxrc = (XrmDatabase) 0;
std::string style = "session.styleFile: ";
style += _resource.styleFilename();
XrmPutLineResource(&new_blackboxrc, style.c_str());
XrmDatabase old_blackboxrc = XrmGetFileDatabase(_resource.rcFilename());
XrmMergeDatabases(new_blackboxrc, &old_blackboxrc);
XrmPutFileDatabase(old_blackboxrc, _resource.rcFilename());
if (old_blackboxrc) XrmDestroyDatabase(old_blackboxrc);
std::for_each(menuTimestamps.begin(), menuTimestamps.end(),
bt::PointerAssassin());
menuTimestamps.clear();
std::for_each(screen_list, screen_list + screen_list_count,
std::mem_fun(&BScreen::reconfigure));
bt::Font::clearCache();
bt::PixmapCache::clearCache();
bt::Pen::clearCache();
// clear the color cache here to allow the pen cache to deallocate
// all unused colors
bt::Color::clearCache();
}
void InitPreferenceDB()
{
int i;
char *hdir;
XrmDatabase db;
pref_db.dpyPrefs = dpyPrefs;
pref_db.winPrefs = winPrefs;
pref_db.cliPrefs = cliPrefs;
pref_db.propPrefs = propPrefs;
pref_db.treePrefs = treePrefs;
/*
* if an .xqsrc rcfile doesnt exist in the users home directory create one
*/
hdir = getenv( "HOME" );
rcfile = XtMalloc( strlen(hdir) + strlen(RCFILE) + 1 );
sprintf( rcfile, "%s/%s", hdir, RCFILE );
db = XtDatabase( XtDisplay(appshell) );
for( i=0; i<XtNumber(MiscRes); i++ )
XrmPutLineResource( &db, MiscRes[i] );
pref_db.db = XrmGetFileDatabase( rcfile );
GetPrefFromDB();
}
bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file)
{
if (!wxResourceDatabase)
{
Display *display = wxGlobalDisplay();
wxXMergeDatabases (wxTheApp, display);
}
XrmDatabase database;
if (file != "")
{
char buffer[500];
// Is this right? Trying to get it to look in the user's
// home directory instead of current directory -- JACS
(void) GetIniFile (buffer, file);
wxNode *node = wxResourceCache.Find (buffer);
if (node)
database = (XrmDatabase) node->Data ();
else
{
database = XrmGetFileDatabase (buffer);
wxResourceCache.Append (buffer, (wxObject *) database);
}
}
else
database = wxResourceDatabase;
XrmValue xvalue;
char *str_type[20];
char buf[150];
strcpy (buf, section);
strcat (buf, ".");
strcat (buf, entry);
Bool success = XrmGetResource (database, buf, "*", str_type,
&xvalue);
// Try different combinations of upper/lower case, just in case...
if (!success)
{
buf[0] = (isupper (buf[0]) ? tolower (buf[0]) : toupper (buf[0]));
success = XrmGetResource (database, buf, "*", str_type,
&xvalue);
}
if (success)
{
if (*value)
delete[] *value;
*value = new char[xvalue.size + 1];
strncpy (*value, xvalue.addr, (int) xvalue.size);
return true;
}
return false;
}
void theme_init(Display *display)
{
char b[1024], *tr;
char *p, *q;
XrmDatabase themedb, olddb;
XrmValue vr;
sprintf(b, "%s/theme", siag_basedir);
themedb = XrmGetFileDatabase(b);
if (!themedb) { /* use kde2 as default */
sprintf(b, "%s/common/themes/theme.kde2", datadir);
themedb = XrmGetFileDatabase(b);
}
if (themedb) {
olddb = XrmGetDatabase(display);
XrmMergeDatabases(themedb, &olddb);
XrmSetDatabase(display, olddb);
if (XrmGetResource(olddb, "PIXPATH", XtNstring, &tr, &vr)) {
strcpy(b, "PIXPATH=");
p = b+strlen(b);
q = vr.addr;
while (*q) {
if (q[0] == '.' && q[1] == '.' && q[2] == '.') {
strcpy(p, datadir);
p += strlen(p);
q += 2;
} else {
*p++ = *q;
}
q++;
}
*p = '\0';
putenv(MwStrdup(b));
}
if (XrmGetResource(olddb, "XAWM_THEME", XtNstring, &tr, &vr)) {
sprintf(b, "XAWM_THEME=%s", vr.addr);
putenv(MwStrdup(b));
}
}
}
void
mergeDatabases(void)
{
/* using global
rDB
dsply
*/
XrmDatabase homeDB,serverDB,applicationDB;
char filenamebuf[1024];
char *filename = &filenamebuf[0];
char *classname = "Axiom";
char name[255];
(void) XrmInitialize();
(void) strcpy(name, "/usr/lib/X11/app-defaults/");
(void) strcat(name, classname);
applicationDB = XrmGetFileDatabase(name);
(void) XrmMergeDatabases(applicationDB, &rDB);
if (XResourceManagerString(dsply) != NULL)
serverDB = XrmGetStringDatabase(XResourceManagerString(dsply));
else {
(void) strcpy(filename,getenv("HOME"));
(void) strcat(filename,"/.Xdefaults");
serverDB = XrmGetFileDatabase(filename);
}
XrmMergeDatabases(serverDB,&rDB);
if ( getenv ("XENVIRONMENT") == NULL) {
int len;
(void) strcpy(filename,getenv("HOME"));
(void) strcat(filename,"/.Xdefaults-");
len = strlen(filename);
(void) gethostname(filename+len,1024-len);
}
else
(void) strcpy (filename,getenv ("XENVIRONMENT"));
homeDB = XrmGetFileDatabase(filename);
XrmMergeDatabases(homeDB,&rDB);
}
int
read_extra_resources(char *data_in)
/*
* Read in the data-specific resource file.
*/
{
char fname[128];
int found = 0;
int ok = 1;
FILE *fp;
static char *suffix = ".resources";
if (data_in != "" && strcmp(data_in, "stdin") != 0) {
(void) strcpy(fname, data_in);
(void) strcat(fname, suffix);
if ( (fp = fopen(fname,"r")) != NULL)
found = 1;
}
if (found) {
XrmDatabase newdb;
if ( (newdb = (XrmDatabase) XrmGetFileDatabase(fname)) != NULL ) {
XrmDatabase dispdb;
dispdb = XrmGetDatabase(display);
XrmMergeDatabases(newdb, &dispdb);
XrmSetDatabase(display, dispdb);
}
else {
ok = 0;
fprintf(stderr,
"read_extra_resources: problem reading data-specific resource file\n");
exit(0);
}
/*
* Close the data file
*/
if (fclose(fp) == EOF)
fprintf(stderr, "read_extra_resources: error in fclose");
}
return(ok);
}
Bool
InitializeOptionsDatabase(void)
{
static int first = 1;
static Bool result = True;
if (first) {
XrmQuark names[2];
XrmQuark classes[2];
first = 0;
XrmInitialize();
if ((options_xrm = XrmGetFileDatabase(Options)) == (XrmDatabase)0) {
fprintf(stderr, "Cannot open '%s' database.\n", Options);
return (False);
}
/* rebuild database, using only lowercase characters */
names[0] = classes[0] = names[1] = classes[1] = NULLQUARK;
(void)XrmEnumerateDatabase(options_xrm, (XrmNameList)&names,
(XrmClassList)&classes, XrmEnumAllLevels,
EnumDatabase, NULL);
/* free previous database, as it is not guaranteed to be
* "case insensitive" */
XrmDestroyDatabase(options_xrm);
/* create case insensitive database by making everything lowercase */
if (rebuild_xrm.string == NULL ||
(options_xrm = XrmGetStringDatabase(rebuild_xrm.string)) ==
(XrmDatabase)0) {
fprintf(stderr, "Cannot rebuild '%s' database.\n", Options);
XtFree(rebuild_xrm.string);
return (False);
}
XtFree(rebuild_xrm.string);
}
return (result);
}
XrmDatabase
_XInitKeysymDB()
{
#if 1
if (!initialized)
{
char *dbname;
XrmInitialize();
/* use and name of this env var is not part of the standard */
/* implementation-dependent feature */
dbname = getenv("XKEYSYMDB");
if (!dbname)
dbname = KEYSYMDB;
keysymdb = XrmGetFileDatabase(dbname);
if (keysymdb)
Qkeysym[0] = XrmStringToQuark("Keysym");
initialized = True;
}
#endif
return keysymdb;
}
/*
* Read the user preferences from xdvirc_filename and merge them into the
* current resource database *and* into m_user_db so that all of them are
* saved again when xdvi exits.
*/
void
read_user_preferences(Widget toplevel, const char *filename)
{
char *fullpath;
XrmDatabase db;
#if XtSpecificationRelease == 4
XrmDatabase file_db;
#endif
fullpath = get_xdvirc_path(filename);
TRACE_GUI((stderr, "Reading resources from `%s'", fullpath));
db = XtDatabase(XtDisplay(toplevel));
#if XtSpecificationRelease == 4
file_db = XrmGetFileDatabase(fullpath);
XrmMergeDatabases(file_db, &db);
XrmMergeDatabases(file_db, &m_user_db);
#else /* Xt >= X11R5 */
XrmCombineFileDatabase(fullpath, &db, True);
XrmCombineFileDatabase(fullpath, &m_user_db, True);
#endif
free(fullpath);
}
bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
{
char buffer[500];
(void) GetIniFile (buffer, file);
XrmDatabase database;
wxNode *node = wxResourceCache.Find (buffer);
if (node)
database = (XrmDatabase) node->Data ();
else
{
database = XrmGetFileDatabase (buffer);
wxResourceCache.Append (buffer, (wxObject *) database);
}
char resName[300];
strcpy (resName, section.c_str());
strcat (resName, ".");
strcat (resName, entry.c_str());
XrmPutStringResource (&database, resName, value);
return true;
}
static Eina_Bool
xrdb_user_query(const char *name, const char *cls, char **type, XrmValue *val)
{
time_t last = xrdb_user.last_stat, now = time(NULL);
xrdb_user.last_stat = now;
if (last != now) /* don't stat() more than once every second */
{
struct stat st;
const char *home = getenv("HOME");
char tmp[PATH_MAX];
if (!home) goto failed;
snprintf(tmp, sizeof(tmp), "%s/.Xdefaults", home);
if (stat(tmp, &st) != 0) goto failed;
if (xrdb_user.last_mtime != st.st_mtime)
{
if (xrdb_user.db) XrmDestroyDatabase(xrdb_user.db);
xrdb_user.db = XrmGetFileDatabase(tmp);
if (!xrdb_user.db) goto failed;
xrdb_user.last_mtime = st.st_mtime;
}
}
if (!xrdb_user.db) return EINA_FALSE;
return XrmGetResource(xrdb_user.db, name, cls, type, val);
failed:
if (xrdb_user.db)
{
XrmDestroyDatabase(xrdb_user.db);
xrdb_user.db = NULL;
}
xrdb_user.last_mtime = 0;
return EINA_FALSE;
}
static void Get_file_defaults(XrmDatabase *rDBptr,
char *myName, char *myClass)
{
#ifdef VMS
#define MAXPATHLEN 1024
#endif
int len;
char *ptr,
*lang = getenv("LANG"),
*home = getenv("HOME"),
path[MAXPATHLEN];
XrmDatabase tmpDB;
sprintf(path, "%s%s", LIBDIR, myClass);
*rDBptr = XrmGetFileDatabase(path);
#ifdef VMS
/*
* None of the paths generated will be valid VMS file names.
*/
tmpDB = XrmGetFileDatabase("SYS$LOGIN:decw$xdefaults.dat");
XrmMergeDatabases(tmpDB, rDBptr);
tmpDB = XrmGetFileDatabase("DECW$USER_DEFAULTS:xpilot.dat");
XrmMergeDatabases(tmpDB, rDBptr);
#else
if (lang != NULL) {
sprintf(path, "/usr/lib/X11/%s/app-defaults/%s", lang, myClass);
if (access(path, 0) == -1) {
sprintf(path, "/usr/lib/X11/app-defaults/%s", myClass);
}
} else {
sprintf(path, "/usr/lib/X11/app-defaults/%s", myClass);
}
tmpDB = XrmGetFileDatabase(path);
XrmMergeDatabases(tmpDB, rDBptr);
if ((ptr = getenv("XUSERFILESEARCHPATH")) != NULL) {
sprintf(path, "%s/%s", ptr, myClass);
tmpDB = XrmGetFileDatabase(path);
XrmMergeDatabases(tmpDB, rDBptr);
}
else if ((ptr = getenv("XAPPLRESDIR")) != NULL) {
if (lang != NULL) {
sprintf(path, "%s/%s/%s", ptr, lang, myClass);
if (access(path, 0) == -1) {
sprintf(path, "%s/%s", ptr, myClass);
}
} else {
sprintf(path, "%s/%s", ptr, myClass);
}
tmpDB = XrmGetFileDatabase(path);
XrmMergeDatabases(tmpDB, rDBptr);
}
else if (home != NULL) {
if (lang != NULL) {
sprintf(path, "%s/app-defaults/%s/%s", home, lang, myClass);
if (access(path, 0) == -1) {
sprintf(path, "%s/app-defaults/%s", home, myClass);
}
} else {
sprintf(path, "%s/app-defaults/%s", home, myClass);
}
tmpDB = XrmGetFileDatabase(path);
XrmMergeDatabases(tmpDB, rDBptr);
}
if ((ptr = XResourceManagerString(dpy)) != NULL) {
tmpDB = XrmGetStringDatabase(ptr);
XrmMergeDatabases(tmpDB, rDBptr);
}
else if (home != NULL) {
sprintf(path, "%s/.Xdefaults", home);
tmpDB = XrmGetFileDatabase(path);
XrmMergeDatabases(tmpDB, rDBptr);
}
if ((ptr = getenv("XENVIRONMENT")) != NULL) {
tmpDB = XrmGetFileDatabase(ptr);
XrmMergeDatabases(tmpDB, rDBptr);
}
else if (home != NULL) {
sprintf(path, "%s/.Xdefaults-", home);
len = strlen(path);
gethostname(&path[len], sizeof path - len);
path[sizeof path - 1] = '\0';
tmpDB = XrmGetFileDatabase(path);
XrmMergeDatabases(tmpDB, rDBptr);
}
if (home != NULL) {
sprintf(path, "%s/.xpilotrc", home);
tmpDB = XrmGetFileDatabase(path);
XrmMergeDatabases(tmpDB, rDBptr);
}
#endif
}
void aX_open_disp(aX_options *useropt, int useroptlen,
int *argcp, char *argv[],
aX_default_resources *defres)
{
XrmValue value;
char *str_type;
char *disp_res;
char *environment;
char *display_name = NULL;
char filename[MAX_FILENAME_LEN];
int i;
XrmDatabase commandlineDB = NULL, usercommandlineDB = NULL;
XrmDatabase homeDB, serverDB, applicationDB;
/*
if(disp_start.next_disp != NULL) {
fprintf(stderr, "aX_open_disp: Cannot open first display twice.\n");
exit(-1);
}
*/
XrmInitialize();
class_name[0] = '\0';
class_name[MAX_CLASS_NAME_LEN] = '\0';
if(defres->class_name != NULL)
strncpy(class_name, defres->class_name, MAX_CLASS_NAME_LEN);
fill_event_info();
for(i = 1; i < *argcp; i++)
if(strcmp(argv[i], "-name") == 0 && ++i < *argcp){
defres->prog_name = argv[i];
break;
}
prog_name[0] = '\0';
prog_name[MAX_PROG_NAME_LEN] = '\0';
if(defres->prog_name != NULL)
strncpy(prog_name, defres->prog_name, MAX_PROG_NAME_LEN);
else
strncpy(prog_name, argv[0], MAX_PROG_NAME_LEN);
defres->prog_name = prog_name;
XrmParseCommand(&commandlineDB, (XrmOptionDescRec *) opTable,
opTableEntries, prog_name, argcp, argv);
if(useropt != NULL)
XrmParseCommand(&usercommandlineDB, (XrmOptionDescRec *) useropt,
useroptlen, prog_name, argcp, argv);
else usercommandlineDB = NULL;
/*
if(*argcp != 1) {
fprintf(stderr,
"%s: aX_open_disp: Unrecognised options in command line!\n",
prog_name);
exit(-1);
}
*/
if(XrmGetResource(commandlineDB, pname(".display"), pclass(".Display"),
&str_type, &value)) display_name = (char *) value.addr;
if((defres->disp = XOpenDisplay(display_name)) == NULL) {
fprintf(stderr, "%s: aX_open_disp: cannot connect to X server %s\n",
prog_name, XDisplayName(display_name));
exit(-1);
}
applicationDB = XrmGetFileDatabase(
addstr("/usr/lib/X11/app-defaults/",
class_name,
filename,
MAX_FILENAME_LEN));
/*
if(defres->disp->xdefaults)
serverDB = XrmGetStringDatabase(defres->disp->xdefaults);
else serverDB = NULL;
*/
disp_res = XResourceManagerString(defres->disp);
if(disp_res) serverDB = XrmGetStringDatabase(disp_res);
else serverDB = NULL;
if((environment = getenv("XENVIRONMENT")) != NULL)
homeDB = XrmGetFileDatabase(environment);
else homeDB = NULL;
XrmMergeDatabases(applicationDB, &rDB);
XrmMergeDatabases(serverDB, &rDB);
XrmMergeDatabases(homeDB, &rDB);
XrmMergeDatabases(commandlineDB, &rDB);
XrmMergeDatabases(usercommandlineDB, &rDB);
get_def_res(defres);
add_disp(defres);
}
ClientDB
OpenInputClientDB(char *fileName,
char **version,
char **dtsessionID)
{
ClientDBRec *inputDB;
char **tmpPtr;
char *resourceType;
XrmValue resourceValue;
*version = (char *)NULL;
*dtsessionID = (char *)NULL;
_initXrm();
if ((fileName == (char *)NULL) ||
((inputDB = (ClientDBRec *)XtMalloc(sizeof(ClientDBRec)))
== (ClientDBRec *)NULL))
return (ClientDB)NULL;
if ((inputDB->xrmDB = XrmGetFileDatabase(fileName))
== (XrmDatabase)NULL)
{
XtFree((char *)inputDB);
return (ClientDB)NULL;
}
inputDB->openForInput = True;
inputDB->XSMPClients = inputDB->proxyClients = (char **)NULL;
inputDB->nXSMPClients = inputDB->nProxyClients = 0;
inputDB->nextXSMPClientIndex = inputDB->nextProxyClientIndex = 0;
/* Count the number of XSMP and Proxy clients. */
XrmEnumerateDatabase(inputDB->xrmDB, XSMPName, XSMPClass,
XrmEnumOneLevel, _countProc,
(XPointer)&inputDB->nXSMPClients);
XrmEnumerateDatabase(inputDB->xrmDB, proxyName, proxyClass,
XrmEnumOneLevel, _countProc,
(XPointer)&inputDB->nProxyClients);
/* Allocate space for the client IDs and fill from database. */
if (inputDB->nXSMPClients > 0)
{
if ((inputDB->XSMPClients =
(char **)XtMalloc(inputDB->nXSMPClients * sizeof(char *)))
== (char **)NULL)
{
XrmDestroyDatabase(inputDB->xrmDB);
XtFree((char *)inputDB);
return (ClientDB)NULL;
}
tmpPtr = inputDB->XSMPClients;
XrmEnumerateDatabase(inputDB->xrmDB, XSMPName, XSMPClass,
XrmEnumOneLevel, _fillClientIDProc,
(XPointer)&tmpPtr);
}
if (inputDB->nProxyClients > 0)
{
if ((inputDB->proxyClients =
(char **)XtMalloc(inputDB->nProxyClients * sizeof(char *)))
== (char **)NULL)
{
XrmDestroyDatabase(inputDB->xrmDB);
XtFree((char *)inputDB->XSMPClients);
XtFree((char *)inputDB);
return (ClientDB)NULL;
}
tmpPtr = inputDB->proxyClients;
XrmEnumerateDatabase(inputDB->xrmDB, proxyName, proxyClass,
XrmEnumOneLevel, _fillClientIDProc,
(XPointer)&tmpPtr);
}
if ((!XrmGetResource(inputDB->xrmDB, versionStr, versionStr,
&resourceType, &resourceValue)) ||
((*version = XtNewString(resourceValue.addr)) == (char *)NULL) ||
(!XrmGetResource(inputDB->xrmDB, dtsessionIDStr, dtsessionIDStr,
&resourceType, &resourceValue)) ||
((*dtsessionID = XtNewString(resourceValue.addr)) == (char *)NULL))
{
if (*version)
{
XtFree(*version);
*version = (char *)NULL;
}
XrmDestroyDatabase(inputDB->xrmDB);
XtFree((char *)inputDB->XSMPClients);
XtFree((char *)inputDB->proxyClients);
XtFree((char *)inputDB);
return (ClientDB)NULL;
}
return (ClientDB)inputDB;
}
static void bubblemon_session_defaults(void)
{
/* handy way to collect all this stuff in one place */
typedef struct {
char *name; /* name as appears in Xdefaults */
int type; /* int, double, or color, see up */
void *var; /* pointer to value - only handles INT atm */
} xrm_vars;
/* XResource stuff */
char name[BUFSIZ] = "", *ptr;
XrmDatabase db = NULL;
XrmValue val;
char *type;
int i;
xrm_vars tab[] = {
{"bubblemon.maxbubbles", INT_VAL, &bm.maxbubbles},
{"bubblemon.air_noswap", COLOR_VAL, &bm.air_noswap},
{"bubblemon.air_maxswap", COLOR_VAL, &bm.air_maxswap},
{"bubblemon.liquid_noswap", COLOR_VAL, &bm.liquid_noswap},
{"bubblemon.liquid_maxswap", COLOR_VAL, &bm.liquid_maxswap},
{"bubblemon.ripples", DOUBLE_VAL, &bm.ripples},
{"bubblemon.gravity", DOUBLE_VAL, &bm.gravity},
{"bubblemon.volatility", DOUBLE_VAL, &bm.volatility},
{"bubblemon.viscosity", DOUBLE_VAL, &bm.viscosity},
{"bubblemon.speed_limit", DOUBLE_VAL, &bm.speed_limit}
};
/* number of CPU load samples */
bm.samples = 16;
/* default colors. changeable from Xdefaults */
bm.air_noswap = 0x2299ff;
bm.liquid_noswap = 0x0055ff;
bm.air_maxswap = 0xff0000;
bm.liquid_maxswap = 0xaa0000;
/* default bubble engine parameters. Changeable from Xdefaults */
bm.maxbubbles = 100;
bm.ripples = 0.2;
bm.gravity = 0.01;
bm.volatility = 1.0;
bm.viscosity = 0.98;
bm.speed_limit = 1.0;
db = NULL;
XrmInitialize();
/* get users's local Xdefaults */
if ((ptr = getenv("HOME")) != NULL) {
snprintf(name, sizeof(name), "%s/.Xdefaults", ptr);
}
/* get the database and parse resources if we have some */
if ((db = XrmGetFileDatabase(name)) != NULL) {
for (i = 0; i < (sizeof(tab) / sizeof(tab[0])); i++) {
if (XrmGetResource(db, tab[i].name, tab[i].name, &type, &val)) {
if (val.size > 0) /* no empty strings and shit like that */
switch (tab[i].type) {
case INT_VAL:
*(int *) tab[i].var = atoi(val.addr);
break;
case DOUBLE_VAL:
*(double *) tab[i].var = atof(val.addr);
break;
case COLOR_VAL:
sscanf(val.addr, "#%x", (int *) tab[i].var);
break;
default:
/* WTF? */
break;
}
}
}
}
#define RANGE_CHECK(x, min, max, def) \
if ((x) > (max) || (x) < (min)) { \
fprintf(stderr, #x" value is out of range. Using default value ("#def")\n"); \
(x) = (def); \
}
/* range validation. 3l33t hackerz NO PASARAN */
RANGE_CHECK(bm.air_noswap, 0, 0xffffff, 0x2299ff);
RANGE_CHECK(bm.liquid_noswap, 0, 0xffffff, 0x0055ff);
RANGE_CHECK(bm.air_maxswap, 0, 0xffffff, 0xff0000);
RANGE_CHECK(bm.liquid_maxswap, 0, 0xffffff, 0xaa0000);
RANGE_CHECK(bm.maxbubbles, 10, 200, 100);
RANGE_CHECK(bm.ripples, 0, 1, 0.2);
RANGE_CHECK(bm.gravity, 0.005, 0.5, 0.01);
RANGE_CHECK(bm.volatility, 0.1, 2, 1.0);
RANGE_CHECK(bm.viscosity, 0, 1.0, 0.98);
RANGE_CHECK(bm.speed_limit, 0.5, 2, 1.0);
#undef RANGE_CHECK
/* convert doubles into integer representation */
bm.ripples_int = MAKE_INTEGER(bm.ripples);
bm.gravity_int = MAKE_INTEGER(bm.gravity);
bm.volatility_int = MAKE_INTEGER(bm.volatility);
bm.viscosity_int = MAKE_INTEGER(bm.viscosity);
bm.speed_limit_int = MAKE_INTEGER(bm.speed_limit);
}
char* MpXResource (const char *Application, const char *Name, const char *Class)
{
const int STRLEN = 256;
static int init = true;
static XrmDatabase DefaultResource;
char CompName[STRLEN], CompClass[STRLEN], *type;
XrmValue result;
// initialize X resource manager
if (init) {
init = false;
XrmInitialize();
DefaultResource = (XrmDatabase) 0;
char tmp[STRLEN];
XrmDatabase EnvironmentResource;
// search file $HOME/.Xresources
char *homedir = getenv("HOME");
if (!homedir) homedir = ".";
sprintf(tmp,"%s/.Xresources", homedir);
DefaultResource = XrmGetFileDatabase(tmp);
#ifdef DEBUG
cerr << "seaching HOME='" << tmp << "' "
<< (DefaultResource ? "was successful" : "failed")
<< endl;
#endif
// merge file given by $XENVIRONMENT
char *xenviron = (char *) getenv("XENVIRONMENT");
if (xenviron) {
EnvironmentResource = XrmGetFileDatabase(xenviron);
#ifdef DEBUG
cerr << "seaching XENVIRONMENT='" << xenviron << "' "
<< (EnvironmentResource ? "was successful" : "failed")
<< endl;
#endif
// merge both databases
if (EnvironmentResource) {
if (!DefaultResource)
DefaultResource = EnvironmentResource;
else
XrmMergeDatabases(EnvironmentResource, &DefaultResource);
}
}
}
// no resource database available
if (!DefaultResource) return 0;
// now search resource in database
strcpy (CompName, Application);
strcat (CompName, ".");
strcat (CompName, Name);
strcpy (CompClass, "Program");
strcat (CompClass, ".");
strcat (CompClass, Class);
XrmGetResource(DefaultResource, CompName, CompClass, &type, &result);
return result.addr;
}
int
/*ARGSUSED*/
XGetErrorDatabaseText(
Display *dpy,
register _Xconst char *name,
register _Xconst char *type,
_Xconst char *defaultp,
char *buffer,
int nbytes)
{
static XrmDatabase db = NULL;
XrmString type_str;
XrmValue result;
char temp[BUFSIZ];
char* tptr;
unsigned long tlen;
if (nbytes == 0) return 0;
if (!db) {
/* the Xrm routines expect to be called with the global
mutex unlocked. */
XrmDatabase temp_db;
int do_destroy;
const char *dbname;
XrmInitialize();
#ifdef WIN32
dbname = getenv("XERRORDB");
if (!dbname)
dbname = ERRORDB;
#else
dbname = ERRORDB;
#endif
temp_db = XrmGetFileDatabase(dbname);
_XLockMutex(_Xglobal_lock);
if (!db) {
db = temp_db;
do_destroy = 0;
} else
do_destroy = 1; /* we didn't need to get it after all */
_XUnlockMutex(_Xglobal_lock);
if (do_destroy)
XrmDestroyDatabase(temp_db);
}
if (db)
{
tlen = strlen (name) + strlen (type) + 2;
if (tlen <= sizeof(temp))
tptr = temp;
else
tptr = Xmalloc (tlen);
if (tptr) {
sprintf(tptr, "%s.%s", name, type);
XrmGetResource(db, tptr, "ErrorType.ErrorNumber",
&type_str, &result);
if (tptr != temp)
Xfree (tptr);
} else {
result.addr = (XPointer) NULL;
}
}
else
result.addr = (XPointer)NULL;
if (!result.addr) {
result.addr = (XPointer) defaultp;
result.size = strlen(defaultp) + 1;
}
(void) strncpy (buffer, (char *) result.addr, nbytes);
if (result.size > nbytes) buffer[nbytes-1] = '\0';
return 0;
}
void conf_init(void) {
init_default_values();
gboolean keyoption = FALSE;
Display *dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
XrmInitialize();
char basename[12] = "/.Xdefaults";
char *filename = strcat(getpwuid(getuid())->pw_dir, basename);
XrmSetDatabase(dpy, XrmGetFileDatabase(filename));
char *op;
int i;
Option o;
for (i = 0; i < OPTION_COUNT; i++) {
o = options[i];
if ((op = XGetDefault(dpy, "stjerm", o.long_name)))
read_value(o.long_name, op);
}
char color[8];
for (i = 0; i < 16; i++) {
sprintf(color, "color%d", i);
if ((op = XGetDefault(dpy, "stjerm", color)))
read_value(color, op);
}
for (i = 1; i < sargc; i++) {
if (sargv != NULL) {
if (!strcmp(sargv[i], "--help")) {
print_help();
exit(1);
} else if (!strcmp(sargv[i], "--info")) {
print_info();
exit(1);
} else if (!strcmp("--toggle", sargv[i])) {
kill(get_stjerm_pid(), SIGUSR1);
exit(1);
} else if (!strcmp("--version", sargv[i]) || !strcmp("-v", sargv[i])){
print_version();
exit(1);
}
}
if (i + 1>= sargc)
break;
read_value(sargv[i], sargv[i + 1]);
}
if (keyoption == FALSE && _key == 0) {
printf("Hint: You started stjerm without specifying a shortcut key\n"
" To show/hide stjerm run stjerm with the toggle option\n"
" like this: stjerm --toggle");
}
struct stat st;
if (stat(_shell, &st) != 0) {
fprintf(stderr, "ERROR: The shell '%s' can't be opened\n", _shell);
exit(1);
}
if (_lines < 0) {
fprintf(stderr, "ERROR: A scrollback line count < 0 is not allowed\n");
exit(1);
}
if (keyoption == TRUE && _key == 0) {
fprintf(stderr, "ERROR: Wrong shortcut key is defined\n");
exit(1);
}
if (read_colors > 0 && read_colors < 16) {
fprintf(stderr, "ERROR: Read only %d colors, not 16\n"
"Specify a complete color palette\n", read_colors);
exit(1);
}
signal(SIGUSR1, (__sighandler_t) mainwindow_toggle);
int scrw = gdk_screen_get_width(gdk_screen_get_default());
int scrh = gdk_screen_get_height(gdk_screen_get_default());
if (_pos == POS_TOP) {
_posx = (scrw - _width) / 2;
_posy = 0;
} else if (_pos == POS_BOTTOM) {
_posx = (scrw - _width) / 2;
_posy = scrh - _height;
} else if (_pos == POS_LEFT) {
_posx = 0;
_posy = (scrh - _height) / 2;
} else if (_pos == POS_RIGHT) {
_posx = scrw - _width;
_posy = (scrh - _height) / 2;
} else if (_pos == POS_TOPLEFT) {
_posx = 0;
_posy = 0;
} else if (_pos == POS_TOPRIGHT) {
_posx = scrw - _width;
_posy = 0;
} else if (_pos == POS_BOTTOMLEFT) {
_posx = 0;
_posy = scrh - _height;
} else if (_pos == POS_BOTTOMRIGHT) {
_posx = scrw - _width;
_posy = scrh - _height;
}
}
/***********************************************************************
*
* restoreSession - gets the valid x and y location of where to put the
* Text Edit on the root window. Sets the global varible
* dtpad.saveRestore to True so the rest of the program knows that
* a session is being restored.
*
***********************************************************************/
void
restoreSession(
Editor *pPad)
{
XrmDatabase db;
char *tmpStr;
XrmName xrm_name[5];
XrmRepresentation rep_type;
XrmValue value;
char *fileName = pPad->xrdb.session;
char *path;
int numPadsToRestore, i;
Boolean foundPad;
if(DtSessionRestorePath(topLevelWithWmCommand, &path, fileName) == False)
path = fileName;
/* Open the file as a resource database */
if ((db = XrmGetFileDatabase (path)) == NULL)
{
tmpStr = (char *)XtMalloc(strlen(MSG2) + strlen(path)+ 1);
sprintf(tmpStr, MSG2, path);
_DtSimpleErrnoError(pPad->progname, DtError, MSG1, tmpStr, NULL);
XtFree(tmpStr);
return;
}
xrm_name[0] = XrmStringToQuark ("pads");
xrm_name[1] = XrmStringToQuark ("numActivePads");
xrm_name[2] = NULL;
XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value);
numPadsToRestore = atoi((char *)value.addr);
if(numPadsToRestore == 0)
{
/*
* Either it's an old (i.e. 2.01) session file,
* or it's bogus. Either way, we'll create one
* window, taking whatever mainWindow: resources
* we can find.
*/
xrm_name[0] = XrmStringToQuark ("mainWindow");
xrm_name[2] = NULL;
/* get x position */
xrm_name[1] = XrmStringToQuark ("x");
XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value);
pPad->x = atoi((char *)value.addr);
/* get y position */
xrm_name[1] = XrmStringToQuark ("y");
XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value);
pPad->y = atoi((char *)value.addr);
pPad->saveRestore = True;
return;
}
RestorePad(pPad, 0, db);
for(i = 1; i < numPadsToRestore; i++)
{
foundPad = FindOrCreatePad(&pPad);
RestorePad(pPad, i, db);
if(foundPad == False)
RealizeNewPad(pPad);
else
ManageOldPad(pPad, False);
}
}
