'''
    Copyright (C) 2021 - 2025 Akaneyu

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
'''
import bpy
from . import operators
from . import app

def get_icon_id(icon_name):
    session = app.get_session()

    if icon_name in session.icons:
        return session.icons[icon_name].icon_id
    else:
        return 0

def menu_func(self, context):
    area_session = app.get_area_session(context)

    layout = self.layout

    if context.area.spaces.active.mode != 'UV' \
            and context.area.spaces.active.image != None \
            and context.area.spaces.active.image.source != 'VIEWER':

        layout.separator()
        layout.label(text='Image Editor+')

        if area_session.selection:
            layout.operator(operators.IMAGE_EDITOR_PLUS_OT_make_selection.bl_idname, text='Select Box',
                icon_value=get_icon_id('select'))

            layout.operator(operators.IMAGE_EDITOR_PLUS_OT_cancel_selection.bl_idname, text='Deselect',
                icon_value=get_icon_id('deselect'))
        else:
            layout.operator(operators.IMAGE_EDITOR_PLUS_OT_make_selection.bl_idname, text='Select Box',
                icon_value=get_icon_id('select'))

        layout.menu(IMAGE_EDITOR_PLUS_MT_edit_menu.bl_idname, text='Edit')
        layout.menu(IMAGE_EDITOR_PLUS_MT_layers_menu.bl_idname, text='Pasted Layers')
        layout.menu(IMAGE_EDITOR_PLUS_MT_transform_menu.bl_idname, text='Transform')
        layout.menu(IMAGE_EDITOR_PLUS_MT_transform_layer_menu.bl_idname, text='Transform Layer')
        layout.menu(IMAGE_EDITOR_PLUS_MT_offset_menu.bl_idname, text='Offset')
        layout.menu(IMAGE_EDITOR_PLUS_MT_adjust_menu.bl_idname, text='Adjust')
        layout.menu(IMAGE_EDITOR_PLUS_MT_filter_menu.bl_idname, text='Filter')

def reset_scale_properties(self, context):
    if self.reset:
        self.width_pixels = self.original_width
        self.height_pixels = self.original_height
        self.property_unset('width_percent')
        self.property_unset('height_percent')
        self.property_unset('keep_aspect_ratio')
        self.property_unset('scale_layers')

        self.reset = False

def update_scale_width_properties(self, context):
    if self.skip_property_update:
        return

    if self.keep_aspect_ratio:
        self.skip_property_update = True

        ratio = self.original_width / self.original_height
        self.height_pixels = int(self.width_pixels / ratio)
        self.height_percent = self.width_percent

        self.skip_property_update = False

def update_scale_height_properties(self, context):
    if self.skip_property_update:
        return

    if self.keep_aspect_ratio:
        self.skip_property_update = True

        ratio = self.original_width / self.original_height
        self.width_pixels = int(self.height_pixels * ratio)
        self.width_percent = self.height_percent

        self.skip_property_update = False

class IMAGE_EDITOR_PLUS_OT_scale_dialog(bpy.types.Operator):
    """Scale the image"""
    bl_idname = 'image_editor_plus.scale_image_dialog'
    bl_label = "Scale Image"
    reset: bpy.props.BoolProperty(options={'SKIP_SAVE'}, update=reset_scale_properties)
    unit: bpy.props.EnumProperty(options={'SKIP_SAVE'}, items=(
            ('pixels', 'Pixels', 'In pixels'),
            ('percent', 'Percent', 'In percent')))
    width_pixels: bpy.props.IntProperty(name='Width',
        min=1, options={'SKIP_SAVE'},
        update=update_scale_width_properties)
    height_pixels: bpy.props.IntProperty(name='Height',
        min=1, options={'SKIP_SAVE'},
        update=update_scale_height_properties)
    width_percent: bpy.props.FloatProperty(name='Width', subtype='PERCENTAGE',
        min=1.0, soft_max=200.0, default=100.0, options={'SKIP_SAVE'},
        update=update_scale_width_properties)
    height_percent: bpy.props.FloatProperty(name='Height', subtype='PERCENTAGE',
        min=1.0, soft_max=200.0, default=100.0, options={'SKIP_SAVE'},
        update=update_scale_height_properties)
    keep_aspect_ratio: bpy.props.BoolProperty(name='Keep Aspect Ratio', default=True,
            options={'SKIP_SAVE'}, update=update_scale_width_properties)
    scale_layers: bpy.props.BoolProperty(name='Scale Layers', default=True,
            options={'SKIP_SAVE'}, description='Only if Keep Aspect Ratio is turned on')
    original_width: bpy.props.IntProperty()
    original_height: bpy.props.IntProperty()
    skip_property_update: bpy.props.BoolProperty()

    def invoke(self, context, event):
        wm = context.window_manager

        img = context.area.spaces.active.image
        if not img:
            return {'CANCELLED'}

        width, height = img.size

        self.original_width = width
        self.original_height = height
        self.width_pixels = width
        self.height_pixels = height

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        if self.unit == 'pixels':
            width = self.width_pixels
            height = self.height_pixels
        else:   # percent
            width = int(self.original_width * self.width_percent / 100.0)
            height = int(self.original_height * self.height_percent / 100.0)

        if width < 1:
            width = 1
        if height < 1:
            height = 1

        scale_layers = False
        if self.keep_aspect_ratio:
            scale_layers = self.scale_layers

        bpy.ops.image_editor_plus.scale('EXEC_DEFAULT', False,
                width=width, height=height, scale_layers=scale_layers)

        return {'FINISHED'}

    def draw(self, context):
        layout = self.layout

        row = layout.row()
        row.prop(self, "unit", expand=True) 

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Width')

        if self.unit == 'pixels':
            row.prop(self, 'width_pixels', text='')
        else:
            row.prop(self, 'width_percent', text='')

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Height')

        if self.unit == 'pixels':
            row.prop(self, 'height_pixels', text='')
        else:
            row.prop(self, 'height_percent', text='')

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'keep_aspect_ratio')

        row = layout.split(align=True)
        row.column()

        if self.keep_aspect_ratio:
            row.prop(self, 'scale_layers')
        else:
            row.label(text='No layers scaled.')

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def reset_canvas_size_properties(self, context):
    if self.reset:
        self.width = self.original_width
        self.height = self.original_height
        self.expand_from_center = False
        self.use_background_color = False

        self.reset = False

