"""

License:
This collection of code named GS CurveTools is a property of George Sladkovsky (Yehor Sladkovskyi)
and can not be copied or distributed without his written permission.

GS CurveTools v1.3.1 Studio
Copyright 2023, George Sladkovsky (Yehor Sladkovskyi)
All Rights Reserved

Autodesk Maya is a property of Autodesk, Inc.

Social Media and Contact Links:

Discord Server:       https://discord.gg/f4DH6HQ
Online Store:         https://sladkovsky3d.artstation.com/store
Online Documentation: https://gs-curvetools.readthedocs.io/
Twitch Channel:       https://www.twitch.tv/videonomad
YouTube Channel:      https://www.youtube.com/c/GeorgeSladkovsky
ArtStation Portfolio: https://www.artstation.com/sladkovsky3d
Contact Email:        george.sladkovsky@gmail.com

"""

import os
from functools import partial as pa
from imp import reload

import maya.cmds as mc
import maya.OpenMayaUI as omui
from PySide2 import QtCore, QtGui, QtWidgets
from shiboken2 import wrapInstance

from . import core, uv_editor
from .constants import *
from .utils import gs_math as mt
from .utils import style, tooltips, utils, wrap
from .utils.utils import deferred, noUndo, undo
from .utils.wrap import WIDGETS

reload(core)
reload(uv_editor)
reload(utils)
reload(wrap)
reload(style)

MESSAGE = utils.logger
LOGGER = utils.logger.logger

# Maya Main Window and Workspace


def mayaMainWindow():
    """ Get Maya main window pointer"""
    mayaWindow = wrapInstance(int(omui.MQtUtil.mainWindow()), QtWidgets.QMainWindow)
    return mayaWindow


def mayaWorkspaceControl(name, label, retain=True, iw=164, ih=783, widthProperty='preferred'):
    """ Create Maya Dockable Workspace """
    try:
        control = mc.workspaceControl(name, l=label, r=retain, li=True, vis=True, wp=widthProperty, iw=iw, ih=ih, mw=iw, mh=100)
    except BaseException:
        LOGGER.debug("Using legacy workspace control")
        control = mc.workspaceControl(name, l=label, r=retain, li=True, vis=True, wp=widthProperty, iw=iw, ih=ih, mw=iw)
    qtControl = omui.MQtUtil.findControl(control)
    dock = wrapInstance(int(qtControl), QtWidgets.QWidget)
    wrap.WIDGETS[name] = dock

    return dock


def curveControlWorkspace():
    if mc.workspaceControl(CURVE_CONTROL_NAME, q=1, ex=1):
        if MAYA_VER >= 2018:
            if not mc.workspaceControl(CURVE_CONTROL_NAME, q=1, vis=1):
                mc.workspaceControl(CURVE_CONTROL_NAME, e=1, rs=1)
                deferred(core.updateMainUI)()
            else:
                mc.workspaceControl(CURVE_CONTROL_NAME, e=1, vis=0)
        else:
            mc.workspaceControl(CURVE_CONTROL_NAME, e=1, fl=1)
            mc.deleteUI(CURVE_CONTROL_NAME)
    else:
        CurveControlUI()
        core.curveControlUI.updateUI()
        from . import main
        main.checkScriptJobs(CURVE_CONTROL_NAME)


