Commit: 2a0474b5df077959fd7ca149eefcd9dc4af61e1e - mingw-get (git)

The MinGW.org Installation Manager Tool

Commit MetaInfo

• Revision: 2a0474b5df077959fd7ca149eefcd9dc4af61e1e (tree)
• Time: 2013-07-15 06:13:50
• Author: Keith Marshall <keithmarshall@user...>
• Commiter: Keith Marshall

Log Message

Implement GUI filtering of package list by group selection.

Change Summary

• modified: ChangeLog
• modified: src/guimain.h
• modified: src/pkgbase.h
• modified: src/pkgbind.cpp
• modified: src/pkgdata.cpp
• modified: src/pkglist.cpp
• modified: src/pkgtree.cpp

Incremental Difference

--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,42 @@
[phone]  Keith Marshall  <[e-mail]>
+
+	Implement GUI filtering of package list by group selection.
+
+	* src/pkgbase.h (pkgXmlNode::IsVisibleGroupMember):
+	(pkgXmlNode::IsVisibleClass): New inline methods; declare them.
+	(pkgXmlNode::MapPackageGroupHierarchy): New inline method; declare it.
+	(pkgXmlNode::SetPackageGroupHierarchyMapper): Likewise; it sets up...
+	(pkgXmlNode::PackageGroupHierarchyMapper): ...this new private static
+	function pointer; declare it as a function reference, in terms of...
+	(pkgXmlNode::GroupHierarchyMapper): ...this new typedef; define it.
+
+	* src/guimain.h (AppWindowMaker::PackageTreeView): Make it static.
+	(AppWindowMaker::IsPackageGroupAffiliate): Declare new static method.
+
+	* src/pkgbind.cpp (pkgRepository::GetPackageList): Make it invoke...
+	(pkgXmlNode::MapPackageGroupHierarchy): ...this; implement it.
+
+	* src/pkglist.cpp (pkgXmlNode::IsVisibleGroupMember): Implement it.
+	(pkgXmlNode::IsVisibleClass): Likewise; just provide a stub, for now.
+	(pkgListViewMaker::Dispatch): Use them to filter package list content.
+	(AppWindowMaker::UpdatePackageList): Redraw main window when done.
+
+	* src/pkgtree.cpp [_WIN32_IE >= 0x0400]: Require this.
+	(AppWindowMaker::PackageTreeView): Define and initialise it.
+	(AppWindowMaker::InitPackageTreeView): Extend implementation; use...
+	(map_package_group_hierarchy_recursive, load package_group_hierarchy):
+	(is_existing_group, map_package_group_hierarchy): ...these; implement
+	them locally, as file scoped static helper functions.
+	(select_key): New static local string constant; define it.
+	(pkgInitCategoryTreeGraft): Use it; also have it invoke...
+	(pkgXmlNode::SetPackageGroupHierarchyMapper): ...this; implement it.
+	(AppWindowMaker::IsPackageGroupAffiliate): Implement it; it uses...
+	(is_affiliated, is_child_affiliate): ...these helpers; provide them as
+	locally implemented, file scoped static functions.
+
+	* src/pkgdata.cpp (AppWindowMaker::OnNotify): Add handler for...
+	[ID_PACKAGE_TREEVIEW && TVN_SELCHANGED]: ...this notification.
+
 2013-07-12  Keith Marshall  <[e-mail]>
 
 	Correct a static string buffer aliasing issue.

--- a/src/guimain.h
+++ b/src/guimain.h
@@ -185,6 +185,7 @@ class AppWindowMaker: public WTK::MainWindowMaker
     int DispatchDialogueThread( int, pkgDialogueThread * );
 
     void LoadPackageData( bool = false );
+    static bool IsPackageGroupAffiliate( pkgXmlNode * );
     void ClearPackageList( void ){ ListView_DeleteAllItems( PackageListView ); }
     void UpdatePackageList( void );
 
@@ -210,7 +211,7 @@ class AppWindowMaker: public WTK::MainWindowMaker
     pkgProgressMeter *AttachedProgressMeter;
     HFONT DefaultFont;
 
-    HWND PackageTreeView;
+    static HWND PackageTreeView;
     void InitPackageTreeView( void );
 
     HWND PackageListView;

