gtkmm : DrawingArea dans une ScrolledWindow

Version imprimable

04/07/2012, 15h22
superZozo

gtkmm : DrawingArea dans une ScrolledWindow

Bonjour,

Voici ce que je chreche a faire:
dans ma fenetre principale, je souhaiterais mettre une DrawingArea dans une ScrolledWindow de maniere a ce que :

- la ScrolledWindow a une taille minimum. (< taille de la drawingArea);
- lorsque l'on augmente la taille de la fenetre principale, la ScrolledWindow augmente jusque la drawingArea soit entierement visible. Au dela, sa taille est bloquée (on compense par du padding).

Je tourne depuis un moment avec les Box et les alignment, mais ça ne marche pas... :cry: soit la ScrolledWindow est trop "elastique" soit elle reste bloquée à la taille initiale...

Je ne pratique pas le C++, donc l'exemple dont je dispose est en C, mais il doit pouvoir s'adapter facilement à ton cas.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include <math.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
 
/*  Essai de   scrolled window  */
 
gboolean expose_event_callback (GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
  gdk_draw_arc (widget->window,
                widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
                TRUE,
                50, 0, widget->allocation.height, widget->allocation.height,
                0, 64 * 360);
 
  gdk_draw_line (widget->window ,widget->style->white_gc  ,50 ,50 ,1150, 250);
  return TRUE;
}
 
int main( int   argc ,char *argv[] )
{
  GtkWidget *gg_main_window ,*gg_main_vbox ,*scrol ,*gg_canvas;
 
  gtk_init (&argc, &argv);
  gg_main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);  
  gtk_widget_set_size_request (gg_main_window, 500, 500);
 
  /* vbox principale */
  gg_main_vbox = gtk_vbox_new (FALSE, 1);
  gtk_box_set_homogeneous (GTK_BOX(gg_main_vbox) , FALSE);
  gtk_container_add (GTK_CONTAINER (gg_main_window), gg_main_vbox);
  scrol = gtk_scrolled_window_new (NULL ,NULL);
  gtk_box_pack_start (GTK_BOX (gg_main_vbox) ,scrol , TRUE, TRUE, 0);
 
  gg_canvas = gtk_drawing_area_new ();  
  gtk_widget_set_size_request (gg_canvas ,700 ,600);
 
  /* Rajoute la drawing_area a la scrolled_window */
  gtk_scrolled_window_add_with_viewport  (GTK_SCROLLED_WINDOW(scrol),gg_canvas );
   g_signal_connect (G_OBJECT (gg_canvas), "expose_event",  
                    G_CALLBACK (expose_event_callback), NULL);
 
  g_signal_connect (G_OBJECT (gg_main_window), "delete_event"
		    ,G_CALLBACK (gtk_main_quit), NULL);
 
  gtk_widget_show_all (gg_main_window);
  gtk_main ();
  return 0;
}

Salut,

J'ai fait quelquechose qui ressemble avec scrollWindow. Ca marche bien, hormis le fait que la drawing area est extensible a l'infini. J'aurais préféré que la taille de la fenetre se bloque lorsque la drawing area est entierement visible.

le code:

gui.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Fenetre : public Gtk::Window {
    private:
 
        Gtk::ScrolledWindow compoSW;
 
        //dessin
        Gtk::ScrolledWindow plaqueSW;
        Gtk::Viewport plaqueVP;
        Gtk::DrawingArea plaque;
 
        void on_cablage_toggled();
    public:
        Fenetre();
        ~Fenetre();
 
};

gui.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
Fenetre::Fenetre() :
     plaqueVP(*(plaqueSW.get_hadjustment()),*(plaqueSW.get_vadjustment()))
{
 
    plaqueVP.add(plaque); //plaque decrit ailleurs
 
    plaqueSW.set_size_request(220,200); //la taille minimum
    plaqueSW.add(plaqueVP);
    plaqueSW.set_policy(Gtk::POLICY_AUTOMATIC,Gtk::POLICY_AUTOMATIC);
 
 
    add(plaqueSW);
 
    show_all();
}
Fenetre::~Fenetre(){/***/}