Archives pour la catégorie Programmation

Scanner I2C pour Arduino

Le programme suivant est un scanner I2C pour Arduino. Il tente de lire une donnée (un octet) à chaque adresse I2C inclue dans l’intervalle [0:255]. Les adresses des modules esclaves qui répondent sont affichées dans le terminal.

#include 


void setup() { 
 //Initialize serial and wait for port to open:
  Serial.begin(115200); 
  
  // prints title with ending line break 
  Serial.println("I2C scanner ::: www.lucidarme.me"); 
} 


void loop() 
{
  // Test each I2C address 
  for (int i=0;i<256;i++)
  {
    // Request data (read one byte)
    Wire.requestFrom(i, 1);

    // If slave answers, a device is found
    if (Wire.available())
    {
      // Display address
      Serial.print(i,DEC);
      Serial.print("\t0x");
      Serial.print(i,HEX);
      Serial.print("\t");    
      Serial.print("0b");
      Serial.print(i,BIN);
      Serial.print("\t");
      Serial.println("Device found");
    }
    
//    delay(100);
  }
  Serial.println("End of scan"); 
  while (1);
} 

gtkmm – exemple 24

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cette exemple montre comment créer une application avec des onglets. Le premier onglet contient un bouton et le deuxième onglet contient juste un label.

capture

Téléchargement


Code source


main.cpp

#include 
#include 


int main(int argc, char* argv[])
{
    // Initialize gtkmm and create the main window
    Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");
    // Create the window
    mainwindow window;
    // Start main loop
    return app->run(window);
}

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include 
#include 




// The class mainwindow inherits from Gtk::Window
class mainwindow : public Gtk::Window
{
    // Constructor and destructor
public:    
	mainwindow();
	virtual             ~mainwindow();

protected:
    //Signal handlers (run when the button is clicked)
    void                    on_button_clicked();

    //Page selector
    Gtk::Notebook           Selector;

    // Button for the first page
    Gtk::Button             Button;

    // Label for the second page
    Gtk::Label              Label;
};


#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"



// Constructor of the main Window (build ui interface).
mainwindow::mainwindow()
{
    // Resize the main window and set border width
    this->resize(400,200);
    set_border_width(5);

    // Add the label and connect the button
    Button.add_label("Page 1 (button)");
    Button.signal_clicked().connect(sigc::mem_fun(*this,&mainwindow::on_button_clicked));

    // Set label text
    Label.set_text("Page 2 (label)");

    // Add the widgets (button and label) in the notebook
    Selector.append_page(Button, "First");
    Selector.append_page(Label, "Second");

    // This packs the button into the Window (a container).
    add(Selector);
    show_all_children();
}




// Destructor of the class
mainwindow::~mainwindow()
{}

// Call when the button os clicked and display my url
void mainwindow::on_button_clicked()
{
    std::cout << "www.lucidarme.me" << std::endl;
}

Héritage en C++

Cet article montre, à travers un exemple simple, comment fonctionne l’héritage. Considérons une classe Parent avec deux fonctions membres (fct1 et fct2). Notons que fct2 est virtuelle. Considérons maintenant une seconde classe Child (qui hérite de la classe Parent) qui contient aussi deux fonctions membres (fct1 et fct2). Toutes ces fonctions sont déclarées en protégées et peuvent être appelées grâce aux fonctions publiques callFunction1 et callFunction2 qui sont déclarées dans la classe Parent. La question est : que va-t-il se passer quand ces fonctions seront appelées de la classe Child ? Dans le cas de fct1, qui n’est pas virtuelle, c’est la fonction fct1 de la classe Parent qui est appelée. En revanche, dans le cas de fct2, qui est virtuelle, c’est la fonction qui est déclarée dans la classe Child qui est appelée. Notons que la fonction de la classe parent peut être appelée avec la syntaxe suivante : Parent::fct2(). Notons enfin que lors de l’instanciation de la classe Child, le constructeur de la classe Parent est appelé en premier. Le programme suivant illustre ces explications :

#include 


class Parent
{
public:
    Parent() {std::cout << "Constructor Parent" << std::endl;}

    void            callFunction1() { fct1(); }
    void            callFunction2() { fct2(); }

protected:
    void            fct1() 
    {   std::cout << "Class Parent :: function 1" << std::endl; }
    
    virtual void    fct2() 
    {   std::cout << "Class Parent :: function 2" << std::endl; }
};



class Child : public Parent
{
public:
    Child() {std::cout << "Constructor Child" << std::endl;}

protected:
    void            fct1() 
    {   std::cout << "Class Child :: function 1" << std::endl; }
    
    void            fct2() 
    {   std::cout << "Class Child :: function 2" << std::endl; 
        Parent::fct2(); }
};

int main()
{

    Child c;
    c.callFunction1();
    c.callFunction2();
    return 0;
}

Ce code affiche les lignes suivantes. Le constructeur parent est apellé avant le constructeur Child. Pour fct1, c'est la fonction de la classe Parent qui est appelée. Pour fct2, c'est la fonction de la classe Child qui est appelée car la fonction est virtuelle.

Constructor Parent
Constructor Child
Class Parent :: function 1
Class Child :: function 2
Class Parent :: function 2

gtkmm – exemple 23

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre comment afficher une image (Pixbuf) dans une zone de dessin Cairo. L’image peut être déplacée, redimensionnée, centrée ou ajustée avec la souris. Le redimensionnement est réalisé avec la molette. Les déplacements sont font avec le clic gauche. Le bouton droit permet d’afficher un menu contextuel (popup) avec différentes options illustrées ci-dessous.

capture

Téléchargement


Code source

main.cpp

#include 
#include 


int main(int argc, char* argv[])
{
	// Initialize gtkmm and create the main window
	Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");
	Gtk::Window window;
	
	// Create the drawing and add an image from file
	ScrollImage Img;    	
	Img.set_image_from_file("gtk.png");
	
	// Insert the drawing in the window
	window.add(Img);
	// Resize the window
	window.resize(600,400);
	// Set the window title
	window.set_title("ScrollImage");
	// Show the drawing
	Img.show();
	
	// Start main loop
	return app->run(window);
}

scrollimage.h

#ifndef SCROLLIMAGE_H
#define SCROLLIMAGE_H

#include 
#include 


// Minimun scale (low boundary)
#define			MIN_SCALE			0.05



class ScrollImage : public Gtk::DrawingArea
{
public:
	
	
	/*!
	 * \brief ScrollImage				Constructor, initialize the widget.
	 */
	ScrollImage();
	
	
	/*!
	 * \brief set_image_from_file		Load the image to display.
	 * \param filename					File name of the image.
	 */
	void set_image_from_file(const std::string& filename);
	
	
	
	
	
protected:
	
