Qt_widget

Navigation: Up, Table of Contents, Bibliography, Index, Title Page

CGAL::Qt_widget

Definition

An object of type Qt_widget is a two-dimensional window for graphical IO. It is a class that is designed to help CGAL users to visualize easily CGAL objects and for advanced users to interact with them. This widget is designed for 2D CGAL objects only.

#include <CGAL/IO/Qt_widget.h>

Inherits From

QWidget

Types

The widget class also defines the following enum type to specify which kind of point representation do you want to use:

enum PointStyle { PIXEL , CROSS , PLUS , CIRCLE , DISC , RECT , BOX };

Creation

Qt_widget win ( QWidget *parent = 0, const char *name =);
Constructs a widget which is a child of parent, with the name name. The default visible area is between ranges xmin = -1, xmax = 1, ymin = -1, ymax = 1. By default the X and Y scale factors are equal.

Qt_widget provides scaling support. You can use a scaling factor for your objects as well as you can draw the objects with one scale and look at the objects with different scales. Also there is a possibility to tell the widget that you want that the visible area should be mapped to a certain interval, and the widget adjust the scaling factor according to that.

void
win.set_window ( double x_min,
double x_max,
double y_min,
double y_max,
bool u = false)

Map the widget coordinates to the interval defined by the rectangle with given coordinates. This method should be called after resize() from QWidget. If u is true the X and Y scale factors will not be equal and the widget will not keep the aspect ratio.

void win.set_x_scale ( double xscale)
Set the current X scaling factor. Actually the scales are recomputed when you resize, so this method is not used very often.

void win.set_y_scale ( double yscale)
Set the current Y scaling factor. Actually the scales are recomputed when you resize, so this method is not used very often.

advanced

You should have the same scaling factor for X and Y if you want to keep the aspect ratio of your objects.

advanced

void win.zoom ( double ratio)
Multiply the X and Y scaling factors by ratio, then calls redraw. The center of the visible area remains the same.

void win.zoom ( double ratio, double xc, double yc)
Multiply the X and Y scaling factors by ratio, then calls redraw. The center of the visible area becomes (xc, yc).

void
win.move_center ( const double distx,
const double disty)

Move the center of the widget with distx on the X axis and disty on the Y axis.

void win.set_center ( const double x, const double y)
Set the center of the widget to (x, y).

void win.add_to_history ()
Deprecated: This function adds the current viewport and transformations to history. You should use save() public slot from Qt_widget_history object.

void win.clear_history ()
Deprecated: Clears the history. This means that there are no elements in the history list. Call this method when you want to reinitialize the history list. You should use clear_history() method from Qt_widget_standard_toolbar or the clear() public slot from Qt_widget_history object.

public slots:

bool	win.back ()
bool	win.forth ()	Deprecated: This slots permit to walk into history. Return true if succeded. These slots are deprecated. You should use the backward() and forward() methods of Qt_widget_history object, or the back() and forward() public slots from Qt_widget_standard_toolbar object.

void	win.clear ()	Clear the screen. The properties of the widget remain the same after calling this member function. You can see a list of the properties that you can set at the properties description.

void	win.lock ()	Locks the widget, keeping the widget from being refreshed. If you lock the widget you should verify that you unlock it somewhere. The number of lock() calls should be the same with the number of unlock() calls. Lock and unlock calls can be nested.

void	win.unlock ()	Unlocks the widget, and calls do_paint(). The widget is only unlocked if the number of unlock calls is equal to the number of lock calls.

void	win.do_paint ()	Refresh the widget calling paintEvent(QPaintEvent e)* for the Qt_widget only if the widget is unlocked. This mean that redraw() is called if and only if the widget is unlocked.

void	win.redraw ()	If you derive from Qt_widget you have to overload this function and put your code for drawing here if you don't use layers. The best way is to attach layers to the widget and call this method. This method redraws the layers attached and active. Before drawing the layers, redraw clear the screen and emit redraw_on_back(). Emit redraw_on_front() at the end.

void	win.print_to_ps ()	Redraws all the attached and active layers into a Postscript device. It could be a file or a printer. This method also use signals as redraw_on_back() or redraw_on_front().

Properties

You can set the properties of the functions through this functions as well as with the help of manipulators described later. The function naming convention has changed for this member functions, to Qt convention.

void win.setColor ( Qcolor c)
Set the current pen color of the widget to be c.

void win.setBackgroundColor ( QColor c)
Set the current background color to be c.

void win.setFillColor ( QColor c)
Set the current fill color of the widget to be c.

