Plug into our supply of electrical safety courses to avoid the impact of an incident involving electricity.
There is always safety in numbers, especially when it comes to electrical hazards. The more employees are aware of the devastation that electrical hazards, arc flashes, and other electrical incidents cause, the safer they will be.
This training focuses on teaching basic electrical safety principles and procedures, including working around electrical circuits, grounding measures and circuit-protection devices.
Designed to provide important information about safe work practices when working with or around electricity, this interactive training program focuses on how employees can protect themselves from injuries, or even fatalities.
Employees must be reminded from time to time about the various electrical hazards that they may face in their jobs. This safety program will provide the information they need to work safely around low voltage electricity.
Plug into the fundamentals of electrical theory, including current, voltage, and resistance, with this new release electrical training program.
Electrical hazards are all around us at work and at home, in the walls, in ceilings, on counters, in equipment and machinery, and even numerous places outside. Know how to reduce the risk with this electrical safety training.
Shocking, real-life electrical incidents are re-enacted in this training program to help motivate every employee to follow proper electrical safety procedures. Don't let history repeat itself in your facility!
Discuss safe work practices that everyone working around electricity should employ to avoid electrical shock or electrocution. This training provides guidelines for working with electrical circuits, proper grounding procedures and controlling electricity by using proper lockout/tagout methods.
"There were three of us down there. My friend was closer to the breaker...all of a sudden he was a ball of flames." So begins this program which will help your facility comply with OSHA's Electric Power Generation, Transmission and Distribution Standard and keep your workers in electrical utilities operations safe.
Make sure your qualified electrical workers are well informed about safety procedures. This cutting-edge training demonstrates proper methods and precautions to avoid electrical shock, serious burns and arc flash accidents.
Electricity is something that we use everyday and sometimes ignore its hazards. This program will present information on how electricity works, what it can do to the human body and how to use electricity safely.
Focuses on what arc flash is, its hazards and how employees can avoid it on the job. The program provides practical procedures employees can use to protect themselves from electric shock.
Ensure your workers never experience the devastation of an arc flash explosion. This training program will help bring you and your workers up to speed on the 2009 version of NFPA 70E.
The electricity coming into a construction site can be dangerous and deadly. This program teaches construction workers how to work safely around electricity, and covers protective devices and safe work practices.
Designed to teach basic concepts about the nature of the beast, hazardous energy, this training covers information on various energy sources, what lockout/tagout is, and when you should lockout/tagout. You'll also learn to use the six steps that are required to control hazardous energy properly.
Make no mistake...all it takes is just one slipup when working with energy for it to become unstable to the point of damaging equipment and injuring or even killing your employees.
This training program will help you comply with OSHA's Lockout/Tagout Standard (1910.147). Designed to provide important information about safe work practices when locking and tagging, this interactive video program focuses on how employees can spot potential dangers before it's too late.
Give your employees a basic overview of digital multimeters and clampmeters, from key components to maintenance procedures.
MARCOM's HAZWOPER: Electrical Safety in HAZMAT Environments Program assists facilities in complying with the employee training requirements of OSHA's HAZWOPER regulation (29 CFR 1910.120), and helps employees understand the hazards of uncontrolled energy in hazardous materials environments, and how to reduce or eliminate these potential hazards.
The first in a two-part series on electrocution hazards, MARCOM's Electrocution Hazards In Construction Environments PART I - Types of Hazards and How You Can Protect Yourself discusses the major types of electrocution hazards, and how employees can reduce the risk from electrical hazards and electrocution in construction environments.
The second in a two-part series on electrocution hazards, MARCOM's Electrocution Hazards In Construction Environments PART II - Employer Requirements Program discusses the major types of electrocution hazards, and emphasizes employers' responsibilities in these areas.
This informative training course covers requirements for qualification, working with and around live circuits, National Electrical Code, and test equipment. Make sure your safety measures are ready for primetime when working around live circuits.
Electrical Safety: Beware The Bite!
This training shows workers how to protect themselves from this controllable hazard and what to do if danger strikes. It covers information on conductivity, levels of protection, lockout/tagout, personal protective equipment and emergency response.
Every year electrical accidents kill people performing maintenance in high-voltage, high power situations. This training will help employees understand how proper grounding techniques can save their lives.
When faced with an emergency such as electrical shock or an electrical fire, the initial response can save lives. This program covers crucial information such as the three levels of electric shock, common causes and classifications of fire and proper first aid measures for victims of shock or smoke inhalation.
Motor Drives 6-Part Series helps participants understand the fundamentals of motor drives.


Intermountain Healthcare is raising awareness for National Healthcare Decisions Day on April 16. This date is a reminder to encourage you and your family to make important decisions regarding medical care and how to communicate those decisions. Advance care planning means planning your wishes ahead of time should you become sick or injured.
April Krutka, DO, medical director of palliative care at McKay-Dee Hospital, explains that as people live longer and with chronic diseases it's important to plan ahead and communicate your wishes to loved ones and providers for medical care and treatment.
Think carefully about your core values, beliefs, and goals.
Talk with loved ones about your wishes regarding medical care.
Document your decisions using these documents.
The Advance Care Planning workbook has two forms that you need. An Advance Directive is a legal document that tells others what you want and includes either a living will or a medical power of attorney. The Utah Advance Directive Forms includes part 1 (My Agent) — this tells your healthcare providers who to talk to if you get sick, and part 2 (Living Will) — this identifies specific situation and what you want.
Even if you're healthy, Dr. Krutka recommends filling out advance care planning forms if you're over age 18. It's important to identify a trusted family member or loved one who can speak for you if you cannot speak for yourself.
Meet the McKay-Dee Hospital Palliative Care Team on Monday, April 16, to ask questions about the forms, learn about your rights, and pick up a booklet. They will be available from 11 a.m. to 1 p.m., at the waterfall lobby near the hospital visitor entrance.
Watch an interview with Dr. Krutka on Facebook.


A VIDEO_TS file is a DVD folder file, mainly containing all data for the DVD movies. It totally contains three kinds of files inside: VIDEO_TS.IFO, VIDEO_TS.BUP, and VIDEO_TS.VOB. In general, you cannot play Video_TS files on Mac directly. And it's quite annoying to search for the solutions in either the communities or forums just to be painfully returned with results that's not so useful. Get frustrated? Don't worry. This article will guide you on how to play the Video_TS files on your Mac smoothly.
There are two easy ways to play Video_TS folder on your Mac, one method is to download and install VLC Player to your Mac, the either one is to convert Video_TS to Mac compatible video formats. Check the out below.
You can easily playback your VIDEO_TS files on Mac if you have a VIDEO_TS player installed. VideoLAN (VLC Player) will be the best choices. This is one of the standard players for various people and there's not a bought about it, VLC really brings some of the best video playback as it provides seamless support for multiple file types and it's very easy to use as well. It's also very customizable and it doesn't require any codec packs in order to run properly.
I can still recalled of the questions asked by the user in a forum; "I've downloaded that's called a VIDEO_TS file. When I double click on it, it brings up lots of other VIDEO_TS files. I can't play them or convert them so that they are only one file. And I do really like the interface of my own player, so I don't want to download others. Anyone help?"
Similar to this user's query; if you also want to convert your VIDEO_TS file to a Mac compatible format for playback on QuickTime, you can try the Video Converter Ultimate for Mac (Windows version). With it, you can convert Video_TS to Mac compatible video formats (i.e. M4V, MOV or MP4) with fast speed and zero quality loss. After that, you can play your Video_TS folder on Mac using QuickTime as you like. Now let's see how to use it.
Step 1: After running it, just go to Convert's tab > Load DVD > Load DVD folder to import your VIDEO_TS files.
Step 2: Click "Profile" box and move mouse cursor to "Common Video" or "HD Video" category, choose MP4, MOV or M4V as the output format.
Step 3: Start converting VIDEO_TS files by hitting the Convert button in the lower-right corner of this app.
See, so easy, isn't it? Now you may have known how to play your Video_TS files on your Mac.
A VIDEO_TS file is a DVD folder file, mainly containing all data for the DVD movie. It totally contains three kinds of files inside: VIDEO_TS.IFO, VIDEO_TS.BUP, and VIDEO_TS.VOB.
VIDEO_TS.IFO - the configuration files with information like menus, subtitles, aspect ratio, languages etc.
Note: Usually, users can get lots VOB files when they convert a DVD file and want to convert to other formats for uses. See also how to convert VOB to MOV.


text:
Q: Why does the condition for a breakpoint failed to execute? I want to temporarily disable a breakpoint for a short time, so I set a conditional breakpoint with the following condition:
(global::System.DateTime.Now<new global::System.DateTime(2014,03,28,11,0,0))

When this breakpoint is hit a dialog pops up, saying
The condition for a breakpoint failed to execute. The condition was
'(global::System.DateTime.Now<new
global::System.DateTime(2014,03,28,11,0,0))'. The error returned was
'The runtime has refused to evaluate the expression at this time.'. Click
OK to stop at this breakpoint.

Why has the runtime refused to evaluate the expression?
What can I do to get the desired behavior without modifying the debugged source code?

A: From VS2012 on, you have to switch to the Managed Compatibility Mode, to use conditional breakpoints. Why (sorry, no more why from MS since that link is broken.. I added link to archive.org) and how is described here:
switching-to-managed-compatibility-mode-in-visual-studio-2013
old Microsoft link, now dead
the original Microsoft article on archive.org

A: It's not possible as far as I know.  What you can do instead is use of HitCount
or hardcode with a timer (as you like) in C# code
#if DEBUG
  if(System.Diagnostics.Debugger.IsAttached)
     System.Diagnostics.Debugger.Break();
#endif

redpajama_set_name: RedPajamaStackExchange