class IMAGE_EDITOR_PLUS_OT_change_canvas_size_dialog(bpy.types.Operator):
    """Change the canvas size"""
    bl_idname = 'image_editor_plus.change_canvas_size_dialog'
    bl_label = "Canvas Size"
    reset: bpy.props.BoolProperty(options={'SKIP_SAVE'}, update=reset_canvas_size_properties)
    width: bpy.props.IntProperty(name='Width',
        min=1, options={'SKIP_SAVE'})
    height: bpy.props.IntProperty(name='Height',
        min=1, options={'SKIP_SAVE'})
    expand_from_center: bpy.props.BoolProperty(name='Expand from Center', default=False)
    use_background_color: bpy.props.BoolProperty(name='Use Background Color', default=False)
    original_width: bpy.props.IntProperty()
    original_height: bpy.props.IntProperty()

    def invoke(self, context, event):
        wm = context.window_manager

        img = context.area.spaces.active.image
        if not img:
            return {'CANCELLED'}

        width, height = img.size

        self.original_width = width
        self.original_height = height
        self.width = width
        self.height = height

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        width = self.width
        height = self.height

        if width < 1:
            width = 1
        if height < 1:
            height = 1

        bpy.ops.image_editor_plus.change_canvas_size('EXEC_DEFAULT', False,
                width=width, height=height, expand_from_center=self.expand_from_center,
                use_background_color=self.use_background_color)

        return {'FINISHED'}

    def draw(self, context):
        layout = self.layout

        row = layout.row()

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Width')
        row.prop(self, 'width', text='')

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Height')
        row.prop(self, 'height', text='')

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'expand_from_center')

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'use_background_color')

        row = layout.split(align=True)
        row.column()

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def reset_offset_properties(self, context):
    if self.reset:
        self.reset = False

    self.offset_properties.property_unset('offset_x')
    self.offset_properties.property_unset('offset_y')
    self.property_unset('offset_edge_behavior')
    update_offset_properties(self, context)

def update_offset_properties(self, context):
    if self.update_preview:
        self.update_preview = False

    bpy.ops.image_editor_plus.offset('EXEC_DEFAULT', False,
            offset_x=self.offset_properties.offset_x,
            offset_y=self.offset_properties.offset_y,
            offset_edge_behavior=self.offset_edge_behavior)

# wrap these properties to change their attributes dynamically
class IMAGE_EDITOR_PLUS_OffsetPropertyGroup(bpy.types.PropertyGroup):
    offset_x: bpy.props.IntProperty()
    offset_y: bpy.props.IntProperty()

class IMAGE_EDITOR_PLUS_OT_offset_dialog(bpy.types.Operator):
    """Offset the image"""
    bl_idname = 'image_editor_plus.offset_dialog'
    bl_label = "Offset"
    update_preview: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=update_offset_properties,
            description='Update preview')
    reset: bpy.props.BoolProperty(options={'SKIP_SAVE'}, update=reset_offset_properties)
    offset_properties: bpy.props.PointerProperty(options={'SKIP_SAVE'},
            type=IMAGE_EDITOR_PLUS_OffsetPropertyGroup)
    offset_edge_behavior: bpy.props.EnumProperty(options={'SKIP_SAVE'}, items=(
            ('wrap', 'Wrap', 'Wrap image around'),
            ('edge', 'Edge', 'Repeat edge pixels')))

    def invoke(self, context, event):
        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img)

        width, height = img.size

        selection = app.get_target_selection(context)
        if selection:
            width = selection[1][0] - selection[0][0]
            height = selection[1][1] - selection[0][1]

        IMAGE_EDITOR_PLUS_OffsetPropertyGroup.offset_x = \
                bpy.props.IntProperty(name='Offset X', subtype='FACTOR',
                min=-width + 1, max=width - 1)

        IMAGE_EDITOR_PLUS_OffsetPropertyGroup.offset_y = \
                bpy.props.IntProperty(name='Offset Y', subtype='FACTOR',
                min=-height + 1, max=height - 1)

        update_offset_properties(self, context)

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.offset('EXEC_DEFAULT', False,
                offset_x=self.offset_properties.offset_x,
                offset_y=self.offset_properties.offset_y,
                offset_edge_behavior=self.offset_edge_behavior)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        layout = self.layout

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'update_preview', text='Update Preview', toggle=True, icon='FILE_REFRESH')

        layout.separator()

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Offset X')
        row.prop(self.offset_properties, 'offset_x', text='')

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Offset Y')
        row.prop(self.offset_properties, 'offset_y', text='')

        row = layout.row()
        row.prop(self, "offset_edge_behavior", expand=True) 

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def reset_adjust_color_properties(self, context):
    if self.reset:
        self.reset = False

    self.property_unset('adjust_hue')
    self.property_unset('adjust_lightness')
    self.property_unset('adjust_saturation')
    update_adjust_color_properties(self, context)

def update_adjust_color_properties(self, context):
    if self.update_preview:
        self.update_preview = False

    bpy.ops.image_editor_plus.adjust_color('EXEC_DEFAULT', False,
            adjust_hue=self.adjust_hue,
            adjust_lightness=self.adjust_lightness,
            adjust_saturation=self.adjust_saturation)

class IMAGE_EDITOR_PLUS_OT_adjust_color_dialog(bpy.types.Operator):
    """Adjust hue/saturation/lightness of the image"""
    bl_idname = 'image_editor_plus.adjust_color_dialog'
    bl_label = "Hue/Saturation"
    update_preview: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=update_adjust_color_properties,
            description='Update preview')
    reset: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=reset_adjust_color_properties)
    adjust_hue: bpy.props.FloatProperty(name='Hue', subtype='FACTOR',
            min=-180, max=180, default=0, options={'SKIP_SAVE'})
    adjust_lightness: bpy.props.FloatProperty(name='Lightness', subtype='PERCENTAGE',
            min=0, max=200, default=100, options={'SKIP_SAVE'})
    adjust_saturation: bpy.props.FloatProperty(name='Saturation', subtype='PERCENTAGE',
            min=0, max=200, default=100, options={'SKIP_SAVE'})

    def invoke(self, context, event):
        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img, need_hsl=True)

        update_adjust_color_properties(self, context)

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.adjust_color('EXEC_DEFAULT', False,
                adjust_hue=self.adjust_hue,
                adjust_lightness=self.adjust_lightness,
                adjust_saturation=self.adjust_saturation)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        layout = self.layout

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'update_preview', text='Update Preview', toggle=True, icon='FILE_REFRESH')

        layout.separator()

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Hue')
        row.prop(self, 'adjust_hue', text='')

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Lightness')
        row.prop(self, 'adjust_lightness', text='')

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Saturation')
        row.prop(self, 'adjust_saturation', text='')

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def reset_adjust_brightness_properties(self, context):
    if self.reset:
        self.reset = False

    self.property_unset('adjust_brightness')
    self.property_unset('adjust_contrast')
    update_adjust_brightness_properties(self, context)