void win.setFilled ( bool f)
Set the status of the widget to true or false concerning filling the objects: polygons, circles, rectangles ...

void win.setLineWidth ( unsigned int i)
Set the current line width of the widget.

void win.setPointSize ( unsigned int i)
Set the current point size of the widget.

void win.setPointStyle ( PointStyle s)
Set the current point style of the widget to s. PointStyle is a enumeration declared in Qt_widget.

void win.setRasterOp ( RasterOp r)
Set the current raster operation.

Layers

void win.attach ( Qt_widget_layer* s)
Add the layer s in the list of layers.The last added will be on top of the screen. Also the events are forwarded to layers in the order they have been attached.

void win.detach ( Qt_widget_layer* s)
Remove the layer s from the list. s it's a pointer to an existing layer.

New CGAL Objects

void	win.new_object ( CGAL::Object obj)
		This function should be called by the tools that create CGAL objects. It then emits the signal new_cgal_object(CGAL::Object). Slots of other components can be connected to this signal.

Access Functions

Note that we use also types from Qt here.

QColor win.color () Returns the current pen color. The color returned is a Qt class.

QColor win.backgroundColor ()
Returns the current widget background color. The color returned is a Qt class.

QColor win.fillColor () Returns the current color used for filling the objects. The color returned is a Qt class.

PointStyle win.pointStyle () Returns the current point style. PointStyle is a enumeration declared in Qt_widget.

uint win.pointSize () Returns the current point size.

uint win.lineWidth () Returns the current line width.

RasterOp win.rasterOp () Return the current raster operation.

double win.x_min () Returns the left x coordinate of the widget.

double win.y_min () Returns the lower y coordinate of the widget.

double win.x_max () Returns the right x coordinate of the widget.

double win.y_max () Returns the upper y coordinate of the widget.

advanced

The coordinates of the screen are maped to a certain interval that you can choose with set_window member function. The scale of the objects you can visualize is computed and maintained the same for both axes to keep the aspect ratio of the objects. You should use x_real or y_real to get the real world coordinates, for your screen coordinates. If you are using gmp you can use this functions with Gmpq as second parameter. You may need it when you work with rationals. The double from the other function could be more complex and can make you loose speed in computations. Computing with rational coordinates directly could increase the speed, rather than computing with complex double coordinates.

double win.x_real ( int x)

double win.y_real ( int y)

template<class FT>

void x_real ( int x, FT&)
Returns the x real world coordinate of the Qt_widget.

template<class FT>

void y_real ( int y, FT&)
Returns the y real world coordinate of the Qt_widget.

void win.x_real ( int, Gmpq&)

void win.y_real ( int, Gmpq&)

end of advanced section advanced

int win.x_pixel ( double x)
This method is the opposite of x_real method. Converts the world coordinates in screen coordinates. If you want to get an integer between 0 and width, you should pass an x between xmin and xmax.

int win.y_pixel ( double y)
This method is the opposite of y_real method. Converts the world coordinates in screen coordinates. If you want to get an integer between 0 and height, you should pass an y between ymin and ymax.

advanced

Painter and Pixmap

In order that layers can draw on the drawing area of a widget, they have to access the underlying pixmap and painter.

Qt_widget use as a backbuffer for drawing a pixmap defined inside the class, i.e. an object of type QPixmap. The QPixmap class is an off-screen pixel-based paint device. One common use of the QPixmap class is to enable smooth updating of widgets. The QPainter class paints on paint devices. There is an object of type QPainter defined in Qt_widget that uses as a paint device the QPixmap object.

QPixmap& win.get_pixmap () Returns the current pixmap.

QPainter& win.get_painter () Returns the current painter.

end of advanced section advanced

Signals

void win.s_mousePressEvent ( QMouseEvent *e)

void win.s_mouseReleaseEvent ( QMouseEvent *e)

void win.s_mouseMoveEvent ( QMouseEvent *e)

void win.s_paintEvent ( QPaintEvent *e)

void win.s_resizeEvent ( QResizeEvent *e)

void win.s_wheelEvent ( QMouseEvent *e)

void win.s_mouseDoubleClickEvent ( QMouseEvent *e)

void win.s_keyPressEvent ( QKeyEvent *e)

void win.s_keyReleaseEvent ( QKeyEvent *e)

void win.s_enterEvent ( QEvent *e)

void win.s_leaveEvent ( QEvent *e)

void win.s_event ( QEvent *e)
The Qt_widget receives the events through virtual functions. This is the mechanism that Qt offers for dispaching events. This signals are called every time an event is dispatched to a virtual function. For example if Qt_widget receives mousePressEvent(QMouseEvent *e) emits s_mousePressEvent(e). This is very useful when you have only a pointer to Qt_widget. It is enough to connect this slot to your function to receive the event.

