Sets the enabled member to True or False for a node and all it's children
481270
def enableBranch(self, enabled):
        
        self.enabled = enabled
        for child in self.childItems:
            child.enableBranch(enabled)
192507
function(children) {
			_assert(
				children && (!this.children || this.children.length === 0),
				"only init supported"
			);
			this.children = [];
			for (var i = 0, l = children.length; i < l; i++) {
				this.children.push(new FancytreeNode(this, children[i]));
			}
		}
235306
public void enable(int level) {
        if (level >= PmiConstants.LEVEL_HIGH)
            sync = true;
        else
            sync = false;

        if (!enabled) {
            enabled = true;
            reset();
        }
    }
923652
@Override
    public void setActive(boolean active) {
        TreeModelEvent event = null;
        BugTreeModel.TreeModification whatToDo;

        if (active != this.active) {
            if (active == false) {
                this.active = active;
            }

            StackedFilterMatcher theSame = this;
            FilterMatcher[] filtersInStack = theSame.getFilters();
            ArrayList<Sortables> order = MainFrame.getInstance().getSorter().getOrder();
            int sizeToCheck = filtersInStack.length;
            if (order.contains(Sortables.DIVIDER)) {
                if (order.indexOf(Sortables.DIVIDER) < filtersInStack.length) {
                    sizeToCheck++;
                }
            }
            List<Sortables> sortablesToCheck = order.subList(0, Math.min(sizeToCheck, order.size()));
            Debug.println("Size to check" + sizeToCheck + " checking list" + sortablesToCheck);
            Debug.println("checking filters");
            ArrayList<String> almostPath = new ArrayList<>();
            ArrayList<Sortables> almostPathSortables = new ArrayList<>();
            for (int x = 0; x < sortablesToCheck.size(); x++) {
                Sortables s = sortablesToCheck.get(x);
                for (FilterMatcher fm : filtersInStack) {
                    if (s.equals(fm.getFilterBy())) {
                        almostPath.add(fm.getValue());
                        almostPathSortables.add(fm.getFilterBy());
                    }
                }
            }
            ArrayList<String> finalPath = new ArrayList<>();
            for (int x = 0; x < almostPath.size(); x++) {
                Sortables s = almostPathSortables.get(x);
                if (MainFrame.getInstance().getSorter().getOrderBeforeDivider().contains(s)) {
                    finalPath.add(almostPath.get(x));
                }
            }
            try {
                if (finalPath.size() == filtersInStack.length) {
                    if (active == true) {
                        event = (MainFrame.getInstance().getBugTreeModel()).removeBranch(finalPath);
                        whatToDo = BugTreeModel.TreeModification.REMOVE;
                    } else {
                        event = (MainFrame.getInstance().getBugTreeModel()).insertBranch(finalPath);
                        whatToDo = BugTreeModel.TreeModification.INSERT;
                    }
                } else {
                    event = (MainFrame.getInstance().getBugTreeModel()).restructureBranch(finalPath, active);// if
                    // active
                    // is
                    // true,
                    // this
                    // removes,
                    // if
                    // active
                    // if
                    // false,
                    // it
                    // inserts
                    if (active) {
                        whatToDo = BugTreeModel.TreeModification.REMOVERESTRUCTURE;
                    } else {
                        whatToDo = BugTreeModel.TreeModification.INSERTRESTRUCTURE;
                    }
                }

                if (active == true) {
                    this.active = active;
                }
                (MainFrame.getInstance().getBugTreeModel()).sendEvent(event, whatToDo);
            } catch (BranchOperationException e) {
                // Another filter already filters out the branch this filter
                // would filter out, set active, but don't send any tree model
                // events.
                this.active = active;
            }
        }

    }
259592
function setActive() {
      for (var i = 0; i < this._n.length; i++) {
        this.addClass(this._n[i].children);
      }
    }
518031
function(parent, children) {
			if (this.myTree) {
				this.myTree.refresh.bind(this.myTree)(parent, children, true);
			}
		}
684774
public void setEnabled(boolean enabled) {
		if (enabled && engine == null) {
			return;
		}

		if (this.enabled != enabled) {
			this.enabled = enabled;
			this.changed = true;
		}
	}
549447
public void setEnabled(boolean enabled) {
		super.setEnabled(enabled);

		if (dayChooser != null) {
			dayChooser.setEnabled(enabled);
			monthChooser.setEnabled(enabled);
			yearChooser.setEnabled(enabled);
		}
	}
