Initial import of the CDE 2.1.30 sources from the Open Group.

cde/programs/dtprintinfo/objects/BaseObj.C

@@ -0,0 +1,532 @@
+/* $TOG: BaseObj.C /main/4 1998/08/03 16:30:23 mgreess $ */
+/*                                                                      *
+ * (c) Copyright 1993, 1994 Hewlett-Packard Company                     *
+ * (c) Copyright 1993, 1994 International Business Machines Corp.       *
+ * (c) Copyright 1993, 1994 Sun Microsystems, Inc.                      *
+ * (c) Copyright 1993, 1994 Novell, Inc.                                *
+ */
+
+#include "BaseObj.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+const char *ACTION_NOT_FOUND = "ActionNotFound";
+
+BaseObj::BaseObj(BaseObj *parent,
+	         const char *name)
+{
+   _name = STRDUP(name);
+   _displayName = NULL;
+   _details = NULL;
+   _parent = parent;
+   _init_children = false;
+   _init_attributes = false;
+   _children = NULL;
+   _numChildren = 0;
+   _numActions = 0;
+   _numAttributes = 0;
+   _actions = NULL;
+   _attributes = NULL;
+   _lastActionName = NULL;
+   _lastActionOutput = NULL;
+   _lastActionStatus = 0;
+   AddToParent();
+   BaseObj *p = _parent;
+   while (p)
+    {
+      p->NotifyCreate(this);
+      p = p->_parent;
+    }
+}
+
+BaseObj::~BaseObj()
+{
+   int i;
+
+   DeleteChildren();
+   DeleteFromParent();
+
+   BaseObj *parent = _parent;
+   while (parent)
+    {
+      parent->NotifyDelete(this);
+      parent = parent->_parent;
+    }
+
+   for (i = 0; i < _numAttributes; i++)
+    {
+      delete _attributes[i]->ReferenceName;
+      delete _attributes[i]->Value;
+      delete _attributes[i]->DisplayName;
+      delete _attributes[i]->DisplayValue;
+      delete _attributes[i]->DefaultValue;
+      delete _attributes[i]->DisplayDefaultValue;
+      delete _attributes[i]->Help;
+      delete _attributes[i]->ContextualHelp;
+      delete _attributes[i]->Listing;
+      delete _attributes[i]->Dependancies;
+      delete _attributes[i];
+    }
+   delete []_attributes;
+   for (i = 0; i < _numActions; i++)
+    {
+      delete _actions[i]->ReferenceName;
+      delete _actions[i]->DisplayName;
+      delete _actions[i]->Nmemonic;
+      delete _actions[i]->AcceleratorText;
+      delete _actions[i]->Accelerator;
+      delete _actions[i]->Help;
+      delete _actions[i]->ContextualHelp;
+      delete _actions[i]->Dependancies;
+      delete _actions[i];
+    }
+   delete []_actions;
+   delete []_children;
+   free(_lastActionName);
+   delete [] _lastActionOutput;
+   free(_details);
+   free(_displayName);
+   free(_name);
+}
+
+char *BaseObj::DisplayName()
+{
+   if (!_displayName)
+    {
+      InitDisplayName();
+      if (!_displayName)
+	 _displayName = STRDUP(_name);
+    }
+   return _displayName; 
+}
+
+void BaseObj::ReadAttributes()
+{
+   if (_init_attributes == false)
+    {
+      LoadAttributes(_numAttributes, _attributes);
+      _init_attributes = true;
+    }
+}
+
+char *BaseObj::Details()
+{
+   if (!_details)
+    {
+      InitDetails();
+      if (!_details)
+	 _details = STRDUP("");
+    }
+   return _details; 
+}
+
+void BaseObj::UpdateDetails()
+{
+   free(_details);
+   _details = NULL;
+   (void) Details();
+}
+
+void BaseObj::UpdateChildren()
+{
+   DeleteChildren();
+   InitChildren();
+   _init_children = true;
+}
+
+BaseObj **BaseObj::Children()
+{
+   if (_init_children == false)
+    {
+      InitChildren();
+      _init_children = true;
+    }
+   return _children; 
+}
+
+int BaseObj::NumChildren()
+{
+   if (_init_children == false)
+    {
+      InitChildren();
+      _init_children = true;
+    }
+   return _numChildren; 
+}
+
+void BaseObj::DeleteAction(const char *name)
+{
+   Action *action;
+
+   if (!HasAction(name, &action))
+      return;
+
+   Action **new_actions;
+   int i, index;
+
+   index = 0;
+   new_actions = new Action*[_numActions - 1];
+   for (i = 0; i < _numActions; i++)
+      if (_actions[i] != action)
+         new_actions[index++] = _actions[i];
+   delete action->ReferenceName;
+   delete action->DisplayName;
+   delete action->Nmemonic;
+   delete action->AcceleratorText;
+   delete action->Accelerator;
+   delete action->Help;
+   delete action->ContextualHelp;
+   delete action->Dependancies;
+   delete action;
+
+   delete []_actions;
+   _actions = new_actions;
+
+   _numActions--;
+}
+
+void BaseObj::DeleteAttribute(const char *name)
+{
+   Attribute *attribute;
+
+   if (!HasAttribute(name, &attribute))
+      return;
+
+   Attribute **new_attributes;
+   int i, index;
+
+   index = 0;
+   new_attributes = new Attribute*[_numAttributes - 1];
+   for (i = 0; i < _numAttributes; i++)
+      if (_attributes[i] != attribute)
+         new_attributes[index++] = _attributes[i];
+   delete attribute->ReferenceName;
+   delete attribute->Value;
+   delete attribute->DisplayName;
+   delete attribute->DisplayValue;
+   delete attribute->DefaultValue;
+   delete attribute->DisplayDefaultValue;
+   delete attribute->Help;
+   delete attribute->ContextualHelp;
+   delete attribute->Listing;
+   delete attribute->Dependancies;
+   delete attribute;
+
+   delete []_attributes;
+   _attributes = new_attributes;
+
+   _numAttributes--;
+}
+
+void BaseObj::AddAttribute(const char *ReferenceName,
+                           const char *DisplayName,
+                           const char *Help,
+                           const char *ContextualHelp,
+                           Characteristics Mask,
+                           ValueList ValueListType,
+                           const char *Listing,
+                           const char *Dependancies,
+                           const char *DefaultValue,
+                           const char *DisplayDefaultValue)
+{
+   Attribute **new_attributes;
+   int i;
+
+   new_attributes = new Attribute*[_numAttributes + 1];
+   for (i = 0; i < _numAttributes; i++)
+      new_attributes[i] = _attributes[i];
+
+   delete []_attributes;
+   _attributes = new_attributes;
+   Attribute *attribute = new Attribute;
+   attribute->ReferenceName = STRDUP(ReferenceName);
+   attribute->Value = NULL;
+   attribute->DisplayName = STRDUP(DisplayName);
+   attribute->DisplayValue = NULL;
+   attribute->DefaultValue = STRDUP(DefaultValue);
+   attribute->DisplayDefaultValue = STRDUP(DisplayDefaultValue);
+   attribute->Mask = Mask;
+   attribute->Help = STRDUP(Help);
+   attribute->ContextualHelp = STRDUP(ContextualHelp);
+   attribute->Listing = STRDUP(Listing);
+   attribute->ValueListType = ValueListType;
+   attribute->Dependancies = STRDUP(Dependancies);
+   _attributes[_numAttributes] = attribute;
+
+   _numAttributes++;
+}
+
+void BaseObj::AddAction(ActionHandler Handler, 
+			const char *ReferenceName,
+			const char *DisplayName,
+			const char *Nmemonic,
+                        const char *Help, 
+                        const char *ContextualHelp,
+			boolean InputRequired,
+                        const char *AcceleratorText,
+                        const char *Accelerator,
+                        const char *Dependancies)
+{
+   Action **new_actions;
+   int i;
+
+   new_actions = new Action*[_numActions + 1];
+   for (i = 0; i < _numActions; i++)
+      new_actions[i] = _actions[i];
+
+   delete []_actions;
+   _actions = new_actions;
+   Action *action = new Action;
+   action->Handler = Handler;
+   action->ReferenceName = STRDUP(ReferenceName);
+   action->DisplayName = STRDUP(DisplayName);
+   action->Nmemonic = STRDUP(Nmemonic);
+   action->AcceleratorText = STRDUP(AcceleratorText);
+   action->Accelerator = STRDUP(Accelerator);
+   action->InputRequired = InputRequired;
+   action->Help = STRDUP(Help);
+   action->ContextualHelp = STRDUP(ContextualHelp);
+   action->Dependancies = STRDUP(Dependancies);
+   _actions[_numActions] = action;
+
+   _numActions++;
+}
+
+void BaseObj::AddToParent()
+{
+   if (!_parent)
+      return;
+
+   BaseObj **new_children;
+   int i;
+
+   new_children = new BaseObj*[_parent->_numChildren + 1];
+   for (i = 0; i < _parent->_numChildren; i++)
+      new_children[i] = _parent->_children[i];
+
+   delete []_parent->_children;
+   _parent->_children = new_children;
+   _parent->_children[_parent->_numChildren] = this;
+
+   _parent->_numChildren++;
+}
+
+void BaseObj::DeleteFromParent()
+{
+   if (!_parent)
+      return;
+
+   BaseObj **new_children;
+   int i, index;
+
+   index = 0;
+   new_children = new BaseObj*[_parent->_numChildren - 1];
+   for (i = 0; i < _parent->_numChildren; i++)
+      if (_parent->_children[i] != this)
+         new_children[index++] = _parent->_children[i];
+
+   delete []_parent->_children;
+   _parent->_children = new_children;
+
+   _parent->_numChildren--;
+}
+
+int BaseObj::NumSiblings()
+{
+   if (_parent)
+      return _parent->_numChildren;
+   else
+      return 0;
+}
+
+BaseObj ** BaseObj::Siblings()
+{
+   if (_parent)
+      return _parent->_children;
+   else
+      return NULL;
+}
+
+boolean BaseObj::HasAction(const char *actionName,
+	                   Action **action)
+{
+   int i;
+
+   for (i = 0; i < _numActions; i++)
+      if (!strcmp(_actions[i]->ReferenceName, actionName))
+	{
+	  *action = _actions[i];
+	  return true;
+	}
+   return false;
+}
+
+boolean BaseObj::HasAction(Action *action)
+{
+   Action *dummy;
+
+   if (action)
+      return HasAction(action->ReferenceName, &dummy);
+   else
+      return false;
+}
+
+boolean BaseObj::HasAction(const char *actionName)
+{
+   Action *dummy;
+
+   return HasAction(actionName, &dummy);
+}
+
+boolean BaseObj::SendAction(Action *action,
+		            BaseObj *requestor)
+{
+   boolean status;
+
+   delete [] _lastActionOutput;
+   free(_lastActionName);
+   _lastActionOutput = NULL;
+   _lastActionName = strdup(action->ReferenceName);
+   if ((status = HasAction(action)) == true)
+      _lastActionStatus = (*action->Handler)(this, &_lastActionOutput,
+					     requestor);
+   else
+    {
+      _lastActionStatus = -1;
+      int len = strlen("'%s' is not an action of %s") +
+		strlen(ObjectClassName()) + strlen(action->ReferenceName);
+      _lastActionOutput = new char [len];
+      sprintf(_lastActionOutput, "'%s' is not an action of %s", 
+	      ObjectClassName(), action->ReferenceName);
+    }
+   return status;
+}
+
+boolean BaseObj::SendAction(const char *actionName,
+		            BaseObj *requestor)
+{
+   Action *action;
+
+   (void) HasAction(actionName, &action);
+   return SendAction(action, requestor);
+}
+
+char * BaseObj::AttributeValue(char *referenceName)
+{
+   Attribute *dummy;
+
+   ReadAttributes();
+   if (HasAttribute(referenceName, &dummy))
+      return dummy->Value;
+   else
+      return NULL;
+}
+
+boolean BaseObj::HasAttribute(const char *attributeName,
+	                      Attribute **attribute)
+{
+   int i;
+
+   for (i = 0; i < _numAttributes; i++)
+      if (!strcmp(_attributes[i]->ReferenceName, attributeName))
+	{
+	  *attribute = _attributes[i];
+	  return true;
+	}
+   return false;
+}
+
+boolean BaseObj::HasAttribute(Attribute *attribute)
+{
+   Attribute *dummy;
+
+   return HasAttribute(attribute->ReferenceName, &dummy);
+}
+
+boolean BaseObj::HasAttribute(const char *attributeName)
+{
+   Attribute *dummy;
+
+   return HasAttribute(attributeName, &dummy);
+}
+
+void BaseObj::DeleteChildren()
+{
+   if (_numChildren)
+    {
+      BaseObj **kids = new BaseObj*[_numChildren];
+      int i, n = _numChildren;
+      // Save children first before deleting a child since the destructor
+      // updates the _children variable
+      for (i = 0; i < n; i++)
+         kids[i] = _children[i];
+      for (i = 0; i < n; i++)
+         delete kids[i];
+      delete []kids;
+    }
+}
+
+// Dump object
+void BaseObj::Dump(boolean verbose, int level)
+{
+   int i, j;
+
+   for (i = 0; i < level; i++) printf("   ");
+   printf("%s : %s\n", Name(), ObjectClassName());
+   if (verbose)
+    {
+      for (i = -1; i <= level; i++) printf("   ");
+      printf("Display Name = '%s'\n", _displayName);
+      for (i = -1; i <= level; i++) printf("   ");
+      printf("Details = '%s'\n", _details);
+      for (i = -1; i <= level; i++) printf("   ");
+      printf("Number Actions = %d\n", _numActions);
+      for (j = 0; j < _numActions; j++)
+       {
+         for (i = -2; i <= level; i++) printf("   ");
+	 printf("Action.%s = '%s'\n", _actions[j]->ReferenceName,
+		_actions[j]->DisplayName);
+       }
+      for (i = -1; i <= level; i++) printf("   ");
+      printf("Number Attributes = %d\n", _numAttributes);
+      for (j = 0; j < _numAttributes; j++)
+       {
+         for (i = -2; i <= level; i++) printf("   ");
+	 printf("Attribute.%s = '%s'\n", _attributes[j]->ReferenceName,
+		_attributes[j]->DisplayValue);
+       }
+      for (i = -1; i <= level; i++) printf("   ");
+      printf("Number Children = %d\n", _numChildren);
+    }
+}
+
+// Dump object hierarchy
+void BaseObj::DumpHierarchy(boolean verbose, int level)
+{
+   int i;
+
+   Dump(verbose, level);
+   for (i = 0; i < _numChildren; i++)
+      _children[i]->DumpHierarchy(verbose, level + 1);
+}
+
+void BaseObj::Error(const char *message) 
+{
+   // Log Error
+   printf("%s: (%s) %s\n", ObjectClassName(), Name(), message);
+}
+
+int BaseObj::RunCommand(const char *command, 
+			char **std_out,
+			char **std_err)
+{
+   int status;
+
+   Invoke *_thread = new Invoke(command, std_out, std_err);
+
+   status = _thread->status;
+   delete _thread;
+
+   return status;
+}