void win.new_cgal_object ( CGAL::Object)
Triggered when a new object from a tool is received. The user should catch this signal if it's working with tools that provide CGAL objects as input.

void win.custom_redraw ()
Deprecated: Emitted in the redraw() function after the layers are drawn.

void win.redraw_on_back ()
Emmitted in redraw() method before calling layer's redraw.

void win.redraw_on_front ()
Emmitted in redraw() method after calling layer's redraw.

void win.rangesChanged ()
Emmitted each time (xmin, xmax) and (ymin, ymax) ranges are changed.

Operators for Output

The output operator is defined for all geometric classes in the CGAL kernel.

template<class R>

Qt_widget& & win << Point_2<R> p

template<class R>

Qt_widget& & win << Segment_2<R> s

template<class R>

Qt_widget& & win << Line_2<R> l

template<class R>

Qt_widget& & win << Ray_2<R> r

template<class R>

Qt_widget& & win << Triangle_2<R> t

template<class R>

Qt_widget& & win << Iso_rectangle_2<R> r

template<class R>

Qt_widget& & win << Circle_2<R> c

To use the other operators described you have to include the right header.

#include <CGAL/IO/Qt_widget_Polygon_2.h>

template<class Tr, class Co>

Qt_widget& & win << Polygon_2<Tr,Co> pol

#include <CGAL/IO/Qt_widget_Min_ellipse_2.h>

template<class Traits_>

Qt_widget& &win << Min_ellipse_2<Traits_> min_ellipse

#include <CGAL/IO/Qt_widget_Optimisation_ellipse_2.h>

template<class Traits_>

Qt_widget& &win << Optimisation_ellipse_2<Traits_> oe

#include <CGAL/IO/Qt_widget_Optimisation_circle_2.h>

template<class Traits>

Qt_widget& &win << Optimisation_circle_2<Traits_> oc

#include <CGAL/IO/Qt_widget_Conic_2.h>

template<class R>

Qt_widget& & win << Conic_2<R> c

#include <CGAL/IO/Qt_widget_Triangulation_2.h>

template <class Gt, class Tds>

Qt_widget& & win << Triangulation_2<Gt, Tds> t

#include <CGAL/IO/Qt_widget_Alpha_shape_2.h>

template <class Dt>

Qt_widget& & win << Alpha_shape_2<Dt> As

#include <CGAL/IO/Qt_widget_Delaunay_triangulation_2.h>

template<class Gt, class Tds>

Qt_widget& & win << Delaunay_triangulation_2<R> dt

#include <CGAL/IO/Qt_widget_Constrained_triangulation_2.h>

template<class Gt, class Tds>

Qt_widget& & win << Constrained_triangulation_2<Gt, Tds> t

#include <CGAL/IO/Qt_widget_Regular_triangulation_2.h>

template<class Gt, class Tds>

Qt_widget& & win << Regular_triangulation_2<Gt, Tds> t

Manipulators for Qt_widget

A manipulator is an object which can be inserted in the Qt_widget , via the operator <<, to change the context for further drawing.

Here, we simply document the use of these operators which is all the user needs to know to modify the state of a stream.

Qt_widget& & win << BackgroundColor( Color c)
Sets the color used for background color.

Qt_widget& & win << FillColor( Color c)
Sets the color used for filling the objects.

Qt_widget& & win << LineWidth(const unsigned int i)
Sets the width of the line for drawing objects.

Qt_widget& & win << PointSize(const unsigned int i)
Sets the size of the points.

Qt_widget& & win << noFill Sets the state of Qt_widget concerning filling the objects to be false.

Qt_widget& & win << Color c Sets the color used as the Qt_widget fillColor.

Qt_widget& & win << PointStyle ps
Sets the point style for Qt_widget.

Example

In the given example, that is found in tutorial/Qt_widget/tutorial1/tutorial1.C, we create an object of type Qt_widget and then we use the operators for output and the manipulators to show some of the widget's functionality.

#include <CGAL/Cartesian.h>
#include <CGAL/Bbox_2.h>
#include <list>
#include <CGAL/Polygon_2.h>
#include <CGAL/IO/Qt_widget_Polygon_2.h>
#include <qapplication.h>
#include <CGAL/IO/Qt_widget.h>

