Creating Forms in SKILL Code: A Practical Guide

Why should we create graphical user interfaces (GUIs) for our tools?

GUIs offer a user-friendly and intuitive way to interact with software, making complex tasks more accessible and efficient. They provide visual feedback and structured workflows, reducing errors and enhancing productivity, allowing users to focus on their work rather than memorizing commands. GUIs also simplify training, making it easier for new users to explore features without extensive documentation.

SKILL code offers powerful ways to develop GUIs (or forms) within the Virtuoso environment. Cadence provides comprehensive documentation for all their hi* functions, which handle form development, along with examples of various features:

• Worked example using all available SKILL UI fields (Cadence Support Portal)
• Advanced GUI building using dynamically resizable layout forms (Cadence Support Portal)

In this guide, we'll walk through the GUI development process using a practical example. We'll use layout forms and define several callbacks, with the full code attached at the end.

1. Layout Forms

There are two main approaches for field placement in a GUI: using pixels (hiCreateAppForm()) and using layout forms (hiCreateLayoutForm()). Placing fields using pixels gives you freedom in choosing exact x, y coordinates and a size for your fields. Despite the fact that it’s intuitive, the major problem with this approach is it’s not scalable. The more complex the GUI is, the harder it’s to add a new field to it. Imagine you have to add a new field to a complex GUI such this:

Complex GUI example

In the by-pixel approach, in addition to a new field, you’ll have to change the location of other fields manually. Which will end up in long and tedious work. A more modern and scalable approach is using layout forms. At first, it’s not as intuitive as defining locations by pixels, but after you get hold of it, it turns into a powerful skill in GUI development. Layout forms allow you to build GUIs with container layouts (like Lego). When you have to add a new field, you just add it to the required layout and other fields will move automatically.

So for scalable and robust GUIs it is recommended to use layout forms approach.

Now, let’s get to our practical example.

2. GUI Template

Start by building a GUI template. Our GUI will receive the top cell's library, cell, and view names as input and display library and cell names used in the top cell's hierarchy.

Here, we define labels, string fields, buttons and a report field, and use form layouts to organize the fields into sections. To display the GUI in SKILL, create the form and display it with these two commands:

Display GUI in SKILL

Tip: If you change anything in the form’s creation function, you have to re-create the form to see the changes. Re-run the two functions above.

3. Map Callback

Map callbacks are used to perform additional setup or customization when a form is instantiated and displayed. They are particularly useful for initializing form fields, setting default values, adjusting field sizes, or performing any other setup tasks that need to occur when the form is first displayed.

Define a map callback for our GUI to change the size of "Browse" and "Get Hierarchy Info" buttons and initialize top cell info fields if a cell view is currently open.

Here, we must instantiate the form before modifying its fields’ sizes. Additionally, we assign values to our string fields. Set the function as a map callback by adding the ?mapCB keyword to the hiCreateLayoutForm() function.

Note: You can define field callbacks either as a symbol, like 'myFunc, or as a string, such as "myFunc()". Using a symbol automatically passes default arguments to the function based on the field, with each field's callback having its own set of default arguments. In case of the ?mapCB, it sends the current form object as an argument. Setting callbacks as strings is useful when you need to pass different arguments to a function.

Callback example

4. Modify Callback

A modify callback in SKILL is a function that is triggered whenever the user changes the value of a string field, such as by typing a new value. This callback is executed immediately when a change is detected in the field, but before the change is displayed.

The modify callback function can return one of three values:

• t: If the function returns t, the changes made to the field are allowed and displayed as they are entered.
• nil: If the function returns nil, the changes are not allowed, and the original value of the field is retained.
• value: If the function returns a string, this value replaces the current value of the field.

This mechanism provides a powerful way to validate input, update other fields, or trigger additional logic based on the new value, enabling dynamic and responsive interactions within SKILL forms.

Add a modify callback to the library string field to validate the entered name and highlight the field if incorrect.

Here, we attempt to retrieve a library object using its name and adjust the string field's highlight based on the result. Set the function as a modify callback by adding the ?modifyCallback keyword to the library's hiCreateStringField() function.

Note: To practice, you can add modify callbacks to the cell and view string fields.

5. Button Callback - Browse

Instead of manually entering library/cell/view names, we can define a callback to invoke the Library Manager for selection.

Here, we use the built-in ddsSyncWithForm() function, which requires a form, an action to perform, and fields’ symbols to update when selection is done.

Add this function to the browse button as a callback. Use the string approach this time, as we want to send only the form as an argument.

6. Button Callback - Run

The run button executes the main algorithm. Here, we’ll use the getLibrariesCellsUsedIn() function, described in the “Extracting Library and Cell Names from a Top Cell Hierarchy Using SKILL Code” guide.

Define a function to run the algorithm, get results, and display them in a table.

Here, first of all, we check the input, and if it’s incorrect we exit the function in an early stage by return(). To use the return() function to exit your function at a desired stage, you’ll have to wrap your code in the prog() scope, instead of the let(). Next, we get the cell view object, using the provided library/cell/view names.

After this, we use the cell view object to get libraries and cells names that are in use in this cell view’s hierarchy. When we get the result, we need to process it to be able to add to the report field, our results table. And finally, we add the processed results to the report field.

Add this function to the run button as a callback.

Now, when you provide correct library/cell/view names and click the run button, you'll see the extracted results in the report field.

7. Conclusion

In this guide, we've explored how to use layout forms, define various callbacks, highlight string fields, display error messages, invoke the Library Manager, and utilize let() and prog() scopes. To further explore, check out Cadence guides on creating forms and experiment with different fields and parameters.

8. Full code