bool isAllowMixed = Enumeration.IsMixedVertexProcessingPossible;

            foreach(EnumDeviceSettingsCombo edsc in edi.deviceSettingsList)
            {
                if (edsc.IsWindowed == globalSettings.presentParams.Windowed &&
                    edsc.AdapterFormat == adapterFormat &&
                    edsc.BackBufferFormat == backFormat)
                {
                    // Clear the depth stencil buffer
                    depthStencilCombo.Clear();
                    depthStencilCombo.IsEnabled = (globalSettings.presentParams.EnableAutoDepthStencil);
                    if (globalSettings.presentParams.EnableAutoDepthStencil)
                    {
                        foreach(Format f in edsc.depthStencilFormatList)
                        {
                            if (!depthStencilCombo.ContainsItem(f.ToString()))
                                depthStencilCombo.AddItem(f.ToString(), f);
                        }

                        depthStencilCombo.SetSelectedByData(globalSettings.presentParams.AutoDepthStencilFormat);
                    }
                    else
                    {
                        if (!depthStencilCombo.ContainsItem("(not used)") )
                            depthStencilCombo.AddItem("(not used)", null);
                    }
                    OnDepthStencilChanged(depthStencilCombo, e);

                    // Now remove all the vertex processing information
                    vertexCombo.Clear();
                    if (isAllowPure)
                        AddVertexProcessing(CreateFlags.PureDevice);
                    if (isAllowHardware)
                        AddVertexProcessing(CreateFlags.HardwareVertexProcessing);
                    if (isAllowSoftware)
                        AddVertexProcessing(CreateFlags.SoftwareVertexProcessing);
                    if (isAllowMixed)
                        AddVertexProcessing(CreateFlags.MixedVertexProcessing);

                    // Select the right one
                    BehaviorFlags flags = new BehaviorFlags(globalSettings.BehaviorFlags);
                    if (flags.PureDevice)
                        vertexCombo.SetSelectedByData(CreateFlags.PureDevice);
                    else if (flags.HardwareVertexProcessing)
                        vertexCombo.SetSelectedByData(CreateFlags.HardwareVertexProcessing);
                    else if (flags.SoftwareVertexProcessing)
                        vertexCombo.SetSelectedByData(CreateFlags.SoftwareVertexProcessing);
                    else if (flags.MixedVertexProcessing)
                        vertexCombo.SetSelectedByData(CreateFlags.MixedVertexProcessing);

                    OnVertexProcessingChanged(vertexCombo, e);

                    // Now present intervals
                    presentCombo.Clear();
                    foreach(PresentInterval pf in edsc.presentIntervalList)
                    {
                        if (!presentCombo.ContainsItem(pf.ToString()))
                            presentCombo.AddItem(pf.ToString(), pf);
                    }

                    presentCombo.SetSelectedByData(globalSettings.presentParams.PresentationInterval);
                    OnPresentIntervalChanged(presentCombo, e);
                }
            }

        }
        
        /// <summary>Called when the depth stencil changes</summary>
        private void OnDepthStencilChanged(object sender, EventArgs e)
        {
            ComboBox cb = sender as ComboBox;
            DepthFormat stencilFormat = (DepthFormat)cb.GetSelectedData();

            if (globalSettings.presentParams.EnableAutoDepthStencil)
                globalSettings.presentParams.AutoDepthStencilFormat = stencilFormat;

            EnumDeviceSettingsCombo combo = GetCurrentDeviceSettingsCombo();

            // Remove all of the multisample items and add the new ones
            multiSampleTypeCombo.Clear();
            foreach(MultiSampleType mst in combo.multiSampleTypeList)
            {
                bool conflictFound = false;
                foreach(EnumDepthStencilMultisampleConflict c in combo.depthStencilConflictList)
                {
                    if (c.DepthStencilFormat == stencilFormat &&
                        c.MultisampleType == mst)
                    {
                        conflictFound = true;
                        break;
                    }
                }

                if (!conflictFound)
                {
                    if (!multiSampleTypeCombo.ContainsItem(mst.ToString()))
                        multiSampleTypeCombo.AddItem(mst.ToString(), mst);
                }
            }
            // Select the correct multisampling type
            multiSampleTypeCombo.SetSelectedByData(globalSettings.presentParams.MultiSample);
            OnMultisampleTypeChanged(multiSampleTypeCombo, e);
        }
        
        /// <summary>Called when the multisample type changes</summary>
        private void OnMultisampleTypeChanged(object sender, EventArgs e)
        {
            ComboBox cb = sender as ComboBox;
            MultiSampleType mst = (MultiSampleType)cb.GetSelectedData();
            globalSettings.presentParams.MultiSample = mst;

            EnumDeviceSettingsCombo combo = GetCurrentDeviceSettingsCombo();

            int maxQuality = 0;
            for (int i = 0; i < combo.multiSampleTypeList.Count; i++)
            {
                MultiSampleType msType = (MultiSampleType)combo.multiSampleTypeList[i];
                if (msType == mst)
                {
                    maxQuality = (int)combo.multiSampleQualityList[i];
                }
            }

            // We have the max quality now, add to our list
            multiSampleQualityCombo.Clear();
            for(int i = 0; i < maxQuality; i++)
            {
                if (!multiSampleQualityCombo.ContainsItem(i.ToString()))
                    multiSampleQualityCombo.AddItem(i.ToString(), i);
            }
            multiSampleQualityCombo.SetSelectedByData(globalSettings.presentParams.MultiSampleQuality);
            OnMultisampleQualityChanged(multiSampleQualityCombo, e);
        }
        /// <summary>Called when the multisample quality changes</summary>
        private void OnMultisampleQualityChanged(object sender, EventArgs e)
        {
            ComboBox cb = sender as ComboBox;
            globalSettings.presentParams.MultiSampleQuality = (int)cb.GetSelectedData();
        }
        /// <summary>Called when the vertex processing changes</summary>
        private void OnVertexProcessingChanged(object sender, EventArgs e)
        {
            ComboBox cb = sender as ComboBox;

            CreateFlags behavior = globalSettings.BehaviorFlags;

            // Clear flags
            behavior &= ~CreateFlags.HardwareVertexProcessing;
            behavior &= ~CreateFlags.SoftwareVertexProcessing;
            behavior &= ~CreateFlags.PureDevice;
            behavior &= ~CreateFlags.MixedVertexProcessing;

            // Determine new flags
            CreateFlags newFlags = (CreateFlags)vertexCombo.GetSelectedData();
            if ((newFlags & CreateFlags.PureDevice) != 0)
                newFlags |= CreateFlags.HardwareVertexProcessing;

            // Make changes
            globalSettings.BehaviorFlags = behavior | newFlags;
        }
        /// <summary>Called when the presentation interval changes</summary>
        private void OnPresentIntervalChanged(object sender, EventArgs e)
        {
            ComboBox cb = sender as ComboBox;
            globalSettings.presentParams.PresentationInterval = (PresentInterval)cb.GetSelectedData();
        }
        /// <summary>Called when the clip to window state changes</summary>
        private void OnClipWindowChanged(object sender, EventArgs e)
        {
            Checkbox cb = sender as Checkbox;
            if (cb.IsChecked)
                globalSettings.presentParams.PresentFlag |= PresentFlag.DeviceClip;
            else
                globalSettings.presentParams.PresentFlag &= ~PresentFlag.DeviceClip;
        }
        /// <summary>Called when the fullscreen or windowed item changes</summary>
        private void OnWindowedFullscreenChanged(object sender, EventArgs e)
        {
            bool isWindowed = windowedButton.IsChecked;
            globalSettings.presentParams.Windowed = isWindowed;

            // Set the control enabled or disabled properties
            dialog.SetControlEnable((int)SettingsDialogControlIds.AdapterFormatLabel, !isWindowed);
            dialog.SetControlEnable((int)SettingsDialogControlIds.ResolutionLabel, !isWindowed);
            dialog.SetControlEnable((int)SettingsDialogControlIds.RefreshRateLabel, !isWindowed);

            dialog.SetControlEnable((int)SettingsDialogControlIds.AdapterFormat, !isWindowed);
            dialog.SetControlEnable((int)SettingsDialogControlIds.Resolution, !isWindowed);
            dialog.SetControlEnable((int)SettingsDialogControlIds.RefreshRate, !isWindowed);
            dialog.SetControlEnable((int)SettingsDialogControlIds.DeviceClip, isWindowed);

            bool deviceClip = ((globalSettings.presentParams.PresentFlag & PresentFlag.DeviceClip) != 0);

            // If windowed, get the appropriate adapter format from Direct3D
            if (globalSettings.presentParams.Windowed)
            {
                DisplayMode mode = Manager.Adapters[(int)globalSettings.AdapterOrdinal].CurrentDisplayMode;
                globalSettings.AdapterFormat = mode.Format;
                globalSettings.presentParams.BackBufferWidth = mode.Width;
                globalSettings.presentParams.BackBufferHeight = mode.Height;
                globalSettings.presentParams.FullScreenRefreshRateInHz = mode.RefreshRate;
            }

            // Update the clip check box
            clipBox.IsChecked = deviceClip;

            // Update the adapter format list
            adapterFormatCombo.Clear();

            EnumDeviceInformation edi = GetCurrentDeviceInfo();

            if (isWindowed)
            {
                if (!adapterFormatCombo.ContainsItem(globalSettings.AdapterFormat.ToString()))
                    adapterFormatCombo.AddItem(globalSettings.AdapterFormat.ToString(), globalSettings.AdapterFormat);
            }
            else
            {
                // Add all the supported formats
                foreach(EnumDeviceSettingsCombo edsc in edi.deviceSettingsList)
                {
                    if (!adapterFormatCombo.ContainsItem(edsc.AdapterFormat.ToString()))
                        adapterFormatCombo.AddItem(edsc.AdapterFormat.ToString(), edsc.AdapterFormat);
                }
            }
            adapterFormatCombo.SetSelectedByData(globalSettings.AdapterFormat);
            // Adapter format changed, update there
            OnAdapterFormatChange(adapterFormatCombo, EventArgs.Empty);

            // Update resolution
            if (isWindowed)
            {
                resolution.Clear();
                AddResolution((short)globalSettings.presentParams.BackBufferWidth, (short)globalSettings.presentParams.BackBufferHeight);
            }
            resolution.SetSelectedByData(NativeMethods.MakeUInt32(
                (short)globalSettings.presentParams.BackBufferWidth, (short)globalSettings.presentParams.BackBufferHeight));

            // Resolution changed
            OnResolutionChanged(resolution, EventArgs.Empty);

            // Update refresh
            if (isWindowed)
            {
                refreshCombo.Clear();
                AddRefreshRate(globalSettings.presentParams.FullScreenRefreshRateInHz);
            }

            // Select the correct refresh rate
            refreshCombo.SetSelectedByData(globalSettings.presentParams.FullScreenRefreshRateInHz);

            // refresh rate changed
            OnRefreshRateChanged(refreshCombo, EventArgs.Empty);
        }
        /// <summary>Called when the cancel button is clicked</summary>
        private void OnCancelClicked(object sender, EventArgs e)
        {
            // Nothing left to do, quit showing the screen
            parent.ShowSettingsDialog(false);
        }
        /// <summary>Called when the ok button is clicked</summary>
        private void OnOkClicked(object sender, EventArgs e)
        {
            // The device needs to be updated
            if (globalSettings.presentParams.Windowed)
            {
                globalSettings.presentParams.FullScreenRefreshRateInHz = 0;
                globalSettings.presentParams.BackBufferWidth = (int)windowWidth;
                globalSettings.presentParams.BackBufferHeight = (int)windowHeight;
            }

            if (globalSettings.presentParams.MultiSample != MultiSampleType.None)
            {
                globalSettings.presentParams.PresentFlag &= ~PresentFlag.LockableBackBuffer;
            }

            // Create a device
            parent.CreateDeviceFromSettings(globalSettings);

            // Stop showing the dialog now
            parent.ShowSettingsDialog(false);
        }
        #endregion
    }
}