text:
January Effect Boosting Stock Prices: Here Are the Possible Winners
Rebecca Lipman, Kapitall, The Motley Fool, AOL.com
Nov 14th 2011 3:14PM
If you're looking for a cheery reason to ring in the New Year, the "January effect" could be the very thing to keep you on your toes.
The January effect is a phenomenon that makes prices of certain stocks rise more in January than the market averages. It presents a unique money making opportunity for astute investors, says Nigam Arora of Market Watch.
Two events theoretically cause the January effect: Firstly, at year's end, investors sell losing stocks to better their tax returns. The mass sell-off lowers prices of these loser stocks.
Secondly, come January, Wall Street professionals can expect to receive their long awaited bonuses. Bonus season puts a significant amount of money in the hands of individuals likely to invest in the market, and bargain hunters seek out depressed names, such as those sold off in December. The renewed demand theoretically brings the prices back up.
The casual investor can usually capitalize on this January effect by searching for and buying up depressed stocks in December and then selling, with proper timing, in January.
However this technique is not fool-proof. Arora himself claims to have lost money with this trick 15% of the time (success rate: 75%, broke even: 10%).
Arora also says the game is changing. "Thirty years ago, one could simply buy depressed stocks in the last week of December. Now that the phenomenon has become well known, the time to buy is in November."
So, how do you go about finding stocks that might benefit from the January effect?
To create this list, we started with a universe of about 180 stocks that have seen significant losses over the last year, in addition to accelerating losses over the last month.
In other words, price action suggests that many of these stocks are being sold to harvest tax losses.
To refine the list, we collected data on insider buying, and identified a list of names that have seen significant buying from insider executives over the last year.
Theoretically, insiders know more about their businesses than anyone else, so if they're using their own money to buy the shares of their employers, you better pay close attention.
Recent price action suggests these names are being sold to harvest tax losses, and insiders seem to think these stocks are ready to benefit from the January effect -- do you agree?
List sorted by monthly performance. (Click here to access free, interactive tools to analyze these ideas.)
List compiled by Eben Esterhuizen, CFA:
1. GeoEye (NAS: GEOY) : Provides earth imagery and imagery information products, as well as image processing services to the United States and foreign government defense and intelligence organizations, domestic federal and foreign civil agencies, and commercial customers. The stock has lost 25.28% over the last month, and lost 40.36% over the last year. Over the last six months, insiders were net buyers of 810,000 shares, which represents about 4.07% of the company's 19.92M share float.
2. Sequenom (NAS: SQNM) : Provides products, services, diagnostic testing, applications, and genetic analysis products that translate the results of genomic science into solutions for biomedical research, translational research, molecular medicine applications, and agricultural and livestock research. The stock has lost 19.52% over the last month, and lost 45.11% over the last year. Over the last six months, insiders were net buyers of 32,850 shares, which represents about 0.04% of the company's 89.83M share float.
3. MannKind (NAS: MNKD) : Focuses on the discovery, development, and commercialization of therapeutic products for diabetes and cancer. The stock has lost 17.04% over the last month, and lost 46.29% over the last year. Over the last six months, insiders were net buyers of 3,478,136 shares, which represents about 4.69% of the company's 74.22M share float.
4. Jefferies Group (NYS: JEF) : Operates as a securities and investment banking company in the Americas, Europe, and Asia. The stock has lost 15% over the last month, and lost 55.61% over the last year. Over the last six months, insiders were net buyers of 766,000 shares, which represents about 0.36% of the company's 213.56M share float.
5. Overseas Shipholding Group (NYS: OSG) : Engages in the ocean transportation of crude oil and petroleum products. The stock has lost 6.45% over the last month, and lost 58.05% over the last year. Over the last six months, insiders were net buyers of 73,682 shares, which represents about 0.31% of the company's 23.43M share float.
6. Vantage Drilling (NYS: VTG) : Provides offshore contract drilling services to large multinational oil and natural gas companies, government owned oil and natural gas companies, and independent oil and natural gas producers in the United States and internationally. The stock has lost 6.20% over the last month, and lost 30.86% over the last year. Over the last six months, insiders were net buyers of 5,350,210 shares, which represents about 3.22% of the company's 165.97M share float.
7. Pacific Capital Bancorp (NAS: PCBC) : Provides a range of commercial and consumer banking services to households, professionals, and businesses primarily in the central coast of California. The stock has lost 5.55% over the last month, and lost 53.11% over the last year. Over the last six months, insiders were net buyers of 3,495,414 shares, which represents about 85.67% of the company's 4.08M share float.
8. Fortress Investment Group (NYS: FIG) : Fortress Investment Group LLC is a public investment firm specializing in investments in debt and equity securities of public and privately held companies. The stock has lost 2.83% over the last month, and lost 32.75% over the last year. Over the last six months, insiders were net buyers of 60,000 shares, which represents about 0.03% of the company's 182.14M share float.
9. American International Group (NYS: AIG) : The company operates property and casualty insurance networks worldwide and conducts activities in the U.S. life insurance and retirement services industry. The stock has lost 2.57% over the last month, and lost 35.01% over the last year. Over the last six months, insiders were net buyers of 6,982,680 shares, which represents about 2.87% of the company's 243.61M share float.
10. Griffon (NYS: GFF) : Operates as a manufacturing company. The stock has lost 1.55% over the last month, and lost 34.08% over the last year. Over the last six months, insiders were net buyers of 14,000 shares, which represents about 0.02% of the company's 57.64M share float.
Interactive Chart: Press Play to compare changes in analyst ratings over the last two years for the stocks mentioned above. Analyst ratings sourced from Zacks Investment Research.
Kapitall's Eben Esterhuizen and Rebecca Lipman do not own any of the shares mentioned above. Insider data sourced from Yahoo! Finance.
At the time this article was published The Motley Fool owns shares of Pacific Capital Bancorp. Motley Fool newsletter services have recommended buying shares of GeoEye. Try any of our Foolish newsletter services free for 30 days. We Fools may not all hold the same opinions, but we all believe that considering a diverse range of insights makes us better investors. The Motley Fool has a disclosure policy.

redpajama_set_name: RedPajamaCommonCrawl


The excitement and emotions of graduation have wrapped around us at The First Academy. It is a time of reflection and nostalgia of taking the great leap into college. As our seniors at The Classical School, The First Hope, and The First Academy's 5 Day program take the walk toward their future on Friday night, I am reminded of what inspired me at that age. My dad often wrote quotes inside special books or cards during milestone moments of my life. Here is the quote he wrote to me as I began my journey to college, "The journey between what you once were and who you are now becoming is where the dance of life really takes place." To the graduating seniors: enjoy the dance, be strong Christian leaders as you enter these new journeys, and take advantage of opportunities to travel and experience this beautiful world. To all our Extended Educational Program families, please join me in praying for the Class of 2018. We are so proud of you all!
School gets out Friday, May 26th! Last call for Summer Camp!
TFA Preschool is so excited to partner with First Baptist in offering VBS for our preschool friends (Ages 3 & 4) this summer. During the week of June 26-June 30, 2017, we will be experiencing all the fun! Our theme this year is going to be a blast and will include art, music, worship, edible arts & more! If you are signed up for Summer Camp your 3 & 4 year old child will automatically participate in VBS during this week. If you have an older child in elementary that would like to attend as well, please click on the link below to register them today!!
To help us begin to prep for Vacation Bible School, we need the following materials. If you have any of these items lying around the house, we would love to take them off your hands.
Please drop them off to the preschool office. Thank you!!


Dual world champion Mitch Larkin will headline some of the country's best swimmers including fellow World Championship medallists Madi Wilson, Mack Horton and Jessica Ashwood at the Melbourne Sports and Aquatic Centre this weekend for their first hit-out of the new year at the 2016 Victorian Open Swimming Championships.
The championships, which will run from Friday January 22 to Sunday January 24, will allow the Dolphins to test their early season speed ahead of the hotly contested 2016 Perth Aquatic Super Series that will see the team take on China and Japan at HBF Stadium on February 5 and 6.
It will also be the first chance that former world champion James Magnussen will get to race following shoulder surgery last year.
Magnussen has entered the 50, 100 and 200m freestyle with his pet event, the 100m freestyle, scheduled for the Friday morning heats (approx. 10:45am AEDT).
Following on from a stellar year in the pool in 2015, Larkin will no doubt be looking to carry on his impressive form, consistently pushing the Australian and Commonwealth record times.
While his training partner Wilson will get the chance to practise her race skills before coming up against her friendly rival and dual world champion Emily Seebohm in Perth next month.
Then the race to Rio will be on with the hotly contested backstroke events at the Hancock Prospecting Australian Championships in Adelaide from April 7 to 14.
In Adelaide, Wilson and Seebohm will be joined by Victorians Belinda Hocking and Hayley Baker as well as Junior World Champion Minna Atherton as they race for a spot on the Australian team in the 100 or 200m backstroke events.
Also in action this weekend, World Championship bronze medallist Horton will have the home-town advantage when he takes on a packed schedule including the 100, 200, 400, 800 and 1500m freestyle events.
He will also get the chance to race Canadian distance ace, Ryan Cochrane who will swim in four of Horton's events; the 200, 400, 800 and 1500m freestyle.
And in the corresponding women's events, Australia's distance freestyle queen, Ashwood, will be looking to start her summer of swimming off on a similarly speedy note to the USA's Katie Ledecky who set a new world mark in the women's 800m freestyle earlier in the week.
Heats will start from 9:00am and Finals from 6:00pm AEDT with all information and results available athttp://vic.swimming.org.au/open-championships.html.


With "Shallow" cemented in the psyche of the cinema-going population, we've all thrown the big question out there – will Lady Gaga take home the 2019 Best Actress Oscar? Spare a thought, then, for Gaga's stylists, Sandra Amador and Tom Eerebout. As awards season creeps ever closer, the duo must start mapping out potential red carpet and acceptance speech-worthy ensembles, despite no nominations having been announced.
And therein lies the complexity of constructing a look for Gaga. As we have seen throughout her career, she will push the envelope as far as is physically possible – remember 2010's meat dress? – for her progressive art-meets-fashion, but her looks are rooted in concepts, be they abstract, political or in support of a designer she is close to. And that requires plenty of time for brainstorming, research and construction.
From the pink feathered Valentino in Venice to the statuesque metallic Givenchy gown in LA and the mass of ornate McQueen in London, everything on the promo trail was "100% a collaboration between all of the creative individuals," Amador shared.
Team Gaga were out in force this weekend for the Governors Awards. The event, which is now in its 10th year, might not have the same status as the SAG Awards, Golden Globes et al, but it can be considered a warm-up act for the coming months.
So, what can we read into her red-carpet look – a sweeping, off-the-shoulder black Valentino dress from the Spring 2019 collection? Pierpaolo Piccioli's voluminous designs have been a previous favorite of Frances McDormand, who used her time on the stage during the 2018 awards season to promote equal pay. A second outing in the label, which has resolutely become a fashion editors' favorite under Piccioli's solo reign, in recent months could signify a friendship budding between popstar and fashion house.
But, there's another designer in Gaga's life: Hedi Slimane. After sitting front row at his debut show for Celine in September, having carried his first bag for the brand a few weeks earlier, will Gaga continue her allegiance to his vision in the months ahead? We haven't seen her in Slimane's glitzy, short-hemmed eveningwear yet.
Of course, a black oversized Valentino dress, penchant for Celine's top handle bags and diverse press tour wardrobe are scant details to go on, leaving the sartorial path Gaga will tread towards the Dolby Theatre ambiguous. Rightly so – her career trajectory has been built on tapping into the unexpected. And the brands, which Amador said came calling after Gaga's cinema debut, have plenty of ideas from her style CV to consult for their bespoke commissions (meat perhaps excluded). Expect one mood to be present in each brand's design and Team Gaga's execution of a look, however, and that is "fearless".


