[FlUX] Fawhxl's User Experience - Pre-Release Dev Log [Outdated]

[fawhxldawg]

Alrighty,

So check out the log now:

Spoiler: Journal Frame

Lookin alright!

Though I don't think I like the whole entry buttons changing colors like it does, I may adjust that some how...
Maybe like a square in the middle of the button that shows the entry's color instead just because it is a bit ugly tbh with how it is now.
And probably won't do the gradient with that color, (I did the gradient by extracting each rgb value and then halving it, so that
way it matched how the rest of the frame does gradients but eh, if I don't make the whole button change colors then I might
just make it a solid color instead)

Anyways,

The big behemoth I've been avoiding working on, the component outlined in red, the text area.

Also wanted to point out again, since somewhere in my older posts I mentioned that the text area
and the input field at the top are actually separate components and not the same. I thought about
making them the same component but I figured it'd be best not to.

These components already sometimes require hefty inits and I don't really want to make them heftier.

Because sometimes you only need a simple text field for specific, quick and short input, so thus,
I keep them different components. initing a whole text area loaded with additional features just
to use it as a little input field rubs me the wrong way.

That said,

I'm not really satisfied with my string/input handling and will probably be reworking a lot of that as
I work on the text area and re-incorporate a new and improved way of handling string input into the
text field.

This of course is another thing that requires a lot of work because there's a lot of controls and features
you want and users expect when it comes to text input. Text selection, copy/cut/paste and carot navigation.
(Something my text field doesn't actually do, and why when I finish with the text area I will incorporate some
of that new logic into the text field as well as replacing the older more basic input logic)

I almost want to give up and outsource/import this part because it gives me a headache just thinking about
and the stuff I gotta do to make decent enough text editor stuff for my GUI...

Spoiler: Random Motivational Tangent

NO!

We don't do it because it is easy...
We don't cut corners for a quick buck...
We don't do it for money...
We don't give up because its hard...
We don't wait for someone else...

WE DO IT BECAUSE WE CAN!
WE DO IT BECAUSE WE WANT!
WE DO IT BECAUSE WE CARE!

WE DO IT BECAUSE IT HAS TO BE THE BEST!

Anyways there's my pep talk to myself to share with you guys,
I actually feel better now ;p, was getting a little unmotivated for a sec because I know this is going to be a challenge for me.

 

[fawhxldawg]

Alright,

UPCOMING RELEASE ANNOUNCEMENT:

Got exciting news,

I'm going to prepare an alpha release of this GUI system I'm officially calling.