def update_adjust_brightness_properties(self, context):
    if self.update_preview:
        self.update_preview = False

    bpy.ops.image_editor_plus.adjust_brightness('EXEC_DEFAULT', False,
            adjust_brightness=self.adjust_brightness,
            adjust_contrast=self.adjust_contrast)

class IMAGE_EDITOR_PLUS_OT_adjust_brightness_dialog(bpy.types.Operator):
    """Adjust brightness/contrast of the image"""
    bl_idname = 'image_editor_plus.adjust_brightness_dialog'
    bl_label = "Brightness/Contrast"
    update_preview: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=update_adjust_brightness_properties,
            description='Update preview')
    reset: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=reset_adjust_brightness_properties)
    adjust_brightness: bpy.props.FloatProperty(name='Brightness', subtype='PERCENTAGE',
        min=0, max=200, default=100, options={'SKIP_SAVE'})
    adjust_contrast: bpy.props.FloatProperty(name='Contrast', subtype='PERCENTAGE',
        min=0, max=200, default=100, options={'SKIP_SAVE'})

    def invoke(self, context, event):
        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img)

        update_adjust_brightness_properties(self, context)

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.adjust_brightness('EXEC_DEFAULT', False,
                adjust_brightness=self.adjust_brightness,
                adjust_contrast=self.adjust_contrast)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        layout = self.layout

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'update_preview', text='Update Preview', toggle=True, icon='FILE_REFRESH')

        layout.separator()

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Brightness')
        row.prop(self, 'adjust_brightness', text='')

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Contrast')
        row.prop(self, 'adjust_contrast', text='')

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def reset_adjust_gamma_properties(self, context):
    if self.reset:
        self.reset = False

    self.property_unset('adjust_gamma')
    update_adjust_gamma_properties(self, context)

def update_adjust_gamma_properties(self, context):
    if self.update_preview:
        self.update_preview = False

    bpy.ops.image_editor_plus.adjust_gamma('EXEC_DEFAULT', False,
            adjust_gamma=self.adjust_gamma)

class IMAGE_EDITOR_PLUS_OT_adjust_gamma_dialog(bpy.types.Operator):
    """Adjust gamma of the image"""
    bl_idname = 'image_editor_plus.adjust_gamma_dialog'
    bl_label = "Gamma"
    update_preview: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=update_adjust_gamma_properties,
            description='Update preview')
    reset: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=reset_adjust_gamma_properties)
    adjust_gamma: bpy.props.FloatProperty(name='Gamma', subtype='FACTOR',
        min=0.01, soft_max=3.0, default=1.0, options={'SKIP_SAVE'})

    def invoke(self, context, event):
        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img)

        update_adjust_gamma_properties(self, context)

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.adjust_gamma('EXEC_DEFAULT', False,
                adjust_gamma=self.adjust_gamma)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        layout = self.layout

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'update_preview', text='Update Preview', toggle=True, icon='FILE_REFRESH')

        layout.separator()

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Gamma')
        row.prop(self, 'adjust_gamma', text='')

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def reset_adjust_color_curve_properties(self, context):
    if self.reset:
        self.reset = False

    app.reset_curve_mapping()
    update_adjust_color_curve_properties(self, context)

def update_adjust_color_curve_properties(self, context):
    if self.update_preview:
        self.update_preview = False

    bpy.ops.image_editor_plus.adjust_color_curve('EXEC_DEFAULT', False)

class IMAGE_EDITOR_PLUS_OT_adjust_color_curve_dialog(bpy.types.Operator):
    """Adjust color curve of the image"""
    bl_idname = 'image_editor_plus.adjust_curve_dialog'
    bl_label = "Adjust Color Curve"
    update_preview: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=update_adjust_color_curve_properties,
            description='Update preview')
    reset: bpy.props.BoolProperty(update=reset_adjust_color_curve_properties,
            options={'SKIP_SAVE'})

    def invoke(self, context, event):
        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img)

        app.reset_curve_mapping()

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.adjust_color_curve('EXEC_DEFAULT', False)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        layout = self.layout

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'update_preview', text='Update Preview', toggle=True, icon='FILE_REFRESH')

        layout.separator()

        curve_node = app.get_curve_node()

        col = layout.column(align=True)
        col.template_curve_mapping(curve_node, 'mapping', type='COLOR')

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def reset_replace_color_properties(self, context):
    if self.reset:
        self.reset = False

    self.property_unset('source_color')
    self.property_unset('replace_color')
    self.property_unset('color_threshold')
    update_replace_color_properties(self, context)

def update_replace_color_properties(self, context):
    if self.update_preview:
        self.update_preview = False

    bpy.ops.image_editor_plus.replace_color('EXEC_DEFAULT', False,
            source_color=self.source_color,
            replace_color=self.replace_color,
            color_threshold=self.color_threshold)

class IMAGE_EDITOR_PLUS_OT_replace_color_dialog(bpy.types.Operator):
    """Replace one color in the image with another"""
    bl_idname = 'image_editor_plus.replace_color_dialog'
    bl_label = "Replace Color"
    update_preview: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=update_replace_color_properties,
            description='Update preview')
    reset: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=reset_replace_color_properties)
    source_color: bpy.props.FloatVectorProperty(name='Source Color', subtype='COLOR_GAMMA',
            min=0, max=1.0, size=3, default=(1.0, 1.0, 1.0), options={'SKIP_SAVE'})     # no alpha
    replace_color: bpy.props.FloatVectorProperty(name='Replace Color', subtype='COLOR_GAMMA',
            min=0, max=1.0, size=4, default=(0, 0, 0, 1.0), options={'SKIP_SAVE'})
    color_threshold: bpy.props.FloatProperty(name='Threshold', subtype='FACTOR',
            min=0, max=1.0, default=0.1, options={'SKIP_SAVE'})

    def invoke(self, context, event):
        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img)

        update_replace_color_properties(self, context)

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.replace_color('EXEC_DEFAULT', False,
                source_color=self.source_color,
                replace_color=self.replace_color,
                color_threshold=self.color_threshold)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        layout = self.layout

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'update_preview', text='Update Preview', toggle=True, icon='FILE_REFRESH')

        layout.separator()

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Source Color')
        row.prop(self, 'source_color', text='')

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Replace Color')
        row.prop(self, 'replace_color', text='')

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Threshold')
        row.prop(self, 'color_threshold', text='')

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def reset_blur_properties(self, context):
    if self.reset:
        self.reset = False

    self.property_unset('blur_size')
    self.property_unset('expand_layer')
    update_blur_properties(self, context)

