Added a (very) basic tree walking functionality for Mac

examples/mac/dump_tree_mac.cc

@@ -7,17 +7,18 @@
 #include "include/axaccess/mac/axapi_node.h"
 
 using mac_inspect::AXAPINode;
+using mac_inspect::AXAPINodePtr;
 
 void print_usage(std::string& program_name) {
   std::cout << "Usage: "<< program_name << " <pid>\n";
 }
 
 void logInfoForPID(pid_t pid) {
-  AXAPINode application = AXAPINode::createForPID(pid);
+  AXAPINodePtr application = AXAPINode::createForPID(pid);
 
-  std::string title = application.GetTitle();
+  std::string title = application->GetTitle();
   std::cerr <<  "Title: " << title << "\n";
-  std::string role = application.GetRole();
+  std::string role = application->GetRole();
   std::cerr << "Role: " << role << "\n";
 }
 

include/axaccess/mac/axapi_node.h

@@ -1,24 +1,36 @@
+#ifndef LIB_MAC_AXAPI_NODE_H_
+#define LIB_MAC_AXAPI_NODE_H_
+
 #include <ApplicationServices/ApplicationServices.h>
 
+#include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
 namespace mac_inspect {
 
+class AXAPINode;
+typedef std::unique_ptr<AXAPINode> AXAPINodePtr;
+
 class AXAPINode {
  public:
-  explicit AXAPINode(AXUIElementRef ax_element);
   ~AXAPINode() = default;
 
-  static AXAPINode createForPID(long pid);
+  static AXAPINodePtr createForPID(long pid);
 
   std::string GetRole();
   std::string GetTitle();
   std::vector<std::string> GetAttributeNames();
   std::string GetStringAttributeValue(std::string& attribute_name);
+  long GetChildCount();
+  AXAPINodePtr GetChildAt(long index);
 
  private:
-  AXUIElementRef ax_element_;
+  explicit AXAPINode(AXUIElementRef ax_element);
+  AXUIElementRef ax_ui_element_;
 };
 
 }  // namespace mac_inspect
+
+#endif  // LIB_MAC_AXAPI_NODE_H_

lib/mac/axapi_node.mm

@@ -11,30 +11,43 @@
   if (cf_string == nullptr)
     return "";
 
-  const char* chars = CFStringGetCStringPtr(cf_string, CFStringGetSystemEncoding());
+  const char* chars =
+      CFStringGetCStringPtr(cf_string, CFStringGetSystemEncoding());
   if (!chars) {
-    // CFStringRef can secretly be an NSString, in which case CFStringGetCStringPtr doesn't work.
-    NSString* ns_string = (__bridge NSString*) cf_string;
-    const char* ns_chars = [ns_string cStringUsingEncoding:[NSString defaultCStringEncoding]];
+    // CFStringRef can secretly be an NSString, in which case
+    // CFStringGetCStringPtr doesn't work.
+    NSString* ns_string = (__bridge NSString*)cf_string;
+    const char* ns_chars =
+        [ns_string cStringUsingEncoding:[NSString defaultCStringEncoding]];
     chars = ns_chars ? ns_chars : "";
   }
   return std::string(chars);
 }
 
-AXAPINode::AXAPINode(AXUIElementRef ax_element) : ax_element_(ax_element) {}
+AXAPINode::AXAPINode(AXUIElementRef ax_ui_element)
+    : ax_ui_element_(ax_ui_element) {}
+
+AXAPINodePtr AXAPINode::createForPID(long pid) {
+  AXUIElementRef ax_ui_element = AXUIElementCreateApplication((pid_t)pid);
+  return std::unique_ptr<AXAPINode>(new AXAPINode(ax_ui_element));
+}
 
 std::string AXAPINode::GetRole() {
   CFTypeRef cf_role = nullptr;
-  if (AXUIElementCopyAttributeValue(ax_element_, kAXRoleAttribute, &cf_role) != noErr)
+  if (AXUIElementCopyAttributeValue(ax_ui_element_, kAXRoleAttribute,
+                                    &cf_role) != kAXErrorSuccess) {
     return "";
+  }
 
-  return CFStringRefToStdString((CFStringRef) cf_role);
+  return CFStringRefToStdString((CFStringRef)cf_role);
 }
 
 std::string AXAPINode::GetTitle() {
   CFStringRef cf_title = nullptr;
-  if (AXUIElementCopyAttributeValue(ax_element_, kAXTitleAttribute, (CFTypeRef*)&cf_title) != noErr)
+  if (AXUIElementCopyAttributeValue(ax_ui_element_, kAXTitleAttribute,
+                                    (CFTypeRef*)&cf_title) != kAXErrorSuccess) {
     return "";
+  }
 
   return CFStringRefToStdString(cf_title);
 }
@@ -48,9 +61,28 @@
   return "";
 }
 
-AXAPINode AXAPINode::createForPID(long pid) {
-  AXUIElementRef axuielement = AXUIElementCreateApplication((pid_t) pid);
-  return AXAPINode(axuielement);
+long AXAPINode::GetChildCount() {
+  CFArrayRef children_ref;
+  if ((AXUIElementCopyAttributeValue(ax_ui_element_, kAXChildrenAttribute,
+                                     (CFTypeRef*)&children_ref)) !=
+      kAXErrorSuccess) {
+    return 0;
+  }
+  return CFArrayGetCount(children_ref);
+}
+
+AXAPINodePtr AXAPINode::GetChildAt(long index) {
+  CFArrayRef children_ref;
+  if ((AXUIElementCopyAttributeValue(ax_ui_element_, kAXChildrenAttribute,
+                                     (CFTypeRef*)&children_ref)) !=
+      kAXErrorSuccess) {
+    return nullptr;
+  }
+  AXUIElementRef child_ref =
+      (AXUIElementRef)CFArrayGetValueAtIndex(children_ref, index);
+  if (!child_ref)
+    return nullptr;
+  return AXAPINodePtr(new AXAPINode(child_ref));
 }
 
 }  // namespace mac_inspect

lib/mac/mac_inspect.i

@@ -1,11 +1,11 @@
 %module mac_inspect
+
 %{
 #include <axaccess/mac/axapi_node.h>
 %}
 
-
 %include "std_string.i"
 %include <std_unique_ptr.i>
-%unique_ptr(AXAPINode)
+%unique_ptr(mac_inspect::AXAPINode)
 
 %include <axaccess/mac/axapi_node.h>