Show
Ignore:
Timestamp:
05/09/08 12:27:59 (6 years ago)
Author:
robert
Message:

From Jeremy Moles, fixed window resize problem

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/examples/osgviewerGTK/osgviewerGTK.cpp

    r8290 r8294  
    1 // by: Jeremy Moles <jeremy@emperorlinux.com> 2007 
    2  
    31#include <iostream> 
    42#include <string> 
     
    97 
    108const char* HELP_TEXT = 
    11         "Use CTRL or SHIFT plus right-click to pull up a fake menu.\n" 
    12         "Use the standard TrackballManipulator keys to rotate the loaded\n" 
    13         "model (with caveats; the model won't keep rotating).\n" 
    14         "\n" 
    15         "<b>OpenSceneGraph Project, 2008</b>" 
     9    "Use CTRL or SHIFT plus right-click to pull up a fake menu.\n" 
     10    "Use the standard TrackballManipulator keys to rotate the loaded\n" 
     11    "model (with caveats; the model won't keep rotating).\n" 
     12    "\n" 
     13    "<b>OpenSceneGraph Project, 2008</b>" 
    1614; 
    1715 
     
    2018// come up with. 
    2119bool activate(GtkWidget* widget, gpointer) { 
    22         GtkWidget* label = gtk_bin_get_child(GTK_BIN(widget)); 
    23  
    24         std::cout << "MENU: " << gtk_label_get_label(GTK_LABEL(label)) << std::endl; 
    25  
    26         return true; 
     20    GtkWidget* label = gtk_bin_get_child(GTK_BIN(widget)); 
     21 
     22    std::cout << "MENU: " << gtk_label_get_label(GTK_LABEL(label)) << std::endl; 
     23 
     24    return true; 
    2725} 
    2826 
     
    3533// itself. 
    3634class ExampleOSGGTKDrawingArea : public OSGGTKDrawingArea { 
    37         GtkWidget* _menu; 
    38          
    39         unsigned int _tid; 
    40  
    41         // A helper function to easily setup our menu entries. 
    42         void _menuAdd(const std::string& title) { 
    43                 GtkWidget* item = gtk_menu_item_new_with_label(title.c_str()); 
    44                  
    45                 gtk_menu_shell_append(GTK_MENU_SHELL(_menu), item); 
    46  
    47                 g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(activate), 0); 
    48         } 
    49  
    50         bool _clicked(GtkWidget* widget) { 
    51                 const char* text = gtk_label_get_label( 
    52                         GTK_LABEL(gtk_bin_get_child(GTK_BIN(widget))) 
    53                 ); 
    54  
    55                 if(not std::strncmp(text, "Close", 5)) gtk_main_quit(); 
    56          
    57                 else if(not std::strncmp(text, "Open File", 9)) { 
    58                         GtkWidget* of = gtk_file_chooser_dialog_new( 
    59                                 "Please select an OSG file...", 
    60                                 GTK_WINDOW(gtk_widget_get_toplevel(getWidget())), 
    61                                 GTK_FILE_CHOOSER_ACTION_OPEN, 
    62                                 GTK_STOCK_CANCEL, 
    63                                 GTK_RESPONSE_CANCEL, 
    64                                 GTK_STOCK_OPEN, 
    65                                 GTK_RESPONSE_ACCEPT, 
    66                                 NULL 
    67                         ); 
    68  
    69                         if(gtk_dialog_run(GTK_DIALOG(of)) == GTK_RESPONSE_ACCEPT) { 
    70                                 char* file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(of)); 
    71  
    72                                 osg::ref_ptr<osg::Node> model = osgDB::readNodeFile(file); 
    73  
    74                                 if(model.valid()) { 
    75                                         setSceneData(model.get()); 
    76                                  
    77                                         queueDraw(); 
    78                                 } 
    79  
    80                                 g_free(file); 
    81                         } 
    82                          
    83                         gtk_widget_destroy(of); 
    84                 } 
    85  
    86                 // Assume we're wanting FPS toggling. 
    87                 else { 
    88                         if(not _tid) { 
    89                                 _tid = g_timeout_add( 
    90                                         15, 
    91                                         (GSourceFunc)(ExampleOSGGTKDrawingArea::timeout), 
    92                                         this 
    93                                 ); 
    94  
    95                                 gtk_button_set_label(GTK_BUTTON(widget), "Toggle 60 FPS (off)"); 
    96                         } 
    97  
    98                         else { 
    99                                 g_source_remove(_tid); 
    100                                 gtk_button_set_label(GTK_BUTTON(widget), "Toggle 60 FPS (on)"); 
    101  
    102                                 _tid = 0; 
    103                         } 
    104                 } 
    105  
    106                 return true; 
    107         } 
     35    GtkWidget* _menu; 
     36     
     37    unsigned int _tid; 
     38 
     39    // A helper function to easily setup our menu entries. 
     40    void _menuAdd(const std::string& title) { 
     41        GtkWidget* item = gtk_menu_item_new_with_label(title.c_str()); 
     42         
     43        gtk_menu_shell_append(GTK_MENU_SHELL(_menu), item); 
     44 
     45        g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(activate), 0); 
     46    } 
     47 
     48    bool _clicked(GtkWidget* widget) { 
     49        const char* text = gtk_label_get_label( 
     50            GTK_LABEL(gtk_bin_get_child(GTK_BIN(widget))) 
     51        ); 
     52 
     53        if(not std::strncmp(text, "Close", 5)) gtk_main_quit(); 
     54     
     55        else if(not std::strncmp(text, "Open File", 9)) { 
     56            GtkWidget* of = gtk_file_chooser_dialog_new( 
     57                "Please select an OSG file...", 
     58                GTK_WINDOW(gtk_widget_get_toplevel(getWidget())), 
     59                GTK_FILE_CHOOSER_ACTION_OPEN, 
     60                GTK_STOCK_CANCEL, 
     61                GTK_RESPONSE_CANCEL, 
     62                GTK_STOCK_OPEN, 
     63                GTK_RESPONSE_ACCEPT, 
     64                NULL 
     65            ); 
     66 
     67            if(gtk_dialog_run(GTK_DIALOG(of)) == GTK_RESPONSE_ACCEPT) { 
     68                char* file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(of)); 
     69 
     70                osg::ref_ptr<osg::Node> model = osgDB::readNodeFile(file); 
     71 
     72                if(model.valid()) { 
     73                    setSceneData(model.get()); 
     74                 
     75                    queueDraw(); 
     76                } 
     77 
     78                g_free(file); 
     79            } 
     80             
     81            gtk_widget_destroy(of); 
     82        } 
     83 
     84        // Assume we're wanting FPS toggling. 
     85        else { 
     86            if(not _tid) { 
     87                _tid = g_timeout_add( 
     88                    15, 
     89                    (GSourceFunc)(ExampleOSGGTKDrawingArea::timeout), 
     90                    this 
     91                ); 
     92 
     93                gtk_button_set_label(GTK_BUTTON(widget), "Toggle 60 FPS (off)"); 
     94            } 
     95 
     96            else { 
     97                g_source_remove(_tid); 
     98                gtk_button_set_label(GTK_BUTTON(widget), "Toggle 60 FPS (on)"); 
     99 
     100                _tid = 0; 
     101            } 
     102        } 
     103 
     104        return true; 
     105    } 
    108106 
    109107protected: 
    110         // Check right-click release to see if we need to popup our menu. 
    111         bool gtkButtonRelease(double, double, unsigned int button) { 
    112                 if(button == 3 and (stateControl() or stateShift())) gtk_menu_popup( 
    113                         GTK_MENU(_menu), 
    114                         0, 
    115                         0, 
    116                         0, 
    117                         0, 
    118                         button, 
    119                         0 
    120                 ); 
    121  
    122                 return true; 
    123         } 
    124  
    125         // Our "main" drawing pump. Since our app is just a model viewer, we use 
    126         // click+motion as our criteria for issuing OpenGL refreshes. 
    127         bool gtkMotionNotify(double, double) { 
    128                 if(stateButton()) queueDraw(); 
    129  
    130                 return true; 
    131         } 
     108    // Check right-click release to see if we need to popup our menu. 
     109    bool gtkButtonRelease(double, double, unsigned int button) { 
     110        if(button == 3 and (stateControl() or stateShift())) gtk_menu_popup( 
     111            GTK_MENU(_menu), 
     112            0, 
     113            0, 
     114            0, 
     115            0, 
     116            button, 
     117            0 
     118        ); 
     119 
     120        return true; 
     121    } 
     122 
     123    // Our "main" drawing pump. Since our app is just a model viewer, we use 
     124    // click+motion as our criteria for issuing OpenGL refreshes. 
     125    bool gtkMotionNotify(double, double) { 
     126        if(stateButton()) queueDraw(); 
     127 
     128        return true; 
     129    } 
    132130 
    133131public: 
    134         ExampleOSGGTKDrawingArea(): 
    135         OSGGTKDrawingArea (), 
    136         _menu             (gtk_menu_new()), 
    137         _tid              (0) { 
    138                 _menuAdd("Option"); 
    139                 _menuAdd("Another Option"); 
    140                 _menuAdd("Still More Options"); 
    141  
    142                 gtk_widget_show_all(_menu); 
    143  
    144                 getCamera()->setStats(new osg::Stats("omg")); 
    145         } 
    146  
    147         ~ExampleOSGGTKDrawingArea() {} 
    148  
    149         // Public so that we can use this as a callback in main(). 
    150         static bool clicked(GtkWidget* widget, gpointer self) { 
    151                 return static_cast<ExampleOSGGTKDrawingArea*>(self)->_clicked(widget); 
    152         } 
    153  
    154         //static gboolean timeout(GtkWidget* widget) { 
    155         static bool timeout(void* self) { 
    156                 static_cast<ExampleOSGGTKDrawingArea*>(self)->queueDraw(); 
    157  
    158                 return true; 
    159         } 
     132    ExampleOSGGTKDrawingArea(): 
     133    OSGGTKDrawingArea (), 
     134    _menu             (gtk_menu_new()), 
     135    _tid              (0) { 
     136        _menuAdd("Option"); 
     137        _menuAdd("Another Option"); 
     138        _menuAdd("Still More Options"); 
     139 
     140        gtk_widget_show_all(_menu); 
     141 
     142        getCamera()->setStats(new osg::Stats("omg")); 
     143    } 
     144 
     145    ~ExampleOSGGTKDrawingArea() {} 
     146 
     147    // Public so that we can use this as a callback in main(). 
     148    static bool clicked(GtkWidget* widget, gpointer self) { 
     149        return static_cast<ExampleOSGGTKDrawingArea*>(self)->_clicked(widget); 
     150    } 
     151 
     152    //static gboolean timeout(GtkWidget* widget) { 
     153    static bool timeout(void* self) { 
     154        static_cast<ExampleOSGGTKDrawingArea*>(self)->queueDraw(); 
     155 
     156        return true; 
     157    } 
    160158}; 
    161159 
     
    164162// code or so. 
    165163int main(int argc, char** argv) { 
    166         gtk_init(&argc, &argv); 
    167         gtk_gl_init(&argc, &argv); 
    168  
    169         ExampleOSGGTKDrawingArea da; 
    170  
    171         if(da.createWidget(640, 480)) { 
    172                 if(argc >= 2) { 
    173                         osg::ref_ptr<osg::Node> model = osgDB::readNodeFile(argv[1]); 
    174  
    175                         if(model.valid()) da.setSceneData(model.get()); 
    176                 } 
    177  
    178                 GtkWidget* window    = gtk_window_new(GTK_WINDOW_TOPLEVEL); 
    179                 GtkWidget* vbox1     = gtk_vbox_new(false, 3); 
    180                 GtkWidget* vbox2     = gtk_vbox_new(false, 3); 
    181                 GtkWidget* hbox      = gtk_hbox_new(false, 3); 
    182                 GtkWidget* label     = gtk_label_new(""); 
    183                 GtkWidget* buttons[] = { 
    184                         gtk_button_new_with_label("Open File"), 
    185                         gtk_button_new_with_label("Toggle 60 FPS (on)"), 
    186                         gtk_button_new_with_label("Close") 
    187                 }; 
    188  
    189                 gtk_label_set_use_markup(GTK_LABEL(label), true); 
    190                 gtk_label_set_label(GTK_LABEL(label), HELP_TEXT); 
    191  
    192                 for(unsigned int i = 0; i < sizeof(buttons) / sizeof(GtkWidget*); i++) { 
    193                         gtk_box_pack_start( 
    194                                 GTK_BOX(vbox2), 
    195                                 buttons[i], 
    196                                 false, 
    197                                 false, 
    198                                 0 
    199                         ); 
    200  
    201                         g_signal_connect( 
    202                                 G_OBJECT(buttons[i]), 
    203                                 "clicked", 
    204                                 G_CALLBACK(ExampleOSGGTKDrawingArea::clicked), 
    205                                 &da 
    206                         ); 
    207                 } 
    208  
    209                 gtk_window_set_title(GTK_WINDOW(window), "osgviewerGTK"); 
    210  
    211                 gtk_box_pack_start(GTK_BOX(hbox), vbox2, true, true, 2); 
    212                 gtk_box_pack_start(GTK_BOX(hbox), label, true, true, 2); 
    213  
    214                 gtk_box_pack_start(GTK_BOX(vbox1), da.getWidget(), true, true, 2); 
    215                 gtk_box_pack_start(GTK_BOX(vbox1), hbox, false, false, 2); 
    216  
    217                 gtk_container_set_reallocate_redraws(GTK_CONTAINER(window), true); 
    218                 gtk_container_add(GTK_CONTAINER(window), vbox1); 
    219  
    220                 g_signal_connect( 
    221                         G_OBJECT(window), 
    222                         "delete_event", 
    223                         G_CALLBACK(gtk_main_quit), 
    224                         0 
    225                 ); 
    226  
    227                 gtk_widget_show_all(window); 
    228                 gtk_main(); 
    229         } 
    230  
    231         else return 1; 
    232  
    233         return 0; 
     164    gtk_init(&argc, &argv); 
     165    gtk_gl_init(&argc, &argv); 
     166 
     167    ExampleOSGGTKDrawingArea da; 
     168 
     169    if(da.createWidget(640, 480)) { 
     170        if(argc >= 2) { 
     171            osg::ref_ptr<osg::Node> model = osgDB::readNodeFile(argv[1]); 
     172 
     173            if(model.valid()) da.setSceneData(model.get()); 
     174        } 
     175 
     176        GtkWidget* window    = gtk_window_new(GTK_WINDOW_TOPLEVEL); 
     177        GtkWidget* vbox1     = gtk_vbox_new(false, 3); 
     178        GtkWidget* vbox2     = gtk_vbox_new(false, 3); 
     179        GtkWidget* hbox      = gtk_hbox_new(false, 3); 
     180        GtkWidget* label     = gtk_label_new(""); 
     181        GtkWidget* buttons[] = { 
     182            gtk_button_new_with_label("Open File"), 
     183            gtk_button_new_with_label("Toggle 60 FPS (on)"), 
     184            gtk_button_new_with_label("Close") 
     185        }; 
     186 
     187        gtk_label_set_use_markup(GTK_LABEL(label), true); 
     188        gtk_label_set_label(GTK_LABEL(label), HELP_TEXT); 
     189 
     190        for(unsigned int i = 0; i < sizeof(buttons) / sizeof(GtkWidget*); i++) { 
     191            gtk_box_pack_start( 
     192                GTK_BOX(vbox2), 
     193                buttons[i], 
     194                false, 
     195                false, 
     196                0 
     197            ); 
     198 
     199            g_signal_connect( 
     200                G_OBJECT(buttons[i]), 
     201                "clicked", 
     202                G_CALLBACK(ExampleOSGGTKDrawingArea::clicked), 
     203                &da 
     204            ); 
     205        } 
     206 
     207        gtk_window_set_title(GTK_WINDOW(window), "osgviewerGTK"); 
     208 
     209        gtk_box_pack_start(GTK_BOX(hbox), vbox2, true, true, 2); 
     210        gtk_box_pack_start(GTK_BOX(hbox), label, true, true, 2); 
     211 
     212        gtk_box_pack_start(GTK_BOX(vbox1), da.getWidget(), true, true, 2); 
     213        gtk_box_pack_start(GTK_BOX(vbox1), hbox, false, false, 2); 
     214 
     215        gtk_container_set_reallocate_redraws(GTK_CONTAINER(window), true); 
     216        gtk_container_add(GTK_CONTAINER(window), vbox1); 
     217 
     218        g_signal_connect( 
     219            G_OBJECT(window), 
     220            "delete_event", 
     221            G_CALLBACK(gtk_main_quit), 
     222            0 
     223        ); 
     224 
     225        gtk_widget_show_all(window); 
     226        gtk_main(); 
     227    } 
     228 
     229    else return 1; 
     230 
     231    return 0; 
    234232}