1132884
private boolean setChild1(N newChild) {
		if (this.child1 == newChild) {
			return false;
		}

		if (this.child1 != null) {
			this.child1.setParentNodeReference(null, true);
			--this.notNullChildCount;
			firePropertyChildRemoved(0, this.child1);
		}

		if (newChild != null) {
			final N oldParent = newChild.getParentNode();
			if (oldParent != this) {
				newChild.removeFromParent();
			}
		}

		this.child1 = newChild;

		if (newChild != null) {
			newChild.setParentNodeReference(toN(), true);
			++this.notNullChildCount;
			firePropertyChildAdded(0, newChild);
		}

		return true;
	}
944763
function(node) { 
        var p = node.parent;

        // Update the parent's collection of children
        var a = [];

        for (var i=0, len=p.children.length;i<len;++i) {
            if (p.children[i] != node) {
                a[a.length] = p.children[i];
            }
        }

        p.children = a;

        // reset the childrenRendered flag for the parent
        p.childrenRendered = false;

         // Update the sibling relationship
        if (node.previousSibling) {
            node.previousSibling.nextSibling = node.nextSibling;
        }

        if (node.nextSibling) {
            node.nextSibling.previousSibling = node.previousSibling;
        }

		if (this.currentFocus == node) {
			this.currentFocus = null;
		}
		if (this._currentlyHighlighted == node) {
			this._currentlyHighlighted = null;
		}

        node.parent = null;
        node.previousSibling = null;
        node.nextSibling = null;
        node.tree = null;

        // Update the tree's node collection 
        delete this._nodes[node.index];
    }
191977
private void setConditionEnabled(boolean enabled)
	{
		fConditionEditor.setEnabled(enabled);
		fSuspendWhenLabel.setEnabled(enabled);
		fConditionIsTrue.setEnabled(enabled);
		fConditionHasChanged.setEnabled(enabled);
	}
22657
function() {
    var self = this;
    var children = self._children;
    var prev = self.state.childrenLoadingStatus;
    var isLoading = false;

    for (var k in children) {
      if (children[k]) {
        isLoading = true;
        break;
      }
    }

    if (prev === isLoading) return;
    self.setState({childrenLoadingStatus: isLoading});
  }
911471
def is_child(self, node):
        
        if node in self.children:
            return True
        for c in self.children:
            if c.is_child(node):
                return True
        return False
95106
@Override
    public void setActive(boolean active) {
        this.active = active;

        if (parent != null) {
            fireCollapsibleHandler();
            removeStyleName(CssName.ACTIVE);
            if (header != null) {
                header.removeStyleName(CssName.ACTIVE);
            }
            if (active) {
                if (parent != null && parent.isAccordion()) {
                    parent.clearActive();
                }
                addStyleName(CssName.ACTIVE);

                if (header != null) {
                    header.addStyleName(CssName.ACTIVE);
                }
            }

            if (body != null) {
                body.setDisplay(active ? Display.BLOCK : Display.NONE);
            }
        } else {
            GWT.log("Please make sure that the Collapsible parent is attached or existed.", new IllegalStateException());
        }
    }
496906
public static void setEnabled(Element element, boolean enabled) {
        element.setPropertyBoolean("disabled", !enabled);
	setStyleName(element, "disabled", !enabled);
    }
17201
public void setAllInjectableAndRPC(boolean enabled) {
        
        this.getChkInjectableQueryString().setEnabled(enabled);
        this.getChkAddQueryParam().setEnabled(enabled && getChkInjectableQueryString().isSelected());
        this.getChkInjectableUrlPath().setEnabled(enabled);
        this.getChkInjectablePostData().setEnabled(enabled);
        this.getChkInjectableHeaders().setEnabled(enabled);
        this.getChkInjectableHeadersAllRequests().setEnabled(enabled && getChkInjectableHeaders().isSelected());
        this.getChkInjectableCookie().setEnabled(enabled);
         
        this.getChkRPCMultipart().setEnabled(enabled);
        this.getChkRPCXML().setEnabled(enabled);
        this.getChkRPCJSON().setEnabled(enabled);
        this.getChkRPCGWT().setEnabled(enabled);
        this.getChkRPCoData().setEnabled(enabled);
        this.getChkRPCDWR().setEnabled(enabled);
        this.getChkRPCCustom().setEnabled(enabled && isExtensionScriptEnabled());

        if (!reasonVariantsDisabled.isEmpty()) {
            labelReasonVariantsDisabled.setVisible(!enabled);
        }
    }
70563
public void setControl(Node control) {
        if (control != null) {
            this.control = control;
            this.badge = new Group();
            this.getChildren().add(control);
            this.getChildren().add(badge);

            // if the control got resized the badge must be rest
            if (control instanceof Region) {
                ((Region) control).widthProperty().addListener((o, oldVal, newVal) -> refreshBadge());
                ((Region) control).heightProperty().addListener((o, oldVal, newVal) -> refreshBadge());
            }
            text.addListener((o, oldVal, newVal) -> refreshBadge());
        }
    }