# XLnt ii User Guide

## Contents:

####

- About this Guide
- OverView
  - Windows
  - Gadgets
  - Menus
- Getting Started
  - Setting Up
  - Blitz 2D/Plus and XLnt
  - An Example
- Windows
  - Colors
  - Flags
  - Tabs
  - Skins
- Gadgets
  - Gadget Types
  - Icons
  - Groups
  - Lists
    - Item Selection Groups
- 3D Stuff
- Menus
- Interaction and Events
  - Events
    - Window Events
    - Gadget Events
    - Group Events
    - Menu Events
    - List Events
  - Interaction
    - System Variables
    - Window Interaction
    - Gadget Interaction
    - List Interaction
    - Menu Interaction
    - Text Interaction
- General XLnt Functions
- Window Functions
- Gadget Functions
- List Functions
- Menu Functions
- 3D Functions
- License Information
- Thanks & Greets
- Contact Me
- History

## About this Guide

This HTML user guide refers to commands that are in both the shareware and registered release of XLnt II. Therefore, if you have not registered as an XLnt II User then some of these commands will be missing from your version. To see which commands these are - take a look at the History section, then read the License section for registration info.
Now on with the show........

## OverView

Before we get started lets run through a few basic fundamentals.
Firstly, XLnt is a set of additional functions which can be accessed by you the user in your own programs. This allows you to easily create a user interface (UI) for your programs without having to worry too much about the behind the scenes technicalities.
When you are developing your code then you must "Include" the XLnt files. However, when you have finished your program and make an .EXE then the "Include" files are automatically inserted into the single .EXE file.
XLnt works on the principal of Types and Handles. All user specified objects (ie Windows, Gadgets, Menus) have a unique Handle (or name) assigned to them upon creation. This allows the programmer (you!) to access individual objects without having to worry about conflicts or errors. (hopefully!)
Interfaces built using XLnt can be broken down into 3 separate sections; Windows, Gadgets, and Menus.

### Windows

