{"version":"1.0","provider_name":"Tarsanas Restaurant Spetses","provider_url":"https:\/\/tarsanasrestaurant.com\/home","author_name":"tarssot","author_url":"https:\/\/tarsanasrestaurant.com\/home\/author\/tarssot\/","title":"Homepage I - Tarsanas Restaurant Spetses","type":"rich","width":600,"height":338,"html":"<blockquote class=\"wp-embedded-content\" data-secret=\"nBogFXDuGb\"><a href=\"https:\/\/tarsanasrestaurant.com\/home\/\">Homepage I<\/a><\/blockquote><iframe sandbox=\"allow-scripts\" security=\"restricted\" src=\"https:\/\/tarsanasrestaurant.com\/home\/embed\/#?secret=nBogFXDuGb\" width=\"600\" height=\"338\" title=\"&#8220;Homepage I&#8221; &#8212; Tarsanas Restaurant Spetses\" data-secret=\"nBogFXDuGb\" frameborder=\"0\" marginwidth=\"0\" marginheight=\"0\" scrolling=\"no\" class=\"wp-embedded-content\"><\/iframe><script type=\"text\/javascript\">\n\/*! This file is auto-generated *\/\n!function(c,d){\"use strict\";var e=!1,o=!1;if(d.querySelector)if(c.addEventListener)e=!0;if(c.wp=c.wp||{},c.wp.receiveEmbedMessage);else if(c.wp.receiveEmbedMessage=function(e){var t=e.data;if(!t);else if(!(t.secret||t.message||t.value));else if(\/[^a-zA-Z0-9]\/.test(t.secret));else{for(var r,s,a,i=d.querySelectorAll('iframe[data-secret=\"'+t.secret+'\"]'),n=d.querySelectorAll('blockquote[data-secret=\"'+t.secret+'\"]'),o=new RegExp(\"^https?:$\",\"i\"),l=0;l<n.length;l++)n[l].style.display=\"none\";for(l=0;l<i.length;l++)if(r=i[l],e.source!==r.contentWindow);else{if(r.removeAttribute(\"style\"),\"height\"===t.message){if(1e3<(s=parseInt(t.value,10)))s=1e3;else if(~~s<200)s=200;r.height=s}if(\"link\"===t.message)if(s=d.createElement(\"a\"),a=d.createElement(\"a\"),s.href=r.getAttribute(\"src\"),a.href=t.value,!o.test(a.protocol));else if(a.host===s.host)if(d.activeElement===r)c.top.location.href=t.value}}},e)c.addEventListener(\"message\",c.wp.receiveEmbedMessage,!1),d.addEventListener(\"DOMContentLoaded\",t,!1),c.addEventListener(\"load\",t,!1);function t(){if(o);else{o=!0;for(var e,t,r,s=-1!==navigator.appVersion.indexOf(\"MSIE 10\"),a=!!navigator.userAgent.match(\/Trident.*rv:11\\.\/),i=d.querySelectorAll(\"iframe.wp-embedded-content\"),n=0;n<i.length;n++){if(!(r=(t=i[n]).getAttribute(\"data-secret\")))r=Math.random().toString(36).substr(2,10),t.src+=\"#?secret=\"+r,t.setAttribute(\"data-secret\",r);if(s||a)(e=t.cloneNode(!0)).removeAttribute(\"security\"),t.parentNode.replaceChild(e,t);t.contentWindow.postMessage({message:\"ready\",secret:r},\"*\")}}}}(window,document);\n<\/script>\n","description":"<li id=\"template-block-13\" class=\"block block-em_column_block ui-resizable mtheme-columns span12\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\">
				<ul class=\"block-controls\">
					<li class=\"block-control-actions cf\">
						<a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove Column Container\"><i class=\"fa fa-trash\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#my-column-content-13\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit Column Container\"><i class=\"fa fa-pencil\"></i></a>
					</li>
					<li class=\"block-control-actions cf\">
						<a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\" data-toggle=\"modal\"><i class=\"fa fa-upload\"></i></a>
					</li>
				</ul>
				<dt class=\"block-handle ui-sortable-handle\">
	 				<div class=\"block-icon\" style=\"color:none;\"><i class=\"fa fa-bars\"></i></div>
					<div class=\"block-title\">Column Container</div>
					<div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span>
					<div class=\"blocknote-self\"></div>
				</dt>
			</dl><div class=\"block-settings-column cf ui-sortable-handle\" id=\"block-settings-13\"><p class=\"empty-column\">Drag block items into this container</p><ul class=\"blocks column-blocks cf ui-sortable\"><li id=\"template-block-14\" class=\"block block-em_sectionheading span12 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-14\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"14\" data-mblocktype=\"em_sectionheading\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(255,105,97,0.3) 0%, rgba(255,105,97,1) 100%);
background: -webkit-linear-gradient(left, rgba(255,105,97,0.5) 0%,rgba(255,105,97,1) 100%);
background: linear-gradient(to right, rgba(255,105,97,0.5) 0%,rgba(255,105,97,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#FF6961a5\', endColorstr=\'#FF6961a5\',GradientType=1 );\"><i class=\"fa fa-header\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Section Heading</div><div class=\"block-size\">12/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-14\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Section Heading</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_14][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_14][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-14\">
						<div class=\"description mtheme-input-type-is-animated\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_animated\">Animation type</label>
							<span class=\"forminputdescription\">
								Animation type
							</span>
						</div><div class=\"formview-rightside animated\"><select id=\"aq_block_14_mtheme_animated\" name=\"aq_blocks[aq_block_14][mtheme_animated]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"fadeIn\">fadeIn</option><option value=\"fadeInDown\">fadeInDown</option><option value=\"fadeInDownBig\">fadeInDownBig</option><option value=\"fadeInLeft\">fadeInLeft</option><option value=\"fadeInLeftBig\">fadeInLeftBig</option><option value=\"fadeInRight\">fadeInRight</option><option value=\"fadeInRightBig\">fadeInRightBig</option><option value=\"fadeInUp\">fadeInUp</option><option value=\"fadeInUpBig\">fadeInUpBig</option><option value=\"zoomIn\">zoomIn</option><option value=\"zoomInOut\">zoomInOut</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_title\">Section Heading text</label>
							<span class=\"forminputdescription\">
								Section Heading text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_title\" class=\"input-text-full\" value=\"Menu\" name=\"aq_blocks[aq_block_14][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_subtitle\">Section subheading text</label>
							<span class=\"forminputdescription\">
								Section subheading text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_subtitle\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_subtitle]\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_titlecolor\">Title color</label>
							<span class=\"forminputdescription\">
								Title color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_14_mtheme_titlecolor\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_titlecolor]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_subtitlecolor\">Subtitle color</label>
							<span class=\"forminputdescription\">
								Subtitle color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_14_mtheme_subtitlecolor\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_subtitlecolor]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_description\">Description (optional)</label>
							<span class=\"forminputdescription\">
								Description text
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_14_mtheme_description-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_14_mtheme_description-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_14][mtheme_description]\" id=\"aq_block_14_mtheme_description\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_descstyle\">Description style</label>
							<span class=\"forminputdescription\">
								Description style
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_14_mtheme_descstyle\" name=\"aq_blocks[aq_block_14][mtheme_descstyle]\"><option value=\"none\" selected=\"selected\">None</option><option value=\"fill\">Fill</option><option value=\"boxborder\">Box Border</option><option value=\"bordertop\">Border top</option><option value=\"borderbottom\">Border bottom</option><option value=\"bordertopbottom\">Border top and bottom</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_align\">Align text</label>
							<span class=\"forminputdescription\">
								Align text
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_14_mtheme_align\" name=\"aq_blocks[aq_block_14][mtheme_align]\"><option value=\"center\" selected=\"selected\">Center</option><option value=\"left\">Left</option><option value=\"right\">Right</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_size\">Heading size</label>
							<span class=\"forminputdescription\">
								Heading size
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_14_mtheme_size\" name=\"aq_blocks[aq_block_14][mtheme_size]\"><option value=\"1\" selected=\"selected\">H1</option><option value=\"2\">H2</option><option value=\"3\">H3</option><option value=\"4\">H4</option><option value=\"5\">H5</option><option value=\"6\">H6</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_button_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_button_text]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_button_url\">Button url</label>
							<span class=\"forminputdescription\">
								Button url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_button_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_button_url]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_width\">Width in percent</label>
							<span class=\"forminputdescription\">
								Width in percent
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_width\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_14][mtheme_width]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_top\">Padding Top in pixels</label>
							<span class=\"forminputdescription\">
								Top Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_top\" class=\"input-text-full\" value=\"10\" name=\"aq_blocks[aq_block_14][mtheme_top]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_bottom\">Padding bottom pixels</label>
							<span class=\"forminputdescription\">
								Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_bottom\" class=\"input-text-full\" value=\"10\" name=\"aq_blocks[aq_block_14][mtheme_bottom]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_14_mtheme_marginbottom\">Margin bottom pixels</label>
							<span class=\"forminputdescription\">
								Margin Bottom Spacing
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_14_mtheme_marginbottom\" class=\"input-text-full\" value=\"60\" name=\"aq_blocks[aq_block_14][mtheme_marginbottom]\"></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_14][id_base]\" value=\"em_sectionheading\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_14][name]\" value=\"Section Heading\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_14][order]\" value=\"1\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_14][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_14][parent]\" value=\"7\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_14][number]\" value=\"14\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-15\" class=\"block block-em_food_list span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-15\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"15\" data-mblocktype=\"em_food_list\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(131,105,83,0.3) 0%, rgba(131,105,83,1) 100%);
background: -webkit-linear-gradient(left, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
background: linear-gradient(to right, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#836953a5\', endColorstr=\'#836953a5\',GradientType=1 );\"><i class=\"simpleicon-grid\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Food List</div><div class=\"block-size\">6/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-15\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Food List</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_15][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_15][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-15\">
						<div class=\"description mtheme-input-type-is-category_list\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_foodtype_slugs\">Choose Food types to list</label>
							<span class=\"forminputdescription\">
								Leave blank to list all. Enter comma seperated food type categories. eg. mains,dessert,dinner 
							</span>
						</div><div class=\"formview-rightside category_list\"><div class=\"mtheme-work-type-items\">,<span>cold-starters</span>,<span>dessert</span>,<span>fisherman-basket</span>,<span>hot-starters</span>,<span>our-choise</span>,<span>pasta</span>,<span>rizzoto-oizo</span>,<span>salads</span>,<span>seafood-creation</span></div><input type=\"text\" id=\"aq_block_15_mtheme_foodtype_slugs\" class=\"input-\" value=\"salads\" name=\"aq_blocks[aq_block_15][mtheme_foodtype_slugs]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_animated\">Animate List</label>
							<span class=\"forminputdescription\">
								Animate List
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_15_mtheme_animated\" name=\"aq_blocks[aq_block_15][mtheme_animated]\"><option value=\"false\" selected=\"selected\">No</option><option value=\"true\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_columns\">Columns</label>
							<span class=\"forminputdescription\">
								No. of Columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_15_mtheme_columns\" name=\"aq_blocks[aq_block_15][mtheme_columns]\"><option value=\"1\" selected=\"selected\">1</option><option value=\"2\">2</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title for list
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_15_mtheme_title\" class=\"input-text-full\" value=\"Salads\" name=\"aq_blocks[aq_block_15][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_padding\">Padding</label>
							<span class=\"forminputdescription\">
								Padding around menu
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_15_mtheme_padding\" class=\"input-text-full\" value=\"15\" name=\"aq_blocks[aq_block_15][mtheme_padding]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_button_url\">Button url</label>
							<span class=\"forminputdescription\">
								Button url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_15_mtheme_button_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_15][mtheme_button_url]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_15_mtheme_button_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_15][mtheme_button_text]\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_15_mtheme_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_15][mtheme_background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_content\">Text</label>
							<span class=\"forminputdescription\">
								Text
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_15_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_15_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_15][mtheme_content]\" id=\"aq_block_15_mtheme_content\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_item_image\">Item Image</label>
							<span class=\"forminputdescription\">
								Item Image
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_15_mtheme_item_image\" name=\"aq_blocks[aq_block_15][mtheme_item_image]\"><option value=\"no\">No</option><option value=\"yes\" selected=\"selected\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_lightbox\">Image Lightbox</label>
							<span class=\"forminputdescription\">
								Image Lightbox
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_15_mtheme_lightbox\" name=\"aq_blocks[aq_block_15][mtheme_lightbox]\"><option value=\"no\" selected=\"selected\">No</option><option value=\"yes\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_15_mtheme_limit\">Limit. -1 for unlimited</label>
							<span class=\"forminputdescription\">
								Limit items. -1 for unlimited
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_15_mtheme_limit\" class=\"input-text-full\" value=\"-1\" name=\"aq_blocks[aq_block_15][mtheme_limit]\"></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_15][id_base]\" value=\"em_food_list\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_15][name]\" value=\"Food List\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_15][order]\" value=\"2\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_15][size]\" value=\"span6\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_15][parent]\" value=\"7\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_15][number]\" value=\"15\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-16\" class=\"block block-em_food_list span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-16\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"16\" data-mblocktype=\"em_food_list\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(131,105,83,0.3) 0%, rgba(131,105,83,1) 100%);
background: -webkit-linear-gradient(left, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
background: linear-gradient(to right, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#836953a5\', endColorstr=\'#836953a5\',GradientType=1 );\"><i class=\"simpleicon-grid\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Food List</div><div class=\"block-size\">6/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-16\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Food List</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_16][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_16][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-16\">
						<div class=\"description mtheme-input-type-is-category_list\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_foodtype_slugs\">Choose Food types to list</label>
							<span class=\"forminputdescription\">
								Leave blank to list all. Enter comma seperated food type categories. eg. mains,dessert,dinner 
							</span>
						</div><div class=\"formview-rightside category_list\"><div class=\"mtheme-work-type-items\">,<span>cold-starters</span>,<span>dessert</span>,<span>fisherman-basket</span>,<span>hot-starters</span>,<span>our-choise</span>,<span>pasta</span>,<span>rizzoto-oizo</span>,<span>salads</span>,<span>seafood-creation</span></div><input type=\"text\" id=\"aq_block_16_mtheme_foodtype_slugs\" class=\"input-\" value=\"pasta\" name=\"aq_blocks[aq_block_16][mtheme_foodtype_slugs]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_animated\">Animate List</label>
							<span class=\"forminputdescription\">
								Animate List
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_16_mtheme_animated\" name=\"aq_blocks[aq_block_16][mtheme_animated]\"><option value=\"false\" selected=\"selected\">No</option><option value=\"true\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_columns\">Columns</label>
							<span class=\"forminputdescription\">
								No. of Columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_16_mtheme_columns\" name=\"aq_blocks[aq_block_16][mtheme_columns]\"><option value=\"1\" selected=\"selected\">1</option><option value=\"2\">2</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title for list
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_16_mtheme_title\" class=\"input-text-full\" value=\"pasta\" name=\"aq_blocks[aq_block_16][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_padding\">Padding</label>
							<span class=\"forminputdescription\">
								Padding around menu
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_16_mtheme_padding\" class=\"input-text-full\" value=\"15\" name=\"aq_blocks[aq_block_16][mtheme_padding]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_button_url\">Button url</label>
							<span class=\"forminputdescription\">
								Button url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_16_mtheme_button_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_16][mtheme_button_url]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_16_mtheme_button_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_16][mtheme_button_text]\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_16_mtheme_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_16][mtheme_background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_content\">Text</label>
							<span class=\"forminputdescription\">
								Text
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_16_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_16_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_16][mtheme_content]\" id=\"aq_block_16_mtheme_content\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_item_image\">Item Image</label>
							<span class=\"forminputdescription\">
								Item Image
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_16_mtheme_item_image\" name=\"aq_blocks[aq_block_16][mtheme_item_image]\"><option value=\"no\">No</option><option value=\"yes\" selected=\"selected\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_lightbox\">Image Lightbox</label>
							<span class=\"forminputdescription\">
								Image Lightbox
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_16_mtheme_lightbox\" name=\"aq_blocks[aq_block_16][mtheme_lightbox]\"><option value=\"no\" selected=\"selected\">No</option><option value=\"yes\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_16_mtheme_limit\">Limit. -1 for unlimited</label>
							<span class=\"forminputdescription\">
								Limit items. -1 for unlimited
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_16_mtheme_limit\" class=\"input-text-full\" value=\"-1\" name=\"aq_blocks[aq_block_16][mtheme_limit]\"></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_16][id_base]\" value=\"em_food_list\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_16][name]\" value=\"Food List\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_16][order]\" value=\"3\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_16][size]\" value=\"span6\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_16][parent]\" value=\"7\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_16][number]\" value=\"16\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-17\" class=\"block block-em_food_list span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-17\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"17\" data-mblocktype=\"em_food_list\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(131,105,83,0.3) 0%, rgba(131,105,83,1) 100%);
background: -webkit-linear-gradient(left, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
background: linear-gradient(to right, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#836953a5\', endColorstr=\'#836953a5\',GradientType=1 );\"><i class=\"simpleicon-grid\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Food List</div><div class=\"block-size\">6/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-17\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Food List</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_17][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_17][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-17\">
						<div class=\"description mtheme-input-type-is-category_list\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_foodtype_slugs\">Choose Food types to list</label>
							<span class=\"forminputdescription\">
								Leave blank to list all. Enter comma seperated food type categories. eg. mains,dessert,dinner 
							</span>
						</div><div class=\"formview-rightside category_list\"><div class=\"mtheme-work-type-items\">,<span>cold-starters</span>,<span>dessert</span>,<span>fisherman-basket</span>,<span>hot-starters</span>,<span>our-choise</span>,<span>pasta</span>,<span>rizzoto-oizo</span>,<span>salads</span>,<span>seafood-creation</span></div><input type=\"text\" id=\"aq_block_17_mtheme_foodtype_slugs\" class=\"input-\" value=\"cold-starters\" name=\"aq_blocks[aq_block_17][mtheme_foodtype_slugs]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_animated\">Animate List</label>
							<span class=\"forminputdescription\">
								Animate List
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_17_mtheme_animated\" name=\"aq_blocks[aq_block_17][mtheme_animated]\"><option value=\"false\" selected=\"selected\">No</option><option value=\"true\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_columns\">Columns</label>
							<span class=\"forminputdescription\">
								No. of Columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_17_mtheme_columns\" name=\"aq_blocks[aq_block_17][mtheme_columns]\"><option value=\"1\" selected=\"selected\">1</option><option value=\"2\">2</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title for list
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_17_mtheme_title\" class=\"input-text-full\" value=\"Cold Starters\" name=\"aq_blocks[aq_block_17][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_padding\">Padding</label>
							<span class=\"forminputdescription\">
								Padding around menu
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_17_mtheme_padding\" class=\"input-text-full\" value=\"15\" name=\"aq_blocks[aq_block_17][mtheme_padding]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_button_url\">Button url</label>
							<span class=\"forminputdescription\">
								Button url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_17_mtheme_button_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_17][mtheme_button_url]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_17_mtheme_button_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_17][mtheme_button_text]\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_17_mtheme_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_17][mtheme_background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_content\">Text</label>
							<span class=\"forminputdescription\">
								Text
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_17_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_17_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_17][mtheme_content]\" id=\"aq_block_17_mtheme_content\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_item_image\">Item Image</label>
							<span class=\"forminputdescription\">
								Item Image
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_17_mtheme_item_image\" name=\"aq_blocks[aq_block_17][mtheme_item_image]\"><option value=\"no\">No</option><option value=\"yes\" selected=\"selected\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_lightbox\">Image Lightbox</label>
							<span class=\"forminputdescription\">
								Image Lightbox
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_17_mtheme_lightbox\" name=\"aq_blocks[aq_block_17][mtheme_lightbox]\"><option value=\"no\" selected=\"selected\">No</option><option value=\"yes\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_17_mtheme_limit\">Limit. -1 for unlimited</label>
							<span class=\"forminputdescription\">
								Limit items. -1 for unlimited
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_17_mtheme_limit\" class=\"input-text-full\" value=\"-1\" name=\"aq_blocks[aq_block_17][mtheme_limit]\"></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_17][id_base]\" value=\"em_food_list\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_17][name]\" value=\"Food List\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_17][order]\" value=\"4\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_17][size]\" value=\"span6\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_17][parent]\" value=\"7\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_17][number]\" value=\"17\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-18\" class=\"block block-em_food_list span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-18\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"18\" data-mblocktype=\"em_food_list\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(131,105,83,0.3) 0%, rgba(131,105,83,1) 100%);
background: -webkit-linear-gradient(left, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
background: linear-gradient(to right, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#836953a5\', endColorstr=\'#836953a5\',GradientType=1 );\"><i class=\"simpleicon-grid\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Food List</div><div class=\"block-size\">6/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-18\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Food List</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_18][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_18][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-18\">
						<div class=\"description mtheme-input-type-is-category_list\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_foodtype_slugs\">Choose Food types to list</label>
							<span class=\"forminputdescription\">
								Leave blank to list all. Enter comma seperated food type categories. eg. mains,dessert,dinner 
							</span>
						</div><div class=\"formview-rightside category_list\"><div class=\"mtheme-work-type-items\">,<span>cold-starters</span>,<span>dessert</span>,<span>fisherman-basket</span>,<span>hot-starters</span>,<span>our-choise</span>,<span>pasta</span>,<span>rizzoto-oizo</span>,<span>salads</span>,<span>seafood-creation</span></div><input type=\"text\" id=\"aq_block_18_mtheme_foodtype_slugs\" class=\"input-\" value=\"rizzoto-oizo\" name=\"aq_blocks[aq_block_18][mtheme_foodtype_slugs]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_animated\">Animate List</label>
							<span class=\"forminputdescription\">
								Animate List
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_18_mtheme_animated\" name=\"aq_blocks[aq_block_18][mtheme_animated]\"><option value=\"false\" selected=\"selected\">No</option><option value=\"true\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_columns\">Columns</label>
							<span class=\"forminputdescription\">
								No. of Columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_18_mtheme_columns\" name=\"aq_blocks[aq_block_18][mtheme_columns]\"><option value=\"1\" selected=\"selected\">1</option><option value=\"2\">2</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title for list
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_18_mtheme_title\" class=\"input-text-full\" value=\"Rizzoto &amp; Orzo\" name=\"aq_blocks[aq_block_18][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_padding\">Padding</label>
							<span class=\"forminputdescription\">
								Padding around menu
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_18_mtheme_padding\" class=\"input-text-full\" value=\"15\" name=\"aq_blocks[aq_block_18][mtheme_padding]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_button_url\">Button url</label>
							<span class=\"forminputdescription\">
								Button url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_18_mtheme_button_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_18][mtheme_button_url]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_18_mtheme_button_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_18][mtheme_button_text]\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_18_mtheme_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_18][mtheme_background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_content\">Text</label>
							<span class=\"forminputdescription\">
								Text
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_18_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_18_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_18][mtheme_content]\" id=\"aq_block_18_mtheme_content\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_item_image\">Item Image</label>
							<span class=\"forminputdescription\">
								Item Image
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_18_mtheme_item_image\" name=\"aq_blocks[aq_block_18][mtheme_item_image]\"><option value=\"no\">No</option><option value=\"yes\" selected=\"selected\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_lightbox\">Image Lightbox</label>
							<span class=\"forminputdescription\">
								Image Lightbox
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_18_mtheme_lightbox\" name=\"aq_blocks[aq_block_18][mtheme_lightbox]\"><option value=\"no\" selected=\"selected\">No</option><option value=\"yes\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_18_mtheme_limit\">Limit. -1 for unlimited</label>
							<span class=\"forminputdescription\">
								Limit items. -1 for unlimited
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_18_mtheme_limit\" class=\"input-text-full\" value=\"-1\" name=\"aq_blocks[aq_block_18][mtheme_limit]\"></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_18][id_base]\" value=\"em_food_list\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_18][name]\" value=\"Food List\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_18][order]\" value=\"5\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_18][size]\" value=\"span6\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_18][parent]\" value=\"7\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_18][number]\" value=\"18\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-19\" class=\"block block-em_food_list span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-19\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"19\" data-mblocktype=\"em_food_list\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(131,105,83,0.3) 0%, rgba(131,105,83,1) 100%);
background: -webkit-linear-gradient(left, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
background: linear-gradient(to right, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#836953a5\', endColorstr=\'#836953a5\',GradientType=1 );\"><i class=\"simpleicon-grid\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Food List</div><div class=\"block-size\">6/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-19\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Food List</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_19][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_19][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-19\">
						<div class=\"description mtheme-input-type-is-category_list\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_foodtype_slugs\">Choose Food types to list</label>
							<span class=\"forminputdescription\">
								Leave blank to list all. Enter comma seperated food type categories. eg. mains,dessert,dinner 
							</span>
						</div><div class=\"formview-rightside category_list\"><div class=\"mtheme-work-type-items\">,<span>cold-starters</span>,<span>dessert</span>,<span>fisherman-basket</span>,<span>hot-starters</span>,<span>our-choise</span>,<span>pasta</span>,<span>rizzoto-oizo</span>,<span>salads</span>,<span>seafood-creation</span></div><input type=\"text\" id=\"aq_block_19_mtheme_foodtype_slugs\" class=\"input-\" value=\"hot-starters\" name=\"aq_blocks[aq_block_19][mtheme_foodtype_slugs]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_animated\">Animate List</label>
							<span class=\"forminputdescription\">
								Animate List
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_19_mtheme_animated\" name=\"aq_blocks[aq_block_19][mtheme_animated]\"><option value=\"false\" selected=\"selected\">No</option><option value=\"true\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_columns\">Columns</label>
							<span class=\"forminputdescription\">
								No. of Columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_19_mtheme_columns\" name=\"aq_blocks[aq_block_19][mtheme_columns]\"><option value=\"1\" selected=\"selected\">1</option><option value=\"2\">2</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title for list
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_19_mtheme_title\" class=\"input-text-full\" value=\"hot-starters\" name=\"aq_blocks[aq_block_19][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_padding\">Padding</label>
							<span class=\"forminputdescription\">
								Padding around menu
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_19_mtheme_padding\" class=\"input-text-full\" value=\"15\" name=\"aq_blocks[aq_block_19][mtheme_padding]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_button_url\">Button url</label>
							<span class=\"forminputdescription\">
								Button url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_19_mtheme_button_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_19][mtheme_button_url]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_19_mtheme_button_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_19][mtheme_button_text]\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_19_mtheme_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_19][mtheme_background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_content\">Text</label>
							<span class=\"forminputdescription\">
								Text
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_19_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_19_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_19][mtheme_content]\" id=\"aq_block_19_mtheme_content\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_item_image\">Item Image</label>
							<span class=\"forminputdescription\">
								Item Image
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_19_mtheme_item_image\" name=\"aq_blocks[aq_block_19][mtheme_item_image]\"><option value=\"no\">No</option><option value=\"yes\" selected=\"selected\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_lightbox\">Image Lightbox</label>
							<span class=\"forminputdescription\">
								Image Lightbox
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_19_mtheme_lightbox\" name=\"aq_blocks[aq_block_19][mtheme_lightbox]\"><option value=\"no\" selected=\"selected\">No</option><option value=\"yes\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_19_mtheme_limit\">Limit. -1 for unlimited</label>
							<span class=\"forminputdescription\">
								Limit items. -1 for unlimited
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_19_mtheme_limit\" class=\"input-text-full\" value=\"-1\" name=\"aq_blocks[aq_block_19][mtheme_limit]\"></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_19][id_base]\" value=\"em_food_list\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_19][name]\" value=\"Food List\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_19][order]\" value=\"6\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_19][size]\" value=\"span6\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_19][parent]\" value=\"7\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_19][number]\" value=\"19\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-20\" class=\"block block-em_food_list span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-20\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"20\" data-mblocktype=\"em_food_list\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(131,105,83,0.3) 0%, rgba(131,105,83,1) 100%);
background: -webkit-linear-gradient(left, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
background: linear-gradient(to right, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#836953a5\', endColorstr=\'#836953a5\',GradientType=1 );\"><i class=\"simpleicon-grid\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Food List</div><div class=\"block-size\">6/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-20\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Food List</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_20][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_20][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-20\">
						<div class=\"description mtheme-input-type-is-category_list\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_foodtype_slugs\">Choose Food types to list</label>
							<span class=\"forminputdescription\">
								Leave blank to list all. Enter comma seperated food type categories. eg. mains,dessert,dinner 
							</span>
						</div><div class=\"formview-rightside category_list\"><div class=\"mtheme-work-type-items\">,<span>cold-starters</span>,<span>dessert</span>,<span>fisherman-basket</span>,<span>hot-starters</span>,<span>our-choise</span>,<span>pasta</span>,<span>rizzoto-oizo</span>,<span>salads</span>,<span>seafood-creation</span></div><input type=\"text\" id=\"aq_block_20_mtheme_foodtype_slugs\" class=\"input-\" value=\"seafood-creation\" name=\"aq_blocks[aq_block_20][mtheme_foodtype_slugs]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_animated\">Animate List</label>
							<span class=\"forminputdescription\">
								Animate List
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_20_mtheme_animated\" name=\"aq_blocks[aq_block_20][mtheme_animated]\"><option value=\"false\" selected=\"selected\">No</option><option value=\"true\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_columns\">Columns</label>
							<span class=\"forminputdescription\">
								No. of Columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_20_mtheme_columns\" name=\"aq_blocks[aq_block_20][mtheme_columns]\"><option value=\"1\" selected=\"selected\">1</option><option value=\"2\">2</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title for list
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_20_mtheme_title\" class=\"input-text-full\" value=\"Seafood creation\" name=\"aq_blocks[aq_block_20][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_padding\">Padding</label>
							<span class=\"forminputdescription\">
								Padding around menu
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_20_mtheme_padding\" class=\"input-text-full\" value=\"15\" name=\"aq_blocks[aq_block_20][mtheme_padding]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_button_url\">Button url</label>
							<span class=\"forminputdescription\">
								Button url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_20_mtheme_button_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_20][mtheme_button_url]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_20_mtheme_button_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_20][mtheme_button_text]\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_20_mtheme_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_20][mtheme_background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_content\">Text</label>
							<span class=\"forminputdescription\">
								Text
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_20_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_20_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_20][mtheme_content]\" id=\"aq_block_20_mtheme_content\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_item_image\">Item Image</label>
							<span class=\"forminputdescription\">
								Item Image
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_20_mtheme_item_image\" name=\"aq_blocks[aq_block_20][mtheme_item_image]\"><option value=\"no\">No</option><option value=\"yes\" selected=\"selected\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_lightbox\">Image Lightbox</label>
							<span class=\"forminputdescription\">
								Image Lightbox
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_20_mtheme_lightbox\" name=\"aq_blocks[aq_block_20][mtheme_lightbox]\"><option value=\"no\" selected=\"selected\">No</option><option value=\"yes\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_20_mtheme_limit\">Limit. -1 for unlimited</label>
							<span class=\"forminputdescription\">
								Limit items. -1 for unlimited
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_20_mtheme_limit\" class=\"input-text-full\" value=\"-1\" name=\"aq_blocks[aq_block_20][mtheme_limit]\"></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_20][id_base]\" value=\"em_food_list\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_20][name]\" value=\"Food List\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_20][order]\" value=\"7\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_20][size]\" value=\"span6\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_20][parent]\" value=\"7\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_20][number]\" value=\"20\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-21\" class=\"block block-em_food_list span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-21\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"21\" data-mblocktype=\"em_food_list\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(131,105,83,0.3) 0%, rgba(131,105,83,1) 100%);
background: -webkit-linear-gradient(left, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
background: linear-gradient(to right, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#836953a5\', endColorstr=\'#836953a5\',GradientType=1 );\"><i class=\"simpleicon-grid\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Food List</div><div class=\"block-size\">6/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-21\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Food List</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_21][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_21][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-21\">
						<div class=\"description mtheme-input-type-is-category_list\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_foodtype_slugs\">Choose Food types to list</label>
							<span class=\"forminputdescription\">
								Leave blank to list all. Enter comma seperated food type categories. eg. mains,dessert,dinner 
							</span>
						</div><div class=\"formview-rightside category_list\"><div class=\"mtheme-work-type-items\">,<span>cold-starters</span>,<span>dessert</span>,<span>fisherman-basket</span>,<span>hot-starters</span>,<span>our-choise</span>,<span>pasta</span>,<span>rizzoto-oizo</span>,<span>salads</span>,<span>seafood-creation</span></div><input type=\"text\" id=\"aq_block_21_mtheme_foodtype_slugs\" class=\"input-\" value=\"fisherman-basket\" name=\"aq_blocks[aq_block_21][mtheme_foodtype_slugs]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_animated\">Animate List</label>
							<span class=\"forminputdescription\">
								Animate List
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_21_mtheme_animated\" name=\"aq_blocks[aq_block_21][mtheme_animated]\"><option value=\"false\" selected=\"selected\">No</option><option value=\"true\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_columns\">Columns</label>
							<span class=\"forminputdescription\">
								No. of Columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_21_mtheme_columns\" name=\"aq_blocks[aq_block_21][mtheme_columns]\"><option value=\"1\" selected=\"selected\">1</option><option value=\"2\">2</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title for list
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_21_mtheme_title\" class=\"input-text-full\" value=\"From the fisherman\'s basket\" name=\"aq_blocks[aq_block_21][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_padding\">Padding</label>
							<span class=\"forminputdescription\">
								Padding around menu
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_21_mtheme_padding\" class=\"input-text-full\" value=\"15\" name=\"aq_blocks[aq_block_21][mtheme_padding]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_button_url\">Button url</label>
							<span class=\"forminputdescription\">
								Button url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_21_mtheme_button_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_21][mtheme_button_url]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_21_mtheme_button_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_21][mtheme_button_text]\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_21_mtheme_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_21][mtheme_background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_content\">Text</label>
							<span class=\"forminputdescription\">
								Text
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_21_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_21_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_21][mtheme_content]\" id=\"aq_block_21_mtheme_content\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_item_image\">Item Image</label>
							<span class=\"forminputdescription\">
								Item Image
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_21_mtheme_item_image\" name=\"aq_blocks[aq_block_21][mtheme_item_image]\"><option value=\"no\">No</option><option value=\"yes\" selected=\"selected\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_lightbox\">Image Lightbox</label>
							<span class=\"forminputdescription\">
								Image Lightbox
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_21_mtheme_lightbox\" name=\"aq_blocks[aq_block_21][mtheme_lightbox]\"><option value=\"no\" selected=\"selected\">No</option><option value=\"yes\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_21_mtheme_limit\">Limit. -1 for unlimited</label>
							<span class=\"forminputdescription\">
								Limit items. -1 for unlimited
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_21_mtheme_limit\" class=\"input-text-full\" value=\"-1\" name=\"aq_blocks[aq_block_21][mtheme_limit]\"></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_21][id_base]\" value=\"em_food_list\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_21][name]\" value=\"Food List\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_21][order]\" value=\"8\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_21][size]\" value=\"span6\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_21][parent]\" value=\"7\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_21][number]\" value=\"21\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li><li id=\"template-block-22\" class=\"block block-em_food_list span6 ui-sortable-handle ui-resizable\" data-toggle=\"tooltip\" data-placement=\"top\" style=\"top: auto; left: 0px;\"><dl class=\"block-bar\"><ul class=\"block-controls\"><li class=\"block-control-actions cf\"><a href=\"#\" class=\"delete\" data-tooltip=\"tooltip\" data-original-title=\"Remove\"><i class=\"fa fa-trash\"></i></a></li>
								 <li class=\"block-control-actions cf\"><a href=\"#\" class=\"clone\" data-tooltip=\"tooltip\" data-original-title=\"Duplicate\"><i class=\"fa fa-files-o\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#block-settings-22\" class=\"block-edit\" data-toggle=\"stackablemodal\" data-tooltip=\"tooltip\" data-original-title=\"Edit\" data-mblockid=\"22\" data-mblocktype=\"em_food_list\" data-keyboard=\"true\"><i class=\"fa fa-edit\"></i></a></li><li class=\"block-control-actions cf\"><a href=\"#mtheme-pb-export-a-block\" class=\"export\" data-toggle=\"modal\" data-tooltip=\"tooltip\" data-original-title=\"Export Block\"><i class=\"fa fa-upload\"></i></a></li></ul><dt class=\"block-handle\"><div class=\"block-icon\" style=\"background: -moz-linear-gradient(left, rgba(131,105,83,0.3) 0%, rgba(131,105,83,1) 100%);
