create or replace package body htmltree
as

/*****************************************************************************************
Purpose         HTML Tree Navigator

Usage

Remarks         required GIFs


Revision history
When        Who                                Construct
  Revision  What
------------------------------------------------------------------------------------------
$REVISION_HISTORY$
16-mar-2001   Lucas Jellema                     
  3.7         Filter carriage returns from Display labels of nodes 
09-mar-2001   Lucas Jellema                     
  3.6         - take out hardcode references of /odwa_images/ 
06-mar-2001   Lucas Jellema                     
  3.5         - inflate bottom node does not result in duplicate nodes anymore 
09-feb-2001   Lucas Jellema                     
  3.4         - style definition corrected: double colon changed in single colon 
26-jan-2001   Lucas Jellema                     
  3.3         fixed error: outcommented PL/SQL Code corrupted JavaScript code 
26-jan-2001   Lucas Jellema                     
  3.2         - do something about hard-coded image path '||g_image_path||'
              : added a call to ODWAPREF in package body initialization
              this is NOT proper for a true reusable component; however, to make the release date of  ODWA 6i, is it pragmatical. We need to find a more generic solution: HTMLTREE should not be dependent on ODWA objects
               
26-jan-2001   Lucas Jellema                     
  3.1         - restore js_refresh_tree
              - restore the reload node functions 
25-jan-2001   Lucas Jellema                     
  3.0         - add STYLE to tree frame
              - display reload node image for selected node when appropriate 
10-nov-2000   Lucas Jellema
  2.6         removed all external dependencies (except HTP and HTF)
08-nov-2000   Lucas Jellema
  2.5         reloadNode option added (to refresh an inflateable node)
              hideNode option added (to hide a node/branch to save memory/speed up the tree)
15-sep-2000   Lucas Jellema
  2.4         procedure draw_tree: the first node should have the firstopennode image instead of the openFolderImage
28-aug-2000   Lucas Jellema
  2.3         New procedure draw_tree
              (limited) Support for Server Side tree-construction
11-aug-2000   Lucas Jellema
  2.2         Support refreshTree()
              Fixed small problem with inflation giving too many folderTree members
10-aug-2000   Lucas Jellema
  2.1         - made generic; no hard-coded frame waSelector in write_inflate_code

27-jul-2000 Lucas Jellema
2.0         many many changes to make the code more generic, robust and efficient
added some comments
function getParentNodeAbsolute and getParentNodeRelative
better support for node inflation

To Do:
----------
- self contained (no outgoing dependencies)
- more comments in code
- strip out things we do not use at all
- allow tree-deflation (return to bare tree to clear browser memory
- get/set marks/targets
- place nodesTree in FRAMESET (window level) instead of one of the frames?
24-jul-2000 Lucas Jellema
1.9         - made generic; no hard-coded frame names
- support for node inflation

10-jun-2000 Lucas Jellema
  1.8       changed the set define off to set define on at the end of this script (it caused installation to fail)
09-jun-2000 Lucas Jellema
  1.7       writeNode: highlighted node is made BOLD; no longer do we use the yellow highlighting
08-jun-2000 Lucas Jellema
  1.6       Alt text for collapse and expand
            Use index properly for 'click on element' and set selectedIdx
07-jun-2000 Lucas Jellema
  1.5       Collapse/Expand did not work yet
07-jun-2000 Lucas Jellema
  1.4       Better graphics, less HTML tables (just one table), support for LastLeaf
            Support for Collapse/Expand All
            Support for highlighting the selected element
            Questions:
            - is collapse/expand useful
            - is highlighting not too bad for performance
06-jun-2000 Lucas Jellema
  1.3       Be smart about opening and closing nodes (improve performance)
06-jun-2000 Lucas Jellema
  1.2       Use function showPalette in onClick event instead of URL in name
            Set SelectedIdx and show selected element in yellow (but only after the tree
             is redrawn for open or close folder)
06-jun-2000 Lucas Jellema
  1.1       Use new graphics for Node and Leaf
02-jun-2000 Lucas Jellema
  1.0       Creation based on WebDB Edit Module Screen
            (http://NLG0552.nl.oracle.com/WebDB/WEBDB22.wwv_builder.show?p_module_id=1007430466&p_version=2&p_save_version=2&p_mode=EDIT)
2.1
- made generic; no hard-coded frame waSelector in write_inflate_code
1.9
- made generic; no hard-coded frame names
- support for node inflation
*****************************************************************************************/

--
-- private constants
--
REVISION_LABEL        constant varchar2(30) := '$x.y::3.7     $';
PACKAGE_NAME          constant varchar2(30) := 'htmltree';

g_image_path    varchar2(500);

g_col_levels    number(3)    :=15; -- the maximum levels in the tree

g_codeFrameName varchar2(200); -- the frame that contains the Tree JavaScript
g_treeFrameName   varchar2(200); -- name of the frame that contains the Tree (e.g. '||g_treeFrameName||')
g_treeFramePath   varchar2(200); -- the frame (full path) that contains the Tree (e.g. top.selector.'||g_treeFrameName||')
g_xchangeFramePath varchar2(500); -- the full frame path to the frame that contains the dataXchange procedure
type t_node_rec is record
( display_label    varchar2(500)
, additional       varchar2(500)
, node_level       number(4)
, has_children     boolean
, is_expanded      boolean
, last_leaf        boolean
, parent_index     number(10)
, next_sibling     number(10)  -- the next node or leaf at the same node_level; only required for nodes (elements with has_children = true)
, value            varchar2(500)
, is_inflatable    boolean
, is_inflated      boolean
, classification   varchar2(500)
);

type t_node_tbl is
table of t_node_rec
index by binary_integer;

g_node_tbl t_node_tbl;

-- function return the value assigned to a certain TAG
-- written in the following format: {TAG=value} or more generic:
-- <open separator> tag = value <close separator>
function get_tag_value
( p_string          in varchar2
, p_tag             in varchar2
, p_separator_open  in varchar2 default '{'
, p_separator_close in varchar2 default '}'
) return varchar2
is
 l_open_pos    number(10):= instr
                            ( replace(upper(p_string),' ','')
                            , p_separator_open||upper(p_tag)||'='
                            );
 l_value_start number(10);
 l_end_pos     number(10);
begin
 if l_open_pos > 0
 then
   l_value_start:= instr( replace(p_string,' ',''), '=', l_open_pos)+1;
   l_end_pos    := instr( p_string, p_separator_close, l_value_start+1);
   return substr( p_string, l_value_start, l_end_pos - l_value_start);
 else
   return '';
 end if;
end;  -- get_tag_value

function nbsp
( p_times in number default 1
) return varchar2
is
  l_string varchar2(4000);
