Home / Uncategorized / Go hard or GO HOME!
Yes, I said it! Go Hard or GO HOME!
I have been working out for about a month and one week now! That is a huge step for me lol. I have develop a routine (sort of kind of). I listed a break down of my daily workout below. Let me know what you think!
Monday: 40 minutes of cardio (treadmill, bicycle, jog around house, elliptical, etc.). I do a incline of 2.5 while walking at 3.7 mph. when running, I do a incline of 2.0 while running at 4.2 mph. This helps me to burn more calories and to really work my calves.
Tuesday: AB day. I do planks, crunches, squats, and I have found some workout videos that helps with your abs as well.
Wednesday: AB and arms day. I do the same workouts, but I do more. I have also found a video that is great for arms.
Thursday: AB and leg day. I increase the amount I do and I sometimes add weights. I do a lot of squats and I use a bar when I am doing them to get more of a workout.
Friday: All body workout. I don't do 40 minutes of cardio, instead I do about 15-20 minutes. I run as long as I can without stopping and I have a incline of 2.0.
Saturday & Sunday are my rest days.
This is a great workout to try! If you do this like 3-4 times a week, you will defiantly see results!
Here are some of my results thus far (some old and some new).
** I know you may be thinking that I should give my body a rest in between, but I have come to the conclusion that I am more motivated to workout during the week and not the weekend. If you need to rotate days between, please do that. It is about doing what is best for you.
I tell myself everyday, GO hard or GO HOME! I say this because, if you are not going to give working out your best, then you should not do it. I am a big believer in when you do things to the best of your abilities, you will get the results you want.
If you want those abs, you have to put in the work! If you want that nice toned booty, you have to put in the work! Obtaining a healthy lifestyle starts with you and a made up mind. So don't expect to get results if you don't put in the work.
I know the holiday is here and I know we are all going to eat real good! Just remember to not over due it lol. Make sure to work out at home or go to the gym when you are able to. Every rib or macaroni and cheese bite counts lol.


text:
Cristiano Ronaldo beats Lionel Messi and Mohamed Salah to win player of century award
Juventus striker, Cristiano Ronaldo has been named player of the century at the 2020 Globe Soccer Awards.
The Portuguese superstar was crowned ahead of Barcelona's Leo Messi and Liverpool's Mohamed Salah to win the award on Sunday night in Dubai.
He voted best player of the 2000s by a 23-person jury, including coaches and former players and worldwide fan votes.
"CRISTIANO RONALDO presented with the ?PLAYER OF THE CENTURY? 2001-2020 Globe Soccer Award," the Dubai Global Soccer Awards said on Twitter.
Ronaldo is a five-time UEFA Champions League winner (four with Real Madrid, one with Manchester United). He won the English Premier League title with the Red Devils for three consecutive years (2007, 2008, and 2009).
Ronaldo, who is also the captain of Portugal led his country to win their first-ever major title, the UEFA EURO 2016.
Since becoming a Juventus player in 2018, Ronaldo became the Italian champion twice as he scored 81 goals in 103 games for the Italian club.
The superstar also has two of the Best FIFA Men's Player awards, five Ballon d'Or awards, and was chosen the UEFA best player in Europe three times.
The 2020 Globe Soccer Awards also honored Real Madrid as Club of the Century, while Manchester City manager Pep Guardiola won the Coach of the Century title and Bayern Munich forward Robert Lewandowski became Player of the Year for 2020.

redpajama_set_name: RedPajamaCommonCrawl


Swing through our 30ft high ropes course, explore Siblyback Lake by canoe or try something new and discover paddle boarding.
Fantastic setting backing onto the lake. Great hospitality and even better food. Check them out - they win awards!
Located next to the boating lake in Newquay, a warm, cosy cafe by day and gastro delight by night!
Tasty Lunch and Breakfast Menus. Pretty setting overlooking boating lake and near to gardens.
Swanpool is a nature reserve, all sorts of birds can be found on the lake.
The house is private, but there are great walks around the lake and on Loe Bar.
Beautiful gem of a house with long rhododendron lined drive, stunning garden and lake. Perfect for a day's outing near Wadebridge.
Trenance Gardens offers quiet areas, boating lake, walks, cafe's and restaurant, duck feeding & boat hire.
Beautiful gardens with a boating lake where you can hire pedalos, feed the ducks, or have a coffee.
Day out around Cornwall's largest lake.
A world class walk though National Trust land, taking in coast path, woodland, beach and a lake. The full walk is 6 miles, and we love it!
Scenic walk with squirrels and a couple of lakes and woodland, and a lovely little Cafe.


For the very first time, the city of Amsterdam will hold its very own Christmas boat parade in the historical city of Amsterdam this year on Christmas Eve.
Set for 24th of December from 20:00 to 22:00, the parade will travel down the historical canals of Amsterdam.
The initiators have aspired to create a spectacular event promoting Christmas spirit in and around the historical canals of Amsterdam. The boats in the parade will be decorated with lights, music, choirs etc. in holiday themes and a delight to watch along the canals. The beautiful city of Amsterdam and her canals are the perfect background to host this festive Christmas event in 2009 and in the future. The event will take place on Thursday the 24th of December from 20:00 to 22:00. The tour will start from the "IJ" through the Prinsengracht and finish in the "Oosterdok".
The Xmas Canal Parade mission is: to enhance the community's image by producing a wholesome, unique, national recognized event that reflects the diversity and culture of Amsterdam. The Amsterdam boat parade embraces the dual goals of providing a means for the community to come together and enjoy a spectacular and unique Christmas event as well as attract positive national attention to the Amsterdam area as a tourist destination and as a great place to live and work.
The Xmas Canal Parade organization is comprised of a huge contingency of volunteers, supporters and sponsors. The foundation is entirely dependent upon sponsorship from local and national corporate sponsors. The event is free to the public. The Xmas Canal Parade is very pleased to have the commitment of our corporate citizens to help expand the quality of the Boat Parade.
The festivities are aimed at bringing the city together for a celebration of Christmas spirit. We congratulate Xmas Canal Parade foundation of Amsterdam and the city for bringing this event about for citizens this holiday season.


So currently i'm attempting to fit a sat nav to my early loom car (2009 Zetec S pre facelift) without sync. Ive managed to get all the bits from a scrap dealer from a facelift ST and i am currently looking to make the 24 pin adapter for the stereo using this post How-to Retrofit a non-DAB Sony to an early loom car.
My first issue is the guide is old and i cant load the guide images. I was considering removing the entire dash and retrofitting the late loom but i'm not sure of its compatibility - i have everything on that loom for sync and the associated hardware along with some nice extras such as the loom for the reversing camera so id like to see if its possible but for the time being i'd be happy with an adapter.
The second issue is that i have been given a full dash loom for the associated facelift car and i cant find any reference to my aerial loom and what the connectors do.
Thanks for reading and i hope someone can help.
So I've attempted to make an adapter loom using the two parrot leads and matching the colours from my early connectors to the late ones. Not sure if it's right though and I don't want to chance it.
I also tried looking into the mystery I type fakra connector on the aerial loom and I'm still stumped as to where I can connect it.
I assume it's for gps or dab but I cant find a factory loom for it. Can anyone help?
On the subject of your connectors, I will try to assist. The single grey plug with the black wire is the power feed for your DAB aerial booster located in the boot. The yellow connector I have no idea. Blue is your GPS aerial, black and white connectors are for your radio aerial.
Thanks for your help. As for the yellow connector I'm thinking on just getting a different loom as it is where the dab amplifier should go and I cant find any reference of it, or an adapter through Google.
I assume it is supposed to attach to the gps reciever and the dab amp.
The DAB amplifier is located on the O/S of the car in the boot and external aerial is fixed underneath the rear bumper, the loom you have there will run from the back of the headunit and up the A pillar where it will connect with various wiring looms.
Thanks for your help. I managed to find the loom part number 1843613 and i think it attaches to a part called 1843614 which runs to the boot using the curry fakra connector to provide DAB where traditionally the white connector is used but i'm just speculating a bit and i'm not exactly sure why ford did this. For now i just bought a new loom for the aerial so i could add DAB.
As for the other connector i cut up the loom from the scrapped fiesta that i have (as retrofitting it to my car will probably be impossible) and pulled out the connector and its associated length of wire for power to the DAB amp. My thoughts were that if i find a loom to connect to the curry fakra, i can just swap it out. As for updating your car to DAB did you use forscan or run in to any issues?


Hi Nikki, Thankyou Thankyou Thankyou for your awesomeness and uplifting presentation today. I really got a lot out of what you said, especially planning the week.
Hi Nikki, Your presentation was WOW. I enjoyed your presentation and took a lot away from that for myself and my family. Thanks again for your inspiration.
This podcast was amazing. I have a few of my favourites saved so I can revisit them regularly and this will be added to that list.
Nikki is committed to improving wellness in the workplace through education, enabling clients to make informed decisions and choices to sustain their individual well being. I can't recommend Nikki highly enough.
Nikki is the picture of health and oozes vitality herself. Nikki has embodied her approach to life through her passion for working with clients, corporate and individuals encouraging them to work to their optimal level – with lasting results.
Great Blog Nikki, reading your blog was similar to having my morning coffee, it made my heart quicken and armed me for the rest of the day with conviction! Thanks for the wisdom as always.


VapeCase Quarantine Series is designed specifically for IOLITE Original. The impact resistant outer shell and padded inside keep your IOLITE protected. The air tight seal keeps water out and conceals odors.


