You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
222 lines
8.3 KiB
222 lines
8.3 KiB
/*!
|
|
\page helpsystem-example.html
|
|
|
|
\ingroup examples
|
|
\title Helpsystem
|
|
|
|
This example demonstrates the different TQt classes
|
|
that can be used to provide context sensitive help
|
|
in an application.
|
|
|
|
It uses QToolTip and QWhatsThis to provide both static and
|
|
dynamic balloon help for the widgets in the application, and
|
|
QToolTipGroup to display extended information for each tooltip
|
|
in the statusbar. QAssistantClient is used to display help
|
|
pages using TQt Assistant.
|
|
|
|
The application has a user interface based on a
|
|
QMainWindow with a menubar, statusbar and a toolbar, and uses
|
|
a QTable as the central widget.
|
|
\quotefile helpsystem/tooltip.h
|
|
\skipto : public QToolTip
|
|
\printuntil };
|
|
|
|
Two QToolTip subclasses implement dynamic tooltips for
|
|
QHeader and QTable by reimplementing maybeTip(). The
|
|
constructors differ from the QToolTip constructor in having a
|
|
QHeader and a QTable respectively as the first parameter for
|
|
the constructor instead of a QWidget. This is because
|
|
we want to ensure that only headers and tables can be
|
|
passed as arguments. A QToolTipGroup can be provided as the
|
|
second argument to show tooltips in, for example a statusbar.
|
|
|
|
\printuntil };
|
|
|
|
The TableToolTip class keeps a reference to the QTable
|
|
as a member for easier access of the QTable object later on.
|
|
|
|
\quotefile helpsystem/tooltip.cpp
|
|
\skipto HeaderToolTip::HeaderToolTip
|
|
\printuntil }
|
|
|
|
The HeaderToolTip constructor propagates the parameters
|
|
to the QToolTip constructor.
|
|
\printuntil }
|
|
|
|
The implementation of maybeTip() uses the QHeader API
|
|
to get the section at the requested position and uses
|
|
QToolTip::tip() to display the section's label in a
|
|
tooltip. The second string is used by QToolTipGroup and will
|
|
show up in the statusbar.
|
|
|
|
\printuntil }
|
|
|
|
Since QTable is a QScrollView all user interaction
|
|
happens on QTable's viewport() . The TableToolTip
|
|
constructor passes the viewport() and the tooltip
|
|
group to the QToolTip constructor, and initializes the table
|
|
member with the QTable pointer itself.
|
|
\printto moveTopLeft
|
|
|
|
The implementation of maybeTip() uses the QTable API
|
|
to get information about the cell at the requested position.
|
|
The QTable API expects contents coordinates, and since the
|
|
requested point is relative to the viewport we need to translate
|
|
the coordinates before we can use QTable's functions.
|
|
\printuntil }
|
|
\quotefile helpsystem/whatsthis.h
|
|
\skipto class WhatsThis
|
|
|
|
We translate the cell's geometry back to viewport coordinates
|
|
so that the tooltip disappears when the mouse cursor leaves
|
|
the cell, and use QToolTip::tip() to display the cell's label
|
|
in a tooltip and to provide text for the QToolTipGroup as before.
|
|
\printuntil };
|
|
\quotefile helpsystem/whatsthis.cpp
|
|
\skipto WhatsThis::WhatsThis
|
|
|
|
|
|
The WhatsThis class is a subclass of both QObject and
|
|
QWhatsThis and serves as a base class for the HeaderWhatsThis
|
|
and TableWhatsThis classes. \footnote Note that moc requires that QObject
|
|
is the first base class. \endfootnote WhatsThis
|
|
reimplements clicked() which will be called when the user clicks
|
|
inside the "What's this?" window. It also declares a signal
|
|
linkClicked() which will be emitted when a hyperlink is clicked.
|
|
\printuntil }
|
|
|
|
The WhatsThis constructor takes two parameters, the first is the
|
|
widget we want to provide WhatsThis for, and the second is the
|
|
one which receives the events. Normally this is the same widget,
|
|
but some widgets, like QTable, are more complex and have a
|
|
viewport() widget which receives the events. If such a widget
|
|
is passed to the constructor it will propagate the parameter to
|
|
the QWhatsThis constructor and store the QWidget pointer itself
|
|
in it's member variable to allow easier use of the QWidget API
|
|
later on.
|
|
\skipto bool WhatsThis::clicked
|
|
\printuntil }
|
|
\quotefile helpsystem/whatsthis.h
|
|
\skipto class HeaderWhatsThis
|
|
|
|
The implementation of clicked() emits the linkClicked() signal
|
|
if a hyperlink has been clicked.
|
|
\printuntil };
|
|
|
|
\printuntil };
|
|
|
|
\quotefile helpsystem/whatsthis.cpp
|
|
\skipto HeaderWhatsThis::HeaderWhatsThis
|
|
|
|
The HeaderWhatsThis and TableWhatsThis classes reimplement
|
|
text() to make it possible to return texts depending on the
|
|
mouse click's position. All the other functionality is
|
|
already provided by the generic WhatsThis base class. We ensure
|
|
type safety here in the same manner as in the tooltip classes.
|
|
\printuntil }
|
|
|
|
The HeaderWhatsThis constructor propagates the parameter to the
|
|
WhatsThis constructor.
|
|
\printto TableWhatsThis::TableWhatsThis
|
|
|
|
The implementation of text() uses the QHeader API to determine
|
|
whether we have a horizontal or a vertical header and returns
|
|
a string which states the header's orientation and section.
|
|
\footnote
|
|
Note that we have to explicitly scope the orientation
|
|
(QObject or QWhatsThis) since HeaderWhatsThis uses multiple
|
|
inheritance. \endfootnote
|
|
\printuntil }
|
|
|
|
Since QTable is a scrollview and has a viewport() which receives
|
|
the events, we propagate the table itself and the table's
|
|
viewport() to the WhatsThis constructor.
|
|
\printuntil }
|
|
\printuntil }
|
|
\printuntil }
|
|
\printuntil }
|
|
|
|
The implementation of text() uses the QTable API to get
|
|
information about the cell at the requested position.
|
|
The QTable API expects contents coordinates, so we need to
|
|
translate the point as shown earlier for the tooltip classes.
|
|
We use the rtti() function to figure out the item's type
|
|
and return a string accordingly.
|
|
|
|
\quotefile helpsystem/mainwindow.h
|
|
\skipto class MainWindow
|
|
\printuntil };
|
|
|
|
A QMainWindow is used to create a user interface that uses the
|
|
above classes in addition to TQt Assistant to provide context
|
|
sensitive help in the application.
|
|
|
|
The MainWindow class declares a slot called assistantSlot()
|
|
which creates an instance of TQt Assistant when it is called.
|
|
The class keeps references to the tooltip classes as members
|
|
because they are not QObjects and need to be deleted explicitly.
|
|
The class has a reference to QAssistantClient as a
|
|
member as well, to allow easier access to TQt Assistant later on.
|
|
|
|
\quotefile helpsystem/mainwindow.cpp
|
|
\skipto MainWindow::MainWindow
|
|
\printuntil assistant
|
|
|
|
The MainWindow constructor creates an instance of
|
|
QAssistantClient using QString::null as the first argument
|
|
so that the system path is used.
|
|
\printto QWhatsThis::whatsThisButton
|
|
|
|
A QTable is used as the central widget and the table, the menus
|
|
and the toolbar are populated.
|
|
\printto // create
|
|
|
|
The static function whatsThisButton() creates a QToolButton
|
|
which will enter "What's this?" mode when clicked.
|
|
\printto // set up
|
|
|
|
A QToolTipGroup is created and will show and remove tooltips
|
|
in the statusbar as the tooltips are displayed on the widgets.
|
|
\printto // set up whats this
|
|
|
|
The tooltips are set up. The static function add() sets up a
|
|
tooltip on the Assistant toolbutton. Tooltip objects are created
|
|
using the QToolTip subclasses, the constructor's first parameter
|
|
specifies the widget we want to add dynamic tooltips for and the
|
|
second argument specifies the QToolTipGroup they should belong
|
|
to.
|
|
\printto // connections
|
|
|
|
The WhatsThis help is set up. The static function add() adds
|
|
What's This? help for the toolbutton which opens Assistant.
|
|
Instances of the two WhatsThis subclasses are created for the
|
|
headers and the table. What's This? help is also added for the
|
|
menu items.
|
|
\printto MainWindow::~MainWindow
|
|
|
|
Signals and slots are connected, so that the relevant pages will
|
|
be displayed in TQt Assistant when clicking on a hyperlink or on
|
|
the assistant button.
|
|
\printuntil }
|
|
|
|
The destructor deletes the tooltips. We need to delete the
|
|
tooltips explicitly since QToolTip is, as mentioned above, not
|
|
a subclass of QObject and the instances of QToolTip not will be
|
|
deleted when the widget is deleted.
|
|
\printuntil }
|
|
|
|
The assistantSlot() uses applicationDirPath() to find the
|
|
location of the documentation files and shows the specified page
|
|
in TQt Assistant.
|
|
\quotefile helpsystem/main.cpp
|
|
\skipto #include
|
|
\printuntil }
|
|
|
|
The main function is a standard implementation opening
|
|
the application main window.
|
|
|
|
To build the example go to the helpsystem directory
|
|
(TQTDIR/examples/helpsystem) run qmake to generate the makefile,
|
|
and use the make tool to build the library.
|
|
*/
|