class CurveControlUI(QtWidgets.QWidget):

    def __init__(self):
        parent = mayaWorkspaceControl(name=CURVE_CONTROL_NAME,
                                      label=CURVE_CONTROL_LABEL,
                                      retain=False, iw=350, ih=750, widthProperty="free")
        # Dockable Workspace Connection
        super(CurveControlUI, self).__init__(parent)
        self.ui()
        parent.layout().addWidget(self)

    def ui(self):
        # Layout
        mainLayout = QtWidgets.QVBoxLayout(self)
        mainLayout.setContentsMargins(*style.scale([2, 0, 2, 0]))

        self.scrollWidget = QtWidgets.QWidget()
        layout = QtWidgets.QVBoxLayout(self.scrollWidget)
        scrollArea = QtWidgets.QScrollArea()
        scrollArea.setWidget(self.scrollWidget)
        mainLayout.addWidget(scrollArea)

        # Layout Settings
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(style.scale(2))
        layout.setMargin(0)
        layout.setAlignment(QtCore.Qt.AlignTop)

        scrollArea.setFrameShape(QtWidgets.QFrame.NoFrame)
        scrollArea.setWidgetResizable(True)

        # Main Controls
        layout.addWidget(wrap.separator())

        # Layer Selector, Color Picker, Curve Name and Line Thickness
        with wrap.Row(layout, 'gsCurveControlHeader') as row:
            layerSelector = wrap.LayerSelector('gsLayerSelector', row.layout())
            layerSelector.setFixedWidth(style.scale(40))
            layerSelector.currentIndexChanged.connect(core.changeLayerViaOptionMenu)

            layerColorPicker = wrap.ColorPicker('gsColorPicker', row.layout())
            layerColorPicker.setContentsMargins(*style.scale([3, 3, 1, 3]))
            layerColorPicker.setFixedWidth(style.scale(20))
            layerColorPicker.connectCommand(core.toggleColor.changeLayerColor)

            curveColorPicker = wrap.ColorPicker('gsCurveColorPicker', row.layout())
            curveColorPicker.setContentsMargins(*style.scale([1, 3, 2, 3]))
            curveColorPicker.setFixedWidth(style.scale(20))
            curveColorPicker.connectCommand(core.toggleColor.changeCurveColor)

            selectedObjectName = wrap.LineEdit('selectedObjectName', row.layout())
            selectedObjectName.setPlaceholderText('Select Curve')
            selectedObjectName.returnPressed.connect(undo(core.renameSelected))

            lineThickness = wrap.FloatField('lineWidth', row.layout())
            lineThickness.setFixedWidth(style.scale(35))
            lineThickness.setRange(-1, 10)
            lineThickness.setValue(-1)
            lineThickness.setDragCommand(pa(core.sliders.curveControlSliderDrag, lineThickness))
            lineThickness.setReleaseCommand(core.sliders.release)

        layout.addWidget(wrap.separator())

        # Select Curves Prompt
        label = wrap.Label(layout, 'selectCurvesPrompt')
        label.setLabel('Select Compatible Curves')
        label.setFontSize(14)
        label.setVisible(False)

        # Axis Control
        with wrap.Column(layout, 'axisFrame') as column:
            label = wrap.Label(column.layout())
            label.setLabel('Axis Control')
            label.setFontSize(14)
            with wrap.Row(column.layout()) as row:
                WIDGETS['Axis'] = axisButtonGrp = QtWidgets.QButtonGroup()

                axisAuto = wrap.Button(row.layout(), 'gsBindAxisAuto')
                axisAuto.setLabel('Auto', lineHeight=100)
                axisAuto.setCheckable(True)
                axisAuto.setButtonStyle('small')
                axisAuto.setChecked(True)
                axisAuto.clicked.connect(pa(undo(core.applyAxis), 0))

                axisX = wrap.Button(row.layout(), 'gsBindAxisX')
                axisX.setLabel('X', lineHeight=100)
                axisX.setCheckable(True)
                axisX.setButtonStyle('small')
                axisX.clicked.connect(pa(undo(core.applyAxis), 1))

                axisY = wrap.Button(row.layout(), 'gsBindAxisY')
                axisY.setLabel('Y', lineHeight=100)
                axisY.setCheckable(True)
                axisY.setButtonStyle('small')
                axisY.clicked.connect(pa(undo(core.applyAxis), 2))

                axisZ = wrap.Button(row.layout(), 'gsBindAxisZ')
                axisZ.setLabel('Z', lineHeight=100)
                axisZ.setCheckable(True)
                axisZ.setButtonStyle('small')
                axisZ.clicked.connect(pa(undo(core.applyAxis), 3))

                axisButtonGrp.addButton(axisAuto, 0)
                axisButtonGrp.addButton(axisX, 1)
                axisButtonGrp.addButton(axisY, 2)
                axisButtonGrp.addButton(axisZ, 3)

                axisFlip = wrap.Button(row.layout(), 'AxisFlip')
                axisFlip.setLabel('Flip', lineHeight=100)
                axisFlip.setCheckable(True)
                axisFlip.setButtonStyle('small')
                axisFlip.clicked.connect(pa(undo(core.applyAxis), -1))

            column.layout().addWidget(wrap.separator())

            # Edit Original Objects
            with wrap.Row(column.layout(), margins=style.scale([0, 0, 0, 0]), objName='originalCurvesRow') as originalCurvesRow:
                selectOriginalCurves = wrap.Button(originalCurvesRow.layout(), 'selectOriginalCurves')
                selectOriginalCurves.setLabel('Select Original Curves', lineHeight=100)
                selectOriginalCurves.setButtonStyle('small-filled')
                selectOriginalCurves.clicked.connect(undo(core.curveControlUI.selectOriginalObjects))

                editOrigObj = wrap.Button(originalCurvesRow.layout(), 'editOrigObj')
                editOrigObj.setLabel('Edit Original Objects', lineHeight=100)
                editOrigObj.setCheckable(True)
                editOrigObj.setButtonStyle('small')
                editOrigObj.clicked.connect(undo(core.curveControlUI.editOriginalObjects))

            column.layout().addWidget(wrap.separator())

        # Length Divisions
        with wrap.Row(layout, margins=style.scale([0, 0, 3, 0])) as lengthDivisionsRow:
            lengthDivision = wrap.ControlSlider(objName='lengthDivisions', typ='int')
            lengthDivision.setLabel('L-Div')
            lengthDivision.setMinMax(2, 100)
            lengthDivision.setFieldMinMax(2, 10000)
            lengthDivision.setValue(2)
            lengthDivision.setDragCommand(pa(core.sliders.curveControlSliderDrag, lengthDivision))
            lengthDivision.setReleaseCommand(core.sliders.release)

            dynamicDivisionsToggle = wrap.Button(objName='dynamicDivisions')
            dynamicDivisionsToggle.setLabel('Auto')
            dynamicDivisionsToggle.setFixedWidth(style.scale(35))
            dynamicDivisionsToggle.setButtonStyle('small')
            dynamicDivisionsToggle.setCheckable(True)
            dynamicDivisionsToggle.clicked.connect(undo(core.toggleDynamicDivisions))

            lengthDivisionsRow.layout().addWidget(lengthDivision, 4)
            lengthDivisionsRow.layout().addWidget(dynamicDivisionsToggle, 1)

        # Width Divisions
        widthDivision = wrap.ControlSlider(layout, 'widthDivisions', 'int')
        widthDivision.setLabel('W-Div')
        widthDivision.setMinMax(2, 31)
        widthDivision.setFieldMinMax(2, 10000)
        widthDivision.setValue(2)
        widthDivision.setDragCommand(pa(core.sliders.curveControlSliderDrag, widthDivision))
        widthDivision.setReleaseCommand(core.sliders.release)

        # Orientation
        orientation = wrap.ControlSlider(layout, 'Orientation', 'float')
        orientation.setLabel('Orien')
        orientation.setMinMax(-180, 180)
        orientation.setFieldMinMax(-36000, 36000)
        orientation.setPrecision(1)
        orientation.setStep(0.5)
        orientation.setDragCommand(pa(core.sliders.curveControlSliderDrag, orientation))
        orientation.setReleaseCommand(core.sliders.release)

        # Twist
        twist = wrap.ControlSlider(layout, 'Twist', 'float')
        twist.setLabel('Twist')
        twist.setMinMax(-180, 180)
        twist.setFieldMinMax(-36000, 36000)
        twist.setPrecision(1)
        twist.setStep(0.5)
        twist.setDragCommand(pa(core.sliders.curveControlSliderDrag, twist))
        twist.setReleaseCommand(core.sliders.release)

        # Twist
        invTwist = wrap.ControlSlider(layout, 'invTwist', 'float')
        invTwist.setLabel('Inv.Twist')
        invTwist.setMinMax(-180, 180)
        invTwist.setFieldMinMax(-36000, 36000)
        invTwist.setPrecision(1)
        invTwist.setStep(0.5)
        invTwist.setDragCommand(pa(core.sliders.curveControlSliderDrag, invTwist))
        invTwist.setReleaseCommand(core.sliders.release)

        # Twist Curve Graph
        with wrap.Frame(layout, 'twistCurveFrame', margins=[0, 1, 0, 2]) as twistCurveFrame:
            twistCurveFrame.frameButton.setLabel('Twist Curve Graph')
            twistGraph = wrap.FallOffCurve(twistCurveFrame.getFrameLayout(), 'twistCurve')

            def twistGraphCommand(_):  # BUG: When undoing multiple edits, last edit is not reverted
                core.attributes.propagateGraphs(twistGraph)
                core.attributes.storeGraphs(twistGraph)
            twistGraph.changeCommand(twistGraphCommand)

            with wrap.Row(twistCurveFrame.getFrameLayout(), margins=style.scale([5, 0, 5, 2])) as row:
                row.setFixedHeight(style.BUTTON_HEIGHT)

                magnitude = wrap.FloatField('Magnitude', row.layout())
                magnitude.setFixedWidth(style.scale(45))
                magnitude.setRange(-99, 99)
                magnitude.setStep(0.01)
                magnitude.setPrecision(2)
                magnitude.setDragCommand(pa(core.sliders.curveControlSliderDrag, magnitude))
                magnitude.setReleaseCommand(core.sliders.release)

                resetButton = wrap.Button(row.layout(), 'gsTwistGraphResetButton')
                resetButton.setLabel('Reset Curve')

                def resetTwistCmd():
                    utils.resetSingleGraph('twist')
                    core.attributes.storeGraphs(twistGraph)
                resetButton.clicked.connect(undo(resetTwistCmd))

                popOutButton = wrap.Button(row.layout(), 'gsTwistGraphPopOut')
                popOutButton.setFixedWidth(style.scale(56))
                popOutButton.setLabel('^')
                popOutButton.clicked.connect(self.twistGraphPopOut)

        # Width
        width = wrap.ControlSlider(layout, 'Width', 'float')
        width.setLabel('Width')
        width.setMinMax(0.001, 5)
        width.setFieldMinMax(0.001, 1000)
        width.setPrecision(3)
        width.setStep(0.001)
        width.setValue(1)
        width.setDragCommand(pa(core.sliders.curveControlSliderDrag, width))
        width.setReleaseCommand(core.sliders.release)

        # Taper
        taper = wrap.ControlSlider(layout, 'Taper', 'float')
        taper.setLabel('Taper')
        taper.setMinMax(0.001, 3)
        taper.setFieldMinMax(0.001, 1000)
        taper.setPrecision(3)
        taper.setStep(0.001)
        taper.setValue(1)
        taper.setDragCommand(pa(core.sliders.curveControlSliderDrag, taper))
        taper.setReleaseCommand(core.sliders.release)

        # Width for Tubes
        with wrap.Row(layout, objName='widthComboSlider', spacing=0) as row:
            with wrap.Column(row.layout()) as column:
                widthX = wrap.ControlSlider(column.layout(), "WidthX", 'float')
                widthX.setLabel("WidthX")
                widthX.setMinMax(0.001, 5)
                widthX.setFieldMinMax(0.001, 1000)
                widthX.setPrecision(3)
                widthX.setStep(0.001)
                widthX.setValue(1)
                widthX.setDragCommand(pa(core.sliders.curveControlSliderDrag, widthX))
                widthX.setReleaseCommand(core.sliders.release)

                widthZ = wrap.ControlSlider(column.layout(), "WidthZ", 'float')
                widthZ.setLabel("WidthZ")
                widthZ.setMinMax(0.001, 5)
                widthZ.setFieldMinMax(0.001, 1000)
                widthZ.setPrecision(3)
                widthZ.setStep(0.001)
                widthZ.setValue(1)
                widthZ.setDragCommand(pa(core.sliders.curveControlSliderDrag, widthZ))
                widthZ.setReleaseCommand(core.sliders.release)

            lockButton = wrap.IconCheckButton(row.layout(), 'widthLockSwitch')
            lockButton.setIcons(utils.getFolder.icons() + 'sliderLock_en_reversed.png',
                                utils.getFolder.icons() + 'sliderLock_reversed.png')
            lockButton.setIconWidthHeight(10, 30)
            lockButton.setChecked(True)

        # Width Curve Graph
        with wrap.Frame(layout, 'widthCurveFrame', margins=[0, 1, 0, 2]) as widthCurveFrame:
            widthCurveFrame.frameButton.setLabel('Width Curve Graph')
            widthGraph = wrap.FallOffCurve(widthCurveFrame.getFrameLayout(), 'scaleCurve')

            def widthGraphCommand(_):  # BUG: When undoing multiple edits, last edit is not reverted
                core.attributes.propagateGraphs(widthGraph)
                core.attributes.storeGraphs(widthGraph)
            widthGraph.changeCommand(widthGraphCommand)

            with wrap.Row(widthCurveFrame.getFrameLayout(), margins=style.scale([5, 0, 5, 2])) as row:
                row.setFixedHeight(style.BUTTON_HEIGHT)

                resetButton = wrap.Button(row.layout(), 'gsWidthGraphResetButton')
                resetButton.setLabel('Reset Curve')

                def resetWidthCmd():
                    utils.resetSingleGraph('scale')
                    core.attributes.storeGraphs(widthGraph)
                resetButton.clicked.connect(undo(resetWidthCmd))

                popOutButton = wrap.Button(row.layout(), 'gsWidthGraphPopOut')
                popOutButton.setFixedWidth(style.scale(56))
                popOutButton.setLabel('^')
                popOutButton.clicked.connect(self.widthGraphPopOut)

        # Length Unlock Switch
        lengthUnlock = wrap.Button(layout, 'LengthLock')
        lengthUnlock.setLabel('Length Unlock', lineHeight=100)
        lengthUnlock.setCheckable(True)
        lengthUnlock.setButtonStyle('small')
        lengthUnlock.setFixedWidth(style.scale(106))
        lengthUnlock.clicked.connect(pa(core.curveControlCheckBoxes, 2))

        # Length
        length = wrap.ControlSlider(layout, 'Length', 'float')
        length.setLabel('Length')
        length.setMinMax(0.001, 3)
        length.setFieldMinMax(-1000, 1000)
        length.setPrecision(3)
        length.setStep(0.001)
        length.setValue(1)
        length.setDragCommand(pa(core.sliders.curveControlSliderDrag, length))
        length.setReleaseCommand(core.sliders.release)

        # TODO: Offset card from curve attribute
        # Offset
        offset = wrap.ControlSlider(layout, 'Offset', 'float')
        offset.setLabel('Offset')
        offset.setMinMax(-1, 1)
        offset.setFieldMinMax(-30, 30)
        offset.setStep(0.001)
        offset.setValue(1)
        offset.setDragCommand(pa(core.sliders.curveControlSliderDrag, offset))
        offset.setReleaseCommand(core.sliders.release)

        # Profile
        profile = wrap.ControlSlider(layout, 'Profile', 'float')
        profile.setLabel('Profile')
        profile.setMinMax(-2, 2)
        profile.setFieldMinMax(-1000, 1000)
        profile.setStep(0.001)
        profile.setDragCommand(pa(core.sliders.curveControlSliderDrag, profile))
        profile.setReleaseCommand(core.sliders.release)

        # Profile Curve Graph
        with wrap.Frame(layout, 'profileCurveGraph', margins=[0, 1, 0, 2]) as profileCurveFrame:
            profileCurveFrame.frameButton.setLabel('Profile Curve Graph')
            profileGraph = wrap.FallOffCurve(profileCurveFrame.getFrameLayout(), 'profileCurve', attr=False)

            def changeCommand(value):
                core.updateLattice(value)
                core.equalizeProfileCurve()
                core.attributes.storeGraphs(profileGraph)
            profileGraph.changeCommand(changeCommand)

            profileSmoothingSlider = wrap.ControlSlider(profileCurveFrame.getFrameLayout(), 'profileSmoothing', 'int')
            profileSmoothingSlider.setLabel('Smoothing')
            profileSmoothingSlider.setMinMax(2, 30)
            profileSmoothingSlider.setValue(2)
            profileSmoothingSlider.setDragCommand(pa(core.sliders.curveControlSliderDrag, profileSmoothingSlider))
            profileSmoothingSlider.setReleaseCommand(core.sliders.release)

            with wrap.Row(profileCurveFrame.getFrameLayout(), margins=style.scale([5, 0, 5, 2])) as row:
                row.setFixedHeight(style.BUTTON_HEIGHT)

                profileMagnitude = wrap.FloatField('profileMagnitude', row.layout())
                profileMagnitude.setFixedWidth(style.scale(45))
                profileMagnitude.setValue(1)
                profileMagnitude.setRange(-2, 2)
                profileMagnitude.setStep(0.01)
                profileMagnitude.setPrecision(2)
                profileMagnitude.setDragCommand(pa(core.sliders.curveControlSliderDrag, profileMagnitude))
                profileMagnitude.setReleaseCommand(core.sliders.release)

                with wrap.Column(row.layout(), spacing=0) as eqColumn:
                    eqColumn.setFixedHeight(style.scale(24))
                    with wrap.Row(eqColumn.layout(), spacing=0) as eqRow:
                        def toggleEq():
                            WIDGETS['equalizeCurveButton'].setDisabled(
                                WIDGETS['autoEqualizeSwitchOn'].isChecked()
                            )
                        autoEqualizeGroup = QtWidgets.QButtonGroup(eqRow.layout())
                        autoEqualizeGroup.buttonClicked.connect(toggleEq)
                        autoEqualizeGroup.buttonClicked.connect(undo(core.equalizeProfileCurve))

                        autoEqualize = wrap.Button(eqRow.layout(), 'autoEqualizeSwitchOn')
                        autoEqualize.setLabel('Auto', lineHeight=100)
                        autoEqualize.setLabelStyle('small')
                        autoEqualize.setButtonStyle('small-compound-top-left')
                        autoEqualize.setCheckable(True)
                        autoEqualize.setChecked(True)

                        autoEqualizeOff = wrap.Button(eqRow.layout(), 'autoEqualizeSwitchOff')
                        autoEqualizeOff.setLabel('Manual', lineHeight=100)
                        autoEqualizeOff.setLabelStyle('small')
                        autoEqualizeOff.setButtonStyle('small-compound-top-right')
                        autoEqualizeOff.setCheckable(True)

                        autoEqualizeGroup.addButton(autoEqualize)
                        autoEqualizeGroup.addButton(autoEqualizeOff)

                    equalizeProfileCurve = wrap.Button(eqColumn.layout(), 'equalizeCurveButton')
                    equalizeProfileCurve.setLabel('Equalize Curve', lineHeight=100)
                    equalizeProfileCurve.setLabelStyle('small')
                    equalizeProfileCurve.setButtonStyle('small-filled-compound-bottom')
                    equalizeProfileCurve.setDisabled(True)
                    equalizeProfileCurve.clicked.connect(pa(undo(core.equalizeProfileCurve), True))

                resetButton = wrap.Button(row.layout(), 'gsResetProfileGraphButton')
                resetButton.setLabel('Reset Curve')

                def resetButtonClicked(*_):
                    core.resetProfileCurve()
                    core.attributes.storeGraphs(profileGraph)
                resetButton.clicked.connect(undo(resetButtonClicked))

                popOutButton = wrap.Button(row.layout(), 'gsProfileGraphPopOut')
                popOutButton.setFixedWidth(style.scale(56))
                popOutButton.setLabel('^')
                popOutButton.clicked.connect(self.profileGraphPopOut)
        # Normals
        normals = wrap.ControlSlider(layout, 'surfaceNormals', 'float')
        normals.setLabel('Normals')
        normals.setMinMax(0, 180)
        normals.setPrecision(1)
        normals.setValue(180)
        normals.setDragCommand(pa(core.sliders.curveControlSliderDrag, normals))
        normals.setReleaseCommand(core.sliders.release)

        # Reverse Normals Switch
        reverseNormals = wrap.Button(layout, 'reverseNormals')
        reverseNormals.setLabel('Reverse Normals', lineHeight=100)
        reverseNormals.setCheckable(True)
        reverseNormals.setButtonStyle('small')
        reverseNormals.setFixedWidth(style.scale(106))
        reverseNormals.clicked.connect(pa(core.curveControlCheckBoxes, 0))

        with wrap.Frame(layout, 'otherFrame', label='Other', margins=[2, 2, 2, 2]) as refineFrame:
            samplingAccuracy = wrap.ControlSlider(parent=refineFrame.getFrameLayout(), objName='samplingAccuracy', typ='float')
            samplingAccuracy.setLabel('SamplAcc')
            samplingAccuracy.setMinMax(0.001, 2)
            samplingAccuracy.setStep(0.01)
            samplingAccuracy.setValue(0.33)
            samplingAccuracy.setDragCommand(pa(core.sliders.curveControlSliderDrag, samplingAccuracy))
            samplingAccuracy.setReleaseCommand(core.sliders.release)
            # Refine
            with wrap.Row(refineFrame.getFrameLayout(), margins=style.scale([0, 0, 3, 0])) as curveRefineRow:
                refine = wrap.ControlSlider(layout, 'curveRefine', 'int')
                refine.setLabel('Refine')
                refine.setMinMax(0, 100)
                refine.setFieldMinMax(0, 10000)
                refine.setValue(20)
                refine.setDragCommand(pa(core.sliders.curveControlSliderDrag, refine))
                refine.setReleaseCommand(core.sliders.release)

                autoRefineToggle = wrap.Button(objName='autoRefine')
                autoRefineToggle.setLabel('Auto')
                autoRefineToggle.setFixedWidth(style.scale(35))
                autoRefineToggle.setButtonStyle('small')
                autoRefineToggle.setCheckable(True)
                autoRefineToggle.clicked.connect(undo(core.toggleAutoRefine))

                curveRefineRow.layout().addWidget(refine, 4)
                curveRefineRow.layout().addWidget(autoRefineToggle, 1)

            # Smooth
            smooth = wrap.ControlSlider(refineFrame.getFrameLayout(), 'curveSmooth', 'float')
            smooth.setLabel('Smooth')
            smooth.setMinMax(0, 10)
            smooth.setDragCommand(pa(core.sliders.curveControlSliderDrag, smooth))
            smooth.setReleaseCommand(core.sliders.release)

        with wrap.Frame(layout, 'orientToNormalsFrame', label='Orient to Normals',
                        margins=[2, 2, 2, 2]) as orientFrame:

            orientFrame.setVisible(False)

            def selectMesh():
                sel = mc.filterExpand(mc.ls(sl=1, l=1), sm=12)
                if not sel:
                    sel = mc.ls(hl=1, o=1, l=1)
                if not sel:
                    MESSAGE.warningInView('Select compatible mesh.')
                    return
                self.meshName.setText(sel[0])

            with wrap.Row(orientFrame.getFrameLayout()) as row:
                selectMeshBtn = wrap.Button(row.layout(), "gsOrientToNormalsSelectTarget")
                selectMeshBtn.setFixedWidth(style.scale(100))
                selectMeshBtn.setLabel('Select Target')
                selectMeshBtn.clicked.connect(selectMesh)

                self.meshName = wrap.LineEdit('gsOrientMeshName', row.layout())
                self.meshName.setPlaceholderText('Select or Type Target Mesh')
                self.meshName.setClearButtonEnabled(True)

            orientFrame.getFrameLayout().addWidget(wrap.separator())

            with wrap.Row(orientFrame.getFrameLayout()) as row:
                iterationsSlider = wrap.ControlSlider(row.layout(), 'gsIterationsSlider', 'int')
                iterationsSlider.setMinMax(1, 100)
                iterationsSlider.setValue(10)
                iterationsSlider.setLabel('Iterations')

                autoRefreshButton = wrap.Button(row.layout(), 'orientRefreshViewport')
                autoRefreshButton.setButtonStyle('small')
                autoRefreshButton.setCheckable(True)
                autoRefreshButton.setChecked(True)
                autoRefreshButton.setWidthHeight(w=style.scale(50))
                autoRefreshButton.setLabel('Refresh VP', lineHeight=100)

            with wrap.Row(orientFrame.getFrameLayout()) as row:
                minAngleSlider = wrap.ControlSlider(row.layout(), 'gsMinimumAngle', 'float')
                minAngleSlider.setMinMax(0.1, 90)
                minAngleSlider.setValue(1)
                minAngleSlider.setLabel('Min Angle')

            orientFrame.getFrameLayout().addWidget(wrap.separator())

            with wrap.Row(orientFrame.getFrameLayout()) as row:
                orient = wrap.Button(row.layout(), 'gsOrientToNormals')
                orient.setLabel('Orient')
                orient.clicked.connect(undo(core.orientToFaceNormals))

        with wrap.Frame(layout, 'solidifyFrame', label='Solidify Controls', margins=[2, 2, 2, 2]) as solidifyFrame:
            # Solidify Activate
            solidify = wrap.Button(solidifyFrame.getFrameLayout(), 'solidify')
            solidify.setLabel('Solidify', lineHeight=100)
            solidify.setCheckable(True)
            solidify.setButtonStyle('small')
            solidify.setFixedWidth(style.scale(106))
            solidify.clicked.connect(pa(core.curveControlCheckBoxes, 1))

            # Thickness
            thickness = wrap.ControlSlider(solidifyFrame.getFrameLayout(), 'solidifyThickness', 'float')
            thickness.setLabel('Thickness')
            thickness.setMinMax(0.001, 5)
            thickness.setFieldMinMax(-100, 100)
            thickness.setValue(0.25)
            thickness.setStep(0.01)
            thickness.setDragCommand(pa(core.sliders.curveControlSliderDrag, thickness))
            thickness.setReleaseCommand(core.sliders.release)

            # Divisions
            divisions = wrap.ControlSlider(solidifyFrame.getFrameLayout(), 'solidifyDivisions', 'int')
            divisions.setLabel('Divisions')
            divisions.setMinMax(0, 10)
            divisions.setFieldMinMax(0, 100)
            divisions.setDragCommand(pa(core.sliders.curveControlSliderDrag, divisions))
            divisions.setReleaseCommand(core.sliders.release)

            # ScaleX
            solidifyScaleX = wrap.ControlSlider(solidifyFrame.getFrameLayout(), 'solidifyScaleX', 'float')
            solidifyScaleX.setLabel('ScaleX')
            solidifyScaleX.setMinMax(-10, 10)
            solidifyScaleX.setFieldMinMax(-100, 100)
            solidifyScaleX.setDragCommand(pa(core.sliders.curveControlSliderDrag, solidifyScaleX))
            solidifyScaleX.setReleaseCommand(core.sliders.release)

            # ScaleY
            solidifyScaleY = wrap.ControlSlider(solidifyFrame.getFrameLayout(), 'solidifyScaleY', 'float')
            solidifyScaleY.setLabel('ScaleY')
            solidifyScaleY.setMinMax(-10, 10)
            solidifyScaleY.setFieldMinMax(-100, 100)
            solidifyScaleY.setDragCommand(pa(core.sliders.curveControlSliderDrag, solidifyScaleY))
            solidifyScaleY.setReleaseCommand(core.sliders.release)

            # Offset
            offset = wrap.ControlSlider(solidifyFrame.getFrameLayout(), 'solidifyOffset', 'float')
            offset.setLabel('Offset')
            offset.setMinMax(-10, 10)
            offset.setFieldMinMax(-100, 100)
            offset.setDragCommand(pa(core.sliders.curveControlSliderDrag, offset))
            offset.setReleaseCommand(core.sliders.release)

            # Normals
            solidifyNormals = wrap.ControlSlider(solidifyFrame.getFrameLayout(), 'solidifyNormals', 'float')
            solidifyNormals.setLabel('SNormals')
            solidifyNormals.setMinMax(0, 180)
            solidifyNormals.setPrecision(1)
            solidifyNormals.setValue(180)
            solidifyNormals.setDragCommand(pa(core.sliders.curveControlSliderDrag, solidifyNormals))
            solidifyNormals.setReleaseCommand(core.sliders.release)

        with wrap.Frame(layout, 'UVFrame', label='UV Controls', margins=[2, 2, 2, 2]) as UVFrame:
            flipUV = wrap.Button(UVFrame.getFrameLayout(), 'flipUV')
            flipUV.setLabel('H-Flip UV', lineHeight=100)
            flipUV.setCheckable(True)
            flipUV.setButtonStyle('small')
            flipUV.setFixedWidth(style.scale(106))
            flipUV.clicked.connect(pa(undo(core.curveControlCheckBoxes), 3))

            # Move U
            moveU = wrap.ControlSlider(UVFrame.getFrameLayout(), 'moveU', 'float')
            moveU.setLabel('MoveU')
            moveU.setMinMax(-0.5, 0.5)
            moveU.setStep(0.001)
            moveU.setFieldMinMax(-100, 100)
            moveU.setDragCommand(pa(core.sliders.curveControlSliderDrag, moveU))
            moveU.setReleaseCommand(core.sliders.release)

            # Move V
            moveV = wrap.ControlSlider(UVFrame.getFrameLayout(), 'moveV', 'float')
            moveV.setLabel('MoveV')
            moveV.setMinMax(-0.5, 0.5)
            moveV.setStep(0.001)
            moveV.setFieldMinMax(-100, 100)
            moveV.setDragCommand(pa(core.sliders.curveControlSliderDrag, moveV))
            moveV.setReleaseCommand(core.sliders.release)

            # Scale U
            scaleU = wrap.ControlSlider(UVFrame.getFrameLayout(), 'scaleU', 'float')
            scaleU.setLabel('ScaleU')
            scaleU.setMinMax(0.001, 1.999)
            scaleU.setFieldMinMax(0, 100)
            scaleU.setStep(0.001)
            scaleU.setValue(1)
            scaleU.setDragCommand(pa(core.sliders.curveControlSliderDrag, scaleU))
            scaleU.setReleaseCommand(core.sliders.release)

            # Scale V
            scaleV = wrap.ControlSlider(UVFrame.getFrameLayout(), 'scaleV', 'float')
            scaleV.setLabel('ScaleV')
            scaleV.setMinMax(0.001, 1.999)
            scaleV.setFieldMinMax(0, 100)
            scaleV.setStep(0.001)
            scaleV.setValue(1)
            scaleV.setDragCommand(pa(core.sliders.curveControlSliderDrag, scaleV))
            scaleV.setReleaseCommand(core.sliders.release)

            # Rotate UV
            rotateUV = wrap.ControlSlider(UVFrame.getFrameLayout(), 'rotateUV', 'float')
            rotateUV.setLabel('RotUV')
            rotateUV.setMinMax(-180, 180)
            rotateUV.setFieldMinMax(-3600, 3600)
            rotateUV.setPrecision(2)
            rotateUV.setDragCommand(pa(core.sliders.curveControlSliderDrag, rotateUV))
            rotateUV.setReleaseCommand(core.sliders.release)

            # Rotate UV Root (Legacy)
            rotateUVRoot = wrap.ControlSlider(UVFrame.getFrameLayout(), 'rotateRootUV', 'float')
            rotateUVRoot.setLabel('RotRtUV')
            rotateUVRoot.setMinMax(-180, 180)
            rotateUVRoot.setFieldMinMax(-3600, 3600)
            rotateUVRoot.setPrecision(2)
            rotateUVRoot.setDragCommand(pa(core.sliders.curveControlSliderDrag, rotateUVRoot))
            rotateUVRoot.setReleaseCommand(core.sliders.release)
            rotateUVRoot.setVisible(False)

            # Rotate Tip UV (Legacy)
            rotateUVTip = wrap.ControlSlider(UVFrame.getFrameLayout(), 'rotateTipUV', 'float')
            rotateUVTip.setLabel('RotTipUV')
            rotateUVTip.setMinMax(-180, 180)
            rotateUVTip.setFieldMinMax(-3600, 3600)
            rotateUVTip.setPrecision(2)
            rotateUVTip.setDragCommand(pa(core.sliders.curveControlSliderDrag, rotateUVTip))
            rotateUVTip.setReleaseCommand(core.sliders.release)
            rotateUVRoot.setVisible(False)

            # UV Bug Message
            if MAYA_VER in [2020, 2022] and not mc.optionVar(q='GSCT_UVBugMessageDismissed'):
                with wrap.Row(UVFrame.getFrameLayout()) as row:
                    label = wrap.Label(row.layout())
                    label.setLabel('<p style="color:#FF542F">How To Fix Maya 2020-2022 UV Bug:</p>')

                    linkButton = wrap.Button(row.layout())
                    linkButton.setLabel('Open Fix')
                    linkButton.setButtonStyle('small-filled')
                    linkButton.clicked.connect(lambda: utils.openLink(
                        'https://gs-curvetools.readthedocs.io/en/latest/faq.html#maya-2020-2022-and-broken-uvs'))

                    dismissMessage = wrap.Button(row.layout())
                    dismissMessage.setLabel('Dismiss')
                    dismissMessage.setButtonStyle('small-filled')
                    dismissMessage.clicked.connect(lambda: row.setHidden(True))
                    dismissMessage.clicked.connect(lambda: mc.optionVar(iv=['GSCT_UVBugMessageDismissed', 1]))

        # Advanced Visibility Frame
        with wrap.Frame(layout, 'advancedVisibilityFrame', label='Advanced Visibility',
                        margins=style.scale([3, 2, 3, 2]), spacing=style.scale(3)) as visibilityFrame:
            with wrap.Row(visibilityFrame.getFrameLayout()) as row:

                geometryHighlight = wrap.Button(row.layout(), 'geometryHighlight')
                geometryHighlight.setLabel('Geometry Highlight', lineHeight=100)
                geometryHighlight.setCheckable(True)
                geometryHighlight.setChecked(bool(mc.optionVar(q="GSCT_GeometryHighlightEnabled")))
                geometryHighlight.setButtonStyle('small')

                geometryHighlight.clicked.connect(noUndo(core.advancedVisibility.geometryHighlightCommand))

                curveHighlight = wrap.Button(row.layout(), 'curveHighlight')
                curveHighlight.setLabel('Curve Highlight', lineHeight=100)
                curveHighlight.setCheckable(True)
                curveHighlight.setButtonStyle('small')
                curveHighlight.setChecked(False)
                curveHighlight.clicked.connect(undo(core.advancedVisibility.toggleCurveHighlightFromUI))

            visibilityFrame.getFrameLayout().addWidget(wrap.separator())

            def sliderChangeCommand(*_):
                core.advancedVisibility.applySettingsToNode()
                core.advancedVisibility.saveSettingsFromUI()

            with wrap.Column(visibilityFrame.getFrameLayout(), objName='gsCurveHighlightFrame', spacing=style.scale(4)) as column:
                column.setEnabled(False)  # Disable immediately. We are going to check its state later.

                # CV Size
                with wrap.Row(column.layout(), spacing=4) as row:
                    CVsizeLabel = wrap.Label()
                    CVsizeLabel.setLabel("CV Size:")
                    CVsizeLabel.setFixedWidth(style.scale(100))
                    CVsizeLabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

                    pointSizeSlider = wrap.mayaSlider(
                        mc.floatSliderGrp(
                            'gsPointSizeSlider',
                            f=1, adj=2, w=1, cw=[1, 45], min=1, max=100, v=10,
                            dc=lambda _: noUndo(core.advancedVisibility.applySettingsToNode)(),
                            cc=noUndo(sliderChangeCommand),
                        )
                    )
                    WIDGETS['gsPointSizeSlider'] = pointSizeSlider

                    row.layout().addWidget(CVsizeLabel, 0)
                    row.layout().addWidget(pointSizeSlider, 1)

                # Selected Color
                with wrap.Row(column.layout(), spacing=style.scale(4)) as row:
                    selectedColorLabel = wrap.Label()
                    selectedColorLabel.setLabel("Selected Color:")
                    selectedColorLabel.setFixedWidth(style.scale(100))
                    selectedColorLabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

                    selectedColorPicker = wrap.ColorPicker("gsSelectedCVColor")
                    selectedColorPicker.connectDragCommand(lambda *_: noUndo(core.advancedVisibility.applySettingsToNode)())
                    selectedColorPicker.connectCommand(noUndo(sliderChangeCommand))

                    selectedAlphaValue = wrap.FloatField("gsSelectedCVAlpha")
                    selectedAlphaValue.setFixedWidth(style.scale(45))
                    selectedAlphaValue.setValue(1.0)
                    selectedAlphaValue.setRange(0, 1)
                    selectedAlphaValue.setStep(0.01)
                    selectedAlphaValue.setPrecision(2)
                    selectedAlphaValue.setDragCommand(lambda *_: noUndo(core.advancedVisibility.applySettingsToNode)())
                    selectedAlphaValue.setReleaseCommand(noUndo(sliderChangeCommand))

                    row.layout().addWidget(selectedColorLabel, 0)
                    row.layout().addWidget(selectedColorPicker, 1)
                    row.layout().addWidget(selectedAlphaValue, 0)

                # Deselected Color
                with wrap.Row(column.layout(), spacing=style.scale(4)) as row:
                    deselectedColorLabel = wrap.Label()
                    deselectedColorLabel.setLabel("Deselected Color:")
                    deselectedColorLabel.setFixedWidth(style.scale(100))
                    deselectedColorLabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

                    deselectedColorPicker = wrap.ColorPicker("gsDeselectedCVColor")
                    deselectedColorPicker.connectDragCommand(lambda *_: noUndo(core.advancedVisibility.applySettingsToNode)())
                    deselectedColorPicker.connectCommand(noUndo(sliderChangeCommand))

                    deselectedAlphaValue = wrap.FloatField("gsDeselectedCVAlpha")
                    deselectedAlphaValue.setFixedWidth(style.scale(45))
                    deselectedAlphaValue.setValue(1)
                    deselectedAlphaValue.setRange(0, 1)
                    deselectedAlphaValue.setStep(0.01)
                    deselectedAlphaValue.setPrecision(2)
                    deselectedAlphaValue.setDragCommand(lambda *_: noUndo(core.advancedVisibility.applySettingsToNode)())
                    deselectedAlphaValue.setReleaseCommand(noUndo(sliderChangeCommand))

                    row.layout().addWidget(deselectedColorLabel, 0)
                    row.layout().addWidget(deselectedColorPicker, 1)
                    row.layout().addWidget(deselectedAlphaValue, 1)

                column.layout().addWidget(wrap.separator())

                # Curve Visibility
                curveVisibility = wrap.Button(column.layout(), 'curveVisibility')
                curveVisibility.setLabel('Curve Visibility', lineHeight=100)
                curveVisibility.setCheckable(True)
                curveVisibility.setButtonStyle('small')
                curveVisibility.setChecked(True)
                curveVisibility.clicked.connect(noUndo(sliderChangeCommand))

                with wrap.Row(column.layout(), spacing=4) as row:
                    curveWidthLabel = wrap.Label()
                    curveWidthLabel.setLabel("Curve Width:")
                    curveWidthLabel.setFixedWidth(style.scale(100))
                    curveWidthLabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

                    curveWidthSlider = wrap.mayaSlider(
                        mc.floatSliderGrp(
                            'gsCurveWidthSlider',
                            f=1, adj=2, w=1, cw=[1, 45], min=1, max=100, v=4,
                            dc=lambda _: noUndo(core.advancedVisibility.applySettingsToNode)(),
                            cc=noUndo(sliderChangeCommand),
                        ),
                    )
                    WIDGETS['gsCurveWidthSlider'] = curveWidthSlider

                    row.layout().addWidget(curveWidthLabel, 0)
                    row.layout().addWidget(curveWidthSlider, 1)

                with wrap.Row(column.layout(), spacing=style.scale(4)) as row:
                    curveHighlightColorLabel = wrap.Label()
                    curveHighlightColorLabel.setLabel("Curve Color:")
                    curveHighlightColorLabel.setFixedWidth(style.scale(100))
                    curveHighlightColorLabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

                    curveHighlightColor = wrap.ColorPicker("gsCurveHighlightColor")
                    curveHighlightColor.connectDragCommand(lambda *_: noUndo(core.advancedVisibility.applySettingsToNode)())
                    curveHighlightColor.connectCommand(noUndo(sliderChangeCommand))

                    curveHighlightAlpha = wrap.FloatField("gsCurveHighlightAlpha")
                    curveHighlightAlpha.setFixedWidth(style.scale(45))
                    curveHighlightAlpha.setValue(1.0)
                    curveHighlightAlpha.setRange(0, 1)
                    curveHighlightAlpha.setStep(0.01)
                    curveHighlightAlpha.setPrecision(2)
                    curveHighlightAlpha.setDragCommand(lambda *_: noUndo(core.advancedVisibility.applySettingsToNode)())
                    curveHighlightAlpha.setReleaseCommand(noUndo(sliderChangeCommand))

                    row.layout().addWidget(curveHighlightColorLabel, 0)
                    row.layout().addWidget(curveHighlightColor, 1)
                    row.layout().addWidget(curveHighlightAlpha, 1)

                column.layout().addWidget(wrap.separator())

                # Hull Visibility
                hullVisibility = wrap.Button(column.layout(), 'hullVisibility')
                hullVisibility.setLabel('Hull Visibility', lineHeight=100)
                hullVisibility.setCheckable(True)
                hullVisibility.setButtonStyle('small')
                hullVisibility.clicked.connect(noUndo(sliderChangeCommand))

                with wrap.Row(column.layout(), spacing=4) as row:
                    hullWidthLabel = wrap.Label()
                    hullWidthLabel.setLabel("Hull Width:")
                    hullWidthLabel.setFixedWidth(style.scale(100))
                    hullWidthLabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

                    hullWidthSlider = wrap.mayaSlider(
                        mc.floatSliderGrp(
                            'gsHullWidthSlider',
                            f=1, adj=2, w=1, cw=[1, 45], min=1, max=100, v=3,
                            dc=lambda _: noUndo(core.advancedVisibility.applySettingsToNode)(),
                            cc=noUndo(sliderChangeCommand),
                        )
                    )
                    WIDGETS['gsHullWidthSlider'] = hullWidthSlider

                    row.layout().addWidget(hullWidthLabel, 0)
                    row.layout().addWidget(hullWidthSlider, 1)

                with wrap.Row(column.layout(), spacing=style.scale(4)) as row:
                    hullColorLabel = wrap.Label()
                    hullColorLabel.setLabel("Hull Color:")
                    hullColorLabel.setFixedWidth(style.scale(100))
                    hullColorLabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

                    hullColor = wrap.ColorPicker("gsHullHighlightColor")
                    hullColor.connectDragCommand(lambda *_: noUndo(core.advancedVisibility.applySettingsToNode)())
                    hullColor.connectCommand(noUndo(sliderChangeCommand))

                    hullAlpha = wrap.FloatField("gsHullHighlightAlpha")
                    hullAlpha.setFixedWidth(style.scale(45))
                    hullAlpha.setValue(1.0)
                    hullAlpha.setRange(0, 1)
                    hullAlpha.setStep(0.01)
                    hullAlpha.setPrecision(2)
                    hullAlpha.setDragCommand(lambda *_: noUndo(core.advancedVisibility.applySettingsToNode)())
                    hullAlpha.setReleaseCommand(noUndo(sliderChangeCommand))

                    row.layout().addWidget(hullColorLabel, 0)
                    row.layout().addWidget(hullColor, 1)
                    row.layout().addWidget(hullAlpha, 1)

                column.layout().addWidget(wrap.separator())

                with wrap.Frame(column.layout(), 'advancedVisibilityFrame', label='Other Options:',
                                margins=style.scale([3, 2, 3, 2]), spacing=style.scale(3)) as optionsFrame:
                    with wrap.Row(optionsFrame.getFrameLayout()) as row:
                        lazyUpdate = wrap.Button(row.layout(), 'lazyUpdate')
                        lazyUpdate.setLabel("Lazy Update", lineHeight=100)
                        lazyUpdate.setCheckable(True)
                        lazyUpdate.setButtonStyle('small')
                        lazyUpdate.clicked.connect(noUndo(sliderChangeCommand))

                        alwaysOnTop = wrap.Button(row.layout(), 'alwaysOnTop')
                        alwaysOnTop.setLabel("Always On Top", lineHeight=100)
                        alwaysOnTop.setCheckable(True)
                        alwaysOnTop.setButtonStyle('small')
                        alwaysOnTop.setChecked(True)
                        alwaysOnTop.clicked.connect(noUndo(sliderChangeCommand))

                    optionsFrame.getFrameLayout().addWidget(wrap.separator())

                    experimentalLabel = wrap.Label(optionsFrame.getFrameLayout())
                    experimentalLabel.setLabel("Distance Colors:")

                    with wrap.Row(optionsFrame.getFrameLayout()) as row:
                        curveDistanceColor = wrap.Button(row.layout(), 'curveDistanceColor')
                        curveDistanceColor.setLabel("Curve", lineHeight=100)
                        curveDistanceColor.setCheckable(True)
                        curveDistanceColor.setButtonStyle('small')
                        curveDistanceColor.setChecked(True)
                        curveDistanceColor.clicked.connect(noUndo(sliderChangeCommand))

                        cvDistanceColor = wrap.Button(row.layout(), 'cvDistanceColor')
                        cvDistanceColor.setLabel("CV", lineHeight=100)
                        cvDistanceColor.setCheckable(True)
                        cvDistanceColor.setButtonStyle('small')
                        cvDistanceColor.setChecked(True)
                        cvDistanceColor.clicked.connect(noUndo(sliderChangeCommand))

                        hullDistanceColor = wrap.Button(row.layout(), 'hullDistanceColor')
                        hullDistanceColor.setLabel("Hull", lineHeight=100)
                        hullDistanceColor.setCheckable(True)
                        hullDistanceColor.setButtonStyle('small')
                        hullDistanceColor.setChecked(True)
                        hullDistanceColor.clicked.connect(noUndo(sliderChangeCommand))

                    with wrap.Row(optionsFrame.getFrameLayout()) as row:
                        distanceColorMinLabel = wrap.Label()
                        distanceColorMinLabel.setLabel("Color Min:")
                        distanceColorMinLabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

                        distanceColorMinInput = wrap.FloatField("gsDistanceColorMinValue")
                        distanceColorMinInput.setValue(0.25)
                        distanceColorMinInput.setRange(0.01, 1)
                        distanceColorMinInput.setStep(0.01)
                        distanceColorMinInput.setPrecision(2)
                        distanceColorMinInput.setDragCommand(lambda *_: noUndo(core.advancedVisibility.applySettingsToNode)())
                        distanceColorMinInput.setReleaseCommand(noUndo(sliderChangeCommand))

                        distanceColorMaxLabel = wrap.Label()
                        distanceColorMaxLabel.setLabel("Color Max:")
                        distanceColorMaxLabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

                        distanceColorMaxInput = wrap.FloatField("gsDistanceColorMaxValue")
                        distanceColorMaxInput.setValue(1.0)
                        distanceColorMaxInput.setRange(0.01, 1)
                        distanceColorMaxInput.setStep(0.01)
                        distanceColorMaxInput.setPrecision(2)
                        distanceColorMaxInput.setDragCommand(lambda *_: noUndo(core.advancedVisibility.applySettingsToNode)())
                        distanceColorMaxInput.setReleaseCommand(noUndo(sliderChangeCommand))

                        row.layout().addWidget(distanceColorMinLabel, 1)
                        row.layout().addWidget(distanceColorMinInput, 1)
                        row.layout().addWidget(distanceColorMaxLabel, 1)
                        row.layout().addWidget(distanceColorMaxInput, 1)

                    optionsFrame.getFrameLayout().addWidget(wrap.separator())

                    experimentalLabel = wrap.Label(optionsFrame.getFrameLayout())
                    experimentalLabel.setLabel("Experimental (possibly slow):")

                    CVocclusion = wrap.Button(optionsFrame.getFrameLayout(), 'CVocclusion')
                    CVocclusion.setLabel("Enable CV Occlusion", lineHeight=100)
                    CVocclusion.setCheckable(True)
                    CVocclusion.setButtonStyle('small')
                    CVocclusion.clicked.connect(noUndo(sliderChangeCommand))

                    with wrap.Row(optionsFrame.getFrameLayout(), spacing=style.scale(4)) as row:
                        selectOccluderButton = wrap.Button(row.layout(), "gsSelectOccluderButton")
                        selectOccluderButton.setFixedWidth(style.scale(100))
                        selectOccluderButton.setLabel('Select Occluder')
                        selectOccluderButton.clicked.connect(noUndo(core.advancedVisibility.selectOccluderFromScene))

                        occluderMeshName = wrap.LineEdit('gsOccluderMeshName', row.layout())
                        occluderMeshName.setPlaceholderText('Select or Type Occluder Mesh Name')
                        occluderMeshName.setClearButtonEnabled(True)
                        occluderMeshName.editingFinished.connect(noUndo(sliderChangeCommand))
        core.advancedVisibility.loadSettingsFromOptionVar()
        tooltips.toggleCustomTooltipsCurveControl(core.getOption('enableTooltips'))

        layout.addWidget(wrap.separator())

        resetButton = wrap.Button(layout, 'resetControlSliders')
        resetButton.setLabel('Reset Sliders Range')
        resetButton.clicked.connect(core.resetControlSliders)

    def twistGraphPopOut(self):
        name = "GSCT_TwistGraphPopOut"
        if mc.workspaceControl(name, q=1, ex=1):
            mc.deleteUI(name)
        popOut = CreatePopOut(name, "Twist Graph Large", 512, 400)
        graph = wrap.FallOffCurve(popOut.widgetLayout, 'twistCurve_large')

        def twistGraphCommand(_):
            core.attributes.propagateGraphs(graph)
            core.attributes.storeGraphs(graph)
        graph.changeCommand(twistGraphCommand)
        with wrap.Row(popOut.widgetLayout, margins=style.scale([5, 0, 5, 2])) as row:
            row.setFixedHeight(style.BUTTON_HEIGHT)

            magnitude = wrap.FloatField('Magnitude_large', row.layout(), attrName='Magnitude')
            magnitude.setFixedWidth(style.scale(45))
            magnitude.setRange(-99, 99)
            magnitude.setStep(0.01)
            magnitude.setPrecision(2)
            magnitude.setDragCommand(pa(core.sliders.curveControlSliderDrag, magnitude))
            magnitude.setReleaseCommand(core.sliders.release)

            resetButton = wrap.Button(row.layout())
            resetButton.setLabel('Reset Curve')

            def resetTwist():
                utils.resetSingleGraph('twist')
                core.attributes.storeGraphs(graph)
            resetButton.clicked.connect(undo(resetTwist))

        core.curveControlUI.updateUI()

    def widthGraphPopOut(self):
        name = "GSCT_WidthGraphPopOut"
        if mc.workspaceControl(name, q=1, ex=1):
            mc.deleteUI(name)
        popOut = CreatePopOut(name, "Width Graph Large", 512, 400)
        graph = wrap.FallOffCurve(popOut.widgetLayout, 'scaleCurve_large')

        def widthGraphCommand(_):
            core.attributes.propagateGraphs(graph)
            core.attributes.storeGraphs(graph)
        graph.changeCommand(widthGraphCommand)
        with wrap.Row(popOut.widgetLayout, margins=style.scale([5, 0, 5, 2])) as row:
            row.setFixedHeight(style.BUTTON_HEIGHT)
            resetButton = wrap.Button(row.layout())
            resetButton.setLabel('Reset Curve')

            def resetWidthCmd():
                utils.resetSingleGraph('width')
                core.attributes.storeGraphs(graph)
            resetButton.clicked.connect(undo(resetWidthCmd))
        core.curveControlUI.updateUI()

    def profileGraphPopOut(self):
        name = "GSCT_ProfileGraphPopOut"
        if mc.workspaceControl(name, q=1, ex=1):
            mc.deleteUI(name)
        popOut = CreatePopOut(name, "Profile Graph Large", 512, 400)
        graph = wrap.FallOffCurve(popOut.widgetLayout, 'profileCurve_large', attr=False)

        def changeCommand(value):
            core.updateLattice(value)
            core.equalizeProfileCurve()
        graph.changeCommand(changeCommand)
        with wrap.Row(popOut.widgetLayout, margins=style.scale([5, 0, 5, 2])) as row:
            row.setFixedHeight(style.BUTTON_HEIGHT)
            resetButton = wrap.Button(row.layout())
            resetButton.setLabel('Reset Curve')
            resetButton.clicked.connect(undo(core.resetProfileCurve))
        core.curveControlUI.updateUI()