def update_blur_properties(self, context):
    if self.update_preview:
        self.update_preview = False

    bpy.ops.image_editor_plus.blur('EXEC_DEFAULT', False,
            blur_size=self.blur_size,
            expand_layer=False)

class IMAGE_EDITOR_PLUS_OT_blur_dialog(bpy.types.Operator):
    """Blur the image"""
    bl_idname = 'image_editor_plus.blur_dialog'
    bl_label = "Blur (Gaussian Blur)"
    update_preview: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=update_blur_properties,
            description='Update preview')
    reset: bpy.props.BoolProperty(options={'SKIP_SAVE'}, update=reset_blur_properties)
    blur_size: bpy.props.FloatProperty(name='Size', subtype='FACTOR',
            min=0, soft_max=10.0, default=3.0, options={'SKIP_SAVE'})
    expand_layer: bpy.props.BoolProperty(name='Expand Layer', default=True, options={'SKIP_SAVE'})

    def invoke(self, context, event):
        session = app.get_session()

        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img)

        layer = app.get_active_layer(context)
        if layer:
            session.cached_layer_location = layer.location[:]

        update_blur_properties(self, context)

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.blur('EXEC_DEFAULT', False,
                blur_size=self.blur_size,
                expand_layer=self.expand_layer)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        layout = self.layout

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'update_preview', text='Update Preview', toggle=True, icon='FILE_REFRESH')

        layout.separator()

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Size')
        row.prop(self, 'blur_size', text='')

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'expand_layer')

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def reset_sharpen_properties(self, context):
    if self.reset:
        self.reset = False

    self.property_unset('sharpen_radius')
    self.property_unset('sharpen_amount')
    self.property_unset('sharpen_threshold')
    update_sharpen_properties(self, context)

def update_sharpen_properties(self, context):
    if self.update_preview:
        self.update_preview = False

    bpy.ops.image_editor_plus.sharpen('EXEC_DEFAULT', False,
            sharpen_radius=self.sharpen_radius,
            sharpen_amount=self.sharpen_amount,
            sharpen_threshold=self.sharpen_threshold)

class IMAGE_EDITOR_PLUS_OT_sharpen_dialog(bpy.types.Operator):
    """Sharpen the image"""
    bl_idname = 'image_editor_plus.sharpen_dialog'
    bl_label = "Sharpen (Unsharp Mask)"
    update_preview: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=update_sharpen_properties,
            description='Update preview')
    reset: bpy.props.BoolProperty(update=reset_sharpen_properties, options={'SKIP_SAVE'})
    sharpen_radius: bpy.props.FloatProperty(name='Radius', subtype='FACTOR',
        min=0, soft_max=10.0, default=3.0, options={'SKIP_SAVE'})
    sharpen_amount: bpy.props.FloatProperty(name='Amount', subtype='FACTOR',
        min=0, soft_max=10.0, default=0.5, options={'SKIP_SAVE'})
    sharpen_threshold: bpy.props.FloatProperty(name='Threshold', subtype='FACTOR',
        min=0, soft_max=1.0, default=0, options={'SKIP_SAVE'})

    def invoke(self, context, event):
        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img)

        update_sharpen_properties(self, context)

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.sharpen('EXEC_DEFAULT', False,
                sharpen_radius=self.sharpen_radius,
                sharpen_amount=self.sharpen_amount,
                sharpen_threshold=self.sharpen_threshold)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        layout = self.layout

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'update_preview', text='Update Preview', toggle=True, icon='FILE_REFRESH')

        layout.separator()

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Radius')
        row.prop(self, 'sharpen_radius', text='')

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Amount')
        row.prop(self, 'sharpen_amount', text='')

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Threshold')
        row.prop(self, 'sharpen_threshold', text='')

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def reset_add_noise_properties(self, context):
    if self.reset:
        self.reset = False

    self.property_unset('add_noise_intensity')
    update_add_noise_properties(self, context)

def update_add_noise_properties(self, context):
    if self.update_preview:
        self.update_preview = False

    bpy.ops.image_editor_plus.add_noise('EXEC_DEFAULT', False,
            add_noise_intensity=self.add_noise_intensity)

class IMAGE_EDITOR_PLUS_OT_add_noise_dialog(bpy.types.Operator):
    """Add some noise to the image"""
    bl_idname = 'image_editor_plus.add_noise_dialog'
    bl_label = "Add Noise (Gaussian Noise)"
    update_preview: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=update_add_noise_properties,
            description='Update preview')
    reset: bpy.props.BoolProperty(options={'SKIP_SAVE'}, update=reset_add_noise_properties)
    add_noise_intensity: bpy.props.FloatProperty(name='Intensity', subtype='FACTOR',
        min=0, soft_max=10.0, default=0.1, options={'SKIP_SAVE'})

    def invoke(self, context, event):
        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img)

        update_add_noise_properties(self, context)

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.add_noise('EXEC_DEFAULT', False,
                add_noise_intensity=self.add_noise_intensity)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        layout = self.layout

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'update_preview', text='Update Preview', toggle=True, icon='FILE_REFRESH')

        layout.separator()

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Intensity')
        row.prop(self, 'add_noise_intensity', text='')

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def reset_pixelize_properties(self, context):
    if self.reset:
        self.reset = False

    self.property_unset('pixelize_pixel_size')
    update_pixelize_properties(self, context)

def update_pixelize_properties(self, context):
    if self.update_preview:
        self.update_preview = False

    bpy.ops.image_editor_plus.pixelize('EXEC_DEFAULT', False,
            pixelize_pixel_size=self.pixelize_pixel_size)