begin
  for i in 1..p_times loop
    l_string:= l_string||chr(38)||'nbsp;';
  end loop;
  return l_string;
end; -- nbsp


function ifThenElse
( p_if   in boolean
, p_then in varchar2
, p_else in varchar2 default null
) return varchar2
is
begin
  if p_if
  then
    return p_then;
  else
    return p_else;
  end if;
end; -- ifThenElse

procedure reset_tbl
is
begin
  g_node_tbl.delete;
end;

procedure add_node
( p_display_label    in  varchar2
, p_node_level       in  number           -- start at 1 (root-level)
, p_has_children     in  boolean
, p_is_expanded      in  boolean          default false
, p_value            in  varchar2
, p_additional_label in  varchar2         default ''
, p_is_inflatable    in  boolean          default false
, p_classification   in  varchar2         default ''
) is
  l_ctr number(10):= g_node_tbl.count+1;

  function find_parent
  ( p_node_level in number
  ) return number
  is
  begin
    -- parent is the nearest node earlier in the tree with a higher level
    if p_node_level = 1
    then
      return null; -- l_ctr; -- when level 1, the node is its own parent
    end if;
    for i in 1..l_ctr-1 loop
      if g_node_tbl(l_ctr-i).node_level < p_node_level
      then
        return l_ctr-i;
      end if;
    end loop;
    return null;
  end; -- find_parent
begin
  g_node_tbl(l_ctr).display_label := replace(replace(replace( p_display_label, '"','\"'),chr(13),';'),chr(10),'');
  g_node_tbl(l_ctr).node_level    := p_node_level;
  g_node_tbl(l_ctr).has_children  := p_is_inflatable or p_has_children;
  g_node_tbl(l_ctr).is_expanded   := p_is_expanded;
  g_node_tbl(l_ctr).is_inflatable := p_is_inflatable;
  g_node_tbl(l_ctr).parent_index  := find_parent( p_node_level);
  if g_node_tbl(l_ctr).parent_index is not null
  then
    g_node_tbl(g_node_tbl(l_ctr).parent_index).has_children  := true;
  end if;
  g_node_tbl(l_ctr).value           := p_value;
  g_node_tbl(l_ctr).additional      := replace( p_additional_label, '"','\"');
  g_node_tbl(l_ctr).classification  := p_classification;
end; -- add_node

-- this procedure will walk through the tree table and set the has_children property
-- where it is not set while in fact children DO exist
procedure find_folder_nodes
is
  l_last_node_level number(3):=999;
begin
   -- this can be done much smarter and faster
   if g_node_tbl.count > 0
   then
       for i in reverse 1..g_node_tbl.count loop
          if g_node_tbl(i).node_level < l_last_node_level
          then
            -- find the first node with a higher level and set its property has_children property
            for j in reverse 1..i loop
              if g_node_tbl(j).node_level < g_node_tbl(i).node_level
              then
                g_node_tbl(j).has_children:= true;
                exit;
              end if;
            end loop;
          end if; -- g_node_tbl(i).node_level > l_last_node_level
          l_last_node_level:= g_node_tbl(i).node_level;
       end loop; -- i in reverse 1..g_node_tbl.count
   end if; -- g_node_tbl.count > 0
end; -- find_folder_nodes

function get_number_of_nodes
return number
is
begin
  return g_node_tbl.count;
end;