FlUX (FawhxL's User EXperience)

I still have to finish the multi-line text solution,
i want to make it robust enough since it will likely
be the core system behind all input/string related
handling for the GUI.

Think of me basically making a notepad for my GUI and making it
modular to where you can have any text areas you want and init them
appropriately for their desired use cases.

After that then I'm going to start converting my code to the actual studio
format. (since I've been working in GMEdit in the browser)

While I'm doing that conversion I should be able to polish up the code,
comment and make some last minute adjustments to help others understand
how to use it.

I will also need to develop documentation for the GUI system because there
are a lot of moving parts to cover. I'll probably still release the alpha version
of this before the documentation is complete but at least people will be able
to start messing with it and working with it.

Though I do expect there to be some growing pains with the initial release,
There's still a great many improvements to be made with this system, bugs to
be fixed and edge case testing to be performed.

As long as everything is set up right for now the GUI should be able to do what
anyone wants it to do, it will just be a matter of debugging unexpected behavior
initially, but otherwise, despite some clunkiness should still be very useful for
devs and hopefully save a lot of time while providing a decent looking and
functional GUI.

I'm personally more of a utilitarian kind of guy so my design philosophy is typically
functionality first.

I guess this is more then just a GUI as it kind of includes a toolkit,
but again there will still be a lot more work needed to be done.

I will be releasing two versions of this GUI system.

A free and paid version (2.00 bucks) or maybe even a pay what you want type model,
and the only stipulations being if you don't donate at least 2 bucks you have to put
me in your credits and any other significant contributors (which I'll get into in a sec).

So as the nature of selling code on the marketplace, we're open source obviously,
and again, I'll get the specific licensing I want to use but anyone is open to modify,
change, add, and such to the code HOWEVER I want to retain the right to add your code
to my branch, obviously we can talk about things but if you make contributions to the
code and you will get credit for your contributions and we'll talk about royalties depending
on the extent of your contributions.

If you want to take what I have and make your own unique system with it you may but
I'll also like to request royalties and perhaps sharing our code incase you do something really
cool with it and I want to incorporate it into my branch again, we can come up for negotiations
at that point and figure out what will make us a both happy.

Anyways, I don't imagine this getting any bigger than a couple of people using my GUI for
a short while especially since GMS is coming out with their own system. It'll be nice to
have the options I suppose.

What are your thoughts on how I'm handling the release? Is it agreeable? I hate to sound
like I'm tooting my own here but I am excited for my first major (for me its major) release.

Anyways still a lot of work to be done and timeline wise I think I will be nearing the public
release of an alpha build in about a month.

I don't expect to be in alpha long, as once the system is made more robust and debugged,
and unexpected behavior is phased out I'll call it beta, and I don't expect to be in the beta
for too long either, just until most every potential function or component for the GUI is finished,
which I don't think will be much as we already do have a lot of the functionality most games would
need GUI wise.

In a few months I think we'll be able to call it a v1.0 and officially stable.

If you are interested in a 3rd party GUI system that will be regularly maintained and updated,
receive new features and on going development of new GUI elements then FlUX is for you . I hope
to be a helpful asset in your own future success.

Thanks,
FXL

 

[fawhxldawg]

It's been a good ride, can't believe it has been almost half a year since I started this.

Spoiler: Text Area

Alright so as you see I'm making good progress on the text area,
it is still early but there's the idea.

Looks good, the typing is responsive and fast.

It'd be GREAT to actually use a custom font but I can't in the GMEdit
so blurry default font it is for now lol.

Soon enough there'll be custom fonts that look better.

I still need to make the text area scrollable and most importantly,
get the carot working and do the carot navigation (like controls you'd expect in
any text editor).

It'll also have to be drawn on a surface so I can do smooth scrolling
but I already have a quick method of drawing things to surfaces so that'll be easy.

The hard part for me will be drawing the carot lol. I've always had such a hard time getting
multi-line carots to work right.

I hope everyone is ok with my personal preference of a block style carot for now lol.

Anyways,

To accomplish this text area, I'm using a list of lists. Each list in the list is a list of the characters
per line break or "\n". Words will wrap as you see so not each line is a list per se, but each line
break actually typed in by the user is. (When you press enter, it adds a \n to the list where the breaks at).

I'm using a variable 2d list essentially to store each character since it already keeps things ordered,
I can delete and insert into the lists easily and is fairly resource friendly for this task.

Maybe later I'll look into changing the lists into structs because maybe there's a way to make
the text formattable per character, but until then areas will only be able to use the same formatting throughout.

Also I realize a lot of people probably won't like this manual journal/quest log I'm doing.

But eh, it's better than nothing and at least is a starting point if they want to make it into an automated quest log.

I can eventually automate the journal here too, maybe make it an option to have it manual or automatically filled.

 

[fawhxldawg]

Making good progress on the string handling.

So I'm holding nothing back, I'm going to support fully functional text editing with the text areas.

I'm drawing the text now in a way that it draws per char, because I will be able to introduce
controls, checks and such as I iterate through each char.

This is important that I handle each char individually because in order support to more advanced
string manipulation I'm going to need to take a look at each char at a time.

This will support things like inserting/deleting chars in the middle of the string, navigating the
carot to desired spots in the string, making changes, as well as selecting, copying and pasting
text. With the bonus of any future ideas for functionality easier to append.

However I'm getting caught up troubleshooting my station for my actual work so I'm getting distracted.

Sigh have to actually focus on my job atm ;p.

 

[fawhxldawg]

Alright a little weekend update,

Spoiler: Text Area Basic Demo

So here I'm just showing what I got working so far for the Text Area.

The real big part is down, input, parse and string handling.

Text will wrap as you'd expect, carot stays aligned with text,
can hold keys down for increasingly faster repeated input,
line breaks, all the super basic stuff.

Also shoutout to @CMAllen for helping me understand
how surface drawing works, my 0 alpha surface blending
with my anti-aliased text was causing my text to look blurry and
transparent.

I wasn't able to use blendmodes to help me because I'm thinking
the browser editor will only use bm_normal even
if I try to change it.

So generally when I'm using surfaces I'm only drawing what I need
to them, in this case it was just the text and carot.

but because of the previously stated issue of the transparent surface
blending with my text I had to work around it by drawing the my
text area's background onto the surface (where before I tried to keep
as much as possible on the application surface, like the backgrounds
of components) then I had to disable the alpha channel when I drew
the text... Anyways looks great now thanks again @CMAllen !


And you know what, if you've been lurking and are interested in this UI
system you're going to become familiar with the source code anyway,
so I might as well show you this text area drawing script so you can get
an idea of what to expect.

(Note: I have a lot of cleaning up to do with my code after this, as well
as make my code more readable for others and also add more comments
to help others understand what they're looking at, ohhh the joys of reading
other people's code)

(Another Note: I use a lot of global variables as macros and global maps,
and local maps as well as other DS, all of the maps will be changed to structs
once I start converting it in GMS2 Studio, the accessor for structs doesn't work
in the browser editor so that is why I'm using maps.)

(Last Note: I use a lot of enums and compressed variable names. When I go about
getting ready to release the alpha I will be uncompressing my variable names
for again, readability purposes as a lot of the stuff I do is just how I'm used to
it and I'm 90% self-taught lol, so expect me to stray from conventions if you're
a student or professional in programming)

Spoiler: multi_field_draw()

#region Params & CFGs
   
    var cmp = argument0
    var cStr = cmp[?k.str_cfg]
    var crt = cmp[?k.carot_cfg]
   
#endregion

#region Text
   
    #region Keyboard Input to String Config
       
        // Init
        var listy = ds_list_size(cStr[?k.list_2d])-1
        var listx = ds_list_size(cStr[?k.list_2d][|listy])
       
        if(cmp[?k.selected]) {
           
            if(cStr[?k.type] == inp.num and kb_str != "-") {
                cStr[?k.str] = string_num(kb_str)
            } else if(cStr[?k.type] == inp.posnum) {
                cStr[?k.str] = string_posnum(kb_str)
            } else if(cStr[?k.type] == inp.negnum and kb_str != "-") {
                cStr[?k.str] = string_negnum(kb_str)
            } else if(cStr[?k.type] == inp.alpha) {
                cStr[?k.str] = string_alpha(kb_str)
            } else if(cStr[?k.type] == inp.alphanum) {
                cStr[?k.str] = string_alphanum(kb_str)
            } else cStr[?k.str] = kb_str
            kb_str = cStr[?k.str]
           
            // Add to list
            if(kb_str != "") {
               
                cStr[?k.list_2d][|listy][|listx] = kb_str
                kb_str = ""
               
            }
           
            if(kbNTRp) {
               
                kb_str += lb
                cStr[?k.list_2d][|ds_list_size(cStr[?k.list_2d])-1][|ds_list_size(cStr[?k.list_2d][|ds_list_size(cStr[?k.list_2d])-1])] = kb_str
                ds_list_add(cStr[?k.list_2d],ds_list_create())
                kb_str = ""
                cStr[?k.str] = ""
               
            } else if(kbBKp) {
               
                if(!ds_list_empty(cStr[?k.list_2d][|listy]))
                    ds_list_delete(cStr[?k.list_2d][|listy],listx-1)
                else if(ds_list_empty(cStr[?k.list_2d][|listy]) and listy > 0) {
                   
                    var listx2 = ds_list_size(cStr[?k.list_2d][|listy-1])
                   
                    ds_list_destroy(cStr[?k.list_2d][|listy])
                    ds_list_delete(cStr[?k.list_2d],listy)
                    ds_list_delete(cStr[?k.list_2d][|listy-1],listx2-1)
                   
                }
               
            } else if(kb_heldi > room_speed/2) {
               
                #region Repeat Input Logic
                   
                    if(kb_heldi < room_speed*2.5) {
                       
                        if(kbBK and rf%5 == 0) {
                           
                            if(!ds_list_empty(cStr[?k.list_2d][|listy]))
                                ds_list_delete(cStr[?k.list_2d][|listy],listx-1)
                            else if(ds_list_empty(cStr[?k.list_2d][|listy]) and listy > 0) {
                               
                                var listx2 = ds_list_size(cStr[?k.list_2d][|listy-1])
                               
                                ds_list_destroy(cStr[?k.list_2d][|listy])
                                ds_list_delete(cStr[?k.list_2d],listy)
                                ds_list_delete(cStr[?k.list_2d][|listy-1],listx2-1)
                               
                            }
                           
                        }
                       
                    } else if (kb_heldi < room_speed*5) {
                       
                        if(kbBK and rf%2 == 0) {
                           
                            if(!ds_list_empty(cStr[?k.list_2d][|listy]))
                                ds_list_delete(cStr[?k.list_2d][|listy],listx-1)
                            else if(ds_list_empty(cStr[?k.list_2d][|listy]) and listy > 0) {
                               
                                var listx2 = ds_list_size(cStr[?k.list_2d][|listy-1])
                               
                                ds_list_destroy(cStr[?k.list_2d][|listy])
                                ds_list_delete(cStr[?k.list_2d],listy)
                                ds_list_delete(cStr[?k.list_2d][|listy-1],listx2-1)
                               
                            }
                           
                        }
                       
                    } else {
                       
                        if(kbBK) {
                           
                            if(!ds_list_empty(cStr[?k.list_2d][|listy]))
                                ds_list_delete(cStr[?k.list_2d][|listy],listx-1)
                            else if(ds_list_empty(cStr[?k.list_2d][|listy]) and listy > 0) {
                               
                                var listx2 = ds_list_size(cStr[?k.list_2d][|listy-1])
                               
                                ds_list_destroy(cStr[?k.list_2d][|listy])
                                ds_list_delete(cStr[?k.list_2d],listy)
                                ds_list_delete(cStr[?k.list_2d][|listy-1],listx2-1)
                               
                            }
                           
                        }
                       
                    }
                   
                #endregion
               
            }
           
        }
       
    #endregion
   
    #region Init Draw
       
        var a
        if(!cmp[?k.active]) a = cmp[?k.fga]/2
        else a = cmp[?k.fga]
        draw_set_halign(cStr[?k.hvalign][0])
        draw_set_valign(cStr[?k.hvalign][1])
       
    #endregion
   
    #region Init Txt vars
       
        // X/Y Init as Middle/Center
        var txtx = ((cmp[?k.xy][2]-cmp[?k.xy][0])/2)
        var txty = ((cmp[?k.xy][3]-cmp[?k.xy][1])/2)
       
        // Otherwise Init XY according to alignment
        if(cStr[?k.hvalign][0] == fa_left) txtx = cStr[?k.marginx]
        else if(cStr[?k.hvalign][0] == fa_right) txtx = cmp[?k.w]-cStr[?k.marginx]
        if(cStr[?k.hvalign][1] == fa_top) txty = cStr[?k.marginy]
        else if(cStr[?k.hvalign][1] == fa_bottom) txty = cmp[?k.h]-cStr[?k.marginy]
       
    #endregion
   
    #region Setup Surface
       
        // Doing this here so we can also draw carot to surface.
        var w = cmp[?k.xy][2] - cmp[?k.xy][0]
        var h = cmp[?k.xy][3] - cmp[?k.xy][1]
        cmp[?k.surf_wh] = [w-1,h-1]
        cmp[?k.surf_id] = ds_map_size(SM)
        SM[?cmp[?k.surf_id]] = surface_create(cmp[?k.surf_wh][0],cmp[?k.surf_wh][1])
        surface_set_target(SM[?cmp[?k.surf_id]])
        cmp[?k.surf_xy] = [cmp[?k.xy][0]+1,cmp[?k.xy][1]+1]
        sxy = cmp[?k.surf_xy]
       
    #endregion
   
    #region Draw Body
       
        // BG
        draw_set_alpha(cmp[?k.bga])
        draw_rectangle_color(-1,-1,cmp[?k.surf_wh][0],cmp[?k.surf_wh][1],
            cmp[?k.bgc][0],cmp[?k.bgc][1],cmp[?k.bgc][2],cmp[?k.bgc][3],f)
       
        // Outline
        if(!cmp[?k.active]) draw_set_alpha(cmp[?k.fga]/2)
        else draw_set_alpha(cmp[?k.fga])
        draw_rectangle_color(0,0,cmp[?k.surf_wh][0]-1,cmp[?k.surf_wh][1]-1,
            cmp[?k.fgc][0],cmp[?k.fgc][1],cmp[?k.fgc][2],cmp[?k.fgc][3],t)
       
    #endregion
   
    #region Parse String Config
       
        // Init Y Loop
        var txtw = (cmp[?k.xy][2]-cmp[?k.xy][0])-(cStr[?k.marginx]*2)
        var txth = (cmp[?k.xy][3]-cmp[?k.xy][1])-(cStr[?k.marginy]*2)
        var lh = ds_list_size(cStr[?k.list_2d])
        var yy = txty
        var line_all = ""
        var line = ""
        var word = ""
        var ls = 0
        for(var iy = 0; iy < lh; iy++) {
           
            // Init X Loop
            var lw = ds_list_size(cStr[?k.list_2d][|iy])
            var xx = txtx
            for(var ix = 0; ix < lw; ix++) {
               
                // Init
                var c = cStr[?k.list_2d][|iy][|ix]
               
                if(line == "" and string_width(word)+string_width(c) >= txtw) {
                   
                    // Wrap/Next Line
                    ls += 1
                    line_all += word + lb
                    word = c
                    yy += sep.txt
                    xx = txtx
                   
                } else if(c = " ") {
                   
                    line += word + c
                    word = ""
                   
                } else word += c
               
                if(string_width(line)+string_width(word) >= txtw) {
                   
                    // Wrap/Next Line
                    ls += 1
                    line_all += line + lb
                    line = ""
                    yy += sep.txt
                    xx = txtx+string_width(word)
                   
                } else xx += string_width(cStr[?k.list_2d][|iy][|ix])
               
                if(dbg_txt_in) {
               
                    trace("Line : " + line)
                    trace("Word : " + word)
                    trace("Char : " + c)
                    trace(list_to_array(cStr[?k.list_2d][|iy]))
                    trace("")
               
                }
               
            }
           
            #region Carot
               
                // Normal Text (TOP LEFT TO BOTTOM RIGHT)
                if((cStr[?k.hvalign][0] == fa_top)
                    and (cStr[?k.hvalign][1] = fa_left)
                    and cmp[?k.selected] and cmp[?k.active]
                    and iy == lh-1) {
                   
                    crt[?k.xy] = []
                    crt[?k.xy][0] = xx+1
                    crt[?k.xy][1] = yy+3
                    crt[?k.xy][2] = crt[?k.xy][0]+(sep.txtw*1.2)
                    crt[?k.xy][3] = crt[?k.xy][1]+(sep.txt*.65)
                    var cxy = crt[?k.xy]
                   
                    if(rf > room_speed*.5 ) {
                       
                        draw_rectangle_color(cxy[0],cxy[1],cxy[2],cxy[3],cmp[?k.fgc][0],
                            cmp[?k.fgc][1],cmp[?k.fgc][2],cmp[?k.fgc][3],f)
                           
                    }
                   
                }
               
            #endregion
           
            // Next line
            if(iy < lh) {
               
                // Wrap/Next Line
                ls += 1
                line_all += line + word
                line = ""
                word = ""
                yy += sep.txt
                xx = txtx
               
            }
           
        }
       
    #endregion
   
    #region Draw Text to Surface
       
        // Draw text to surface
        gpu_set_colorwriteenable(t,t,t,f)
        draw_text_ext_transformed_color(txtx,txty,line_all+word,sep.txt,cmp[?k.w],1,1,0,
            cmp[?k.fgc][0],cmp[?k.fgc][1],cmp[?k.fgc][2],cmp[?k.fgc][3],1)
        gpu_set_colorwriteenable(t,t,t,t)
       
    #endregion
   
    #region Draw/Reset Surface
       
        // Draw Surface and Reset
        surface_reset_target()
        draw_set_alpha(1)
        draw_surface(SM[?cmp[?k.surf_id]],sxy[0],sxy[1]+1)
        sxy = [0,0]
       
    #endregion

#endregion

#region Interaction/Hilight Logic
   
    var in_cmp = t // Used to return if mouse is inside button
    if(mx-sxy[0] > cmp[?k.xy][0]-sep.sm and mx-sxy[0] < cmp[?k.xy][2]+sep.sm
        and my-sxy[1] > cmp[?k.xy][1]-sep.sm and my-sxy[1] < cmp[?k.xy][3]+sep.sm
        and cmp[?k.active] and !GFMO and !cmp[?k.override]) {
       
        // Draw
        if(mbl) draw_set_alpha(cmp[?k.fga]*.0625)
        else draw_set_alpha(cmp[?k.fga]*.125)
        draw_rectangle_color(cmp[?k.xy][0],cmp[?k.xy][1],cmp[?k.xy][2],cmp[?k.xy][3],
            cmp[?k.fgc][0],cmp[?k.fgc][1],cmp[?k.fgc][2],cmp[?k.fgc][3],f)
       
        if(mblr and rfd == 0) {
           
            cmp[?k.selected] = t
            kb_str = cStr[?k.str]
            crt[?k.yy] = array_height_2d(cStr[?k.varr])-1
            crt[?k.xx] = array_length_2d(cStr[?k.varr],crt[?k.yy])-1
            GFCF = cmp
            GFMO = t
           
        }
       
    } else {
       
        in_cmp = f
        if(mblr and cmp[?k.selected]) {
           
            cmp[?k.selected] = f
            kb_str = ""
            GFMO = f
            GFCF = nn
            rfd = 2
           
        }
       
    }

#endregion

// Return whether or not mouse inside btn
return in_cmp

I'm a little embarrassed to show my code that in so much need of housekeeping,
but I promise when I make my first public release it will all make a more sense and
be a lot easier to read lol.

Basically what this code is doing is:

Taking each char entered into the keyboard_string and putting it into a list of lists of chars.

Then we take the list of lists of chars and iterate through each char in a double for loop,
I do that because I build the string we end up drawing to the screen. This way I have
greater flexibility and control over what is happening per char, I will also need to do
this so I can do my carot navigation and text selection copy/pasting more easily too.

WHICH speaking of the things I still need to add to this code is:

Planned before release:
Carot Navigation w/ Arrow Keys or Clicking
Text Selection (Mouse Click n Drag) w/ Copy/Cut/Paste or even Delete
Scrolling

But there is more I can add to this text area (and ultimately all my
text handling in the future):

Planned after release:
Overwrite Mode
Find and/or Replace/Replace All (Maybe, I don't know if this is entirely important for a game UI but w/e lol)

...

Anyways with that said,

like a lot of parts in this GUI there are additional options, features and modifications I want to not
only ADD to the system itself but also improve upon older already "finished" components.

But like I said a lot of that stuff will come AFTER release, during the beta phase.

Upon initial release I will be focusing on edge cases, bug fixing and cleaning up the code as well as documentation.

That's all for now.

Have a good weekend,
FXL

 

[fawhxldawg]

Quick update,

Spoiler: Text Area Debug

As you can see in the spoiler I have my debug/console output in redish on the left,
using trace() which is a GMEdit thing, GMS2 doesn't have it.

I'm going to keep it in as a debug feature but I'll have to make my own trace function
in GMS2 to use it.

Anyways you can kind of start to see how the text manipulation works behind the scenes.

Note: Each line isn't necessarily its own list (though in this example they are).
If you type and the line wraps itself it won't make a new list, a new list is only
made when the user presses enter.

Why? Or what function does not making each line a list serve? I'm not sure really,
just seems good to distinguish separate lists when the user specifically and purposefully
inserts a line break with enter manually for possible future purposes that may or may not
turn out to be useful... No good reason otherwise.

When the carot is at the very end of the whole text area a bool "CAROT END" is set to true
so the carot knows to just progress normally.

Otherwise when navigating the carot in the middle or elsewhere throughout the text area
besides the end of the text, the code knows to insert characters or if overwrite is on (which yes i already added)
which characters to replace.

Gonna have to also work on adding inserting line breaks, which would split a list into another new one or
the reverse, and join two separate lists when line breaks are deleted.

I'm still working on the carot navigation, (i.e. arrow keys and mouse clicking)
Debugging some weird/buggy behavior atm with it, otherwise is mostly smooth sailing.

However progress has been a lil slow the past few days, from 4th of July stuff (Yeah I'm in USA)
to my actual job requiring me to spend time troubleshooting my work station equipment.
(Troubleshooting/Debugging software for this, and then troubleshooting hardware... Double T/Sing whammy lol)

I try to get on here and plug away at it a lil more when I can but yeah haven't been able to focus on it like I have been,
I hope tomorrow goes more smoothly and I can get a lot more done but for now I'mma try to wrap up here at
work and get some rest.

Thanks,
FXL

 

[fawhxldawg]

Alrighty,

So wanted to stop by with an update, it was my intent to release the alpha around this time however it will probably take an additional month, maybe two before it is really available.

I got to admit a lot more had to go into the text area (multi-line string input) component than I had initially anticipated.

It didn't help I stumbled across a bug with HTML5 exports.

Anyways,

It is nearly done though almost a fully functional notepad! (minus the mouse controls for now, will add that later).

Just having some issues with wrapping appended lines... I.E., lets say you wrote 30 lines of text.
Then lets say you went to the 10th line and inserted a word or two for whatever reason.

If you add words in the middle of the text I'm working on wrapping the end of lines to the next line, etc.
But some of my logic is exactly right yet as you can see here I was adding (.) periods between sequence
of characters and numbers too track how they wrapped and let's just say they didn't exactly do what I wanted.

Spoiler: Wrapping bug

I just wonder if there is anyone actually interested in trying my GUI lol.

I know a few people follow this log just curious but hearing from someone
that has a genuine interest with my GUI and telling me to get my butt to work so they can get the alpha release would be motivating .

Anyways,
More to come soon!
Thanks.