copy the parts of gsoc2024-basic_viewer_glfw-tgrillon that concern only the qt basic viewer

Author: gdamiand

Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/draw_arrangement_2.h

@@ -29,11 +29,8 @@ namespace CGAL {
  * `CGAL::Arrangement_2` class template. Parameters of the drawing are taken
  * from the optional graphics scene options parameter.
  *
- * A call to this function blocks the execution of the program until the drawing
- * window is closed. This function requires `CGAL_Qt6`, and is only available if
- * the macro `CGAL_USE_BASIC_VIEWER` is defined.  Linking with the cmake target
- * `CGAL::CGAL_Basic_viewer` will link with `CGAL_Qt6` and add the definition
- * `CGAL_USE_BASIC_VIEWER`.
+A call to this function blocks the execution of the program until the drawing window is closed. This function requires `CGAL_Qt6`, and is only available if the macro `CGAL_USE_BASIC_VIEWER`/`CGAL_USE_BASIC_VIEWER_QT` (Qt viewer) is defined.
+Linking with the cmake target `CGAL::CGAL_Basic_viewer`/`CGAL::CGAL_Basic_viewer_Qt` will link with `CGAL_Qt6` and add the definition `CGAL_USE_BASIC_VIEWER`/`CGAL_USE_BASIC_VIEWER_QT`.
  *
  * \tparam GeometryTraits_2 a geometry traits type, a model of a 2D arrangement
  * traits concept. At this point it must be an instance of either

Arrangement_on_surface_2/include/CGAL/draw_arrangement_2.h

@@ -25,7 +25,7 @@
 #include <cstdlib>
 #include <random>
 
-#include <CGAL/Qt/Basic_viewer.h>
+#include <CGAL/Basic_viewer.h>
 #include <CGAL/Graphics_scene.h>
 #include <CGAL/Graphics_scene_options.h>
 #include <CGAL/Random.h>
@@ -587,8 +587,6 @@ void add_to_graphics_scene(const CGAL_ARR_TYPE& aos,
   add_to_graphics_scene(aos, graphics_scene, gso);
 }
 
-#ifdef CGAL_USE_BASIC_VIEWER
-
 /// Draw an arrangement on surface.
 template <typename GeometryTraits_2, typename TopologyTraits, class GSOptions>
 void draw(const CGAL_ARR_TYPE& aos, const GSOptions& gso,
@@ -609,8 +607,6 @@ void draw(const CGAL_ARR_TYPE& aos,
   draw_graphics_scene(graphics_scene, title);
 }
 
-#endif // CGAL_USE_BASIC_VIEWER
-
 #undef CGAL_ARR_TYPE
 
 } // namespace CGAL

Basic_viewer/doc/Basic_viewer/Basic_viewer.txt

@@ -131,7 +131,7 @@ Example of drawing of a point cloud and a polyhedron in a same viewer.
 \cgalFigureEnd
 
 <!-- /////////////////////////////////////////////////////////////////////////////// -->
-\section BV_BasicViewer The Basic Viewer Class
+\section BV_BasicViewer The Qt Basic Viewer Class
 
 The class `CGAL::Qt::Basic_viewer` is a \qt widget that inherits from `QGLViewer` and mainly stores a `Graphics_scene` and allows to visualize it and interact with the scene. Since this class is a \qt widget, it can be used into more complex \qt code to create more advanced demos.
 

Basic_viewer/doc/Basic_viewer/CGAL/Graphics_scene.h

@@ -102,6 +102,36 @@ class Graphics_scene {
 
   /// returns `true` if the scene is in 2D, i.e., lies on the XY or XZ or YZ plane.
   bool is_two_dimensional() const;
+
+  /// set the default color of faces 
+  void set_default_color_face(const CGAL::IO::Color& c);  
+
+  /// set the default color of points 
+  void set_default_color_point(const CGAL::IO::Color& c);  
+
+  /// set the default color of segments 
+  void set_default_color_segment(const CGAL::IO::Color& c);  
+
+  /// set the default color of rays 
+  void set_default_color_ray(const CGAL::IO::Color& c);  
+
+  /// set the default color of lines 
+  void set_default_color_line(const CGAL::IO::Color& c);  
+
+  /// returns the default color of faces  
+  const CGAL::IO::Color &get_default_color_face() const; 
+
+  /// returns the default color of points  
+  const CGAL::IO::Color &get_default_color_point() const; 
+
+  /// returns the default color of segments
+  const CGAL::IO::Color &get_default_color_segment() const; 
+
+  /// returns the default color of rays
+  const CGAL::IO::Color &get_default_color_ray() const; 
+
+  /// returns the default color of lines
+  const CGAL::IO::Color &get_default_color_line() const; 
 };
 
 } // namespace CGAL

