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);
        }

	void Start()
	{
		data = MainSystem.Instance.gameData;

		nowType = StateType.human;
		SetTexture (nowType);

		SetData ();

		GUIController.Instance.SetCoolTime (data.StomacCoolTime, data.TrainingCoolTime, data.PreachingCoolTime);

		GUIController.Instance.OnButtonDownStomac = () => {
			Stomac += data.GainStomacValue * (1 - Hotoke * 0.005f);
		};
		GUIController.Instance.OnButtonDownTreaning = () => {
			Hotoke += data.GainHotokeValue;
			hide = true;
		};
		GUIController.Instance.OnButtonDownPreaching = () => {
			Faith += data.GainFaithValue * (1 + Hotoke * 0.01f);
			hide = true;
		};

		GUIController.Instance.OnCoolFinish = () => {
			hide = false;
		};
	}

		protected override IPropertyEditor CreateEditor (Gdk.Rectangle cell_area, StateType state)
		{
			if (Property.Converter.CanConvertTo (typeof(string)) && Property.Converter.CanConvertFrom (typeof(string)))
				return new TextEditor ();
			else
				return null;
		}

		public static void Add(string description, string userName, Device panelDevice = null, Device device = null, Zone zone = null, StateType stateType = StateType.Info)
		{
			var journalItem = new FS2JournalItem
			{
				DeviceTime = DateTime.Now,
				SystemTime = DateTime.Now,
				Description = description,
				UserName = userName,
				PanelDevice = panelDevice,
				Device = device,
				StateType = stateType,
				SubsystemType = SubsystemType.Other,
			};
			if (panelDevice != null)
			{
				journalItem.PanelName = panelDevice.DottedPresentationNameAndAddress;
				journalItem.PanelUID = panelDevice.UID;
			}
			if (device != null)
			{
				journalItem.DeviceName = device.DottedPresentationNameAndAddress;
				journalItem.DeviceUID = device.UID;
			}
			if (zone != null)
			{
				journalItem.ZoneNo = zone.No;
				journalItem.ZoneName = zone.PresentationName;
			}

			AddJournalItem(journalItem);
		}

        public override void Render(Drawable window,
                                     Widget widget,
                                     Rectangle cell_area,
                                     Rectangle expose_area,
                                     StateType cell_state,
                                     IPhoto photo)
        {
            string text = GetRenderText (photo);

            var layout = new Pango.Layout (widget.PangoContext);
            layout.SetText (text);

            Rectangle layout_bounds;
            layout.GetPixelSize (out layout_bounds.Width, out layout_bounds.Height);

            layout_bounds.Y = cell_area.Y;
            layout_bounds.X = cell_area.X + (cell_area.Width - layout_bounds.Width) / 2;

            if (layout_bounds.IntersectsWith (expose_area)) {
                Style.PaintLayout (widget.Style, window, cell_state,
                                   true, expose_area, widget, "IconView",
                                   layout_bounds.X, layout_bounds.Y,
                                   layout);
            }
        }

		public EditSession StartEditing (Gdk.Rectangle cell_area, StateType state)
		{
			IPropertyEditor ed = CreateEditor (cell_area, state);
			if (ed == null)
				return null;
			return new EditSession (container, obj, property, ed);
		}