Removed all global preferences path constants.

PrefHandler now exports a static method GetDefaultPath() which gets the
path to the default settings file (using find_directory(), of course).
Disabled locale support; should be easy to reenable when needed again, though.
Made all the PrefHandler getters a lot more robust (could easily crash when asking
for an unknown item).
Some cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@13853 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/apps/terminal/MenuUtil.cpp

@@ -42,7 +42,8 @@
 
 extern PrefHandler *gTermPref;
 
-#define LOCALE_FILE_DIR PREF_FOLDER"menu/"
+//#define LOCALE_FILE_DIR PREF_FOLDER"menu/"
+
 
 BPopUpMenu *
 MakeMenu(ulong msg, const char **items, const char *defaultItemName)
@@ -50,29 +51,26 @@ MakeMenu(ulong msg, const char **items, const char *defaultItemName)
 	BPopUpMenu *menu = new BPopUpMenu("");
 
 	int32 i = 0;
-	while(*items)
+	while (*items) {
-	{
 		menu->AddItem(new BMenuItem(*items, new BMessage(msg)));
 		if (!strcmp(*items, defaultItemName))
-		{
+			menu->ItemAt(i)->SetMarked(true);
-			(menu->ItemAt(i))->SetMarked(true);
+
-		}
 		items++;
 		i++;
 	}
 	return menu;
 }
 