typedef CGAL::Cartesian<int>   Rep;
typedef CGAL::Point_2<Rep>     Point;
typedef CGAL::Circle_2<Rep>    Circle;
typedef CGAL::Segment_2<Rep>   Segment;
typedef CGAL::Line_2<Rep>      Line;
typedef CGAL::Ray_2<Rep>       Ray;
typedef CGAL::Triangle_2<Rep>  Triangle;
typedef CGAL::Iso_rectangle_2<Rep>
                               Cgal_Rectangle;
typedef CGAL::Bbox_2           BBox;
typedef std::list<Point>       Container;
typedef CGAL::Polygon_2<Rep,Container>
                               Cgal_Polygon;

int main( int argc, char **argv )
{
  QApplication app( argc, argv );
  using namespace CGAL;
  CGAL::Qt_widget * W = new CGAL::Qt_widget();
  app.setMainWidget( W );
  W->resize(600, 600);
  W->set_window(0, 600, 0, 600);
  W->show();
  //painting something on the screen
  W->lock();

  *W << BackgroundColor(ORANGE) << RED <<
  LineWidth(3) << PointSize(3) << PointStyle(DISC);
  *W << Segment(Point(10,20),Point(300,400));
  *W << LineWidth(5) << GREEN << FillColor(BLACK) <<
    Circle(Point(400,400),50*50);
  *W << LineWidth(1) << noFill << Circle(Point(300,300),300*300);
  *W << BLUE << LineWidth(2);
  *W << Segment(Point(200,200),Point(400,400));
  *W << Segment(Point(200,400),Point(400,200));
  W->setFilled(TRUE);
  *W << RED << Triangle(Point(150,300),
                                  Point(150,350),
                                  Point(100,325));
  *W << FillColor(RED) << Cgal_Rectangle(Point(320,220),
                                              Point(350,240));
  *W << DEEPBLUE << BBox(100,80,260,140);
  Cgal_Polygon p;
  p.push_back(Point(300,30));
  p.push_back(Point(400,30));
  p.push_back(Point(500,130));
  p.push_back(Point(400,180));
  p.push_back(Point(300,130));
  *W << p;
  *W << Ray(Point(200,400), Point(180,430))
    << Ray(Point(200,400), Point(180,370));
  W->unlock();

  return app.exec();
}

Next: Qt_widget_layer

Navigation: Table of Contents, Bibliography, Index, Title Page

The CGAL Project . Tue, December 21, 2004 .

Qt_widget win ( QWidget parent = 0, const char name =);
	Constructs a widget which is a child of parent, with the name name. The default visible area is between ranges xmin = -1, xmax = 1, ymin = -1, ymax = 1. By default the X and Y scale factors are equal.

void	win.setColor ( Qcolor c)
		Set the current pen color of the widget to be c.

void	win.setBackgroundColor ( QColor c)
		Set the current background color to be c.

void	win.setFillColor ( QColor c)
		Set the current fill color of the widget to be c.

void	win.setFilled ( bool f)
		Set the status of the widget to true or false concerning filling the objects: polygons, circles, rectangles ...

void	win.setLineWidth ( unsigned int i)
		Set the current line width of the widget.

void	win.setPointSize ( unsigned int i)
		Set the current point size of the widget.

void	win.setPointStyle ( PointStyle s)
		Set the current point style of the widget to s. PointStyle is a enumeration declared in Qt_widget.

void	win.setRasterOp ( RasterOp r)
		Set the current raster operation.

void	win.attach ( Qt_widget_layer s)*
		Add the layer s in the list of layers.The last added will be on top of the screen. Also the events are forwarded to layers in the order they have been attached.

void	win.detach ( Qt_widget_layer s)*
		Remove the layer s from the list. s it's a pointer to an existing layer.

QColor	win.color ()	Returns the current pen color. The color returned is a Qt class.

QColor	win.backgroundColor ()
		Returns the current widget background color. The color returned is a Qt class.

QColor	win.fillColor ()	Returns the current color used for filling the objects. The color returned is a Qt class.

PointStyle	win.pointStyle ()	Returns the current point style. PointStyle is a enumeration declared in Qt_widget.

uint	win.pointSize ()	Returns the current point size.

uint	win.lineWidth ()	Returns the current line width.

RasterOp	win.rasterOp ()	Return the current raster operation.

double	win.x_min ()	Returns the left x coordinate of the widget.

double	win.y_min ()	Returns the lower y coordinate of the widget.

double	win.x_max ()	Returns the right x coordinate of the widget.

double	win.y_max ()	Returns the upper y coordinate of the widget.

double	win.x_real ( int x)
double	win.y_real ( int y)

