public override void Bind(Bind Options)
        {
            Console.WriteLine ("Bind Account:{0} PIN:{1}",
                Options.Account.Value, Options.PIN.Value);

            TicketBroker TicketBroker = new TicketBroker () ;

            TicketBroker.Bind (Options.Account.Value, Options.PIN.Value);
        }

 public Window(Main _controller, Model.Buffer _model)
 {
     Controller = _controller;
     Model = new Bind<Model.Buffer>(_model);
     CurrentMode = new BindList<WindowMode>();
     CurrentMode.Event.Changed += (list) => { CurrentKeyMap = list.FoldLeft(EmptyKeyMap, (a, b) => a + b.KeyMap); };
     CurrentMode.Add(Controller.WindowModes[0]);
     CurrentMode.Add(Controller.WindowModes[2]);
     CurrentMode.Add(Controller.WindowModes[3]);
     Parser = new CommandParser();
 }

 public Window(Main _controller, Model.Buffer _model)
 {
     Controller = _controller;
     Model = new Bind<Model.Buffer>(_model);
     CurrentMode = new BindSet<WindowMode>();
     CurrentMode.Changed.Add(() =>
     {
         CurrentKeyMap = CurrentMode.ToList().FoldLeft(EmptyKeyMap, (a, b) => a + b.KeyMap);
     });
     DefaultMode.ForEach(CurrentMode.Add);
     Parser = new CommandParser();
 }

 public BindData(Bind bind)
 {
     control = bind.control;
     keys = bind.keys;
 }

 public new DatePicker Cursor( Bind<System.Windows.Input.Cursor> bind )
 {
     return  base.Cursor( bind ) as DatePicker;
 }

        void TranslateType(Bind.Structures.Type type,
            XPathNavigator function_override, XPathNavigator overrides,
            EnumProcessor enum_processor, EnumCollection enums,
            string category, string apiname)
        {
            Bind.Structures.Enum @enum;
            string s;

            category = enum_processor.TranslateEnumName(category);

            // Try to find out if it is an enum. If the type exists in the normal GLEnums list, use this.
            // Special case for Boolean which is there simply because C89 does not support bool types.
            // We don't really need that in C#
            bool normal =
                enums.TryGetValue(type.CurrentType, out @enum) ||
                enums.TryGetValue(enum_processor.TranslateEnumName(type.CurrentType), out @enum);

            // Translate enum types
            type.IsEnum = false;
            if (normal && @enum.Name != "GLenum" && @enum.Name != "Boolean")
            {
                type.IsEnum = true;

                if ((Settings.Compatibility & Settings.Legacy.ConstIntEnums) != Settings.Legacy.None)
                {
                    type.QualifiedType = "int";
                }
                else
                {
                    // Some functions and enums have the same names.
                    // Make sure we reference the enums rather than the functions.
                    if (normal)
                    {
                        type.QualifiedType = String.Format("{0}.{1}", Settings.EnumsOutput, @enum.Name);
                    }
                }
            }
            else if (Generator.GLTypes.TryGetValue(type.CurrentType, out s))
            {
                // Check if the parameter is a generic GLenum. If it is, search for a better match,
                // otherwise fallback to Settings.CompleteEnumName (named 'All' by default).
                if (s.Contains("GLenum") /*&& !String.IsNullOrEmpty(category)*/)
                {
                    type.IsEnum = true;

                    if ((Settings.Compatibility & Settings.Legacy.ConstIntEnums) != Settings.Legacy.None)
                    {
                        type.QualifiedType = "int";
                    }
                    else
                    {
                        // Better match: enum.Name == function.Category (e.g. GL_VERSION_1_1 etc)
                        // Note: for backwards compatibility we use "category" only for the gl api.
                        // glcore, gles1 and gles2 use the All enum instead.
                        if (apiname == "gl" && enums.ContainsKey(category))
                        {
                            type.QualifiedType = String.Format("{0}{1}{2}", Settings.EnumsOutput,
                                Settings.NamespaceSeparator, enum_processor.TranslateEnumName(category));
                        }
                        else
                        {
                            type.QualifiedType = String.Format("{0}{1}{2}", Settings.EnumsOutput,
                                Settings.NamespaceSeparator, Settings.CompleteEnumName);
                        }
                    }
                }
                else
                {
                    // Todo: what is the point of this here? It is overwritten below.
                    // A few translations for consistency
                    switch (type.CurrentType.ToLower())
                    {
                        case "string":
                            type.QualifiedType = "String";
                            break;
                    }

                    type.QualifiedType = s;
                }
            }

            type.CurrentType =
                Generator.CSTypes.ContainsKey(type.CurrentType) ?
                Generator.CSTypes[type.CurrentType] : type.CurrentType;

            // Make sure that enum parameters follow enum overrides, i.e.
            // if enum ErrorCodes is overriden to ErrorCode, then parameters
            // of type ErrorCodes should also be overriden to ErrorCode.
            XPathNavigator enum_override = overrides.SelectSingleNode(
                EnumProcessor.GetOverridesPath(apiname, type.CurrentType));
            if (enum_override != null)
            {
                // For consistency - many overrides use string instead of String.
                if (enum_override.Value == "string")
                    type.QualifiedType = "String";
                else if (enum_override.Value == "StringBuilder")
                    type.QualifiedType = "StringBuilder";
                else
                    type.CurrentType = enum_override.Value;
            }
//.........这里部分代码省略.........

 public new AccessText Visibility( Bind<System.Windows.Visibility> bind )
 {
     return  base.Visibility( bind ) as AccessText;
 }

 public void Write(Bind.Structures.Function f)
 {
     foreach (string s in splitLines.Split(f.ToString()))
         WriteLine(s);
 }

        private static void Handle_Bind(
					OBPClient Dispatch, string[] args, int index)
        {
            Bind		Options = new Bind ();

            Registry Registry = new Registry ();

            Options.Account.Register ("account", Registry, (int) TagType_Bind.Account);
            Options.PIN.Register ("pin", Registry, (int) TagType_Bind.PIN);
            Options.Server.Register ("server", Registry, (int) TagType_Bind.Server);
            Options.Port.Register ("port", Registry, (int) TagType_Bind.Port);

            // looking for parameter Param.Name}
            if (index < args.Length && !IsFlag (args [index][0] )) {
                // Have got the parameter, call the parameter value method
                Options.Account.Parameter (args [index]);
                index++;
                }
            // looking for parameter Param.Name}
            if (index < args.Length && !IsFlag (args [index][0] )) {
                // Have got the parameter, call the parameter value method
                Options.PIN.Parameter (args [index]);
                index++;
                }

            #pragma warning disable 162
            for (int i = index; i< args.Length; i++) {
                if 	(!IsFlag (args [i][0] )) {
                    throw new Exception ("Unexpected parameter: " + args[i]);}
                string Rest = args [i].Substring (1);

                TagType_Bind TagType = (TagType_Bind) Registry.Find (Rest);

                // here have the cases for what to do with it.

                switch (TagType) {
                    case TagType_Bind.Server : {
                        int OptionParams = Options.Server.Tag (Rest);

                        if (OptionParams>0 && ((i+1) < args.Length)) {
                            if 	(!IsFlag (args [i+1][0] )) {
                                i++;
                                Options.Server.Parameter (args[i]);
                                }
                            }
                        break;
                        }
                    case TagType_Bind.Port : {
                        int OptionParams = Options.Port.Tag (Rest);

                        if (OptionParams>0 && ((i+1) < args.Length)) {
                            if 	(!IsFlag (args [i+1][0] )) {
                                i++;
                                Options.Port.Parameter (args[i]);
                                }
                            }
                        break;
                        }
                    default : throw new Exception ("Internal error");
                    }
                }

            #pragma warning restore 162
            Dispatch.Bind (Options);
        }

 public Control Height( Bind<double> height )
 {
     C.Height = height.V;
     return this;
 }

 public new DatePicker AllowDrop( Bind<System.Boolean> bind )
 {
     return  base.AllowDrop( bind ) as DatePicker;
 }

 public new AccessText Width( Bind<System.Double> bind )
 {
     return  base.Width( bind ) as AccessText;
 }

 public Control AllowDrop( Bind<bool> allowDrop )
 {
     C.AllowDrop = allowDrop.V;
     return this;
 }

 public new DatePicker ContextMenu( Bind<System.Windows.Controls.ContextMenu> bind )
 {
     return  base.ContextMenu( bind ) as DatePicker;
 }

 public new DatePicker ClipToBounds( Bind<System.Boolean> bind )
 {
     return  base.ClipToBounds( bind ) as DatePicker;
 }

 public DatePicker CalendarStyle( Bind<System.Windows.Style> bind )
 {
     C.CalendarStyle = bind.V;
     return this;
 }

 public DatePicker BorderThickness( Bind<System.Windows.Thickness> bind )
 {
     C.BorderThickness = bind.V;
     return this;
 }

 public DatePicker BorderBrush( Bind<System.Windows.Media.Brush> bind )
 {
     C.BorderBrush = bind.V;
     return this;
 }

 public Control Background( Bind<System.Windows.Media.Brush> background )
 {
     C.Background = background;
     return this;
 }

 public new DatePicker DataContext( Bind<System.Object> bind )
 {
     return  base.DataContext( bind ) as DatePicker;
 }