Google+
Cornerstone Air offers Heating, Air, Plumbing services in Tampa, FL

Some call it convenient. We call it comprehensive. Our skilled technicians provide Air Conditioning, Plumbing and Electrical service to keep you comfortable, 24/7. OUR SERVICES ›

Cornerstone Air has 24/7 emergency services for every customer

Your comfort is Cornerstone’s top priority, and our maintenance agreements are designed to keep your system running strong. MAINTENANCE PLANS ›

Cornerstone makes scheduling your HVAC services easy

You call; we fix it. No matter what type of system you have, we pride ourselves on professional service, quality workmanship and fair pricing. LEARN MORE ›

  
<center>
                <div class='gf_browser_unknown gform_wrapper' id='gform_wrapper_2' ><a id='gf_2' class='gform_anchor' ></a><form method='post' enctype='multipart/form-data' target='gform_ajax_frame_2' id='gform_2'  action='/#gf_2'>
                        <div class='gform_body'><ul id='gform_fields_2' class='gform_fields top_label form_sublabel_below description_below'><li id='field_2_7' class='gfield gplaceholder gf_left_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_2_7' >First Name<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_7' id='input_2_7' type='text' value='' class='medium'  tabindex='1'   aria-required="true" aria-invalid="false" /></div></li><li id='field_2_8' class='gfield gplaceholder gf_right_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_2_8' >Last Name<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_8' id='input_2_8' type='text' value='' class='medium'  tabindex='2'   aria-required="true" aria-invalid="false" /></div></li><li id='field_2_9' class='gfield gplaceholder gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_2_9' >Street Address<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_9' id='input_2_9' type='text' value='' class='large'  tabindex='3'   aria-required="true" aria-invalid="false" /></div></li><li id='field_2_10' class='gfield gplaceholder gf_left_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_2_10' >City<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_10' id='input_2_10' type='text' value='' class='medium'  tabindex='4'   aria-required="true" aria-invalid="false" /></div></li><li id='field_2_11' class='gfield gplaceholder gf_right_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_2_11' >Zip Code<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_11' id='input_2_11' type='text' value='' class='medium'  tabindex='5'   aria-required="true" aria-invalid="false" /></div></li><li id='field_2_3' class='gfield gplaceholder gf_left_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_2_3' >Email<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_email'>
                            <input name='input_3' id='input_2_3' type='text' value='' class='medium' tabindex='6'   />
                        </div></li><li id='field_2_5' class='gfield gplaceholder gf_right_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_2_5' >Phone<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_phone'><input name='input_5' id='input_2_5' type='text' value='' class='medium' tabindex='7'   aria-required="true" aria-invalid="false" /></div></li><li id='field_2_4' class='gfield gplaceholder field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_2_4' >How can we help you?</label><div class='ginput_container ginput_container_textarea'><textarea name='input_4' id='input_2_4' class='textarea large' tabindex='8'    aria-invalid="false"   rows='10' cols='50'></textarea></div></li><li id='field_2_6' class='gfield field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_2_6' ></label><div class='ginput_container ginput_container_select'><select name='input_6' id='input_2_6'  class='large gfield_select' tabindex='9'   aria-invalid="false"><option value='Type of Service Needed' >Type of Service Needed</option><option value='' ></option><option value='Air Conditioning' >Air Conditioning</option><option value='Heating' >Heating</option><option value='Plumbing' >Plumbing</option><option value='Electrical' >Electrical</option><option value='Other' >Other</option></select></div></li><li id='field_2_12' class='gfield gform_validation_container field_sublabel_below field_description_below gfield_visibility_' ><label class='gfield_label' for='input_2_12' >Name</label><div class='ginput_container'><input name='input_12' id='input_2_12' type='text' value='' /></div><div class='gfield_description'>This field is for validation purposes and should be left unchanged.</div></li>
                            </ul></div>
        <div class='gform_footer top_label'> <input type='submit' id='gform_submit_button_2' class='gform_button button' value='Submit' tabindex='10' onclick='if(window["gf_submitting_2"]){return false;}  window["gf_submitting_2"]=true;  ' onkeypress='if( event.keyCode == 13 ){ if(window["gf_submitting_2"]){return false;} window["gf_submitting_2"]=true;  jQuery("#gform_2").trigger("submit",[true]); }' /> <input type='hidden' name='gform_ajax' value='form_id=2&amp;title=&amp;description=&amp;tabindex=1' />
            <input type='hidden' class='gform_hidden' name='is_submit_2' value='1' />
            <input type='hidden' class='gform_hidden' name='gform_submit' value='2' />
            
            <input type='hidden' class='gform_hidden' name='gform_unique_id' value='' />
            <input type='hidden' class='gform_hidden' name='state_2' value='WyJbXSIsIjlhMjkyYWJkOTJkYTY3OTU5ZGRjYzE2NDY1MGRkMDY1Il0=' />
            <input type='hidden' class='gform_hidden' name='gform_target_page_number_2' id='gform_target_page_number_2' value='0' />
            <input type='hidden' class='gform_hidden' name='gform_source_page_number_2' id='gform_source_page_number_2' value='1' />
            <input type='hidden' name='gform_field_values' value='' />
            
        </div>
                        </form>
                        </div>
                <iframe style='display:none;width:0px;height:0px;' src='about:blank' name='gform_ajax_frame_2' id='gform_ajax_frame_2'>This iframe contains the logic required to handle AJAX powered Gravity Forms.</iframe>
                <script type='text/javascript'>jQuery(document).ready(function($){gformInitSpinner( 2, 'http://cornerstonepros.com/wp-content/plugins/gravityforms/images/spinner.gif' );jQuery('#gform_ajax_frame_2').load( function(){var contents = jQuery(this).contents().find('*').html();var is_postback = contents.indexOf('GF_AJAX_POSTBACK') >= 0;if(!is_postback){return;}var form_content = jQuery(this).contents().find('#gform_wrapper_2');var is_confirmation = jQuery(this).contents().find('#gform_confirmation_wrapper_2').length > 0;var is_redirect = contents.indexOf('gformRedirect(){') >= 0;var is_form = form_content.length > 0 && ! is_redirect && ! is_confirmation;if(is_form){jQuery('#gform_wrapper_2').html(form_content.html());if(form_content.hasClass('gform_validation_error')){jQuery('#gform_wrapper_2').addClass('gform_validation_error');} else {jQuery('#gform_wrapper_2').removeClass('gform_validation_error');}setTimeout( function() { /* delay the scroll by 50 milliseconds to fix a bug in chrome */ jQuery(document).scrollTop(jQuery('#gform_wrapper_2').offset().top); }, 50 );if(window['gformInitDatepicker']) {gformInitDatepicker();}if(window['gformInitPriceFields']) {gformInitPriceFields();}var current_page = jQuery('#gform_source_page_number_2').val();gformInitSpinner( 2, 'http://cornerstonepros.com/wp-content/plugins/gravityforms/images/spinner.gif' );jQuery(document).trigger('gform_page_loaded', [2, current_page]);window['gf_submitting_2'] = false;}else if(!is_redirect){var confirmation_content = jQuery(this).contents().find('#gforms_confirmation_message_2').html();if(!confirmation_content){confirmation_content = contents;}setTimeout(function(){jQuery('#gform_wrapper_2').replaceWith('<' + 'div id=\'gforms_confirmation_message_2\' class=\'gform_confirmation_message_2 gforms_confirmation_message\'' + '>' + confirmation_content + '<' + '/div' + '>');jQuery(document).scrollTop(jQuery('#gforms_confirmation_message_2').offset().top);jQuery(document).trigger('gform_confirmation_loaded', [2]);window['gf_submitting_2'] = false;}, 50);}else{jQuery('#gform_2').append(contents);if(window['gformRedirect']) {gformRedirect();}}jQuery(document).trigger('gform_post_render', [2, current_page]);} );} );</script><script type='text/javascript'> if(typeof gf_global == 'undefined') var gf_global = {"gf_currency_config":{"name":"U.S. Dollar","symbol_left":"$","symbol_right":"","symbol_padding":"","thousand_separator":",","decimal_separator":".","decimals":2},"base_url":"http:\/\/cornerstonepros.com\/wp-content\/plugins\/gravityforms","number_formats":[],"spinnerUrl":"http:\/\/cornerstonepros.com\/wp-content\/plugins\/gravityforms\/images\/spinner.gif"};jQuery(document).bind('gform_post_render', function(event, formId, currentPage){if(formId == 2) {if(!/(android)/i.test(navigator.userAgent)){jQuery('#input_2_5').mask('(999) 999-9999').bind('keypress', function(e){if(e.which == 13){jQuery(this).blur();} } );}} } );jQuery(document).bind('gform_post_conditional_logic', function(event, formId, fields, isInit){} );</script><script type='text/javascript'> jQuery(document).ready(function(){jQuery(document).trigger('gform_post_render', [2, 1]) } ); </script></center>