text:
NewsUniversal
An Epic Universe is coming to Universal Orlando with huge new resort
By ErikAug 01, 2019, 10:33 am
Universal changed the theme park game in 2010 with the Wizarding World of Harry Potter, redefining what it could mean to build a world within a theme park. In 2014 they did it again with Diagon Alley, not only creating a world, but hiding it from plain sight and immersing guests into fantastic new realms, while connecting them from park to park.
Now Universal is doing it again, and it's going to be EPIC. Epic Universe will be the fourth gate in the Universal Orlando portfolio.
On Thursday, Universal announced their plans for the future, with a brand new resort. What's so different about this? While most parks announce resorts in different parts of the country, Universal Orlando is opening theirs right down the street. 12 minutes to be exact. And that's as of right now. The worlds are going to be unlike anything we've ever seen before, and will take guests into realms they never thought possible.
"Universal's Epic Universe will be the biggest and best Universal Park ever" said Universal's Tom Williams.
The new resort will include restaurants, hotels and will be responsible for creating more than 14,000 jobs with a base salary of $15 dollars an hour.
There is a push for the new train line that is coming through South Florida to Orlando to make a stop at the new Epic Universe as well, connecting more and more residents in the southern part of the state to the resort than ever before.
While there aren't many details as of right now, that will change as we get closer to the opening date, and throughout the next several months and years. No timeline was also given, nor any cost…though "hundreds of millions" was said by the Orlando Mayor.
What we did get to see was some Epic Concept art.
No lands, attractions or themes were announced but Tom Williams said that a "Universe is bigger than a world". The same marriage of all technology will be used.
"Our new park represents the single-largest investment Comcast NBCUniversal has made in its theme park business and in Florida overall," said Brian L. Roberts, Chairman and Chief Executive Officer of Comcast Corporation. "It reflects the tremendous excitement we have for the future of our theme park business and for our entire company's future in Florida."
The new theme park will also feature an entertainment center, hotels, shops, restaurants and more. It will be located within a larger 750-acre site that nearly doubles Universal's total available acreage in Central Florida. Universal's Epic Universe is just a few miles from the existing resort in Southwest Orange County. Specifically, it will be south of Sand Lake Road and east of Universal Boulevard.
"Our vision for Epic Universe is historic," said Tom Williams, Chairman and Chief Executive Officer for Universal Parks & Resorts. "It will build on everything we have done and become the most immersive and innovative theme park we have ever created. It is an investment in our business, our industry, our team members and our community."
The new park was announced Thursday in an event attended by Florida Governor Ron DeSantis, Orange County Mayor Jerry Demings, Tom Williams and Brian Roberts.
"We look forward to the new level of entertainment and innovation Universal's Epic Universe will bring to one of our state's most important industries," said Governor DeSantis. "We look forward to Universal's continued contribution to our state's economic growth and development. And we are especially grateful for Universal's partnership in improving Shingle Creek, which plays a critical role in serving the Everglades."
"The investment Universal is making in our community and the benefit all of us will see is substantial," said Mayor Demings. "This will benefit nearly every segment of our economy – from tourism to high-tech."
Mayor Demings also spotlighted Universal's role in the Kirkman Road extension. This is a 50/50 public-private partnership in which Universal is investing $160 million to extend Kirkman into the area where the new park will be located.
"The Kirkman extension will improve transportation through a busy and growing portion of our county and open up the entire area for additional development – including an important expansion of our Convention Center," he said.
During the announcement, Governor DeSantis, Mayor Demings and Tom Williams released information about Universal's economic contribution to the state and local economy.
Stay tuned for more from Universal, and be sure to get social with us on Facebook and follow along with us on Twitter @BehindThrills for the latest updates!
For more information about Universal Orlando,including tickets, visit the official website by clicking here!
TAG2023 attractions Epic Universe Super Mario World Super Nintendo World Universal Orlando
Previous PostGet ready for jolting tales of horror as Creepshow comes to Halloween Horror Nights Hollywood! Next PostIT Chapter 2 getting pop-up horror experience
Midnight Syndicate teams up with HHN to bring the soundtrack of your nightmares
Universal Studios Cancels Halloween Horror Nights Orlando AND Hollywood.
Universal reopening Select Hotels


There may be some days when you are so stressed and tense at the end of the day that it feels impossible to fall asleep. When you need it most, sleep alludes you. There are a number of exercises that relieve stress, relax muscles and help your body drift to sleep. These are often referred to as Relaxation Techniques. Slowed heart rate, lowered blood pressure, increased blood flow and reduction of chronic pain and muscle tension are just a few of the benefits of using relaxation techniques mentioned by the Mayo Clinic.
One technique, suggested by the University of Maryland Medical Center is called Toe Tensing. Laying down, flex your toes towards you and count to 10. Then relax your toes and count to 10. Repeat this cycle at least 10 times. The idea is to draw tension down from the rest of your body into your toes. As you tense your toes, other muscles will relax.
The Mayo Clinic suggests a technique that involves engaging all of your muscles in tension and relaxation. It is called progressive muscle relaxation. Start with your toes and working up your body, tense each muscle group for 30 seconds. Then relax that same muscle group for 30 seconds. The idea is that you will be more aware of your tension and become more physically aware of what relaxation feels like.
The National Institute of Health discusses guided imagery as a method of relaxation. You can listen to a recording, have someone speak to you or simply walk yourself through this technique mentally. In this technique a relaxing place or situation is brought to mind, allowing you to picture it mentally and focus your thoughts. This technique is also sometimes called visualization.
Other techniques include deep breathing, repeating single words or mantras while picturing them in your mind or simply listening to relaxing repetitive sounds such as ocean waves or rain. There are also ways to reduce stress for the long term. Exercises, especially ones that focus on stretching and breathing, such as yoga, can relieve day to day stress over time.
On a really tough day, try one of these techniques to help get you to sleep. They can also be useful to relieve stress at work. Just practice one for a few minutes right at your desk. Be careful not to fall asleep there! Do you have any favorite ways to relax after a tough day?
March 8, 2013 | Posted by Lee C.
A pillow protector is different from a pillow case. It can be made from various materials, but it encloses the entire pillow and zips shut. You can then place a pillow case over the top.
There are several reasons why you should be using a pillow protector.
Pillow protectors are easier to clean.
They are much easier to wash and dry than pillows themselves. Using pillow protectors will allow you to wash the casing much more frequently. Not having to wash the pillow itself as often will lengthen the life of the pillow.
Pillow protectors can keep dust mites and their leavings from pilling up in your pillow. They add another layer to "catch" the pests before they wind up in your pillow filling. A simple, hot wash will remove the allergens from your pillow protector. If you are sensitive to dust mites, you will not have to replace your pillow as often when you use a pillow protector. In addition to dust mites, Bedding Care suggests covers will also protect your pillow from bacteria, dust and mold.
You may not always be able to bring your own pillow when you travel. Pillow protectors fold up nicely and fit easily into luggage. You can put your own pillow protector on hotel pillows or guest room pillows. This will help you avoid allergens in spaces that are different from your home. It can also make you feel a bit better hygienically.
Choose a pillow protector that is made from high quality fabrics. These pillow protectors will withstand more washing. They also provide a bit more comfort and extra softness and fluff to your pillow. Higher quality fabrics will more effectively protect your pillow.
You rest your head on your pillow every night. Every night your pillow is exposed to dead skin cells, perspiration, and more. Keeping your pillow protected with an extra layer of washable material will help your pillow last longer. Investing in a few pillow protectors will save money on pillows in the long run. Cleaning your pillow protector regularly will help keep you safe from allergens and bacteria. You may sleep better at night and feel better during the day if you start sleeping with a pillow protector.


text:
World of Warcraft: Looking for Group
To celebrate 10 years of World of Warcraft, Blizzard have released a new documentary that sets about exploring the history of WoW, from it's early inception right up to today's development. It includes interviews with it's creators, who explain how the game came to be as successful as it is.
8.90 N.W.A. The World's Most Dangerous Group
WA: The World's Most Dangerous Group tells the story of a group of childhood friends from Compton who channeled the rage of the streets through the...
8.11 Inventions That Changed the World
This documentary series hosted by Jeremy Clarkson (best known from the BBC TV series Top Gear) sets about exploring the origins and genius behind s...
8.14 Einstein
I'm typically not a big fan of History Channel documentaries but I believe this one in particular to be somewhat of a higher quality, it focuses on...
5.33 Iron Triangle: The Carlyle Group
The Bush family, the Saudi Royal family, Osama Bin Laden's family and Donald Rumsfeld's inner circle - these are just some of the high profile figu...


Collaborative Self-Portrait of Anthony Luvera with Tom Pye from Let Us Eat Cake, 2017.
To be queer in Northern Ireland is to live in one of the most homophobic places in Western Europe. While public attitudes may be shifting in much more supportive directions, many LGBTQ+ people are rejected by their families, there is still too much homophobic hate crime, and many queer people face discrimination in their daily lives. Let Us Eat Cake speaks out about the fact that although changes for the better have taken place, much more needs to be done.
Collaborative Self-Portrait of Sarah Cromie from Let us Eat Cake, 2017.
Collaborative Self-Portrait of Chris Finlay from Let us Eat Cake, 2017.
Collaborative Self-Portrait of Ciaran Rafferty from Let us Eat Cake, 2017.
Collaborative Self-Portrait of Natalie McFall from Let us Eat Cake, 2017.
Collaborative Self-Portrait of Paul Campbell from Let us Eat Cake, 2017.
Collaborative Self-Portrait of Raymond Dunn from Let us Eat Cake, 2017.
Tagged Anthony Luvera, Assisted Portraits, Belfast Exposed, Collaborative Self-Portrait, Let Us Eat Cake, LGBTQ+, Northern Ireland.


Private setting for this lovely 3bed,2bath Santa Clara model. No one above or below. Level in unit!! Cute kitchen with corian counters, beautifully remodeled bathrooms with stall showers. dual pane windows, newer carpets. Inside laundry-close to parking. Brand New cement patio. SAME MODEL -1601 SKYCREST #1 JUST CLOSED AT $635,000 !!!
Bay East ©2019. CCAR ©2019. bridgeMLS ©2019. Information Deemed Reliable But Not Guaranteed. This information is being provided by the Bay East MLS, or CCAR MLS, or bridgeMLS. The listings presented here may or may not be listed by the Broker/Agent operating this website. This information is intended for the personal use of consumers and may not be used for any purpose other than to identify prospective properties consumers may be interested in purchasing. Data last updated at 4/21/19 12:59 AM PDT.


