void Box::read(XmlReader& e)
{
_leftMargin = _rightMargin = _topMargin = _bottomMargin = 0.0;
_boxHeight = Spatium(0); // override default set in constructor
_boxWidth = Spatium(0);
bool keepMargins = false; // whether original margins have to be kept when reading old file
while (e.readNextStartElement()) {
const QStringRef& tag(e.name());
if (tag == "HBox") {
HBox* hb = new HBox(score());
hb->read(e);
add(hb);
keepMargins = true; // in old file, box nesting used outer box margins
}
else if (tag == "VBox") {
VBox* vb = new VBox(score());
vb->read(e);
add(vb);
keepMargins = true; // in old file, box nesting used outer box margins
}
else if (!Box::readProperties(e))
e.unknown();
}
// with .msc versions prior to 1.17, box margins were only used when nesting another box inside this box:
// for backward compatibility set them to 0 in all other cases
if (score()->mscVersion() < 117 && (type() == Element::Type::HBOX || type() == Element::Type::VBOX) && !keepMargins) {
_leftMargin = _rightMargin = _topMargin = _bottomMargin = 0.0;
}
}
options::options (Gtk::Window & parent, perform * a_p):
Gtk::Dialog ("Options", parent, true, true),
m_perf(a_p)
{
#if GTK_MINOR_VERSION < 12
m_tooltips = manage(new Tooltips());
#endif
HBox *hbox = manage (new HBox ());
get_vbox ()->pack_start (*hbox, false, false);
get_action_area ()->set_border_width (2);
hbox->set_border_width (6);
m_button_ok = manage (new Button(Gtk::Stock::OK));
get_action_area ()->pack_end (*m_button_ok, false, false);
m_button_ok->signal_clicked ().connect (mem_fun (*this, &options::hide));
m_notebook = manage (new Notebook ());
hbox->pack_start (*m_notebook);
add_midi_clock_page();
add_midi_input_page();
add_keyboard_page();
add_mouse_page();
add_jack_sync_page();
}
//-----------------------------------------------------------------
void
MenuOptions::prepareMenu()
{
if (m_container) {
deregisterDrawable(m_container);
delete m_container;
m_container = NULL;
}
Labels labels(Path::dataReadPath("script/labels.lua"));
IWidget *soundBox = createSoundPanel(labels);
IWidget *musicBox = createMusicPanel(labels);
VBox *vbox = new VBox();
vbox->addWidget(soundBox);
vbox->addWidget(new WiSpace(0, 10));
vbox->addWidget(musicBox);
vbox->addWidget(new WiSpace(0, 10));
vbox->addWidget(createLangPanel(labels));
vbox->addWidget(new WiSpace(0, 5));
vbox->addWidget(createSpeechPanel(labels));
vbox->addWidget(new WiSpace(0, 5));
vbox->addWidget(createSubtitlesPanel(labels));
IWidget *backButton = createBackButton(labels);
m_statusBar = createStatusBar(musicBox->getW() - backButton->getW());
HBox *backBox = new HBox();
backBox->addWidget(m_statusBar);
backBox->addWidget(backButton);
vbox->addWidget(backBox);
m_container = vbox;
registerDrawable(m_container);
}
BrushPopup::BrushPopup()
: PopupWindow("", ClickBehavior::CloseOnClickInOtherWindow)
, m_tooltipManager(nullptr)
, m_standardBrushes(3)
, m_customBrushes(nullptr)
{
auto& brushes = App::instance()->brushes();
setAutoRemap(false);
setBorder(gfx::Border(2)*guiscale());
setChildSpacing(0);
m_box.noBorderNoChildSpacing();
m_standardBrushes.setTriggerOnMouseUp(true);
addChild(&m_box);
HBox* top = new HBox;
top->addChild(&m_standardBrushes);
top->addChild(new BoxFiller);
m_box.addChild(top);
m_box.addChild(new Separator("", HORIZONTAL));
for (const auto& brush : brushes.getStandardBrushes())
m_standardBrushes.addItem(
new SelectBrushItem(
BrushSlot(BrushSlot::Flags::BrushType, brush)));
m_standardBrushes.setTransparent(true);
m_standardBrushes.setBgColor(gfx::ColorNone);
brushes.ItemsChange.connect(&BrushPopup::onBrushChanges, this);
}
void
setupOverlayView( osgViewer::View* view, osg::Group* parent, MapNode* mapNode )
{
ControlCanvas* canvas = ControlCanvas::getOrCreate(view);
VBox* v = canvas->addControl(new VBox());
v->setBackColor( Color(Color::Black,0.75) );
{
HBox* camBox = v->addControl(new HBox());
{
camBox->addControl(s_cameraCheck = new CheckBoxControl(true, new Toggle(parent,"camera")));
camBox->addControl(new LabelControl("Camera", Color("#00ff00")));
}
//HBox* overlayBox = v->addControl(new HBox());
//{
// overlayBox->addControl(s_overlayCheck = new CheckBoxControl(false, new Toggle(parent,"overlay")));
// overlayBox->addControl(new LabelControl("Overlay", Color("#00ffff")));
//}
HBox* isectBox = v->addControl(new HBox());
{
isectBox->addControl(s_intersectionCheck = new CheckBoxControl(true, new Toggle(parent,"intersection")));
isectBox->addControl(new LabelControl("Intersection",Color("#ff7f00")));
}
HBox* rttBox = v->addControl(new HBox());
{
rttBox->addControl(s_rttCheck = new CheckBoxControl(true, new Toggle(parent,"rtt")));
rttBox->addControl(new LabelControl("RTT", Color("#ffff00")));
}
}
view->addEventHandler( new PHDumper(mapNode, parent) );
}
HBox* HBox::create(const cocos2d::Size &size)
{
HBox* widget = new (std::nothrow) HBox();
if (widget && widget->initWithSize(size))
{
widget->autorelease();
return widget;
}
CC_SAFE_DELETE(widget);
return nullptr;
}
//-----------------------------------------------------------------
IWidget *
MenuOptions::createMusicPanel(const Labels &labels)
{
HBox *musicBox = new HBox();
musicBox->addWidget(new WiPicture(
Path::dataReadPath("images/menu/volume_music.png")));
musicBox->addWidget(new WiSpace(10, 0));
musicBox->addWidget(new Slider("volume_music", 0, 100));
musicBox->setTip(labels.getLabel("menu_music"));
return musicBox;
}
//-----------------------------------------------------------------
IWidget *
MenuOptions::createSoundPanel(const Labels &labels)
{
HBox *soundBox = new HBox();
soundBox->addWidget(new WiPicture(
Path::dataReadPath("images/menu/volume_sound.png")));
soundBox->addWidget(new WiSpace(10, 0));
soundBox->addWidget(new Slider("volume_sound", 0, 100));
soundBox->setTip(labels.getLabel("menu_sound"));
return soundBox;
}
HBox* HBox::create()
{
HBox* widget = new (std::nothrow) HBox();
if (widget && widget->init())
{
widget->autorelease();
return widget;
}
CC_SAFE_DELETE(widget);
return nullptr;
}
/**
* Creates menu to select 'speech'.
* NOTE: default speech is customized in "script/init.lua"
*/
IWidget *
MenuOptions::createSpeechPanel(const Labels &labels)
{
HBox *speechBox = new HBox();
speechBox->addWidget(new WiPicture(
Path::dataReadPath("images/menu/speech.png")));
speechBox->addWidget(new WiSpace(10, 0));
speechBox->addWidget(new SelectLang("speech",
Path::dataReadPath("script/select_speech.lua")));
speechBox->setTip(labels.getLabel("menu_speech"));
return speechBox;
}
//-----------------------------------------------------------------
IWidget *
MenuOptions::createLangPanel(const Labels &labels)
{
HBox *langBox = new HBox();
langBox->addWidget(new WiPicture(
Path::dataReadPath("images/menu/lang.png")));
langBox->addWidget(new WiSpace(10, 0));
langBox->addWidget(new SelectLang("lang",
Path::dataReadPath("script/select_lang.lua")));
langBox->setTip(labels.getLabel("menu_lang"));
return langBox;
}
SimpleFileInfoRenderer(FileInfoItem *fileInfo) : pause(Stock::MEDIA_PAUSE), cancel(Stock::CANCEL), icon(fileInfo->getDirection()?Stock::GOTO_TOP:Stock::GOTO_BOTTOM, IconSize(ICON_SIZE_DND)) {
finfo = fileInfo;
textInfo.pack_start(fileName, PACK_EXPAND_WIDGET);
textInfo.pack_start(peerName, PACK_EXPAND_WIDGET);
progressContainer.pack_start(progress, PACK_EXPAND_WIDGET);
progressContainer.pack_start(pause, PACK_SHRINK);
progressContainer.pack_start(cancel, PACK_SHRINK);
info.pack_start(textInfo, PACK_EXPAND_WIDGET);
info.pack_start(icon, PACK_SHRINK);
mainBox.pack_start(info, PACK_SHRINK);
mainBox.pack_start(progressContainer, PACK_SHRINK);
updateData();
}
FileDialog::FileDialog (
const char* msg, const char* dir, const char* confirmLbl
) {
int space = Math::round(fspace*ivcm);
_browser = new FileBrowser(state, dir, 20, 35, false, Reversed,"\000\007");
_dirs = new FileBrowser(
"dirBrowser", state, dir, 20, 24, true, Reversed,"d\007"
);
_dirs->SetTextFilter("^$"); // show directories only
_dirs->Update();
_cur_dir = new MarginFrame(new Message("path", FullPath(_dirs)));
HBox* dirBox = new HBox(
new Message("Directory: "),
_cur_dir,
new HGlue
);
dirBox->Propagate(false);
Insert(
new MarginFrame(
new VBox(
new HBox(
new VBox(
new Message("Change directory to:", Left, 0, hfil),
new Frame(AddScroller(_dirs))
),
new HGlue(space, 0),
new VBox(
new Message(msg, Left, 0, hfil),
new Frame(AddScroller(_browser))
)
),
new VGlue(space, 0),
dirBox,
new VGlue(space, 0),
new HBox(
new HGlue,
new PushButton(" Cancel ", state, '\007'),
new HGlue(space, 0),
new PushButton(confirmLbl, state, '\r')
)
), space, space, 0
)
);
}
void InspectorHBox::setElement(Element* e)
{
HBox* box = static_cast<HBox*>(e);
qreal _spatium = e->score()->spatium();
hb.elementName->setText(e->name());
hb.leftGap->blockSignals(true);
hb.rightGap->blockSignals(true);
hb.width->blockSignals(true);
hb.leftGap->setValue(box->topGap() / _spatium);
hb.rightGap->setValue(box->bottomGap() / _spatium);
hb.width->setValue(box->boxHeight().val());
hb.leftGap->blockSignals(false);
hb.rightGap->blockSignals(false);
hb.width->blockSignals(false);
}
// Build a slider to adjust the vertical scale
osgEarth::Util::Controls::Control* createUI( osg::Uniform* scaler )
{
using namespace osgEarth::Util::Controls;
struct ApplyVerticalScale : public ControlEventHandler {
osg::Uniform* _u;
ApplyVerticalScale(osg::Uniform* u) : _u(u) { }
void onValueChanged(Control*, float value) {
_u->set( value );
}
};
HBox* hbox = new HBox();
hbox->setChildVertAlign( Control::ALIGN_CENTER );
hbox->addControl( new LabelControl("Scale:") );
HSliderControl* slider = hbox->addControl( new HSliderControl(0.0, 5.0, 1.0, new ApplyVerticalScale(scaler)) );
slider->setHorizFill( true, 200 );
hbox->addControl( new LabelControl(slider) );
return hbox;
}
void InspectorHBox::apply()
{
HBox* box = static_cast<HBox*>(inspector->element());
Score* score = box->score();
qreal _spatium = score->spatium();
qreal leftGap = hb.leftGap->value() * _spatium;
qreal rightGap = hb.rightGap->value() * _spatium;
Spatium width(hb.width->value());
if (leftGap != box->topGap() || rightGap != box->bottomGap()
|| width != box->boxWidth()) {
score->startCmd();
score->undo(new ChangeBoxProperties(box,
box->leftMargin(), box->topMargin(), box->rightMargin(), box->bottomMargin(),
box->boxHeight(), width,
leftGap, rightGap
));
score->setLayoutAll(true);
score->endCmd();
mscore->endCmd();
}
}
void ColorSliders::addSlider(Channel channel, const char* labelText, int min, int max)
{
Label* label = new Label(labelText);
Slider* absSlider = new Slider(min, max, 0);
Slider* relSlider = new Slider(min-max, max-min, 0);
Entry* entry = new Entry(4, "0");
m_label.push_back(label);
m_absSlider.push_back(absSlider);
m_relSlider.push_back(relSlider);
m_entry.push_back(entry);
m_channel.push_back(channel);
absSlider->setProperty(SkinSliderPropertyPtr(new SkinSliderProperty(new ColorSliderBgPainter(channel))));
absSlider->setDoubleBuffered(true);
get_skin_property(entry)->setLook(MiniLook);
absSlider->Change.connect(Bind<void>(&ColorSliders::onSliderChange, this, m_absSlider.size()-1));
relSlider->Change.connect(Bind<void>(&ColorSliders::onSliderChange, this, m_relSlider.size()-1));
entry->Change.connect(Bind<void>(&ColorSliders::onEntryChange, this, m_entry.size()-1));
HBox* box = new HBox();
box->addChild(absSlider);
box->addChild(relSlider);
absSlider->setExpansive(true);
relSlider->setExpansive(true);
relSlider->setVisible(false);
gfx::Size sz(INT_MAX, SkinTheme::instance()->dimensions.colorSliderHeight());
label->setMaxSize(sz);
box->setMaxSize(sz);
entry->setMaxSize(sz);
m_grid.addChildInCell(label, 1, 1, LEFT | MIDDLE);
m_grid.addChildInCell(box, 1, 1, HORIZONTAL | VERTICAL | EXPANSIVE);
m_grid.addChildInCell(entry, 1, 1, LEFT | MIDDLE);
}
void StringDialog::Init (const char* msg, const char* confirmLbl, int width) {
int space = Math::round(fspace*ivcm);
_sedit = new StringEditor(state, "");
HBox* framedSedit = new HBox;
if (width == 0) {
framedSedit->Insert(_sedit);
} else {
framedSedit->Insert(new HGlue);
framedSedit->Insert(
new VBox(
new Frame(new MarginFrame(_sedit, 2)),
new HGlue(width, 0, 0)
)
);
framedSedit->Insert(new HGlue);
}
Insert(
new MarginFrame(
new VBox(
new Message(msg),
new VGlue(space),
framedSedit,
new VGlue(space),
new HBox(
new HGlue,
new PushButton(" Cancel ", state, '\007'),
new HGlue(space, 0),
new PushButton(confirmLbl, state, '\r')
)
), space, space, 0
)
);
}
Interactor* MoveDialog::Interior () {
const int space = iv26_round(.5*cm);
VBox* titleblock = new VBox(
new HBox(_title, new HGlue),
new HBox(_subtitle, new HGlue)
);
HBox* rbuttons = new HBox(
new RadioButton("Pixels", _units, 'p'),
new HGlue(space, 0),
new RadioButton("Points", _units, 'o'),
new HGlue(space, 0),
new RadioButton("Centimeters", _units, 'c'),
new HGlue(space, 0),
new RadioButton("Inches", _units, 'i')
);
rbuttons->Insert(new HGlue);
return new MarginFrame(
new VBox(
titleblock,
new VGlue(space),
new Frame(new MarginFrame(_medit, 2)),
new VGlue(space/2, 0),
rbuttons,
new VGlue(space),
new HBox(
new HGlue,
new PushButton("Cancel", state, '\007'),
new HGlue(space, 0),
new PushButton(" OK ", state, '\r')
)
), space, space/2, 0
);
}
bool PlayVideoLayer::init()
{
if (! Layer::init()){
return false;
}
MenuItemFont::setFontSize(16);
_visibleRect = Director::getInstance()->getOpenGLView()->getVisibleRect();
//createVideo();
playResourceVideo();
/* ==============test============== */
LinearLayoutParameter *layoutParams = LinearLayoutParameter::create();
layoutParams->setMargin(Margin(59,40,0,0));
//first layout ��剧ず涓����涓���������� HBox
HBox *layoutHeader = HBox::create();
// layoutHeader->setLoopFocus(true);
layoutHeader->setLayoutParameter(layoutParams);
layoutHeader->setFocused(true);
_widget = layoutHeader;
/* ==============test============== */
//register focus event
_eventListener = EventListenerFocus::create();
_eventListener->onFocusChanged = CC_CALLBACK_2(PlayVideoLayer::onFocusChanged, this);
_eventDispatcher->addEventListenerWithFixedPriority(_eventListener, 1);
//register the keyboard event
_keyboardListener = EventListenerKeyboard::create();
_keyboardListener->onKeyReleased = CC_CALLBACK_2(PlayVideoLayer::onKeyboardReleased, this);
_eventDispatcher->addEventListenerWithFixedPriority(_keyboardListener, 2);
return true;
}
void Chat::setWidgets() {
// Show user button
showUsersBtn_.set_can_focus(false);
showUsersBtn_.signal_clicked().connect(mem_fun(this, &Chat::ShowUsers));
// First level
HButtonBox * firstLvl = new HButtonBox(Gtk::BUTTONBOX_END);
firstLvl->pack_start(showUsersBtn_);
// Result view
resultView_.set_wrap_mode(Gtk::WRAP_WORD);
resultView_.set_editable(false);
ScrolledWindow * messageScroll = new Gtk::ScrolledWindow();
messageScroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
messageScroll->add(resultView_);
// User list
users_.set_column_title(0, "Users");
users_.set_headers_visible(false);
users_.append("Admin");
users_.append("Console");
userScroll_.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
userScroll_.add(users_);
// Second level
HBox * secondLvl = new HBox();
secondLvl->pack_start(*manage(messageScroll));
secondLvl->pack_start(userScroll_, Gtk::PACK_SHRINK);
// Command entry
commandEntry_.signal_activate().connect(mem_fun(this, &Chat::Submit));
commandEntry_.signal_changed().connect(mem_fun(this, &Chat::ShowSubmit));
// Submit button
submitBtn_.set_can_focus(false);
submitBtn_.signal_clicked().connect(mem_fun(this, &Chat::Submit));
// Third level
HBox * thirdLvl = new HBox();
thirdLvl->pack_start(commandEntry_);
thirdLvl->pack_start(submitBtn_, Gtk::PACK_SHRINK);
// Vertical Align
pack_start(*manage(firstLvl), Gtk::PACK_SHRINK);
pack_start(*manage(secondLvl));
pack_start(*manage(thirdLvl), Gtk::PACK_SHRINK);
// Window Settings
set_focus_child(commandEntry_);
show_all();
submitBtn_.hide();
userScroll_.hide();
}
void init(){
int masksize = 10;
int thresh = 2;
float gamma = 0;
if(pa("-config")){
ConfigFile f(*pa("-config"));
masksize = f["config.masksize"];
thresh = f["config.threshold"];
gamma = f["config.gammaslope"];
}
gui << Draw().minSize(16,12).handle("orig").label("original image")
<< Image().minSize(16,12).handle("prev").label("preview image")
<< ( VBox().label("controls")
<< Slider(2,200,masksize).label("mask size").out("masksize").minSize(15,2).handle("a")
<< FSlider(-30,40,thresh).label("threshold").out("threshold").minSize(15,2).handle("b")
<< FSlider(0,15,gamma).label("gamma slope").out("gamma").minSize(15,2).handle("c")
<< Button("next image").handle("next")
<< Button("stopped","running").out("loop").handle("d")
<< Button("no clip","clip to roi").out("clipToROI").handle("e")
<< Button("save params").handle("save")
<< Combo("region mean,tiledNN,tiledLIN").handle("algorithm").label("algorithm")
<< ( HBox()
<< Label("..ms").handle("time").label("apply time").minSize(2,3)
<< Fps(10).handle("fps").minSize(4,3).label("fps")
)
)
<< Show();
grabber.init(pa("-i"));
if(grabber.getType() != "file"){
grabber.useDesired<Size>(pa("-s"));
if(!pa("-color")){
grabber.useDesired(formatGray);
}else{
grabber.useDesired(formatRGB);
}
grabber.useDesired(depth8u);
}
gui.registerCallback(step,"a,b,c,d,e,next,algorithm");
gui["orig"].install(new MouseHandler(mouse));
step();
}
//-----------------------------------------------------------------
IWidget *
MenuOptions::createSubtitlesPanel(const Labels &labels)
{
HBox *chooseBox = new HBox();
chooseBox->addWidget(new WiPicture(
Path::dataReadPath("images/menu/subtitle.png")));
chooseBox->addWidget(new WiSpace(10, 0));
chooseBox->addWidget(new RadioBox("subtitles", "1",
Path::dataReadPath("images/menu/subtitles/yes.png")));
chooseBox->addWidget(new RadioBox("subtitles", "0",
Path::dataReadPath("images/menu/subtitles/no.png")));
chooseBox->setTip(labels.getLabel("menu_subtitles"));
return chooseBox;
}
Control*
SkyControlFactory::create(SkyNode* sky,
osgViewer::View* view) const
{
HBox* skyBox = new HBox();
skyBox->setChildVertAlign( Control::ALIGN_CENTER );
skyBox->setChildSpacing( 10 );
skyBox->setHorizFill( true );
skyBox->addControl( new LabelControl("Time: ", 16) );
HSliderControl* skySlider = skyBox->addControl(new HSliderControl( 0.0f, 24.0f, 18.0f ));
skySlider->setBackColor( Color::Gray );
skySlider->setHeight( 12 );
skySlider->setHorizFill( true, 200 );
skySlider->addEventHandler( new SkySliderHandler(sky) );
return skyBox;
}
void
mainwnd::file_import_dialog( void )
{
FileSelection dialog( "Import..." );
HBox *abox = dialog.get_action_area();
HBox hbox( false, 2 );
m_adjust_load_offset = manage( new Adjustment( 0, -(c_max_sets - 1) , c_max_sets - 1, 1 ));
m_spinbutton_load_offset = manage( new SpinButton( *m_adjust_load_offset ));
m_spinbutton_load_offset->set_editable( false );
m_spinbutton_load_offset->set_wrap( true );
hbox.pack_end(*m_spinbutton_load_offset, false, false );
hbox.pack_end(*(manage( new Label( "Screen Set Offset" ))), false, false, 4);
abox->pack_end(hbox, false, false );
dialog.show_all_children();
int result = dialog.run();
//Handle the response:
switch(result)
{
case(Gtk::RESPONSE_OK):
{
try{
midifile f( dialog.get_filename() );
f.parse( m_mainperf, (int) m_adjust_load_offset->get_value() );
}
catch(...){
Gtk::MessageDialog errdialog(*this,
"Error reading file.", false,
Gtk::MESSAGE_ERROR,
(Gtk::ButtonsType)(Gtk::BUTTONS_OK),
true);
errdialog.run();
}
global_filename = std::string(dialog.get_filename());
set_window_title_filename( global_filename );
m_main_wid->reset();
m_entry_notes->set_text( * m_mainperf->get_screen_set_notepad( m_mainperf->get_screenset() ));
m_adjust_bpm->set_value( m_mainperf->get_bpm() );
break;
}
case(Gtk::RESPONSE_CANCEL):
{
break;
}
default:
{
break;
}
}
}
mainwnd::mainwnd(perform *a_p)
{
/* set the performance */
m_mainperf = a_p;
/* main window */
set_window_title_filename( global_filename );
m_main_wid = manage( new mainwid( m_mainperf ));
m_main_time = manage( new maintime( ));
m_menubar = manage(new MenuBar());
m_menu_file = manage(new Menu());
m_menu_control = manage( new Menu());
m_menu_help = manage( new Menu());
/* fill with items */
m_menu_file->items().push_back(MenuElem("New", mem_fun(*this,&mainwnd::file_new_dialog)));
m_menu_file->items().push_back(SeparatorElem());
m_menu_file->items().push_back(MenuElem("Open...", mem_fun(*this,&mainwnd::file_open_dialog)));
m_menu_file->items().push_back(MenuElem("Import...", mem_fun(*this,&mainwnd::file_import_dialog)));
m_menu_file->items().push_back(SeparatorElem());
m_menu_file->items().push_back(MenuElem("Save", mem_fun(*this,&mainwnd::file_save_dialog)));
m_menu_file->items().push_back(MenuElem("Save As...", mem_fun(*this,&mainwnd::file_saveas_dialog)));
m_menu_file->items().push_back(SeparatorElem());
m_menu_file->items().push_back(MenuElem("Options...", mem_fun(*this,&mainwnd::options_dialog)));
m_menu_file->items().push_back(SeparatorElem());
m_menu_file->items().push_back(MenuElem("Exit", mem_fun(*this,&mainwnd::file_exit_dialog)));
m_menu_help->items().push_back(MenuElem("About", mem_fun(*this,&mainwnd::about_dialog)));
m_menubar->items().push_front(MenuElem("File", *m_menu_file));
m_menubar->items().push_back(MenuElem("Help", *m_menu_help));
HBox *hbox = manage( new HBox( false, 2 ) );
m_button_stop = manage( new Button( ));
m_button_stop->add( *manage( new Image(Gdk::Pixbuf::create_from_xpm_data( stop_xpm ))));
m_button_stop->signal_clicked().connect( mem_fun(*this,&mainwnd::stop_playing));
hbox->pack_start(*m_button_stop, false, false);
m_button_play = manage( new Button() );
m_button_play->add( *manage( new Image(Gdk::Pixbuf::create_from_xpm_data( play2_xpm ))));
m_button_play->signal_clicked().connect( mem_fun( *this, &mainwnd::start_playing));
hbox->pack_start(*m_button_play, false, false);
//m_button_test = manage( new Button("test") );
//m_button_test->signal_clicked().connect( mem_fun( *this, &mainwnd::test));
//hbox->pack_start(*m_button_test, false, false);
m_button_perfedit = manage( new Button( ));
m_button_perfedit->add( *manage( new Image(Gdk::Pixbuf::create_from_xpm_data( perfedit_xpm ))));
m_button_perfedit->signal_clicked().connect( mem_fun( *this, &mainwnd::open_performance_edit ));
hbox->pack_end(*m_button_perfedit, false, false, 4);
m_adjust_bpm = manage( new Adjustment( m_mainperf->get_bpm(), 20, 500, 1 ));
m_spinbutton_bpm = manage( new SpinButton( *m_adjust_bpm ));
m_spinbutton_bpm->set_editable( false );
hbox->pack_start(*(manage( new Label( " bpm " ))), false, false, 4);
hbox->pack_start(*m_spinbutton_bpm, false, false );
m_adjust_ss = manage( new Adjustment( 0, 0, c_max_sets - 1, 1 ));
m_spinbutton_ss = manage( new SpinButton( *m_adjust_ss ));
m_spinbutton_ss->set_editable( false );
m_spinbutton_ss->set_wrap( true );
hbox->pack_end(*m_spinbutton_ss, false, false );
hbox->pack_end(*(manage( new Label( " set " ))), false, false, 4);
m_adjust_bpm->signal_value_changed().connect( mem_fun(*this,&mainwnd::adj_callback_bpm ));
m_adjust_ss->signal_value_changed().connect( mem_fun(*this,&mainwnd::adj_callback_ss ));
m_entry_notes = manage( new Entry());
m_entry_notes->signal_changed().connect( mem_fun(*this,&mainwnd::edit_callback_notepad ));
hbox->pack_start( *m_entry_notes, true, true );
/* 2nd hbox */
HBox *hbox2 = manage( new HBox( false, 0 ) );
hbox2->pack_start( *manage( new Image(Gdk::Pixbuf::create_from_xpm_data( seq24_xpm ))), false, false );
hbox2->pack_end( *m_main_time, false, false );
/* set up a vbox, put the menu in it, and add it */
VBox *vbox = new VBox();
vbox->set_border_width( 10 );
vbox->pack_start(*hbox2, false, false );
vbox->pack_start(*m_main_wid, true, true, 10 );
vbox->pack_start(*hbox, false, false );
VBox *ovbox = new VBox();
ovbox->pack_start(*m_menubar, false, false );
ovbox->pack_start( *vbox );
/* add box */
this->add (*ovbox);
/* show everything */
show_all();
add_events( Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK );
m_entry_notes->set_text( * m_mainperf->get_screen_set_notepad( m_mainperf->get_screenset() ));
m_timeout_connect = Glib::signal_timeout().connect(mem_fun(*this,&mainwnd::timer_callback), 25);
m_quit = false;
m_perf_edit = new perfedit( m_mainperf );
m_options = NULL;
}
void
createControls( ControlCanvas* cs )
{
// a container centered on the screen, containing an image and a text label.
{
VBox* center = new VBox();
center->setFrame( new RoundedFrame() );
center->getFrame()->setBackColor( 1,1,1,0.5 );
center->setPadding( 10 );
center->setHorizAlign( Control::ALIGN_CENTER );
center->setVertAlign( Control::ALIGN_CENTER );
// Add an image:
osg::ref_ptr<osg::Image> image = osgDB::readImageFile("http://demo.pelicanmapping.com/rmweb/readymap_logo.png");
if ( image.valid() )
{
s_imageControl = new ImageControl( image.get() );
s_imageControl->setHorizAlign( Control::ALIGN_CENTER );
s_imageControl->setFixSizeForRotation( true );
//imageCon->addEventHandler( new ImageRotationHandler );
center->addControl( s_imageControl );
center->setHorizAlign( Control::ALIGN_CENTER );
}
// Add a text label:
LabelControl* label = new LabelControl( "osgEarth Controls Toolkit" );
label->setFont( osgEarth::Registry::instance()->getDefaultFont() );
label->setFontSize( 24.0f );
label->setHorizAlign( Control::ALIGN_CENTER );
label->setMargin( 5 );
center->addControl( label );
// Rotation slider
HBox* rotateBox = new HBox();
rotateBox->setChildVertAlign( Control::ALIGN_CENTER );
rotateBox->setHorizFill( true );
rotateBox->setBackColor( Color::Blue );
{
rotateBox->addControl( new LabelControl("Rotate: ") );
HSliderControl* rotateSlider = new HSliderControl( -180.0, 180.0, 0.0 );
rotateSlider->addEventHandler( new RotateImage() );
rotateSlider->setHeight( 8.0f );
rotateSlider->setHorizFill( true );
rotateBox->addControl( rotateSlider );
}
center->addControl( rotateBox );
cs->addControl( center );
}
// a simple vbox with absolute positioning in the upper left with two text labels.
{
VBox* ul = new VBox();
ul->setPosition( 20, 20 );
ul->setPadding( 10 );
{
LabelControl* title = new LabelControl( "Upper left control", 22, osg::Vec4f(1,1,0,1) );
ul->addControl( title );
LabelControl* content = new LabelControl( "Here is some text in the upper left control" );
ul->addControl( content );
HBox* c2 = new HBox();
c2->setChildSpacing( 10 );
{
HSliderControl* slider = new HSliderControl( 0, 100 );
slider->setBackColor( .6,0,0,1 );
slider->setHeight( 25 );
slider->setWidth( 300 );
slider->addEventHandler( new MySliderHandler() );
c2->addControl( slider );
s_sliderLabel = new LabelControl();
s_sliderLabel->setVertAlign( Control::ALIGN_CENTER );
c2->addControl( s_sliderLabel );
}
ul->addControl( c2 );
HBox* c3 = new HBox();
c3->setHorizAlign( Control::ALIGN_CENTER );
c3->setChildSpacing( 10 );
{
HBox* c4 = new HBox();
c4->setChildSpacing( 5 );
{
c4->addControl( new CheckBoxControl( true ) );
c4->addControl( new LabelControl( "Checkbox 1" ) );
}
c3->addControl( c4 );
HBox* c5 = new HBox();
c5->setChildSpacing( 5 );
{
c5->addControl( new CheckBoxControl( false ) );
c5->addControl( new LabelControl( "Checkbox 2" ) );
}
c3->addControl( c5 );
}
ul->addControl( c3 );
}
cs->addControl( ul );
ul->addEventHandler( new MyClickHandler );
}
// a centered hbox container along the bottom on the screen.
{
HBox* bottom = new HBox();
bottom->setFrame( new RoundedFrame() );
bottom->getFrame()->setBackColor(0,0,0,0.5);
bottom->setMargin( 10 );
bottom->setChildSpacing( 145 );
bottom->setVertAlign( Control::ALIGN_BOTTOM );
bottom->setHorizAlign( Control::ALIGN_CENTER );
for( int i=0; i<4; ++i )
{
LabelControl* label = new LabelControl();
std::stringstream buf;
buf << "Label_" << i;
std::string str;
str = buf.str();
label->setText( str );
label->setMargin( 10 );
label->setBackColor( 1,1,1,0.4 );
bottom->addControl( label );
label->setActiveColor(1,.3,.3,1);
label->addEventHandler( new MyClickHandler );
}
cs->addControl( bottom );
}
}
void
createControls( ControlCanvas* cs )
{
// a container centered on the screen, containing an image and a text label.
{
VBox* center = new VBox();
center->setFrame( new RoundedFrame() );
center->getFrame()->setBackColor( 1,1,1,0.5 );
center->setPadding( 10 );
center->setHorizAlign( Control::ALIGN_CENTER );
center->setVertAlign( Control::ALIGN_CENTER );
// Add an image:
osg::Image* image = osgDB::readImageFile( "http://osgearth.org/chrome/site/osgearth.gif" );
if ( image ) {
ImageControl* imageCon = new ImageControl( image );
imageCon->setHorizAlign( Control::ALIGN_CENTER );
imageCon->setFixSizeForRotation( true );
imageCon->addEventHandler( new ImageRotationHandler );
center->addControl( imageCon );
center->setHorizAlign( Control::ALIGN_CENTER );
}
// Add a text label:
LabelControl* label = new LabelControl( "osgEarth Controls Toolkit" );
label->setFont( osgText::readFontFile( "arialbd.ttf" ) );
label->setFontSize( 24.0f );
label->setHorizAlign( Control::ALIGN_CENTER );
label->setMargin( 5 );
center->addControl( label );
// Add another
LabelControl* label2 = new LabelControl( "(Click the osgEarth logo to rotate it)" );
label2->setHorizAlign( Control::ALIGN_CENTER );
center->addControl( label2 );
cs->addControl( center );
}
// a simple vbox with absolute positioning in the upper left with two text labels.
{
VBox* ul = new VBox();
ul->setFrame( new Frame() );
ul->setPosition( 20, 20 );
ul->setPadding( 10 );
{
LabelControl* title = new LabelControl( "Upper left control", 22, osg::Vec4f(1,1,0,1) );
ul->addControl( title );
LabelControl* content = new LabelControl( "Here is some text in the upper left control" );
ul->addControl( content );
HBox* c2 = new HBox();
c2->setSpacing( 10 );
{
HSliderControl* slider = new HSliderControl( 0, 100 );
slider->setBackColor( .6,0,0,1 );
slider->setHeight( 25 );
slider->setWidth( 300 );
slider->addEventHandler( new MySliderHandler() );
c2->addControl( slider );
s_sliderLabel = new LabelControl();
s_sliderLabel->setVertAlign( Control::ALIGN_CENTER );
c2->addControl( s_sliderLabel );
}
ul->addControl( c2 );
HBox* c3 = new HBox();
c3->setHorizAlign( Control::ALIGN_CENTER );
c3->setSpacing( 10 );
{
HBox* c4 = new HBox();
c4->setSpacing( 5 );
{
c4->addControl( new CheckBoxControl( true ) );
c4->addControl( new LabelControl( "Checkbox 1" ) );
}
c3->addControl( c4 );
HBox* c5 = new HBox();
c5->setSpacing( 5 );
{
c5->addControl( new CheckBoxControl( false ) );
c5->addControl( new LabelControl( "Checkbox 2" ) );
}
c3->addControl( c5 );
}
ul->addControl( c3 );
}
cs->addControl( ul );
ul->addEventHandler( new MyClickHandler );
}
// a centered hbox container along the bottom on the screen.
{
HBox* bottom = new HBox();
bottom->setFrame( new RoundedFrame() );
bottom->getFrame()->setBackColor(0,0,0,0.5);
bottom->setMargin( 10 );
bottom->setSpacing( 145 );
bottom->setVertAlign( Control::ALIGN_BOTTOM );
bottom->setHorizAlign( Control::ALIGN_CENTER );
for( int i=0; i<4; ++i )
{
LabelControl* label = new LabelControl();
std::stringstream buf;
buf << "Label_" << i;
label->setText( buf.str() );
label->setMargin( 10 );
label->setBackColor( 1,1,1,0.4 );
bottom->addControl( label );
label->setActiveColor(1,.3,.3,1);
label->addEventHandler( new MyClickHandler );
}
cs->addControl( bottom );
}
}
void
MapNodeHelper::parse(MapNode* mapNode,
osg::ArgumentParser& args,
osgViewer::View* view,
osg::Group* root,
Control* userControl ) const
{
if ( !root )
root = mapNode;
// options to use for the load
osg::ref_ptr<osgDB::Options> dbOptions = Registry::instance()->cloneOrCreateOptions();
// parse out custom example arguments first:
bool useSky = args.read("--sky");
bool useOcean = args.read("--ocean");
bool useMGRS = args.read("--mgrs");
bool useDMS = args.read("--dms");
bool useDD = args.read("--dd");
bool useCoords = args.read("--coords") || useMGRS || useDMS || useDD;
bool useOrtho = args.read("--ortho");
bool useAutoClip = args.read("--autoclip");
bool useShadows = args.read("--shadows");
bool animateSky = args.read("--animate-sky");
bool showActivity = args.read("--activity");
bool useLogDepth = args.read("--logdepth");
bool useLogDepth2 = args.read("--logdepth2");
bool kmlUI = args.read("--kmlui");
if (args.read("--verbose"))
osgEarth::setNotifyLevel(osg::INFO);
if (args.read("--quiet"))
osgEarth::setNotifyLevel(osg::FATAL);
float ambientBrightness = 0.2f;
args.read("--ambientBrightness", ambientBrightness);
std::string kmlFile;
args.read( "--kml", kmlFile );
std::string imageFolder;
args.read( "--images", imageFolder );
std::string imageExtensions;
args.read("--image-extensions", imageExtensions);
// animation path:
std::string animpath;
if ( args.read("--path", animpath) )
{
view->setCameraManipulator( new osgGA::AnimationPathManipulator(animpath) );
}
// Install a new Canvas for our UI controls, or use one that already exists.
ControlCanvas* canvas = ControlCanvas::getOrCreate( view );
Container* mainContainer = canvas->addControl( new VBox() );
mainContainer->setAbsorbEvents( true );
mainContainer->setBackColor( Color(Color::Black, 0.8) );
mainContainer->setHorizAlign( Control::ALIGN_LEFT );
mainContainer->setVertAlign( Control::ALIGN_BOTTOM );
// install the user control:
if ( userControl )
mainContainer->addControl( userControl );
// look for external data in the map node:
const Config& externals = mapNode->externalConfig();
const Config& skyConf = externals.child("sky");
const Config& oceanConf = externals.child("ocean");
const Config& annoConf = externals.child("annotations");
const Config& declutterConf = externals.child("decluttering");
// some terrain effects.
// TODO: Most of these are likely to move into extensions.
const Config& lodBlendingConf = externals.child("lod_blending");
const Config& vertScaleConf = externals.child("vertical_scale");
const Config& contourMapConf = externals.child("contour_map");
// Adding a sky model:
if ( useSky || !skyConf.empty() )
{
SkyOptions options(skyConf);
if ( options.getDriver().empty() )
{
if ( mapNode->getMapSRS()->isGeographic() )
options.setDriver("simple");
else
options.setDriver("gl");
}
SkyNode* sky = SkyNode::create(options, mapNode);
if ( sky )
{
sky->attach( view, 0 );
if ( mapNode->getNumParents() > 0 )
{
osgEarth::insertGroup(sky, mapNode->getParent(0));
}
else
{
sky->addChild( mapNode );
root = sky;
}
Control* c = SkyControlFactory().create(sky, view);
if ( c )
mainContainer->addControl( c );
if (animateSky)
{
sky->setUpdateCallback( new AnimateSkyUpdateCallback() );
}
}
}
// Adding an ocean model:
if ( useOcean || !oceanConf.empty() )
{
OceanNode* ocean = OceanNode::create(OceanOptions(oceanConf), mapNode);
if ( ocean )
{
// if there's a sky, we want to ocean under it
osg::Group* parent = osgEarth::findTopMostNodeOfType<SkyNode>(root);
if ( !parent ) parent = root;
parent->addChild( ocean );
Control* c = OceanControlFactory().create(ocean);
if ( c )
mainContainer->addControl(c);
}
}
// Shadowing.
if ( useShadows )
{
ShadowCaster* caster = new ShadowCaster();
caster->setLight( view->getLight() );
caster->getShadowCastingGroup()->addChild( mapNode->getModelLayerGroup() );
if ( mapNode->getNumParents() > 0 )
{
insertGroup(caster, mapNode->getParent(0));
}
else
{
caster->addChild(mapNode);
root = caster;
}
}
// Loading KML from the command line:
if ( !kmlFile.empty() )
{
KMLOptions kml_options;
kml_options.declutter() = true;
// set up a default icon for point placemarks:
IconSymbol* defaultIcon = new IconSymbol();
defaultIcon->url()->setLiteral(KML_PUSHPIN_URL);
kml_options.defaultIconSymbol() = defaultIcon;
osg::Node* kml = KML::load( URI(kmlFile), mapNode, kml_options );
if ( kml )
{
if (kmlUI)
{
Control* c = AnnotationGraphControlFactory().create(kml, view);
if ( c )
{
c->setVertAlign( Control::ALIGN_TOP );
canvas->addControl( c );
}
}
root->addChild( kml );
}
else
{
OE_NOTICE << "Failed to load " << kmlFile << std::endl;
}
}
// Annotations in the map node externals:
if ( !annoConf.empty() )
{
osg::Group* annotations = 0L;
AnnotationRegistry::instance()->create( mapNode, annoConf, dbOptions.get(), annotations );
if ( annotations )
{
root->addChild( annotations );
}
}
// Configure the de-cluttering engine for labels and annotations:
if ( !declutterConf.empty() )
{
Decluttering::setOptions( DeclutteringOptions(declutterConf) );
}
// Configure the mouse coordinate readout:
if ( useCoords )
{
LabelControl* readout = new LabelControl();
readout->setBackColor( Color(Color::Black, 0.8) );
readout->setHorizAlign( Control::ALIGN_RIGHT );
readout->setVertAlign( Control::ALIGN_BOTTOM );
Formatter* formatter =
useMGRS ? (Formatter*)new MGRSFormatter(MGRSFormatter::PRECISION_1M, 0L, MGRSFormatter::USE_SPACES) :
useDMS ? (Formatter*)new LatLongFormatter(LatLongFormatter::FORMAT_DEGREES_MINUTES_SECONDS) :
useDD ? (Formatter*)new LatLongFormatter(LatLongFormatter::FORMAT_DECIMAL_DEGREES) :
0L;
MouseCoordsTool* mcTool = new MouseCoordsTool( mapNode );
mcTool->addCallback( new MouseCoordsLabelCallback(readout, formatter) );
view->addEventHandler( mcTool );
canvas->addControl( readout );
}
// Configure for an ortho camera:
if ( useOrtho )
{
EarthManipulator* manip = dynamic_cast<EarthManipulator*>(view->getCameraManipulator());
if ( manip )
{
manip->getSettings()->setCameraProjection( EarthManipulator::PROJ_ORTHOGRAPHIC );
}
}
// activity monitor (debugging)
if ( showActivity )
{
VBox* vbox = new VBox();
vbox->setBackColor( Color(Color::Black, 0.8) );
vbox->setHorizAlign( Control::ALIGN_RIGHT );
vbox->setVertAlign( Control::ALIGN_BOTTOM );
view->addEventHandler( new ActivityMonitorTool(vbox) );
canvas->addControl( vbox );
}
// Install an auto clip plane clamper
if ( useAutoClip )
{
mapNode->addCullCallback( new AutoClipPlaneCullCallback(mapNode) );
}
// Install logarithmic depth buffer on main camera
if ( useLogDepth )
{
OE_INFO << LC << "Activating logarithmic depth buffer on main camera" << std::endl;
osgEarth::Util::LogarithmicDepthBuffer logDepth;
logDepth.setUseFragDepth( true );
logDepth.install( view->getCamera() );
}
else if ( useLogDepth2 )
{
OE_INFO << LC << "Activating logarithmic depth buffer (vertex-only) on main camera" << std::endl;
osgEarth::Util::LogarithmicDepthBuffer logDepth;
logDepth.setUseFragDepth( false );
logDepth.install( view->getCamera() );
}
// Scan for images if necessary.
if ( !imageFolder.empty() )
{
std::vector<std::string> extensions;
if ( !imageExtensions.empty() )
StringTokenizer( imageExtensions, extensions, ",;", "", false, true );
if ( extensions.empty() )
extensions.push_back( "tif" );
OE_INFO << LC << "Loading images from " << imageFolder << "..." << std::endl;
ImageLayerVector imageLayers;
DataScanner scanner;
scanner.findImageLayers( imageFolder, extensions, imageLayers );
if ( imageLayers.size() > 0 )
{
mapNode->getMap()->beginUpdate();
for( ImageLayerVector::iterator i = imageLayers.begin(); i != imageLayers.end(); ++i )
{
mapNode->getMap()->addImageLayer( i->get() );
}
mapNode->getMap()->endUpdate();
}
OE_INFO << LC << "...found " << imageLayers.size() << " image layers." << std::endl;
}
// Install elevation morphing
if ( !lodBlendingConf.empty() )
{
mapNode->getTerrainEngine()->addEffect( new LODBlending(lodBlendingConf) );
}
// Install vertical scaler
if ( !vertScaleConf.empty() )
{
mapNode->getTerrainEngine()->addEffect( new VerticalScale(vertScaleConf) );
}
// Install a contour map effect.
if ( !contourMapConf.empty() )
{
mapNode->getTerrainEngine()->addEffect( new ContourMap(contourMapConf) );
}
// Generic named value uniform with min/max.
VBox* uniformBox = 0L;
while( args.find( "--uniform" ) >= 0 )
{
std::string name;
float minval, maxval;
if ( args.read( "--uniform", name, minval, maxval ) )
{
if ( uniformBox == 0L )
{
uniformBox = new VBox();
uniformBox->setBackColor(0,0,0,0.5);
uniformBox->setAbsorbEvents( true );
canvas->addControl( uniformBox );
}
osg::Uniform* uniform = new osg::Uniform(osg::Uniform::FLOAT, name);
uniform->set( minval );
root->getOrCreateStateSet()->addUniform( uniform, osg::StateAttribute::OVERRIDE );
HBox* box = new HBox();
box->addControl( new LabelControl(name) );
HSliderControl* hs = box->addControl( new HSliderControl(minval, maxval, minval, new ApplyValueUniform(uniform)));
hs->setHorizFill(true, 200);
box->addControl( new LabelControl(hs) );
uniformBox->addControl( box );
OE_INFO << LC << "Installed uniform controller for " << name << std::endl;
}
}
// Process extensions.
for(std::vector<osg::ref_ptr<Extension> >::const_iterator eiter = mapNode->getExtensions().begin();
eiter != mapNode->getExtensions().end();
++eiter)
{
Extension* e = eiter->get();
// Check for a View interface:
ExtensionInterface<osg::View>* viewIF = ExtensionInterface<osg::View>::get( e );
if ( viewIF )
viewIF->connect( view );
// Check for a Control interface:
ExtensionInterface<Control>* controlIF = ExtensionInterface<Control>::get( e );
if ( controlIF )
controlIF->connect( mainContainer );
}
root->addChild( canvas );
}
tempopopup::tempopopup(tempo *a_tempo) :
m_tempo(a_tempo),
m_escape(false),
m_return(false),
m_is_typing(false),
m_current_beats(0),
m_base_time_ms(0),
m_last_time_ms(0)
{
// std::string title = "BPM";
// set_title(title);
set_size_request(150, 50);
#if GTK_MINOR_VERSION < 12
m_tooltips = manage( new Tooltips() );
#endif
/* bpm spin button */
m_adjust_bpm = manage(new Adjustment(m_tempo->m_mainperf->get_bpm(), c_bpm_minimum -1, c_bpm_maximum, 1));
m_spinbutton_bpm = manage( new SpinButton( *m_adjust_bpm ));
m_spinbutton_bpm->set_editable( true );
m_spinbutton_bpm->set_digits(2); // 2 = two decimal precision
m_adjust_bpm->signal_value_changed().connect(
mem_fun(*this, &tempopopup::adj_callback_bpm ));
m_spinbutton_bpm->set_numeric();
add_tooltip
(
m_spinbutton_bpm,
"Adjust beats per minute (BPM) value.\n"
"Values range from 0 to 600.00.\n"
"Escape to leave without setting\n"
"Entry of 0 indicates a STOP marker.\n"
);
m_spinbutton_bpm->set_update_policy(Gtk::UPDATE_IF_VALID); // ignore bad entries
Label* bpmlabel = manage(new Label("BPM"));
/* bpm tap tempo button - sequencer64 */
m_button_tap = manage(new Button("0"));
m_button_tap->signal_clicked().connect(sigc::mem_fun(*this, &tempopopup::tap));
add_tooltip
(
m_button_tap,
"Tap in time to set the beats per minute (BPM) value. "
"After 5 seconds of no taps, the tap-counter will reset to 0. "
"Also see the File / Options / Keyboard / Tap BPM key assignment."
);
m_button_tap->set_can_focus(false); // to force all keys to the spin button
HBox *hbox = manage(new HBox());
hbox->set_border_width(6);
hbox->pack_start(*bpmlabel, Gtk::PACK_SHRINK);
hbox->pack_start(*m_spinbutton_bpm, Gtk::PACK_SHRINK );
hbox->pack_start(*m_button_tap, Gtk::PACK_SHRINK, 5 );
add(*hbox);
set_modal(); // keep focus until done
set_transient_for(*m_tempo->m_perfedit); // always on top
set_decorated(false); // don't show title bar
add_events( Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK );
m_timeout_connect = Glib::signal_timeout().connect(
mem_fun(*this, &tempopopup::timer_callback), 25);
}