text:
Penthouse 1019 at the Lantern House in Chelsea features interiors by Thomas Heatherwick, listed on the market for $12.97 million.
Take a Look at 10 Sustainable High-End Homes For Sale in New York
Across the Big Apple, these posh properties equally embrace design and the environment
Luxury living in New York is going the way of green. A small but increasing number of new buildings in the city are built with sustainability in mind and have an eye on design at the same time.
A decade ago, sustainable apartments were unheard of in New York, according to Steven James, the CEO of Douglas Elliman, New York City. "Today, the idea is not totally commonplace but definitely increasing, especially in very upscale high-rises where no expense was spared during the construction," he says.
Douglas Elliman lists several thousand residences a month in the city, says James, and around 5% include eco-friendly features, compared with virtually zero five years ago. "We're talking about properties that run well into the seven figures," he says.
If the idea of green living appeals, we've found six possibilities for sale around New York. From an apartment in Thomas Heatherwick's first North American residential venture to a new Upper West Side building where a green lifestyle is the highlight, the following list is proof that sustainability isn't about compromising on style.
Located in the heart of FiDi, Jolie 15D boasts eco-friendly interiors designed by AD100 architect Deborah Berke
Jolie, 15D
Jolie is a 42-story tower in the Financial District with interiors by AD 100–ranked Deborah Berke and a pleated glass wall façade that provides panoramic water views from each of the 90 apartments. The condominium, slated to open this summer, is around 30% more energy efficient than standard buildings in the city because of features like glass in lieu of artificial light and a variable-flow heating and cooling system that's twice as efficient as regular systems. Each residence also has air filters that provide a dedicated outdoor air supply. Amenities include a roof deck, children's playroom, gym and bike room. This 15th floor unit has 2 bedrooms, 2.5 bathrooms, light wood floors, marble baths and unobstructed Hudson River views. All of the appliances are energy efficient.
Bed/Baths: 2 bedrooms, 2.5 bathrooms
The Lantern House in Chelsea features interiors by Thomas Heatherwick marking his first residential project in the states
Lantern House, Penthouse 1019
Located in Chelsea, Lantern House is Thomas Heatherwick's first residential project in North America and will be ready for occupancy this summer. Human health and clean living are top priorities: Every unit features a high-efficiency water filtration system, air filters to minimize contaminants, an energy-efficient heating and cooling system, and insulated window frames that minimize the use of air conditioning and heat. Lantern House amenities include a pool, gym, garden and roof deck. This penthouse is notable for its oversized bay windows overlooking the city skyline, high ceilings, an airy great room with a fireplace, and a 900-square-foot rooftop terrace on the second floor with a kitchen and refrigerator. The en suite bedrooms are generously sized while the master suite is in its own wing and has two walk- in closets.
Price: $12.97 million
Square Footage: 2,810 plus a 900-square-foot terrace.
70 Little West 12th Street 23B in the Visonnaire building boasts lots of green features including a rooftop garden.
70 Little West 12th Street, 23B
In Battery Park City, the Visionaire is a LEED-certified glass tower that has a light footprint but doesn't skimp on design. The building was partly constructed with recyclable materials, and half were sourced from within a 500-mile radius. Additional green elements include a high-efficiency air filtration system, the use of natural gas, eco-friendly paints in the public spaces and apartments, and native landscaping in the rooftop gardens, which are not treated with pesticides and are irrigated using harvested rainwater. Amenities include a rooftop terrace, lounge, gym, and pool. With two bedrooms and baths, this apartment sees plenty of natural light thanks to the floor to ceiling windows, spanning 45 feet long. The views of the city and Hudson River are hard to beat, and the open kitchen cum living area is ideal for entertaining.
Price: $2.24 million
Bed/Baths: 2 bedrooms, 2 bathrooms
Square Footage: 1,311.
50 Clinton Street 3C on the Lower East Side comes with 10 foot high ceilings filled with natural light
50 Clinton Street, 3-C
Constructed in 2016, this Lower East Side condominium has several appealing amenities including a gym, a rooftop terrace with grills, and a bike room. Reminiscent of a stylish European flat, this third-floor residence with 10-foot-high ceilings is full of eco-friendly features such as solar shades that help minimize energy use, energy-efficient appliances, an emphasis on natural light, and LED lighting. The unit has large windows with views of lower New York and a kitchen counter with barstools. The master bathroom is a retreat with its chevron-patterned white marble, soaking tub. and floor-to-ceiling glass shower.
Charlotte of the Upper West Side contains 7 full floor units each crafted with sustainably sourced materials
Charlotte of the Upper West Side
One of the first new residential buildings to be constructed in the Central Park Historic District in the past 30 years, Charlotte of the Upper West Side has seven sustainably designed full-floor residences; listings will be live this spring. Each features its own energy recovery ventilation system that delivers fresh filtered outside air to each room of the home and is crafted with sustainably sourced materials; the wood frames, trims, flooring and millwork, for example, are certified by the Forest Stewardship Council (FSC) as meeting its worldwide standards of environmentally responsible forest management. The showpiece in all the units is the sprawling kitchen-living-dining room with floor-to-ceiling windows. All the bedrooms are airy while the master suites have 20-foot terraces overlooking the private garden. The building's amenities include a gym, a pet spa, and additional storage for each residence.
Price: Starting from $11 million
Bed/Baths: Starting from 4 bedrooms, 4.5 bathrooms
Square Footage: Starting from approximately 3,750 square feet, plus private outdoor space
The panoramic views at 2 River Terrace 18D
�2020 VHT Studios All rights reserved
2 River Terrace, 18D
Situated in Battery Park City, Riverhouse is a LEED-certified condominium with low carbon features such as twice-filtered air, filtered water, sustainable construction materials, and nontoxic paints. The apartments all have energy-efficient appliances, teak cabinets made with sustainably sourced wood, insulated windows, and an abundance of natural light, which helps cut down on energy use. Amenities include a gym, a pet spa, a library, a lounge, a yoga studio, and a pool. With a loftlike feel, this three-bedroom, 3.5-bath home is notable for its high ceilings and has a large entry hall plus an open design living room cum kitchen. The master bath is a standout with its frameless glass shower, soaking tub, and teakwood marble finishes.
Leonardo DiCaprio Expands His LA Home, New York City's Biggest Sale of 2022 Is Revealed, and More Real Estate News
By Dan Avery
Is TikTok the Secret to Finding an Apartment?
From renters to agents, the social platform has become a valuable resource
"The Manor" House Relists for $155 Million, the Iconic "Domestead" Goes Up For Sale, and More Real Estate News
The Evolution of New York City's Subway Stations in 8 Stunning Photos
The design details within transit stops offer a fascinating look at the transportation system's history


text:
#ifndef _GLUI_H_
#define _GLUI_H_

#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define GLUI_VERSION 2.01f    /********** Current version **********/

#ifdef WIN32
#pragma comment(lib, "glui32.lib")  // Link against GLUI library
#endif

class Arcball;

/********** Do some basic defines *******/
/*
#ifndef false
#define true 1
#define false 0
#endif
*/

#ifndef Byte
#define Byte unsigned char
#endif

#ifndef _RGBC_
class RGBc {
public:
  Byte r, g, b;

  void set(Byte r,Byte g,Byte b) {this->r=r;this->g=g;this->b=b;};

  RGBc( void ) {};
  RGBc( Byte r, Byte g, Byte b ) { set( r, g, b ); };
};
#define _RGBC_
#endif

/********** List of GLUT callbacks ********/

enum GLUI_Glut_CB_Types {
  GLUI_GLUT_RESHAPE,
  GLUI_GLUT_KEYBOARD,
  GLUI_GLUT_DISPLAY,
  GLUI_GLUT_MOUSE,
  GLUI_GLUT_MOTION,
  GLUI_GLUT_SPECIAL,
  GLUI_GLUT_PASSIVE_MOTION,
  GLUI_GLUT_ENTRY,
  GLUI_GLUT_VISIBILITY
};

/********** List of control types **********/
enum GLUI_Control_Types {
  GLUI_CONTROL_CHECKBOX =1,
  GLUI_CONTROL_BUTTON,
  GLUI_CONTROL_RADIOBUTTON,
  GLUI_CONTROL_RADIOGROUP,
  GLUI_CONTROL_SLIDER,
  GLUI_CONTROL_STATICTEXT,
  GLUI_CONTROL_EDITTEXT,
  GLUI_CONTROL_BITMAP,
  GLUI_CONTROL_PANEL,
  GLUI_CONTROL_SPINNER,
  GLUI_CONTROL_SEPARATOR,
  GLUI_CONTROL_COLUMN,
  GLUI_CONTROL_LISTBOX,
  GLUI_CONTROL_MOUSE_INTERACTION,
  GLUI_CONTROL_ROTATION,
  GLUI_CONTROL_TRANSLATION,
  GLUI_CONTROL_ROLLOUT
};

/********* Constants for window placement **********/
#define GLUI_XOFF                     6
#define GLUI_YOFF                     6
#define GLUI_ITEMSPACING              3
#define GLUI_CHECKBOX_SIZE           13
#define GLUI_RADIOBUTTON_SIZE        13
#define GLUI_BUTTON_SIZE             20
#define GLUI_STATICTEXT_SIZE         13
#define GLUI_SEPARATOR_HEIGHT         8
#define GLUI_DEFAULT_CONTROL_WIDTH  100
#define GLUI_DEFAULT_CONTROL_HEIGHT  13
#define GLUI_EDITTEXT_BOXINNERMARGINX   3
#define GLUI_EDITTEXT_HEIGHT            20
#define GLUI_EDITTEXT_WIDTH            130
#define GLUI_EDITTEXT_MIN_INT_WIDTH   35
#define GLUI_EDITTEXT_MIN_TEXT_WIDTH   50
#define GLUI_PANEL_NAME_DROP           8
#define GLUI_PANEL_EMBOSS_TOP          4
/* #define GLUI_ROTATION_WIDTH            60*/
/*  #define GLUI_ROTATION_HEIGHT           78 */
#define GLUI_ROTATION_WIDTH            50
#define GLUI_ROTATION_HEIGHT           (GLUI_ROTATION_WIDTH+18)
#define GLUI_MOUSE_INTERACTION_WIDTH   50
#define GLUI_MOUSE_INTERACTION_HEIGHT  (GLUI_MOUSE_INTERACTION_WIDTH)+18

/** Different panel control types **/
#define GLUI_PANEL_NONE      0
#define GLUI_PANEL_EMBOSSED  1
#define GLUI_PANEL_RAISED    2

/**  Max # of els in control's float_array  **/
#define GLUI_DEF_MAX_ARRAY  30

/********* The control's 'active' behavior *********/
#define GLUI_CONTROL_ACTIVE_MOUSEDOWN       1
#define GLUI_CONTROL_ACTIVE_PERMANENT       2

/********* Control alignment types **********/
#define GLUI_ALIGN_CENTER   1
#define GLUI_ALIGN_RIGHT    2
#define GLUI_ALIGN_LEFT     3

/********** Limit types - how to limit spinner values *********/
#define GLUI_LIMIT_NONE    0
#define GLUI_LIMIT_CLAMP   1
#define GLUI_LIMIT_WRAP    2

/********** Translation control types ********************/

#define GLUI_TRANSLATION_XY 0
#define GLUI_TRANSLATION_Z  1
#define GLUI_TRANSLATION_X  2
#define GLUI_TRANSLATION_Y  3

