bool Application::onCreate()
{
// Get a pointer to the menu of the main window
Menu &menu = *FrameWindow::inst()->createMainMenu();
// Create a new drop down menu
Menu *pFileMenu = menu.addMenuItem("File", 1, makeFunctor(*this, &Application::onMenu));
// Add menu items to this menu.
pFileMenu->addMenuItem("Open image", 101, makeFunctor(*this, &Application::onMenu));
pFileMenu->addMenuItem("Save image", 102, makeFunctor(*this, &Application::onMenu));
pFileMenu->addMenuItem("Save image as..", 103, makeFunctor(*this, &Application::onMenu));
pFileMenu->addSeparator();
pFileMenu->addMenuItem("Page Setup", 104, makeFunctor(*this, &Application::onMenu));
pFileMenu->addMenuItem("Print Preview", 105, makeFunctor(*this, &Application::onMenu));
pFileMenu->addSeparator();
pFileMenu->addMenuItem("Exit", 106, makeFunctor(*this, &Application::onMenu));
Menu *pMenu2 = menu.addMenuItem("Menu 02", 2, makeFunctor(*this, &Application::onMenu));
pMenu2->addMenuItem("Item 1", 201, makeFunctor(*this, &Application::onMenu));
pMenu2->addMenuItem("Item 2", 202, makeFunctor(*this, &Application::onMenu));
// create a child window
m_wnd1.create(30, 50, 420, 400, "child window");
FrameWindow::inst()->addComponent(&m_wnd1);
return true;
}
int main(int argc, char *argv[])
{
// initialize glut
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
// create the main window
glutInitWindowPosition(30,30);
glutInitWindowSize(800,600);
glutCreateWindow("beGUI GLUT Example");
// set the display function
glutDisplayFunc(renderScene);
glutIdleFunc(renderScene);
// resize function
glutReshapeFunc(changeSize);
// handle mouse events
glutMouseFunc(processMouse);
glutMotionFunc(processMouseActiveMotion);
glutPassiveMotionFunc(processMousePassiveMotion);
// initialize beGUI subsystems
initBeGUI();
// create the beGUI window
myWindow.create(20, 20, 200, 200, "test");
myBtn1.create(20, 20, "Show Modal Dialog", 101, makeFunctor((Functor1<int>*)0, &onButtonClick));
myWindow.addComponent(&myBtn1);
myList1.create(20, 50, 160, 100, ListBox::SINGLE_SELECT);
myList1.handleOnItemSelect(makeFunctor((Functor1<int>*)0, &onListSelect));
myList1.addItem("White");
myList1.addItem("Red");
myList1.addItem("Orange");
myList1.addItem("Green");
myList1.addItem("Yellow");
myList1.addItem("Blue");
myList1.addItem("Purple");
myList1.addItem("Grey");
myWindow.addComponent(&myList1);
// create a container to hold all beGUI components
mainContainer.setPos(0,0);
mainContainer.setSize(800, 600);
mainContainer.addComponent(&myWindow);
// create a modal dialog
myModalDlg.create(100, 100, 300, 300, "Modal Dialog");
myDlgBtn1.create(30, 30, "Close Dialog", 10001, makeFunctor((Functor1<int>*)0, &onCloseDlg));
myModalDlg.addComponent(&myDlgBtn1);
// start the main loop
glutMainLoop();
return 0;
}
GUIframe* GUIsharingDialog::CreateControl(const std::string& type, int x, int y, int w, int h, TdfParser& parser)
{
GUIframe *frame=NULL;
if(type=="slider")
{
GUIslider *slider=new GUIslider(x, y, w, 100, makeFunctor((Functor2<GUIslider*, int>*)0, *this, &GUIsharingDialog::SliderChanged));
frame=slider;
}
return frame;
}
void Application::onMenu(int id)
{
switch (id)
{
case 101:
m_dlg1.create(30, 30, 300, 300, "test_dialog");
m_dlgBtn1.create(30, 30, "Close", 10001, makeFunctor(*this, &Application::onMenu));
m_dlg1.addComponent(&m_dlgBtn1);
m_dlg1.showModal();
break;
case 10001:
m_dlg1.close();
break;
case 106:
exit(0);
break;
}
}
void GUItable::ChangeList(const vector<string>* contents)
{
// we kill of the scroll bar
if(bar)
RemoveChild(bar);
data.clear();
// add the new contents
if(contents)
data.insert(data.begin(), contents->begin(), contents->end());
numEntries = data.size();
width=w;
if(numEntries>numLines)
{
width=w-KNOB_SIZE;
// and now we add a new one with the right proportions
bar=new GUIscrollbar(width, 0, h, numEntries-numLines+1, makeFunctor((Functor1<int> *)0, *this, &GUItable::Scrolled));
AddChild(bar);
}
}
int main()
{
int n = 2;
double x[2];
double l[2];
double u[2];
long nbd[2];
nbd[0] = 0;
nbd[1] = 0;
x[0] = 1.;
x[1] = 0.;
// cout << "guesses? ";
// cin >> x[0] >> x [1];
double f = lbfgsb_SS(makeFunctor((VOF*)0, SS), n, n, x, l, u, nbd);
cout << "lbfgsb_SS results" << endl;
cout << "solution = " << setw(10) << x[0] << setw(10) << x[1] << endl;
cout << "SS = " << f << endl;
cout << "reference results from IBM PC/AT" << endl;
cout << "estimate of solution 2.000000 1.000000" << endl;
cout << "values of nonlinear functions 0.0000e+00 0.0000e+00" << endl;
return 0;
}
void ChildWnd1::onCreate()
{
// create the tabs
m_tabs.create(8, 8, 400, 360);
m_tabs.addTab("tab 1");
m_tabs.addTab("tab 2");
m_tabs.addTab("Buttons");
m_tabs.addTab("Radio Buttons");
m_tabs.addTab("Comboboxes");
addComponent(&m_tabs);
// create a simple push button
m_button1.create(260, 40, "Button", 1);
//m_button1.create(260, 40, 80, 60, "Button", 1);
m_button1.setIcon(ResourceManager::inst()->loadImage("gears.png"), Button::NEAR_LEFT, 32,32);
//m_button1.setFace(Button::UP, ResourceManager::inst()->loadImage("gears.png"));
m_tabs.addComponent(&m_button1, 0);
m_button2.create(40, 70, "Button2", 201);
m_button2.disable();
m_button3.create(40, 100, "Button3", 202);
m_button3.repeatClickOnHold(true);
m_button3.handleButtonDown(makeFunctor(*Application::inst(), &Application::onButtonDown));
m_button4.create(40, 130, "Button4", 203, makeFunctor(*Application::inst(), &Application::onClick));
m_button4.setFace(Button::UP, ResourceManager::inst()->loadImage("gears.png"));
m_button4.setTextColor(Color(0.2f, 0.2f, 0.2f));
m_button5.create(240, 130, "Button5", 203);
m_button5.setFace(Button::UP, ResourceManager::inst()->loadImage("gears.png"));
m_button5.setSize(100, 20);
m_button5.setTextColor(Color(0.2f, 0.2f, 0.2f));
//m_tabs.addComponent(&m_button1, 2);
m_tabs.addComponent(&m_button2, 2);
m_tabs.addComponent(&m_button3, 2);
m_tabs.addComponent(&m_button4, 2);
m_tabs.addComponent(&m_button5, 2);
m_checkbox1.create(260, 70, "check here", 102);
m_tabs.addComponent(&m_checkbox1, 0);
m_label1.create(260, 90, "eò á !@#$%^&*()");
// m_tabs.addComponent(&m_label1, 0);
// create a group of radio buttons
m_radio1.create(20, 20, "Radio Button 1", 2);
m_radio2.create(20, 40, "Radio Button 2", 3);
m_group.create(20, 20, 200, 80, "Radio group");
m_group.addComponent(&m_radio1);
m_group.addComponent(&m_radio2);
m_tabs.addComponent(&m_group, 0);
// create a slider (also an example of using a live
// variable)
m_slider.create(20, 120, 300, 4);
m_slider.bindValue(&m_sliderPos);
m_slider.setBounds(0, 10, 2, 20);
m_tabs.addComponent(&m_slider, 0);
// create a textbox
m_textbox.create(230, 160, 130, 180, true, true);
m_textbox.setText("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.");
m_tabs.addComponent(&m_textbox, 0);
m_listbox1.create(20, 140, 200, 200, ListBox::MULTI_SELECT_SINGLECLICK);
m_listbox1.addItem("item 1");
m_listbox1.addItem("disabled item 2");
m_listbox1.addItem("item 3");
m_listbox1.addItem("item 4");
m_listbox1.addItem("item 5");
for (size_t i=0; i<20; ++i)
m_listbox1.addItem("item");
m_listbox1.addItem("last item");
m_listbox1.disableItem(1);
int t1 = m_listbox1.getCurrentItem();
m_listbox1.setCurrentItem(3);
m_listbox1.selectItem(2, true);
int t2 = m_listbox1.getCurrentItem();
Console::print("%d %d\n", t1,t2);
m_tabs.addComponent(&m_listbox1, 0);
m_combobox1.create(230, 140, 80, 200);
m_combobox1.addItem("item 1");
m_combobox1.addItem("item 2");
m_combobox1.addItem("item 3");
m_combobox1.addItem("item 4");
m_combobox1.disableItem(2);
m_combobox1.setCurrentItem(1);
/*m_combobox2.create(230, 120, 80, 200);
m_combobox2.addItem("item 1");
m_tabs.addComponent(&m_combobox2, 0);*/
m_tabs.addComponent(&m_combobox1, 0);
// create a test viewport
Viewport vp;
vp.setPerspectiveProj(0.1f, 100.0f, 45.0f);
m_vp.create(40, 40, 300, 300, vp, makeFunctor(*Application::inst(), &Application::onRenderVp));
m_tabs.addComponent(&m_vp, 1);
// change the size of the window, so that the client area is large
// enough to hold the contents
setClientAreaSize(416, 410);
}
void BoardLedController::setup()
{
// Server Setup
modular_server_.setup();
// Pin Setup
pinMode(constants::led_pin, OUTPUT);
// Add Server Streams
modular_server_.addServerStream(Serial);
// Set Device ID
modular_server_.setDeviceName(constants::device_name);
modular_server_.setFormFactor(constants::form_factor);
// Add Hardware
modular_server_.addHardware(constants::hardware_info,
interrupts_);
// Interrupts
// Add Firmware
modular_server_.addFirmware(constants::firmware_info,
properties_,
parameters_,
functions_,
callbacks_);
// Properties
// Parameters
modular_server::Parameter & duration_on_parameter = modular_server_.createParameter(constants::duration_on_parameter_name);
duration_on_parameter.setUnits(constants::seconds_unit);
duration_on_parameter.setRange(constants::duration_min,constants::duration_max);
modular_server::Parameter & duration_off_parameter = modular_server_.copyParameter(duration_on_parameter,constants::duration_off_parameter_name);
modular_server::Parameter & count_parameter = modular_server_.createParameter(constants::count_parameter_name);
count_parameter.setRange(constants::count_min,constants::count_max);
// Functions
modular_server::Function & led_on_function = modular_server_.createFunction(constants::led_on_function_name);
led_on_function.attachFunctor(makeFunctor((Functor0 *)0,*this,&BoardLedController::setLedOnHandler));
modular_server::Function & led_off_function = modular_server_.createFunction(constants::led_off_function_name);
led_off_function.attachFunctor(makeFunctor((Functor0 *)0,*this,&BoardLedController::setLedOffHandler));
modular_server::Function & get_led_pin_function = modular_server_.createFunction(constants::get_led_pin_function_name);
get_led_pin_function.attachFunctor(makeFunctor((Functor0 *)0,*this,&BoardLedController::getLedPinHandler));
get_led_pin_function.setReturnTypeLong();
modular_server::Function & blink_led_function = modular_server_.createFunction(constants::blink_led_function_name);
blink_led_function.attachFunctor(makeFunctor((Functor0 *)0,*this,&BoardLedController::blinkLedHandler));
blink_led_function.addParameter(duration_on_parameter);
blink_led_function.addParameter(duration_off_parameter);
blink_led_function.addParameter(count_parameter);
// Functions
// Callbacks
// Begin Streams
Serial.begin(constants::baudrate);
// Start Modular Device Server
modular_server_.startServer();
}
void CallbackTester::setup()
{
// Server Setup
modular_server_.setup();
// Add Server Streams
modular_server_.addServerStream(Serial);
// Set Device ID
modular_server_.setDeviceName(constants::device_name);
modular_server_.setFormFactor(constants::form_factor);
// Add Hardware
modular_server_.addHardware(constants::hardware_info,
pins_);
// Pins
modular_server::Pin & led_pin = modular_server_.createPin(constants::led_pin_name,constants::led_pin_number);
led_pin.setModeDigitalOutput();
blinker_.setup(led_pin);
modular_server::Pin & bnc_a_pin = modular_server_.createPin(constants::bnc_a_pin_name,
constants::bnc_a_pin_number);
modular_server::Pin & bnc_b_pin = modular_server_.createPin(constants::bnc_b_pin_name,
constants::bnc_b_pin_number);
modular_server::Pin & bnc_c_pin = modular_server_.createPin(constants::bnc_c_pin_name,
constants::bnc_c_pin_number);
modular_server::Pin & bnc_d_pin = modular_server_.createPin(constants::bnc_d_pin_name,
constants::bnc_d_pin_number);
modular_server::Pin & bnc_e_pin = modular_server_.createPin(constants::bnc_e_pin_name,
constants::bnc_e_pin_number);
modular_server::Pin & bnc_f_pin = modular_server_.createPin(constants::bnc_f_pin_name,
constants::bnc_f_pin_number);
// Add Firmware
modular_server_.addFirmware(constants::firmware_info,
properties_,
parameters_,
functions_,
callbacks_);
// Properties
modular_server::Property & duration_on_property = modular_server_.createProperty(constants::duration_on_property_name,constants::duration_on_default);
duration_on_property.setUnits(constants::seconds_unit);
duration_on_property.setRange(constants::duration_min,constants::duration_max);
modular_server::Property & duration_off_property = modular_server_.createProperty(constants::duration_off_property_name,constants::duration_off_default);
duration_off_property.setUnits(constants::seconds_unit);
duration_off_property.setRange(constants::duration_min,constants::duration_max);
modular_server::Property & count_property = modular_server_.createProperty(constants::count_property_name,constants::count_default);
count_property.setRange(constants::count_min,constants::count_max);
// Parameters
// Functions
// Callbacks
modular_server::Callback & set_led_on_callback = modular_server_.createCallback(constants::set_led_on_callback_name);
set_led_on_callback.attachFunctor(makeFunctor((Functor1<modular_server::Pin *> *)0,*this,&CallbackTester::setLedOnHandler));
set_led_on_callback.attachTo(bnc_a_pin,modular_server::constants::pin_mode_interrupt_falling);
set_led_on_callback.attachTo(bnc_c_pin,modular_server::constants::pin_mode_interrupt_falling);
modular_server::Callback & set_led_off_callback = modular_server_.createCallback(constants::set_led_off_callback_name);
set_led_off_callback.attachFunctor(makeFunctor((Functor1<modular_server::Pin *> *)0,*this,&CallbackTester::setLedOffHandler));
set_led_off_callback.attachTo(bnc_b_pin,modular_server::constants::pin_mode_interrupt_falling);
set_led_off_callback.attachTo(bnc_d_pin,modular_server::constants::pin_mode_interrupt_falling);
set_led_off_callback.attachTo(bnc_f_pin,modular_server::constants::pin_mode_interrupt_falling);
modular_server::Callback & blink_led_callback = modular_server_.createCallback(constants::blink_led_callback_name);
blink_led_callback.attachFunctor(makeFunctor((Functor1<modular_server::Pin *> *)0,*this,&CallbackTester::blinkLedHandler));
blink_led_callback.addProperty(duration_on_property);
blink_led_callback.addProperty(duration_off_property);
blink_led_callback.addProperty(count_property);
blink_led_callback.attachTo(bnc_e_pin,modular_server::constants::pin_mode_interrupt_falling);
// Begin Streams
Serial.begin(constants::baud);
}
void Interrupt::resetIsr()
{
FunctorCallbacks::remove(isr_);
isr_ = FunctorCallbacks::add(makeFunctor((Functor0 *)0,*this,&Interrupt::isrHandler));
}
