Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-image

Source of release 0.45.1

0.45.1 / src / canvas / layer_masks.lucb

#==============================================================================================
#
#   canvas/layer_masks - Layer masks, clipping and styles
#
#   DESCRIPTION:
#       A layer's mask (made, enabled, linked, copied, edited), clipping to the layer below,
#       and its layer style's values.
#
#==============================================================================================

extend Canvas:
    ## Give a layer a mask, or remove its mask. `fill` is what the new mask
    ## holds: 0 reveals everything, 1 hides everything (Photoshop's Alt-click),
    ## 2 reveals the selection.
    pub func set_mask(id: i64, present: bool, fill: i64 = 0) -> !:
        try self.require_open()
        try self.require_idle()
        try self.remember_state("Layer Mask")
        let index = try self.index((u64)id)
        if fill < 0 or fill > 2:
            error(invalid, "a mask is filled 0 white, 1 black or 2 from the selection")
        if let document = self.document:
            try document.set_mask((u64)id, present)
            if present and fill != 0:
                let mask = (document.find((u64)id) else trap("masked layer")).mask_tiles() else trap("just masked")
                try fill_mask_cells(&self, mask, fill == 2)
        elif present and fill != 0:
            error(invalid, "draw the document once before filling a mask")
        self.records[index].masked = present
        self.records[index].mask_enabled = true
        self.records[index].mask_linked = true
        if not present and self.mask_editing:
            self.mask_editing = false

    pub func layer_masked(index: i64) -> bool!:
        return (try self.record(index)).masked

    ## Disable a layer's mask — kept, hiding nothing — or enable it again.
    pub func enable_mask(id: i64, enabled: bool) -> !:
        try self.require_open()
        try self.remember_state("Disable Mask")
        let index = try self.index((u64)id)
        if not self.records[index].masked:
            error(invalid, "the layer has no mask")
        if let document = self.document:
            try document.enable_mask((u64)id, enabled)
        self.records[index].mask_enabled = enabled

    pub func layer_mask_enabled(index: i64) -> bool!:
        return (try self.record(index)).mask_enabled

    ## Link a layer's mask to its pixels (the default: it moves and transforms
    ## with them) or unlink it (it stays where it is). Undoable.
    pub func link_mask(id: i64, linked: bool) -> !:
        try self.require_open()
        let index = try self.index((u64)id)
        if not self.records[index].masked:
            error(invalid, "the layer has no mask")
        try self.remember_state("Link Mask" if linked else "Unlink Mask")
        self.records[index].mask_linked = linked

    pub func layer_mask_linked(index: i64) -> bool!:
        return (try self.record(index)).mask_linked

    ## Give layer `target` a copy of layer `source`'s mask, replacing any it
    ## has: Photoshop's Alt-drag of a mask thumbnail. Undoable.
    pub func copy_mask(source: i64, target: i64) -> !:
        try self.require_open()
        try self.require_idle()
        let source_index = try self.index((u64)source)
        let target_index = try self.index((u64)target)
        if not self.records[source_index].masked:
            error(invalid, "the layer has no mask to copy")
        let document = self.document else error(invalid, "draw the document once before copying a mask")
        let copied = (document.find((u64)source) else trap("masked layer")).mask_tiles() else trap("masked layer without a mask")
        try self.remember_state("Copy Mask")
        try document.set_mask((u64)target, true)
        var replaced = try document.take_mask((u64)target, try copied.clone())
        replaced.destroy()
        self.records[target_index].masked = true
        self.records[target_index].mask_enabled = true
        self.records[target_index].mask_linked = true

    ## Route strokes to the selected layer's mask instead of its pixels: white
    ## reveals, black hides.
    pub func edit_mask(enabled: bool):
        self.mask_editing = enabled

    ## Whether edits to layer `id` go to its mask: it has one and it is being edited.
    func editing_mask_of(id: i64) -> bool!:
        return self.mask_editing and self.records[try self.index((u64)id)].masked

    pub func editing_mask() -> bool:
        return self.mask_editing

    ## Clip a layer to the nearest unclipped layer below it, or unclip it.
    pub func set_clipped(id: i64, clipped: bool) -> !:
        try self.require_open()
        try self.remember_state("Clipping Mask")
        let index = try self.index((u64)id)
        if let document = self.document:
            try document.set_clipped((u64)id, clipped)
        self.records[index].clipped = clipped

    ## Set one of layer `id`'s style settings, by field (`style_value` lists
    ## them); the compositor draws the effects and the document keeps them.
    pub func set_style_value(id: i64, field: i64, value: f64) -> !:
        try self.remember_state("Layer Style", (u64)id)
        var style = try self.style_of(id)
        try style.set_field(field, value)
        try self.set_style(id, style)

    ## Whether the layer at `index` has any style on.
    pub func layer_styled(index: i64) -> bool!:
        return (try self.record(index)).style.any()

    ## One style setting of the layer at `index`, by field: 0 drop shadow on,
    ## 1 dx, 2 dy, 3 blur, 4..6 color, 7 opacity; 8 stroke on, 9 size, 10..12
    ## color, 13 opacity; 14 outer glow on, 15 size, 16..18 color, 19 opacity;
    ## 20 stroke position (0 outside, 1 centered, 2 inside); 21 color overlay
    ## on, 22..24 color, 25 opacity; 26 inner shadow on, 27 dx, 28 dy, 29 blur,
    ## 30..32 color, 33 opacity. Colors are linear 0..1; sizes in pixels.
    pub func style_value(index: i64, field: i64) -> f64!:
        let style = (try self.record(index)).style
        return style.field(field) else error(invalid, "style fields are 0..33")

    ## How many style fields there are.
    pub static func style_field_count() -> i64:
        return style_field_count

    func style_of(id: i64) -> Style!:
        try self.require_open()
        let index = try self.index((u64)id)
        return self.records[index].style

    ## Every field was checked as it was set (`Style.set_field`).
    func set_style(id: i64, style: Style) -> !:
        let index = try self.index((u64)id)
        if let document = self.document:
            (document.find((u64)id) else error(invalid, "no such layer")).style = style
        self.records[index].style = style

    pub func layer_clipped(index: i64) -> bool!:
        return (try self.record(index)).clipped