# UV Editor Window
def uvEditorWorkspace():
    global uveditor
    if mc.workspaceControl(UV_EDITOR_NAME, q=1, ex=1):
        if MAYA_VER >= 2018:
            if not mc.workspaceControl(UV_EDITOR_NAME, q=1, vis=1):
                mc.workspaceControl(UV_EDITOR_NAME, e=1, rs=1)
            else:
                mc.workspaceControl(UV_EDITOR_NAME, e=1, vis=0)
            try:
                uveditor.updateEditor()  # pylint: disable=used-before-assignment
            except Exception as e:
                LOGGER.exception(e)
        else:
            mc.workspaceControl(UV_EDITOR_NAME, e=1, fl=1)
            mc.deleteUI(UV_EDITOR_NAME)
    else:
        uveditor = UVEditor('uveditor')
        uveditor.init()
        uveditor.updateEditor()
        from . import main
        main.checkScriptJobs(UV_EDITOR_NAME)


class UVEditor(QtWidgets.QWidget):

    def __init__(self, name):
        super(UVEditor, self).__init__()
        self.name = name
        self.timer = utils.Timer()
        self.mouseToggle = False
        self.previousSelection = []
        self.uvUpdateCheck = 0
        self.isolateMode = False
        self.currentSelection = []

    def init(self):
        if mc.workspaceControl(UV_EDITOR_NAME, q=1, ex=1):
            mc.deleteUI(UV_EDITOR_NAME)
        parent = mayaWorkspaceControl(name=UV_EDITOR_NAME,
                                      label=UV_EDITOR_LABEL,
                                      retain=False, iw=705, ih=575,
                                      widthProperty="free")
        self.setParent(parent)

        parent.layout().addWidget(self)
        self.window()

        self.editor.signal_keyPress.connect(self.updateButtons)
        self.editor.signal_mouseMove.connect(self._updateCurves)
        self.editor.signal_mouseRelease.connect(self._stopCurvesUpdate)
        self.editor.signal_uvDrawEnd.connect(self.manualCurveUpdate)
        self.editor.signal_functionKeyPress.connect(undo(self.functionSwitch))
        self.uvList.signal_keyPressed.connect(self.updateVisibility)

    def window(self):
        # Layout
        mainLayout = QtWidgets.QVBoxLayout(self)
        mainLayout.setContentsMargins(*style.scale([2, 2, 2, 2]))

        self.scrollWidget = QtWidgets.QWidget()
        layout = QtWidgets.QVBoxLayout(self.scrollWidget)
        scrollArea = QtWidgets.QScrollArea()
        scrollArea.setWidget(self.scrollWidget)
        mainLayout.addWidget(scrollArea)

        # Layout Settings
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(style.scale(2))
        layout.setMargin(0)
        layout.setAlignment(QtCore.Qt.AlignTop)

        scrollArea.setFrameShape(QtWidgets.QFrame.NoFrame)
        scrollArea.setWidgetResizable(True)

        # Editor Init
        self.editor = uv_editor.Editor()
        self.editor.init()
        self.updateColors()

        # Main Widgets
        with wrap.Row(layout) as mainRow:
            with wrap.Column(mainRow.layout()) as mainColumn:
                mainColumn.layout().setAlignment(QtCore.Qt.AlignTop)
                mainColumn.setFixedWidth(style.scale(130))

                # Controller switches
                mainColumn.layout().addWidget(wrap.separator())
                controllerLabel = wrap.Label(mainColumn.layout())
                controllerLabel.setLabel('Controller Mode')

                self.controllerGroup = QtWidgets.QButtonGroup(mainColumn.layout())
                self.controllerGroup.buttonReleased.connect(self.updateControllerMode)

                with wrap.Row(mainColumn.layout()) as selectMove:
                    select = wrap.Button(selectMove.layout(), 'gsUVSelect')
                    select.setCheckable(True)
                    select.setChecked(True)
                    select.setLabel("Select (Q)")
                    move = wrap.Button(selectMove.layout(), 'gsUVMove')
                    move.setCheckable(True)
                    move.setLabel("Move (W)")
                with wrap.Row(mainColumn.layout()) as rotateScale:
                    rotate = wrap.Button(rotateScale.layout(), 'gsUVRotate')
                    rotate.setCheckable(True)
                    rotate.setLabel("Rotate (E)")
                    scale = wrap.Button(rotateScale.layout(), 'gsUVScale')
                    scale.setCheckable(True)
                    scale.setLabel("Scale (R)")

                with wrap.Row(mainColumn.layout()) as scaleRow:
                    self.directionSwitch = QtWidgets.QButtonGroup(scaleRow.layout())
                    self.directionSwitch.buttonReleased.connect(self.updateControllerMode)

                    horizontal = wrap.Button(scaleRow.layout(), 'gsUVHorizontalScale')
                    horizontal.setLabel('H')
                    horizontal.setButtonStyle('small')
                    horizontal.setCheckable(True)
                    horizontal.setChecked(True)
                    vertical = wrap.Button(scaleRow.layout(), 'gsUVVerticalScale')
                    vertical.setButtonStyle('small')
                    vertical.setCheckable(True)
                    vertical.setLabel('V')

                    self.directionSwitch.addButton(horizontal, 0)
                    self.directionSwitch.addButton(vertical, 1)

                drawUV = wrap.Button(mainColumn.layout(), 'gsDrawUVs')
                drawUV.setCheckable(True)
                drawUV.setLabel('Draw (D)')

                self.controllerGroup.addButton(select, 0)
                self.controllerGroup.addButton(move, 1)
                self.controllerGroup.addButton(rotate, 2)
                self.controllerGroup.addButton(scale, 3)
                self.controllerGroup.addButton(drawUV, 4)

                mainColumn.layout().addWidget(wrap.separator())

                # Utility Functions
                utilityLabel = wrap.Label(mainColumn.layout())
                utilityLabel.setLabel('Utility Functions')

                with wrap.Row(mainColumn.layout()) as HVFlip:
                    hFlipUV = wrap.Button(HVFlip.layout(), 'gsHorizontalFlipUV')
                    hFlipUV.setLabel('H-Flip (H)')
                    hFlipUV.clicked.connect(undo(self.horizontalFlipUV))

                    vFlipUV = wrap.Button(HVFlip.layout(), 'gsVerticalFlipUV')
                    vFlipUV.setLabel('V-Flip (V)')
                    vFlipUV.clicked.connect(undo(self.verticalFlipUV))

                resetUV = wrap.Button(mainColumn.layout(), 'gsResetUVs')
                resetUV.setLabel('Reset UV (X)')
                resetUV.clicked.connect(undo(self.resetUVs))

                syncSelection = wrap.Button(mainColumn.layout(), 'gsSyncSelectionUVs')
                syncSelection.setLabel('Sync Selection (S)')
                syncSelection.clicked.connect(undo(self.syncSelection))

                randomizeUVs = wrap.Button(mainColumn.layout(), 'gsRandomizeUVs')
                randomizeUVs.setLabel('Randomize')
                randomizeUVs.setIcon('mod-bottom')
                randomizeUVs.clicked.connect(undo(self.randomizeUVs))

                mainColumn.layout().addWidget(wrap.separator())

                # UV List
                uvListLabel = wrap.Label(mainColumn.layout())
                uvListLabel.setLabel('UV List')

                self.uvList = wrap.UVItemList(mainColumn.layout())
                self.uvList.setLayout(mainColumn.layout())
                self.uvList.signal_mouseReleased.connect(self.updateVisibility)

                focusView = wrap.Button(mainColumn.layout(), 'gsFocusUVs')
                focusView.setLabel('Focus View (F)')
                focusView.clicked.connect(self.editor.focusView)

                with wrap.Row(mainColumn.layout()) as hideIsolate:
                    isolateSelect = wrap.Button(hideIsolate.layout(), 'gsUVIsolateSelect')
                    isolateSelect.setLabel('Isolate (I)')
                    isolateSelect.clicked.connect(self.isolateSelect)

                    hide = wrap.Button(hideIsolate.layout(), 'gsUVHide')
                    hide.setLabel('Hide (O)')
                    hide.clicked.connect(self.hide)

                showAllButton = wrap.Button(mainColumn.layout(), 'gsUVShowAll')
                showAllButton.setLabel('Show All (A)')
                showAllButton.clicked.connect(self.showAll)

                mainColumn.layout().addWidget(wrap.separator())

                with wrap.Frame(mainColumn.layout(), label="Options") as optionsFrame:
                    # Texture Controls
                    textureFunctionsLabel = wrap.Label(optionsFrame.getFrameLayout())
                    textureFunctionsLabel.setLabel('Texture Controls:')

                    transparency = wrap.Button(optionsFrame.getFrameLayout(), 'UVEditorTransparencyToggle')
                    transparency.setButtonStyle('small')
                    transparency.setCheckable(True)
                    transparency.setChecked(mc.optionVar(q='GSCT_UVEditorTransparencyToggle'))
                    transparency.setLabel("Transparency")

                    alphaOnly = wrap.Button(optionsFrame.getFrameLayout(), 'UVEditorAlphaOnlyToggle')
                    alphaOnly.setButtonStyle('small')
                    alphaOnly.setCheckable(True)
                    alphaOnly.setChecked(mc.optionVar(q='GSCT_UVEditorAlphaOnly'))
                    alphaOnly.setLabel("Alpha Only")

                    useTransforms = wrap.Button(optionsFrame.getFrameLayout(), 'UVEditorUseTransforms')
                    useTransforms.setButtonStyle('small')
                    useTransforms.setCheckable(True)
                    useTransforms.setChecked(True)
                    useTransforms.setLabel("Use Transforms")
                    useTransforms.clicked.connect(self.updateTexture)

                    def toggleAlphaCommand():
                        if transparency.isChecked():
                            self.editor.toggleAlpha(True)
                        else:
                            self.editor.toggleAlpha(False)
                            alphaOnly.setChecked(False)
                        self.updateTexture()
                        mc.optionVar(iv=['GSCT_UVEditorTransparencyToggle', transparency.isChecked()])
                    transparency.clicked.connect(toggleAlphaCommand)

                    def toggleAlphaOnlyCommand():  # BUG: Find out why switching textures does not update alpha
                        if alphaOnly.isChecked():
                            transparency.setChecked(True)
                        else:
                            transparency.setChecked(False)
                        toggleAlphaCommand()
                        mc.optionVar(iv=['GSCT_UVEditorAlphaOnly', alphaOnly.isChecked()])
                    alphaOnly.clicked.connect(toggleAlphaOnlyCommand)

                    optionsFrame.getFrameLayout().addWidget(wrap.separator())

                    # Editor Colors
                    textureFunctionsLabel = wrap.Label(optionsFrame.getFrameLayout())
                    textureFunctionsLabel.setLabel('Editor Colors:')

                    with wrap.Row(optionsFrame.getFrameLayout(), margins=style.scale([5, 0, 5, 5])) as colorRow:
                        backgroundColorPicker = wrap.ColorPicker('UVEditorBGColorPicker', colorRow.layout())
                        backgroundColorPicker.setRGBColors(
                            utils.colorFrom255to1(eval(mc.optionVar(q="GSCT_UVEditorBGColor")))
                        )
                        backgroundColorPicker.connectCommand(self.updateColors)

                        gridColorPicker = wrap.ColorPicker('UVEditorGridColorPicker', colorRow.layout())
                        gridColorPicker.setRGBColors(
                            utils.colorFrom255to1(eval(mc.optionVar(q="GSCT_UVEditorGridColor")))
                        )
                        gridColorPicker.connectCommand(self.updateColors)

                        frameColorPicker = wrap.ColorPicker('UVEditorFrameColorPicker', colorRow.layout())
                        frameColorPicker.setRGBColors(
                            utils.colorFrom255to1(eval(mc.optionVar(q="GSCT_UVEditorFrameColor")))
                        )
                        frameColorPicker.connectCommand(self.updateColors)

                    # UV Card Colors
                    cardColors = wrap.Label(optionsFrame.getFrameLayout())
                    cardColors.setLabel('UV Colors:')

                    with wrap.Row(optionsFrame.getFrameLayout(), margins=style.scale([5, 0, 5, 5])) as colorRow2:
                        selectedCardFrameColor = wrap.ColorPicker('UVEditorUVFrameSelectedColorPicker', colorRow2.layout())
                        selectedCardFrameColor.setRGBColors(
                            utils.colorFrom255to1(eval(mc.optionVar(q="GSCT_UVEditorUVFrameSelectedColor")))
                        )
                        selectedCardFrameColor.connectCommand(self.updateColors)

                        deselectedCardFrameColor = wrap.ColorPicker('UVEditorUVFrameDeselectedColorPicker', colorRow2.layout())
                        deselectedCardFrameColor.setRGBColors(
                            utils.colorFrom255to1(eval(mc.optionVar(q="GSCT_UVEditorUVFrameDeselectedColor")))
                        )
                        deselectedCardFrameColor.connectCommand(self.updateColors)

                        cardFillColor = wrap.ColorPicker('UVEditorUVCardFillColorPicker', colorRow2.layout())
                        cardFillColor.setRGBColors(
                            utils.colorFrom255to1(eval(mc.optionVar(q="GSCT_UVEditorUVCardFillColor")))
                        )
                        cardFillColor.connectCommand(self.updateColors)

                mainColumn.layout().addWidget(wrap.separator())

            mainRow.layout().addWidget(self.editor)

            if MAYA_VER in [2020, 2022] and not mc.optionVar(q='GSCT_UVBugMessageDismissed'):
                with wrap.Row(mainLayout) as row:
                    label = wrap.Label(row.layout())
                    label.setLabel('<p style="color:#FF542F">How To Fix Maya 2020-2022 UV Bug:</p>')

                    linkButton = wrap.Button(row.layout())
                    linkButton.setLabel('Open Fix')
                    linkButton.setButtonStyle('small-filled')
                    linkButton.clicked.connect(lambda: utils.openLink(
                        'https://gs-curvetools.readthedocs.io/en/latest/faq.html#maya-2020-2022-and-broken-uvs')
                    )

                    dismissMessage = wrap.Button(row.layout())
                    dismissMessage.setLabel('Dismiss Message')
                    dismissMessage.setButtonStyle('small-filled')
                    dismissMessage.clicked.connect(lambda: row.setHidden(True))
                    dismissMessage.clicked.connect(lambda: mc.optionVar(iv=['GSCT_UVBugMessageDismissed', 1]))

    def updateColors(self, *_):
        if self.editor:
            core.saveOptions()
            try:
                self.editor.changeColor(
                    eval(mc.optionVar(q="GSCT_UVEditorBGColor")),
                    eval(mc.optionVar(q="GSCT_UVEditorGridColor")),
                    eval(mc.optionVar(q="GSCT_UVEditorFrameColor")),
                    eval(mc.optionVar(q="GSCT_UVEditorUVCardFillColor")),
                    eval(mc.optionVar(q="GSCT_UVEditorUVFrameSelectedColor")),
                    eval(mc.optionVar(q="GSCT_UVEditorUVFrameDeselectedColor"))
                )
            except Exception as e:
                self.editor.changeColor()
                LOGGER.exception(e)
            self.editor.update()

    @noUndo
    def updateEditor(self):
        uveditor.updateItemList()
        uveditor.updateUVs()
        uveditor.updateTexture()

    def showAll(self):
        self.uvList.expandAll()
        self.uvList.selectAll()
        self.updateVisibility()
        self.isolateMode = False

    @noUndo
    def updateUVs(self, keepSelection=False):
        sel = mc.filterExpand(mc.ls(sl=1, fl=1, l=1), sm=9)
        oldUVs = self.editor.UVDict
        self.editor.purgeUVs()
        if not sel:
            return
        sel = self.checkForLegacyUVs(sel)
        for item in sel:
            if (mc.attributeQuery('Orientation', n=item, ex=1) and
                    mc.connectionInfo(item + '.Orientation', isSource=1)):
                if (mc.attributeQuery('gsmessage', n=item, ex=1) and
                        mc.listConnections(item + '.gsmessage')):
                    curves = core.getAllConnectedCurves(item)
                else:
                    curves = [item]
                for curve in curves:
                    attrs = core.attributes.getUVs(curve)
                    cb = core.attributes.getCheckboxes(curve)
                    if attrs:
                        uv = self.editor.createUV(curve)
                        if 'flipUV' in cb:
                            uv.flip = not cb['flipUV']
                        uv.moveUV(
                            x=attrs['moveU'],
                            y=attrs['moveV'],
                            rot=attrs['rotateUV'] * -1,
                            sx=attrs['scaleU'],
                            sy=attrs['scaleV'],
                        )
        if keepSelection:
            newUVs = self.editor.UVDict
            for uv in newUVs:
                if uv in oldUVs:
                    newUVs[uv].setSelected(True)

    def checkForLegacyUVs(self, curves):
        legacyCurves = []
        for curve in curves:
            root = mc.attributeQuery('rotateRootUV', n=curve, ex=1)
            tip = mc.attributeQuery('rotateTipUV', n=curve, ex=1)
            if root or tip:
                rootValue = mc.getAttr(curve + '.rotateRootUV')
                tipValue = mc.getAttr(curve + '.rotateTipUV')
                if rootValue or tipValue:
                    legacyCurves.append(curve)
        if not legacyCurves:
            return curves
        else:
            MESSAGE.warningInView('Non Zero Legacy UV Attributes Detected')
            dialog = mc.confirmDialog(
                title='Legacy UVs',
                message='Non Zero Legacy UVs Detected.\nUV Editor is not compatible with them.\nZero them out to proceed?',
                icon='warning',
                button=['Yes', 'Cancel'],
                cancelButton='Cancel',
                dismissString='Cancel'
            )
            if dialog == 'Yes':
                for curve in legacyCurves:
                    mc.setAttr(curve + '.rotateRootUV', 0)
                    mc.setAttr(curve + '.rotateTipUV', 0)
                return curves
            elif dialog == 'Cancel':
                dialog = mc.confirmDialog(
                    title='Legacy UVs',
                    message='UV Editor is not compatible with the old UVs.\nSome of the cards are ignored.',
                    icon='information',
                    button='OK',
                    cancelButton='OK',
                    dismissString='OK'
                )
                return list(set(curves) - set(legacyCurves))

    @noUndo
    def updateTexture(self):
        sel = core.selectPart(2, justReturn=True)
        if not sel:
            self.editor.removeTexture()
            self.editor.diffusePath = ''
            return
        geo = mc.filterExpand(sel, sm=12)
        if not geo:
            return
        dag = mc.ls(geo[-1], dag=1, s=1)
        shader = mc.listConnections(dag, d=1, s=1, t='shadingEngine')
        if not shader:
            return
        network = mc.hyperShade(lun=shader[0])
        fileNode = None
        alphaNode = None
        if network:
            for node in network:
                if mc.nodeType(node) == 'file' and mc.connectionInfo(node + '.outColor', isSource=1):
                    fileNode = node
                    break
            for node in network:
                if mc.nodeType(node) == 'file' and mc.connectionInfo(node + '.outTransparency', isSource=1):
                    alphaNode = node
                    break
        if not fileNode:
            return
        texturePath = mc.getAttr(fileNode + '.fileTextureName')
        alphaPath = mc.getAttr(alphaNode + '.fileTextureName') if alphaNode else None

        # Find place2dTexture node
        place2dTexture = None
        if mc.attributeQuery('coverage', n=fileNode, ex=1):
            info = mc.connectionInfo(fileNode + '.coverage', sfd=1)
            if info:
                place2dTexture = info.split('.')
                if place2dTexture:
                    place2dTexture = place2dTexture[0]

        # Get coverage and transformFrame from place2dTexture
        cov, trans = None, None
        if place2dTexture and mc.objExists(place2dTexture) and WIDGETS['UVEditorUseTransforms'].isChecked():
            if (mc.attributeQuery('coverage', ex=1, n=place2dTexture) and
                    mc.attributeQuery('translateFrame', ex=1, n=place2dTexture)):
                try:
                    cov = mc.getAttr(place2dTexture + '.coverage')[0]
                    trans = mc.getAttr(place2dTexture + '.translateFrame')[0]
                except Exception as e:
                    LOGGER.exception(e)
        coverage = cov if cov else (1.0, 1.0)
        translation = (trans[0], trans[1]) if trans and trans else (0, 0)

        if not WIDGETS['UVEditorTransparencyToggle'].isChecked() and not WIDGETS['UVEditorAlphaOnlyToggle'].isChecked():
            alphaPath = None
        if texturePath:
            _, ext = os.path.splitext(texturePath)
            try:  # Python 3
                supportedFormats = list([str(x, encoding='ASCII').lower() for x in QtGui.QImageReader.supportedImageFormats()])
            except BaseException:  # Python 2 fallback
                supportedFormats = list([str(x).decode('ASCII').lower() for x in QtGui.QImageReader.supportedImageFormats()])
            if ext and (ext[1:].lower() not in supportedFormats):
                MESSAGE.warning(
                    "{} format is not supported. Use JPG/JPEG, PNG, TIF/TIFF (LZW or No Compression), TGA (24bit, no RLE)".format(ext[1:].upper()))
                return
            err = self.editor.setTexture('%s' % texturePath, alphaPath, coverage, translation)
            if err == 'SamePath':
                return
            elif err == 'NoTexture':
                MESSAGE.warning("Texture file could not be loaded.")
                return
            elif err == 'ZeroTexture':
                MESSAGE.warning("Invalid Path or Zero Texture")
                return

    def manualCurveUpdate(self):
        try:
            self._updateCurves()
        except Exception as e:
            LOGGER.exception(e)
        finally:
            self._stopCurvesUpdate()

    def _updateCurves(self):
        if self.uvUpdateCheck == 0:
            mc.undoInfo(ock=1, cn='gsUVUpdate')
            self.uvUpdateCheck = 1

            sel = mc.filterExpand(mc.ls(sl=1), sm=9)
            uvs = self.editor.getUVs()
            self.currentSelection *= 0

            if not sel:
                return

            for curve in sel:
                if curve in uvs:
                    self.currentSelection.append(curve)
                else:
                    if (mc.attributeQuery('gsmessage', n=curve, ex=1) and
                            mc.listConnections(curve + '.gsmessage')):
                        boundCurves = core.getAllConnectedCurves(curve)
                        if boundCurves:
                            self.currentSelection += boundCurves

        if not self.timer.increment(1.0 / 60.0):
            return
        if not self.currentSelection:
            return

        uvs = self.editor.getUVs()
        for curve in self.currentSelection:
            if curve in uvs:
                core.attributes.setAttr(curve, uvs[curve])

    def _stopCurvesUpdate(self):
        if self.uvUpdateCheck == 1:
            mc.undoInfo(cck=1)
            self.uvUpdateCheck = 0
            self.currentSelection *= 0
            core.curveControlUI.updateUI()

    def updateButtons(self, controllerMode, scaleMode):
        buttons = self.controllerGroup.buttons()
        direction = self.directionSwitch.buttons()
        if controllerMode == 'SELECT':
            buttons[0].setChecked(True)
        elif controllerMode == 'MOVE':
            buttons[1].setChecked(True)
        elif controllerMode == 'ROTATE':
            buttons[2].setChecked(True)
        elif controllerMode == 'SCALE':
            buttons[3].setChecked(True)
            if scaleMode == 'H':
                direction[0].setChecked(True)
            else:
                direction[1].setChecked(True)
        elif controllerMode == 'DRAW':
            buttons[4].setChecked(True)

    def updateControllerMode(self):
        buttonID = self.controllerGroup.checkedId()
        scaleID = self.directionSwitch.checkedId()
        scale = 'H'
        if buttonID == 0:
            mode = 'SELECT'
        elif buttonID == 1:
            mode = 'MOVE'
        elif buttonID == 2:
            mode = 'ROTATE'
        elif buttonID == 3:
            mode = 'SCALE'
            if scaleID == 0:
                scale = 'H'
            else:
                scale = 'V'
        else:
            mode = 'DRAW'
        self.editor.controllerModeChange(mode, scale)

    def updateItemList(self):
        sel = mc.filterExpand(mc.ls(sl=1), sm=9)
        if not sel:
            self.uvList.clearItemList()
            return

        finalDict = {}
        for curve in sel:
            if (mc.attributeQuery('Orientation', n=curve, ex=1) and
                    mc.connectionInfo(curve + '.Orientation', isSource=1)):
                if (mc.attributeQuery('gsmessage', n=curve, ex=1) and
                        mc.listConnections(curve + '.gsmessage')):
                    boundCurves = core.getAllConnectedCurves(curve)
                    finalDict[curve] = boundCurves
                else:
                    finalDict[curve] = []
        self.uvList.updateItemList(finalDict)

    def updateVisibility(self):
        itemList = self.uvList.getSelection()
        items = self.editor.getAllUVs()
        for item in items:
            if item.name in itemList:
                item.setVisible(True)
            else:
                item.setVisible(False)
        self.editor.update()

    def hide(self):
        """Hides selected UV items"""
        selUVs = self.editor.getAllUVs(selected=True)
        selUVsList = [i.name for i in selUVs]
        for uv in selUVs:
            uv.setVisible(False)
        itemList = self.uvList.getItemList()
        selectList = []
        for item in itemList:
            if item.curveName in selUVsList:
                selectList.append(item)
        self.uvList.selectItems(selectList)

    def isolateSelect(self):
        allUVs = self.editor.getAllUVs()
        selUVs = self.editor.getAllUVs(selected=True)
        if not selUVs:
            return
        if self.isolateMode:
            self.showAll()
            self.isolateMode = False
            return
        self.isolateMode = True
        selUVsList = [i.name for i in selUVs]
        for uv in allUVs:
            if uv.name not in selUVsList:
                uv.setVisible(False)
        itemList = self.uvList.getItemList()
        deselectList = []
        for item in itemList:
            if item.curveName not in selUVsList:
                deselectList.append(item)
        self.uvList.selectItems(deselectList)

    def horizontalFlipUV(self):
        items = self.editor.getAllUVs(selected=True)
        for item in items:
            if item.name and mc.attributeQuery('flipUV', n=item.name, ex=1):
                flip = mc.getAttr(item.name + '.flipUV')
                mc.setAttr(item.name + '.flipUV', not flip)
                item.flip = flip
                item.update()
        if items:
            self.editor.update()

    def verticalFlipUV(self):
        self.editor.verticalFlipUV()
        self.manualCurveUpdate()

    def functionSwitch(self, key):
        if key == 'H':
            self.horizontalFlipUV()
        elif key == 'V':
            self.verticalFlipUV()
        elif key == 'X':
            self.resetUVs()
        elif key == 'I':
            self.isolateSelect()
        elif key == 'O':
            self.hide()
        elif key == 'A':
            self.showAll()
        elif key == 'S':
            self.syncSelection()

    def resetUVs(self):
        self.editor.resetUV()
        self.manualCurveUpdate()

    def randomizeUVs(self):
        if utils.getMod() == 'Shift':
            self.editor.randomizeUVs(True)
        else:
            self.editor.randomizeUVs(False)
        self.manualCurveUpdate()

    def syncSelection(self):
        """Selects curves in Maya Viewport based on UV Editor selection"""
        sel = mc.filterExpand(mc.ls(sl=1), sm=9)
        if not sel:
            return
        selUVs = [x.name for x in self.editor.getAllUVs(selected=True)]
        newSel = [x for x in sel if x in selUVs]
        if newSel:
            mc.select(newSel, r=1)

            @utils.deferredLp
            def x():
                uvs = self.editor.getAllUVs()
                for uv in uvs:
                    uv.setSelected(True)
                self.editor.scene().update()
            x()