--- a/src/pkgbase.h
+++ b/src/pkgbase.h
@@ -151,12 +151,28 @@ class pkgXmlNode : public TiXmlElement
       return this ? strcmp( GetName(), tagname ) == 0 : false;
     }
 
+    /* Methods to determine which packages should be displayed
+     * in the package list pane of the GUI client.
+     */
+    inline bool IsVisibleGroupMember();
+    inline bool IsVisibleClass();
+
     /* Methods for retrieving the system root management records
      * for a specified installed subsystem.
      */
     pkgXmlNode *GetSysRoot( const char* );
     pkgXmlNode *GetInstallationRecord( const char* );
 
+    /* Methods for mapping the package group hierarchy.
+     */
+    inline void SetPackageGroupHierarchyMapper();
+    inline void MapPackageGroupHierarchy( pkgXmlNode* );
+
+    /* Type definition for a helper function, which must be assigned
+     * to the package group hierarchy mapper, in order to enable it.
+     */
+    typedef void (*GroupHierarchyMapper)( pkgXmlNode*, pkgXmlNode* );
+
     /* The following pair of methods provide an iterator
      * for enumerating the contained nodes, within the owner,
      * which themselves exhibit a specified tagname.
@@ -195,6 +211,11 @@ class pkgXmlNode : public TiXmlElement
      */
     int InvokeScript( int, const char* );
     int DispatchScript( int, const char*, const char*, pkgXmlNode* );
+
+    /* Hook via which the requisite helper function is attached
+     * to the package group hierarchy mapper.
+     */
+    static GroupHierarchyMapper PackageGroupHierarchyMapper;
 };
 
 enum { to_remove = 0, to_install, selection_types };

--- a/src/pkgbind.cpp
+++ b/src/pkgbind.cpp
@@ -83,6 +83,21 @@ pkgRepository::pkgRepository
 owner( client ), dbase( db ), repository( ref ), force_update( mode ),
 expected_issue( value_assumed_new ){}
 
+/* Provide the hook, via which the package group hierarchy builder
+ * may gain access to its configuration data, during loading of the
+ * package list files.
+ */
+pkgXmlNode::GroupHierarchyMapper
+pkgXmlNode::PackageGroupHierarchyMapper = NULL;
+inline void pkgXmlNode::MapPackageGroupHierarchy( pkgXmlNode *catalogue )
+{
+  /* This is a no-op, unless the client attaches a handler to the
+   * hook, before invoking the package list loader.
+   */
+  if( PackageGroupHierarchyMapper != NULL )
+    PackageGroupHierarchyMapper( this, catalogue );
+}
+
 void pkgRepository::GetPackageList( const char *dname )
 {
   /* Helper to retrieve and recursively process a named package list.
@@ -179,7 +194,11 @@ void pkgRepository::GetPackageList( const char *dname )
 	pkgXmlNode *catalogue, *pkglist;
 	if( (catalogue = merge.GetRoot()) != NULL )
 	{
-	  /* ...read it, selecting each of the "package-collection"
+	  /* ...map any package group hierarchy which it specifies...
+	   */
+	  dbase->MapPackageGroupHierarchy( catalogue );
+
+	  /* ...then read it, selecting each of the "package-collection"
 	   * records contained within it...
 	   */
 	  pkglist = catalogue->FindFirstAssociate( package_collection_key );

--- a/src/pkgdata.cpp
+++ b/src/pkgdata.cpp
@@ -1328,6 +1328,66 @@ long AppWindowMaker::OnNotify( WPARAM client_id, LPARAM data )
 	  SelectPackageAction( LVHT_ONITEMICON );
       }
       break;