#define GLUI_TRANSLATION_LOCK_NONE 0
#define GLUI_TRANSLATION_LOCK_X    1
#define GLUI_TRANSLATION_LOCK_Y    2

/********** How was a control activated? *****************/
#define GLUI_ACTIVATE_MOUSE 1
#define GLUI_ACTIVATE_TAB   2

/********** What type of live variable does a control have? **********/
#define GLUI_LIVE_NONE          0
#define GLUI_LIVE_INT           1
#define GLUI_LIVE_FLOAT         2
#define GLUI_LIVE_TEXT          3
#define GLUI_LIVE_DOUBLE        4
#define GLUI_LIVE_FLOAT_ARRAY   5

/**********  Translation codes  **********/

enum TranslationCodes  {
  GLUI_TRANSLATION_MOUSE_NONE=0,
  GLUI_TRANSLATION_MOUSE_UP,
  GLUI_TRANSLATION_MOUSE_DOWN,
  GLUI_TRANSLATION_MOUSE_LEFT,
  GLUI_TRANSLATION_MOUSE_RIGHT,
  GLUI_TRANSLATION_MOUSE_UP_LEFT,
  GLUI_TRANSLATION_MOUSE_UP_RIGHT,
  GLUI_TRANSLATION_MOUSE_DOWN_LEFT,
  GLUI_TRANSLATION_MOUSE_DOWN_RIGHT
};

/************ A string type for us to use **********/
/*  typedef char  GLUI_String[300]; */
class GLUI_String
{
public:
  char string[300];

  char &operator[]( int i ) {
    return string[i];
  }

  operator char*() { return (char*) &string[0]; };
  /*    operator void*() { return (void*) &string[0]; }; */

  GLUI_String( void ) {
    string[0] = '\0';
  }

  GLUI_String( char *text ) {
    strcpy( string, text );
  }
};

/********* Pre-declare the various classes *********/
class GLUI;
class GLUI_Control;
class GLUI_Listbox;
class GLUI_Rotation;
class GLUI_Translation;
class GLUI_Mouse_Interaction;
class GLUI_Checkbox;
class GLUI_Slider;
class GLUI_Button;
class GLUI_StaticText;
class GLUI_Bitmap;
class GLUI_EditText;
class GLUI_Node;
class GLUI_Main;
class GLUI_Panel;
class GLUI_Spinner;
class GLUI_RadioButton;
class GLUI_RadioGroup;
class GLUI_Separator;
class GLUI_Column;
class GLUI_Master;
class GLUI_Glut_Window;
class GLUI_Rollout;

/*** Flags for GLUI class constructor ***/
#define  GLUI_SUBWINDOW          ((long)(1<< 1))
#define  GLUI_SUBWINDOW_TOP      ((long)(1<< 2))
#define  GLUI_SUBWINDOW_BOTTOM   ((long)(1<< 3))
#define  GLUI_SUBWINDOW_LEFT     ((long)(1<< 4))
#define  GLUI_SUBWINDOW_RIGHT    ((long)(1<< 5))

/*** Codes for different type of edittext boxes and spinners ***/
#define GLUI_EDITTEXT_TEXT             1
#define GLUI_EDITTEXT_INT              2
#define GLUI_EDITTEXT_FLOAT            3
#define GLUI_SPINNER_INT               GLUI_EDITTEXT_INT
#define GLUI_SPINNER_FLOAT             GLUI_EDITTEXT_FLOAT

/*** Definition of callbacks ***/
typedef void (*GLUI_Update_CB) (int id);
typedef void (*Int1_CB)        (int);
typedef void (*Int2_CB)        (int, int);
typedef void (*Int3_CB)        (int, int, int);
typedef void (*Int4_CB)        (int, int, int, int);

/************************************************************/
/*                                                          */
/*          Base class, for hierarchical relationships      */
/*                                                          */
/************************************************************/

class GLUI_Node {
protected:
  GLUI_Node *parent_node;
  GLUI_Node *child_head;
  GLUI_Node *child_tail;
  GLUI_Node *next_sibling;
  GLUI_Node *prev_sibling;

public:
  GLUI_Node *first_sibling( void );
  GLUI_Node *last_sibling( void );
  GLUI_Node *prev( void );
  GLUI_Node *next( void );
  GLUI_Node *first_child( void )   { return child_head; };
  GLUI_Node *last_child( void )    { return child_tail; };
  GLUI_Node *parent(void)          { return parent_node; };

  void      link_this_to_parent_last( GLUI_Node *parent );
  void      link_this_to_parent_first( GLUI_Node *parent );
  void      link_this_to_sibling_next( GLUI_Node *sibling );
  void      link_this_to_sibling_prev( GLUI_Node *sibling );
  void      unlink( void );

  void dump( FILE *out, char *name ) {
    fprintf( out, "GLUI_node: %s\n", name );
    fprintf( out, "   parent: %p     child_head: %p    child_tail: %p\n",
         parent_node, child_head, child_tail );
    fprintf( out, "   next: %p       prev: %p\n", next_sibling, prev_sibling );
  }

  GLUI_Node( void ) {
    parent_node= child_head = child_tail = next_sibling = prev_sibling = NULL;
  };

  friend class GLUI_Rollout;
  friend class GLUI_Main;
};

/************************************************************/
/*                                                          */
/*                  Standard Bitmap stuff                   */
/*                                                          */
/************************************************************/

enum GLUI_StdBitmaps_Codes {
  GLUI_STDBITMAP_CHECKBOX_OFF=0,
  GLUI_STDBITMAP_CHECKBOX_ON,
  GLUI_STDBITMAP_RADIOBUTTON_OFF,
  GLUI_STDBITMAP_RADIOBUTTON_ON,
  GLUI_STDBITMAP_UP_ARROW,
  GLUI_STDBITMAP_DOWN_ARROW,
  GLUI_STDBITMAP_LEFT_ARROW,
  GLUI_STDBITMAP_RIGHT_ARROW,
  GLUI_STDBITMAP_SPINNER_UP_OFF,
  GLUI_STDBITMAP_SPINNER_UP_ON,
  GLUI_STDBITMAP_SPINNER_DOWN_OFF,
  GLUI_STDBITMAP_SPINNER_DOWN_ON,

  GLUI_STDBITMAP_CHECKBOX_OFF_DIS,    /*** Disactivated control bitmaps ***/
  GLUI_STDBITMAP_CHECKBOX_ON_DIS,
  GLUI_STDBITMAP_RADIOBUTTON_OFF_DIS,
  GLUI_STDBITMAP_RADIOBUTTON_ON_DIS,
  GLUI_STDBITMAP_SPINNER_UP_DIS,
  GLUI_STDBITMAP_SPINNER_DOWN_DIS,
  GLUI_STDBITMAP_LISTBOX_UP,
  GLUI_STDBITMAP_LISTBOX_DOWN,
  GLUI_STDBITMAP_LISTBOX_UP_DIS,
  /***
    GLUI_STDBITMAP_SLIDER_TAB,
    ***/
  GLUI_STDBITMAP_NUM_ITEMS
};

/************ Image Bitmap arrays **********/
extern int glui_img_checkbox_0[];
extern int glui_img_checkbox_1[];
extern int glui_img_radiobutton_0[];
extern int glui_img_radiobutton_1[];
extern int glui_img_uparrow[];
extern int glui_img_downarrow[];
extern int glui_img_leftarrow[];
extern int glui_img_rightarrow[];
extern int glui_img_spinup_0[];
extern int glui_img_spinup_1[];
extern int glui_img_spindown_0[];
extern int glui_img_spindown_1[];
extern int glui_img_checkbox_0_dis[];
extern int glui_img_checkbox_1_dis[];
extern int glui_img_radiobutton_0_dis[];
extern int glui_img_radiobutton_1_dis[];
extern int glui_img_spinup_dis[];
extern int glui_img_spindown_dis[];
extern int glui_img_listbox_up[];
extern int glui_img_listbox_down[];
extern int glui_img_listbox_up_dis[];

extern int *bitmap_arrays[];

/************************************************************/
/*                                                          */
/*                  Class GLUI_Bitmap                       */
/*                                                          */
/************************************************************/
class GLUI_Bitmap
{
public:
  unsigned char *pixels;
  int            w, h;

  void load_from_array( int *array );

  GLUI_Bitmap( void ) {
    pixels = NULL;
    w      = 0;
    h      = 0;
  }
};

/************************************************************/
/*                                                          */
/*                  Class GLUI_StdBitmap                    */
/*                                                          */
/************************************************************/
class GLUI_StdBitmaps
{
public:
  GLUI_Bitmap bitmaps[ GLUI_STDBITMAP_NUM_ITEMS ];

  void draw( int bitmap_num, int x, int y );

  GLUI_StdBitmaps( void ) {
    int i;

    for( i=0; i<GLUI_STDBITMAP_NUM_ITEMS; i++ ) {
      bitmaps[i].load_from_array( bitmap_arrays[i] );
    }
  }
};

/************************************************************/
/*                                                          */
/*                     Master GLUI Class                    */
/*                                                          */
/************************************************************/
class GLUI_Master_Object {
private:
  GLUI_Node     glut_windows;
  void (*glut_idle_CB)(void);

  void                add_cb_to_glut_window(int window,int cb_type,void *cb);

public:
  GLUI_Node     gluis;
  GLUI_Control *active_control, *curr_left_button_glut_menu;
  GLUI         *active_control_glui;
  int           glui_id_counter;

  GLUI_Glut_Window   *find_glut_window( int window_id );

  void           set_glutIdleFunc(void (*f)(void));

  /**************
    void (*glut_keyboard_CB)(unsigned char, int, int);
    void (*glut_reshape_CB)(int, int);
    void (*glut_special_CB)(int, int, int);
    void (*glut_mouse_CB)(int,int,int,int);

    void (*glut_passive_motion_CB)(int,int);
    void (*glut_visibility_CB)(int);
    void (*glut_motion_CB)(int,int);
    void (*glut_display_CB)(void);
    void (*glut_entry_CB)(int);
    **********/

  void  set_left_button_glut_menu_control( GLUI_Control *control );

  /********** GLUT callthroughs **********/
  /* These are the glut callbacks that we do not handle */

  void set_glutReshapeFunc(void (*f)(int width, int height));
  void set_glutKeyboardFunc(void (*f)(unsigned char key, int x, int y));
  void set_glutSpecialFunc(void (*f)(int key, int x, int y));
  void set_glutMouseFunc(void (*f)(int, int, int, int ));

