public override bool CreateMethod(EventDescription eventDescription, string methodName, string initialStatements)
        {
            // build the new method handler
            var view = _pythonFileNode.GetTextView();
            var textBuffer = _pythonFileNode.GetTextBuffer();
            var classDef = GetClassForEvents();
            if (classDef != null) {
                int end = classDef.Body.EndIndex;

                using (var edit = textBuffer.CreateEdit()) {
                    var text = BuildMethod(
                        eventDescription,
                        methodName,
                        new string(' ', classDef.Body.Start.Column - 1),
                        view.Options.IsConvertTabsToSpacesEnabled() ?
                            view.Options.GetIndentSize() :
                            -1);

                    edit.Insert(end, text);
                    edit.Apply();
                    return true;
                }
            }

            return false;
        }

        public Event MapIt(Event a, EventDescription p)
        {
            // Terminating call.  Since we can return null from this function
            // we need to be ready for PetaPoco to callback later with null
            // parameters
            if (a == null)
                return current;

            // Is this the same author as the current one we're processing
            if (current != null && current.Id == a.Id)
            {
                // Yes, just add this post to the current author's collection of posts
                current.descriptions.Add(p);

                // Return null to indicate we're not done with this author yet
                return null;
            }

            // This is a different author to the current one, or this is the 
            // first time through and we don't have an author yet

            // Save the current author
            var prev = current;

            // Setup the new current author
            current = a;
            current.descriptions = new List<EventDescription>();
            current.descriptions.Add(p);

            // Return the now populated previous author (or null if first time through)
            return prev;
        }

        public override string CreateUniqueMethodName(string objectName, EventDescription eventDescription)
        {
            string originalMethodName = string.Format(CultureInfo.InvariantCulture, "{0}_{1}", objectName, eventDescription.Name);
            string methodName = originalMethodName;

            List<CodeTypeMember> methods = GetHandlersFromActiveFile(string.Format(CultureInfo.InvariantCulture, "{0}_{1}", objectName, eventDescription.Name));

            while (methods.Count > 0)
            {
                //Try to append a _# at the end until we find an unused method name
                Match match = Regex.Match(methodName, @"_\d+$");

                if (!match.Success)
                {
                    methodName = originalMethodName + "_1";
                }
                else
                {
                    int nextValue = Int32.Parse(match.Value.Substring(1)) + 1;
                    methodName = string.Format(CultureInfo.InvariantCulture, "{0}_{1}", originalMethodName, nextValue);
                }

                methods = GetHandlersFromActiveFile(methodName);
            }
            return methodName;
        }

        private static string BuildMethod(EventDescription eventDescription, string methodName, string indentation, int tabSize) {
            StringBuilder text = new StringBuilder();
            text.AppendLine(indentation);
            text.Append(indentation);
            text.Append("def ");
            text.Append(methodName);
            text.Append('(');
            text.Append("self");
            foreach (var param in eventDescription.Parameters) {
                text.Append(", ");
                text.Append(param.Name);
            }
            text.AppendLine("):");
            if (tabSize < 0) {
                text.Append(indentation);
                text.Append("\tpass");
            } else {
                text.Append(indentation);
                text.Append(' ', tabSize);
                text.Append("pass");
            }
            text.AppendLine();

            return text.ToString();
        }

        public override bool AddEventHandler(EventDescription eventDescription, string objectName, string methodName)
        {
            //FixMe: VladD2: Какая-то питоновская чушь! Надо разобраться и переписать.
            const string Init = "__init__";

            //This is not the most optimal solution for WPF since we will call FindLogicalNode for each event handler,
            //but it simplifies the code generation for now.

            CodeDomDocDataAdapter adapter = GetDocDataAdapterForNemerleFile();
            CodeMemberMethod      method  = null;

            //Find the __init__ method
            foreach (CodeTypeMember ctMember in adapter.TypeDeclaration.Members)
            {
                if (ctMember is CodeConstructor)
                {
                    if (ctMember.Name == Init)
                    {
                        method = ctMember as CodeMemberMethod;
                        break;
                    }
                }
            }

            if (method == null)
            {
                method = new CodeConstructor();
                method.Name = Init;
            }

            //Create a code statement which looks like: LogicalTreeHelper.FindLogicalNode(self.Root, "button1").Click += self.button1_Click
            var logicalTreeHelper        = new CodeTypeReferenceExpression  ("LogicalTreeHelper");
            var findLogicalNodeMethod    = new CodeMethodReferenceExpression(logicalTreeHelper, "FindLogicalNode");
            var selfWindow               = new CodeFieldReferenceExpression (new CodeThisReferenceExpression(), "Root");
            var findLogicalNodeInvoke    = new CodeMethodInvokeExpression   (findLogicalNodeMethod, selfWindow, new CodeSnippetExpression("\'" + objectName + "\'"));
            var createDelegateExpression = new CodeDelegateCreateExpression (new CodeTypeReference("System.EventHandler"), new CodeThisReferenceExpression(), methodName);
            var attachEvent              = new CodeAttachEventStatement     (findLogicalNodeInvoke, eventDescription.Name, createDelegateExpression);

            method.Statements.Add(attachEvent);
            adapter.Generate();

            return true;
        }

        public override bool CreateMethod(EventDescription eventDescription, string methodName, string initialStatements)
        {
            CodeMemberMethod method = new CodeMemberMethod();

            method.Name = methodName;

            foreach (EventParameter param in eventDescription.Parameters)
            {
                method.Parameters.Add(new CodeParameterDeclarationExpression(param.TypeName, param.Name));
            }

            //Finally, add the new method to the class

            CodeDomDocDataAdapter adapter = GetDocDataAdapterForXSharpFile();

            adapter.TypeDeclaration.Members.Add(method);
            adapter.Generate();

            return true;
        }

        public override bool CreateMethod(EventDescription eventDescription, string methodName, string initialStatements) {
            // build the new method handler
            var view = _pythonFileNode.GetTextView();
            var textBuffer = _pythonFileNode.GetTextBuffer();
            PythonAst ast;
            var classDef = GetClassForEvents(out ast);
            if (classDef != null) {
                int end = classDef.Body.EndIndex;
                
                // insert after the newline at the end of the last statement of the class def
                if (textBuffer.CurrentSnapshot[end] == '\r') {
                    if (end + 1 < textBuffer.CurrentSnapshot.Length &&
                        textBuffer.CurrentSnapshot[end + 1] == '\n') {
                        end += 2;
                    } else {
                        end++;
                    }
                } else if (textBuffer.CurrentSnapshot[end] == '\n') {
                    end++;
                }

                using (var edit = textBuffer.CreateEdit()) {
                    var text = BuildMethod(
                        eventDescription,
                        methodName,
                        new string(' ', classDef.Body.GetStart(ast).Column - 1),
                        view.Options.IsConvertTabsToSpacesEnabled() ?
                            view.Options.GetIndentSize() :
                            -1);

                    edit.Insert(end, text);
                    edit.Apply();
                    return true;
                }
            }


            return false;
        }

        public override bool CreateMethod(EventDescription eventDescription, string methodName, string initialStatements) {
            // build the new method handler
            var insertPoint = _callback.GetInsertionPoint(null);

            if (insertPoint != null) {
                var view = _callback.TextView;
                var textBuffer = _callback.Buffer;
                using (var edit = textBuffer.CreateEdit()) {
                    var text = BuildMethod(
                        eventDescription,
                        methodName,
                        new string(' ', insertPoint.Indentation),
                        view.Options.IsConvertTabsToSpacesEnabled() ?
                            view.Options.GetIndentSize() :
                            -1);

                    edit.Insert(insertPoint.Location, text);
                    edit.Apply();
                    return true;
                }
            }

            return false;
        }

 public override IEnumerable<string> GetCompatibleMethods(EventDescription eventDescription)
 {
     throw new NotImplementedException();
 }

            public RESULT getEvent(GUID guid, LOADING_MODE mode, out EventDescription _event)
            {
                RESULT result   = RESULT.OK;
                IntPtr eventraw = new IntPtr();
                _event = null;

                try
                {
                result = FMOD_Studio_System_GetEvent(rawPtr, ref guid, mode, out eventraw);
                }
                catch
                {
                result = RESULT.ERR_INVALID_PARAM;
                }
                if (result != RESULT.OK)
                {
                return result;
                }

                _event = new EventDescription();
                _event.setRaw(eventraw);

                return result;
            }

 public override void AppendStatements(EventDescription eventDescription, string methodName, string statements, int relativePosition)
 {
     throw new NotImplementedException();
 }

        public override IEnumerable<string> GetCompatibleMethods(EventDescription eventDescription) {
            var classDef = GetClassForEvents();
            SuiteStatement suite = classDef.Body as SuiteStatement;

            if (suite != null) {
                int requiredParamCount = eventDescription.Parameters.Count() + 1;
                foreach (var methodCandidate in suite.Statements) {
                    FunctionDefinition funcDef = methodCandidate as FunctionDefinition;
                    if (funcDef != null) {
                        // Given that event handlers can be given any arbitrary 
                        // name, it is important to not rely on the default naming 
                        // to detect compatible methods.  Instead we look at the 
                        // event parameters. We don't have param types in Python, 
                        // so really the only thing that can be done is look at 
                        // the method parameter count, which should be one more than
                        // the event parameter count (to account for the self param).
                        if (funcDef.Parameters.Count == requiredParamCount) {
                            yield return funcDef.Name;
                        }
                    }
                }
            }
        }

 public override bool RemoveEventHandler(EventDescription eventDescription, string objectName, string methodName)
 {
     throw new NotImplementedException();
 }

        public override bool ShowMethod(EventDescription eventDescription, string methodName)
        {
            CodeDomDocDataAdapter adapter = GetDocDataAdapterForPyFile();
            List<CodeTypeMember> methodsToShow = GetHandlersFromActivePyFile(methodName);
            if (methodsToShow == null || methodsToShow.Count < 1)
                return false;

            Point point = new Point();
            if (methodsToShow[0] != null)
            {
                //We can't navigate to every method, so just take the first one in the list.
                object pt = methodsToShow[0].UserData[typeof(Point)];
                if (pt != null)
                {
                    point = (Point)pt;
                }
            }
            //Get IVsTextManager to navigate to the code
            IVsTextManager mgr = Package.GetGlobalService(typeof(VsTextManagerClass)) as IVsTextManager;
            Guid logViewCode = VSConstants.LOGVIEWID_Code;
            return ErrorHandler.Succeeded(mgr.NavigateToLineAndColumn(adapter.DocData.Buffer, ref logViewCode, point.Y - 1, point.X, point.Y - 1, point.X));
        }

            public RESULT getEvent(string path, out EventDescription _event)
            {
                _event = null;

                IntPtr eventraw = new IntPtr();
                RESULT result = FMOD_Studio_System_GetEvent(rawPtr, Encoding.UTF8.GetBytes(path + Char.MinValue), out eventraw);
                if (result != RESULT.OK)
                {
                return result;
                }

                _event = new EventDescription(eventraw);
                return result;
            }

		///     Shows the body of the user code with the given method
		///     name. This returns true if it was possible to show
		///     the code, or false if not. We are never showing code
		///     since we do not generate handler methods.
		protected bool ShowCode(object component, EventDescriptor e, string methodName)
        {
            EventDescription ev = new EventDescription(methodName, e);
            VisualPascalABC.CodeFileDocumentControl cfdc = VisualPascalABC.VisualPABCSingleton.MainForm._currentCodeFileDocument;
            cfdc.GenerateDesignerCode(ev);
            if (ev.editor != null)
            {
                cfdc.DesignerAndCodeTabs.SelectedTab = cfdc.TextPage;
                VisualPascalABC.VisualPABCSingleton.MainForm.VisualEnvironmentCompiler.ExecuteSourceLocationAction(
                    new PascalABCCompiler.SourceLocation(cfdc.FileName, ev.line_num, ev.column_num, ev.line_num, ev.column_num),
                    VisualPascalABCPlugins.SourceLocationAction.GotoBeg);
            }
            return false;
        }

        public override bool ShowMethod(EventDescription eventDescription, string methodName) {
            var method = FindMethod(methodName);
            if (method != null) {
                var view = _pythonFileNode.GetTextView();
                view.Caret.MoveTo(new VisualStudio.Text.SnapshotPoint(view.TextSnapshot, method.StartIndex));
                view.Caret.EnsureVisible();
                return true;
            }

            return false;
        }

 public override bool AddEventHandler(EventDescription eventDescription, string objectName, string methodName) {
     // we return false here which causes the event handler to always be wired up via XAML instead of via code.
     return false;
 }

        public override bool RemoveEventHandler(EventDescription eventDescription, string objectName, string methodName) {
            var method = FindMethod(methodName);
            if (method != null) {
                var view = _pythonFileNode.GetTextView();
                var textBuffer = _pythonFileNode.GetTextBuffer();

                // appending a method adds 2 extra newlines, we want to remove those if those are still
                // present so that adding a handler and then removing it leaves the buffer unchanged.

                using (var edit = textBuffer.CreateEdit()) {
                    int start = method.StartIndex - 1;

                    // eat the newline we insert before the method
                    while (start >= 0) {
                        var curChar = edit.Snapshot[start];
                        if (!Char.IsWhiteSpace(curChar)) {
                            break;
                        } else if (curChar == ' ' || curChar == '\t') {
                            start--;
                            continue;
                        } else if (curChar == '\n') {
                            if (start != 0) {
                                if (edit.Snapshot[start - 1] == '\r') {
                                    start--;
                                }
                            }
                            start--;
                            break;
                        } else if (curChar == '\r') {
                            start--;
                            break;
                        }

                        start--;
                    }

                    
                    // eat the newline we insert at the end of the method
                    int end = method.EndIndex;                    
                    while (end < edit.Snapshot.Length) {
                        if (edit.Snapshot[end] == '\n') {
                            end++;
                            break;
                        } else if (edit.Snapshot[end] == '\r') {
                            if (end < edit.Snapshot.Length - 1 && edit.Snapshot[end + 1] == '\n') {
                                end += 2;
                            } else {
                                end++;
                            }
                            break;
                        } else if (edit.Snapshot[end] == ' ' || edit.Snapshot[end] == '\t') {
                            end++;
                            continue;
                        } else {
                            break;
                        }
                    }

                    // delete the method and the extra whitespace that we just calculated.
                    edit.Delete(Span.FromBounds(start + 1, end));
                    edit.Apply();
                }

                return true;
            }
            return false;
        }

 public override bool IsExistingMethodName(EventDescription eventDescription, string methodName) {
     return FindMethod(methodName) != null;
 }