Wikispaces : Liberty BASIC Programmer's Encyc - items matching description

BmpButtons

Alyce — Thu, 26 Jul 2012 10:30:13 GMT

BmpButtons

What are BmpButtons?

BmpButtons are buttons that display an image instead of text. The button on the left is a BmpButton. The button on the right is a regular push button.

How Do BmpButtons Work?

Bmpbuttons work a little differently than regular buttons. Instead of a caption, we must specify a filename for the bitmap that will appear on the button. This filename can have a relative path. If we run a program in the Liberty BASIC directory, it can find the bmps in the bmp directory if we specify the path like this:

bmpbutton #1.b, "bmp\copy.bmp",[hi],UL,10,10

The bmpbutton command also includes the name of the branch label or sub that will be the event handler for the button, the corner to which placement will be relative, and the x and y placement coordinates. We can't specify a width and height as we can with regular push buttons, because Liberty BASIC checks the size of the bitmap and makes the button that same size.

BmpButton Commands

Bmpbuttons understand a limited command set.

print #handle.ext, "bitmap bitmapname"
print #handle.ext, "locate x y width height"
print #handle.ext, "setfocus"
print #handle.ext, "enable"
print #handle.ext, "disable"
print #handle.ext, "show"
print #handle.ext, "hide"

SETTING FOCUS TO A BMPBUTTON

Commands sent to a bmpbutton should not begin with a "!" character like commands sent to a regular button. We cannot change the text on a bmpbutton, because there IS no text on a bmpbutton. We can cause a bmpbutton to receive the input focus so that any keypresses will be directed to the bmpbutton. Here is the syntax:

print #handle.ext, "setfocus"

CHANGING THE BITMAP ON THE BUTTON

We can set the bitmap of the control to be the named bitmap that has been loaded previously with the LOADBMP command (not the filename of the bitmap).

loadbmp "bitmapname", "filename.bmp"
print #handle.ext, "bitmap bitmapname"

If the new bitmap is not the same dimensions as the original bitmap, it won't look right, because the bmpbutton will not automatically change size to match the new bitmap. You can find the dimensions of a bitmap by loading it into MS Paint and checking its attributes. You can also find the dimensions of a loaded bitmap at runtime by opening the file and reading the info, or via API calls.

MOVING AND RESIZING A BMPBUTTON

You can reposition the bmpbutton within the window that contains it. Use the "locate" command. This command requires the new x and y coordinates for the bmpbutton, plus the width and height desired. You must issue a "refresh" command to the window to cause it to update the display to show the new location of the button. To use the "locate" command, you must know the desired dimensions of the bmpbutton. See Issue #100 for a way to discover bitmap dimensions at runtime. Here is the syntax:

print #handle.ext, "locate x y width height"
print #handle, "refresh"

Remember that values inside the quotes are hard-coded. To use variables, place them outside of the quote marks and preserve the blank spaces inside the quote marks.

print #handle.ext, "locate 12 45 25 25"
or
x=12 : y=45 : width=25 : height=25
print #handle.ext, "locate ";x;" ";y;" ";width;" ";height

The "locate" command gives us the ability to specify a width and height for our bmpbuttons, so we are not limited to accepting the size given them by Liberty BASIC. We can change the look of our buttons this way, making them smaller if the window is resized by the user to be very small, for instance. We can also use the "bitmap" command to place a new image on the button, and then use the "locate" command to change the size of the button to match the size of the new bitmap.

DEMO

Here is a small demo that illustrates some of the possibilities of using the "bitmap" and "locate" commands with bmpbuttons.

'run this code from within your Liberty BASIC directory
'so that the bmps can be found by the program
nomainwin
WindowWidth=600:WindowHeight=400
bmpbutton #1.b, "bmp\copy.bmp",[hi],UL,10,10
button #1.move, "Move Button",[moveButton],UL,10,80,140,24
button #1.new, "New Bitmap",[new],UL,10,120,140,24
open "Move Bmpbutton" for window as #1
#1 "trapclose [quit]"
wait
 
[quit]
'if bmp was loaded, unload it
if pianoLoaded then unloadbmp "piano"
close #1:end
 
[moveButton]
'move bmpbutton to new coords
 
if not(pianoLoaded) then
'actual size of copy bmp is
'25x25, and we will preserve that:
#1.b "locate 200 10 25 25"
else
'if piano bmp is in use, use
'these dimensions:
#1.b, "locate 200 10 300 50"
end if
 
#1 "refresh"
wait
 
 
[new]
'change bmp and reposition
loadbmp "piano","bmp\piano6.bmp"
pianoLoaded=1   'flag that bmp was loaded
'actual size of piano.bmp is 600x100
'but we will make it 300x50 here:
#1.b "bitmap piano"
#1.b "locate 50 10 300 50"
#1 "refresh"
wait
 
[hi]
notice "Hi"
wait

ccbCode

Alyce — Wed, 08 Apr 2009 13:24:16 GMT

'Make a custom control hyperlink with a Liberty BASIC graphicbox.
'-----------------------------------------------------------------'
 [SetupWindow]
 NoMainWin
 WindowWidth = 400
 WindowHeight = 200
 UpperLeftX = Int((DisplayWidth-WindowWidth)/2)
 UpperLeftY = Int((DisplayHeight-WindowHeight)/2)
 Link1.Width = 80
 Link1.Height = 26
 GraphicBox #Win.Link1, 4, 4, Link.Width, Link.Height
 Stylebits #Win.Link1, 0, _WS_BORDER, 0, 0
 Open "Hyperlink Custom Control" For Window As #Win
 #Win, "TrapClose [Quit.Win]"
 Wait
 [Quit.Win]
 Close #Win
 End
 [Link1.Click]
 Wait
 [Link1.Move]
 Wait

    [SetupWindow]
        NoMainWin
        WindowWidth = 400
        WindowHeight = 200
        UpperLeftX = Int((DisplayWidth-WindowWidth)/2)
        UpperLeftY = Int((DisplayHeight-WindowHeight)/2)
 
        Link1.Width = 80
        Link1.Height = 26
 
        GraphicBox #Win.Link1, 4, 4, Link1.Width, Link1.Height
        Stylebits #Win.Link1, 0, _WS_BORDER, 0, 0
 
        Open "Hyperlink Custom Control" For Window As #Win
 
        #Win, "TrapClose [Quit.Win]"
 
                Link1$ = cCc.Hyperlink$("#Win.Link1", Link1.Width, Link1.Height, "Link 1 Text", _
        "Arial 10", "buttonface", "blue", "[Link1.Click]", "[Link1.Move]")
    Wait
 
    [Quit.Win]
        Close #Win
    End
 
    [Link1.Click]
        Notice "You clicked Link 1."
    Wait
 
    [Link1.Move]
        Call cC.RollHyperlink Link1$, MouseX, MouseY
    Wait
 
 
    Function cCc.Hyperlink$(gbHndl$, width, height, text$, font$, backcolor$, linkcolor$, eventClick$, eventMove$)
 
        #gbHndl$, "CLS; Down; Fill ";backcolor$ 'Clear the graphicbox and fill it with the specified backcolor.
 
        'We need the height of the current font in pixels. Here's an easy way:
            #gbHndl$, "Place -100 -100 " 'Place pen offscreen
            #gbHndl$, "| " 'Print a blank line.
            #gbHndl$, "PosXY penX penY" 'Get the coordinates of the pen. After drawing text, the pen moves down the proper
                'height to make room for another line. Just subtract the end position from the start position to get the height
                'of the font:
            fontHeight = penY-(-100) 'And it works, if you print the results out!
        '--------------------------------------------------------------------'
 
        #gbHndl$, "CLS; Down; Fill ";backcolor$;"; Flush" 'Redo the intial thing just in case and this time flush it
            'so the graphics will stick.
        #gbHndl$, "Font ";font$;" ; Color ";linkcolor$;" ; BackColor ";backcolor$ 'Set the font, foreground and background
            'color.
 
        'While we're at it, let's get the width of the string (so we can center our text in the graphicbox!):
            #gbHndl$, "StringWidth? text$ stringWidth"
            'Calculate the x coordinate for text placement:
            Xcoord = Int((width-stringWidth)/2)
        '--------------------------------------------------------------------'
 
        #gbHndl$, "Place ";Xcoord;" ";fontHeight+2 'Set the pen at the proper location so the text will draw correctly
            'in the graphicbox.
            'Notice the text will start at the far left of the gbox, just like statictext would.
 
        #gbHndl$, "|"; text$ 'Draw the text!
 
        #gbHndl$, "Flush DefaultText" 'Make this drawing stick. And, give this drawing (segment) the name DefaultText .
 
        #gbHndl$, "when leftButtonUp "; eventClick$ 'Set the graphicbox to jump to the branch label/sub that the user
            'specified when the link/graphicbox is clicked.
        #gbHndl$, "when mouseMove "; eventMove$
 
        'Now, return the handle to a hyperlink so the user can pass it to the hyperlink functions:
 
        hlinkActive = 0 'The hyperlink isn't active just yet.
 
        'Return all the info as one big string of data seperated by spaces. We'll parse this using word$() in another
        'function. This allows the user to have more or less a "handle" to a link.
 
        font$ = Sys.ReplaceChar$(font$," ","ø") 'Replace any spaces in the font text with a weird symbol, so we can parse the
            'handle with word$() in another function.
 
        text$ = Sys.ReplaceChar$(text$," ","ø") 'Do the same with the text of the hyperlink. We'll reverse this in the other
            'function using Sys.ReplaceChar$(text$,"_"," ") which will replace the underscores with spaces - so we'll be back
            'to normal. Same with the font$.
 
        cCc.Hyperlink$=gbHndl$;" ";width;" ";height;" ";hlinkActive;" ";font$;" ";backcolor$;" ";linkcolor$;" ";_
        eventClick$;" ";eventMove$;" ";text$;" ";fontHeight
 
        'Word 1 = handle to the graphicbox.
        'Word 2 = the width of the graphicbox
        'Word 3 = the height of the graphicbox.
        'Word 4 = 0/1 - whether or not the link is active (mouse over) hlinkActive
        'Word 5 = the font used
        'Word 6 = the backcolor
        'Word 7 = the link color
        'Word 8 = the event in which to trigger when the link is clicked.
        'Word 9 = the event in which to trigger when the mouse is moved over the gbox.
        'Word 10 = the text for the hyperlink
        'Word 11 = the height of the font
 
    End Function
 
    Sub cC.RollHyperlink byref Link$, X, Y
        'Extract information from the hyperlink's handle:
        gbHndl$ = Word$(Link$,1) : width = Val(Word$(Link$,2)) : height = Val(Word$(Link$,3))
        hlinkActive = Val(Word$(Link$,4)) : font$ = Word$(Link$,5) : backcolor$ = Word$(Link$,6)
        linkcolor$ = Word$(Link$,7) : eventClick$ = Word$(Link$,8) : eventMove$ = Word$(Link$,9)
        text$ = Word$(Link$,10) : fontHeight = Val(Word$(Link$,11))
 
        #gbHndl$, "Font ";font$;" ; Color ";linkcolor$;" ; BackColor ";backcolor$ 'Make sure the colors and fonts are set
            'right...
 
        'Now, replace the weird symbol in the font$ and text$ with spaces:
        font$ = Sys.ReplaceChar$(font$,"ø"," ")
        text$ = Sys.ReplaceChar$(text$,"ø"," ")
 
        'Recalculate the width of the text for placement's sake:
            #gbHndl$, "StringWidth? text$ stringWidth"
            'Calculate the x coordinate for text placement:
            Xcoord = Int((width-stringWidth)/2)
        '--------------------------------------------------------------------'
 
        'Check to see if the mouse coordinates (X, Y) are over the link's text - if so, we'll make sure the hyperlink
        'becomes underlined:
 
        'First, let's get the width of the hyperlink's text using the stringwidth? command:
        #gbHndl$, "StringWidth? text$ textWidth"
        textWidth = textWidth + 1
            'Now, we know both the width and height of the text. they are stored in textWidth and fontHeight . Perfect!
 
        'Now, check to see if the mouse is over the actual area the text is drawn in:
            If X<=(textWidth+Xcoord) And X>=Xcoord And Y<=(fontHeight+2) And Y>=2 Then 'If the mouse is in the proper area:
                If Not(hlinkActive) Then
                    'If the link has not been drawn in it's mouseOver (active) state, then let's do so now.
                    'If hlinkActive was true (set to 1),
                    'it means we had already drawn it in it's active state, so we wouldn't need to redraw the same thing.
                    'That just causes flickering.
                    #gbHndl$, "DELSEGMENT DefaultText" 'Delete the inactive (normal) drawing of the text.
                    #gbHndl$, "REDRAW" 'Update the graphicbox to reflect our deletion.
                    #gbHndl$, "Place ";Xcoord;" ";fontHeight+2 'Position the pen to redraw the text.
                    #gbHndl$, "Font ";font$;" underscore" 'Set the font to be underlined! Of course,
                        'if the user already has an underlined font, this is a bummer. :(
                    #gbHndl$, "|";text$ 'Draw the new, underlined text!
                    #gbHndl$, "Flush ActiveText" 'Make this drawing stick, and call it ActiveText -
                              'we can remove this drawing and redraw the old one when the mouse isn't
                        'over the graphicbox text area. Cool, huh?
                    hlinkActive = 1 'The hyperlink is now in it's active state!
                End If
            Else 'If the mouse is NOT over the actual text area, then let's make sure that the hyperlink is drawn in it's
                 'inactive state.
                If hlinkActive Then 'If the hyperlink is being drawn in it's active state, then let's unactivate it!
                    #gbHndl$, "DELSEGMENT ActiveText" 'Remove the drawing of the active text.
                    'Draw the text in it's normal state:
                    #gbHndl$, "REDRAW"
                    #gbHndl$, "Font ";font$
                    #gbHndl$, "Place ";Xcoord;" ";fontHeight+2
                    #gbHndl$, "|";text$
                    #gbHndl$, "Flush DefaultText" 'Make it stick and call this drawing the DefaultText drawing.
                    hlinkActive = 0 'hlinkActive is now inactive.
                End If
            End If
        '----------------------------------------------------------------------------'
 
        'Replace spaces with underscores...
        font$ = Sys.ReplaceChar$(font$," ","ø")
        text$ = Sys.ReplaceChar$(text$," ","ø")
 
        'Change the properties of the hyperlink's handle to match the updated properties.
        'This will actually affect the user's handle, because we passed Link$ by reference. (byref in the help file)
        Link$=gbHndl$;" ";width;" ";height;" ";hlinkActive;" ";font$;" ";backcolor$;" ";linkcolor$;" ";_
        eventClick$;" ";eventMove$;" ";text$;" ";fontHeight
 
    End Sub
 
    'This is a helper function for the hyperlink functions.
    Function Sys.ReplaceChar$(String$, FindChar$, ReplaceChar$) 'Find the character FindChar$ and replace
        'it with ReplaceChar$
        For i = 1 To Len(String$)
            char$=Mid$(String$,i,1)
            If char$=FindChar$ Then char$=ReplaceChar$
            Sys.ReplaceChar$=Sys.ReplaceChar$;char$
        Next i
    End Function

Link1$ = cCc.Hyperlink$("#Win.Link1", "Link 1 Text", "Arial 10", "buttonface", "blue", "[Link1.Click]", "[Link1.Move]")

Link1$ = cCc.Hyperlink$("#Win.Link1", Link1.Width, Link1.Height "Link 1 Text", "Arial 10", "buttonface", "blue",  "[Link1.Click]", "[Link1.Move]")
Function cCc.Hyperlink$(  gbHndl$,       width,        height,      text$,       font$,     backcolor$, linkcolor$, eventClick$,    eventMove$)

    [Link1.Move]
        Call cC.RollHyperlink Link1$, MouseX, MouseY
    Wait

        Link$=gbHndl$;" ";width;" ";height;" ";hlinkActive;" ";font$;" ";backcolor$;" ";linkcolor$;" ";_
        eventClick$;" ";eventMove$;" ";text$;" ";fontHeight

#Win.Link1 80 26 1 Arialø10 buttonface blue [Link1.Click] [Link1.Move] Linkø1øText 16
#Win.Link1 80 26 0 Arialø10 buttonface blue [Link1.Click] [Link1.Move] Linkø1øText 16

Sub cC.RollHyperlink byref Link$, X, Y

Link1$ = cCc.Hyperlink$("#Win.Link1", Link1.Width, Link1.Height, "Link 1 Text", "Arial 10", "buttonface", "blue", "[Link1.Click]", "[Link1.Move]")

    [Link1.Move]
        Call cC.RollHyperlink Link1$, MouseX, MouseY
    Wait

Global Link1$

You would also have to pass the name of the sub in for the mouse over event when you use the cCc.Hyperlink$() function, instead of the name of a branch label:

Link1$ = cCc.Hyperlink$("#Win.Link1", Link1.Width, Link1.Height, "Link 1 Text", "Arial 10", "buttonface", "blue", "[Link1.Click]", "Link1.Move")

    Sub Link1.Move GraphicBox$, X, Y
            Call cC.RollHyperlink Link1$, X, Y
    End Sub

    NoMainWin
    WindowWidth = 600
    WindowHeight = 400
    Button #Win.b, "Unstep progress bar",[UnStepIt],UL,4,38,130,30
    Button #Win.b2, "Step progress bar",[StepIt],UL,138, 38, 130, 30
    Button #Win.b3, "Set Percentage",[Percent],UL,4,72,130,30
    GraphicBox #Win.g, 4, 4, 436, 30
    Stylebits #Win.g, 0,_WS_BORDER,0,0
    Open "Temp" For Window_NF As #Win
    #Win, "TrapClose [Quit]"
    #Win, "Font Arial 10"
    Prog1$ = cCc.ProgressBar$("#Win.g", 436, 30)
    Wait
 
    [UnStepIt]
        Call cC.UnStepProgressBar Prog1$
    Wait
 
    [StepIt]
        Call cC.StepProgressBar Prog1$
    Wait
 
    [Percent]
        Prompt "Choose percentage (0-100):"; Percent
        Call cC.SetProgressBarPercent Prog1$, Percent
    Wait
 
    [Quit]
    Close #Win
    End
 
 
'*****************************************************************************************************************'
'BEGIN PROGRESS BAR FUNCTIONS ************************************************************************************'
'*****************************************************************************************************************'
    Function cCc.ProgressBar$(gbHndlb$, width, height) 'Create Custom Control Progress Bar
        gbHndl$ = Word$(gbHndlb$,1)
        'Border drawing...sad this takes up a ton of code :( - but looks beautiful!
        dkGray$ = "102 102 102" : mdGray$ = "185 185 185" : ltGray$ = "234 234 234"
        #gbHndl$, "CLS;Down;Fill White ; Size 1 ; Color ";ltGray$;"; Set 0 0 ; Color ";dkGray$;"; Line 1 0 ";(width-3);_
        " 0 ; Color 124 124 124 ; set ";(width-3);" 0"
        #gbHndl$, "Color 167 167 170 ; Set ";(width-2);" 0 ; Color 178 178 178 ; Set 0 1 ; Color 127 127 127 ; Set 0 2"
        #gbHndl$, "Color ";mdGray$;" ; Line 1 1 ";(width-2);" 1 ; Color 117 117 117 ; Set ";(width-2);" 1"
        #gbHndl$, "Color 167 167 170 ; Set ";(width-1);" 1 ; Color 124 124 124 ; Set ";(width-1);" 2"
        #gbHndl$, "Color ";ltGray$;" ; Line 1 2 ";(width-2);" 2 ; Color ";mdGray$;";Set ";(width-3);" 1 ; Set ";(width-2);" 2"
        #gbHndl$, "Set ";(width-3);" 2 ; Color ";dkGray$;" ; Line 0 3 0 ";(height-3)
        #gbHndl$, "Color 124 124 124 ; Set 0 ";(height-3);" ; Color 167 167 167 ; Set 0 ";(height-2)
        #gbHndl$, "Color ";dkGray$;" ; Line 1 ";(height-1);" ";(width-3);" ";(height-1);";Line ";(width-1);" 3 ";(width-1);" ";(height-3)
        #gbHndl$, "Color 124 124 124 ; Set ";(width-1);" ";(height-3);"; Set ";(width-2); " ";(height-2);";Set ";(width-3);" ";(height-1)
        #gbHndl$, "Color 167 167 167 ; Set ";(width-1);" ";(height-2);"; Set ";(width-2); " ";(height-1);";Color ";ltGray$;_
        "; Line 1 ";(height-2);" ";(width-2);" ";(height-2)
        #gbHndl$, "Color ";mdGray$;"; Line ";(width-2);" 2 ";(width-2);" ";(height-2);";Color ";ltGray$;"; Line ";(width-3);" 3 ";_
        (width-3);" ";(height-2)
        barWidth = Int(width/50)
        padWidth = Int(width/218)
        maxBars = Int(width/(barWidth+padWidth)) 'holds how many bars this progressbar holds...
        cCc.ProgressBar$ = gbHndl$;" ";width;" ";height;" ";barWidth;" ";padWidth;" ";barCount;" ";maxBars
        #gbHndl$, "backcolor 255 255 255"
        #gbHndl$, "Flush"
    End Function
    Sub cC.SetProgressBarPercent byref progHndl$, percent
        gbHndl$=Word$(progHndl$,1):width=Val(Word$(progHndl$,2)):height=Val(Word$(progHndl$,3)):barWidth=Val(Word$(progHndl$,4))
        padWidth=Val(Word$(progHndl$,5)):barCount=Val(Word$(progHndl$,6)):maxBars=Val(Word$(progHndl$,7))
        p = Int((maxBars/100)*percent)
        If p = 0 Then
            progHndl$=cCc.ProgressBar$(gbHndl$;" .", width, height)
            Exit Sub
        End If
        If p>barCount Then
            dif = p-barCount
            For i = 1 To dif
                Call cC.StepProgressBar progHndl$
            Next i
        End If
        If p<barCount Then
            dif = barCount - p
            For i = 1 to dif
                Call cC.UnStepProgressBar progHndl$
            Next i
        End If
        progHndl$ = progHndl$
    End Sub
    Sub cC.StepProgressBar byref progHndl$
        gbHndl$=Word$(progHndl$,1):width=Val(Word$(progHndl$,2)):height=Val(Word$(progHndl$,3)):barWidth=Val(Word$(progHndl$,4))
        padWidth=Val(Word$(progHndl$,5)):barCount=Val(Word$(progHndl$,6)):maxBars=Val(Word$(progHndl$,7))
        barCount=barCount+1
        If barCount>maxBars Then Exit Sub
        If barCount>1 Then Lx=((barWidth+padWidth)*(barCount-1))+1 Else Lx=1
        LxF = Lx+barWidth
        #gbHndl$, "Color 181 200 226;Line ";Lx;" 1 ";LxF;" 1;Color 164 191 221;Line ";Lx;" 2 ";LxF;" 2;Color 146 180 219;Line ";_
        Lx;" 3 ";LxF;" 3"
        #gbHndl$, "Color 130 166 214;Line ";Lx;" 4 ";LxF;" 4;Color 114 156 211;Line ";Lx;" 5 ";LxF;" 5;Color 95 145 206;Line ";_
        Lx;" 6 ";LxF;" 6"
        #gbHndl$, "BackColor 87 138 204; Color 87 138 204; Size 1; Place ";Lx;" 7; BoxFilled ";LxF;" ";(height-6)
        #gbHndl$, "Color 90 142 206;Line ";Lx;" ";(height-6);" ";LxF;" ";(height-6);"; Color 104 151 209;Line ";Lx;" ";(height-5);" ";_
        LxF;" ";(height-5)
        #gbHndl$, "Color 124 163 214;Line ";Lx;" ";(height-4);" ";LxF;" ";(height-4);";Color 140 173 216;Line ";Lx;" ";(height-3);" ";_
        LxF;" ";(height-3)
        #gbHndl$, "Color 159 187 221;Line ";Lx;" ";(height-2);" ";LxF;" ";(height-2)
        progHndl$ = gbHndl$;" ";width;" ";height;" ";barWidth;" ";padWidth;" ";barCount;" ";maxBars
        #gbHndl$, "Backcolor 255 255 255"
        #gbHndl$, "Flush bar";barCount
    End Sub
    Sub cC.UnStepProgressBar byref progHndl$
        gbHndl$=Word$(progHndl$,1):width=Val(Word$(progHndl$,2)):height=Val(Word$(progHndl$,3)):barWidth=Val(Word$(progHndl$,4))
        padWidth=Val(Word$(progHndl$,5)):barCount=Val(Word$(progHndl$,6)):maxBars=Val(Word$(progHndl$,7))
        If barCount=0 Then Exit Sub
        barSeg = barCount' + 1
        #gbHndl$, "delsegment bar";barSeg
        #gbHndl$, "redraw"
        if barCount>0 Then barCount=barCount-1
        progHndl$ = gbHndl$;" ";width;" ";height;" ";barWidth;" ";padWidth;" ";barCount;" ";maxBars
    End Sub
