/* inputs everywhere */

@mixin os-dialog {
	
	/* table and grid headers inside form/dialog */
   	.v-caption-on-top >.v-caption >.v-captiontext {
		font-size: $os-font-size * $os-l-font-factor;
		}
	
	.v-caption-on-top >.v-caption-l-control >.v-captiontext {
		font-size: $os-font-size;
		}	 
	
	/* extreme checkbox workaround */
	.v-formlayout-row {
		:root & .v-checkbox {
			@include os-checkbox();
			padding-top: inherit;
			> input ~ label:before, > input~ label:after {
				margin-top: inherit;
				}
			> input ~ label:before {
				margin-top: inherit;
				}		
			}
		.v-gridlayout {
			}
		}
	
	.v-gridlayout-slot .v-checkbox-os-box {
		@include os-checkbox();
		
		padding-top: floor($os-unit-size * 1.2);
		> input ~ label:before, > input~ label:after {
			margin-top: floor($os-unit-size * 1.2);
			}
		> input ~ label:before {
			margin-top: floor($os-unit-size * 1.2);
			}	
		} 

	/* Multiselect */
	select.v-select-select {
		color: inherit !important;
		border: $os-border
		}
	select.v-select-select option:checked {
 	   	box-shadow: 0 0 10px 100px $os-highlight-color inset;
 	   	color: valo-font-color($os-highlight-color) !important;	//? no effect
		}
		 
	.l-controlbase {
		overflow: auto;
		
		.v-grid-os-box {	
			//width: 800px !important; //needs fixed size as of now
			}
		}
		
	.v-panel-os-has-focus {
		@include os-panel-focus;
		}		
	
	.l-control { 
		//table and grid inside dialog
		.v-table {
			border-bottom: $os-border;
			}
		.v-table-header-wrap {
			border-top: none;
			height: $os-unit-size;
			}
			
		// grid inside dialog
		.v-grid-os-box {
			.v-grid-tablewrapper {
				border-top: 0px;
				}
			}
		.v-gridlayout-slot {
			.v-grid-os-box {
				.v-grid-tablewrapper {
					border-top: $os-border;
					}	
				}
			}			
		}
	
	.l-control, .toptrimbar, .os-selection-area {
		.v-panel {
			border-width: 1px;
			} 
		
		.v-caption {
			font-size: $os-font-size;
			}
			
		.v-caption-on-top >.v-caption, 
		.v-gridlayout-slot >.v-caption {
	    	padding-bottom: $os-unit-size*0.05;
	    	padding-top: $os-unit-size*0.3;
	    	}
	    
	    .v-caption-os-has-focus {
	    	@include os-caption-focus;
	    	}   
	    	
		.v-formlayout-captioncell, 
		.v-formlayout-errorcell {
			border-bottom: $os-border;
			vertical-align: bottom;
			}
			
		.v-textfield {
			width: $v-default-field-width;
			@include os-textfield;
			}
			
		.v-filterselect-input, .v-filterselect [class*="input"] {
			@include os-textfield;
			@include box-shadow(none); /*valo mixin*/
			}
		.v-filterselect-os-box .v-icon {
    		z-index: 999;
			}	 	
		.v-textfield-readonly, .v-disabled {
			@include os-textfield-readonly;
			}
		
		.l-beansearchfield {
    		@include os-button-l-beansearch;
    		> .v-slot > .v-filterselect { 
				//width: $v-default-field-width - $os-unit-size;
				}
    		}
    		 
		.v-datefield-error {
			.v-datefield-textfield {
				@include os-error-textfield;
				&.v-textfield-focus {
					color: valo-font-color($os-focus-color);
					}
				}
			.v-datefield-button {
				@include os-error-button;
				}
			}
		.v-textfield-error {
			@include os-error-textfield;
			}
    	
    	.v-button {
    		height: $os-unit-size;
    		}
    		
    	.v-upload-immediate .v-button {
    		@include os-button-formlayout;
			}
    	
    	.v-gridlayout-slot > .v-label > img {
    		@if $os-img-size-override == true {
        		height: $os-unit-size * 3;
        		}
    		}
    	
    	
		/* panel margins */
		[class*="margin-bottom"] > tbody > [class*="lastrow"] > td {
			padding-bottom: 0px;
			}
		[class*="margin-top"] > tbody > [class*="firstrow"] > td {
		    padding-top: 0px; 
			}
		}
		
	.v-filterselect-os-single-selection {
		color: valo-font-color($os-sub-header-bg);
		margin: floor($os-unit-size/3);
		width: $os-button-width;
		}    
	    
	.os-multi-selection select.v-select-select {
		color: inherit !important;
		border: $os-border;
		margin: floor($os-unit-size/3);
		width: $os-button-width;
		option:checked{
	 	   	box-shadow: 0 0 10px 100px $os-highlight-color inset;
			}	
		}		
	}