/******************************************************************************
             Copyright (c) 1999 Unigraphics Solutions, Inc.
                       Unpublished - All Rights Reserved

*******************************************************************************/
/*
The example shown below covers a wide range of the UG/Manager
UG/Open APIs. Its purpose is to find out the contents of all your
folders, starting at your Home folder. All your folders, parts, part
revisions, master part files, non-master part files, and dependent files
are printed. The information is printed in an indented form, so that
you can see at a glance the contents of a particular folder. For
example:
Folder: Home
    Part: engine
Rev: A - Type: master
    Folder: screws
Part: flat_head
    Rev: A - Type: master
    Rev: A - Type: specification, Name: dwg001
    Rev: A - Type: manifestation, Name: NCtool001
Part: cross_head
    Rev: B - Type: master


*/

#include <stdio.h>
#include <stdlib.h>
#include <uf.h>
#include <uf_ugmgr.h>
#define CHECK( func_ ) \
    ifail = (func_); \
    if ( ifail != 0 ) {\
        printf("ERROR: %s returned %d", # func_, ifail ); \
        return ifail; }
#define PRINT( content_ ) \
    { int ii; \
for (ii=0; ii<indent_level; ii++) \
        { printf("  "); } \
        printf content_ ; \
        printf("\n"); }
static int list_in_folder(UF_UGMGR_tag_t folder);
static int list_in_part(UF_UGMGR_tag_t part);
static int indent_level = 0;
/*---------------------------------------------------------------*/
int main (int argc, char *argv[])
{
  int               ifail = 0;
  UF_UGMGR_tag_t    root;
  ifail = UF_UGMGR_initialize(argc,(const char**)argv);
  if (ifail != 0)
  {
    printf("ERROR: Failed to initialize with error code %d",
 ifail);
    exit(1);
  }
  ifail = UF_UGMGR_ask_root_folder(&root);
  if(ifail == 0)
  {
    ifail = list_in_folder(root);
  }
  else
  {
    exit(1);
  }
  UF_UGMGR_terminate();
  return 0;
}
/*---------------------------------------------------------------*/
static int  list_in_folder(UF_UGMGR_tag_t folder)
{
  int                      ifail = 0;
  char                     folder_name[UF_UGMGR_NAME_SIZE + 1];
  int                      i;
  int                      count;
  UF_UGMGR_tag_t*          folder_contents;
  UF_UGMGR_object_type_t   obj_type;
  if (folder == UF_UGMGR_null_tag)
  {
    return ifail;
  }
  CHECK(UF_UGMGR_ask_folder_name(folder, folder_name));
  PRINT(("Folder: %s", folder_name));
indent_level++;
  CHECK(UF_UGMGR_list_folder_contents(folder, &count,
&folder_contents));
  for(i=0; i<count; i++)
  {
    CHECK(UF_UGMGR_ask_object_type(folder_contents[i], &obj_type));
    switch(obj_type)
    {
      case UF_UGMGR_type_folder :
        CHECK(list_in_folder(folder_contents[i]));
        break;
      case UF_UGMGR_type_part :
        CHECK(list_in_part(folder_contents[i]));
        break;
      default :
        printf("Invalid object type found");
        break;
    }
  }
  UF_free( folder_contents );
  indent_level--;
  return ifail;
}
/*---------------------------------------------------------------*/
static int  list_in_part(UF_UGMGR_tag_t part)
{
  int ifail = 0;
  char             part_name[MAX_FSPEC_SIZE + 1];
  int              i, j, k;
  int              count;
  int              dep_count;
  char**           names;
  int              rev_count;
  UF_UGMGR_tag_t*  revisions;
  char             revision_id[UF_UGMGR_NAME_SIZE + 1];
  char             part_number[UF_UGMGR_NAME_SIZE + 1];
  char**           file_types;
  char**           file_names;
  if (part == UF_UGMGR_null_tag)
  {
    return ifail;
  }
  CHECK(UF_UGMGR_ask_part_number(part, part_number));
  PRINT(("Part: %s", part_number));
  indent_level++;
  CHECK(UF_UGMGR_list_part_revisions(part, &rev_count,
        &revisions));
  for(j=0; j<rev_count; j++)
  {
    CHECK(UF_UGMGR_ask_part_revision_id(revisions[j],
          revision_id));
    /** listing dependent files for master **/
    CHECK(UF_UGMGR_encode_part_filename (part_number, revision_id,
  "" , "", part_name));
    PRINT(("Rev.: %s - Type: %s", revision_id, "master"));
    indent_level++;

    CHECK(UF_UGMGR_ask_dependent_files(part_name, &dep_count,
          &names));
    for(k=0; k<dep_count; k++)
    {
      PRINT(("Dependent files: %s", names[k]));
    }
    indent_level--;
    UF_free_string_array(dep_count, names);
    CHECK(UF_UGMGR_list_part_rev_files(revisions[j], &count,
          &file_types, &file_names));
    for(i=0; i<count;i++)
    {
      CHECK(UF_UGMGR_encode_part_filename (part_number,
     revision_id,
     file_types[i],
     file_names[i],
     part_name));
      PRINT(("Rev.: %s - Type: %s, Name: %s", revision_id,
   file_types[i], file_names[i]));
      indent_level++;
      CHECK(UF_UGMGR_ask_dependent_files(part_name, &dep_count,
            &names));
      for(k=0; k<dep_count; k++)
      {
        PRINT(("Dependent files: %s", names[k]));
      }
      indent_level--;
      UF_free_string_array(dep_count, names);
    }
    UF_free_string_array(count, file_types);
    UF_free_string_array(count, file_names);
  }
  indent_level--;
  UF_free(revisions);
  return ifail;
}