Инсталяция библиотеки FLTK

//
// This is a GUI support code to the chapters 12-16 of the book
// "Programming -- Principles and Practice Using C++" by Bjarne Stroustrup
//
 
#ifndef GUI_GUARD
#define GUI_GUARD
 
#include "Window.h"
#include "Graph.h"
#include<FL\Fl_Widget.h>
#include<FL\Fl_Input.h>
#include<FL\Fl_Output.h>
#include<FL\Fl_Button.h>
#include<cctype>
 
namespace Graph_lib {
//------------------------------------------------------------------------------
 
    typedef void* Address;    // Address is a synonym for void*
    typedef void(*Callback)(Graph_lib::Address, Graph_lib::Address);    // FLTK's required function type for all callbacks
 
//------------------------------------------------------------------------------
 
    template<class W> W& reference_to(Graph_lib::Address pw)
    // treat an address as a reference to a W
    {
        return *static_cast<W*>(pw);
    }
 
//------------------------------------------------------------------------------
 
    class Widget {
    // Widget is a handle to an Fl_widget - it is *not* an Fl_widget
    // We try to keep our interface classes at arm's length from FLTK
    public:
        Widget(Point xy, int w, int h, const string& s, Callback cb)
            : loc(xy), width(w), height(h), label(s), do_it(cb)
        {}
 
        virtual void move(int dx,int dy) { hide(); pw->position(loc.x+=dx, loc.y+=dy); show(); }
        virtual void hide() { pw->hide(); }
        virtual void show() { pw->show(); }
        virtual void attach(Window&) = 0;
 
        Point loc;
        int width;
        int height;
        string label;
        Callback do_it;
 
        virtual ~Widget() { }
 
    protected:
        Window* own;    // every Widget belongs to a Window
        Fl_Widget* pw;  // connection to the FLTK Widget
    private:
        Widget& operator=(const Widget&) = delete; // don't copy Widgets
        Widget(const Widget&) = delete;
    };
 
//------------------------------------------------------------------------------
 
    struct Button : Widget {
        Button(Point xy, int w, int h, const string& label, Callback cb)
            : Widget(xy,w,h,label,cb)
        {}
 
        void attach(Window&);
    };
 
//------------------------------------------------------------------------------
 
    struct In_box : Widget {
        In_box(Point xy, int w, int h, const string& s)
            :Widget(xy,w,h,s,0) { }
        int get_int();
        string get_string();
 
        void attach(Window& win);
    };
 
//------------------------------------------------------------------------------
 
    struct Out_box : Widget {
        Out_box(Point xy, int w, int h, const string& s)
            :Widget(xy,w,h,s,0) { }
        void put(int);
        void put(const string&);
 
        void attach(Window& win);
    };
 
//------------------------------------------------------------------------------
 
    struct Menu : Widget {
        enum Kind { horizontal, vertical };
        Menu(Point xy, int w, int h, Kind kk, const string& label)
            : Widget(xy,w,h,label,0), k(kk), offset(0)
        { }
 
        Vector_ref<Button> selection;
        //vector<Button> selection;
        Kind k;
        int offset;
        int attach(Button& b);      // Menu does not delete &b
        int attach(Button* p);      // Menu deletes p
 
        void show()                 // show all buttons
        {
            for (int i = 0; i<selection.size(); ++i)
                selection[i].show();
        }
        void hide()                 // hide all buttons
        {
            for (int i = 0; i<selection.size(); ++i) 
                selection[i].hide(); 
        }
        void move(int dx, int dy)   // move all buttons
        {
            for (int i = 0; i<selection.size(); ++i) 
                selection[i].move(dx,dy);
        }
        //void attach(Window& win);
       [B] void attach(Window& win)    // attach all buttons
        {
            for (unsigned int i=0; i<selection.size(); ++i) 
                win.attach(selection[i]);
 
            own = &win;
        }[/B]
 
    };
 
//------------------------------------------------------------------------------
 
} // of namespace Graph_lib
 
#endif // GUI_GUARD

#include "Window.h"
//#include "Graph.h"
//#include "GUI.h"
 
namespace Graph_lib
{
 
Window::Window(int ww, int hh, const string& title)
:Fl_Window(ww,hh,title.c_str()),w(ww),h(hh)
{
    init();
}
 
Window::Window(Point xy, int ww, int hh, const string& title)
:Fl_Window(xy.x,xy.y,ww,hh,title.c_str()),w(ww),h(hh)
{ 
    init();
}
 
void Window::init()
{
   resizable(this);
   show();
} 
 
//---------------------------------------------------- 
 
void Window::draw()
{
    Fl_Window::draw();
    for (unsigned int i=0; i<shapes.size(); ++i) shapes[i]->draw();
}
 
[B]void Window::attach(Widget& w)
{
    begin();            // FTLK: begin attaching new Fl_Wigets to this window
        w.attach(*this);    // let the Widget create its Fl_Wigits
    end();              // FTLK: stop attaching new Fl_Wigets to this window
}[/B]
 
void Window::detach(Widget& b)
{
      b.hide();
}
 
void Window::attach(Shape& s)
{
        shapes.push_back(&s);
//      s.attached = this;
}
void Window::detach(Shape& s)
{
        for (unsigned int i = shapes.size(); 0<i; --i)  // guess last attached will be first released
            if (shapes[i-1]==&s)
                shapes.erase(shapes.begin()+(i-1));//&shapes[i-1]);
}
 
 
void Window::put_on_top(Shape& p) {
    for (unsigned int i=0; i<shapes.size(); ++i) {
        if (&p==shapes[i]) {
            for (++i; i<shapes.size(); ++i)
                shapes[i-1] = shapes[i];
            shapes[shapes.size()-1] = &p;
            return;
        }
    }
}
 
 
 
int gui_main() { return Fl::run(); }
 
} // Graph