  void set_glutDisplayFunc(void (*f)(void)) {glutDisplayFunc(f);};
  void set_glutTimerFunc(unsigned int millis, void (*f)(int value), int value)
    { ::glutTimerFunc(millis,f,value);};
  void set_glutOverlayDisplayFunc(void(*f)(void)){glutOverlayDisplayFunc(f);};
  void set_glutSpaceballMotionFunc(Int3_CB f)  {glutSpaceballMotionFunc(f);};
  void set_glutSpaceballRotateFunc(Int3_CB f)  {glutSpaceballRotateFunc(f);};
  void set_glutSpaceballButtonFunc(Int2_CB f)  {glutSpaceballButtonFunc(f);};
  void set_glutTabletMotionFunc(Int2_CB f)        {glutTabletMotionFunc(f);};
  void set_glutTabletButtonFunc(Int4_CB f)        {glutTabletButtonFunc(f);};
  /*    void set_glutWindowStatusFunc(Int1_CB f)        {glutWindowStatusFunc(f);}; */
  void set_glutMenuStatusFunc(Int3_CB f)            {glutMenuStatusFunc(f);};
  void set_glutMenuStateFunc(Int1_CB f)              {glutMenuStateFunc(f);};
  void set_glutButtonBoxFunc(Int2_CB f)              {glutButtonBoxFunc(f);};
  void set_glutDialsFunc(Int2_CB f)                      {glutDialsFunc(f);};

  GLUI          *create_glui( char *name, long flags=0, int x=-1, int y=-1 );
  GLUI          *create_glui_subwindow( int parent_window, long flags=0 );
  GLUI          *find_glui_by_window_id( int window_id );
  void           get_viewport_area( int *x, int *y, int *w, int *h );
  void           auto_set_viewport( void );
  void           close_all( void );
  void           sync_live_all( void );

  void           reshape( void );

  float          get_version( void ) { return GLUI_VERSION; };

  friend void    glui_idle_func(void);

  GLUI_Master_Object( void ) {
    glut_idle_CB    = NULL;
    glui_id_counter = 1;
  }
};

extern GLUI_Master_Object GLUI_Master;

/************************************************************/
/*                                                          */
/*              Class for managing a GLUT window            */
/*                                                          */
/************************************************************/

class GLUI_Glut_Window : public GLUI_Node {
public:
  int    glut_window_id;

  /*********** Pointers to GLUT callthrough functions *****/
  void (*glut_keyboard_CB)(unsigned char, int, int);
  void (*glut_special_CB)(int, int, int);
  void (*glut_reshape_CB)(int, int);
  void (*glut_passive_motion_CB)(int,int);
  void (*glut_mouse_CB)(int,int,int,int);
  void (*glut_visibility_CB)(int);
  void (*glut_motion_CB)(int,int);
  void (*glut_display_CB)(void);
  void (*glut_entry_CB)(int);

  GLUI_Glut_Window( void ) {
    glut_display_CB         = NULL;
    glut_reshape_CB         = NULL;
    glut_keyboard_CB        = NULL;
    glut_special_CB         = NULL;
    glut_mouse_CB           = NULL;
    glut_motion_CB          = NULL;
    glut_passive_motion_CB  = NULL;
    glut_entry_CB           = NULL;
    glut_visibility_CB      = NULL;
    glut_window_id          = 0;
  };
};

/************************************************************/
/*                                                          */
/*              Main GLUI class (not user-level)            */
/*                                                          */
/************************************************************/

class GLUI_Main : public GLUI_Node {
protected:
  /*** Variables ***/
  int           main_gfx_window_id;
  int           mouse_button_down;
  int           glut_window_id;
  int           top_level_glut_window_id;
  GLUI_Control *active_control;
  GLUI_Control *mouse_over_control;
  GLUI_Panel   *main_panel;
  int           curr_cursor;
  int           w, h;
  long          flags;
  int           closing;
  int           parent_window;
  int           glui_id;

  /********** Friend classes *************/

  friend class GLUI_Control;
  friend class GLUI_Rotation;
  friend class GLUI_Translation;
  friend class GLUI;
  friend class GLUI_Master_Object;

  /********** Misc functions *************/

  GLUI_Control  *find_control( int x, int y );
  GLUI_Control  *find_next_control( GLUI_Control *control );
  GLUI_Control  *find_next_control_rec( GLUI_Control *control );
  GLUI_Control  *find_next_control_( GLUI_Control *control );
  GLUI_Control  *find_prev_control( GLUI_Control *control );
  void           create_standalone_window( char *name, int x=-1, int y=-1 );
  void           create_subwindow( int parent,int window_alignment );
  void           setup_default_glut_callbacks( void );

  void           mouse(int button, int state, int x, int y);
  void           keyboard(unsigned char key, int x, int y);
  void           special(int key, int x, int y);
  void           passive_motion(int x, int y);
  void           reshape( int w, int h );
  void           visibility(int state);
  void           motion(int x, int y);
  void           entry(int state);
  void           display( void );
  void           idle(void);

  void (*glut_mouse_CB)(int, int, int, int);
  void (*glut_keyboard_CB)(unsigned char, int, int);
  void (*glut_special_CB)(int, int, int);
  void (*glut_reshape_CB)(int, int);

  /*********** Friend functions and classes **********/

  friend void    glui_mouse_func(int button, int state, int x, int y);
  friend void    glui_keyboard_func(unsigned char key, int x, int y);
  friend void    glui_special_func(int key, int x, int y);
  friend void    glui_passive_motion_func(int x, int y);
  friend void    glui_reshape_func( int w, int h );
  friend void    glui_visibility_func(int state);
  friend void    glui_motion_func(int x, int y);
  friend void    glui_entry_func(int state);
  friend void    glui_display_func( void );
  friend void    glui_idle_func(void);

  friend void    glui_parent_window_reshape_func( int w, int h );
  friend void    glui_parent_window_keyboard_func( unsigned char, int, int );
  friend void    glui_parent_window_special_func( int, int, int );
  friend void    glui_parent_window_mouse_func( int, int, int, int );

  /*********** Controls ************/
  GLUI_Control *controls;
  int           num_controls;

  int           add_control( GLUI_Node *parent, GLUI_Control *control );

  /********** Constructors and Destructors ***********/

  GLUI_Main( void );

public:
  GLUI_StdBitmaps  std_bitmaps;
  GLUI_String      window_name;
  RGBc             bkgd_color;
  float            bkgd_color_f[3];

  void            *font;
  int              curr_modifiers;

  void         adjust_glut_xy( int &x, int &y ) { y = h-y; };
  void         activate_control( GLUI_Control *control, int how );
  void         align_controls( GLUI_Control *control );
  void         restore_draw_buffer( int buffer_state );
  void         disactivate_current_control( void );
  void         draw_raised_box( int x, int y, int w, int h );
  void         draw_lowered_box( int x, int y, int w, int h );
  int          set_front_draw_buffer( void );
  void         post_update_main_gfx( void );
  void         pack_controls( void );
  void         close_internal( void );
  void         check_subwindow_position( void );
  void         set_ortho_projection( void );
  void         set_viewport( void );
  void         refresh( void );
};

/************************************************************/
/*                                                          */
/*       GLUI_Control: base class for all controls          */
/*                                                          */
/************************************************************/

class GLUI_Control : public GLUI_Node {
public:

  int             w, h;                        /* dimensions of control */
  int             x_abs, y_abs;
  int             x_off, y_off_top, y_off_bot; /* INNER margins, by which
                          child controls are indented */
  int             contain_x, contain_y;
  int             contain_w, contain_h;
  /* if this is a container control (e.g.,
     radiogroup or panel) this indicated dimensions
     of inner area in which controls reside */
  int             active, active_type, can_activate;
  int             spacebar_mouse_click;
  long            user_id, type;
  int             is_container;  /* Is this a container class (e.g., panel) */
  int             alignment;
  GLUI_Update_CB  callback;
  void            *ptr_val;                              /* A pointer value */
  float           float_val;                               /* A float value */
  int             enabled;                   /* Is this control grayed out? */
  int             int_val;                              /* An integer value */
  float           float_array_val[GLUI_DEF_MAX_ARRAY];
  int             state;
  GLUI_String     name;                         /* The name of this control */
  GLUI_String     text;
  GLUI           *glui;
  void           *font;
  int             live_type, live_inited;
  int             last_live_int;   /* last value that live var known to have */
  float           last_live_float;
  GLUI_String     last_live_text;
  float           last_live_float_array[GLUI_DEF_MAX_ARRAY];
  int             float_array_size;

  int             collapsible, is_open;
  GLUI_Node       collapsed_node;
  int             hidden; /* Collapsed controls (and children) are hidden */

  /*** Get/Set values ***/

  virtual void   set_name( char *string );
  virtual void   set_int_val( int new_int )         { int_val = new_int; output_live(true); };
  virtual void   set_float_val( float new_float )   { float_val = new_float; output_live(true); };
  virtual void   set_ptr_val( void *new_ptr )       { ptr_val = new_ptr; output_live(true); };
  virtual void   set_float_array_val( float *array_ptr );

  virtual float  get_float_val( void )              { return float_val; };
  virtual int    get_int_val( void )                { return int_val; };
  virtual void   get_float_array_val( float *array_ptr );

  virtual int mouse_down_handler( int local_x, int local_y )
    { return false; };
  virtual int mouse_up_handler( int local_x, int local_y, int inside )
    { return false; };
  virtual int mouse_held_down_handler( int local_x, int local_y, int inside)
    { return false; };
  virtual int key_handler( unsigned char key, int modifiers )
    { return false; };
  virtual int special_handler( int key,int modifiers )
    { return false; };

  virtual void update_size( void )     { };
  virtual void idle( void )            { };
  virtual int  mouse_over( int state, int x, int y ) { return false; };

  virtual void enable( void );
  virtual void disable( void );
  virtual void activate( int how )     { active = true; };
  virtual void disactivate( void )     { active = false; };

  void         hide_internal( int recurse );
  void         unhide_internal( int recurse );

  int          can_draw( void ) { return (glui != NULL && hidden == false); };

  virtual void align( void );
  void         pack( int x, int y );    /* Recalculate positions and offsets */
  void         pack_old( int x, int y );
  void         draw_recursive( int x, int y );
  int          set_to_glut_window( void );
  void         restore_window( int orig );
  void         translate_and_draw_front( void );
  void         translate_to_origin( void )
    {glTranslatef((float)x_abs+.5,(float)y_abs+.5,0.0);};
  virtual void draw( int x, int y )=0;
  void         set_font( void *new_font );
  void        *get_font( void );
  int          string_width( char *text );
  int          char_width( char c );

  void         draw_name( int x, int y );
  void         draw_box_inwards_outline( int x_min, int x_max,
                     int y_min, int y_max );
  void         draw_box( int x_min, int x_max, int y_min, int y_max,
             float r, float g, float b );
  void         draw_bkgd_box( int x_min, int x_max, int y_min, int y_max );
  void         draw_emboss_box( int x_min, int x_max,int y_min,int y_max);
  void         draw_string( char *text );
  void         draw_char( char c );
  void         draw_active_box( int x_min, int x_max, int y_min, int y_max );
  void         set_to_bkgd_color( void );