+
+    /* We also need to consider notifications from the tree view...
+     */
+    case ID_PACKAGE_TREEVIEW:
+      if( ((NMHDR *)(data))->code == TVN_SELCHANGED )
+      {
+	/* ...from which we are interested only in notifications
+	 * that the user has changed the package group selection.
+	 *
+	 * First, we ensure that any children of the selected
+	 * package group are made visible.
+	 */
+	TreeView_Expand( PackageTreeView,
+	    ((NMTREEVIEW *)(data))->itemNew.hItem, TVE_EXPAND
+	  );
+
+	/* We then clear out the previous content of the list view
+	 * pane, and reconstruct it with new content, as determined
+	 * by the new package group selection...
+	 */
+	ClearPackageList();
+	UpdatePackageList();
+
+	/* ...and reapply any scheduled action markers, which may
+	 * be applicable.
+	 */
+	MarkSchedule( pkgData->Schedule() );
+
+	/* Finally, provided the previous selection is not an
+	 * ancestor of the current, we may collapse any visible
+	 * subtree descending from the previous.
+	 *
+	 * FIXME: We may wish to avoid collapsing any subtree
+	 * which was designated as "expanded", in the original
+	 * group hierarchy specification.  We may also wish to
+	 * provide a user option, to disable this feature.
+	 */
+	bool may_fold = true;
+	HTREEITEM prev = ((NMTREEVIEW *)(data))->itemNew.hItem;
+	while( may_fold && (prev != NULL) )
+	{ if( prev == ((NMTREEVIEW *)(data))->itemOld.hItem )
+	    /*
+	     * Previous selection IS an ancestor of current;
+	     * we must not collapse it.
+	     */
+	    may_fold = false;
+
+	  else
+	    /* Continue tracing ancestry, back to the root.
+	     */
+	    prev = TreeView_GetParent( PackageTreeView, prev );
+	}
+	if( may_fold )
+	  /*
+	   * Previous selection may be collapsed; do so.
+	   */
+	  TreeView_Expand( PackageTreeView,
+	      ((NMTREEVIEW *)(data))->itemOld.hItem, TVE_COLLAPSE
+	    );
+      }
   }
   /* Otherwise, this return causes any other notifiable events
    * to be simply ignored, (as they were by the original stub).

--- a/src/pkglist.cpp
+++ b/src/pkglist.cpp
@@ -113,8 +113,24 @@ void AppWindowMaker::UpdatePackageList()
   pkgDirectory *dir = pkgData->CatalogueAllPackages();
   dir->InOrder( &PackageList );
   delete dir;
+
+  /* Force a redraw of the application window, to ensure that the
+   * data pane content remains synchronised.
+   */
+  InvalidateRect( AppWindow, NULL, FALSE );
+  UpdateWindow( AppWindow );
 }
 