Windows will form the main component of your UI. They provide the backing to which you apply your Gadgets and Menus. XLnt allows you to open an unlimited number of Windows, each with its own unique set of Gadgets and Menus.....thus allowing you to make quite complex UI`s. Windows can be re sized, minimized, dragged, pushed, pulled, opened, closed, you name it you can do it!
See the Window section for more info.

### Gadgets

Gadgets are the tools that allow the user to talk to your program. XLnt offers a whole range of MS Windows type Gadgets, including Buttons, Text Input Boxes, Pull-Down Selectors etc. These Gadgets are attached to their respective Windows and are accessed using the Gadget Functions. See the Gadget section for more info.

### Menus

Menus can be:
Window Specific - they are attached to a Windows Menu bar.
Quick Menus - not Window specific, but are "floating" Menus called up from anywhere on screen using the right mouse button.
Attached - called when a gadget is clicked with either the Left or Right Mouse Button (user specified).
Menus can contain; normal menu items, grouped Radio Items, click able Item "Switches", separator lines, and spaces.
See the Menus section for more info.

## Getting Started

As I said earlier - XLnt is a group of Include files which need to be included into your Blitz Program. However, you do not need to manually include all of the files yourself - the only file that you need to include is "XStart.bb". This file contains a list of all the other include files - and will include them on execution. See how kind I am to you :)

### Important! Blitz 2D Users Please Read

XLnt is set up to use Blitz3D as the default Blitz language. If you are NOT using Blitz3D then you will need to remove the 3D specific command calls - else there will be problems. but don't panic! Its Easy!
If you are not using Blitz 3D do the following:

1. Open the "XStart.bb" Include file
2. Comment out [;] the Include "XLnt\X3D.bb" line [ its at the bottom ;) ]
3. Save the file

Thats it! XLnt will no longer try to access non-existent Blitz3D commands in Blitz 2D!

### Setup Code

Here's how XLnt is included into your own Blitz programs:

    ;Simple XLnt Example

    ;Include XLnt stuff first.....
    Include "XStart.bb"

    ;Setup our Graphics Display
    Graphics 800,600,32,1

    ;Setup XLnts internal graphics - see below
    GUI_GFXSETUP()

GUI_GFXSETUP() : hmmmm, what does this do eh? Basically, this functions loads in all the internal GUI graphics (mouse pointer, fonts etc) - and needs to be called before you access any other XLnt functions. But once you've called it once thats it - you can forget about it :)

### An Example

The easiest way to learn is by example - so here is a simple bit of code that will run through the basics of setting up XLnt, adding some stuff, and entering the loop.

    ;Simple XLnt Example

    ;First we include the XLnt files
    Include "XStart.bb"

    ;Now we set up our Graphics Display
    Graphics 800,600,32,1

    ;Now we setup XLnts internal GFX
    GUI_GFXSETUP()

    ;Thats all the setup code complete - now we can start adding GUI elements....

    ;First we will need a Window - lets call it MyWin
    MyWIN=GUI_Window(100,200,300,400,"My First Window")

    ;Now lets add a button gadget to our window
    Quit=GUI_Button(MyWin,10,50,100,"Quit")

    ;Thats enough for now - so lets tell XLnt that we have finished making this window
    GUI_OpenWin(Mywin)

    ;And lets fall through to our main loop.....

    While Finish=False And KeyDown(1)=False

       ;Sort out the buffers
       Setbuffer BackBuffer():Cls

       ;Update our GUI
       GUI()

       ;Check if we clicked the QUIT gadget....
       If EV_Gad_Release(Quit)
           Finish=True
       Endif

       ;And check if we clicked MyWin's Title bar Close Button
       If EV_Win_Close(MyWin)
           Finish=True
       Endif

       Flip

    Wend

    End

Now lets go through that one line at a time - because even though it was a very simple program, it contains all the basic functions of XLnt ;)

    Include "XStart.bb"

Simply tells Blitz to load in all of XLnts Include Files

    Graphics 800,600,32,1

Setup a Graphics Display - but you knew that anyway - right? :P

    GUI_GFXSETUP()

An Important line this - it loads in all of XLnts internal GFX and Fonts, so don't forget to include it :)

    MyWIN=GUI_Window(100,200,300,400,"My First Window")

This is where it gets a little tricky, and as you'll be using this line quite often lets go through it in more detail...
Firstly, XLnt uses Types to store its data - so every Window (and Gadget) needs a unique Handle (name)
Eg: MyWIN is the Handle and will store the pointer to the rest of the window data.
Now we have 4 different numbers; 100,200,300,400 - what do these do? These are.... X Position, Y Position, Width, and Height. So our window will be at position x:100 y:200 and will be 300x400 in size.
Thats all we need to make a window - a handle variable and X,Y,W,H but in our example we also supply a window title - "My First Window". Try removing this to see what happens....

    Quit=GUI_Button(MyWin,10,50,100,"Quit")

This line is very similar to the previous window one - but in this case we want to add a new gadget to a window
Again - we need a Handle, which is used to access the gadget later on, so......
Quit : make an instance of a .gad type and stores it in the variable called Quit.
GUI_Button : tells XLnt that we want to make a click able button gadget - each gadget type has its own GUI_Function()
(MyWin,10,50,100,"Quit") : MyWin tells XLnt that we want to add this gadget to the window called MyWin. The other parameters are simply X,Y,W and Caption$. Easy eh? :P

    GUI_OpenWin(Mywin)

Tells XLnt that we have finished making the window called MyWin - gets the window ready for more GUI stuff so don't forget to add this line ;)
Now we enter a pretty standard Blitz loop - so lets skip to the next XLnt bit.....

    GUI()

This is the most important line - the bit that does all the work! This function call will update all of the GUI functions, check for mouse clicks/key presses etc. and also DRAW the GUI to the screen. Once again - don't forget to add this line ;)

    If EV_Gad_Release(Quit)

Our first bit of interaction - cool!
This is one of the Event Check Functions (there are a few of 'em) - this one will tell you if the user has clicked AND released a specific gadget during the last GUI() update. So here we are checking to see if our previously made "Quit" button gadget has been clicked, and if so setting our Finish flag to True. Piece of cake...

    If EV_Win_Close(MyWin)

Another Event Check Function!
This one checks to see if the user has clicked a windows Close button (the X at the top-right corner), and if so set the Finish flag to True.
Thats about it! Now lets go into the various XLnt elements in more detail. Starting with........

## Windows

Windows are the basic component of any XLnt program and are created in the following way...

- Use GUI_WINDOW() to create a window
- If the Window contains Menus then add them now
- If the Window contains Tabs then use GUI_WIN_TABAREA() to create a tab area
- Add your gadgets to the Window - Tab gadgets first tho ;)
- When all gadgets have been added, use GUI_OPENWIN() to finish the window creation

### Colors

Just a quick note about colors.... all colors passed to XLnt functions are in $RRGGBB format.
Example:
Purple in R,G,B is 255,0,255. To get the $RRGGBB value we do this... col=(R shl 16) or (G shl 8) or B which comes up with $ff00ff
Don't worry if you didn't get that - there is a function in XLnt that returns the $RRGGBB value of a R,G,B color

GUI_Rgb(Red,Green,Blue) Returns : $RRGGBB format of passed R,G,B color

### Flags

Each window has a set of flags that correspond to various window options. These flags are set using the Flag parameter in GUI_WINDOW() - adding the relative values together will allow you set multiple flags. These values are:
1 : Menu : Setting this flag will create a menu-bar at the top of the window, ready for menus to be added [Default On]
2 : Quit : Window has a Close button at the top right of its title bar [Default On]
4 : Min : Window has a Minimize button at the top right of its title bar [Default On]
8 : Back : Window has a Push-Back button at the top right of its title bar [Default On]
16 : Drag : Window can be Dragged - clicking anywhere that isn't a gadget will allow you to move the window [Default On]
32 : Scale : Window can be scaled - click in the bottom right hand corner [Default On]
64 : Not Used - bugger :P
128 : Gradient : Window has a Gradient fill - the main window area will have color one at the top and color two at the bottom. Looks nice, but may be slow ;) [Default Off]
Example : Flag=51 [1+2+16+32] will make a Window with a Menu bar[1], a Close button[2], Drag able[16], and Scalable[32].

### Tabs

A Window can become quite crowded with Gadgets. Therefore, XLnt allows you to group all related gadgets together under their own Tab. Each Window can have an unlimited number of Tabs, with each Tab having its own gadgets. However, every Window has a special default tab - tab 0. This is the background tab, and any gadgets attached to this tab are displayed at all times, regardless of any other active tabs. This is useful for adding OK Cancel Apply buttons - which can be accessed at anytime.
Before you can add a tabbed gadget tho, you must set the windows tab area. This is a pre-defined box into which all the tabbed gadgets are placed and to which all tab gadgets are attached. So, if your window is going to contain tabbed gadgets you must do the following:

- First create the window - GUI_WINDOW()
- Use GUI_WIN_TABAREA() to set the window tab space
- Add all the Tab Gadgets - GUI_TAB()
- Add all the other gadgets, setting their tabs as you create them
- Open the window - GUI_OPENWIN()

### Skins

XLnt ii now includes simple Window background skinning and "Splash Window" style background images. If your window has different tabs then you can also specify different skins for each seperate tab - nice :) To use skins you do this:

- First create a new Skin Object - GUI_Skin()
- Now attach the Skin to your Window - GUI_Skin_Window()

#### Window Functions

GUI_Window() GUI_OpenWin() GUI_Refresh() GUI_WinStatus() GUI_Win_TabArea() GUI_WinMin() GUI_WinMax() GUI_WinHide() GUI_WinShow() GUI_WinTab() GUI_WinX() GUI_WinY() GUI_Win_XY() GUI_Win_Title() | Create a Window Open a Window Redraw a Window Get a Windows status Set a Windows Tab Area Minimize a Window Maximize a Window Hide a Window Show a Window Get Windows Open Tab Get Windows X Position Get WIndows Y Position Set Windows Position Set Windows Title

## Gadgets

### Gadget Types

The full release version of XLnt contains 24! different types of gadgets! Yes you read correctly - 24! , and here they all are:

GUI_Button GUI_Switch GUI_Cycle GUI_ImgButton GUI_ImgSwitch GUI_Tick GUI_Radio GUI_Prop GUI_Slider GUI_Integer GUI_Float GUI_TxtList GUI_TreeList GUI_Selector GUI_ImgBox GUI_Frame GUI_Panel GUI_ToolBar GUI_Tab GUI_Label GUI_TextBox GUI_Input GUI_ImgArea GUI_3DPort | Normal Button On/Off Button Cycle Button Image Button Image On/Off Button Tick Box Grouped Check Box Prop Slider Value Slider Integer Spinner Float Spinner Text Item List Tree Item List Pull-Down Selector Image Display Box Gfx Frame Expandable Gadget Container Scrollable ToolBar Container Tab Button Text Label Multi-line Text Input Single-line Text Input Scrollable Image Box 3D Viewport Box

### Icons

Many gadgets (and lists, menus, and windows) can have a graphical image displayed alongside its text component. These Gfx images are called Icons and have the following features/restrictions:

- Icons have 1 main image, and optional "down" , "over" and "inactive" images
- Icons must have a unique name supplied on creation
- Icons used for gadgets can be any size - but those used for Window titles, Menu items, and List items must be 16x16 pixels in size
- All images within an icon must be the same size
- Icons are drawn using DrawImage and use mask color $ff00ff

Creating an icon: the following function is used to create an icon, which can then be used in any number of gadgets, lists, menus, etc

GUI_GADICON() | Create an Icon
GUI_GADICON(NAME$,IMG, [IMAGES]) NAME$ : unique icon name IMG : iconstrip image IMAGES : optional number of images in strip [Default 1] This function will create an Icon ready for further use. An iconstrip is used as a template for the icon, with between 1 and 4 images on the strip. The images go in this order : Off, On, Mouse Over, and InActive. If you want more than 1 image then simply pass the total number of images (1 to 4) when setting up the icon. The height of each icon will be the height of the icon strip, and the width will be the total width of the strip divided by the number of images that it contains. Oh.. icons used for gadgets may be any size, but those used for windows, lists or menus must be 16x16! Example:
    ;Load some images...
    win_IMG=LoadImage("gfx\win_icon.bmp")

    disk_IMG=Loadimage("gfx\disk_icon.bmp")

    ;Now create an icon for our window - with only 1 image
    GUI_GADICON("icn_WINDOW",win_IMG)

    ;And a gadget icon with 4 separate images
    GUI_GADICON("icn_DISK",disk_IMG,4)

    ;Add a window with an icon
    MyWIN=GUI_Window(-1,-1,200,200,"Centered Window","icn_WINDOW")

    ;And an image button...
    But1=GUI_ImgButton(MyWin,10,50,"icn_DISK")

    ;Open the window ready for more stuff...
    GUI_OpenWin(MyWin)

### Groups

Gadgets that can be clicked Off and On (Radio Boxes, Switch Buttons) can belong to a Group. Only one gadget within each individual group may be on at any one time. To attach a gadget to a group then a group number must be supplied when it is created. This group number must be greater than 0 to have any effect.

### Lists

Several XLnt gadgets are used to display lists of selectable items. Lists are treated as separate XLnt entities - and there are 2 kinds; normal 1-dimensional lists, and multi-dimensional tree lists. Lists may contain normal selectable items (with or without icons), tick boxes, grouped check boxes, and sub-directories [nodes] (Tree list only).
One Dimensional : these lists are used in Pull-Down Selector and TextList gadgets. If any nodes are added to the list then they are processed like a normal list item.
Tree List : these are multi-dimensional lists used by the TreeList gadget. These lists may contain nodes which act like sub-directories within the list.
To create a list you must first make a parent list to which you add all of the separate list items. You then pass this list to any gadget that you want to attach the list to. Thats it!

#### List Functions

GUI_List() GUI_List_AddItm() GUI_List_AddNode() GUI_List_AddTick() GUI_List_AddCheck() GUI_List_AddInt() GUI_List_AddFloat() GUI_List_AddInput() GUI_List_AddLine() GUI_List_AddIcon() | Create a List Add an Item Add a Sub Node Add a Tick Box Add a Grouped Check Box Add an Integer Gadget Add a Float Gadget Add an Input Gadget Add a separation Line Add a clickable Icon Item

#### Item Selection Groups

New to XLnt ii v1.4 are Item Selection Groups. These allow you to force the user to select a number of list items from within your own pre-defined selection groups. Useful if you want to add options to a list and you need a certain number of items selected.
There are only 2 functions for selection groups.

GUI_List_NewGroup() GUI_Item_AddGroup() | Create a new Selection Group Set an items's Selection Group

## 3D Stuff

XLnt is now fully compatible with background 3D operations - ie. you can now drag a window around the screen and any 3D scene in the background will not be effected.
To use XLnt over 3D you only need to do one thing - call RenderWorld() before you call GUI(), this will then draw the UI on top of any 3D stuff already rendered.

### 3D Gadget

XLnt contains only one 3D specific gadget - but its a "dead good" one :P GUI_3DPort() will add a 3D Viewport gadget to a window. This gadget has its own camera and own wireframe setting and is pretty cool!

#### Important!

Because Blitz only allows you to render a 3D scene to the BackBuffer (Doh!), XLnt has to perform a separate Renderworld + CopyRect to grab the 3D image and display it on a window. This means that a 3D gadget may be slow on some systems. However, to combat this XLnt does not automatically update any 3D gadgets every time GUI() is called - instead the user must manually update any 3D gadgets when he sees fit. Although this may seem a little "crap" it allows you much greater control over you FPS - as you choose when the slow Renderworld + CopyRect takes place.
Here's an example of a 3D gadget main loop:

    ;We already have a window which contains a 3D Viewport gadget call MyGad3D
    ;So lets drop thru to our main loop......

    While Not KeyDown(1)

      ;Render our 3D gadget every other frame
      Frame=1-Frame

      If Frame=1
         GUI_RENDER3D(MyGad3D)
      EndIf

      ;Render the world
      Renderworld()

      ;Update XLnt
      GUI()

      Flip
      Setbuffer Backbuffer():Cls

    Wend
    End

#### 3D Functions

GUI_3DPort() GUI_Render3D() GUI_SetWire() GUI_GadWire() GUI_SetCam() GUI_GadCam() | Create a 3D ViewPort Gadget Render a 3D gadget Set a 3D gadgets wireframe mode Returns a 3D gadgets wireframe mode Set a 3D gadgets camera Returns a 3D gadgets camera

## Menus

#### Menu Types

XLnt allows access to 3 types of menus ; Normal, QMenus, and Attached Menus.
Normal : these are your standard Window menus. Each has a root menu attached to a windows menubar which opens when the user clicks on it with the left mouse button.
QMenus : QMenus is short for Quick Menus - unlike normal menus these are not attached to any window and are called by clicking the right mouse button anywhere on-screen.
Attached : XLnt allows you to attach a menu to a specific gadget - when the gadget is clicked (with a pre-set mouse button) then the menu will appear.

#### Menu Creation

All menus are created in a very similar way:

- Create a Main Menu - GUI_MENU()
- Create any Sub-Menus - GUI_SUBMENU()
- Add all your Menu Items - the order in which you add them will be the order in which they are displayed
- Update all the Menu GFX - GUI_MENU_REFRESH()

Sub Menus : all menus (and sub menus) may contain sub menus - allowing for quite complex menu systems to be designed. To create a sub menu you must do the following:

- Create the Parent Menu first - GUI_MENU() or GUI_SUBMENU()
- Now add a sub menu to the parent menu - GUI_SUBMENU()
- Continue until all Menus and Sub Menus are created
- Add Sub Menu Items to allow menu access - GUI_MENU_SUB()
- Refresh all menus - GUI_MENU_REFRESH()

#### Sub Menu Example:

    ;Make a window
    MyWin=GUI_WINDOW(0,0,200,200,"My Window")

    ;Get the windows menubar menu
    WinMenu=GUI_WINMENU(MyWin)

    ;Make a File root Menu
    mnu_File=GUI_MENU(WinMenu,"File")

    ;Make an Edit root menu
    mnu_File=GUI_MENU(WinMenu,"Edit")

    ;Add an options sub menu to the edit menu
    mnu_Opt=GUI_SUBMENU(mnu_Edit)

    ;And a further sub menu to the options sub menu
    mnu_WinOpt=GUI_SUBMENU(mnu_Opt)

    ;Add a menu pointer to the edit menu
    itm_Opt=GUI_MENU_SUB(mnu_Edit,"Options",mnu_Opt)

    ;And a menu pointer to the options menu
    itm_WinOpt=GUI_MENU_SUB(mnu_Opt,"Window Options",mnu_WinOpt)

    ;Refresh ALL the menus
    GUI_MENU_REFRESH(mnu_FILE)
    GUI_MENU_REFRESH(mnu_EDIT)
    GUI_MENU_REFRESH(mnu_OPT)
    GUI_MENU_REFRESH(mnu_WINOPT)

    ;Open the window
    GUI_OPENWIN(MyWin)

It doesn't do much but it shows the order in which you create sub menus and add sub menu pointers to the menus.

#### Example 1 : Normal Menu

    ;Make a window
    MyWin=GUI_WINDOW(0,0,200,200,"My Window")

    ;Get the windows menubar menu
    WinMenu=GUI_WINMENU(MyWin)

    ;Make a File Menu
    mnu_File=GUI_MENU(WinMenu,"File")

    ;Add a menu item to it
    itm_New=GUI_MENU_ITEM(mnu_File,"New")

    ;Refresh the menu
    GUI_MENU_REFRESH(mnu_FILE)

    ;Open the window
    GUI_OPENWIN(MyWin)

GUI_WINMENU() : what's this for? All Normal menus need a Parent Menu to be passed on creation, but the root menus such as File, Edit, Insert etc have no parent menus. Therefore, this function will return a windows Menubar menu which is used as parent for root menus.
GUI_MENU_REFRESH() : this is used to redraw a menus gfx. So you must call it when you have finished creating a menu or if you add any more items to it after it has been created.

#### Example 2 : Quick Menu [QMenu]

    ;Just create a menu
    qmnu_Main=GUI_MENU(0,"Quick Menu")

    ;Add a menu item to it
    itm_New=GUI_MENU_ITEM(qmnu_Main,"New")

    ;Refresh the menu
    GUI_MENU_REFRESH(qmnu_Main)

    ;Turn on QMenus
    GUI_QMENU_ACTIVE=True

    ;And set this menu as the current QMenu
    GUI_QMENU=qmnu_Main

As you can see - when creating a QMenu you do not need to call GUI_WinMenu() as a QMenu has no parent menu. You can also see that 2 variables are used to control QMenu access - GUI_Qmenu_Active is used to turn QMenu access On [True] or Off [False]. GUI_Qmenu is used to hold the currently active QMenu.
Attached Menus are created in exactly the same way as QMenus, but instead of setting GUI_Qmenu_Active and GUI_Qmenu, you call GUI_Menu_Attach()

GUI_Menu_Attach() | Attach a Menu to a Gadget
GUI_MENU_ATTACH(MENU,GAD,[LMB]) MENU : menu to attach GAD : gadget to attach menu to LMB : use left [True] or right [False] mouse button to open menu [Default Right] Attaches a menu to a gadget.

## Interaction and Events

So, we've made some spiffy Windows, Gadgets, and Menus but how do we go about using 'em?

### Event Functions

XLnt contains quite a few EVENT functions - these functions will tell you whether a specific gadget has been hit, a window has been moved, a item has been selected from a list etc. These functions will return a different value every time GUI() is called, so the best time to check for user activity is straight after your GUI() line.
Example:

    ;We've already made our windows and gadgets, so lets just enter the main loop

    While Finish=False And KeyDown(1)=False

       ;Sort out the buffers
       Setbuffer BackBuffer():Cls

       ;Update our GUI
       GUI()

       ;Check if we clicked the QUIT gadget....
       If EV_Gad_Release(Quit)
           Finish=True
       Endif

       ;And check if we clicked MyWin's Title bar Close Button
       If EV_Win_Close(MyWin)
           Finish=True
       Endif

       Flip

    Wend

    End

As you can see - the above code segment contains 2 event functions; EV_Gad_Release() and EV_Win_Close(). Both of which access a specific XLnt element and return True or False depending upon a specific status. There are many event functions, and each XLnt element (Window, Gadget, Menu etc) has its own set of functions. These are:

### Window Event Functions

EV_WIN() Returns : The currently Active window

EV_WIN_OVER() Returns : The window that the mouse is currently over

EV_WIN_CLOSE(WIN) Returns : True if the passed window has had its Close gadget clicked.

EV_WIN_SCALE(WIN) Returns : True if the passed window has been resized

EV_WIN_DRAG(WIN) Returns : True if the passed window has been moved

EV_WIN_MIN(WIN) Returns : True if the passed window has been minimized

EV_WIN_MAX(WIN) Returns : True if the passed window has been maximized

EV_WIN_FRONT(WIN) Returns : True if the passed window has been pulled to the front

### Gadget Event Functions

EV_HIT() Returns : ID (or 0) of any hit gadget

EV_HOLD() Returns : ID (or 0) of any gadget being held down

EV_RELEASE() Returns : ID (or 0) of any gadget that has been released

EV_GAD_DOWN(GAD) Returns : True if the passed gadget is being held down with the LMB

EV_GAD_RELEASE(GAD) Returns : True if the passed gadget has been released with the LMB

EV_GAD_RMBRELEASE(GAD) Returns : True if the passed gadget has been released with the RMB

EV_GAD_TOGGLE(GAD) Returns : True if the passed gadget has been clicked On or Off

EV_GAD_NEWTEXT(GAD) Returns : True if the passed gadgets text has been changed

EV_GAD_NEWVAL(GAD) Returns : True if the passed gadgets value has changed

EV_GAD_INPUTGAD(GAD) Returns : Currently active Input gadget

### Group Event Functions

EV_GROUP_TOGGLE(GROUP) Returns : True if a gadget in the passed gadget group has been clicked

EV_GROUP_DOWN(GROUP) Returns : The ID of the gadget in the passed gadget group that is On or 0

### Menu Event Functions

EV_MENU_HIT() Returns : The ID (or 0) of ANY menu item that has been clicked

EV_MENU_SELECT(ITEM) Returns : True if the passed menu item has been clicked

EV_MENU_TOGGLE(ITEM) Returns : True if the passed menu item has be clicked On or Off

EV_MENU_GROUP(MENU,GROUP) Returns : The ID of any item in the passed menu group that has been clicked

### List Event Functions

EV_ITEM_SELECT(ITEM) Returns : True if the passed has been selected

EV_ITEM_OVER(ITEM) Returns : True if the mouse is over the passed item

EV_ITEM_DBLCLICK(ITEM) Returns : True if the passed has been double clicked with the LMB

EV_ITEM_RMBCLICK(ITEM) Returns : True if the item has been clicked with the RMB

EV_SELECTOR(GAD) Returns : The ID of any item clicked in a pull down selector gadget

EV_LIST_OVER(LIST) Returns : True if the mouse is over the passed list

EV_LIST_SELECT(LIST) Returns : The ID of any clicked item in the passed list

EV_LIST_DBLCLICK(LIST) Returns : The ID of any item double clicked in the passed list

EV_LIST_RMBSELECT(LIST) Returns : The ID of any item that has been clicked with the RMB in the passed list

### Interaction

We now know how do detect User -> XLnt interaction using the Event functions, so now we need to know how we can access and change the XLnt objects from within the program.
XLnt contains many functions that can be used to read and write data to any specific XLnt object, as well as a few Global System Variables that you can change to alter certain UI properties. So lets get down to business, starting with the system variables:

### System Variables

GUI_Debug Set : True or False Will turn Debug Mode on or off [Default Off]

GUI_GFXDir$ Set : valid Directory Holds path to XLnt GFX directory. [Default "XLnt/GFX/"]

GUI_Mouse Set : valid Image Holds current mouse pointer image - changes depending upon current UI state

GUI_Mouse_Draw Set : True or False If False then the mouse pointer will not be drawn [Default True]

GUI_Scroll_Lock Set : True or False If True then the arrow keys will not have any effect on key-scrollable gadgets, used to stop your game/app control messing about with any clicked gadgets [Default False]

GUI_3DCam Set : valid 3D Port gadget ID Holds last clicked (or created) 3D gadget ID - useful for making a multiple 3D viewport based app ;)

### Window Interaction Functions

The following functions are used to read or write specific Window attributes:

GUI_WinMin() GUI_WinMax() GUI_WinHide() GUI_WinShow() GUI_WinTab() GUI_SetTab() GUI_WinX() GUI_WinY() GUI_Win_XY() GUI_Win_Title() GUI_FreeWin() | Minimize a window Maximize a window Hide a window Show a window Get currently open window tab Set a window open tab Get window X position Get window Y position Set window position Set window title text Delete a window

### Gadget Interaction Functions

#### Read values:

The following functions are used to read data from a gadget.

GUI_GadActive() GUI_GadOn() GUI_GadStatus() GUI_GadList() GUI_GadFloat() GUI_GadVal() GUI_GadText$() GUI_GadGroup() GUI_GadGroup_On() GUI_GadTab() GUI_GadX() GUI_GadY() GUI_GadW() GUI_GadH() GUI_Gad_ScreenX() GUI_Gad_ScreenY() GUI_Gad_MouseX() GUI_Gad_MouseY() | Is the gadget Active or Inactive Is the gadget On or Off Returns the gadgets physical status Returns the gadgets list Returns the gadgets Float value Returns the gadgets Integer value Returns the gadgets Text Returns the gadgets Group Returns On gadget in this gadgets group Returns gadgets tab Returns gadgets X position Returns gadgets Y position Returns gadgets Width Returns gadgets Height Returns gadgets Screen X position Returns gadgets Screen Y position Returns relative mouse X position Returns relative mouse Y position

#### Set values:

The following functions are used to set a gadgets data or attributes.

GUI_SetActive() GUI_SetOn() GUI_Gad_Status() GUI_SetList() GUI_SetXY() GUI_SetFloat() GUI_SetVal() GUI_SetText() GUI_Selector_Set() GUI_ToolTip() | Set gadget to Active or Inactive Set gadget On or Off Set gadget status Set gadget list Set gadget position Set gadget Float value Set gadget Integer value Set gadget text Set selector gadget current item Set gadget tooltip text

#### Gadget list functions:

The following functions are used to interact with a gadgets list items

GUI_Item_Gad() GUI_List_SetAct() GUI_List_SetText() GUI_List_SetCol() GUI_List_GetText() GUI_List_Toggle() GUI_List_ItmList() GUI_List_KillItm() GUI_List_Clear() GUI_Item_GetVal() GUI_Item_SetVal() GUI_Item_GetText() GUI_Item_SetText() GUI_List_NumItems() GUI_List_CurPos() GUI_Item_Pos() GUI_Item_Move() GUI_List_CountSelected() GUI_List_Selected() GUI_Item_Selected() GUI_Item_On() GUI_Selector_Set() GUI_List_Item() GUI_Item_Type() GUI_Item_Icon() GUI_Item_SetIcon() | Returns list items attached gadget Set list item active or inactive Set list item text Set list item colors Returns list item text Set list item On or Off Returns list items parent list Delete a list item Delete a list Return list item INT DATA Set list item INT DATA Return list item TEXT DATA Set list item TEXT DATA Returns number of items in list/node Returns item current position in list/node Set item position in list/node Move item within list/node Returns number of selected items Returns selected item ID Returns item selected status Return items On/Off status Set a selectors current item Step thru a list/node Returns Item type Returns Item's Icon Sets Item's Icon

### Gadget Control Functions:

The following functions are used to control gadgets.

GUI_ActGroup() GUI_Set_ActGroup() GUI_Range() GUI_Prop_Range() GUI_FreeGad() | Set gadget Action Group Set Action Group status Set Int and Float gadget range Set Prop and Slider gadget range Delete a gadget

### Menu Interaction Functions

The following functions are used for menu interaction.

GUI_Menu_Act() GUI_Menu_ItmAct() GUI_Menu_GetOn() GUI_Menu_SetOn() GUI_Menu_Attach() GUI_FreeMenu() | Set menu active or inactive Set menu item active or inactive Returns menu item On or Off Set menu item On or Off Attach a menu to a gadget Delete a menu

### Text Interaction Functions

The following functions are used to interact with selected Text Blocks and Text Input gadgets:

GUI_Input_Gad() GUI_Block_Gad() GUI_Gad_AddLine() GUI_Block_Active() GUI_Block_Copy() GUI_Block_Delete() GUI_Block_Insert() GUI_Block_Replace() GUI_Block_CursorPos() | Returns last Input gadget Returns current Block Selection gadget Adds a line of text to an Input gadget Toggles Input gadgets Block selection flag Returns current Text Block as a string Deletes current Text Block Inserts a string into an Input gadget Replaces current Text Block with a new string Returns start position of current Text Block

## Functions

### General XLnt Functions

GUI_GFXSetup() | Loads Internal XLnt GFX
Used after your Graphics command to setup all internal XLnt GFX - don't forget to include this line! << Back

GUI() | Processes XLnt functions
GUI( [PROCESS], [MOUSE] ) PROCESS [True/False] : If set to False then XLnt will skip the processing and just draw the UI and mouse [Default True] MOUSE [True/False] : If set to False then the mouse pointer will not be drawn [Default True] Processes the GUI and draws the screen and mouse. << Back

GUI_Pre_Render() | User-Set Pre-Render function
Any code in this function will be executed immediately before the GUI is drawn to the screen. For Example: if you want a background image displayed then simply put the display code in this function Empty by Default << Back

GUI_Post_Render() | User-Set Post-Render function
Any code in this function will be executed immediately after the GUI is drawn to the screen. Empty by Default << Back

GUI_Set_Focus(Gad) Sets the passed gadget as the currently active gadget. Use to force text input from user. << Back

GUI_Focus() Returns : currently focused gadget ID << Back

GUI_DrawMouse() Draws the mouse pointer Gfx to screen. << Back

### Window Functions

GUI_Window() | Add a New Window
GUI_WINDOW(X,Y,W,H,TITLE$,[ICON$],[FLAG],[MOD],[WIN_COL0],[BAR_COL0],[TITLE_COL],[WIN_COL1],[BAR_COL1]) ICON$ : Window Icon Name [Default ""] FLAG : Window Flag - see below MOD : Window Modal - see below [Default Normal] WIN_COL0 : Main Window Color BAR_COL0 : Window Title bar Color TITLE_COL : Window Title bar Text Color WIN_COL1 : Optional Second Window Color BAR_COL1 : Optional Second Title bar Color Returns : INT pointer Adds a new Window and returns a type. Flag: the flag value is used to set the windows internal values. This value is made up of several bytes - which may be added together to set multiple flags. These are: 1 : Menu : Window has a Menu bar 2 : Quit : Window has a Close button (must have a title bar!) 4 : Min : Window has a Minimize button 8 : Back : Window has a Push-Back button 16 : Drag : Window can be Dragged 32 : Scale : Window can be scaled 64 : Not Used 128 : Gradient : Window has a Gradient fill Example : Flag=51 [1+2+16+32] will make a Window with a Menu bar[1], a Close button[2], Drag able[16], and Scalable[32]. Default : Menu+Quit+Min+Back+Drag+Scale Modal : This value determines how the Window behaves when it isn't the currently active window. 0 : Normal : Window can be pushed behind other windows [Default Value] 1 : OnTop : Window always remains in front of all other windows, but other windows may be interacted with. 2 : Locked : Window is locked in front of all other windows - forces the user to interact with this window Example:
    MyWIN=GUI_Window(100,100,200,200,"My Window")
<< Back

GUI_OpenWin() | Open a Window
GUI_OpenWin(WIN) Call when you have finished setting up a window - will "open" a window ready for further access. Example:
    ;Add a window
    MyWIN=GUI_Window(-1,-1,200,200,"Centered Window")

    ;Open the window ready for more stuff...
    GUI_OpenWin(MyWin)
<< Back

GUI_Refresh() | Redraws a Window
GUI_REFRESH(WIN) Redraws a Windows GFX and all of its gadgets - can be called by the user but you shouldn't need it ;) << Back

GUI_FreeWin() | Deletes a Window
GUI_FreeWin(WIN) Deletes a Window and all of its gadgets. Example:
    ;Add a window
    MyWIN=GUI_Window(-1,-1,200,200,"Centered Window")

    ;Open the window ready for more stuff...
    GUI_OpenWin(MyWin)

    ;Now Delete it!
    GUI_FreeWin(MyWin)
<< Back

GUI_WinStatus() | Windows Current Status
GUI_WinStatus(WIN) Returns: 0 : Window not "opened" use GUI_OpenWin() 1 : Window is open and on-screen. 2 : Window is Minimized. 3 : Window is Hidden. Returns the current physical status of a Window - Open, Minimized, or Hidden. << Back

GUI_Win_TabArea() | Set a Windows Tab Panel
GUI_WIN_TABAREA(WIN,X,Y,W,H) X,Y,W,H : Position and dimensions relative to the top-left of the window Sets the position and dimensions of a windows Tab Panel. Any Tab Gadgets will be attached to this panel - so use this function before you try and attach any Tab gadgets to a window. << Back

GUI_WinMin() | Minimize a Window
GUI_WINMIN(WIN) Will minimize an open window - ie. only a portion of the title bar will show. << Back

GUI_WinMax() | Maximize a Window
GUI_WINMAX(WIN) Will maximize a minimized window << Back

GUI_WinHide() | Hide a Window
GUI_WINHIDE(WIN) Will hide a window << Back

GUI_WinShow() | Un-Hide a Window
GUI_WINSHOW(WIN,[MAX]) Will show a hidden window - if Max is set as True then the window will be maximized too << Back

GUI_WinTab() | Windows Current Tab
GUI_WINTAB(WIN) Returns : INT Tab value [Default 0] Will return the windows current active Tab - or 0 if no tabs exist or no tabs are open. << Back

GUI_Skin() | Create a new Skin
GUI_SKIN(IMG,[SPLASH]) Splash : Tile this Image [False] or resize the Window to the image size [True] [Default False] Returns : INT skin ID Will create a new Skin object and return its ID. If Splash is set to True then this image will be used as a spalsh screen - ie. the window will be resized to fit the image dimensions.. Example:
    ;Add a window
    MyWIN=GUI_Window(-1,-1,200,200,"Centered Window")

    ;Turn this into a Splash Screen
    MySkin=GUI_Skin(Loadimage(SkinImage.BMP"),True)

    ;Assign the skin to the window
    GUI_Skin_Window(Mywin,MySkin)

    ;Open the window ready for more stuff...
    GUI_OpenWin(MyWin)
<< Back

GUI_Skin_Window() | Assign a Skin to a Window
GUI_SKIN_WINDOW(WIN,SKIN,[TAB]) SKIN : Pre-created skin object. TAB : use to set skin to different window tabs [Default 0] Will assign an already created Skin to a window. If Tab is set to any number then this skin will be assigned to that tab number - allows for different images in different window tabs. Example:
    ;Add a window
    MyWIN=GUI_Window(-1,-1,200,200,"Centered Window")

    ;Create 3 different skins for 3 tabs - the 2nd one will be a splash screen
    Tab_Skin_0=GUI_Skin(Loadimage(Skin_0.BMP"))
    Tab_Skin_1=GUI_Skin(Loadimage(Skin_1.BMP"),True)
    Tab_Skin_2=GUI_Skin(Loadimage(Skin_2.BMP"))

    ;Assign the skins to the window tabs - the 2nd one will be a splash screen
    GUI_Skin_Window(Mywin,Tab_Skin_0,0)
    GUI_Skin_Window(Mywin,Tab_Skin_1,1)
    GUI_Skin_Window(Mywin,Tab_Skin_2,2)

    ;Open the window ready for more stuff...
    GUI_OpenWin(MyWin)
<< Back

GUI_WinX() | Windows Horizontal Position
GUI_WINX(WIN) Returns : INT X value Returns a window horizontal screen position << Back

GUI_WinY() | Windows Vertical Position
GUI_WINY(WIN) Returns : INT Y value Returns a window vertical screen position << Back

GUI_Win_XY() | Set a Windows Position
GUI_WIN_XY(WIN,X,Y) Sets a windows screen position to X,Y << Back

GUI_Win_Title() | Set a Windows Title
GUI_WIN_TITLE(WIN,TEXT$) Set a Windows Title Bar text. << Back

GUI_Win_SetTab() | Set a Windows Tab
GUI_WIN_SETTAB(WIN,Tab_Number) Set a Windows currently Open Tab. << Back

### Gadget Functions

Most of the gadget setup functions contain identical parameters - and to avoid too much typing I'll list those here:
WIN : gadgets parent Window
X,Y,W,H : position in Window and dimensions
ICON$ : Icon Name (see Icons) [Default ""]
TAB : gadgets Tab [Default 0]
ACT : gadget active [True] or inactive [False] [Default True]
HELP$ : gadgets ToolTips text [Default ""]
COL0 : gadgets primary color
COL1 : gadgets secondary color [Default Darker Shade of COL0]
TCOL : gadgets Text color [Default Black]
Any parameters passed in [brackets] are optional, and do not need to be passed unless you want to change from the defaults.

GUI_Button() | Standard Button Gadget
GUI_BUTTON(WIN,X,Y,W,TXT$,[ICON$],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) Returns : INT pointer Adds a standard click able button gadget to a Window. Example:
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,200,200,"My Window")

    ;Add a Button
    But1=GUI_BUTTON(MyWin,10,50,100,"Button 1")

    ;Add a Red[$ff0000] Button with White[$ffffff] Text
    But2=GUI_BUTTON(MyWin,10,70,100,"Button 2","",0,True,"Help Text",$ff0000,$dd0000,$ffffff)

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_Switch() | On/Off Type Button
GUI_SWITCH(WIN,X,Y,W,TXT$,[GRP],[ICON$],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) GRP : group ID. If greater than 0 gadget belongs to this group. [Default 0] Returns : INT pointer Adds a standard On/Off button gadget to a Window. This button can belong to a group. If the passed group number is greater than 0 then this gadget belongs in this group - meaning that only one gadget in this group can be On at any one time. Example:
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,200,200,"My Window")

    ;Add a non-grouped switch
    But1=GUI_SWITCH(MyWin,10,50,100,"Switch 1")

    ;Add 3 buttons all in group 1
    But2=GUI_SWITCH(MyWin,10,70,100,"Switch 2",1)
    But3=GUI_SWITCH(MyWin,10,90,100,"Switch 3",1)
    But4=GUI_SWITCH(MyWin,10,110,100,"Switch 4",1)

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_Cycle() | Cycle Button
GUI_CYCLE(WIN,X,Y,W,LIST$,[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) LIST : list of options separated by a "|" character. Eg. "One|Two|Three|Four|" Returns : INT pointer Adds a cycle button gadget to a Window. Pressing the LMB or RMB will cycle the current item in either direction Example:
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,200,200,"My Window")

    ;Add a cycle gadget
    But1=GUI_CYCLE(MyWin,10,50,100,"Item one|Item two|Item three|Final item|")

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_ImgButton() | Standard Image based Button
GUI_IMGBUTTON(WIN,X,Y,ICON$,[BORDER],[TAB],[ACT],[HELP$],[STYLE],[COL0],[COL1],[TCOL]) BORDER : border On [True] or Off [False] [Default On] STYLE : border style [Default 0] Returns : INT pointer Adds a simple image button - containing the passed Icon GFX image. The gadget will have the same dimensions as the passed Icon. Example:
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,200,200,"My Window")

    ;Add an image button gadget
    But1=GUI_IMGBUTTON(MyWin,10,50,"Disk_Icon")

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_ImgSwitch() | On/Off Type Image Button
GUI_IMGSWITCH(WIN,X,Y,ICON$,[GRP],[BORDER],[TAB],[ACT],[HLP$],[STYLE],[COL0],[COL1],[TCOL]) GRP : group ID. If greater than 0 gadget belongs to this group. [Default 0] BORDER : border On [True] or Off [False] [Default On] STYLE : border style [Default 0] Returns : INT pointer Adds a standard On/Off Image button gadget to a Window. This button can belong to a group. If the passed group number is greater than 0 then this gadget belongs in this group - meaning that only one gadget in this group can be On at any one time.The button will have the same dimensions as the passed Icon, and may be enclosed in a GFX border or not. Example:
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,200,200,"My Window")

    ;Add an image switch gadget - belonging to group 9, but with no border
    But1=GUI_IMGSWITCH(MyWin,10,50,"Disk_Icon",9,False)

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_Tick() | Tick Box
GUI_TICK(WIN,X,Y,TEXT$,[ON],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) ON : gadget On [True] or Off [False] [Default Off] Returns : INT pointer Adds a standard tick box gadget to a Window. Used for selecting from a list of options. << Back

GUI_Radio() | Grouped Radio Check Box
GUI_RADIO(WIN,X,Y,TEXT$,[GRP],[ON],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) GRP : group ID. If greater than 0 gadget belongs to this group. [Default 0] ON : gadget On [True] or Off [False] [Default Off] Returns : INT pointer Adds a standard radio check box to a Window. This gadget can be grouped - if the passed group parameter is greater than 0 then this gadget belongs to that group. Example:
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,200,200,"My Window")

    ;Add a few options - using group 23! oh.. lets set the first 1 on too
    opt1=GUI_RADIO(MyWin,10,50,"Option 1",23,True)
    opt2=GUI_RADIO(MyWin,10,70,"Option 2",23)
    opt3=GUI_RADIO(MyWin,10,90,"Option 3",23)
    opt4=GUI_RADIO(MyWin,10,110,"Option 4",23)

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_Prop() | Proportional Slider
GUI_PROP(WIN,X,Y,SIZE,MIN,MAX,[HORZ],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) SIZE : size of gadget MIN,MAX : minimum and maximum values HORZ : horizontal [True] or vertical [False] [Default Horizontal] Returns : INT pointer Adds a standard proportional slider to a Window. << Back

GUI_Slider() | Slider Gadget
GUI_SLIDER(WIN,X,Y,SIZE,MIN,MAX,[HORZ],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) SIZE : size of gadget MIN,MAX : minimum and maximum values HORZ : horizontal [True] or vertical [False] [Default Horizontal] COL0,COL1 : box gradient fill colors Returns : INT pointer Adds a value slider gadget to a Window << Back

GUI_Integer() | INT Spinner/Input Gadget
GUI_INTEGER(WIN,X,Y,VAL,MIN,MAX, [LABEL$], [STEP],[W],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) STEP : gadget increase/decrease step value [Default 1] Returns : INT pointer Adds a integer spinner box to a Window - with an optional user defined step value << Back

GUI_Float() | Float Spinner/Input Gadget
GUI_FLOAT(WIN,X,Y,VAL#,MIN#,MAX#, [LABEL$], [STEP#],[W],[DEC],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) STEP# : gadget increase/decrease step value [Default .01] DEC : number of decimal places to show [Default 2] Returns : INT pointer Adds a float spinner box to a Window - with an optional user defined step value, and variable number of decimal places << Back

GUI_TxtList() | Simple Text List
GUI_TXTLIST(WIN,X,Y,W,H,LIST,[MULTI],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) LIST : previously made list MULTI : number of items that may be selected at any time [Default 1] Returns : INT pointer Adds a simple 1-dimensional text list to a Window. Example:
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,200,200,"My Window")

    ;Make a list
    MyList=GUI_List()

    ;Add some items to it....
    Itm1=GUI_LIST_ADDITM(MyList,"Item one")
    Itm2=GUI_LIST_ADDITM(MyList,"Item two")
    Itm3=GUI_LIST_ADDITM(MyList,"Item three")
    Itm4=GUI_LIST_ADDITM(MyList,"Item four")

    ;Add a text list gadget
    TxtLst=GUI_TxtList(MyWin,10,50,100,200,MyList)

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_TreeList() | Advanced Tree List
GUI_TREELIST(WIN,X,Y,W,H,LIST,[MULTI],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) LIST : previously made list MULTI : number of items that may be selected at any time [Default 1] Returns : INT pointer Adds a multi-dimensional treelist to a Window.
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,200,200,"My Window")

    ;Make a list
    MyList=GUI_List()

    ;Add a node to the list
    Node1=GUI_LIST_ADDNODE(MyList,"Node one")

    ;Add some items to it....
    Itm1=GUI_LIST_ADDITM(MyList,"Item one",Node1)
    Itm2=GUI_LIST_ADDITM(MyList,"Item two",Node1)
    Itm3=GUI_LIST_ADDITM(MyList,"Item three",Node1)
    Itm4=GUI_LIST_ADDITM(MyList,"Item four",Node1)

    ;Add a sub-node to the node :P
    Node2=GUI_LIST_ADDNODE(MyList,"Node two",Node1)

    ;Add an item to the sub node
    Itm5=GUI_LIST_ADDITM(MyList,"Item Five",Node2)

    ;Add a tree list gadget
    TreeLst=GUI_TreeList(MyWin,10,50,100,200,MyList)

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_Selector() | Drop Down Selector Box
GUI_SELECTOR(WIN,X,Y,W,LIST,[SIZE],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) LIST : previously made list SIZE : height of drop-down box in text lines [Default 5] Returns : INT pointer Adds a pull-down selector gadget to a Window. The user can set the width and height of the pull down box. Example:
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,200,200,"My Window")

    ;Make a list
    MyList=GUI_List()

    ;Add some items to it....
    Itm1=GUI_LIST_ADDITM(MyList,"Item one")
    Itm2=GUI_LIST_ADDITM(MyList,"Item two")
    Itm3=GUI_LIST_ADDITM(MyList,"Item three")
    Itm4=GUI_LIST_ADDITM(MyList,"Item four")

    ;Add a combo gadget
    Selector=GUI_Selector(MyWin,10,50,100,MyList,6)

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_ImgBox() | Image Display Box
GUI_IMGBOX(WIN,X,Y,W,H,IMAGE,[SCALE],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) IMAGE : previously loaded Image SCALE : proportionally resize image to fit box [True] or normal resize [False] [Default False] Returns : INT pointer Adds an image display box to a Window. Displays an image within a Gfx frame of set dimensions << Back

GUI_Frame() | Graphical Frame Border
GUI_FRAME(WIN,X,Y,W,H,[TEXT$],[TYPE],[TAB],[ACT],[HELP$]) TEXT$ : optional frame label TYPE : style of frame [0 to 4] [Default 0] Returns : INT pointer Adds a Gfx frame to a Window. << Back

GUI_Panel() | Expandable Gadget Panel
GUI_PANEL(WIN,X,Y,W,H,TEXT$,[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) H : height of open panel Returns : INT pointer Adds a "3D Max" style expandable panel to a Window. This panel acts as a gadget container - when it is closed then all of its attached gadgets will be hidden, when it is open then all of its gadgets will be visible. In order to use a panel you must first create all of its contained gadgets and then attach each one to the panel gadget. Note: when you attach a gadget to a panel the gadgets X and Y position will become relative to the panels position, not the Window. Also, please make sure that there is enough space within the panel to display all of its gadgets, as panel auto-resizing is not yet available. Oh....and panels are only for basic gadgets, so if you add another panel or a toolbar to a panel you may get a few problems ;) Example:
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,300,300,"My Window")

    ;Make a list
    MyList=GUI_List()

    ;Add some items to it....
    Itm1=GUI_LIST_ADDITM(MyList,"Item one")
    Itm2=GUI_LIST_ADDITM(MyList,"Item two")
    Itm3=GUI_LIST_ADDITM(MyList,"Item three")
    Itm4=GUI_LIST_ADDITM(MyList,"Item four")

    ;Add a combo gadget
    Selector=GUI_Selector(MyWin,10,10,100,MyList,6)

    ;Now add a panel gadget
    Pan=GUI_PANEL(MyWin,10,50,200,200,"Panel Gad")

    ;And attach our selector gadget to the panel
    GUI_PANEL_ATTACH(Selector,Pan)

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_ToolBar() | Scrollable ToolBar
GUI_TOOLBAR(WIN,X,Y,W,H,[HORZ],[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) HORZ : horizontal [True] or vertical [False] toolbar [Default Horizontal] Returns : INT pointer Adds a simple scrolling toolbar to a Window. As with Panels, you must first make all of your gadgets and then attach them to the toolbar. However, unlike panels, the gadgets X and Y positions are ignored when you add them to a toolbar. Toolbars allow either a single horizontal row or vertical column of gadgets to be added, so any gadgets in a toolbar will have their X and Y positions changed when they are attached. Example:
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,200,200,"My Window")

    ;Make a list
    MyList=GUI_List()

    ;Add some items to it....
    Itm1=GUI_LIST_ADDITM(MyList,"Item one")
    Itm2=GUI_LIST_ADDITM(MyList,"Item two")
    Itm3=GUI_LIST_ADDITM(MyList,"Item three")
    Itm4=GUI_LIST_ADDITM(MyList,"Item four")

    ;Add a combo gadget
    Selector=GUI_Selector(MyWin,10,50,100,MyList,6)

    ;Now make a Toolbar container
    Tool=GUI_TOOLBAR(MyWin,5,40,180,30)

    ;And attach our selector gadget
    GUI_TOOLBAR_ATTACH(Selector,Tool)

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_Tab() | Tab Gadget
GUI_TAB(WIN,W,TABNUMBER,TEXT$,[ICON$],[ALIGN],[BORDER],[ACT],[COL0],[COL1],[TCOL]) TABNUMBER : tab group that this gadget toggles - must be greater than 0 ALIGN : gadget placed at top [False] or bottom [True] of tab area [Default Top] BORDER : bordered [True] or non-bordered [False] [Default True] Returns : INT pointer Adds a Tab gadget to a Windows Tab Area. Before you add a tab gadget you must first set the Windows Tab Area - a defined space within the window where all "tabbed" gadgets will be located. The tab gadget can be aligned to either the top or bottom of the tab area. Note: to avoid errors it is best to create tabs in this order... Create window - GUI_WINDOW() Create tab area - GUI_WIN_TABAREA() Add all tab gadgets - GUI_TAB() Create all other gadgets Example:
    ;Make a window
    MyWIN=GUI_WINDOW(0,0,200,200,"My Window")

    ;Set the window tab area - all "tabbed" gadgets will now be located relative to this area
    GUI_WIN_TABAREA(MyWin,2,50,150,150)

    ;Add a tab gadget for tab 1
    Tab1=GUI_TAB(MyWin,30,1,"Tab One")

    ;Now add some buttons to tab 1
    but1=GUI_BUTTON(MyWin,10,10,100,"Button 1",1)
    but2=GUI_BUTTON(MyWin,10,25,100,"Button 2",1)

    ;Open the Window
    GUI_OPENWIN(MyWin)
<< Back

GUI_Label() | Simple Text Label
GUI_LABEL(WIN,X,Y,W,H,TEXT$,[ALIGN],[TAB],[ACT],[HELP$],[TCOL]) ALIGN : text alignment; 0[Left], 1[Center], or 2[Right] [Default Left] Returns : INT pointer Displays text within a pre-defined "box" with set alignment and word wrapping. A newline character [Chr$(13)] or a "¬" character will force a line break. << Back

GUI_TextBox() | Scrollable Text Box
GUI_TEXTBOX(WIN,X,Y,W,H,[TAB],[ACT],[HELP$],[WRAP],[TCOL],[BCOL],[COL0],[COL1]) WRAP : horizontal and vertical scrolling [False] or simple single line word-wrap [True] [Default False] BCOL : background color [Default White] Returns : INT pointer Adds a scrollable text input area to a Window. If wrap is set to True then the text will wrap when it reaches the right hand side of the gadget. If wrap is set to False then the text will not wrap but the gadget will have both horizontal and vertical scrollbars << Back

GUI_Input() | Input Box
GUI_INPUT(WIN,X,Y,W,[TEXT$],[PASSWORD],[TAB],[ACT],[HELP$],[TCOL],[BCOL],[COL0],[COL1]) TEXT$ : initial box contents [Default ""] PASSWORD : password input [True] or normal text [False] [Default False] BCOL : background color [Default White] Returns : INT pointer Adds a single line text input box to a Window. If password is set to true then the text will be hidden and *'s will be displayed instead. << Back

GUI_ImgArea() | Scrollable Image Display
GUI_IMGAREA(WIN,X,Y,W,H,IMAGE,[TAB],[ACT],[HELP$],[COL0],[COL1],[TCOL]) IMAGE : previously loaded Image Returns : INT pointer Adds a scrollable image display box to a Window. << Back

GUI_GadW(Gad) Returns : gadget width << Back

GUI_GadH(Gad) Returns : gadget height << Back

GUI_Gad_ScreenX(Gad) Returns : gadget on screen X position << Back

GUI_Gad_ScreenY(Gad) Returns : gadget on screen Y position << Back

GUI_Gad_MouseX(Gad) Returns : mouse X position relative to ImageBox Image [thanks Kanati] << Back

GUI_Gad_MouseY(Gad) Returns : mouse Y position relative to ImageBox Image [thanks Kanati] << Back

GUI_GadActive(Gad) Returns : gadget Active [True] or Inactive [False] << Back

GUI_GadOn(Gad) Returns : gadget On [True] or Off [False] << Back

GUI_GadStatus(Gad) Returns : gadget status: 0 [hidden], 1 [normal], 2 [locked] << Back

GUI_SetActive(Gad,True/False) Set a gadget Active [True] or Inactive [False] << Back

GUI_Selector_Set(Gad,Item) Set the currently selected item in a pull-down selector to the passed list item << Back

GUI_GadList(Gad) Returns : gadget list ID or 0 << Back

GUI_SetOn(Gad,True/False) Set a gadget On [True] or Off [False] << Back

GUI_Gad_Status(Gad,Status) Set a gadget status to 0 [hidden], 1 [normal] or 2 [locked] << Back

GUI_GadFloat(Gad) Returns : gadget Float value << Back

GUI_GadVal(Gad) Returns : gadget Integer value << Back

GUI_GadGroup_On(Group) Returns : gadget ID (or 0) of the ON gadget in the passed group << Back

GUI_GadGroup(Gad) Returns : gadget group << Back

GUI_GadTab(Gad) Returns : gadget tab number << Back

GUI_GadX(Gad) Returns : gadget X position << Back

GUI_GadY(Gad) Returns : gadget Y position << Back

GUI_ToolTip(Gad,Help$) Set a gadgets tooltip text to the passed Help$ string. Use a "¬" character to insert a newline ;) << Back

GUI_SetXY(Gad,X,Y) Set a gadgets position << Back

GUI_SetFloat(Gad,Val#) Set a gadgets Float value << Back

GUI_SetVal(Gad,Val) Set a gadgets Integer value << Back

GUI_GadText$(Gad) Returns : gadgets current text << Back

GUI_SetText(Gad,Text$) Set a gadgets text << Back

GUI_SetList(Gad,List) Set a gadgets list << Back

GUI_ActGroup(Group, Gad1,[Gad2],[Gad3],[Gad4],[Gad5]) Add upto 5 gadgets to an action group. Action groups allow you to activate / deactivate multiple gadgets with just one function call - gadgets may belong to more than one action group too ;) << Back

GUI_Set_ActGroup(Group,True/False) Set all gadgets in the passed action group to active [True] or inactive [False] << Back

GUI_Range(Gad,Val,Min,Max) Set a Int or Float gadgets range << Back

GUI_Prop_Range(Gad,Min,Max) Set a slider or prop gadgets range << Back

GUI_FreeGad(Gad) Delete a gadget and anything attached to it (lists, images etc) << Back

GUI_Set_Focus(Gad) Sets focus to passed gadget << Back

GUI_Focus() Returns : current focused gadget << Back

GUI_Gad_AddLine(Gad,Text$) Adds a line of text to the end of the passed input gadgets current text << Back

GUI_Block_Active(Gad,Active) Sets input gadgets Block selection flag. If True then text can be selected in this gadget [Default True] << Back

GUI_Block_Copy$() Returns : current selected text block << Back

GUI_Block_Delete() Deletes current text block << Back

GUI_Block_Insert(Gad,Text$,[Pos]) Pos: Position to insert at: Current Cursor Pos [-1], Start of text [0], or any other position [>0] [Default -1] Inserts a string into an input gadget. You can insert at the current cursor position [Default], at the start of the gadgets text, or at any position in the text. << Back

GUI_Block_Replace(Text$) Replaces the curently selected text block with the passed string << Back

GUI_Block_CursorPos() Returns : start position of text block << Back

GUI_Block_Gad() Returns : ID of text blocks gadget << Back

GUI_Input_Gad() Returns : ID of current input gadget << Back

### List Functions

GUI_List() | Create a List
GUI_LIST() Returns:INT pointer Makes a new list and returns its type pointer. Example:
    ;Make a list
    MyList=GUI_LIST()

    ;Add a few items to the list
    itm1=GUI_LIST_ADDITM(MyList,"Item 1")
    itm2=GUI_LIST_ADDITM(MyList,"Item 2")
    itm3=GUI_LIST_ADDITM(MyList,"Item 3")

    ;Add a textlist gadget which contains our list
    Lst=GUI_TXTLST(MyWin,10,50,100,100,MyList)

    ;Open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_List_AddItm() | Add a List Item
GUI_LIST_ADDITM(LIST,TXT$,DIR,[ICON$],[ACT],[VAL_INT],[VAL_TXT$], [REFRESH], [TXT_COL],[COL]) LIST : parent list TXT$ : items text DIR : items parent directory - see below ICON$ : optional icon name ACT : item active [True] or inactive [False] [Default True] VAL_INT : optional integer data held by item VAL_TXT$ : optional string data held by item TXT_COL : text color [Default Black] COL : item background color [Default White] Returns:INT pointer Add a new list item to a previously made List. Dir is the items parent directory within the list - so pass the node if it is within a sub-node. You can also store an Int and String value in an item - very useful ;) Example:
    ;Make a list
    MyList=GUI_LIST()

    ;Add a sub-node to the list
    Node1=GUI_LIST_ADDNODE(MyList,"Sub Node")

    ;Add a few items to the list

    ;One in the root node
    itm1=GUI_LIST_ADDITM(MyList,"Item 1")

    ;And two in our sub-node
    itm2=GUI_LIST_ADDITM(MyList,"Item 2",Node1)
    itm3=GUI_LIST_ADDITM(MyList,"Item 3",Node1)

    ;Add a treelist gadget which contains our list
    Lst=GUI_TREELST(MyWin,10,50,100,100,MyList)

    ;Open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_List_AddNode() | Add a Sub-Node
GUI_LIST_ADDNODE(LIST,TXT$,DIR,[ICON$],[ACT],[VAL_INT],[VAL_TXT$], [REFRESH], [TXT_COL],[COL]) LIST : parent list TXT$ : items text DIR : items parent directory - see below ICON$ : optional icon name ACT : item active [True] or inactive [False] [Default True] VAL_INT : optional integer data held by item VAL_TXT$ : optional string data held by item TXT_COL : text color [Default Black] COL : item background color [Default White] Returns:INT pointer Add a new sub-node to a previously made List. Example:
    ;Make a list
    MyList=GUI_LIST()

    ;Add a sub-node to the list
    Node1=GUI_LIST_ADDNODE(MyList,"Sub Node")

    ;Add one item to the first sub-node
    itm1=GUI_LIST_ADDITM(MyList,"Item 1",Node1)

    ;Now add a further sub-node to the first sub-node (oooh!)
    Node2=GUI_LIST_ADDNODE(MyList,"Sub Sub Node",Node1)

    ;And add a couple of items to it
    itm2=GUI_LIST_ADDITM(MyList,"Item 2",Node2)
    itm3=GUI_LIST_ADDITM(MyList,"Item 3",Node2)

    ;Add a treelist gadget which contains our list
    Lst=GUI_TREELST(MyWin,10,50,100,100,MyList)

    ;Open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_List_AddTick() | Add a Tick Box
GUI_LIST_ADDTICK(LIST,TXT$,DIR,[ACT],[VAL_INT],[VAL_TXT$], [REFRESH], [TXT_COL],[COL]) LIST : parent list TXT$ : items text DIR : items parent directory - see below ACT : item active [True] or inactive [False] [Default True] VAL_INT : optional integer data held by item VAL_TXT$ : optional string data held by item TXT_COL : text color [Default Black] COL : item background color [Default White] Returns:INT pointer Add a tick box to a previously made List. Example:
    ;Make a list
    MyList=GUI_LIST()

    ;Add a tick box to the list
    Option1=GUI_LIST_ADDTICK(MyList,"Option One")

    ;Add a treelist gadget which contains our list
    Lst=GUI_TREELST(MyWin,10,50,100,100,MyList)

    ;Open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_List_AddCheck() | Add a Grouped Check Box
GUI_LIST_ADDCHECK(LIST,TXT$,DIR,[GRP],[ACT],[VAL_INT],[VAL_TXT$], [REFRESH], [TXT_COL],[COL]) LIST : parent list TXT$ : items text DIR : items parent directory - see below GRP : items group ID - if greater than 0 then this item is in a group [Default 0] ACT : item active [True] or inactive [False] [Default True] VAL_INT : optional integer data held by item VAL_TXT$ : optional string data held by item TXT_COL : text color [Default Black] COL : item background color [Default White] Returns:INT pointer Add a grouped check box to a previously made List. If the passed group parameter is greater than 0 then this item belongs in that group - meaning that only one item in the group may be on at any one time. Example:
    ;Make a list
    MyList=GUI_LIST()

    ;Add a few check boxes to the list
    Option1=GUI_LIST_ADDCHECK(MyList,"Option One",1)
    Option2=GUI_LIST_ADDCHECK(MyList,"Option Two",1)
    Option3=GUI_LIST_ADDCHECK(MyList,"Option Three",1)

    ;Add a treelist gadget which contains our list
    Lst=GUI_TREELST(MyWin,10,50,100,100,MyList)

    ;Open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_List_AddInt() | Add an Integer Gadget
GUI_LIST_ADDINT(LIST,VAL,MIN,MAX,[TXT$],[DIR],[ICON$],[ACT],[VAL_INT],[VAL_TXT$], [REFRESH], [TXT_COL],[COL]) LIST : parent list TXT$ : items text DIR : items parent directory - see below ACT : item active [True] or inactive [False] [Default True] VAL_INT : optional integer data held by item VAL_TXT$ : optional string data held by item TXT_COL : text color [Default Black] COL : item background color [Default White] Returns:INT pointer Adds an Integer gadget to a list Example:
    ;Make a list
    MyList=GUI_LIST()

    ;Add an Integer Gadget to the list
    itm_1=GUI_List_AddInt(MyList,50,0,255,"Input:")

    ;Add a treelist gadget which contains our list
    Lst=GUI_TREELST(MyWin,10,50,100,100,MyList)

    ;Get the int items gadget ID
    itm_1_gad=GUI_Item_Gad(itm_1)

    ;Open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_List_AddFloat() | Add a Float Gadget
GUI_LIST_ADDFLOAT(LIST,VAL#,MIN#,MAX#,[TXT$],[DIR],[ICON$],[STEP#],[DECIMALS],[ACT],[VAL_INT],[VAL_TXT$], [REFRESH], [TXT_COL],[COL]) LIST : parent list TXT$ : items text DIR : items parent directory - see below ACT : item active [True] or inactive [False] [Default True] VAL_INT : optional integer data held by item VAL_TXT$ : optional string data held by item TXT_COL : text color [Default Black] COL : item background color [Default White] Returns:INT pointer Adds a Float gadget to a list Example:
    ;Make a list
    MyList=GUI_LIST()

    ;Add an Integer Gadget to the list
    itm_1=GUI_List_AddFloat(MyList,50,0,255,"Float:")

    ;Add a treelist gadget which contains our list
    Lst=GUI_TREELST(MyWin,10,50,100,100,MyList)

    ;Get the int items gadget ID
    itm_1_gad=GUI_Item_Gad(itm_1)

    ;Open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_List_AddInput() | Add an Input Gadget
GUI_LIST_ADDINPUT(LIST,TXT$,[DIR],[ICON$],[ACT],[VAL_INT],[VAL_TXT$], [REFRESH], [TXT_COL],[COL]) LIST : parent list TXT$ : items text DIR : items parent directory - see below ACT : item active [True] or inactive [False] [Default True] VAL_INT : optional integer data held by item VAL_TXT$ : optional string data held by item TXT_COL : text color [Default Black] COL : item background color [Default White] Returns:INT pointer Adds an Input gadget to a list Example:
    ;Make a list
    MyList=GUI_LIST()

    ;Add an Integer Gadget to the list
    itm_1=GUI_List_AddInput(MyList,"Input:")

    ;Add a treelist gadget which contains our list
    Lst=GUI_TREELST(MyWin,10,50,100,100,MyList)

    ;Get the int items gadget ID
    itm_1_gad=GUI_Item_Gad(itm_1)

    ;Open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_List_AddLine(List,[Dir],[Refresh],[Line Col],[Back Col]) Adds a separation line to a list << Back

GUI_List_AddIcon(List,Text$,Dir,Icon$,[Active],[Val_Int],[Val_Txt$],[Refresh],[Text Col],[Back Col]) Adds a clickable Icon item to a list. Acts like a normal Tick Box Item - but you supply the Icon Gfx. << Back

GUI_List_CountSelected(List) Returns : number of selected items in a list << Back

GUI_List_Selected(List,[Index]) Returns : ID of first selected list item or the next item after [Index] Example
    ;the following code will loop thru a list and return all
    ;selected items in it

    For INDEX=1 To GUI_LIST_NUMITEMS(MYLIST)
        Itm=GUI_LIST_SELECTED(MYLIST,INDEX)
    Next
<< Back

GUI_Item_Selected(Item) Returns : True if the item is currently selected or False if not << Back

GUI_Item_On(Item) Returns : True if the item is On or False if Off << Back

GUI_List_SetAct(Item,True/False) Set a list item active [True] or inactive [False] << Back

GUI_List_SetText(Item,Text$) Set a list items text << Back

GUI_List_SetCol(Item,Text_RGB,Back_RGB) Set a list items colors << Back

GUI_List_GetText$(Item) Returns : list item text << Back

GUI_List_ItmList(Item) Returns : list items parent list ID or 0 << Back

GUI_List_Toggle(Item,True/False) Turn a list item On/Open/Selected [True] or Off/Closed/Free [False] << Back

GUI_List_KillItm(Item) Delete a list item << Back

GUI_List_Clear(List) Delete a list << Back

GUI_Item_GetVal(Item) Returns : list items Integer Data << Back

GUI_Item_GetText$(Item) Returns : list items Text data << Back

GUI_Item_SetVal(Item,Val) Set a list items Integer data << Back

GUI_Item_SetText(Item,Text$) Set a list items Text data << Back

GUI_Item_Gad(Item) Returns : ID of items attached gadget Example:
    ;Make a list
    MyList=GUI_LIST()

    ;Add an Integer Gadget to the list
    itm_1=GUI_List_AddInput(MyList,"Input:")

    ;Add a treelist gadget which contains our list
    Lst=GUI_TREELST(MyWin,10,50,100,100,MyList)

    ;Get the int items gadget ID
    itm_1_gad=GUI_Item_Gad(itm_1)

    ;Open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_List_NumItems(List,Node[0]) Returns : number of list items in a passed node [leave as 0 for root node] << Back

GUI_List_CurPos(Item) Returns : list item current position from top of its parent node [starts from 0] << Back

GUI_Item_Pos(Item,Pos) Moves an item to a specific point in its node << Back

GUI_Item_Move(Item,Step Value [+ or -]) Move an item the specified number of steps within its node << Back

GUI_List_NewGroup() | Create a new Selection Group
GUI_LIST_NEWGROUP(LIST,MAX) LIST : parent list MAX : number of selectable items Returns:INT pointer Creates a new Item Selection Group to which you can add list items. Example:
    ;Make a list
    MyList=GUI_List()

    ;Add a node to the list
    Node1=GUI_LIST_ADDNODE(MyList,"Node one")

    ;Add some items to it....
    Itm1=GUI_LIST_ADDTICK(MyList,"Please",Node1)
    Itm2=GUI_LIST_ADDTICK(MyList,"Select",Node1)
    Itm3=GUI_LIST_ADDTICK(MyList,"Three Items",Node1)
    Itm4=GUI_LIST_ADDTICK(MyList,"From this",Node1)
    Itm5=GUI_LIST_ADDTICK(MyList,"List...",Node1)

    ;Add a Selection Group to this Node
    MyGroup=GUI_LIST_NEWGROUP(MyList,3)

    ;And add some items to the new Group
    GUI_ITEM_ADDGROUP(Itm1,MyGroup)
    GUI_ITEM_ADDGROUP(Itm2,MyGroup)
    GUI_ITEM_ADDGROUP(Itm3,MyGroup)
    GUI_ITEM_ADDGROUP(Itm4,MyGroup)
    GUI_ITEM_ADDGROUP(Itm5,MyGroup)
<< Back

GUI_Item_AddGroup() | Add Items to a group
GUI_ITEM_ADDGROUP(ITEM,GROUP) GROUP : selection group ID Adds an item to a pre-created Selection Group. Example:
    ;Make a list
    MyList=GUI_List()

    ;Add a node to the list
    Node1=GUI_LIST_ADDNODE(MyList,"Node one")

    ;Add some items to it....
    Itm1=GUI_LIST_ADDTICK(MyList,"Please",Node1)
    Itm2=GUI_LIST_ADDTICK(MyList,"Select",Node1)
    Itm3=GUI_LIST_ADDTICK(MyList,"Three Items",Node1)
    Itm4=GUI_LIST_ADDTICK(MyList,"From this",Node1)
    Itm5=GUI_LIST_ADDTICK(MyList,"List...",Node1)

    ;Add a Selection Group to this Node
    MyGroup=GUI_LIST_NEWGROUP(MyList,3)

    ;And add some items to the new Group
    GUI_ITEM_ADDGROUP(Itm1,MyGroup)
    GUI_ITEM_ADDGROUP(Itm2,MyGroup)
    GUI_ITEM_ADDGROUP(Itm3,MyGroup)
    GUI_ITEM_ADDGROUP(Itm4,MyGroup)
    GUI_ITEM_ADDGROUP(Itm5,MyGroup)
<< Back

GUI_List_Item() | Step thru an List/Node
GUI_LIST_ITEM(LIST,[NODE],[POS]) LIST : parent list NODE : optional Node ID [Default Root-Node 0] POS : position of item Returns:INT Item ID Returns the ID of the Item at position POS in the passed List/Node Example:
    ;Make a list
    MyList=GUI_List()

    ;Add a node to the list
    Node1=GUI_LIST_ADDNODE(MyList,"Node one")

    ;Add some items to it....
    Itm1=GUI_LIST_ADDTICK(MyList,"Please",Node1)
    Itm2=GUI_LIST_ADDTICK(MyList,"Select",Node1)
    Itm3=GUI_LIST_ADDTICK(MyList,"Three Items",Node1)
    Itm4=GUI_LIST_ADDTICK(MyList,"From this",Node1)
    Itm5=GUI_LIST_ADDTICK(MyList,"List...",Node1)

    ;Add a Selection Group to this Node
    MyGroup=GUI_LIST_NEWGROUP(MyList,3)

    ;And add some items to the new Group
    GUI_ITEM_ADDGROUP(Itm1,MyGroup)
    GUI_ITEM_ADDGROUP(Itm2,MyGroup)
    GUI_ITEM_ADDGROUP(Itm3,MyGroup)
    GUI_ITEM_ADDGROUP(Itm4,MyGroup)
    GUI_ITEM_ADDGROUP(Itm5,MyGroup)

    ;Step thru our list and print out the item text and types
    For INDEX=1 To GUI_LIST_NUMITEMS(MYLIST,NODE1)
      XL_ITM=GUI_LIST_ITEM(MYLIST,NODE1,INDEX)
      Text 0,Y,GUI_LIST_GETTEXT(XL_ITM)+" "+GUI_ITEM_TYPE(XL_ITM)
      Y=Y+16
    Next
<< Back

GUI_Item_Type() | Returns Item Type
GUI_ITEM_Type(ITEM) Returns:INT Item TYPE Returns a value depending on the type of item passed. Example:
    ;Make a list
    MyList=GUI_List()

    ;Add a node to the list
    Node1=GUI_LIST_ADDNODE(MyList,"Node one")

    ;Add some items to it....
    Itm1=GUI_LIST_ADDTICK(MyList,"Please",Node1)
    Itm2=GUI_LIST_ADDTICK(MyList,"Select",Node1)
    Itm3=GUI_LIST_ADDTICK(MyList,"Three Items",Node1)
    Itm4=GUI_LIST_ADDTICK(MyList,"From this",Node1)
    Itm5=GUI_LIST_ADDTICK(MyList,"List...",Node1)

    ;Add a Selection Group to this Node
    MyGroup=GUI_LIST_NEWGROUP(MyList,3)

    ;And add some items to the new Group
    GUI_ITEM_ADDGROUP(Itm1,MyGroup)
    GUI_ITEM_ADDGROUP(Itm2,MyGroup)
    GUI_ITEM_ADDGROUP(Itm3,MyGroup)
    GUI_ITEM_ADDGROUP(Itm4,MyGroup)
    GUI_ITEM_ADDGROUP(Itm5,MyGroup)

    ;Step thru our list and print out the item text and types
    For INDEX=1 To GUI_LIST_NUMITEMS(MYLIST,NODE1)
      XL_ITM=GUI_LIST_ITEM(MYLIST,NODE1,INDEX)
      Text 0,Y,GUI_LIST_GETTEXT(XL_ITM)+" "+GUI_ITEM_TYPE(XL_ITM)
      Y=Y+16
    Next
<< Back

GUI_Item_Icon() | Returns Item's Icon
GUI_ITEM_ICON$(ITEM) Returns:STRING$ Icon Name$ << Back

GUI_Item_SetIcon() | Set an Item's Icon
GUI_ITEM_SETICON(ITEM,ICON$) Sets an Item's Icon to the passed one. << Back

### Menu Functions

GUI_WinMenu() | Get Windows Menu
GUI_WINMENU(WIN) Returns :INT pointer Returns a Windows menubar Menu. All main "menubar" menus (eg File, Edit, Insert) must have this menu as their parent menu. Example :
    ;Make a window
    MyWin=GUI_WINDOW(0,0,200,200,"My Window")

    ;Get the windows menubar menu
    WinMenu=GUI_WINMENU(MyWin)

    ;Make a File Menu
    mnu_File=GUI_MENU(WinMenu,"File")

    ;Add a menu item to it
    itm_New=GUI_MENU_ITEM(mnu_File,"New")

    ;Refresh the menu
    GUI_MENU_REFRESH(mnu_FILE)

    ;Open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_Menu_Refresh() | Update a Menu
GUI_MENU_REFRESH(MENU) Use when you have finished creating or updating a menu so that all of the menus Gfx may be redrawn. Example :
    ;Make a menu
    mnu_File=GUI_MENU(GUI_WINMENU(MyWin),"File")

    ;Add an item to it
    itm_New=GUI_MENU_ITEM(mnu_File,"New")

    ;We have finished making the menu - so we need to update its gfx
    GUI_MENU_REFRESH(mnu_File)
<< Back

GUI_Menu() | Create a Menu
GUI_MENU(PARENT,TEXT$,[ACTIVE],[COL]) PARENT : menus parent menu TEXT$ : menus title ACTIVE : menu active [Default True] COL : menu background color Returns :INT pointer Creates a new main menu and returns a pointer. Parent should contain this menus' parent menu or 0 if it has no parent. To add a root menu to a windows' menubar then you must use GUI_WinMenu() to find the menus' parent. Example :
    ;Make a Window
    MyWin=GUI_WINDOW(-1,-1,300,200,"Window...")

    ;Find out the window menubars menu
    mnu_bar=GUI_WINMENU(MyWin)

    ;Add a File menu to the menubar
    mnu_File=GUI_MENU(mnu_Bar,"File")

    ;Add a couple of items to it...
    itm_New=GUI_MENU_ITEM(mnu_File,"New")
    itm_Load=GUI_MENU_ITEM(mnu_File,"Load")
    itm_Save=GUI_MENU_ITEM(mnu_File,"Save")

    ;Add a menu line
    GUI_MENU_LINE(mnu_File)

    ;And a final item
    itm_Quit=GUI_MENU_ITEM(mnu_File,"Quit")

    ;Now refresh the menu
    GUI_MENU_REFRESH(mnu_File)

    ;And open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_SubMenu() | Create a Sub Menu
GUI_SUBMENU(MENU) MENU : sub-menus parent menu Returns :INT pointer Creates a new sub-menu attached to the passed parent menu. Don't forget to call GUI_Menu_Refresh() to draw this menu too ;) Example :
    ;Make a Window
    MyWin=GUI_WINDOW(-1,-1,300,200,"Window...")

    ;Find out the window menubars menu
    mnu_bar=GUI_WINMENU(MyWin)

    ;Add a File menu to the menubar
    mnu_File=GUI_MENU(mnu_Bar,"File")

    ;Add a sub menu to the File menu
    mnu_New=GUI_SUBMENU(mnu_File)

    ;Add a couple of items to it...
    itm_NewPro=GUI_MENU_ITEM(mnu_New,"Project")
    itm_NewPage=GUI_MENU_ITEM(mnu_New,"Page")
    itm_NewWin=GUI_MENU_ITEM(mnu_New,"Window")

    ;Add a pointer to the sub menu in the File menu
    itm_New=GUI_MENU_SUB(mnu_File,"New..",mnu_New)

    ;Add a menu line
    GUI_MENU_LINE(mnu_File)

    ;And a final item
    itm_Quit=GUI_MENU_ITEM(mnu_File,"Quit")

    ;Now refresh the menus
    GUI_MENU_REFRESH(mnu_File)
    GUI_MENU_REFRESH(mnu_New)

    ;And open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_Menu_Item() | Add a Menu Item
GUI_MENU_ITEM(MENU,TEXT$,[ACTIVE],[ICON$],[COL]) MENU : items menu TEXT$ : items text ACTIVE : item active [True] or inactive [False] [Default True] ICON$ : optional Icon to display next to items text COL : text color [Default Black] Returns :INT pointer Adds a standard menu item to a menu. << Back

GUI_Menu_Sub() | Add a Menu Pointer
GUI_MENU_SUB(MENU,TEXT$,SUB_MENU,[ACTIVE],[ICON$],[COL]) MENU : sub-menus parent menu TEXT$ : items text SUB_MENU : menu which this item will open ACTIVE : active [True] or inactive [False] [Default True] ICON$ : optional icon COL : text color [Default Black] Returns :INT pointer Adds a sub-menu item to a menu. When the mouse is over this item then the passed sub-menu will open. Example :
    ;Make a Window
    MyWin=GUI_WINDOW(-1,-1,300,200,"Window...")

    ;Find out the window menubars menu
    mnu_bar=GUI_WINMENU(MyWin)

    ;Add a File menu to the menubar
    mnu_File=GUI_MENU(mnu_Bar,"File")

    ;Add a sub menu to the File menu
    mnu_New=GUI_SUBMENU(mnu_File)

    ;Add a couple of items to it...
    itm_NewPro=GUI_MENU_ITEM(mnu_New,"Project")
    itm_NewPage=GUI_MENU_ITEM(mnu_New,"Page")
    itm_NewWin=GUI_MENU_ITEM(mnu_New,"Window")

    ;Add a pointer to the sub menu in the File menu
    itm_New=GUI_MENU_SUB(mnu_File,"New..",mnu_New)

    ;Add a menu line
    GUI_MENU_LINE(mnu_File)

    ;And a final item
    itm_Quit=GUI_MENU_ITEM(mnu_File,"Quit")

    ;Now refresh the menus
    GUI_MENU_REFRESH(mnu_File)
    GUI_MENU_REFRESH(mnu_New)

    ;And open the window
    GUI_OPENWIN(MyWin)
<< Back

GUI_Menu_Tick() | Add a Menu Check Item
GUI_MENU_TICK(MENU,TEXT$,[ON],[ACTIVE],[COL]) MENU : items menu TEXT$ : items text ON : item On [True] or Off [False] [Default Off] ACTIVE : item active [True] or inactive [False] [Default True] COL : text color [Default Black] Returns :INT pointer Adds a standard check box menu item to a menu. << Back

GUI_Menu_Radio() | Add a Grouped Menu Check Item
GUI_MENU_RADIO(MENU,TEXT$,GROUP,[ACTIVE],[COL]) MENU : items menu TEXT$ : items text GROUP : items Group number ACTIVE : item active [True] or inactive [False] [Default True] COL : text color [Default Black] Returns :INT pointer Adds a grouped check box menu item to a menu. Only one item in a group may be on at any one time. << Back

GUI_Menu_Line() | Add a Divider Line
GUI_MENU_LINE(MENU) MENU : items menu Adds a divider line to a menu. << Back

GUI_Menu_Space() | Add a Divider Space
GUI_MENU_SPACE(MENU) MENU : items menu Adds a divider space to a menu. << Back

GUI_Menu_Act(Menu,True/False) Activate [True] or Deactivate [False] a whole menu << Back

GUI_Menu_ItmAct(Item,True/False) Activate [True] or Deactivate [False] a menu item << Back

GUI_Menu_GetOn(Item) Returns : menu item On [True] or Off [False] << Back

GUI_Menu_SetOn(Item,True/False) Set a menu item On [True] or Off [False] << Back

GUI_FreeMenu(Menu) Delete a menu << Back

### 3D Functions

GUI_3DPort() | Add a 3D ViewPort Gadget
GUI_3DPORT(WIN,X,Y,W,H,TEXT$,[CAM],[WIRE],[TAB]) TEXT$ : 3D ports label CAM : optional camera WIRE : camera wire mode [Default False] Returns :INT pointer Adds a 3D viewport to a window. Any camera attached to this gadget will have a viewport of W and H. If no camera is passed then a new camera is created. << Back

GUI_Render3D() | Renders a 3D Viewport
GUI_RENDER3D(PORT,[TWEEN]) PORT : 3D port gadget TWEEN : optional Renderworld() tween Renders a 3D ports' camera onto its window. << Back

GUI_SetWire() | Sets WireFrame mode
GUI_SETWIRE(PORT,WIRE) PORT : 3D port gadget WIRE : wireframe On [True] or Off [False] Sets a 3D Ports wireframe mode << Back

GUI_Gadwire(Port) Returns : 3D ports wireframe mode: On [True] or Off [False] << Back

GUI_GetCam(Port) Returns : 3D ports camera << Back

GUI_SetCam(Gad,Camera,[Free_Old_Camera]) Set a 3D ports camera. Camera Viewport will be resized to fit gadget dimensions. If Free_Old_Camera is set to True then the previous camera will be deleted. << Back

## License Info

XLnt ii General EULA

- The author retains the copyright on the original XLnt II source files, the functions contained within them, help files and all other files included in the distribution pack. With the sole exception of the XPlugin.bb include file
- The author of XLnt II accepts no liability for any program coded using XLnt II
- The author accepts no responsibility for any damage to/or loss of property or data caused through the use or miss use of this program
- XLnt II may not be distributed by any means without the authors consent
- Future features, content, price, and licenses may change

Non-Registered License

- Users who have not registered are limited in their use of the XLnt ii GUI library. They may not release ANY software created using, or containing, XLnt ii code. This restriction applies to all programs and source code - FreeWare, Public Domain, ShareWare, or Commercial Software.
- Non-registered users may make feature/update requests but registered users' requests will always take precedence.
- Only registered users will have access to the most current features and updates.

By reading the above statements or by using Xlnt II you have agreed to the above terms/conditions
Registered License
Users who register have no restrictions placed upon them - they may release any code created with XLnt ii, including full commercial releases! The author of XLnt will claim no ownership of said releases. Registered users will also be entitled to free upgrades, plugins etc so it pays to register!
To register visit XLnt Homepage - the price is only $15 US - its a bargain!!!

## Greets

Hello and thanks to....
Robin, Snarty, xMystik, Ben G, John H, Kefir, and everyone at #blitzbasic and #blitzcoder!!!

## Contact me..

XLnt Email :Stew Yapp
XLnt WebSite :Register and Info
Xlnt Forum :Please drop in

## History

XLnt ii v1.4 | [15.05.04]
Release Type : Public A Long awaited updated. Bug fixes, text input re-write, and a few new features. New Stuff Window Skins - simple window skinning added TitleBar Min/Max - double clicking on the title bar will Min/Max a window Line Wrap - put back in text boxes [still a little quirky tho] EV_Gad_InputGad() - returns currently active Input gadget EV_Gad_ClearText() - clear input gadget text GUI_Gad_MouseX() - returns mouse X.position in an imagebox [thanks Kanati] GUI_Gad_MouseY() - returns mouse Y.position in an imagebox [thanks Kanati] Item Toggle - manually selecting an item will now open all its parent nodes Selection Groups - force selection of 1 or more list items GUI_List_CountSelected() - returns number of selected items in a list/node GUI_List_Item() - step thru a node's items GUI_Item_Type() - return an item's type BUG: ToolTip - fixed BUG: GUI_List_Toggle() - fixed BUG: Input/Tabs - fixed

XLnt ii v1.3 | [20.11.03]
Release Type : registered users only Added loads of new features - the main one being Text Block Copy & Paste. Also fixed a few bugs. New Stuff GUI_Gad_Screenx() and GUI_Gad_Screeny() used to return actual onscreen gadget locations. GUI() - now contains optional draw mouse flag GUI_DrawMouse() - draw mouse image function GUI_Set_Focus() - set current focused gadget GUI_Focus() - returns current focused gadget GUI_List_AddIcon() - New List Item. Same as a Tick Box but you supply the icon GUI_Gad_Resize() - resize a gadget GUI_Input_Gad() - returns current input gad GUI_Gad_AddLine() - adds a new line of text to a text gadget GUI_Block_Gad() - returns gad that contains selected text block GUI_Block_Active() - toggle a gadgets text block selection abilities GUI_Block_Copy() - returns currently selected text block GUI_Block_Delete() - deletes currently selected text block GUI_Block_Insert() - insert a text block at any point in a gadget GUI_Block_Replace() - replace current text block with a new string GUI_Block_CursorPos() - returns start position of text block in a gadget GUI_InvCol - New Variable. Contains color of Inverted Text Block

XLnt ii v1.2 | [26.09.03]
Release Type : registered users only Added quite a few new things - mostly to do with lists, and fixed a load of stupid bugs [thanks Ben]. New Stuff Window resize tab - click the little triangle to resize [cheers Wendell] GUI_List_AddInt() - add an integer gadget to a list GUI_List_AddFloat() - add a float gadget to a list GUI_List_AddInput() - add text input gadget to a list GUI_Item_Gad() - get a list items gadget GUI_Item_Icon() - get an items icon GUI_Item_SetIcon() - set an items icon GUI_Icon_Mask() - set icons mask color Added [Max] flag to GUI_ShowWin()

XLnt ii v1.1b | [26.09.03]
Release Type : Public Public release of v1.1 - contains a few bug fixes [thanks Ben] and the window resize tab.

XLnt ii v1.1 | [14.09.03]
Release Type : registered users only First update - contains new features and bug fixes. Bug Fixes "Object does not exist" when clicking on the minimize button "Font does not exist" never had this error, but was reported by one user Holding down a gadget and moving mouse over resize area - doesn't force window resize anymore EV_GAD_HIT() was one step behind clicks - fixed New stuff GUI_GadW() : returns gadget width GUI_GadH() : returns gadget height GUI_List_AddLine() : adds a separation line to a list GUI_List_CountSelected() : returns number of selected items in a list GUI_List_Selected() : returns selected item in a list GUI_Item_Selected() : returns if the passed item is selected GUI_Item_On() : returns if the passed item is On or Off

XLnt ii v1.0 | [05.09.03]
Release Type : Public Initial public release of XLnt ii