MONTGOMERY, Alabama -- The state board of education delayed today consideration of a measure to recommend more than 500 new social studies books for use in public schools based on allegations that 12 of those books are pro-Islamic.
Objections raised by the conservative groups Eagle Forum of Alabama and ACT! for America included that authors went out of their way to present Islam in a positive light and that they dedicated more space to Islam as compared to Christianity.
The reviews were highly critical of Islam, calling it a violent, intolerant religion and calling for the school board to reject books that did not portray that. They also said certain statements from the books were insulting to Christians.
Should Alabama students learn about world religions in public school?
"Jesus is presented as a man who decided to preach to people about his 'ideas.' No mention of his virgin birth or of his deity as the Son of God. This is offensive and an insult to the Holy Bible scriptures," read one review sent Dec. 4 to school board members.
"Islam has always spread by the sword," read another.
Multiple school board members said they had received few specific criticisms upon which to act, but they would review the complaints before the matter returns to the board in January.
One school board member expressed concern that rejecting the books would be isolating for children.
"My religion stands toe to toe with any religion, and I'm not intimidated because I have faith. ..." said Ella Bell of Montgomery. "I am worried about us trying to protect people from the knowledge of things that happen right around them."
Discovering Our Past: A History of the World-Early Ages. Grade level: 8. Publisher McGraw-Hill.
My World Geography, Chu-Hardwick-Holtgrieve-Wiggins. Grade level: 7. Publisher: Pearson.
World History & Geography: Modern Times, Spielvogel. Grade level 9. Publisher: Glencoe/McGraw-Hill.
World History: Early Ages. Grade: 8. Publisher: Pearson Prentice Hall.
The Americans: Reconstruction to the 21st Century. Grade level: 11. Publisher: Houghton, Mifflin, Harcourt.
Ancient Civilizations Through the Renaissance. Grade level: 8. Publisher: Houghton, Mifflin, Harcourt.
Discovering World Geography, Spielvogel. Grade level: 7. Publisher: McGraw-Hill.
Ancient World History: Patterns of Interaction. Grade level: N.A. Publisher: McDougal Littell.
The Cultural Landscape. Grade level: AP 9-12. Publisher: Pearson Education Inc.
My World History: Pro Guide. Grade level: 8. Publisher: Pearson.
Modern World History: Patterns of Interaction. Grade level: N.A. Publisher: McDougal Littell.
Geography: Teacher's Edition. Grade level: N.A. Publisher: Holt McDougal.


In today's video Daniel will walk you through and provide insights on what to expect when doing a straight arm handstand press, the benefits of doing the handstand and how he's been doing it.
This is a type of handstand that'll activate muscles in your whole body and comes with a very controlled movement that will surely call for a lot of shoulder and core strength. Watch the full video and keep in mind the tips that Daniel is sharing with you through this video.
Don't forget to properly warm-up before doing any kind of handstand training and pay special attention to your wrists.


text:
Flood Prevention Information & Maps
NFIP Technical Bulletins
The National Flood Insurance Program (NFIP) Technical Bulletins provide guidance for complying with the NFIP's building performance requirements contained in Title 44 of the U.S. Code of Federal Regulations (44 CFR) at Section 60.3 Floodplain Management Criteria for Flood-prone Areas. The bulletins help state and local officials interpret the NFIP regulations and are also useful resources for homeowners, insurance agents, building professionals and designers.
Users who need additional guidance concerning National Flood Insurance Program regulatory requirements should contact their appropriate FEMA Regional Office.
FEMA Building Science Branch is committed to its ongoing effort to update all the Technical Bulletins. Keep informed by subscribing to our GovDelivery e-Newsletter!
Technical Bulletin Update Overview (March 2020)
The Bulletins are changing to modernize and streamline their content and presentation, incorporate relevant information from the latest I-Codes and ASCE Standards, provide updated guidance and best practices observed from post-disaster assessments and address known issues identified by a wide range of stakeholders. These changes intended to improve the TBs' usability, credibility, and content while presenting them in a streamlined format.
Access the Updates to NFIP Technical Bulletins www.fema.gov/media-library/assets/documents/166093
TB 0, User's Guide To NFIP Technical Bulletins (2019)
This User's Guide is intended to assist those using the Technical Bulletins issued by the FEMA Mitigation Directorate. This Guide contains a Key Word/Subject Index that identifies topics contained in the Technical Bulletins regarding the National Flood Insurance Program (NFIP). Reference sources and information about ordering additional publications are also provided.
Access Bulletin 0 at www.fema.gov/media-library/assets/documents/1169
TB 1, Requirements For Flood Openings In Foundation Walls And Walls Of Enclosures (2020)
Provides guidance on the NFIP regulations concerning the requirement for openings in below-Base Flood Elevation foundation walls and walls of enclosures for buildings located in Zones A, AE, A1-A30, AR, AO, and AH.
TB 2, Flood Damage-Resistant Materials Requirements (2008)
Provides guidance on the NFIP regulations concerning the required use of flood-damage resistant construction materials for building components located below the Base Flood Elevation in Special Flood Hazard Areas (both A and V zones).
TB 3, Non-Residential Floodproofing - Requirements And Certification (1993)
Provides guidance on the NFIP regulations concerning watertight construction and the required certification for floodproofed non-residential buildings in Zones A, AE, A1-A30, AR, AO, and AH whose lowest floors are below the Base Flood Elevation.
TB 4, Elevator Installation (2019)
Provides guidance on the NFIP regulations concerning the installation of elevators below the Base Flood Elevation in Special Flood Hazard Areas (both A and V zones).
Access Bulletin 4 at https://www.fema.gov/media-library/assets/documents/3478
TB 5, Free-Of-Obstruction Requirements (2020)
Provides guidance on the NFIP regulations concerning obstructions to flood wates below elevated buildings and on building sites in Coastal High Hazard Areas (Zones V, VE, and elevated V1-V30).
TB 6, Below-Grade Parking Requirements (1993)
The purpose of this bulletin is to provide technical guidance on the National Flood Insurance Program (NFIP) floodplain management requirements for below-grade parking garages for nonresidential buildings in Special Flood Hazard Areas (SFHAS) shown on Flood Insurance Rate Maps (FIRMs).
TB 7, Wet Floodproofing Requirements (1993)
Provides guidance on the NFIP regulations concerning wet floodproofing of certain types of structures located in Zones A, AE, A1-A30, AR, AO, and AH.
TB 8, Corrosion Protection Of Metal Connectors In Coastal Areas (2019)
Provides guidance on the need for, selection of, and use of corrosion-resistant metal connectors for the construction of buildings in coastal areas.
TB 9, Design And Construction Guidance For Breakaway Walls Below Elevated Coastal Buildings (2008)
Provides guidance on the NFIP regulations concerning the design and construction of breakaway walls beneath elevated buildings in Coastal High Hazard Areas (Zones V, VE, and VI-V30).
TB 10, Ensuring That Structures Built On Fill In Or Near Special Flood Hazard Areas Are Reasonably Safe From Flooding (2001)
This technical bulletin discusses building techniques, including the use of fill, that can be used to ensure structures are reasonably safe from flooding.
Access Bulletin 10 at https://www.fema.gov/media-library/assets/documents/3522
TB 11, Crawlspace Construction For Buildings Located In Special Flood Hazard Areas (2001)
Provides interim guidance on minimum NFIP requirements as well as best practices for crawlspace construction in the Special Flood Hazard Area.
Flood Prevention Information & Maps Home
Non-Conversion Agreement
Structure Repairs after a Flood

redpajama_set_name: RedPajamaCommonCrawl


by John Richardson ; introduction by David Beasley.
Simcoe, Ont. : Davus Pub., 2001.
Originally publ.: New York : Dewitt and Davenport, 1850.
Title on front flyleaf: Richardson's 'The monk knight of St. John'.
Scott Copy 1 : Gift of Professor Barbara Godard.
viii, 202 p. ; 22 cm.


Hawker is the largest brand of industrial lead-acid batteries in the world. Hawker has manufacturing, assembly, and sales capabilities world-wide – with product solutions that are the moving force behind applications as diverse as telecommunications and aircraft, UPS systems, and submarines.
Brodie is a direct distributor for Hawker. We get our batteries right from the factory so makes purchasing a breeze. The technological expertise of Hawker is nowhere more evident than in the Hawker manufacturing facility in Ooltewah, Tennessee. This Hawker production facility is the most technologically-advanced and environmentally-friendly facility in the industry.
All of technicians at Brodie are certified and trained to work on all makes and model batteries.
Brodie sells and repairs Ice resurfacer batteries.
Ask about our battery planned maintenance!
For more information on batteries, give us a call 800.828.2804 or submit form below.


Sign up to our monthly newsletter to receive FREE UK delivery on your first order, hear about our new releases and get a monthly update buzzing its way to your inbox!
Make sure to tick the box below!
You can change your mind at any time by clicking the unsubscribe link in the footer of any email you receive from us, or by contacting us at info@nectarandbumble.co.uk. We will treat your information with respect. For more information about our privacy practices please visit our website. By clicking below, you agree that we may process your information in accordance with these terms.
*Please note, free delivery codes cannot be used for our subscription box orders.


