I think that you get a list of all the layers, then scan through that list applying gimp-drawable-get-visible and if it returns TRUE, then add it to a new list.

Kevin

You could just loop through all the layers and check to see which are visible with gimp-item-get-visible, then save those layers in a vector using gimp-image-get-active-layer.

At the end of the script, loop though the vector and make each of stored layers visible again using gimp-item-set-visible. Maybe there is a more efficient way but that's what I would do.

But I don't see the purpose of this unless you are trying to emulate an animation by uncovering the layers one by one?

Probably having different layers opening on a canvas that shows them all simultaneously?
Each layer staying visible on the canvas as they open 1 at a time.

My guess anyways. Could be a lot of uses for that. Loading bars for 1.

To add a new element to a list of elements, you would use 'cons', which is short for "construct". The new element is placed at the front of the list (to avoid having to walk along the length of the list to find its end).

The following code snippet uses "named let" to loop through each of the layers. This is generally considered preferable to using "while" loops since there is no need to use 'set!' to change the state of a variable. Note that I use 'reverse' on the final list of visibles to maintain the top-to-bottom ordering of the layers (this is necessary because 'cons'ing builds the list in reverse order).



Alternately, you could use 'for-each' instead of 'map'. 'for-each' is acceptable whenever you don't care about the result being returned which is the case here; however, I just prefer to use 'map' since it works either way.

Another approach to obtaining the visibles is to use folding. Script-fu's 'foldr' function is not exactly the same as the traditional 'fold-right', but it does serve the same purpose.

Graechan, come to the dark side of python-fu(*)

Otherwise see: http://en.wikipedia.org/wiki/List_comprehension#Scheme

(*) and the the 21th Century, 3rd millenium, etc...

Hi Graechan.
Saulgoode and the others who replied before me have already given you suitable advices on how to proceed, so I have nothing to add in this regard.

However, just one last remark: when you operate in GIMP 2.8 and above and you deal with an image fitted with one or more layer groups, notice that the "gimp-image-get-layers" procedure alone is not enough to detect and list all the layers in the image, since it can only return those placed in the main stack, while omitting the ones embedded in groups at any level of nesting.
So, in that case, you ought to recursively invoke the "gimp-item-get-children" procedure whenever a layer group is detected during the loop in order to make sure to trace every layer in each group.

If you are interested, take a glance at this procedure that I implemented in my "Identify Image Objects" script just for working around the aforesaid limitation of the "gimp-image-get-layers" command, where you can see that it produces the very same type of output, namely a list containing the actual number of layers alongside the array with their identifiers:

Code: Select all

(define (gimp-image-get-nested-layers image)
  (letrec
   ((find-children
     (lambda (layer-ids k n)
       (if (< k n)
           (let* ((layer-k (vector-ref layer-ids k)))
             (append
              (cons layer-k
                    (if (= (car (gimp-item-is-group layer-k)) TRUE)
                        (find-children
                         (car (cdr
                               (gimp-item-get-children layer-k)))
                         0
                         (car (gimp-item-get-children layer-k)))
                        ()))
              (find-children layer-ids (+ k 1) n)))
           ()))))
    (let* ((all-layers
            (apply vector
                   (find-children
                    (car (cdr (gimp-image-get-layers image)))
                    0
                    (car (gimp-image-get-layers image))))))
      (cons (vector-length all-layers)
            (cons all-layers
                  ())))))


Correct. You can remove the active layer from the list with 'delq':


The drawable ID will change if you perform a Merge Down or a Merge Visible Layers. It also changes when certain filters are run (but this is fairly rare). As long as you remove the original drawable's ID from your list of visibles before unhiding them, you should be fine.

Oops! I made a mistake in my code. Here is what it should be (the reference to 'drawable' should be to the first layer in the list of layers):



Sorry about that.