class IMAGE_EDITOR_PLUS_OT_pixelize_dialog(bpy.types.Operator):
    """Pixelize the image"""
    bl_idname = 'image_editor_plus.pixelize_dialog'
    bl_label = "Pixelize"
    update_preview: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=update_pixelize_properties,
            description='Update preview')
    reset: bpy.props.BoolProperty(options={'SKIP_SAVE'}, update=reset_pixelize_properties)
    pixelize_pixel_size: bpy.props.IntProperty(name='Pixel Size', subtype='FACTOR',
            min=1, soft_max=64, default=16, options={'SKIP_SAVE'})

    def invoke(self, context, event):
        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img)

        update_pixelize_properties(self, context)

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.pixelize('EXEC_DEFAULT', False,
                pixelize_pixel_size=self.pixelize_pixel_size)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        layout = self.layout

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'update_preview', text='Update Preview', toggle=True, icon='FILE_REFRESH')

        layout.separator()

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Pixel Size')
        row.prop(self, 'pixelize_pixel_size', text='')

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

def update_make_seamless_properties(self, context):
    bpy.ops.image_editor_plus.make_seamless('EXEC_DEFAULT', False)

class IMAGE_EDITOR_PLUS_OT_make_seamless_dialog(bpy.types.Operator):
    """Turn the image into seamless tile"""
    bl_idname = 'image_editor_plus.make_seamless_dialog'
    bl_label = "Make Seamless"

    def invoke(self, context, event):
        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img)

        update_make_seamless_properties(self, context)

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.make_seamless('EXEC_DEFAULT', False)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        pass

def reset_normal_map_properties(self, context):
    if self.reset:
        self.reset = False

    self.property_unset('scale')
    self.property_unset('flip_x')
    self.property_unset('flip_y')
    self.property_unset('full_z')
    update_normal_map_properties(self, context)

def update_normal_map_properties(self, context):
    if self.update_preview:
        self.update_preview = False

    bpy.ops.image_editor_plus.normal_map('EXEC_DEFAULT', False,
            scale=self.scale,
            flip_x=self.flip_x,
            flip_y=self.flip_y,
            full_z=self.full_z)

class IMAGE_EDITOR_PLUS_OT_normal_map_dialog(bpy.types.Operator):
    """Generate a normal map"""
    bl_idname = 'image_editor_plus.normal_map_dialog'
    bl_label = "Normal Map"
    update_preview: bpy.props.BoolProperty(options={'SKIP_SAVE'},
            update=update_normal_map_properties,
            description='Update preview')
    reset: bpy.props.BoolProperty(options={'SKIP_SAVE'}, update=reset_normal_map_properties)
    scale: bpy.props.FloatProperty(name='Scale', subtype='FACTOR',
            min=0, soft_max=250.0, default=10.0, options={'SKIP_SAVE'})
    flip_x: bpy.props.BoolProperty(name='Flip X', default=False, options={'SKIP_SAVE'})
    flip_y: bpy.props.BoolProperty(name='Flip Y', default=False, options={'SKIP_SAVE'})
    full_z: bpy.props.BoolProperty(name='Full Range for Z', default=False, options={'SKIP_SAVE'})

    def invoke(self, context, event):
        session = app.get_session()

        wm = context.window_manager

        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.cache_image(img, need_hsl=True)

        layer = app.get_active_layer(context)
        if layer:
            session.cached_layer_location = layer.location[:]

        update_normal_map_properties(self, context)

        return wm.invoke_props_dialog(self)

    def execute(self, context):
        bpy.ops.image_editor_plus.normal_map('EXEC_DEFAULT', False,
                scale=self.scale,
                flip_x=self.flip_x,
                flip_y=self.flip_y,
                full_z=self.full_z)

        return {'FINISHED'}

    def cancel(self, context):
        img = app.get_target_image(context)
        if not img:
            return {'CANCELLED'}

        app.revert_image_cache(img)
        app.clear_image_cache()
        app.refresh_image(context)

    def draw(self, context):
        layout = self.layout

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'update_preview', text='Update Preview', toggle=True, icon='FILE_REFRESH')

        layout.separator()

        row = layout.split(align=True)
        row.alignment = 'RIGHT'
        row.label(text='Scale')
        row.prop(self, 'scale', text='')

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'flip_x')

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'flip_y')

        row = layout.split(align=True)
        row.column()
        row.prop(self, 'full_z')

        row = layout.split(factor=0.7)
        row.column()
        row.prop(self, 'reset', text='Reset', toggle=True)

class IMAGE_EDITOR_PLUS_UL_layer_list(bpy.types.UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
        icon_value = 0
        img = bpy.data.images.get(item.name)
        if img:
            icon_value = bpy.types.UILayout.icon(img)

            row = layout.row()

            row.alignment = 'EXPAND'
            row.prop(item, 'label', text='', emboss=False, icon_value=icon_value)

            hide_icon = 'HIDE_ON' if item.hide else 'HIDE_OFF'
            row.prop(item, 'hide', text='', emboss=False, icon=hide_icon)

class IMAGE_EDITOR_PLUS_MT_edit_menu(bpy.types.Menu):
    bl_idname = "IMAGE_EDITOR_PLUS_MT_edit_menu"
    bl_label = "Edit"

    def draw(self, context):
        layout = self.layout

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_fill_with_fg_color.bl_idname, text='Fill with FG Color',
            icon_value=get_icon_id('fill'))

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_fill_with_bg_color.bl_idname, text='Fill with BG Color',
            icon_value=get_icon_id('fill'))

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_clear.bl_idname, text='Clear',
            icon_value=get_icon_id('clear'))

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_cut.bl_idname, text='Cut',
            icon_value=get_icon_id('cut'))

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_copy.bl_idname, text='Copy', icon='COPYDOWN')

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_paste.bl_idname, text='Paste', icon='PASTEDOWN')

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_crop.bl_idname, text='Crop',
            icon_value=get_icon_id('crop'))

class IMAGE_EDITOR_PLUS_MT_layers_menu(bpy.types.Menu):
    bl_idname = "IMAGE_EDITOR_PLUS_MT_layers_menu"
    bl_label = "Pasted Layers"

    def draw(self, context):
        layout = self.layout

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_deselect_layer.bl_idname, text='Deselect Layer',
            icon_value=get_icon_id('deselect'))

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_move_layer.bl_idname, text='Move',
            icon_value=get_icon_id('move'))

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_rotate_layer.bl_idname, text='Rotate',
            icon_value=get_icon_id('rotate'))

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_scale_layer.bl_idname, text='Scale',
            icon_value=get_icon_id('scale'))

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_delete_layer.bl_idname, text='Delete',
            icon='TRASH')

        layout.operator(operators.IMAGE_EDITOR_PLUS_OT_merge_layers.bl_idname, text='Merge Layers',
            icon_value=get_icon_id('check'))