uveditor = UVEditor('uveditor')


# Colors Window

class CustomLayerColors:

    def window(self, *_):
        self.windowName = 'GSCT_CustomLayerColorsWindow'
        if mc.workspaceControl(self.windowName, q=1, ex=1):
            mc.deleteUI(self.windowName)
        popOut = CreatePopOut(self.windowName, "Layers Customization", 280, 586)

        layout = popOut.widgetLayout
        layout.setAlignment(QtCore.Qt.AlignTop)

        letters = [chr(l) for l in range(ord('A'), ord('A') + 10)]

        wrap.Label(layout).setLabel("Color Controls:")

        with wrap.Frame(layout, label='Gradient', margins=[2, 2, 2, 2]) as generateFrame:

            self.gradientRowsNumber = wrap.ControlSlider(generateFrame.getFrameLayout())
            self.gradientRowsNumber.setLabel('Rows')
            self.gradientRowsNumber.setMinMax(1, 80)
            self.gradientRowsNumber.setValue(20)

            with wrap.Row(generateFrame.getFrameLayout()) as gradientColorsLayout:
                self.minGradientSwatch = wrap.ColorPicker('gradientSwatchMin', gradientColorsLayout.layout())
                self.minGradientSwatch.setHSVColors([0.1, 1, 1])
                self.maxGradientSwatch = wrap.ColorPicker('gradientSwatchMax', gradientColorsLayout.layout())
                self.maxGradientSwatch.setHSVColors([300, 1, 1])

            generateGradient = wrap.Button(generateFrame.getFrameLayout(), 'gsGenerateLayerColorGradient')
            generateGradient.setLabel('Generate Gradient')
            generateGradient.clicked.connect(self.generateColorGradient)

        with wrap.Frame(layout, label='Randomize', margins=[2, 2, 2, 2]) as randomizeFrame:

            self.saturationMin = wrap.ControlSlider(randomizeFrame.getFrameLayout(), typ='float')
            self.saturationMin.setMinMax(0, 1)
            self.saturationMin.setValue(0.8)
            self.saturationMin.setStep(0.01)
            self.saturationMin.setLabel('SatMin')

            self.saturationMax = wrap.ControlSlider(randomizeFrame.getFrameLayout(), typ='float')
            self.saturationMax.setMinMax(0, 1)
            self.saturationMax.setValue(1.0)
            self.saturationMax.setStep(0.01)
            self.saturationMax.setLabel('SatMax')

            randomizeButton = wrap.Button(randomizeFrame.getFrameLayout(), 'gsRandomizeLayerColors')
            randomizeButton.setLabel('Randomize All')
            randomizeButton.clicked.connect(self.randomizeAllColors)

        layout.addWidget(wrap.separator())

        wrap.Label(layout).setLabel("Layers:")

        def colorRow(parent, i):
            with wrap.Row(parent) as singleColor:
                singleColor.setFixedHeight(style.scale(16))

                label = wrap.Label()
                if 10 <= i < 20:
                    label.setLabel('%s (%s)' % (i, letters[i - 10]))
                else:
                    label.setLabel(str(i))
                label.setFixedWidth(style.scale(int(35)))

                layerName = wrap.LineEdit('layerCustomName_%s' % i)
                newFont = QtGui.QFont('Roboto')
                newFont.setPointSizeF(style.scale(5))
                layerName.setFixedHeight(style.scale(18))
                layerName.setFrame(False)
                layerName.setFont(newFont)
                layerName.setAutoFormat(True)
                layerName.setClearButtonEnabled(True)

                swatch = wrap.ColorPicker('layerColorPicker_%s' % i)

                randButton = wrap.Button()
                randButton.setButtonStyle('small-filled')
                randButton.setLabel('Rand', lineHeight=100)
                randButton.setLabelStyle('small')
                randButton.setWidthHeight(h=style.scale(10))
                randButton.clicked.connect(pa(self.randomizeColor, swatch))

                resetButton = wrap.Button()
                resetButton.setButtonStyle('small-filled')
                resetButton.setLabel('Reset', lineHeight=100)
                resetButton.setLabelStyle('small')
                resetButton.setWidthHeight(h=style.scale(10))
                resetButton.clicked.connect(pa(self.resetColor, swatch))
                resetButton.clicked.connect(pa(self.resetName, layerName))

                singleColor.layout().addWidget(label)
                singleColor.layout().addWidget(layerName, 3)
                singleColor.layout().addWidget(swatch, 1)
                singleColor.layout().addWidget(randButton, 1)
                singleColor.layout().addWidget(resetButton, 1)
            return singleColor

        with wrap.Frame(layout, label='0-19') as frame1:
            for i in range(20):
                colorRow(frame1.getFrameLayout(), i)
                frame1.setCollapsed(False)
        with wrap.Frame(layout, label='20-39') as frame2:
            for i in range(20, 40):
                colorRow(frame2.getFrameLayout(), i)
                frame2.setCollapsed(True)
        with wrap.Frame(layout, label='40-79') as frame3:
            for i in range(40, 80):
                colorRow(frame3.getFrameLayout(), i)
                frame3.setCollapsed(True)

        layout.addWidget(wrap.separator())

        wrap.Label(layout).setLabel("Commands:")

        resetButton = wrap.Button(layout, 'gsResetAllLayerColors')
        resetButton.setLabel('Reset All')
        resetButton.clicked.connect(self.resetAll)

        with wrap.Row(layout) as controlButtons:
            getCurrent = wrap.Button(controlButtons.layout(), 'gsGetCurrentSceneLayers')
            getCurrent.setLabel('Get From Scene')
            getCurrent.clicked.connect(self.getFromLayers)

            setAsCurrent = wrap.Button(controlButtons.layout(), 'gsSetAsCurrentSceneLayers')
            setAsCurrent.setLabel('Set To Scene')
            setAsCurrent.clicked.connect(self.setToLayers)

        with wrap.Row(layout) as buttonsFrame:

            loadSaved = wrap.Button(buttonsFrame.layout(), 'gsLoadGlobalLayerPreset')
            loadSaved.setLabel('Load Preset')
            loadSaved.clicked.connect(self.loadPreset)

            saveButton = wrap.Button(buttonsFrame.layout(), 'gsSaveGlobalLayerPreset')
            saveButton.setLabel('Save As Preset')
            saveButton.clicked.connect(self.savePreset)

        self.getFromLayers()

    def randomizeColor(self, swatch):
        satMin = self.saturationMin.getValue()
        satMax = self.saturationMax.getValue()
        swatch.setRGBColors(core.toggleColor.generateBrightColor(satMin, satMax))

    def randomizeAllColors(self):
        for i in range(80):
            self.randomizeColor(WIDGETS['layerColorPicker_%s' % i])

    def resetColor(self, swatch):
        swatch.setRGBColors([0, 0, 0])

    def resetName(self, field):
        field.clear()

    def resetAll(self):
        for i in range(80):
            WIDGETS['layerColorPicker_%s' % i].setRGBColors([0, 0, 0])
            WIDGETS['layerCustomName_%s' % i].clear()

    def generateColorGradient(self):
        rows = self.gradientRowsNumber.getValue()
        colorMin = self.minGradientSwatch.getHSVColors()
        colorMax = self.maxGradientSwatch.getHSVColors()
        for i in range(rows):
            fraction = i / float(rows)
            h = mt.lerp(fraction, colorMin[0], colorMax[0])
            s = mt.lerp(fraction, colorMin[1], colorMax[1])
            v = mt.lerp(fraction, colorMin[2], colorMax[2])
            WIDGETS['layerColorPicker_%s' % i].setHSVColors([h, s, v])

    def getFromLayers(self):
        # Getting colors
        colorDict = core.toggleColor.readColorDict()
        for key in colorDict:
            WIDGETS['layerColorPicker_%s' % key].setRGBColors(colorDict[key])
        # Getting names
        core.toggleColor.checkColorStorageNode()
        nameDict = eval(mc.getAttr(core.toggleColor.STORAGE_NODE + '.layerName'))
        for key in nameDict:
            if nameDict[key]:
                WIDGETS['layerCustomName_%s' % key].setText(nameDict[key])

    def getCurrentSwatches(self):
        colorDict = {}
        for i in range(80):
            colorDict[i] = WIDGETS['layerColorPicker_%s' % i].getRGBColors()
        return colorDict

    def getCurrentNames(self):
        core.toggleColor.checkColorStorageNode()
        nameDict = {}
        for i in range(80):
            nameDict[i] = WIDGETS['layerCustomName_%s' % i].text()
        return nameDict

    def setToLayers(self):
        colorDict = self.getCurrentSwatches()
        core.toggleColor.writeColorDict(colorDict)
        if WIDGETS['colorMode'].isChecked():
            core.toggleColor.updateColors()
        if WIDGETS['syncCurveColor'].isChecked():
            core.toggleColor.syncCurveColors()
        core.updateMainUI()

        # Setting names
        nameDict = self.getCurrentNames()
        core.toggleColor.checkColorStorageNode()
        mc.setAttr(core.toggleColor.STORAGE_NODE + '.layerName', str(nameDict), typ='string')

    def setCurrentSwathes(self, colorDict):
        for key in colorDict:
            WIDGETS['layerColorPicker_%s' % key].setRGBColors(colorDict[key])

    def setCurrentNames(self, nameDict):
        for key in nameDict:
            WIDGETS['layerCustomName_%s' % key].setText(nameDict[key])

    def savePreset(self):
        mc.optionVar(sv=['gsCurveToolsCustomColors', str(self.getCurrentSwatches())])
        mc.optionVar(sv=['gsCurveToolsCustomLayerNames', str(self.getCurrentNames())])

    def loadPreset(self):
        colorString = mc.optionVar(q='gsCurveToolsCustomColors')
        colorDict = eval(colorString)
        self.setCurrentSwathes(colorDict)
        nameString = mc.optionVar(q='gsCurveToolsCustomLayerNames')
        nameDict = eval(nameString)
        self.setCurrentNames(nameDict)


