Q.

1(A)
Introduction
Here you can find the list with the standard set of fonts common to all
versions of Windows and their Mac substitutes, referred sometimes as
"browser safe fonts". This is the reference I use when making web pages
and I expect you will find it useful too.
If you are new to web design, maybe you are thinking: "Why I have to limit
to that small set of fonts? I have a large collection of nice fonts in my
computer". Well, as seasoned web designers already know, browsers can
use only the fonts installed in each computer, so it means that every
visitor of your web page needs to have all the fonts you want to use
installed in his/her computer. Of course, different people will have different
fonts installed, and thus come the need of a standard set of fonts.
Fortunately, CSS allows set several values for the font-family property,
which eases the task a bit.
If you want to know how the fonts are displayed in other OS's or browsers
than yours, after the table you can find several screen shots of this page in
different systems and browsers. Also, you can take a look to the list of the
default fonts included with each version of Windows.
The list
First, a few introductory notes:

The names in grey are the generic family of each font.

In some cases the Mac equivalent is the same font, since Mac OS X
also includes some of the fonts shipped with Windows.

The notes at the bottom contains specific information about some of

the fonts.

Windows fonts / Mac fonts / Font family

Normal style

Bold style

Arial, Arial, Helvetica, sans-serif

Arial, Arial, Helvetica, sansserif

Arial Black, Arial Black,

Gadget, sans-serif

Arial Black, Arial Black,

Gadget, sans-serif

Comic Sans MS, Comic Sans

MS5, cursive

Comic Sans MS, Comic Sans

MS5, cursive

Courier New, Courier

Courier New, Courier

New, monospace

New, monospace

Georgia1, Georgia, serif

Georgia1, Georgia, serif

Impact, Impact5,
Charcoal6, sans-serif

Impact, Impact5,
Charcoal6, sans-serif

Lucida
Console, Monaco5, monospace

Lucida
Console, Monaco5, monospac
e

Lucida Sans Unicode, Lucida

Grande, sans-serif

Lucida Sans Unicode, Lucida

Grande, sans-serif

Palatino Linotype, Book

Antiqua3, Palatino, serif

Palatino Linotype, Book

Antiqua3, Palatino, serif

Tahoma, Geneva, sans-serif

Tahoma, Geneva, sans-serif

Times New Roman, Times New

Roman, Times, serif

Times New Roman, Times

New Roman, Times, serif

Trebuchet MS1, Trebuchet

MS, sans-serif

Trebuchet MS1, Trebuchet

MS, sans-serif

Verdana, Verdana,
Geneva, sans-serif

Verdana, Verdana,
Geneva, sans-serif

Symbol, Symbol (Symbol2, Sym

bol2)

Symbol, Symbol (Symbol2, Sy

mbol2)

Webdings, Webdings (Webdings

2
, Webdings2)

Webdings, Webdings (Webdin

gs2, Webdings2)

Wingdings, Zapf Dingbats(Wing

dings2, Zapf Dingbats2)

Wingdings, Zapf Dingbats(Wi

ngdings2, Zapf Dingbats2)

MS Sans Serif4, Geneva, sansserif

MS Sans Serif4, Geneva, sansserif

MS Serif4, New York6, serif

MS Serif4, New York6, serif

Q.2(a)
Modal and Modeless Dialog Boxes
Dialog boxes are either modal or modeless. A modal dialog box must be
closed (hidden or unloaded) before you can continue working with the rest
of the application. For example, a dialog box is modal if it requires you to
click OK or Cancel before you can switch to another form or dialog box.