class IMAGE_EDITOR_PLUS_MT_transform_menu(bpy.types.Menu):
    bl_idname = "IMAGE_EDITOR_PLUS_MT_transform_menu"
    bl_label = "Transform"

    def draw(self, context):
        layout = self.layout

        op = layout.operator(operators.IMAGE_EDITOR_PLUS_OT_flip.bl_idname, text='Flip Horizontally',
            icon_value=get_icon_id('flip_horz'))
        op.is_vertically = False

        op = layout.operator(operators.IMAGE_EDITOR_PLUS_OT_flip.bl_idname, text='Flip Vertically',
            icon_value=get_icon_id('flip_vert'))
        op.is_vertically = True

        op = layout.operator(operators.IMAGE_EDITOR_PLUS_OT_rotate.bl_idname, text="Rotate 90\u00b0 Left",
            icon_value=get_icon_id('rot_left'))
        op.is_left = True

        op = layout.operator(operators.IMAGE_EDITOR_PLUS_OT_rotate.bl_idname, text="Rotate 90\u00b0 Right",
            icon_value=get_icon_id('rot_right'))
        op.is_left = False

        op = layout.operator(IMAGE_EDITOR_PLUS_OT_scale_dialog.bl_idname, text='Scale...',
            icon_value=get_icon_id('scale'))

        op = layout.operator(IMAGE_EDITOR_PLUS_OT_change_canvas_size_dialog.bl_idname, text='Canvas Size...',
            icon_value=get_icon_id('scale'))

class IMAGE_EDITOR_PLUS_MT_transform_layer_menu(bpy.types.Menu):
    bl_idname = "IMAGE_EDITOR_PLUS_MT_transform_layer_menu"
    bl_label = "Transform Layer"

    def draw(self, context):
        layout = self.layout

        op = layout.operator(operators.IMAGE_EDITOR_PLUS_OT_flip_layer.bl_idname, text='Flip Horizontally',
            icon_value=get_icon_id('flip_horz'))
        op.is_vertically = False

        op = layout.operator(operators.IMAGE_EDITOR_PLUS_OT_flip_layer.bl_idname, text='Flip Vertically',
            icon_value=get_icon_id('flip_vert'))
        op.is_vertically = True

        op = layout.operator(operators.IMAGE_EDITOR_PLUS_OT_rotate_layer.bl_idname, text="Rotate 90\u00b0 Left",
            icon_value=get_icon_id('rot_left'))
        op.is_left = True

        op = layout.operator(operators.IMAGE_EDITOR_PLUS_OT_rotate_layer.bl_idname, text="Rotate 90\u00b0 Right",
            icon_value=get_icon_id('rot_right'))
        op.is_left = False

        op = layout.operator(operators.IMAGE_EDITOR_PLUS_OT_rotate_layer_arbitrary.bl_idname,
            text="Rotate Arbitrary",
            icon_value=get_icon_id('rotate'))

        op = layout.operator(operators.IMAGE_EDITOR_PLUS_OT_scale_layer.bl_idname, text="Scale",
            icon_value=get_icon_id('scale'))

class IMAGE_EDITOR_PLUS_MT_offset_menu(bpy.types.Menu):
    bl_idname = "IMAGE_EDITOR_PLUS_MT_offset_menu"
    bl_label = "Offset"

    def draw(self, context):
        layout = self.layout

        layout.operator(IMAGE_EDITOR_PLUS_OT_offset_dialog.bl_idname, text='Offset...',
            icon_value=get_icon_id('offset'))

class IMAGE_EDITOR_PLUS_MT_adjust_menu(bpy.types.Menu):
    bl_idname = "IMAGE_EDITOR_PLUS_MT_adjust_menu"
    bl_label = "Adjust"

    def draw(self, context):
        layout = self.layout

        layout.operator(IMAGE_EDITOR_PLUS_OT_adjust_color_dialog.bl_idname, text='Hue/Saturation...',
            icon_value=get_icon_id('adjust'))

        layout.operator(IMAGE_EDITOR_PLUS_OT_adjust_brightness_dialog.bl_idname, text='Brightness/Contrast...',
            icon_value=get_icon_id('adjust'))

        layout.operator(IMAGE_EDITOR_PLUS_OT_adjust_gamma_dialog.bl_idname, text='Gamma...',
            icon_value=get_icon_id('adjust'))

        layout.operator(IMAGE_EDITOR_PLUS_OT_adjust_color_curve_dialog.bl_idname, text='Color Curve...',
            icon_value=get_icon_id('color_curve'))

        layout.operator(IMAGE_EDITOR_PLUS_OT_replace_color_dialog.bl_idname, text="Replace Color...",
            icon='COLOR')

class IMAGE_EDITOR_PLUS_MT_filter_menu(bpy.types.Menu):
    bl_idname = "IMAGE_EDITOR_PLUS_MT_filter_menu"
    bl_label = "Filter"

    def draw(self, context):
        layout = self.layout

        layout.operator(IMAGE_EDITOR_PLUS_OT_blur_dialog.bl_idname, text="Blur...",
            icon_value=get_icon_id('filter'))

        layout.operator(IMAGE_EDITOR_PLUS_OT_sharpen_dialog.bl_idname, text="Sharpen...",
            icon_value=get_icon_id('filter'))

        layout.operator(IMAGE_EDITOR_PLUS_OT_add_noise_dialog.bl_idname, text="Add Noise...",
            icon_value=get_icon_id('filter'))

        layout.operator(IMAGE_EDITOR_PLUS_OT_pixelize_dialog.bl_idname, text="Pixelize...",
            icon_value=get_icon_id('filter'))

        layout.operator(IMAGE_EDITOR_PLUS_OT_make_seamless_dialog.bl_idname, text='Make Seamless...',
            icon_value=get_icon_id('filter'))

        layout.operator(IMAGE_EDITOR_PLUS_OT_normal_map_dialog.bl_idname, text='Normal Map...',
            icon_value=get_icon_id('filter'))