  void         set_w( int new_w );
  void         set_h( int new_w );
  void         set_alignment( int new_align );
  void         sync_live( int recurse, int draw );  /* Reads live variable */
  void         init_live( void );
  void         output_live( int update_main_gfx );        /** Writes live variable **/
  virtual void set_text( char *t )   {};
  void         execute_callback( void );
  void         get_this_column_dims( int *col_x, int *col_y,
                     int *col_w, int *col_h,
                     int *col_x_off, int *col_y_off );
  virtual int  needs_idle( void );

  GLUI_Control(void) {
    x_off          = GLUI_XOFF;
    y_off_top      = GLUI_YOFF;
    y_off_bot      = GLUI_YOFF;
    x_abs          = GLUI_XOFF;
    y_abs          = GLUI_YOFF;
    state          = 0;
    active         = false;
    enabled        = true;
    int_val        = 0;
    last_live_int  = 0;
    float_array_size = 0;
    sprintf( (char*)name, "Control: %p", this );
    float_val      = 0.0;
    last_live_float = 0.0;
    ptr_val        = NULL;
    glui           = NULL;
    w              = GLUI_DEFAULT_CONTROL_WIDTH;
    h              = GLUI_DEFAULT_CONTROL_HEIGHT;
    font           = NULL;
    active_type    = GLUI_CONTROL_ACTIVE_MOUSEDOWN;
    alignment      = GLUI_ALIGN_LEFT;
    is_container   = false;
    can_activate   = true;         /* By default, you can activate a control */
    spacebar_mouse_click = true;    /* Does spacebar simulate a mouse click? */
    live_type      = GLUI_LIVE_NONE;
    strcpy( (char*)text, "" );
    strcpy( (char*)last_live_text, "" );
    live_inited    = false;
    collapsible    = false;
    is_open        = true;
    hidden         = false;

    int i;
    for( i=0; i<GLUI_DEF_MAX_ARRAY; i++ )
      float_array_val[i] = last_live_float_array[i] = 0.0;
  };

  virtual ~GLUI_Control();
};

/************************************************************/
/*                                                          */
/*               Button class (container)                   */
/*                                                          */
/************************************************************/

class GLUI_Button : public GLUI_Control
{
public:
  int currently_inside;

  int  mouse_down_handler( int local_x, int local_y );
  int  mouse_up_handler( int local_x, int local_y, int same );
  int  mouse_held_down_handler( int local_x, int local_y, int inside );
  int  key_handler( unsigned char key,int modifiers );

  void draw( int x, int y );
  void draw_pressed( void );
  void draw_unpressed( void );
  void draw_text( int sunken );

  void update_size( void );

  GLUI_Button( void ) {
    sprintf( name, "Button: %p", this );
    type         = GLUI_CONTROL_BUTTON;
    h            = GLUI_BUTTON_SIZE;
    w            = 100;
    alignment    = GLUI_ALIGN_CENTER;
    can_activate = true;
  };

  virtual ~GLUI_Button() {};
};

/************************************************************/
/*                                                          */
/*               Checkbox class (container)                 */
/*                                                          */
/************************************************************/

class GLUI_Checkbox : public GLUI_Control
{
public:
  int  orig_value, currently_inside;
  int  text_x_offset;

  int  mouse_down_handler( int local_x, int local_y );
  int  mouse_up_handler( int local_x, int local_y, int inside );
  int  mouse_held_down_handler( int local_x, int local_y, int inside );
  int  key_handler( unsigned char key,int modifiers );

  void update_size( void );

  void draw( int x, int y );

  void draw_active_area( void );
  void draw_checked( void );
  void draw_unchecked( void );
  void draw_X( void );
  void draw_empty_box( void );
  void set_int_val( int new_val );

  GLUI_Checkbox( void ) {
    sprintf( name, "Checkbox: %p", this );
    type           = GLUI_CONTROL_CHECKBOX;
    w              = 100;
    h              = GLUI_CHECKBOX_SIZE;
    orig_value     = -1;
    text_x_offset  = 18;
    can_activate   = true;
    live_type      = GLUI_LIVE_INT;   /* This control has an 'int' live var */
  };

  virtual ~GLUI_Checkbox() {};
};

/************************************************************/
/*                                                          */
/*               Column class                               */
/*                                                          */
/************************************************************/

class GLUI_Column : public GLUI_Control
{
public:
  void draw( int x, int y );

  GLUI_Column( void ) {
    type         = GLUI_CONTROL_COLUMN;
    w            = 0;
    h            = 0;
    int_val      = 0;
    can_activate = false;
  };

  virtual ~GLUI_Column() {};
};

/************************************************************/
/*                                                          */
/*               Panel class (container)                    */
/*                                                          */
/************************************************************/

class GLUI_Panel : public GLUI_Control
{
public:
  void draw( int x, int y );
  void set_name( char *text );
  void set_type( int new_type );

  void update_size( void );

  GLUI_Panel( void ) {
    type         = GLUI_CONTROL_PANEL;
    w            = 300;
    h            = GLUI_DEFAULT_CONTROL_HEIGHT + 7;
    int_val      = GLUI_PANEL_EMBOSSED;
    alignment    = GLUI_ALIGN_CENTER;
    is_container = true;
    can_activate = false;
    strcpy( name, "" );
  };

  virtual ~GLUI_Panel() {};
};

/************************************************************/
/*                                                          */
/*               Panel class (container)                    */
/*                                                          */
/************************************************************/

class GLUI_Rollout : public GLUI_Panel
{
  /*  private: */
  /*    GLUI_Panel panel; */
public:
  int          currently_inside, initially_inside;
  GLUI_Button  button;

  void draw( int x, int y );
  void draw_pressed( void );
  void draw_unpressed( void );
  int mouse_down_handler( int local_x, int local_y );
  int mouse_up_handler( int local_x, int local_y, int inside );
  int  mouse_held_down_handler( int local_x, int local_y, int inside );

  void  open( void );
  void  close( void );

    /*   void set_name( char *text )   { panel.set_name( text ); }; */
  void update_size( void );

  GLUI_Rollout( void ) {
    currently_inside = false;
    initially_inside = false;
    can_activate     = true;
    is_container     = true;
    type             = GLUI_CONTROL_ROLLOUT;
    h                = GLUI_DEFAULT_CONTROL_HEIGHT + 7;
    w                = GLUI_DEFAULT_CONTROL_WIDTH;
    y_off_top        = 21;
    collapsible      = true;
    strcpy( name, "" );
  };

  virtual ~GLUI_Rollout() {};
};

/************************************************************/
/*                                                          */
/*                     User-Level GLUI class                */
/*                                                          */
/************************************************************/

class GLUI : public GLUI_Main {
private:
public:
  void  add_column( int draw_bar = true );
  void  add_column_to_panel( GLUI_Panel *panel, int draw_bar = true );

  void  add_separator( void );
  void  add_separator_to_panel( GLUI_Panel *panel );

  GLUI_RadioGroup
    *add_radiogroup( int *live_var=NULL,
             int user_id=-1,GLUI_Update_CB callback=NULL);

  GLUI_RadioGroup
    *add_radiogroup_to_panel(  GLUI_Panel *panel,
                   int *live_var=NULL,
                   int user_id=-1, GLUI_Update_CB callback=NULL );
  GLUI_RadioButton
    *add_radiobutton_to_group(  GLUI_RadioGroup *group,
                char *name );

  GLUI_Listbox *add_listbox( char *name, int *live_var=NULL,
                 int id=-1, GLUI_Update_CB callback=NULL    );
  GLUI_Listbox *add_listbox_to_panel( GLUI_Panel *panel,
                      char *name, int *live_var=NULL,
                      int id=-1, GLUI_Update_CB callback=NULL);

  GLUI_Rotation *add_rotation( char *name, float *live_var=NULL,
                   int id=-1, GLUI_Update_CB callback=NULL  );
  GLUI_Rotation *add_rotation_to_panel( GLUI_Panel *panel,
                    char *name, float *live_var=NULL,
                    int id=-1, GLUI_Update_CB callback=NULL);

  GLUI_Translation *add_translation( char *name,
                     int trans_type, float *live_var=NULL,
                     int id=-1, GLUI_Update_CB callback=NULL    );
  GLUI_Translation *add_translation_to_panel(
                         GLUI_Panel *panel, char *name,
                         int trans_type, float *live_var=NULL,
                         int id=-1, GLUI_Update_CB callback=NULL);

  GLUI_Checkbox  *add_checkbox( char *name,
                int *live_var=NULL,
                int id=-1, GLUI_Update_CB callback=NULL);
  GLUI_Checkbox  *add_checkbox_to_panel( GLUI_Panel *panel, char *name,
                     int *live_var=NULL, int id=-1,
                     GLUI_Update_CB callback=NULL);

  GLUI_Button  *add_button( char *name, int id=-1,
                GLUI_Update_CB callback=NULL);
  GLUI_Button  *add_button_to_panel( GLUI_Panel *panel, char *name,
                     int id=-1, GLUI_Update_CB callback=NULL );

  GLUI_StaticText  *add_statictext( char *name );
  GLUI_StaticText  *add_statictext_to_panel( GLUI_Panel *panel, char *name );

  GLUI_EditText  *add_edittext( char *name,
                int data_type=GLUI_EDITTEXT_TEXT,
                void *live_var=NULL,
                int id=-1, GLUI_Update_CB callback=NULL );
  GLUI_EditText  *add_edittext_to_panel( GLUI_Panel *panel,
                     char *name,
                     int data_type=GLUI_EDITTEXT_TEXT,
                     void *live_var=NULL, int id=-1,
                     GLUI_Update_CB callback=NULL );

  GLUI_Spinner  *add_spinner( char *name,
                  int data_type=GLUI_SPINNER_INT,
                  void *live_var=NULL,
                  int id=-1, GLUI_Update_CB callback=NULL );
  GLUI_Spinner  *add_spinner_to_panel( GLUI_Panel *panel,
                       char *name,
                       int data_type=GLUI_SPINNER_INT,
                       void *live_var=NULL,
                       int id=-1,
                       GLUI_Update_CB callback=NULL );

  GLUI_Panel     *add_panel( char *name, int type=GLUI_PANEL_EMBOSSED );
  GLUI_Panel     *add_panel_to_panel( GLUI_Panel *panel, char *name,
                      int type=GLUI_PANEL_EMBOSSED );

  GLUI_Rollout   *add_rollout( char *name, int open=true );
  GLUI_Rollout   *add_rollout_to_panel( GLUI_Panel *panel, char *name, int open=true );

  void            set_main_gfx_window( int window_id );
  int             get_glut_window_id( void ) { return glut_window_id; };

  void            enable( void ) { main_panel->enable(); };
  void            disable( void );

  void            sync_live( void );

  void            close( void );

  void            show( void );
  void            hide( void );