customLayerColors = CustomLayerColors()


class CreatePopOut(QtWidgets.QWidget):

    def __init__(self, name, label, width, height):
        self.name = name

        parent = mayaWorkspaceControl(name=name,
                                      label=label,
                                      retain=False, iw=width, ih=height, widthProperty="free")

        super(CreatePopOut, self).__init__(parent)

        self.ui()

        parent.layout().addWidget(self)

    def ui(self):
        self.mainLayout = QtWidgets.QVBoxLayout(self)
        self.mainLayout.setContentsMargins(*style.scale([5, 5, 5, 5]))

        self.scrollWidget = QtWidgets.QWidget()
        self.widgetLayout = QtWidgets.QVBoxLayout(self.scrollWidget)
        scrollArea = QtWidgets.QScrollArea()
        scrollArea.setWidget(self.scrollWidget)
        self.mainLayout.addWidget(scrollArea)

        # Layout Settings
        self.widgetLayout.setContentsMargins(0, 0, 0, 0)
        self.widgetLayout.setSpacing(style.scale(2))
        self.widgetLayout.setMargin(0)

        scrollArea.setFrameShape(QtWidgets.QFrame.NoFrame)
        scrollArea.setWidgetResizable(True)


class About:  # Creates "About" and "Contacts" windows

    def social(self):
        layout = mc.columnLayout()
        mc.textFieldButtonGrp(
            bl='>',
            bc=pa(
                utils.openLink,
                'https://discord.gg/f4DH6HQ'),
            l='Discord Server',
            tx='https://discord.gg/f4DH6HQ')
        mc.textFieldButtonGrp(bl='>', bc=pa(utils.openLink, 'https://sladkovsky3d.artstation.com/store'),
                              l='Online Store', tx='https://sladkovsky3d.artstation.com/store')
        mc.textFieldButtonGrp(bl='>', bc=pa(utils.openLink, 'http://gs-curvetools.readthedocs.io/'),
                              l='Online Documentation', tx='http://gs-curvetools.readthedocs.io/')
        mc.textFieldButtonGrp(bl='>', bc=pa(utils.openLink, 'https://www.twitch.tv/videonomad'),
                              l='Twitch Channel', tx='https://www.twitch.tv/videonomad')
        mc.textFieldButtonGrp(bl='>', bc=pa(utils.openLink, 'https://www.youtube.com/GeorgeSladkovsky'),
                              l='YouTube Channel', tx='https://www.youtube.com/GeorgeSladkovsky')
        mc.textFieldButtonGrp(bl='>', bc=pa(utils.openLink, 'https://www.artstation.com/sladkovsky3d'),
                              l='ArtStation Portfolio', tx='https://www.artstation.com/sladkovsky3d')
        mc.textFieldButtonGrp(bl='>', bc=pa(utils.openLink, 'mailto:george.sladkovsky@gmail.com'),
                              l='Contact Email', tx='george.sladkovsky@gmail.com')
        return layout

    def socialWindow(self):
        if (mc.window('gsSocialMedia', ex=1)):
            mc.deleteUI('gsSocialMedia')
        mc.window('gsSocialMedia', t='Useful Links:', tlb=1)
        self.social()
        mc.showWindow()

    def aboutWindow(self):
        if mc.window('gsAboutWindow', ex=1):
            mc.deleteUI('gsAboutWindow')
        mc.window('gsAboutWindow', t='About', tlb=1)
        mc.rowColumnLayout(h=400, co=[1, 'left', 10], cal=([1, 'left'], [2, 'right']), nc=2, cw=[1, 200])
        mc.text(al='left', l='Version: \n%s' % core.VERSION)
        mc.iconTextButton(al='right', w=90, h=80, i=utils.getFolder.icons() + 'gsCurveToolsIcon_logo.png')
        mc.setParent('..')
        mc.columnLayout(w=460, h=400)
        mc.text(w=400, ww=1, al='left',
                l='License:\nThis collection of code named GS CurveTools is a property of George Sladkovsky\
                   (Yehor Sladkovskyi) and can not be copied or distributed without his written permission.\
                   \n\n%s\nGeorge Sladkovsky (Yehor Sladkovskyi)\nAll Rights Reserved\
                   \n\nAutodesk Maya is a property of Autodesk, Inc.\n' % core.VERSION)
        mc.text(l='Social Media and Contact Links:\n')
        self.social()
        mc.showWindow('gsAboutWindow')