class IMAGE_EDITOR_PLUS_PT_select_panel(bpy.types.Panel):
    bl_label = "Select"
    bl_space_type = "IMAGE_EDITOR"
    bl_region_type = "UI"
    bl_category = "Image Editor+"

    @classmethod
    def poll(cls, context):
        return context.area.spaces.active.mode != 'UV' \
                and context.area.spaces.active.image != None \
                and context.area.spaces.active.image.source != 'VIEWER'

    def draw(self, context):
        area_session = app.get_area_session(context)

        wm = context.window_manager
        props = wm.imageeditorplus_properties

        layout = self.layout

        if area_session.selecting:
            row = layout.row()
            row.enabled = False
            row.operator(operators.IMAGE_EDITOR_PLUS_OT_make_selection.bl_idname, text='Selecting...')
        else:
            if area_session.selection:
                row = layout.row()
                row.operator(operators.IMAGE_EDITOR_PLUS_OT_make_selection.bl_idname, text='Select Box',
                    icon_value=get_icon_id('select'))

                row = layout.row()
                row.operator(operators.IMAGE_EDITOR_PLUS_OT_cancel_selection.bl_idname,
                    text='Deselect',
                    icon_value=get_icon_id('deselect'))
            else:
                row = layout.row()
                row.operator(operators.IMAGE_EDITOR_PLUS_OT_make_selection.bl_idname, text='Select Box',
                    icon_value=get_icon_id('select'))

            if area_session.selection:
                img = context.area.spaces.active.image
                width, height = img.size

                selection = app.get_selection(context)
                x1 = selection[0][0]
                y1 = height - selection[1][1]
                x2 = selection[1][0]
                y2 = height - selection[0][1]

                row = layout.row()
                row.label(text='({}, {}) - ({}, {})'.format(x1, y1, x2, y2),
                    icon_value=get_icon_id('select'))

class IMAGE_EDITOR_PLUS_PT_edit_panel(bpy.types.Panel):
    bl_label = "Edit"
    bl_space_type = "IMAGE_EDITOR"
    bl_region_type = "UI"
    bl_category = "Image Editor+"

    @classmethod
    def poll(cls, context):
        return context.area.spaces.active.mode != 'UV' \
                and context.area.spaces.active.image != None \
                and context.area.spaces.active.image.source != 'VIEWER'

    def draw(self, context):
        wm = context.window_manager
        props = wm.imageeditorplus_properties

        layout = self.layout

        row = layout.split(factor=0.9)
        col = row.column()
        row2 = col.split(align=True)
        row2.prop(props, 'foreground_color', text='') 
        row2.prop(props, 'background_color', text='') 
        row.operator(operators.IMAGE_EDITOR_PLUS_OT_swap_colors.bl_idname, text='', icon='FILE_REFRESH',
                emboss=False)

        fill_clear_box = layout.box()

        row = fill_clear_box.row()
        row.operator(operators.IMAGE_EDITOR_PLUS_OT_fill_with_fg_color.bl_idname, text='Fill',
            icon_value=get_icon_id('fill'))

        row.operator(operators.IMAGE_EDITOR_PLUS_OT_clear.bl_idname, text='Clear',
            icon_value=get_icon_id('clear'))

        copy_paste_box = layout.box()

        row = copy_paste_box.row()
        row.operator(operators.IMAGE_EDITOR_PLUS_OT_cut.bl_idname, text='Cut',
            icon_value=get_icon_id('cut'))

        row.operator(operators.IMAGE_EDITOR_PLUS_OT_copy.bl_idname, text='Copy', icon='COPYDOWN')

        row.operator(operators.IMAGE_EDITOR_PLUS_OT_paste.bl_idname, text='Paste', icon='PASTEDOWN')

        row = layout.row()
        row.operator(operators.IMAGE_EDITOR_PLUS_OT_crop.bl_idname, text='Crop',
            icon_value=get_icon_id('crop'))

class IMAGE_EDITOR_PLUS_PT_layers_panel(bpy.types.Panel):
    bl_label = "Pasted Layers"
    bl_space_type = "IMAGE_EDITOR"
    bl_region_type = "UI"
    bl_category = "Image Editor+"

    @classmethod
    def poll(cls, context):
        return context.area.spaces.active.mode != 'UV' \
                and context.area.spaces.active.image != None \
                and context.area.spaces.active.image.source != 'VIEWER'

    def draw(self, context):
        layout = self.layout

        img = context.area.spaces.active.image
        if img:
            img_props = img.imageeditorplus_properties
            layers = img_props.layers

            row = layout.row()
            row.template_list("IMAGE_EDITOR_PLUS_UL_layer_list", "",
                img_props, "layers", 
                img_props, "selected_layer_index", rows=2)

            if layers:
                row = layout.row()
                row.operator(operators.IMAGE_EDITOR_PLUS_OT_deselect_layer.bl_idname, text='Deselect Layer',
                    icon_value=get_icon_id('deselect'))

                row = layout.split(align=True)
                row.operator(operators.IMAGE_EDITOR_PLUS_OT_move_layer.bl_idname, text='',
                    icon_value=get_icon_id('move'))

                op = row.operator(operators.IMAGE_EDITOR_PLUS_OT_change_image_layer_order.bl_idname, text='',
                    icon="TRIA_UP")
                op.up = True

                op = row.operator(operators.IMAGE_EDITOR_PLUS_OT_change_image_layer_order.bl_idname, text='',
                    icon="TRIA_DOWN")
                op.up = False

                row.operator(operators.IMAGE_EDITOR_PLUS_OT_delete_layer.bl_idname, text='',
                    icon='TRASH')

                row = layout.row()
                row.operator(operators.IMAGE_EDITOR_PLUS_OT_merge_layers.bl_idname, text='Merge Layers',
                    icon_value=get_icon_id('check'))

class IMAGE_EDITOR_PLUS_PT_transform_panel(bpy.types.Panel):
    bl_label = "Transform"
    bl_space_type = "IMAGE_EDITOR"
    bl_region_type = "UI"
    bl_category = "Image Editor+"
    bl_options = {'DEFAULT_CLOSED'}

    @classmethod
    def poll(cls, context):
        return context.area.spaces.active.mode != 'UV' \
                and context.area.spaces.active.image != None \
                and context.area.spaces.active.image.source != 'VIEWER'

    def draw(self, context):
        wm = context.window_manager

        layout = self.layout

        row = layout.split(factor=0.8)
        op = row.operator(operators.IMAGE_EDITOR_PLUS_OT_flip.bl_idname, text='Flip',
            icon_value=get_icon_id('flip_horz'))
        op.is_vertically = False

        op = row.operator(operators.IMAGE_EDITOR_PLUS_OT_flip.bl_idname, text='',
            icon_value=get_icon_id('flip_vert'))
        op.is_vertically = True

        row = layout.split(factor=0.8)
        op = row.operator(operators.IMAGE_EDITOR_PLUS_OT_rotate.bl_idname, text='Rotate',
            icon_value=get_icon_id('rot_left'))
        op.is_left = True

        op = row.operator(operators.IMAGE_EDITOR_PLUS_OT_rotate.bl_idname, text='',
            icon_value=get_icon_id('rot_right'))
        op.is_left = False

        row = layout.row()
        op = row.operator(IMAGE_EDITOR_PLUS_OT_scale_dialog.bl_idname, text='Scale...',
            icon_value=get_icon_id('scale'))

        row = layout.row()
        op = row.operator(IMAGE_EDITOR_PLUS_OT_change_canvas_size_dialog.bl_idname,
            text='Canvas Size...',
            icon_value=get_icon_id('scale'))