text:
Victor Canning pages:
News, links and publications
Back to Higgins Home Page
Introduction Biography Addresses Portraits
Books Short stories Stage plays Film and TV Radio and audio
Quotations Fishing Poetry Food Settings Dedications Narrative style Canning in the OED Reading lists Articles on Canning
Centenary News Links Availability
Victor Canning is included on "Nigel Balchin's Contemporaries", part of an excellent web site about Balchin managed by Derek Collett.
Extract from Mastermind Quiz show (BBC2) of 13 November 2009, answering questions on Victor Canning's Birdcage books.
I have created entries for Canning in The Literary Encylopedia and Wikipedia.
The well-known literary agency Curtis Brown handle the rights to Canning's work.
The US publishing house Crippen and Landru has just published a collection of Victor Caninng short stories which I have compiled. Follow this link to their page.
I have put back in print the three Mr. Finchley books along with a dozen other titles by using the print-on-demand service Lulu.com. Details are on the availability page.
Meanwhile an audio book of Canning's 1936 travel book, Everyman's England, read by Charles Collingwood, has been published by Crimson Cats Audio Books (click on this link for details).
I recently came across an enjoyable song by Chicago rock musician Fred Prellberg called Victor Canning and me. He wrote it, he tells me, "to express the personal relationship one can form with an author or a songwriter", and attributes his liking for Victor Canning's work as "probably the identification with hard-scrabble heroes, long on individuality & integrity, but seemingly at odds with their world & their times". You can listen to the song and other sample tracks from his album on this link.
Finding second-hand copies of Canning's books
See also the availability page.
The widest selection of secondhand books is probably to be found on the ABE (Advanced Book Exchange) site, which includes many professional and amateur dealers.
The Amazon site is a good source for new and, through its Market Place section, second-hand books.
For professional second-hand book dealers, two very good sites are Bookfinder and Addall, both of which search a large number of second-hand outlets world wide.
Page last updated October 2018.


text:
using ColossalFramework.UI;
using SkylineToolkit.Events;
using SkylineToolkit.UI.CustomControls;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using UnityEngine;

namespace SkylineToolkit.UI
{
    /// <summary>
    /// Basic wrapper for all <see cref="UIComponent"/> objects.
    /// </summary>
    /// <remarks>
    /// <para>
    /// Note: You should always dispose ColossalControls if you don't need them anymore because the wrapper registers
    /// itself to all of the events of the wrapped object. This causes massive memory leaks if not needed control wrappers
    /// are active. You can savely keep the wrappers active and stored if your UI persists for the whole game lifetime.
    ///
    /// You can use the <see cref="UIDisposingManager"/> to register all your <see cref="IColossalControl"/> wrappers and
    /// <see cref="CustomControls.ICustomControl"/>s for disposion if you dispose the UIDisposingManager.
    /// </para>
    /// <para>
    /// If wrapping an existing <see cref="UIComponent"/> the wrapper won't subscribe to the component events. If you need
    /// the events, just subscribe to them by invoking <see cref="SubscribeToEvents"/>. Altenratively the events can be
    /// subscribed using the corresponding constructur parameter.
    /// </para>
    /// </remarks>
    public class ColossalControl : Control, IColossalControl, IComparable<IColossalControl>, IDisposable
    {
        public static readonly int[] TriangleIndices = new int[6] { 0, 1, 3, 3, 1, 2 };

        private static UIView uiView;

        private UIComponent colossalUIComponent;

        private bool subscribedEvents = false;

        #region Events

        #region Mouse actions

        public event MouseEventHandler Click;

        public event MouseEventHandler DisabledClick;

        public event MouseEventHandler DoubleClick;

        public event MouseEventHandler MouseDown;

        public event MouseEventHandler MouseUp;

        public event MouseEventHandler MouseWheel;

        public event MouseEventHandler MouseEnter;

        public event MouseEventHandler MouseLeave;

        public event MouseEventHandler MouseHover;

        public event MouseEventHandler MouseMove;

        public event DragDropEventHandler DragStart;

        public event DragDropEventHandler DragEnd;

        public event DragDropEventHandler DragEnter;

        public event DragDropEventHandler DragLeave;

        public event DragDropEventHandler DragOver;

        public event DragDropEventHandler DragDrop;

        public event MouseEventHandler TooltipEnter;

        public event MouseEventHandler TooltipLeave;

        #endregion

        #region Keyboard actions

        public event KeyboardEventHandler KeyDown;

        public event KeyboardEventHandler KeyUp;

        public event KeyboardEventHandler KeyPress;

        #endregion

        #region Child controls

        public event ChildControlEventHandler ChildControlAdded;

        public event ChildControlEventHandler ChildControlRemoved;

        #endregion

        #region Positioning and Scaling

        public event PropChangedEventHandler<Anchor> AnchorChanged;

        public event FitChildrenEventHandler FitChildren;

        public event PropChangedEventHandler<Vector2> PositionChanged;

        public event PropChangedEventHandler<Vector2> SizeChanged;

        #endregion

        #region Appearance

        public event PropChangedEventHandler<Color32> ColorChanged;

        public event PropChangedEventHandler<Color32> DisabledColorChanged;

        public event PropChangedEventHandler<float> OpacityChanged;

        public event PropChangedEventHandler<PivotPoint> PivotChanged;

        public event TooltipEventHandler TooltipShow;

        public event TooltipEventHandler TooltipHide;

        public event PropChangedEventHandler<string> TooltipTextChanged;

        public event PropChangedEventHandler<int> ZOrderChanged;

        #endregion

        #region State

        public event FocusEventHandler Focus;

        public event FocusEventHandler Focused;

        public event FocusEventHandler Unfocus;

        public event FocusEventHandler Unfocused;

        public event PropChangedEventHandler<bool> Enabled;

        public event PropChangedEventHandler<bool> Disabled;

        public event PropChangedEventHandler<bool> VisibilityChanged;

        public event PropChangedEventHandler<int> TabIndexChanged;

        #endregion

        #endregion

        #region Constructors

        internal ColossalControl()
        {
        }

        public ColossalControl(UIComponent component, bool subscribeEvents = false)
        {
            this.UIComponent = component;

            if (subscribeEvents)
            {
                SubscribeToEvents();
            }
        }

        public ColossalControl(string name, Type componentType, bool subscribeEvents = true)
        {
            this.InitializeComponent(name, componentType);

            if (subscribeEvents)
            {
                SubscribeToEvents();
            }

            this.SetDefaultStyle();
        }

        public ColossalControl(IColossalControl control, bool subscribeEvents = false)
        {
            this.UIComponent = control.UIComponent;

            if (subscribeEvents)
            {
                SubscribeToEvents();
            }
        }

        #endregion

        #region Properties

        // TODO: Wrapper for UIView ?
        public static UIView ColossalUIView
        {
            get
            {
                if (uiView == null)
                {
                    UIView foundUIView = GameObject.FindObjectOfType<UIView>();

                    if (foundUIView != null)
                    {
                        uiView = foundUIView;
                    }
                }

                return uiView;
            }
        }

        #region Component

        public UIComponent UIComponent
        {
            get
            {
                return colossalUIComponent;
            }
            protected set
            {
                colossalUIComponent = value;

                this.GameObject = value.gameObject;
            }
        }

        public string Name
        {
            get
            {
                return this.UIComponent.gameObject.name;
            }
            set
            {
                this.UIComponent.gameObject.name = value;
            }
        }

        #endregion

        #region Positioning and Scaling

        public Anchor Anchor
        {
            get
            {
                return (Anchor)this.UIComponent.anchor;
            }
            set
            {
                this.UIComponent.anchor = (UIAnchorStyle)value;
            }
        }

        public Vector3 ArbitaryPivotOffset
        {
            get
            {
                return this.UIComponent.arbitraryPivotOffset;
            }
            set
            {
                this.UIComponent.arbitraryPivotOffset = value;
            }
        }

        public Vector4 Area
        {
            get
            {
                return this.UIComponent.area;
            }
            set
            {
                this.UIComponent.area = value;
            }
        }

        public Vector4 Limits
        {
            get
            {
                return this.UIComponent.limits;
            }
            set
            {
                this.UIComponent.limits = value;
            }
        }

        public Vector2 MaxSize
        {
            get
            {
                return this.UIComponent.maximumSize;
            }
            set
            {
                this.UIComponent.maximumSize = value;
            }
        }

        public Vector2 MinSize
        {
            get
            {
                return this.UIComponent.minimumSize;
            }
            set
            {
                this.UIComponent.minimumSize = value;
            }
        }

        public Vector3 TransformPosition
        {
            get
            {
                return this.UIComponent.transformPosition;
            }
            set
            {
                this.UIComponent.transformPosition = value;
            }
        }

        public Vector3 Position
        {
            get
            {
                return this.RelativePosition;
            }
            set
            {
                this.RelativePosition = value;
            }
        }

        public Vector3 AbsolutePosition
        {
            get
            {
                return this.UIComponent.absolutePosition;
            }
            set
            {
                this.UIComponent.absolutePosition = value;
            }
        }

        public Vector3 RelativePosition
        {
            get
            {
                return this.UIComponent.relativePosition;
            }
            set
            {
                this.UIComponent.relativePosition = value;
            }
        }

        public Vector3 GlobalRotation
        {
            get
            {
                return this.UIComponent.gameObject.transform.eulerAngles;
            }
            set
            {
                this.UIComponent.gameObject.transform.eulerAngles = value;
            }
        }

        public Vector3 LocalRotation
        {
            get
            {
                return this.UIComponent.gameObject.transform.localEulerAngles;
            }
            set
            {
                this.UIComponent.gameObject.transform.localEulerAngles = value;
            }
        }

        public bool IsClippedFromParent
        {
            get
            {
                return this.UIComponent.IsClippedFromParent();
            }
        }

        public virtual bool EnableAutoSize
        {
            get
            {
                return this.UIComponent.autoSize;
            }
            set
            {
                this.UIComponent.autoSize = value;
            }
        }

        public Vector3 Center
        {
            get
            {
                return this.UIComponent.center;
            }
        }

        public bool IsClippingChildren
        {
            get
            {
                return this.UIComponent.clipChildren;
            }
            set
            {
                this.UIComponent.clipChildren = value;
            }
        }

        public float Height
        {
            get
            {
                return this.UIComponent.height;
            }
            set
            {
                this.UIComponent.height = value;
            }
        }

        public float Width
        {
            get
            {
                return this.UIComponent.width;
            }
            set
            {
                this.UIComponent.width = value;
            }
        }

        public Vector2 Size
        {
            get
            {
                return this.UIComponent.size;
            }
            set
            {
                this.UIComponent.size = value;
            }
        }

        public int ZOrder
        {
            get
            {
                return this.UIComponent.zOrder;
            }
            set
            {
                this.UIComponent.zOrder = value;
            }
        }

        #endregion

        #region Appearance