When my son turned 11, I opened a Schwab brokerage account for him. This was in the midst of the technology bust; stock prices had fallen far below their bubble peaks, so it seemed like a good time to buy. More important, it seemed a good way for him to learn about investing, the economy, and the world around him. We didn't catch the market's bottom—9/11 hit a few months later—but we did pretty well over the next several years. I taught him about the merits of long-term investing and diversification; staples in our portfolio included blue-chip companies such as JPMorgan Chase, IBM, ExxonMobil, and Boeing.


Here I am again but this time with a little review of my newest gadget. As some of you might know, I'm an Audio Editor and need a tablet to read the script while editing. Till 2 days ago I had my most beloved Samsung Galaxy tab for this job. I always love especially the size of it which made it so handy for all sorts of things…the only downside was reading scripts on it. I always had to adjust the size of the pages which made it difficult because you had to do it every time the page changed.
Well, since Neil had the 'horrible' (just joking) idea to have a nice drive around to pop down to B&Q, Toy's r Us and Best Buy.
So we ended up in our most loved (hated) Electronic Store in the area: Best Buy and took a look around the available tablets. I really liked the new Samsung Galaxy 10.1 but from my point of view it was with £399 still too expensive.
So I took another look around and found the Motorola Xoom for only £330 with much more power and also 32 GB RAM, double as much as the Samsung.
After Neil had a little play with it as well, he decided that it would be a good thing to have this one for our new business instead of the Galaxy. So this gorgeous new friend found a new home in Hokusbloke HQ.
I must say, that it is very light (it feels lighter then the iPad 2) which makes it a lot easier to hold in your hand without getting any aches.
I especially like the way how you can lock your device with this little program were you decide in which way it unlocks the tablet.
And this is my home screen. Of course you can organize it the way you like it.
This is the multi-tasking view where you can see all the programs that are running at the moment. (there is also a nice app to kill all those with just one click..more about that later).
Here you can see the overview about your notifications which you can open by tapping on the clock in the right bottom corner. There you find all your notifications like: emails, G+, tweets, basically all the stuff from your apps that are allowed to notify you. You also have a little shortcut under the clock to get direct to a mini version of the full settings menu, like the pull-down bar that you have on your Android.
And because I am a weather geek, I also have to have my all time favourite App on the Xoom again: WeatherPro. For me THE best weather forecast app on the market. The guys from MeteoGroup are also on twitter and facebook and if you have any questions they reply quite quickly. (well, at least the German gang is always up for a quick tweet or reply on facebook).
1st: the overview of the weather of a location you have chosen before. You can find even more details about the daily weather by clicking on the symbols on the left & right side.
2nd: Here you get the satellite images and 3rd the radar view for the oncoming rain.
And this is how the picture overview looks like. All the pictures you have taken with your camera will show up here.
And since one of the most brilliant features about an Android is the live wallpaper, I just wanted to show you my favourite one: Thunderstorm.
You can get it for free or pay the full version which allows you to make more changes.
So, all in all I really love my new gadget. It is faster, I can stream easily my favourite Animes on Crunchyroll even with a low WiFi signal. And yes, the Animes there are free and also is the program. You just have to ignore the advert at the start of every episode you want to watch.
Haven't tried any movie files yet but as many people online say, I don't think that it will be any problem since the Xoom has a lot more power then my Galaxy.
There is just one more App I really think you should have to kill running programs Advance Task Killer. It is free and really does the job – it kills everything (you have ticked…oh…that sadly doesn't apply for annoying co-workers, your boss 0r the noisy neighbours).
I just wish that Kaspersky's Internet Security for the Android wouldn't be so expensive. I really love their prog and would love to have it on the Xoom as well….but not for something around £7.
So, if you like gadgets, tablets and Androids…then forget about the iPad and join me on the dark side! Androids are cool!
Em, well…not sure what my overall message of this post is….maybe…I love my new gadget and it is faster then the Galaxy tab and better then the iPad 2 because it's an Android?!
This entry was posted in Uncategorized and tagged Advanced Task Killer, Android, App, Apple, Best Buy, Gadget, Galaxy tab, iPad 2, MeteoGroup, Motorola Xoom, Samsung, tablet, Thunderstorm, WeatherPro. Bookmark the permalink.


text:
Lavazza Group reaches Gold medal EcoVadis rating
"We are proud of this recognition that has been made possible thanks to the sharing of values and the joint commitment of employees and collaborators, together with representatives of our supply chain," commented Mario Cerutti, our Chief Institutional Relations and Sustainability Officer
EcoVadis logo
TURIN, Italy – For the fourth year in a row, Lavazza Group has obtained the EcoVadis certification, one of the most accredited awards in the international sustainability rating for suppliers. This year, for the first time, Lavazza received the Gold Medal, which attests that they are among the top 5% of the companies evaluated by the team of international experts of EcoVadis.
"Promotion and protection of human rights, environmental protection and business ethics are fundamental principles that have always guided our Group's procurement policy.
We are proud of this recognition that has been made possible thanks to the sharing of values and the joint commitment of employees and collaborators, together with representatives of our supply chain," commented Mario Cerutti, our Chief Institutional Relations and Sustainability Officer.
The EcoVadis platform
The commitment to social and environmental sustainability involves all stakeholders: EcoVadis is the external system that Lavazza has adopted since 2020 to monitor the sustainability performance of its suppliers and propose improvement plans for the environment, human rights, ethics and sustainable supply.
By sending out tailor made questionnaires based on specific indicators (number of workers, country of origin and sector) and the responses received, suppliers are awarded a general score on the performance of the company and a specific ranking related to sustainability issues.
Using the EcoVadis platform, they then assess areas of risk in the supply chain in order to work towards continuous improvement.
Among the pillars on which the evaluation by EcoVadis experts is based, the sections on Environment and Sustainable Supply, together with the section on Work and Human Rights, are those that have contributed most to the achievement of this important result.
Lavazza Group
"Growing Coffee in the Face of Climate Change": the Premier on YouTube on February 8th
Rolando Schirato, Vittoria Coffee: "The history of our company is intertwined with the growth of espresso coffee in Australia"


text:
DEPARTMENT OF HEALTH IN WALTON COUNTY PROVIDES COVID-19 UPDATE, ANNOUNCES 1 ADDITIONAL COVID-19 DEATH 05-24-20
DEPARTMENT OF HEALTH IN WALTON COUNTY PROVIDES
COVID-19 UPDATE, ANNOUNCES 1 ADDITIONAL COVID-19
Patti Roberts
DeFuniak Springs, Fla.— A 81-year-old male who tested positive with COVID-19 has passed
away in Walton County.
We are expressing our condolences to his family and the Florida Department of Health in Walton County will continue to work with our community partners to prevent the spread of COVID-19.
The list of long-term care facilities in Florida associated with COVID-19 cases now includes active cases in each facility in order to provide real-time data. It is important to note, case data contained within the other publicly available information is separate from the data contained in the daily report. The information in the daily report is derived directly from Merlin (State Surveillance System), whereas the information in the long-term care facility list is derived from the Agency for Health Care Administration's Emergency Status System.
The information contained in the report reflects the current available information reported by each facility's staff to the Department via the Agency for Health Care Administration's Emergency Status System. The data is not cumulative but reflects the information available for current residents and staff with cases as of the reported date. Data in the Long-Term Care Facility List report is provisional and subject to change.
Updated demographic information on cases due to ongoing epidemiological
investigations, Data in this report are provisional and subject to change: 106 Walton
County cases include: Laurel Hill-Paxton (1) DeFuniak Springs (69) Freeport (5),
Miramar Beach (3), Santa Rosa Beach (12), Ponce de Leon (2 )Out-of-state tested in
Walton County (14), 8 Walton County deaths.
Age, gender, race, and ethnicity data is available on the dashboard. Zip code level case numbers are also available. The dashboard is updated daily. For more detail on Florida resident cases, please visit the live DOH Dashboard. More information on a case-by-case basis can also be found in the Daily Report. Both are located at FloridaHealthCOVID19.gov. We encourage all Floridians to take the COVID-19 Community Action Survey by visiting www.StrongerThanC19.com
COVID-19 symptoms and treatment
The symptoms of COVID-19 can mirror illnesses such as influenza. Patients with COVID-19 typically
display symptoms such as fever (100.4°F or higher), cough, and/or shortness of breath within 2 to 14
days of exposure to the virus. Approximately 80% of those affected with COVID-19 report mild to
moderate illness and experience a complete recovery. Some experience more severe illness. People who are more vulnerable to the illness include individuals who are over age 65 with underlying health
conditions, immunocompromised, ill or have underlying chronic health conditions, such as heart disease or diabetes.
Many cases of COVID-19 can be managed at home by treating symptoms, and this is encouraged.
However, if you develop worsening symptoms, such as shortness of breath, chest pain, or inability to
drink fluids, contact 911 and advise them of your symptoms as you may need treatment at a hospital.
COVID-19 overview, symptoms, and general prevention
COVID-19 is a new type of coronavirus; coronaviruses are a large family of viruses, some causing illness in people and others that circulate among animals. Other coronaviruses include the common cold and Severe Acute Respiratory Syndrome (SARS). COVID-19 is believed to have emerged from an animal source and is now capable of spreading from person-to-person. There is currently no vaccine to prevent COVID-19.
For more Information on COVID-19
The Joint Information Center on COVID-19 for the State of Florida is also issuing regular
updates daily. Updated information can also be found at https://walton.floridahealth.gov/,
www.floridahealth.gov and www.cdc.gov or you can call the COVID-19 Call Center (866)
779- 6121 24/7 or email COVID-19@flhealth.gov. The Florida Department of Health has
launched a COVID-19 dashboard that will be updated daily with specific County information
more information on daily case by case can be found on daily report
https://floridadisaster.org/covid19/. Expansion to private laboratories has changed the
COVID-19 testing landscape in Florida. Private laboratories are running tests as they receive
swab samples from practitioners. Testing and reporting times vary among commercial and
DOH laboratories. Demographic information may be updated during epidemiological
investigations. These daily reports reflect the state's efforts to accurately and transparently
share information.
DOH-Walton has also initiated the use of Nextdoor application for
Public Agencies, to share information with Walton County residents.
For more information and/or to sign up visit Nextdoor.com.
Follow us on Facebook, Instagram and Twitter at @HealthyFla. For more information about the Florida
Department of Health, please visit www.FloridaHealth.gov .


text:
/********************************************************************/
/*  Office 2007 Renderer Project                                    */
/*                                                                  */
/*  Use the Office2007Renderer class as a custom renderer by        */
/*  providing it to the ToolStripManager.Renderer property. Then    */
/*  all tool strips, menu strips, status strips etc will be drawn   */
/*  using the Office 2007 style renderer in your application.       */
/*                                                                  */
/*   Author: Phil Wright                                            */
/*  Website: www.componentfactory.com                               */
/*  Contact: phil.wright@componentfactory.com                       */
/********************************************************************/

using System.Drawing;
using System.Drawing.Text;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using System.Collections.Generic;

namespace Office2007Renderer
{
    /// <summary>
    /// Draw ToolStrips using the Office 2007 themed appearance.
    /// </summary>
    public class Office2007Renderer : ToolStripProfessionalRenderer
    {
        #region GradientItemColors
        private class GradientItemColors
        {
            #region Public Fields
            public Color InsideTop1;
            public Color InsideTop2;
            public Color InsideBottom1;
            public Color InsideBottom2;
            public Color FillTop1;
            public Color FillTop2;
            public Color FillBottom1;
            public Color FillBottom2;
            public Color Border1;
            public Color Border2;
            #endregion

            #region Identity
            public GradientItemColors(Color insideTop1, Color insideTop2,
                                      Color insideBottom1, Color insideBottom2,
                                      Color fillTop1, Color fillTop2,
                                      Color fillBottom1, Color fillBottom2,
                                      Color border1, Color border2)
            {
                InsideTop1 = insideTop1;
                InsideTop2 = insideTop2;
                InsideBottom1 = insideBottom1;
                InsideBottom2 = insideBottom2;
                FillTop1 = fillTop1;
                FillTop2 = fillTop2;
                FillBottom1 = fillBottom1;
                FillBottom2 = fillBottom2;
                Border1 = border1;
                Border2 = border2;
            }
            #endregion
        }
        #endregion

        #region Static Metrics
        private static int _gripOffset = 1;
        private static int _gripSquare = 2;
        private static int _gripSize = 3;
        private static int _gripMove = 4;
        private static int _gripLines = 3;
        private static int _checkInset = 1;
        private static int _marginInset = 2;
        private static int _separatorInset = 31;
        private static float _cutToolItemMenu = 1.0f;
        private static float _cutContextMenu = 0f;
        private static float _cutMenuItemBack = 1.2f;
        private static float _contextCheckTickThickness = 1.6f;
        private static Blend _statusStripBlend;
        #endregion

        #region Static Colors
        private static Color _c1 = Color.FromArgb(167, 167, 167);
        private static Color _c2 = Color.FromArgb(21, 66, 139);
        private static Color _c3 = Color.FromArgb(76, 83, 92);
        private static Color _c4 = Color.FromArgb(250, 250, 250);
        private static Color _c5 = Color.FromArgb(248, 248, 248);
        private static Color _c6 = Color.FromArgb(243, 243, 243);
        private static Color _r1 = Color.FromArgb(255, 255, 251);
        private static Color _r2 = Color.FromArgb(255, 249, 227);
        private static Color _r3 = Color.FromArgb(255, 242, 201);
        private static Color _r4 = Color.FromArgb(255, 248, 181);
        private static Color _r5 = Color.FromArgb(255, 252, 229);
        private static Color _r6 = Color.FromArgb(255, 235, 166);
        private static Color _r7 = Color.FromArgb(255, 213, 103);
        private static Color _r8 = Color.FromArgb(255, 228, 145);
        private static Color _r9 = Color.FromArgb(160, 188, 228);
        private static Color _rA = Color.FromArgb(121, 153, 194);
        private static Color _rB = Color.FromArgb(182, 190, 192);
        private static Color _rC = Color.FromArgb(155, 163, 167);
        private static Color _rD = Color.FromArgb(233, 168, 97);
        private static Color _rE = Color.FromArgb(247, 164, 39);
        private static Color _rF = Color.FromArgb(246, 156, 24);
        private static Color _rG = Color.FromArgb(253, 173, 17);
        private static Color _rH = Color.FromArgb(254, 185, 108);
        private static Color _rI = Color.FromArgb(253, 164, 97);
        private static Color _rJ = Color.FromArgb(252, 143, 61);
        private static Color _rK = Color.FromArgb(255, 208, 134);
        private static Color _rL = Color.FromArgb(249, 192, 103);
        private static Color _rM = Color.FromArgb(250, 195, 93);
        private static Color _rN = Color.FromArgb(248, 190, 81);
        private static Color _rO = Color.FromArgb(255, 208, 49);
        private static Color _rP = Color.FromArgb(254, 214, 168);
        private static Color _rQ = Color.FromArgb(252, 180, 100);
        private static Color _rR = Color.FromArgb(252, 161, 54);
        private static Color _rS = Color.FromArgb(254, 238, 170);
        private static Color _rT = Color.FromArgb(249, 202, 113);
        private static Color _rU = Color.FromArgb(250, 205, 103);
        private static Color _rV = Color.FromArgb(248, 200, 91);
        private static Color _rW = Color.FromArgb(255, 218, 59);
        private static Color _rX = Color.FromArgb(254, 185, 108);
        private static Color _rY = Color.FromArgb(252, 161, 54);
        private static Color _rZ = Color.FromArgb(254, 238, 170);

        // Color scheme values
        private static Color _textDisabled = _c1;
        private static Color _textMenuStripItem = _c2;
        private static Color _textStatusStripItem = _c2;
        private static Color _textContextMenuItem = _c2;
        private static Color _arrowDisabled = _c1;
        private static Color _arrowLight = Color.FromArgb(106, 126, 197);
        private static Color _arrowDark = Color.FromArgb(64, 70, 90);
        private static Color _separatorMenuLight = Color.FromArgb(245, 245, 245);
        private static Color _separatorMenuDark = Color.FromArgb(197, 197, 197);
        private static Color _contextMenuBack = _c4;
        private static Color _contextCheckBorder = Color.FromArgb(242, 149, 54);
        private static Color _contextCheckTick = Color.FromArgb(66, 75, 138);
        private static Color _statusStripBorderDark = Color.FromArgb(86, 125, 176);
        private static Color _statusStripBorderLight = Color.White;
        private static Color _gripDark = Color.FromArgb(114, 152, 204);
        private static Color _gripLight = _c5;
        private static GradientItemColors _itemContextItemEnabledColors = new GradientItemColors(_r1, _r2, _r3, _r4, _r5, _r6, _r7, _r8, Color.FromArgb(217, 203, 150), Color.FromArgb(192, 167, 118));
        private static GradientItemColors _itemDisabledColors = new GradientItemColors(_c4, _c6, Color.FromArgb(236, 236, 236), Color.FromArgb(230, 230, 230), _c6, Color.FromArgb(224, 224, 224), Color.FromArgb(200, 200, 200), Color.FromArgb(210, 210, 210), Color.FromArgb(212, 212, 212), Color.FromArgb(195, 195, 195));
        private static GradientItemColors _itemToolItemSelectedColors = new GradientItemColors(_r1, _r2, _r3, _r4, _r5, _r6, _r7, _r8, _r9, _rA);
        private static GradientItemColors _itemToolItemPressedColors = new GradientItemColors(_rD, _rE, _rF, _rG, _rH, _rI, _rJ, _rK, _r9, _rA);
        private static GradientItemColors _itemToolItemCheckedColors = new GradientItemColors(_rL, _rM, _rN, _rO, _rP, _rQ, _rR, _rS, _r9, _rA);
        private static GradientItemColors _itemToolItemCheckPressColors = new GradientItemColors(_rT, _rU, _rV, _rW, _rX, _rI, _rY, _rZ, _r9, _rA);
        #endregion

        #region Identity
        static Office2007Renderer()
        {
            InitOffice2007();
        }
        public static void InitOffice2007()
        {
            // One time creation of the blend for the status strip gradient brush
            _statusStripBlend = new Blend();
            _statusStripBlend.Positions = new float[] { 0.0f, 0.25f, 0.25f, 0.57f, 0.86f, 1.0f };
            _statusStripBlend.Factors = new float[] { 0.1f, 0.6f, 1.0f, 0.4f, 0.0f, 0.95f };

        }

        /// <summary>
        /// Initialize a new instance of the Office2007Renderer class.
        /// </summary>
        public Office2007Renderer()
            : base(new Office2007ColorTable())
        {
        }
        #endregion

        #region OnRenderArrow
        /// <summary>
        /// Raises the RenderArrow event.
        /// </summary>
        /// <param name="e">An ToolStripArrowRenderEventArgs containing the event data.</param>
        protected override void OnRenderArrow(ToolStripArrowRenderEventArgs e)
        {
            // Cannot paint a zero sized area
            if ((e.ArrowRectangle.Width > 0) &&
                (e.ArrowRectangle.Height > 0))
            {
                // Create a path that is used to fill the arrow
                using (GraphicsPath arrowPath = CreateArrowPath(e.Item,
                                                                e.ArrowRectangle,
                                                                e.Direction))
                {
                    // Get the rectangle that encloses the arrow and expand slightly
                    // so that the gradient is always within the expanding bounds
                    RectangleF boundsF = arrowPath.GetBounds();
                    boundsF.Inflate(1f, 1f);

                    Color color1 = (e.Item.Enabled ? _arrowLight : _arrowDisabled);
                    Color color2 = (e.Item.Enabled ? _arrowDark : _arrowDisabled);

                    float angle = 0;

                    // Use gradient angle to match the arrow direction
                    switch (e.Direction)
                    {
                        case ArrowDirection.Right:
                            angle = 0;
                            break;
                        case ArrowDirection.Left:
                            angle = 180f;
                            break;
                        case ArrowDirection.Down:
                            angle = 90f;
                            break;
                        case ArrowDirection.Up:
                            angle = 270f;
                            break;
                    }

                    // Draw the actual arrow using a gradient
                    using (LinearGradientBrush arrowBrush = new LinearGradientBrush(boundsF, color1, color2, angle))
                        e.Graphics.FillPath(arrowBrush, arrowPath);
                }
            }
        }
        #endregion

        #region OnRenderButtonBackground
        /// <summary>
        /// Raises the RenderButtonBackground event.
        /// </summary>
        /// <param name="e">An ToolStripItemRenderEventArgs containing the event data.</param>
        protected override void OnRenderButtonBackground(ToolStripItemRenderEventArgs e)
        {
            // Cast to correct type
            ToolStripButton button = (ToolStripButton)e.Item;

            if (button.Selected || button.Pressed || button.Checked)
                RenderToolButtonBackground(e.Graphics, button, e.ToolStrip);
        }
        #endregion

        #region OnRenderDropDownButtonBackground
        /// <summary>
        /// Raises the RenderDropDownButtonBackground event.
        /// </summary>
        /// <param name="e">An ToolStripItemRenderEventArgs containing the event data.</param>
        protected override void OnRenderDropDownButtonBackground(ToolStripItemRenderEventArgs e)
        {
            if (e.Item.Selected || e.Item.Pressed)
                RenderToolDropButtonBackground(e.Graphics, e.Item, e.ToolStrip);
        }
        #endregion

        #region OnRenderItemCheck
        /// <summary>
        /// Raises the RenderItemCheck event.
        /// </summary>
        /// <param name="e">An ToolStripItemImageRenderEventArgs containing the event data.</param>
        protected override void OnRenderItemCheck(ToolStripItemImageRenderEventArgs e)
        {
            // Staring size of the checkbox is the image rectangle
            Rectangle checkBox = e.ImageRectangle;

            // Make the border of the check box 1 pixel bigger on all sides, as a minimum
            checkBox.Inflate(1, 1);

            // Can we extend upwards?
            if (checkBox.Top > _checkInset)
            {
                int diff = checkBox.Top - _checkInset;
                checkBox.Y -= diff;
                checkBox.Height += diff;
            }

            // Can we extend downwards?
            if (checkBox.Height <= (e.Item.Bounds.Height - (_checkInset * 2)))
            {
                int diff = e.Item.Bounds.Height - (_checkInset * 2) - checkBox.Height;
                checkBox.Height += diff;
            }

            // Drawing with anti aliasing to create smoother appearance
            using (UseAntiAlias uaa = new UseAntiAlias(e.Graphics))
            {
                // Create border path for the check box
                using (GraphicsPath borderPath = CreateBorderPath(checkBox, _cutMenuItemBack))
                {
                    // Fill the background in a solid color
                    using (SolidBrush fillBrush = new SolidBrush(ColorTable.CheckBackground))
                        e.Graphics.FillPath(fillBrush, borderPath);

                    // Draw the border around the check box
                    using (Pen borderPen = new Pen(_contextCheckBorder))
                        e.Graphics.DrawPath(borderPen, borderPath);

                    // If there is not an image, then we can draw the tick, square etc...
                    if (e.Image != null)
                    {
                        CheckState checkState = CheckState.Unchecked;

                        // Extract the check state from the item
                        if (e.Item is ToolStripMenuItem)
                        {
                            ToolStripMenuItem item = (ToolStripMenuItem)e.Item;
                            checkState = item.CheckState;
                        }

                        // Decide what graphic to draw
                        switch (checkState)
                        {
                            case CheckState.Checked:
                                // Create a path for the tick
                                using (GraphicsPath tickPath = CreateTickPath(checkBox))
                                {
                                    // Draw the tick with a thickish brush
                                    using (Pen tickPen = new Pen(_contextCheckTick,_contextCheckTickThickness))
                                        e.Graphics.DrawPath(tickPen, tickPath);
                                }
                                break;
                            case CheckState.Indeterminate:
                                // Create a path for the indeterminate diamond
                                using (GraphicsPath tickPath = CreateIndeterminatePath(checkBox))
                                {
                                    // Draw the tick with a thickish brush
                                    using (SolidBrush tickBrush = new SolidBrush(_contextCheckTick))
                                        e.Graphics.FillPath(tickBrush, tickPath);
                                }
                                break;
                        }
                    }
                }
            }
        }
        #endregion

        #region OnRenderItemText
        /// <summary>
        /// Raises the RenderItemText event.
        /// </summary>
        /// <param name="e">An ToolStripItemTextRenderEventArgs containing the event data.</param>
        protected override void OnRenderItemText(ToolStripItemTextRenderEventArgs e)
        {
            if ((e.ToolStrip is MenuStrip) ||
                (e.ToolStrip is ToolStrip) ||
                (e.ToolStrip is ContextMenuStrip) ||
                (e.ToolStrip is ToolStripDropDownMenu))
            {
                // We set the color depending on the enabled state
                if (!e.Item.Enabled)
                    e.TextColor = _textDisabled;
                else
                {
                    if ((e.ToolStrip is MenuStrip) && !e.Item.Pressed && !e.Item.Selected)
                        e.TextColor = _textMenuStripItem;
                    else if ((e.ToolStrip is StatusStrip) && !e.Item.Pressed && !e.Item.Selected)
                        e.TextColor = _textStatusStripItem;
                    else
                        e.TextColor = _textContextMenuItem;
                }

                // All text is draw using the ClearTypeGridFit text rendering hint
                using (UseClearTypeGridFit clearTypeGridFit = new UseClearTypeGridFit(e.Graphics))
                    base.OnRenderItemText(e);
            }
            else
            {
                base.OnRenderItemText(e);
            }
        }
        #endregion

        #region OnRenderItemImage
        /// <summary>
        /// Raises the RenderItemImage event.
        /// </summary>
        /// <param name="e">An ToolStripItemImageRenderEventArgs containing the event data.</param>
        protected override void OnRenderItemImage(ToolStripItemImageRenderEventArgs e)
        {
            // We only override the image drawing for context menus
            if ((e.ToolStrip is ContextMenuStrip) ||
                (e.ToolStrip is ToolStripDropDownMenu))
            {
                if (e.Image != null)
                {
                    if (e.Item.Enabled)
                        e.Graphics.DrawImage(e.Image, e.ImageRectangle);
                    else
                        ControlPaint.DrawImageDisabled(e.Graphics, e.Image,
                                                       e.ImageRectangle.X,
                                                       e.ImageRectangle.Y,
                                                       Color.Transparent);
                }
            }
            else
            {
                base.OnRenderItemImage(e);
            }
        }
        #endregion

        #region OnRenderMenuItemBackground
        /// <summary>
        /// Raises the RenderMenuItemBackground event.
        /// </summary>
        /// <param name="e">An ToolStripItemRenderEventArgs containing the event data.</param>
        protected override void OnRenderMenuItemBackground(ToolStripItemRenderEventArgs e)
        {
            if ((e.ToolStrip is MenuStrip) ||
                (e.ToolStrip is ContextMenuStrip) ||
                (e.ToolStrip is ToolStripDropDownMenu))
            {
                if ((e.Item.Pressed) && (e.ToolStrip is MenuStrip))
                {
                    // Draw the menu/tool strip as a header for a context menu item
                    DrawContextMenuHeader(e.Graphics, e.Item);
                }
                else
                {
                    // We only draw a background if the item is selected and enabled
                    if (e.Item.Selected)
                    {
                        if (e.Item.Enabled)
                        {
                            // Do we draw as a menu strip or context menu item?
                            if (e.ToolStrip is MenuStrip)
                                DrawGradientToolItem(e.Graphics, e.Item, _itemToolItemSelectedColors);
                            else
                                DrawGradientContextMenuItem(e.Graphics, e.Item, _itemContextItemEnabledColors);
                        }
                        else
                        {
                            // Get the mouse position in tool strip coordinates
                            Point mousePos = e.ToolStrip.PointToClient(Control.MousePosition);

                            // If the mouse is not in the item area, then draw disabled
                            if (!e.Item.Bounds.Contains(mousePos))
                            {
                                // Do we draw as a menu strip or context menu item?
                                if (e.ToolStrip is MenuStrip)
                                    DrawGradientToolItem(e.Graphics, e.Item, _itemDisabledColors);
                                else
                                    DrawGradientContextMenuItem(e.Graphics, e.Item, _itemDisabledColors);
                            }
                        }
                    }
                }
            }
            else
            {
                base.OnRenderMenuItemBackground(e);
            }
        }
        #endregion

        #region OnRenderSplitButtonBackground
        /// <summary>
        /// Raises the RenderSplitButtonBackground event.
        /// </summary>
        /// <param name="e">An ToolStripItemRenderEventArgs containing the event data.</param>
        protected override void OnRenderSplitButtonBackground(ToolStripItemRenderEventArgs e)
        {
            if (e.Item.Selected || e.Item.Pressed)
            {
                // Cast to correct type
                ToolStripSplitButton splitButton = (ToolStripSplitButton)e.Item;

                // Draw the border and background
                RenderToolSplitButtonBackground(e.Graphics, splitButton, e.ToolStrip);

                // Get the rectangle that needs to show the arrow
                Rectangle arrowBounds = splitButton.DropDownButtonBounds;

                // Draw the arrow on top of the background
                OnRenderArrow(new ToolStripArrowRenderEventArgs(e.Graphics,
                                                                splitButton,
                                                                arrowBounds,
                                                                SystemColors.ControlText,
                                                                ArrowDirection.Down));
            }
            else
            {
                base.OnRenderSplitButtonBackground(e);
            }
        }
        #endregion

        #region OnRenderStatusStripSizingGrip
        /// <summary>
        /// Raises the RenderStatusStripSizingGrip event.
        /// </summary>
        /// <param name="e">An ToolStripRenderEventArgs containing the event data.</param>
        protected override void OnRenderStatusStripSizingGrip(ToolStripRenderEventArgs e)
        {
            using(SolidBrush darkBrush = new SolidBrush(_gripDark),
                            lightBrush = new SolidBrush(_gripLight))
             {
                // Do we need to invert the drawing edge?
                bool rtl = (e.ToolStrip.RightToLeft == RightToLeft.Yes);

                // Find vertical position of the lowest grip line
                int y = e.AffectedBounds.Bottom - _gripSize * 2 + 1;

                // Draw three lines of grips
                for (int i = _gripLines; i >= 1; i--)
                {
                    // Find the rightmost grip position on the line
                    int x = (rtl ? e.AffectedBounds.Left + 1 :
                                   e.AffectedBounds.Right - _gripSize * 2 + 1);

                    // Draw grips from right to left on line
                    for (int j = 0; j < i; j++)
                    {
                        // Just the single grip glyph
                        DrawGripGlyph(e.Graphics, x, y, darkBrush, lightBrush);

                        // Move left to next grip position
                        x -= (rtl ? -_gripMove : _gripMove);
                    }

                    // Move upwards to next grip line
                    y -= _gripMove;
                }
            }
        }
        #endregion

        #region OnRenderToolStripContentPanelBackground
        /// <summary>
        /// Raises the RenderToolStripContentPanelBackground event.
        /// </summary>
        /// <param name="e">An ToolStripContentPanelRenderEventArgs containing the event data.</param>
        protected override void OnRenderToolStripContentPanelBackground(ToolStripContentPanelRenderEventArgs e)
        {
            // Must call base class, otherwise the subsequent drawing does not appear!
            base.OnRenderToolStripContentPanelBackground(e);

            // Cannot paint a zero sized area
            if ((e.ToolStripContentPanel.Width > 0) &&
                (e.ToolStripContentPanel.Height > 0))
            {
                using (LinearGradientBrush backBrush = new LinearGradientBrush(e.ToolStripContentPanel.ClientRectangle,
                                                                               ColorTable.ToolStripContentPanelGradientEnd,
                                                                               ColorTable.ToolStripContentPanelGradientBegin,
                                                                               90f))
                {
                    e.Graphics.FillRectangle(backBrush, e.ToolStripContentPanel.ClientRectangle);
                }
            }
        }
        #endregion

        #region OnRenderSeparator
        /// <summary>
        /// Raises the RenderSeparator event.
        /// </summary>
        /// <param name="e">An ToolStripSeparatorRenderEventArgs containing the event data.</param>
        protected override void OnRenderSeparator(ToolStripSeparatorRenderEventArgs e)
        {
            if ((e.ToolStrip is ContextMenuStrip) ||
                (e.ToolStrip is ToolStripDropDownMenu))
            {
                // Create the light and dark line pens
                using (Pen lightPen = new Pen(_separatorMenuLight),
                            darkPen = new Pen(_separatorMenuDark))
                {
                    DrawSeparator(e.Graphics, e.Vertical, e.Item.Bounds,
                                  lightPen, darkPen, _separatorInset,
                                  (e.ToolStrip.RightToLeft == RightToLeft.Yes));
                }
            }
            else if (e.ToolStrip is StatusStrip)
            {
                // Create the light and dark line pens
                using (Pen lightPen = new Pen(ColorTable.SeparatorLight),
                            darkPen = new Pen(ColorTable.SeparatorDark))
                {
                    DrawSeparator(e.Graphics, e.Vertical, e.Item.Bounds,
                                  lightPen, darkPen, 0, false);
                }
            }
            else
            {
                base.OnRenderSeparator(e);
            }
        }
        #endregion

        #region OnRenderToolStripBackground
        /// <summary>
        /// Raises the RenderToolStripBackground event.
        /// </summary>
        /// <param name="e">An ToolStripRenderEventArgs containing the event data.</param>
        protected override void OnRenderToolStripBackground(ToolStripRenderEventArgs e)
        {
            if ((e.ToolStrip is ContextMenuStrip) ||
                (e.ToolStrip is ToolStripDropDownMenu))
            {
                // Create border and clipping paths
                using (GraphicsPath borderPath = CreateBorderPath(e.AffectedBounds, _cutContextMenu),
                                      clipPath = CreateClipBorderPath(e.AffectedBounds, _cutContextMenu))
                {
                    // Clip all drawing to within the border path
                    using (UseClipping clipping = new UseClipping(e.Graphics, clipPath))
                    {
                        // Create the background brush
                        using (SolidBrush backBrush = new SolidBrush(_contextMenuBack))
                            e.Graphics.FillPath(backBrush, borderPath);
                    }
                }
            }
            else if (e.ToolStrip is StatusStrip)
            {
                // We do not paint the top two pixel lines, so are drawn by the status strip border render method
                RectangleF backRect = new RectangleF(0, 1.5f, e.ToolStrip.Width, e.ToolStrip.Height - 2);

                // Cannot paint a zero sized area
                if ((backRect.Width > 0) && (backRect.Height > 0))
                {
                    using (LinearGradientBrush backBrush = new LinearGradientBrush(backRect,
                                                                                ColorTable.StatusStripGradientBegin,
                                                                                ColorTable.StatusStripGradientEnd,
                                                                                90f))
                    {
                        backBrush.Blend = _statusStripBlend;
                        e.Graphics.FillRectangle(backBrush, backRect);
                    }
                }
            }
            else
            {
                base.OnRenderToolStripBackground(e);
            }
        }
        #endregion

        #region OnRenderImageMargin
        /// <summary>
        /// Raises the RenderImageMargin event.
        /// </summary>
        /// <param name="e">An ToolStripRenderEventArgs containing the event data.</param>
        protected override void OnRenderImageMargin(ToolStripRenderEventArgs e)
        {
            if ((e.ToolStrip is ContextMenuStrip) ||
                (e.ToolStrip is ToolStripDropDownMenu))
            {
                // Start with the total margin area
                Rectangle marginRect = e.AffectedBounds;

                // Do we need to draw with separator on the opposite edge?
                bool rtl = (e.ToolStrip.RightToLeft == RightToLeft.Yes);

                marginRect.Y += _marginInset;
                marginRect.Height -= _marginInset * 2;

                // Reduce so it is inside the border
                if (!rtl)
                    marginRect.X += _marginInset;
                else
                    marginRect.X += _marginInset / 2;

                // Draw the entire margine area in a solid color
                using (SolidBrush backBrush = new SolidBrush(ColorTable.ImageMarginGradientBegin))
                    e.Graphics.FillRectangle(backBrush, marginRect);

                // Create the light and dark line pens
                using (Pen lightPen = new Pen(_separatorMenuLight),
                            darkPen = new Pen(_separatorMenuDark))
                {
                    if (!rtl)
                    {
                        // Draw the light and dark lines on the right hand side
                        e.Graphics.DrawLine(lightPen, marginRect.Right, marginRect.Top, marginRect.Right, marginRect.Bottom);
                        e.Graphics.DrawLine(darkPen, marginRect.Right - 1, marginRect.Top, marginRect.Right - 1, marginRect.Bottom);
                    }
                    else
                    {
                        // Draw the light and dark lines on the left hand side
                        e.Graphics.DrawLine(lightPen, marginRect.Left - 1, marginRect.Top, marginRect.Left - 1, marginRect.Bottom);
                        e.Graphics.DrawLine(darkPen, marginRect.Left, marginRect.Top, marginRect.Left, marginRect.Bottom);
                    }
                }
            }
            else
            {
                base.OnRenderImageMargin(e);
            }
        }
        #endregion

        #region OnRenderToolStripBorder
        /// <summary>
        /// Raises the RenderToolStripBorder event.
        /// </summary>
        /// <param name="e">An ToolStripRenderEventArgs containing the event data.</param>
        protected override void OnRenderToolStripBorder(ToolStripRenderEventArgs e)
        {
            if ((e.ToolStrip is ContextMenuStrip) ||
                (e.ToolStrip is ToolStripDropDownMenu))
            {
                // If there is a connected area to be drawn
                if (!e.ConnectedArea.IsEmpty)
                    using (SolidBrush excludeBrush = new SolidBrush(_contextMenuBack))
                        e.Graphics.FillRectangle(excludeBrush, e.ConnectedArea);

                // Create border and clipping paths
                using (GraphicsPath borderPath = CreateBorderPath(e.AffectedBounds, e.ConnectedArea, _cutContextMenu),
                                    insidePath = CreateInsideBorderPath(e.AffectedBounds, e.ConnectedArea, _cutContextMenu),
                                      clipPath = CreateClipBorderPath(e.AffectedBounds, e.ConnectedArea, _cutContextMenu))
                {
                    // Create the different pen colors we need
                    using (Pen borderPen = new Pen(ColorTable.MenuBorder),
                               insidePen = new Pen(_separatorMenuLight))
                    {
                        // Clip all drawing to within the border path
                        using (UseClipping clipping = new UseClipping(e.Graphics, clipPath))
                        {
                            // Drawing with anti aliasing to create smoother appearance
                            using (UseAntiAlias uaa = new UseAntiAlias(e.Graphics))
                            {
                                // Draw the inside area first
                                e.Graphics.DrawPath(insidePen, insidePath);

                                // Draw the border area second, so any overlapping gives it priority
                                e.Graphics.DrawPath(borderPen, borderPath);
                            }

                            // Draw the pixel at the bottom right of the context menu
                            e.Graphics.DrawLine(borderPen, e.AffectedBounds.Right, e.AffectedBounds.Bottom,
                                                           e.AffectedBounds.Right - 1, e.AffectedBounds.Bottom - 1);
                        }
                    }
                }
            }
            else if (e.ToolStrip is StatusStrip)
            {
                // Draw two lines at top of the status strip
                using (Pen darkBorder = new Pen(_statusStripBorderDark),
                          lightBorder = new Pen(_statusStripBorderLight))
                {
                    e.Graphics.DrawLine(darkBorder, 0, 0, e.ToolStrip.Width, 0);
                    e.Graphics.DrawLine(lightBorder, 0, 1, e.ToolStrip.Width, 1);
                }
            }
            else
            {
                base.OnRenderToolStripBorder(e);
            }
        }
        #endregion

        #region Implementation
        private void RenderToolButtonBackground(Graphics g,
                                                ToolStripButton button,
                                                ToolStrip toolstrip)
        {
            // We only draw a background if the item is selected or being pressed
            if (button.Enabled)
            {
                if (button.Checked)
                {
                    if (button.Pressed)
                        DrawGradientToolItem(g, button, _itemToolItemPressedColors);
                    else if (button.Selected)
                        DrawGradientToolItem(g, button, _itemToolItemCheckPressColors);
                    else
                        DrawGradientToolItem(g, button, _itemToolItemCheckedColors);
                }
                else
                {
                    if (button.Pressed)
                        DrawGradientToolItem(g, button, _itemToolItemPressedColors);
                    else if (button.Selected)
                        DrawGradientToolItem(g, button, _itemToolItemSelectedColors);
                }
            }
            else
            {
                if (button.Selected)
                {
                    // Get the mouse position in tool strip coordinates
                    Point mousePos = toolstrip.PointToClient(Control.MousePosition);

                    // If the mouse is not in the item area, then draw disabled
                    if (!button.Bounds.Contains(mousePos))
                        DrawGradientToolItem(g, button, _itemDisabledColors);
                }
            }
        }

        private void RenderToolDropButtonBackground(Graphics g,
                                                    ToolStripItem item,
                                                    ToolStrip toolstrip)
        {
            // We only draw a background if the item is selected or being pressed
            if (item.Selected || item.Pressed)
            {
                if (item.Enabled)
                {
                    if (item.Pressed)
                        DrawContextMenuHeader(g, item);
                    else
                        DrawGradientToolItem(g, item, _itemToolItemSelectedColors);
                }
                else
                {
                    // Get the mouse position in tool strip coordinates
                    Point mousePos = toolstrip.PointToClient(Control.MousePosition);

                    // If the mouse is not in the item area, then draw disabled
                    if (!item.Bounds.Contains(mousePos))
                        DrawGradientToolItem(g, item, _itemDisabledColors);
                }
            }

        }

        private void RenderToolSplitButtonBackground(Graphics g,
                                                     ToolStripSplitButton splitButton,
                                                     ToolStrip toolstrip)
        {
            // We only draw a background if the item is selected or being pressed
            if (splitButton.Selected || splitButton.Pressed)
            {
                if (splitButton.Enabled)
                {
                    if (!splitButton.Pressed && splitButton.ButtonPressed)
                        DrawGradientToolSplitItem(g, splitButton,
                                                 _itemToolItemPressedColors,
                                                 _itemToolItemSelectedColors,
                                                 _itemContextItemEnabledColors);
                    else if (splitButton.Pressed && !splitButton.ButtonPressed)
                        DrawContextMenuHeader(g, splitButton);
                    else
                        DrawGradientToolSplitItem(g, splitButton,
                                                 _itemToolItemSelectedColors,
                                                 _itemToolItemSelectedColors,
                                                 _itemContextItemEnabledColors);
                }
                else
                {
                    // Get the mouse position in tool strip coordinates
                    Point mousePos = toolstrip.PointToClient(Control.MousePosition);

                    // If the mouse is not in the item area, then draw disabled
                    if (!splitButton.Bounds.Contains(mousePos))
                        DrawGradientToolItem(g, splitButton, _itemDisabledColors);
                }
            }

        }

        private void DrawGradientToolItem(Graphics g,
                                          ToolStripItem item,
                                          GradientItemColors colors)
        {
            // Perform drawing into the entire background of the item
            DrawGradientItem(g, new Rectangle(Point.Empty, item.Bounds.Size), colors);
        }

        private void DrawGradientToolSplitItem(Graphics g,
                                               ToolStripSplitButton splitButton,
                                               GradientItemColors colorsButton,
                                               GradientItemColors colorsDrop,
                                               GradientItemColors colorsSplit)
        {
            // Create entire area and just the drop button area rectangles
            Rectangle backRect = new Rectangle(Point.Empty, splitButton.Bounds.Size);
            Rectangle backRectDrop = splitButton.DropDownButtonBounds;

            // Cannot paint zero sized areas
            if ((backRect.Width > 0) && (backRectDrop.Width > 0) &&
                (backRect.Height > 0) && (backRectDrop.Height > 0))
            {
                // Area that is the normal button starts as everything
                Rectangle backRectButton = backRect;

                // The X offset to draw the split line
                int splitOffset;

                // Is the drop button on the right hand side of entire area?
                if (backRectDrop.X > 0)
                {
                    backRectButton.Width = backRectDrop.Left;
                    backRectDrop.X -= 1;
                    backRectDrop.Width++;
                    splitOffset = backRectDrop.X;
                }
                else
                {
                    backRectButton.Width -= backRectDrop.Width - 2;
                    backRectButton.X = backRectDrop.Right - 1;
                    backRectDrop.Width++;
                    splitOffset = backRectDrop.Right - 1;
                }

                // Create border path around the item
                using (GraphicsPath borderPath = CreateBorderPath(backRect, _cutMenuItemBack))
                {
                    // Draw the normal button area background
                    DrawGradientBack(g, backRectButton, colorsButton);

                    // Draw the drop button area background
                    DrawGradientBack(g, backRectDrop, colorsDrop);

                    // Draw the split line between the areas
                    using (LinearGradientBrush splitBrush = new LinearGradientBrush(new Rectangle(backRect.X + splitOffset, backRect.Top, 1, backRect.Height + 1),
                                                                                colorsSplit.Border1, colorsSplit.Border2, 90f))
                    {
                        // Sigma curve, so go from color1 to color2 and back to color1 again
                        splitBrush.SetSigmaBellShape(0.5f);

                        // Convert the brush to a pen for DrawPath call
                        using (Pen splitPen = new Pen(splitBrush))
                            g.DrawLine(splitPen, backRect.X + splitOffset, backRect.Top + 1, backRect.X + splitOffset, backRect.Bottom - 1);
                    }

                    // Draw the border of the entire item
                    DrawGradientBorder(g, backRect, colorsButton);
                }
            }
        }

        private void DrawContextMenuHeader(Graphics g, ToolStripItem item)
        {
            // Get the rectangle the is the items area
            Rectangle itemRect = new Rectangle(Point.Empty, item.Bounds.Size);

            // Create border and clipping paths
            using (GraphicsPath borderPath = CreateBorderPath(itemRect, _cutToolItemMenu),
                                insidePath = CreateInsideBorderPath(itemRect, _cutToolItemMenu),
                                  clipPath = CreateClipBorderPath(itemRect, _cutToolItemMenu))
            {
                // Clip all drawing to within the border path
                using (UseClipping clipping = new UseClipping(g, clipPath))
                {
                    // Draw the entire background area first
                    using (SolidBrush backBrush = new SolidBrush(_separatorMenuLight))
                        g.FillPath(backBrush, borderPath);

                    // Draw the border
                    using (Pen borderPen = new Pen(ColorTable.MenuBorder))
                        g.DrawPath(borderPen, borderPath);
                }
            }
        }

        private void DrawGradientContextMenuItem(Graphics g,
                                                 ToolStripItem item,
                                                 GradientItemColors colors)
        {
            // Do we need to draw with separator on the opposite edge?
            Rectangle backRect = new Rectangle(2, 0, item.Bounds.Width - 3, item.Bounds.Height);

            // Perform actual drawing into the background
            DrawGradientItem(g, backRect, colors);
        }

        private void DrawGradientItem(Graphics g,
                                      Rectangle backRect,
                                      GradientItemColors colors)
        {
            // Cannot paint a zero sized area
            if ((backRect.Width > 0) && (backRect.Height > 0))
            {
                // Draw the background of the entire item
                DrawGradientBack(g, backRect, colors);

                // Draw the border of the entire item
                DrawGradientBorder(g, backRect, colors);
            }
        }

        private void DrawGradientBack(Graphics g,
                                      Rectangle backRect,
                                      GradientItemColors colors)
        {
            // Reduce rect draw drawing inside the border
            backRect.Inflate(-1, -1);

            int y2 = backRect.Height / 2;
            Rectangle backRect1 = new Rectangle(backRect.X, backRect.Y, backRect.Width, y2);
            Rectangle backRect2 = new Rectangle(backRect.X, backRect.Y + y2, backRect.Width, backRect.Height - y2);
            Rectangle backRect1I = backRect1;
            Rectangle backRect2I = backRect2;
            backRect1I.Inflate(1, 1);
            backRect2I.Inflate(1, 1);

            using (LinearGradientBrush insideBrush1 = new LinearGradientBrush(backRect1I, colors.InsideTop1, colors.InsideTop2, 90f),
                                       insideBrush2 = new LinearGradientBrush(backRect2I, colors.InsideBottom1, colors.InsideBottom2, 90f))
            {
                g.FillRectangle(insideBrush1, backRect1);
                g.FillRectangle(insideBrush2, backRect2);
            }

            y2 = backRect.Height / 2;
            backRect1 = new Rectangle(backRect.X, backRect.Y, backRect.Width, y2);
            backRect2 = new Rectangle(backRect.X, backRect.Y + y2, backRect.Width, backRect.Height - y2);
            backRect1I = backRect1;
            backRect2I = backRect2;
            backRect1I.Inflate(1, 1);
            backRect2I.Inflate(1, 1);

            using (LinearGradientBrush fillBrush1 = new LinearGradientBrush(backRect1I, colors.FillTop1, colors.FillTop2, 90f),
                                       fillBrush2 = new LinearGradientBrush(backRect2I, colors.FillBottom1, colors.FillBottom2, 90f))
            {
                // Reduce rect one more time for the innermost drawing
                backRect.Inflate(-1, -1);

                y2 = backRect.Height / 2;
                backRect1 = new Rectangle(backRect.X, backRect.Y, backRect.Width, y2);
                backRect2 = new Rectangle(backRect.X, backRect.Y + y2, backRect.Width, backRect.Height - y2);

                g.FillRectangle(fillBrush1, backRect1);
                g.FillRectangle(fillBrush2, backRect2);
            }
        }

        private void DrawGradientBorder(Graphics g,
                                        Rectangle backRect,
                                        GradientItemColors colors)
        {
            // Drawing with anti aliasing to create smoother appearance
            using (UseAntiAlias uaa = new UseAntiAlias(g))
            {
                Rectangle backRectI = backRect;
                backRectI.Inflate(1, 1);

                // Finally draw the border around the menu item
                using (LinearGradientBrush borderBrush = new LinearGradientBrush(backRectI, colors.Border1, colors.Border2, 90f))
                {
                    // Sigma curve, so go from color1 to color2 and back to color1 again
                    borderBrush.SetSigmaBellShape(0.5f);

                    // Convert the brush to a pen for DrawPath call
                    using (Pen borderPen = new Pen(borderBrush))
                    {
                        // Create border path around the entire item
                        using (GraphicsPath borderPath = CreateBorderPath(backRect, _cutMenuItemBack))
                            g.DrawPath(borderPen, borderPath);
                    }
                }
            }
        }

        private void DrawGripGlyph(Graphics g,
                                   int x,
                                   int y,
                                   Brush darkBrush,
                                   Brush lightBrush)
        {
            g.FillRectangle(lightBrush, x + _gripOffset, y + _gripOffset, _gripSquare, _gripSquare);
            g.FillRectangle(darkBrush, x, y, _gripSquare, _gripSquare);
        }

        private void DrawSeparator(Graphics g,
                                   bool vertical,
                                   Rectangle rect,
                                   Pen lightPen,
                                   Pen darkPen,
                                   int horizontalInset,
                                   bool rtl)
        {
            if (vertical)
            {
                int l = rect.Width / 2;
                int t = rect.Y;
                int b = rect.Bottom;

                // Draw vertical lines centered
                g.DrawLine(darkPen, l, t, l, b);
                g.DrawLine(lightPen, l + 1, t, l + 1, b);
            }
            else
            {
                int y = rect.Height / 2;
                int l = rect.X + (rtl ? 0 : horizontalInset);
                int r = rect.Right - (rtl ? horizontalInset : 0);

                // Draw horizontal lines centered
                g.DrawLine(darkPen, l, y, r, y);
                g.DrawLine(lightPen, l, y + 1, r, y + 1);
            }
        }

        private GraphicsPath CreateBorderPath(Rectangle rect,
                                              Rectangle exclude,
                                              float cut)
        {
            // If nothing to exclude, then use quicker method
            if (exclude.IsEmpty)
                return CreateBorderPath(rect, cut);

            // Drawing lines requires we draw inside the area we want
            rect.Width--;
            rect.Height--;

            // Create an array of points to draw lines between
            List<PointF> pts = new List<PointF>();

            float l = rect.X;
            float t = rect.Y;
            float r = rect.Right;
            float b = rect.Bottom;
            float x0 = rect.X + cut;
            float x3 = rect.Right - cut;
            float y0 = rect.Y + cut;
            float y3 = rect.Bottom - cut;
            float cutBack = (cut == 0f ? 1 : cut);

            // Does the exclude intercept the top line
            if ((rect.Y >= exclude.Top) && (rect.Y <= exclude.Bottom))
            {
                float x1 = exclude.X - 1 - cut;
                float x2 = exclude.Right + cut;

                if (x0 <= x1)
                {
                    pts.Add(new PointF(x0, t));
                    pts.Add(new PointF(x1, t));
                    pts.Add(new PointF(x1 + cut, t - cutBack));
                }
                else
                {
                    x1 = exclude.X - 1;
                    pts.Add(new PointF(x1, t));
                    pts.Add(new PointF(x1, t - cutBack));
                }

                if (x3 > x2)
                {
                    pts.Add(new PointF(x2 - cut, t - cutBack));
                    pts.Add(new PointF(x2, t));
                    pts.Add(new PointF(x3, t));
                }
                else
                {
                    x2 = exclude.Right;
                    pts.Add(new PointF(x2, t - cutBack));
                    pts.Add(new PointF(x2, t));
                }
            }
            else
            {
                pts.Add(new PointF(x0, t));
                pts.Add(new PointF(x3, t));
            }

            pts.Add(new PointF(r, y0));
            pts.Add(new PointF(r, y3));
            pts.Add(new PointF(x3, b));
            pts.Add(new PointF(x0, b));
            pts.Add(new PointF(l, y3));
            pts.Add(new PointF(l, y0));

            // Create path using a simple set of lines that cut the corner
            GraphicsPath path = new GraphicsPath();

            // Add a line between each set of points
            for (int i = 1; i < pts.Count; i++)
                path.AddLine(pts[i - 1], pts[i]);

            // Add a line to join the last to the first
            path.AddLine(pts[pts.Count - 1], pts[0]);

            return path;
        }

        private GraphicsPath CreateBorderPath(Rectangle rect, float cut)
        {
            // Drawing lines requires we draw inside the area we want
            rect.Width--;
            rect.Height--;

            // Create path using a simple set of lines that cut the corner
            GraphicsPath path = new GraphicsPath();
            path.AddLine(rect.Left + cut, rect.Top, rect.Right - cut, rect.Top);
            path.AddLine(rect.Right - cut, rect.Top, rect.Right, rect.Top + cut);
            path.AddLine(rect.Right, rect.Top + cut, rect.Right, rect.Bottom - cut);
            path.AddLine(rect.Right, rect.Bottom - cut, rect.Right - cut, rect.Bottom);
            path.AddLine(rect.Right - cut, rect.Bottom, rect.Left + cut, rect.Bottom);
            path.AddLine(rect.Left + cut, rect.Bottom, rect.Left, rect.Bottom - cut);
            path.AddLine(rect.Left, rect.Bottom - cut, rect.Left, rect.Top + cut);
            path.AddLine(rect.Left, rect.Top + cut, rect.Left + cut, rect.Top);
            return path;
        }

        private GraphicsPath CreateInsideBorderPath(Rectangle rect, float cut)
        {
            // Adjust rectangle to be 1 pixel inside the original area
            rect.Inflate(-1, -1);

            // Now create a path based on this inner rectangle
            return CreateBorderPath(rect, cut);
        }

        private GraphicsPath CreateInsideBorderPath(Rectangle rect,
                                                    Rectangle exclude,
                                                    float cut)
        {
            // Adjust rectangle to be 1 pixel inside the original area
            rect.Inflate(-1, -1);

            // Now create a path based on this inner rectangle
            return CreateBorderPath(rect, exclude, cut);
        }

        private GraphicsPath CreateClipBorderPath(Rectangle rect, float cut)
        {
            // Clipping happens inside the rect, so make 1 wider and taller
            rect.Width++;
            rect.Height++;

            // Now create a path based on this inner rectangle
            return CreateBorderPath(rect, cut);
        }

        private GraphicsPath CreateClipBorderPath(Rectangle rect,
                                                  Rectangle exclude,
                                                  float cut)
        {
            // Clipping happens inside the rect, so make 1 wider and taller
            rect.Width++;
            rect.Height++;

            // Now create a path based on this inner rectangle
            return CreateBorderPath(rect, exclude, cut);
        }

        private GraphicsPath CreateArrowPath(ToolStripItem item,
                                             Rectangle rect,
                                             ArrowDirection direction)
        {
            int x, y;

            // Find the correct starting position, which depends on direction
            if ((direction == ArrowDirection.Left) ||
                (direction == ArrowDirection.Right))
            {
                x = rect.Right - (rect.Width - 4) / 2;
                y = rect.Y + rect.Height / 2;
            }
            else
            {
                x = rect.X + rect.Width / 2;
                y = rect.Bottom - (rect.Height - 3) / 2;

                // The drop down button is position 1 pixel incorrectly when in RTL
                if ((item is ToolStripDropDownButton) &&
                    (item.RightToLeft == RightToLeft.Yes))
                    x++;
            }

            // Create triangle using a series of lines
            GraphicsPath path = new GraphicsPath();

            switch (direction)
            {
                case ArrowDirection.Right:
                    path.AddLine(x, y, x - 4, y - 4);
                    path.AddLine(x - 4, y - 4, x - 4, y + 4);
                    path.AddLine(x - 4, y + 4, x, y);
                    break;
                case ArrowDirection.Left:
                    path.AddLine(x - 4, y, x, y - 4);
                    path.AddLine(x, y - 4, x, y + 4);
                    path.AddLine(x, y + 4, x - 4, y);
                    break;
                case ArrowDirection.Down:
                    path.AddLine(x + 3f, y - 3f, x - 2f, y - 3f);
                    path.AddLine(x - 2f, y - 3f, x, y);
                    path.AddLine(x, y, x + 3f, y - 3f);
                    break;
                case ArrowDirection.Up:
                    path.AddLine(x + 3f, y, x - 3f, y);
                    path.AddLine(x - 3f, y, x, y - 4f);
                    path.AddLine(x, y - 4f, x + 3f, y);
                    break;
            }

            return path;
        }

        private GraphicsPath CreateTickPath(Rectangle rect)
        {
            // Get the center point of the rect
            int x = rect.X + rect.Width / 2;
            int y = rect.Y + rect.Height / 2;

            GraphicsPath path = new GraphicsPath();
            path.AddLine(x - 4, y, x - 2, y + 4);
            path.AddLine(x - 2, y + 4, x + 3, y - 5);
            return path;
        }

        private GraphicsPath CreateIndeterminatePath(Rectangle rect)
        {
            // Get the center point of the rect
            int x = rect.X + rect.Width / 2;
            int y = rect.Y + rect.Height / 2;

            GraphicsPath path = new GraphicsPath();
            path.AddLine(x - 3, y, x, y - 3);
            path.AddLine(x, y - 3, x + 3, y);
            path.AddLine(x + 3, y, x, y + 3);
            path.AddLine(x, y + 3, x - 3, y);
            return path;
        }
        #endregion
    }
}

redpajama_set_name: RedPajamaGithub


Clyde: Strangled with a belt by his owner.
We contacted by Scouts Honor Rescue about their latest save. SHR rescued this wonderful boy on Friday and now they need our help! His name is Clyde and his "owners" are under investigation and will hopefully be prosecuted. We are beyond thrilled that his abusers will face consequences for their actions. This is rare in animal abuse cases.
We are now focused on saving Clyde's life. He was strangled with a belt by his abuser/owners. The belt was removed from around his neck and left a gruesome injury. The restriction caused by the belt made his face swell significantly. He is also grossly underweight and has no doubt suffered severe abuse for a long time.
He's staying at their ER vet and getting 24 hour care. He is still in critical condition. He's so sweet and it's obvious he's not used to people being nice to him. He now is starting to wag his tail when we talk to him and lifts his head up for pets instead of cowering when anyone gets close to him. Its heart breaking to see how he has been mentally and physically abused.
Clyde has endured the unthinkable, absolutely horrifying abuse! But you can help him! Saving Clyde is as simple as wearing a tee! We have partnered with Scout's Honor Rescue in creating this week's animal-saving shirt, long sleeve and hoodie design to help us raise funds needed for Clyde's recovery. Please, if you are able, consider purchasing an item below to help save this baby's life!
UPDATE 4-25-17: Happy update on our boy Clyde! Rescuers visited him this morning at their vet and he's doing amazing! He was in great spirits and bouncing around so full of life! He's seriously the cutest! His neck is healing up, but he still has to wear a bandage.
Update on his abuse case. We heard from BARC that all evidence has been turned over to the Harris County DA's office and we are hoping they pursue his former "owner" to the fullest extent!
UPDATE 5-18-17: You may remember Clyde's sad story of cruelty and neglect. We were shocked when we saw his pictures and heard how he had literally been strangled with a belt by his so called owner. His strangulation caused a massive deep cut all around his neck and caused the blood not be able to circulate resulting in his face ballooning until he was unrecognizable. He was confiscated from his owner and charges are pending.
In the meantime, Scout's Honor Rescue brought him into their rescue and have nursed him back to health. We could tell he didn't know what it was like to be treated kindly, but after talking to him a bit and giving him love, he started wagging his tail. He is BEYOND sweet!


Vocalist/Pianist/Composer Mala Waldron (pronounced MAL-uh WALL-drun) is a New York City native who balances local performances with tours all over Europe and Asia. Featured recordings include her CD debut, "Lullabye" (tribute to godmother, Billie Holiday), a duo project with her father, pianist, composer Mal Waldron ("He's My Father") and "Always There" which, in addition to being her first U.S. release, was licensed by Columbia Records (Japan) and voted one of the Top 20 Jazz CDs of 2006 by JazzUSA.
As a band leader, Mala has performed with her group at many esteemed venues including the Jazz Standard, Dizzy's Club Coca Cola, the 55 Bar, Cornelia St. Cafe, BAM Cafe , the 1st Annual Coltrane Day Music Festival, and most recently at the Kennedy Center Millennium Stage, and the 17th Annual Jazz in the Valley festival with the Christopher Dean Sullivan Ensemble. Career highlights include touring and recording with her father, writing and performing her big band arrangements with the James Jabbo Ware, "Me We & Them" Orchestra and singing her original music (orchestrated and conducted by Alfonso Girardo) with a 45-piece jazz symphony, the Magna Grecia Orchestra while on tour in Taranto, Italy.