To edit a dialog box that is being run, press Ctrl+Shift+Space or right-click on the top of a form and select Edit. If you press Ctrl+Shift+Space while the Properties dialog box is active, you edit the Properties dialog box. Double-click the system menu to close the edited Properties form. Some UNIX window managers do not close windows when you double-click on the system menu.

The bitmaps on the left of the Properties dialog box are used to create controls. Hover over a bitmap to display the function of a bitmap. There are two methods for creating a control. The first method is to double-click the left mouse button on the bitmap of the control that you want to create. This places a new control in the middle of the selected form.

The Picture Box and Frame controls enable you to place controls inside of them. To do so, select Window → Properties or, use the show_properties command.

To use the other method for creating a control, complete the following steps:

To delete a control, select the control(s) to remove, then press Backspace or Delete.

To set properties, complete the following steps:

Select the control with which you want to align the other controls. Select the other controls with Shift+ LButton. Double-click the left mouse button on one of the properties x or y to align the controls in the x or y direction. Press Enter on the value in the Properties combo box.

To size controls, use one of the following methods:

To move controls, use one of the following methods:

The table below shows a list of miscellaneous button and key assignments that can be used when the form is active.

The table below shows the miscellaneous menu items.

A form is the outer window of a dialog box. The objects within the dialog box are called controls. The form also refers to the entire dialog box. A new form can be created by using one of the following methods:

OR

Click on the form being edited and press Ctrl+S.

Set the form name and the control names (name property in Properties list box) before adding code to the dialog box because these names are referenced in the code. Prefix your control names using the letters ctl so that they are easily recognizable. To add an event handler, complete the following steps:

After performing the above steps, the dialog editor inserts an event function definition into your source file and places your cursor in the function.

This dialog box is displayed when there is no code for the event you have chosen and the control is using an inherited event table. You will see this dialog box if you copy a control with existing code, paste elsewhere and then double-click on the new instance of the control.

The following options are available on the dialog:

To run the current dialog box that you are editing, click Macro → Load and Run Form or use the run_selected command. This loads the code, loads the dialog box, and runs the dialog box. To close the dialog box, double-click on the system menu (some UNIX window managers do not close windows when you double-click on the system menu) or press Ctrl+Shift+Space (in the running version of your dialog box and not the edited copy). Press Ctrl+Shift+Space when any dialog box is running to edit it (this includes the Properties dialog box).

Display the dialog box from the command line by typing show <FormName>. To display the dialog box modally enter show -modal <FormName> on the command line. For more information about this command, see Displaying Dialog Boxes. Dialog box templates and compiled macros are stored in the state file vslick.sta (UNIX: vslick.stu).

The example code below shows how to write a command that displays a dialog box. This is used when binding a command to a key that displays a dialog box.

#include "slick.sh"
_command void run_form1()
{
    // The -modal option displays other windows while the dialog box
    // is displayed.
    show("-modal form1");
}

#include "slick.sh"
defeventtab form1
// Code for OK button.
ctlok.lbutton_up()
{
    // Close the dialog box and return a value. The _delete_window 
    // function allows modal dialog boxes to return a value. For
    // more information, see "Displaying Dialog Boxes"  below. Each object 
    // in the dialog box will receive an on_destroy event.
    // NOTE: If "" is a valid return value. Return 1 here and store
    // your results in the global _param1 variable.
    p_active_form._delete_window("return value");
    // Statements after closing a dialog box are executed.
}

        
    show cmdline 
      
      

        
    show (cmdline [,arg1 [,arg2 ... [argN]]])
      
      

        
    [option] form_name
      
      

// This example requires that you create a form called form1 with a 
// command button and load this file.
#include "slick.sh"
_command mytest()
{
    result=show("-modal form1");
    if (result=="") {
       return(COMMAND_CANCELLED_RC);
    }
    message("_param1="_param1" _param2="_param2);
}
 