        public AudioClip ClickSound
        {
            get
            {
                return this.UIComponent.clickSound;
            }
            set
            {
                this.UIComponent.clickSound = value;
            }
        }

        public AudioClip DisabledClickSound
        {
            get
            {
                return this.UIComponent.disabledClickSound;
            }
            set
            {
                this.UIComponent.disabledClickSound = value;
            }
        }

        public Color32 Color
        {
            get
            {
                return this.UIComponent.color;
            }
            set
            {
                this.UIComponent.color = value;
            }
        }

        public Color32 DisabledColor
        {
            get
            {
                return this.UIComponent.disabledColor;
            }
            set
            {
                this.UIComponent.disabledColor = value;
            }
        }

        public CursorInfo HoverCursorStyle
        {
            get
            {
                return CursorInfo.FromColossalCursorInfo(this.UIComponent.hoverCursor);
            }
            set
            {
                this.UIComponent.hoverCursor = value.ToColossalCursorInfo();
            }
        }

        public float Opacity
        {
            get
            {
                return this.UIComponent.opacity;
            }
            set
            {
                this.UIComponent.opacity = value;
            }
        }

        public PivotPoint Pivot
        {
            get
            {
                return (PivotPoint)this.UIComponent.pivot;
            }
            set
            {
                this.UIComponent.pivot = (UIPivotPoint)value;
            }
        }

        public string TooltipText
        {
            get
            {
                return this.UIComponent.tooltip;
            }
            set
            {
                this.UIComponent.tooltip = value;
            }
        }

        public TooltipAnchor TooltipAnchor
        {
            get
            {
                return (TooltipAnchor)this.UIComponent.tooltipAnchor;
            }
            set
            {
                this.UIComponent.tooltipAnchor = (UITooltipAnchor)value;
            }
        }

        public IColossalControl TooltipBox
        {
            get
            {
                UIComponent component = this.UIComponent.tooltipBox;

                return new ColossalControl(component);
            }
            set
            {
                this.UIComponent.tooltipBox = value.UIComponent;
            }
        }

        #endregion

        #region State

        public bool IsEnabled
        {
            get
            {
                return this.UIComponent.isEnabled;
            }
            set
            {
                if (value)
                {
                    this.UIComponent.Enable();
                }
                else
                {
                    this.UIComponent.Disable();
                }
            }
        }

        public bool HasFocus
        {
            get
            {
                return this.UIComponent.hasFocus;
            }
            set
            {
                if (value)
                {
                    this.UIComponent.Focus();
                }
                else
                {
                    this.UIComponent.Unfocus();
                }
            }
        }

        public bool IsVisible
        {
            get
            {
                return this.UIComponent.isVisible;
            }
            set
            {
                if (value)
                {
                    this.UIComponent.Show();
                }
                else
                {
                    this.UIComponent.Hide();
                }
            }
        }

        public bool IsVisibleSelf
        {
            get
            {
                return this.UIComponent.isVisibleSelf;
            }
        }

        public bool IsVisibleInParent
        {
            get
            {
                return this.UIComponent.IsVisibleInParent();
            }
        }

        public bool IsInteractive
        {
            get
            {
                return this.UIComponent.isInteractive;
            }
            set
            {
                this.UIComponent.isInteractive = value;
            }
        }

        public bool IsTooltipOnTop
        {
            get
            {
                return this.UIComponent.bringTooltipToFront;
            }
            set
            {
                this.UIComponent.bringTooltipToFront = value;
            }
        }

        public bool IsLocalized
        {
            get
            {
                return this.UIComponent.isLocalized;
            }
            set
            {
                this.UIComponent.isLocalized = value;
            }
        }

        public bool IsTooltipLocalized
        {
            get
            {
                return this.UIComponent.isTooltipLocalized;
            }
            set
            {
                this.UIComponent.isTooltipLocalized = value;
            }
        }

        public bool IsPlayingAudioEvents
        {
            get
            {
                return this.UIComponent.playAudioEvents;
            }
            set
            {
                this.UIComponent.playAudioEvents = value;
            }
        }

        public bool UseBuiltinKeyNavigation
        {
            get
            {
                return this.UIComponent.builtinKeyNavigation;
            }
            set
            {
                this.UIComponent.builtinKeyNavigation = value;
            }
        }

        public virtual bool CanGetFocus
        {
            get
            {
                return this.UIComponent.canFocus;
            }
            set
            {
                this.UIComponent.canFocus = value;
            }
        }

        public int ChildCount
        {
            get
            {
                return this.UIComponent.childCount;
            }
        }

        public IColossalControl[] Children
        {
            get
            {
                return this.UIComponent.components.Select(component =>
                {
                    return new ColossalControl(component);
                }).ToArray();
            }
        }

        public IColossalControl Parent
        {
            get
            {
                if (this.UIComponent.parent == null)
                {
                    return null;
                }

                return new ColossalControl(this.UIComponent.parent);
            }
        }

        public virtual bool ContainsFocus
        {
            get
            {
                return this.UIComponent.containsFocus;
            }
        }

        public bool ContainsMouse
        {
            get
            {
                return this.UIComponent.containsMouse;
            }
        }

        protected bool HasPendingLayoutRequest
        {
            get
            {
                return this.GetUIComponentProperty<bool>("hasPendingLayoutRequest");
            }
        }

        protected bool IsLayoutSuspended
        {
            get
            {
                return this.GetUIComponentProperty<bool>("isLayoutSuspended");
            }
        }

        protected bool IsPerformingLayout
        {
            get
            {
                return this.GetUIComponentProperty<bool>("isPerformingLayout");
            }
        }

        public int TabIndex
        {
            get
            {
                return this.UIComponent.tabIndex;
            }
            set
            {
                this.UIComponent.tabIndex = value;
            }
        }

        public string TooltipLocaleId
        {
            get
            {
                return this.UIComponent.tooltipLocaleID;
            }
            set
            {
                this.UIComponent.tooltipLocaleID = value;
            }
        }

        #endregion

        #region Cached values

        public string CachedName
        {
            get
            {
                return this.UIComponent.cachedName;
            }
            set
            {
                this.UIComponent.cachedName = value;
            }
        }

        public Transform CachedTransform
        {
            get
            {
                return this.UIComponent.cachedTransform;
            }
        }

        #endregion

        public object ObjectUserData
        {
            get
            {
                return this.UIComponent.objectUserData;
            }
            set
            {
                this.UIComponent.objectUserData = value;
            }
        }

        public string StringUserData
        {
            get
            {
                return this.UIComponent.stringUserData;
            }
            set
            {
                this.UIComponent.stringUserData = value;
            }
        }

        protected UIRenderData RenderData
        {
            get
            {
                return this.GetUIComponentProperty<UIRenderData>("renderData");
            }
        }

        public int RenderOrder
        {
            get
            {
                return this.UIComponent.renderOrder;
            }
        }

        #endregion

        #region Methods

        public static ColossalControl FromUIComponent(UIComponent component)
        {
            if(component == null)
            {
                throw new ArgumentNullException("component");
            }

            return new ColossalControl(component);
        }

        public static TControl FromUIComponent<TControl>(UIComponent component)
            where TControl : ColossalControl
        {
            ColossalControl control = FromUIComponent(component);

            return (TControl)Activator.CreateInstance(typeof(TControl), new object[] { control });
        }

        #region Wrapping Colossal UI

        /// <summary>
        /// Initializes the Colossal UI wrapper.
        /// </summary>
        /// <param name="name">The name for the newly created <see cref="UnityEngine.GameObject"/>.</param>
        /// <param name="componentType">Type of the wrapped <see cref="ColossalFramework.UI.UIComponent"/>.</param>
        protected virtual void InitializeComponent(string name, Type componentType)
        {
            if (!typeof(ColossalFramework.UI.UIComponent).IsAssignableFrom(componentType))
            {
                throw new InvalidCastException("The given type is not assignable to UIComponent");
            }

            if (ColossalUIView == null)
            {
                Log.Warning("No Colossal UIView found in game.");

                throw new InvalidOperationException("No UIView found in game.");
            }

            this.GameObject = new GameObject(name, componentType);

            this.GameObject.transform.parent = ColossalUIView.transform;

            this.UIComponent = (UIComponent)this.GameObject.GetComponent(componentType);

            ColossalUIView.AttachUIComponent(this.UIComponent.gameObject);
        }

        public void SubscribeToEvents()
        {
            if (subscribedEvents)
            {
                return;
            }

            this.SubscribeEvents();

            subscribedEvents = true;
        }

        public void UnsubscribeFromEvents()
        {
            if (!subscribedEvents)
            {
                return;
            }

            this.UnsubscribeEvents();

            subscribedEvents = false;
        }

        /// <summary>
        /// Subscribes the internal event wrappers to the events of the wrapped <see cref="UIComponent"/>.
        /// </summary>
        protected virtual void SubscribeEvents()
        {
            this.UIComponent.eventClick += OnClick;
            this.UIComponent.eventDisabledClick += OnDisabledClick;
            this.UIComponent.eventDoubleClick += OnDoubleClick;
            this.UIComponent.eventMouseDown += OnMouseDown;
            this.UIComponent.eventMouseUp += OnMouseUp;
            this.UIComponent.eventMouseWheel += OnMouseWheel;
            this.UIComponent.eventMouseEnter += OnMouseEnter;
            this.UIComponent.eventMouseLeave += OnMouseLeave;
            this.UIComponent.eventMouseHover += OnMouseHover;
            this.UIComponent.eventMouseMove += OnMouseMove;
            this.UIComponent.eventDragStart += OnDragStart;
            this.UIComponent.eventDragEnd += OnDragEnd;
            this.UIComponent.eventDragEnter += OnDragEnter;
            this.UIComponent.eventDragLeave += OnDragLeave;
            this.UIComponent.eventDragOver += OnDragOver;
            this.UIComponent.eventDragDrop += OnDragDrop;
            this.UIComponent.eventTooltipEnter += OnTooltipEnter;
            this.UIComponent.eventTooltipLeave += OnTooltipLeave;

            this.UIComponent.eventKeyDown += OnKeyDown;
            this.UIComponent.eventKeyUp += OnKeyUp;
            this.UIComponent.eventKeyPress += OnKeyPress;

            this.UIComponent.eventComponentAdded += OnChildControlAdded;
            this.UIComponent.eventComponentRemoved += OnChildControlRemoved;

            this.UIComponent.eventAnchorChanged += OnAnchorChanged;
            this.UIComponent.eventFitChildren += OnFitChildren;
            this.UIComponent.eventPositionChanged += OnPositionChanged;
            this.UIComponent.eventSizeChanged += OnSizeChanged;

            this.UIComponent.eventColorChanged += OnColorChanged;
            this.UIComponent.eventDisabledColorChanged += OnDisabledColorChanged;
            this.UIComponent.eventOpacityChanged += OnOpacityChanged;
            this.UIComponent.eventPivotChanged += OnPivotChanged;
            this.UIComponent.eventTooltipShow += OnTooltipShow;
            this.UIComponent.eventTooltipHide += OnTooltipHide;
            this.UIComponent.eventTooltipTextChanged += OnTooltipTextChanged;
            this.UIComponent.eventZOrderChanged += OnZOrderChanged;

            this.UIComponent.eventEnterFocus += OnFocus;
            this.UIComponent.eventGotFocus += OnFocused;
            this.UIComponent.eventLeaveFocus += OnUnfocus;
            this.UIComponent.eventLostFocus += OnUnfocused;
            this.UIComponent.eventIsEnabledChanged += OnIsEnabledChanged;
            this.UIComponent.eventVisibilityChanged += OnVisibilityChanged;
            this.UIComponent.eventTabIndexChanged += OnTabIndexChanged;
        }