class IMAGE_EDITOR_PLUS_PT_transform_layer_panel(bpy.types.Panel):
    bl_label = "Transform Layer"
    bl_space_type = "IMAGE_EDITOR"
    bl_region_type = "UI"
    bl_category = "Image Editor+"
    bl_options = {'DEFAULT_CLOSED'}

    @classmethod
    def poll(cls, context):
        return context.area.spaces.active.mode != 'UV' \
                and context.area.spaces.active.image != None \
                and context.area.spaces.active.image.source != 'VIEWER'

    def draw(self, context):
        wm = context.window_manager

        layout = self.layout

        img = context.area.spaces.active.image
        if img:
            img_props = img.imageeditorplus_properties
            layers = img_props.layers
            selected_layer_index = img_props.selected_layer_index

            if selected_layer_index != -1 and selected_layer_index < len(layers):
                layer = layers[selected_layer_index]

                row = layout.split(align=True)
                row.alignment = 'RIGHT' 
                row.label(text='Location')
                row.prop(layer, 'location', text='')

                row = layout.split(align=True)
                row.alignment = 'RIGHT' 
                row.label(text='Rotation')
                row.prop(layer, 'rotation', text='')

                row = layout.split(align=True)
                row.alignment = 'RIGHT' 
                row.label(text='Scale')
                row.prop(layer, 'scale', text='')

        row = layout.split(factor=0.8)
        op = row.operator(operators.IMAGE_EDITOR_PLUS_OT_flip_layer.bl_idname, text='Flip',
            icon_value=get_icon_id('flip_horz'))
        op.is_vertically = False

        op = row.operator(operators.IMAGE_EDITOR_PLUS_OT_flip_layer.bl_idname, text='',
            icon_value=get_icon_id('flip_vert'))
        op.is_vertically = True

        row = layout.split(factor=0.6)
        op = row.operator(operators.IMAGE_EDITOR_PLUS_OT_rotate_layer.bl_idname, text='Rotate',
            icon_value=get_icon_id('rot_left'))
        op.is_left = True

        row = row.split(factor=0.5)
        op = row.operator(operators.IMAGE_EDITOR_PLUS_OT_rotate_layer.bl_idname, text='',
            icon_value=get_icon_id('rot_right'))
        op.is_left = False

        row.operator(operators.IMAGE_EDITOR_PLUS_OT_rotate_layer_arbitrary.bl_idname, text='',
            icon_value=get_icon_id('rotate'))

        row = layout.row()
        row.operator(operators.IMAGE_EDITOR_PLUS_OT_scale_layer.bl_idname, text='Scale',
            icon_value=get_icon_id('scale'))

class IMAGE_EDITOR_PLUS_PT_offset_panel(bpy.types.Panel):
    bl_label = "Offset"
    bl_space_type = "IMAGE_EDITOR"
    bl_region_type = "UI"
    bl_category = "Image Editor+"
    bl_options = {'DEFAULT_CLOSED'}

    @classmethod
    def poll(cls, context):
        return context.area.spaces.active.mode != 'UV' \
                and context.area.spaces.active.image != None \
                and context.area.spaces.active.image.source != 'VIEWER'

    def draw(self, context):
        wm = context.window_manager

        layout = self.layout

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_offset_dialog.bl_idname, text='Offset...',
            icon_value=get_icon_id('offset'))

class IMAGE_EDITOR_PLUS_PT_adjust_panel(bpy.types.Panel):
    bl_label = "Adjust"
    bl_space_type = "IMAGE_EDITOR"
    bl_region_type = "UI"
    bl_category = "Image Editor+"
    bl_options = {'DEFAULT_CLOSED'}

    @classmethod
    def poll(cls, context):
        return context.area.spaces.active.mode != 'UV' \
                and context.area.spaces.active.image != None \
                and context.area.spaces.active.image.source != 'VIEWER'

    def draw(self, context):
        wm = context.window_manager

        layout = self.layout

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_adjust_color_dialog.bl_idname, text='Hue/Saturation...',
            icon_value=get_icon_id('adjust'))

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_adjust_brightness_dialog.bl_idname, text='Brightness/Contrast...',
            icon_value=get_icon_id('adjust'))

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_adjust_gamma_dialog.bl_idname, text='Gamma...',
            icon_value=get_icon_id('adjust'))

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_adjust_color_curve_dialog.bl_idname, text='Color Curve...',
            icon_value=get_icon_id('color_curve'))

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_replace_color_dialog.bl_idname, text='Replace Color...',
            icon='COLOR')

class IMAGE_EDITOR_PLUS_PT_filter_panel(bpy.types.Panel):
    bl_label = "Filter"
    bl_space_type = "IMAGE_EDITOR"
    bl_region_type = "UI"
    bl_category = "Image Editor+"
    bl_options = {'DEFAULT_CLOSED'}

    @classmethod
    def poll(cls, context):
        return context.area.spaces.active.mode != 'UV' \
                and context.area.spaces.active.image != None \
                and context.area.spaces.active.image.source != 'VIEWER'

    def draw(self, context):
        wm = context.window_manager

        layout = self.layout

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_blur_dialog.bl_idname, text='Blur...',
            icon_value=get_icon_id('filter'))

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_sharpen_dialog.bl_idname, text='Sharpen...',
            icon_value=get_icon_id('filter'))

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_add_noise_dialog.bl_idname, text='Add Noise...',
            icon_value=get_icon_id('filter'))

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_pixelize_dialog.bl_idname, text='Pixelize...',
            icon_value=get_icon_id('filter'))

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_make_seamless_dialog.bl_idname, text='Make Seamless...',
            icon_value=get_icon_id('filter'))

        row = layout.row()
        row.operator(IMAGE_EDITOR_PLUS_OT_normal_map_dialog.bl_idname, text='Normal Map...',
            icon_value=get_icon_id('filter'))
