<<<<<<< HEAD
                    // o whose value changed
            return;
        }
                    //
        containingDocument.startHandleOperation("model", "performing refresh", "container id", container.getEffectiveId());
        {
            // Update control bindings
            updateControlBindingsIfNeeded(propertyContext);
            // Update control values
            evaluateControlValuesIfNeeded(propertyContext, true);
=======
        indentedLogger.startHandleOperation("model", "performing refresh", "model id", model.getEffectiveId());

        // Update control bindings if needed
        updateControlBindingsIfNeeded(propertyContext);

        // Obtain global information about event handlers. This is a rough optimization so we can avoid sending certain
        // types of events below.
        final boolean isAllowSendingValueChangedEvents = hasHandlerForEvent(XFormsEvents.XFORMS_VALUE_CHANGED);
        final boolean isAllowSendingRequiredEvents = hasHandlerForEvent(XFormsEvents.XFORMS_REQUIRED) || hasHandlerForEvent(XFormsEvents.XFORMS_OPTIONAL);
        final boolean isAllowSendingRelevantEvents = hasHandlerForEvent(XFormsEvents.XFORMS_ENABLED) || hasHandlerForEvent(XFormsEvents.XFORMS_DISABLED);
        final boolean isAllowSendingReadonlyEvents = hasHandlerForEvent(XFormsEvents.XFORMS_READONLY) || hasHandlerForEvent(XFormsEvents.XFORMS_READWRITE);
        final boolean isAllowSendingValidEvents = hasHandlerForEvent(XFormsEvents.XFORMS_VALID) || hasHandlerForEvent(XFormsEvents.XFORMS_INVALID);

        final boolean isAllowSendingUIEvents = isAllowSendingValueChangedEvents || isAllowSendingRequiredEvents || isAllowSendingRelevantEvents || isAllowSendingReadonlyEvents || isAllowSendingValidEvents;
        if (isAllowSendingUIEvents) {
            // There are potentially event handlers for UI events, so do the whole processing

            // If this is the first refresh we mark nodes to dispatch MIP events
            final boolean isFirstRefresh = isInitialRefreshEvents && containingDocument.isInitializationFirstRefreshClear();

            // Build list of events to send
            final Map relevantBindingEvents = getCurrentControlTree().getEventsToDispatch();
            final List eventsToDispatch = new ArrayList();

            // Iterate through controls and check the nodes they are bound to
            visitAllControls(new XFormsControlVisitorAdapter() {
                public void startVisitControl(XFormsControl control) {

                    // We must be an XFormsSingleNodeControl
                    // NOTE: We don't dispatch events to repeat iterations
                    if (!(control instanceof XFormsSingleNodeControl && !(control instanceof XFormsRepeatIterationControl)))
                        return;

                    // This can happen if control is not bound to anything (includes xforms:group[not(@ref) and not(@bind)])
                    final NodeInfo currentNodeInfo = ((XFormsSingleNodeControl) control).getBoundNode();
                    if (currentNodeInfo == null)
                        return;

                    // We only dispatch events for controls bound to a mutable document
                    // TODO: what about initial events? those could be sent.
                    if (!(currentNodeInfo instanceof NodeWrapper))
                        return;

                    // Check if value has changed

                    // NOTE: For the purpose of dispatching value change and MIP events, we used to make a
                    // distinction between value controls and plain single-node controls. However it seems that it is
                    // still reasonable to dispatch those events to xforms:group, xforms:switch, and even repeat
                    // iterations if they are bound.

                    final String effectiveId = control.getEffectiveId();
                    final EventSchedule existingEventSchedule = (relevantBindingEvents == null) ? null : relevantBindingEvents.get(effectiveId);
                                    // ... nothing else
                                    if (isAllowSendingRelevantEvents)
                            }
                        }


                    // Allow dispatching value change to:
                    // o relevant control
                                    addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.VALUE);
                                }
                            } else {
                                if (!isPlainValueChange) {
                                    // Dispatch all the allowed MIP events

                                    if (isAllowSendingRequiredEvents)
                                        addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.REQUIRED);
                    // NOTE: We tried dispatching also during first refresh, but only if it is not a container control
                    // OR if the bound node is simple content. However, right now we have decided against dispatching
                    // this during initialization. See:
                    //
                    //   http://wiki.orbeon.com/forms/doc/contributor-guide/xforms-ui-events

//                     This last part of the logic is there to prevent dispatching spurious value change events for all
                        if (!isShouldSendValueChangeEvent || isPlainValueChange) {
//                     groups during initialization, while still allowing listening to value changes on groups that have
//                     simple content and therefore can hold a value.
//
//                     Whether the control is a container control: group, switch, repeat iteration
//                    final boolean isContainerControl = control instanceof XFormsSingleNodeContainerControl;
//                    final boolean isShouldSendValueChangeEvent
//                            = newRelevantState
//                                && (isControlValueChanged
//                                    || isFirstRefresh && (!isContainerControl || Dom4jUtils.isSimpleContent((Node) ((NodeWrapper) currentNodeInfo).getUnderlyingNode())));

                    // NOTE: In the whole refresh process, no control evaluation takes place. This is needed at this
                    // point because with multiple models, a refresh might occur before all models have been RRR. This
                    // means that evaluating here might incorrect values for MIPs and control values.

                    // Don't dispatch events to static readonly triggers, as they in fact behave as if they were not relevant!
                    if (control instanceof XFormsTriggerControl && XFormsSingleNodeControl.isStaticReadonlyNoEvaluate((XFormsSingleNodeControl) control)) {
                        return;
                    }

                    final boolean newRelevantState = InstanceData.getInheritedRelevant(currentNodeInfo);
                    final boolean isControlValueChanged = InstanceData.isValueChanged(currentNodeInfo);
                    // TODO: if control *becomes* non-relevant and value changed, arguably we should dispatch the value-changed event
                    final boolean isShouldSendValueChangeEvent = newRelevantState && isControlValueChanged;

                    if (isFirstRefresh) {
                        // Special processing for first refresh

                        // Don't dispatch any value change
                        // NOP

                        // Display events only if the control is relevant
                        if (newRelevantState) {

                            // Dispatch xforms-enabled if needed
                            if (isAllowSendingRelevantEvents) {
                                addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.RELEVANT);
                            }

                            // Dispatch events only if the MIP value is different from the default

                            // Dispatch xforms-required if needed
                            if (isAllowSendingRequiredEvents && InstanceData.getRequired(currentNodeInfo)) {
                                addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.REQUIRED);
                            }

                            // Dispatch xforms-readonly if needed
                            if (isAllowSendingReadonlyEvents && InstanceData.getInheritedReadonly(currentNodeInfo)) {
                                addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.READONLY);
                            }

                            // Dispatch xforms-invalid if needed
                            if (isAllowSendingValidEvents && !InstanceData.getValid(currentNodeInfo)) {
                                addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.VALID);
                            }
                        }

                    } else {
                        // Subsequent refreshes

                        if (isShouldSendValueChangeEvent) {
                            if (isAllowSendingValueChangedEvents) {
                                // Dispatch value change and...

                                if (!isPlainValueChange) {
                                    // ... all MIP events
                                    addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.ALL);
                                } else {
                                        addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.RELEVANT);
                                    if (isAllowSendingReadonlyEvents)
                                        addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.READONLY);
                                    if (isAllowSendingValidEvents)
                                        addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.VALID);
                                }
                            // Send individual MIP events
                            // Come here if MIP events are not already handled above

                            // Dispatch xforms-optional/xforms-required if needed
                            if (isAllowSendingRequiredEvents) {
                                // Send only when value has changed
                                final boolean previousRequiredState = InstanceData.getPreviousRequiredState(currentNodeInfo);
                                final boolean newRequiredState = InstanceData.getRequired(currentNodeInfo);

                                if (previousRequiredState != newRequiredState) {
                                    addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.REQUIRED);
                                }
                            }
                            // Dispatch xforms-enabled/xforms-disabled if needed
                            if (isAllowSendingRelevantEvents) {
                                // Send only when value has changed
                                final boolean previousRelevantState = InstanceData.getPreviousInheritedRelevantState(currentNodeInfo);

                                if (previousRelevantState != newRelevantState) {
                                    addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.RELEVANT);
                                }
                            }
                            // Dispatch xforms-readonly/xforms-readwrite if needed
                            if (isAllowSendingReadonlyEvents) {
                                final boolean previousReadonlyState = InstanceData.getPreviousInheritedReadonlyState(currentNodeInfo);
                                final boolean newReadonlyState = InstanceData.getInheritedReadonly(currentNodeInfo);

                                if (previousReadonlyState != newReadonlyState) {
                                    addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.READONLY);
                                }
                            }

                            // Dispatch xforms-valid/xforms-invalid if needed

                            // NOTE: There is no mention in the spec that these events should be displatched automatically
                            // when the value has changed, contrary to the other events above.
                            if (isAllowSendingValidEvents) {
                                final boolean previousValidState = InstanceData.getPreviousValidState(currentNodeInfo);
                                final boolean newValidState = InstanceData.getValid(currentNodeInfo);

                                if (previousValidState != newValidState) {
                                    addEventToSchedule(existingEventSchedule, effectiveId, EventSchedule.VALID);
                                }
                            }
                        }
                    }
                }

                private void addEventToSchedule(EventSchedule eventSchedule, String effectiveControlId, int type) {
                    if (eventSchedule == null)
                        eventsToDispatch.add(new EventSchedule(effectiveControlId, type));
                    else
                        eventSchedule.updateType(type);
                }
            });

            // Clear InstanceData event state
            // NOTE: We clear for all models, as we are processing refresh events for all models here. This may have to be changed in the future.
            containingDocument.synchronizeInstanceDataEventState();
            getCurrentControlTree().clearEventsToDispatch();

            // "Actions that directly invoke rebuild, recalculate, revalidate, or refresh always
            // have an immediate effect, and clear the corresponding flag."
            model.refreshDone();

            // Add "relevant binding" events
            if (relevantBindingEvents != null)
                eventsToDispatch.addAll(relevantBindingEvents.values());

            // Send events and (try to) make sure the event corresponds to the current instance data
            // NOTE: event order and the exact steps to take are under-specified in 1.0.
            for (EventSchedule eventSchedule : eventsToDispatch) {

                final String controlInfoId = eventSchedule.getEffectiveControlId();
                final int type = eventSchedule.getType();
                final boolean isRelevantBindingEvent = (type & EventSchedule.RELEVANT_BINDING) != 0;

                final XFormsControl xformsControl = (XFormsControl) getObjectByEffectiveId(controlInfoId);

                if (!isRelevantBindingEvent) {
                    // Regular type of event
>>>>>>> 4a6d2c0a2704e73705cfb3c0dbd5415b21130425

            if (currentControlTree.isAllowSendingRefreshEvents()) {
                // There are potentially event handlers for UI events, so do the whole processing

            return;
        }

        indentedLogger.startHandleOperation("model", "performing refresh", "container id", container.getEffectiveId());
        {
            // Update control bindings
            updateControlBindingsIfNeeded(propertyContext);
            // Update control values
            evaluateControlValuesIfNeeded(propertyContext, true);

            if (currentControlTree.isAllowSendingRefreshEvents()) {
                // There are potentially event handlers for UI events, so do the whole processing