 coming true I would have to say are infinitely higher then the odds of winning the lottery.
And if by chance it is the beginning of the end I doubt the event would be cataclysmic in nature, my guess it would be something seemingly insignificant that would start a chain of events that would eventually lead up to our demise.
About the Maya stuff, is this not just a "wouldn't-it-be-crazy-if" media creation? Does any non-trivial number of people seriously believe something is going to happen on whatever 2012 date? I mean not to the point of arguing that it might happen, but to the point of selling their stocks and stockpiling canned goods?
It's going to happen everyone best build your bunkers right now!
ends in cataclysmic burn.
1/7 Pride Level currently, soon I will be indestructible.
Using pure reason, I say that nothing's going to happen. I'm still going to get smashed if I can.‘Nocturne: Co-Creating Wild Altars’ workshop at ReFest: ReUnification, CultureHub (image credit: Isabel Beavers).
The altars are light, semi-translucent sculptures made of beeswax with attached LED solar paneled lights (image credit: Isabel Beavers).
The altars are labeled with QR codes offering more information about the project (image credit: Isabel Beavers).
In the workshop, 12 participants joined Isabel at her home studio to co-create wild altars in the form of light sculptures. After the workshop, participants took their altars home to place in their chosen ecological environments. Participants learned the process of creating these small wax sculptures and dedicated their altar to a new eco-ritual they hoped to enact.
Find out more about the workshop, and other programmed events at CultureHub here, and more about the Nocturne project here.
// Python Tools for Visual Studio
// Copyright(c) Microsoft Corporation
// All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the License); you may not use
// this file except in compliance with the License. You may obtain a copy of the
// License at http://www.apache.org/licenses/LICENSE-2.0
//
// THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS
// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY
// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
//
// See the Apache Version 2.0 License for specific language governing
// permissions and limitations under the License.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.PythonTools.Infrastructure;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Editor.OptionsExtensionMethods;
using Microsoft.Windows.Design.Host;

namespace Microsoft.PythonTools.XamlDesignerSupport {
    class WpfEventBindingProvider : EventBindingProvider {
        private readonly IXamlDesignerCallback _callback;

        public WpfEventBindingProvider(IXamlDesignerCallback callback) {
            _callback = callback;
        }

        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 AllowClassNameForMethodName() {
            return true;
        }

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

        public override string CodeProviderLanguage {
            get { return "Python"; }
        }

        public override bool CreateMethod(EventDescription eventDescription, string methodName, string initialStatements) {
            if (!_callback.EnsureDocumentIsOpen()) {
                return false;
            }

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

        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 string CreateUniqueMethodName(string objectName, EventDescription eventDescription) {
            var name = string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}_{1}", objectName, eventDescription.Name);
            int count = 0;

            var methods = _callback.FindMethods(
               null,
               null
           );

            while (methods.Contains(name)) {
                name = string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}_{1}{2}", objectName, eventDescription.Name, ++count);
            }
            return name;
        }

        public override IEnumerable<string> GetCompatibleMethods(EventDescription eventDescription) {
            return _callback.FindMethods(null, eventDescription.Parameters.Count() + 1);
        }

        public override IEnumerable<string> GetMethodHandlers(EventDescription eventDescription, string objectName) {
            return new string[0];
        }

        public override bool IsExistingMethodName(EventDescription eventDescription, string methodName) {
            return _callback.FindMethods(null, null).Contains(methodName);
        }

        private MethodInformation FindMethod(string methodName) {
            return _callback.GetMethodInfo(null, methodName);
        }

        public override bool RemoveEventHandler(EventDescription eventDescription, string objectName, string methodName) {
            var method = FindMethod(methodName);
            if (method!= null && method.IsFound) {
                var view = _callback.TextView;
                var textBuffer = _callback.Buffer;

                // 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.Start - 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.End;
                    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