+inline bool pkgXmlNode::IsVisibleGroupMember()
+{
+  /* Hook invoked before adding a package reference to the package list,
+   * to ensure that it represents a member of the current package group.
+   */
+  return AppWindowMaker::IsPackageGroupAffiliate( this );
+}
+
+inline bool pkgXmlNode::IsVisibleClass(){ return true; }
+
 static char *pkgGetTitle( pkgXmlNode *pkg, const pkgXmlNode *xml_root )
 {
   /* A private helper method, to retrieve the title attribute
@@ -421,7 +437,7 @@ void pkgListViewMaker::Dispatch( pkgXmlNode *package )
    * dispatching the content of the directory to the display service,
    * (which, in this case, populates the list view window pane).
    */
-  if( package->IsElementOfType( package_key ) )
+  if( package->IsElementOfType( package_key ) && package->IsVisibleGroupMember() )
   {
     /* Assemble the package name into the list view record block.
      */
@@ -445,7 +461,7 @@ void pkgListViewMaker::Dispatch( pkgXmlNode *package )
        */
       InsertItem( package, (char *)("") );
   }
-  else if( package->IsElementOfType( component_key ) )
+  else if( package->IsElementOfType( component_key ) && package->IsVisibleClass() )
   {
     /* Handle the recursive calls for the component sub-directory,
      * inheriting the package name entry from the original package

--- a/src/pkgtree.cpp
+++ b/src/pkgtree.cpp
@@ -4,7 +4,7 @@
  * $Id$
  *
  * Written by Keith Marshall <[e-mail]>
- * Copyright (C) 2012, MinGW.org Project
+ * Copyright (C) 2012, 2013, MinGW.org Project
  *
  *
  * Implementation of the methods for the pkgTreeViewMaker class, and
@@ -26,6 +26,8 @@
  * arising from the use of this software.
  *
  */
+#define _WIN32_IE 0x0400
+
 #include "guimain.h"
 #include "pkgbase.h"
 #include "pkgkeys.h"
@@ -36,9 +38,186 @@ static const char *package_group_all = "All Packages";
 /* The following are candidates for inclusion in "pkgkeys";
  * for now, we may keep them as local defines.
  */
+static const char *select_key = "select";
 static const char *expand_key = "expand";
 static const char *value_true = "true";
 
+static inline
+pkgXmlNode *is_existing_group( pkgXmlNode *dbase, const char *name )
+{
+  /* Helper to check for prior existence of a specified group name,
+   * at a specified level within the XML representation of the package
+   * group hierarchy, so we may avoid adding redundant duplicates.
+   */
+  while( dbase != NULL )
+  {
+    /* We haven't yet considered all XML database entries, at the
+     * requisite level; check the current reference entry...
+     */
+    if( safe_strcmp( strcasecmp, name, dbase->GetPropVal( name_key, NULL )) )
+      /*
+       * ...returning it immediately, if it is a named duplicate of
+       * the entry we are seeking to add.
+       */
+      return dbase;
+
+    /* When no duplicate found yet, move on to consider the next
+     * entry at the requisite XML database level, if any.
+     */
+    dbase = dbase->FindNextAssociate( package_group_key );
+  }
+  /* If we get to here, then no duplicate was found; the database
+   * reference must have become NULL, which we return.
+   */
+  return dbase;
+}
+
+static void
+map_package_group_hierarchy_recursive( pkgXmlNode *dbase, pkgXmlNode *group )
+{
+  /* Helper to recursively reconstruct an in-core image of the XML
+   * structure of the package list hierarchy, as it is specified in
+   * the package list read from external storage.
+   */
+  const char *name = group->GetPropVal( name_key, value_unknown );
+  pkgXmlNode *ref, *map = dbase->FindFirstAssociate( package_group_key ); 
+  if( (ref = is_existing_group( map, name )) == NULL )
+  {
+    /* The group name we are seeking to add doesn't yet appear at
+     * the requisite level within the in-core XML image; construct
+     * a new record, comprising the relevant data as represented
+     * in the external database...
+     */
+    ref = new pkgXmlNode( package_group_key );
+    ref->SetAttribute( name_key, name );
+    if( (name = group->GetPropVal( expand_key, NULL )) != NULL )
+      ref->SetAttribute( expand_key, name );
+
+    /* ...and attach it as the last sibling of any existing
+     * in-core records at the requisite level.
+     */
+    ref = (pkgXmlNode *)(dbase->LinkEndChild( ref ));
+  }
+  /* Recurse...
+   */
+  group = group->FindFirstAssociate( package_group_key );
+  while( group != NULL )
+  {
+    /* ...to capture any newly specified children of this group,
+     * regardless of whether the group already existed, or has
+     * just been added.
+     */
+    map_package_group_hierarchy_recursive( ref, group );
+    group = group->FindNextAssociate( package_group_key );
+  }
+}
+
+static void
+map_package_group_hierarchy( pkgXmlNode *dbase, pkgXmlNode *catalogue )
+{
+  /* Helper to kick-start the recursive mapping of external XML
+   * records into the in-core package group hierarchy image.
+   */
+  const char *group_hierarchy_key = "package-group-hierarchy";
+  if( (catalogue = catalogue->FindFirstAssociate( group_hierarchy_key )) != NULL )
+  {
+    /* We found a package group hierarchy specification...
+     */
+    dbase = dbase->FindFirstAssociate( package_group_key );
+    do { pkgXmlNode *group = catalogue->FindFirstAssociate( package_group_key );
+	  while( group != NULL )
+	  {
+	    /* ...recursively map each top level package group
+	     * which is specified within it...
+	     */
+	    map_package_group_hierarchy_recursive( dbase, group );
+	    group = group->FindNextAssociate( package_group_key );
+	  }
+	  /* ...and repeat for any other package group hierarchy
+	   * specifications we may encounter.
+	   */
+	  catalogue = catalogue->FindNextAssociate( group_hierarchy_key );
+       } while( catalogue != NULL );
+  }
+}
+
+static void
+load_package_group_hierarchy( HWND display, HTREEITEM parent, pkgXmlNode *group )
+{
+  /* Helper to load the package group hierarchy from it's in-core XML
+   * database representation, into a Windows tree view control.
+   */
+  TVINSERTSTRUCT ref;
+
+  /* Establish initial state for the tree view item insertion control.
+   */
+  ref.hParent = parent;
+  ref.item.mask = TVIF_TEXT | TVIF_CHILDREN;
+  ref.hInsertAfter = TVI_FIRST;
+
+  do { /* For each package group specified at the current level in the
+	* package group hierarchy, retrieve its name from the XML record...
+	*/
+       pkgXmlNode *first_child = group->FindFirstAssociate( package_group_key );
+       ref.item.pszText = (char *)(group->GetPropVal( name_key, value_unknown ));
+       /*
+	* ...note whether any descendants are to be specified...
+	*/
+       ref.item.cChildren = (first_child == NULL) ? 0 : 1;
+       /*
+	* ...and add a corresponding entry to the tree view.
+	*/
+       ref.hInsertAfter = TreeView_InsertItem( display, &ref );
+
+       /* Check if the current group is to be made the initial selection,
+	* when the tree view is first displayed; the last entry so marked
+	* will become the actual initial selection.  (Note that, to ensure
+	* that this setting cannot be abused by package maintainers, it is
+	* defined internally by mingw-get; it is not propagated from any
+	* external XML resource).
+	*/
+       const char *option = group->GetPropVal( select_key, NULL );
+       if( (option != NULL) && (strcmp( option, value_true ) == 0) )
+	 /*
+	  * Make any group, which marked with the "select" attribute, the
+	  * active selection; (note that this selection may be superseded,
+	  * should another similarly marked group be encountered later).
+	  */
+	 TreeView_SelectItem( display, ref.hInsertAfter );
+
+       /* Any descendants specified, for the current group, must be
+	* processed recursively...
+	*/
+       if( first_child != NULL )
+       {
+	 /* There is at least one generation of children, of the current
+	  * tree view entry; check if this entry should be expanded, so as
+	  * to make its children visible in the initial view, recursively
+	  * evaluate to identify further generations of descendants...
+	  */
+	 option = group->GetPropVal( expand_key, NULL );
+	 load_package_group_hierarchy( display, ref.hInsertAfter, first_child );
+	 if( (option != NULL) && (strcmp( option, value_true ) == 0) )
+	   /*
+	    * ...and expand to the requested level of visibility.
+	    */
+	   TreeView_Expand( display, ref.hInsertAfter, TVE_EXPAND );
+       }
+       /* Repeat for any other package groups which may be specified at
+	* the current level within the hierarchy.
+	*/
+       group = group->FindNextAssociate( package_group_key );
+     } while( group != NULL );
+}
+
+inline void pkgXmlNode::SetPackageGroupHierarchyMapper()
+{
+  /* Method to assign the preceding helper, as the active handler
+   * for pkgXmlNode::MapPackageGroupHierarchy().
+   */
+  PackageGroupHierarchyMapper = map_package_group_hierarchy;
+}
+
 EXTERN_C void pkgInitCategoryTreeGraft( pkgXmlNode *root )
 {
   /* Helper function to create the graft point, at which the
@@ -47,7 +226,10 @@ EXTERN_C void pkgInitCategoryTreeGraft( pkgXmlNode *root )
    * of the XML database image.
    */
   pkgXmlNode *pkgtree = new pkgXmlNode( package_group_key );
+
+  pkgtree->SetPackageGroupHierarchyMapper();
   pkgtree->SetAttribute( name_key, package_group_all );
+  pkgtree->SetAttribute( select_key, value_true );
   pkgtree->SetAttribute( expand_key, value_true );
   root->LinkEndChild( pkgtree );
 }
@@ -57,8 +239,8 @@ void AppWindowMaker::InitPackageTreeView()
   /* Create and initialise a TreeView window, in which to present
    * the package group hierarchy display...
    */
-  PackageTreeView = CreateWindow( WC_TREEVIEW, NULL,
-      WS_VISIBLE | WS_BORDER | WS_CHILD, 0, 0, 0, 0,
+  PackageTreeView = CreateWindow( WC_TREEVIEW, NULL, WS_VISIBLE |
+      WS_BORDER | WS_CHILD | TVS_FULLROWSELECT | TVS_SHOWSELALWAYS, 0, 0, 0, 0,
       AppWindow, (HMENU)(ID_PACKAGE_TREEVIEW),
       AppInstance, NULL
     );
@@ -67,14 +249,7 @@ void AppWindowMaker::InitPackageTreeView()
    * displaying the category headings within the tree view.
    */
   SendMessage( PackageTreeView, WM_SETFONT, (WPARAM)(DefaultFont), TRUE );
-
-  /* Initialise a tree view insertion structure, to the appropriate
-   * state for assignment of the root entry in the tree view.
-   */
-  TVINSERTSTRUCT cat;
-  cat.hParent = TVI_ROOT;
-  cat.item.mask = TVIF_TEXT;
-  cat.hInsertAfter = TVI_ROOT;
+  SendMessage( PackageTreeView, TVM_SETINDENT, 0, 0 );
 
   /* Retrieve the root category entry, if any, as recorded in
    * the package XML database, for assignment as the root entry
@@ -87,23 +262,181 @@ void AppWindowMaker::InitPackageTreeView()
      * create an artificial root entry, (which will then become
      * the sole entry in our tree view).
      */
-    cat.item.pszText = (char *)(package_group_all);
-    TreeView_InsertItem( PackageTreeView, &cat );
+    TVINSERTSTRUCT entry;
+    entry.hParent = TVI_ROOT;
+    entry.item.mask = TVIF_TEXT | TVIF_CHILDREN;
+    entry.item.pszText = (char *)(package_group_all);
+    entry.hInsertAfter = TVI_ROOT;
+    entry.item.cChildren = 0;
+
+    /* Map this sole entry into the tree view pane.
+     */
+    TreeView_InsertItem( PackageTreeView, &entry );
   }
-  else while( tree != NULL )
-  {
+  else
     /* The package group hierarchy has been incorporated into
      * the in-core image of the XML database; create a windows
-     * "tree view" representation of its structure.
-     *
-     * FIXME: this currently creates only the root of the tree;
-     * we need to walk the XML hierarchy, and add an additional
-     * tree view node for each element found.
+     * "tree view", into which we load a representation of the
+     * structure of this hierarchy.
+     */
+    load_package_group_hierarchy( PackageTreeView, TVI_ROOT, tree );
+}
+
+static bool is_child_affiliate( HWND tree, TVITEM *ref, const char *name )
+{
+  /* Helper method to recursively traverse a subtree of the
+   * package group hierarchy, to check if a specified package
+   * group name matches any descendant of the current group
+   * selection...
+   */
+  HTREEITEM mark = ref->hItem;
+  do { if(  TreeView_GetItem( tree, ref )
+       &&  (strcasecmp( name, ref->pszText ) == 0)  )
+	 /*
+	  * ...immediately promoting any such match as an
+	  * affiliate of the current selection...
+	  */
+	 return true;
+
+       /* ...otherwise, recursively traverse each child
+	* subtree, at the current level...
+	*/
+       if( ((ref->hItem = TreeView_GetChild( tree, mark )) != NULL)
+       &&    is_child_affiliate( tree, ref, name )		     )
+	 /*
+	  * ...again, immediately promoting any match...
+	  */
+	 return true;
+
+       /* ...or otherwise, rewind to the marked match point,
+	* whence we repeat the search into its next immediate
+	* sibling subtree, (if any).
+	*/
+       mark = ref->hItem = TreeView_GetNextSibling( tree, mark );
+     } while( mark != NULL );
+
+  /* If we get to here, the specified package group name is NOT
+   * an affiliate of any descendant, at the current match level,
+   * of the currently selected package group.
+   */
+  return false;
+}
+
+static inline bool is_affiliated( HWND tree, const char *name )
+{
+  /* Helper to initiate a determination if a specified package
+   * group name is an affiliate of the currently selected package
+   * group; i.e. if it matches the name of the selected group, or
+   * any of its descendants.
+   */
+  TVITEM ref;
+  if(  ((ref.hItem = TreeView_GetSelection( tree )) == NULL)
+  ||    (ref.hItem == TreeView_GetRoot( tree ))		      )
+    /*
+     * Before proceeding further, we may note that ANY group name
+     * is considered to be IMPLICITLY matched, at the root of the
+     * package group tree.
+     */
+    return true;
+
+  /* At any level in the hierarchy, other than the root, the group
+   * name MUST be matched EXPLICITLY; note that...
+   */
+  if( name == NULL )
+    /* ...an unspecified name can never satisfy this criterion.
      */
-    cat.item.pszText = (char *)(tree->GetPropVal( name_key, value_unknown ));
-    HTREEITEM top = TreeView_InsertItem( PackageTreeView, &cat );
-    tree = tree->FindNextAssociate( package_group_key );
+    return false;
+
+  /* As a basis for comparison, we must provide a working buffer
+   * into which we may retrieve names from the tree view...
+   */
+  char ref_text[ref.cchTextMax = 1 + strlen( name )];
+
+  /* ...beginning with the currently selected tree view item...
+   */
+  ref.mask = TVIF_TEXT;
+  ref.pszText = ref_text;
+  if( TreeView_GetItem( tree, &ref ) && (strcasecmp( name, ref_text ) == 0) )
+    /*
+     * ...and returning immediately, when it is found to match.
+     */
+    return true;
+
+  /* When the selected item doesn't match, we also look for a
+   * possible match among its descendants, if any...
+   */
+  if( (ref.hItem = TreeView_GetChild( tree, ref.hItem )) != NULL )
+    /*
+     * ...which we also promote as a match.
+     */
+    return is_child_affiliate( tree, &ref, name );
+
+  /* If we get to here, the selected tree item doesn't match;
+   * nor does it have any descendants among which a possible
+   * match might be found.
+   */
+  return false;
+}
+
+/* We use static methods to reference the tree view class object;
+ * thus, we must define a static reference pointer.  (Note that its
+ * initial assignment to NULL will be updated, when the tree view
+ * class object is instantiated).
+ */
+HWND AppWindowMaker::PackageTreeView = NULL;
+bool AppWindowMaker::IsPackageGroupAffiliate( pkgXmlNode *package )
+{
+  /* Method to determine if a particular pkgXmlNode object is
+   * an affiliate of the currently selected package group, as
+   * specified in the tree view of the package group hierarchy.
+   * Note that this must be a static method, so that it may be
+   * invoked by methods of the pkgXmlNode object, without any
+   * requirement for that object to hold a reference to the
+   * AppWindowMaker object which owns the tree view.
+   */
+  static const char *group_key = "group";
+  static const char *affiliate_key = "affiliate";
+
+  /* An affiliation may be declared at any level, between the
+   * root of the XML document, and the pkgXmlNode specifications
+   * to which it applies; save an end-point reference, so that
+   * we may avoid overrunning the document root, as we walk
+   * back through the document...
+   */
+  pkgXmlNode *top = package->GetDocumentRoot();
+  while( package != top )
+  {
+    /* ...in search of applicable "affiliate" declarations.
+     */
+    pkgXmlNode *group = package->FindFirstAssociate( affiliate_key );
+    while( group != NULL )
+    {
+      /* For each declared affiliation, check if it matches the
+       * current selection in the package group hierarchy...
+       */
+      const char *group_name = group->GetPropVal( group_key, NULL );
+      if( is_affiliated( PackageTreeView, group_name ) )
+	/*
+	 * ...immediately returning any successful match; (just one
+	 * positive match is sufficient to determine affiliation).
+	 */
+	return true;
+
+      /* When no affiliation has yet been identified, repeat the
+       * check for any further "affiliate" declarations at the
+       * current level within the XML document hierarchy...
+       */
+      group = group->FindNextAssociate( group_key );
+    }
+    /* ...and at enclosing levels, as may be necessary.
+     */
+    package = package->GetParent();
   }
+  /* If we get to here, then we found no "affiliate" declarations to
+   * be evaluated; only a root match in the package group hierarchy
+   * is sufficient, to determine affiliation.
+   */
+  return is_affiliated( PackageTreeView, NULL );
 }
 
 /* $RCSfile$: end of file */