* Boolean preference whether to show inferior processes in the debug view. Default is <code>true</code>. 

	 * @since 4.0

	 */

	public static final String PREF_SHOW_INFERIORS = "showInferiors"; //$NON-NLS-1$

	/**

		group.setText(MessagesForPreferences.GdbDebugPreferencePage_display_label);

		groupLayout= new GridLayout(3, false);

		group.setLayout(groupLayout);

		group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

		boolField= new BooleanFieldEditor(

				IGdbDebugPreferenceConstants.PREF_SHOW_INFERIORS,

				MessagesForPreferences.GdbDebugPreferencePage_showInferiors_label,

				group);

		boolField.fillIntoGrid(group, 3);

		addField(boolField);

		// need to set layout again

		group.setLayout(groupLayout);

		group= new Group(parent, SWT.NONE);

		store.setDefault(IGdbDebugPreferenceConstants.PREF_SHOW_INFERIORS, true);

	/** @since 2.2 */

	public static String GdbDebugPreferencePage_display_label;

	/** @since 2.2 */

	public static String GdbDebugPreferencePage_showInferiors_label;

/*******************************************************************************

 * Copyright (c) 2011 Ericsson and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     Ericsson - initial API and implementation

 *******************************************************************************/

package org.eclipse.cdt.dsf.gdb.internal.ui.viewmodel.launch;

import org.eclipse.cdt.dsf.concurrent.RequestMonitor;

import org.eclipse.cdt.dsf.debug.ui.viewmodel.launch.StandardProcessVMNode;

import org.eclipse.cdt.dsf.gdb.IGdbDebugPreferenceConstants;

import org.eclipse.cdt.dsf.gdb.internal.ui.GdbUIPlugin;

import org.eclipse.cdt.dsf.gdb.launching.GDBProcess;

import org.eclipse.cdt.dsf.ui.viewmodel.AbstractVMProvider;

import org.eclipse.cdt.dsf.ui.viewmodel.VMDelta;

import org.eclipse.debug.core.DebugEvent;

import org.eclipse.debug.core.ILaunch;

import org.eclipse.debug.core.model.IProcess;

import org.eclipse.debug.internal.ui.viewers.model.provisional.IChildrenCountUpdate;

import org.eclipse.debug.internal.ui.viewers.model.provisional.IChildrenUpdate;

import org.eclipse.debug.internal.ui.viewers.model.provisional.IHasChildrenUpdate;

import org.eclipse.debug.internal.ui.viewers.model.provisional.IModelDelta;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.util.IPropertyChangeListener;

import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.jface.viewers.TreePath;

/**

 * Layout node for the standard platform debug model IProcess object. This 

 * node requires that an ILaunch object be found as an ancestor of this node.  

 * It does not implement the label provider functionality, so the default 

 * adapters should be used to retrieve the label.  

 */

public class GdbStandardProcessVMNode extends StandardProcessVMNode {

	private Class<?> fProcessType = IProcess.class;

	private IPropertyChangeListener fPropertyListener = new IPropertyChangeListener() {

		public void propertyChange(PropertyChangeEvent event) {

			if (event.getProperty().equals(IGdbDebugPreferenceConstants.PREF_SHOW_INFERIORS)) {

				showInferiors((Boolean)event.getNewValue());

				// khouzam, need to refresh the debug view...				

			}

		}

	};

    public GdbStandardProcessVMNode(AbstractVMProvider provider) {

        super(provider);

        IPreferenceStore store = GdbUIPlugin.getDefault().getPreferenceStore();

		showInferiors(store.getBoolean(IGdbDebugPreferenceConstants.PREF_SHOW_INFERIORS));

		store.addPropertyChangeListener(fPropertyListener);

    }

    @Override

    public String toString() {

        return "GdbStandardProcessVMNode";  //$NON-NLS-1$ 

    }

    @Override

    public void dispose() {

		GdbUIPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(fPropertyListener);

		super.dispose();

    }