The About dialog box in Visual Basic is modal. Dialog boxes that display
important messages should always be modal that is, the user should
always be required to close the dialog box or respond to its message before
proceeding.
Modeless dialog boxes let you shift the focus between the dialog box and
another form without having to close the dialog box. You can continue to
work elsewhere in the current application while the dialog box is displayed.
Modeless dialog boxes are rare. From the Edit menu, the Find dialog box in
Visual Basic is an example of a modeless dialog box. Use modeless dialog
boxes to display frequently used commands or information.
To display a form as a modal dialog box
Use the Show method with a style argument of vbModal (a constant for
the value 1).
For example:
' Display frmAbout as a modal dialog.
frmAbout.Show vbModal
To display a form as a modeless dialog box
Use the Show method without a style argument.
For example:
' Display frmAbout as a modeless dialog.
frmAbout.Show
Note If a form is displayed as modal, the code following the Show method
is not executed until the dialog box is closed. However, when a form is
shown as modeless, the code following the Show method is executed
immediately after the form is displayed.
The Show method has another optional argument, owner, that can be used
to specify a parent-child relationship for a form. You can pass the name of a
form to this argument to make that form the owner of the new form.
To display a form as a child of another form
Use the Show method with both style and owner arguments.
For example:

' Display frmAbout as a modeless child of frmMain.

frmAbout.Show vbModeless, frmMain
Using the owner argument with the Show method ensures that the dialog
box will be minimized when its parent is minimized, or unloaded should the
parent form be closed.

Q.3 (a)
File and Database Classes
These classes allow you to store information to a database or a disk file.
There are three sets of database classes OLE DB, ODBC, and DAO that
provide similar functionality. The OLE DB group is implemented using OLE
DB and works with the OLE DB consumer templates, the DAO group is
implemented using the Data Access Object, and the ODBC group is
implemented using Open Database Connectivity. There are also a set of
classes for manipulating standard files, Active streams, and HTML streams.
The following categories of classes support data persistence.
File I/O Classes
OLE DB Classes
DAO Classes
ODBC Classes

File I/O Classes

These classes provide an interface to traditional disk files, in-memory files,
Active streams, and Windows sockets. All of the classes derived
from CFile can be used with a CArchive object to perform serialization.
Use the following classes, particularly CArchive and CFile, if you write your
own input/output processing. Normally you do not need to derive from these
classes. If you use the application framework, the default implementations
of the Open and Save commands on the Filemenu will handle file I/O
(using class CArchive), as long as you override your
document's Serialize function to supply details about how a document

serializes its contents. For more information about the file classes and
serialization, see the article Files in MFC and the articleSerialization.
OLE DB Classes
The OLE DB support in MFC currently consists of the
class COLEDBRecordView. COleDBRecordView displays database
records in controls, through a form view directly connected to
a CRowset object. For more information about the OLE DB consumer
templates, see List of OLE DB Consumer Templates.

DAO Classes
These classes work with the other application framework classes to give
easy access to Data Access Object (DAO) databases, which use the same
database engine as Microsoft Visual Basic and Microsoft Access. The DAO
classes can also access a wide variety of databases for which Open
Database Connectivity (ODBC) drivers are available.
Programs that use DAO databases will have at least
a CDaoDatabase object and a CDaoRecordset object.

ODBC Classes
These classes work with the other application framework classes to give
easy access to a wide variety of databases for which Open Database
Connectivity (ODBC) drivers are available.
Programs that use ODBC databases will have at least a CDatabase object
and a CRecordset object.

Q.4(a)
visual c++ Status bar example
1- Make single document MFC application and deselect printing and
printview options
2- In the view menu chose resource and then add New resource and then
add ID_TIME_STATUSBAR and accept the defaul value (101) .
3- Add message handler and update message handler in the CMainFrame
class for both ID_VIEW_STATUS_BAR .

4- Replace the previously created indicators array with single ID_SEPARATOR

