It is currently Sun Jun 30, 2024 5:17 am


All times are UTC - 5 hours [ DST ]



Post new topic Reply to topic  [ 13 posts ] 
Author Message
 Post subject: Gimp Lambda Lib version 1.0.0 for Script-Fu
PostPosted: Tue Nov 30, 2021 3:42 pm  (#1) 
Offline
GimpChat Member
User avatar

Joined: Oct 23, 2021
Posts: 67
Foreword: this article focus more about the Scheme language implemented in Script-Fu for Gimp 2.10.28.
Scheme is a Lisp dialect that is to say a functional programming language where f(x, y) is noted (f x y). :geek

1. What are the features that Script-Fu supports?

Open the Script-Fu console: Alt+filte(R)s → (S)cript-Fu → (C)onsole
Copy in the clipboard by Ctrl+C the variable *features* between two stars
then paste it in the input area of the Script-Fu console.
Press ENTER to validate the command.
The two stars mean that it is a predefined variable such *pi* 3.141592654 or *seed* 1
*features*

;-> (srfi-0 tinyscheme) is the list returned by Script-Fu.

According to Wikipedia, SRFI stands for Scheme Requests For Implementation.
The number "0" indicates the first level of SRFI.
SRFI-0 by Marc Feeley 1999 is about "Feature-based conditional expansion construct" in short cond-expand.
It is a conditional instruction to build libraries for specific targets for example the target "tinyscheme" that appears in 2nd position of the list returned by *features*.
Attachment:
LegacyLib.jpg
LegacyLib.jpg [ 71.48 KiB | Viewed 2054 times ]

If you edit for example in Notepad++:
C:\Program Files\GIMP 2\share\gimp\2.0\scripts\script-fu.init

you will find how is defined *features* line 684 then two lines after, cond-expand as a macro.

In fact, Script-Fu supports more than SRFI-0 but partially.

Retain that script-fu.init, script-fu-compat.init and plug-in-compat.init are the foundations of the Gimp 2.10.28 legacy library for Script-Fu.
script-fu-compat.init and plug-in-compat.init are more for the compatibility with SIOD for Gimp 2.2 and mainly TinyScheme since Gimp 2.4

The Scheme file extension is .scm
However the legacy library for Script-Fu is implemented in three text file source code .init
The legacy library is automatically loaded at each time that you run Gimp.


Last edited by AlSchemist on Sat Dec 04, 2021 7:47 am, edited 1 time in total.

Share on Facebook Share on Twitter Share on Orkut Share on Digg Share on MySpace Share on Delicious Share on Technorati
Top
 Post subject: Gimp Lambda Lib v1.0.0 for Gimp 2.10.28 Script-Fu
PostPosted: Wed Dec 01, 2021 3:17 pm  (#2) 
Offline
GimpChat Member
User avatar

Joined: Oct 23, 2021
Posts: 67
:drum 2. Introducing Gimp Lambda Lib version 1.0.0 :drum
Attachment:
filemngt-scripts.png
filemngt-scripts.png [ 79.87 KiB | Viewed 1985 times ]

GimpLambdaLib v1.0.0.0 2021 by AlSchemist is a free library for Gimp 2.10.28 Script-Fu that supports more SRFI than the legacy library supplied by default with Gimp.

2.1 Download Gimp Lambda Lib

Where are the source files *.scm? In the AlSchemist's github.
Browse the release: you can freely download the zipped archive of the :arrow: source code V1.0.0.zip under "Assets".

2.2 Install Gimp Lambda Lib
As usual, to install a .scm script, copy the source code in the Gimp script folder of the user:
Copy *.scm "C:\Users\YourUserName\AppData\Roaming\GIMP\2.10\scripts\"

Replace YourUserName with your Windows user name.

Of course, it is not mandatory to copy all scripts *.scm
You could make a progressive integration of the Gimp Lambda Lib step by step :sneak "à la carte". :yesnod

On :pengy consult 2.2. Installing Script-Fus :proppeng

However be sure to begin with script files of rank 0 that is to say beginning with "0". :geek:

2.3 How to know if Gimp Lambda Lib is well installed?

Attachment:
srfi-000-features.png
srfi-000-features.png [ 23.83 KiB | Viewed 1985 times ]

Gimp menu "Filters" > "Script-Fu" > "Console"
:ditto As in the previous post, copy in the clipboard by Ctrl+C the variable *features*
then paste it in the input area of the Script-Fu console.
*features*

;-> (tinyscheme srfi-0 srfi-1 srfi-2 srfi-6 srfi-8 srfi-9 srfi-13 srfi-23 srfi-30 srfi-32 srfi-47 srfi-60 srfi-66 srfi-111) is the list returned by Script-Fu.

The SRFI numbers are a little bit abstract. Consider the supplied source code of rank 1 code-named 1srfi-000-cond-expand.scm
Attachment:
srfi-000-cond-expand.png
srfi-000-cond-expand.png [ 105.15 KiB | Viewed 1985 times ]

1srfi-000-cond-expand.scm explains and fixes the known bug of cond-expand in Gimp 2.10.28 since the "else" part is not implemented in the legacy library script-fu.init

cond-expand tests if a SRFI is implemented or not.
(cond-expand
   (srfi-38   (displayln "srfi-38 is supported!"))
   (else      (displayln "srfi-38 is not supported!"))
)
;-> srfi-38 is not supported! Gimp Lambda Lib does not support SRFI-38 (write-with-shared-structure) :bawl

If you move 1srfi-000-cond-expand.scm to another folder :trash than the Gimp script folder or if you did not yet install the Gimp Lambda Lib, Script-Fu will reply:
;-> #t without any message to really know if SRFI-38 is supported.


Top
 Post subject: #| Multi-line block comment in Script-Fu |#
PostPosted: Thu Dec 02, 2021 3:10 pm  (#3) 
Offline
GimpChat Member
User avatar

Joined: Oct 23, 2021
Posts: 67
3. SRFI-30 Nested Multi-line Comments

The first script 0srfi-030-comment.scm of the Gimp Lambda Lib must be copied in the Gimp script folder of the user
before any other source files of this library.

SRFI-30 by Martin Gasbichler 2002 implements "Nested Multi-line Comments" between "#|" and "|#".
Technically, Gimp Lambda Lib makes the integration of the SRFI-30 in the specific Gimp context of Script-Fu that exposes the system handler *sharp-hook*.
Take a look at the two types of comments in the Script-Fu console:
Attachment:
iconGimpMultiCmt.png
iconGimpMultiCmt.png [ 81.88 KiB | Viewed 1913 times ]

(For the sake of simplicity, it will be no longer mentioned that) you could copy and paste each code in the Script-Fu console then press ENTER key:
#| Return Gimp version
(gimp-version)
|#

;-> #<EOF> is the value of a comment according to Script-Fu.

In Gimp 2.10.28, Script-Fu enables the single line comment starting with ";" until the end of line.
SRFI-30 in Gimp Lambda Lib offers the block comment on several lines.
  • You do not need to insert "; " at each beginning of commented lines.
  • You can comment an entire function or groups of functions between "#|" and "|#".
  • You can comment a function having block or full-line comments: hence the notion of nested comments.

Attachment:
srfi-030-comment.png
srfi-030-comment.png [ 26.27 KiB | Viewed 1913 times ]

#| SRFI-30 #| nested |# multi-line comment
(gimp-version)
|#

;-> #<EOF> is returned by Script-Fu in the console.
The second call of (gimp-version) is in a multi-line block comment.
So instead of "(2.10.28)", Script-Fu replies #<EOF>, which is the value of a comment no matter the type of comment, full-line or multi-line.
#<EOF> is also returned if a parenthesis is missing or if there is a syntax error.

That is why each source code of the Gimp Lambda Lib never ends by a comment to avoid the returned value #<EOF>.
Consult the last line 213 of 0srfi-030-comment.scm
(closure? multiline-comment)

Ask Script-Fu if the function multiline-comment is a closure that is to say a defined function.
;-> #t will reply Script-Fu that is to say :yesnod multiline-comment is well defined in Script-Fu.

The added-value of block multi-line comments in Gimp Lambda Lib is that the main functions are commented with a block comment above define
with an example that you can directly copy and paste in the Script-Fu console like in this thread.
The full-line comment ;-> indicates the expected result.

:help If you have any issue to install or use the Gimp Lambda Lib, or if you wish more explanation about this thread,
do not hesitate to reply with your questions since:

Gimp Chat is the English forum of the Gimp Lambda Lib.


Last edited by AlSchemist on Sun Dec 05, 2021 4:57 am, edited 2 times in total.

Top
 Post subject: Initiation to Script-Fu from beginner to expert
PostPosted: Fri Dec 03, 2021 5:27 pm  (#4) 
Offline
GimpChat Member
User avatar

Joined: Oct 23, 2021
Posts: 67
4. Seeking for deprecated functions

Usage: Gimp menu "Filters" → "Script-Fu" → "Console"

:piano All codes could be copied (Ctrl+C) in the clipboard then pasted (Ctrl+V) in the input zone of the Script-Fu console.
Press the ENTER key.
In this thread, the expected result will be displayed after the green arrow ;->

4.1 Revisiting gimp-procedural-db-query, car and cadr

Do you remember the predicate deprecated?

Firstly, we need the list of deprecated functions asking PDB: Procedural DataBase
(gimp-procedural-db-query ".*" ".*deprecated.*" ".*deprecated.*" ".*" ".*" ".*" ".*")

;-> (204 ("gimp-brushes-get-brush-data" "gimp-drawable-transform-rotate-default" ... "gimp-convert-indexed"))

Script-Fu returns a list with two elements:
  1. the number of deprecated function : 204
  2. the real list of 204 deprecated functions

To get the number of deprecated functions, use car that returns the first element of the given list.
(car (gimp-procedural-db-query ".*" ".*deprecated.*" ".*deprecated.*" ".*" ".*" ".*" ".*"))

;-> 204

To get the list of deprecated functions, use cadr that returns the second element of the given list.
(cadr (gimp-procedural-db-query ".*" ".*deprecated.*" ".*deprecated.*" ".*" ".*" ".*" ".*"))

;-> ("gimp-brushes-get-brush-data" ... "gimp-convert-indexed"))

In fact, cadr is equivalent to:
(car (cdr '(first second third etc)))

;-> second :hi5


Last edited by AlSchemist on Sun Dec 05, 2021 4:58 am, edited 2 times in total.

Top
 Post subject: (Let* ((localVariable1 init1) (localVariable2 ini2)) (body))
PostPosted: Fri Dec 03, 2021 5:34 pm  (#5) 
Offline
GimpChat Member
User avatar

Joined: Oct 23, 2021
Posts: 67
4.2 let* and its local variable(s), display vs. show

We save the list of deprecated functions in a local variable called lstDeprecFnc in a structure called let*.
Let us count the number of deprecated functions so we can compare with the expected value of 204:
(let*   (   (lstDeprecFnc (cadr (gimp-procedural-db-query ".*" ".*deprecated.*" ".*deprecated.*" ".*" ".*" ".*" ".*"))))
   (display "Number of deprecated functions: ") (displayln (length lstDeprecFnc))
)

;-> Number of deprecated functions: 204
The function length returns the number of elements in the given list.

:present If you have installed the Gimp Lambda Lib, you can simplify display and displayln by the generic show:
(let*   (   (lstDeprecFnc (cadr (gimp-procedural-db-query ".*" ".*deprecated.*" ".*deprecated.*" ".*" ".*" ".*" ".*"))))
   (show "Number of deprecated functions: " (length lstDeprecFnc))
)

;-> Number of deprecated functions: 204 :bump


Top
 Post subject: (Let loop ((prm1 init1) (prm2 init2)) (body))
PostPosted: Fri Dec 03, 2021 5:44 pm  (#6) 
Offline
GimpChat Member
User avatar

Joined: Oct 23, 2021
Posts: 67
4.3 let loop and not-pair?

Let us introduce the basic iterator let loop to count the number of deprecated functions:
(let*   (   (lstDeprecFnc (cadr (gimp-procedural-db-query ".*" ".*deprecated.*" ".*deprecated.*" ".*" ".*" ".*" ".*"))))
   (let loop ( (lstWord lstDeprecFnc) (count 0))
      (if (pair? lstWord)
         (loop (cdr lstWord) (+ count 1))
         (begin (display "Number of deprecated functions: ") (displayln count))
)   )   )

;-> Number of deprecated functions: 204
loop is a function that accepts two parameters:
  1. lstWord is initialized with the list of deprecated function lstDeprecFnc
  2. count is a counter initialized with 0
With if (pair? lstWord), we test if the list of words is a pair that is to say a list having at least one element or more.
If the answer is true, in the then part, we call our function loop with:
  • first parameter: the rest of lstWord except its first element thanks to cdr
  • second parameter: our incremented counter (+ count 1)

The else part is reached if the lstWord becomes empty.
We call our two display. Since there are more than one statement, we need to encapsulate them inside (begin ...).

That is why, we prefer the version with the Gimp Lambda Lib introducing not-pair? = (not(pair? ...)) and the generic show :blind without begin.
(let*   (   (lstDeprecFnc (cadr (gimp-procedural-db-query ".*" ".*deprecated.*" ".*deprecated.*" ".*" ".*" ".*" ".*"))))
   (let loop ( (lstWord lstDeprecFnc) (count 0))
      (if (not-pair? lstWord) (show "Number of deprecated functions: " count)
         (loop (cdr lstWord) (+ count 1))
)   )   )

;-> Number of deprecated functions: 204 :bugthumb

We can simplify removing let*:
(let loop ( (lstWord (cadr (gimp-procedural-db-query ".*" ".*deprecated.*" ".*deprecated.*" ".*" ".*" ".*" ".*"))) (count 0))
   (if (not-pair? lstWord) (show "Number of deprecated functions: " count) (loop (cdr lstWord) (+ count 1)))
) ;      test                then part is the result                         else part

;-> Number of deprecated functions: 204 :bump


Top
 Post subject: Level advanced: parsing a function
PostPosted: Fri Dec 03, 2021 6:23 pm  (#7) 
Offline
GimpChat Member
User avatar

Joined: Oct 23, 2021
Posts: 67
4.4 proc->list and slow deprecated-list

Download and install the old iccii-aquabou.scm version 1.3e in the script folder of the user.
Restart Gimp. Then call the Gimp Lambda Lib function that transforms the definition of a function into a list.
(proc->list script-fu-aqua-button2)

;-> (define (script-fu-aqua-button2 ... fond ombre base lum reflh)))
The body of the legacy script-fu-aqua-button2 is enough long to scroll vertically the Script-Fu window.

Hereafter enclosed is the parser seeking for deprecated functions in the definition of the function fnc:
(define (deprecated-list fnc)
   (let*   (   (lstDeprecFnc (cadr (gimp-procedural-db-query ".*" ".*deprecated.*" ".*deprecated.*" ".*" ".*" ".*" ".*"))))
      (let loop ((lstBody (proc->list fnc)) (lstDeprecUsed nil))
         (if (not-pair? lstBody) lstDeprecUsed
            (let*   ((item (car lstBody)))
               (if (symbol? item)
                  (let*   (   (strItem   (symbol->string item))
                           (len      (string-length strItem))
                        )
                     (if (and (> len 5) (not (member strItem lstDeprecUsed)) (member strItem lstDeprecFnc))
                        (loop (cdr lstBody) (cons strItem lstDeprecUsed))
                        (loop (cdr lstBody) lstDeprecUsed)
                  )   )
                  (if (list? item)
                     (loop (cdr lstBody) (loop item lstDeprecUsed))
                     (loop (cdr lstBody) lstDeprecUsed)
)   )   )   )   )   )   )

;-> deprecated-list
In the let loop, the loop function accepts two parameters:
  1. lstBody: the list of the definition of the function fnc initialized with (proc->list fnc)
  2. lstDeprecUsed: the list of deprecated functions used in the body of fnc initialized with nil = '() the empty list.

If item of the list of the body of fnc is a symbol (that is to say a word), we convert it to the string strItem with (symbol->string item).
So we can extract its lenght len with (string-length strItem).

The criteria if (and (> len 5) (not (member strItem lstDeprecUsed)) (member strItem lstDeprecFnc)) means:
  • the lenght len of the string strItem must be superior to 5 characters such as "gimp-something"
  • strItem must not be already known in the list lstDeprecUsed of deprecated functions already found
  • strItem must belong to the list of deprecated function of PDB: (member strItem lstDeprecFnc)

Then part: the criteria matches. strItem is a deprecated function that we insert in the list of results by: (cons strItem lstDeprecUsed)
(loop (cdr lstBody) (cons strItem lstDeprecUsed)) continues to parse the rest of the lstBody with partial result (cons strItem lstDeprecUsed).

Else part: In case where item is not a symbol but a list:
(if (list? item) (loop (cdr lstBody) (loop item lstDeprecUsed))
we loop at two levels:
  1. (cdr lstBody): the rest of the definition of the function fnc
  2. (loop item lstDeprecUsed): since item is a list, we will scan each element of the list called item
This recursive call is extremely powerful. So always use let loop instead of classical while or do.

Finally, if item is not a symbol and not a list, continue with the rest of lstBody with the current result in lstDeprecUsed:
(loop (cdr lstBody) lstDeprecUsed)

Let us call our new function deprecated-list with as parameter the legacy function script-fu-aqua-button2.
Please pay attention that we directly use the name of the legacy function without double quotes.
It is a procedure, a function, a closure but not a string.
(deprecated-list script-fu-aqua-button2)

:hoh What's happening?
Nothing is written and the title of the title of the Script-Fu window becomes: Script-Fu (does not answer) or something like that.
Please wait.
Then...
;-> ("gimp-perspective" "gimp-selection-layer-alpha" "gimp-drawable-set-visible" "gimp-patterns-set-pattern" "gimp-blend" "gimp-gradients-set-gradient" "gimp-image-add-layer" "gimp-palette-set-background" "gimp-palette-set-foreground" "gimp-rect-select" "gimp-ellipse-select" "gimp-patterns-get-pattern" "gimp-gradients-get-gradient" "gimp-palette-get-background" "gimp-palette-get-foreground")

Generally a second call is faster.
So close Gimp, restart it and restore the same running context.

How many times the parser needed to scan this legacy function?
The function time-stat belongs to GimpLambdaLib:
(let*   (   (timeStart   (gettimeofday)))
   (deprecated-list script-fu-aqua-button2)
   (time-stat timeStart (gettimeofday) 1)
)

;-> 27 s 053 ms 816 µs for one run :zzz


Last edited by AlSchemist on Sun Dec 05, 2021 5:03 am, edited 1 time in total.

Top
 Post subject: Gimp Lambda Lib added-values: sorting, dichotomous search
PostPosted: Fri Dec 03, 2021 6:35 pm  (#8) 
Offline
GimpChat Member
User avatar

Joined: Oct 23, 2021
Posts: 67
4.5 Advanced fast deprecated-list with binary search and sorting

The added-value of the Gimp Lambda Lib is that
you can improve the linear search of the function member using dichotomous :sglasses research on sorted list: :geeking
  • heap-sort!: exclamation mark means that the function modifies an existing variable.
  • vector-binary-search using the string<? comparator predicate and the identity function (lambda (str) str)
  • list-sort using the string<? comparator predicate
Into the bargain, vector is faster than list, hence list->vector.
(define (deprecated-list fnc)
   (let*   (   (vPdb   (list->vector (cadr (gimp-procedural-db-query ".*" ".*deprecated.*" ".*deprecated.*" ".*" ".*" ".*" ".*"))))
            (lstFnc   (and (heap-sort! vPdb string<?) ; ascending sort of vPdb for binary research
                     (let loop ((lstBody (proc->list fnc)) (lstDeprecUsed nil))
                        (if (not-pair? lstBody) lstDeprecUsed
                           (let*   ((item (car lstBody)))
                              (if (symbol? item)
                                 (let*   (   (strItem   (symbol->string item))
                                          (len      (string-length strItem))
                                       )
                                    (if (and (> len 5) (not (member strItem lstDeprecUsed))
                                          (vector-binary-search vPdb string<? (lambda (str) str) strItem) #t
                                       )
                                       (loop (cdr lstBody) (cons strItem lstDeprecUsed))
                                       (loop (cdr lstBody) lstDeprecUsed)
                                 )   )
                                 (if (list? item)
                                    (loop (cdr lstBody) (loop item lstDeprecUsed))
                                    (loop (cdr lstBody) lstDeprecUsed)
         )   )      )   )   )   )   )   )
      (list-sort lstFnc string<?)
)   )

;-> deprecated-list

(deprecated-list script-fu-aqua-button2)

;-> ("gimp-blend" "gimp-drawable-set-visible" "gimp-ellipse-select" "gimp-gradients-get-gradient" "gimp-gradients-set-gradient" "gimp-image-add-layer" "gimp-palette-get-background" "gimp-palette-get-foreground" "gimp-palette-set-background" "gimp-palette-set-foreground" "gimp-patterns-get-pattern" "gimp-patterns-set-pattern" "gimp-perspective" "gimp-rect-select" "gimp-selection-layer-alpha")

Close Gimp, restart it and restore the running context to compare with the slow version in the same conditions.
How many times the advanced parser will need to scan this legacy function despite the conversion list to vector and the sorting:
(let*   (   (timeStart   (gettimeofday)))
   (deprecated-list script-fu-aqua-button2)
   (time-stat timeStart (gettimeofday) 1)
)

;-> 2 s 500 ms 395 µs for one run :shock:


Top
 Post subject: Beautify Scheme code with pp: pretty-print
PostPosted: Sat Dec 04, 2021 4:07 pm  (#9) 
Offline
GimpChat Member
User avatar

Joined: Oct 23, 2021
Posts: 67
5. Pretty-print or how to beautify Scheme code

The real difficulty in the List dialects --no matter your level-- is to close correctly each open parenthesis.

5.1 Legacy pretty-print

In 1991, Marc Feeley created the beautifier of source code called pp.scm standing for pretty-print.
To optionally freely download pp.scm from the Indiana repository, you need any FTP software such as the free FileZilla.

The legacy pretty-print begins by three full lines of comments starting with a semicolon in green:
Attachment:
pp-legacy.png
pp-legacy.png [ 26.06 KiB | Viewed 1805 times ]

Marc Feeley defined the de facto standard of presentation of Lisp code:
  • indentation of two spaces between two open parenthesis on consecutive lines:
    (define indent-general 2) ; line 244 of pp.scm

    ;-> indent-general: the constant indent-general has been defined with the value 2
  • the last line of the define must include all closed unaligned parenthesis :roll:
  • Notepad++ colors in red the corresponding open and closed parenthesis
For big unstructured programs, the number of closing parameters could be impressive :huh and subject to errors :2thd during the development.


Top
 Post subject: Gimp Lambda Lib pretty-print
PostPosted: Sat Dec 04, 2021 4:23 pm  (#10) 
Offline
GimpChat Member
User avatar

Joined: Oct 23, 2021
Posts: 67
Gimp Lambda Lib's beautifier: 2pp.scm of rank 2:

:paint2 The modern pretty-print is introduced with one multi-line block comment between "#|" and "|#" in dark blue.
Attachment:
pretty-print.png
pretty-print.png [ 101.39 KiB | Viewed 1805 times ]

  • Note the indentation of 4 spaces = 1 tab between two open parenthesis on consecutive lines.
  • the alignment between open and close parenthesis
    This alignement could be crossed to regroup ending closing parenthesis on only one line.

In seeking for deprecated functions, we already used proc->list:
(proc->list pp-call)

;->
(define (pp-call expr colFrom extra pp-item) (let* ((colAfter (wr (car expr) (pp-par-open colFrom))) (colMargin (- colAfter (remainder colAfter 4)))) (and colFrom (pp-down (cdr expr) colMargin (+ colMargin 4) extra pp-item))))

The resulting list is presented sequentially regrouping all closed unaligned parenthesis.

The beautifier improves the presentation of the code and its readability:
(pp pp-call)

;->
(define (pp-call expr colFrom extra pp-item)
    (let*   (   (colAfter (wr (car expr) (pp-par-open colFrom)))
                (colMargin (- colAfter (remainder colAfter 4)))
            )
        (and colFrom (pp-down (cdr expr) colMargin (+ colMargin 4) extra pp-item))
)   )


  • Note the alignment of open and closed parenthesis for the group of local variables of let*.
  • (and ...) is enough short to close its parenthesis on the same line.
  • There is a cross alignement between the closing parenthesis of define and let*.
  • The BBCode "[code]...[/code]" in Gimp Chat does not render tab = 4 spaces. The tab has been converted to 4 spaces in Notepad++

Unlike the legacy pp, the modern pp has independent subroutines that can be called directly in the Script-Fu console.
In the legacy version, those subroutines are embedded inside a main function. So the running context cannot be simulated.

On the contrary, you can test each subroutine of the modern beautifier in the Script-Fu console to learn how pp works. :coolthup

To be continued... :cu


Top
 Post subject: Re: Gimp Lambda Lib version 1.0.0 for Script-Fu
PostPosted: Sat Dec 04, 2021 5:32 pm  (#11) 
Offline
Administrator
User avatar

Joined: Aug 10, 2012
Posts: 13068
Location: Native to NYC living in Arizona, Gimp 2.8 & 2.10, Win 11 PC.
This is a lot to digest.
:hehe

_________________
Image
"A wise man learns more from a foolish question than a fool can learn from a wise answer"
Image


Top
 Post subject: Re: Gimp Lambda Lib version 1.0.0 for Script-Fu
PostPosted: Sat Dec 04, 2021 10:38 pm  (#12) 
Offline
GimpChat Member
User avatar

Joined: May 24, 2021
Posts: 787
Location: SEA - South East Asia
@AlSchemist, very cool avatar, it suits you perfectly :bigthup
A big :clap for your in-deep explanations and doc, that's a lot of work, also we can feel a true passion behind your post, that's super :coolthup

_________________
Patrice


Top
 Post subject: Re: Gimp Lambda Lib version 1.0.0 for Script-Fu
PostPosted: Sun Dec 05, 2021 5:09 am  (#13) 
Offline
GimpChat Member
User avatar

Joined: Oct 23, 2021
Posts: 67
:tyspin Wallace and PixLab.


Top
Post new topic Reply to topic  [ 13 posts ] 

All times are UTC - 5 hours [ DST ]


   Similar Topics   Replies 
No new posts Attachment(s) SOLVED Wrong version of script running due to folder locn confusion

9

No new posts Installing the Mac version of G'MIC

1

No new posts G'MIC version: 2.9.1 not working...?

2

No new posts G'MIC pre-release version 2.8.3

6

No new posts Attachment(s) Looking for Script Coder to make Script of my VHS effect

2


cron

* Login  



Powered by phpBB3 © phpBB Group