  /***** GLUT callback setup functions *****/
  /*
    void set_glutDisplayFunc(void (*f)(void));
    void set_glutReshapeFunc(void (*f)(int width, int height));
    void set_glutKeyboardFunc(void (*f)(unsigned char key, int x, int y));
    void set_glutSpecialFunc(void (*f)(int key, int x, int y));
    void set_glutMouseFunc(void (*f)(int button, int state, int x, int y));
    void set_glutMotionFunc(void (*f)(int x, int y));
    void set_glutPassiveMotionFunc(void (*f)(int x, int y));
    void set_glutEntryFunc(void (*f)(int state));
    void set_glutVisibilityFunc(void (*f)(int state));
    void set_glutInit( int *argcp, char **argv );
    void set_glutInitWindowSize(int width, int height);
    void set_glutInitWindowPosition(int x, int y);
    void set_glutInitDisplayMode(unsigned int mode);
    int  set_glutCreateWindow(char *name);
    */

  /***** Constructors and desctructors *****/

  int init( char *name, long flags, int x, int y, int parent_window );
};

/************************************************************/
/*                                                          */
/*               EditText class                             */
/*                                                          */
/************************************************************/

class GLUI_EditText : public GLUI_Control
{
public:
  int                 has_limits;
  int                 data_type;
  GLUI_String         orig_text;
  int                 insertion_pt;
  int                 title_x_offset;
  int                 text_x_offset;
  int                 substring_start; /*substring that gets displayed in box*/
  int                 substring_end;
  int                 sel_start, sel_end;  /* current selection */
  int                 num_periods;
  int                 last_insertion_pt;
  float               float_low, float_high;
  int                 int_low, int_high;
  GLUI_Spinner       *spinner;
  int                 debug;
  int                 draw_text_only;

  int  mouse_down_handler( int local_x, int local_y );
  int  mouse_up_handler( int local_x, int local_y, int same );
  int  mouse_held_down_handler( int local_x, int local_y, int inside );
  int  key_handler( unsigned char key,int modifiers );
  int  special_handler( int key,int modifiers );

  void activate( int how );
  void disactivate( void );

  void draw( int x, int y );

  int  mouse_over( int state, int x, int y );

  int  find_word_break( int start, int direction );
  int  substring_width( int start, int end );
  void clear_substring( int start, int end );
  int  find_insertion_pt( int x, int y );
  int  update_substring_bounds( void );
  void update_and_draw_text( void );
  void draw_text( int x, int y );
  void draw_insertion_pt( void );
  void set_numeric_text( void );
  void update_x_offsets( void );
  void update_size( void );

  void set_float_limits( float low,float high,int limit_type=GLUI_LIMIT_CLAMP);
  void set_int_limits( int low, int high, int limit_type=GLUI_LIMIT_CLAMP );
  void set_float_val( float new_val );
  void set_int_val( int new_val );
  void set_text( char *text );
  char *get_text( void )         { return text; };

  void dump( FILE *out, char *text );

  GLUI_EditText( void ) {
    type                  = GLUI_CONTROL_EDITTEXT;
    h                     = GLUI_EDITTEXT_HEIGHT;
    w                     = GLUI_EDITTEXT_WIDTH;
    title_x_offset        = 0;
    text_x_offset         = 55;
    insertion_pt          = -1;
    last_insertion_pt     = -1;
    name[0]               = '\0';
    substring_start       = 0;
    data_type             = GLUI_EDITTEXT_TEXT;
    substring_end         = 2;
    num_periods           = 0;
    has_limits            = GLUI_LIMIT_NONE;
    sel_start             = 0;
    sel_end               = 0;
    active_type           = GLUI_CONTROL_ACTIVE_PERMANENT;
    can_activate          = true;
    spacebar_mouse_click  = false;
    spinner               = NULL;
    debug                 = false;
    draw_text_only        = false;
  };
};

/************************************************************/
/*                                                          */
/*              RadioGroup class (container)                */
/*                                                          */
/************************************************************/

class GLUI_RadioGroup : public GLUI_Control
{
public:
  int  num_buttons;

  void draw( int x, int y );
  void set_name( char *text );
  void set_int_val( int int_val );
  void set_selected( int int_val );

  void draw_group( int translate );

  GLUI_RadioGroup( void ) {
    type          = GLUI_CONTROL_RADIOGROUP;
    x_off         = 0;
    y_off_top     = 0;
    y_off_bot     = 0;
    is_container  = true;
    w             = 300;
    h             = 300;
    num_buttons   = 0;
    name[0]       = '\0';
    can_activate  = false;
    live_type     = GLUI_LIVE_INT;
  };
};

/************************************************************/
/*                                                          */
/*               RadioButton class (container)              */
/*                                                          */
/************************************************************/

class GLUI_RadioButton : public GLUI_Control
{
public:
  int orig_value, currently_inside;
  int text_x_offset;

  int  mouse_down_handler( int local_x, int local_y );
  int  mouse_up_handler( int local_x, int local_y, int inside );
  int  mouse_held_down_handler( int local_x, int local_y, int inside );

  void draw( int x, int y );
  void update_size( void );

  void draw_active_area( void );
  void draw_checked( void );
  void draw_unchecked( void );
  void draw_O( void );

  GLUI_RadioGroup *group;

  GLUI_RadioButton( void ) {
    sprintf( name, "RadioButton: %p", this );
    type           = GLUI_CONTROL_RADIOBUTTON;
    h              = GLUI_RADIOBUTTON_SIZE;
    group          = NULL;
    orig_value     = -1;
    text_x_offset  = 18;
    can_activate   = true;
  };
};

/************************************************************/
/*                                                          */
/*               Separator class (container)                */
/*                                                          */
/************************************************************/

class GLUI_Separator : public GLUI_Control
{
public:
  void draw( int x, int y );

  GLUI_Separator( void ) {
    type         = GLUI_CONTROL_SEPARATOR;
    w            = 100;
    h            = GLUI_SEPARATOR_HEIGHT;
    can_activate = false;
  };
};

#define  GLUI_SPINNER_ARROW_WIDTH  12
#define  GLUI_SPINNER_ARROW_HEIGHT  8
#define  GLUI_SPINNER_ARROW_Y       2

#define  GLUI_SPINNER_STATE_NONE   0
#define  GLUI_SPINNER_STATE_UP     1
#define  GLUI_SPINNER_STATE_DOWN   2
#define  GLUI_SPINNER_STATE_BOTH   3

#define  GLUI_SPINNER_DEFAULT_GROWTH_EXP   1.05f

/************************************************************/
/*                                                          */
/*               Spinner class (container)                  */
/*                                                          */
/************************************************************/

class GLUI_Spinner : public GLUI_Control
{
public:
  int           currently_inside;
  int           state;
  float         growth, growth_exp;
  int           last_x, last_y;
  int           data_type;
  int           callback_count;
  int           last_int_val;
  float         last_float_val;
  int           first_callback;
  float         user_speed;

  GLUI_EditText *edittext;

  int  mouse_down_handler( int local_x, int local_y );
  int  mouse_up_handler( int local_x, int local_y, int same );
  int  mouse_held_down_handler( int local_x, int local_y, int inside );
  int  key_handler( unsigned char key,int modifiers );
  int  special_handler( int key,int modifiers );

  void draw( int x, int y );
  void draw_pressed( void );
  void draw_unpressed( void );
  void draw_text( int sunken );

  void update_size( void );

  void set_float_limits( float low,float high,int limit_type=GLUI_LIMIT_CLAMP);
  void set_int_limits( int low, int high,int limit_type=GLUI_LIMIT_CLAMP);
  int  find_arrow( int local_x, int local_y );
  void do_drag( int x, int y );
  void do_callbacks( void );
  void draw_arrows( void );
  void do_click( void );
  void idle( void );
  int  needs_idle( void );

  char *get_text( void );

  void set_float_val( float new_val );
  void set_int_val( int new_val );
  float  get_float_val( void );
  int    get_int_val( void );
  void increase_growth( void );
  void reset_growth( void );

  void set_speed( float speed ) { user_speed = speed; };

  GLUI_Spinner( void ) {
    sprintf( name, "Spinner: %p", this );
    type         = GLUI_CONTROL_SPINNER;
    h            = GLUI_EDITTEXT_HEIGHT;
    w            = GLUI_EDITTEXT_WIDTH;
    x_off        = 0;
    y_off_top    = 0;
    y_off_bot    = 0;
    can_activate = true;
    state        = GLUI_SPINNER_STATE_NONE;
    edittext     = NULL;
    growth_exp   = GLUI_SPINNER_DEFAULT_GROWTH_EXP;
    callback_count = 0;
    first_callback = true;
    user_speed   = 1.0;
  };
};

/************************************************************/

/*                                                          */
/*               StaticText class                           */
/*                                                          */
/************************************************************/

class GLUI_StaticText : public GLUI_Control
{
public:
  void set_text( char *text );
  void draw( int x, int y );
  void draw_text( void );
  void update_size( void );
  void erase_text( void );

  GLUI_StaticText( void ) {
    type    = GLUI_CONTROL_STATICTEXT;
    h       = GLUI_STATICTEXT_SIZE;
    name[0] = '\0';
    can_activate  = false;
  };
};

/************************************************************/
/*                                                          */
/*                   Listbox class                          */
/*                                                          */
/************************************************************/

class GLUI_Listbox_Item : public GLUI_Node
{
public:
  GLUI_String text;
  int         id;
};

class GLUI_Listbox : public GLUI_Control
{
public:
  GLUI_String       curr_text;
  GLUI_Listbox_Item items_list;
  int               depressed;

  int  orig_value, currently_inside;
  int  text_x_offset, title_x_offset;
  int  glut_menu_id;

  int  mouse_down_handler( int local_x, int local_y );
  int  mouse_up_handler( int local_x, int local_y, int inside );
  int  mouse_held_down_handler( int local_x, int local_y, int inside );
  int  key_handler( unsigned char key,int modifiers );
  int  special_handler( int key,int modifiers );

  void update_size( void );
  void draw( int x, int y );
  int  mouse_over( int state, int x, int y );

  void draw_active_area( void );
  void set_int_val( int new_val );
  void dump( FILE *output );

  int  add_item( int id, char *text );
  int  delete_item( char *text );
  int  delete_item( int id );
  int  sort_items( void );

  int  do_selection( int item );

  void increase_width( void );

  GLUI_Listbox_Item *get_item_ptr( char *text );
  GLUI_Listbox_Item *get_item_ptr( int id );

  GLUI_Listbox( void ) {
    sprintf( name, "Listbox: %p", this );
    type           = GLUI_CONTROL_LISTBOX;
    w              = GLUI_EDITTEXT_WIDTH;
    h              = GLUI_EDITTEXT_HEIGHT;
    orig_value     = -1;
    title_x_offset = 0;
    text_x_offset  = 55;
    can_activate   = true;
    curr_text[0]   = '\0';
    live_type      = GLUI_LIVE_INT;  /* This has an integer live var */
    depressed      = false;
    glut_menu_id   = -1;
  };

  ~GLUI_Listbox();
};

/************************************************************/
/*                                                          */
/*              Mouse_Interaction class                     */
/*                                                          */
/************************************************************/