and make sure that the CMainFrame data member m_wndStatusBar is
public instead of protected so that it can be accessed from the View class .
5- Replace if (!m_wndStatusBar.Create(this) with this, WS_CHILD |
WS_VISIBLE | CBRS_BOTTOM,ID_TIME_STATUSBAR) ;
6- Add the following code to ur CMainFrame.cpp
void CMainFrame::OnViewStatusBar()
{
m_wndStatusBar.ShowWindow((m_wndStatusBar.GetStyle() &
WS_VISIBLE) == 0);
RecalcLayout();
}
void CMainFrame::OnUpdateViewStatusBar(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck((m_wndStatusBar.GetStyle() & WS_VISIBLE) !=
0);
}
Q.5(b)
CDialog::Create
Call Create to create a modeless dialog box using a dialog-box template
from a resource.
virtual BOOL Create(
LPCTSTR lpszTemplateName,
CWnd* pParentWnd = NULL
);
virtual BOOL Create(
UINT nIDTemplate,
CWnd* pParentWnd = NULL
);
Parameters
lpszTemplateName
Contains a null-terminated string that is the name of a dialog-box
template resource.

pParentWnd
Points to the parent window object (of type CWnd) to which the dialog
object belongs. If it is NULL, the dialog object's parent window is set to
the main application window.
nIDTemplate
Contains the ID number of a dialog-box template resource.
Return Value
Both forms return nonzero if dialog-box creation and initialization were
successful; otherwise 0.
Remarks
You can put the call to Create inside the constructor or call it after the
constructor is invoked.
Two forms of the Create member function are provided for access to the
dialog-box template resource by either template name or template ID
number (for example, IDD_DIALOG1).
For either form, pass a pointer to the parent window object.
If pParentWnd is NULL, the dialog box will be created with its parent or
owner window set to the main application window.
The Create member function returns immediately after it creates the dialog
box.
Use the WS_VISIBLE style in the dialog-box template if the dialog box
should appear when the parent window is created. Otherwise, you must
call ShowWindow. For further dialog-box styles and their application, see
the DLGTEMPLATE structure in the Windows SDK and Window Styles in
the MFC Reference.
Use the CWnd::DestroyWindow function to destroy a dialog box created
by the Create function.
Example
C++
void CMyDialog::OnMenuShowSimpleDialog()
{

//m_pSimpleDialog initialized to NULL in the constructor of CMyDialog

class
m_pSimpleDlg = new CSimpleDlg();
//Check if new succeeded and we got a valid pointer to a dialog object
if(m_pSimpleDlg != NULL)
{
BOOL ret = m_pSimpleDlg->Create(IDD_SIMPLEDIALOG, this);
if(!ret) //Create failed.
AfxMessageBox(_T("Error creating Dialog"));
m_pSimpleDlg->ShowWindow(SW_SHOW);
}
else
{
AfxMessageBox(_T("Error Creating Dialog Object"));
}
}
Q.6 (A)
SPIN CONTROL
A spin button is a control equipped with two buttons and each
button displays an arrow. The spin button allows the user to
navigate through a range of value using the arrow buttons to
increase or decrease the value held by the control.

To create a spin button, you can use the Spin button

from the Controls
toolbox. Alternatively, Visual C++ provides the Microsoft UpDown Control
as an ActiveX control.
1. Use AppWizard to create a Dialog based app. Call it: ExoSpin

2. Once you are in the Visual Studio, press the following combination:
Alt -> b -> o to access the Set Active Configuration... dialog box.
Click ExoSpin - Win32 Release and press Enter
3. Pick up an Edit box from the Control toolbox and drop it in your dialog
4. Change the identifier of that Edit to IDC_EDITSPIN.
5.Get a Spin control from the Controls toolbox, drop that Spin control on
your dialog, preferably next on the right of the Edit box.
Press Alt+Enter to access the Spin Properties dialog.
from the General tab, change the Spin's ID to IDC_SPIN. From
theStyles
tab, specify the Alignment as Right, check the Set buddy integer.
c) To build and execute your app now, press Ctrl+F5.
3.
its

The Spin control works fine but like most users, you might not like
orientation.

a) Press Ctrl+W to access the ClassWizard. Click the Member Variables