about = About()


class AttributesFilter:

    def __init__(self):
        self.uiName = "GSCT_AttributesFilterPopOut"
        self.attrs = [
            ('Length Divisions', 'lengthDivisions'),
            ('Dynamic Divisions', 'dynamicDivisions'),
            ('Width Divisions', 'widthDivisions'),
            ('Orientation', 'Orientation'),
            ('Twist', 'Twist'),
            ('Inverted Twist', 'invTwist'),
            ('Width', 'Width'),
            ('WidthX', 'WidthX'),
            ('WidthZ', 'WidthZ'),
            ('Taper', 'Taper'),
            ('Length Lock', 'LengthLock'),
            ('Length', 'Length'),
            ('Offset', 'Offset'),
            ('Profile', 'Profile'),
            ('Refine', 'curveRefine'),
            ('Auto Refine', 'autoRefine'),
            ('Smooth', 'curveSmooth'),
            ('Normals', 'surfaceNormals'),
            ('Reverse Normals', 'reverseNormals'),
            ('Axis Flip', 'AxisFlip'),
            ('Line Width', 'lineWidth'),
            ('Sampling', 'samplingAccuracy'),
        ]

        self.solidify = [
            ('Solidify', 'solidify'),
            ('Solidify Thickness', 'solidifyThickness'),
            ('Solidify Divisions', 'solidifyDivisions'),
            ('Solidify Scale X', 'solidifyScaleX'),
            ('Solidify Scale Y', 'solidifyScaleY'),
            ('Solidify Offset', 'solidifyOffset'),
            ('Solidify Normals', 'solidifyNormals'),
        ]

        self.uvs = [
            ('Move U', 'moveU'),
            ('Move V', 'moveV'),
            ('Rotate UV', 'rotateUV'),
            ('Scale U', 'scaleU'),
            ('Scale V', 'scaleV'),
            ('Flip UV', 'flipUV'),
            ('Rotate Root UV', 'rotateRootUV'),
            ('Rotate Tip UV', 'rotateTipUV'),
        ]

        self.graphs = [
            ('Twist Graph', 'twistCurve'),
            ('Scale Graph', 'scaleCurve'),
            ('Profile Graph', 'profileCurve'),
            ('Twist Magnitude', 'Magnitude'),
            ('Profile Smoothing', 'profileSmoothing'),
            ('Profile Magnitude', 'profileMagnitude'),
        ]

    def openUI(self):
        if mc.workspaceControl(self.uiName, q=1, ex=1):
            if mc.workspaceControl(self.uiName, q=1, vis=1):
                mc.deleteUI(self.uiName)
                return
            else:
                mc.deleteUI(self.uiName)
        popOut = CreatePopOut(self.uiName, "Attributes Filter", 260, 456.0)

        layout = popOut.widgetLayout
        layout.setAlignment(QtCore.Qt.AlignTop)
        with wrap.Row(layout, margins=style.scale([6, 0, 6, 0]), spacing=style.scale(10)) as mainRow:
            mainRow.layout().setAlignment(QtCore.Qt.AlignTop)
            with wrap.Column(mainRow.layout()) as leftColumn:
                with wrap.Frame(leftColumn.layout(), label='Attributes', margins=[2, 0, 2, 0]) as leftFrame:
                    leftFrame.setCollapsible(False)
                    leftFrame.getFrameLayout().setAlignment(QtCore.Qt.AlignTop)
                    for i in range(len(self.attrs)):
                        btn = wrap.Button(leftFrame.getFrameLayout(), 'gsFilter_%s' % self.attrs[i][1])
                        btn.setLabel(self.attrs[i][0])
                        btn.setButtonStyle('small')
                        btn.setCheckable(True)
                        btn.setChecked(False if self.attrs[i][0] == 'Orientation' else True)
            with wrap.Column(mainRow.layout()) as rightColumn:
                rightColumn.layout().setAlignment(QtCore.Qt.AlignTop)
                with wrap.Frame(rightColumn.layout(), label='Solidify', margins=[2, 0, 2, 0]) as rightFrame1:
                    rightFrame1.setCollapsible(False)
                    rightFrame1.getFrameLayout().setAlignment(QtCore.Qt.AlignTop)
                    for i in range(len(self.solidify)):
                        btn = wrap.Button(rightFrame1.getFrameLayout(), 'gsFilter_%s' % self.solidify[i][1])
                        btn.setLabel(self.solidify[i][0])
                        btn.setButtonStyle('small')
                        btn.setCheckable(True)
                        btn.setChecked(True)
                with wrap.Frame(rightColumn.layout(), label='Graphs', margins=[2, 0, 2, 0]) as rightFrame2:
                    rightFrame2.setCollapsible(False)
                    rightFrame2.getFrameLayout().setAlignment(QtCore.Qt.AlignTop)
                    for i in range(len(self.graphs)):
                        btn = wrap.Button(rightFrame2.getFrameLayout(), 'gsFilter_%s' % self.graphs[i][1])
                        btn.setLabel(list(self.graphs)[i][0])
                        btn.setButtonStyle('small')
                        btn.setCheckable(True)
                        btn.setChecked(True)
                with wrap.Frame(rightColumn.layout(), label='UVs', margins=[2, 0, 2, 0]) as rightFrame3:
                    rightFrame3.setCollapsible(False)
                    rightFrame3.getFrameLayout().setAlignment(QtCore.Qt.AlignTop)
                    for i in range(len(self.uvs)):
                        btn = wrap.Button(rightFrame3.getFrameLayout(), 'gsFilter_%s' % self.uvs[i][1])
                        btn.setLabel(list(self.uvs)[i][0])
                        btn.setButtonStyle('small')
                        btn.setCheckable(True)
                        btn.setChecked(True)

        layout.addWidget(wrap.separator())

        with wrap.Row(layout) as confirmCancelLayout:
            btn = wrap.Button(confirmCancelLayout.layout())
            btn.setLabel('Save')
            btn.clicked.connect(self.saveToOptionVar)
            btn.clicked.connect(lambda: MESSAGE.printInView("Filters Saved"))
            btn = wrap.Button(confirmCancelLayout.layout())
            btn.setLabel('Close')
            btn.clicked.connect(self.closeUI)

        self.updateUI()
        self.saveToOptionVar()

    def closeUI(self):
        if mc.workspaceControl(self.uiName, q=1, ex=1):
            mc.deleteUI(self.uiName)

    def updateUI(self):
        if mc.workspaceControl(self.uiName, q=1, ex=1):
            controlsDict = self.getFromOptionVar()
            if controlsDict and isinstance(controlsDict, dict):
                for key in controlsDict:
                    buttonName = 'gsFilter_%s' % key
                    WIDGETS[buttonName].setChecked(controlsDict[key])

    def saveToOptionVar(self):
        if mc.workspaceControl(self.uiName, q=1, ex=1):
            allControls = self.attrs + self.graphs + self.uvs + self.solidify
            controlsDict = {}
            for control in allControls:
                buttonName = 'gsFilter_%s' % control[1]
                button = WIDGETS[buttonName] if buttonName in WIDGETS else None
                if button:
                    controlsDict.update({control[1]: button.isChecked()})
            mc.optionVar(sv=('GSCT_AttributesFilter', str(controlsDict)))

    def getFromOptionVar(self):
        if mc.optionVar(ex='GSCT_AttributesFilter'):
            dictString = mc.optionVar(q='GSCT_AttributesFilter')
            if dictString:
                return dict(eval(dictString))


