Coverage Report - org.apache.tapestry.contrib.tree.components.TreeNodeView
 
Classes in this File Line Coverage Branch Coverage Complexity
TreeNodeView
0%
0/197
0%
0/70
2.049
 
 1  
 // Copyright 2004, 2005 The Apache Software Foundation
 2  
 //
 3  
 // Licensed under the Apache License, Version 2.0 (the "License");
 4  
 // you may not use this file except in compliance with the License.
 5  
 // You may obtain a copy of the License at
 6  
 //
 7  
 //     http://www.apache.org/licenses/LICENSE-2.0
 8  
 //
 9  
 // Unless required by applicable law or agreed to in writing, software
 10  
 // distributed under the License is distributed on an "AS IS" BASIS,
 11  
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12  
 // See the License for the specific language governing permissions and
 13  
 // limitations under the License.
 14  
 
 15  
 package org.apache.tapestry.contrib.tree.components;
 16  
 
 17  
 import org.apache.commons.logging.Log;
 18  
 import org.apache.commons.logging.LogFactory;
 19  
 import org.apache.tapestry.BaseComponent;
 20  
 import org.apache.tapestry.IAsset;
 21  
 import org.apache.tapestry.IMarkupWriter;
 22  
 import org.apache.tapestry.IRender;
 23  
 import org.apache.tapestry.IRequestCycle;
 24  
 import org.apache.tapestry.contrib.tree.model.ITreeModelSource;
 25  
 import org.apache.tapestry.contrib.tree.model.ITreeRowSource;
 26  
 import org.apache.tapestry.contrib.tree.model.ITreeStateListener;
 27  
 import org.apache.tapestry.contrib.tree.model.ITreeStateModel;
 28  
 import org.apache.tapestry.contrib.tree.model.TreeRowObject;
 29  
 import org.apache.tapestry.contrib.tree.model.TreeStateEvent;
 30  
 import org.apache.tapestry.contrib.tree.simple.SimpleNodeRenderFactory;
 31  
 import org.apache.tapestry.engine.IPageLoader;
 32  
 import org.apache.tapestry.event.PageDetachListener;
 33  
 import org.apache.tapestry.event.PageEvent;
 34  
 import org.apache.tapestry.spec.ComponentSpecification;
 35  
 import org.apache.tapestry.util.ComponentAddress;
 36  
 
 37  
 /**
 38  
  * @author tsveltin?
 39  
  */
 40  
 public abstract class TreeNodeView extends BaseComponent implements
 41  
         PageDetachListener
 42  
 {
 43  
 
 44  0
     private static final Log LOG = LogFactory.getLog(TreeNodeView.class);
 45  
 
 46  
     private Boolean m_objNodeState;
 47  
 
 48  
     private Boolean m_objShowNodeImages;
 49  
 
 50  
     private INodeRenderFactory m_objNodeRenderFactory;
 51  
 
 52  
     private IAsset m_objOpenNodeImage;
 53  
 
 54  
     private IAsset m_objCloseNodeImage;
 55  
 
 56  0
     private int m_currentForeachConnectImageValue = TreeRowObject.LINE_CONN_IMG;
 57  
 
 58  
     /**
 59  
      * Creates tree .
 60  
      *
 61  
      */
 62  
     public TreeNodeView()
 63  
     {
 64  0
         super();
 65  0
         initialize();
 66  0
     }
 67  
     
 68  
     public abstract INodeRenderFactory getNodeRenderFactoryParameter();
 69  
 
 70  
     public abstract Boolean getShowNodeImages();
 71  
     
 72  
     private void initialize()
 73  
     {
 74  0
         m_objNodeState = null;
 75  0
         m_objShowNodeImages = null;
 76  0
         m_objNodeRenderFactory = null;
 77  0
         m_currentForeachConnectImageValue = TreeRowObject.LINE_CONN_IMG;
 78  0
     }
 79  
 
 80  
     public IRender getCurrentRenderer()
 81  
     {
 82  0
         INodeRenderFactory objRenderFactory = getNodeRenderFactory();
 83  0
         ITreeRowSource objTreeRowSource = getTreeRowSource();
 84  0
         return objRenderFactory.getRender(objTreeRowSource.getTreeRow()
 85  
                 .getTreeNode(), getTreeModelSource(), getPage()
 86  
                 .getRequestCycle());
 87  
     }
 88  
 
 89  
     public Object[] getNodeContext()
 90  
     {
 91  0
         ITreeModelSource objModelSource = getTreeModelSource();
 92  0
         ComponentAddress objModelSourceAddress = new ComponentAddress(
 93  
                 objModelSource);
 94  0
         ITreeRowSource objTreeRowSource = getTreeRowSource();
 95  0
         TreeRowObject objTreeRowObject = objTreeRowSource.getTreeRow();
 96  0
         Object objValueUID = objTreeRowObject.getTreeNodeUID();
 97  0
         if (LOG.isDebugEnabled())
 98  
         {
 99  0
             LOG.debug("getNodeContext objValueUID = " + objValueUID);
 100  
         }
 101  
 
 102  0
         return new Object[] { objValueUID, new Boolean(isNodeOpen()),
 103  
                 objModelSourceAddress };
 104  
     }
 105  
 
 106  
     /**
 107  
      * Called when a node in the tree is clicked by the user. If the node is
 108  
      * expanded, it will be collapsed, and vice-versa, that is, the tree state
 109  
      * model is retrieved, and it is told to collapse or expand the node.
 110  
      * 
 111  
      * @param cycle
 112  
      *            The Tapestry request cycle object.
 113  
      */
 114  
     public void nodeExpandCollaps(IRequestCycle cycle)
 115  
     {
 116  0
         Object[] context = cycle.getListenerParameters();
 117  0
         Object objValueUID = null;
 118  0
         if (context != null && context.length > 0)
 119  
         {
 120  0
             objValueUID = context[0];
 121  
         }
 122  0
         ComponentAddress objModelSourceAddress = (ComponentAddress) context[2];
 123  0
         ITreeModelSource objTreeModelSource = (ITreeModelSource) objModelSourceAddress
 124  
                 .findComponent(cycle);
 125  
         // ITreeModelSource objTreeModelSource = getTreeModelSource();
 126  0
         ITreeStateModel objStateModel = objTreeModelSource.getTreeModel()
 127  
                 .getTreeStateModel();
 128  0
         boolean bState = objStateModel.isUniqueKeyExpanded(objValueUID);
 129  
 
 130  0
         if (bState)
 131  
         {
 132  0
             objStateModel.collapse(objValueUID);
 133  0
             fireNodeCollapsed(objValueUID, objTreeModelSource);
 134  
         }
 135  
         else
 136  
         {
 137  0
             objStateModel.expandPath(objValueUID);
 138  0
             fireNodeExpanded(objValueUID, objTreeModelSource);
 139  
         }
 140  0
     }
 141  
 
 142  
     /**
 143  
      * Called when a node in the tree is selected by the user. the tree state
 144  
      * model is retrieved, and it is told to select the node.
 145  
      * 
 146  
      * @param cycle
 147  
      *            The Tapestry request cycle object.
 148  
      */
 149  
     public void nodeSelect(IRequestCycle cycle)
 150  
     {
 151  0
         Object[] context = cycle.getListenerParameters();
 152  0
         Object objValueUID = null;
 153  0
         if (context != null && context.length > 0)
 154  
         {
 155  0
             objValueUID = context[0];
 156  
         }
 157  0
         ComponentAddress objModelSourceAddress = (ComponentAddress) context[2];
 158  0
         ITreeModelSource objTreeModelSource = (ITreeModelSource) objModelSourceAddress
 159  
                 .findComponent(cycle);
 160  
         // ITreeModelSource objTreeModelSource = getTreeModelSource();
 161  0
         ITreeStateModel objStateModel = objTreeModelSource.getTreeModel()
 162  
                 .getTreeStateModel();
 163  0
         Object objSelectedNodeInState = objStateModel.getSelectedNode();
 164  
 
 165  0
         if (objValueUID.equals(objSelectedNodeInState))
 166  
         {
 167  
             // do nothing, the selected node in UI is the same as the selected
 168  
             // in
 169  
             // state model. The user should use refresh of back button.
 170  0
             return;
 171  
         }
 172  
 
 173  0
         objStateModel.setSelectedNode(objValueUID);
 174  0
         fireNodeSelected(objValueUID, objTreeModelSource);
 175  0
     }
 176  
 
 177  
     private void fireNodeSelected(Object objValueUID,
 178  
             ITreeModelSource objTreeModelSource)
 179  
     {
 180  0
         deliverEvent(TreeStateEvent.SELECTED_NODE_CHANGED, objValueUID,
 181  
                 objTreeModelSource);
 182  0
     }
 183  
 
 184  
     private void fireNodeCollapsed(Object objValueUID,
 185  
             ITreeModelSource objTreeModelSource)
 186  
     {
 187  0
         deliverEvent(TreeStateEvent.NODE_COLLAPSED, objValueUID,
 188  
                 objTreeModelSource);
 189  0
     }
 190  
 
 191  
     private void fireNodeExpanded(Object objValueUID,
 192  
             ITreeModelSource objTreeModelSource)
 193  
     {
 194  0
         deliverEvent(TreeStateEvent.NODE_EXPANDED, objValueUID,
 195  
                 objTreeModelSource);
 196  0
     }
 197  
 
 198  
     private void deliverEvent(int nEventUID, Object objValueUID,
 199  
             ITreeModelSource objTreeModelSource)
 200  
     {
 201  0
         ITreeStateListener objListener = objTreeModelSource
 202  
                 .getTreeStateListener();
 203  0
         if (objListener != null)
 204  
         {
 205  0
             TreeStateEvent objEvent = new TreeStateEvent(nEventUID,
 206  
                     objValueUID, objTreeModelSource.getTreeModel()
 207  
                             .getTreeStateModel());
 208  0
             objListener.treeStateChanged(objEvent);
 209  
         }
 210  
 
 211  0
     }
 212  
 
 213  
     public void pageDetached(PageEvent arg0)
 214  
     {
 215  0
         initialize();
 216  0
     }
 217  
 
 218  
     public void finishLoad(IRequestCycle objCycle, IPageLoader arg0,
 219  
             ComponentSpecification arg1)
 220  
     {
 221  0
         super.finishLoad(objCycle, arg0, arg1);
 222  0
         getPage().addPageDetachListener(this);
 223  
 
 224  0
         m_objOpenNodeImage = getAsset("_openNodeImage");
 225  0
         m_objCloseNodeImage = getAsset("_closeNodeImage");
 226  0
     }
 227  
 
 228  
     public boolean isNodeOpen()
 229  
     {
 230  0
         if (m_objNodeState == null)
 231  
         {
 232  0
             ITreeRowSource objTreeRowSource = getTreeRowSource();
 233  0
             TreeRowObject objTreeRowObject = objTreeRowSource.getTreeRow();
 234  0
             Object objValueUID = objTreeRowObject.getTreeNodeUID();
 235  0
             ITreeModelSource objTreeModelSource = getTreeModelSource();
 236  0
             ITreeStateModel objStateModel = objTreeModelSource.getTreeModel()
 237  
                     .getTreeStateModel();
 238  0
             boolean bState = objStateModel.isUniqueKeyExpanded(objValueUID);
 239  0
             m_objNodeState = new Boolean(bState);
 240  
         }
 241  0
         return m_objNodeState.booleanValue();
 242  
     }
 243  
 
 244  
     /**
 245  
      * Returns the openNodeImage.
 246  
      * 
 247  
      * @return IAsset
 248  
      */
 249  
     public IAsset getNodeImage()
 250  
     {
 251  0
         IAsset objResult = null;
 252  0
         ITreeRowSource objRowSource = getTreeRowSource();
 253  0
         boolean bLeaf = objRowSource.getTreeRow().getLeaf();
 254  0
         int nRowType = objRowSource.getTreeRow().getTreeRowPossiotionType();
 255  0
         if (!bLeaf)
 256  
         {
 257  0
             if (isNodeOpen())
 258  
             {
 259  0
                 switch(nRowType)
 260  
                 {
 261  
                 case TreeRowObject.FIRST_LAST_ROW:
 262  
                 {
 263  0
                     objResult = getAsset("_topLastOpenNodeImage");
 264  0
                     break;
 265  
                 }
 266  
 
 267  
                 case TreeRowObject.FIRST_ROW:
 268  
                 {
 269  0
                     objResult = getAsset("_topOpenNodeImage");
 270  0
                     break;
 271  
                 }
 272  
 
 273  
                 case TreeRowObject.MIDDLE_ROW:
 274  
                 {
 275  0
                     objResult = getAsset("_middleOpenNodeImage");
 276  0
                     break;
 277  
                 }
 278  
 
 279  
                 case TreeRowObject.LAST_ROW:
 280  
                 {
 281  0
                     objResult = getAsset("_bottomOpenNodeImage");
 282  0
                     break;
 283  
                 }
 284  
 
 285  
                 default:
 286  
                 {
 287  0
                     objResult = getAsset("_openNodeImage");
 288  0
                     break;
 289  
                 }
 290  
                 }
 291  
             }
 292  
             else
 293  
             {
 294  0
                 switch(nRowType)
 295  
                 {
 296  
                 case TreeRowObject.FIRST_LAST_ROW:
 297  
                 {
 298  0
                     objResult = getAsset("_topLastCloseNodeImage");
 299  0
                     break;
 300  
                 }
 301  
 
 302  
                 case TreeRowObject.FIRST_ROW:
 303  
                 {
 304  0
                     objResult = getAsset("_topCloseNodeImage");
 305  0
                     break;
 306  
                 }
 307  
 
 308  
                 case TreeRowObject.MIDDLE_ROW:
 309  
                 {
 310  0
                     objResult = getAsset("_middleCloseNodeImage");
 311  0
                     break;
 312  
                 }
 313  
 
 314  
                 case TreeRowObject.LAST_ROW:
 315  
                 {
 316  0
                     objResult = getAsset("_bottomCloseNodeImage");
 317  0
                     break;
 318  
                 }
 319  
 
 320  
                 default:
 321  
                 {
 322  0
                     objResult = getAsset("_closeNodeImage");
 323  0
                     break;
 324  
                 }
 325  
                 }
 326  
             }
 327  
         }
 328  
         else
 329  
         {
 330  0
             switch(nRowType)
 331  
             {
 332  
             case TreeRowObject.FIRST_LAST_ROW:
 333  
             {
 334  0
                 objResult = getAsset("_topLineImage");
 335  0
                 break;
 336  
             }
 337  
 
 338  
             case TreeRowObject.FIRST_ROW:
 339  
             {
 340  0
                 objResult = getAsset("_topLineImage");
 341  0
                 break;
 342  
             }
 343  
 
 344  
             case TreeRowObject.MIDDLE_ROW:
 345  
             {
 346  0
                 objResult = getAsset("_middleCrossLineImage");
 347  0
                 break;
 348  
             }
 349  
 
 350  
             case TreeRowObject.LAST_ROW:
 351  
             {
 352  0
                 objResult = getAsset("_bottomLineImage");
 353  0
                 break;
 354  
             }
 355  
 
 356  
             default:
 357  
             {
 358  0
                 objResult = getAsset("_bottomLineImage");
 359  
                 break;
 360  
             }
 361  
             }
 362  
 
 363  
         }
 364  0
         return objResult;
 365  
     }
 366  
 
 367  
     public IAsset getNodeImageOld()
 368  
     {
 369  0
         if (isNodeOpen())
 370  
         {
 371  0
             if (m_objOpenNodeImage == null)
 372  
             {
 373  0
                 m_objOpenNodeImage = getAsset("_openNodeImage");
 374  
             }
 375  0
             return m_objOpenNodeImage;
 376  
         }
 377  
 
 378  0
         if (m_objCloseNodeImage == null)
 379  
         {
 380  0
             m_objCloseNodeImage = getAsset("_closeNodeImage");
 381  
         }
 382  0
         return m_objCloseNodeImage;
 383  
     }
 384  
 
 385  
     /**
 386  
      * Returns the closeNodeImage.
 387  
      * 
 388  
      * @return IAsset
 389  
      */
 390  
     public IAsset getCloseNodeImage()
 391  
     {
 392  0
         return m_objCloseNodeImage;
 393  
     }
 394  
 
 395  
     /**
 396  
      * Returns the openNodeImage.
 397  
      * 
 398  
      * @return IAsset
 399  
      */
 400  
     public IAsset getOpenNodeImage()
 401  
     {
 402  0
         return m_objOpenNodeImage;
 403  
     }
 404  
 
 405  
     /**
 406  
      * Sets the closeNodeImage.
 407  
      * 
 408  
      * @param closeNodeImage
 409  
      *            The closeNodeImage to set
 410  
      */
 411  
     public void setCloseNodeImage(IAsset closeNodeImage)
 412  
     {
 413  0
         m_objCloseNodeImage = closeNodeImage;
 414  0
     }
 415  
 
 416  
     /**
 417  
      * Sets the openNodeImage.
 418  
      * 
 419  
      * @param openNodeImage
 420  
      *            The openNodeImage to set
 421  
      */
 422  
     public void setOpenNodeImage(IAsset openNodeImage)
 423  
     {
 424  0
         m_objOpenNodeImage = openNodeImage;
 425  0
     }
 426  
 
 427  
     /**
 428  
      * @see org.apache.tapestry.AbstractComponent#renderComponent(IMarkupWriter,
 429  
      *      IRequestCycle)
 430  
      */
 431  
     protected void renderComponent(IMarkupWriter arg0, IRequestCycle arg1)
 432  
     {
 433  0
         super.renderComponent(arg0, arg1);
 434  0
         m_objNodeState = null;
 435  0
     }
 436  
 
 437  
     /**
 438  
      * Returns the ShowNodeImages.
 439  
      * 
 440  
      * @return Boolean
 441  
      */
 442  
     public Boolean isShowNodeImages()
 443  
     {
 444  0
         if (m_objShowNodeImages == null)
 445  
         {
 446  0
             if (isParameterBound("nodeRenderFactory"))
 447  
             {
 448  0
                 m_objShowNodeImages = getShowNodeImages();
 449  
             }
 450  
             else
 451  
             {
 452  0
                 m_objShowNodeImages = Boolean.TRUE;
 453  
             }
 454  
 
 455  
         }
 456  0
         return m_objShowNodeImages;
 457  
     }
 458  
 
 459  
     public boolean getShowImages()
 460  
     {
 461  0
         boolean bResult = isShowNodeImages().booleanValue();
 462  0
         return bResult;
 463  
     }
 464  
 
 465  
     public boolean getShowWithoutImages()
 466  
     {
 467  0
         boolean bResult = !isShowNodeImages().booleanValue();
 468  0
         return bResult;
 469  
     }
 470  
 
 471  
     public String getOffsetStyle()
 472  
     {
 473  
         // return "width: " + getTreeDataView().getTreeDeep() * 15;
 474  0
         ITreeRowSource objTreeRowSource = getTreeRowSource();
 475  0
         TreeRowObject objTreeRowObject = objTreeRowSource.getTreeRow();
 476  0
         int nTreeRowDepth = 0;
 477  0
         if (objTreeRowObject != null)
 478  
         {
 479  0
             nTreeRowDepth = objTreeRowObject.getTreeRowDepth();
 480  0
             if (nTreeRowDepth != 0) nTreeRowDepth = nTreeRowDepth - 1;
 481  
         }
 482  0
         return "padding-left: " + nTreeRowDepth * 19 + "px";
 483  
     }
 484  
 
 485  
     public INodeRenderFactory getNodeRenderFactory()
 486  
     {
 487  0
         if (m_objNodeRenderFactory == null)
 488  
         {
 489  0
             if (isParameterBound("nodeRenderFactory"))
 490  0
                 m_objNodeRenderFactory = getNodeRenderFactoryParameter();
 491  0
             else m_objNodeRenderFactory = new SimpleNodeRenderFactory();
 492  
         }
 493  0
         return m_objNodeRenderFactory;
 494  
     }
 495  
 
 496  
     public abstract boolean getMakeNodeDirect();
 497  
 
 498  
     public boolean getMakeNodeNoDirect()
 499  
     {
 500  0
         return !getMakeNodeDirect();
 501  
     }
 502  
 
 503  
     public String getCleanSelectedID()
 504  
     {
 505  0
         return getSelectedNodeID();
 506  
     }
 507  
 
 508  
     public String getSelectedID()
 509  
     {
 510  0
         ITreeRowSource objTreeRowSource = getTreeRowSource();
 511  0
         ITreeModelSource objTreeModelSource = getTreeModelSource();
 512  0
         TreeRowObject objTreeRowObject = objTreeRowSource.getTreeRow();
 513  0
         Object objNodeValueUID = objTreeRowObject.getTreeNodeUID();
 514  0
         Object objSelectedNode = objTreeModelSource.getTreeModel()
 515  
                 .getTreeStateModel().getSelectedNode();
 516  0
         if (objNodeValueUID.equals(objSelectedNode)) { return getSelectedNodeID(); }
 517  0
         return "";
 518  
     }
 519  
 
 520  
     private String getSelectedNodeID()
 521  
     {
 522  
         // return getTreeDataView().getTreeView().getSelectedNodeID();
 523  0
         return "tree";
 524  
     }
 525  
 
 526  
     public String getNodeStyleClass()
 527  
     {
 528  0
         ITreeRowSource objTreeRowSource = getTreeRowSource();
 529  0
         ITreeModelSource objTreeModelSource = getTreeModelSource();
 530  0
         TreeRowObject objTreeRowObject = objTreeRowSource.getTreeRow();
 531  0
         boolean bResult = false;
 532  0
         if (objTreeRowObject != null)
 533  
         {
 534  0
             Object objNodeValueUID = objTreeRowObject.getTreeNodeUID();
 535  0
             Object objSelectedNode = objTreeModelSource.getTreeModel()
 536  
                     .getTreeStateModel().getSelectedNode();
 537  0
             bResult = objNodeValueUID.equals(objSelectedNode);
 538  
         }
 539  0
         if (bResult) { return "selectedNodeViewClass"; }
 540  
 
 541  0
         return "notSelectedNodeViewClass";
 542  
     }
 543  
 
 544  
     public ITreeRowSource getTreeRowSource()
 545  
     {
 546  0
         ITreeRowSource objSource = (ITreeRowSource) getPage().getRequestCycle()
 547  
                 .getAttribute(ITreeRowSource.TREE_ROW_SOURCE_ATTRIBUTE);
 548  0
         return objSource;
 549  
     }
 550  
 
 551  
     public ITreeModelSource getTreeModelSource()
 552  
     {
 553  0
         ITreeModelSource objSource = (ITreeModelSource) getPage()
 554  
                 .getRequestCycle().getAttribute(
 555  
                         ITreeModelSource.TREE_MODEL_SOURCE_ATTRIBUTE);
 556  0
         return objSource;
 557  
     }
 558  
 
 559  
     public boolean getShowConnectImage()
 560  
     {
 561  0
         ITreeRowSource objRowSource = getTreeRowSource();
 562  0
         int nRowType = objRowSource.getTreeRow().getTreeRowPossiotionType();
 563  0
         if (TreeRowObject.MIDDLE_ROW == nRowType) return true;
 564  0
         return false;
 565  
     }
 566  
 
 567  
     public int[] getForeachConnectImageList()
 568  
     {
 569  0
         ITreeRowSource objTreeRowSource = getTreeRowSource();
 570  0
         TreeRowObject objTreeRowObject = objTreeRowSource.getTreeRow();
 571  0
         return objTreeRowObject.getLineConnImages();
 572  
     }
 573  
 
 574  
     public boolean getDisableLink()
 575  
     {
 576  0
         ITreeRowSource objRowSource = getTreeRowSource();
 577  0
         boolean bLeaf = objRowSource.getTreeRow().getLeaf();
 578  0
         return bLeaf;
 579  
     }
 580  
 
 581  
     /**
 582  
      * Returns the openNodeImage.
 583  
      * 
 584  
      * @return IAsset nevalidno neshto
 585  
      */
 586  
     public IAsset getConnectImage()
 587  
     {
 588  0
         IAsset objResult = null;
 589  0
         int nConnectImageType = getCurrentForeachConnectImageValue();
 590  0
         switch(nConnectImageType)
 591  
         {
 592  
         case TreeRowObject.EMPTY_CONN_IMG:
 593  
         {
 594  0
             objResult = getAsset("_whiteSpaceImage");
 595  0
             break;
 596  
         }
 597  
 
 598  
         case TreeRowObject.LINE_CONN_IMG:
 599  
         {
 600  0
             objResult = getAsset("_middleLineImage");
 601  0
             break;
 602  
         }
 603  
 
 604  
         default:
 605  
         {
 606  0
             objResult = getAsset("_whiteSpaceImage");
 607  
             break;
 608  
         }
 609  
         }
 610  0
         return objResult;
 611  
     }
 612  
 
 613  
     /**
 614  
      * @return Returns the m_CurrentForeachConnectImageValue.
 615  
      */
 616  
     public int getCurrentForeachConnectImageValue()
 617  
     {
 618  0
         return m_currentForeachConnectImageValue;
 619  
     }
 620  
 
 621  
     /**
 622  
      * @param currentForeachConnectImageValue
 623  
      *            The m_CurrentForeachConnectImageValue to set.
 624  
      */
 625  
     public void setCurrentForeachConnectImageValue(
 626  
             int currentForeachConnectImageValue)
 627  
     {
 628  0
         m_currentForeachConnectImageValue = currentForeachConnectImageValue;
 629  0
     }
 630  
 }