    private void showInferiors(boolean show) {

		if (show) {

			fProcessType = IProcess.class;

		} else {

			fProcessType = GDBProcess.class;

		}    	

    }

    @Override

    public void update(IChildrenUpdate[] updates) {

        for (IChildrenUpdate update : updates) {

            ILaunch launch = findLaunch(update.getElementPath());

            if (launch == null) {

                // There is no launch in the parent of this node.  This means that the 

                // layout is misconfigured.  

                assert false; 

                update.done();

                continue;

            }

            /*

             * Assume that the process objects are stored within the launch, and 

             * retrieve them on dispatch thread.  

             */

            int count = 0;

            for (IProcess process : launch.getProcesses()) {

            	if (fProcessType.isAssignableFrom(process.getClass())) {

            		update.setChild(process, count++);

            	}

            }

            update.done();

        }

    }

    @Override

    public void update(final IChildrenCountUpdate[] updates) {

        for (IChildrenCountUpdate update : updates) {

            if (!checkUpdate(update)) continue;

            ILaunch launch = findLaunch(update.getElementPath());

            if (launch == null) {

                assert false;

                update.setChildCount(0);

                update.done();

                return;

            }

            int count = 0;

            for (IProcess process : launch.getProcesses()) {

            	if (fProcessType.isAssignableFrom(process.getClass())) {

            		count++;

            	}

            }

            update.setChildCount(count);

            update.done();

        }

    }

    // @see org.eclipse.cdt.dsf.ui.viewmodel.IViewModelLayoutNode#hasElements(org.eclipse.cdt.dsf.ui.viewmodel.IVMContext, org.eclipse.cdt.dsf.concurrent.DataRequestMonitor)

    @Override

    public void update(IHasChildrenUpdate[] updates) {

        for (IHasChildrenUpdate update : updates) {

            ILaunch launch = findLaunch(update.getElementPath());

            if (launch == null) {

                assert false;

                update.setHasChilren(false);

                update.done();

                return;

            }

            boolean hasChildren = false;

            for (IProcess process : launch.getProcesses()) {

            	if (fProcessType.isAssignableFrom(process.getClass())) {

            		hasChildren = true;

            		break;

            	}

            }

            update.setHasChilren(hasChildren);

            update.done();

        }

    }

    /**

     * Recursively searches the VMC for Launch VMC, and returns its ILaunch.  

     * Returns null if an ILaunch is not found.

     */

    private ILaunch findLaunch(TreePath path) {

        for (int i = path.getSegmentCount() - 1; i >= 0; i--) {

            if (path.getSegment(i) instanceof ILaunch) {

                return (ILaunch)path.getSegment(i);

            }

        }

        return null;

    }

    @Override

    public int getDeltaFlags(Object e) {

        int myFlags = 0;

        if (e instanceof DebugEvent) {

            DebugEvent de = (DebugEvent)e;

            if (fProcessType.isAssignableFrom(de.getSource().getClass()) && 

                 (de.getKind() == DebugEvent.CHANGE || 

                  de.getKind() == DebugEvent.CREATE || 

                  de.getKind() == DebugEvent.TERMINATE) )

            {

                myFlags = IModelDelta.STATE;

            }

        }

        return myFlags;

    }

    @Override

    public void buildDelta(Object e, VMDelta parent, int nodeOffset, RequestMonitor requestMonitor) {

        if (e instanceof DebugEvent && fProcessType.isAssignableFrom(((DebugEvent)e).getSource().getClass())) {

            DebugEvent de = (DebugEvent)e;

            if (de.getKind() == DebugEvent.CHANGE) {

                handleChange(de, parent);

            } else if (de.getKind() == DebugEvent.CREATE) {

                handleCreate(de, parent);

            } else if (de.getKind() == DebugEvent.TERMINATE) {

                handleTerminate(de, parent);

            }

            /*

             * No other node should need to process events related to process.

             * Therefore, just invoke the request monitor without calling super.buildDelta().

             */

        } 

        requestMonitor.done();

    }

}