attributesFilter = AttributesFilter()


class CardToCurveWindow:

    def __init__(self):
        self.uiName = "GSCT_CardToCurvePopOut"
        self.buttonsDict = {}

    def openUI(self):
        if mc.workspaceControl(self.uiName, q=1, ex=1):
            if mc.workspaceControl(self.uiName, q=1, vis=1):
                mc.deleteUI(self.uiName)
                return
            else:
                mc.deleteUI(self.uiName)

        self.buttonsDict = self.loadClickedButtons()
        self.getBtn = lambda name: self.buttonsDict[name] if name in self.buttonsDict else True

        popOut = CreatePopOut(self.uiName, "Card to Curve", 245, 271)
        layout = popOut.widgetLayout
        layout.setAlignment(QtCore.Qt.AlignTop)
        self.mainButtonGroup = QtWidgets.QButtonGroup()
        self.mainButtonGroup.setExclusive(False)
        self.mainButtonGroup.buttonClicked.connect(self.saveButtonsState)
        with wrap.Column(layout) as mainColumn:
            mainColumn.layout().setAlignment(QtCore.Qt.AlignTop)

            with wrap.Frame(mainColumn.layout(), label='Output Type:', objName='gsCardToCurve_outputTypeSwitch') as outputTypeFrame:
                outputTypeFrame.setCollapsible(False)
                outputTypeFrame.setCollapsed(False)

                with wrap.Row(outputTypeFrame.getFrameLayout()) as outputTypeSwitch:
                    self.outputTypeGroup = QtWidgets.QButtonGroup()
                    WIDGETS['gsCardToCurve_cardTypeGroup'] = self.outputTypeGroup

                    generateCards = wrap.Button(outputTypeSwitch.layout(), 'gsCardToCurve_generateCards')
                    generateCards.setButtonStyle('small')
                    generateCards.setLabel('Cards')
                    generateCards.setCheckable(True)

                    generateCurves = wrap.Button(outputTypeSwitch.layout(), 'gsCardToCurve_generateCurves')
                    generateCurves.setButtonStyle('small')
                    generateCurves.setLabel('Curves Only')
                    generateCurves.setCheckable(True)

                    self.outputTypeGroup.addButton(generateCards, 0)
                    self.outputTypeGroup.addButton(generateCurves, 1)
                    generateCards.setChecked(not mc.optionVar(q='GSCT_CardToCurveOutputType'))
                    generateCurves.setChecked(mc.optionVar(q='GSCT_CardToCurveOutputType'))
                    self.outputTypeGroup.buttonClicked.connect(self.updateActiveButtons)

            with wrap.Frame(mainColumn.layout(), label='Card Type:', objName="gsCardToCurve_cardType") as cardTypeFrame:
                self.cardTypeFrame = cardTypeFrame
                cardTypeFrame.setCollapsible(False)
                cardTypeFrame.setCollapsed(False)

                with wrap.Row(cardTypeFrame.getFrameLayout()) as outputTypeSwitch:
                    self.cardTypeGroup = QtWidgets.QButtonGroup()
                    WIDGETS['gsCardToCurve_cardTypeGroup'] = self.cardTypeGroup

                    self.warpCards = wrap.Button(outputTypeSwitch.layout(), 'gsCardToCurve_warp')
                    self.warpCards.setButtonStyle('small')
                    self.warpCards.setLabel('Warp')
                    self.warpCards.setCheckable(True)

                    extrudeCards = wrap.Button(outputTypeSwitch.layout(), 'gsCardToCurve_extrude')
                    extrudeCards.setButtonStyle('small')
                    extrudeCards.setLabel('Extrude')
                    extrudeCards.setCheckable(True)

                    self.cardTypeGroup.addButton(self.warpCards, 0)
                    self.cardTypeGroup.addButton(extrudeCards, 1)
                    self.warpCards.setChecked(not mc.optionVar(q='GSCT_CardToCurveCardType'))
                    extrudeCards.setChecked(mc.optionVar(q='GSCT_CardToCurveCardType'))
                    self.cardTypeGroup.buttonClicked.connect(self.updateActiveButtons)

            with wrap.Frame(mainColumn.layout(), label='Match Attributes:', objName="gsCardToCurve_matchAttributes") as matchAttributeFrame:
                self.matchAttributeFrame = matchAttributeFrame
                matchAttributeFrame.setCollapsible(False)
                matchAttributeFrame.setCollapsed(False)

                with wrap.Row(matchAttributeFrame.getFrameLayout()) as row:
                    orientation = wrap.Button(row.layout(), 'gsCardToCurve_orientation')
                    orientation.setButtonStyle('small')
                    orientation.setLabel('Orientation')
                    orientation.setCheckable(True)
                    orientation.setChecked(self.getBtn('gsCardToCurve_orientation'))

                    width = wrap.Button(row.layout(), 'gsCardToCurve_width')
                    width.setButtonStyle('small')
                    width.setLabel('Width')
                    width.setCheckable(True)
                    width.setChecked(self.getBtn('gsCardToCurve_width'))

                    self.mainButtonGroup.addButton(orientation)
                    self.mainButtonGroup.addButton(width)

                with wrap.Row(matchAttributeFrame.getFrameLayout()) as row:
                    taper = wrap.Button(row.layout(), 'gsCardToCurve_taper')
                    taper.setButtonStyle('small')
                    taper.setLabel('Taper')
                    taper.setCheckable(True)
                    taper.setChecked(self.getBtn('gsCardToCurve_taper'))

                    twist = wrap.Button(row.layout(), 'gsCardToCurve_twist')
                    twist.setButtonStyle('small')
                    twist.setLabel('Twist')
                    twist.setCheckable(True)
                    twist.setChecked(self.getBtn('gsCardToCurve_twist'))

                    self.mainButtonGroup.addButton(taper)
                    self.mainButtonGroup.addButton(twist)

                with wrap.Row(matchAttributeFrame.getFrameLayout()) as row:
                    profile = wrap.Button(row.layout(), 'gsCardToCurve_profile')
                    profile.setButtonStyle('small')
                    profile.setLabel('Profile')
                    profile.setCheckable(True)
                    profile.setChecked(self.getBtn('gsCardToCurve_profile'))

                    material = wrap.Button(row.layout(), 'gsCardToCurve_material')
                    material.setButtonStyle('small')
                    material.setLabel('Material')
                    material.setCheckable(True)
                    material.setChecked(self.getBtn('gsCardToCurve_material'))

                    self.mainButtonGroup.addButton(profile)
                    self.mainButtonGroup.addButton(material)

                UVs = wrap.Button(matchAttributeFrame.getFrameLayout(), 'gsCardToCurve_UVs')
                UVs.setButtonStyle('small')
                UVs.setLabel('UVs')
                UVs.setCheckable(True)
                UVs.setChecked(self.getBtn('gsCardToCurve_UVs'))
                UVs.clicked.connect(self.updateActiveButtons)
                self.mainButtonGroup.addButton(UVs)

            with wrap.Frame(mainColumn.layout(), label='UV Match Options:', objName="gsCardToCurve_UVMatchOptions") as uvMatchOptionsFrame:
                self.uvMatchOptionsFrame = uvMatchOptionsFrame
                uvMatchOptionsFrame.setCollapsible(False)
                uvMatchOptionsFrame.setCollapsed(False)

                with wrap.Row(uvMatchOptionsFrame.getFrameLayout()) as row:
                    verticalFlip = wrap.Button(row.layout(), 'gsCardToCurve_verticalFlip')
                    verticalFlip.setButtonStyle('small')
                    verticalFlip.setLabel('Vertical Flip')
                    verticalFlip.setCheckable(True)
                    verticalFlip.setChecked(self.getBtn('gsCardToCurve_verticalFlip'))

                    horizontalFlip = wrap.Button(row.layout(), 'gsCardToCurve_horizontalFlip')
                    horizontalFlip.setButtonStyle('small')
                    horizontalFlip.setLabel('Horizontal Flip')
                    horizontalFlip.setCheckable(True)
                    horizontalFlip.setChecked(self.getBtn('gsCardToCurve_horizontalFlip'))

                    self.mainButtonGroup.addButton(verticalFlip)
                    self.mainButtonGroup.addButton(horizontalFlip)

            with wrap.Frame(mainColumn.layout(), label='Other:') as otherOptionsFrame:
                otherOptionsFrame.setCollapsible(False)
                otherOptionsFrame.setCollapsed(False)
                reverseCurve = wrap.Button(otherOptionsFrame.getFrameLayout(), 'gsCardToCurve_reverseCurve')
                reverseCurve.setButtonStyle('small')
                reverseCurve.setLabel('Reverse Curve')
                reverseCurve.setCheckable(True)
                reverseCurve.setChecked(self.getBtn('gsCardToCurve_reverseCurve'))

                self.mainButtonGroup.addButton(reverseCurve)

            mainColumn.layout().addWidget(wrap.separator())
            with wrap.Row(mainColumn.layout(), margins=style.scale([0, 3, 0, 3])) as _:
                pass
            mainColumn.layout().addWidget(wrap.separator())
            with wrap.Row(mainColumn.layout()) as row:
                convertSelected = wrap.Button(row.layout(), objName="gsCardToCurve_convertSelected")
                convertSelected.setLabel('Convert Selected')
                convertSelected.clicked.connect(undo(core.cardToCurve))

                cancel = wrap.Button(row.layout())
                cancel.setLabel('Cancel')
                cancel.clicked.connect(self.closeUI)

            self.updateActiveButtons()
            self.saveButtonsState()

    def closeUI(self):
        self.saveButtonsState()
        if mc.workspaceControl(self.uiName, q=1, ex=1):
            if mc.workspaceControl(self.uiName, q=1, vis=1):
                mc.deleteUI(self.uiName)
            else:
                mc.deleteUI(self.uiName)

    def updateActiveButtons(self):
        if self.outputTypeGroup.checkedId() == 1:
            self.matchAttributeFrame.setEnabled(False)
            self.uvMatchOptionsFrame.setEnabled(False)
            self.cardTypeFrame.setEnabled(False)
            mc.optionVar(iv=['GSCT_CardToCurveOutputType', 1])
        else:
            mc.optionVar(iv=['GSCT_CardToCurveOutputType', 0])
            mc.optionVar(iv=['GSCT_CardToCurveCardType', int(not self.warpCards.isChecked())])
            self.matchAttributeFrame.setEnabled(True)
            self.cardTypeFrame.setEnabled(True)
            if WIDGETS['gsCardToCurve_UVs'].isChecked():
                self.uvMatchOptionsFrame.setEnabled(True)
            else:
                self.uvMatchOptionsFrame.setEnabled(False)

    def saveButtonsState(self):
        buttons = self.mainButtonGroup.buttons()
        buttonsDict = {}
        for b in buttons:
            buttonsDict.update({b.objName: b.isChecked()})
        mc.optionVar(sv=['GSCT_CardToCurveOptions', str(buttonsDict)])

    def loadClickedButtons(self):
        return eval(mc.optionVar(q='GSCT_CardToCurveOptions'))


