C# StateType类代码示例

 public DataSource(TwainDevice twain, TwIdentity identity)
 {
   fTwain = twain;
   fIdent = identity;
   fState = StateType.Closed;
   fSettings = null;
   fCapabilities = null;
 }

        public void ChangeState(StateType type)
        {
            if (EditPanel.LayerInfo == null)
                return;

            switch (type)
            {
                case StateType.CreateButton:
                    m_currentState = new CreateControlState(new CreateButton(m_editPanel), this, m_commandManager);
                    break;
                case StateType.CreateLabel:
                    m_currentState = new CreateControlState(new CreateLabel(m_editPanel), this, m_commandManager);
                    break;
                case StateType.CreatePanel:
                    m_currentState = new CreateControlState(new CreatePanel(m_editPanel), this, m_commandManager);
                    break;
                case StateType.Move:
                    m_currentState = new MoveState(m_editPanel.SelectedControls, this, m_commandManager);
                    break;
                case StateType.Resize:
                    m_currentState = new ResizeControlState(m_editPanel.SelectedControls, this, m_commandManager, m_flagPosition);
                    break;
                case StateType.Idle:
                    m_currentState = new IdleState(m_editPanel, this, m_commandManager);
                    break;
            }
        }

 void Awake()
 {
     // 減算から開始する
     stateType = StateType.Sub;
     image = GetComponent<Image>();
     color = image.color;
 }

 void CheckLength()
 {
     if( ( transform.position - PlayerControl.player.transform.position ).magnitude > LengthLimitation )
     {
         state = StateType.Recive;
     }
 }

        public override void Render (CellContext context, StateType state, double cellWidth, double cellHeight)
        {
            if (data_handler == null) {
                return;
            }

            if (!has_sort) {
                base.Render (context, state, cellWidth, cellHeight);
                return;
            }

            Gdk.Rectangle arrow_alloc = new Gdk.Rectangle ();
            arrow_alloc.Width = (int)(cellHeight / 3.0);
            arrow_alloc.Height = (int)((double)arrow_alloc.Width / 1.6);
            arrow_alloc.X = (int)cellWidth - arrow_alloc.Width - Spacing;
            arrow_alloc.Y = ((int)cellHeight - arrow_alloc.Height) / 2;

            double textWidth = arrow_alloc.X - Spacing;
            if (textWidth > 0) {
                base.Render (context, state, textWidth, cellHeight);
            }

            SortType sort_type = ((ISortableColumn)data_handler ()).SortType;
            if (sort_type != SortType.None) {
                context.Theme.DrawArrow (context.Context, arrow_alloc, sort_type);
            }
        }

 protected override void observer(StateType x, double t)
 {
     if (OdeObserver != null)
     {
         OdeObserver(x, t);
     }
 }

 protected override void system(StateType x, StateType dxdt, double t)
 {
     if (OdeSystem != null)
     {
         OdeSystem(x, dxdt, t);
     }
 }

 /// <summary>
 /// Construct a <see cref="ZoomState"/> object from the scale ranges settings contained
 /// in the specified <see cref="GraphPane"/>.
 /// </summary>
 /// <param name="pane">The <see cref="GraphPane"/> from which to obtain the scale
 /// range values.
 /// </param>
 /// <param name="type">A <see cref="StateType"/> enumeration that indicates whether
 /// this saved state is from a pan or zoom.</param>
 public ZoomState(GraphPane pane, StateType type)
 {
     _xAxis = new ScaleState(pane.XAxis);
     _yAxis = new ScaleStateList(pane.YAxisList);
     _y2Axis = new ScaleStateList(pane.Y2AxisList);
     _type = type;
 }

                    public IEnumerable<Tuple<DiagnosticState, ProviderId, StateType>> GetAllExistingDiagnosticStates(StateType type, string languageOpt)
                    {
                        if (languageOpt != null)
                        {
                            PerLanguageAnalyzersAndStates analyzersStates;
                            if (_perLanguageAnalyzersAndStatesMap.TryGetValue(languageOpt, out analyzersStates))
                            {
                                return analyzersStates.GetAllExistingDiagnosticStates(type);
                            }
                            else
                            {
                                return SpecializedCollections.EmptyEnumerable<Tuple<DiagnosticState, ProviderId, StateType>>();
                            }
                        }

                        // This might be a removed or closed document/project/solution.
                        // Return all existing states.
                        var current = SpecializedCollections.EmptyEnumerable<Tuple<DiagnosticState, ProviderId, StateType>>();
                        foreach (var analyzersAndStates in _perLanguageAnalyzersAndStatesMap.Values)
                        {
                            current = current.Concat(analyzersAndStates.GetAllExistingDiagnosticStates(type));
                        }

                        return current;
                    }

        public void SwitchState(StateType type)
        {
            switch (type)
            {
                case StateType.MainMenu:
                    if (Logic.CurrentParty != null && Logic.CurrentWorld != null)
                    {
                        for (int i = 0; i < Logic.CurrentParty.MainParty.MyParty.Count; i++)
                        {
                            Logic.CurrentParty.MainParty.MyParty[i].CurMap.SpawnedLivingThing[Logic.CurrentParty.MainParty.MyParty[i].Y + Logic.CurrentParty.MainParty.MyParty[i].CurMap.MinY][Logic.CurrentParty.MainParty.MyParty[i].X + Logic.CurrentParty.MainParty.MyParty[i].CurMap.MinX].Remove(Logic.CurrentParty.MainParty.MyParty[i].Index);
                            Logic.CurrentParty.MainParty.MyParty[i].CurMap.LivingThing[Logic.CurrentParty.MainParty.MyParty[i].Index] = null;
                        }
                        CurrentState = 0;
                    }
                    break;
                case StateType.InGame:
                    if (Logic.CurrentParty != null && Logic.CurrentWorld != null)
                    {
                        for (int i = 0; i < Logic.CurrentParty.MainParty.MyParty.Count; i++)
                        {
                            Logic.CurrentParty.MainParty.MyParty[i].OnMapType = Logic.CurrentWorld.SpawnPlaceMapType;
                            Logic.CurrentParty.MainParty.MyParty[i].SideMapID = Logic.CurrentWorld.SpawnMapIndex;
                            Logic.CurrentParty.MainParty.MyParty[i].X = Logic.CurrentWorld.SpawnMapX;
                            Logic.CurrentParty.MainParty.MyParty[i].Y = Logic.CurrentWorld.SpawnMapY;
                            Logic.CurrentParty.MainParty.MyParty[i].PutOnMap();

                            InGameState s = (InGameState)Program.SM.States[1];
                            s.Initialize();
                            CurrentState = 1;
                        }
                    }
                    break;
            }
        }

 protected override void observer(StateType x, double t)
 {
     if (x.Capacity != 0)
     {
         Console.WriteLine("{0} : {1} : {2}", x[0], x[1], x[2]);
     }
 }

	public void GoToState( StateType newState ) {
		if ( curState != null ) {
			curState.UnLoad();
		}
		switch ( newState ) {
			case StateType.Menu:
				Header.ShowBack = false;
				Header.IsShow = true;
				Header.UpdateInfo();
				curState = Menu;
				break;
			case StateType.Character:
				Header.ShowBack = true;
				curState = Character;
				break;
			case StateType.Map:
				Header.ShowBack = true;
				curState = Map;
				break;
			case StateType.MatchScore:
				curState = MatchScore;
				break;
			case StateType.EnterName:
				curState = EnterName;
				break;
			default:
				Debug.LogError( "state " + newState + " doesn't implemented!" );
				break;
		}
		curState.Load();
	}

 public DeviceViewModel(DeviceState deviceState)
 {
     DeviceState = deviceState;
     _stateType = deviceState.StateType;
     FiresecCallbackService.DeviceStateChangedEvent += new Action<Guid>(OnDeviceStateChangedEvent);
     Name = DeviceState.Device.Driver.ShortName + " - " + DeviceState.Device.DottedAddress;
 }

 public void Push( Vector3 dir )
 {
     transform.position = PlayerControl.player.transform.position;
     rigidbody.velocity = dir.normalized * PlayerControl.HandPushspeed;
     state = StateType.Throw;
     Debug.Log("Push");
 }

        public override void Render(CellContext context, StateType state, double cellWidth, double cellHeight)
        {
            if (BoundObject == null) {
                return;
            }

            if (!(BoundObject is TrackInfo)) {
                throw new InvalidCastException ("CubanoTitleCell can only bind to TrackInfo objects");
            }

            TrackInfo track = (TrackInfo)BoundObject;

            context.Layout.Width = (int)((cellWidth - 8) * Pango.Scale.PangoScale);
            context.Layout.Ellipsize = Pango.EllipsizeMode.End;
            //context.Layout.FontDescription = context.Widget.PangoContext.FontDescription.Copy ();
            context.Layout.FontDescription.Weight = font_weight;
            context.Layout.SetMarkup (String.Format ("<big>{0}</big>  {1}",
                track.TrackNumber,
                GLib.Markup.EscapeText (track.DisplayTrackTitle)));

            int text_width;
            int text_height;
            context.Layout.GetPixelSize (out text_width, out text_height);

            context.Context.MoveTo (4, ((int)cellHeight - text_height) / 2);
            Cairo.Color color = context.Theme.Colors.GetWidgetColor (
                context.TextAsForeground ? GtkColorClass.Foreground : GtkColorClass.Text, state);
            color.A = (!context.Sensitive) ? 0.3 : 1.0;
            context.Context.Color = color;

            PangoCairoHelper.ShowLayout (context.Context, context.Layout);
        }