'*****************************************************************************************************************'
'END PROGRESS BAR FUNCTIONS **************************************************************************************'
'*****************************************************************************************************************'

CustomControlsBox

JanetTerra — Thu, 09 Apr 2009 13:16:11 GMT

Custom Controls in a Box (- lbjoseph)

Making your own custom control with a graphicbox in Liberty BASIC.

Throughout the ages, mankind has sought after customization and personalization. Now, with the power of Liberty BASIC 4, you can create your very own custom control inside of a simple graphicbox. The following article expects you to be familiar with the Liberty BASIC language, as well as with Liberty BASIC's native drawing commands.

In this article, we will discuss the techniques that I (- lbjoseph) think are necessary to creating a good custom control.

Code for this article is on a separate page.

Custom Controls in a Box (user:lbjoseph)

Making your own custom control with a graphicbox in Liberty BASIC.

Why a custom control?

The container

The foundation of what we want

Data management

The guts of our hyperlink program

What does it all mean?

Utilizing the hyperlink

Conclusion and a Progress bar control

Why a custom control?

Because you can. But there's more to it than that - by creating your own custom control, its look and feel will stay consistent throughout all the various versions of Windows. Secondly, you can make them much easier to use than the Windows API controls. It is also possible to setup your custom control's functions/subs without global variables (depending on what kind of control you make). Another advantage of custom controls is that they do not require a huge wrapper of subs and functions to deal with the Windows API calls, callbacks, messages, and so on.

The container

First of all, we need some sort of object that we can manipulate to turn into our own object. The Liberty BASIC graphicbox is just the thing. Not only does it let you draw on it with LB's native drawing commands, but it lets you set event handlers to branch labels or subs when it is clicked, etc. This allows you to make a click-able control that looks beautiful to the eyes (some sarcasm implied).

The foundation of what we want

In this article we'll walk through custom control creation by creating a "fake" hyperlink control. There's are a couple of things we want specifically from this control:

It needs to have a roll-over effect (becomes underlined upon mouse-over)
We want to be able to create as many as we like
And we want it to specify its properties upon creation - like background color, text color, font, etc.

So, let's go ahead and create the basis of our program. We'll need a window with a graphicbox in place and a trapclose event setup so our program will actually close when someone hits the little red x.

If we wanted to have more than one hyperlink, we'd make a graphicbox for every link we want. More on that later.
Click here for code.

If you run the code above, things don't look too promising. However, this is just the foundation of our program.

There are a couple of things you need to note about the above code:

First, we issued a "Stylebits" Command - we used the flag _WS_BORDER in the removeBits section. This removes the border of the graphicbox. This command is necessary to remove clutter which could mess up the way our control looks (especially in a dialog window).

Secondly, we created two "stubs" - [Link1.Click] and [Link1.Move] - these are event handlers for graphicbox. We'll find out what these are for shortly.

Now we have the foundation of a custom control - a graphicbox without a clunky border and two stubs for when the user clicks the graphicbox, and moves the mouse over the graphicbox.

Data management

Here's where the fun begins. We know we need several parameters to create a hyperlink:

We need the handle to the "parent" graphicbox container. We'll call this variable "gbHndl$". In our case, the programmer would pass the value "#Win.Link1" into the function.
We need the width of the hyperlink - we'll call this "width"
We need the height of the hyperlink - we'll call this "height"
We need the text for the hyperlink - we'll call this "text$"
We need to know what font to use - we'll call this "font$"
We need to know the background color of the window the link is on (so it won't look ugly) - we'll call this "backcolor$"
We need to know what color to make the hyperlink -we'll call this "linkcolor$"
We need the name of the sub or branch label that contains the user's code to execute upon clicking the link. We'll call this "eventClick$". In our case, the programmer would pass the value "[Link1.Click]" into the function.
We'll need the name of the sub or branch label that contains the user's code to execute when the mouse moves over the link. We'll call this "eventMove$"
We need the height of the font the user specified for the hyperlink - we'll call this "fontHeight"
The hyperlink also needs to know what state it is in - whether or not is "active". We'll call this "hlinkActive".

We keep track of 11 variables for the hyperlink. We'll need to remember these so we can render the hyperlink. To avoid flickering the graphicbox, we'll only render the hyperlink when we absolutely need to. By calculating to see if the mouse is inside the coordinates of the text, we can find out whether or not to underline the hyperlink. If so, we'll redraw the link and change the value of hlinkActive to 1 (if the mouse is over the text) or 0 (if the mouse is not over the text).

The guts of our hyperlink program

Here's the updated program (heavily commented) with the sub and functions required for the hyperlink:
Click here for code.

What does it all mean?

To make the most out of this, you should probably look over the code and read the comments. It's designed to be easy to understand. You should be able to keep up quite well after doing so.

The function cCc.Hyperlink$ (the cCc stands for create custom control) is called after the window has been setup like this:
Click here for code.

The arguments passed into this function correspond with the parameters (representational variables) received by the function cCc.Hyperlink$():
Click here for code.

The function returns a string of values put together. When we called this function, we assigned the variable Link1$ to be that string.

Earlier, we mentioned that we need an event for when the mouse moves over the link. If you compare the two above, you'll notice that we specified the branch label [Link1.Move] to be the block of code that Liberty jumps to when the mouse moves over the graphicbox #Win.Link1. Let's take a look at that block:
Click here for code.

Notice that we called the sub in our program. This sub, cC.RollHyperlink (cC stands for Custom Control), checks to see if the mouse is directly over the rendered text (using the graphics commands, and a little bit of math and conditional checking). The sub then draws the hyperlink either in its active (underlined) form or inactive (not underlined) form depending on if the mouse is over it or not.

In the sub, we passed the value Link1$ as the handle to our link. It contains the string of information returned by the cCc.Hyperlink$() function. The sub breaks this information down, and uses it to see if it needs to redraw the hyperlink. If it does, it changes the value of the paremeter hlinkActive, which happens to be second word inside Link1$.

When the sub is done, it puts the link handle back together:
Click here for code.

Now, remember that in our case, we passed the value Link1$ in the sub. If you were to compare the values of the string variable Link1$ when the mouse is over, and when it is not, you would get this:
Click here for code.

The first line is the value of Link1$ when the mouse is over the link. The second line is the value when the mouse is not over. There is only one difference between the two, and that is found in the fourth word. If you looked at the code, you'd realize that the fourth word in the "handle" of our link is the value of hlinkActive. But how are we able to change the actual value of a handle from the sub?

We take advantage of passing an argument by reference. Look at this:
Click here for code.

Notice the little "byref" that is thrown in right before Link$ (the parameter that represents the handle of the link passed in). Even though it doesn't turn blue in the Liberty BASIC 4.03 editor, it is still a recognized specification by Liberty BASIC's standards. Whenever you pass a variable into a sub or function by reference, the sub or function can actually modify the value of the variable you gave it! Isn't that amazing? Ok, well maybe it doesn't blow you out of your seat, but it can be really useful - as we just saw.

For more info, check out BYREF in the help file.

Utilizing the hyperlink

Ok, so we have this great hyperlink custom control, but how do we use it? Well, it's really quite simple to use. All you have to do is look a little closer at the demo program.

You already know how to make a hyperlink. Just assign a value like we did in the demo to the result of cCc.Hyperlink$(), with your own arguments.
Click here for code.

As you know, the hyperlink function requires two events. The second event, what to do on mouse over, requires us to call the sub cC.RollHyperlink.

So, once you have your events setup, all you have to do is call the cC.RollHyperlink sub from your mouse over event:
Click here for code.

Then, all you have to do is pass the handle to the link - in this case, it's Link1$.

When you use a branch label event handler (like the example above) you must use the special variables MouseX and MouseY for the mouse coordinates. Liberty BASIC always assigns the x and y position of the mouse into these special global variables.

What if you chose to use a sub for an event handler? You would have to make the handle to your link global:
Click here for code.

And your sub might look something like this:
Click here for code.

Notice the sub must accept three parameters. When Liberty BASIC calls a sub event for a graphicbox, it always passes the graphicbox handle, mouse x position, and mouse y position.

As for the mouse click event, you can just put your own code in a sub or branch label. If you use a sub, be sure to put a receiver for the graphicbox handle, mouse x, and mouse y coordinates!

Conclusion and a Progress bar control

Well, that's about it for the hyperlink. With the power of Liberty BASIC graphicboxes, you can create all kinds of custom controls.

An example of a progressbar custom control can be found below. It's really quite simple, if you understand the principles discussed in this article.
Click here for code.

Graphicbox and Scrollbars

RodBird — Mon, 23 Nov 2015 12:06:55 GMT

A Graphicbox with Scrollbars

- janetterra

A Graphicbox with Scrollbars

Horizscrollbar and Vertscrollbar

A Graphics Window with Scrollbars

A Graphicbox with Scrollbars

A Word About the Actual size of the Graphicbox

Setting the Scrollbar min and max Parameters

Fixing a Glitch

Scrolling Within the Program

Graphicbox and Scrollbars Demo

Horizscrollbar and Vertscrollbar

Liberty BASIC v4 gives us more control of the horizontal and vertical scrollbars of the Graphics window and even a Graphicbox. From the What's New of the Liberty BASIC v4 Help File -

print #handle "horizscrollbar on/off [min max]"
This command manages the horizontal scrollbar. If the value is "on", the scrollbar is made visible. If the value is "off", the scrollbar is hidden. When turning on the scrollbar the optional parameters for min and max set the minimum and maximum scrollbar range in pixels (these parameters do nothing when turning the scrollbar off.) Without these parameters the default range is set to 0 and the width of the graphics view in pixels. A large scrollbar range allows the graphics window to scroll a long distance, while a short range allows it to scroll a short distance.

A Graphics Window with Scrollbars

A window opened for Graphics contains scrollbars by default.

    Open "A Graphics Window" for Graphics as #1
    #1 "Trapclose EndDemo"
    Wait
 
    Sub EndDemo handle$
        Close #1
        End
        End Sub

These scrollbars can be removed using the Vertscrollbar off and Horizscrollbar off commands.

    Open "A Graphics Window" for Graphics as #1
    #1 "Trapclose EndDemo"
    #1 "Horizscrollbar Off"
    #1 "Vertscrollbar Off"
    Wait
 
    Sub EndDemo handle$
        Close #1
        End
        End Sub

A Graphicbox with Scrollbars

Normally, a graphicbox opened within another window does not contain scrollbars. Scrollbars can be added with the Vertscrollbar On and Horizscrollbar On commands.

    Nomainwin
    WindowWidth = 800
    WindowHeight = 554
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
    Graphicbox #main.gb, 0, 0, 794, 320
    Open "Graphicbox and Scrollbars" for Window_nf as #main
    #main "Trapclose EndDemo"
    #main "Font Verdana 10 Bold"
    #main.gb "Horizscrollbar On"
    #main.gb "Vertscrollbar On"
    #main.gb "Down; Color Darkblue"
    For x = 0 to 1550 Step 10
        #main.gb "Place ";x;" 10"
        #main.gb "North; Turn 180; Go 10"
        If x / 100 = Int( x / 100 ) Then
            #main.gb "Go 10"
            #main.gb "Place ";x - 10;" 40"
            #main.gb "\";x
        End If
    Next x
    For y = 0 to 1500 Step 10
        #main.gb "Place 10 ";y
        #main.gb "North; Turn 90; Go 10"
        If y / 100 = Int( y / 100 ) Then
            #main.gb "Go 10"
            #main.gb "Place 30 ";y + 5
            #main.gb "\";y
        End If
    Next y
    #main.gb "Flush"
    Wait
 
    Sub EndDemo handle$
        Close #main
        End
        End Sub

A Word About the Actual size of the Graphicbox

The defined size of a graphicbox includes the graphicbox borders as well. This means that a 200 x 200 graphicbox can only display a 198 x 198 graphic. The display size is further compromised by the addition of scrollbars. Windows automatically subtracts the width of the scrollbar from the client area, so that painting on the client area does not run over the scrollbars. Increasing the width and height of the graphicbox by 20 pixels each should fully compensate for this loss. A 500 x 500 graphicbox with scrollbars has an approximate 480 x 480 display area.

Setting the Scrollbar min and max Parameters

The Scrollbar commands support optional min and max parameters. By including these limits, the programmer can define the exact area to be scrolled. The min of both width and height is usually zero, but it can be any number, even a negative number. It is important to note that the max is not the actual final limit of the display. Rather, it is the Upper Left value. The size of the graphicbox (both width and height) extends this values. If the max width parameter is set to 500 for a graphicbox that is 400 pixels wide, the actual display area becomes approximately 880 pixels wide (900 pixels minus the scrollbar width). The same is true for the max height parameter.

    Nomainwin
    WindowWidth = 806
    WindowHeight = 554
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
    Graphicbox #main.gb, 0, 0, 800, 320
    Open "Graphicbox and Scrollbars" for Window_nf as #main
    #main "Trapclose EndDemo"
    #main "Font Verdana 10 Bold"
    #main.gb "Vertscrollbar On 0 500"
    #main.gb "Horizscrollbar On 0 1000"
    #main.gb "Down; Color Darkblue"
    For x = 0 to 1780 Step 10 '1000 (max) + 800 (graphicbox width) - 20 = 1780
        #main.gb "Place ";x;" 10"
        #main.gb "North; Turn 180; Go 10"
        If x / 100 = Int( x / 100 ) Then
            #main.gb "Go 10"
            #main.gb "Place ";x - 10;" 40"
            #main.gb "\";x
        End If
    Next x
    For y = 0 to 800 Step 10 '500 (max) + 320 (graphicbox height) - 20 = 800
        #main.gb "Place 10 ";y
        #main.gb "North; Turn 90; Go 10"
        If y / 100 = Int( y / 100 ) Then
            #main.gb "Go 10"
            #main.gb "Place 30 ";y + 5
            #main.gb "\";y
        End If
    Next y
    #main.gb "Flush"
    Wait
 
    Sub EndDemo handle$
        Close #main
        End
        End Sub

Fixing a Glitch

As the scrolled area becomes greater, a known glitch will appear with the graphics. The graphics at lower and/or rightmost become distorted.

The following code shows this glitch. Run the code and then scroll all the way down and then all the way to the right.

    Nomainwin
    WindowWidth = 806
    WindowHeight = 554
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
    Graphicbox #main.gb, 0, 0, 800, 320
    Open "Graphicbox and Scrollbars" for Window_nf as #main
    #main "Trapclose EndDemo"
    #main "Font Verdana 10 Bold"
    #main.gb "Horizscrollbar On 0 2000"
    #main.gb "Vertscrollbar On 0 1000"
    #main.gb "Down; Color Darkblue"
'    #main.gb "Place -20, -20; Boxfilled 2800 1320"
    For x = 0 to 2780 Step 10 '2000 (max) + 800 (graphicbox width) - 20 = 1780
        #main.gb "Place ";x;" 10"
        #main.gb "North; Turn 180; Go 10"
        If x / 100 = Int( x / 100 ) Then
            #main.gb "Go 10"
            #main.gb "Place ";x - 10;" 40"
            #main.gb "\";x
        End If
    Next x
    For y = 0 to 1300 Step 10 '1000 (max) + 320 (graphicbox height) - 20 = 1300
        #main.gb "Place 10 ";y
        #main.gb "North; Turn 90; Go 10"
        If y / 100 = Int( y / 100 ) Then
            #main.gb "Go 10"
            #main.gb "Place 30 ";y + 5
            #main.gb "\";y
        End If
    Next y
    #main.gb "Flush"
    Wait
 
    Sub EndDemo handle$
        Close #main
        End
        End Sub

The fix? Uncomment the line

'    #main.gb "Place -20, -20; Boxfilled 2800 1320"

and try the code again. The graphics now flush and persist properly. The filled box should fully extend beyond the borders of the desired visible scrolled area to be effective. Note that if you ever issue a CLS command you will need to reissue the above boxfilled instruction to continue to avoid distortion.

Scrolling Within the Program

The API call "SetScrollPos" allows the programmer to set the scrollbar positions. Pass Windows constants to the call to define the scrollbar (horizontal or vertical) and the amount to scroll. The position is the position of the Upper Left Corner. Some Windows constants include

_SBS_HORZ ' Designates the Horizontal Scrollbar
_WM_HSCROLL ' Windows Message to the Horizontal Scrollbar
_SBS_VERT ' Designates the Vertical Scrollbar
_WM_VSCROLL ' Windows Message to the Vertical Scrollbar
_SB_THUMBPOSITION ' The Value Within the Range of the Scroll Limits

Setting the Scrollbar position requires first designating the Scrollbar to be set, then defining the desired position, and lastly posting that message to the scrollbar.

    CallDLL #user32, "SetScrollPos", _
        handle as Ulong, _ 'handle of the graphicbox
        scrollDir as Long, _ '_SBS_HORZ or _SBS_VERT
        pos as Long, _ 'Desired Position
        1 as long, _ 'Flag to Repaint the Scrollbar Control
        result as Long 'Returned Value
'The position must then be multiplied by &H10000 and added to _SB_THUMBPOSITION
        hPos = pos * HexDec("&H10000") + _SB_THUMBPOSITION
    CallDLL #user32, "PostMessageA", _
        handle as Ulong, _ 'handle of the Graphicbox
        scrollFlag as Long, _ '_WM_HSCROLL or _WM_VSCROLL
            hPos as Long, _ 'Position in hexadecimal + H10000
            0 as Long, _ 'No significance
            result as long 'Returned Value

The API call "GetScrollPos" returns the current position of the Scrollbar.

    CallDLL #user32, "GetScrollPos", _
        handle As Ulong, _ 'handle of the Graphicbox
        scrollDir as Long, _ '_SBS_HORZ or _SBS_VERT
        resultPos as Long 'The Position in decimal format

Graphicbox and Scrollbars Demo

Copy and paste the following demo to your favorite Liberty BASIC IDE. No external files are required.

A Graphicbox with Scrollbars

Horizscrollbar and Vertscrollbar

A Graphics Window with Scrollbars

A Graphicbox with Scrollbars

A Word About the Actual size of the Graphicbox

Setting the Scrollbar min and max Parameters

Fixing a Glitch

Scrolling Within the Program

Graphicbox and Scrollbars Demo

    Nomainwin
    WindowWidth = 800
    WindowHeight = 554
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
    Graphicbox #main.gb, 0, 0, 520, 520
    Button #main.b1, "Scroll Left Most", ScrollButtonSet, UL, 560, 50, 180, 40
    Button #main.b2, "Scroll Right Most", ScrollButtonSet, UL, 560, 100, 180, 40
    Button #main.b3, "Scroll To Top", ScrollButtonSet, UL, 560, 150, 180, 40
    Button #main.b4, "Scroll To Bottom", ScrollButtonSet, UL, 560, 200, 180, 40
    Button #main.b5, "HScroll --> ", ScrollButtonSet, UL, 560, 250, 120, 40
    Textbox #main.tb5, 690, 255, 50, 30
    Button #main.b6, "VScroll --> ", ScrollButtonSet, UL, 560, 300, 120, 40
    Textbox #main.tb6, 690, 305, 50, 30
    Stylebits #main.b7, _BS_MULTILINE, 0, 0, 0
    Button #main.b7, "Horizontal Thumbposition", ScrollButtonGet, UL, 560, 370, 120, 40
    Statictext #main.st7, "0", 690, 380, 50, 30
    Stylebits #main.b8, _BS_MULTILINE, 0, 0, 0
    Button #main.b8, "Vertical Thumbposition", ScrollButtonGet, UL, 560, 420, 120, 40
    Statictext #main.st8, "0", 690, 430, 50, 30
    Open "Graphicbox and Scrollbars" for Window as #main
    #main "Trapclose EndDemo"
    #main "Font Verdana 10 Bold"
    #main.gb "Vertscrollbar On 0 500"
    #main.gb "Horizscrollbar On 0 500" '
    #main.gb "Down; Fill Darkblue; Color Lightgray; Backcolor Darkblue"
    For x = 0 to 1000 Step 10
        #main.gb "Place ";x;" 10"
        #main.gb "North; Turn 180; Go 10"
        If x / 100 = Int( x / 100 ) Then
            #main.gb "Go 10"
            #main.gb "Place ";x - 10;" 20"
            #main.gb "\";x
        End If
    Next x
    For y = 0 to 1000 Step 10
        #main.gb "Place 10 ";y
        #main.gb "North; Turn 90; Go 10"
        If y / 100 = Int( y / 100 ) Then
            #main.gb "Go 10"
            #main.gb "Place 30 ";y + 5
            #main.gb "\";y
        End If
    Next y
    #main.gb "Flush"
    Wait
 
    Sub EndDemo handle$
        Close #main
        End
        End Sub
 
    Sub ScrollButtonSet handle$
        nExtension$ = Right$(handle$, 1)
        Select Case Val(nExtension$)
            Case 1
                pos = 0
                scrollDir = _SBS_HORZ
                scrollFlag = _WM_HSCROLL
            Case 2
                pos = 500
                scrollDir = _SBS_HORZ
                scrollFlag = _WM_HSCROLL
            Case 3
                pos = 0
                scrollDir = _SBS_VERT
                scrollFlag = _WM_VSCROLL
            Case 4
                pos = 500
                scrollDir = _SBS_VERT
                scrollFlag = _WM_VSCROLL
            Case 5
                #main.tb5, "!Contents? pos$"
                pos = Val(pos$)
                scrollDir = _SBS_HORZ
                scrollFlag = _WM_HSCROLL
            Case 6
                #main.tb6, "!Contents? pos$"
                pos = Val(pos$)
                scrollDir = _SBS_VERT
                scrollFlag = _WM_VSCROLL
        End Select
        Call SetScrollPos hWnd(#main.gb), pos, scrollDir, scrollFlag
        End Sub
 
    Sub ScrollButtonGet handle$
        nExtension$ = Right$(handle$, 1)
        Select Case Val(nExtension$)
            Case 7
                scrollDir = _SBS_HORZ
            Case 8
                scrollDir = _SBS_VERT
        End Select
        pos = GetScrollPos(hWnd(#main.gb), scrollDir)
        handle$ = "#main.st";nExtension$
        #handle$ pos
        End Sub
 
 
    Sub SetScrollPos handle, pos, scrollDir, scrollFlag
        CallDLL #user32, "SetScrollPos", _
            handle as Ulong, _
            scrollDir as Long, _
            pos as Long, _
            1 as long, _
            result as Long
            hPos = pos * HexDec("&H10000") + _SB_THUMBPOSITION
        CallDLL #user32, "PostMessageA", _
            handle as Ulong, _
            scrollFlag as Long, _
            hPos as Long, _
            0 as Long, _
            result as long
        End Sub
 
    Function GetScrollPos(handle, scrollDir)
        CallDLL #user32, "GetScrollPos", _
            handle As Ulong, _
            scrollDir as Long, _
            GetScrollPos as Long
        End Function

This article first appeared in Issue #139 (December 2005) of the Liberty BASIC Newsletter.

gui

Alyce — Mon, 24 Oct 2011 13:49:21 GMT

GUI Programming

Windows

Transparent Window Using SetLayeredWindowAttributes - JanetTerra Aug 3, 2006
Getting a Window's Coordinates - Alyce Jan 8, 2007
Moving or Resizing a Window or Control - Alyce Jan 29, 2007
GetSysColor: Designing Your Program With GUI Compatible Colors - JanetTerra Feb 1, 2007
Managing Multiple Windows - harmonv
AnimateWindow - JanetTerra Jan 14, 2008
ChangingTheIcon - Alyce Mar 31, 2011
MDI Client Window to Scroll Controls - Alyce Oct 24, 2011

Menus

The Liberty BASIC Menu Bar - JanetTerra Sep 24, 2006
The Liberty BASIC Popup Menu - JanetTerra Sep 24, 2006
Understanding Cascading Menus Jim Brossman

Controls

Color Statements for Controls - Alyce

Buttons

Textboxes

Creating Columns in a Textbox with _EM_SETTABSTOPS - JanetTerra Feb 5, 2007
Retrieving Information from Textboxes with SendMessageA - JanetTerra Feb 9, 2007

Listboxes

How to have a single- and a double-click handler for a listbox - StPendl Sep 10, 2007
Rearranging a listbox and repeating buttons - by Jim Brossman

Graphics Windows and Graphicboxes

Graphics Windows, Graphicboxes and Scrollbars - JanetTerra May 21, 2006
A Graphicbox with Scrollbars - JanetTerra Feb 4, 2007
Custom Controls in a Box - - lbjoseph

Stylebits

Stylebits and Windows Constants - JanetTerra Aug 2, 2006
Stylebits - Windows - JanetTerra May 9, 2006
Stylebits - Textboxes - JanetTerra May 9, 2006
Stylebits - Statictext - JanetTerra May 10, 2006
Stylebits - Buttons - JanetTerra May 11, 2006
Stylebits - Listboxes - JanetTerra May 17, 2006
Stylebits - Comboboxes - JanetTerra May 17, 2006
Stylebits - Toggle Buttons - JanetTerra May 19, 2006
Stylebits - Dialog Windows - JanetTerra May 20, 2006

Stylebits - Texteditor (this is an internal widget of LB, so there are no styles available)

Windows References on the Microsoft Developer Network Library

The following links take you to the Microsoft documentation for Windows. The articles in this list are not part of the Liberty BASIC Programmer's Encyclopedia, and they are not specific to the Liberty BASIC language .

List Categories Here

list articles here

Graphics Windows and Graphicboxes

Stylebits

Windows References on the Microsoft Developer Network Library

Improved BmpButton

Alyce — Sat, 24 Jul 2010 20:16:05 GMT

Why Create BmpButtons?
Liberty BASIC has easy, native BmpButtons. The alternate method described here is useful because the appearance of Liberty BASIC BmpButtons does not suit everybody.

BmpButtons look like this when they are not being clicked:

Windows BmpButtons look like they are pushed down when the user clicks on them:

Liberty BASIC BmpButtons don't conform to 32-bit Windows norms in their appearance. Liberty BASIC BmpButtons invert their colors as a signal that they are depressed. (When I'm depressed, I reach for a good book!)

Stylebits to the Rescue!

The STYLEBITS command, which is new in Liberty BASIC 4, allows us to alter the properties of a control or window. The first argument is for adding stylebits. We can alter a regular BUTTON by adding the _BS_BITMAP style to it, like this:

stylebits #1.b, _BS_BITMAP,0,0,0
button #1.b, "",[click],UL,10,10,25,25

The button doesn't need a caption, since the text won't be displayed anyway. The width and height arguments should match the width and height of the image we plan to use on our bmpbutton. If we don't include width and height arguments, Liberty BASIC sizes the button to fit the caption.

Sending a Message

The regular button has now become a BmpButton. If we stop here, it won't look very good!

We must tell the button which image to display. We do that by using the SendMessageA API call. The function requires the handle to the button. We retrieve that handle with the HWND command:

    hButton=hwnd(#1.b)

The next argument is the message to send, which is _BM_SETIMAGE. This is the message that tells the button to use the image whose handle is passed into the function. The next argument tells the function the type of image being used. We are using a bitmap, so this is _IMAGE_BITMAP. The last argument is the handle of the bitmap. We must first load a bmp with LOADBMP, then retrieve its handle with HBMP.

loadbmp "test","bmp\copy.bmp"
hBitmap = hbmp("test")

Here is the SendMessageA function as it appears in the demo program:

    CallDLL #user32, "SendMessageA",_
    hButton As uLong, _      'handle of button
    _BM_SETIMAGE As Long,_   'message to set new image
    _IMAGE_BITMAP as long,_  'type of image
    hBitmap As uLong,_       'handle of bitmap
    re As Long

DEMO

 
'run from root LB directory so program can find bmp
 
loadbmp "test","bmp\copy.bmp"
hBitmap = hbmp("test")
 
nomainwin
stylebits #1.b, _BS_BITMAP,0,0,0
button #1.b, "",[click],UL,10,10,35,35
open "Bmpbutton Play" for window as #1
#1 "trapclose [quit]"
 
    hButton=hwnd(#1.b)
 
    'set new bmp
    CallDLL #user32, "SendMessageA",_
    hButton As uLong, _      'handle of button
    _BM_SETIMAGE As Long,_   'message to set new image
    _IMAGE_BITMAP as long,_  'type of image
    hBitmap As uLong,_       'handle of bitmap
    re As Long
 
wait
 
[quit] unloadbmp "test":close #1:end
 
[click]
   'notice "Hello"
    wait

LayeredWindowTransparency

RodBird — Wed, 25 Nov 2015 17:32:34 GMT

Fun With Transparent Windows

#User32 - "SetLayeredWindowAttributes"

Janet Terra with inspiration from Alyce Watson and Stefan Pendl

Windows 2000 and Windows XP both support transparent and semi-transparent windows. If you are designing a program for others, you will want to be sure the host computer supports transparent windows. This function, available at Alyce's Restaurant, will retrieve the OS version. A returned MajorVer of 5, setting the OSVersionFlag value to 1, indicates the required Windows 2000 or XP.

    If OSVersionFlag() Then
        Print "This computer DOES support Transparent Windows"
    Else
        Print "This computer DOES NOT support Transparent Windows"
    End If
    End
 
Function OSVersionFlag()
    struct OSVERSIONINFO, _
        dwOSVersionInfoSize as Long, _
        dwMajorVersion as Long, _
        dwMinorVersion as Long, _
        dwBuildNumber as Long, _
        dwPlatformId as Long, _
        szCSDVersion as Char[128]
    L = Len(OSVERSIONINFO.struct)
    OSVERSIONINFO.dwOSVersionInfoSize.struct = L
    CallDLL #kernel32, "GetVersionExA", _
        OSVERSIONINFO as struct, _
        result as long
    MajorVer = OSVERSIONINFO.dwMajorVersion.struct
    If MajorVer < 5 Then
        OSVersionFlag = 0
    Else
        OSVersionFlag = 1
    End If
End Function

Once the programmer has established the host machine will support a transparent window, the window can be opened. Prior to Liberty BASIC v4.0 and Stylebits, the only way to code a transparent window was after opening the window and then issuing a SetWindowLongA to the User32.dll to give that window a layered quality. After the layered message was sent, a call to SetLayeredWindowAttributes was issued, again to the User32.dll to define the amount of transparency, more correctly called opacity. This is the technique used in John Richardson's LB Spier and discussed in the Transparent Window article at the Liberty BASIC Programming Wiki Site.

A more recent, and perhaps more effective, method of coding a transparent window is by including WS_EX_LAYERED in the window's addExtendedBits, the third parameter of the Stylebits command. As in the previous method, a call is then made to SetLayeredWindowAttributes in the User32.dll to define the amount of opacity.

The WS_EX_LAYERED addExtendedBits Stylebit

WS_EX_LAYERED is one of the Windows constants that is not recognized by Liberty BASIC. This doesn't mean that the style can't be used, though. It just means the numerical value of that Windows constant will need to be determined and assigned as either a literal or a variable. See Stylebits and Windows Constants for further discussion if needed. Here, we'll assign the correct value of 524288 to the variable WS.EX.LAYERED.

    WS.EX.LAYERED = 524288
    Stylebits #w, 0, 0, WS.EX.LAYERED, 0

Having given the layered quality to the window, the opacity is then determined after the window is opened. This is done with a call to "SetLayeredWindowAttributes."

    CallDLL #user32, "SetLayeredWindowAttributes", _
        hMain as Ulong, _
        ColorRef as Ulong, _
        bAlpha as Short, _
        dwFLAGS as Long, _
        result as long

Looking at the four passed parameters more closely -

hMain is the handle of the main window. Typically, this is the first parameter to be passed to any DLL when that DLL modifies a window or control.
ColorRef is the color assigned to be transparent. ColorRef is only relevant when the fourth parameter, dwFLAGS, is assigned as LWA_COLORKEY.
bAlpha is the amount of transparency or opacity. bAlpha is sometimes referred to as BlendedAlpha. When bAlpha is set at 0, the window is completely transparent. When bAlpha is set at 255, the window is completely opaque, the normal or default state. bAlpha is only relevant when the fourth parameter, dwFLAGS, is assigned as LWA_ALPHA.
dwFLAGS is the desired event to be passed to the DLL. There are actually two layered window actions that can be passed in the "SetLayeredWindowAttributes" call. The first is LWA_COLORKEY and the second is LWA_ALPHA.
LWA_COLORKEY assigns one color of the window to be transparent. If the value of dwFLAGS is set to LWA_COLORKEY, then that one assigned color is the color passed in ColorRef and bAlpha is ignored. If the value of dwFLAGS is set to LWA_ALPHA, then the degree of opacity of the entire window is set to the value passed in bAlpha and ColorRef is ignored.

Demo of LWA_ALPHA

The Transparent Window demo works with the action LWA_ALPHA. The numerical value of the Windows constant LWA_ALPHA is 2. Since LWA_ALPHA is not a Liberty BASIC recognized constant, then that value (2) will be assigned to the user defined variable LWA.ALPHA.

    LWA.ALPHA = 2

Here is a simple modification of Transparent Window using the previously described constants and variables. This demo requires Windows 2000, Windows XP, or better.

' Set the Variables
    WS.EX.LAYERED = 524288 ' WS_EX_LAYERED Unrecognized Windows constant
    ColorRef = 0 ' ColorRef ignored in this demo so value is irrelevant
    bAlpha = 128 ' Degree of opacity (0 - 255)
    LWA.ALPHA = 2 ' LWA_ALPHA Unrecognized Windows constant
    dwFLAGS = LWA.ALPHA ' Action is transparency of entire window (LWA_ALPHA)
    Nomainwin
 
    WindowWidth = 600
    WindowHeight = 400
 
    UpperLeftX = int((DisplayWidth-WindowWidth)/2)
    UpperLeftY = int((DisplayHeight-WindowHeight)/2)
 
    text$ = "Translucence here is initially set at 128.  Try " + _
        "setting bAlpha to higher and lower numbers for desired " + _
        "transparency.  0 will make your window complete " + _
        "transparent.  255 is the maximum.  This demo will " + _
        "NOT work on Windows 98 or Windows 95."
 
    Statictext #main.msg, text$, 20, 20, 550, 200
    Stylebits #main, 0, 0, WS.EX.LAYERED, 0
    Open "Transparent Window" for Window as #main
 
    #main "Trapclose EndDemo"
    hMain = hWnd(#main)
    #main "Font Verdana 12 Bold"
    Call SetLayeredWindowAttributes, hMain, ColorRef, bAlpha, dwFLAGS
 
    Wait
 
Sub EndDemo handle$
    Close #main
    End
End Sub
 
Sub SetLayeredWindowAttributes hWindow, ColorRef, bAlpha, dwFLAGS
    CallDLL #user32, "SetLayeredWindowAttributes", _
        hWindow as Ulong, _
        ColorRef as Long, _
        bAlpha as Long, _
        dwFLAGS as Long, _
        result as Long
End Sub

Stefan Pendl's Demo Using LWA_COLORKEY

The inspiration for this article came from Stefan Pendl- StPendl, one of Liberty BASIC's true gurus. Stefan is a contributor at both the Official Liberty BASIC Support Group and the very popular Liberty BASIC Conforum.

The Request: "I have read in the news letter 132 about how to make shaped windows, but it is a little bit confusing, is there a way faster then reading pixle by pixle, like setting one color as the part to be deleted, and if thats what the other examples do, can i make the drawing without haveing to use api calls for
drawing. my whole goal in total is to make an icon sized animal walk around on the screen. I have a program that does it already, but i would like to make my
own thing. Thanks in advance." Message #31512

Stefan's Reply: "How about making a fullscreen graphic window, make it transparent and use simple sprites ???"Message #31533

Stefan's Demo Message #31576 Be sure to run this demo from your Liberty BASIC root directory so the /SPRITES folder and cave1.bmp can be found.

'---code start
nomainwin
WindowWidth = DisplayWidth
WindowHeight = DisplayHeight
 
' You may want to change this path to your own path
LBFolder$ = "C:\Programme\Liberty BASIC v4.03"
' or simply
' LBFolder$ = DefaultDir$

graphicbox #m.g, 0, 0, WindowWidth, WindowHeight
 
'set the window to layered and topmost, to keep sprite visible
'and have access to the windows beneeth
WS.EX.LAYERED = hexdec("80000")
stylebits #m, 0, 0, WS.EX.LAYERED or _WS_EX_TOPMOST, 0
 
open "Sprite on Transparent Background" for window_popup as #m
#m "trapclose quit"
#m.g "down"
 
'make the white portion of the window transparent
hwndMain = hwnd(#m)
LWA.COLORKEY = 1
COLORREF = hexdec("FFFFFF")
calldll #user32, "SetLayeredWindowAttributes", _
hwndMain as ulong, _
COLORREF as ulong, _
bAlpha as short, _
LWA.COLORKEY as long, _
result as long
 
loadbmp "man", LBFolder$ + "\sprites\cave1.bmp"
loadbmp "man1", LBFolder$ + "\sprites\cave2.bmp"
#m.g "addsprite test man man1"
#m.g "home;posxy xPos yPos"
#m.g "spritexy test "; xPos; " "; yPos
#m.g "cyclesprite test 1"
 
call moveSprite "", "", xPos, yPos
timer 100, drawFrame
wait
 
sub quit handle$
unloadbmp "man"
close #handle$
end
end sub
 
sub moveSprite handle$, sprite$, xPosOld, yPosOld
xPos = int(rnd(0) * DisplayWidth) + 1
yPos = int(rnd(0) * DisplayHeight) + 1
 
if xPosOld < xPos then
#m.g "spriteorient test normal"
else
#m.g "spriteorient test mirror"
end if
 
#m.g "spritetravelxy test "; xPos; " "; yPos; " 15 moveSprite"
end sub
 
sub drawFrame
#m.g "drawsprites"
wait ' †Added to original code by Janet, see footnote for discussion
end sub
'---code end

† A recently identified bug in with a Timer Sub Event using Liberty BASIC is easily fixed by adding a WAIT statement in that fired sub event.

How cool is this!!

Closing Stefan's Demo

It may be difficult to regain focus of a transparent window. If you are finding difficulty closing Stefan's demo, press Alt - Tab until Sprite on Transparent Background is selected. Then press Alt - F4.

How Does Stefan's Demo Work?

In Stefan's Demo, a popup window is used. The background is white. White (&FFFFFF or 16777215) is set as the transparent color and no white pixels are drawn. Since the entire window is white, effectively, no pixel of the window is drawn. The window still provides a background for the sprite, though, and the sprite is content to bounce around that invisible window.

If you change

open "Sprite on Transparent Background" for window_popup as #m

open "Sprite on Transparent Background" for window as #m

you'll see more clearly how only the white pixels (and the graphicbox is comprised of all white pixels) are not drawn. All non-white pixels, in this case, the window caption and borders are drawn as usual. Notice the distortion of the title bar as the white pixels of the title have not been drawn.

In Stefan's demo, the Stylebits _WS_EX_TOPMOST is used to keep the invisible window on top of all other windows, even if that window isn't the window with focus. This is essential to keeping the sprite visible to the viewer. Since the invisible window spans the entire display screen and remains topmost, how then is the user able to interact with other programs? Simply stated, the "SetLayeredWindowsAttributes" allows all mouseclicks to filter down through the invisible pixels to the window underneath.

Reversing Transparency

There may be times when you will want to restore the translucent window to the default opacity of 255 or undo the single color transparency. To restore opacity, simply issue another call to "SetLayeredWindowAttributes" passing the parameters bAlpha with the value of 255 and dwFLAGS with the value of LWA_ALPHA, or 2.

When the passed dwFLAGS parameter is LWA_COLORKEY, the transparent color can be made opaque by assigning ColorKey a value of a non present color or even by passing bAlpha with a value of 255 and dwFLAGS with the value of LWA.COLORKEY or 2. Either might be effective in many cases, but the best method is to simply remove the Layered attribute. Get the current value of the extendedAddBits of the window with "GetWindowLongA". To this result, subtract the value of WS.EX.LAYERED using the Bitwise Operand XOR. Write the new value back to the window by calling "SetWindowLongA".

' Demo to demonstrating defining and reversing transparency
' Set the Variables
    WS.EX.LAYERED = 524288 ' WS_EX_LAYERED Unrecognized Windows constant
    ColorRef = 255 ' Long Pixel Color, ColorRef is only relevant when dwFLAGS = LWA.COLORKEY
    bAlpha = 128 ' Degree of opacity (0 - 255), bAlpha is only relevant when dwFLAGS = LWA.ALPHA
    LWA.COLORKEY = 1 ' LWA_COLORKEY Unrecognized Windows constant
    LWA.ALPHA = 2 ' LWA_ALPHA Unrecognized Windows constant
' Choose just ONE of these next two lines
    dwFLAGS = LWA.COLORKEY ' Action is transparency of just one color (LWA_COLORKEY)
'    dwFLAGS = LWA.ALPHA ' Action is transparency of entire window (LWA_ALPHA)

' Specify variables holding Windows constants as Global
    Global WS.EX.LAYERED, LWA.COLORKEY, LWA.ALPHA
 
    Nomainwin
 
    WindowWidth = 600
    WindowHeight = 400
 
    BackgroundColor$ = "Red"
    ForegroundColor$ = "Blue"
 
    UpperLeftX = int((DisplayWidth-WindowWidth)/2)
    UpperLeftY = int((DisplayHeight-WindowHeight)/2)
 
    text1$ = "The red pixels have been rendered transparent " + _
        "in this demo.  This demo will NOT work on Windows " + _
        "98 or Windows 95."
 
    text2$ = "Translucence here is initially set at 128.  Try " + _
        "setting bAlpha to higher and lower numbers for desired " + _
        "transparency.  0 will make your window complete " + _
        "transparent.  255 is the maximum.  This demo will " + _
        "NOT work on Windows 98 or Windows 95."
 
    If dwFLAGS = 1 Then
        Button #main.btn, " Show All Pixels ", ShowAllPixels, UL, 150, 250, 200, 30
    Else
        Button #main.btn, " FullOpacity ", FullOpacity, UL, 150, 250, 200, 30
    End If
 
    Statictext #main.msg, "", 20, 20, 550, 200
    Stylebits #main, 0, 0, WS.EX.LAYERED, 0
    Open "Transparent Window" for Window as #main
 
    #main "Trapclose EndDemo"
    hMain = hWnd(#main)
    #main, "Font Verdana 12 Bold"
 
    If dwFLAGS = 1 Then
        #main.msg text1$
    Else
        #main.msg text2$
    End If
    Call SetLayeredWindowAttributes, hMain, ColorRef, bAlpha, dwFLAGS
 
    Wait
 
Sub EndDemo handle$
    Close #main
    End
End Sub
 
Sub SetLayeredWindowAttributes hWindow, ColorRef, bAlpha, dwFLAGS
    CallDLL #user32, "SetLayeredWindowAttributes", _
        hWindow as Ulong, _
        ColorRef as Long, _
        bAlpha as Long, _
        dwFLAGS as Long, _
        result as Long
End Sub
 
Sub FullOpacity handle$
    Call SetLayeredWindowAttributes hWnd(#main), 0, 255, 2
    #main.msg, "The window is now 100% opaque."
    #main.btn, "!Hide"
End Sub
 
Sub ShowAllPixels handle$
    hMain = hWnd(#main)
    CallDLL #user32, "GetWindowLongA", _
        hMain as Ulong, _
        _GWL_EXSTYLE as Long, _
        style as Long
' Remove the extendedAddBits WS.EX.LAYERED
        newStyle = style xor WS.EX.LAYERED
    CallDLL #user32, "SetWindowLongA", _
        hMain as Ulong, _
        _GWL_EXSTYLE as Long, _
        newStyle as Long, _
        result as Long
    #main.msg, "The red pixels have been repainted."
    #main.btn, "!Hide"
End Sub

A special Thank You to Alyce Watson - alyce and Stefan Pendl - StPendl for their continued and unfailing willingness to mentor and share expertise. - JanetTerra

MDIScroll

RodBird — Mon, 23 Nov 2015 11:42:51 GMT

Why Scroll?

Sometimes we simply don't have enough room on a window for all of the controls needed by a program. We can get around this in several ways. One way is to move controls on and off the window as needed with the LOCATE statement. Another way is to make the controls do double duty. When one set of conditions is in effect, button one might be the "Okay" button, but when another set of conditions is in effect, it might be the "Save" button. This can get a little complicated! We can also break the program into logical parts and use separate windows to manage different tasks.

Here is a new idea. We can scroll the controls on the window. If we allow scrolling, then more controls, or larger controls may fit on a single window.

MDI is the Key

We could go about the scrolling in several ways, but using an MDI client is probably the easiest way of all. An MDI application has an MDI client that acts as parent to any child windows it contains. When one of the child windows is larger than the workspace, the MDI window automatically adds scrollbars to allow access to the entire child window.

Creating an MDI Client

As with other API-created controls, we create the MDI client with CreateWindowExA. It will itself be a child of our main program window, and it won't really be visible until it displays scrollbars. We need the handle of our program window, and the instance handle, which we retrieve with GetWindowLongA. We also fill arguments for the location and dimensions. See the sample program below, where all arguments for CreateWindowExA are documented.

Creating a Child Window

We'll need a child window to hold all of our controls. We don't want the user to move it around, so we'll create it with no titlebar using the window_popup style. We can make this window as large as we need to hold the controls, and of course we need to include commands to create these controls before the command to open the popup window. We'll locate the popup window so that it fills the client area of our main program window. Once this popup window is created, we'll make it a child of the MDI client with the SetParent function.

Making it Work

We need to check for the resize event of the window and resize the MDI client so that it fills the new workspace whenever the window changes size. If the user has scrolled the MDI window and then resizes the program window, the child popup will not be in the correct locatoin, so we'll also need to relocate our popup child window. We need to force a resize event when the window first opens so that the MDI scrollbars will display. We do all of these sizing and locating chores with MoveWindow.

The demo below only has a single button on the far right side of the popup child window. Your own program would probably have many controls on this window.

Scrolling Demo

'MDI window to allow
'scrolling of large window
'area
'based on work
'By Mitchell Kotler
 
nomainwin
 
    WindowWidth=350 : WindowHeight=350
    childWide=1400 : childHigh=1000 'child window dims
 
menu #main, "File", "E&xit",[quit]
open "Scrolling Big Window" for window as #main
print #main, "trapclose [quit]"
print #main, "resizehandler [resize]"
 
    hMain=hwnd(#main) 'main window handle
 
    calldll #user32, "GetWindowLongA",_
        hMain as uLong,_         'handle of window
        _GWl_HINSTANCE as long,_ 'flag for instance handle
        hInstance as uLONG       'returns instance handle of window
 
    dwStyle=_WS_CLIPCHILDREN OR _WS_CHILD OR _WS_VISIBLE OR _
        _WS_BORDER or _WS_VSCROLL OR _WS_HSCROLL
 
    'create an MDI Client Control
    calldll #user32, "CreateWindowExA",_
        0 as long,_             'extended class style
        "MDICLIENT" as ptr,_    'class name
        "" as ptr,_             'title or string
        dwStyle as long,_       'window style
        2 as long,_             'x org
        2 as long,_             'y org
        339 as long,_           'width
        302 as long,_           'height
        hMain as ulong,_        'parent window
        0 as ulong,_            'handle to menu = 0 for class menu
        hInstance as ulong,_    'instance handle of parent window
        "" as ptr,_             'always NULL
        hMDI as ulong           'returns handle of MDI Client
 
WindowWidth=childWide:WindowHeight=childHigh
statictext #child, "Scroll Me A LOT!",10,10,200,24
button #child.b, "Click Me!",[doClick],UL,1200,100,100,24
open "" for window_popup as #child
print #child, "trapclose [quit]"
 
    hChild=hwnd(#child) 'handle of popup window
 
    calldll #user32, "SetParent",_
        hChild as ulong,_    'make popup the child
        hMDI as ulong,_      'make MDI the parent
        result as long
 
    'use MoveWindow to force window resize
    'so scrollbars will show
    CallDLL #user32, "MoveWindow",hMain As uLong,_
         11 As Long, 11 As Long,_
         333 As Long, 333 As Long,_
         1 As long, r As long
 
wait
 
[resize]
    newWide=WindowWidth-4
    newHigh=WindowHeight-4
    ret=MoveWindow(hMDI,2,2,newWide,newHigh)
    ret=MoveWindow(hChild,0,0,childWide,childHigh)
    wait
 
[doClick]
    notice "Thanks for clicking me!"
    wait
 
[quit] close #child : close #main : end
 
Function MoveWindow(hWnd,x,y,wide,high)
    CallDLL #user32, "MoveWindow",_
        hWnd As uLong,_         'handle
        x As Long, y As Long,_  'x,y pos
        wide As Long,_          'width
        high As Long,_          'height
        1 As long,_             'repaint flag
        MoveWindow As long
    end function

MoveWindow

StPendl — Sun, 02 Jan 2011 16:29:40 GMT

Moving or Resizing a Window or Control

Native LOCATE Command

MoveWindow API

Demo

Moving or Resizing a Window or Control

Native LOCATE Command

Liberty BASIC includes a "LOCATE" command for moving and resizing controls. This command only works on controls and it only works in windows of type "WINDOW."

nomainwin
button #main.b, "Move Me",[moveMe],UL,10,10,100,30
open "Move a Button" for window as #main
#main "trapclose [quit]"
wait
 
[quit] close #main:end
 
[moveMe]
#main.b "!locate 50 100 200 50"
#main.b "I've been moved!"
#main "refresh"
wait

When the "LOCATE" command is sent to a control that can accept a new label or text, we must precede the command with a ! character as we did above, or the command string is simply displayed on the control and not acted on. Note the difference in the two lines below. The first line is a command that instructs the button to change its size and location. The second line changes the caption on the button.

#main.b "!locate 50 100 200 50"
#main.b "I've been moved!"

Don't forget to issue a "REFRESH" command to cause the window display to be updated after moving a control.

MoveWindow API

We can move and resize any window or control with the MoveWindow API call. The coordinates for the x and y locations of a window are relative to the upper left corner of the desktop. If the API call is used to move or resize a control, the coordinates are relative to the upper left corner of the window's workspace, which is called the Client Area.

Liberty BASIC does not currently have a native function for moving or resizing an open window. It also does not allow us to move or resize controls contained in windows that are not of type "WINDOW." We must use an API call to change the location and size of windows and of controls not in "WINDOW" type windows. \
To move or resize a window, use the handle of the window obtained with the HWND() function.

    hMain = HWND(#main)
 
    calldll #user32, "MoveWindow",_
    hMain as ulong, _       'window handle
    10 as long,_            'x location of window
    20 as long,_            'y location of window
    730 as long,_           'desired width of window
    590 as long,_           'desired height of window
    1 as long,_             'repaint flag,0=false,1=true
    ret as long             'nonzero=success

To move or resize a control, use the handle of the control obtained with the HWND() function.

hButton = HWND(#main.b)
 
calldll #user32, "MoveWindow",_
    hButton as ulong, _     'control handle
    50 as long,_            'x location of control
    150 as long,_            'y location of control
    200 as long,_           'desired width of control
    50 as long,_            'desired height of control
    1 as long,_             'repaint flag,0=false,1=true
    ret as long             'nonzero=success

Demo

nomainwin
button #main.b, "Move Me",[moveMe],UL,10,10,100,30
button #main.move, "Move Window",[moveWindow],UL,120,10,100,30
open "Move a Button" for window as #main
#main "trapclose [quit]"
wait
 
[quit] close #main:end
 
[moveMe]
#main.b "I've been moved!"
 
hButton = HWND(#main.b)
 
calldll #user32, "MoveWindow",_
    hButton as ulong, _     'control handle
    50 as long,_            'x location of control
    150 as long,_           'y location of control
    200 as long,_           'desired width of control
    50 as long,_            'desired height of control
    1 as long,_             'repaint flag,0=false,1=true
    ret as long             'nonzero=success
wait
 
[moveWindow]
    hMain = HWND(#main)
 
    calldll #user32, "MoveWindow",_
    hMain as ulong, _       'window handle
    10 as long,_            'x location of window
    20 as long,_            'y location of window
    730 as long,_           'desired width of window
    590 as long,_           'desired height of window
    1 as long,_             'repaint flag,0=false,1=true
    ret as long             'nonzero=success
 
    'we'll only move window once, then disable button 
    #main.move "!disable" 
 
 
wait

PushButtons

Alyce — Wed, 22 Jun 2011 13:18:05 GMT

Push Buttons

Button

A push button is a regular button. The user clicks on it to interact with a program. The button on the right in the image below is a push button.

As with all other controls, buttons must be listed in the code before the window is opened. There are two kinds of buttons in Liberty BASIC, (regular) push buttons and BMPBUTTONS. The command to create push buttons must begin with the window handle, then a dot and a unique extension. Although the use of an extension is optional, omitting it isn't recommended, since that limits the program's ability to send commands to the button. In the following example, the window handle is "#1," and the extension for this button is ".button1" Here is the format to include a button:

BUTTON #1.button1, "I'm a Button!", [branchLabel], UL, _
    xpos, ypos, width, height
or
BUTTON #1.button1, "I'm a Button!", subName, UL, _
    xpos, ypos, width, height

The label that appears on the button is written between the quotation marks.

After the button label, the button command must specify the branch label or sub name in the program where execution should continue when the button is pushed by the user. [branchLabel] or subName

The UL designates a corner of the client area. (Client area is the area of the window that does not include the titlebar, menu or frame - the workspace of the window.) UL stands for upper left. The button appears at a distance specified from the upper left corner. The other possibilities are UR (upper right,) LL (lower left,) and LR (lower right.)

The next number is the X position in relationship to the corner specified. The following number is the Y position.

The last two numbers are optional. Use them to specify the desired width and height of the button for a uniform look to the buttons in a window. If the program does not specify dimensions, the button is sized automatically to the correct width and height for the label and font size chosen. If the font size of a button is changed during program execution, it may be necessary to change the size of the button also with the LOCATE command, since Liberty BASIC does not automatically resize the button.

Default Button

To create a button in a dialog window that will be activated when the user pushes ENTER, give it the extension DEFAULT as in this example:

button #1.default, "OK",[do.it],UL,10,300

Non-literals in Button Statements

Expressions and variables are also acceptable as parameters in the BUTTON command. Some examples follow.

buttonwidth = 2*60
 
button #1.1, "Open",[open],UL,10,20,buttonwidth,40
button #1.1, "Edit",[edit],UL,200,20,buttonwidth,40
 
width = 60
height = 25
xOrigin = 10
yOrigin = 10
label$ = "Button"
bitmapFile$ = "run.bmp"
button #main.sized, label$+" Label!", [click], UL,_
    xOrigin+60, yOrigin, width*3, height
bmpbutton #main.run, bitmapFile$, [run], UL, xOrigin, yOrigin
bmpbutton #main.bug, "bug.bmp", [bug], UL, xOrigin, yOrigin * 4

EVENT HANDLERS

Both branch labels and subs can be used to handle button events. If a sub is used, the handle of the button is passed into the sub by Liberty BASIC. It is passed in as a string variable. Refer to it by placing the # character in front of this handle variable, as in the demo below:

button #1.b, "Click Me",clickMe,UL,10,10
button #1.c, "Pick Me",[pick],UL,10,60
open "duh" for window as #1
 
wait
 
[pick]
'enable the other button
#1.b "!enable"
wait
 
Sub clickMe handle$
'send a command to this button
'using handle variable
#handle$ "!disable"
End Sub

COLORS

The background color of a button is a system color. It cannot be changed by Liberty BASIC. The user's default system color for this is called BUTTONFACE by Liberty BASIC. It is not possible to change the color of the text displayed on the button.

LABEL

The label of a push button can be changed in the course of running the program. Bmpbuttons do not have labels. To change the label on a button, use this command:

print #1.button1, "Changed!"
 
or
 
caption$="Changed!"
print #1.button1, caption$

After the command is carried out, the button caption displays the text supplied in the PRINT command. (Changed!)

FONTS

The default font for controls is Ms Sans Serif 8 point. This is the same font most Windows applications use. A program may change the font that is displayed on buttons. Bmpbuttons cannot accept a FONT command.

print #window.bttn, "!font facename width height [attributes]"

First designate the font name, then the desired width and height of the font characters in pixels. If the command designates a value of 0 for the width, Liberty BASIC automatically supplies the default width for the chosen font. If a value (or 0) is given for width, the font is sized in pixels. If there is no width parameter specified, the font is sized in points. There are 72 points in an inch.

Possible attributes are bold, underscore, italic and strikeout. They may be used in any combination and listed in any order. Adding attributes is completely optional.

If the program cannot match the font exactly, it provides the closest font matching the one specified. If the desired font name contains blank spaces, you must use an underscore character in place of the spaces when specifying the face name. Both facename and attributes are case insensitive, so "Arial" is the same as "arial" and "ARIAL." "BOLD" is the same as "bolD" and "Bold." Here's the button font command as it appears in a program:

print #1.button1, "!font Times_New_Roman 0 20 bold"

SETFOCUS

To cause a button to receive the input focus, issue a !SETFOCUS command:

print #1.button1, "!setfocus"

LOCATE

It is possible to move or resize a button during program execution with the LOCATE statement. After the locate command is sent to the button, always send a REFRESH command to the window itself, so that the screen is redrawn to reflect the change. The format is:

print #1.button1, "locate X Y Width Height"
print #1, "refresh"

In a program, it looks like this:

print #1.button1, "locate 20 400 100 30"
print #1.button2, "locate 20 400 ";buttonwidth;" ";buttonheight
print #1, "refresh"

SHOW/HIDE

To hide a button or show a button:

print #1.button1, "!show"
print #1.button2, "!hide"

ENABLE/DISABLE

A button can be disabled, so that it appears grayed-out and the user cannot click it. It can be enabled again with the ENABLE command:

print #1.button1, "!enable"
print #1.button2, "!disable"

Retrieving Information from Textboxes

JanetTerra — Fri, 27 Aug 2010 02:42:34 GMT

Retrieving Information from Textboxes with SendMessageA

The Native Liberty BASIC Command

Retrieving Information from Textboxes with SendMessageA

The Native Liberty BASIC Command

A Multiline Textbox

CallDLL #user32, "SendMessageA"

Get the Number of Lines in the Textbox

Get the Number of Characters in Each Line of Text

Liberty BASIC's Mid$() Function

Liberty BASIC has a native command for retrieving textbox contents -

Print #main.tbx1, "!Contents? text$"

In most instances, this is all the code programs require.

    WindowWidth = 400
    WindowHeight = 300
    UpperLeftX = Int((DisplayWidth - WindowWidth) /2)
    UpperLeftY = Int((DisplayHeight - WindowHeight) /2)
    Statictext #main.stx1, "What is your name?", 20, 34, 70, 60
    Textbox #main.tbx1, 100, 50, 200, 30
    Button #main.default, " OK ", GetName, UL, 320, 50
    Open "Retrieving Textbox Contents" for Dialog as #main
    #main "Trapclose XbyTrap"
    #main "Font Times_New_Roman 12 Bold"
 
 
Wait
 
Sub XbyTrap handle$
    Close #handle$
    End
End Sub
 
Sub GetName handle$
    #main.tbx1 "!Contents? name$"
    Notice "Hello, ";name$
End Sub

A Multiline Textbox

There are times when a multiline, word wrapping textbox may be preferred over the native Liberty BASIC texteditor. See also An Improved Stylebits Textbox.

There may also be a need to

Get the number of lines in the textbox
Get the number of characters in each line of text
Get each separate line of text

These functions are possible with an API call to #user32, "SendMessageA".

CallDLL #user32, "SendMessageA"

The SendMessageA function sends a specified messsage to a window or a control. The arguments to be passed include

handle The handle of the window or control ULONG
Msg The specific message LONG
wParam additional information about the message LONG
lParam additional information about the message LONG

When the message is received, the return value specifies the result of the message processing.

result LONG

Visit the MSDN Library for more information about SendMessage.

Get the Number of Lines in the Textbox

The Windows constant _EM_GETLINECOUNT is the message used to retrieve the number of lines from a textbox.

    CallDLL #user32, "SendMessageA", _
        hText as Ulong, _ ' handle of the textbox
        _EM_GETLINECOUNT as Long, _ ' message to be passed
        0 as Long, _ ' no further information to be passed
        0 as Long, _ ' no further information to be passed
        result as Long ' Windows returns the number of lines

Here is a demo to get the number of lines in a textbox. The mainwindow is kept visible for the printing of returned information. You may need to reposition your GUI window to see this information.

' Define a textbox
    Textbox #main.tb, 10, 20, 150, 68
 
' Stylebits for word wrapping and vertical scrolling
    Stylebits #main.tb, _WS_VSCROLL OR _ES_MULTILINE, _ES_AUTOHSCROLL, 0, 0
 
' Define text
    demoText$ = "All Gaul is divided into three parts, one of " + _
        "which the Belgae inhabit, the Aquitani another, those who " + _
        "in their own language are called Celts, in our Gauls, the third. " + _
        "All these differ from each other in language, customs, and laws."
 
    Open "Lines of Multiline Textbox" for Window as #main
    #main "Trapclose XbyTrap"
    #main "Font Times_New_Roman 10 bold"
 
' Print the text in the textbox
    #main.tb demoText$
 
' Get the handle of the textbox
    hText=hWnd(#main.tb)
 
' Pass the required arguments to SendMessageA API
    nLines = ReturnedMessage(hText, _EM_GETLINECOUNT, 0, 0)
    Print "There are ";nLines;" lines in this textbox."
 
Wait
 
' Program ends here
Sub XbyTrap handle$
    Close #handle$
    End
End Sub
 
' SendMessageA Function
Function ReturnedMessage(handle, Msg, wParam, lParam)
    CallDLL #user32, "SendMessageA", _
        handle as Ulong, _
        Msg as Long, _
        wParam as Long, _
        lParam as Long, _
        ReturnedMessage as Long
End Function

Get the Number of Characters in Each Line of Text

SendMessageA will not return the actual text string. Instead, it returns the number of characters in that string. This next demo is the same as the previous demo, with a function added to get the number of characters at the end of each line. It is important to recognize that the function does not return the number of characters in that line, but the number of characters from the beginning of the text to the end of that line. Again using the API call SendMessageA, the handle of the textbox is passed as well as the message _EM_LINEINDEX. SendMessageA also needs to know which line is being questioned. The first available extra information argument, wParam, passes the line number to be queried. There is no additional information needed, so the second informational argument, lParam, remains 0.

    CallDLL #user32, "SendMessageA", _
        hText as Ulong, _ ' handle of the textbox
        _EM_LINEINDEX as Long, _ ' message to be passed
        lineNumber as Long, _ ' the queried line number
        0 as Long, _ ' no further information to be passed
        result as Long ' Windows returns the number of lines

Since the last line is treated a little differently, the loop must terminate at the next to the last line For i = 1 to nLines - 1. The code for the last line immediately follows the loop.

' Define a textbox
    Textbox #main.tb, 10, 20, 150, 68
 
' Stylebits for word wrapping and vertical scrolling
    Stylebits #main.tb, _WS_VSCROLL OR _ES_MULTILINE, _ES_AUTOHSCROLL, 0, 0
 
' Define text
    demoText$ = "All Gaul is divided into three parts, one of " + _
        "which the Belgae inhabit, the Aquitani another, those who " + _
        "in their own language are called Celts, in our Gauls, the third. " + _
        "All these differ from each other in language, customs, and laws."
 
    Open "Lines of Multiline Textbox" for Window as #main
    #main "Trapclose XbyTrap"
    #main "Font Times_New_Roman 10 bold"
 
' Print the text in the textbox
    #main.tb demoText$
 
' Get the handle of the textbox
    hText=hWnd(#main.tb)
 
' Pass the required arguments to SendMessageA API
    nLines = ReturnedMessage(hText, _EM_GETLINECOUNT, 0, 0)
    Print "There are ";nLines;" lines in this textbox."
 
' Get the total number of characters at the end of each line
    For i = 1 to nLines - 1
        nCharacters = ReturnedMessage(hText, _EM_LINEINDEX, i, 0)
        Print "Line #";i;": ";nCharacters;" Characters"
    Next i
 
Wait
 
' Program ends here
Sub XbyTrap handle$
    Close #handle$
    End
End Sub
 
' SendMessageA Function
Function ReturnedMessage(handle, Msg, wParam, lParam)
    CallDLL #user32, "SendMessageA", _
        handle as Ulong, _
        Msg as Long, _
        wParam as Long, _
        lParam as Long, _
        ReturnedMessage as Long
End Function

How will knowing what the total number of characters reveal the actual number of characters in each line? By keeping track of how many characters were used in preceding lines, the number of characters already assigned is known. Subtract that number from the number of characters up to and including the selected line. The difference is the number of characters in just the selected line. Start the position, startPos, as 1.

' Define a textbox
    Textbox #main.tb, 10, 20, 150, 68
 
' Stylebits for word wrapping and vertical scrolling
    Stylebits #main.tb, _WS_VSCROLL OR _ES_MULTILINE, _ES_AUTOHSCROLL, 0, 0
 
' Define text
    demoText$ = "All Gaul is divided into three parts, one of " + _
        "which the Belgae inhabit, the Aquitani another, those who " + _
        "in their own language are called Celts, in our Gauls, the third. " + _
        "All these differ from each other in language, customs, and laws."
 
    Open "Lines of Multiline Textbox" for Window as #main
    #main, "Trapclose XbyTrap"
    #main, "Font Times_New_Roman 10 bold"
 
' Print the text in the textbox
    #main.tb demoText$
    textLength = Len(demoText$)
 
' Get the handle of the textbox
    hText=hWnd(#main.tb)
 
' Pass the required arguments to SendMessageA API
    nLines = ReturnedMessage(hText, _EM_GETLINECOUNT, 0, 0)
    Print "There are ";nLines;" lines in this textbox"
 
' The starting position is 1
    startPos = 1
 
    For i = 1 to nLines - 1
' Get the total number of characters in each line
        nCharacters = ReturnedMessage(hText, _EM_LINEINDEX, i, 0)
' The characters in that line start with startPos and continue through to nCharacters
        Print "Line ";i;": Characters ";startPos;" - ";nCharacters
' startPos moves up to the nCharacters pos for the next line
        startPos = nCharacters + 1
    Next i
' Get the number of characters in the last line by subtracting the nCharacters
' found thus far from the Length of the entire text
    nCharacters = textLength - nCharacters
    Print "Line ";i;": Characters ";startPos;" - ";textLength
 
'Wait for button to be pushed
    Wait
 
' Program ends here
Sub XbyTrap handle$
    Close #handle$
    End
End Sub
 
' SendMessageA Function
Function ReturnedMessage(handle, Msg, wParam, lParam)
    CallDLL #user32, "SendMessageA", _
        handle as Ulong, _
        Msg as Long, _
        wParam as Long, _
        lParam as Long, _
        ReturnedMessage as Long
End Function

Liberty BASIC's Mid$() Function

Now that the starting and ending character position number is known, the Liberty BASIC Mid$() function can be used to extract that one line. The Mid$() function has 3 elements

The whole text to be parsed (demoText$)
The starting position (startPos)
The number of characters to be extracted from the starting position to the right (nCharacters - startPos)

A simple demo of the Liberty BASIC Mid$() function -

    txt$ = "trouble"
    m$ = Mid$(txt$, 4, 3)
    Print m$
    End

Executing this code prints ubl, where u is the character in the fourth position of the string trouble, and ubl are the three characters in sequence beginning in this fourth position.

In this textbox demo, startPos becomes the start position and nCharacters - startPos becomes the sequence range of characters. Here is the code again, this time extracting and printing each line of text.

' Define a textbox
    Textbox #main.tb, 10, 20, 150, 68
 
' Stylebits for word wrapping and vertical scrolling
    Stylebits #main.tb, _WS_VSCROLL OR _ES_MULTILINE, _ES_AUTOHSCROLL, 0, 0
 
' Define text
    demoText$ = "All Gaul is divided into three parts, one of " + _
        "which the Belgae inhabit, the Aquitani another, those who " + _
        "in their own language are called Celts, in our Gauls, the third. " + _
        "All these differ from each other in language, customs, and laws."
 
    Open "Lines of Multiline Textbox" for Window as #main
    #main "Trapclose XbyTrap"
    #main "Font Times_New_Roman 10 bold"
 
' Print the text in the textbox
    #main.tb demoText$
    textLength = Len(demoText$)
 
' Get the handle of the textbox
    hText=hWnd(#main.tb)
 
' Pass the required arguments to SendMessageA API
    nLines = ReturnedMessage(hText, _EM_GETLINECOUNT, 0, 0)
    Print "There are ";nLines;" lines in this textbox"
 
' The starting position is 1
    startPos = 1
 
    For i = 1 to nLines - 1
' Get the total number of characters in each line
        nCharacters = ReturnedMessage(hText, _EM_LINEINDEX, i, 0)
' Print that line of text using the Mid$() function
        Print Mid$(demoText$, startPos, nCharacters - startPos)
' startPos moves up to the nCharacters pos for the next line
        startPos = nCharacters + 1
    Next i
' Get the number of characters in the last line by subtracting the nCharacters
' found thus far from the Length of the entire text
    nCharacters = textLength - nCharacters
    Print Mid$(demoText$, startPos, nCharacters)
 
'Wait for button to be pushed
    Wait
 
' Program ends here
Sub XbyTrap handle$
    Close #handle$
    End
End Sub
 
' SendMessageA Function
Function ReturnedMessage(handle, Msg, wParam, lParam)
    CallDLL #user32, "SendMessageA", _
        handle as Ulong, _
        Msg as Long, _
        wParam as Long, _
        lParam as Long, _
        ReturnedMessage as Long
End Function

You may never need to extract single lines of text in a multiline textbox, but at least you know you can.

Stylebits - Buttons

StPendl — Fri, 16 Aug 2013 08:54:29 GMT

Reviewing the Stylebits Parameters

Stylebits and a Default Button

A default button is the button that will be triggered with the Enter key, as long as the dialog window has focus. Without stylebits, a default button is only possible in a Dialog Window and then only if the button has the extension default. Brent Thorn posted code using Stylebits _BS_DEFPUSHBUTTON to assign a default button in a regular window with any extension. Thanks, Brent! Be sure to give focus to the dialog window by setting focus to one of the (non-button) controls prior to the activation of the default button. A simple Setfocus to a textbox (any textbox) will accomplish that. Here is a modification of Brent's code.

'Using a Default Button in a Regular Window
'Thanks to Brent Thorn
' http://libertybasic.conforums.com/index.cgi?board=novice&action=display&num=1134254812
'Modifications by Janet = Menu and Setfocus to #main.tbx1
 
    WindowWidth = 300
    WindowHeight = 350
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
    Menu #main, "&Options", "E&xit", EndDemoMenu
    Textbox #main.tbx1, 150, 50, 120, 30
    Textbox #main.tbx2, 150, 100, 120, 30
    Textbox #main.tbx3, 150, 150, 120, 30
    Textbox #main.tbx4, 150, 200, 120, 30
    Stylebits #main.default, _BS_DEFPUSHBUTTON, 0, 0, 0
    Button #main.default, "", DefaultButton, UL, -100, -100
 
    Open "Default Button in a Regular Window" for Window as #main
    #main "Trapclose EndDemo"
    #main.textbox "!Setfocus"
 
    Wait
 
    Sub DefaultButton handle$
        #main.tbx1 "!Contents? text1$"
        #main.tbx2 "!Contents? text2$"
        #main.tbx3 "!Contents? text3$"
        #main.tbx4 "!Contents? text4$"
        Notice "The textboxes read";Chr$(13);Chr$(13) + _
            text1$;Chr$(13);text2$;Chr$(13);text3$;Chr$(13);text4$
    End Sub
 
    Sub EndDemoMenu
        Call EndDemo "#main"
    End Sub
 
    Sub EndDemo handle$
        Close #main
        End
    End Sub

Stylebits and Button Labels

Many of the stylebits statictext border effects can be obtained with buttons as well. Use the same windows style _WS_ prefixes seen in changing window and other control edges. You can even add a titlebar to a button. These stylebits give a bit of variety to the button appearance and may enhance the overall 3D effect.

_WS_BORDER, 0, 0, 0
_WS_DLGFRAME
_WS_CAPTION, _WS_MAXIMIZEBOX
0, 0, _WS_EX_CLIENTEDGE, 0
0, 0, _WS_EX_CLIENTEDGE or _WS_EX_DLGMODALFRAME, 0

This demo shows some of the border effects that can be achieved with stylebits

    WindowWidth = 600
    WindowHeight = 560
    UpperLeftX = Int((DisplayWidth-WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight-WindowHeight)/3)
 
    Nomainwin
 
    Button #demo.bttn1, "One", Click, UL, 20, 60, 80, 40
    bttnText1$ = "0, 0, 0, 0 'No Stylebits"
    Statictext #demo, bttnText1$, 180, 70, 400, 30
    Button #demo.bttn2, "Two", Click, UL, 20, 120, 80, 40
    bttnText2$ = "_WS_BORDER, 0, 0, 0"
    Stylebits #demo.bttn2, _WS_BORDER, 0, 0, 0
    Statictext #demo, bttnText2$, 180, 130, 400, 30
    Button #demo.bttn3, "Three", Click, UL, 20, 180, 80, 40
    bttnText3$ = "_WS_DLGFRAME, 0, 0, 0"
    Stylebits #demo.bttn3, _WS_DLGFRAME, 0, 0, 0
    Statictext #demo, bttnText3$, 180, 190, 400, 30
    Button #demo.bttn4, "Four", Click, UL, 20, 240, 80, 100
    bttnText4$ = "_WS_CAPTION, _WS_MAXIMIZEBOX, 0, 0";Chr$(13) + _
        "Remove maximize ability or double clicking caption will cause " + _
        "button to expand to size of window."
    Stylebits #demo.bttn4, _WS_CAPTION, _WS_MAXIMIZEBOX, 0, 0
    Statictext #demo, bttnText4$, 180, 250, 400, 90
    Button #demo.bttn5, "Five", Click, UL, 20, 360, 80, 40
    bttnText5$ = "0, 0, _WS_EX_CLIENTEDGE, 0"
    Stylebits #demo.bttn5, 0, 0, _WS_EX_CLIENTEDGE, 0
    Statictext #demo, bttnText5$, 180, 370, 400, 30
    Button #demo.bttn6, "Six", Click, UL, 20, 420, 80, 40
    bttnText6$ = "0, 0, _WS_EX_CLIENTEDGE or _WS_EX_DLGMODALFRAME, 0"
    Stylebits #demo.bttn6, 0, 0, _WS_EX_CLIENTEDGE or _WS_EX_DLGMODALFRAME, 0
    Statictext #demo, bttnText6$, 180, 420, 400, 60
    msg$ = "These are only a few examples of button borders available with " + _
        "stylebits.  Experiment to find others."
    Statictext #demo, msg$, 20, 480, 560, 60
 
    Open "Button Effects with Stylebits" for Window as #demo
    #demo "Trapclose EndDemo"
    #demo "Font Times_New_Roman 14 Bold"
    Wait
 
Sub EndDemo handle$
    Close #demo
    End
End Sub
 
Sub Click handle$
    nButton$ = Right$(handle$, 1)
    Notice "Button #";nButton$;" Clicked"
End Sub

Stylebits and Tabbing

Pressing the TAB key can cycle focus from one control to the next. The cycling order is the same order as that which the controls are created. Sometimes it may be desirable to not include a control in the tabbed cycle. The programmer may not want the QUIT button to be included in the TAB Cycle so that the user doesn't inadvertently exit a program prematurely. Assigning the stylebit _WS_TABSTOP to the RemoveBit (second) stylebits parameter will keep that button from gaining focus in the TAB sequence. The button does remain active and will receive focus when mouseclicked.

    WindowWidth = 600
    WindowHeight = 560
    UpperLeftX = Int((DisplayWidth-WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight-WindowHeight)/3)
 
    Nomainwin
 
    Button #demo.bttn1, "Button 1", Click, UL, 100, 100, 120, 40
    Stylebits #demo.bttn1, 0, 0, 0, 0
    Button #demo.bttn2, "Button 2", Click, UL, 100, 200, 120, 40
    Stylebits #demo.bttn2, 0, 0, 0, 0
    Button #demo.bttn3, "Button 3", Click, UL, 320, 100, 120, 40
    Stylebits #demo.bttn3, 0, 0, 0, 0
    Button #demo.bttn4, "Button 4", Click, UL, 320, 200, 120, 40
    Stylebits #demo.bttn4, 0, 0, 0, 0
    Button #demo.bttn5, "Exit", endDemo, UL, 100, 300, 120, 40
    Statictext #demo, "0, _WS_TABSTOP, 0, 0", 40, 350, 200, 30
    Stylebits #demo.bttn5, 0, _WS_TABSTOP, 0, 0
    Textbox #demo.txtbx, 320, 300, 120, 40
    Stylebits #demo.txtbx, 0, _WS_TABSTOP, 0, 0
    Statictext #demo, "0, _WS_TABSTOP, 0, 0", 320, 350, 200, 30
    msg$ = "Use the TAB key to maneuver from one button to the next.  " + _
        "The button with focus has a darkened outline.  The removal of " + _
        "_WS_TABSTOP stylebits prevents the EXIT button and the textbox " + _
        "from being part of the tabbed cycle.  Note that one button must " + _
        "receive focus before the TAB key can be recognized."
    StaticText #demo.txt5, msg$, 20, 390, 560, 120
 
    Open "Button Effects with Stylebits" for Window as #demo
    #demo "Trapclose EndDemo"
    #demo "Font Times_New_Roman 14 Bold"
    #demo.bttn4 "!Setfocus"
 
    Wait
 
Sub EndDemo handle$
    Close #demo
    End
End Sub
 
Sub Click handle$
    nButton$ = Right$(handle$, 1)
    Notice "Button #";nButton$;" Clicked"
End Sub

Stylebits and Formatted Text Labels

The stylebits commands to format button text labels are similar to those _ES_ textbox and statictext formatting commands. Button formatting style commands begin with _BS_. The default style is text that remains on one line centered both vertically and horizontally. With stylebits, you can left justify, right justify, center, place text at the top of the button and place text at the bottom of the button. The most useful of these stylebits is the _BS_MULTILINE which allows word wrapping and multiline button labels.

_BS_LEFT
_BS_CENTER 'The Default
_BS_RIGHT
_BS_TOP
_BS_BOTTOM
_BS_MULTLINE

This third demo demonstrates button text formatting with stylebits

    WindowWidth = 600
    WindowHeight = 560
    UpperLeftX = Int((DisplayWidth-WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight-WindowHeight)/3)
 
    Nomainwin
    Button #demo.bttn1, "Default", Click, UL, 20, 80, 120, 80
    Statictext #demo, "0, 0, 0, 0", 44, 165, 260, 60
    Button #demo.bttn2, "Multiline Text on a Button", Click, UL, 20, 230, 120, 80
    Stylebits #demo.bttn2, _BS_MULTILINE, 0, 0, 0
    Statictext #demo, "_BS_MULTILINE, 0, 0, 0", 20, 315, 260, 60
    Button #demo.bttn3, "Text@Bottom", Click, UL, 300, 80, 120, 80
    Stylebits #demo.bttn3, _BS_BOTTOM, 0, 0, 0
    Statictext #demo, "_BS_BOTTOM, 0, 0, 0", 300, 165, 260, 260
    Button #demo.bttn4, "Text@Top", Click, UL, 300, 230, 120, 80
    Stylebits #demo.bttn4, _BS_TOP, 0, 0, 0
    Statictext #demo, "_BS_TOP, 0, 0, 0", 300, 315, 260, 60
 
    msg$ = "See API Corner - Easy BMPButtons by Alyce Watson " + _
        "in the Liberty BASIC Newsletter Issue #123 to learn how the " + _
        "Stylebit _BS_BITMAP is used to create a more Windows " + _
        "conforming look to your buttons. "
    StaticText #demo.txt5, msg$, 20, 370, 560, 120
 
    Open "Button Formatting with Stylebits" for Window as #demo
    #demo "Trapclose EndDemo"
    #demo "Font Times_New_Roman 14 Bold"
    #demo.bttn4 "!Setfocus"
    Wait
 
Sub EndDemo handle$
    Close #demo
    End
End Sub
 
Sub Click handle$
    nButton$ = Right$(handle$, 1)
    Notice "Button #";nButton$;" Clicked"
End Sub

Stylebits and API Calls

Stylebits allow buttons to display images, but only when accompanied by an API call to user32.dll (SendMessageA). For an indepth explanation of placing images on button controls, see API Corner - Easy BmpButtons (Liberty BASIC Newsletter, May, 2004) by Alyce Watson. In this referenced article, Alyce also explains how using Stylebits with BmpButtons preserves the intended recessed look of the button when clicked, rather than the inverse color effect on the non-Stylebits native Liberty Basic BmpButton. If you use the _BS_BITMAP stylebit, be sure to include the height and width of the bitmap as the height and width of the button. Otherwise, the button size defaults to that of the null character of the chosen font. As with statictext, you can combine _BS_BITMAP with border styles to achieve interesting effects. Try making colorful buttons in your program without having to preload bitmap images.

' Demonstrates colorful buttons without first
' having to load bitmaps
    WindowWidth = 600
    WindowHeight = 560
    UpperLeftX = Int((DisplayWidth-WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight-WindowHeight)/3)
 
    Nomainwin
 
    Open "Quick Draw" for Graphics as #1
    #1 "Trapclose EndDemo"
    #1 "Down"
    hBmp1 = solidButton()
    hBmp2 = varigatedButton()
    hBmp3 = stripedButton()
    Close #1
 
    Button #demo.b1, "", Click, UL, 20, 20, 50, 50
    Stylebits #demo.b1, _BS_BITMAP, 0, _WS_EX_CLIENTEDGE OR _WS_EX_DLGMODALFRAME, 0
    Button #demo.b2, "", Click, UL, 20, 100, 50, 50
    Stylebits #demo.b2, _BS_BITMAP OR _WS_DLGFRAME, 0, 0, 0
    Button #demo.b3, "", Click, UL, 20, 180, 50, 50
    Stylebits #demo.b3, _BS_BITMAP OR _WS_BORDER, 0, 0, 0
 
    Open "Colorful Buttons" for Window as #demo
    #demo "Trapclose EndDemo"
    hButton1 = hWnd(#demo.b1)
    Call CreateBMPButton hButton1, hBmp1
    hButton2 = hWnd(#demo.b2)
    Call CreateBMPButton hButton2, hBmp2
    hButton3 = hWnd(#demo.b3)
    Call CreateBMPButton hButton3, hBmp3
    Wait
 
Sub EndDemo handle$
    Close #demo
    End
End Sub
 
Sub Click handle$
    nButton$ = Right$(handle$, 1)
    Notice "Button #";nButton$;" Clicked"
End Sub
 
 
Sub CreateBMPButton hButton, hBmp
    CallDLL #user32, "SendMessageA",_
        hButton As uLong, _
        _BM_SETIMAGE As Long,_
        _IMAGE_BITMAP as long,_
        hBmp As uLong,_
        re As Long
End Sub
 
Function solidButton()
    hue$ = "128 0 128"
    #1 "Backcolor ";hue$
    #1 "Color ";hue$
    #1 "Place 0 0"
    #1 "Boxfilled 50 50"
    #1 "Getbmp button1 1 1 50 50"
    solidButton = hBmp("button1")
End Function
 
Function varigatedButton()
    c1 = 51: c2 = 101
    blueHue = 232
    For i = 1 to 25
        #1 "Color 0 0 ";blueHue
        #1 "Place ";c1;" ";c1
        #1 "Box ";c2;" ";c2
        c1 = c1+1: c2 = c2-1
        blueHue = blueHue-8
    Next i
    #1 "Flush"
    #1 "Getbmp button2 51 51 50 50"
    varigatedButton = hBmp("button2")
End Function
 
Function stripedButton()
    hueStrand$ = "Red White Blue White Red"
    For i = 0 to 4
        hue$ = Word$(hueStrand$, i+1)
        #1, "Color ";hue$
        For j = 1 to 10
            #1, "Line ";50+i*10+j;" 0 ";50+i*10+j;" 50"
        Next j
    Next i
    #1 "Flush"
    #1 "Getbmp button3 50 0 50 50"
    stripedButton = hBmp("button3")
End Function

These are just some examples of what you can do with stylebits and buttons. With experimentation, you may find more.

A List of Stylebits

You can get a list of all dwStyles and dwExStyles available with the Stylebits command at the MSDN Library - Button Styles.

Stylebits - Comboboxes

JanetTerra — Fri, 27 Aug 2010 02:25:42 GMT

Reviewing the Stylebits Parameters

The four parameters of stylebits are AddBit, RemoveBit, AddExtendedBit, RemoveExtendedBit. For a review of these four parameters, and an introduction to Stylebits in general, please view Stylebits - Windows.

A combobox is a combination listbox and textbox. Comboboxes are designed to save space by only showing the listbox when needed. When the arrow button is clicked, the listbox drops down. The user can then mouse click an item from the loaded array. The selected item is then printed in the textbox portion of the combobox. In the standard combobox, it is also possible for the user to type an entry in the textbox that is not already a member of the array. Unlike other controls, comboboxes do not respond well to changes with border stylebits. For this reason, the ExtendedBits aren't all that useful with comboboxes. The stylebits _CBS_LOWERCASE and _CBS_UPPERCASE work quite well with comboboxes. Even though _CBS_SORT is a documented Window's constant, I have never been able to sort a combobox array with the stylebit alone. Fortunately alphabetizing is easily accomplished with Liberty BASIC's native SORT and RELOAD commands. The stylebits that are most effective with comboboxes are _CBS_DROPDOWN, _CBS_DISABLENOSCROLL, _CBS_DROPDOWNLIST, and _CBS_AUTOHSCROLL.

The Listbox and the Textbox

CBS_DROPDOWN as an AddBits is the standard combobox setting. This allows the dropdown listbox. Including _CBS_DROPDOWN in RemoveBits will keep the listbox visible at all times, rather than dropping down when needed. The textbox allows user entry. The listbox automatically scrolls to an item which satisfies the entry being typed. Try typing in "July", then backspace the "y" and "l" and continue with "ne" to see this scrolling in action.

_CBS_DISABLENOSCROLL draws a disabled scroll bar rather than no scroll bar when the dropdown listbox displays all array items. This gives a more polished look to the listbox. _CBS_DISABLEDNOSCROLL looks especially nice when coupled as an AddBits with the RemoveBits _CBS_DROPDOWN.

_CBS_DROPDOWNLIST used as an AddBits will cause the textbox to act as statictext rather than an edit control. This will prevent users from typing into the textbox component of the combobox. This is especially useful if you want your user to select only what's available in the combobox array. Each keypress displays a member of the array with that initial character. Repeating the character brings up the next array item with the same initial letter in alphabetical order. You have probably seen this when prompted for your state abbreviation. Repeatedly pressing the 'M' brings up "Maine, Maryland, Massachusetts, etc.

_CBS_AUTOHSCROLL is another standard combobox default. The textbox scrolls when the user types in characters beyond the visible width of the combobox. By removing _CBS_AUTOHSCROLL, you can limit the number of characters typed by the user. This is, of course, dependent upon the width of the combobox and the size and weight of the font.

Probably the best way to see combobox stylebits effects are to see them in action. In this demo, six comboboxes are each loaded with the same array. Try mouse clicking and keyboard entry with all of them.

    WindowWidth = 400
    WindowHeight = 500
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/3)
 
    Dim month$(12)
    For i = 1 to 12
        Read m$
        month$(i) = m$
    Next i
 
    Nomainwin
'Set up a default button
    Button #main.default, "", selMonth, UL, -100, -100
'Remove default button from tabstop cycle
    Stylebits #main.default, 0, _WS_TABSTOP, 0, 0
'The Standard Combobox
    Statictext #main.st1, "Standard", 30, 14, 100, 24
    Combobox #main.cb1, month$(), selMonth, 30, 40, 100, 124
'Invisible Combobox; Not very practical.
    Statictext #main.st2, "Hidden", 150, 14, 100, 24
    Combobox #main.cb2, month$(), selMonth, 150, 40, 100, 124
    Stylebits #main.cb2, 0, _WS_VISIBLE, 0, 0
'Listbox stays visible at all times; Textbox accepts user input.
    Statictext #main.s3, "Visible Listbox", 270, 14, 100, 24
    Combobox #main.cb3, month$(), selMonth, 270, 40, 100, 124
    Stylebits #main.cb3, 0, _CBS_DROPDOWN, 0, 0
'Disabled vertical scroll bar when all items are visible
    Statictext #main.st4, "Disabled Unneeded Scrollbar", 30, 130, 100, 54
    Combobox #main.cb4, month$(), selMonth, 30, 200, 100, 260
    Stylebits #main.cb4, _CBS_DISABLENOSCROLL, _CBS_DROPDOWN, 0, 0
'Textbox doesn't accept user input, but instead selects Combobox item
'beginning with pressed character; Mouse clicking Textbox drops Listbox.
    Statictext #main.st5, "Keypress Initial", 150, 200, 100, 48
    Combobox #main.cb5, month$(), selMonth, 150, 250, 100, 124
    Stylebits #main.cb5, _CBS_DROPDOWNLIST, 0, 0, 0
'Limits user input to number of visible characters
    Statictext #main.st6, "Limit Number of Characters", 270, 200, 100, 48
    Combobox #main.cb6, month$(), selMonth, 270, 250, 80, 124
    Stylebits #main.cb6, 0, _CBS_AUTOHSCROLL, 0, 0
 
    Open "Stylebits and the Combobox" for Dialog as #main
    #main "Trapclose [endDemo]"
    #main "Font Times_New_Roman 12 Bold"
    #main.cb2 "![Invisible]"
    #main.cb1 "Setfocus"
 
    Wait
 
[endDemo]
    Close #main
    End
 
    Sub selMonth handle$
        If handle$ = "#main.default" Then
            #main.cb1 "Contents? m1$"
            #main.cb2 "Contents? m2$"
            #main.cb3 "Contents? m3$"
            #main.cb4 "Contents? m4$"
            #main.cb5 "Contents? m5$"
            #main.cb6 "Contents? m6$"
            month$ = "The Textboxes Contents" + Chr$(13) + _
                "Combobox 1: ";m1$ + Chr$(13) + _
                "Combobox 2: ";m2$ + Chr$(13) + _
                "Combobox 3: ";m3$ + Chr$(13) + _
                "Combobox 4: ";m4$ + Chr$(13) + _
                "Combobox 5: ";m5$ + Chr$(13) + _
                "Combobox 6: ";m6$ + Chr$(13)
        Else
            #handle$ "Selectionindex? sel"
            month$ = month$(sel)
        End If
        Notice "You chose ";month$
        #main.cb5 "Reload"
    End Sub
 
    Data "January", "February", "March", "April", "May", "June", "July"
    Data "August", "September", "October", "November", "December"

Dialog Windows, Default Buttons and the TabStop Cycle

The advantage of placing comboboxes on a dialog window is the use of the default button. A dialog window can have a default button that is activated when the user hits the ENTER key even if that button is not the control with focus. The default button must have the .default extension. In the above demo, the default button is used to read the contents of the textbox portion of each combobox. If you tab from one control to another, you will find that every sixth tab press appears to do nothing. The second combobox is not the culprit. Because it's hidden, that combobox is not receiving focus. It is the default button that lies off the window, but still able to receive focus. The stylebits _WS_TABSTOP as a RemoveBits for the default button removes the button from the tab cycle. The user can now tab through the five comboboxes without skipping a beat.

A List of Stylebits

You can get a list of all dwStyles and dwExStyles available with the Stylebits command at the MSDN Library - Combo Box Styles.

Stylebits - Dialog Windows

JanetTerra — Sun, 13 Sep 2015 23:45:16 GMT

Reviewing the Stylebits Parameters

Why a Dialog Window?

There are several reasons you might want to use a dialog window in your program. A common reason is the default button. Without stylebits, only dialog windows are capable of default buttons. From the Liberty BASIC help file:

A window of type DIALOG can contain a button with the extension ".default". If the user presses the ENTER key while the dialog window has focus, it is the same as if the button whose extension is "default" is pressed and program execution will continue at the event handler [branchLabel] for that button.

The following code is a simple program illustrating the default button.

    Statictext #dlg.txt, "Press Okay to close this window.", 20, 50, 100, 20
    Button #dlg.default, " Okay ", [OkayButton], UL, 140, 100
    Open "Default Button" for Dialog as #dlg
    Wait
 
[OkayButton]
    Close #dlg
    End

The Choice: A Default Button or a Menu

Unfortunately, dialog windows do not support menus. For a long time, Liberty BASIC programmers have had to choose between a default button and a menu. Recently, Brent Thorn posted code using Stylebits that will allow a default button in a regular window. So, while you still can't program a menu in a dialog window, you can code a default button in a regular window. This means a default button AND a menu in the same window. Thanks, Brent! One peculiarity I did discover was that one of the window controls needs to be given focus prior to the activation of the default button. A simple Setfocus to a textbox (any textbox) will accomplish that. Here is a modification of Brent's code.

'Using a Dialog Default Button in a Regular Window
'Thanks to Brent Thorn
' http://libertybasic.conforums.com/index.cgi?board=novice&action=display&num=1134254812
'Modifications by Janet = Menu and Setfocus to #main.tbx1

    WindowWidth = 300
    WindowHeight = 350
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
    Menu #main, "&Options", "E&xit", EndDemoMenu
    Textbox #main.tbx1, 150, 50, 120, 30
    Textbox #main.tbx2, 150, 100, 120, 30
    Textbox #main.tbx3, 150, 150, 120, 30
    Textbox #main.tbx4, 150, 200, 120, 30
    Stylebits #main.default, _BS_DEFPUSHBUTTON, 0, 0, 0
    Button #main.default, "", DefaultButton, UL, -100, -100
 
    Open "Default Button in a Regular Window" for Window as #main
    #main "Trapclose EndDemo"
    #main.tbx1 "!Setfocus"
 
    Wait
 
    Sub DefaultButton handle$
        #main.tbx1 "!Contents? text1$"
        #main.tbx2 "!Contents? text2$"
        #main.tbx3 "!Contents? text3$"
        #main.tbx4 "!Contents? text4$"
        Notice "The textboxes read";Chr$(13);Chr$(13) + _
            text1$;Chr$(13);text2$;Chr$(13);text3$;Chr$(13);text4$
    End Sub
 
    Sub EndDemoMenu
        Call EndDemo "#main"
    End Sub
 
    Sub EndDemo handle$
        Close #main
        End
    End Sub

An Improved Stylebits Textbox

Since the release of Liberty BASIC 4.0 and stylebits, multilines and wordwrapping have been accomplished in textboxes using the sequence _WS_VSCROLL OR _ES_MULTILINE, _ES_AUTOHSCROLL, 0, 0. Stylebits - Textboxes discusses such a textbox. While the text does, indeed, wrap, the user must resort to CTRL - Enter to force a line feed. Using a hidden button with the stylebit _BS_DEFPUSHBUTTON allows the program to retrieve the contents of the textbox, append Chr$(13);Chr$(10) to the text, then rewrite that text to the textbox. Now the textbox behaves just like any other word processing tool. As is common with so many of the Stylebits tricks, an API call is required to add the final polish. With native Liberty BASIC code, the cursor is placed in front of any text that's been printed in a textbox. The API call "SendMessageA" can be used to position the cursor at the end of the text instead. This cursor position makes keyboarding a more natural and fluent activity.

    Nomainwin
 
    WindowWidth = 400
    WindowHeight = 300
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
' Add a Textbox with Word Wrapping Capability
    Stylebits #main.tbx, _WS_VSCROLL OR _ES_MULTILINE, _ES_AUTOHSCROLL, 0, 0
    Textbox #main.tbx, 20, 20, 150, 200
 
' Add a Hidden Default Button - Use Stylebits Addbits _BS_DEFPUSHBUTTON
    Stylebits #main.btn, _BS_DEFPUSHBUTTON, 0, 0, 0
    Button #main.btn, "", DefaultButton, UL, -10, -10
 
    Open "Main Window" for Window as #main
    #main "Trapclose EndDemo"
    #main "Font Verdana 10 Bold"
    #main.tbx "!Setfocus"
 
    Wait
 
    Sub EndDemo handle$
        Close #main
        End
    End Sub
 
    Sub DefaultButton handle$
        hTextbox = hWnd(#main.tbx)
        #main.tbx "!Contents? text$"
        text$ = text$;Chr$(13);Chr$(10)
        #main.tbx text$
        pos = Len(text$)
        CallDLL #user32, "SendMessageA", _
            hTextbox as Ulong, _
            _EM_SETSEL as Long, _
            pos as Long, _
            pos as Long, _
            result as Long
    End Sub

If you desire or need a truly editable textbox that mimics a text editor, use Alyce Watson's free API Text Editor available at Alyce's Restaurant.

Resizing a Dialog Window

The borders of a native dialog Window (default style = _WS_DLGFRAME) cannot be resized by the user. Neither can the dialog window be maximized or minimized.

    Nomainwin
    WindowWidth = 300
    WindowHeight = 350
    Open "Testing" for Dialog as #dlg
    #dlg "Trapclose CloseDlg"
 
    Wait
 
    Sub CloseDlg handle$
        Close #dlg
        End
    End Sub

In a regular window, you can use _WS_MAXIMIZEBOX or _WS_MINIMIZEBOX in RemoveBits to remove the Maximize and Minimize Controls. In a dialog window, place one or both of these stylebits in the AddBits. To allow border resizing, add the stylebit _WS_THICKFRAME

'Demo illustrating a Dialog Window with Resizable Edges

    Nomainwin
 
    WindowWidth = 800
    WindowHeight = 600
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
    Button #main.b1, "  Normal Dialog Window  ", DialogWin1, UL, 320, 250
    Button #main.b2, " Stylebits Dialog Window ", DialogWin2, UL, 320, 300
 
    Open "Main Window" for Window as #main
    #main "Trapclose EndDemo"
    Wait
 
    Sub EndDemo handle$
        Close #main
        End
        End Sub
 
    Sub DialogWin1 handle$
        WindowWidth = 400
        WindowHeight = 300
        Stylebits #dlg, 0, 0, 0, 0
        Button #dlg.default, " Close ", CloseDlg, UL, 180, 200
        Open "Dialog Window" for Dialog_Modal as #dlg
        #dlg "Trapclose CloseDlg"
        End Sub
 
    Sub DialogWin2 handle$
        WindowWidth = 400
        WindowHeight = 300
        Stylebits #dlg, _WS_THICKFRAME or _DS_CENTER or _WS_MAXIMIZEBOX or _WS_MINIMIZEBOX, 0, 0, 0
        Button #dlg.default, " Close ", CloseDlg, UL, 180, 200
        Open "Dialog Window" for Dialog_Modal as #dlg
        #dlg "Trapclose CloseDlg"
        End Sub
 
    Sub CloseDlg handle$
        Close #dlg
        End Sub

Don't expect to be able to issue a resizehandler control to this modified dialog window, though. The resizehandler command wasn't designed to work with a dialog window, not even a 'stylebitized' dialog window.

Positioning a Dialog Window

A dialog window can easily be centered using the Stylebit _DS_CENTER. See Tip Corner - Center a Dialog with Stylebits by Alyce Watson in the Liberty BASIC Newsletter Issue #128. This centering is in relationship to the screen (monitor) display. By default, dialog windows position themselves according to the client (calling window) area. In the following demo, move the main window (#main) around the screen prior to opening the dialog window. The dialog window will always position itself according to the position of the main window.

    Nomainwin
    WindowWidth = 600
    WindowHeight = 400
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
    Button #main.dlg, "Native Dialog", dlg, UL, 220, 200, 140, 30
 
    Open "Stylebits and Dialogs" for Window as #main
    Wait
 
    Sub CloseMain handle$
        Close #main
        End
    End Sub
 
    Sub CloseDlg handle$
        Close #handle$
    End Sub
 
    Sub dlg handle$
        WindowWidth = 300
        WindowHeight = 250
 
        UpperLeftX = 20 'UpperLeftX 20 pixels to right of #main upper left corner
        UpperLeftY = 20 'UpperLeftY 20 pixels down from #main upper left corner

        text$ = "UpperLeftX and UpperLeftY are, by default, based upon the client "
        text$ = text$;"coordinates of the calling window and not the screen coordinates."
        text$ = text$;Chr$(13);Chr$(13);"UpperLeftX = 20";Chr$(13);"UpperLeftY = 20"
        Statictext #dlg1, text$, 50, 50, 200, 200
        Open "Dialog - No Stylebits" for Dialog_Modal as #dlg
        #dlg "Trapclose CloseDlg"
    End Sub

If your program requires a dialog window to be placed according to screen coordinates, use the stylebit _DS_ABSALIGN.

    Nomainwin
    WindowWidth = 600
    WindowHeight = 400
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
    Button #main.dlg, "_DS_ABSALIGN", dlg, UL, 220, 200, 140, 30
 
    Open "Stylebits and Dialogs" for Window as #main
    Wait
 
    Sub CloseMain handle$
        Close #main
        End
    End Sub
 
    Sub CloseDlg handle$
        Close #handle$
    End Sub
 
    Sub dlg handle$
        WindowWidth = 300
        WindowHeight = 250
 
        UpperLeftX = 20 'UpperLeftX 20 pixels to right of upper left screen corner
        UpperLeftY = 20 'UpperLeftY 20 pixels down from upper left screen corner

        text$ = "_DS_ABSALIGN causes the UpperLeftX and UpperLeftY to be "
        text$ = text$;"determined not as client coordinates but as screen coordinates."
        text$ = text$;Chr$(13);Chr$(13);"UpperLeftX = 20";Chr$(13);"UpperLeftY = 20"
        Statictext #dlg, text$, 50, 50, 200, 200
        Stylebits #dlg, _DS_ABSALIGN, 0, 0, 0
        Open "Dialog - _DS_ABSALIGN" for Dialog_Modal as #dlg
        #dlg "Trapclose CloseDlg"
    End Sub

One other coordinate positioning trick can be accomplished with stylebits. Assigning the stylebit _DS_CENTERMOUSE will cause the dialog window to position itself so that the cursor lies in the center of the dialog window.

    Nomainwin
    WindowWidth = 600
    WindowHeight = 400
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
'All 4 Buttons Call Same Sub
    Button #main.dlg1, "Mouse Centered Dialog", dlg, UL, 20, 80, 140, 30
    Button #main.dlg2, "Mouse Centered Dialog", dlg, UL, 160, 120, 140, 30
    Button #main.dlg3, "Mouse Centered Dialog", dlg, UL, 300, 220, 140, 30
    Button #main.dlg4, "Mouse Centered Dialog", dlg, UL, 400, 300, 140, 30
 
    Open "Stylebits and Dialogs" for Window as #main
 
    #main "Trapclose CloseMain"
 
    Wait
 
    Sub CloseMain handle$
        Close #main
        End
    End Sub
 
    Sub CloseDlg handle$
        Close #handle$
    End Sub
 
    Sub dlg handle$
        WindowWidth = 300
        WindowHeight = 250
 
        UpperLeftX = 20 'UpperLeftX will be ignored
        UpperLeftY = 20 'UpperLeftY will be ignored

        Stylebits #dlg, _DS_CENTERMOUSE, 0, 0, 0
        Open "Dialog - _DS_CENTERMOUSE" for Dialog_Modal as #dlg
        #dlg "Trapclose CloseDlg"
    End Sub

A dialog window can also be positioned in the forefront of all other windows, even when that dialog window isn't the window with focus. The _DS_SYSMODAL stylebit acts the same as the _WS_EX_TOPMOST stylebit for regular windows.</p>

    Nomainwin
    WindowWidth = 600
    WindowHeight = 400
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
'All 4 Buttons Call Same Sub
    Button #main.dlg, "_DS_SYSMODAL", dlg, UL, 220, 200, 140, 30
 
    Open "Stylebits and Dialogs" for Window as #main
 
    #main "Trapclose CloseMain"
 
    Wait
 
    Sub CloseMain handle$
        Close #main
        End
    End Sub
 
    Sub CloseDlg handle$
        Close #handle$
    End Sub
 
    Sub dlg handle$
        WindowWidth = 300
        WindowHeight = 250
 
        UpperLeftX = 20
        UpperLeftY = 20
 
        Stylebits #dlg, _DS_SYSMODAL, 0, 0, 0
        Open "Dialog - _DS_SYSMODAL" for Dialog as #dlg
        #dlg "Trapclose CloseDlg"
    End Sub

A List of Stylebits

You can get a list of all dwStyles and dwExStyles available with the Stylebits command at the MSDN Library - Dialog Styles.
Be sure to precede these constants with an underscore (if constant is DS_CENTERMOUSE, then LB Stylebits is _DS_CENTERMOUSE) when using Windows constants in your Liberty BASIC programs.

Stylebits - Listboxes

JanetTerra — Fri, 27 Aug 2010 02:33:11 GMT

Reviewing the Stylebits Parameters

Listboxes and Colors

The native listbox is black text against a white background. To change the background color to match the default color of the user's scheme, include

ListboxColor$ = "Buttonface"

prior to defining that listbox. Change the ListboxColor$ to white (or any other valid color) for subsequent listboxes if desired. To change the color of the text, use ForegroundColor$ before opening the window. Only one color may be assigned to all controls with ForegroundColor$.

Stylebits, Listboxes and Borders

The default border is single edged. Techniques to change the border of a listbox are similar to changing the border of a window, textbox or any other control.

Borderless

ListboxColor$ = "Buttonface"
Stylebits #style.lb1, 0, _WS_BORDER, 0, _WS_EX_CLIENTEDGE

Sunken Border

Stylebits #style.lb2, 0, 0, _WS_EX_CLIENTEDGE or _WS_EX_STATICEDGE, 0

Raised Border

Stylebits #style.lb2, 0, 0, _WS_EX_DLGMODALFRAME, 0

Resizable Border

Stylebits #style.lb2, _WS_THICKFRAME, 0, 0, 0

Stylebits, Listboxes and Scrollbars

The default scrollbar lies on the right side of the listbox. When the listbox is tall enough to contain all the items, this scrollbar shows in the disabled state. Using the stylebits _WS_HSCROLL, _WS_VSCROLL, _WS_EX_LEFTSCROLLBAR, and _WS_EX_RIGHTSCROLLBAR, you can hide and even reposition the scroll bar.

Add Horizontal Scrollbar and Remove Vertical Scrollbar

Stylebits #style.lb1, _WS_HSCROLL, _WS_VSCROLL, 0, 0

Add Horizontal Position Scrollbar on Left

Stylebits #style.lb2, 0, 0, _WS_EX_LEFTSCROLLBAR, 0

Remove Default Disabled Listbar

Stylebits #style.lb3, 0, _LBS_DISABLENOSCROLL, 0, 0

Stylebits, Listboxes and Columns

The native listbox displays a single, scrolling column. The stylebits _LB_MULTICOLUMN allows the listbox to display more than one column. The number of columns is NOT determined by assigning a value. Rather, the number of columns is determined by the height of the listbox. Only vertically visible items are assigned to each column. By carefully controlling the height of the listbox, thus controlling the number of vertically visible listed items, the programmer can control the number of columns. The width of the column has no effect upon the number of columns. If not all columns will be visible, assign the stylebits _WS_HSCROLL as well.

Multicolumn Listbox with a Horizontal Scrollbar

Stylebits #style.lb3, _LBS_MULTICOLUMN or _WS_HSCROLL, 0,0, 0

Stylebits, Listboxes and Selection

A selection in the native listbox is chosen by double left - clicking. This highlights that item. Only one selection can in the selected state. That selection is retrieved using either the selection? or the selectionindex? command. Stylebits allow more than one item to be in the selected state at any given time.

Multiple Single Selections - String selection is toggled each time the user clicks or double-clicks the string. Any number of strings can be selected.

#style.lb2, _LBS_MULTIPLESEL, 0, 0, 0

Extended Selection - The user can select multiple items using the SHIFT key and the mouse or special key combinations. Ctrl - Mouse Click selects multiple single items. Shift - Mouse Click selects a range of items.

Stylebits #style.lb3, _LBS_EXTENDEDSEL, 0, 0, 0

No Selection - Specifies that the list box contains items that can be viewed but not selected.

Stylebits #style.lb1, _LBS_NOSEL, 0, 0, 0

Stylebits and API Calls

Stylebits do allow multiple and extended selections in listboxes, but an API call (SendMessageA) is required to retrieve those selections. _LB_SETSEL is used to select one, multiple, or all items. By changing the state parameter, _LB_SETSEL is also used to clear one, multiple, or all items. The number of selected items is obtained with _LB_GETSELCOUNT. Because the Listbox sees the items beginning with 0, it may be necessary to decrement the item number by 1.

'Setting Multiple Selections and Getting Multiple Selections
'with SendMessageA API calls
'A special Thank You to Bill Beasley for getting this code started

    Dim itemArray$(20)
    For i = 1 to 20
        itemArray$(i) = "Item Number ";Space$(i < 10);Str$(i)
    Next i
    nullParameter = 0 'Used as filler when parameter irrelevant

    Nomainwin
    WindowWidth = 400
    WindowHeight = 360
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
    Listbox #main.lb, itemArray$(), [selectItem], 20, 20, 140, 200
    '_LBS_MULTIPLESEL = Multiple Single Selections using Left Click
    Stylebits #main.lb, _LBS_MULTIPLESEL, 0, 0, 0
    '_LBS_EXTENDEDSEL = Multiple Single Selections using Ctrl - Left Click as well as
    'selection of a range of items using Shift - Left Click
    'Stylebits #main.lb, _LBS_EXTENDEDSEL, 0, 0, 0
    Statictext #main.st, "", 20, 230, 350, 100
    Button #main.b1, "Count Items Selected", [nItemsSelected], UL, 190, 40, 170, 32
    Button #main.b2, "List Items Selected", [listItemsSelected], UL, 190, 85, 170, 32
    Button #main.b3, "Select All Items", [selectAllItems], UL, 190, 130, 170, 32
    Button #main.b4, "Clear All Items", [clearAllItems], UL, 190, 175, 170, 32
 
    Open "Listbox Multi Select" for Window as #main
    #main "Trapclose [endDemo]"
    #main "Font Times_New_Roman 12 Bold"
    hLB = hwnd(#main.lb)
 
'Select some items
    For i = 1 to 20 step 3
        null = SendMessageA(hLB, _LB_SETSEL, 1, i)
    Next i
    #main.st "Every 3rd Item is Selected"
 
    Wait
 
[selectItem]
'No action necessary
    Wait
 
[nItemsSelected]
    nItemsSelected = SendMessageA(hLB, _LB_GETSELCOUNT, nullParameter, nullParameter) 'no relevance (par1), (par2)
    #main.st "There are ";nItemsSelected;" items selected."
    Wait
 
[listItemsSelected]
    itemsSel$ = ""
    For i = 1 to 20
        isSel = SendMessageA(hLB, _LB_GETSEL, i - 1, nullParameter) 'i - 1 = Item Number (par1), no relevance (par2)
        If isSel Then
            itemsSel$ = itemsSel$;itemArray$(i);", "
        End If
    Next i
    itemsSel$ = Left$(itemsSel$, Len(itemsSel$) - 2)
    #main.st itemsSel$
    Wait
 
[selectAllItems]
    allSel = SendMessageA(hLB, _LB_SETSEL, 1, -1) ' 1 (par1) = Flag to Set, -1 (par2) = ALL
    Wait
 
[clearAllItems]
    allClear = SendMessageA(hLB, _LB_SETSEL, 0, -1) '0 (par1) = Flag to Clear, -1 (par2) = ALL
    Wait
 
[endDemo]
    Close #main
    End
 
Function SendMessageA(hW, msg, par1, par2)
    CallDLL #user32, "SendMessageA",_
        hW as Ulong, _ 'Handle of the control (listbox)
        msg as Long, _ 'Stylebits (Windows Constant)
        par1 as Long, _ 'Parameter 1 (sometimes irrelevant)
        par2 as Long, _ 'Parameter 2 (sometimes irrelevant)
        SendMessageA as long 'Return Value, 1 = success
End Function

These are just some examples of what you can do with stylebits and listboxes. With experimentation, you may find more.

A List of Stylebits

You can get a list of all dwStyles and dwExStyles available with the Stylebits command at the MSDN Library - List Box Styles.

Stylebits - Statictext

JanetTerra — Fri, 27 Aug 2010 02:33:51 GMT

Reviewing the Stylebits Parameters

Stylebits and Formatted Text

Many of the stylebits commands used with windows and textboxes can also be used with statictext controls. Since statictext doesn't accept user input, most of the stylebits effects involve text formatting and borders. Statictext can be justified horizontally using these commands -

_SS_LEFT
_SS_CENTER
_SS_RIGHT

Statictext can also be centered vertically using the command -

_SS_CENTERIMAGE

It is possible to create a nice etched look in your text using the command -

_WS_DISABLED

Use this strategy with caution, though. Any control disabled with the stylebits will require an API call to cause the statictext to later become enabled. The same look can be achieved using the native Liberty BASIC command !Disable and affords the programmer the opportunity to normalize the text look using !Enable later in the code.

There are some very interesting visual effects that can be achieved using a stylebits created border around your statictext.

Stylebits
_WS_DLGFRAME, 0, 0, 0	.....	Raised Background
0, 0, _WS_EX_STATICEDGE, 0	.....	Slightly Recessed Background
0, 0, _WS_EX_CLIENTEDGE, 0	.....	Deeper Recessed Background
0, 0, _WS_EX_STATICEDGE or _WS_EX_CLIENTEDGE, 0	.....	Double Recessed Background
_WS_BORDER, 0, 0, 0	.....	Thin Line Border
0, 0, _WS_EX_DLGMODALFRAME or _WS_EX_CLIENTEDGE, 0	.....	Raised Frame
_WS_THICKFRAME, 0, _WS_EX_DLGMODALFRAME or _WS_EX_CLIENTEDGE, 0	.....	Double Raised Frame

Stylebits and API Calls

Stylebits allow statictext to display images, but only when accompanied by an API call to user32.dll (SendMessageA). The height and width of the statictext will initially cause a smaller bitmap to stretch and fill the originally defined statictext dimensions. You can prevent this distortion by either making certain the statictext width and height is the same as the loaded bitmap or using the _SS_CENTERIMAGE stylebits. Recessed, raised and flat effects can be achieved using window edge stylebits.
Right - Click and save this bitmap as "boy.bmp" on your computer. Run the demo from the same folder in which you saved the bitmap. Once the code is run, maximizing the window will demonstrate how the bitmap stretches to fill the defined statictext area.

    WindowWidth=600
    WindowHeight=450
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2) - 14
 
    Nomainwin
 
    Loadbmp "boy", "boy.bmp"
 
    Statictext #main.st0, "", 10, 10, 54, 100
    Stylebits #main.st0, _SS_BITMAP, 0, 0, 0
    Statictext #main, "The bitmap boy.bmp 54 x 100.", 90, 30, 150, 56
 
    Statictext #main.st1, "", 10, 140, 80, 120
    Stylebits #main.st1, _SS_BITMAP or _WS_BORDER, 0, 0, 0
    Statictext #main, "Thin Line Border, Bitmap expands to fit defined statictext area (80 x 120) when window resized.", _
        100, 120, 150, 140
 
    Statictext #main.st2, "", 10, 300, 80, 120
    Stylebits #main.st2, _SS_BITMAP or _WS_BORDER, 0, _WS_EX_STATICEDGE, 0
    Statictext #main, "Etched look with _WS_BORDER and _WS_EX_STATEDGE, also resizes when window resized.", _
        100, 280, 150, 140
 
    Statictext #main.st3, "", 480, 70, 100, 150
    Stylebits #main.st3, _SS_BITMAP or _SS_CENTERIMAGE, 0, _WS_EX_CLIENTEDGE, 0
    Statictext #main, "_SS_ CENTERIMAGE prevents resizing when window resized.", 320, 90, 150, 140
 
    Statictext #main.st4, "", 480, 250, 100, 150
    Stylebits #main.st4, _SS_BITMAP or _SS_CENTERIMAGE, 0, _WS_EX_DLGMODALFRAME, 0
    Statictext #main, "Borders can be raised, recessed or flat.", 320, 280, 150, 140
 
    Open "Stylebits for Images on Statictext" for Window as #main
    #main "Trapclose [closeDemo]"
    #main "Font Times_New_Roman 14 Bold"
    hStatic0 = hWnd(#main.st0)
    hStatic1 = hWnd(#main.st1)
    hStatic2 = hWnd(#main.st2)
    hStatic3 = hWnd(#main.st3)
    hStatic4 = hWnd(#main.st4)
    hImage = hBmp("boy")
    Call setImage hStatic0, hImage
    Call setImage hStatic1, hImage
    Call setImage hStatic2, hImage
    Call setImage hStatic3, hImage
    Call setImage hStatic4, hImage
    Wait
 
    Sub setImage hStatic, hImage
    CallDLL #user32, "SendMessageA", _
        hStatic as Ulong, _
        _STM_SETIMAGE as Long, _
        _IMAGE_BITMAP as Long, _
        hImage as Ulong, _
        result as Long
    End Sub
 
[closeDemo]
    Close #main
    Unloadbmp "boy"
    End

These are just some examples of what you can do with stylebits and statictext. With experimentation, you may find more.

A List of Stylebits

You can get a list of all dwStyles and dwExStyles available with the Stylebits command at the MSDN Library - Static Styles.

Stylebits - Textboxes

StPendl — Sun, 07 Dec 2008 12:12:31 GMT

Reviewing the Stylebits Parameters

Line Wrapping

How can I get text to wrap in a textbox? This question is frequently asked on the Liberty BASIC Forum. Line wrapping is easily achieved with a few stylebits.

    Nomainwin
    WindowWidth=200
    WindowHeight=160
 
    text1$ = "STYLEBITS allows you to change the style of a Liberty BASIC window or control."
    text2$ = "Add to or edit this text."
 
    Textbox #Main.txtbx, 0, 0, 190, 68
    Stylebits #Main.txtbx, _WS_VSCROLL OR _ES_MULTILINE, _ES_AUTOHSCROLL, 0, 0
    Statictext #Main, text2$, 5, 80, 190, 30
 
    Open "LineWrap for LB" for Window_nf as #Main
    Print #Main, "Trapclose EndDemo"
    Print #Main, "Font Times_New_Roman 12 Bold"
    Print #Main.txtbx, text1$
    Wait
 
Sub EndDemo handle$
    Close #Main
    End
End Sub

Go ahead and type in your own text. The text will wrap automatically as you type. It is possible to begin a new line in this word wrapping textbox, but you must use CTRL-ENTER rather than just ENTER. If you don't like scroll bars, then use a resizable textbox. Substitute the above stylebits command with

Stylebits #main.txtbx, _WS_THICKFRAME OR_ES_MULTILINE, _ES_AUTOHSCROLL, 0, 0

and let the user tug and pull the textbox all over the window. Be careful with this one. If your user shrinks the textbox and drags it behind another control, the textbox may become irretrievable. If you choose this effect, you may want to add some resize handling using the Locate and Refresh commands.

Limiting Text Entry

You can limit text length by omitting the vertical scroll bar. Without the ability to scroll, the textbox will only accept what can be visually seen. By carefully controlling the font size and the height of the textbox, user input can be contained.

    WindowWidth=200
    WindowHeight=160
    Nomainwin
 
    text1$ = "Doc and Sleepy and Grumpy and Sneezy and"
    text2$ = "Can you name the other 3?"
 
    Textbox #main.txtbx, 0, 0, 190, 68
    Stylebits #main.txtbx, _ES_MULTILINE, _ES_AUTOHSCROLL OR _ES_AUTOVSCROLL, 0, 0
    Statictext #main, text2$, 5, 80, 190, 30
 
    Open "LineWrap for LB" for Window_nf as #main
    Print #main, "Trapclose EndDemo"
    Print #main, "Font Times_New_Roman 12 Bold"
    Print #main.txtbx, text1$
 
    Wait
 
Sub EndDemo handle$
    Close #main
    End
End Sub

By removing the multiline stylebit you can control the length of a single line of text input.

Stylebits #main.txtbx, 0, _ES_AUTOHSCROLL OR _ES_AUTOVSCROLL, 0, 0

The textbox is nice, but I really need a text editor. What stylebits will add word wrapping to the text editor? Unfortunately, the text editor is a widget and widgets do not respond well to stylebits. If your program requires a word wrapping text editor, consider downloading Alyce Watson's Text Editor by API. This API modified textbox works just like a real text editor, it's compatible with Liberty BASIC v3.x as well as v4.x, and, best of all, like so many of Alyce's Liberty BASIC contributions, it's free.

Scrolling vs Wrapping

It isn't always desirable to wrap text. If you anticipate text will extend beyond the limits of your textbox but you still want to keep the text on one line, consider adding a horizontal scroll bar.

Stylebits #main.txtbx, _WS_HSCROLL, 0, 0, 0

Textbox Borders

Textbox borders respond to window style (_WS_) stylebits, but may require unique combinations. While

Stylebits #main.gb, 0, _WS_BORDER, 0, 0

will remove the border of a graphic box, the same effect with a textbox can only be achieved with the removal of an extended style:

Stylebits #main.txtbx, 0, _WS_BORDER, 0, _WS_EX_CLIENTEDGE

Thanks to

Mike Bradbury (See Reply #3) for posting this solution for removing the textbox border.

How about adding a horizontal scroll bar and removing the border? Here's a different look.

Stylebits #main.txtbx, _WS_HSCROLL, _WS_BORDER, 0, _WS_EX_CLIENTEDGE

Rather than removing a border, stylebits might be used to draw a more defined border, giving a distinct 3 - D effect. _WS_EX_DLGMODALFRAME draws a raised border

Stylebits #main.txtbx, 0, 0, _WS_EX_DLGMODALFRAME, 0

while _WS_EX_STATICEDGE draws a "step into" sunken border

Stylebits #main.txtbx, 0, 0, _WS_EX_STATICEDGE, 0

Restricting User Input

Edit style (_ES_) stylebits can be used to restrict or modify user input.

Some examples include

Numbers Only (Unfortunately, commas and periods are not accepted. Forget about using this style if decimals are involved.)

Stylebits #main.txtbx, _ES_NUMBER, 0, 0, 0

Password (The asterisk is the default. This character can be changed by using the SetPasswordChar function. Note that _ES_MULTILINE must be included as a RemoveBit parameter.)

Stylebits #main.txtbx, _ES_PASSWORD, _ES_MULTILINE, 0, 0

Uppercase / Lowercase (Converts all user input to uppercase / lowercase.)

Stylebits #main.txtbx, _ES_UPPERCASE, 0, 0, 0
Stylebits #main.txtbx, _ES_LOWERCASE, 0, 0, 0

Left / Center / Right Justify (Can be used in either single line textboxes or multiline textboxes.)

Stylebits #main.txtbx, _ES_LEFT, 0, 0, 0
Stylebits #main.txtbx, _ES_CENTER, _ES_MULTILINE, 0, 0
Stylebits #main.txtbx, _ES_RIGHT, 0, 0, 0

Read Only (Will not accept user input. Issuing a Disable command later in the program will 'gray out' any text in the textbox, but Enable will not reverse the _ES_READONLY style.)

Stylebits #main.txtbx, _ES_READONLY, 0, 0, 0

Demo: Borders, Line Wrapping and Textbox Entry

    ' There is no error catching here to prevent a
    ' crash if more than one demo window is
    ' opened at a time.  Please be sure to close
    ' the demo window before opening a new one.

    WindowWidth=400
    WindowHeight=400
 
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2) - 14
 
    Nomainwin
    text$ = "No stylebits have been added to this textbox."
 
    Textbox #main.txtbx1, 22, 40, 300, 32
 
    Statictext #main, "_Border Styles_", 38, 100, 130, 20
    Button #main.style1, "Add H Scroll Bar", [style1], UL, 30, 130, 130, 32
    Button #main.style2, "Borderless", [style2], UL, 30, 170, 130, 32
    Button #main.style3, "Blend in Window", [style3], UL, 30, 210, 130, 32
    Button #main.style4, "Raised Border", [style4], UL, 30, 250, 130, 32
    Button #main.style5, "SunkenBorder", [style5], UL, 30, 290, 130, 32
    Button #main.style6, "Resizable Border", [style6], UL, 30, 330, 130, 32
 
    Statictext #main, "_Text Entry_", 218, 100, 130, 20
    Button #main.entry1, "Line Wrap 1", [entry1], UL, 200, 130, 130, 32
    Button #main.entry2, "Line Wrap 2", [entry2], UL, 200, 170, 130, 32
    Button #main.entry3, "Numbers Only", [entry3], UL, 200, 210, 130, 32
    Button #main.entry4, "Read Only", [entry4], UL, 200, 250, 130, 32
    Button #main.entry5, "Upper Case", [entry5], UL, 200, 290, 130, 32
    Button #main.entry6, "Stay Selected", [entry6], UL, 200, 330, 130, 32
 
    Open "Stylebits Demo" for Window_nf as #main
 
    #main, "Trapclose [endDemo]"
    #main, "Font Times_New_Roman 12 Bold"
    #main.txtbx1, text$
    Wait
 
[endDemo]
    Close #main
    End
 
[style1] 'Horizontal Scroll
    textBx$ = "Stylebits #w.tb, _WS_HSCROLL, 0, 0, 0"
 
    Stylebits #w.tb, _WS_HSCROLL, 0, 0, 0
    Textbox #w.tb, 22, 40, 200, 48
    staticTxt$ = "Stylebits #w.tb, _WS_HSCROLL, 0, 0, 0" + _
        Chr$(13);Chr$(13);"This textbox has no line wrapping, but user can scroll to end." + _
        "  Be sure to allow extra height to accomodate the Horizontal Scroll Bar."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Horizontal Scroll" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb, textBx$
    Wait
 
[style2] 'Borderless
    textBx$ = "Stylebits #w.tb, 0, _WS_BORDER, 0, _WS_EX_CLIENTEDGE"
 
    Stylebits #w.tb, 0, _WS_BORDER, 0, _WS_EX_CLIENTEDGE
    Textbox #w.tb, 22, 40, 300, 32
    staticTxt$ = "0, _WS_BORDER, 0, _WS_EX_CLIENTEDGE" + _
        Chr$(13);Chr$(13);"Both _WS_BORDER and _WS_EX_CLIENTEDGE bits " + _
        "must be removed."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Borderless" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb, textBx$
    Wait
 
[style3] 'Blend in Window
    TextboxColor$ = "Buttonface"
    textBx$ = "Stylebits #w.tb, _WS_HSCROLL, _WS_BORDER, 0, _WS_EX_CLIENTEDGE"
 
    Stylebits #w.tb, _WS_HSCROLL, _WS_BORDER, 0, _WS_EX_CLIENTEDGE
    Textbox #w.tb, 22, 40, 300, 48
    staticTxt$ = "_WS_HSCROLL, _WS_BORDER, 0, _WS_EX_CLIENTEDGE" + _
        Chr$(13);Chr$(13);"By changing the TextboxColor$ to Buttonface, and removing " + _
        "the borders, the textbox appears to blend into the window.  Add the Horizontal " + _
        "Scroll Bar with the _WS_HSCROLL stylebit."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Blend in Window" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb, textBx$
    TextboxColor$ = "White" 'Reset to white for next display
    Wait
 
[style4] 'Raised Border
    textBx$ = "Stylebits #w, 0, 0, _WS_EX_DLGMODALFRAME, 0"
 
    Stylebits #w.tb, 0, 0, _WS_EX_DLGMODALFRAME, 0
    Textbox #w.tb, 22, 40, 300, 32
    staticTxt$ = "0, 0, _WS_EX_DLGMODALFRAME, 0" + _
        Chr$(13);Chr$(13);"The textbox has a raised double border.  This " + _
        "raised double border cannot be resized by the user."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Raised Border" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb, textBx$
    Wait
 
[style5] 'Sunken Border
    textBx$ = "Stylebits #w, 0, 0, _WS_EX_STATICEDGE, 0"
 
    Stylebits #w.tb, 0, 0, _WS_EX_STATICEDGE, 0
    Textbox #w.tb, 22, 40, 300, 32
    staticTxt$ = "0, 0, _WS_EX_STATICEDGE, 0" + _
        Chr$(13);Chr$(13);"The textbox has a sunken double border.  This " + _
        "gives a crisp 3 - D appearance of increased depth."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Sunken Border" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb, textBx$
    Wait
 
[style6] 'Resizable Border
    textBx$ = "Stylebits #w, _WS_THICKFRAME, 0, 0, 0"
 
    Stylebits #w.tb, _WS_THICKFRAME, 0, 0, 0
    Textbox #w.tb, 22, 40, 300, 32
    staticTxt$ = "_WS_THICKFRAME, 0, 0, 0" + _
        Chr$(13);Chr$(13);"The textbox has a raised double border.  This " + _
        "raised double border can be resized by the user.  The native LB " + _
        "commands LOCATE and REFRESH can be used to resize after " + _
        "the window is opened."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Raised Border" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb, textBx$
    Wait
 
[entry1] 'Line Wrap w/ Vertical Scroll Bar
    textBx$ = "Stylebits #w.tb, _WS_VSCROLL OR _ES_MULTINE, _ES_AUTOHSCROLL, 0, 0"
    Stylebits #w.tb, _WS_VSCROLL OR_ES_MULTILINE, _ES_AUTOHSCROLL, 0, 0
    Textbox #w.tb, 22, 40, 300, 50
    staticTxt$ = "_WS_VSCROLL OR _ES_MULTINE, _ES_AUTOHSCROLL, 0, 0" + _
        Chr$(13);Chr$(13);"To cause a carriage return, you must press CTRL-RETURN.  Try it."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Line Wrap w/ Vertical Scroll Bar" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb, textBx$
    Wait
 
[entry2] 'Line Wrap w/ Resizable Frame
    textBx$ = "Stylebits #w.tb, _THICKFRAME OR _ES_MULTINE, _ES_AUTOHSCROLL, 0, 0"
    Stylebits #w.tb, _WS_THICKFRAME OR_ES_MULTILINE, _ES_AUTOHSCROLL, 0, 0
    Textbox #w.tb, 22, 40, 280, 50
    staticTxt$ = "_WS_THICKFRAME OR _ES_MULTINE, _ES_AUTOHSCROLL, 0, 0" + _
        Chr$(13);Chr$(13);"This textbox can be resized to show as little or as much text as " + _
        "desired.  To cause a carriage return, you must press CTRL-RETURN.  Try it."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Line Wrap w/ Resizable Frame" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb, textBx$
    Wait
 
[entry3] 'Numbers Only
    textBx$ = "Stylebits #w, _ES_NUMBER, 0, 0, 0"
 
    Stylebits #w.tb, _ES_NUMBER, 0, 0, 0
    Textbox #w.tb, 22, 40, 300, 32
    staticTxt$ = "_ES_NUMBER, 0, 0, 0" + _
        Chr$(13);Chr$(13);"Although any characters may be printed to this textbox " + _
        "within the program, the textbox will only accept numerical user input. " + _
        Chr$(13);"Delete what's in the textbox and try to enter numerical and " + _
        "non - numerical characters."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Numbers Only" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb, textBx$
    Wait
 
[entry4] 'Read Only
    textBx$ = "Stylebits #w, _ES_READONLY, 0, 0, 0"
 
    Stylebits #w.tb, _ES_READONLY, 0, 0, 0
    Textbox #w.tb, 22, 40, 300, 32
    staticTxt$ = "_ES_READONLY, 0, 0, 0" + _
        Chr$(13);Chr$(13);"Although any characters may be printed to this textbox " + _
        "within the program, the textbox will not accept user input.  Unlike the native " + _
        "Liberty BASIC DISABLE command, the textbox does not become 'grayed  " + _
        "out.  Try to change the text."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Read Only" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb, textBx$
    Wait
 
 
[entry5] 'Uppercase
    textBx$ = "Stylebits #w, _ES_UPPERCASE, 0, 0, 0"
 
    Stylebits #w.tb, _ES_UPPERCASE, 0, 0, 0
    Textbox #w.tb, 22, 40, 300, 32
    staticTxt$ = "_ES_UPPERCASE, 0, 0, 0" + _
        Chr$(13);Chr$(13);"Any character typed by the user will be printed in the " + _
        "uppercase form.";Chr$(13);Chr$(13);"_ES_LOWERCASE works in the same way."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Uppercase" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb, textBx$
    Wait
 
[entry6] 'Stay Selected
    textBx$ = "Stylebits #w, _ES_NOHIDESEL 0, 0, 0"
 
    Stylebits #w.tb1, _ES_NOHIDESEL, 0, 0, 0
    Textbox #w.tb1, 22, 40, 300, 32
    Textbox #w.tb2, 22, 80, 300, 32
    staticTxt$ = "_ES_NOHIDESEL, 0, 0, 0" + _
        Chr$(13);Chr$(13);"The highlighted text in the upper text box remains " + _
        "selected even when focus shifts to another control.";Chr$(13);Chr$(13) + _
        "The user can override the selection unless the _ES_READONLY " + _
        "stylebit is also applied."
    Statictext #w, staticTxt$, 30, 140, 300, 154
 
    Open "Stylebits: Stay Selected" for Window as #w
    #w, "Font Times_New_Roman 12 Bold"
    #w, "Trapclose [closeDemoWin]"
    #w.tb1, textBx$
    #w.tb1, "!Selectall"
    Wait
 
[closeDemoWin]
    Close #w
    Wait

Other Stylebits with Textboxes

The best way to see how textboxes can be altered with Stylebits is to experiment. You may well find that other combinations will create additional display and editing styles.

A List of Stylebits

You can get a list of all dwStyles and dwExStyles available with the Stylebits command at the MSDN Library - Edit Styles.

Stylebits - Toggle Buttons

JanetTerra — Fri, 27 Aug 2010 02:17:04 GMT

The PUSHLIKE Stylebits

Stylebits allows checkboxes and radiobuttons to appear to be pushed rather than selected. Stefan Pendl, always generous with explanations and code, offered button information in response to a query posed at the Liberty BASIC yahoo! message group. (See the original message #27196.)

For a better understanding, the following controls are all defined as buttons by Windows:

button
groupbox
bmpbutton
checkbox
radiobutton

You can use the style _BS_PUSHLIKE to change the radiobutton and checkbox into a pushbutton, that will keep its state.

These buttons are called toggle buttons, they are raised when inactive and sunken when active. To find out more about toggle buttons, read the information at the MSDN Library.

Stefan's Demo

Stefan was kind enough to grant permission for his yahoo! code to be republished here. Using the _BS_PUSHLIKE stylebits, a checkbox and two grouped radiobuttons are altered from their usual forms to button forms. The change in style does not alter the set and unset properties.

    nomainwin
 
    groupbox #main.gb, "Toggle Radiobuttons", 10, 10, 120, 100
    stylebits #main.bt, _BS_PUSHLIKE, 0, 0, 0
    radiobutton #main.bt, "Toggle", [pushed], [pushed], 20, 30, 100, 30
    stylebits #main.bt1, _BS_PUSHLIKE, 0, 0, 0
    radiobutton #main.bt1, "Toggle1", [pushed], [pushed], 20, 70, 100, 30
 
    stylebits #main.bt2, _BS_PUSHLIKE, 0, 0, 0
    checkbox #main.bt2, "Toggle Checkbox", [pushed], [pushed], 20, 120, 100, 30
 
    open "Toggle demo" for window as #main
    #main "trapclose [quit]"
    wait
 
[pushed]
    wait
 
[quit]
    close #main
    end

Stylebits, Graphics and the API call, "SendMessageA"

Creating graphic buttons using _BS_BITMAP and CallDLL #user32, "SendMessageA" has been discussed by Alyce Watson in API Corner - Easy BMP Buttons (LB Newsletter #123) and also in Stylebits - Buttons. In these next two demos, the graphics are drawn and captured within the program. You could easily substitute your own code for loading the bitmaps from file.

'Demonstration of using Stylebits to turn checkboxes into
'push buttons
'Based on code provided by Stefan Pendl
'Yahoo! Message ##27196

    Nomainwin
 
    WindowWidth = 207
    WindowHeight = 297
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
'Groupbox defines Checkbox Area
    Groupbox #main.gp, "Color", 10, 10, 120, 100
 
'Draw checkboxes that will look like push buttons
'Stylebits _BS_PUSHLIKE causes checkbox to resemble push button
'Stylebits _BS_BITMAP allows a bitmap to be drawn on button
'Be sure to set width and height to bitmap dimensions
    Stylebits #main.bt1, _BS_PUSHLIKE or _BS_BITMAP, 0, _WS_EX_DLGMODALFRAME, 0
    Checkbox #main.bt1, "", checked, unchecked, 20, 30, 40, 30
    Stylebits #main.bt2, _BS_PUSHLIKE or _BS_BITMAP, 0, _WS_EX_DLGMODALFRAME, 0
    Checkbox #main.bt2, "", checked, unchecked, 20, 70, 40, 30
    Stylebits #main.bt3, _BS_PUSHLIKE or _BS_BITMAP, 0, _WS_EX_DLGMODALFRAME, 0
    Checkbox #main.bt3, "", checked, unchecked, 80, 30, 40, 30
    Stylebits #main.bt4, _BS_PUSHLIKE or _BS_BITMAP, 0, _WS_EX_DLGMODALFRAME, 0
    Checkbox #main.bt4, "", checked, unchecked, 80, 70, 40, 30
 
'For this demo, a graphicbox is needed to draw and capture bitmaps
    Graphicbox #main.gb, 0, 150, 200, 120
    Open "Stylebits and Checkboxes" for Window as #main
    #main "Trapclose endDemo"
 
'Obtain handle of the main window
    hMain = hWnd(#main)
'Obtain handles of the 4 checkboxes
    hButton1 = hWnd(#main.bt1)
    hButton2 = hWnd(#main.bt2)
    hButton3 = hWnd(#main.bt3)
    hButton4 = hWnd(#main.bt4)
 
'===============================================
'To load bitmaps from disk, use
    'Loadbmp "buttonPic1", "buttonPic1.bmp"
    'Loadbmp "buttonPic2", "buttonPic2.bmp"
    'etc.
'===============================================
'For this demo, the bitmaps will be drawn and captured
    #main.gb "Down; Fill Black; Size 2"
    #main.gb "Color Lightgray; Backcolor DarkRed"
    #main.gb "Place 2 2; Boxfilled 38 28"
    #main.gb "Getbmp buttonPic1 0 0 40 30"
    #main.gb "Backcolor Darkblue"
    #main.gb "Place 2 2; Boxfilled 38 28"
    #main.gb "Getbmp buttonPic2 0 0 40 30"
    #main.gb "Backcolor Yellow"
    #main.gb "Place 2 2; Boxfilled 38 28"
    #main.gb "Getbmp buttonPic3 0 0 40 30"
    #main.gb "Backcolor Darkgreen"
    #main.gb "Place 2 2; Boxfilled 38 28"
    #main.gb "Getbmp buttonPic4 0 0 40 30"
'===============================================

'Get the handle of the bitmaps
    hPic1 = hBmp("buttonPic1")
    hPic2 = hBmp("buttonPic2")
    hPic3 = hBmp("buttonPic3")
    hPic4 = hBmp("buttonPic4")
 
'Paint the bitmaps on the buttons
    For i = 1 to 4
        Select Case i
            Case 1
                hBtn = hButton1
                hPic = hPic1
            Case 2
                hBtn = hButton2
                hPic = hPic2
            Case 3
                hBtn = hButton3
                hPic = hPic3
            Case 4
                hBtn = hButton4
                hPic = hPic4
        End Select
        CallDll #user32, "SendMessageA", _
            hBtn as uLong, _
            _BM_SETIMAGE as Long, _
            _IMAGE_BITMAP as Long, _
            hPic as uLong, _
            result as Long
    Next i
 
'Erase button drawings in graphicbox
    #main.gb "Cls; Fill Black"
 
'Wait for user input
    Wait
 
'Find which checkbox checked
'Fill quadrant with designated color
    Sub checked handle$
        clr = Val(Right$(handle$, 1))
        Select Case clr
            Case 1
                #main.gb "Color Darkred; Backcolor Darkred"
                x = 1
                y = 1
            Case 2
                #main.gb "Color Darkblue; Backcolor Darkblue"
                x = 1
                y = 61
            Case 3
                #main.gb "Color Yellow; Backcolor Yellow"
                x = 101
                y = 1
            Case 4
                #main.gb "Color Darkgreen; Backcolor Darkgreen"
                x = 101
                y = 61
        End Select
        #main.gb "Place ";x;" ";y
        #main.gb "Boxfilled ";x + 99;" ";y + 59
        End Sub
 
'Find which checkbox unchecked
'Fill appropriate quadrant with black
    Sub unchecked handle$
        clr = Val(Right$(handle$, 1))
        #main.gb "Color Black; Backcolor Black"
        Select Case clr
            Case 1
                x = 1
                y = 1
            Case 2
                x = 1
                y = 61
            Case 3
                x = 101
                y = 1
            Case 4
                x = 101
                y = 61
        End Select
        #main.gb "Place ";x;" ";y
        #main.gb "Boxfilled ";x + 99;" ";y + 59
        End Sub
 
'End the program
    Sub endDemo handle$
'Unload bitmaps to free memory
        For i = 1 to 4
            Unloadbmp "buttonPic";i
        Next i
        Close #main
        End
        End Sub

Button Event Handlers: Branch Label or Sub?

As is the case with most event handlers, the button event handler can be either a branch label or a sub. The advantage of using a sub with grouped checkboxes or radiobuttons is that the control handle is automatically passed into the sub. With careful parsing of the control handle extension and the use of Select Case, code becomes much more efficient than is possible with branch labels. The following demo contains just four radiobuttons within a group, but could easily serve a group of 100 radiobuttons or more.

'Demonstration of using Stylebits to turn radiobuttons into
'push buttons
'Based on code provided by Stefan Pendl
'Yahoo! Message ##27196

    Nomainwin
 
    WindowWidth = 207
    WindowHeight = 297
    UpperLeftX = Int((DisplayWidth - WindowWidth)/2)
    UpperLeftY = Int((DisplayHeight - WindowHeight)/2)
 
'Groupbox defines Radiobuttons Area
    Groupbox #main.gp, "Color", 10, 10, 120, 100
 
'Draw radiobuttons that will look like push buttons
'Stylebits _BS_PUSHLIKE causes radiobutton to resemble push button
'Stylebits _BS_BITMAP allows a bitmap to be drawn on button
'Be sure to set width and height to bitmap dimensions
    Stylebits #main.bt1, _BS_PUSHLIKE or _BS_BITMAP, 0, _WS_EX_DLGMODALFRAME, 0
    Radiobutton #main.bt1, "", selected, unselected, 20, 30, 40, 30
    Stylebits #main.bt2, _BS_PUSHLIKE or _BS_BITMAP, 0, _WS_EX_DLGMODALFRAME, 0
    Radiobutton #main.bt2, "", selected, unselected, 20, 70, 40, 30
    Stylebits #main.bt3, _BS_PUSHLIKE or _BS_BITMAP, 0, _WS_EX_DLGMODALFRAME, 0
    Radiobutton #main.bt3, "", selected, unselected, 80, 30, 40, 30
    Stylebits #main.bt4, _BS_PUSHLIKE or _BS_BITMAP, 0, _WS_EX_DLGMODALFRAME, 0
    Radiobutton #main.bt4, "", selected, unselected, 80, 70, 40, 30
 
'For this demo, a graphicbox is needed to draw and capture bitmaps
    Graphicbox #main.gb, 0, 150, 200, 120
    Open "Stylebits and Radiobuttons" for Window as #main
    #main "Trapclose endDemo"
 
'Obtain handle of the main window
    hMain = hWnd(#main)
'Obtain handles of the 4 radiobuttons
    hButton1 = hWnd(#main.bt1)
    hButton2 = hWnd(#main.bt2)
    hButton3 = hWnd(#main.bt3)
    hButton4 = hWnd(#main.bt4)
 
'===============================================
'To load bitmaps from disk, use
    'Loadbmp "buttonPic1", "buttonPic1.bmp"
    'Loadbmp "buttonPic2", "buttonPic2.bmp"
    'etc.
'===============================================
'For this demo, the bitmaps will be drawn and captured
    #main.gb "Down; Fill Black; Size 2"
    #main.gb "Color Lightgray; Backcolor DarkRed"
    #main.gb "Place 2 2; Boxfilled 38 28"
    #main.gb "Getbmp buttonPic1 0 0 40 30"
    #main.gb "Backcolor Darkblue"
    #main.gb "Place 2 2; Boxfilled 38 28"
    #main.gb "Getbmp buttonPic2 0 0 40 30"
    #main.gb "Backcolor Yellow"
    #main.gb "Place 2 2; Boxfilled 38 28"
    #main.gb "Getbmp buttonPic3 0 0 40 30"
    #main.gb "Backcolor Darkgreen"
    #main.gb "Place 2 2; Boxfilled 38 28"
    #main.gb "Getbmp buttonPic4 0 0 40 30"
    #main.gb "Backcolor Black; Fill Black"
'===============================================

'Get the handle of the bitmaps
    hPic1 = hBmp("buttonPic1")
    hPic2 = hBmp("buttonPic2")
    hPic3 = hBmp("buttonPic3")
    hPic4 = hBmp("buttonPic4")
 
'Paint the bitmaps on the radiobuttons
    For i = 1 to 4
        Select Case i
            Case 1
                hBtn = hButton1
                hPic = hPic1
            Case 2
                hBtn = hButton2
                hPic = hPic2
            Case 3
                hBtn = hButton3
                hPic = hPic3
            Case 4
                hBtn = hButton4
                hPic = hPic4
        End Select
        CallDll #user32, "SendMessageA", _
            hBtn as uLong, _
            _BM_SETIMAGE as Long, _
            _IMAGE_BITMAP as Long, _
            hPic as uLong, _
            result as Long
    Next i
 
'Erase button drawings in graphicbox
    #main.gb "Cls; Fill Black"
 
'Wait for user input
    Wait
 
'Find which radiobutton checked
'Fill quadrant with designated color
    Sub selected handle$
        clr = Val(Right$(handle$, 1))
        #main.gb "Cls; Fill Black"
        Select Case clr
            Case 1
                #main.gb "Color Darkred; Backcolor Darkred"
                x = 1
                y = 1
            Case 2
                #main.gb "Color Darkblue; Backcolor Darkblue"
                x = 1
                y = 61
            Case 3
                #main.gb "Color Yellow; Backcolor Yellow"
                x = 101
                y = 1
            Case 4
                #main.gb "Color Darkgreen; Backcolor Darkgreen"
                x = 101
                y = 61
        End Select
        #main.gb "Place ";x;" ";y
        #main.gb "Boxfilled ";x + 99;" ";y + 59
        End Sub
 
'As is the case with any radiobutton, an
'Unset event handler needs to be defined
'but is never actually executed
    Sub unselected handle$
        clr = Val(Right$(handle$, 1))
        #main.gb "Color Black; Backcolor Black"
        #main.gb "Cls; Fill Black"
        End Sub
 
'End the program
    Sub endDemo handle$
'Unload bitmaps to free memory
        For i = 1 to 4
            Unloadbmp "buttonPic";i
        Next i
        Close #main
        End
        End Sub

A List of Stylebits

You can get a list of all dwStyles and dwExStyles available with the Stylebits command at the MSDN Library - Button Styles.
Be sure to precede these constants with an underscore (if constant is BS_PUSHLIKE, then LB Stylebits is _BS_PUSHLIKE) when using Windows constants in your Liberty BASIC programs.

Stylebits - Windows

StPendl — Sun, 07 Dec 2008 11:43:18 GMT

Defining the Window

To understand how stylebits can modify a window, it's important to first understand what the traditional window looks like and how it behaves. Generally speaking, a window is distinguishable from the rest of the screen by its borders. The borders create a box.

Open "My Window" for Window as #1
Print #1, "Trapclose [closeWindow]"
 
Wait
 
[closeWindow]
Close #1
End

Types of Windows

The Liberty BASIC Help File identifies these four types of windows created using native LB commands:

WINDOW - the most common and the most useful, used to hold controls, can include one or more menus, can trap TAB key to move focus from one control to another.

GRAPHICS - designed to display graphics and sprites, not intended to hold controls, can trap mouse clicks and character key presses.

DIALOG - similar to the traditional window, can contain controls, cannot contain menus, can trap ENTER key as a special button to direct action. When displayed as "modal," the dialog window remain in focus until closed. (The prompt, notice and confirm windows are special dialog modal windows.

TEXT - Limited to writing and editing text, always contain a menubar that contains a read-made File Menu and a ready-made Edit Menu. (The Mainwindow is a Text Window.

There are many native variations of these four windows. See the Helpfile for variations such as full screen (_fs), _nf (no sizing frame), no scroll bars (_nsb), no titlebar (_popup), among others.

Elements of a Window

For an explanation of the parts of a window, visit this tutorial.

As well as the borders of the window box, the typical window contains a blue title bar along its top. The windows constant for the border is WS_BORDER and for the title bar is WS_CAPTION. The window icon, the small picture located in the left portion of the title bar is referred to as WS_SYSMENU. Double-clicking this icon reveals the window menu (Restore, Move, Size, Minimize, Maximize, Close). In addition, there are three buttons located in the right portion of the title bar. They are

the minimize button or WS_MINIMIZEBOX
the maximize button or WS_MAXIMIZEBOX
the trapclose button.

Using Window Styles Constants in Your Program

Window styling changes have long been available in Liberty BASIC using the API calls SendMessageLong. Liberty BASIC v4.x offers the programmer the opportunity to modify these styles using the native command STYLEBITS. Stylebits commands are used to access or change the style and attributes of a window and other controls. There are two categories of styles: standard and extended.

Extended attributes resulted from newer CreateWindwoEX functions so they are more useful in adding qualities rather than removing qualities. Both categories are represented as flags in 32 - bit integers. These styles must be applied to the window and / or controls before the gui is opened.

The stylebits of any particular window and the controls of that window may not be altered after the window is opened except, in some but not all cases, with API calls.

From the Liberty BASIC v4.01 Help File
stylebits #handle, addBits, removeBits, addExtendedBits, removeExtendedBits

STYLEBITS allows you to change the style of a Liberty BASIC window or control. It accepts a handle and four parameters. When the window is opened it checks to see if there are style bits for the window or for any controls. If there is a STYLEBITS command it applies the remove bits first, then applies the add bits. In this way the control is created from the get-go with the desired style. The STYLEBITS command must be issued before the command to open the window.

Most often you can recognize whether a stylebit is standard (dwStyle) or extended (dwExStyle) by its Window Constant. The stylebit WS_CAPTION can be passed as the first (addBits) or second (removeBits) parameter, while the stylebit WS_EX_TOPMOST is passed as either the third (addExtendedBits) or fourth (removeExtendedBits) parameter. Liberty BASIC recognizes window constants by placing an additional underscore immediately in front of the constant, e.g, _WS_CAPTION. Run this demo to see how window attributes can be both added and removed.

    'This Demo opens up to five independent windows.  The windows
    'will be placed side by side for visual comparison.  The left (primary)
    'window is opened 'as is' with no Stylebits assigned.  The
    'right windows show windows with attributes either added
    'or removed by the use of the Stylebits command.
    'This demo requires Liberty BASIC v4.x or greater.

    Nomainwin
    If Val(Version$) < 4 Then
        Notice "This program requires Liberty BASIC V4.0 or greater"
        End
    End If
 
    'The main (left) window - No stylebits assigned
    WindowWidth = 300
    WindowHeight = 350
    UpperLeftX = 50
    UpperLeftY = 100
 
    Statictext #main.0a, "No Stylebits commands have been used in this window", 20, 10, 260, 40
    Statictext #main.0b, "Click on any of the buttons to see Stylebits in action", 20, 50, 260, 40
    Button #main.1, "addBits: Vertical Scroll Bar", [parameter1], UL, 15, 120, 270, 30
    Button #main.2, "removeBits: Maximize Button", [parameter2], UL, 15, 160, 270, 30
    Button #main.3, "addExtendedBits: Sunken Edge Border", [parameter3], UL, 15, 200, 270, 30
    Button #main.4, "removeExtendedBits: No Demo", [parameter4], UL, 15, 240, 270, 30
    Button #main.5, "See All 3 Stylebits Commands", [parameterAll], UL, 15, 280, 270, 30
 
    Open "The Window - AS IS" for Window as #main
    Print #main, "Trapclose [endDemo]"
    Print #main, "Font Times_New_Roman 12 Bold"
 
    Wait
 
[parameter1]
    'addBits: Add a vertical scroll bar to the window
    WindowWidth = 300
    WindowHeight = 350
    UpperLeftX = 400
    UpperLeftY = 100
 
    Stylebits #1, _WS_VSCROLL, 0, 0, 0
 
    Statictext #1.0a, "A regular window does not normally include a vertical scroll bar.", 20, 10, 260, 40
    Statictext #1.0b, "The Stylebits (1st parameter) has ADDED this feature.", 20, 50, 260, 40
    Statictext #1.1, "addBits: Vertical Scroll Bar", 15, 120, 270, 20
    Statictext #1.2, "Stylebits #1, _WS_VSCROLL, 0, 0, 0", 15, 160, 270, 40
    Button #1.3, "Close", [close1], UL, 120, 250
 
    Open "addBits: Vertical Scroll Bar" for Window as #1
    Print #1, "Trapclose [close1]"
    Print #1, "Font Times_New_Roman 12 Bold"
    window1 = 1
 
    Wait
 
[close1]
    Close #1
    window1 = 0
    Wait
 
[parameter2]
    'removeBits: Remove the maximize button
    WindowWidth = 300
    WindowHeight = 350
    UpperLeftX = 400
    UpperLeftY = 100
 
    Stylebits #2, 0, _WS_MAXIMIZEBOX, 0, 0
 
    Statictext #2.0a, "A regular window contains a maximize button", 20, 10, 260, 40
    Statictext #2.0b, "The Stylebits (2nd parameter) has REMOVED this feature.", 20, 50, 260, 40
    Statictext #2.1, "removeBits: Maximize Window", 15, 120, 270, 20
    Statictext #2.2, "Stylebits #2, 0, _WS_MAXIMIZEBOX, 0, 0", 15, 160, 270, 40
    Button #2.3, "Close", [close2], UL, 120, 250
 
    Open "removeBits: Maximize Window" for Window as #2
    Print #2, "Trapclose [close2]"
    Print #2, "Font Times_New_Roman 12 Bold"
    window2 = 1
 
    Wait
 
[close2]
    Close #2
    window2 = 0
    Wait
 
[parameter3]
    'addExtendedBits: Add Sunken Edge Border
    WindowWidth = 300
    WindowHeight = 350
    UpperLeftX = 400
    UpperLeftY = 100
 
    Stylebits #3, 0, 0, _WS_EX_CLIENTEDGE, 0
 
    Statictext #3.0a, "A regular window has smooth resizable edges.", 20, 10, 260, 40
    Statictext #3.0b, "The Stylebits (3rd parameter) has altered the edges.", 20, 50, 260, 40
    Statictext #3.1, "addExtendedBits: Sunken Edge Border", 15, 120, 270, 20
    Statictext #3.2, "Stylebits #3, 0, 0, _WS_EX_CLIENTEDGE, 0", 15, 160, 270, 40
    Button #3.3, "Close", [close3], UL, 120, 250
 
    Open "addExtendedBits: Sunken Edge Border" for Window as #3
    Print #3, "Trapclose [close3]"
    Print #3, "Font Times_New_Roman 12 Bold"
    window3 = 1
 
    Wait
 
[close3]
    Close #3
    window3 = 0
    Wait
 
 
[parameter4]
    'removeExtendedBits: No Demo
    WindowWidth = 300
    WindowHeight = 350
    UpperLeftX = 400
    UpperLeftY = 100
 
    Stylebits #4, 0, 0, 0, 0 'No Extended Bits to remove

    Statictext #4.0a, "The extended bits are generally added.", 20, 10, 260, 40
    Statictext #4.0b, "There is no demo for removing extended bits.", 20, 50, 260, 40
    Statictext #4.1, "addExtendedBits: No Demo", 15, 120, 270, 20
    Statictext #4.2, "Stylebits #3, 0, 0, 0, 0", 15, 160, 270, 40
    Button #4.3, "Close", [close4], UL, 120, 250
 
    Open "removeExtendedBits: No Changes" for Window as #4
    Print #4, "Trapclose [close4]"
    Print #4, "Font Times_New_Roman 12 Bold"
    window4 = 1
 
    Wait
 
[close4]
    Close #4
    window4 = 0
    Wait
 
[parameterAll]
    'All 3 Stylebits Combined in the Same Window
    WindowWidth = 300
    WindowHeight = 350
    UpperLeftX = 400
    UpperLeftY = 100
 
    Stylebits #5, _WS_VSCROLL, _WS_MAXIMIZEBOX, _WS_EX_CLIENTEDGE, 0
 
    Statictext #5.0a, "This window has all 3 stylebits applied.", 20, 10, 260, 40
    Statictext #5.0b, "No removeExtendedBits has been applied.", 20, 50, 260, 40
    Statictext #5.1, "Stylebits: #1, #2, and #3 combined", 15, 120, 270, 20
    Statictext #5.2, "Stylebits #5, _WS_VSCROLL, _WS_MAXIMIZEBOX, _WS_EX_CLIENTEDGE, 0", 15, 160, 270, 60
    Button #5.3, "Close", [close5], UL, 120, 250
 
    Open "removeExtendedBits: No Changes" for Window as #5
    Print #5, "Trapclose [close5]"
    Print #5, "Font Times_New_Roman 12 Bold"
    window5 = 1
 
    Wait
 
[close5]
    Close #5
    window5 = 0
    Wait
 
[endDemo]
    If window1 = 1 Then Close #1
    If window2 = 1 Then Close #2
    If window3 = 1 Then Close #3
    If window4 = 1 Then Close #4
    If window5 = 1 Then Close #5
    Close #main
    End

It is sometimes desirable to add two or more stylebit parameters. The window constants can be combined using the logical boolean OR conjunction. This next demo first opens a normal window, then opens a second window that

cannot be maximized: uses the removeBits (2nd parameter) _WS_MAXIMIZEBOX
cannot be minimized: uses the removeBits (2nd parameter) _WS_MINIMIZEBOX
has sunken edge borders: uses the addExtendedBits (3rd parameter) _WS_EX_CLIENTEDGE
stays on top even when not active window: uses the addExtendedBits (3rd parameter) _WS_EX_TOPMOST

    'This Demo opens up to two independent windows.  The windows
    'will be placed side by side for visual comparison.  The left (primary)
    'window is opened 'as is' with no Stylebits assigned.  The
    'right window demonstrates
    'cannot be maximized: uses the removeBits (2nd parameter) _WS_MAXIMIZEBOX
    'cannot be minimized: uses the removeBits (2nd parameter) _WS_MINIMIZEBOX
    'has sunken edge borders: uses the addExtendedBits (3rd parameter) _WS_EX_CLIENTEDGE
    'stays on top even when not active window: uses the addExtendedBits (3rd parameter) _WS_EX_TOPMOST
    'This demo requires Liberty BASIC v4.x or greater.

    Nomainwin
    If Val(Version$) < 4 Then
        Notice "This program requires Liberty BASIC V4.0 or greater"
        End
    End If
 
[noStylebits]
    WindowWidth = 300
    WindowHeight = 350
    UpperLeftX = 50
    UpperLeftY = 100
 
    Statictext #1.1, "No Stylebits commands have been used in this window", 20, 10, 260, 40
    Statictext #1.2, "Drag this window 'over' the second window to see the effects of the", 20, 110, 260,40
    Statictext #1.3, "_WS_EX_TOPMOST stylebits command", 20, 150, 260, 40
 
    Open "The Window - AS IS" for Window as #1
    Print #1, "Trapclose [close1]"
    Print #1, "Font Times_New_Roman 12 Bold"
    window1 = 1
 
[multipleStylebits]
    WindowWidth = 300
    WindowHeight = 350
    UpperLeftX = 400
    UpperLeftY = 100
 
    Stylebits #2, 0, _WS_MAXIMIZEBOX or _WS_MINIMIZEBOX, _WS_EX_CLIENTEDGE or _WS_EX_TOPMOST, 0
 
    sbText$ = "_WS_MAXIMIZEBOX or _WS_MINIMIZEBOX, _WS_EX_CLIENTEDGE or _WS_EX_TOPMOST, 0"
    Statictext #2.1, "Try to Maximize or Minimize this Window", 20, 10, 260, 40
    Statictext #2.2, "Click and drag this window around.", 20, 50, 260, 40
    Statictext #2.3, "Notice the sunken border edges.", 20, 90, 260, 40
    Statictext #2.4, "Stylebits #2, ";sbText$, 15, 160, 260, 80
    Statictext #2.5, "2 or more parameters joined with OR", 15, 260, 260, 40
 
    Open "Combining Stylebits Parameters Using OR" for Window as #2
    Print #2, "Trapclose [close2]"
    Print #2, "Font Times_New_Roman 12 Bold"
    window2 = 1
 
    Wait
 
[close1]
    Close #1
    window1 = 0
    If window2 = 0 Then End
    Wait
 
[close2]
    Close #2
    window2 = 0
    If window1 = 0 Then End
    Wait

Stylebits, of both dwStyle and dwExStyle, can be assigned to other types of windows and most controls (buttons, textboxes, listboxes, statictext, etc.). Texteditors are not readily modifiable with Stylebits. The helpfile states that since the texteditor is not a native Windows control you will only be able to do things like tweak its border and perhaps a few other things.

A List of Stylebits

You can get a list of all dwStyles and dwExStyles available with the Stylebits command at the MSDN Library.

StylebitsWindowsConstants

JanetTerra — Fri, 27 Aug 2010 02:12:34 GMT

Stylebits and Windows Constants

Janet Terra

Recognized Windows Constants

Many of the Windows constants are recognized by Liberty BASIC by preceding that constant with an underscore. As an example, the decimal equivalent of WS_EX_TOOLWINDOW (MSDN Defines a Tool Window here) is 128. With the preceding underscore, Liberty BASIC accurately interprets that constant.

    Print _WS_EX_TOOLWINDOW ' Prints 128

While it is most convenient to use the Windows constant itself, the numerical equivalent (either the literal or a variable) can be used just as easily in the Stylebits command.

    Stylebits 0, 0, _WS_EX_TOOLWINDOW, 0

is the same as

    Stylebits 0, 0, 128, 0

is the same as

    exStyle = 128
    Stylebits 0, 0, exStyle, 0

This variable must be in decimal (not hexademical) form. If necesssary, use the Liberty BASIC HexDec() function to convert a hexademical value to a decimal value.

    valueHex$ = "80" ' Hexademical &H80
    Print HexDec(valueHex$) ' Prints 128

Demo 1: Opening a Tool Window using the Windows Constant in the Stylebits command

' Open a Tool Window

    Nomainwin
    Stylebits #w, 0, 0, _WS_EX_TOOLWINDOW, 0
    Open "Tool Window" for Window as #w
    #w "Trapclose QuitDemo"
 
    Wait
 
Sub QuitDemo handle$
    Close #handle$
End Sub

Demo 2: Opening a Tool Window using the literal decimal value in the Stylebits command

' Open a Tool Window

    Nomainwin
    Stylebits #w, 0, 0, 128, 0
    Open "Tool Window" for Window as #w
    #w "Trapclose QuitDemo"
 
    Wait
 
Sub QuitDemo handle$
    Close #handle$
End Sub

Demo 3: Opening a Tool Window using a variable in the Stylebits command

' Open a Tool Window

    Nomainwin
    exStyle = 128
    Stylebits #w, 0, 0, exStyle, 0
    Open "Tool Window" for Window as #w
    #w "Trapclose QuitDemo"
 
    Wait
 
Sub QuitDemo handle$
    Close #handle$
End Sub

Unrecognized Windows Constants

There are well over 55,000 Windows Constants in use. Many, but not all, Windows constants are recognized by Liberty BASIC. WS_EX_LAYERED is one of the unrecognized constants. Due to the very number of entries alone, a comprehensive list of such constants would be near impossible to find. In the case of the unrecognized WS_EX_LAYERED, Google that constant to find the decimal or hexadecimal equivalent. Remember, if the constant value is given as a hexadecimal string, you must convert that hexadecimal string to the equivalent decimal number. The decimal equivalent of WS_EX_LAYERED is 524288.

It is best to choose a meaningful variable name. In this case, we'll name the variable WS.EX.LAYERED. Liberty BASIC will halt with an error when trying to use an unrecognized Windows constant

    Stylebits #w, 0, 0, _WS_EX_LAYERED, 0

but will happilly accept either

    Stylebits #w, 0, 0, 524288, 0

    WS.EX.LAYERED = 524288
    Stylebits #w, 0, 0, WS.EX.LAYERED, 0

Combining Stylebits

Stylebits - Windows shows how to combine two or more Windows constants within the same addbits, removebits, addextendedbits or removeextendedbits of the Stylebits command. Decimal numbers and variables work just as well in combination.

Demo1: Removing the Maximize and Minimize Buttons using Windows Constants in the Stylebits command

    Stylebits #w, 0, _WS_MAXIMIZEBOX or _WS_MINIMIZEBOX, 0, 0
    Open "No Max/Min Boxes" for Window as #w
    #w "Trapclose QuitDemo"
    Wait
 
Sub QuitDemo handle$
    Close #handle$
    End
End Sub

Demo2: Removing the Maximize and Minimize Buttons using literals and variables in the Stylebits command

    WS.MAXIMIZEBOX = 65536
    Stylebits #w, 0, 131072 or WS.MAXIMIZEBOX, 0, 0
    Open "No Max/Min Boxes" for Window as #w
    #w "Trapclose QuitDemo"
    Wait
 
Sub QuitDemo handle$
    Close #handle$
    End
End Sub

Beyond Stylebits

Windows constants can be applied in many other coding situations. One example is passing parameters to a CallDLL #gdi32. Windows constants for opaque and transparent background colors are BKMODE_OPAQUE and BKMODE_TRANSPARENT respectively. Since neither of these constants is recognized by Liberty BASIC, then the value of 1 or 2 must be passed into any CallDLL #gdi32 as either a literal or a variable. Liberty BASIC sees Windows constants as Global variables. It may be beneficial use the Global command when specifying any user defined variable such as BKMODE.TRANSPARENT. The information here can be applied to many other circumstances when the Windows constant is unrecognized by Liberty BASIC and the decimal value is known to the programmer.

Wikispaces : Liberty BASIC Programmer's Encyc - items matching description

BmpButtons

BmpButtons

What are BmpButtons?

How Do BmpButtons Work?

BmpButton Commands

SETTING FOCUS TO A BMPBUTTON

CHANGING THE BITMAP ON THE BUTTON

MOVING AND RESIZING A BMPBUTTON

DEMO

ccbCode

CustomControlsBox

Custom Controls in a Box (- lbjoseph)

Making your own custom control with a graphicbox in Liberty BASIC.

Table of Contents

Why a custom control?

The container

The foundation of what we want

Data management

The guts of our hyperlink program

What does it all mean?

Utilizing the hyperlink

Conclusion and a Progress bar control

Graphicbox and Scrollbars

A Graphicbox with Scrollbars

Table of Contents

Horizscrollbar and Vertscrollbar

A Graphics Window with Scrollbars

A Graphicbox with Scrollbars

A Word About the Actual size of the Graphicbox

Setting the Scrollbar min and max Parameters

Fixing a Glitch

Scrolling Within the Program

Graphicbox and Scrollbars Demo

Table of Contents

gui

GUI Programming

Windows

Menus

Controls

Buttons

Textboxes

Listboxes

Graphics Windows and Graphicboxes

Stylebits

Windows References on the Microsoft Developer Network Library

Table of Contents

Improved BmpButton

LayeredWindowTransparency

Fun With Transparent Windows

Janet Terra with inspiration from Alyce Watson and Stefan Pendl

The WS_EX_LAYERED addExtendedBits Stylebit

Demo of LWA_ALPHA

Stefan Pendl's Demo Using LWA_COLORKEY

Closing Stefan's Demo

How Does Stefan's Demo Work?

Reversing Transparency

MDIScroll

Why Scroll?

MDI is the Key

Creating an MDI Client

Creating a Child Window

Making it Work

Scrolling Demo

MoveWindow

Table of Contents

Moving or Resizing a Window or Control

Native LOCATE Command

MoveWindow API

Demo

PushButtons

Push Buttons

Button

Default Button

Non-literals in Button Statements

EVENT HANDLERS

COLORS

LABEL

FONTS

SETFOCUS