+
 int
 longname2op(const char *longname)
 {
 	int op = M_UTF8;
 	const etable *s = encoding_table;
 	
-	for (int i = 0; s->name; s++, i++)
+	for (int i = 0; s->name; s++, i++) {
-	{
+		if (!strcmp(s->name, longname)) {
-		if(!strcmp(s->name, longname)) 
-		{
 			op = s->op;
 			break;
 		}
@@ -80,19 +78,20 @@ longname2op(const char *longname)
 	return op;
 }
 
+
 const char *
 op2longname(int op)
 {
 	return encoding_table[op].name;
 }
 
+
 void
 MakeEncodingMenu(BMenu *eMenu, int coding, bool flag)
 {
 	const etable *e = encoding_table;
 	int i = 0;
-	while(e->name)
+	while (e->name) {
-	{
 		BMessage *msg = new BMessage(MENU_ENCODING);
 		msg->AddInt32("op", (int32)e->op);
 		if (flag)
@@ -101,26 +100,25 @@ MakeEncodingMenu(BMenu *eMenu, int coding, bool flag)
 			eMenu->AddItem(new BMenuItem(e->name, msg));
 
 		if (i == coding)
-		{
+			eMenu->ItemAt(i)->SetMarked(true);
-			(eMenu->ItemAt(i))->SetMarked(true);
+
-		}
 		e++;
 		i++;
 	}
 }
 
+
 void
 LoadLocaleFile(PrefHandler *pref)
 {
+	char name[B_PATH_NAME_LENGTH];
 	const char *locale;
-	char buf[B_PATH_NAME_LENGTH];
-	status_t sts;
 
 	locale = gTermPref->getString(PREF_GUI_LANGUAGE);
-	sprintf (buf, "%s%s", LOCALE_FILE_DIR, locale);
+	// TODO: this effectively disables any locale support - which is okay for now
+	sprintf(name, "%s%s", /*LOCALE_FILE_DIR*/"", locale);
 
-	sts = pref->OpenText (buf);
+	//if (pref->OpenText(name) < B_OK)
-	
+	//	pref->OpenText(LOCALE_FILE_DEFAULT);
-	if (sts == B_ERROR)
-		pref->OpenText (LOCALE_FILE_DEFAULT);
 }
+

src/apps/terminal/PrefDlg.cpp

@@ -168,19 +168,23 @@ PrefDlg::SaveRequested(BMessage *msg)
 	gTermPref->SaveAsText(path.Path(), PREFFILE_MIMETYPE, TERM_SIGNATURE);
 }
 
+
 void
-PrefDlg::doSave (void)
+PrefDlg::doSave()
 {
 	delete fPrefTemp;
 	fPrefTemp = new PrefHandler(gTermPref);
 
-	gTermPref->SaveAsText (TERM_PREF, PREFFILE_MIMETYPE);
+	BPath path;
-	
+	if (PrefHandler::GetDefaultPath(path) == B_OK) {
+		gTermPref->SaveAsText(path.Path(), PREFFILE_MIMETYPE);
 		fDirty = false;
 	}
+}
+
 
 void
-PrefDlg::doRevert (void)
+PrefDlg::doRevert()
 {
 	BMessenger messenger (fTermWindow);
 

src/apps/terminal/PrefHandler.cpp

@@ -26,22 +26,25 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- *
  */
-#include <stdio.h>
+
-#include <unistd.h>
+#include "Coding.h"
-#include <stdlib.h>
+#include "PrefHandler.h"
-#include <string.h>
+#include "TermConst.h"
 
 #include <GraphicsDefs.h>
 #include <Message.h>
 #include <File.h>
 #include <Entry.h>
 #include <NodeInfo.h>
+#include <Directory.h>
+#include <FindDirectory.h>
+#include <Path.h>
 
-#include "Coding.h"
+#include <stdio.h>
-#include "PrefHandler.h"
+#include <unistd.h>
-#include "TermConst.h"
+#include <stdlib.h>
+#include <string.h>
 
 /*
  * Startup preference settings.
@@ -82,86 +85,95 @@ const prefDefaults  termDefaults[] ={
 	{ NULL, NULL},
 };
 
-/////////////////////////////////////////////////////////////////////////////
+
-//
-//
-/////////////////////////////////////////////////////////////////////////////
 PrefHandler::PrefHandler()
 {
-  mPrefContainer.what = 'Pref';
+	fContainer.what = 'Pref';
-  OpenText(TERM_PREF, termDefaults);
+
+	BPath path;
+	GetDefaultPath(path);
+	OpenText(path.Path(), termDefaults);
 }
-/////////////////////////////////////////////////////////////////////////////
+
-//
+
-//
-/////////////////////////////////////////////////////////////////////////////
 PrefHandler::PrefHandler(const PrefHandler* p)
 {
-  mPrefContainer = p->mPrefContainer;
+	fContainer = p->fContainer;
 }
-/////////////////////////////////////////////////////////////////////////////
+
-//
+
-//
-/////////////////////////////////////////////////////////////////////////////
 PrefHandler::~PrefHandler()
 {
 }
-/////////////////////////////////////////////////////////////////////////////
+
-//
+
-//
+/* static */
-/////////////////////////////////////////////////////////////////////////////
+status_t
+PrefHandler::GetDefaultPath(BPath& path)
+{
+	if (find_directory(B_USER_SETTINGS_DIRECTORY, &path, true) != B_OK)
+		return B_ERROR;
+
+	// TODO: maybe just "Terminal"? (but this collides with the R5 Terminal settings file)
+	path.Append("HaikuTerminal");
+	path.Append("settings");
+
+	return B_OK;
+}
+
+
 status_t
 PrefHandler::Open(const char *path, const prefDefaults *defaults)
 {
-  BEntry ent(path);
+	BEntry entry(path);
-  if(ent.Exists()){
+	if (entry.Exists())
-    return loadFromFile(&ent);
+		return loadFromFile(&entry);
-  }else{
+
 	return loadFromDefault(defaults);
 }
-}
+
-/////////////////////////////////////////////////////////////////////////////
+
-//
-//
-/////////////////////////////////////////////////////////////////////////////
 status_t
 PrefHandler::OpenText(const char *path, const prefDefaults *defaults)
 {
-  BEntry ent(path);
+	BEntry entry(path);
-  if(ent.Exists()){
+	if (entry.Exists())
 		return loadFromTextFile(path);
-  }else{
+
 	return loadFromDefault(defaults);
 }
-}
+
-/////////////////////////////////////////////////////////////////////////////
+
-//
-//
-/////////////////////////////////////////////////////////////////////////////
 status_t
 PrefHandler::Save(const char *path)
 {
-  status_t sts;
+	// make sure the target path exists
+	BPath directoryPath(path);
+	if (directoryPath.GetParent(&directoryPath) == B_OK)
+		create_directory(directoryPath.Path(), 0755);
+
 	BFile file(path, B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
-  sts = mPrefContainer.Flatten(&file);
+	return fContainer.Flatten(&file);
-  return sts;
 }
-/////////////////////////////////////////////////////////////////////////////
+
-//
+
-//
-/////////////////////////////////////////////////////////////////////////////
 void
 PrefHandler::SaveAsText(const char *path, const char *mimetype,
 	const char *signature)
 {
+	// make sure the target path exists
+	BPath directoryPath(path);
+	if (directoryPath.GetParent(&directoryPath) == B_OK)
+		create_directory(directoryPath.Path(), 0755);
+
 	BFile file(path, B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
+	char buffer[512];
 	type_code type;
 	char *key;
-  char buf[256];
 
-  for (int32 i = 0; mPrefContainer.GetInfo(B_STRING_TYPE, i, &key, &type) == B_OK; i++){  
+	for (int32 i = 0; fContainer.GetInfo(B_STRING_TYPE, i, &key, &type) == B_OK; i++) {
-    int len = sprintf(buf, "\"%s\" , \"%s\"\n", key, this->getString(key));
+		int len = snprintf(buffer, sizeof(buffer), "\"%s\" , \"%s\"\n", key, getString(key));
-    file.Write(buf, len);
+		file.Write(buffer, len);
 	}
 
 	if (mimetype != NULL){
@@ -169,143 +181,141 @@ PrefHandler::SaveAsText(const char *path, const char *mimetype,
 		info.SetType(mimetype);
 		info.SetPreferredApp(signature);
 	}
-  
 }
-/////////////////////////////////////////////////////////////////////////////
+
-//
+
-//
-/////////////////////////////////////////////////////////////////////////////
 int32 
 PrefHandler::getInt32(const char *key)
 {
-  return atoi(mPrefContainer.FindString(key));
+	const char *value = fContainer.FindString(key);
+	if (value == NULL)
+		return 0;
+
+	return atoi(value);
 }
-/////////////////////////////////////////////////////////////////////////////
+
-//
+
-//
-/////////////////////////////////////////////////////////////////////////////
 float 
 PrefHandler::getFloat(const char *key)
 {
-  return atof(mPrefContainer.FindString(key));
+	const char *value = fContainer.FindString(key);
+	if (value == NULL)
+		return 0;
+
+	return atof(value);
 }
-/////////////////////////////////////////////////////////////////////////////
+
-//
+
-//
-/////////////////////////////////////////////////////////////////////////////
 const char* 
 PrefHandler::getString(const char *key)
 {
-  const char *buf;
+	const char *buffer;
-
+	if (fContainer.FindString(key, &buffer) != B_OK)
-  if (mPrefContainer.FindString(key, &buf) != B_OK)
+		buffer = "Error!";
-    buf = "Error!";
 
 	//printf("%x GET %s: %s\n", this, key, buf);
-  return buf;
+	return buffer;
 }
-/////////////////////////////////////////////////////////////////////////////
+
-//
+
-//
-/////////////////////////////////////////////////////////////////////////////
 bool
 PrefHandler::getBool(const char *key)
 {
-  const char *s = mPrefContainer.FindString(key);
+	const char *value = fContainer.FindString(key);
-  if (!strcmp(s, PREF_TRUE)) return true;
+	if (value == NULL)
 		return false;
+
+	return !strcmp(value, PREF_TRUE);
 }
-/////////////////////////////////////////////////////////////////////////////
+
-// getRGB
+
-// Returns RGB data from given key. 
+/** Returns RGB data from given key. */
-/////////////////////////////////////////////////////////////////////////////
+
 rgb_color
 PrefHandler::getRGB(const char *key)
 {
-  int r, g, b;
 	rgb_color col;
-  if (const char *s = mPrefContainer.FindString(key)) {
+	int r, g, b;
+
+	if (const char *s = fContainer.FindString(key)) {
 		sscanf(s, "%d, %d, %d", &r, &g, &b);
 	} else {
 		fprintf(stderr, "PrefHandler::getRGB(%s) - key not found\n", key);
 		r = g = b = 0;
 	}
+
 	col.red = r;
 	col.green = g;
 	col.blue = b;
 	col.alpha = 255;
 	return col;
 }
-/////////////////////////////////////////////////////////////////////////////
+
-// setInt32
+
-// Setting Int32 data with key.
+/** Setting Int32 data with key. */
-/////////////////////////////////////////////////////////////////////////////
+
 void
 PrefHandler::setInt32(const char *key, int32 data)
 {
-  char buf[20];
+	char buffer[32];
-  sprintf(buf, "%d", (int)data);
+	snprintf(buffer, sizeof(buffer), "%d", (int)data);
-  this->setString(key, buf);
+	setString(key, buffer);
 }
-/////////////////////////////////////////////////////////////////////////////
+
-// setFloat
+
-// Setting Float data with key
+/** Setting Float data with key */
-/////////////////////////////////////////////////////////////////////////////
+
 void
 PrefHandler::setFloat(const char *key, float data)
 {
-  char buf[20];
+	char buffer[32];
-  sprintf(buf, "%g", data);
+	snprintf(buffer, sizeof(buffer), "%g", data);
-  this->setString(key, buf);
+	setString(key, buffer);
 }
-/////////////////////////////////////////////////////////////////////////////
+
-// setBool
+
-// Setting Bool data with key
+/** Setting Bool data with key */
-/////////////////////////////////////////////////////////////////////////////
+
 void
 PrefHandler::setBool(const char *key, bool data)
 {
-  if(data){
+	if (data)
-    this->setString(key, PREF_TRUE);
+		setString(key, PREF_TRUE);
-  }else{
+	else
-    this->setString(key, PREF_FALSE);
+		setString(key, PREF_FALSE);
 }
-}
+
-/////////////////////////////////////////////////////////////////////////////
+
-// this->setString
+/** Setting CString data with key */
-// Setting CString data with key
+
-/////////////////////////////////////////////////////////////////////////////
 void
 PrefHandler::setString(const char *key, const char *data)
 {
 	//printf("%x SET %s: %s\n", this, key, data);
-  mPrefContainer.RemoveName(key);
+	fContainer.RemoveName(key);
-  mPrefContainer.AddString(key, data);
+	fContainer.AddString(key, data);
 }
-/////////////////////////////////////////////////////////////////////////////
+
-// setRGB
+
-// Setting RGB data with key
+/** Setting RGB data with key */
-/////////////////////////////////////////////////////////////////////////////
+
 void
 PrefHandler::setRGB(const char *key, const rgb_color data)
 {
-  char buf[20];
+	char buffer[32];
-  sprintf(buf, "%d, %d, %d", data.red, data.green, data.blue);
+	snprintf(buffer, sizeof(buffer), "%d, %d, %d", data.red, data.green, data.blue);
-  this->setString(key, buf);
+	setString(key, buffer);
 }
-/////////////////////////////////////////////////////////////////////////////
+
-// IsEmpty
+
-// Check any peference stored or not.
+/** Check any peference stored or not. */
-/////////////////////////////////////////////////////////////////////////////
+
 bool
 PrefHandler::IsEmpty() const
 {
-  return mPrefContainer.IsEmpty();
+	return fContainer.IsEmpty();
 }
-/////////////////////////////////////////////////////////////////////////////
+
-//
-//
-/////////////////////////////////////////////////////////////////////////////
 
 status_t
 PrefHandler::loadFromFile(BEntry *ent)
@@ -314,8 +324,8 @@ PrefHandler::loadFromFile(BEntry *ent)
   // save the settings. (Who cares about compatibility in this case anyway?)
 
   BFile file (ent, B_READ_ONLY);
-  //mPrefContainer.MakeEmpty();
+  //fContainer.MakeEmpty();
-  //mPrefContainer.Unflatten(&file);
+  //fContainer.Unflatten(&file);
   off_t size;
   if (file.GetSize(&size) != B_OK || size != sizeof(struct termprefs))
     return B_ERROR;

src/apps/terminal/PrefHandler.h

@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2003-4 Kian Duffy <[email protected]>
  * Copyright (c) 2004 Daniel Furrer <[email protected]>
- * Parts Copyright (C) 1998,99 Kazuho Okui and Takashi Murai. 
+ * Copyright (C) 1998,99 Kazuho Okui and Takashi Murai. 
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files or portions
@@ -62,8 +62,7 @@ struct termprefs {
 	char unknown[3];
 };
 
-struct prefDefaults
+struct prefDefaults {
-{
 	const char *key;
 	char *item;
 };
@@ -76,9 +75,8 @@ class BEntry;
 
 class PrefHandler {
 	public:
-  PrefHandler();
 		PrefHandler(const PrefHandler* p);
-
+		PrefHandler();
 		~PrefHandler();
 
 		status_t    Open(const char *name, const prefDefaults *defaults = NULL);
@@ -101,15 +99,14 @@ public:
 
 		bool        IsEmpty() const;
 
+		static status_t GetDefaultPath(BPath& path);
+
 	private:
 		status_t    loadFromFile(BEntry *ent);
 		status_t    loadFromDefault(const prefDefaults* defaluts = NULL);
 		status_t    loadFromTextFile(const char * path);
 
-
+		BMessage    fContainer;
-  BMessage    mPrefContainer;
-
-
 };
 
 #endif // PREFHANDLER_H_INCLUDED

src/apps/terminal/TermConst.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2003-4 Kian Duffy <[email protected]>
- * Parts Copyright (C) 1998,99 Kazuho Okui and Takashi Murai. 
+ * Copyright (C) 1998,99 Kazuho Okui and Takashi Murai. 
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files or portions
@@ -147,9 +147,6 @@ enum {
 ////////////////////////////////////////////////////////////////////////////
 // Preference Folder and setting path
 ////////////////////////////////////////////////////////////////////////////
-#define PREF_FOLDER  "/boot/home/config/settings/MuTerminal/"
-const char * const TERM_PREF = PREF_FOLDER "setting.mp";
-const char * const LOCALE_FILE_DEFAULT = PREF_FOLDER "menu/en";
 
 const int32 DEFAULT = -1;