        protected virtual void UnsubscribeEvents()
        {
            this.UIComponent.eventClick -= OnClick;
            this.UIComponent.eventDisabledClick -= OnDisabledClick;
            this.UIComponent.eventDoubleClick -= OnDoubleClick;
            this.UIComponent.eventMouseDown -= OnMouseDown;
            this.UIComponent.eventMouseUp -= OnMouseUp;
            this.UIComponent.eventMouseWheel -= OnMouseWheel;
            this.UIComponent.eventMouseEnter -= OnMouseEnter;
            this.UIComponent.eventMouseLeave -= OnMouseLeave;
            this.UIComponent.eventMouseHover -= OnMouseHover;
            this.UIComponent.eventMouseMove -= OnMouseMove;
            this.UIComponent.eventDragStart -= OnDragStart;
            this.UIComponent.eventDragEnd -= OnDragEnd;
            this.UIComponent.eventDragEnter -= OnDragEnter;
            this.UIComponent.eventDragLeave -= OnDragLeave;
            this.UIComponent.eventDragOver -= OnDragOver;
            this.UIComponent.eventDragDrop -= OnDragDrop;
            this.UIComponent.eventTooltipEnter -= OnTooltipEnter;
            this.UIComponent.eventTooltipLeave -= OnTooltipLeave;

            this.UIComponent.eventKeyDown -= OnKeyDown;
            this.UIComponent.eventKeyUp -= OnKeyUp;
            this.UIComponent.eventKeyPress -= OnKeyPress;

            this.UIComponent.eventComponentAdded -= OnChildControlAdded;
            this.UIComponent.eventComponentRemoved -= OnChildControlRemoved;

            this.UIComponent.eventAnchorChanged -= OnAnchorChanged;
            this.UIComponent.eventFitChildren -= OnFitChildren;
            this.UIComponent.eventPositionChanged -= OnPositionChanged;
            this.UIComponent.eventSizeChanged -= OnSizeChanged;

            this.UIComponent.eventColorChanged -= OnColorChanged;
            this.UIComponent.eventDisabledColorChanged -= OnDisabledColorChanged;
            this.UIComponent.eventOpacityChanged -= OnOpacityChanged;
            this.UIComponent.eventPivotChanged -= OnPivotChanged;
            this.UIComponent.eventTooltipShow -= OnTooltipShow;
            this.UIComponent.eventTooltipHide -= OnTooltipHide;
            this.UIComponent.eventTooltipTextChanged -= OnTooltipTextChanged;
            this.UIComponent.eventZOrderChanged -= OnZOrderChanged;

            this.UIComponent.eventEnterFocus -= OnFocus;
            this.UIComponent.eventGotFocus -= OnFocused;
            this.UIComponent.eventLeaveFocus -= OnUnfocus;
            this.UIComponent.eventLostFocus -= OnUnfocused;
            this.UIComponent.eventIsEnabledChanged -= OnIsEnabledChanged;
            this.UIComponent.eventVisibilityChanged -= OnVisibilityChanged;
            this.UIComponent.eventTabIndexChanged -= OnTabIndexChanged;
        }

        protected virtual void SetDefaultStyle()
        {
            this.EnableAutoSize = false;
            this.IsTooltipOnTop = true;
            this.UseBuiltinKeyNavigation = true;
        }

        /// <summary>
        /// Calls a method with the given <paramref name="methodName"/> on the wrapped <see cref="UIComponent"/>.
        /// Use <paramref name="methodParams"/> to specify parameters to be passed to the called method.
        /// </summary>
        /// <typeparam name="TResult">The type of the result of the called method.</typeparam>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="methodParams">The parameters to pass to the called method.</param>
        /// <returns>The returned value from the called method.</returns>
        protected virtual TResult CallUIComponentMethod<TResult>(string methodName, params object[] methodParams)
        {
            MethodInfo method = this.UIComponent.GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);

            if (method == null)
            {
                throw new MissingMethodException("Method " + methodName + " not found.");
            }

            object result = method.Invoke(this.UIComponent, methodParams);

            return (TResult)result;
        }

        protected virtual TProp GetUIComponentProperty<TProp>(string propertyName)
        {
            PropertyInfo property = this.UIComponent.GetType().GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.GetProperty);

            if (property == null)
            {
                throw new MissingMemberException("Property " + propertyName + " not found.");
            }

            object result = property.GetValue(this.UIComponent, null);