background: -webkit-linear-gradient(left, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
background: linear-gradient(to right, rgba(131,105,83,0.5) 0%,rgba(131,105,83,1) 100%);
filter: progid:DXImageTransform.Microsoft.gradient( startColorstr=\'#836953a5\', endColorstr=\'#836953a5\',GradientType=1 );\"><i class=\"simpleicon-grid\"></i></div><ul class=\"blocksizecontrol-wrap\">
		 							<li>
				 						<a href=\"#\" class=\"blocksizeincr\"><i class=\"fa fa-plus\"></i></a>
				 						<a href=\"#\" class=\"blocksizedecr\"><i class=\"fa fa-minus\"></i></a>
	  								</li>
  								</ul><div class=\"block-title\">Food List</div><div class=\"block-size\">6/12</div><span class=\"user-control-id\"></span><div class=\"blocknote-self\"></div></dt></dl><div class=\"block-settings cf modal fade\" id=\"block-settings-22\">						  <div class=\"modal-dialog modal-lg\" tabindex=\"-1\">
							<div class=\"modal-content em-control-modal\">
							  <div class=\"modal-header\">
								<div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
								<h4 class=\"modal-title\">Food List</h4>
								<label for=\"blockID\">Block ID</label>
								<div class=\"forminputdescription\">Enter a unique ID for this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_22][blockID]\" value=\"\" class=\"blockID\">

								<label for=\"blockNote\">Block Note</label>
								<div class=\"forminputdescription\">Add a note for self - to identify this block.</div>
								<input type=\"text\" name=\"aq_blocks[aq_block_22][blockNote]\" value=\"\" class=\"blockNote\">
							  </div>
							  <div class=\"modal-body\" id=\"my-content-22\">
						<div class=\"description mtheme-input-type-is-category_list\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_foodtype_slugs\">Choose Food types to list</label>
							<span class=\"forminputdescription\">
								Leave blank to list all. Enter comma seperated food type categories. eg. mains,dessert,dinner 
							</span>
						</div><div class=\"formview-rightside category_list\"><div class=\"mtheme-work-type-items\">,<span>cold-starters</span>,<span>dessert</span>,<span>fisherman-basket</span>,<span>hot-starters</span>,<span>our-choise</span>,<span>pasta</span>,<span>rizzoto-oizo</span>,<span>salads</span>,<span>seafood-creation</span></div><input type=\"text\" id=\"aq_block_22_mtheme_foodtype_slugs\" class=\"input-\" value=\"dessert\" name=\"aq_blocks[aq_block_22][mtheme_foodtype_slugs]\"></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_animated\">Animate List</label>
							<span class=\"forminputdescription\">
								Animate List
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_22_mtheme_animated\" name=\"aq_blocks[aq_block_22][mtheme_animated]\"><option value=\"false\" selected=\"selected\">No</option><option value=\"true\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_columns\">Columns</label>
							<span class=\"forminputdescription\">
								No. of Columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_22_mtheme_columns\" name=\"aq_blocks[aq_block_22][mtheme_columns]\"><option value=\"1\" selected=\"selected\">1</option><option value=\"2\">2</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_title\">Title</label>
							<span class=\"forminputdescription\">
								Title for list
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_22_mtheme_title\" class=\"input-text-full\" value=\"Deserts\" name=\"aq_blocks[aq_block_22][mtheme_title]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_padding\">Padding</label>
							<span class=\"forminputdescription\">
								Padding around menu
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_22_mtheme_padding\" class=\"input-text-full\" value=\"15\" name=\"aq_blocks[aq_block_22][mtheme_padding]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_button_url\">Button url</label>
							<span class=\"forminputdescription\">
								Button url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_22_mtheme_button_url\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_22][mtheme_button_url]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_button_text\">Button text</label>
							<span class=\"forminputdescription\">
								Button text
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_22_mtheme_button_text\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_22][mtheme_button_text]\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_22_mtheme_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_22][mtheme_background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-editor\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_content\">Text</label>
							<span class=\"forminputdescription\">
								Text
							</span>
						</div><div class=\"formview-rightside editor\"><div id=\"wp-aq_block_22_mtheme_content-wrap\" class=\"wp-core-ui wp-editor-wrap html-active\"><div id=\"wp-aq_block_22_mtheme_content-editor-container\" class=\"wp-editor-container\"><textarea class=\"wp-editor-area\" rows=\"20\" cols=\"40\" name=\"aq_blocks[aq_block_22][mtheme_content]\" id=\"aq_block_22_mtheme_content\"></textarea></div>
<div class=\"uploader-editor\">
		<div class=\"uploader-editor-content\">
			<div class=\"uploader-editor-title\">Drop files to upload</div>
		</div>
	</div></div>

</div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_item_image\">Item Image</label>
							<span class=\"forminputdescription\">
								Item Image
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_22_mtheme_item_image\" name=\"aq_blocks[aq_block_22][mtheme_item_image]\"><option value=\"no\">No</option><option value=\"yes\" selected=\"selected\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_lightbox\">Image Lightbox</label>
							<span class=\"forminputdescription\">
								Image Lightbox
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_22_mtheme_lightbox\" name=\"aq_blocks[aq_block_22][mtheme_lightbox]\"><option value=\"no\" selected=\"selected\">No</option><option value=\"yes\">Yes</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_22_mtheme_limit\">Limit. -1 for unlimited</label>
							<span class=\"forminputdescription\">
								Limit items. -1 for unlimited
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_22_mtheme_limit\" class=\"input-text-full\" value=\"-1\" name=\"aq_blocks[aq_block_22][mtheme_limit]\"></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_22][id_base]\" value=\"em_food_list\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_22][name]\" value=\"Food List\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_22][order]\" value=\"9\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_22][size]\" value=\"span6\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_22][parent]\" value=\"7\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_22][number]\" value=\"22\">				</div>
				<div class=\"modal-footer\">
					<button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button>
				</div>
				</div><!-- /.modal-content -->
			  </div><!-- /.modal-dialog -->
			</div><!-- /.modal -->
		  <div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li></ul><div id=\"my-column-content-13\" class=\"modal fade\" style=\"display: none;\">			<div class=\"modal-dialog modal-lg\">
				<div class=\"modal-content\">
					  <div class=\"modal-header\">
					  <div type=\"button\" class=\"tb-close-icon\" data-dismiss=\"modal\" aria-hidden=\"true\"></div>
							<h4 class=\"modal-title\">Column Container</h4>
							<label for=\"blockID\">Column ID</label>
							<div class=\"description_text\">Enter a unique ID for this column.</div>
							<input class=\"blockID\" type=\"text\" name=\"aq_blocks[aq_block_13][blockID]\" value=\"\" id=\"blockID\">
							<label for=\"blockNote\">Block Note</label>
							<div class=\"description_text\">Add a note for self - to identify this block.</div>
							<input class=\"blockNote\" type=\"text\" name=\"aq_blocks[aq_block_13][blockNote]\" value=\"\" id=\"blockNote\">
					  </div>
					<div class=\"modal-body\">
							  <div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_container_type\">Boxed or Fullwidth</label>
							<span class=\"forminputdescription\">
								Boxed or Fullwidth. For full columns
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_13_container_type\" name=\"aq_blocks[aq_block_13][container_type]\"><option value=\"boxed\" selected=\"selected\">Boxed</option><option value=\"fullwidth\">Fullwidth</option></select></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_text_intensity\">Text Intensity</label>
							<span class=\"forminputdescription\">
								Text Intensity for headings types
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_13_text_intensity\" name=\"aq_blocks[aq_block_13][text_intensity]\"><option value=\"default\" selected=\"selected\">Default</option><option value=\"dark\">Dark</option><option value=\"bright\">Bright</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_margin_top\">Margin top in pixels</label>
							<span class=\"forminputdescription\">
								Margin top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_margin_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][margin_top]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_margin_bottom\">Margin bottom in pixels</label>
							<span class=\"forminputdescription\">
								Margin bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_margin_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][margin_bottom]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_padding_top\">Padding top in pixels</label>
							<span class=\"forminputdescription\">
								Padding top in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_padding_top\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][padding_top]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_padding_bottom\">Padding bottom in pixels</label>
							<span class=\"forminputdescription\">
								Padding bottom in pixels
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_padding_bottom\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][padding_bottom]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_padding_sides\">Padding sides % ( in percentage )</label>
							<span class=\"forminputdescription\">
								Padding both sides in percentage value
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_padding_sides\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][padding_sides]\"></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_background_color\">Background color</label>
							<span class=\"forminputdescription\">
								Background color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_13_background_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_13][background_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-color\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_gradient_color\">Combine with background color to create Gradients</label>
							<span class=\"forminputdescription\">
								Apply Gradient color
							</span>
						</div><div class=\"formview-rightside color\"><span class=\"aqpb-color-picker\"><div class=\"wp-picker-container\"><button type=\"button\" class=\"button wp-color-result\" aria-expanded=\"false\"><span class=\"wp-color-result-text\">Select Color</span></button><span class=\"wp-picker-input-wrap hidden\"><label><span class=\"screen-reader-text\">Color value</span><input type=\"text\" id=\"aq_block_13_gradient_color\" class=\"input-color-picker wp-color-picker\" value=\"\" name=\"aq_blocks[aq_block_13][gradient_color]\" data-default-color=\"\"></label><input type=\"button\" class=\"button button-small wp-picker-clear\" value=\"Clear\" aria-label=\"Clear color\"></span><div class=\"wp-picker-holder\"><div class=\"iris-picker iris-border\" style=\"display: none; width: 300px; height: 237px; padding-bottom: 27.6675px;\"><div class=\"iris-picker-inner\"><div class=\"iris-square\" style=\"width: 217px; height: 217px;\"><a class=\"iris-square-value ui-draggable ui-draggable-handle\" href=\"#\" style=\"left: 0px; top: 217px;\"><span class=\"iris-square-handle ui-slider-handle\"></span></a><div class=\"iris-square-inner iris-square-horiz\" style=\"background-image: -webkit-linear-gradient(left, rgb(128, 128, 128), rgb(255, 0, 0));\"></div><div class=\"iris-square-inner iris-square-vert\" style=\"background-image: -webkit-linear-gradient(top, rgb(255, 255, 255), rgba(255, 255, 255, 0) 50%, rgba(0, 0, 0, 0) 50%, rgb(0, 0, 0));\"></div></div><div class=\"iris-slider iris-strip\" style=\"height: 244.667px; width: 33.6px; background-image: -webkit-linear-gradient(top, rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0), rgb(0, 0, 0));\"><div class=\"iris-slider-offset ui-slider ui-corner-all ui-slider-vertical ui-widget ui-widget-content\"><span tabindex=\"0\" class=\"ui-slider-handle ui-corner-all ui-state-default\" style=\"bottom: 100%;\"></span></div></div></div><div class=\"iris-palette-container\"><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(0, 0, 0); height: 23.3275px; width: 23.3275px; margin-left: 0px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(255, 255, 255); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 51, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(221, 153, 51); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(238, 238, 34); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(129, 215, 66); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(30, 115, 190); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a><a class=\"iris-palette\" tabindex=\"0\" style=\"background-color: rgb(130, 36, 227); height: 23.3275px; width: 23.3275px; margin-left: 4.34px;\"></a></div></div></div></div></span></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_gradient_angle\">Gradient angle</label>
							<span class=\"forminputdescription\">
								Gradient angle
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_13_gradient_angle\" name=\"aq_blocks[aq_block_13][gradient_angle]\"><option value=\"none\" selected=\"selected\">none</option><option value=\"to_bottom\">to bottom</option><option value=\"to_top\">to top</option><option value=\"to_top_right\">to top right</option><option value=\"to_top_left\">to top left</option><option value=\"to_bottom_right\">to bottom right</option><option value=\"to_bottom_left\">to bottom left</option></select></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_video_mp4\">Fill For Video Background - MP4</label>
							<span class=\"forminputdescription\">
								Required : MP4 url.
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_video_mp4\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][video_mp4]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_video_webm\">Fill For Video Background - WEBM</label>
							<span class=\"forminputdescription\">
								Required : WEBM url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_video_webm\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][video_webm]\"></div></div><div class=\"description mtheme-input-type-is-text\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_video_ogv\">Fill For Video Background - OGV</label>
							<span class=\"forminputdescription\">
								Required : OGV url
							</span>
						</div><div class=\"formview-rightside text\"><input type=\"text\" id=\"aq_block_13_video_ogv\" class=\"input-text-full\" value=\"\" name=\"aq_blocks[aq_block_13][video_ogv]\"></div></div><div class=\"description mtheme-input-type-is-uploader\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_background_image\">Background Image / Fallback Video Image</label>
							<span class=\"forminputdescription\">
								Background Image
							</span>
						</div><div class=\"formview-rightside uploader\"><img class=\"screenshot\" src=\"\" alt=\"\">
						<input type=\"hidden\" id=\"aq_block_13_background_image_imageid\" name=\"aq_blocks[aq_block_13][background_imageid]\" value=\"\"><input type=\"text\" readonly=\"\" id=\"aq_block_13_background_image\" class=\"input-full imagefile-uploader\" value=\"\" name=\"aq_blocks[aq_block_13][background_image]\"><a href=\"#\" class=\"aq_upload_button button\" rel=\"image\">Upload</a><a class=\"remove_image button\" style=\"float:right;\">Remove</a><p></p></div></div><div class=\"description mtheme-input-type-is-select\"><div class=\"formview-leftside\">
							<label for=\"aq_block_13_background_scroll\">Scroll effect</label>
							<span class=\"forminputdescription\">
								Scroll effect
							</span>
						</div><div class=\"formview-rightside select\"><select id=\"aq_block_13_background_scroll\" name=\"aq_blocks[aq_block_13][background_scroll]\"><option value=\"static\" selected=\"selected\">Static</option><option value=\"parallax\">Parallax</option></select></div></div></div><div class=\"modal-footer\"><button class=\"button-primary\" type=\"button\" data-dismiss=\"modal\">Done</button></div></div></div></div><input type=\"hidden\" class=\"id_base\" name=\"aq_blocks[aq_block_13][id_base]\" value=\"em_column_block\"><input type=\"hidden\" class=\"name\" name=\"aq_blocks[aq_block_13][name]\" value=\"Column Container\"><input type=\"hidden\" class=\"order\" name=\"aq_blocks[aq_block_13][order]\" value=\"7\"><input type=\"hidden\" class=\"size\" name=\"aq_blocks[aq_block_13][size]\" value=\"span12\"><input type=\"hidden\" class=\"parent\" name=\"aq_blocks[aq_block_13][parent]\" value=\"0\"><input type=\"hidden\" class=\"number\" name=\"aq_blocks[aq_block_13][number]\" value=\"13\">				</div>
			<div class=\"ui-resizable-handle ui-resizable-e\" style=\"z-index: 90;\"></div></li>"}