<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
-
<html>
<head>
<meta name="generator" content=
- "HTML Tidy for Linux (vers 25 March 2009), see www.w3.org">
-
+ "HTML Tidy for HTML5 for Linux version 5.6.0">
<title>NCURSES Programming HOWTO</title>
<meta name="GENERATOR" content=
"Modular DocBook HTML Stylesheet Version 1.79">
</head>
-
<body class="ARTICLE" bgcolor="#FFFFFF" text="#000000" link=
"#0000FF" vlink="#840084" alink="#0000FF">
<div class="ARTICLE">
<div class="AFFILIATION">
<div class="ADDRESS">
<p class="ADDRESS"><code class="EMAIL"><<a href=
- "mailto:ppadala@gmail.com">ppadala@gmail.com</a>></code></p>
+ "mailto:ppadala@gmail.com">ppadala@gmail.com</a>></code>
+ </p>
</div>
</div>
<p class="PUBDATE">v1.9, 2005-06-20<br></p>
<div class="REVHISTORY">
- <table width="100%" border="0">
+ <table width="100%" border="0" summary="revisions">
<tr>
<th align="left" valign="top" colspan="3"><b>Revision
- History</b></th>
+ History</b>
+ </th>
</tr>
<tr>
- <td align="left">Revision 1.9</td>
+ <td align="left">Revision 2.0</td>
+ <td align="left">2022-12-03</td>
+ <td align="left">Revised by: dickey</td>
+ </tr>
- <td align="left">2005-06-20</td>
+ <tr>
+ <td align="left" colspan="3">Fixes for the sample
+ programs, Correct documentation errata.</td>
+ </tr>
+ <tr>
+ <td align="left">Revision 1.9</td>
+ <td align="left">2005-06-20</td>
<td align="left">Revised by: ppadala</td>
</tr>
<tr>
<td align="left">Revision 1.8</td>
-
<td align="left">2005-06-17</td>
-
<td align="left">Revised by: ppadala</td>
</tr>
<tr>
<td align="left">Revision 1.7.1</td>
-
<td align="left">2002-06-25</td>
-
<td align="left">Revised by: ppadala</td>
</tr>
<tr>
<td align="left">Revision 1.7</td>
-
<td align="left">2002-06-25</td>
-
<td align="left">Revised by: ppadala</td>
</tr>
<tr>
<td align="left">Revision 1.6.1</td>
-
<td align="left">2002-02-24</td>
-
<td align="left">Revised by: ppadala</td>
</tr>
<tr>
<td align="left">Revision 1.6</td>
-
<td align="left">2002-02-16</td>
-
<td align="left">Revised by: ppadala</td>
</tr>
<tr>
<td align="left">Revision 1.5</td>
-
<td align="left">2002-01-05</td>
-
<td align="left">Revised by: ppadala</td>
</tr>
<tr>
<td align="left">Revision 1.3.1</td>
-
<td align="left">2001-07-26</td>
-
<td align="left">Revised by: ppadala</td>
</tr>
<tr>
<td align="left">Revision 1.3</td>
-
<td align="left">2001-07-24</td>
-
<td align="left">Revised by: ppadala</td>
</tr>
<tr>
<td align="left">Revision 1.2</td>
-
<td align="left">2001-06-05</td>
-
<td align="left">Revised by: ppadala</td>
</tr>
<tr>
<td align="left">Revision 1.1</td>
-
<td align="left">2001-05-22</td>
-
<td align="left">Revised by: ppadala</td>
</tr>
<div>
<div class="ABSTRACT">
- <a name="AEN67" id="AEN67"></a>
-
+ <a name="AEN72" id="AEN72"></a>
<p><span class="emphasis"><i class="EMPHASIS">This
document is intended to be an "All in One" guide for
programming with ncurses and its sister libraries. We
complex form manipulation. No prior experience in ncurses
is assumed. Send comments to <a href=
"mailto:ppadala@gmail.com" target="_top">this
- address</a></i></span></p>
+ address</a></i></span>
+ </p>
</div>
</div>
+
<hr>
</div>
<div class="TOC">
<dl>
- <dt><b>Table of Contents</b></dt>
+ <dt><b>Table of Contents</b>
+ </dt>
<dt>1. <a href="#INTRO">Introduction</a></dt>
<dt>6.1. <a href="#ADDCHCLASS">addch() class of
functions</a></dt>
- <dt>6.2. <a href="#AEN298">mvaddch(), waddch() and
+ <dt>6.2. <a href="#AEN303">mvaddch(), waddch() and
mvwaddch()</a></dt>
<dt>6.3. <a href="#PRINTWCLASS">printw() class of
<dt>6.3.2. <a href="#WPRINTWMVWPRINTW">wprintw()
and mvwprintw</a></dt>
- <dt>6.3.3. <a href="#VWPRINTW">vwprintw()</a></dt>
+ <dt>6.3.3. <a href="#VWPRINTW">vw_printw()</a></dt>
<dt>6.3.4. <a href="#SIMPLEPRINTWEX">A Simple
printw example</a></dt>
<dt>7.2.2. <a href="#WSCANWMVWSCANW">wscanw() and
mvwscanw()</a></dt>
- <dt>7.2.3. <a href="#VWSCANW">vwscanw()</a></dt>
+ <dt>7.2.3. <a href="#VWSCANW">vw_scanw()</a></dt>
</dl>
</dd>
cables. The terminals could be configured by sending a series
of bytes. All the capabilities (such as moving the cursor to
a new location, erasing part of the screen, scrolling the
- screen, changing modes etc.) of terminals could be accessed
+ screen, changing modes, etc.) of terminals could be accessed
through these series of bytes. These control seeuqnces are
usually called escape sequences, because they start with an
escape(0x1B) character. Even today, with proper emulation, we
<p>Suppose you wanted to print a line in color. Try typing
this on your console.</p>
- <pre class="PROGRAMLISTING">
-echo "^[[0;31;40mIn Color"
-</pre>
+ <pre class="PROGRAMLISTING">echo "^[[0;31;40mIn Color"</pre>
<p>The first character is an escape character, which looks
like two characters ^ and [. To be able to print it, you have
to press CTRL+V and then the ESC key. All the others are
normal printable characters. You should be able to see the
string "In Color" in red. It stays that way and to revert
back to the original mode type this.</p>
- <pre class="PROGRAMLISTING">
-echo "^[[0;37;40m"
-</pre>
+ <pre class="PROGRAMLISTING">echo "^[[0;37;40m"</pre>
<p>Now, what do these magic characters mean? Difficult to
comprehend? They might even be different for different
terminals. So the designers of UNIX invented a mechanism
<p>You might be wondering, what the import of all this
technical gibberish is. In the above scenario, every
application program is supposed to query the terminfo and
- perform the necessary stuff (sending control characters
+ perform the necessary stuff (sending control characters,
etc.). It soon became difficult to manage this complexity
and this gave birth to 'CURSES'. Curses is a pun on the
name "cursor optimization". The Curses library forms a
wrapper over working with raw terminal codes, and provides
highly flexible and efficient API (Application Programming
Interface). It provides functions to move the cursor,
- create windows, produce colors, play with mouse etc. The
+ create windows, produce colors, play with mouse, etc. The
application programs need not worry about the underlying
terminal capabilities.</p>
<p>A detailed history of NCURSES can be found in the NEWS
file from the source distribution. The current package is
- maintained by <a href="mailto:dickey@his.com" target=
- "_top">Thomas Dickey</a>. You can contact the maintainers
- at <a href="mailto:bug-ncurses@gnu.org" target=
+ maintained by <a href="mailto:dickey@invisible-island.net"
+ target="_top">Thomas Dickey</a>. You can contact the
+ maintainers at <a href="mailto:bug-ncurses@gnu.org" target=
"_top">bug-ncurses@gnu.org</a>.</p>
</div>
<p>NCURSES not only creates a wrapper over terminal
capabilities, but also gives a robust framework to create
nice looking UI (User Interface)s in text mode. It provides
- functions to create windows etc. Its sister libraries
+ functions to create windows, etc. Its sister libraries
panel, menu and form provide an extension to the basic
curses library. These libraries usually come along with
curses. One can create applications that contain multiple
on.</p>
<p><span class="emphasis"><i class="EMPHASIS">Compiling the
- package</i></span></p>
+ package</i></span>
+ </p>
<p>NCURSES can be obtained from <a href=
"ftp://ftp.gnu.org/pub/gnu/ncurses/ncurses.tar.gz" target=
"_top">ftp://ftp.gnu.org/pub/gnu/ncurses/ncurses.tar.gz</a>
or any of the ftp sites mentioned in <a href=
- "http://www.gnu.org/order/ftp.html" target=
- "_top">http://www.gnu.org/order/ftp.html</a>.</p>
+ "https://www.gnu.org/order/ftp.html" target=
+ "_top">https://www.gnu.org/order/ftp.html</a>.</p>
<p>Read the README and INSTALL files for details on to how
to install it. It usually involves the following
operations.</p>
- <pre class="PROGRAMLISTING">
- tar zxvf ncurses<version>.tar.gz # unzip and untar the archive
+
+ <pre class=
+ "PROGRAMLISTING"> tar zxvf ncurses<version>.tar.gz # unzip and untar the archive
cd ncurses<version> # cd to the directory
./configure # configure the build according to your
# environment
make # make it
su root # become root
- make install # install it
-</pre>
-
+ make install # install it</pre>
<p><span class="emphasis"><i class="EMPHASIS">Using the
- RPM</i></span></p>
+ RPM</i></span>
+ </p>
<p>NCURSES RPM can be found and downloaded from <a href=
- "http://rpmfind.net" target="_top">http://rpmfind.net</a> .
- The RPM can be installed with the following command after
+ "https://rpmfind.net" target="_top">https://rpmfind.net</a>
+ . The RPM can be installed with the following command after
becoming root.</p>
- <pre class="PROGRAMLISTING">
- rpm -i <downloaded rpm>
-</pre>
+
+ <pre class=
+ "PROGRAMLISTING"> rpm -i <downloaded rpm></pre>
</div>
<div class="SECT2">
<p>All the programs in the document are available in zipped
form <a href=
- "http://www.tldp.org/HOWTO/NCURSES-Programming-HOWTO/ncurses_programs.tar.gz"
+ "https://www.tldp.org/HOWTO/NCURSES-Programming-HOWTO/ncurses_programs.tar.gz"
target="_top">here</a>. Unzip and untar it. The directory
structure looks like this.</p>
- <pre class="PROGRAMLISTING">
-ncurses
+
+ <pre class="PROGRAMLISTING">ncurses
|
|----> JustForFun -- just for fun programs
|----> basics -- basic programs
| by Anuradha Ratnaweera)
|----> Makefile -- the top level Makefile
|----> README -- the top level README file. contains instructions
- |----> COPYING -- copyright notice
-</pre>
-
+ |----> COPYING -- copyright notice</pre>
<p>The individual directories contain the following
files.</p>
- <pre class="PROGRAMLISTING">
-Description of files in each directory
+
+ <pre class=
+ "PROGRAMLISTING">Description of files in each directory
--------------------------------------
JustForFun
|
menus
|
|----> menu_attrib.c -- Usage of menu attributes
- |----> menu_item_data.c -- Usage of item_name() etc.. functions
+ |----> menu_item_data.c -- Usage of item_name(), etc. functions
|----> menu_multi_column.c -- Creates multi columnar menus
|----> menu_scroll.c -- Demonstrates scrolling capability of menus
|----> menu_simple.c -- A simple menu accessed by arrow keys
|----> panel_simple.c -- A simple panel example
perl
- |----> 01-10.pl -- Perl equivalents of first ten example programs
-</pre>
-
+ |----> 01-10.pl -- Perl equivalents of first ten example programs</pre>
<p>There is a top level Makefile included in the main
directory. It builds all the files and puts the
ready-to-use exes in demo/exe directory. You can also do
<p>If you prefer browsing individual programs, point your
browser to <a href=
- "http://tldp.org/HOWTO/NCURSES-Programming-HOWTO/ncurses_programs/"
+ "https://tldp.org/HOWTO/NCURSES-Programming-HOWTO/ncurses_programs/"
target=
- "_top">http://tldp.org/HOWTO/NCURSES-Programming-HOWTO/ncurses_programs/</a></p>
+ "_top">https://tldp.org/HOWTO/NCURSES-Programming-HOWTO/ncurses_programs/</a></p>
<p>All the programs are released under the same license
that is used by ncurses (MIT-style). This gives you the
<h3 class="SECT2"><a name="OTHERFORMATS" id=
"OTHERFORMATS">1.6. Other Formats of the document</a></h3>
- <p>This howto is also availabe in various other formats on
+ <p>This howto is also available in various other formats on
the tldp.org site. Here are the links to other formats of
this document.</p>
<ul>
<li>
<p><a href=
- "http://www.ibiblio.org/pub/Linux/docs/HOWTO/other-formats/pdf/NCURSES-Programming-HOWTO.pdf"
+ "https://www.ibiblio.org/pub/Linux/docs/HOWTO/other-formats/pdf/NCURSES-Programming-HOWTO.pdf"
target="_top">Acrobat PDF Format</a></p>
</li>
<li>
<p><a href=
- "http://www.ibiblio.org/pub/Linux/docs/HOWTO/other-formats/ps/NCURSES-Programming-HOWTO.ps.gz"
+ "https://www.ibiblio.org/pub/Linux/docs/HOWTO/other-formats/ps/NCURSES-Programming-HOWTO.ps.gz"
target="_top">PostScript Format</a></p>
</li>
<li>
<p><a href=
- "http://www.ibiblio.org/pub/Linux/docs/HOWTO/other-formats/html/NCURSES-Programming-HOWTO-html.tar.gz"
+ "https://www.ibiblio.org/pub/Linux/docs/HOWTO/other-formats/html/NCURSES-Programming-HOWTO-html.tar.gz"
target="_top">In Multiple HTML pages</a></p>
</li>
<li>
<p><a href=
- "http://www.ibiblio.org/pub/Linux/docs/HOWTO/other-formats/html_single/NCURSES-Programming-HOWTO.html"
+ "https://www.ibiblio.org/pub/Linux/docs/HOWTO/other-formats/html_single/NCURSES-Programming-HOWTO.html"
target="_top">In One big HTML format</a></p>
</li>
</ul>
<p>If above links are broken or if you want to experiment
with sgml read on.</p>
- <pre class="PROGRAMLISTING">
- Get both the source and the tar,gzipped programs, available at
+
+ <pre class=
+ "PROGRAMLISTING"> Get both the source and the tar,gzipped programs, available at
http://cvsview.tldp.org/index.cgi/LDP/howto/docbook/
NCURSES-HOWTO/NCURSES-Programming-HOWTO.sgml
http://cvsview.tldp.org/index.cgi/LDP/howto/docbook/
NCURSES-ONE-BIG-FILE.html
for ps, you would use
htmldoc --size universal -t ps --firstpage p1 -f <output file name.ps>
- NCURSES-ONE-BIG-FILE.html
-</pre>
-
+ NCURSES-ONE-BIG-FILE.html</pre>
<p>See <a href=
- "http://www.tldp.org/LDP/LDP-Author-Guide/" target=
+ "https://www.tldp.org/LDP/LDP-Author-Guide/" target=
"_top">LDP Author guide</a> for more details. If all else
- failes, mail me at <a href="ppadala@gmail.com" target=
+ fails, mail me at <a href="ppadala@gmail.com" target=
"_top">ppadala@gmail.com</a></p>
</div>
</div>
<hr>
<h3 class="SECT2"><a name="COMPILECURSES" id=
- "COMPILECURSES">2.1. Compiling With the NCURSES
- Library</a></h3>
+ "COMPILECURSES">2.1. Compiling With the NCURSES Library</a></h3>
<p>To use ncurses library functions, you have to include
ncurses.h in your programs. To link the program with
ncurses the flag -lncurses should be added.</p>
- <pre class="PROGRAMLISTING">
- #include <ncurses.h>
+
+ <pre class="PROGRAMLISTING"> #include <ncurses.h>
.
.
.
- compile and link: gcc <program file> -lncurses
-</pre>
-
+ compile and link: gcc <program file> -lncurses</pre>
<div class="EXAMPLE">
<a name="BHW" id="BHW"></a>
+ <p><b>Example 1. The Hello World !!! Program</b>
+ </p>
- <p><b>Example 1. The Hello World !!! Program</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <ncurses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <curses.h>
int main()
{
endwin(); /* End curses mode */
return 0;
-}</span>
-</pre>
+}</span></pre>
</div>
</div>
initscr() has to be called. There are functions which can be
called after this initialization to customize our curses
session. We may ask the curses system to set the terminal in
- raw mode or initialize color or initialize the mouse etc..
+ raw mode or initialize color or initialize the mouse, etc.
Let's discuss some of the functions that are normally called
immediately after initscr();</p>
"LITERAL">noecho()</tt> switches off echoing. The reason
you might want to do this is to gain more control over
echoing or to suppress unnecessary echoing while taking
- input from the user through the getch() etc. functions.
+ input from the user through the getch(), etc. functions.
Most of the interactive programs call <tt class=
"LITERAL">noecho()</tt> at initialization and do the
echoing of characters in a controlled manner. It gives the
keypad()</a></h3>
<p>This is my favorite initialization function. It enables
- the reading of function keys like F1, F2, arrow keys etc.
+ the reading of function keys like F1, F2, arrow keys, etc.
Almost every interactive program enables this, as arrow
keys are a major part of any User Interface. Do <tt class=
"LITERAL">keypad(stdscr, TRUE)</tt> to enable this feature
<div class="EXAMPLE">
<a name="BINFU" id="BINFU"></a>
-
<p><b>Example 2. Initialization Function Usage
- example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <ncurses.h>
+ example</b>
+ </p>
+
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <curses.h>
int main()
{ int ch;
if(ch == KEY_F(1)) /* Without keypad enabled this will */
printw("F1 Key pressed");/* not get to us either */
/* Without noecho() some ugly escape
- * charachters might have been printed
+ * characters might have been printed
* on screen */
else
{ printw("The pressed key is ");
endwin(); /* End curses mode */
return 0;
-}</span>
-</pre>
+}</span></pre>
</div>
<p>This program is self-explanatory. But I used functions
creates a default window named <tt class=
"LITERAL">stdscr</tt> which represents your 80x25 (or the
size of window in which you are running) screen. If you are
- doing simple tasks like printing few strings, reading input
+ doing simple tasks like printing few strings, reading input,
etc., you can safely use this single window for all of your
purposes. You can also create windows and call functions
which explicitly work on the specified window.</p>
<p>For example, if you call</p>
- <pre class="PROGRAMLISTING">
- printw("Hi There !!!");
- refresh();
-</pre>
+ <pre class="PROGRAMLISTING"> printw("Hi There !!!");
+ refresh();</pre>
<p>It prints the string on stdscr at the present cursor
position. Similarly the call to refresh(), works on stdscr
only.</p>
<p>Say you have created <a href="#WINDOWS">windows</a> then
you have to call a function with a 'w' added to the usual
function.</p>
- <pre class="PROGRAMLISTING">
- wprintw(win, "Hi There !!!");
- wrefresh(win);
-</pre>
+ <pre class="PROGRAMLISTING"> wprintw(win, "Hi There !!!");
+ wrefresh(win);</pre>
<p>As you will see in the rest of the document, naming of
functions follow the same convention. For each function there
usually are three more functions.</p>
- <pre class="PROGRAMLISTING">
- printw(string); /* Print on stdscr at present cursor position */
+
+ <pre class=
+ "PROGRAMLISTING"> printw(string); /* Print on stdscr at present cursor position */
mvprintw(y, x, string);/* Move to (y, x) then print string */
wprintw(win, string); /* Print on window win at present cursor position */
/* in the window */
mvwprintw(win, y, x, string); /* Move to (y, x) relative to window */
- /* co-ordinates and then print */
-</pre>
-
+ /* co-ordinates and then print */</pre>
<p>Usually the w-less functions are macros which expand to
corresponding w-function with stdscr as the window
parameter.</p>
</li>
</ol>
- <p>These functions can be used interchangeably and it's a
+ <p>These functions can be used interchangeably and it is a
matter of style as to which class is used. Let's see each one
in detail.</p>
For example, you want to print a character ch(of type
char) bold and underlined, you would call addch() as
below.</p>
- <pre class="PROGRAMLISTING">
- addch(ch | A_BOLD | A_UNDERLINE);
-</pre>
+
+ <pre class=
+ "PROGRAMLISTING"> addch(ch | A_BOLD | A_UNDERLINE);</pre>
</li>
<li>
<p>Additionally, <tt class="LITERAL">curses</tt> provides
some special characters for character-based graphics. You
can draw tables, horizontal or vertical lines, etc. You can
- find all avaliable characters in the header file <tt class=
+ find all available characters in the header file <tt class=
"LITERAL">ncurses.h</tt>. Try looking for macros beginning
with <tt class="LITERAL">ACS_</tt> in this file.</p>
</div>
<div class="SECT2">
<hr>
- <h3 class="SECT2"><a name="AEN298" id="AEN298">6.2.
+ <h3 class="SECT2"><a name="AEN303" id="AEN303">6.2.
mvaddch(), waddch() and mvwaddch()</a></h3>
<p><tt class="LITERAL">mvaddch()</tt> is used to move the
cursor to a given point, and then print. Thus, the
calls:</p>
- <pre class="PROGRAMLISTING">
- move(row,col); /* moves the cursor to row<span class=
-"emphasis"><i class=
-"EMPHASIS">th</i></span> row and col<span class="emphasis"><i class="EMPHASIS">th</i></span> column */
- addch(ch);
-</pre>can be replaced by
- <pre class="PROGRAMLISTING">
- mvaddch(row,col,ch);
-</pre>
+ <pre class=
+ "PROGRAMLISTING"> move(row,col); /* moves the cursor to row<span class="emphasis"><i class="EMPHASIS">th</i></span> row and col<span class="emphasis"><i class="EMPHASIS">th</i></span> column */
+ addch(ch);</pre>can be replaced by
+
+ <pre class="PROGRAMLISTING"> mvaddch(row,col,ch);</pre>
<p><tt class="LITERAL">waddch()</tt> is similar to
<tt class="LITERAL">addch()</tt>, except that it adds a
character into the given window. (Note that <tt class=
<hr>
<h4 class="SECT3"><a name="WPRINTWMVWPRINTW" id=
- "WPRINTWMVWPRINTW">6.3.2. wprintw() and
- mvwprintw</a></h4>
+ "WPRINTWMVWPRINTW">6.3.2. wprintw() and mvwprintw</a></h4>
<p>These two functions are similar to above two except
that they print in the corresponding window given as
<hr>
<h4 class="SECT3"><a name="VWPRINTW" id="VWPRINTW">6.3.3.
- vwprintw()</a></h4>
+ vw_printw()</a></h4>
<p>This function is similar to <tt class=
"LITERAL">vprintf()</tt>. This can be used when variable
<div class="EXAMPLE">
<a name="BPREX" id="BPREX"></a>
+ <p><b>Example 3. A Simple printw example</b>
+ </p>
- <p><b>Example 3. A Simple printw example</b></p>
- <pre class="PROGRAMLISTING">
-<span class=
-"INLINEMEDIAOBJECT">#include <ncurses.h> /* ncurses.h includes stdio.h */
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <curses.h>
#include <string.h>
int main()
{
char mesg[]="Just a string"; /* message to be appeared on the screen */
int row,col; /* to store the number of rows and *
- * the number of colums of the screen */
+ * the number of columns of the screen */
initscr(); /* start the curses mode */
getmaxyx(stdscr,row,col); /* get the number of rows and columns */
mvprintw(row/2,(col-strlen(mesg))/2,"%s",mesg);
endwin();
return 0;
-}</span>
-</pre>
+}</span></pre>
</div>
<p>Above program demonstrates how easy it is to use
<hr>
<h4 class="SECT3"><a name="VWSCANW" id="VWSCANW">7.2.3.
- vwscanw()</a></h4>
+ vw_scanw()</a></h4>
<p>This function is similar to <tt class=
"LITERAL">vscanf()</tt>. This can be used when a variable
<div class="EXAMPLE">
<a name="BSCEX" id="BSCEX"></a>
+ <p><b>Example 4. A Simple scanw example</b>
+ </p>
- <p><b>Example 4. A Simple scanw example</b></p>
- <pre class="PROGRAMLISTING">
-<span class=
-"INLINEMEDIAOBJECT">#include <ncurses.h> /* ncurses.h includes stdio.h */
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <curses.h>
#include <string.h>
int main()
char mesg[]="Enter a string: "; /* message to be appeared on the screen */
char str[80];
int row,col; /* to store the number of rows and *
- * the number of colums of the screen */
+ * the number of columns of the screen */
initscr(); /* start the curses mode */
getmaxyx(stdscr,row,col); /* get the number of rows and columns */
mvprintw(row/2,(col-strlen(mesg))/2,"%s",mesg);
endwin();
return 0;
-}</span>
-</pre>
+}</span></pre>
</div>
</div>
</div>
<div class="EXAMPLE">
<a name="BSIAT" id="BSIAT"></a>
+ <p><b>Example 5. A Simple Attributes example</b>
+ </p>
- <p><b>Example 5. A Simple Attributes example</b></p>
- <pre class="PROGRAMLISTING">
-<span class=
-"INLINEMEDIAOBJECT">/* pager functionality by Joseph Spainhour" <spainhou@bellsouth.net> */
-#include <ncurses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">/* pager functionality by Joseph Spainhour" <spainhou@bellsouth.net> */
+#include <curses.h>
#include <stdlib.h>
int main(int argc, char *argv[])
getmaxyx(stdscr, row, col); /* find the boundaries of the screeen */
while((ch = fgetc(fp)) != EOF) /* read the file till we reach the end */
{
- getyx(stdscr, y, x); /* get the current curser position */
+ getyx(stdscr, y, x); /* get the current cursor position */
if(y == (row - 1)) /* are we are at the end of the screen */
{
printw("<-Press Any Key->"); /* tell the user to press a key */
* switch bold on */
{
attron(A_BOLD); /* cut bold on */
- getyx(stdscr, y, x); /* get the current curser position */
+ getyx(stdscr, y, x); /* get the current cursor position */
move(y, x - 1); /* back up one space */
printw("%c%c", '/', ch); /* The actual printing is done here */
}
endwin(); /* End curses mode */
fclose(fp);
return 0;
-}</span>
-</pre>
+}</span></pre>
</div>
<p>Don't worry about all those initialization and other crap.
<p>Let's get into more details of attributes. The functions
<tt class="LITERAL">attron(), attroff(), attrset()</tt> ,
and their sister functions <tt class=
- "LITERAL">attr_get()</tt> etc.. can be used to switch
+ "LITERAL">attr_get()</tt>, etc. can be used to switch
attributes on/off , get attributes and produce a colorful
display.</p>
attributes and switch them on or off, respectively. The
following video attributes, which are defined in
<curses.h> can be passed to these functions.</p>
- <pre class="PROGRAMLISTING">
-
+
+ <pre class="PROGRAMLISTING">
A_NORMAL Normal display (no highlight)
A_STANDOUT Best highlighting mode of the terminal.
A_UNDERLINE Underlining
A_ALTCHARSET Alternate character set
A_CHARTEXT Bit-mask to extract a character
COLOR_PAIR(n) Color-pair number n
-
-</pre>
-
+ </pre>
<p>The last one is the most colorful one :-) Colors are
explained in the <a href="#color" target="_top">next
sections</a>.</p>
<p>We can OR(|) any number of above attributes to get a
combined effect. If you wanted reverse video with blinking
characters you can use</p>
- <pre class="PROGRAMLISTING">
- attron(A_REVERSE | A_BLINK);
-</pre>
+
+ <pre class=
+ "PROGRAMLISTING"> attron(A_REVERSE | A_BLINK);</pre>
</div>
<div class="SECT2">
<h3 class="SECT2"><a name="ATTRFUNCS" id="ATTRFUNCS">8.4.
attr_ functions</a></h3>
- <p>There are series of functions like attr_set(), attr_on
- etc.. These are similar to above functions except that they
+ <p>There are series of functions like attr_set(), attr_on,
+ etc. These are similar to above functions except that they
take parameters of type <tt class=
"LITERAL">attr_t</tt>.</p>
</div>
<p>We can give -1 as the character count to update till end
of line. If you want to change attributes of characters
from current position to end of line, just use this.</p>
- <pre class="PROGRAMLISTING">
- chgat(-1, A_REVERSE, 0, NULL);
-</pre>
+ <pre class=
+ "PROGRAMLISTING"> chgat(-1, A_REVERSE, 0, NULL);</pre>
<p>This function is useful when changing attributes for
characters that are already on the screen. Move to the
character from which you want to change and change the
<div class="EXAMPLE">
<a name="BWICH" id="BWICH"></a>
+ <p><b>Example 6. Chgat() Usage example</b>
+ </p>
- <p><b>Example 6. Chgat() Usage example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <ncurses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <curses.h>
int main(int argc, char *argv[])
{ initscr(); /* Start curses mode */
* Third parameter number of characters to update. -1 means till
* end of line
* Forth parameter is the normal attribute you wanted to give
- * to the charcter
+ * to the character
* Fifth is the color index. It is the index given during init_pair()
* use 0 if you didn't want color
* Sixth one is always NULL
getch();
endwin(); /* End curses mode */
return 0;
-}</span>
-</pre>
+}</span></pre>
</div>
<p>This example also introduces us to the color world of
<tt class="LITERAL">newwin()</tt>. It doesn't create any
thing on the screen actually. It allocates memory for a
structure to manipulate the window and updates the
- structure with data regarding the window like it's size,
- beginy, beginx etc.. Hence in curses, a window is just an
+ structure with data regarding the window such as its size,
+ beginy, beginx, etc. Hence in curses, a window is just an
abstraction of an imaginary window, which can be
manipulated independent of other parts of screen. The
function newwin() returns a pointer to structure WINDOW,
- which can be passed to window related functions like
- wprintw() etc.. Finally the window can be destroyed with
+ which can be passed to window related functions such as
+ wprintw(), etc. Finally the window can be destroyed with
delwin(). It will deallocate the memory associated with the
window structure.</p>
</div>
<div class="EXAMPLE">
<a name="BWIBO" id="BWIBO"></a>
+ <p><b>Example 7. Window Border example</b>
+ </p>
- <p><b>Example 7. Window Border example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <ncurses.h>
-
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <curses.h>
WINDOW *create_newwin(int height, int width, int starty, int startx);
void destroy_win(WINDOW *local_win);
void destroy_win(WINDOW *local_win)
{
/* box(local_win, ' ', ' '); : This won't produce the desired
- * result of erasing the window. It will leave it's four corners
+ * result of erasing the window. It will leave its four corners
* and so an ugly remnant of window.
*/
wborder(local_win, ' ', ' ', ' ',' ',' ',' ',' ',' ');
*/
wrefresh(local_win);
delwin(local_win);
-}</span>
-</pre>
+}</span></pre>
</div>
</div>
<h3 class="SECT2"><a name="BORDEREXEXPL" id=
"BORDEREXEXPL">9.3. Explanation</a></h3>
- <p>Don't scream. I know it's a big example. But I have to
+ <p>Don't scream. I know it is a big example. But I have to
explain some important things here :-). This program
creates a rectangular window that can be moved with left,
right, up, down arrow keys. It repeatedly creates and
border around the window with the characters given to it as
the 4 corner points and the 4 lines. To put it clearly, if
you have called wborder as below:</p>
- <pre class="PROGRAMLISTING">
- wborder(win, '|', '|', '-', '-', '+', '+', '+', '+');
-</pre>
- <p>it produces some thing like</p>
- <pre class="PROGRAMLISTING">
- +------------+
+ <pre class=
+ "PROGRAMLISTING"> wborder(win, '|', '|', '-', '-', '+', '+', '+', '+');</pre>
+ <p>it produces something like</p>
+
+ <pre class="PROGRAMLISTING"> +------------+
| |
| |
| |
| |
| |
| |
- +------------+
-</pre>
+ +------------+</pre>
</div>
<div class="SECT2">
<div class="EXAMPLE">
<a name="BOTBO" id="BOTBO"></a>
+ <p><b>Example 8. More border functions</b>
+ </p>
- <p><b>Example 8. More border functions</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <ncurses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <curses.h>
typedef struct _win_border_struct {
chtype ls, rs, ts, bs,
refresh();
-}</span>
-</pre>
+}</span></pre>
</div>
</div>
</div>
<div class="SECT1">
<hr>
- <h2 class="SECT1"><a name="COLOR" id="COLOR">10.
- Colors</a></h2>
+ <h2 class="SECT1"><a name="COLOR" id="COLOR">10. Colors</a></h2>
<div class="SECT2">
<h3 class="SECT2"><a name="COLORBASICS" id=
<div class="EXAMPLE">
<a name="BSICO" id="BSICO"></a>
+ <p><b>Example 9. A Simple Color example</b>
+ </p>
- <p><b>Example 9. A Simple Color example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <ncurses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <stdlib.h>
+#include <string.h>
+#include <curses.h>
void print_in_middle(WINDOW *win, int starty, int startx, int width, char *string);
int main(int argc, char *argv[])
mvwprintw(win, y, x, "%s", string);
refresh();
}
-</span>
-</pre>
+</span></pre>
</div>
<p>As you can see, to start using color, you should first
<p>Curses initializes all the colors supported by terminal
when start_color() is called. These can be accessed by the
define constants like <tt class="LITERAL">COLOR_BLACK</tt>
- etc. Now to actually start using colors, you have to define
- pairs. Colors are always used in pairs. That means you have
- to use the function <tt class="LITERAL">init_pair()</tt> to
- define the foreground and background for the pair number
- you give. After that that pair number can be used as a
- normal attribute with <tt class=
- "LITERAL">COLOR_PAIR()</tt>function. This may seem to be
- cumbersome at first. But this elegant solution allows us to
- manage color pairs very easily. To appreciate it, you have
- to look into the the source code of "dialog", a utility for
- displaying dialog boxes from shell scripts. The developers
- have defined foreground and background combinations for all
- the colors they might need and initialized at the
- beginning. This makes it very easy to set attributes just
- by accessing a pair which we already have defined as a
- constant.</p>
+ , etc. Now to actually start using colors, you have to
+ define pairs. Colors are always used in pairs. That means
+ you have to use the function <tt class=
+ "LITERAL">init_pair()</tt> to define the foreground and
+ background for the pair number you give. After that that
+ pair number can be used as a normal attribute with
+ <tt class="LITERAL">COLOR_PAIR()</tt>function. This may
+ seem to be cumbersome at first. But this elegant solution
+ allows us to manage color pairs very easily. To appreciate
+ it, you have to look into the the source code of "dialog",
+ a utility for displaying dialog boxes from shell scripts.
+ The developers have defined foreground and background
+ combinations for all the colors they might need and
+ initialized at the beginning. This makes it very easy to
+ set attributes just by accessing a pair which we already
+ have defined as a constant.</p>
<p>The following colors are defined in <tt class=
"LITERAL">curses.h</tt>. You can use these as parameters
for various color functions.</p>
- <pre class="PROGRAMLISTING">
- COLOR_BLACK 0
+
+ <pre class="PROGRAMLISTING"> COLOR_BLACK 0
COLOR_RED 1
COLOR_GREEN 2
COLOR_YELLOW 3
COLOR_BLUE 4
COLOR_MAGENTA 5
COLOR_CYAN 6
- COLOR_WHITE 7
-</pre>
+ COLOR_WHITE 7</pre>
</div>
<div class="SECT2">
curses initially. Say you wanted to lighten the intensity
of red color by a minuscule. Then you can use this function
as</p>
- <pre class="PROGRAMLISTING">
- init_color(COLOR_RED, 700, 0, 0);
- /* param 1 : color name
- * param 2, 3, 4 : rgb content min = 0, max = 1000 */
-</pre>
+ <pre class=
+ "PROGRAMLISTING"> init_color(COLOR_RED, 700, 0, 0);
+ /* param 1 : color name
+ * param 2, 3, 4 : rgb content min = 0, max = 1000 */</pre>
<p>If your terminal cannot change the color definitions,
the function returns ERR. The function <tt class=
"LITERAL">can_change_color()</tt> can be used to find out
sensitive to key presses or the mouse actions done by the
user. Let's deal with the keys first.</p>
- <p>As you have seen in almost all of the above examples,
- it's very easy to get key input from the user. A simple way
+ <p>As you have seen in almost all of the above examples, it
+ is very easy to get key input from the user. A simple way
of getting key presses is to use <tt class=
"LITERAL">getch()</tt> function. The cbreak mode should be
enabled to read keys when you are interested in reading
individual key hits rather than complete lines of text
(which usually end with a carriage return). keypad should
- be enabled to get the Functions keys, arrow keys etc. See
+ be enabled to get the Functions keys, arrow keys, etc. See
the initialization section for details.</p>
<p><tt class="LITERAL">getch()</tt> returns an integer
keys portable and easy to manage.</p>
<p>For example, if you call getch() like this</p>
- <pre class="PROGRAMLISTING">
- int ch;
- ch = getch();
-</pre>
+ <pre class="PROGRAMLISTING"> int ch;
+ ch = getch();</pre>
<p>getch() will wait for the user to press a key, (unless
you specified a timeout) and when user presses a key, the
corresponding integer is returned. Then you can check the
match against the keys you want.</p>
<p>The following code piece will do that job.</p>
- <pre class="PROGRAMLISTING">
- if(ch == KEY_LEFT)
- printw("Left arrow is pressed\n");
-</pre>
+ <pre class="PROGRAMLISTING"> if(ch == KEY_LEFT)
+ printw("Left arrow is pressed\n");</pre>
<p>Let's write a small program which creates a menu which
can be navigated by up and down arrows.</p>
</div>
<div class="EXAMPLE">
<a name="BSIKE" id="BSIKE"></a>
+ <p><b>Example 10. A Simple Key Usage example</b>
+ </p>
- <p><b>Example 10. A Simple Key Usage example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <stdio.h>
-#include <ncurses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <curses.h>
#define WIDTH 30
#define HEIGHT 10
choice = highlight;
break;
default:
- mvprintw(24, 0, "Charcter pressed is = %3d Hopefully it can be printed as '%c'", c, c);
+ mvprintw(24, 0, "Character pressed is = %3d Hopefully it can be printed as '%c'", c, c);
refresh();
break;
}
return 0;
}
-
void print_menu(WINDOW *menu_win, int highlight)
{
int x, y, i;
}
wrefresh(menu_win);
}
-</span>
-</pre>
+</span></pre>
</div>
</div>
</div>
<p>Before you do any thing else, the events you want to
receive have to be enabled with <tt class=
"LITERAL">mousemask()</tt>.</p>
- <pre class="PROGRAMLISTING">
- mousemask( mmask_t newmask, /* The events you want to listen to */
- mmask_t *oldmask) /* The old events mask */
-</pre>
+ <pre class=
+ "PROGRAMLISTING"> mousemask( mmask_t newmask, /* The events you want to listen to */
+ mmask_t *oldmask) /* The old events mask */</pre>
<p>The first parameter to above function is a bit mask of
events you would like to listen. By default, all the events
are turned off. The bit mask <tt class=
events.</p>
<p>The following are all the event masks:</p>
- <pre class="PROGRAMLISTING">
- Name Description
+
+ <pre class="PROGRAMLISTING"> Name Description
---------------------------------------------------------------------
BUTTON1_PRESSED mouse button 1 down
BUTTON1_RELEASED mouse button 1 up
BUTTON_CTRL control was down during button state change
BUTTON_ALT alt was down during button state change
ALL_MOUSE_EVENTS report all button state changes
- REPORT_MOUSE_POSITION report mouse movement
-</pre>
+ REPORT_MOUSE_POSITION report mouse movement</pre>
</div>
<div class="SECT2">
<tt class="LITERAL">getmouse()</tt>.</p>
<p>The code approximately looks like this:</p>
- <pre class="PROGRAMLISTING">
- MEVENT event;
+
+ <pre class="PROGRAMLISTING"> MEVENT event;
ch = getch();
if(ch == KEY_MOUSE)
if(getmouse(&event) == OK)
. /* Do some thing with the event */
.
- .
-</pre>
-
+ .</pre>
<p>getmouse() returns the event into the pointer given to
- it. It's a structure which contains</p>
- <pre class="PROGRAMLISTING">
- typedef struct
+ it. It is a structure which contains</p>
+
+ <pre class="PROGRAMLISTING"> typedef struct
{
short id; /* ID to distinguish multiple devices */
int x, y, z; /* event coordinates */
mmask_t bstate; /* button state bits */
- }
-</pre>
-
+ } </pre>
<p>The <tt class="LITERAL">bstate</tt> is the main variable
we are interested in. It tells the button state of the
mouse.</p>
<p>Then with a code snippet like the following, we can find
out what happened.</p>
- <pre class="PROGRAMLISTING">
- if(event.bstate & BUTTON1_PRESSED)
- printw("Left Button Pressed");
-</pre>
+
+ <pre class=
+ "PROGRAMLISTING"> if(event.bstate & BUTTON1_PRESSED)
+ printw("Left Button Pressed");</pre>
</div>
<div class="SECT2">
<div class="EXAMPLE">
<a name="BMOME" id="BMOME"></a>
+ <p><b>Example 11. Access the menu with mouse !!!</b>
+ </p>
- <p><b>Example 11. Access the menu with mouse !!!</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <ncurses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <string.h>
+#include <curses.h>
#define WIDTH 30
#define HEIGHT 10
return 0;
}
-
void print_menu(WINDOW *menu_win, int highlight)
{
int x, y, i;
*p_choice = choice + 1;
break;
}
-}</span>
-</pre>
+}</span></pre>
</div>
</div>
fill the values of x and y co-ordinates in the arguments
given to it. Since getyx() is a macro you don't have to
pass the address of the variables. It can be called as</p>
- <pre class="PROGRAMLISTING">
- getyx(win, y, x);
+
+ <pre class="PROGRAMLISTING"> getyx(win, y, x);
/* win: window pointer
* y, x: y, x co-ordinates will be put into this variables
- */
-</pre>
-
+ */</pre>
<p>The function getparyx() gets the beginning co-ordinates
of the sub window relative to the main window. This is some
times useful to update a sub window. When designing fancy
stuff like writing multiple menus, it becomes difficult to
- store the menu positions, their first option co-ordinates
+ store the menu positions, their first option co-ordinates,
etc. A simple solution to this problem, is to create menus
in sub windows and later find the starting co-ordinates of
the menus by using getparyx().</p>
used to copy a window completely onto another window. It
takes the source and destination windows as parameters and
according to the rectangle specified, it copies the
- rectangular region from source to destination window. It's
+ rectangular region from source to destination window. Its
last parameter specifies whether to overwrite or just
overlay the contents on to the destination window. If this
argument is true, then the copying is non-destructive.</p>
<p>This function can be used to make the cursor invisible.
The parameter to this function should be</p>
- <pre class="PROGRAMLISTING">
- 0 : invisible or
+
+ <pre class="PROGRAMLISTING"> 0 : invisible or
1 : normal or
- 2 : very visible.
-</pre>
+ 2 : very visible.</pre>
</div>
<div class="SECT2">
<div class="EXAMPLE">
<a name="BTELE" id="BTELE"></a>
+ <p><b>Example 12. Temporarily Leaving Curses Mode</b>
+ </p>
- <p><b>Example 12. Temporarily Leaving Curses Mode</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <ncurses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <stdlib.h>
+#include <curses.h>
int main()
{
endwin(); /* End curses mode */
return 0;
-}</span>
-</pre>
+}</span></pre>
</div>
</div>
<tt class="LITERAL">box()</tt> use these characters. All
these variables start with ACS meaning alternative
character set. You might have noticed me using these
- characters in some of the programs above. Here's an example
- showing all the characters.</p>
+ characters in some of the programs above. Here is an
+ example showing all the characters.</p>
<div class="EXAMPLE">
<a name="BACSVARS" id="BACSVARS"></a>
+ <p><b>Example 13. ACS Variables Example</b>
+ </p>
- <p><b>Example 13. ACS Variables Example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <ncurses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <curses.h>
int main()
{
endwin();
return 0;
-}</span>
-</pre>
+}</span></pre>
</div>
</div>
</div>
create blotches, whenever you forget to refresh the windows
in the proper order.</p>
- <p>Don't despair. There's an elegant solution provided in
+ <p>Don't despair. There is an elegant solution provided in
panels library. In the words of developers of ncurses</p>
<p><span class="emphasis"><i class="EMPHASIS">When your
interface design is such that windows may dive deeper into
the visibility stack or pop to the top at runtime, the
resulting book-keeping can be tedious and difficult to get
- right. Hence the panels library.</i></span></p>
+ right. Hence the panels library.</i></span>
+ </p>
<p>If you have lot of overlapping windows, then panels
library is the way to go. It obviates the need of doing
to display them correctly. There is a function similar to
refresh() which, when called , displays panels in the
correct order. Functions are provided to hide or show
- panels, move panels, change its size etc.. The overlapping
+ panels, move panels, change its size, etc. The overlapping
problem is managed by the panels library during all the
calls to these functions.</p>
<li>
<p>Mainpulate the panels with show_panel(),
- hide_panel(), move_panel() etc. Make use of helper
+ hide_panel(), move_panel(), etc. Make use of helper
functions like panel_hidden() and panel_window(). Make
use of user pointer to store custom data for a panel.
Use the functions set_panel_userptr() and
<hr>
<h3 class="SECT2"><a name="COMPILEPANELS" id=
- "COMPILEPANELS">16.2. Compiling With the Panels
- Library</a></h3>
+ "COMPILEPANELS">16.2. Compiling With the Panels Library</a></h3>
<p>To use panels library functions, you have to include
panel.h and to link the program with panels library the
flag -lpanel should be added along with -lncurses in that
order.</p>
- <pre class="PROGRAMLISTING">
- #include <panel.h>
+
+ <pre class="PROGRAMLISTING"> #include <panel.h>
.
.
.
- compile and link: gcc <program file> -lpanel -lncurses
-</pre>
-
+ compile and link: gcc <program file> -lpanel -lncurses</pre>
<div class="EXAMPLE">
<a name="PPASI" id="PPASI"></a>
+ <p><b>Example 14. Panel basics</b>
+ </p>
- <p><b>Example 14. Panel basics</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <panel.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <panel.h>
int main()
{ WINDOW *my_wins[3];
getch();
endwin();
}
-</span>
-</pre>
+</span></pre>
</div>
<p>As you can see, above program follows a simple flow as
<div class="EXAMPLE">
<a name="PPABR" id="PPABR"></a>
+ <p><b>Example 15. Panel Window Browsing Example</b>
+ </p>
- <p><b>Example 15. Panel Window Browsing Example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <panel.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <string.h>
+#include <panel.h>
#define NLINES 10
#define NCOLS 40
mvwprintw(win, y, x, "%s", string);
wattroff(win, color);
refresh();
-}</span>
-</pre>
+}</span></pre>
</div>
</div>
can be accessed using the function <tt class=
"LITERAL">panel_userptr()</tt> which will return the user
pointer for the panel given as argument. After finding the
- next panel in the cycle It's brought to the top by the
+ next panel in the cycle, it is brought to the top by the
function top_panel(). This function brings the panel given
as argument to the top of the panel stack.</p>
</div>
<div class="EXAMPLE">
<a name="PPARE" id="PPARE"></a>
+ <p><b>Example 16. Panel Moving and Resizing example</b>
+ </p>
- <p><b>Example 16. Panel Moving and Resizing
- example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <panel.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <stdlib.h>
+#include <string.h>
+#include <panel.h>
typedef struct _PANEL_DATA {
int x, y, w, h;
mvwprintw(win, y, x, "%s", string);
wattroff(win, color);
refresh();
-}</span>
-</pre>
+}</span></pre>
</div>
<p>Concentrate on the main while loop. Once it finds out
the user presses <ENTER> present selection ends and
panel is resized by using the concept explained. While in
resizing mode the program doesn't show how the window is
- getting resized. It's left as an exercise to the reader to
+ getting resized. It is left as an exercise to the reader to
print a dotted border while it gets resized to a new
position.</p>
<div class="EXAMPLE">
<a name="PPAHI" id="PPAHI"></a>
+ <p><b>Example 17. Panel Hiding and Showing example</b>
+ </p>
- <p><b>Example 17. Panel Hiding and Showing
- example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <panel.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <string.h>
+#include <panel.h>
typedef struct _PANEL_DATA {
int hide; /* TRUE if panel is hidden */
my_panels[1] = new_panel(my_wins[1]); /* Push 1, order: stdscr-0-1 */
my_panels[2] = new_panel(my_wins[2]); /* Push 2, order: stdscr-0-1-2 */
- /* Initialize panel datas saying that nothing is hidden */
+ /* Initialize panel data saying that nothing is hidden */
panel_datas[0].hide = FALSE;
panel_datas[1].hide = FALSE;
panel_datas[2].hide = FALSE;
mvwprintw(win, y, x, "%s", string);
wattroff(win, color);
refresh();
-}</span>
-</pre>
+}</span></pre>
</div>
</div>
<p>The menus library provides a nice extension to basic
curses, through which you can create menus. It provides a set
of functions to create menus. But they have to be customized
- to give a nicer look, with colors etc. Let's get into the
+ to give a nicer look, with colors, etc. Let's get into the
details.</p>
<p>A menu is a screen display that assists the user to choose
<hr>
<h3 class="SECT2"><a name="COMPILEMENUS" id=
- "COMPILEMENUS">17.2. Compiling With the Menu
- Library</a></h3>
+ "COMPILEMENUS">17.2. Compiling With the Menu Library</a></h3>
<p>To use menu library functions, you have to include
menu.h and to link the program with menu library the flag
-lmenu should be added along with -lncurses in that
order.</p>
- <pre class="PROGRAMLISTING">
- #include <menu.h>
+
+ <pre class="PROGRAMLISTING"> #include <menu.h>
.
.
.
- compile and link: gcc <program file> -lmenu -lncurses
-</pre>
-
+ compile and link: gcc <program file> -lmenu -lncurses</pre>
<div class="EXAMPLE">
<a name="MMESI" id="MMESI"></a>
+ <p><b>Example 18. Menu Basics</b>
+ </p>
- <p><b>Example 18. Menu Basics</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <curses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <stdlib.h>
+#include <curses.h>
#include <menu.h>
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
free_menu(my_menu);
endwin();
}
- </span>
-</pre>
+ </span></pre>
</div>
<p>This program demonstrates the basic concepts involved in
<p>The menu_driver accepts following navigational
requests.</p>
- <pre class="PROGRAMLISTING">
- REQ_LEFT_ITEM Move left to an item.
+
+ <pre class=
+ "PROGRAMLISTING"> REQ_LEFT_ITEM Move left to an item.
REQ_RIGHT_ITEM Move right to an item.
REQ_UP_ITEM Move up to an item.
REQ_DOWN_ITEM Move down to an item.
REQ_CLEAR_PATTERN Clear the menu pattern buffer.
REQ_BACK_PATTERN Delete the previous character from the pattern buffer.
REQ_NEXT_MATCH Move to the next item matching the pattern match.
- REQ_PREV_MATCH Move to the previous item matching the pattern match.
-</pre>
-
+ REQ_PREV_MATCH Move to the previous item matching the pattern match. </pre>
<p>Don't get overwhelmed by the number of options. We will
see them slowly one after another. The options of interest
in this example are REQ_UP_ITEM and REQ_DOWN_ITEM. These
<ul>
<li>
<p><span class="emphasis"><i class=
- "EMPHASIS">REQ_LEFT_ITEM and
- REQ_RIGHT_ITEM</i></span></p>
+ "EMPHASIS">REQ_LEFT_ITEM and REQ_RIGHT_ITEM</i></span>
+ </p>
<p>A Menu can be displayed with multiple columns for
more than one item. This can be done by using the
<li>
<p><span class="emphasis"><i class=
- "EMPHASIS">REQ_UP_ITEM and REQ_DOWN_ITEM</i></span></p>
+ "EMPHASIS">REQ_UP_ITEM and REQ_DOWN_ITEM</i></span>
+ </p>
<p>These two options you have seen in the above
example. These options when given, makes the
<li>
<p><span class="emphasis"><i class="EMPHASIS">REQ_SCR_*
- options</i></span></p>
+ options</i></span>
+ </p>
<p>The four options REQ_SCR_ULINE, REQ_SCR_DLINE,
REQ_SCR_DPAGE, REQ_SCR_UPAGE are related to scrolling.
<li>
<p><span class="emphasis"><i class=
"EMPHASIS">REQ_FIRST_ITEM, REQ_LAST_ITEM, REQ_NEXT_ITEM
- and REQ_PREV_ITEM</i></span></p>
+ and REQ_PREV_ITEM</i></span>
+ </p>
<p>These requests are self explanatory.</p>
</li>
<li>
<p><span class="emphasis"><i class=
- "EMPHASIS">REQ_TOGGLE_ITEM</i></span></p>
+ "EMPHASIS">REQ_TOGGLE_ITEM</i></span>
+ </p>
<p>This request when given, toggles the present
selection. This option is to be used only in a multi
<li>
<p><span class="emphasis"><i class="EMPHASIS">Pattern
- Requests</i></span></p>
+ Requests</i></span>
+ </p>
<p>Every menu has an associated pattern buffer, which
is used to find the nearest match to the ascii
<li>
<p><span class="emphasis"><i class="EMPHASIS">Mouse
- Requests</i></span></p>
+ Requests</i></span>
+ </p>
<p>In case of KEY_MOUSE requests, according to the
mouse position an action is taken accordingly. The
action to be taken is explained in the man page as,</p>
- <pre class="PROGRAMLISTING">
-<span class="emphasis"><i class=
-"EMPHASIS"> If the second argument is the KEY_MOUSE special key, the
+
+ <pre class="PROGRAMLISTING"><span class=
+ "emphasis"><i class=
+ "EMPHASIS"> If the second argument is the KEY_MOUSE special key, the
associated mouse event is translated into one of the above
pre-defined requests. Currently only clicks in the user
window (e.g. inside the menu display area or the decora­
generated, if you doubleclick a REQ_SCR_DPAGE is generated
and if you tripleclick a REQ_LAST_ITEM is generated. If
you click at an item inside the display area of the menu,
- the menu cursor is positioned to that item.</i></span>
-</pre>
+ the menu cursor is positioned to that item.</i></span></pre>
</li>
</ul>
<div class="EXAMPLE">
<a name="MMEWI" id="MMEWI"></a>
+ <p><b>Example 19. Menu Windows Usage example</b>
+ </p>
- <p><b>Example 19. Menu Windows Usage example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <menu.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <stdlib.h>
+#include <string.h>
+#include <menu.h>
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
#define CTRLD 4
mvwprintw(win, y, x, "%s", string);
wattroff(win, color);
refresh();
-}</span>
-</pre>
+}</span></pre>
</div>
<p>This example creates a menu with a title, border, a
<div class="EXAMPLE">
<a name="MMESC" id="MMESC"></a>
+ <p><b>Example 20. Scrolling Menus example</b>
+ </p>
- <p><b>Example 20. Scrolling Menus example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <curses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <stdlib.h>
+#include <string.h>
+#include <curses.h>
#include <menu.h>
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
wrefresh(my_menu_win);
attron(COLOR_PAIR(2));
- mvprintw(LINES - 2, 0, "Use PageUp and PageDown to scoll down or up a page of items");
+ mvprintw(LINES - 2, 0, "Use PageUp and PageDown to scroll down or up a page of items");
mvprintw(LINES - 1, 0, "Arrow Keys to navigate (F1 to Exit)");
attroff(COLOR_PAIR(2));
refresh();
mvwprintw(win, y, x, "%s", string);
wattroff(win, color);
refresh();
-}</span>
-</pre>
+}</span></pre>
</div>
<p>This program is self-explanatory. In this example the
<div class="EXAMPLE">
<a name="MMEMUCO" id="MMEMUCO"></a>
+ <p><b>Example 21. Milt Columnar Menus Example</b>
+ </p>
- <p><b>Example 21. Milt Columnar Menus Example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <curses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <stdlib.h>
+#include <curses.h>
#include <menu.h>
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
for(i = 0; i < n_choices; ++i)
free_item(my_items[i]);
endwin();
-}</span>
-</pre>
+}</span></pre>
</div>
<p>Watch the function call to set_menu_format(). It
couple of functions set_menu_opts(), menu_opts_on() and
menu_opts() which can be used to manipulate menu options.
The following menu options can be specified.</p>
- <pre class="PROGRAMLISTING">
- O_ONEVALUE
+
+ <pre class="PROGRAMLISTING"> O_ONEVALUE
Only one item can be selected for this menu.
O_SHOWDESC
O_NONCYCLIC
Don't wrap around next-item and previous-item,
- requests to the other end of the menu.
-</pre>
-
+ requests to the other end of the menu.</pre>
<p>All options are on by default. You can switch specific
attributes on or off with menu_opts_on() and
menu_opts_off() functions. You can also use set_menu_opts()
<div class="EXAMPLE">
<a name="MMETO" id="MMETO"></a>
+ <p><b>Example 22. Multi Valued Menus example</b>
+ </p>
- <p><b>Example 22. Multi Valued Menus example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <curses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <stdlib.h>
+#include <string.h>
+#include <curses.h>
#include <menu.h>
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
free_menu(my_menu);
endwin();
}
- </span>
-</pre>
+ </span></pre>
</div>
<p>Whew, A lot of new functions. Let's take them one after
This brings us to the interesting option for an item the
one and only O_SELECTABLE. We can turn it off by the
function item_opts_off() and after that that item is not
- selectable. It's like a grayed item in those fancy windows
+ selectable. It is like a grayed item in those fancy windows
menus. Let's put these concepts in practice with this
example</p>
<div class="EXAMPLE">
<a name="MMEAT" id="MMEAT"></a>
+ <p><b>Example 23. Menu Options example</b>
+ </p>
- <p><b>Example 23. Menu Options example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <menu.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <stdlib.h>
+#include <menu.h>
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
#define CTRLD 4
free_menu(my_menu);
endwin();
}
- </span>
-</pre>
+ </span></pre>
</div>
</div>
"MENUUSERPTR">17.9. The useful User Pointer</a></h3>
<p>We can associate a user pointer with each item in the
- menu. It works the same way as user pointer in panels. It's
- not touched by menu system. You can store any thing you
+ menu. It works the same way as user pointer in panels. It
+ is not touched by menu system. You can store any thing you
like in that. I usually use it to store the function to be
- executed when the menu option is chosen (It's selected and
+ executed when the menu option is chosen (It is selected and
may be the user pressed <ENTER>);</p>
<div class="EXAMPLE">
<a name="MMEUS" id="MMEUS"></a>
+ <p><b>Example 24. Menu User Pointer Usage</b>
+ </p>
- <p><b>Example 24. Menu User Pointer Usage</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <curses.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <stdlib.h>
+#include <curses.h>
#include <menu.h>
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
{ move(20, 0);
clrtoeol();
mvprintw(20, 0, "Item selected is : %s", name);
-} </span>
-</pre>
+} </span></pre>
</div>
</div>
</div>
<p>Well. If you have seen those forms on web pages which take
input from users and do various kinds of things, you might be
wondering how would any one create such forms in text mode
- display. It's quite difficult to write those nifty forms in
+ display. It is quite difficult to write those nifty forms in
plain ncurses. Forms library tries to provide a basic frame
work to build and maintain forms with ease. It has lot of
features(functions) which manage validation, dynamic
- expansion of fields etc.. Let's see it in full flow.</p>
+ expansion of fields, etc. Let's see it in full flow.</p>
<p>A form is a collection of fields; each field can be either
a label(static text) or a data-entry location. The forms also
the fields related to the form are created with
new_field(). You can set options for the fields, so that
they can be displayed with some fancy attributes, validated
- before the field looses focus etc.. Then the fields are
+ before the field looses focus, etc. Then the fields are
attached to form. After this, the form can be posted to
display and is ready to receive inputs. On the similar
lines to menu_driver(), the form is manipulated with
form_driver(). We can send requests to form_driver to move
focus to a certain field, move cursor to end of the field
- etc.. After the user enters values in the fields and
+ etc. After the user enters values in the fields and
validation done, form can be unposted and memory allocated
can be freed.</p>
<hr>
<h3 class="SECT2"><a name="COMPILEFORMS" id=
- "COMPILEFORMS">18.2. Compiling With the Forms
- Library</a></h3>
+ "COMPILEFORMS">18.2. Compiling With the Forms Library</a></h3>
<p>To use forms library functions, you have to include
form.h and to link the program with forms library the flag
-lform should be added along with -lncurses in that
order.</p>
- <pre class="PROGRAMLISTING">
- #include <form.h>
+
+ <pre class="PROGRAMLISTING"> #include <form.h>
.
.
.
- compile and link: gcc <program file> -lform -lncurses
-</pre>
-
+ compile and link: gcc <program file> -lform -lncurses</pre>
<div class="EXAMPLE">
<a name="FFOSI" id="FFOSI"></a>
+ <p><b>Example 25. Forms Basics</b>
+ </p>
- <p><b>Example 25. Forms Basics</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <form.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <form.h>
int main()
{ FIELD *field[3];
endwin();
return 0;
-}</span>
-</pre>
+}</span></pre>
</div>
<p>Above example is pretty straight forward. It creates two
height, width, starty, startx, number of offscreen rows,
and number of additional buffers into the parameters
given to it. It is a sort of inverse of new_field().</p>
- <pre class="PROGRAMLISTING">
-int field_info( FIELD *field, /* field from which to fetch */
+
+ <pre class=
+ "PROGRAMLISTING">int field_info( FIELD *field, /* field from which to fetch */
int *height, *int width, /* field size */
int *top, int *left, /* upper left corner */
int *offscreen, /* number of offscreen rows */
- int *nbuf); /* number of working buffers */
-</pre>
+ int *nbuf); /* number of working buffers */</pre>
</div>
<div class="SECT3">
<p>The location of the field can be moved to a different
position with move_field().</p>
- <pre class="PROGRAMLISTING">
-int move_field( FIELD *field, /* field to alter */
- int top, int left); /* new upper-left corner */
-</pre>
+ <pre class=
+ "PROGRAMLISTING">int move_field( FIELD *field, /* field to alter */
+ int top, int left); /* new upper-left corner */</pre>
<p>As usual, the changed position can be queried with
field_infor().</p>
</div>
<p>The justification to be done for the field can be
fixed using the function set_field_just().</p>
- <pre class="PROGRAMLISTING">
- int set_field_just(FIELD *field, /* field to alter */
- int justmode); /* mode to set */
- int field_just(FIELD *field); /* fetch justify mode of field */
-</pre>
+ <pre class=
+ "PROGRAMLISTING"> int set_field_just(FIELD *field, /* field to alter */
+ int justmode); /* mode to set */
+ int field_just(FIELD *field); /* fetch justify mode of field */</pre>
<p>The justification mode valued accepted and returned by
these functions are NO_JUSTIFICATION, JUSTIFY_RIGHT,
JUSTIFY_LEFT, or JUSTIFY_CENTER.</p>
<hr>
<h4 class="SECT3"><a name="FIELDDISPATTRIB" id=
- "FIELDDISPATTRIB">18.3.4. Field Display
- Attributes</a></h4>
+ "FIELDDISPATTRIB">18.3.4. Field Display Attributes</a></h4>
<p>As you have seen, in the above example, display
attribute for the fields can be set with set_field_fore()
be used to query the present foreground, background
attributes and pad character for the field. The following
list gives the usage of functions.</p>
- <pre class="PROGRAMLISTING">
- int set_field_fore(FIELD *field, /* field to alter */
+
+ <pre class=
+ "PROGRAMLISTING"> int set_field_fore(FIELD *field, /* field to alter */
chtype attr); /* attribute to set */
chtype field_fore(FIELD *field); /* field to query */
int pad); /* pad character to set */
chtype field_pad(FIELD *field); /* field to query */
- /* returns present pad character */
-</pre>
-
+ /* returns present pad character */ </pre>
<p>Though above functions seem quite simple, using colors
with set_field_fore() may be frustrating in the
beginning. Let me first explain about foreground and
<div class="EXAMPLE">
<a name="FFOAT" id="FFOAT"></a>
+ <p><b>Example 26. Form Attributes example</b>
+ </p>
- <p><b>Example 26. Form Attributes example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <form.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <form.h>
int main()
{ FIELD *field[3];
endwin();
return 0;
-}</span>
-</pre>
+}</span></pre>
</div>
<p>Play with the color pairs and try to understand the
you can set to control various aspects of forms
processing. You can manipulate them with these
functions:</p>
- <pre class="PROGRAMLISTING">
-int set_field_opts(FIELD *field, /* field to alter */
+
+ <pre class=
+ "PROGRAMLISTING">int set_field_opts(FIELD *field, /* field to alter */
int attr); /* attribute to set */
int field_opts_on(FIELD *field, /* field to alter */
int field_opts_off(FIELD *field, /* field to alter */
int attr); /* attributes to turn off */
-int field_opts(FIELD *field); /* field to query */
-</pre>
-
+int field_opts(FIELD *field); /* field to query */ </pre>
<p>The function set_field_opts() can be used to directly
set attributes of a field or you can choose to switch a
few attributes on and off with field_opts_on() and
<div class="EXAMPLE">
<a name="FFOOP" id="FFOOP"></a>
+ <p><b>Example 27. Field Options Usage example</b>
+ </p>
- <p><b>Example 27. Field Options Usage example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <form.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <form.h>
#define STARTX 15
#define STARTY 4
endwin();
return 0;
-}</span>
-</pre>
+}</span></pre>
</div>
<p>This example, though useless, shows the usage of
becomes TRUE. So a field's status can be queried to find
out whether it has been modified or not. The following
functions can assist in those operations.</p>
- <pre class="PROGRAMLISTING">
-int set_field_status(FIELD *field, /* field to alter */
- int status); /* status to set */
-int field_status(FIELD *field); /* fetch status of field */
-</pre>
+ <pre class=
+ "PROGRAMLISTING">int set_field_status(FIELD *field, /* field to alter */
+ int status); /* status to set */
- <p>It's better to check the field's status only after
+int field_status(FIELD *field); /* fetch status of field */</pre>
+ <p>It is better to check the field's status only after
after leaving the field, as data buffer might not have
been updated yet as the validation is still due. To
guarantee that right status is returned, call
by forms library and can be used for any purpose by the
user. The following functions set and fetch user
pointer.</p>
- <pre class="PROGRAMLISTING">
-int set_field_userptr(FIELD *field,
+
+ <pre class=
+ "PROGRAMLISTING">int set_field_userptr(FIELD *field,
char *userptr); /* the user pointer you wish to associate */
/* with the field */
-char *field_userptr(FIELD *field); /* fetch user pointer of the field */
-</pre>
+char *field_userptr(FIELD *field); /* fetch user pointer of the field */</pre>
</div>
<div class="SECT3">
<hr>
<h4 class="SECT3"><a name="VARIABLESIZEFIELDS" id=
- "VARIABLESIZEFIELDS">18.3.8. Variable-Sized
- Fields</a></h4>
+ "VARIABLESIZEFIELDS">18.3.8. Variable-Sized Fields</a></h4>
<p>If you want a dynamically changing field with variable
width, this is the feature you want to put to full use.
<p>To make a field dynamically growable, the option
O_STATIC should be turned off. This can be done with
a</p>
- <pre class="PROGRAMLISTING">
- field_opts_off(field_pointer, O_STATIC);
-</pre>
- <p>But it's usually not advisable to allow a field to
+ <pre class=
+ "PROGRAMLISTING"> field_opts_off(field_pointer, O_STATIC);</pre>
+ <p>But it is usually not advisable to allow a field to
grow infinitely. You can set a maximum limit to the
growth of the field with</p>
- <pre class="PROGRAMLISTING">
-int set_max_field(FIELD *field, /* Field on which to operate */
- int max_growth); /* maximum growth allowed for the field */
-</pre>
+ <pre class=
+ "PROGRAMLISTING">int set_max_field(FIELD *field, /* Field on which to operate */
+ int max_growth); /* maximum growth allowed for the field */</pre>
<p>The field info for a dynamically growable field can be
retrieved by</p>
- <pre class="PROGRAMLISTING">
-int dynamic_field_info( FIELD *field, /* Field on which to operate */
+
+ <pre class=
+ "PROGRAMLISTING">int dynamic_field_info( FIELD *field, /* Field on which to operate */
int *prows, /* number of rows will be filled in this */
int *pcols, /* number of columns will be filled in this*/
int *pmax) /* maximum allowable growth will be filled */
- /* in this */
-</pre>Though field_info work as usual, it is advisable to use this
-function to get the proper attributes of a dynamically growable
-field.
-
+ /* in this */</pre>Though field_info
+work as usual, it is advisable to use this function to get the
+proper attributes of a dynamically growable field.
<p>Recall the library routine new_field; a new field
created with height set to one will be defined to be a
one line field. A new field created with height greater
<div class="EXAMPLE">
<a name="FFOWI" id="FFOWI"></a>
+ <p><b>Example 28. Form Windows Example</b>
+ </p>
- <p><b>Example 28. Form Windows Example</b></p>
- <pre class="PROGRAMLISTING">
-<span class="INLINEMEDIAOBJECT">#include <form.h>
+ <pre class="PROGRAMLISTING"><span class=
+ "INLINEMEDIAOBJECT">#include <string.h>
+#include <form.h>
void print_in_middle(WINDOW *win, int starty, int startx, int width, char *string, chtype color);
mvwprintw(win, y, x, "%s", string);
wattroff(win, color);
refresh();
-}</span>
-</pre>
+}</span></pre>
</div>
</div>
<p>Validation can be attached to a field with the following
function.</p>
- <pre class="PROGRAMLISTING">
-int set_field_type(FIELD *field, /* field to alter */
+
+ <pre class=
+ "PROGRAMLISTING">int set_field_type(FIELD *field, /* field to alter */
FIELDTYPE *ftype, /* type to associate */
- ...); /* additional arguments*/
-</pre>Once set, the validation type for a field can be queried with
- <pre class="PROGRAMLISTING">
-FIELDTYPE *field_type(FIELD *field); /* field to query */
-</pre>
+ ...); /* additional arguments*/</pre>Once
+set, the validation type for a field can be queried with
+ <pre class=
+ "PROGRAMLISTING">FIELDTYPE *field_type(FIELD *field); /* field to query */</pre>
<p>The form driver validates the data in a field only when
data is entered by the end-user. Validation does not occur
when</p>
</ul>
<p>The following are the pre-defined validation types. You
- can also specify custom validation, though it's a bit
+ can also specify custom validation, though it is a bit
tricky and cumbersome.</p>
- <h1 class="BRIDGEHEAD"><a name="AEN1069" id=
- "AEN1069"></a>TYPE_ALPHA</h1>
+ <h1 class="BRIDGEHEAD"><a name="AEN1074" id=
+ "AEN1074"></a>TYPE_ALPHA</h1>
<p>This field type accepts alphabetic data; no blanks, no
digits, no special characters (this is checked at
character-entry time). It is set up with:</p>
- <pre class="PROGRAMLISTING">
-int set_field_type(FIELD *field, /* field to alter */
- TYPE_ALPHA, /* type to associate */
- int width); /* minimum width of field */
-</pre>
+ <pre class=
+ "PROGRAMLISTING">int set_field_type(FIELD *field, /* field to alter */
+ TYPE_ALPHA, /* type to associate */
+ int width); /* minimum width of field */</pre>
<p>The width argument sets a minimum width of data. The
user has to enter at-least width number of characters
before he can leave the field. Typically you'll want to set
- this to the field width; if it's greater than the field
+ this to the field width; if it is greater than the field
width, the validation check will always fail. A minimum
width of zero makes field completion optional.</p>
- <h1 class="BRIDGEHEAD"><a name="AEN1073" id=
- "AEN1073"></a>TYPE_ALNUM</h1>
+ <h1 class="BRIDGEHEAD"><a name="AEN1078" id=
+ "AEN1078"></a>TYPE_ALNUM</h1>
<p>This field type accepts alphabetic data and digits; no
blanks, no special characters (this is checked at
character-entry time). It is set up with:</p>
- <pre class="PROGRAMLISTING">
-int set_field_type(FIELD *field, /* field to alter */
- TYPE_ALNUM, /* type to associate */
- int width); /* minimum width of field */
-</pre>
+ <pre class=
+ "PROGRAMLISTING">int set_field_type(FIELD *field, /* field to alter */
+ TYPE_ALNUM, /* type to associate */
+ int width); /* minimum width of field */</pre>
<p>The width argument sets a minimum width of data. As with
TYPE_ALPHA, typically you'll want to set this to the field
- width; if it's greater than the field width, the validation
- check will always fail. A minimum width of zero makes field
- completion optional.</p>
+ width; if it is greater than the field width, the
+ validation check will always fail. A minimum width of zero
+ makes field completion optional.</p>
- <h1 class="BRIDGEHEAD"><a name="AEN1077" id=
- "AEN1077"></a>TYPE_ENUM</h1>
+ <h1 class="BRIDGEHEAD"><a name="AEN1082" id=
+ "AEN1082"></a>TYPE_ENUM</h1>
<p>This type allows you to restrict a field's values to be
among a specified set of string values (for example, the
two-letter postal codes for U.S. states). It is set up
with:</p>
- <pre class="PROGRAMLISTING">
-int set_field_type(FIELD *field, /* field to alter */
+
+ <pre class=
+ "PROGRAMLISTING">int set_field_type(FIELD *field, /* field to alter */
TYPE_ENUM, /* type to associate */
char **valuelist; /* list of possible values */
int checkcase; /* case-sensitive? */
- int checkunique); /* must specify uniquely? */
-</pre>
-
+ int checkunique); /* must specify uniquely? */</pre>
<p>The valuelist parameter must point at a NULL-terminated
list of valid strings. The checkcase argument, if true,
makes comparison with the string case-sensitive.</p>
<p>The REQ_NEXT_CHOICE and REQ_PREV_CHOICE input requests
can be particularly useful with these fields.</p>
- <h1 class="BRIDGEHEAD"><a name="AEN1084" id=
- "AEN1084"></a>TYPE_INTEGER</h1>
+ <h1 class="BRIDGEHEAD"><a name="AEN1089" id=
+ "AEN1089"></a>TYPE_INTEGER</h1>
<p>This field type accepts an integer. It is set up as
follows:</p>
- <pre class="PROGRAMLISTING">
-int set_field_type(FIELD *field, /* field to alter */
+
+ <pre class=
+ "PROGRAMLISTING">int set_field_type(FIELD *field, /* field to alter */
TYPE_INTEGER, /* type to associate */
int padding, /* # places to zero-pad to */
- int vmin, int vmax); /* valid range */
-</pre>
-
+ int vmin, int vmax); /* valid range */</pre>
<p>Valid characters consist of an optional leading minus
and digits. The range check is performed on exit. If the
range maximum is less than or equal to the minimum, the
<p>A TYPE_INTEGER value buffer can conveniently be
interpreted with the C library function atoi(3).</p>
- <h1 class="BRIDGEHEAD"><a name="AEN1090" id=
- "AEN1090"></a>TYPE_NUMERIC</h1>
+ <h1 class="BRIDGEHEAD"><a name="AEN1095" id=
+ "AEN1095"></a>TYPE_NUMERIC</h1>
<p>This field type accepts a decimal number. It is set up
as follows:</p>
- <pre class="PROGRAMLISTING">
-int set_field_type(FIELD *field, /* field to alter */
+
+ <pre class=
+ "PROGRAMLISTING">int set_field_type(FIELD *field, /* field to alter */
TYPE_NUMERIC, /* type to associate */
int padding, /* # places of precision */
- int vmin, int vmax); /* valid range */
-</pre>
-
+ int vmin, int vmax); /* valid range */</pre>
<p>Valid characters consist of an optional leading minus
and digits. possibly including a decimal point. The range
check is performed on exit. If the range maximum is less
<p>A TYPE_NUMERIC value buffer can conveniently be
interpreted with the C library function atof(3).</p>
- <h1 class="BRIDGEHEAD"><a name="AEN1096" id=
- "AEN1096"></a>TYPE_REGEXP</h1>
+ <h1 class="BRIDGEHEAD"><a name="AEN1101" id=
+ "AEN1101"></a>TYPE_REGEXP</h1>
<p>This field type accepts data matching a regular
expression. It is set up as follows:</p>
- <pre class="PROGRAMLISTING">
-int set_field_type(FIELD *field, /* field to alter */
- TYPE_REGEXP, /* type to associate */
- char *regexp); /* expression to match */
-</pre>
+ <pre class=
+ "PROGRAMLISTING">int set_field_type(FIELD *field, /* field to alter */
+ TYPE_REGEXP, /* type to associate */
+ char *regexp); /* expression to match */</pre>
<p>The syntax for regular expressions is that of
regcomp(3). The check for regular-expression match is
performed on exit.</p>
<p>As in the menu system, form_driver() plays a very
important role in forms system. All types of requests to
forms system should be funneled through form_driver().</p>
- <pre class="PROGRAMLISTING">
-int form_driver(FORM *form, /* form on which to operate */
- int request) /* form request code */
-</pre>
+ <pre class=
+ "PROGRAMLISTING">int form_driver(FORM *form, /* form on which to operate */
+ int request) /* form request code */</pre>
<p>As you have seen some of the examples above, you have to
be in a loop looking for user input and then decide whether
- it's a field data or a form request. The form requests are
+ it is a field data or a form request. The form requests are
then passed to form_driver() to do the work.</p>
<p>The requests roughly can be divided into following
lot of fields and logical sections, then you can divide
the form into pages. The function set_new_page() to set a
new page at the field specified.</p>
- <pre class="PROGRAMLISTING">
-int set_new_page(FIELD *field,/* Field at which page break to be set or unset */
- bool new_page_flag); /* should be TRUE to put a break */
-</pre>
+ <pre class=
+ "PROGRAMLISTING">int set_new_page(FIELD *field,/* Field at which page break to be set or unset */
+ bool new_page_flag); /* should be TRUE to put a break */</pre>
<p>The following requests allow you to move to different
pages</p>
<p><span class="emphasis"><i class="EMPHASIS">CDK stands
for 'Curses Development Kit' and it currently contains 21
ready to use widgets which facilitate the speedy
- development of full screen curses programs.</i></span></p>
+ development of full screen curses programs.</i></span>
+ </p>
<p>The kit provides some useful widgets, which can be used
- in your programs directly. It's pretty well written and the
- documentation is very good. The examples in the examples
- directory can be a good place to start for beginners. The
- CDK can be downloaded from <a href=
+ in your programs directly. It is pretty well written and
+ the documentation is very good. The examples in the
+ examples directory can be a good place to start for
+ beginners. The CDK can be downloaded from <a href=
"https://invisible-island.net/cdk/" target=
"_top">https://invisible-island.net/cdk/</a> . Follow the
instructions in README file to install it.</p>
<p>The following is the list of widgets provided with cdk
and their description.</p>
- <pre class="PROGRAMLISTING">
-Widget Type Quick Description
+
+ <pre class=
+ "PROGRAMLISTING">Widget Type Quick Description
===========================================================================
Alphalist Allows a user to select from a list of words, with
the ability to narrow the search list by typing in a
dates and phone numbers.
Viewer This is a file/information viewer. Very useful
when you need to display loads of information.
-===========================================================================
-</pre>
-
+===========================================================================</pre>
<p>A few of the widgets are modified by Thomas Dickey in
recent versions.</p>
</div>
which are passed to CDK functions. For Example</p>
<p>If the string</p>
- <pre class="PROGRAMLISTING">
-"</B/1>This line should have a yellow foreground and a blue
-background.<!1>"
-</pre>
+ <pre class=
+ "PROGRAMLISTING">"</B/1>This line should have a yellow foreground and a blue
+background.<!1>"</pre>
<p>given as a parameter to newCDKLabel(), it prints the
line with yellow foreground and blue background. There
are other tags available for justifying string, embedding
- special drawing characters etc.. Please refer to the man
+ special drawing characters, etc. Please refer to the man
page cdk_display(3X) for details. The man page explains
the usage with nice examples.</p>
</div>
professional-looking dialog boxes from within shell
scripts. This article presents a tutorial introduction to
the dialog utility, and shows examples of how and where it
- can be used</i></span></p>
+ can be used</i></span>
+ </p>
<p>As he explains, dialog is a real gem in making
professional-looking dialog boxes with ease. It creates a
- variety of dialog boxes, menus, check lists etc.. It is
+ variety of dialog boxes, menus, check lists, etc. It is
usually installed by default. If not, you can download it
from <a href="https://invisible-island.net/dialog/" target=
"_top">Thomas Dickey</a>'s site.</p>
<p>The above-mentioned article gives a very good overview
- of its uses and capabilites. The man page has more details.
- It can be used in variety of situations. One good example
- is building of linux kernel in text mode. Linux kernel uses
- a modified version of dialog tailored for its needs.</p>
+ of its uses and capabilities. The man page has more
+ details. It can be used in variety of situations. One good
+ example is building of linux kernel in text mode. Linux
+ kernel uses a modified version of dialog tailored for its
+ needs.</p>
<p>dialog was initially designed to be used with shell
scripts. If you want to use its functionality in a c
<p>Game of life is a wonder of math. In <a href=
"http://www.math.com/students/wonders/life/life.html"
target="_top">Paul Callahan</a>'s words</p>
- <pre class="PROGRAMLISTING">
-<span class="emphasis"><i class=
-"EMPHASIS">The Game of Life (or simply Life) is not a game in the conventional sense. There
+
+ <pre class="PROGRAMLISTING"><span class="emphasis"><i class=
+ "EMPHASIS">The Game of Life (or simply Life) is not a game in the conventional sense. There
are no players, and no winning or losing. Once the "pieces" are placed in the
starting position, the rules determine everything that happens later.
Nevertheless, Life is full of surprises! In most cases, it is impossible to look
at a starting position (or pattern) and see what will happen in the future. The
-only way to find out is to follow the rules of the game.</i></span>
-</pre>
-
+only way to find out is to follow the rules of the game.</i></span></pre>
<p>This program starts with a simple inverted U pattern and
shows how wonderful life works. There is a lot of room for
improvement in the program. You can let the user enter
pattern of his choice or even take input from a file. You
can also change rules and play with a lot of variations.
- Search on <a href="http://www.google.com" target=
+ Search on <a href="https://www.google.com" target=
"_top">google</a> for interesting information on game of
life.</p>
<p><span class="emphasis"><i class="EMPHASIS">File Path:
- JustForFun/life.c</i></span></p>
+ JustForFun/life.c</i></span>
+ </p>
</div>
<div class="SECT2">
<p>Magic Square, another wonder of math, is very simple to
understand but very difficult to make. In a magic square
sum of the numbers in each row, each column is equal. Even
- diagnol sum can be equal. There are many variations which
+ diagonal sum can be equal. There are many variations which
have special properties.</p>
<p>This program creates a simple magic square of odd
order.</p>
<p><span class="emphasis"><i class="EMPHASIS">File Path:
- JustForFun/magic.c</i></span></p>
+ JustForFun/magic.c</i></span>
+ </p>
</div>
<div class="SECT2">
larger disk over a small disk at any time.</p>
<p><span class="emphasis"><i class="EMPHASIS">File Path:
- JustForFun/hanoi.c</i></span></p>
+ JustForFun/hanoi.c</i></span>
+ </p>
</div>
<div class="SECT2">
technique.</p>
<p><span class="emphasis"><i class="EMPHASIS">File Path:
- JustForFun/queens.c</i></span></p>
+ JustForFun/queens.c</i></span>
+ </p>
</div>
<div class="SECT2">
<p>A fun game, if you have time to kill.</p>
<p><span class="emphasis"><i class="EMPHASIS">File Path:
- JustForFun/shuffle.c</i></span></p>
+ JustForFun/shuffle.c</i></span>
+ </p>
</div>
<div class="SECT2">
helpful.</p>
<p><span class="emphasis"><i class="EMPHASIS">File Path:
- JustForFun/tt.c</i></span></p>
+ JustForFun/tt.c</i></span>
+ </p>
</div>
</div>
<div class="SECT1">
<hr>
- <h2 class="SECT1"><a name="REF" id="REF">21.
- References</a></h2>
+ <h2 class="SECT1"><a name="REF" id="REF">21. References</a></h2>
<ul>
<li>