-- this procedure will write a JavaScript function that can be called to refresh the indicated node
-- in the tree; if the node itself cannot be refreshed, the next higher up that can will be refreshed
procedure js_refreshTree
( p_refresh_tree_level in number default null
) is
begin
  if p_refresh_tree_level is null
  then
    htp.p
    (' <SCRIPT LANGUAGE="JavaScript"><!--
  
  
    function refreshTree( nodeLevel)
    {
       if (nodeLevel == null || nodeLevel == 0)
        top.reloadNode();
       else
         top.reloadNodeIdx( top.getParentNodeRelative( top.selectedIdx, '||to_char(p_refresh_tree_level)||'));
    } // init()
   //--></SCRIPT>
    ');
  else
    htp.p
    (' <SCRIPT LANGUAGE="JavaScript"><!--
  
  
    function refreshTree()
    {
    ');
    if p_refresh_tree_level = 0
    then
      htp.p(' top.reloadNode();');
    else
      htp.p(' top.reloadNodeIdx( top.getParentNodeRelative( top.selectedIdx, '||to_char(p_refresh_tree_level)||'));');
    end if; -- p_refresh_tree_level = 0
    htp.p('    
    } // init()
      //--></SCRIPT>
    ');
  end if; -- p_refresh_tree_level is null
end; -- js_refreshTree


procedure draw_tree
is


type t_last_folder is
table of boolean
index by binary_integer;

l_last_folder t_last_folder;

openFolderImage        varchar2(200):= g_image_path||'nodeop2.jpg';
firstOpenFolderImage   varchar2(200):= g_image_path||'nodeop1.jpg';
closedFolderImage      varchar2(200):= g_image_path||'nodecl3.jpg';
firstClosedFolderImage varchar2(200):= g_image_path||'nodecl1.jpg';
leafImage              varchar2(200):= g_image_path||'leaf5.jpg';
lastLeafImage          varchar2(200):= g_image_path||'leaf7a.jpg';
folderLineImage        varchar2(200):= g_image_path||'leaf8.jpg';
expandAllImage         varchar2(200):= g_image_path||'expall.jpg';
collapseAllImage       varchar2(200):= g_image_path||'collall.jpg';


begin
  -- initialize l_last_folder
  for i in 1..g_col_levels loop
    l_last_folder(i):= false;
  end loop;
  htp.p( '<TABLE BGCOLOR=#FFFFFF border="0" cellspacing="0" cellpadding="0" COLS=15>');

  for i in 1..g_node_tbl.count loop
    htp.p('<tr>');

    -- node is last if g_node_tbl( g_node_tbl(i).next_sibling).node_level < g_node_tbl(i).node_Level

    for l in 2..g_node_tbl(i).node_level loop
      if l_last_folder(l-1) -- if the current folder at level l-1 is the last, no line drawn
      then
        htp.p
        ( '<td bgcolor=#FFFFFF width=20>'
        ||nbsp(1)
        ||'</td>'
        );
      else
        htp.p
        ( '<td align=right> '
        ||'<img src="'
        ||folderLineImage
        ||'"  width=20 height=24'
        ||'>'
        ||'</td>'
        );
      end if; -- l_lastFolder(l)
    end loop; -- l in 1..g_node_tbl(i).node_level
    htp.p
    ( '<td WIDTH=5 COLSPAN=1'
    ||'>'
    );
    if g_node_tbl(i).has_children -- IS FOLDER
    then
      -- the current folder is the last folder at this level
      -- if one of the following conditions is met
      l_last_Folder(g_node_tbl(i).node_level) :=
      g_node_tbl(i).last_leaf
      or
      g_node_tbl(i).next_sibling is null --last_leaf   -- the last one; that means: no line needs to be drawn at that level
      or
      g_node_tbl( g_node_tbl(i).next_sibling).node_level < g_node_tbl(i).node_Level
      ;
      if not g_node_tbl(i).is_expanded -- foldersNode is not opened; that means all its leafs and sub-nodes are invisible
                                           -- and can be bypassed; lets jump to the next sibling!
      then
        if g_node_tbl(i).next_Sibling is not null
        then
          null;
          -- gotoCtr= treeNodeConvertor[foldersNode.nextSibling]; //nextSibling refers to nodeIndex, treeNodeConvertor holds position in nodesTree-array for every nodeIndex
        else
          null;
           -- // if no nextSibling and level = 0, then jump to end of list
              --if (g_node_tbl(i).last_leaf) // will always be true I think
              --   gotoCtr = nodesTree.length+1;
        end if; -- g_node_tbl(i).nextSibling is not null
      end if; -- if not g_node_tbl(i).is_expanded
      -- for each level, a column is written (or, if the columns are empty anyway, one column with colspan=level is written)
      if g_node_tbl(i).is_expanded
      then
         htp.p
          ( '<img src="'
          ||ifThenElse
            ( i = 1    -- 2.4
            , firstOpenFolderImage
            , openFolderImage
            )
          ||'" width=20 height=24 border=noborder>'
          );
      else
         htp.p
          ( '<img src="'
          ||ifThenElse
            ( g_node_tbl(i).node_level = 0
            , firstClosedFolderImage
            , closedFolderImage
            )
          ||'" width=20 height=24 border=noborder>'
          );
      end if; -- is_expanded
  else -- IS LEAF
    htp.p
    ( '<img src="'
    ||ifThenElse
      ( g_node_tbl(i).last_leaf
        or
        g_node_tbl(i).next_sibling is null --last_leaf   -- the last one; that means: no line needs to be drawn at that level
        or
        g_node_tbl( g_node_tbl(i).next_sibling).node_level < g_node_tbl(i).node_Level
      , lastLeafImage
      , leafImage
      )
    ||'" width=20 height=24 border=noborder>'
    );
  end if; -- g_node_tbl(i).has_children -- IS FOLDER
    htp.p('</td>');
    htp.p
    ( '<td nowrap  valign=bottom '
    ||ifThenElse
      ( g_node_tbl(i).value = 'SELECTED'
      , 'bgcolor=#FFFF99'
      )
    ||' colspan=99'
--    ||' colspan='||to_char( (g_col_levels-g_node_tbl(i).node_level))
    ||' >'
    );
      htp.p
      ( '<font size=-1>'
      ||replace( g_node_tbl(i).display_label, '\"','"')
      ||'</font>'
      );
      htp.p('</td>');
      htp.p('</tr>');

  end loop; -- i in 1..g_node_tbl.count
  htp.p( '</TABLE>');
end; -- draw_tree

 -- write the tree-initialization statements (appendChild) for elements in g_node_tbl
 -- should be preceeded by one or more calls to add_node
 procedure populate_tree
 ( p_start_idx         in number default 0  -- where in nodesTree array; 0 means at the start
 , p_node_index_offset in number default 0  -- node index offset
 , p_frame_locator     in varchar2 default null -- if statements are included in other frame than which contains nodesTree and appendChild, the frame locator needs to be provided
 )  is

   type t_sibling_rec is
   record
   ( sibling_index number(10)
   );


   -- 1.3
   type t_sibling_tbl
   is table of t_sibling_rec
   index by binary_integer
   ;

   l_sibling_tbl t_sibling_tbl;
 begin
   -- 1.3
   -- first determine the value of g_node_tbl.next_sibling for all nodes (has_children = true)

   htp.p('  //function appendChild(index, name, level, isFolder, isOpen
  //   , value, additional, nextSibling, lastLeaf, inflatable, inflated )');
   for i in reverse 1..g_node_tbl.count loop
      -- now if has_children, find the the next sibling or higher level (level >= own level)
      --if g_node_tbl(i).has_children -- we really only need siblings for Nodes (not for leaf elements)
      --then
        -- find the index for the next node/leaf at the same or higher level
        for j in reverse 1..g_node_tbl(i).node_level loop
          if l_sibling_tbl.exists( j)
          then
            -- if the next sibling (remember: we treewalk in reverse order) at this node-level exists
            -- the we can assign the value of this sibling's index to the current node
            g_node_tbl(i).next_sibling := l_sibling_tbl( j ).sibling_index;

            exit;
          end if;
        end loop;
      --end if;
      -- all lower level sibling_indexes should be set to this one as well
      for j in g_node_tbl(i).node_level..g_col_levels loop
        l_sibling_tbl( j ).sibling_index:= i; -- the most recent next sibling at this level is i
      end loop; -- j
      if g_node_tbl(i).next_sibling is null -- should only happen to nodes at the end of the tree
                                            -- however, if this is just a subtree, the next sibling
                                            -- will be the next node in the supertree that this sub-tree
                                            -- is added to; only: we do not know the index
                                            -- value just after p_node_index_offset
      then
        g_node_tbl(i).last_leaf := true;
      else
        if g_node_tbl( g_node_tbl(i).next_sibling).node_level < g_node_tbl(i).node_level
        then
          g_node_tbl(i).last_leaf := true;
        end if;
      end if;
     htp.p
     ( p_frame_locator||'nodesTree['||to_char(p_start_idx + i-1)||'] = new '||p_frame_locator||'appendChild'
     ||' ("'||to_char(i+ p_node_index_offset)||'"'                                  -- index
     ||', "'||g_node_tbl(i).display_label||'"'           -- name
     ||', "'||to_char(g_node_tbl(i).node_level-1)||'"'   -- level
     ||', "'||ifThenElse( g_node_tbl(i).has_children, '1','0')||'"'  -- isFolder (has children)
     ||', "'||ifThenElse( (g_node_tbl(i).is_expanded), '1','0')||'"'  -- isOpen
     ||', "'||g_node_tbl(i).value||'"' -- 1.2
     ||', "'||g_node_tbl(i).additional||'"' -- 1.2
     ||', "'||to_char(g_node_tbl(i).next_sibling + p_node_index_offset)||'"' -- 1.3
     ||', "'||ifThenElse( g_node_tbl(i).last_leaf, '1','0')||'"'  -- lastLeaf
     ||', "'||ifThenElse( g_node_tbl(i).is_inflatable, '1','0')||'"'  -- InFlatable
     ||', "'||'0'||'"'  -- never initially InFlated
     ||', "'||g_node_tbl(i).classification||'"'
     ||');'
     );
   end loop; -- i in reverse 1..g_node_tbl.count loop
 end; -- populate_tree

procedure write_inflate_code
( p_node_index    in number
, p_num_of_nodes  in number
, p_frame_locator in varchar2 -- path to the frame that contains the nodesTree
, p_entry_point   in number   default null -- typically equal to p_node_index, although sometimes slightly beyond p_node_index
) is
begin
  g_codeFrameName   := p_frame_locator;
  -- from here on, this is generic again
  htp.htmlOpen;
  htp.headOpen;
  -- now write JS function
    htp.p
    ('
    <SCRIPT LANGUAGE="JavaScript1.1">

    <!-- Comment out script for old browsers
    <!--  to hide script contents from old browsers

   function inflateNode()
   {
    var idx = '||to_char(p_entry_point)||';
    var inflNode = '||to_char(p_node_index)||';
    var level=0;
    var previousSibling;

    '||g_codeFrameName||'makeWay( idx, '||htmltree.get_number_of_nodes
    ||');'
  );
    -- write all the appendChild statements
    htmltree.populate_tree
    ( p_start_idx         => p_entry_point + 1 --node_index+1
    , p_node_index_offset => p_num_of_nodes
    , p_frame_locator     => p_frame_locator
    );
/*
    for i in 1..htmltree.get_number_of_nodes loop
      htp.p('
      '||g_codeFrameName||'treeNodeConvertor['||to_char(p_num_of_nodes+i)||']= idx+'||to_char(i)||';'
      );
    end loop;
*/
    --// the node just before p_entry_point+1 that has the same level as the highest level
--    // node just added should get p_entry_point+1 as new nextSibling
    if htmltree.get_number_of_nodes = 0 -- no nodes written at all
    then  -- this node is not inflateable at all
          -- furthermore, is it really a folder? or did it have children already?
          -- if the next node has a level that is equal to or smaller than the current node's level, it is not a child and therefore
          -- the node is not a folder anymore!
      if p_entry_point < p_num_of_nodes-1
      then
          -- htp.p('
            -- 3.1  '||g_codeFrameName||'nodesTree[inflNode].inflatable = 0; -- on a next inflation perhaps there will be children!!
           --  ');
          htp.p('
            if ('||g_codeFrameName||'nodesTree[inflNode+1].level <= '||g_codeFrameName||'nodesTree[inflNode].level)
               '||g_codeFrameName||'nodesTree[inflNode].isFolder = 0;
          ');
      end if; -- not added at the end
    else
      -- code to set '||g_codeFrameName||'nodesTree[i].nextSibling
      -- for the new nodes, where it is null
      -- set it to nodesTree[ (idx -0 +1 + htmltree.get_number_of_nodes) ].index
      htp.p('
         for ( i=1; i< '||to_char(htmltree.get_number_of_nodes+1)||'; i++)
           '||g_codeFrameName||'treeNodeConvertor[i + '||to_char(p_num_of_nodes)||']='
           ||'i+'||to_char(p_entry_point)||' ;'
      );
/* commented out on 7 november 2000 - needs testing
      htp.p('
        level = '||g_codeFrameName||'nodesTree['||to_char(p_entry_point+1)||'].level;
        previousSibling = '||g_codeFrameName||'getParentNodeRelative( '||to_char(p_entry_point)||', 0); //start looking at entry point
        if (previousSibling != null)
           {
            '||g_codeFrameName||'nodesTree[ previousSibling].nextSibling = '||to_char(p_num_of_nodes+1)||';
           }
     ');
*/
      htp.p('
        '||g_codeFrameName||'nodesTree[inflNode].inflated = 1;
     ');
      if p_entry_point < p_num_of_nodes-1
      then
         htp.p('// now ensure that nextSibling refers to one of the nodes in the supertree
             //if it is currently null within the sub tree (if the sub tree is not added
             // at the end of the supertree of course
            for ( i= '||to_char(p_entry_point+1)||' ; i< '
            ||to_char( p_entry_point + htmltree.get_number_of_nodes + 1)
            ||'; i++)
             {
               if ('||g_codeFrameName||'nodesTree[i].nextSibling == "")
               {
                 if ( '||g_codeFrameName||'nodesTree['
                  ||to_char(p_entry_point + htmltree.get_number_of_nodes + 1)||'] != null)                  
                  {
                     '||g_codeFrameName||'nodesTree[i].nextSibling = '||g_codeFrameName||'nodesTree['
                    ||to_char(p_entry_point + htmltree.get_number_of_nodes + 1)||'].index;
                  }
                }
             }
          ');
      end if;-- subtree not added at end of supertree
    end if; -- htmltree.get_number_of_nodes = 0 -- no nodes written at all
    htp.p( g_codeFrameName||'stopLoading();
    '||g_codeFrameName||'redrawTree();
   }

      // end hiding contents from old browsers  -->
      //-->

      </SCRIPT>
   ');
  htp.headClose;
  htp.bodyOpen(cattributes=>'onLoad="inflateNode()"');
  htp.bodyClose;
  htp.htmlClose;
end; -- write_inflate_code

-- this procedure will write all JavaScript code required to draw and manage a navigator tree
procedure js_tree
( p_codeFrameName in varchar2    -- e.g. treeLogicFrame
, p_treeFrameName in varchar2    -- e.g. folderFrame
, p_treeFramePath in varchar2    -- e.g. top.selector.folderFrame
, p_xchangeFramePath in varchar2 -- e.g. top.appsBottom.rightSide.dataXchange
, p_js_action     in varchar2    -- the JavaScript function to be called when a node is selected
, p_node_href     in varchar2    -- the JavaScript Call to be made to p_js_action when a node is selected
                                 -- elId and idx can be referred to in the call; they the node value and index respectively
                                 -- name and additionalLabel are also available
, p_inflate_request    in varchar2 default null
                                 -- name of PL/SQL procedure to be called to provide inflation data; e.g.  'odwa_fol.inflate_Node'
, p_inflate_parameters in varchar2 default null
                                 -- additional parameters to be passed upon inflation (if more than one parameter, they must be separated by Ampersands)
                                 -- e.g. 'p_session_id='||to_char(odwactxt.get_session_id)||chr(38)||'p_root_node="+getParentNodeAbsolute( idx, 0)
                                 -- the parameters always passed are:
                                 -- p_node_index, p_node_level, p_num_of_nodes, p_node_value, p_node_type, p_entry_point
, p_refresh_tree in varchar2 default null  -- what is the PL/SQL procedure (incl.parameters) to be called to refresh the entire tree
                                           -- if not null, this parameter will results in a function refreshTree()
                                           -- that performs: p_codeFrameName.location = p_refresh_tree
) is

begin
  g_codeFrameName   := p_codeFrameName;
  g_treeFrameName   := p_treeFrameName;
  g_treeFramePath   := p_treeFramePath;
  g_xchangeFramePath:= p_xchangeFramePath;
  htp.p
  ('
  <SCRIPT LANGUAGE="JavaScript1.1">

  <!-- Comment out script for old browsers
  <!--  to hide script contents from old browsers
  var nodesTree = new Array();
  var treeNodeConvertor = new Array();  // this array contains the pointers into nodesTree
                                        // logical index values are converted to positions in nodesTree

  var lastFolder  = new Array(); // holds booleans to indicate whether the Folder currently walked through at level <INDEX> is the last one at that level
  var selectedIdx = -1;
  //var nextIndex;
  var addIndex = -1;
  var colWidth = 20;
  var colLevels = '||to_char(g_col_levels)||'; //maximum number of tree levels
  var selectedBgcolor = "yellow";

  //1.1 global variables for node and leaf images
  var openFolderImage        = "'||g_image_path||'nodeop2.jpg";
  var firstOpenFolderImage   = "'||g_image_path||'nodeop1.jpg";
  var closedFolderImage      = "'||g_image_path||'nodecl3.jpg";
  var firstClosedFolderImage = "'||g_image_path||'nodecl1.jpg";
  var leafImage              = "'||g_image_path||'leaf5.jpg";
  var lastLeafImage          = "'||g_image_path||'leaf7a.jpg";
  var folderLineImage        = "'||g_image_path||'leaf8.jpg";
  var expandAllImage         = "'||g_image_path||'expall.jpg";
  var collapseAllImage       = "'||g_image_path||'collall.jpg";
  var deleteNodeImage        = "'||g_image_path||'diff_deletion.gif";
  var reloadNodeImage        = "'||g_image_path||'requery.gif";
  var hideNodeImage          = "'||g_image_path||'reset.gif";
  var operation              = "";
  var operator1              = "";

  // to support automatic scrolling
      var db;
      var scroll;

  function init()
  {
      db = ('||g_treeFramePath||'.window.document.body) ? 1 : 0;
      scroll = ('||g_treeFramePath||'.window.scrollTo) ? 1 : 0;

  }

  function debug(message)
  {
      var doc = '||g_treeFramePath||'.window.document;
  doc.writeln(message);
 // alert(message);
  }

  //called after this html file is loaded
  function initializeTree()
  {
      var t = getTopWindow();

      generateAttributes();
      //generateTree();
  }
  ');
  if p_refresh_tree is not null
  then
    htp.p
    (' function refreshTree ()
       {
         location.href= location.href; //document.location ="'||p_refresh_tree||'";
       }
    ');
  end if; -- p_refresh_tree is not null



  htp.p('

  // Validation routine

  function validElementName( e )
  {
    if ( e == null ) return 0;
    if ( e == "" ) return 0;
    if ( e.toUpperCase() == "NULL" ) return 0;
    if ( e.toUpperCase() == "%NULL%" ) return 0;
    return 1;
  }

  // Building the data in the tree isFOlder and isOpen should be used

  function appendChild(index, name, level, isFolder, isOpen //, parentIndex
                      , value, additional, nextSibling, lastLeaf
                      , inflatable, inflated, classification
                      )
  {
      this.index             = index;
      this.name              = name;
      this.level             = level;
      this.isFolder          = isFolder;
      this.isOpen            = isOpen;
      this.value             = value;
      this.additional        = additional;
      this.nextSibling       = nextSibling;
      this.lastLeaf          = lastLeaf;
      this.inflatable        = inflatable;
      this.inflated          = inflated;
      this.classification    = classification;

  }


  '||p_js_action
  );
  htp.p('

  function getParentNodeAbsolute( idx, level) // find the first node before (and closest to) idx
                                              // that is at level
                                               // e.g. getParentNodeAbsolute( idx, 1) returns the ancestor node for idx at level 1
                                               // e.g. getParentNodeAbsolute( idx, 0) returns the root node for idx
  {
  var i = idx - 0;
  var targetLevel = level;
  if (targetLevel < 0)
    return null;
  if (nodesTree[idx].level <= targetLevel)  // current node is already at or above requested level
    return idx;

  i=i-1;
      while (i >= 0)
      {
        if (nodesTree[i].level == targetLevel)
        {
          break;
        }
        else
        {
            i= i-1;
        }
      }
      if (i < 0)
        return null;
      else
       return i;
  }


  function getParentNodeRelative( idx, levels) // find the first node before (and closest to) idx
                                               // that is has level == idx.level - levels
                                               // e.g. getParentNodeRelative( idx, 1) returns the immediate parent node for idx
  {
    var targetLevel = nodesTree[idx].level - levels;
    return getParentNodeAbsolute( idx, targetLevel)
  }


  //make room for a number of new childs under node idx
  function makeWay( idx, num)
  {
      // copy/move handles to (nodes after entry point) to the new end of the tree
      for (j = nodesTree.length -1 ; j > idx; j--)
      {
          nodesTree[j+num] = nodesTree[j];
      }
      if (selectedIdx > idx)
      {
        selectedIdx = (selectedIdx - (0 - num));
      }

      // now move the pointers from the treeNodeConvertor so that nextSiblings will know their node
      // a node j thought he was at treeNodeConvertor[j] but he has moved num positions
       for (j=0; j < treeNodeConvertor.length; j++)
       {
         if (treeNodeConvertor[j] > idx)
         {
           treeNodeConvertor[j] = treeNodeConvertor[j] + num;
         }
       }

  }

    //remove nodes for num nodes starting at idx
  function takeAway( idx, num)
  {
    var endPos = Number(idx-0+num);
    
      // move handles starting at (idx + num ) to (idx); the last num of folderTree are set to null
      for (j = idx ; j < endPos ; j++)
      {
          delete nodesTree[j]; // delete the object referred to at position [j]
      }

      // move later nodes into the gap created from idx to (idx+num);
      //
      if (endPos < nodesTree.length)
      {
        for (j = endPos; j < nodesTree.length; j++)
        {
            nodesTree[j-num] = nodesTree[j];
        }
        for (j = nodesTree.length -num+1; j < nodesTree.length; j++)
        {
          nodesTree[j] = null;
        }
      } // (endPos < nodesTree.length)
      
      if (selectedIdx >= idx '||chr(38)||chr(38)||
         ' selectedIdx < (endPos )
         )
      {
        selectedIdx = idx-1;
      }
      // now move the pointers from the treeNodeConvertor so that nextSiblings will know their node
      // a node j thought he was at treeNodeConvertor[j] but he has moved num positions
       for (j=0; j < treeNodeConvertor.length; j++)
       {
         if (treeNodeConvertor[j] >= endPos)
         {
           treeNodeConvertor[j] = treeNodeConvertor[j] - num;
         }
       }
  }//takeAway


  // this function will remove the children of the node idx and will then
  // inflate this node (again)
  function refreshNodeIdx( idx)
  {
    if ( nodesTree[idx].nextSibling == "")
    {
      // no sibling in the remainder of the tree
      // that means that from the next node the remainder of the tree is to be refreshed
      gotoCtr = nodesTree.length;
      takeAway( Number(idx)+1, gotoCtr - idx -1);
    }
    else      
    {
      gotoCtr= treeNodeConvertor[nodesTree[idx].nextSibling];
      takeAway( Number(idx)+1, gotoCtr - idx -1);
    }
    inflateRequest(idx);
  } // reloadNode

 // this function will try to find the first inflatable node in the tree hierarchy 
 // moving up from idx and starting with idx; if none is found, nothing happens
 function reloadNodeIdx(idx)
 {
    if (nodesTree[idx].inflatable == 1)
       refreshNodeIdx( idx)
    else
      if (nodesTree[idx].level > 0)
       reloadNodeIdx( getParentNodeRelative( idx, 1));
      
  } // reloadNode

  
  function reloadNode()
  {
    var idx = selectedIdx;
    if (nodesTree[idx].inflatable == 1)
       refreshNodeIdx( idx)
    else
       reloadNodeIdx( idx);
  } // reloadNode
  
  // this function returns true if node idx is inflateable or has an ancestor in the
  // tree that is inflateable
  function reloadable( idx)  
  {
    if (nodesTree[idx].inflatable == 1)
       return true;
    else
      if (nodesTree[idx].level > 0)
        return reloadable( getParentNodeRelative( idx, 1));
    
  }//reloadable

  // this function will remove node idx and the children of node idx
  // this will save on browser memory and should make tree operations slightly faster
  function hideNode()
  {
    var idx = selectedIdx;
    selectedIdx= -1;
    gotoCtr= treeNodeConvertor[nodesTree[idx].nextSibling];

    takeAway( Number(idx), gotoCtr - idx );
    redrawTree();
  } // reloadNode

  loadImages = new Array("'||g_image_path||'actor.gif", "'||g_image_path||'actor_usage.gif", "'||g_image_path||'actor_generalization.gif");
  thisLoad = 0;
  loadingData  = 0;  // indicates whether we are loading
  statusLabel = "Downloading data .";

  function loading()
  {
    var doc = '||g_treeFramePath||'.window.document;

    if (loadingData == 1)
    {
        if (doc.images)
        {
          thisLoad++
          if (thisLoad == 3)
          {
            thisLoad =0
          }

          doc.loadStatus.src = loadImages[thisLoad];
          statusLabel = statusLabel+".";
          top.status= statusLabel;
          setTimeout("loading()", 1*400);
        }
    }
  }

  function stopLoading()
  {
    var doc = '||g_treeFramePath||'.window.document;

    loadingData = 0;
    thisLoad = 0;
    doc.loadStatus.src = loadImages[thisLoad]
  }


  function redrawTree()
  {
  
      var doc = '||g_treeFramePath||'.window.document;
      var i = 0;
      var t;

      var x = (db) ? '||g_treeFramePath||'.window.document.body.scrollLeft : '||g_treeFramePath||'.window.pageXOffset;
      var y = (db) ? '||g_treeFramePath||'.window.document.body.scrollTop : '||g_treeFramePath||'.window.pageYOffset;
      var focusFolder;

      if (top.frames[1].name == '''||g_treeFrameName||''')
          t = ''top.'||g_treeFrameName||''';
      else
          t = ''top'';
      '
      ||'
      focusFolder = 1; // for simplicity, only allow full expand and collapse
      doc.clear();
      doc.writeln("<STYLE>  TD {font-family:Arial} A  {text-decoration:none}</STYLE> ");
      doc.writeln("<body bgcolor=#FFFFFF >");
          doc.write
          ( "&nbsp;&nbsp;&nbsp;<A href=''javascript:"+t
          + ".'||g_codeFrameName||'.expandFolder( \"" + focusFolder + "\")''>"
          );
          doc.write
          ( "<img src= ''"
            + expandAllImage
            + "''"
            + " ALT=\"Expand all nodes\" "
            + "border=noborder>"
            + "</a>"
          );
          doc.write
          ( "<A href=''javascript:"+t
          + ".'||g_codeFrameName||'.collapseFolder( \"" + focusFolder + "\")''>"
          );
          doc.write
          ( "<img src= ''"
            + collapseAllImage
            + "'' ALT=\"Collapse all nodes\" "
            + " border=noborder></a>"
          );
          if ( nvl( selectedIdx,-1) != -1)
          {   doc.write
              ( "<A href=''javascript:"+t
              + ".'||g_codeFrameName||'.hideNode()''>"
              );
              doc.write
              ( "<img src= ''"
                + hideNodeImage
                + "'' ALT=\"Hide Node (and Children) "+"\" "
                + " border=noborder></a>"
              );
          } // ( nvl( selectedIdx,-1) != -1)
          if ( nvl( selectedIdx,-1) != -1)
          {  if (  nodesTree[selectedIdx].inflatable == 1 )
             {
              doc.write
              ( "<A href=''javascript:"+t
              + ".'||g_codeFrameName||'.reloadNode()''>"
              );
              doc.write
              ( "<img src= ''"
                + reloadNodeImage
                + "'' ALT=\"Reload Node "+"\" "
                + " border=noborder></a>"
              );
              } // inflatable 
          } // a node has been selected
          doc.write
          ( "&nbsp;&nbsp;&nbsp;"
          + "<img src= ''"
            + "'||g_image_path||'actor.gif"
            + "'' NAME=\"loadStatus\" ALT=\"Data Loader...\" "
            + " border=noborder></a>"
          );
          doc.writeln("<table border=0 cellspacing=0 cellpadding=0>");
      // 1.3 for (var i = 0; i < nodesTree.length; i++)
      while (i < nodesTree.length)
      {
        if (nodesTree[i] == null)
        {
          i=i+1;
        }
        else
        {
            if (i == selectedIdx)
                i= redrawNode(t, doc, nodesTree[i], 1, i); //1.3
            else
                i = redrawNode(t, doc, nodesTree[i], 0, i); // 1.3
        }
        if ( i == -1)
        {
         break
        }
        //i= i+1;
      }
      doc.write("<tr>");
      for(i = 0; i < colLevels; i++)
        doc.write("<td width="+colWidth+"></td>");
      doc.write("</tr>");

      doc.writeln("</table>");
      doc.write("</body>");
      doc.close();
      operation = "";
      // to support scrolling to starting position
      '||g_treeFramePath||'.window.scrollTo(x, y);
} // redrawTree

  function drawOnLoad()
  {
    initializeTree();
    if (nodesTree.length > 0)
    {
     redrawTree();
    }
  }


  function writeNode( doc,t, elId, name, additionalLabel, idx, selected, classification, inflatable) // name is used for hyperlink, additionalLabel may contain anything
  {
    if (elId =="-1" || classification.indexOf("nolink") != -1)  // node without hyperlink
    {
      doc.write
      ( "<font size=-1>"
      + name
      + additionalLabel
      + "</font>"
      );
    }  //nolink
    else
    {
      if (selected==1) //<b><font size=+1>
      {
      doc.write
      ( "<b><font size=-1>"'
      ||'+ "<A href=''javascript:"+t+".'||g_codeFrameName||'.'
      ||p_node_href
      ||'''>"
      + name
      + "</a>"
      + additionalLabel
      + "</font></b>"
      );
        if ( inflatable == 1 )
        {
          doc.write
          ( "<A href=''javascript:"+t
          + ".'||g_codeFrameName||'.reloadNode()''>"
          );
          doc.write
          ( "<img src= ''"
          + reloadNodeImage
          + "'' ALT=\"Reload Node"+"\" "
          + " border=noborder></a>"
          );
        } // inflatable 
      else
        if ( reloadable(idx) == 1 )
        {
          doc.write
          ( "<A href=''javascript:"+t
          + ".'||g_codeFrameName||'.reloadNode()''>"
          );
          doc.write
          ( "<img src= ''"
          + reloadNodeImage
          + "'' ALT=\"Reload Ancestor Node "+"\" "
          + " border=noborder></a>"
          );
        } // reloadable
      } //inflatable
      else
      {
      doc.write
      ( "<font size=-1>"'
      ||'+ "<A href=''javascript:"+t+".'||g_codeFrameName||'.'
      ||p_node_href
      ||'''>"
      + name
      + "</a>"
      + additionalLabel
      + "</font>"
      );
      }  //selected
    } //nolink
    // now if a folder has been expanded and that folder is inflateable and it is not selected
    // then display reload folder node image
    if (  operation ==  "openFolder"
          '||chr(38)||chr(38)||'
          operator1 == idx
          '||chr(38)||chr(38)||'
          selected == 0
          '||chr(38)||chr(38)||'
          reloadable(idx) == 1 
        )
        {
          doc.write
          ( "<A href=''javascript:"+t
          + ".'||g_codeFrameName||'.reloadNodeIdx("+idx+")''>"
          );
          doc.write
          ( "<img src= ''"
          + reloadNodeImage
          + "'' ALT=\"Reload Folder Contents "+"\" "
          + " border=noborder></a>"
          );
        } // reloadable        
  }

  function redrawNode(t, doc, foldersNode, selected, ctr) {
      var i;
      var parentPosistion;
      var pIndex;
            //var t;
      var gotoCtr = ctr + 1; // indicates what the new index is for redrawTree to look at

          doc.write("<tr>");

          for (i=0; i < foldersNode.level; i++)
          {
             if (lastFolder[i] == 1)  // folder at level i is the last one; that means: no line needs to be drawn at that level
             {
               doc.write
               ( "<td "
               + ">"
               + "</td>"
             );
            }
            else
            {
               doc.write
               ( "<td align=right> "
               + "<img src= ''"
               + folderLineImage
               + "'' width=20 height=24"
               //+ "border=noborder"
               + ">"
               + "</td>"
               );

            }
          } // for folder levels

             doc.write
             ( "<td "
             + " align=right valign=middle "
             + ">"
             );
      if (foldersNode.isFolder == 1)
      {

          lastFolder[foldersNode.level] = foldersNode.lastLeaf;

          if (foldersNode.isOpen == 0) // foldersNode is not opened; that means all its leafs and sub-nodes are invisible
                                       // and can be bypassed; lets jump to the next sibling!
          {
            if (foldersNode.nextSibling != "")
                gotoCtr= treeNodeConvertor[foldersNode.nextSibling]; //nextSibling refers to nodeIndex, treeNodeConvertor holds position in nodesTree-array for every nodeIndex
            else
              // if no nextSibling and level = 0, then jump to end of list
              if (foldersNode.lastLeaf == 1) // will always be true I think
                 gotoCtr = nodesTree.length+1;

          }


          // for each level, a column is written (or, if the columns are empty anyway, one column with colspan=level is written)

          if (foldersNode.isOpen == 1)
          {
             doc.write
             ( "<A href=''javascript:"+t
              + ".'||g_codeFrameName||'.clickOnFolder(0, \"" + ctr + "\")''>"
              );
              doc.write
              ( "<img src= ''"
                + ifThenElse
                  ( foldersNode.inflatable == 1 '||chr(38)||chr(38)
                    ||' foldersNode.inflated == 0   //inflatable but not yet inflated
                  , ifThenElse( foldersNode.level == 0, firstClosedFolderImage, closedFolderImage)  ////foldersNode.closeFolderImage
                  , ifThenElse( foldersNode.level == 0, firstOpenFolderImage, openFolderImage)  ////foldersNode.openFolderImage
                  )
                + "'' width=20 height=24 border=noborder></a>");  // width was 24, height was 22
          }
          else
          {
              doc.write
              ( "<A href=''javascript:"+t
              + ".'||g_codeFrameName||'.clickOnFolder(1, \"" + ctr + "\")''>"
              );
              doc.write("<img src= ''"
                + ifThenElse( foldersNode.level == 0, firstClosedFolderImage, closedFolderImage)  ////foldersNode.closeFolderImage
                  + "'' width=20 height=24 border=noborder></a>");
          }

          doc.writeln("</td>");
          doc.write
          ( "<td nowrap valign=bottom "
      // alternative way to indicate the selected node: by using a Background Color
      //   + ifThenElse( selected == 1 , " bgcolor=\""+selectedBgcolor+"\"","")
          + " colspan="+(colLevels-foldersNode.level)
          + ">");
          writeNode( doc, t, foldersNode.value, foldersNode.name
          , foldersNode.additional, ctr, selected , foldersNode.classification, foldersNode.inflatable);
      }

      else
      {
            doc.write( "<img src= ''"
                         + ifThenElse( foldersNode.lastLeaf==1, lastLeafImage, leafImage) //foldersNode.docImage
                         + "'' width=20 height=24 border=noborder></a>"
                     );
            doc.writeln("</td>");

          doc.write
          ( "<td nowrap  valign=bottom "
          + " colspan="+(colLevels-foldersNode.level)
      // alternative way to indicate the selected node: by using a Background Color
      //    + ifThenElse( selected == 1 , " bgcolor=\""+selectedBgcolor+"\"","")
          + ">");

          writeNode( doc, t, foldersNode.value, foldersNode.name
                    ,foldersNode.additional, ctr, selected, foldersNode.classification,foldersNode.inflatable);

      }
      doc.writeln("</td>");
      doc.writeln("</tr>");
      return gotoCtr;
  } //redrawNode



  function inflateRequest( idx)
  {
  // find the first node under foldersNodeIndex that is not a folder
  // the inflation should take place just before that node
  // this ensures that children are added
  
  var i = idx - 0;
  var startLevel = nodesTree[i].level;
  i=i+1;
      statusLabel = "Downloading data .";

      while (i < nodesTree.length)
      {
      
        if (nodesTree[i] == null)
        {
          break;
        }

        if (nodesTree[i].level <= startLevel)
        {
          break;
        }
        if (nodesTree[i].isFolder == 1 )
        {
            i= i+1;
        }
        else
        {
           break;
        }
      }
     i=i-1;
    '||nvl( g_xchangeFramePath, 'document') -- 2.0  p_node_index is first node after expanded folder that is not a Folder itself
     ||'.location="'
     ||p_inflate_request
     ||'?p_node_index="+idx
       +"'||chr(38)||'p_node_level="+(startLevel-0+1)
       +"'||chr(38)||'p_num_of_nodes="+nodesTree.length
       +"'||chr(38)||'p_node_value="+nodesTree[idx].value
       +"'||chr(38)||'p_node_type="+nodesTree[idx].classification
       +"'||chr(38)||'p_entry_point="+i'
     ||ifThenElse
       ( p_inflate_parameters is not null
       , '+'||p_inflate_parameters
       )
     ||'
                 ;
     loadingData=1;
     loading(); // set images in motion

  }//inflateRequest

  function clickOnFolder (openOrCloseFlag, foldersNodeIndex) {
      //var prevSelectedIdx = selectedIdx;
      //var pos;
      var t = getTopWindow();
      // new to support scrolling
      // end new to support scrolling - we now have the current x and y scroll coordinate
      if (openOrCloseFlag == 0)
      {  //folder is open and will be closed
          closeFolder(foldersNodeIndex);
          redrawTree();
      }
      else
      {
        openFolder(foldersNodeIndex);
      }


      // one more to support scrolling

      // '||g_treeFramePath||'.window.scrollTo(x, y);
  } //clickOnFolder

  function expandFolder (foldersNodeIndex)
  {

    var endIndex = treeNodeConvertor[nodesTree[foldersNodeIndex ].nextSibling];
    if (endIndex == "") // 1.5
    {
      endIndex = nodesTree.length
    }
    else
    {
      endIndex = endIndex
    }
    //for (i=foldersNodeIndex; i < endIndex; i++)
    for (i=0; i < nodesTree.length-1; i++)
    {
          if (nodesTree[i].isFolder == 1)
          {
                if  ( nodesTree[i].inflatable == 1 '||chr(38)||chr(38)
                    ||' nodesTree[i].inflated == 0   //inflatable but not yet inflated
                    )
                   nodesTree[i].isOpen = 0;
                else
                  nodesTree[i].isOpen = 1;
          }
    }
     redrawTree();
  } //expandFolder

  function collapseFolder (foldersNodeIndex)
  {
    var endIndex = treeNodeConvertor[nodesTree[foldersNodeIndex ].nextSibling];
    if (endIndex == "")
    {
      endIndex = nodesTree.length
    }
    else
    {
      endIndex = endIndex
    }
    //for (i=foldersNodeIndex; i < endIndex; i++)
    for (i=0; i < nodesTree.length-1; i++)
    {
          if (nodesTree[i].isFolder == 1)
          {
            nodesTree[i].isOpen = 0;
          }
    }
     redrawTree();
  } //collapseFolder


  function closeFolder(foldersNodeIndex)
  {
    // no longer close recursively; closing folder node is enough!
    nodesTree[foldersNodeIndex ].isOpen = 0; // array index starts at 0, tree index at 1
  } //closeFolder

  function openFolder(foldersNodeIndex)
  {

  nodesTree[foldersNodeIndex ].isOpen = 1; // array index starts at 0, tree index at 1
  if ( nodesTree[foldersNodeIndex].inflatable == 1
       '||chr(38)||chr(38)||'
       nodesTree[foldersNodeIndex].inflated == 0
     )
  { inflateRequest( foldersNodeIndex)
  // do not redrawTree, wait for inflation to complete
  }
  else
    operation = "openFolder";
    operator1 = foldersNodeIndex;
    redrawTree();


  } //openFolder

      // utility functions

      function valueInArray(arr, val)
      {
          for(i = 0; i < arr.length; i++) {
              if (arr[i] == val)
                    return true;
          }
          return false;
      }


      function getTopWindow()
      {
          if (top.frames[1].name == '''||g_treeFrameName||''')
              return top.'||g_treeFrameName||';
          else
              return top;
      }
      // end hiding contents from old browsers  -->
      //-->

      </SCRIPT>
      <SCRIPT LANGUAGE="JavaScript1.1">

      <!-- Comment out script for old browsers

      function generateAttributes()
      {

        var oldIdx = 0;
        var newCnt = 0;

        var offset = 13;


     ');
     populate_tree;
     htp.p('
     //now load treeNodeConvertor
     for (i=0; i < nodesTree.length; i++)
     {
       treeNodeConvertor[nodesTree[i].index]= i;
     }
     }

       //treeNodeConvertor[nextSibling] renders position/index in nodesTree array

      function generateTree()
      {
       alert("generate tree");
      }

      function setTarget(win)
      {
          var t;
          if (top.frames[1].name == "'||g_treeFrameName||'")
              t = "'||g_treeFrameName||'";
          else
              t = "_top";
          if (win.document.links.length >= 1)
              win.document.links[0].target = t;
      }

      function nvl(f, n)
      {
          var t;

          if (f == "")
              t = n;
          else
              t = f;
          return t;

      }

      // 1.1
        function ifThenElse(condition, ifResult, elseResult)
        {
          var t;

            if (condition)
                t = ifResult;
            else
                t = elseResult;
            return t;

        }



      // end hiding contents from old browsers  -->
      //-->

      </SCRIPT>
   ');
   end; -- js_tree

procedure tree_frame
is
begin
  htp.htmlOpen;
  htp.bodyopen; -- ( cbackground=> '#c0c0c0');
  htp.bodyclose;
  htp.htmlClose;
end;

begin
  --3.2  this line is NOT proper for a true reusable component; however, to make the release date of 
  -- ODWA 6i, is it pragmatical. We need to find a more generic solution: HTMLTREE should not be dependent on ODWA objects
  g_image_path:= odwapref.get_value(p_preference_name => 'image_path'); 
end; --htmltree
/