<center>
                <div class='gf_browser_unknown gform_wrapper' id='gform_wrapper_6' ><a id='gf_6' class='gform_anchor' ></a><form method='post' enctype='multipart/form-data' target='gform_ajax_frame_6' id='gform_6'  action='/#gf_6'>
                        <div class='gform_body'><ul id='gform_fields_6' class='gform_fields top_label form_sublabel_below description_below'><li id='field_6_10' class='gfield gplaceholder gf_left_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_10' >First Name<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_10' id='input_6_10' type='text' value='' class='medium'  tabindex='1'   aria-required="true" aria-invalid="false" /></div></li><li id='field_6_11' class='gfield gplaceholder gf_right_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_11' >Last Name<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_11' id='input_6_11' type='text' value='' class='medium'  tabindex='2'   aria-required="true" aria-invalid="false" /></div></li><li id='field_6_6' class='gfield gplaceholder gf_left_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_6' >Phone<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_phone'><input name='input_6' id='input_6_6' type='text' value='' class='medium' tabindex='3'   aria-required="true" aria-invalid="false" /></div></li><li id='field_6_7' class='gfield gplaceholder gf_right_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_7' >Email<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_email'>
                            <input name='input_7' id='input_6_7' type='text' value='' class='medium' tabindex='4'   />
                        </div></li><li id='field_6_12' class='gfield gplaceholder gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_12' >Street Address<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_12' id='input_6_12' type='text' value='' class='large'  tabindex='5'   aria-required="true" aria-invalid="false" /></div></li><li id='field_6_13' class='gfield gplaceholder gf_left_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_13' >City<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_13' id='input_6_13' type='text' value='' class='medium'  tabindex='6'   aria-required="true" aria-invalid="false" /></div></li><li id='field_6_14' class='gfield gplaceholder gf_right_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_14' >Zip Code<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_14' id='input_6_14' type='text' value='' class='medium'  tabindex='7'   aria-required="true" aria-invalid="false" /></div></li><li id='field_6_3' class='gfield gplaceholder gf_left_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_3' >Type of Service Needed<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_select'><select name='input_3' id='input_6_3'  class='medium gfield_select' tabindex='8'  aria-required="true" aria-invalid="false"><option value='' selected='selected'>Type of Service Needed</option><option value='' ></option><option value='Cooling' >Cooling</option><option value='Heating' >Heating</option><option value='Plumbing' >Plumbing</option><option value='Electrical' >Electrical</option></select></div></li><li id='field_6_15' class='gfield gplaceholder gf_right_half field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_15' >How did you hear about us?</label><div class='ginput_container ginput_container_select'><select name='input_15' id='input_6_15'  class='medium gfield_select' tabindex='9'   aria-invalid="false"><option value='' >How did you hear about us?</option><option value='' ></option><option value='Website' >Website</option><option value='Outdoor Ad' >Outdoor Ad</option><option value='Friend' >Friend</option><option value='Other' >Other</option></select></div></li><li id='field_6_8' class='gfield gplaceholder field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_8' >Additional notes to describe the problem:</label><div class='ginput_container ginput_container_textarea'><textarea name='input_8' id='input_6_8' class='textarea medium' tabindex='10'    aria-invalid="false"   rows='10' cols='50'></textarea></div></li><li id='field_6_16' class='gfield gplaceholder gf_left_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_16' >Date<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_16' id='input_6_16' type='text' value='' class='medium'  tabindex='11'   aria-required="true" aria-invalid="false" /></div></li><li id='field_6_17' class='gfield gplaceholder gf_right_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_6_17' >Time<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_17' id='input_6_17' type='text' value='' class='medium'  tabindex='12'   aria-required="true" aria-invalid="false" /></div></li>
                            </ul></div>
        <div class='gform_footer top_label'> <input type='submit' id='gform_submit_button_6' class='gform_button button' value='Submit' tabindex='13' onclick='if(window["gf_submitting_6"]){return false;}  window["gf_submitting_6"]=true;  ' onkeypress='if( event.keyCode == 13 ){ if(window["gf_submitting_6"]){return false;} window["gf_submitting_6"]=true;  jQuery("#gform_6").trigger("submit",[true]); }' /> <input type='hidden' name='gform_ajax' value='form_id=6&amp;title=&amp;description=&amp;tabindex=1' />
            <input type='hidden' class='gform_hidden' name='is_submit_6' value='1' />
            <input type='hidden' class='gform_hidden' name='gform_submit' value='6' />
            
            <input type='hidden' class='gform_hidden' name='gform_unique_id' value='' />
            <input type='hidden' class='gform_hidden' name='state_6' value='WyJbXSIsIjlhMjkyYWJkOTJkYTY3OTU5ZGRjYzE2NDY1MGRkMDY1Il0=' />
            <input type='hidden' class='gform_hidden' name='gform_target_page_number_6' id='gform_target_page_number_6' value='0' />
            <input type='hidden' class='gform_hidden' name='gform_source_page_number_6' id='gform_source_page_number_6' value='1' />
            <input type='hidden' name='gform_field_values' value='' />
            
        </div>
                        </form>
                        </div>
                <iframe style='display:none;width:0px;height:0px;' src='about:blank' name='gform_ajax_frame_6' id='gform_ajax_frame_6'>This iframe contains the logic required to handle AJAX powered Gravity Forms.</iframe>
                <script type='text/javascript'>jQuery(document).ready(function($){gformInitSpinner( 6, 'http://cornerstonepros.com/wp-content/plugins/gravityforms/images/spinner.gif' );jQuery('#gform_ajax_frame_6').load( function(){var contents = jQuery(this).contents().find('*').html();var is_postback = contents.indexOf('GF_AJAX_POSTBACK') >= 0;if(!is_postback){return;}var form_content = jQuery(this).contents().find('#gform_wrapper_6');var is_confirmation = jQuery(this).contents().find('#gform_confirmation_wrapper_6').length > 0;var is_redirect = contents.indexOf('gformRedirect(){') >= 0;var is_form = form_content.length > 0 && ! is_redirect && ! is_confirmation;if(is_form){jQuery('#gform_wrapper_6').html(form_content.html());if(form_content.hasClass('gform_validation_error')){jQuery('#gform_wrapper_6').addClass('gform_validation_error');} else {jQuery('#gform_wrapper_6').removeClass('gform_validation_error');}setTimeout( function() { /* delay the scroll by 50 milliseconds to fix a bug in chrome */ jQuery(document).scrollTop(jQuery('#gform_wrapper_6').offset().top); }, 50 );if(window['gformInitDatepicker']) {gformInitDatepicker();}if(window['gformInitPriceFields']) {gformInitPriceFields();}var current_page = jQuery('#gform_source_page_number_6').val();gformInitSpinner( 6, 'http://cornerstonepros.com/wp-content/plugins/gravityforms/images/spinner.gif' );jQuery(document).trigger('gform_page_loaded', [6, current_page]);window['gf_submitting_6'] = false;}else if(!is_redirect){var confirmation_content = jQuery(this).contents().find('#gforms_confirmation_message_6').html();if(!confirmation_content){confirmation_content = contents;}setTimeout(function(){jQuery('#gform_wrapper_6').replaceWith('<' + 'div id=\'gforms_confirmation_message_6\' class=\'gform_confirmation_message_6 gforms_confirmation_message\'' + '>' + confirmation_content + '<' + '/div' + '>');jQuery(document).scrollTop(jQuery('#gforms_confirmation_message_6').offset().top);jQuery(document).trigger('gform_confirmation_loaded', [6]);window['gf_submitting_6'] = false;}, 50);}else{jQuery('#gform_6').append(contents);if(window['gformRedirect']) {gformRedirect();}}jQuery(document).trigger('gform_post_render', [6, current_page]);} );} );</script><script type='text/javascript'> if(typeof gf_global == 'undefined') var gf_global = {"gf_currency_config":{"name":"U.S. Dollar","symbol_left":"$","symbol_right":"","symbol_padding":"","thousand_separator":",","decimal_separator":".","decimals":2},"base_url":"http:\/\/cornerstonepros.com\/wp-content\/plugins\/gravityforms","number_formats":[],"spinnerUrl":"http:\/\/cornerstonepros.com\/wp-content\/plugins\/gravityforms\/images\/spinner.gif"};jQuery(document).bind('gform_post_render', function(event, formId, currentPage){if(formId == 6) {if(!/(android)/i.test(navigator.userAgent)){jQuery('#input_6_6').mask('(999) 999-9999').bind('keypress', function(e){if(e.which == 13){jQuery(this).blur();} } );}} } );jQuery(document).bind('gform_post_conditional_logic', function(event, formId, fields, isInit){} );</script><script type='text/javascript'> jQuery(document).ready(function(){jQuery(document).trigger('gform_post_render', [6, 1]) } ); </script></center>