            return (TProp)result;
        }

        protected virtual void SetUIComponentProperty<TProp>(string propertyName, TProp value)
        {
            PropertyInfo property = this.UIComponent.GetType().GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.SetProperty);

            if (property == null)
            {
                throw new MissingMemberException("Property " + propertyName + " not found.");
            }

            property.SetValue(this.UIComponent, value, null);
        }

        #endregion

        #region Handling Child Controls

        /// <summary>
        /// Creates a new control of given type <typeparamref name="TControl"/> and attaches it as a child control.
        /// </summary>
        /// <remarks>
        /// This uses the control classes from SkylineToolkit.
        /// </remarks>
        /// <typeparam name="TControl">The type of the new control.</typeparam>
        /// <returns>The newly created control.</returns>
        public TControl AddControl<TControl>()
            where TControl : IColossalControl, new()
        {
            TControl control = new TControl();

            this.UIComponent.AddUIComponent(control.UIComponent.GetType());

            return control;
        }

        /// <summary>
        /// Creates a new control of given <paramref name="type"/> and attaches it as a child control.
        /// </summary>
        /// <remarks>
        /// This method accepts both SkylineToolkit and Colossal UI control/component classes.
        /// Original Colossal <see cref="UIComponent"/> types gets wrapped automatically with the control classes from SkylineToolkit.
        /// The returned control requires casting to the desired type.
        /// </remarks>
        /// <param name="type">The type of the new control.</param>
        /// <returns>The newly created control.</returns>
        public IColossalControl AddControl(Type type)
        {
            if (typeof(ColossalControl).IsAssignableFrom(type))
            {
                IColossalControl control = (IColossalControl)Activator.CreateInstance(type);

                this.UIComponent.AddUIComponent(control.UIComponent.GetType());

                return control;
            }

            if (typeof(UIComponent).IsAssignableFrom(type))
            {
                UIComponent component = this.UIComponent.AddUIComponent(type);

                return new ColossalControl(component);
            }

            throw new InvalidCastException();
        }

        /// <summary>
        /// Attaches an already existing control as a sub control. Moves the existing control as a child below this control.
        /// </summary>
        /// <typeparam name="TControl">The type of the existing control.</typeparam>
        /// <param name="control">The existing control which should become a child control.</param>
        /// <returns>The attached child control.</returns>
        public TControl AttachControl<TControl>(TControl control)
            where TControl : IColossalControl
        {
            this.UIComponent.AttachUIComponent(control.UIComponent.gameObject);

            return control;
        }

        /// <summary>
        /// Attaches an already existing control as a sub control. Moves the existing control as a child below this control.
        /// </summary>
        /// <typeparam name="TControl">The type of the existing control.</typeparam>
        /// <param name="control">The existing control which should become a child control.</param>
        /// <returns>The attached child control.</returns>
        public IColossalControl AttachControl(IColossalControl control)
        {
            this.UIComponent.AttachUIComponent(control.UIComponent.gameObject);

            return control;
        }

        /// <summary>
        /// Attaches an already existing UI <paramref name="component"/> as a sub control. Moves the existing control as a child below this control.
        /// </summary>
        /// <remarks>
        /// This wraps the given UI <paramref name="component"/> with the SkylineToolkit control wrapper.
        /// </remarks>
        /// <param name="component">The existing UIComponent which should becoma a child control.</param>
        /// <returns>The attached child control.</returns>
        public IColossalControl AttachControl(UIComponent component)
        {
            component = this.UIComponent.AttachUIComponent(component.gameObject);

            return new ColossalControl(component);
        }

        /// <summary>
        /// Attaches an already existing UI component from a given <paramref name="gameObject"/> as a sub control. Moves the existing control as a child below this control.
        /// </summary>
        /// <remarks>
        /// This wraps the given UI <paramref name="gameObject"/> with the SkylineToolkit control wrapper.
        /// </remarks>
        /// <param name="gameObject">The gameobject holding the UIComponent which should become a child control.</param>
        /// <returns>The attached child control.</returns>
        public IColossalControl AttachControl(GameObject gameObject)
        {
            UIComponent component = this.UIComponent.AttachUIComponent(gameObject);

            return new ColossalControl(component);
        }

        public IControlsContainer AttachContainer(IControlsContainer container)
        {
            container.AttachTo(this);

            return container;
        }

        /// <summary>
        /// Finds a child control matching the given filter.
        /// </summary>
        /// <remarks>
        /// The found <see cref="UIComponent"/>, if there's one, gets automatically wrapped up into a SkylineToolkit control wrapper.
        /// </remarks>
        /// <param name="filter">A filter used to search a sub control.</param>
        /// <returns>The found child control or null when found nothin.</returns>
        public IColossalControl FindChild(string filter)
        {
            UIComponent component = this.UIComponent.Find(filter);

            if (component == null)
            {
                return null;
            }

            return new ColossalControl(component);
        }

        #endregion

        #region Positioning and Scaling

        /// <summary>
        /// Aligns the control to the <paramref name="target"/> at the given anchor.
        /// </summary>
        /// <param name="target">The target control on which to align the control.</param>
        /// <param name="anchor">The anchor on which to align the control.</param>
        public virtual void AlignTo(IColossalControl target, AlignmentAnchor anchor)
        {
            this.UIComponent.AlignTo(target.UIComponent, (UIAlignAnchor)anchor);
        }

        /// <summary>
        /// Aligns the control to the <paramref name="target"/> at the given anchor.
        /// </summary>
        /// <param name="target">The target control on which to align the control.</param>
        /// <param name="anchor">The anchor on which to align the control.</param>
        public virtual void AlignTo(UIComponent target, AlignmentAnchor anchor)
        {
            this.UIComponent.AlignTo(target, (UIAlignAnchor)anchor);
        }

        /// <summary>
        /// Places the control centered at the center of the <paramref name="target"/> control.
        /// </summary>
        /// <param name="target"></param>
        public void CenterTo(IColossalControl target)
        {
            this.UIComponent.CenterTo(target.UIComponent);
        }

        /// <summary>
        /// Places the control centered at the center of the parent control.
        /// </summary>
        public void CenterToParent()
        {
            this.UIComponent.CenterToParent();
        }

        /// <summary>
        /// Brings the control to the topmost layer of the UI.
        /// </summary>
        public virtual void BringToFront()
        {
            this.UIComponent.BringToFront();
        }

        /// <summary>
        /// Calculates the minimum required size of the control.
        /// </summary>
        /// <returns>The minimum required size of the control.</returns>
        public virtual Vector2 GetMinimumSize()
        {
            return this.UIComponent.CalculateMinimumSize();
        }

        /// <summary>
        /// Calculates the control's current bounds.
        /// </summary>
        /// <returns>The current bounds of the control.</returns>
        public Bounds GetBounds()
        {
            return this.UIComponent.GetBounds();
        }

        public Vector3[] GetCorners()
        {
            return this.UIComponent.GetCorners();
        }

        public void FitToChildren()
        {
            this.UIComponent.FitChildren();
        }

        public void FitToChildren(Vector2 margin)
        {
            this.UIComponent.FitChildren(margin);
        }

        public void FitToChildrenHorizontally()
        {
            this.UIComponent.FitChildrenHorizontally();
        }

        public void FitToChildrenHorizontally(float margin)
        {
            this.UIComponent.FitChildrenHorizontally(margin);
        }

        public void FitToChildrenVertically()
        {
            this.UIComponent.FitChildrenVertically();
        }

        public void FitToChildrenVertically(float margin)
        {
            this.UIComponent.FitChildrenVertically(margin);
        }

        public void FitTo(IColossalControl control)
        {
            this.UIComponent.FitTo(control.UIComponent);
        }

        public void FitTo(IColossalControl control, float margin)
        {
            this.UIComponent.FlexibleFitTo(control.UIComponent, margin);
        }

        public void FitHorizontallyTo(IColossalControl control)
        {
            this.UIComponent.FitTo(control.UIComponent, ColossalFramework.UI.LayoutDirection.Horizontal);
        }

        public void FitVerticallyTo(IColossalControl control)
        {
            this.UIComponent.FitTo(control.UIComponent, ColossalFramework.UI.LayoutDirection.Vertical);
        }

        public bool GetIsClippedFromParent(out ClippingDirections directions)
        {
            ClipDirection clipDirects;

            bool result = this.UIComponent.IsClippedFromParent(out clipDirects);

            directions = (ClippingDirections)clipDirects;

            return result;
        }

        #endregion

        #region Appearance

        /// <summary>
        /// Applies the calculated opacity (opacity of parent elements included) to the given <paramref name="color"/>.
        /// </summary>
        /// <param name="color">The color on which to apply the opacity.</param>
        /// <returns>A new color with the opacity applied.</returns>
        protected virtual Color32 ApplyOpacity(Color32 color)
        {
            return CallUIComponentMethod<Color32>("ApplyOpacity", color);
        }

        /// <summary>
        /// Calculates the opacity for this control including the opacity values of all parent elements.
        /// </summary>
        /// <returns>The calculated opacity for the control.</returns>
        protected virtual float CalculateOpacity()
        {
            return CallUIComponentMethod<float>("CalculateOpacity");
        }

        /// <summary>
        /// Hides the control.
        /// </summary>
        public void Hide()
        {
            this.UIComponent.Hide();
        }

        /// <summary>
        /// Shows the control.
        /// </summary>
        public void Show()
        {
            this.UIComponent.Show();
        }

        #endregion

        public Camera GetCamera()
        {
            return this.UIComponent.GetCamera();
        }

        public Vector3 GetCenter()
        {
            return this.UIComponent.GetCenter();
        }

        protected virtual Plane[] GetClippingPlanes()
        {
            return CallUIComponentMethod<Plane[]>("GetClippingPlanes");
        }

        public bool GetHitPosition(Ray ray, out Vector2 position)
        {
            return this.UIComponent.GetHitPosition(ray, out position);
        }

        protected UITooltipAnchor GetInheritedTooltipAnchor()
        {
            return CallUIComponentMethod<UITooltipAnchor>("GetInheritedTooltipAnchor");
        }

        public IColossalControl GetRootContainer()
        {
            return new ColossalControl(this.UIComponent.GetRootContainer());
        }

        public IColossalControl GetRootCustomContainer()
        {
            return new ColossalControl(this.UIComponent.GetRootCustomControl());
        }

        protected Vector3 GetScaledDirection(Vector3 direction)
        {
            return CallUIComponentMethod<Vector3>("GetScaledDirection", direction);
        }

        // TODO: Wrapper for UIView ?
        /// <summary>
        /// Searches the next <see cref="UIView"/> up in the UI hierarchy.
        /// </summary>
        /// <returns>The found <see cref="UIView"/>.</returns>
        public UIView GetUIView()
        {
            return this.UIComponent.GetUIView();
        }

        public virtual void Invalidate()
        {
            this.UIComponent.Invalidate();
        }

        #region Event handling

        protected bool InvokeEvent(string eventName, params object[] args)
        {
            return CallUIComponentMethod<bool>("Invoke", eventName, args);
        }

        protected bool InvokeEvent(GameObject target, string eventName, params object[] args)
        {
            return CallUIComponentMethod<bool>("Invoke", eventName, args);
        }

        protected bool InvokeEventUpward(string eventName, params object[] args)
        {
            return CallUIComponentMethod<bool>("InvokeUpward", eventName, args);
        }

        #endregion

        public virtual void Localize()
        {
            this.UIComponent.Localize();
        }

        public virtual void LocalizeTooltip()
        {
            this.UIComponent.LocalizeTooltip();
        }

        public void MakePixelPerfect()
        {
            this.MakePixelPerfect(true);
        }

        public void MakePixelPerfect(bool recursive)
        {
            this.UIComponent.MakePixelPerfect(recursive);
        }

        public virtual void MoveBackward()
        {
            this.UIComponent.MoveBackward();
        }

        public virtual void MoveForward()
        {
            this.UIComponent.MoveForward();
        }

        public void PerformLayout()
        {
            this.UIComponent.PerformLayout();
        }

        public float PixelsToUnits()
        {
            return this.CallUIComponentMethod<float>("PixelsToUnits");
        }

        protected void PlayClickSound()
        {
            this.CallUIComponentMethod<object>("PlayClickSound", this.UIComponent);
        }

        protected void PlayDisabledClickSound()
        {
            this.CallUIComponentMethod<object>("PlayDisabledClickSound", this.UIComponent);
        }

        public bool Raycast(Ray ray)
        {
            Vector3 hitPoint;

            return this.Raycast(ray, out hitPoint);
        }

        public bool Raycast(Ray ray, out Vector3 hitPoint)
        {
            return this.UIComponent.Raycast(ray, out hitPoint);
        }

        public HitPointInfo[] RaycastAll(Ray ray)
        {
            List<UIHitInfo> hitInfos = new List<UIHitInfo>();

            this.UIComponent.Raycast(ray, hitInfos);

            return hitInfos.Select(h => new HitPointInfo(h)).ToArray();
        }

        public void RefreshTooltip()
        {
            this.UIComponent.RefreshTooltip();
        }

        protected void RemoveAllEventHandlers()
        {
            foreach (FieldInfo fieldInfo in GetAllEventFields(this.GetType()))
            {
                fieldInfo.SetValue((object)this, (object)null);
            }

            this.CallUIComponentMethod<object>("RemoveAllEventHandlers");
        }

        public void RemoveControl<TControl>(TControl control)
            where TControl : IColossalControl
        {
            this.UIComponent.RemoveUIComponent(control.UIComponent);
        }

        public virtual void ResetLayout()
        {
            this.UIComponent.ResetLayout();
        }

        public virtual void ResetLayout(bool recursive, bool force)
        {
            this.UIComponent.ResetLayout(recursive, force);
        }

        public virtual void SendToBack()
        {
            this.UIComponent.SendToBack();
        }

        public void Show(bool bringToFront)
        {
            this.UIComponent.Show(bringToFront);
        }

        public void SimulateClick()
        {
            this.UIComponent.SimulateClick();
        }

        protected Vector3 TransformOffset(Vector3 offset)
        {
            return this.CallUIComponentMethod<Vector3>("TransformOffset", offset);
        }

        private static FieldInfo[] GetAllEventFields(Type type)
        {
            if (type == null)
            {
                return new FieldInfo[0];
            }

            BindingFlags bindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

            var fieldInfos = type.GetFields(bindingFlags).Where(fi => typeof(Delegate).IsAssignableFrom(fi.FieldType) && !fi.IsDefined(typeof(HideInInspector), true));

            return fieldInfos.Concat(GetAllEventFields(type.BaseType)).ToArray();
        }

        #endregion

        #region Operators

        public static implicit operator UIComponent(ColossalControl control)
        {
            return control.UIComponent;
        }

        public static ColossalControl operator +(ColossalControl control1, IColossalControl control2)
        {
            control1.AttachControl(control2);

            return control1;
        }

        #endregion

        #region Event wrappers

        #region Mouse actions

        protected void OnClick(UIComponent component, UIMouseEventParameter e)
        {
            if (this.Click != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.Click(this, args);
            }
        }

        protected void OnDisabledClick(UIComponent component, UIMouseEventParameter e)
        {
            if (this.DisabledClick != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.DisabledClick(this, args);
            }
        }

        protected void OnDoubleClick(UIComponent component, UIMouseEventParameter e)
        {
            if (this.DoubleClick != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.DoubleClick(this, args);
            }
        }

        protected void OnMouseDown(UIComponent component, UIMouseEventParameter e)
        {
            if (this.MouseDown != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.MouseDown(this, args);
            }
        }

        protected void OnMouseUp(UIComponent component, UIMouseEventParameter e)
        {
            if (this.MouseUp != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.MouseUp(this, args);
            }
        }

        protected void OnMouseWheel(UIComponent component, UIMouseEventParameter e)
        {
            if (this.MouseWheel != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.MouseWheel(this, args);
            }
        }

        protected void OnMouseEnter(UIComponent component, UIMouseEventParameter e)
        {
            if (this.MouseEnter != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.MouseEnter(this, args);
            }
        }

        protected void OnMouseLeave(UIComponent component, UIMouseEventParameter e)
        {
            if (this.MouseLeave != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.MouseLeave(this, args);
            }
        }

        protected void OnMouseHover(UIComponent component, UIMouseEventParameter e)
        {
            if (this.MouseHover != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.MouseHover(this, args);
            }
        }

        protected void OnMouseMove(UIComponent component, UIMouseEventParameter e)
        {
            if (this.MouseMove != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.MouseMove(this, args);
            }
        }

        protected void OnDragStart(UIComponent component, UIDragEventParameter e)
        {
            if (this.DragStart != null)
            {
                DragEventArgs args = new DragEventArgs(e);

                this.DragStart(this, args);
            }
        }

        protected void OnDragEnd(UIComponent component, UIDragEventParameter e)
        {
            if (this.DragEnd != null)
            {
                DragEventArgs args = new DragEventArgs(e);

                this.DragEnd(this, args);
            }
        }

        protected void OnDragEnter(UIComponent component, UIDragEventParameter e)
        {
            if (this.DragEnter != null)
            {
                DragEventArgs args = new DragEventArgs(e);

                this.DragEnter(this, args);
            }
        }

        protected void OnDragLeave(UIComponent component, UIDragEventParameter e)
        {
            if (this.DragLeave != null)
            {
                DragEventArgs args = new DragEventArgs(e);

                this.DragLeave(this, args);
            }
        }

        protected void OnDragOver(UIComponent component, UIDragEventParameter e)
        {
            if (this.DragOver != null)
            {
                DragEventArgs args = new DragEventArgs(e);

                this.DragOver(this, args);
            }
        }

        protected void OnDragDrop(UIComponent component, UIDragEventParameter e)
        {
            if (this.DragDrop != null)
            {
                DragEventArgs args = new DragEventArgs(e);

                this.DragDrop(this, args);
            }
        }

        protected void OnTooltipEnter(UIComponent component, UIMouseEventParameter e)
        {
            if (this.TooltipEnter != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.TooltipEnter(this, args);
            }
        }

        protected void OnTooltipLeave(UIComponent component, UIMouseEventParameter e)
        {
            if (this.TooltipLeave != null)
            {
                MouseEventArgs args = new MouseEventArgs(e);

                this.TooltipLeave(this, args);
            }
        }

        #endregion

        #region Keyboard actions

        protected void OnKeyDown(UIComponent component, UIKeyEventParameter e)
        {
            if (this.KeyDown != null)
            {
                KeyboardEventArgs args = new KeyboardEventArgs(e);

                this.KeyDown(this, args);
            }
        }

        protected void OnKeyUp(UIComponent component, UIKeyEventParameter e)
        {
            if (this.KeyUp != null)
            {
                KeyboardEventArgs args = new KeyboardEventArgs(e);

                this.KeyUp(this, args);
            }
        }

        protected void OnKeyPress(UIComponent component, UIKeyEventParameter e)
        {
            if (this.KeyPress != null)
            {
                KeyboardEventArgs args = new KeyboardEventArgs(e);

                this.KeyPress(this, args);
            }
        }

        #endregion

        #region Child controls

        protected void OnChildControlAdded(UIComponent component, UIComponent e)
        {
            if (this.ChildControlAdded != null)
            {
                this.ChildControlAdded(this, FromUIComponent(e));
            }
        }

        protected void OnChildControlRemoved(UIComponent component, UIComponent e)
        {
            if (this.ChildControlRemoved != null)
            {
                this.ChildControlRemoved(this, FromUIComponent(e));
            }
        }

        #endregion

        #region Positioning and Scaling

        protected void OnAnchorChanged(UIComponent component, UIAnchorStyle e)
        {
            if (this.AnchorChanged != null)
            {
                PropChangedEventArgs<Anchor> args = new PropChangedEventArgs<Anchor>("Anchor", (Anchor)e);

                this.AnchorChanged(this, args);
            }
        }

        protected void OnFitChildren()
        {
            if (this.FitChildren != null)
            {
                this.FitChildren(this);
            }
        }

        protected void OnPositionChanged(UIComponent component, Vector2 e)
        {
            if (this.PositionChanged != null)
            {
                PropChangedEventArgs<Vector2> args = new PropChangedEventArgs<Vector2>("Position", e);

                this.PositionChanged(this, args);
            }
        }

        protected void OnSizeChanged(UIComponent component, Vector2 e)
        {
            if (this.SizeChanged != null)
            {
                PropChangedEventArgs<Vector2> args = new PropChangedEventArgs<Vector2>("Size", e);

                this.SizeChanged(this, args);
            }
        }

        #endregion

        #region Appearance

        protected void OnColorChanged(UIComponent component, Color32 e)
        {
            if (this.ColorChanged != null)
            {
                PropChangedEventArgs<Color32> args = new PropChangedEventArgs<Color32>("Color", e);

                this.ColorChanged(this, args);
            }
        }

        protected void OnDisabledColorChanged(UIComponent component, Color32 e)
        {
            if (this.DisabledColorChanged != null)
            {
                PropChangedEventArgs<Color32> args = new PropChangedEventArgs<Color32>("DisabledColor", e);

                this.DisabledColorChanged(this, args);
            }
        }

        protected void OnOpacityChanged(UIComponent component, float e)
        {
            if (this.OpacityChanged != null)
            {
                PropChangedEventArgs<float> args = new PropChangedEventArgs<float>("Opacity", e);

                this.OpacityChanged(this, args);
            }
        }

        protected void OnPivotChanged(UIComponent component, UIPivotPoint e)
        {
            if (this.PivotChanged != null)
            {
                PropChangedEventArgs<PivotPoint> args = new PropChangedEventArgs<PivotPoint>("Pivot", (PivotPoint)e);

                this.PivotChanged(this, args);
            }
        }

        protected void OnTooltipShow(UIComponent component, UITooltipEventParameter e)
        {
            if (this.TooltipShow != null)
            {
                TooltipEventArgs args = new TooltipEventArgs(e);

                this.TooltipShow(this, args);
            }
        }

        protected void OnTooltipHide(UIComponent component, UITooltipEventParameter e)
        {
            if (this.TooltipHide != null)
            {
                TooltipEventArgs args = new TooltipEventArgs(e);

                this.TooltipHide(this, args);
            }
        }

        protected void OnTooltipTextChanged(UIComponent component, string e)
        {
            if (this.TooltipTextChanged != null)
            {
                PropChangedEventArgs<string> args = new PropChangedEventArgs<string>("TooltipText", e);

                this.TooltipTextChanged(this, args);
            }
        }

        protected void OnZOrderChanged(UIComponent component, int e)
        {
            if (this.ZOrderChanged != null)
            {
                PropChangedEventArgs<int> args = new PropChangedEventArgs<int>("ZOrder", e);

                this.ZOrderChanged(this, args);
            }
        }

        #endregion

        #region State

        protected void OnFocus(UIComponent component, UIFocusEventParameter e)
        {
            if (this.Focus != null)
            {
                FocusEventArgs args = new FocusEventArgs(e);

                this.Focus(this, args);
            }
        }

        protected void OnFocused(UIComponent component, UIFocusEventParameter e)
        {
            if (this.Focused != null)
            {
                FocusEventArgs args = new FocusEventArgs(e);

                this.Focused(this, args);
            }
        }

        protected void OnUnfocus(UIComponent component, UIFocusEventParameter e)
        {
            if (this.Unfocus != null)
            {
                FocusEventArgs args = new FocusEventArgs(e);

                this.Unfocus(this, args);
            }
        }

        protected void OnUnfocused(UIComponent component, UIFocusEventParameter e)
        {
            if (this.Unfocused != null)
            {
                FocusEventArgs args = new FocusEventArgs(e);

                this.Unfocused(this, args);
            }
        }

        protected void OnIsEnabledChanged(UIComponent component, bool e)
        {
            if (e)
            {
                if (this.Enabled != null)
                {
                    PropChangedEventArgs<bool> args = new PropChangedEventArgs<bool>("IsEnabled", e);

                    this.Enabled(this, args);
                }
            }
            else
            {
                if (this.Disabled != null)
                {
                    PropChangedEventArgs<bool> args = new PropChangedEventArgs<bool>("IsEnabled", e);

                    this.Disabled(this, args);
                }
            }
        }

        protected void OnVisibilityChanged(UIComponent component, bool e)
        {
            if (this.VisibilityChanged != null)
            {
                PropChangedEventArgs<bool> args = new PropChangedEventArgs<bool>("Color", e);

                this.VisibilityChanged(this, args);
            }
        }

        protected void OnTabIndexChanged(UIComponent component, int e)
        {
            if (this.TabIndexChanged != null)
            {
                PropChangedEventArgs<int> args = new PropChangedEventArgs<int>("Color", e);

                this.TabIndexChanged(this, args);
            }
        }

        #endregion

        #endregion

        #region IComparable<ColossalControl<T>>

        public int CompareTo(IColossalControl other)
        {
            return this.UIComponent.CompareTo(other.UIComponent);
        }

        #endregion

        ~ColossalControl()
        {
            this.Dispose(true);
        }

        #region IDisposable

        public void Dispose()
        {
            this.Dispose(true);
        }

        bool disposed = false;

        public void Dispose(bool disposing)
        {
            if(!disposed)
            {
                if (disposing)
                {
                    this.UnsubscribeEvents();
                }

                disposed = true;
            }
        }

        #endregion
    }
}