	/*!
	 * \brief on_draw					Override the draw handler : update display.
	 *									Don't call this function to update display, call queue_draw().
	 * \param cr						Cairo context.
	 * \return							Always false.
	 */
	virtual bool on_draw(const Cairo::RefPtr& cr);
	
	
	/*!
	 * \brief displayTarget				Display a little target at coordinates x,y.
	 * \param cr						Cairo context.
	 * \param x							x-coordinate of the center of the target.
	 * \param y							y-coordinate of the center of the target.
	 */
	void displayTarget(const Cairo::RefPtr& cr,double x, double y);
	
	
	/*!
	 * \brief on_scroll_event			This function is called when the mouse scroll changes.
	 *									This is a default handler for the signal signal_scroll_event().
	 * \param event						Properties of the event.
	 * \return							Always true (the event is processed).
	 */
	bool on_scroll_event(GdkEventScroll *event);
	
	
	/*!
	 * \brief on_button_press_event		This function is called when a mouse button is pressed.
	 *									This is a default handler for the signal signal_button_press_event().
	 * \param event						Properties of the event.
	 * \return							True if the event is processed, false otherwise.
	 */
	bool on_button_press_event(GdkEventButton *event);
	
	
	/*!
	 * \brief on_button_release_event	This function is called when a mouse button is released
	 *									This is a default handler for the signal signal_button_release_event().
	 * \param event						Properties of the event.
	 * \return							True if the event is processed, false otherwise.
	 */
	bool on_button_release_event(GdkEventButton *event);
	
	
	/*!
	 * \brief on_motion_notify_event	This function is called when the pointer is moved
	 *									This is a default handler for the signal signal_motion_notify_event().
	 * \param event						Properties of the event.
	 * \return							True if the event is processed, false otherwise.
	 */
	bool on_motion_notify_event(GdkEventMotion*event);
	
	
	
protected:
	/*!
	 * \brief resetView					Reset the view (best image fit in the window).
	 * \param winWidth					Width of the window (in pixels).
	 * \param winHeight					Height of the window (in pixels).
	 * \param imgWidth					Width of the image (in pixels).
	 * \param imgHeight					Height of the image (in pixels).
	 */
	void                        fitImage(int winWidth,int winHeight, int imgWidth, int imgHeight);
	
	
	/*!
	 * \brief fit						Set the fit flag to one and update display
	 *									Next call of on_draw will fit the image according to the drawing area.
	 */
	void                        fit();
	
	
	/*!
	 * \brief reset						Reset display (center the image and set scale to 1:1) and update display
	 */
	void                        reset();
	
	
	/*!
	 * \brief resetScale				Set scale to 1:1 and update display
	 */
	void                        resetScale();
	
	
	/*!
	 * \brief setCenter					Center the image on the pointer position from last click
	 */
	void                        setCenter();
	
	/*!
	 * \brief showHideTarget			Show or hide the center target and update display
	 */
	void                        showHideTarget();
	
	
private:
	
	// Image to display
	Glib::RefPtr   image;
	
	// Scale of the image
	double                      scale;
	
	// Coordinates of the image point to place at the center of the window (focussed pixel)
	double                      imgFocusX,imgFocusY;
	
	// Used to memorize last mouse coordinates
	int                         lastXMouse, lastYMouse;
	
	// Flags
	bool                        resetFlag;
	bool                        moveFlag;
	bool                        targetFlag;
	
	// Popup menu and submenus
	
	// Main popup menu
	Gtk::Menu                   m_Menu_Popup;
	Gtk::MenuItem               MenuItemFit;
	Gtk::MenuItem               MenuItemRstView;
	Gtk::MenuItem               MenuItemRstScale;
	Gtk::MenuItem               MenuItemSetCenter;
	Gtk::MenuItem               MenuItemTarget;
	Gtk::SeparatorMenuItem      MenuItemLine1;
	Gtk::SeparatorMenuItem      MenuItemLine2;
	
};

#endif // SCROLLIMAGE_H

scrollimage.cpp

#include "scrollimage.h"


// Constructor
ScrollImage::ScrollImage()
{
	// Set masks for mouse events
	add_events(Gdk::BUTTON_PRESS_MASK |
			   Gdk::BUTTON_RELEASE_MASK |
			   Gdk::SCROLL_MASK |
			   Gdk::SMOOTH_SCROLL_MASK |
			   Gdk::POINTER_MOTION_MASK);

	// ::: Create popup menu :::

	// Add and connect action set pointer as center
	MenuItemSetCenter.set_label("Set center here");
	MenuItemSetCenter.signal_activate().connect(sigc::mem_fun(*this,&ScrollImage::setCenter));
	m_Menu_Popup.append(MenuItemSetCenter);

	// Add a separator
	m_Menu_Popup.append(MenuItemLine1);

	// Add and connect action Fit image to drawing area
	MenuItemFit.set_label("Fit image");
	MenuItemFit.signal_activate().connect(sigc::mem_fun(*this,&ScrollImage::fit));
	m_Menu_Popup.append(MenuItemFit);

	// Add and connect action reset (center and set scale to 1)
	MenuItemRstView.set_label("Reset view");
	MenuItemRstView.signal_activate().connect(sigc::mem_fun(*this,&ScrollImage::reset));
	m_Menu_Popup.append(MenuItemRstView);

	// Add and connect action reset scale to 1
	MenuItemRstScale.set_label("Reset scale");
	MenuItemRstScale.signal_activate().connect(sigc::mem_fun(*this,&ScrollImage::resetScale));
	m_Menu_Popup.append(MenuItemRstScale);

	// Add a separator
	m_Menu_Popup.append(MenuItemLine2);

	// Add and connect action reset scale to 1
	MenuItemTarget.set_label("Hide center target");
	MenuItemTarget.signal_activate().connect(sigc::mem_fun(*this,&ScrollImage::showHideTarget));
	m_Menu_Popup.append(MenuItemTarget);

	// Show the menu
	m_Menu_Popup.show_all();
	// Connect the menu to this Widget
	m_Menu_Popup.accelerate(*this);


	// ::: Initialize view and flags :::
	fit();
	moveFlag=false;
	targetFlag=true;
}



// Load an image from file
void ScrollImage::set_image_from_file(const std::string& filename)
{
	image = Gdk::Pixbuf::create_from_file(filename);
}