Basic_viewer/doc/Basic_viewer/CGAL/Qt/Basic_viewer.h

@@ -5,133 +5,196 @@ namespace CGAL {
 /*!
  \ingroup PkgBasicViewerClasses
 
-The class `Basic_viewer` is a Qt widget based on `QGLViewer` that allows to visualize 3D elements: points, segments, triangles, rays and lines. This class stores a reference to a `Graphics_scene`. Elements are added through the scene. This class requires `CGAL_Qt6`, and is only available if the macro `CGAL_USE_BASIC_VIEWER` is defined. Linking with the cmake target `CGAL::CGAL_Basic_viewer` will link with `CGAL_Qt6` and add the definition `CGAL_USE_BASIC_VIEWER`.
+The class `Basic_viewer` is a Qt widget based on `QGLViewer` that allows to visualize 3D elements: points, segments, triangles, rays and lines. This class stores a reference to a `Graphics_scene`. Elements are added through the scene. This class requires `CGAL_Qt6`, and is only available if the macro `CGAL_USE_BASIC_VIEWER_QT` is defined. Linking with the cmake target `CGAL::CGAL_Basic_viewer` or `CGAL::CGAL_Basic_viewer_Qt` will link with `CGAL_Qt6` and add the definition `CGAL_USE_BASIC_VIEWER` & `CGAL_USE_BASIC_VIEWER_QT`.
 
 CGAL::QGLViewer is our internal fork of <a href="https://github.com/GillesDebunne/libQGLViewer">QGLViewer class</a> which is <em>A versatile 3D OpenGL viewer based on QOpenGLWidget</em>.
 */
 class Basic_viewer : public CGAL::QGLViewer
 {
 public:
+  /// \name Constructors
+  /// @{
+
   /// Constructor given a pointer on a `QWidget` (can be a `nullptr`) and a `Graphics_scene`.
   /// `title` will be the title of the window.
   Basic_viewer(QWidget* parent,
                const Graphics_scene& scene,
                const char* title="");
 
-  /// enables or disables the drawing of vertices.
+  /// @}
+
+  /// \name Setters
+  /// @{
+
+  /// \brief Set size of vertices. 
+  /// \param s The size of vertices.
+  void size_vertices(float s);
+
+  /// \brief Set size of edges. 
+  /// \param s The size of edges.
+  void size_edges(float s); 
+
+  /// \brief Set size of rays. 
+  /// \param s The size of rays.
+  void size_rays(float s); 
+
+  /// \brief Set size of lines. 
+  /// \param s The size of lines.
+  void size_lines(float s); 
+
+  /// \brief Enables or disables the drawing of vertices.
+  /// \param b Set to `true` to enable, `false` to disable.
   void draw_vertices(bool b);
 
-  /// enables or disables the drawing of edges.
+  /// \brief Enables or disables the drawing of edges.
+  /// \param b Set to `true` to enable, `false` to disable.
   void draw_edges(bool b);
 
-  /// enables or disables the drawing of rays.
+  /// \brief Enables or disables the drawing of rays.
+  /// \param b Set to `true` to enable, `false` to disable.
   void draw_rays(bool b);
 
-  /// enables or disables the drawing of lines.
+  /// \brief Enables or disables the drawing of lines.
+  /// \param b Set to `true` to enable, `false` to disable.
   void draw_lines(bool b);
 
-  /// enables or disables the drawing of faces.
+  /// \brief enables or disables the drawing of faces.
+  /// \param b Set to `true` to enable, `false` to disable.
   void draw_faces(bool b);
 
-  /// enables or disables the use of only one color (if `b` is `true`) or the use of multiple colors (if `b` is `false`).
-  void use_mono_color(bool b);
-
   /// enables or disables the drawing of texts.
+  /// \brief enables or disables the drawing of texts.
+  /// \param b Set to `true` to enable, `false` to disable.
   void draw_text(bool b);
 
-  /// sets the color used for vertices in mono color mode.
-  void vertices_mono_color(const CGAL::IO::Color& c);
+  /// \brief Enables or disables the drawing of mesh triangles.
+  /// \param b Set to `true` to enable, `false` to disable.
+  void draw_mesh_triangles(bool b);
+
+  /// \brief Enables or disables the use of only one color or the use of multiple colors.
+  /// \param b Set to `true` to use only one color, `false` to use multiple colors.
+  void use_default_color(bool b);
+
+  /// \brief Enables or disables the use of a single color for all normals.
+  /// \param b Set to `true` to enable, `false` to disable.
+  void use_default_color_normals(bool b);
 
-  /// sets the color used for edges in mono color mode.
-  void edges_mono_color(const CGAL::IO::Color& c);
+  /// \brief enables or disables the use of flat shading or the use of smooth shading.
+  /// \param b Set to `true` for flat shading, `false` for smooth shading.
+  void flat_shading(bool b);
 
-  /// sets the color used for rays in mono color mode.
-  void rays_mono_color(const CGAL::IO::Color& c);
+  /// \brief Enables or disables the reversal of normals.
+  /// \param b Set to `true` to reverse normals, `false` to keep normals as is.
+  void reverse_normal(bool b);
 
-  /// sets the color used for lines in mono color mode.
-  void lines_mono_color(const CGAL::IO::Color& c);
+  /// \brief Sets the default color of the normals.
+  /// \param c The default color of the normals.
+  void default_color_normals(const CGAL::IO::Color& c);
 
-  /// sets the color used for faces in mono color mode.
-  void faces_mono_color(const CGAL::IO::Color& c);
+  /// \brief Sets the height factor value of the normals.
+  /// \param h The height factor value of the normals.
+  void normal_height_factor(float h);
 
-  /// toggles the drawing of vertices.
+  /// \brief Toggles the drawing of vertices.
   void toggle_draw_vertices();
 
-  /// toggles the drawing of edges.
+  /// \brief Toggles the drawing of edges.
   void toggle_draw_edges();
 
-  /// toggles the drawing of rays.
+  /// \brief Toggles the drawing of rays.
   void toggle_draw_rays();
 
-  /// toggles the drawing of lines.
+  /// \brief Toggles the drawing of lines.
   void toggle_draw_lines();
 
-  /// toggles the drawing of faces.
+  /// \brief Toggles the drawing of faces.
   void toggle_draw_faces();
 
-  /// toggles the use of mono color mode.
-  void toggle_use_mono_color();
+  /// \brief Toggles the use of mono color mode.
+  void toggle_use_default_color();
 
-  /// toggles the drawing of text.
+  /// \brief Toggles the use of the default color mode for normals.
+  void toggle_use_default_color_normal();
+
+  /// \brief Toggles the use of flat shading.
+  void toggle_flat_shading();
+
+  /// \brief Toggles the drawing of text.
   void toggle_draw_text();
 
-  /// returns `true` if vertices are drawn.
+  /// \brief Reverses all normals of vertices and faces.
+  void reverse_all_normals();
+
+  /// @}
+
+  /// \name Getters
+  /// @{
+
+  /// \brief Checks if vertices are drawn.
+  /// \return `true` if vertices are drawn, `false` otherwise.
   bool draw_vertices() const;
 
-  /// returns `true` if edges are drawn.
+  /// \brief Checks if edges are drawn.
+  /// \return `true` if edges are drawn, `false` otherwise.
   bool draw_edges() const;
 
-  /// returns `true` if rays are drawn.
+  /// \brief Checks if rays are drawn.
+  /// \return `true` if rays are drawn, `false` otherwise.
   bool draw_rays() const;
 
-  /// returns `true` if lines are drawn.
+  /// \brief Checks if lines are drawn.
+  /// \return `true` if lines are drawn, `false` otherwise.
   bool draw_lines() const;
 
-  /// returns `true` if faces are drawn.
+  /// \brief Checks if faces are drawn.
+  /// \return `true` if faces are drawn, `false` otherwise.
   bool draw_faces() const;
 
-  /// returns `true` if mono color mode is used.
-  bool use_mono_color() const;
-
-  /// returns `true` if normals are reversed.
-  bool reverse_normal() const;
-
-  /// returns `true` if text are drawn.
+  /// \brief Checks if text is drawn.
+  /// \return `true` if text is drawn, `false` otherwise.
   bool draw_text() const;
 
-  /// returns the mono color used for vertices.
-  const CGAL::IO::Color& vertices_mono_color() const;
-
-  /// returns the mono color used for edges.
-  const CGAL::IO::Color& edges_mono_color() const;
+  /// \brief Checks if the default color mode is used.
+  /// \return `true` if mono color mode is used, `false` otherwise.
+  bool use_default_color() const;
 
-  /// returns the mono color used for rays.
-  const CGAL::IO::Color& rays_mono_color() const;
+  /// \brief Checks if the default color mode for normals is used.
+  /// \return `true` if default color mode for normals is used, `false` otherwise.
+  bool use_default_color_normal() const;
 
-  /// returns the mono color used for lines.
-  const CGAL::IO::Color& lines_mono_color() const;
-
-  /// returns the mono color used for faces.
-  const CGAL::IO::Color& faces_mono_color() const;
+  /// \brief Checks if normals are reversed.
+  /// \return `true` if normals are reversed, `false` otherwise.
+  bool reverse_normal() const;
 
-  /// returns `true` if the clipping plane is enabled.
+  /// \brief Checks if the clipping plane is enabled.
+  /// \return `true` if the clipping plane is enabled, `false` otherwise.
   bool clipping_plane_enabled() const;
 
-  /// returns the clipping plane when it is enabled.
+  /// \brief Checks if m_no_2D_mode is false and the graphics scene is two-dimensional.
+  /// \return `true` if m_no_2D_mode is false and the scene is 2D, `false` otherwise.
+  bool is_two_dimensional() const;
+
+  /// \brief Gets the clipping plane when enabled.
+  /// \return The clipping plane as a `CGAL::Exact_predicates_inexact_constructions_kernel::Plane_3` object.
   CGAL::Exact_predicates_inexact_constructions_kernel::Plane_3 clipping_plane() const;
 
-  /// returns the graphics scene of the viewer.
+  /// \brief Gets the graphics scene of the viewer.
+  /// \return A reference to the `Graphics_scene` object.
   const Graphics_scene& graphics_scene() const;
 
-  /// reverses all normals of vertices and faces.
-  void reverse_all_normals();
+  /// @}
+
+  /// \name Draw
+  /// @{
 
   /// draws the viewer without recomputing all internal buffers.
   virtual void draw();
 
   /// redraws the viewer, i.e., recompute all internal buffers and update the window.
   virtual void redraw();
 
+  /// @}
+
   /// Function called when a key is pressed. Users can define their own function in order
   /// to add specific behavior.
   std::function<bool(QKeyEvent *, CGAL::Qt::Basic_viewer *)> on_key_pressed;
@@ -144,7 +207,7 @@ class Basic_viewer : public CGAL::QGLViewer
 
 The class `QApplication_and_basic_viewer` regroups a `Basic_viewer` and Qt `QApplication`. The `QApplication` is created in the constructor, but started by the `run()` method. This allows for example users to modify the `on_key_pressed` method of the `Basic_viewer` to define their own behavior.
 
-This class requires `CGAL_Qt6`, and is only available if the macro `CGAL_USE_BASIC_VIEWER` is defined. Linking with the cmake target `CGAL::CGAL_Basic_viewer` will link with `CGAL_Qt6` and add the definition `CGAL_USE_BASIC_VIEWER`.
+This class requires `CGAL_Qt6`, and is only available if the macro `CGAL_USE_BASIC_VIEWER` or `CGAL_USE_BASIC_VIEWER_QT` is defined. Linking with the cmake target `CGAL::CGAL_Basic_viewer` or `CGAL::CGAL_Basic_viewer_Qt` will link with `CGAL_Qt6` and add the definition `CGAL_USE_BASIC_VIEWER` & `CGAL_USE_BASIC_VIEWER_QT`.
 
 */
 class QApplication_and_basic_viewer

Basic_viewer/examples/Basic_viewer/CMakeLists.txt

@@ -23,12 +23,12 @@ create_single_source_cgal_program("draw_surface_mesh_vcolor.cpp")
 
 if(CGAL_Qt6_FOUND)
   #link it with the required CGAL libraries
-  target_link_libraries(draw_lcc PRIVATE CGAL::CGAL_Basic_viewer)
-  target_link_libraries(draw_mesh_and_points PRIVATE CGAL::CGAL_Basic_viewer)
-  target_link_libraries(draw_several_windows PRIVATE CGAL::CGAL_Basic_viewer)
-  target_link_libraries(draw_surface_mesh_height PRIVATE CGAL::CGAL_Basic_viewer)
-  target_link_libraries(draw_surface_mesh_small_faces PRIVATE CGAL::CGAL_Basic_viewer)
-  target_link_libraries(draw_surface_mesh_vcolor PRIVATE CGAL::CGAL_Basic_viewer)
+  target_link_libraries(draw_lcc PRIVATE CGAL::CGAL_Basic_viewer_Qt)
+  target_link_libraries(draw_mesh_and_points PRIVATE CGAL::CGAL_Basic_viewer_Qt)
+  target_link_libraries(draw_several_windows PRIVATE CGAL::CGAL_Basic_viewer_Qt)
+  target_link_libraries(draw_surface_mesh_height PRIVATE CGAL::CGAL_Basic_viewer_Qt)
+  target_link_libraries(draw_surface_mesh_small_faces PRIVATE CGAL::CGAL_Basic_viewer_Qt)
+  target_link_libraries(draw_surface_mesh_vcolor PRIVATE CGAL::CGAL_Basic_viewer_Qt)
 else()
   message("CGAL_Qt6 not configured: examples that require Qt will not be compiled.")
 endif()

Basic_viewer/examples/Basic_viewer/draw_mesh_and_points.cpp

@@ -5,7 +5,7 @@
 #include <CGAL/draw_polyhedron.h>
 #include <CGAL/draw_point_set_3.h>
 #include <CGAL/Graphics_scene_options.h>
-#include <CGAL/Qt/Basic_viewer.h>
+#include <CGAL/Basic_viewer.h>
 
 #include <vector>
 #include <iostream>