Would be nice if udl3 fix this kind of problems… But I am not sure after these years if udl3 will be realease any day…

Thanks for the info.

Many Thanks for the doc and info !!

the script itself doesn’t do any folding operations it just modifies the eols.
So the bug seems not to be solved by using windows eol therefore
the script isn’t helping either.

Unfortunately there is no way python script can interact with lexers in
a safely manner.

Cheers
Claudia

I have upload a video example of the real problem… the bug u can see in the video is totally random… in any sentence suddenly tha open/close folding mark just is in a wrong place… and just creating new lines it auto fix it… and when you remove those new lines again the mark keeps in the correct place… so strange…

Video url --> https://youtu.be/xZZxKMRjU0w

Many thanks !!!

Peter, now I know why it worked because type and subtype is also configured
as keywords. So my workaround seems to be non-working, just another
coloring rule is active.

Cheers
Claudia

if you haven’t already installed the python script plugin, then please
install it from here instead of using
the plugin manager.

The script looks like this

WIN_EOL = 45001                                                                                    # command id edit->eol conversion->windows
UNIX_EOL = 45002                                                                                   # command id edit->eol conversion->unix 
MAC_EOL = 45003                                                                                    # command id edit->eol conversion->mac

TEXT_INSERT = 1                                                                                    # editor constants
TEXT_DELETE = 2                                                                                    # editor constants

IS_ADA_FILE = False                                                                                # variable to identify ada file

format_dict={FORMATTYPE.WIN:WIN_EOL, FORMATTYPE.UNIX:UNIX_EOL, FORMATTYPE.MAC:MAC_EOL,}            # map fromattype to command id
buffer_dict={}                                                                                     # used to save original format or different source files

def this_is_a_ada_file(_filename):                                                                 # if file ends with either .a or .ada it is
    return True if _filename.endswith(('.a', '.ada')) else False                                   # considered to be an ada file


def callback_BUFFERACTIVATED(args):                                                                # gets called when new file is opened
    global IS_ADA_FILE                                                                             # or tab has been changed
    global ORIGINAL_FROMAT_TYPE                                                                    # 
    bufferid = args['bufferID']
    filename = notepad.getBufferFilename(bufferid)                                                 # get the filename from bufferid and
    if this_is_a_ada_file(filename):                                                               # check if it is an ada file if
        IS_ADA_FILE = True                                                                         #    yes, set file identifier and
        if buffer_dict.get(bufferid, None) is None:                                                #    if it hasn't already saved
            buffer_dict[bufferid] = notepad.getFormatType()                                        #        save eol format of current doc
    else:                                                                                          # otherwise
        IS_ADA_FILE = False                                                                        #    set file identifier to false


def callback_FILEBEFORESAVE(args):                                                                 # gets called before file gets saved
    if IS_ADA_FILE:                                                                                # if it is a ada file
        saved_format = buffer_dict.get(args['bufferID'],None)                                      #    try to get a saved format
        if saved_format is not None:                                                               #    if one was found
            notepad.menuCommand(format_dict.get(saved_format))                                     #        set the original format


def callback_MODIFIED(args):                                                                       # gets called whenever something changes (text, style...)
    if IS_ADA_FILE and (notepad.getFormatType() != FORMATTYPE.WIN):                                # if it is an ada file and eol is not windows then
        mod_type = args['modificationType']                                                        #    get type of modification
        if (mod_type & TEXT_INSERT or mod_type & TEXT_DELETE) and args['text'] != '\r':            #    if it is an insert but not a \r or a delete then
            notepad.menuCommand(WIN_EOL)                                                           #        set the windows eol else ignore it


editor.clearCallbacks()                                                                            # sanity check - just to be sure no callback have 
notepad.clearCallbacks()                                                                           # registered yet

notepad.callback(callback_FILEBEFORESAVE, [NOTIFICATION.FILEBEFORESAVE])                           # register before save callback
notepad.callback(callback_BUFFERACTIVATED, [NOTIFICATION.BUFFERACTIVATED ])                        # register buffer activated callback 
editor.callback(callback_MODIFIED,[SCINTILLANOTIFICATION.MODIFIED])                                # register modify callback 

I hope the comments are clear, basically, every time you open a new file or you switch
a tab it get’s checkd if the file is an ada file by checking it extensions (see code).
If it is and you start modifying the code it checks if windows eol is used and if not
script sets it. If you save the file, it gets checked what the original eol was and then it
resets the eol.

If you create a new script with name startup.py and put the content into it
and you change the python script configuration from LAZY to ATSTARTUP, then
the script gets automatically executed every time you start npp.

If you create a new script with a different name, you need to execute it manually once
every time you start npp.

Let me know if something is unclear.

Cheers
Claudia

the truth you want the truth, well - no idea.

I didn’t check the source code yet - found it by trail and error and
still don’t understand when and how it is working but from the examples
(sourceforge thread) provided I see that this might be a solution.

Cheers
Claudia

What’s the difference betweeen the double-(()) and single-() grouping operators? The UDL 2.1 documentation at http://ivan-radic.github.io/udl-documentation/delimiters/ describes the double-(()) version, but not the single-() version. Is it documented someplace else?

did you try using delimiter 1 with a single bracket configuration?

Open:
(type subtype)

Close:
(EOL)

as it looks like it solves the TYPES issue you mentioned.

In regards to the script - I will post it later this day.

Cheers
Claudia

Open:
((type subtype))

Close:
((EOL))

About the eol bug with that script If I understand well… once u press save it will be saved using original format right ? if so then sounds good for me.

Many Thanks for the support !!!

do you still use two round brackets in delimiter1?
If so, can’t you use just one - seems to solve the type TYPES issue.
In regards to windows/linux eol - what about a solution like

• when file gets modified first -> change to windows eol automatically
• when file gets saved (well, before, in reality) -> switch to unix eol.

This would involve python script plugin. Let me know what you think about.

Cheers
Claudia

https://sourceforge.net/p/notepad-plus/discussion/331754/thread/bfb025d5/?limit=25#ce3b

Many thanks.

as I don’t know ADA, could you provide an example code,
with hints what should be done for each feature?
Also your custom ADA UDL would be helpful, I guess.

Cheers
Claudia

1. Precompilation
2. Function list
3. Code folding
   etc…

It only support “colours” nothing else…

In my custom ada colours, precompilation and function list are working… but code folding is not possible because of UDL is weak against ADA syntax…

:(

not sure if this solves your issue but current release is UDL 2.1.0.12
But may I ask why not using builtin ada langauge support?

Cheers
Claudia