redpajama_set_name: RedPajamaGithub


We have launched a new range of Green Dedicated Servers using energy efficient servers housed in our Solar Powered Data Centre, that runs on 100% Renewable Energy and Carbon Offset.
As an introductory offer, we have a limited number of servers available at a reduced price of just £99.95 per month which includes 32GB or RAM and 2 x 480 GB Intel Sold State Drives (SSD) a saving of £74.90 per month over the standard price of £174.85 per month.
ASP.NET Core 2.2 has been released this week and is available on all our Windows Server 2019 Web Hosting Packages and Reseller Web Hosting Packages.
Web Wiz specialises in Green Web Hosting Services from our Energy Efficient Data Centre that is powered by our on-site Solar Panel Array.
Web Wiz is pleased to announce the release of our updated Web Hosting and Reseller Web Hosting Packages based on the Windows Server 2019 platform.
Windows Server 2019 with IIS 10 offers many new features and enhancements over previous versions including improved support for HTTP/2 and OCSP Stapling.
HTTP/2 significantly speeds up the loading times of websites that use SSL/TLS. If you want to take advantage of the extra speed that HTTP/2 provides you will also need to have an SSL Certificate for your website, which Web Wiz are able to provide.
At Web Wiz we are committed to cutting our carbon emissions and off-setting those carbon emissions that we cannot eliminate.
While much of the electric power we use comes from our on-site Solar Panel Array we still need to use utility electricity at times.
While our electricity provider uses only 100% Renewable Energy Sources, like everyone else in the UK our electricity comes from the National Grid which uses a mixture of renewable, nuclear, coal, and gas. We therefore still offset all the electricity that we use.
For the 8th year, we have partnered with the World Land Trust through their Carbon Balanced Programme to offset our Carbon Emissions.
For in-depth information on how our contributions help protect carbon-rich wildlife habitats, the World Land Trust has provided us with a Carbon Balanced Report.