class GLUI_Mouse_Interaction : public GLUI_Control
{
public:
  /*int  get_main_area_size( void ) { return MIN( h-18,  */
  int            draw_active_area_only;

  int  mouse_down_handler( int local_x, int local_y );
  int  mouse_up_handler( int local_x, int local_y, int inside );
  int  mouse_held_down_handler( int local_x, int local_y, int inside );
  int  special_handler( int key, int modifiers );
  void update_size( void );
  void draw( int x, int y );
  void draw_active_area( void );

  /***  The following methods (starting with "iaction_") need to
    be overloaded  ***/
  virtual int  iaction_mouse_down_handler( int local_x, int local_y ) = 0;
  virtual int  iaction_mouse_up_handler( int local_x, int local_y, int inside )=0;
  virtual int  iaction_mouse_held_down_handler( int local_x, int local_y, int inside )=0;
  virtual int  iaction_special_handler( int key, int modifiers )=0;
  virtual void iaction_draw_active_area_persp( void )=0;
  virtual void iaction_draw_active_area_ortho( void )=0;
  virtual void iaction_dump( FILE *output )=0;
  virtual void iaction_init( void ) = 0;

  GLUI_Mouse_Interaction( void ) {
    sprintf( name, "Mouse_Interaction: %p", this );
    type           = GLUI_CONTROL_MOUSE_INTERACTION;
    w              = GLUI_MOUSE_INTERACTION_WIDTH;
    h              = GLUI_MOUSE_INTERACTION_HEIGHT;
    can_activate   = true;
    live_type      = GLUI_LIVE_NONE;
    alignment      = GLUI_ALIGN_CENTER;
    draw_active_area_only = false;
  };
};

/************************************************************/
/*                                                          */
/*                   Rotation class                         */
/*                                                          */
/************************************************************/

class GLUI_Rotation : public GLUI_Mouse_Interaction
{
public:
  Arcball        *ball;
  GLUquadricObj *quadObj;
  int            can_spin, spinning;
  float          damping;

  int  iaction_mouse_down_handler( int local_x, int local_y );
  int  iaction_mouse_up_handler( int local_x, int local_y, int inside );
  int  iaction_mouse_held_down_handler( int local_x, int local_y, int inside );
  int  iaction_special_handler( int key, int modifiers );
  void iaction_init( void ) { init_ball(); };
  void iaction_draw_active_area_persp( void );
  void iaction_draw_active_area_ortho( void );
  void iaction_dump( FILE *output );

  /*  void update_size( void ); */
  /*  void draw( int x, int y ); */
  /*  int mouse_over( int state, int x, int y ); */

  void setup_texture( void );
  void setup_lights( void );
  void draw_ball( float radius );

  void init_ball( void );

  void reset( void );

  int  needs_idle( void );
  void idle( void );

  void copy_float_array_to_ball( void );
  void copy_ball_to_float_array( void );

  void set_spin( float damp_factor );

  GLUI_Rotation(void);
};

/************************************************************/
/*                                                          */
/*                   Translation class                      */
/*                                                          */
/************************************************************/

class GLUI_Translation : public GLUI_Mouse_Interaction
{
public:
  int trans_type;  /* Is this an XY or a Z controller? */
  int down_x, down_y;
  float scale_factor;
  GLUquadricObj *quadObj;
  int   trans_mouse_code;
  float orig_x, orig_y, orig_z;
  int   locked;

  int  iaction_mouse_down_handler( int local_x, int local_y );
  int  iaction_mouse_up_handler( int local_x, int local_y, int inside );
  int  iaction_mouse_held_down_handler( int local_x, int local_y, int inside );
  int  iaction_special_handler( int key, int modifiers );
  void iaction_init( void ) {  };
  void iaction_draw_active_area_persp( void );
  void iaction_draw_active_area_ortho( void );
  void iaction_dump( FILE *output );

  void set_speed( float s ) { scale_factor = s; };

  void setup_texture( void );
  void setup_lights( void );
  void draw_2d_arrow( int radius, int filled, int orientation );
  void draw_2d_x_arrows( int radius );
  void draw_2d_y_arrows( int radius );
  void draw_2d_z_arrows( int radius );
  void draw_2d_xy_arrows( int radius );

  int  get_mouse_code( int x, int y );

  /* Float array is either a single float (for single-axis controls),
     or two floats for X and Y (if an XY controller) */

  float get_z( void ) {     return float_array_val[0];  }
  float get_x( void ) {     return float_array_val[0];  }
  float get_y( void ) {
    if ( trans_type == GLUI_TRANSLATION_XY )    return float_array_val[1];
    else                    return float_array_val[0];
  }

  void  set_z( float val );
  void  set_x( float val );
  void  set_y( float val );
  void  set_one_val( float val, int index );

  GLUI_Translation( void ) {
    locked              = GLUI_TRANSLATION_LOCK_NONE;
    sprintf( name, "Translation: %p", this );
    type                = GLUI_CONTROL_TRANSLATION;
    w                   = GLUI_MOUSE_INTERACTION_WIDTH;
    h                   = GLUI_MOUSE_INTERACTION_HEIGHT;
    can_activate        = true;
    live_type           = GLUI_LIVE_FLOAT_ARRAY;
    float_array_size    = 0;
    alignment           = GLUI_ALIGN_CENTER;
    trans_type          = GLUI_TRANSLATION_XY;
    scale_factor        = 1.0;
    quadObj             = NULL;
    trans_mouse_code    = GLUI_TRANSLATION_MOUSE_NONE;
  };
};

/********** Misc functions *********************/
int _glutBitmapWidthString( void *font, char *s );
void _glutBitmapString( void *font, char *s );

/********** Our own callbacks for glut *********/
/* These are the callbacks that we pass to glut.  They take
   some action if necessary, then (possibly) call the user-level
   glut callbacks.
   */

void glui_display_func( void );
void glui_reshape_func( int w, int h );
void glui_keyboard_func(unsigned char key, int x, int y);
void glui_special_func(int key, int x, int y);
void glui_mouse_func(int button, int state, int x, int y);
void glui_motion_func(int x, int y);
void glui_passive_motion_func(int x, int y);
void glui_entry_func(int state);
void glui_visibility_func(int state);
void glui_idle_func(void);

void glui_parent_window_reshape_func( int w, int h );
void glui_parent_window_keyboard_func(unsigned char key, int x, int y);
void glui_parent_window_mouse_func(int, int, int, int );
void glui_parent_window_special_func(int key, int x, int y);

#endif

redpajama_set_name: RedPajamaGithub


Software's and applications are made to assist you in your work, so that you can easily perform your job with your full potential. MS Office package is designed for the same purpose which includes many ingenious applications that makes your job easy. In the middle of many applications of MS Office, MS Outlook is one such application which every professional is fond of. MS Outlook is equipped with components that help you to store and manage your notes, appointments, calendars, contacts, emails (sending and receiving), journals, tasks etc. in a better manner. This application is like your personal assistant that will help you in your every step towards success.
The sensitive and critical information's that you store in MS Outlook application is automatically saved in a special file called PST (Personal Storage Table) file which is like locker room of MS Outlook. It stores all the information's of MS Outlook in a proper and organized way, so that user can easily access them. The size of MS Outlook's PST file differs from version to version, like MS Outlook 2002 and its previous versions contain PST file of 2GB only which is later extended to 20 GB (extendable) as default in Outlook 2003 and 2007. Since the PST file holds the entire data of Microsoft Outlook it is the most important file in your system.
But, there is always an issue associated with this PST file which is related to its corruption or damage. The PST file gets corrupt or damage easily when it encounters any unusual situation like virus attacks, oversized issue, inappropriate shutdown of application, hardware and software issues etc. as a result the data stored in it becomes inaccessible and ultimately gets lost. This problem occurs in almost all MS Outlook's versions like 2000, 2002, 2003, 2007 etc.
C:\Program Files\Microsoft Office\Office11 (MS Outlook 2002, 2003).
C:\Program Files\Microsoft Office\Office12 (MS Outlook 2007).
If Scanpst.exe is not found at above mentioned location then you need to download Scanpst.exe for MS Outlook 2000, 2002, 2003, 2007 from Microsoft's official site.
Inbox Repair Tool or Scanpst.exe is very powerful tool which is efficient enough to repair the corruption issues of PST file like PST file header corruption etc. It uses its advanced and sophisticated scanning algorithm to scan the corrupt PST file and make it functional. But after using Scanpst.exe tool if the problem persists then you need to use any third party software to repair and recover the PST data.


adds Insurance coverage Technology Market 2018 International Evaluation, Progress, Traits and Opportunities Analysis Report Forecasting to 2025"studies to its database. Store Best Purchase for the highest new expertise products in 2018. CNET is the world's leader in tech product reviews, news, costs, movies, boards, how-tos and more.


A pearlware footed coffee pot and cover printed in brown with the Chinese Veranda pattern. Floral sprays have been added to the domed lid. This pattern is more commonly known printed in blue on porcelain teawares made by both Masons and New Hall. Dimensions are unknown.


Dave Duncan » Reminder: Books are Not Real Life. Got it?
Reminder: Books are Not Real Life. Got it?
Right now, I'm reading and enjoying "The Water-Method Man", which was the first book written by one of my favourite authors, John Irving ("The World According to Garp" and "The Cider House Rules"). I find his characters VERY engaging, either in spite of, or as a direct result of their many faults.
I think part of his skill as a writer is creating characters who are just enough like you, or someone you know, that you can get inside their head easily and accept them, which also means you accept the more odd and possibly unbelievable parts of who they are. In the case of this book, I found myself identifying with the main character quite closely, and as he quickly becomes more anxious about life, I find myself doing the same. It's all very "The Neverending Story".
Late last night, I found I couldn't sleep and curled up with the book under a blanket, reading by a dim lamp in our living room. I realized just how much the setting resembled "The Neverending Story", and fully expected The Nothing to swallow up my house. Alas, no Nothing showed up and I eventually got sleepy and went to bed.
I think I need to hurry up and finish this book so I can have my mind all to myself and not have to share it with Fred "Bogus" Thumper anymore. I think he's putting me on edge.
This entry was posted on Thursday, February 26th, 2009 at 12:42 pm and is filed under Writing.


The brand new Residence Goethe (opening season 2007) is situated in a peaceful and sunny location with a fine view. Walking through a pleasant lake promenade you can reach local shops, the lake shore, the mountains and the historical centre.
Spacious and welcoming two/three rooms apartments with lake view. Furnishings are up-to-date and plain, but careful and comfortable. Heated swimming pool with whirpool and children's section, private parking, air conditioning, LCD SAT TV, internet, dishwasher, microwave, launderette. Open all year round. Facilities for disabled.


So I make a joke by posting a meme on Facebook and now my wife is saying it was a threat and reported it to the police and family court. So one of her friends are running and telling her these things that I post. In no way would I threaten the wife of my kids. Have good day with Father's day shirt. I know who these people are, in fact they are supposed to be our mutual friends. That's okay though, I'm like an elephant I never forget anything. I will pray for each and every one of you.