defeventtab form1
ctlcommand1.on_create()
{
    // Global variable _param1.._param10 are defined in "slick.sh" to
    // allow for multiple strings to be returned in separate variables.
    // Alternatively, if the return strings do not contain spaces, you
    // could concatenate them together with a space and use the parse 
    // built-in to easily separate them.
    _param1="string1";
    _param2="string2";
    // Close the dialog box and indicate that the dialog box was not canceled.
    // Each object in the dialog box will receive an on_destroy event.
    p_active_form._delete_window(1);
}

// This example requires that you create a form called form1 with a
// command button and load this file.
#include "slick.sh"
_command void mytest()
{
    show("-modal form1","param1 to on_create", "param2 to on_create");
}
 
defeventtab form1
ctlcommand1.on_create(_str arg1="", _str arg2="")
{
    _str tmpArg1 , tmpArg2;
   tmpArg1=arg(1);
   tmpArg2=arg(2);
   _message_box("arg1="arg1" arg2="arg2);
   _message_box("tmpArg1="tmpArg1" tmpArg2="tmpArg2);
}

#include "slick.sh"
defmain()
{
    index=find_index("form1",oi2type(OI_FORM));
    if (!index) {
       messageNwait("form1 not found");
       return(1);
    }
    // Can specify name table index instead of name. When show is called
    // without the "-modal" option, the positive window id (instance handle)
    // of the form created is returned.
    form_wid=show("-hidden -nocenter "index);
    if (form_wid<0) {
       return(1);
    }
    // Place the form at the top left corner of the display.
    form_wid.p_x=form_wid.p_y=0;
    // Make the form visible.
    form_wid.p_visible=1;
    return(0);
}

If you do not want the MDI window or any other form to get focus when your dialog box is displayed, specify the -modaloption to the show command (see Displaying Dialog Boxes). When the -modal option is given, other forms, including the MDI window, are disabled (p_enabled=0) until the form is closed. In addition, the _delete_window function can be used to return a value (see the previous example).

Modeless example:

#include "slick.sh"
defmain()
{
    // When show is called without the "-modal" option, the positive
    // window id (instance handle) of the form created is returned.
    form_wid=show("-hidden -nocenter form1");
    if (form_wid<0) {
       return(1);
    }
    // Place the form at the top left corner of the display.
    form_wid.p_x=form_wid.p_y=0;
    // Make the form visible.
    form_wid.p_visible=1;
    return(0);
}

If you need to display a status dialog box during processing, you might require a modeless dialog box so control is returned to you. However, it is a best practice to disable all other dialog boxes including the MDI window during processing.

Advanced modeless example:

#include "slick.sh"
static typeless gcancel;
_command void test()
{
    // Show the form modeless so there is no modal wait.
    form1_wid=show("form1");
    // Disable all forms by the one with p_window_id==form_wid. A space-
    // delimited string of disabled form window ids is returned.
    disabled_wid_list=_enable_non_modal_forms(0,form_wid);
    gcancel=0;
    for (;;) {
       // Read mouse, key, and all other events until none are left
       // or until the variable gcancel becomes true.
       process_events(gcancel);
       if (gcancel) break;
       // Do your processing here.
    }
    // Enable the forms that were disabled.
    enable_non_modal_forms(1,0,disabled_wid_list);
    form1_wid._delete_window();
}
defeventtab form1;
ctlcancel.lbutton_up()
{
    gcancel=1;
}

The parent window of a dialog box form has two uses. First, the dialog box remains on top of the parent window. Use the show command and specify the -app option if you want to allow a modeless dialog box be displayed behind the MDI window. The -mdi option of the show command can be used to make sure a dialog box stays on top of the MDI window.

Command line examples:

      
    show -app _calc_form
    show -mdi -new _calc_form
    
    

Second, the parent window is used by some dialog boxes (such as the Print and Spelling dialog boxes) to determine on which buffer to operate. This permits the dialog boxes to support the editor control. To do this, they call the _form_parent function during an on_create event to get the window id of the window which contains the buffer to be operated on. These dialog boxes only support certain parent windows. For example, the Print dialog box will not run correctly if the -app option of the show command is used.