public ConvertNode(Source source, CodeTreeNode child,
            CodeTreeNode type)
			    : base(source)
        {
            this.child = child;
            this.type = type;
        }

 public SourcePage(Source source)
     : this(source.UniqueId, source.Name, null, source.Order)
 {
     this.source = source;
     source.Properties.PropertyChanged += OnPropertyChanged;
     UpdateIcon ();
 }

        public ErrorsSource(string name, Source source)
            : base(name, 50)
        {
            this.source = source;
            this.source.AddChildSource (this);

            scrolled_window = new ScrolledWindow();
            scrolled_window.ShadowType = ShadowType.In;
            scrolled_window.VscrollbarPolicy = PolicyType.Automatic;
            scrolled_window.HscrollbarPolicy = PolicyType.Automatic;

            view = new TreeView();

            scrolled_window.Add(view);
            scrolled_window.ShowAll();

            TreeViewColumn message_col = view.AppendColumn(Catalog.GetString("Message"),
                new CellRendererText(), "text", 0);
            TreeViewColumn file_col = view.AppendColumn(Catalog.GetString("File Name"),
                new CellRendererText(), "text", 1);

            message_col.Resizable = true;
            file_col.Resizable = true;

            store = new ListStore(typeof(string), typeof(string), typeof(Exception));
            view.Model = store;
        }

        /**
         * Handles an error.
         *
         * The behaviour of this method is defined by the
         * implementation. It may simply record the error message, or
         * it may throw an exception.
         */
        public void handleError(Source source, int line, int column,
					String msg)
        {
            errors++;
            print(source.getName() + ":" + line + ":" + column +
                ": error: " + msg);
        }

 public ILangErrorToken(Source source, ILangErrorCode error, char current)
     : base(source)
 {
     TokenType = "error";
     Value = error;
     Text = current.ToString();
 }

 public SubtractExpression(Source source, object a,
     object b)
         : base(source)
 {
     this.a = (Expression) a;
     this.b = (Expression) b;
 }

 public MultiplyExpression(Source source, object a,
     object b)
         : base(source)
 {
     this.a = (Expression) a;
     this.b = (Expression) b;
 }

 public DatabaseSource (string generic_name, string name, string id, int order, Source parent) : base (generic_name, name, order, id)
 {
     if (parent != null) {
         SetParentSource (parent);
     }
     DatabaseSourceInitialize ();
 }

        public override void CreateOrUpdateOrganization(RmUnifyOrganization organization, Source source)
        {
            using (var context = new UsersContext())
            {
                // Get the school (if it exists)
                School school = (from s in context.Schools
                              where s.RmUnifyOrganizationId == organization.Id
                              select s).SingleOrDefault();

                if (school == null)
                {
                    // School does not exist - create
                    school = new School()
                    {
                        RmUnifyOrganizationId = organization.Id,
                        DisplayName = organization.Name
                    };
                    context.Schools.Add(school);
                    context.SaveChanges();
                }
                else
                {
                    // School exists - update
                    if (school.Deleted != null || school.RmUnifyOrganizationId != organization.Id)
                    {
                        school.Deleted = null;
                        school.RmUnifyOrganizationId = organization.Id;
                        context.SaveChanges();
                    }
                }
            }
        }

		public void ShouldNotMapFromStaticProperties()
		{
			Mapper.CreateMap<Source, Destination>();
			var source = new Source();
			Destination destination = Mapper.Map<Source, Destination>(source);
			Assert.NotEqual(100, destination.Static);
		}

        public DomainEventFunnel(object observable, Source.Of<object> observer)
        {
            this.observable = new WeakReference<object>(observable);
            this.observer = observer;

            GetDomainEventAddMethodsFrom(observable).ForEach(e => e.Invoke(observable, new object[] {observer}));
        }

        public Pascal(String operation, String filePath, String flags)
        {
            try{
                bool intermediate = flags.IndexOf('i') > 1;
                bool xref = flags.IndexOf('x') > 1;
                source = new Source(new StreamReader(filePath));
                source.AddMessageListener(new SourceMessageListener());

                parser = FrontEndFactory.CreateParser("pascal","top-down",source);
                parser.AddMessageListener(new ParserMessageListener());

                backend = BackendFactory.CreateBackend("compile");
                backend.AddMessageListener(new BackendMessageListener());

                parser.Parse();
                source.close();

                intermediateCode = parser.IntermediateCode;
                symbolTable = Parser.SymbolTable;

                backend.Process(intermediateCode,symbolTable);
            }
            catch(Exception ex){
                Console.WriteLine ("Internal translation error");
                Console.WriteLine (ex.StackTrace);
            }
        }

 public AssignExpression(Source source, object to,
     object from)
         : base(source)
 {
     this.from = (Expression) from;
     this.to = (Expression) to;
 }

 void Instance_OnSourceChanged(Source newSource)
 {
     if (newSource != m_currentSource)
     {
         Slide currentSlide = PresentationController.Instance.SelectedSlide;
         if (currentSlide == null)
             return;
         Display disp = currentSlide.DisplayList.Find(d => d.EquipmentType == m_Display.EquipmentType);
         if (disp == null)
             return;
         Window wnd = disp.WindowList.Where(x => x.Source == newSource).FirstOrDefault();
         if (wnd != null)
         {
             SelectedSource = new RectangleF(wnd.Left / (float)m_Display.Width, wnd.Top / (float)m_Display.Height, wnd.Width / (float)m_Display.Width, wnd.Height / (float)m_Display.Height);
             m_currentSource = wnd.Source;
         }
         else
         {
             SelectedSource = null;
             m_currentSource = null;
         }
         if (OnSourceSelected != null)
             OnSourceSelected();
     }
 }

 public void WhenParseLiteralTokenFromAndSaveResultAs(Source source, string key)
 {
     var parser = new LiteralTokenParser(Settings);
     var stream = new SourceStream(source);
     var result = parser.Parse(stream);
     ScenarioContext.Current.Set(result, key);
 }

        /// <summary>
        /// Render a helpful description of the location of the error in the GraphQL
        /// Source document.
        /// </summary>
        private static string highlightSourceAtLocation(Source source, SourceLocation location)
        {
            var line = location.Line;
            var prevLineNum = (line - 1).ToString();
            var lineNum = line.ToString();
            var nextLineNum = (line + 1).ToString();
            var padLen = nextLineNum.Length;
            var lines = _lineSplitter.Split(source.Body);
            var errorMessage = new StringBuilder();

            if (line >= 2)
            {
                errorMessage.AppendLine(prevLineNum.PadLeft(padLen, ' ') + ": " + lines[line - 2]);
            }
            else
            {
                errorMessage.AppendLine();
            }

            errorMessage.AppendLine(lineNum.PadLeft(padLen, ' ') + ": " + lines[line - 1]);
            errorMessage.AppendLine(new String(' ', padLen + location.Column) + "^");
            if (line < lines.Length)
            {
                errorMessage.AppendLine(nextLineNum.PadLeft(padLen, ' ') + ": " + lines[line]);
            }
            else
            {
                errorMessage.AppendLine();
            }

            return errorMessage.ToString();
        }

 public EqualityExpression(Source source, object a,
     object b)
         : base(source)
 {
     this.a = (Expression) a;
     this.b = (Expression) b;
 }

 public Reference(Source source, string name, string title, string chapter, string verse)
     : this(source, name)
 {
     this.title = title;
     this.chapter = chapter;
     this.verse = verse;
 }

 public CallExpression(Source source, object callable,
     object parameters)
         : base(source)
 {
     this.callable = (Expression) callable;
     this.parameters = (List<object>) parameters;
 }

        public void Should_use_passed_in_configuration()
        {
            var source = new Source {Value = 5};
            var dest = Mapper.Map<Source, Dest>(source);

            dest.Value.ShouldEqual(source.Value);
        }