cardToCurveWindow = CardToCurveWindow()


def scaleFactorWindow():
    windowName = SCALE_FACTOR_UI
    if mc.workspaceControl(windowName, q=1, ex=1):
        mc.deleteUI(windowName)
    popOut = CreatePopOut(windowName, "Scale Factor", 300, 95)

    layout = popOut.widgetLayout

    scaleFactor = core.getScaleFactor()
    m_slider = mc.floatSliderGrp('GSCT_scaleFactorSlider',
                                 pre=3, ss=0.01, min=0.01, max=10, fmn=0.001, fmx=1000, f=1,
                                 v=scaleFactor
                                 )

    wrap.MayaSlider(m_slider, layout=layout)

    with wrap.Row(layout) as row:
        saveButton = wrap.Button(row.layout())
        saveButton.setLabel('Save')
        saveButton.clicked.connect(pa(core.saveScaleFactor, windowName, False))
        saveButton.clicked.connect(updateScaleFactorWindow)
        saveAndCloseButton = wrap.Button(row.layout())
        saveAndCloseButton.setLabel('Save & Close')
        saveAndCloseButton.clicked.connect(pa(core.saveScaleFactor, windowName))
        cancelButton = wrap.Button(row.layout())
        cancelButton.setLabel('Cancel')
        cancelButton.clicked.connect(lambda: mc.deleteUI(windowName))

    layout.addWidget(wrap.separator())

    with wrap.Row(layout) as row:
        with wrap.Row(row.layout(), margins=style.scale([2, 0, 2, 0])) as globalRow:
            label = wrap.Label(globalRow.layout())
            label.setLabel("Global:")
            globalValue = mc.optionVar(q=('GSCT_globalScaleFactor'))
            field = wrap.LineEdit("scaleFactorGlobalValue", globalRow.layout())
            field.setText(str(globalValue))
            field.setEnabled(False)
        with wrap.Row(row.layout(), margins=style.scale([2, 0, 2, 0])) as sceneRow:
            label = wrap.Label(sceneRow.layout())
            label.setLabel("Scene:")
            if mc.objExists('gsScaleFactorStorageNode') and mc.attributeQuery('scaleFactor', n='gsScaleFactorStorageNode', ex=1):
                sceneValue = mc.getAttr('gsScaleFactorStorageNode.scaleFactor')
            else:
                sceneValue = "####"
            field = wrap.LineEdit("scaleFactorSceneValue", sceneRow.layout())
            field.setText(str(sceneValue))
            field.setEnabled(False)

        with wrap.Row(row.layout(), margins=style.scale([2, 0, 2, 0])) as sceneRow:
            label = wrap.Label(sceneRow.layout())
            label.setLabel("Selected:")
            if mc.objExists('gsScaleFactorStorageNode') and mc.attributeQuery('scaleFactor', n='gsScaleFactorStorageNode', ex=1):
                sceneValue = mc.getAttr('gsScaleFactorStorageNode.scaleFactor')
            else:
                sceneValue = "####"
            field = wrap.LineEdit("scaleFactorSelectedValue", sceneRow.layout())
            field.setText(str(sceneValue))
            field.setEnabled(False)

    from . import main
    main.checkScriptJobs(SCALE_FACTOR_UI)


def updateScaleFactorWindow():
    WIDGETS["scaleFactorGlobalValue"].setText(str(mc.optionVar(q=('GSCT_globalScaleFactor'))))
    if mc.objExists('gsScaleFactorStorageNode') and mc.attributeQuery('scaleFactor', n='gsScaleFactorStorageNode', ex=1):
        sceneValue = mc.getAttr('gsScaleFactorStorageNode.scaleFactor')
    else:
        sceneValue = "####"
    WIDGETS["scaleFactorSceneValue"].setText(str(sceneValue))


def scaleFactorConversionDialog():
    MESSAGE.warningInView('Curves Without Scale Factor Detected')
    dialog = mc.confirmDialog(
        title='No Scale Factor',
        message='Curves without scale factor detected\nThose Curves were created before v1.2.7 and might not convert correctly',
        icon='warning',
        button=['Skip Old Curves', 'Convert All', 'Cancel'],
        cancelButton='Cancel',
        dismissString='Cancel'
    )
    if dialog == 'Cancel':
        return None
    if dialog == 'Skip Old Curves':
        return 'Skip'
    if 'Convert All':
        return 'All'


def curveThicknessWindow():
    name = 'GSCT_CurveThicknessWindow'
    if mc.workspaceControl(name, q=1, ex=1):
        mc.deleteUI(name)
    popOut = CreatePopOut(name, "Curve Thickness", 300, 65)

    layout = popOut.widgetLayout

    layout.setAlignment(QtCore.Qt.AlignTop)

    m_slider = mc.floatSliderGrp('GSCT_curveThicknessSlider',
                                 pre=3, ss=0.01, min=-1, max=10, fmn=0.001, fmx=1000, f=1,
                                 v=mc.optionVar(q='GSCT_globalCurveThickness')
                                 )

    wrap.MayaSlider(m_slider, layout=layout)

    with wrap.Row(layout, margins=style.scale([0, 5, 0, 0])) as row:
        def save():
            mc.optionVar(fv=('GSCT_globalCurveThickness', mc.floatSliderGrp('GSCT_curveThicknessSlider', q=1, v=1)))
            mc.deleteUI(name)

        def update():
            mc.optionVar(fv=('GSCT_globalCurveThickness', mc.floatSliderGrp('GSCT_curveThicknessSlider', q=1, v=1)))
            core.updateLayerThickness()
        saveButton = wrap.Button(row.layout())
        saveButton.setLabel('Save')
        saveButton.clicked.connect(save)
        updateCurves = wrap.Button(row.layout())
        updateCurves.setLabel('Update Curves')
        updateCurves.clicked.connect(update)
        cancelButton = wrap.Button(row.layout())
        cancelButton.setLabel('Cancel')
        cancelButton.clicked.connect(lambda: mc.deleteUI(name))


def randomizeCurveWindow():
    name = "GSCT_RandomizeCurvePopOut"
    if mc.workspaceControl(name, q=1, ex=1):
        if mc.workspaceControl(name, q=1, vis=1):
            mc.deleteUI(name)
            return
        else:
            mc.deleteUI(name)
    popOut = CreatePopOut(name, "Randomize Curve", 270, 565)

    layout = popOut.widgetLayout
    layout.setAlignment(QtCore.Qt.AlignTop)

    def release(slider, *_):
        core.sliders.randSliderDrag(slider)
        core.sliders.randSliderRelease(slider)
        core.sliders.release()
    # Control Points
    with wrap.Frame(layout, label='Control Points') as frame:
        frame.setCollapsible(False)
        with wrap.Row(frame.getFrameLayout()) as row:
            enable = wrap.Button(row.layout(), 'curveRandomizeSlider0')
            enable.setLabel('Enabled', lineHeight=100)
            enable.setButtonStyle('small')
            enable.setCheckable(True)

            slider = wrap.mayaSlider(mc.floatSliderGrp('gsCurveCVsRandMulti', l='Mult:',
                                                       min=1, max=50, pre=1, step=0.5, cw=[(1, 30), (2, 1)]))
            row.layout().addWidget(slider)

        with wrap.Row(frame.getFrameLayout()) as row:
            lockFirst = wrap.Button(row.layout(), 'gsLockFirstCV')
            lockFirst.setLabel('Lock First CV', lineHeight=100)
            lockFirst.setButtonStyle('small')
            lockFirst.setCheckable(True)

            lockLast = wrap.Button(row.layout(), 'gsLockLastCV')
            lockLast.setLabel('Lock Last CV', lineHeight=100)
            lockLast.setButtonStyle('small')
            lockLast.setCheckable(True)

        with wrap.Row(frame.getFrameLayout()) as row:
            axisX = wrap.Button(row.layout(), 'gsRandAxisX')
            axisX.setLabel('X', lineHeight=100)
            axisX.setButtonStyle('small')
            axisX.setCheckable(True)

            axisY = wrap.Button(row.layout(), 'gsRandAxisY')
            axisY.setLabel('Y', lineHeight=100)
            axisY.setButtonStyle('small')
            axisY.setCheckable(True)

            axisZ = wrap.Button(row.layout(), 'gsRandAxisZ')
            axisZ.setLabel('Z', lineHeight=100)
            axisZ.setButtonStyle('small')
            axisZ.setCheckable(True)

        wrap.MayaSlider(
            mc.floatSliderGrp(
                'gsCurveCVsRand', min=0, max=1, step=0.05,
                dc=pa(core.sliders.randSliderDrag, 0),
                cc=pa(release, 0),
            ),
            layout=frame.getFrameLayout()
        )

    # Rotation
    with wrap.Frame(layout, label='Rotation') as frame:
        frame.setCollapsible(False)
        with wrap.Row(frame.getFrameLayout()) as row:
            enable = wrap.Button(row.layout(), 'curveRandomizeSlider1')
            enable.setLabel('Enabled', lineHeight=100)
            enable.setButtonStyle('small')
            enable.setCheckable(True)

            slider = wrap.mayaSlider(mc.floatSliderGrp('gsCurveRotationRandMulti', l='Mult:',
                                                       min=1, max=50, pre=1, step=0.5, cw=[(1, 30), (2, 1)]))
            row.layout().addWidget(slider)

        with wrap.Row(frame.getFrameLayout()) as row:
            axisX = wrap.Button(row.layout(), 'gsRandRotateAxisX')
            axisX.setLabel('X', lineHeight=100)
            axisX.setButtonStyle('small')
            axisX.setCheckable(True)

            axisY = wrap.Button(row.layout(), 'gsRandRotateAxisY')
            axisY.setLabel('Y', lineHeight=100)
            axisY.setButtonStyle('small')
            axisY.setCheckable(True)

            axisZ = wrap.Button(row.layout(), 'gsRandRotateAxisZ')
            axisZ.setLabel('Z', lineHeight=100)
            axisZ.setButtonStyle('small')
            axisZ.setCheckable(True)

        wrap.MayaSlider(
            mc.floatSliderGrp(
                'gsCurveRotationRand', min=0, max=1, step=0.05,
                dc=pa(core.sliders.randSliderDrag, 1),
                cc=pa(release, 1),
            ),
            layout=frame.getFrameLayout()
        )

    # Orientation
    with wrap.Frame(layout, label='Orientation') as frame:
        frame.setCollapsible(False)
        with wrap.Row(frame.getFrameLayout()) as row:
            enable = wrap.Button(row.layout(), 'curveRandomizeSlider2')
            enable.setLabel('Enabled', lineHeight=100)
            enable.setButtonStyle('small')
            enable.setCheckable(True)

            slider = wrap.mayaSlider(mc.floatSliderGrp('gsCurveOrientationRandMulti', l='Mult:',
                                                       min=1, max=50, pre=1, step=0.5, cw=[(1, 30), (2, 1)]))
            row.layout().addWidget(slider)

        wrap.MayaSlider(
            mc.floatSliderGrp(
                'gsCurveOrientationRand', min=0, max=1, step=0.05,
                dc=pa(core.sliders.randSliderDrag, 2),
                cc=pa(release, 2),
            ),
            layout=frame.getFrameLayout()
        )

    # Twist
    with wrap.Frame(layout, label='Twist') as frame:
        frame.setCollapsible(False)
        with wrap.Row(frame.getFrameLayout()) as row:
            enable = wrap.Button(row.layout(), 'curveRandomizeSlider3')
            enable.setLabel('Enabled', lineHeight=100)
            enable.setButtonStyle('small')
            enable.setCheckable(True)

            slider = wrap.mayaSlider(mc.floatSliderGrp('gsCurveTwistRandMulti', l='Mult:',
                                                       min=1, max=50, pre=1, step=0.5, cw=[(1, 30), (2, 1)]))
            row.layout().addWidget(slider)

        wrap.MayaSlider(
            mc.floatSliderGrp(
                'gsCurveTwistRand', min=0, max=1, step=0.05,
                dc=pa(core.sliders.randSliderDrag, 3),
                cc=pa(release, 3),
            ),
            layout=frame.getFrameLayout()
        )

    # Width
    with wrap.Frame(layout, label='Width') as frame:
        frame.setCollapsible(False)
        with wrap.Row(frame.getFrameLayout()) as row:
            enable = wrap.Button(row.layout(), 'curveRandomizeSlider4')
            enable.setLabel('Enabled', lineHeight=100)
            enable.setButtonStyle('small')
            enable.setCheckable(True)

            slider = wrap.mayaSlider(mc.floatSliderGrp('gsCurveWidthRandMulti', l='Mult:',
                                                       min=1, max=50, pre=1, step=0.5, cw=[(1, 30), (2, 1)]))
            row.layout().addWidget(slider)

        uniform = wrap.Button(frame.getFrameLayout(), 'gsWidthCheckBoxUniform')
        uniform.setButtonStyle('small')
        uniform.setLabel('Uniform', lineHeight=100)
        uniform.setCheckable(True)

        wrap.MayaSlider(
            mc.floatSliderGrp(
                'gsCurveWidthRand', min=0.001, max=1, step=0.05,
                dc=pa(core.sliders.randSliderDrag, 4),
                cc=pa(release, 4),
            ),
            layout=frame.getFrameLayout()
        )

    # Taper
    with wrap.Frame(layout, label='Taper') as frame:
        frame.setCollapsible(False)
        with wrap.Row(frame.getFrameLayout()) as row:
            enable = wrap.Button(row.layout(), 'curveRandomizeSlider5')
            enable.setLabel('Enabled', lineHeight=100)
            enable.setButtonStyle('small')
            enable.setCheckable(True)

            slider = wrap.mayaSlider(mc.floatSliderGrp('gsCurveTaperRandMulti', l='Mult:',
                                                       min=1, max=50, pre=1, step=0.5, cw=[(1, 30), (2, 1)]))
            row.layout().addWidget(slider)

        wrap.MayaSlider(
            mc.floatSliderGrp(
                'gsCurveTaperRand', min=0, max=1, step=0.05,
                dc=pa(core.sliders.randSliderDrag, 5),
                cc=pa(release, 5),
            ),
            layout=frame.getFrameLayout()
        )

    # Profile
    with wrap.Frame(layout, label='Profile') as frame:
        frame.setCollapsible(False)
        with wrap.Row(frame.getFrameLayout()) as row:
            enable = wrap.Button(row.layout(), 'curveRandomizeSlider6')
            enable.setLabel('Enabled', lineHeight=100)
            enable.setButtonStyle('small')
            enable.setCheckable(True)

            slider = wrap.mayaSlider(mc.floatSliderGrp('gsCurveProfileRandMulti', l='Mult:',
                                                       min=1, max=50, pre=1, step=0.5, cw=[(1, 30), (2, 1)]))
            row.layout().addWidget(slider)

        uniform = wrap.Button(frame.getFrameLayout(), 'gsProfileCheckBoxNegative')
        uniform.setButtonStyle('small')
        uniform.setLabel('Allow Negative Values', lineHeight=100)
        uniform.setCheckable(True)

        wrap.MayaSlider(
            mc.floatSliderGrp(
                'gsCurveProfileRand', min=0, max=1, step=0.05,
                dc=pa(core.sliders.randSliderDrag, 6),
                cc=pa(release, 6),
            ),
            layout=frame.getFrameLayout()
        )

    # Selection
    with wrap.Frame(layout, label='Selection') as frame:
        frame.setCollapsible(False)

        enable = wrap.Button(frame.getFrameLayout(), 'curveRandomizeSlider7')
        enable.setLabel('Enabled', lineHeight=100)
        enable.setButtonStyle('small')
        enable.setCheckable(True)

        wrap.MayaSlider(
            mc.floatSliderGrp(
                'gsCurveSelectRand', min=0, max=1, step=0.05,
                dc=pa(core.sliders.randSliderDrag, 7),
                cc=pa(release, 7),
            ),
            layout=frame.getFrameLayout()
        )

    layout.addWidget(wrap.separator())

    with wrap.Row(layout) as row:
        def randomizeClick():
            core.sliders.randSliderDrag(-1)
            core.sliders.randSliderRelease(-1)
            core.sliders.release()
        randomize = wrap.Button(row.layout())
        randomize.setLabel("Randomize")
        randomize.clicked.connect(randomizeClick)

        close = wrap.Button(row.layout())
        close.setLabel("Close")
        close.clicked.connect(lambda: mc.deleteUI(name))