<center>
                <div class='gf_browser_unknown gform_wrapper' id='gform_wrapper_3' ><a id='gf_3' class='gform_anchor' ></a><form method='post' enctype='multipart/form-data' target='gform_ajax_frame_3' id='gform_3'  action='/#gf_3'>
                        <div class='gform_body'><ul id='gform_fields_3' class='gform_fields top_label form_sublabel_below description_below'><li id='field_3_8' class='gfield gplaceholder gf_left_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_3_8' >First Name<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_8' id='input_3_8' type='text' value='' class='medium'  tabindex='1'   aria-required="true" aria-invalid="false" /></div></li><li id='field_3_9' class='gfield gplaceholder gf_right_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_3_9' >Last Name<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_9' id='input_3_9' type='text' value='' class='medium'  tabindex='2'   aria-required="true" aria-invalid="false" /></div></li><li id='field_3_10' class='gfield gplaceholder gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_3_10' >Address<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_10' id='input_3_10' type='text' value='' class='large'  tabindex='3'   aria-required="true" aria-invalid="false" /></div></li><li id='field_3_12' class='gfield gplaceholder gf_left_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_3_12' >City<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_12' id='input_3_12' type='text' value='' class='medium'  tabindex='4'   aria-required="true" aria-invalid="false" /></div></li><li id='field_3_11' class='gfield gplaceholder gf_right_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_3_11' >Zip Code<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_text'><input name='input_11' id='input_3_11' type='text' value='' class='medium'  tabindex='5'   aria-required="true" aria-invalid="false" /></div></li><li id='field_3_3' class='gfield gplaceholder gf_left_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_3_3' >Email<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_email'>
                            <input name='input_3' id='input_3_3' type='text' value='' class='medium' tabindex='6'   />
                        </div></li><li id='field_3_5' class='gfield gplaceholder gf_right_half gfield_contains_required field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_3_5' >Phone<span class='gfield_required'>*</span></label><div class='ginput_container ginput_container_phone'><input name='input_5' id='input_3_5' type='text' value='' class='medium' tabindex='7'   aria-required="true" aria-invalid="false" /></div></li><li id='field_3_4' class='gfield gplaceholder field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_3_4' >How can we help you?</label><div class='ginput_container ginput_container_textarea'><textarea name='input_4' id='input_3_4' class='textarea medium' tabindex='8'    aria-invalid="false"   rows='10' cols='50'></textarea></div></li><li id='field_3_6' class='gfield gplaceholder gf_left_half field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_3_6' >Anticipated date for new Installation</label><div class='ginput_container ginput_container_select'><select name='input_6' id='input_3_6'  class='medium gfield_select' tabindex='9'   aria-invalid="false"><option value='Anticipated date for new Installation' >Anticipated date for new Installation</option><option value='' ></option><option value='Same Day Installation' >Same Day Installation</option><option value='1-7 days' >1-7 days</option><option value='2-3 weeks' >2-3 weeks</option><option value='2-3 Months' >2-3 Months</option></select></div></li><li id='field_3_7' class='gfield gplaceholder gf_right_half field_sublabel_below field_description_below gfield_visibility_visible' ><label class='gfield_label' for='input_3_7' >System Efficiency Rating</label><div class='ginput_container ginput_container_select'><select name='input_7' id='input_3_7'  class='medium gfield_select' tabindex='10'   aria-invalid="false"><option value='System Efficiency Rating' >System Efficiency Rating</option><option value='' ></option><option value='13 Seer' >13 Seer</option><option value='15 Seer' >15 Seer</option><option value='16 Seer' >16 Seer</option><option value='19 Seer' >19 Seer</option><option value='Other' >Other</option></select></div></li><li id='field_3_13' class='gfield gform_validation_container field_sublabel_below field_description_below gfield_visibility_' ><label class='gfield_label' for='input_3_13' >Phone</label><div class='ginput_container'><input name='input_13' id='input_3_13' type='text' value='' /></div><div class='gfield_description'>This field is for validation purposes and should be left unchanged.</div></li>
                            </ul></div>
        <div class='gform_footer top_label'> <input type='submit' id='gform_submit_button_3' class='gform_button button' value='Submit' tabindex='11' onclick='if(window["gf_submitting_3"]){return false;}  window["gf_submitting_3"]=true;  ' onkeypress='if( event.keyCode == 13 ){ if(window["gf_submitting_3"]){return false;} window["gf_submitting_3"]=true;  jQuery("#gform_3").trigger("submit",[true]); }' /> <input type='hidden' name='gform_ajax' value='form_id=3&amp;title=&amp;description=&amp;tabindex=1' />
            <input type='hidden' class='gform_hidden' name='is_submit_3' value='1' />
            <input type='hidden' class='gform_hidden' name='gform_submit' value='3' />
            
            <input type='hidden' class='gform_hidden' name='gform_unique_id' value='' />
            <input type='hidden' class='gform_hidden' name='state_3' value='WyJbXSIsIjlhMjkyYWJkOTJkYTY3OTU5ZGRjYzE2NDY1MGRkMDY1Il0=' />
            <input type='hidden' class='gform_hidden' name='gform_target_page_number_3' id='gform_target_page_number_3' value='0' />
            <input type='hidden' class='gform_hidden' name='gform_source_page_number_3' id='gform_source_page_number_3' value='1' />
            <input type='hidden' name='gform_field_values' value='' />
            
        </div>
                        </form>
                        </div>
                <iframe style='display:none;width:0px;height:0px;' src='about:blank' name='gform_ajax_frame_3' id='gform_ajax_frame_3'>This iframe contains the logic required to handle AJAX powered Gravity Forms.</iframe>
                <script type='text/javascript'>jQuery(document).ready(function($){gformInitSpinner( 3, 'http://cornerstonepros.com/wp-content/plugins/gravityforms/images/spinner.gif' );jQuery('#gform_ajax_frame_3').load( function(){var contents = jQuery(this).contents().find('*').html();var is_postback = contents.indexOf('GF_AJAX_POSTBACK') >= 0;if(!is_postback){return;}var form_content = jQuery(this).contents().find('#gform_wrapper_3');var is_confirmation = jQuery(this).contents().find('#gform_confirmation_wrapper_3').length > 0;var is_redirect = contents.indexOf('gformRedirect(){') >= 0;var is_form = form_content.length > 0 && ! is_redirect && ! is_confirmation;if(is_form){jQuery('#gform_wrapper_3').html(form_content.html());if(form_content.hasClass('gform_validation_error')){jQuery('#gform_wrapper_3').addClass('gform_validation_error');} else {jQuery('#gform_wrapper_3').removeClass('gform_validation_error');}setTimeout( function() { /* delay the scroll by 50 milliseconds to fix a bug in chrome */ jQuery(document).scrollTop(jQuery('#gform_wrapper_3').offset().top); }, 50 );if(window['gformInitDatepicker']) {gformInitDatepicker();}if(window['gformInitPriceFields']) {gformInitPriceFields();}var current_page = jQuery('#gform_source_page_number_3').val();gformInitSpinner( 3, 'http://cornerstonepros.com/wp-content/plugins/gravityforms/images/spinner.gif' );jQuery(document).trigger('gform_page_loaded', [3, current_page]);window['gf_submitting_3'] = false;}else if(!is_redirect){var confirmation_content = jQuery(this).contents().find('#gforms_confirmation_message_3').html();if(!confirmation_content){confirmation_content = contents;}setTimeout(function(){jQuery('#gform_wrapper_3').replaceWith('<' + 'div id=\'gforms_confirmation_message_3\' class=\'gform_confirmation_message_3 gforms_confirmation_message\'' + '>' + confirmation_content + '<' + '/div' + '>');jQuery(document).scrollTop(jQuery('#gforms_confirmation_message_3').offset().top);jQuery(document).trigger('gform_confirmation_loaded', [3]);window['gf_submitting_3'] = false;}, 50);}else{jQuery('#gform_3').append(contents);if(window['gformRedirect']) {gformRedirect();}}jQuery(document).trigger('gform_post_render', [3, current_page]);} );} );</script><script type='text/javascript'> if(typeof gf_global == 'undefined') var gf_global = {"gf_currency_config":{"name":"U.S. Dollar","symbol_left":"$","symbol_right":"","symbol_padding":"","thousand_separator":",","decimal_separator":".","decimals":2},"base_url":"http:\/\/cornerstonepros.com\/wp-content\/plugins\/gravityforms","number_formats":[],"spinnerUrl":"http:\/\/cornerstonepros.com\/wp-content\/plugins\/gravityforms\/images\/spinner.gif"};jQuery(document).bind('gform_post_render', function(event, formId, currentPage){if(formId == 3) {if(!/(android)/i.test(navigator.userAgent)){jQuery('#input_3_5').mask('(999) 999-9999').bind('keypress', function(e){if(e.which == 13){jQuery(this).blur();} } );}} } );jQuery(document).bind('gform_post_conditional_logic', function(event, formId, fields, isInit){} );</script><script type='text/javascript'> jQuery(document).ready(function(){jQuery(document).trigger('gform_post_render', [3, 1]) } ); </script></center>