template<class FT>
void	x_real ( int x, FT&)
		Returns the x real world coordinate of the Qt_widget.

template<class FT>
void	y_real ( int y, FT&)
		Returns the y real world coordinate of the Qt_widget.

void	win.x_real ( int, Gmpq&)
void	win.y_real ( int, Gmpq&)

int	win.x_pixel ( double x)
		This method is the opposite of x_real method. Converts the world coordinates in screen coordinates. If you want to get an integer between 0 and width, you should pass an x between xmin and xmax.

int	win.y_pixel ( double y)
		This method is the opposite of y_real method. Converts the world coordinates in screen coordinates. If you want to get an integer between 0 and height, you should pass an y between ymin and ymax.

QPixmap&	win.get_pixmap ()	Returns the current pixmap.

QPainter&	win.get_painter ()	Returns the current painter.

void	win.s_mousePressEvent ( QMouseEvent e)*
void	win.s_mouseReleaseEvent ( QMouseEvent e)*
void	win.s_mouseMoveEvent ( QMouseEvent e)*
void	win.s_paintEvent ( QPaintEvent e)*
void	win.s_resizeEvent ( QResizeEvent e)*
void	win.s_wheelEvent ( QMouseEvent e)*
void	win.s_mouseDoubleClickEvent ( QMouseEvent e)*
void	win.s_keyPressEvent ( QKeyEvent e)*
void	win.s_keyReleaseEvent ( QKeyEvent e)*
void	win.s_enterEvent ( QEvent e)*
void	win.s_leaveEvent ( QEvent e)*
void	win.s_event ( QEvent e)*
		The Qt_widget receives the events through virtual functions. This is the mechanism that Qt offers for dispaching events. This signals are called every time an event is dispatched to a virtual function. For example if Qt_widget receives mousePressEvent(QMouseEvent e)* emits s_mousePressEvent(e). This is very useful when you have only a pointer to Qt_widget. It is enough to connect this slot to your function to receive the event.

void	win.new_cgal_object ( CGAL::Object)
		Triggered when a new object from a tool is received. The user should catch this signal if it's working with tools that provide CGAL objects as input.

void	win.custom_redraw ()
		Deprecated: Emitted in the redraw() function after the layers are drawn.

void	win.redraw_on_back ()
		Emmitted in redraw() method before calling layer's redraw.

void	win.redraw_on_front ()
		Emmitted in redraw() method after calling layer's redraw.

void	win.rangesChanged ()
		Emmitted each time (xmin, xmax) and (ymin, ymax) ranges are changed.

template<class R>
Qt_widget&	& win << Point_2<R> p

template<class R>
Qt_widget&	& win << Segment_2<R> s

template<class R>
Qt_widget&	& win << Line_2<R> l

template<class R>
Qt_widget&	& win << Ray_2<R> r

template<class R>
Qt_widget&	& win << Triangle_2<R> t

template<class R>
Qt_widget&	& win << Iso_rectangle_2<R> r

template<class R>
Qt_widget&	& win << Circle_2<R> c

template<class Tr, class Co>
Qt_widget&	& win << Polygon_2<Tr,Co> pol

template<class Traits_>
Qt_widget&	&win << Min_ellipse_2<Traits_> min_ellipse

template<class Traits_>
Qt_widget&	&win << Optimisation_ellipse_2<Traits_> oe

template<class Traits>
Qt_widget&	&win << Optimisation_circle_2<Traits_> oc

template <class Gt, class Tds>
Qt_widget&	& win << Triangulation_2<Gt, Tds> t

template <class Dt>
Qt_widget&	& win << Alpha_shape_2<Dt> As

template<class Gt, class Tds>
Qt_widget&	& win << Delaunay_triangulation_2<R> dt

template<class Gt, class Tds>
Qt_widget&	& win << Constrained_triangulation_2<Gt, Tds> t

template<class Gt, class Tds>
Qt_widget&	& win << Regular_triangulation_2<Gt, Tds> t

Qt_widget&	& win << BackgroundColor( Color c)
		Sets the color used for background color.
Qt_widget&	& win << FillColor( Color c)
		Sets the color used for filling the objects.
Qt_widget&	& win << LineWidth(const unsigned int i)
		Sets the width of the line for drawing objects.
Qt_widget&	& win << PointSize(const unsigned int i)
		Sets the size of the points.
Qt_widget&	& win << noFill	Sets the state of Qt_widget concerning filling the objects to be false.
Qt_widget&	& win << Color c	Sets the color used as the Qt_widget fillColor.
Qt_widget&	& win << PointStyle ps
		Sets the point style for Qt_widget.