tab.
Make sure that the Class name: is CExoSpinDlg.
Double-click IDC_SPIN and Add Member Variable as: m_Spin,
press Enter.
b) While you are still in the MFC ClassWizard,
and the Class name: is CExoSpinDlg, click the Message Maps.
In the Member functions: listbox,
double-click OnInitDialog to access its implementation.
The default range of a SpinCtrl is from 0 to 100 (actually, it's
awkwardly from 100 to 0.
So, we will change that range to make it look better, we will use the
CSpinButtonCtrl::SetRange() function. That function simply requires
a
lower and an upper integers. For demonstration purposes, use 0 and
54.
Edit it as follows:
Q.7 (a)

Launch your Visual C++, click the File menu and click the New sub menu. Click the Projects tab
for the AppWizard as shown below. Select the MFC AppWizard (exe), type your project name and
set the project location as needed. Leave other setting as default and click the OK button.

Figure 19: AppWizard dialog.

The wizard has 6 steps and you can exit at any step. Select the Single document radio button and
uncheck the Document/View architecture support then click Next button.

Figure 20: Visual C++ AppWizard step 1 of 6.

Select the None radio button for database support. Click the Next button. We are going to create the
simplest project.

Figure 21: Visual C++ AppWizard step 2 of 6.

Uncheck the ActiveX Controls. Just to make our code simpler.

Figure 22: Visual C++ AppWizard step 3 of 6.

Accept the defaults and click the Next button.

Figure 23: Visual C++ AppWizard step 4 of 6.

Accept the defaults and click Next button.

Figure 24: Visual C++ AppWizard step 5 of 6.

The following are the classes that will be generated (also the related files created) for our project.
Click theNext button.

Figure 25: Visual C++ AppWizard step 6 of 6.

Finally the summary of the project settings. Click the OK button.

Q.8 (b)

Definition of Structured Programming

Structured programming can be defined as a Software

application programming technique that follows a top down design
approach with block oriented structures. This style of programming is
characterized by the programmers tendency to divide his program source
code into logically structured blocks which would normally consist of
conditional statements, loops and logic blocks. This style of programming
has the implementation of the source code being processed in the order in
which bits of the code have been typed in.

Structured Programming can save time and energy when writing simple programs that
implement classes or complex functions as would be the case in object-oriented programming.
In most cases straightforward pieces of code would get the job done. Structured programming is
ideal for development of small programs as it would beat the purpose spending a lot of time and
energy designing classes when an entire working program could be developed within the same
time period.
This will also hold true in that small programs are easy to maintain and most fit within a single
page or so, making more sense for the Web developer to visualize the program code. It therefore
make structured programming well suited for small to medium website which would probably
not require much maintenance.
Structured programs are easy to read and understand as you would simply need to follow the
source code as it is written on the file as you would be guaranteed that there are no jumps or
deviations to other pieces of code in other files. This however does not mean such a program
would necessarily be easier to maintain; that brings me to the reason why object-oriented
programming would be suited in other situations.

Definition of Object-Oriented Programming

Object-oriented programming can be defined in simplest

terms as software application programming where there is an interaction
between self-contained mini-programs or objects within the main program.
In other terms, object-oriented programming can be known as the process
of using several classes to represent different areas of functionality or data
objects within your software application. These data objects have data fields
and functions that act on the data fields. The hold three main characteristics
which are encapsulation, inheritance, and polymorphism. Examples of
objects would include windows, menus, text inputs, icons, etc. There must
be procedures to manipulate them.
Object-oriented programming takes pride in its suitability for sustaining huge software and
web development projects. This is a far better option than using structured programming when
you have massive code bases. The sheer nature of object-oriented programs allows the
developer to save a lot of time and energy when developing programs as the components of the
programs are in the form of objects which can be plugged into the program wherever they are

needed. So having an application with several hundred buttons implemented as objects would
be pretty easy to maintain, for example, if the developer wanted to change the style or behavior
of all the buttons, it would simply entail changing a single object which defines everything
about the button and this would change every instance of the button object.
Even though object-oriented programming is suitable for large project and
long term maintenance of software of web projects, this method of
programming poses its own disadvantages as object-oriented programming
tends to be more complex than structured programming as there is a lot as
far as design the decisions that need to be made and consequently the
entire task of managing the project may be a bit difficult to the
inexperienced web developer.

Q.9 (a)
STUDENT MARKSHEET
#include
#include
#include

class stud
{
int rno,m1,m2,m3,tot;
char name[20];
float avg;

public:
void getdata()
{
cout<<"\n\nEnter the rno:";
cin>>rno;
cout<<"Enter the name:";
cin>>name;
cout<<"Enter the first marks:";
cin>>m1;
cout<<"Enter the second mark:";
cin>>m2;
cout<<"Enter the third mark:";
cin>>m3;
}

void caldata()
{
tot=m1+m2+m3;
avg=tot/3;
}

void putdata()
{
cout<<"\n"<<rno<< "\t="" ";=""
cout<<name<<"\t\t";
cout<<m1<<"\t";
cout<<m2<<"\t";
cout<<m3<<"\t";
cout<<tot<<"\t";
cout<
if(avg>=80)
cout<<"\t A";
else if(avg>=60&&avg<=79)
cout<<"\t B";
else if(avg>=40&&avg<=59)
cout<<"\t C";
else

cout<<"\t FAIL";
}
};

void main()
{
int i,n;
stud s[20];
clrscr();
cout<<"\n\t\t\t STUDENT MARKSHEET";
cout<<"\n\t\t\t ~~~~~~~~~~~~~~~~~~";
cout<<"\n ENTER THE NUMBER OF STUDENTS:";
cin>>n;
for(i=0;i
{
s[i].getdata();
s[i].caldata();
}
cout<<"\n\nRNO"<<"\t"<<"NAME"<<"\t\t"<<"M1"<<"\t"<<"M2"<<"\t"<<"M3"<<"\t"<<"TOT"<<"\t"<<"AVG"<<"\t"<<"GRADE"<<"\n";
cout<<"_______________________________________________________________";
for(i=0;i
{
s[i].putdata();
}
getch();
}

OUTPUT:

STUDENT MARKSHEET
~~~~~~~~~~~~~~~~~~

ENTER THE NUMBER OF STUDENTS : 3

Enter the rno:1

Enter the name:hussain

Enter the first marks:89

Enter the second mark:67
Enter the third mark:56

Enter the rno:2

Enter the name:kumar
Enter the first marks:45
Enter the second mark:67
Enter the third mark:89

Enter the rno:3

Enter the name:raju
Enter the first marks:78
Enter the second mark:98
Enter the third mark:90

RNO NAME M1 M2 M3 TOT AVG GRADE

________________________________________________________
1 hussain 89 67 56 212 70 B
2 kumar 45 67 89 201 67 B
3 raju 78 98 90 266 88 A
</tot<<"\t";></m3<<"\t";></m2<<"\t";></m1<<"\t";></name<<"\t\t";></rno<<>

Q.10 (a)
MFC Application Architecture Classes
Classes in this category contribute to the architecture of a framework
application. They supply functionality common to most applications. You fill
in the framework to add application-specific functionality. Typically, you do
so by deriving new classes from the architecture classes, and then adding
new members or overriding existing member functions.
Application wizards generate several types of applications, all of which use
the application framework in differing ways. SDI (single document interface)
and MDI (multiple document interface) applications make full use of a part

of the framework called document/view architecture. Other types of

applications, such as dialog-based applications, form-based applications,
and DLLs, use only some of document/view architecture features.
Document/view applications contain one or more sets of documents, views,
and frame windows. A document-template object associates the classes for
each document/view/frame set.
Although you do not have to use document/view architecture in your MFC
application, there are a number of advantages to doing so. The MFC OLE
container and server support is based on document/view architecture, as is
support for printing and print preview.
All MFC applications have at least two objects: an application object derived
from CWinApp, and some sort of main window object, derived (often
indirectly) from CWnd. (Most often, the main window is derived
from CFrameWnd, CMDIFrameWnd, or CDialog, all of which are derived
from CWnd.)
Applications that use document/view architecture contain additional objects.
The principal objects are:
An application object derived from class CWinApp, as mentioned
before.
One or more document class objects derived from class CDocument.
Document class objects are responsible for the internal representation
of the data manipulated in the view. They may be associated with a
data file.
One or more view objects derived from class CView. Each view is a
window that is attached to a document and associated with a frame
window. Views display and manipulate the data contained in a
document class object.
Synchronization Classes
Synchronizing resource access between threads is a common problem when
writing multithreaded applications. Having two or more threads
simultaneously access the same data can lead to undesirable and
unpredictable results. For example, one thread could be updating the
contents of a structure while another thread is reading the contents of the
same structure. It is unknown what data the reading thread will receive: the
old data, the newly written data, or possibly a mixture of both. MFC provides
a number of synchronization and synchronization access classes to aid in

solving this problem. This topic explains the classes available and how to
use them to create thread-safe classes in a typical multithreaded
application.
A typical multithreaded application has a class that represents a resource to
be shared among threads. A properly designed, fully thread-safe class does
not require you to call any synchronization functions. Everything is handled
internally to the class, allowing you to concentrate on how to best use the
class, not about how it might get corrupted. An effective technique for
creating a fully thread-safe class is to merge the synchronization class into
the resource class. Merging the synchronization classes into the shared
class is a straightforward process.
As an example, take an application that maintains a linked list of accounts.
This application allows up to three accounts to be examined in separate
windows, but only one can be updated at any particular time. When an
account is updated, the updated data is sent over the network to a data
archive.
This example application uses all three types of synchronization classes.
Because it allows up to three accounts to be examined at one time, it
uses CSemaphore to limit access to three view objects. When an attempt to
view a fourth account occurs, the application either waits until one of the
first three windows closes or it fails. When an account is updated, the
application uses CCriticalSection to ensure that only one account is updated
at a time. After the update succeeds, it signals CEvent, which releases a
thread waiting for the event to be signaled. This thread sends the new data
to the data archive.
Q.11 (a)
StaticText control
StaticText is display text that the user can select but cannot modify with the keyboard.
You can explicitly modify the StaticText in a script.
Properties
StaticText
property

Datatype

AccessibleDescrip String
tion

Description

A description of the control and/or its purpose for

use by accessibility tools such as readers for
visually impaired users.

StaticText
property

Datatype

Description

AccessibleName

String

A label that briefly describes the control, such as

the text in a button or the name of a menu item.

AccessibleRole

AccessibleRole Describes what kind of user interface element the

(enumerated) control is.

Alignment

Alignment
(enumerated)

Specifies the text alignment in the control. Values

are:

Left!

Center!

Right!

BackColor

Long

Specifies the numeric value of the background

color: -2 to 16,777,215. For more information about
color, see the RGB function in the PowerScript
Reference.

Border

Boolean

Specifies whether the control has a border. Values

are:

TRUE Control has a border.

FALSE Control does not have a border.

BorderColor

Long

Specifies the numerical value of the border color:

-2 to 16,777,215.

BorderStyle

BorderStyle
(enumerated)

Specifies the style of the border of the control.

Values are:

StaticText
property

BringToTop

Datatype

Description

StyleBox!

StyleLowered!

StyleRaised!

StyleShadowBox!

Boolean

Specifies whether PowerBuilder moves the control

to the top of the front-to-back order of the window.
Values are:

TRUE Control moved to top.

FALSE Control not moved to top.

ClassDefinition

PowerObject

An object of type PowerObject containing

information about the class definition of the object
or control.

DisabledLook

Boolean

Specifies whether the control appears to be

enabled.

DragAuto

Boolean

Specifies whether PowerBuilder puts the control

automatically into Drag mode. Values are:

TRUE When the control is clicked, the

control is automatically in Drag mode.

FALSE When the control is clicked, the

control is not automatically in Drag mode. You
have to manually put the control into Drag mode
by using the Drag function.

StaticText
property

Datatype

Description

DragIcon

String

Specifies the name of the stock icon or the file

containing the icon you want to display when the
user drags the control (the ICO file). The default
icon is a box the size of the control.
When the user drags the control, the icon displays
when the control is over an area in which the
control can be dropped (a valid drop area). When
the control is over an area that is not a valid drop
area, the No-Drop icon displays.

Enabled

Boolean

Specifies whether the control is enabled (can be

selected). Values are:

TRUE Control can be selected.

FALSE Control cannot be selected.

FaceName

String

Specifies the name of the typeface in which the

text of the control displays (for example, Arial or
Courier).

FillPattern

FillPattern
(enumerated)

Specifies the hatch pattern used to fill the control.

Values are:

BDiagonal!

Diamond!

FDiagonal!

Horizontal!

Solid!

Square!

StaticText
property

Datatype

Description

Vertical!
FDiagonal! is lines going from the lower-left to the
upper-right. BDiagonal! is lines going from the
upper-left to the lower right.

FocusRectangle

Boolean

Specifies whether a dotted rectangle (focus

rectangle) frames the control when it has focus.
Values are:

TRUE Control framed when it has focus.

FALSE Control not framed when it has
focus.

FontCharSet

FontCharSet
(enumerated)

Specifies the font character set used for the text in

the control. For a complete list of possible values,
see the list of properties for the FontCharSet
variable on the Enumerated tab page of the
Browser.

FontFamily

FontFamily
(enumerated)

Specifies the font family (type style) used for the

text in the control. Values are:

AnyFont!

Decorative!

Modern!

Roman!

Script!

Swiss!

StaticText
property

FontPitch

Datatype

Description

FontPitch
(enumerated)

Specifies the pitch (spacing) of the font used for

the text in the control. Values are:

Default!

Fixed!

Variable!

Height

Integer

Specifies the height of the rectangular box that

contains the control, in PowerBuilder units.

Italic

Boolean

Specifies whether the text in the control is italic.

Values are:

TRUE Text is italic.

FALSE Text is not italic.

Pointer

String

Specifies the name of the stock pointer or the file

containing the pointer used for the control.

RightToLeft

Boolean

Specifies that characters should be displayed in

right-to-left order. The application must be running
on an operating system that supports right-to-left
display. Values are:

TabOrder

Integer

TRUE Characters display in right-to-left

order.

FALSE Characters display in left-to-right

order.

Specifies the tab value of the control within the

StaticText
property

Datatype

Description

window (0 is the default and means the user

cannot tab to the control).

Tag

String

Specifies the tag value assigned to the control.

Text

String

Specifies the text that displays in the control.

TextColor

Long

Specifies the numeric value of the text color in the

control: -2 to 16,777,215. For more information
about color, see the RGB function in
the PowerScript Reference.

TextSize

Integer

Specifies the size of the text in the control, in

points. For backward compatibility, the size is
stored as a negative number; for example, 10-point
text size is stored as -10.

Underline

Boolean

Specifies whether the text in the control is

underlined. Values are:

Visible

Weight

TRUE Text is underlined.

FALSE Text is not underlined.

Boolean

Integer

Specifies whether the control is visible. Values are:

TRUE Control is visible.

FALSE Control is not visible.

Specifies the stroke weight of the text in the

StaticText
property

Datatype

Description

control; for example, 400 for normal or 700 for

bold.

Width

Integer

Specifies the width of the rectangular box that

contains the control, in pixels.

Integer

Specifies the X position (the distance from the left

edge of the window), in PowerBuilder units.

Integer

Specifies the Y position (the distance from the top

of the window), in PowerBuilder units.