Wow, your code is MUCH cleaner than mine. I basically did a hack job on the rest of the program just to get things to work. Now I'm going to redo my entire program based off the framework you showed me. That way I can keep things tight without all the mess I had before. It's going to take me a while, but in the end it'll be worth it. As I said earlier I am still learning this stuff.

I see what you did and the way things are laid out is almost perfect for my program. With a little tweaking here and there, I should be able to modify most of my other program to do what I need. There are just a bunch of different ways to do things like this. With some studying on this program and FLUID code I'll make, I think I'll get things down before too long.

On a side note, do you plan on making any more FLTK videos? They are a HUGE help and I'd love to get into some class stuff (that's the thing I feel I'm lacking most in C++)

Thanks for all your help,
Adam



> > 	I'll try to follow up with a rewrite of your app, so that you can get
> > 	an idea of how it should be laid out. Shouldn't be hard.
>
>    I rewrote it -- you may not recognize it, but this is more likely
>    how it should be laid out.. this approach will 'scale' to larger apps.
>
>    Notice how everything is in the EditorWindow class now.. this
>    way all the methods/callbacks can access all the data it needs
>    without it being global.
>
>    This means you can easily create several instances of EditorWindow,
>    each with its own commands that can be running concurrently.
>
>    Notes on what I removed (for brevity):
>
>        > I wasn't sure what the multibrowser was for, so I took it out.
>
>        > I also removed the file load stuff, because it seemed unrelated
>          to the problem. Note that Fl_Text_Buffer has a loadfile() method,
>          so you can use that to load the editor with a text file, rather
>          than writing it yourself, though maybe you needed something custom,
>          I didn't look.
>
>        > I rewrote the menu code a bit.. I dislike using that static menu
>          array stuff, and prefer using the menubar->add() approach.
>
>    Study the design of this, and see if you can see why it has
>    been laid out this way. Putting all the variables into the class
>    cleans up all the variable scoping, so that everything has access
>    to what it needs, cleanly, without all those nasty globals.
>
>    Follow up with questions if you need to, but I think if you look
>    at it carefully, you'll get it.
>
>    The nasty globals in the original demo app were just to keep
>    the demo simple. It's assumed the reader is familiar with the
>    mechanics of C++, and after reading the example, can re-scope the
>    the variables as they please.
>
>    HTH.
>
> ---- snip
>
> #include <stdio.h>
> #include <stdlib.h>
> #include <string.h>
> #include <ctype.h>
> #include <errno.h>
> #ifdef _WIN32
> #include <windows.h>
> #define popen  _popen
> #define pclose _pclose
> #else
> #include <unistd.h>
> #endif
> #include <FL/Fl.H>
> #include <FL/Fl_Double_Window.H>
> #include <FL/Fl_Menu_Bar.H>
> #include <FL/Fl_Text_Buffer.H>
> #include <FL/Fl_Text_Editor.H>
> #include <FL/Fl_Window.H>
>
> class EditorWindow : public Fl_Double_Window {
>     // Menubar
>     Fl_Menu_Bar *menubar;
>
>     // File editor
>     Fl_Text_Editor *file_edit;
>     Fl_Text_Buffer *file_buff;
>
>     // Console editor
>     Fl_Text_Editor *console_edit;
>     Fl_Text_Buffer *console_buff;
>
>     // Popen stuff
>     FILE *fp;
>     char command[512];
>
>     // DATA CALLBACK: Handle reading data from running command
>     void HandleFD() {
>         static char s[1024];
>         if ( fgets(s, sizeof(s)-1, fp) == NULL ) {
>             Fl::remove_fd(fileno(fp));
>             pclose(fp);
>             fp = 0;
>             console_buff->append("--- COMMAND COMPLETED\n");
>         } else {
>             console_buff->append(s);
>         }
>     }
>     static void HandleFD_CB(int, void *userdata) {
>         EditorWindow *ewin = (EditorWindow*)userdata;
>         ewin->HandleFD();                               // avoids having to do ewin->xxx to access vars
>     }
>     // MENU CALLBACK: Build command
>     static void MakeCommand_CB(Fl_Widget*, void*userdata) {
>         EditorWindow *ewin = (EditorWindow*)userdata;
>         strcpy(ewin->command, "netstat -an 2>&1");      // create the command
>     }
>     // MENU CALLBACK: Start command running
>     void RunCommand() {
>         if ( fp != 0 ) return;                          // command already running? ignore
>         console_buff->text("");                         // clear window
>         if ( command[0] == 0 ) {                        // no command? complain
>             console_buff->text("No command specified");
>             return;
>         }
>         fp = popen(command, "r");                       // start command running..
>         if ( fp == NULL ) {                             // Failed? show error
>             console_buff->append("ERROR: popen: ");
>             console_buff->append(strerror(errno));
>         } else {                                        // Worked? setup handler
>             Fl::add_fd(fileno(fp), HandleFD_CB, (void*)this);
>         }
>     }
>     // MENU CALLBACK: Start command running
>     static void RunCommand_CB(Fl_Widget*, void*userdata) {
>         EditorWindow *ewin = (EditorWindow*)userdata;
>         ewin->RunCommand();                             // avoids having to do ewin->xxx to access vars
>     }
>
> public:
>     // Ctor
>     EditorWindow(int w, int h, const char* t) : Fl_Double_Window(w, h, t) {
>         // Create menu bar
>         menubar = new Fl_Menu_Bar(0, 0, w, 25);
>         menubar->add("&File/Make Command", FL_CTRL+'s', MakeCommand_CB, (void*)this);
>         menubar->add("&File/Run",          FL_CTRL+'r', RunCommand_CB,  (void*)this);
>
>         // Create file editor
>         file_edit = new Fl_Text_Editor(0, 40, w, 260, "File Editor");
>         file_buff = new Fl_Text_Buffer();
>         file_edit->buffer(file_buff);
>         file_edit->textfont(FL_COURIER);
>
>         // Create console editor
>         console_edit = new Fl_Text_Editor(0, 320, w, 260, "Console Output");
>         console_buff = new Fl_Text_Buffer();
>         console_edit->buffer(console_buff);
>         console_edit->textfont(FL_COURIER);
>
>         // Popen stuff
>         fp = NULL;
>         command[0] = 0;
>
>         end();
>         resizable(this);
>     }
>     ~EditorWindow() {
>     }
> };
>
> int main(int argc, char **argv) {
>     EditorWindow *ewin = new EditorWindow(600, 600, "Test");
>     ewin->show();
>     return(Fl::run());
> }