Treasure Cave is a new Enterprise program, graphics was made by Endi, the program EXOS compatible. It contains 10 maps.
Enterprise conversion of Commodore +4 Exorcist game, it is EXOS compatible, ZIP file contains 2 loaders, EXORC128.COM can be loaded only on EP with at least 96KB of RAM, EXORCIST.COM can be loaded on all machines, it just makes some restrictions on EP64, 1 song is not loaded, cheat song is loaded only if there is enough free space on shared segment, and sprite display mode can not be changed.
Conversion of Commodore Plus4 Quadrillion 4K game, the game is Exos compatible and runs on EP64 also.
IstvanV has rewritten Commodore Plus4 Quadrillion 4K game, the game is Exos compatible, runs on EP64 also, and recognize turbo machines.
Additional sounds have been added.
Modified version of Qaudrillion by Istvanv which got levels of C64 game Crillion, and game rules of it. The game is Exos compatible, runs on EP64 also, and recognize turbo machines.
Quadrillion 4K version of IstvanV has been upgraded, display can be changed between IstvanV's version and my version, contains all backrounds, and the menu music has been changed to 2 MOD musics, moving blocks are moving , explosion effect was built in, and sounds has been changed. It needs 128KB RAM, and recognize turbo machines.
File selection did not work with SD card reader, now it has been solved, and snapshot can be saved into file and loaded back, RAM save/load remained.
Treasure Cave is an extended version of Treasure Cave 4K, graphics by Endi, music and sound effects by Szipucsu, the program is EXOS compatible, at least 128KB is needed to start, It contains 32 maps, 4 digi ingame songs, and 5 different game over digi songs.


text:
This is the story behind the first AirAsia plane that touched down at klia2. The global AirAsia BIG Loyalty Programme (BIG), takes to the skies today, launching its new livery on the plane that made history by being the first AirAsia plane to land at klia2. Inspired by Asian culture and its significance in the world, the new BIG livery design is part of the BIG Plane Project, which included a social media contest on AirAsia BIG's Facebook page, with fifty livery designs submitted by fans over ten days.
Malaysia's own artist, Cheeming Boey, known for his coffee cup illustrations
and web comic 'iamboey' was commissioned for the caricatures.
6 lucky winners with the best livery designs had their portrait caricatures featured on BIG's Airbus A320 in AirAsia's distinctive red and white theme, serving both domestic and regional routes.
Moving forward, BIG plans to feature local artists from various countries around the region on AirAsia planes. BIG member Krittaphong Wongsachai, from Thailand, won the grand prize with more than 500 votes for his koi fish inspired design. Wongsachai walked away with 100,000 BIG points, equivalent to three free return flights to Hong Kong from Bangkok. Koi is believed to be a lucky fish in Asian culture, having the power to enhance lives and bring auspiciousness. The fish is also recognizable for its red and white hues, which also happens to be AirAsia's iconic colours. F
For more information about AirAsia Big New Livery & New Direction Forward, please visit: www.airasiabig.com
Unknown 3 Jun 2014, 08:17:00
I see, I got the BIG card but seldom use it.


We specialize in designing and installing barcode scanning software and RFID tracking systems for bar code folders, file folders, and other items.
If you have a question about our bar code scanning and tracking systems, please visit our IMS Division website or call us toll free at 1-800-803-1083.
Click below to view RFID tracking brochures and filing systems brochures for file management.


I purchased my La Pavoni Zip in April of 2000. Plenty of coffee has run through the mill and I have used this machine daily for 13 years without any issues whatsoever.
Looking at it I decided it's finally time to renew the burrs (which cost less than $50 from dealers). Inspecting the interior, it is "as new" with the exception of normal, uniform wear to the grinding surfaces (still grinds fine as I write this).
So what more can I say about this fine, robust appliance? The hopper exactly fits a standard 1,000 gram bag of imported espresso, it's simple to disassemble the grinding chamber for inspection or to clear a foreign object if need presents, and it runs forever. I paid $450.00 for mine back then, today they sell on line for around $850, a good deal if you want to buy one and forget fiddling with it for more than a decade of steady grinding. Well, inspecting the interior led me to write this review, it's seldom that one can speak so well of an old appliance.


text:
Knee replacement surgery (partial)
What is partial knee replacement surgery?
Partial knee replacement, also known as uni-compartmental knee replacement, may be suitable for patients suffering from arthritis, where only one of the three main parts of the knee has been affected. The majority of patients needing knee replacement surgery will need a total knee replacement.
The inner half of the joint between the thigh bone and shin bone is called the medial compartment. Approximately one third of people with knee osteoarthritis will have it only in the medial compartment.
Robotics-assisted knee surgery at Circle Reading Hospital
As a private patient, you can now choose to have a robotics-assisted partial knee replacement with an expert surgeon at Circle Reading Hospital.
The NAVIO Surgical system helps some of the country's leading surgeons to deliver even greater accuracy during your operation, while also eliminating the need for a CT scan before surgery.
Find out more about the NAVIO Surgical System and how it can help you.
When is partial knee replacement suitable?
The symptoms will be very similar to those in people with arthritis throughout the joint. Pain, stiffness and progressive deformity are the possible features. There may well be a pre-existing bow-legged deformity which predisposes to medial compartment arthritis as all the load passes through the inner half of the knee.
There are two options once the stage has been reached where knee replacement needs to be considered. Either total knee replacement or a uni-compartmental (partial) knee replacement. For a partial knee replacement, the deformity must be correctable, the ligaments must all be intact and the range of knee movement should be preserved.
The guide price for a partial knee replacement is £10,550. This excludes the initial consultation with a specialist, but includes pre-assessment, surgery and aftercare. A fixed quotation will be provided after the initial consultation.
The guide price for knee replacement surgery (partial) is £10550. This excludes the initial consultation with a specialist, but includes pre-assessment, surgery and aftercare. A fixed quotation will be provided after the initial consultation.
Mr Ashwin Unnithan
Mr Chinna Arvind
Mr Ed Tayton
Mr Hazem Hassouna
Mr Joshua Jacob
Consultant Trauma & Orthopaedic Surgeon
Mr Klaus Hilt
Mr Nev Davies
Mr Raj Goel
Mr Richard Dodds
Mr Sean O'Leary
Mr Shawn Tavares


Birkenstock is back with their infamous Arizona sandal. Step out this summer in comfort and timeless style with this brown design, featuring two buckled straps sat on a leather insole. The cork latex midsole and EVA outsole give a shock absorbing finish.


The Farfa Benedictine Abbey is one of the most important religious monuments of the Lazio and one of the leading places in the history of Italian and European monasticism. Founded by San Lorenzo Siro the mid-sixth century, it was destroyed by the Lombards and was then rebuilt between VII and VIII century by a group of monks ladyfingers. Thanks to its strategic position, throughout the Middle Ages the Abbey of Farfa maintained an important economic and political position, by exercising its power of castles, towers and villages.
The Abbey of Farfa was enriched soon of a wonderful library, and became the center of the cultural renaissance of this part of Italy. Today Farfa Abbey is one of the key tourist destinations in Sabina. The center of the visit is the beautiful church of Santa Maria, characterized externally by the original Romanesque appearance, visible in the facade and especially in the beautiful and austere bell tower, and within the Roman Ionic columns that divide the three aisles, from thirteenth miraculous icon of Our Lady of Farfa to the sixteenth "Last Judgment" of the Flemish school of counter-façade and the masterpieces of the apse and the elegant seventeenth-century wooden choir.


The nation's debt profile has risen to N22.38 trillion within the last six months, the Debt Management Office (DMO) has said.
The current debt profile indicates 3.01 percent increase from N21.68 trillion recorded at end of December 2017.
Addressing newsmen in Abuja on Tuesday, the DMO attributed the increase to the $2.5bn Eurobond issued by the Federal Government in February.
The debt office said, "The total public debt which encompasses the domestic and external debt stock of the Federal and 36 State governments and the Federal Capital Territory stood at N22.38 trillion or $73.21 billion as at June 30, 2018.
"When compared to the debt data for March 2018, the public debt stock actually decreased by 1.44 percent from N22.71 trillion in March 2018 to N22.38tn in June 2018.