// Mouse wheel event detected : update scale
bool ScrollImage::on_scroll_event(GdkEventScroll *event)
{
	// Compute the new scale according to mouse scroll
	double newScale=scale*(1-event->delta_y/20);
	if (newScalex - get_allocated_width()/2.;
	double DeltaY=event->y - get_allocated_height()/2.;
	imgFocusX=imgFocusX + DeltaX/scale - DeltaX/newScale ;
	imgFocusY=imgFocusY + DeltaY/scale - DeltaY/newScale ;;

	// Update scale and redraw the widget
	scale=newScale;
	queue_draw();

	// Event has been handled
	return true;
}


// Mouse button pressed : process mouse button event
bool ScrollImage::on_button_press_event(GdkEventButton *event)
{

	// Check if the event is a left button click.
	if (event->button == 1)
	{
		// Memorize pointer position
		lastXMouse=event->x;
		lastYMouse=event->y;
		// Start moving the view
		moveFlag=true;
		// Event has been handled
		return true;
	}

	// Check if the event is a right button click.
	if(event->button == 3)
	{
		// Memorize mouse coordinates
		lastXMouse=event->x;
		lastYMouse=event->y;
		// Display the popup menu
		m_Menu_Popup.popup(event->button, event->time);
		// The event has been handled.
		return true;
	}
	// Event has not been handled
	return false;
}



// Mouse button released : process mouse button event
bool ScrollImage::on_button_release_event(GdkEventButton *event)
{
	// Check if it is the left button
	if (event->button==1 && moveFlag)
	{
		// End of motion
		moveFlag=false;
		// Update image focus
		imgFocusX -= (event->x-lastXMouse)/scale;
		imgFocusY -= (event->y-lastYMouse)/scale;
		// Update display
		queue_draw();
		return true;
	}
	// Event has been handled
	return false;
}



// Mouse pointer moved : process event
bool ScrollImage::on_motion_notify_event (GdkEventMotion*event)
{

	// If the left button is pressed, move the view
	if (moveFlag)
	{
		// Get mouse coordinates
		int XMouse=event->x;
		int YMouse=event->y;

		// Update image focus
		imgFocusX -= (XMouse-lastXMouse)/scale;
		imgFocusY -= (YMouse-lastYMouse)/scale;

		// Memorize new position of the pointer
		lastXMouse=XMouse;
		lastYMouse=YMouse;

		// Update view
		queue_draw();
		return true;
	}
	// Event has been handled
	return false;
}


// Reset view (scale is set to 1:1 and image is centered)
void ScrollImage::reset()
{
	// Set scale to 1:1
	scale=1;
	// Update image focus
	imgFocusX = image->get_width()/2.;
	imgFocusY = image->get_height()/2.;
	// Update display
	queue_draw();
}


// Reset scale to 1:1
void ScrollImage::resetScale()
{
	scale=1;
	// Update display
	queue_draw();
}


// Center the dispay at the pointer coordinates
void ScrollImage::setCenter()
{
	// Update image focus
	imgFocusX += (lastXMouse - get_allocated_width()/2.)/scale;
	imgFocusY += (lastYMouse - get_allocated_height()/2.)/scale;
	// Update display
	queue_draw();
}

// Best fit of the image in the display
void ScrollImage::fit()
{
	// Set reset flag to true, next call of on_draw will reset display
	resetFlag=true;
	queue_draw();
}


// Hide or show the target center
void ScrollImage::showHideTarget()
{
	// Invert flag
	targetFlag=!targetFlag;
	// Update popup menu according to current status
	if (targetFlag)
		MenuItemTarget.set_label("Hide center target");
	else
		MenuItemTarget.set_label("Show center target");
	// Update display
	queue_draw();
}


// Reset view to fit in the drawing area
void ScrollImage::fitImage(int winWidth,int winHeight, int imgWidth, int imgHeight)
{
	// Compute ratio of the window and the image
	double winRatio=(double)winWidth/winHeight;
	double imgRatio=(double)imgWidth/imgHeight;

	// Check what is the best fit for the image according to the ratio
	if (imgRatio& cr)
{

	// Get the window size
	int winWidth=get_allocated_width();
	int winHeight=get_allocated_height();

	// Get the image size
	int imgWidth=image->get_width();
	int imgHeight=image->get_height();

	// If requested, reset view
	if (resetFlag) fitImage(winWidth,winHeight,imgWidth,imgHeight);

	// Create a new image for display filled with grey
	Glib::RefPtr display = Gdk::Pixbuf::create(Gdk::COLORSPACE_RGB,false,8,winWidth,winHeight);
	display->fill(0x5F5F5F00);

	// Compute offset of the source image
	double OffsetX=winWidth/2-imgFocusX*scale;
	double OffsetY=winHeight/2-imgFocusY*scale;
	// Compute top left coordinate of the image in the area
	double Min_X=std::max(0.,OffsetX);
	double Min_Y=std::max(0.,OffsetY);
	// Compute bottom right coordinates of the image in the area
	double Max_X=std::min((double)winWidth,winWidth/2+(imgWidth-imgFocusX)*scale);
	double Max_Y=std::min((double)winHeight,winHeight/2+(imgHeight-imgFocusY)*scale);
	// Compute width and height
	double Width=Max_X-Min_X;
	double Height=Max_Y-Min_Y;

	// Scale image
	image->scale(display,
				 Min_X,Min_Y,
				 Width,Height,
				 OffsetX,OffsetY,
				 scale,scale,Gdk::INTERP_TILES);

	// Display the image in the drawing area
	Gdk::Cairo::set_source_pixbuf(cr,display,0,0);
	cr->rectangle(0,0,winWidth,winHeight);
	cr->fill();

	// Display the center target if requested
	if (targetFlag) displayTarget(cr,winWidth/2.,winHeight/2.);

	// Event has been handled
	return false;
}


// Display a target at coordinates x,y
void ScrollImage::displayTarget(const Cairo::RefPtr& cr,double x, double y)
{
	// Set color to black
	cr->set_source_rgba(0,0,0,0.5);

	// Display black quaters
	cr->arc(x,y,15,0,M_PI/2.);
	cr->line_to(x,y);
	cr->fill();
	cr->arc(x,y,15,M_PI,3.*M_PI/2.);
	cr->line_to(x,y);
	cr->fill();

	// Set color to white
	cr->set_source_rgba(1,1,1,0.5);

	// Display white quaters
	cr->arc(x,y,15,M_PI/2.,M_PI);
	cr->line_to(x,y);
	cr->fill();
	cr->arc(x,y,15,3.*M_PI/2.,0);
	cr->line_to(x,y);
	cr->fill();

	// Set color to black
	cr->set_source_rgba(0,0,0,0.8);

	// Display the cross
	cr->move_to(x-20,y);
	cr->line_to(x+20,y);
	cr->stroke();
	cr->move_to(x,y-20);
	cr->line_to(x,y+20);
	cr->stroke();

	// Display the circle
	cr->arc(x,y,15,0,2*M_PI);
	cr->stroke();
}

gtkmm – exemple 22

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple explique et montre comme redimensionner une image avec gtkmm. Regardons en détail la fonction Gdk::Pixbuf::scale :

void Gdk::Pixbuf::scale	(
const Glib::RefPtr< Gdk::Pixbuf >& dest,
int 		dest_x,
int 		dest_y,
int 		dest_width,
int 		dest_height,
double 		offset_x,
double 		offset_y,
double 		scale_x,
double 		scale_y,
InterpType 	interp_type 
) const

scale



  • dest est le buffer image de destination (Gdk::Pixbuf). La fonction redimensionne et copie l’image source dans une nouvelle image (dest). La mémoire n’est pas automatiquement alouée. Cela signifie que l’image de destination dest doit être créée préalablement à l’appel de la fonction scale. La largeur et la hauteur de dest doivent être en accord avec les autres paramètres de la fonction.
  • dest_x et dest_y sont les coordonnées du point en haut à gauche de l’image de destination. Tous les pixels à gauche de dest_x et au dessus de dest_y ne seront pas modifiés.
  • dest_width et dest_height sont les dimensions (largeur et hauteur) de la zone à mettre à jour dans le buffer de destination.
  • offset_x et offset_y sont les décalages de l’image source dans le repère de l’image de destination.
  • scale_x et scale_y sont les facteurs d’échelle appliqués à l’image source avant la copie. Un facteur de 1 conservera les proportions de l’image originale. Un facteur de 2 doublera les dimensions par rapport à l’image originale et ainsi de suite.
  • interp_type est la méthode d’interpolation utilisée pour la transformation. Quatre méthodes peuvent être utilisées :

    • Gdk::INTERP_NEAREST (en haut à gauche): échantillonage par le plus proche voisin: c’est la méthode la plus rapide, mais elle produit la plus mauvaise qualité. La qualité est mauvaise pour les zooms arrières, en revanche, elle peut être acceptable pour les zooms avant.
    • Gdk::INTERP_TILES (en bas à droite): c’est une implémentation fidèle à l’opérateur image de PostScript sans interpolation. Chaque pixel est redessiné comme un petit parallélogramme d’une seule couleur, les contours sont dessinés avec un anticrénelage. Cela ressemble au plus proche voisin pour les agrandissements et la méthode bilinéaire pour les réductions.
    • Gdk::INTERP_BILINEAR (en bas à gauche): le meilleur compromis entre la qualité et la rapidité; utilisez ce mode par défaut. Pour l’agrandissement, c’est équivalent à l’échantillonnage de interpolation bilinéaire. Pour les réductions, c’est équivalent à une intégration sur la zone à redimensionner.
    • Gdk::INTERP_HYPER (en haut à droite): c’est la méthode la plus lente, mais aussi cette qui présente le meilleur résultat. C’est dérivé des filtres hyperboliques présentés dans l’ouvrage de Wolberg’s “Digital Image Warping”. Cette méthode est formellement définie comme la méthode idéale d’interpolation d’image.

output2

Téléchargement


Code source


main.cpp

#include 
#include 


// Scale used for the demonstration
#define         SCALE           8.



int main(int argc, char* argv[])
{
    // Initialize gtkmm library
    Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");


    // Load the source image
    Glib::RefPtr image = Gdk::Pixbuf::create_from_file("gtk_icon.png");
    int width=image->get_width();
    int height=image->get_height();
    //image2=image; // = image->scale_simple(image->get_width()*scale,image->get_height()*scale,Gdk::INTERP_NEAREST);


    // __________________________
    // ::: Create output1.png :::

    // Create, fill and save the destination image
    Glib::RefPtr image2 = Gdk::Pixbuf::create(Gdk::COLORSPACE_RGB,true,8,width*SCALE,height*SCALE);
    image2->fill(0x0000FFA0);
    image2->save("output1.png","png");
    std::cout << "output1.png created" << std::endl;


    // __________________________
    // ::: Create output2.png :::

    // Scale and copy the first image in the destination image with several type of scalin method
    // Top left
    image->scale(image2,
                 10,10,
                 (width*SCALE)/2.-10,(height*SCALE)/2-10,
                 0,0,
                 SCALE,SCALE,
                 Gdk::INTERP_NEAREST);
    // Top right
    image->scale(image2,
                 (width*SCALE)/2.+10,10,
                 (width*SCALE)/2.-20,(height*SCALE)/2.-10,
                 0,0,
                 SCALE,SCALE,
                 Gdk::INTERP_HYPER);
    // Bottom left
    image->scale(image2,
                 10,(height*SCALE)/2.+10,
                 (width*SCALE)/2.-10,(height*SCALE)/2.-20,
                 0,0,
                 SCALE,SCALE,
                 Gdk::INTERP_BILINEAR);
    // Bottom right
    image->scale(image2,
                 (width*SCALE)/2.+10,(height*SCALE)/2.+10,
                 (width*SCALE)/2.-20,(height*SCALE)/2.-20,
                 0,0,
                 SCALE,SCALE,
                 Gdk::INTERP_TILES);
    // Save the output image
    image2->save("output2.png","png");
    std::cout << "output2.png created" << std::endl;


    // __________________________
    // ::: Create output3.png :::

    // Scale and translate the source image
    image2->fill(0x70707070);
    image->scale(image2,
                 20,20,
                 width*SCALE-40,height*SCALE-40,
                 -width*SCALE/2.,-height*SCALE/2.,
                 SCALE*2,SCALE*2,
                 Gdk::INTERP_BILINEAR);
    image2->save("output3.png","png");
    std::cout << "output3.png created" << std::endl;

    // __________________________
    // ::: Create output4.png :::

    // Scale and translate the source image
    image2->fill(0x70707070);
    image->scale(image2,
				 image2->get_width()/2.,image2->get_height()/2.,
				 image2->get_width()/2.,image2->get_height()/2.,
				 -width*SCALE,-height*SCALE,
                 SCALE*2,SCALE*2,
                 Gdk::INTERP_TILES);
    image2->save("output4.png","png");
    std::cout << "output4.png created" << std::endl;
    return 0;
}

Résultats


output1
output2
output3
output4

gtkmm – exemple 21

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre comment créer un menu popup (menu contextuel clic droit) à l’intérieur d’une zone de dessin (avec Cairo). Cet exemple peut facilement être transposé à d’autre Widgets.

capture

Téléchargement


Code source

main.cpp

#include 
#include 


int main(int argc, char* argv[])
{
	// Initialize gtkmm and create the main window
	Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");
	Gtk::Window window;
	
	// Create the drawing
	DrawingArea Dwg;
	// Insert the drawing in the window
	window.add(Dwg);
	// Resize the window
	window.resize(250,250);
	// Set the window title
	window.set_title("Popup menu");
	// Show the drawing
	Dwg.show();
	
	// Start main loop
	return app->run(window);
}

drawingarea.h

#ifndef DRAWINGAREA_H
#define DRAWINGAREA_H

#include 
#include 


class DrawingArea : public Gtk::DrawingArea
{
public:
	DrawingArea();

protected:
	// Override default signal handler:
	virtual bool                on_draw(const Cairo::RefPtr& cr);

	// Override mouse events
	bool                        on_button_press_event(GdkEventButton *event);

	// Signal handlers (run when a popup item is clicked)
	void                        on_action1_event();
	void                        on_action2_event();

private:

	// Image displayed
	Glib::RefPtr   image;

	// Scale of the image
	double                      scale;

	// Popup menu and submenus
	Gtk::Menu                   m_Menu_Popup;
	Gtk::MenuItem               MenuItem1;
	Gtk::MenuItem               MenuItem2;

};
#endif // DRAWINGAREA_H

drawingarea.cpp

#include "drawingarea.h"



DrawingArea::DrawingArea()
{
	// Load the image
	image = Gdk::Pixbuf::create_from_file("gtk.png");

	// Set masks for mouse events
	add_events(Gdk::BUTTON_PRESS_MASK);

	// ::: Create popup menu :::

	// Add and connect action 1
	MenuItem1.set_label("Action 1");
	MenuItem1.signal_activate().connect(sigc::mem_fun(*this,&DrawingArea::on_action1_event));
	m_Menu_Popup.append(MenuItem1);

	// Add and connect action 2
	MenuItem2.set_label("Action 2");
	MenuItem2.signal_activate().connect(sigc::mem_fun(*this,&DrawingArea::on_action2_event));
	m_Menu_Popup.append(MenuItem2);

	// Show the menu
	m_Menu_Popup.show_all();

	// Connect the menu to this Widget
	m_Menu_Popup.accelerate(*this);
}


// Signal handlers for acion 1
void DrawingArea::on_action1_event()
{
	std::cout << "Action 1 selected" << std::endl;
}


// Signal handlers for acion 2
void DrawingArea::on_action2_event()
{
	std::cout << "Action 2 selected" << std::endl;
}


// Mouse button press event
bool DrawingArea::on_button_press_event(GdkEventButton *event)
{
	// Check if the event is a right button click.
	if( (event->type == GDK_BUTTON_PRESS) && (event->button == 3) )
	{
		// Display the popup menu
		m_Menu_Popup.popup(event->button, event->time);
		// The event has been handled.
		return true;
	}

	// Propagate the event further.
	return false;
}


// Call when the display need to be updated
bool DrawingArea::on_draw(const Cairo::RefPtr& cr)
{
	// Place the image at the center of the window
	Gdk::Cairo::set_source_pixbuf(cr, image, 0,0);
	// Update the whole drawing area
	cr->rectangle(0, 0, image->get_width(), image->get_height());
	// Fill the area with the image
	cr->fill();
	// The event has been handled.
	return true;
}

Ecran d’accueil absent avec Qt Creator

Après avoir installé Qt Creator sur Xubuntu 14.04, l’écran d’accueil (onglet Welcome) est vide. La solution est d’installer le paquet manquant suivant ::

sudo apt-get install qtdeclarative5-qtquick2-plugin

Cette solution a été testée avec les versions suivantes:

  • Xubuntu 14.04 LTS
  • Qt Creator 3.0.1

Il se peut que l’aide soit aussi manquante. Pour installer la documentation, consultez cette page.

gtkmm – exemple 20

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Ce programme montre comment traiter les données issues de la molette de souris dans une zone de dessin (par exemple pour zommer).

capture

Téléchargement


Code source


main.cpp

#include 
#include 


int main(int argc, char* argv[])
{
	// Initialize gtkmm and create the main window
	Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");
	Gtk::Window window;

	// Create the drawing
	Drawing Dwg;


	// Insert the drawing in the window
	window.add(Dwg);
	// Resize the window
	window.resize(400,400);
	// Set the window title
	window.set_title("Mouse scroll");
	// Show the drawing
	Dwg.show();

	// Start main loop
	return app->run(window);
}

drawing.h

#ifndef DRAWING_H
#define DRAWING_H

#include 
#include 

class Drawing : public Gtk::DrawingArea
{
public:
    Drawing();

protected:
    // Override default signal handler:
    virtual bool on_draw(const Cairo::RefPtr& cr);

    // Override mouse scroll event
    bool on_scroll_event(GdkEventScroll *ev);



private:
    // Image displayed
    Glib::RefPtr   image;
    // Scale of the image
    double                      scale;


};

#endif // DRAWING_H

drawing.cpp

#include "drawing.h"

Drawing::Drawing()
{
    // Load the image
    image = Gdk::Pixbuf::create_from_file("gtk.png");
    add_events(Gdk::BUTTON_PRESS_MASK | Gdk::SCROLL_MASK  |Gdk::SMOOTH_SCROLL_MASK);
    scale=1;
}


bool Drawing::on_scroll_event(GdkEventScroll *ev)
{
    // Update scale according to mouse scroll
    scale-=ev->delta_y/10.;
	if (scale<0.1) scale=0.1;
    std::cout << scale << std::endl;
    std::cout.flush();
    // Update drawing
    queue_draw();
    // There is probably a good reason to do this
    return true;
}




bool Drawing::on_draw(const Cairo::RefPtr& cr)
{
    // Get drawing area size
    Gtk::Allocation allocation = get_allocation();
    const int width = allocation.get_width();
    const int height = allocation.get_height();

    // Scale the image to the area
    cr->scale(scale,scale);

    // Place the image at the center of the window
    Gdk::Cairo::set_source_pixbuf(cr, image, (width/2)/scale-image->get_width()/2,(height/2)/scale-image->get_height()/2);

    // Update the whole drawing area
    cr->rectangle(0, 0, get_allocation().get_width()/scale, get_allocation().get_width()/scale);
    // Fill the area with the image
    cr->fill();

    return true;
}

gtkmm – exemple 19

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre comment créer plusieurs fenêtre avec gtkmm (fenêtres filles ou secondaires).

capture

Téléchargement


Code source


main.cpp

#include 

int main(int argc, char* argv[])
{
    // Initialize gtkmm and create the main window
    Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");

    // Create the main window with an image
    Gtk::Window window;
    Gtk::Image image1("gtk.png");
    window.add(image1);
    image1.show();
    window.move(200,200);
    window.set_title("Main window");

    // Create the secondary window with another image
    Gtk::Window window2;
    Gtk::Image image2("minirex.png");
    window2.add(image2);
    image2.show();
    window2.set_title("Secondary window");
    window2.show();
    window2.set_deletable(false);
    window2.move(400,200);

    // Start main loop
    return app->run(window);
}

gtkmm – exemple 18

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre comment mélanger images et dessin avec Cairo.

capture

Téléchargement


Code source


main.cpp

#include 
#include 


int main(int argc, char* argv[])
{
	// Initialize gtkmm and create the main window
	Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");
	Gtk::Window window;
	
	// Create the drawing
	Drawing Dwg;
	
	// Insert the drawing in the window
	window.add(Dwg);
	
	// Show the drawing
	Dwg.show();
	
	// Start main loop
	return app->run(window);
}

drawing.h

#ifndef DRAWING_H
#define DRAWING_H

#include 
#include 

class Drawing : public Gtk::DrawingArea
{
public:
	Drawing();
	
protected:
	//Override default signal handler:
	virtual bool on_draw(const Cairo::RefPtr& cr);
	
private:
	Glib::RefPtr image;
};

#endif // DRAWING_H

drawing.cpp

#include "drawing.h"

Drawing::Drawing()
{
	// Load the image
	image = Gdk::Pixbuf::create_from_file("gtk.png");
}


bool Drawing::on_draw(const Cairo::RefPtr& cr)
{
	// Get drawing area size
	Gtk::Allocation allocation = get_allocation();
	const int width = allocation.get_width();
	const int height = allocation.get_height();
	
	// Scale the image to the area
	cr->scale((double)width/image->get_width(),(double)height/image->get_height());
	
	cr->save();
	// Place the image at 0,0
	Gdk::Cairo::set_source_pixbuf(cr, image, 0,0);
	// Update the area where the image is located
	cr->rectangle(0, 0, image->get_width(), image->get_height());
	// Fill the area with the image
	cr->fill();
	cr->restore();
	
	
	cr->save();
	cr->set_source_rgba(0.,0.,1.,1.);   // blue
	cr->set_line_width(10);
	cr->arc(image->get_width()/2.,image->get_height()/2,width/3,0,2*M_PI);
	cr->stroke();
	cr->restore();
	
	return true;
}

gtkmm – exemple 17

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre comment redimensionner la zone de dessin en fonction de la taille de la fenêtre.

capture

Téléchargement


Code source


main.cpp

#include 
#include 


int main(int argc, char* argv[])
{
	// Initialize gtkmm and create the main window
	Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");
	Gtk::Window window;
	// Set window size
	window.resize(600,400);

	// Create the drawing
	Drawing Dwg;

	// Insert the drawing in the window
	window.add(Dwg);

	// Show the drawing
	Dwg.show();

	// Start main loop
	return app->run(window);
}

drawing.h

#ifndef DRAWING_H
#define DRAWING_H

#include 
#include 

class Drawing : public Gtk::DrawingArea
{
public:
	Drawing();

protected:
	//Override default signal handler:
	virtual bool on_draw(const Cairo::RefPtr& cr);

private:
	Glib::RefPtr image;
};

#endif // DRAWING_H

drawing.cpp

#include "drawing.h"

Drawing::Drawing()
{
	// Load the image
	image = Gdk::Pixbuf::create_from_file("gtk.png");
}


bool Drawing::on_draw(const Cairo::RefPtr& cr)
{
	// Get drawing area size
	Gtk::Allocation allocation = get_allocation();
	const int width = allocation.get_width();
	const int height = allocation.get_height();

	// Scale the image to the area
	cr->scale((double)width/image->get_width(),(double)height/image->get_height());
	// Place the image at 0,0
	Gdk::Cairo::set_source_pixbuf(cr, image, 0,0);
	// Update the area where the image is located
	cr->rectangle(0, 0, image->get_width(), image->get_height());
	// Fill the area with the image
	cr->fill();

	return true;
}

gtkmm – exemple 16

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre comment afficher une image dans une zone de dessin créée avec Cairo.

capture

Téléchargement


Code source


main.cpp

#include 
#include 


int main(int argc, char* argv[])
{
	// Initialize gtkmm and create the main window
	Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");
	Gtk::Window window;

	// Create the drawing
	Drawing Dwg;

	// Insert the drawing in the window
	window.add(Dwg);

	// Show the drawing
	Dwg.show();

	// Start main loop
	return app->run(window);
}

drawing.h

#ifndef DRAWING_H
#define DRAWING_H

#include 
#include 

class Drawing : public Gtk::DrawingArea
{
public:
	Drawing();

protected:
	//Override default signal handler:
	virtual bool on_draw(const Cairo::RefPtr& cr);

private:
	Glib::RefPtr image;
};

#endif // DRAWING_H

drawing.cpp

#include "drawing.h"

Drawing::Drawing()
{
	// Load the image
	image = Gdk::Pixbuf::create_from_file("gtk.png");
}


bool Drawing::on_draw(const Cairo::RefPtr& cr)
{

	// Place the image at 0,0
	Gdk::Cairo::set_source_pixbuf(cr, image, 0,0);
	// Update the area where the image is located
	cr->rectangle(0, 0, image->get_width(), image->get_height());
	// Fill the area with the image
	cr->fill();

	return true;
}

gtkmm – exemple 15

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre comment utiliser la transparence avec Cairo.

capture

Téléchargement


Code source


main.cpp

#include 
#include 


int main(int argc, char* argv[])
{
	// Initialize gtkmm and create the main window
	Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");
	Gtk::Window window;
	
	// Create the drawing
	Drawing Dwg;
	
	// Insert the drawing in the window
	window.add(Dwg);
	
	// Show the drawing
	Dwg.show();
	
	// Start main loop
	return app->run(window);
}

drawing.h

#ifndef DRAWING_H
#define DRAWING_H

#include 
#include 

class Drawing : public Gtk::DrawingArea
{
public:
	Drawing();
	
protected:
	//Override default signal handler:
	virtual bool on_draw(const Cairo::RefPtr& cr);
	
};

#endif // DRAWING_H

drawing.cpp

#include "drawing.h"

Drawing::Drawing()
{
}


bool Drawing::on_draw(const Cairo::RefPtr& cr)
{
	// Draw the first circle
	cr->arc(75,75,50,0,2*M_PI);
	cr->set_source_rgba(0, 0, 1.0,0.5);
	cr->fill();
	cr->stroke();

	cr->set_source_rgba(0, 1, 0,0.5);
	cr->arc(100,125,50,0,2*M_PI);
	cr->fill();
	cr->stroke();

	cr->set_source_rgba(1, 0, 0,0.5);
	cr->arc(125,75,50,0,2*M_PI);
	cr->fill();
	cr->stroke();


	return true;
}

gtkmm – exemple 14

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre comment créer une zone de dessin avec Cairo.

capture

Téléchargement


Code source


main.cpp

#include 
#include 


int main(int argc, char* argv[])
{
    // Initialize gtkmm and create the main window
    Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");
    Gtk::Window window;
    
    // Create the drawing
    Drawing Dwg;

    // Insert the drawing in the window
    window.add(Dwg);

    // Show the drawing
    Dwg.show();

    // Start main loop
    return app->run(window);
}

drawing.h

#ifndef DRAWING_H
#define DRAWING_H

#include 
#include 

class Drawing : public Gtk::DrawingArea
{
public:
	Drawing();
	
protected:
	//Override default signal handler:
	virtual bool on_draw(const Cairo::RefPtr& cr);
	
};

#endif // DRAWING_H

drawing.cpp

#include "drawing.h"

Drawing::Drawing()
{
}


bool Drawing::on_draw(const Cairo::RefPtr& cr)
{
    // Set color
    cr->set_source_rgb(0, 0.0, 1.0);
    // Set line width
    cr->set_line_width(15.0);
    // Set line cap
    cr->set_line_cap(Cairo::LINE_CAP_ROUND);

    // Draw the lines
    cr->move_to(50, 50);
    cr->line_to(150, 150);
    cr->move_to(150,50);
    cr->line_to(50, 150);

    // Apply drawing
    cr->stroke();

    return true;
}

gtkmm – exemple 13

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre comment créer une barre de menu dans la fenêtre.

capture

Téléchargement


Code source


main.cpp

#include 



int main(int argc, char* argv[])
{
    // Initialize gtkmm and create the window
	Glib::RefPtr app = Gtk::Application::create(argc, argv, "www.lucidarme.me");
    Gtk::Window window;

    // Create the vertical layout
    Gtk::VBox mainLayout;
    window.add(mainLayout);


    // Create and add the menuBar to the layout
    Gtk::MenuBar menuBar;
    mainLayout.pack_start(menuBar, Gtk::PACK_SHRINK);


    // _________________________________
    // ::: Create the sub menu Files :::


    // Create the menu item files
    Gtk::MenuItem menuFiles;
    menuFiles.set_label("Files");
    menuBar.append(menuFiles);

    // Create a sub menu in files
    Gtk::Menu subMenuFiles;
    menuFiles.set_submenu(subMenuFiles);

    // Create a menu item from Stock (New)
    Gtk::ImageMenuItem menuNew(Gtk::Stock::NEW);
    subMenuFiles.append(menuNew);

    // Create a menu item with a sub menu (Recent files)
    Gtk::MenuItem menuRecentFiles("Recent files", true);
    subMenuFiles.append(menuRecentFiles);
    Gtk::Menu subMenuRecentFiles;
    menuRecentFiles.set_submenu(subMenuRecentFiles);
    Gtk::MenuItem recentFile1("File1.txt");
    subMenuRecentFiles.append(recentFile1);
    Gtk::MenuItem recentFile2("File2.txt");
    subMenuRecentFiles.append(recentFile2);
    Gtk::MenuItem recentFile3("File3.txt");
    subMenuRecentFiles.append(recentFile3);

    // Create a menu item from Stock (Open)
    Gtk::ImageMenuItem menuOpen(Gtk::Stock::OPEN);
    subMenuFiles.append(menuOpen);

    // Create a menu item from Stock (Save)
    Gtk::ImageMenuItem menuSave(Gtk::Stock::SAVE);
    subMenuFiles.append(menuSave);

    // Add a separator
    Gtk::SeparatorMenuItem hline;
    subMenuFiles.append(hline);

    // Create a menu item from Stock (Close)
    Gtk::ImageMenuItem menuClose(Gtk::Stock::CLOSE);
    subMenuFiles.append(menuClose);

    //  Create and connect a menu item from Stock (Quit)
    Gtk::ImageMenuItem menuQuit(Gtk::Stock::QUIT);
    menuQuit.signal_activate().connect(sigc::ptr_fun(&Gtk::Main::quit));
    subMenuFiles.append(menuQuit);



    // _________________________________
    // ::: Create the sub menu Edit :::


    // Create the menu item Edit
    Gtk::MenuItem menuEdit("Edit", true);
    menuBar.append(menuEdit);

    // Create a sub menu in Edit
    Gtk::Menu subMenuEdit;
    menuEdit.set_submenu(subMenuEdit);

    // Create a menu item from Stock (Cut)
    Gtk::ImageMenuItem menuCut(Gtk::Stock::CUT);
    subMenuEdit.append(menuCut);

    // Create a menu item from Stock (Copy)
    Gtk::ImageMenuItem menuCopy(Gtk::Stock::COPY);
    subMenuEdit.append(menuCopy);

    // Create a menu item from Stock (Paste)
    Gtk::ImageMenuItem menuPaste(Gtk::Stock::PASTE);
    subMenuEdit.append(menuPaste);

    // Create a menu item
    Gtk::MenuItem menuExample("Example");
    subMenuEdit.append(menuExample);



    // Create and add an image in the window
    Gtk::Image image("gtk.png");
    mainLayout.pack_end(image);

    // Show window itens
    window.show_all();


    // Start main loop
	return app->run(window);
    return 0;
}

gtkmm – exemple 12

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre les différents types de boites de dialogue:

capture

capture2

Téléchargement


Code source


main.cpp

#include 
#include 


int main(int argc, char* argv[])
{
	// Initialize gtkmm
	Gtk::Main app(argc, argv);
	// Create the window
	mainwindow w;
	// Start main loop
	Gtk::Main::run(w);
	return 0;
}

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include 




// The class mainwindow inherits from Gtk::Window
class mainwindow : public Gtk::Window
{
	// Constructor and destructor
public:    
	mainwindow();
	virtual                 ~mainwindow();
	
protected:
	void                    messageInfo();
	void                    messageWarning();
	void                    messageQuestion();
	void                    messageError();
	void                    messageOther();
	
	//Override default signal handler:
	//    virtual bool on_draw(const Cairo::RefPtr& cr);
	
	//Member widgets:
	Gtk::Button             buttonInfo;
	Gtk::Button             buttonWarning;
	Gtk::Button             buttonQuestion;
	Gtk::Button             buttonError;
	Gtk::Button             buttonOther;
	Gtk::Button             buttonQuit;
	Gtk::VBox               mainLayout;
	
};


#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include 


// Constructor of the main Window (build ui interface).
mainwindow::mainwindow()
{
	this->resize(400,200);
	
	// Add the info message button
	buttonInfo.add_label("Information");
	buttonInfo.signal_pressed().connect(sigc::mem_fun(*this,&mainwindow::messageInfo));
	mainLayout.pack_start(buttonInfo);
	
	// Add the warning message button
	buttonWarning.add_label("Warning");
	buttonWarning.signal_pressed().connect(sigc::mem_fun(*this,&mainwindow::messageWarning));
	mainLayout.pack_start(buttonWarning);
	
	// Add the question message button
	buttonQuestion.add_label("Question");
	buttonQuestion.signal_pressed().connect(sigc::mem_fun(*this,&mainwindow::messageQuestion));
	mainLayout.pack_start(buttonQuestion);
	
	// Add the error message button
	buttonError.add_label("Error");
	buttonError.signal_pressed().connect(sigc::mem_fun(*this,&mainwindow::messageError));
	mainLayout.pack_start(buttonError);
	
	// Add the other message button
	buttonOther.add_label("Other");
	buttonOther.signal_pressed().connect(sigc::mem_fun(*this,&mainwindow::messageOther));
	mainLayout.pack_start(buttonOther);
	
	// Add the Quit button
	buttonQuit.add_label("Quit");
	buttonQuit.signal_pressed().connect(sigc::mem_fun(*this,&mainwindow::close));
	mainLayout.pack_start(buttonQuit);
	
	// Display the main grid in the main window
	mainLayout.show_all();
	
	// Insert the grid in the main window
	add(mainLayout);
	
}


// Destructor of the class
mainwindow::~mainwindow()
{}


// Display message info
void mainwindow::messageInfo()
{
	Gtk::MessageDialog dialog(*this, "This is an information MessageDialog",false,Gtk::MESSAGE_INFO);
	dialog.set_secondary_text("And this is the secondary text that explains things.");
	dialog.run();
}

// Display warning message
void mainwindow::messageWarning()
{
	Gtk::MessageDialog dialog(*this, "This is a warning MessageDialog",false,Gtk::MESSAGE_WARNING);
	dialog.run();
}

// Display a question message
void mainwindow::messageQuestion()
{
	Gtk::MessageDialog dialog(*this, "This is a question MessageDialog",false,Gtk::MESSAGE_QUESTION,Gtk::BUTTONS_OK_CANCEL);
	int Answer=dialog.run();
	
	// Process user choice
	switch(Answer)
	{
	case(Gtk::RESPONSE_OK):
		std::cout << "OK clicked." << std::endl;
		break;
	case(Gtk::RESPONSE_CANCEL):
		std::cout << "Cancel clicked." << std::endl;
		break;
	default:
		std::cout << "Unexpected button clicked." << std::endl;
		break;
	}
}

// Display error message
void mainwindow::messageError()
{
	Gtk::MessageDialog dialog(*this, "This is an error MessageDialog",false,Gtk::MESSAGE_ERROR);
	dialog.run();
}

// Display other message
void mainwindow::messageOther()
{
	Gtk::MessageDialog dialog(*this, "This is an other MessageDialog",true,Gtk::MESSAGE_OTHER);
	dialog.set_secondary_text("Note that the text support HTML markups.",true);
	dialog.run();
}

gtkmm – exemples et tutoriels

Cette page rassemble divers liens et exemples pour démarrer avec gtkmm.

gtkmm et Qt Creator : comment configurer Qt Creator avec gtkmm.
gtkmm – exemple 1 : simple application ‘Hello world’.
gtkmm – exemple 2 : application simple avec un container (Gtk::Grid).
gtkmm – exemple 3 : un container un peu plus complexe.
gtkmm – exemple 4 : simple application avec Gtk::Scale widget.
gtkmm – exemple 5 : simple application avec Gtk::SpinButton.
gtkmm – exemple 6 : déplacer la fenêtre.
gtkmm – exemple 7 : charge et affiche une image.
gtkmm – exemple 8 : charge et affiche plusieurs images.
gtkmm – exemple 9 : modifie l’icone de l’application
gtkmm – exemple 10 : boite de dialogue pour la sélection ou l’ouverture d’un fichier.
gtkmm – exemple 11 : simple application avec un timer.
gtkmm – exemple 12 : boites de dialogue.
gtkmm – exemple 13 : barre de menu.
gtkmm – exemple 14 : zone de dessin avec Cairo.
gtkmm – exemple 15 : transparence avec Cairo.
gtkmm – exemple 16 : afficher une image avec Cairo.
gtkmm – exemple 17 : redimensionnement de la zone de dessin.
gtkmm – exemple 18 : image et dessin avec Cairo.
gtkmm – exemple 19 : plusieurs fenêtres avec gtkmm.
gtkmm – exemple 20 : zoom avec la molette de la sourie.
gtkmm – exemple 21 : popup menu (menu contextuel clic droit).
gtkmm – exemple 22 : redimensionnement d’images.
gtkmm – exemple 23 : affichage interactif d’une image avec Cairo.
gtkmm – exemple 24 : fenêtre avec des onglets (tabs).

gtkmm – exemple 11

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre comment créer un timer et exploiter le signal émis:

capture

Téléchargement


Code source


main.cpp

#include 
#include 

int main(int argc, char* argv[])
{
	// Initialize gtkmm
	Gtk::Main app(argc, argv);
	// Create the window
	mainwindow w;
	// Start main loop
	Gtk::Main::run(w);
	return 0;
}

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include 
#include 
#include 
#include 


// The class mainwindow inherits from Gtk::Window
class mainwindow : public Gtk::Window
{
	// Constructor and destructor
public:    
	mainwindow();
	virtual                 ~mainwindow();
	
protected:
	// Called every timeout
	bool                    on_my_timeout();
	
	//Member widgets:
	Gtk::Label              label;
	Gtk::Button             buttonQuit;
	Gtk::Grid               mainGrid;
	
private:
	int                     seconds;
	
};

#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include 


// Constructor of the main Window (build ui interface).
mainwindow::mainwindow()
{
	// Initialize seconds
	seconds=0;
	
	// Add the label displaying the ellapsed tim
	label.set_text("Elapsed time: 0 s");
	mainGrid.attach(label,0,0,1,1);
	
	// Add the Quit button
	buttonQuit.add_label("Quit");
	buttonQuit.set_size_request(200,50);
	buttonQuit.signal_pressed().connect(sigc::mem_fun(*this,&mainwindow::close));
	mainGrid.attach(buttonQuit,0,1,1,1);
	
	// Display the main grid in the main window
	mainGrid.show_all();
	
	// Launch timer every second
	Glib::signal_timeout().connect( sigc::mem_fun(*this, &mainwindow::on_my_timeout), 1000 );
	
	// Insert the grid in the main window
	add(mainGrid);
}


// Destructor of the class
mainwindow::~mainwindow()
{}


bool mainwindow::on_my_timeout()
{
	// Prepare message
	char Text[50];
	sprintf (Text,"Elapsed time: %d s",++seconds);
	// Display message in the label
	label.set_text(Text);
	return true;
}

gtkmm – exemple 10

Cet article fait parti d’un ensemble d’exemples et d’articles sur gtkmm consultables ici. Cet exemple montre comment créer une boite de dialogue pour l’ouverture d’un fichier:

capture

Téléchargement


Code source


main.cpp

#include 
#include 

int main(int argc, char* argv[])
{
	// Initialize gtkmm
	Gtk::Main app(argc, argv);
	// Create the window
	mainwindow w;
	// Start main loop
	Gtk::Main::run(w);
	return 0;
}

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include 


// The class mainwindow inherits from Gtk::Window
class mainwindow : public Gtk::Window
{
	// Constructor and destructor
public:    
	mainwindow();
	virtual					~mainwindow();

protected:
	void                    on_button_load();

	//Member widgets:
	Gtk::Button             buttonLoad;
	Gtk::Button             buttonQuit;
	Gtk::Grid               mainGrid;

};


#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include 


// Constructor of the main Window (build ui interface).
mainwindow::mainwindow()
{
    // Initialize the main window and hide the title bar
    this->set_border_width(10);

    // Add the load button
    buttonLoad.add_label("Load file");
    buttonLoad.set_size_request(200,50);
    buttonLoad.signal_pressed().connect(sigc::mem_fun(*this,&mainwindow::on_button_load));
    mainGrid.attach(buttonLoad,0,0,1,1);

    // Add the Quit button
    buttonQuit.add_label("Quit");
    buttonQuit.set_size_request(200,50);
    buttonQuit.signal_pressed().connect(sigc::mem_fun(*this,&mainwindow::close));
    mainGrid.attach(buttonQuit,0,1,1,1);

    // Display the main grid in the main window
    mainGrid.show_all();

    // Insert the grid in the main window
    add(mainGrid);
}


// Destructor of the class
mainwindow::~mainwindow()
{}


void mainwindow::on_button_load()
{
    // Create the dialog box FileChooser
    Gtk::FileChooserDialog dialog("Please choose a file",Gtk::FILE_CHOOSER_ACTION_OPEN);
    dialog.set_transient_for(*this);

    //Add response buttons the the dialog:
    dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
    dialog.add_button("_Open", Gtk::RESPONSE_OK);

    //Add filters, so that only certain file types can be selected:
    Glib::RefPtr filter_text = Gtk::FileFilter::create();
    filter_text->set_name("Text files");
    filter_text->add_mime_type("text/plain");
    dialog.add_filter(filter_text);

    Glib::RefPtr filter_cpp = Gtk::FileFilter::create();
    filter_cpp->set_name("C/C++ files");
    filter_cpp->add_mime_type("text/x-c");
    filter_cpp->add_mime_type("text/x-c++");
    filter_cpp->add_mime_type("text/x-c-header");
    dialog.add_filter(filter_cpp);

    Glib::RefPtr filter_any = Gtk::FileFilter::create();
    filter_any->set_name("Any files");
    filter_any->add_pattern("*");
    dialog.add_filter(filter_any);

    //Show the dialog and wait for a user response:
    int result = dialog.run();

    //Handle the response:
    switch(result)
    {
    case(Gtk::RESPONSE_OK):
    {
        // The user selected a file
        std::cout << "Open clicked." << std::endl;
        std::string filename = dialog.get_filename();
        std::cout << "File selected: " <<  filename << std::endl;
        break;
    }
    case(Gtk::RESPONSE_CANCEL):
    {
        // The user clicked cancel
        std::cout << "Cancel clicked." << std::endl;
        break;
    }
    default:
    {
        // The user closed the dialog box
        std::cout << "Unexpected button clicked." << std::endl;
        break;
    }
    }
}