void WidgetButton::setDisableHighlight(bool disableHighlight) {
_disableHighlight = disableHighlight;
if (_disableHighlight) {
setHighlight(false);
} else if (_hovered) {
setHighlight(true);
}
}
bool MacWindow::processEvent(Common::Event &event) {
WindowClick click = isInBorder(event.mouse.x, event.mouse.y);
switch (event.type) {
case Common::EVENT_MOUSEMOVE:
if (_beingDragged) {
_dims.translate(event.mouse.x - _draggedX, event.mouse.y - _draggedY);
updateInnerDims();
_draggedX = event.mouse.x;
_draggedY = event.mouse.y;
_wm->setFullRefresh(true);
}
if (_beingResized) {
resize(MAX(kBorderWidth * 4, _dims.width() + event.mouse.x - _draggedX),
MAX(kBorderWidth * 4, _dims.height() + event.mouse.y - _draggedY));
_draggedX = event.mouse.x;
_draggedY = event.mouse.y;
_wm->setFullRefresh(true);
(*_callback)(click, event, _dataPtr);
}
break;
case Common::EVENT_LBUTTONDOWN:
setHighlight(click);
if (click == kBorderBorder) {
_beingDragged = true;
_draggedX = event.mouse.x;
_draggedY = event.mouse.y;
}
if (click == kBorderResizeButton) {
_beingResized = true;
_draggedX = event.mouse.x;
_draggedY = event.mouse.y;
}
break;
case Common::EVENT_LBUTTONUP:
_beingDragged = false;
_beingResized = false;
setHighlight(kBorderNone);
break;
default:
return false;
}
return (*_callback)(click, event, _dataPtr);
}
void RobotStateDisplay::setRobotHighlights(const moveit_msgs::DisplayRobotState::_highlight_links_type& highlight_links)
{
if (highlight_links.empty() && highlights_.empty())
return;
std::map<std::string, std_msgs::ColorRGBA> highlights;
for (moveit_msgs::DisplayRobotState::_highlight_links_type::const_iterator it = highlight_links.begin() ;
it != highlight_links.end() ;
++it)
{
highlights[it->id] = it->color;
}
if (enable_link_highlight_->getBool())
{
std::map<std::string, std_msgs::ColorRGBA>::iterator ho = highlights_.begin();
std::map<std::string, std_msgs::ColorRGBA>::iterator hn = highlights.begin();
while (ho != highlights_.end() || hn != highlights.end())
{
if (ho == highlights_.end())
{
setHighlight(hn->first, hn->second);
++hn;
}
else if (hn == highlights.end())
{
unsetHighlight(ho->first);
++ho;
}
else if (hn->first < ho->first)
{
setHighlight(hn->first, hn->second);
++hn;
}
else if (hn->first > ho->first)
{
unsetHighlight(ho->first);
++ho;
}
else if (hn->second != ho->second)
{
setHighlight(hn->first, hn->second);
++ho;
++hn;
}
else
{
++ho;
++hn;
}
}
}
swap(highlights, highlights_);
}
void HighlightDialog::highlightSetSelected(int index)
{
if (index < 0)
{
ui->name->setEnabled(false);
ui->remove->setEnabled(false);
ui->highlights->setEnabled(false);
return;
}
ui->name->setEnabled(true);
ui->remove->setEnabled(true);
ui->highlights->setEnabled(true);
ui->name->setText(m_highlightSets[index].m_name);
for (auto it = std::begin(m_highlightWidgets); it != std::end(m_highlightWidgets); ++it)
{
delete *it;
}
m_highlightWidgets.clear();
for (auto it = std::begin(m_highlightSets[index].m_highlights); it != std::end(m_highlightSets[index].m_highlights); ++it)
{
auto highlight = new FilterHighlight(ui->highlightsAreaContents);
highlight->setHighlight(*it);
connect(highlight, &FilterHighlight::changed, this, &HighlightDialog::highlightChanged);
connect(highlight, &FilterHighlight::removed, this, &HighlightDialog::highlightRemoved);
m_highlightWidgets.push_back(highlight);
static_cast<QBoxLayout*>(ui->highlightsAreaContents->layout())->insertWidget(ui->highlightsAreaContents->layout()->count() - 1, highlight);
}
}
void ChatRooms::selected(QWidget* chatwidget) {
if (currentIndex() == 0)
return;
ChatRoom * uw = dynamic_cast<ChatRoom*>(chatwidget);
if(uw && uw->highlighted() != 0) {
uw->setHighlighted(0);
setHighlight(uw->highlighted(), uw );
}
else if (!uw) {
PublicChat * pc = dynamic_cast<PublicChat*>(chatwidget);
if(pc && pc->highlighted() != 0) {
pc->setHighlighted(0);
setHighlight(pc->highlighted(), pc );
}
}
}
bool GUIInventory::onEvent(M4EventType eventType, int param, int x, int y, GUIObject *¤tItem) {
bool result = false;
int overIndex = getInsideIndex(x, y);
bool isPressed = (eventType == MEVENT_LEFT_CLICK) || (eventType == MEVENT_LEFT_HOLD) ||
(eventType == MEVENT_LEFT_DRAG);
ItemsIterator curItem = _inventoryItems.begin();
if (isPressed) {
if (_selectedIndex == -1 && overIndex != -1) {
setHighlight(overIndex);
_selectedIndex = overIndex;
for (int i = 0; i < _scrollPosition + _selectedIndex; i++)
++curItem;
if (_scrollPosition + _selectedIndex < (int)_inventoryItems.size())
_vm->_mouse->setCursorNum(curItem->get()->iconIndex);
result = true;
} else {
// We are over something being tracked
if (_selectedIndex == overIndex) {
setHighlight(overIndex);
result = true;
} else {
// Otherwise reset highlighting
setHighlight(-1);
result = false;
}
}
} else {
// No button pressed
if (_selectedIndex == overIndex) {
result = (_selectedIndex != -1);
} else {
result = (overIndex + _scrollPosition < (int)_inventoryItems.size());
if (result) {
for (int i = 0; i < overIndex + _scrollPosition; i++)
++curItem;
_vm->_interfaceView->setStatusText(curItem->get()->name);
}
}
// Stop tracking anything
setHighlight(overIndex);
}
return result;
}
void DialogBox::mouseMove(int x, int y) {
float screenX, screenY;
CursorMan.toScreenCoordinates(x, y, screenX, screenY);
if (!isIn(screenX, screenY)) {
setHighlight(_replyLines.end());
return;
}
std::list<ReplyLine>::iterator highlight;
for (highlight = _replyLines.begin(); highlight != _replyLines.end(); ++highlight)
if ((highlight->count && highlight->count->isIn(screenX, screenY)) ||
(highlight->line && highlight->line->isIn (screenX, screenY)))
break;
setHighlight(highlight);
}
void SearchTabWidget::selected(QWidget* searchwidget) {
if (currentIndex() <= 1)
return;
Search * uw = dynamic_cast<Search*>(searchwidget);
if(uw && uw->highlighted() != 0) {
uw->setHighlighted(0);
setHighlight(uw->highlighted(), uw );
}
}
void InteractiveMarkerControl::enableInteraction( bool enable )
{
interaction_enabled_ = enable;
setVisible(visible_);
if (!enable)
{
setHighlight(0.0);
}
}
void WidgetButton::enter() {
if (!_disableHoverSound)
_sound = playSound("gui_actscroll", Sound::kSoundTypeSFX);
if (!_permanentHighlight && !_disableHighlight)
setHighlight(true);
// The button is being hovered over
_hovered = true;
}
void WidgetButton::leave() {
if (!_disableHoverSound)
SoundMan.stopChannel(_sound);
if (!_permanentHighlight && !_disableHighlight)
setHighlight(false);
// The button is not being hovered over anymore
_hovered = false;
}
void TransformNode::draw(bool displayHelpers) const
{
gPush(matrix);
glPushName(identifier);
bool highlight = getHighlight();
if (selected) {
setHighlight(selected);
}
if (shapeNode != NULL) {
shapeNode->draw();
}
for (list<TransformNode*> :: const_iterator iter = children.begin();
iter != children.end();
++iter)
(*iter)->draw(displayHelpers);
setHighlight(highlight);
glPopName();
gPop();
}
void HighlightDialog::addHighlight()
{
auto index = ui->highlightSets->currentIndex();
if (index < 0)
{
return;
}
auto highlight = new FilterHighlight(ui->highlightsAreaContents);
highlight->setHighlight(HighlightSet::Highlight());
connect(highlight, &FilterHighlight::changed, this, &HighlightDialog::highlightChanged);
connect(highlight, &FilterHighlight::removed, this, &HighlightDialog::highlightRemoved);
m_highlightSets[index].m_highlights.push_back(HighlightSet::Highlight());
m_highlightWidgets.push_back(highlight);
static_cast<QBoxLayout*>(ui->highlightsAreaContents->layout())->insertWidget(ui->highlightsAreaContents->layout()->count() - 1, highlight);
}
void DialogBox::clearReplies() {
hideReplies();
setHighlight(_replyLines.end());
_pickedReply = _replies.end();
for (std::list<ReplyLine>::iterator r = _replyLines.begin(); r != _replyLines.end(); ++r) {
delete r->count;
delete r->line;
}
_replyLines.clear();
_replies.clear();
_replyCount = 0;
_replyCountWidth = 0.0f;
}
// Set the box.
void BoxGraphNode::setBox(Box *b)
{
assert(b == 0 || b->OK());
setHighlight(0);
Box *old = _box;
if (b)
_box = b->link();
else
_box = 0;
if (old)
old->unlink();
if (b)
resize(b->size());
}
void setFakeHighlightEX(int subAmount)
{
int tBegin = beginHighlight - subAmount;
int tEnd = endHighlight - subAmount;
if(subAmount != 0)
{
if(tBegin < 0)
{
tBegin = 0;
}
if(tEnd < 0)
{
tEnd = 0;
}
}
setHighlightColor(genericHighlightColor);
setHighlight(tBegin, tEnd);
}
void RobotStateDisplay::changedEnableLinkHighlight()
{
if (enable_link_highlight_->getBool())
{
for (std::map<std::string, std_msgs::ColorRGBA>::iterator it = highlights_.begin() ;
it != highlights_.end() ;
++it)
{
setHighlight(it->first, it->second);
}
}
else
{
for (std::map<std::string, std_msgs::ColorRGBA>::iterator it = highlights_.begin() ;
it != highlights_.end() ;
++it)
{
unsetHighlight(it->first);
}
}
}
Button::Button(float rel_x, float rel_y, float rel_width, float rel_height, std::string title, int outcome, DisplayPiece * parent)
: DisplayPiece(rel_x, rel_y, rel_width, rel_height, parent)
{
std::cout << "INFO: Button::Button:1 In first Constructor" << std::endl;
/*mTexture = parent->mTexture;
mRenderer = nullptr;
mWindow = nullptr;
mTitle = nullptr;*/
//FunctionCaller funcCaller = nullptr;
mFunctionCaller = nullptr;
ArgContainer args = ArgContainer();
//setFunctionCaller(funcCaller);
setArgContainer(args);
setParent(parent);
mTexture = loadTexture("res/images/menu/button_0_0.png", mRenderer, true);
//mRenderer = renderer;
//mWindow = window;
//mRect = new SDL_Rect();
/* setRelPosX(rel_x);
setRelPosY(rel_y);
setRelWidth(rel_w);
setRelHeight(rel_h);*/
setHighlight(false);
setTitleString(title);
//mTextMaker = TextHandler;
makeTitleTextLine();
setOutcome(outcome);
std::cout << "INFO: Button::Button:1 End of first constructor" << std::endl;
}
void WidgetButton::setPermanentHighlight(bool permanentHighlight) {
_permanentHighlight = permanentHighlight;
setHighlight(_permanentHighlight);
}
int main(int argc, char *argv[])
{
/*****
* boolean value indicates when to break main loop
* (and thus finish this configuration tool)
*****/
int request_finish = 0;
int current = 0; /***** menu selection related variables */
int menu_items = 5;
enum state status[] = {active, active, active, active, active};
WINDOW *mainscr; /***** ncurses related variables */
int i, j;
/***** load configuration */
if (loadConfiguration() == 0)
{
fprintf(stderr, "couldn't load configuration!");
exit(-1);
}
/***** setup speaker model */
model = (Model *) malloc(sizeof(Model));
initModel(model);
/***** ignore Ctrl-C */
signal(SIGINT, SIG_IGN);
/***** ncurses stuff */
initscr(); /***** initialize the curses library */
if (color_term != -1) /***** define dialog color pairs if terminal supports colors */
{
start_color ();
if ((color_term = has_colors ()))
{
color_term = 1;
init_pair (1, COLOR_WHITE, COLOR_BLUE);
init_pair (2, COLOR_YELLOW, COLOR_BLUE);
init_pair (3, COLOR_BLUE, COLOR_YELLOW);
init_pair (4, COLOR_YELLOW, COLOR_CYAN);
}
}
else
color_term = 0;
keypad(stdscr, TRUE); /* enable keyboard mapping */
scrollok (stdscr, FALSE);
cbreak(); /* take input chars one at a time, no wait for \n */
noecho(); /* don't echo input */
refresh();
mainscr = popupWindow(COLS, LINES); /***** dialog window that contains the main menu */
leaveok (mainscr, FALSE);
while (!request_finish)
{
wattrset (mainscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */
/*****
* draw a box around the dialog window
* and empty it.
*****/
box(mainscr, 0, 0);
for (i = 1; i < COLS-1; i++)
for (j = 1; j < LINES-1; j++)
mvwaddch(mainscr, j, i, ' ');
/***** dialog header */
mvwaddstr(mainscr, 1, 2, "CVoiceControl");
mvwaddstrrght(mainscr, 1, COLS, "(c) 2000 Daniel Kiecza");
mvwaddseparator(mainscr, 2, COLS);
mvwaddstrcntr(mainscr, 3, COLS, "Speaker Model Editor");
mvwaddseparator(mainscr, 4, COLS);
/***** display main menu */
mvwaddstr(mainscr, 5, 2, "Please Select:");
mvwaddstr(mainscr, 5, 35, "Model:");
if (model_file_name != NULL)
mvwaddstr(mainscr, 5, 42, model_file_name);
else
mvwaddstr(mainscr, 5, 42, "(none)");
setHighlight(mainscr, status[0], current == 0);
mvwaddstr(mainscr, 7, 5,"New Speaker Model");
setHighlight(mainscr, status[1], current == 1);
mvwaddstr(mainscr, 8, 5,"Load Speaker Model");
setHighlight(mainscr, status[2], current == 2);
mvwaddstr(mainscr, 9, 5,"Edit Speaker Model");
setHighlight(mainscr, status[3], current == 3);
mvwaddstr(mainscr, 10, 5,"Save Speaker Model");
setHighlight(mainscr, status[4], current == 4);
mvwaddstr(mainscr, 11, 5,"Exit");
wmove(mainscr, 5, 17); /***** move cursor to an appropriate location */
wrefresh(mainscr); /***** refresh dialog window */
/* process the command keystroke */
switch(getch())
{
case KEY_UP: /***** cursor up */
current = (current == 0 ? menu_items - 1 : current - 1);
break;
case KEY_DOWN: /***** cursor down */
current = (current == menu_items-1 ? 0 : current + 1);
break;
case ENTER: /***** handle menu selections */
case BLANK:
switch (current)
{
case 0: /***** reset model, but make sure no data gets lost */
safeResetModel();
break;
case 1: /***** load model */
if (safeResetModel())
{
int max_file_length = 80;
char *file_name;
char show_file_name[82];
int width = 45, height = 11, i, j; /***** ncurses related variables */
WINDOW *loadscr = popupWindow (width, height);
wattrset (loadscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */
/*****
* draw a box around the dialog window
* and empty it.
*****/
werase (loadscr);
box (loadscr, 0, 0);
for (i = 1; i < width-1; i++)
for (j = 1; j < height-1; j++)
mvwaddch(loadscr, j, i, ' ');
/***** dialog header */
mvwaddstr(loadscr, 1, 2, "Please enter file name:");
mvwaddseparator(loadscr, 2, width);
wrefresh (loadscr);
wattroff(loadscr, A_BOLD);
file_name = wstringInput(loadscr, 4, 2, max_file_length, width-5, ""); /***** get file name */
/*****
* show_file_name is set to "file" if the file_name is longer
* than 15 characters. That way dialog messages stay within the
* boundaries of the dialog
*****/
if (strlen(file_name) <= 15)
strcpy(show_file_name, file_name);
else
strcpy(show_file_name, "file");
/***** display information that model is being loaded */
wattrset (loadscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL);
mvwaddstr(loadscr, 6, 2, "Loading");
mvwaddstr(loadscr, 6, 10, show_file_name);
mvwaddstr(loadscr, 6, 11+strlen(show_file_name), "...");
wrefresh(loadscr);
if (loadModel(model, file_name, 1) == 1) /***** loading model is successful */
{
mvwaddstr(loadscr, 6, 15+strlen(show_file_name), "success!");
/***** set variable model_file_name */
if (strstr(file_name, model_file_extension) !=
file_name+strlen(file_name)-strlen(model_file_extension))
{
model_file_name = malloc(strlen(file_name) + strlen(model_file_extension) + 1);
strcpy(model_file_name, file_name);
strcat(model_file_name, model_file_extension);
}
else
{
model_file_name = malloc(strlen(file_name) + 1);
strcpy(model_file_name, file_name);
}
}
else /***** loading model has failed */
mvwaddstr(loadscr, 6, 15+strlen(show_file_name), "failed!");
mvwaddstrcntr(loadscr, 8, width,"Press <Space> to return to menu ...");
wrefresh(loadscr); /***** refresh dialog */
getch(); /***** wait for keyboard input */
delwin(loadscr); /***** delete ncurses dialog window */
free (file_name);
}
break;
case 2: /***** edit the speaker model */
editModel();
break;
case 3: /***** save the speaker model */
if (model->number_of_items > 0)
{
char *file_name;
int max_file_length = 84;
int width = 45, height = 11, i, j; /***** ncurses related variables */
WINDOW *savescr = popupWindow (width, height);
wattrset (savescr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */
/*****
* draw a box around the dialog window
* and empty it.
*****/
werase (savescr);
box (savescr, 0, 0);
for (i = 1; i < width-1; i++)
for (j = 1; j < height-1; j++)
mvwaddch(savescr, j, i, ' ');
/***** display dialog header */
mvwaddstr(savescr, 1, 2, "Please enter file name:");
mvwaddseparator(savescr, 2, width);
wrefresh (savescr);
wattroff(savescr, A_BOLD);
file_name = wstringInput(savescr, 4, 2, max_file_length,
width-5, model_file_name); /***** get file name */
/***** display information that model is being saved */
wattrset (savescr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL);
mvwaddstr(savescr, 6, 2, "Saving ...");
wrefresh(savescr);
if (saveModel(model, file_name) == 1) /***** saving successful */
{
mvwaddstr(savescr, 6, 13, "success!");
/***** update model_file_name if necessary */
if (model_file_name != NULL && strcmp(model_file_name, file_name) != 0)
{
free(model_file_name);
model_file_name = malloc(strlen(file_name) + 1);
strcpy(model_file_name, file_name);
}
modified = 0; /***** switch modified to '0' */
}
else /***** saving failed */
mvwaddstr(savescr, 6, 13, "failed!");
mvwaddstrcntr(savescr, 8, width,"Press <Space> to return to menu ...");
wrefresh(savescr); /***** refresh dialog */
getch(); /***** wait for keyboard input */
delwin(savescr); /***** delete ncurses dialog window */
free (file_name);
}
break;
case 4: /***** quit program */
if (safeResetModel())
{
wrefresh(mainscr);
request_finish = 1;
delwin(mainscr); /***** delete ncurses dialog window */
}
break;
}
break;
}
}
endwin(); /***** wrap up ncurses stuff */
exit(0); /***** exit program */
}
void InteractiveMarkerControl::handleMouseEvent( ViewportMouseEvent& event )
{
// * check if this is just a receive/lost focus event
// * try to hand over the mouse event to the parent interactive marker
// * otherwise, execute mouse move handling
// handle receive/lose focus
if( event.type == QEvent::FocusIn )
{
has_focus_ = true;
std::set<Ogre::Pass*>::iterator it;
setHighlight( HOVER_HIGHLIGHT );
event.panel->setCursor( cursor_ );
}
else if( event.type == QEvent::FocusOut )
{
has_focus_ = false;
setHighlight(0.0);
return;
}
// change dragging state
switch( interaction_mode_ )
{
case visualization_msgs::InteractiveMarkerControl::BUTTON:
if( event.leftUp() )
{
Ogre::Vector3 point_rel_world;
bool got_3D_point = context_->getSelectionManager()->get3DPoint( event.viewport, event.x, event.y, point_rel_world );
visualization_msgs::InteractiveMarkerFeedback feedback;
feedback.event_type = visualization_msgs::InteractiveMarkerFeedback::BUTTON_CLICK;
feedback.control_name = name_;
feedback.marker_name = parent_->getName();
parent_->publishFeedback( feedback, got_3D_point, point_rel_world );
}
break;
case visualization_msgs::InteractiveMarkerControl::MOVE_AXIS:
case visualization_msgs::InteractiveMarkerControl::MOVE_PLANE:
case visualization_msgs::InteractiveMarkerControl::MOVE_ROTATE:
case visualization_msgs::InteractiveMarkerControl::ROTATE_AXIS:
if( event.leftDown() )
{
parent_->startDragging();
dragging_ = true;
drag_viewport_ = event.viewport;
recordDraggingInPlaceEvent( event );
if( ! context_->getSelectionManager()->get3DPoint( event.viewport, event.x, event.y, grab_point_ ))
{
// If we couldn't get a 3D point for the grab, just use the
// current relative position of the control frame.
grab_point_ = control_frame_node_->getPosition();
}
else
{
// If we could get a 3D point for the grab, convert it from
// the world frame to the reference frame (in case those are different).
grab_point_ = reference_node_->convertWorldToLocalPosition(grab_point_);
}
grab_pixel_.x = event.x;
grab_pixel_.y = event.y;
parent_position_at_mouse_down_ = parent_->getPosition();
parent_orientation_at_mouse_down_ = parent_->getOrientation();
if( orientation_mode_ == visualization_msgs::InteractiveMarkerControl::VIEW_FACING &&
drag_viewport_ )
{
updateControlOrientationForViewFacing( drag_viewport_ );
}
control_frame_orientation_at_mouse_down_ = control_frame_node_->getOrientation();
rotation_at_mouse_down_ = rotation_;
rotation_axis_ = control_frame_node_->getOrientation() * control_orientation_.xAxis();
// Find rotation_center = 3D point closest to grab_point_ which is
// on the rotation axis, relative to the reference frame.
Ogre::Vector3 rotation_center_rel_ref = closestPointOnLineToPoint( parent_->getPosition(),
rotation_axis_,
grab_point_ );
Ogre::Matrix4 reference_rel_control_frame;
reference_rel_control_frame.makeInverseTransform( control_frame_node_->getPosition(),
Ogre::Vector3::UNIT_SCALE,
control_frame_node_->getOrientation() );
rotation_center_rel_control_ = reference_rel_control_frame * rotation_center_rel_ref;
grab_point_rel_control_ = reference_rel_control_frame * grab_point_;
}
if( event.leftUp() )
{
dragging_ = false;
drag_viewport_ = NULL;
parent_->stopDragging();
}
break;
default:
break;
}
if( event.leftDown() )
{
setHighlight( ACTIVE_HIGHLIGHT );
}
else if( event.leftUp() )
{
setHighlight( HOVER_HIGHLIGHT );
}
if (!parent_->handleMouseEvent(event, name_))
{
if( event.type == QEvent::MouseMove && event.left() )
{
recordDraggingInPlaceEvent( event );
handleMouseMovement( event );
}
}
}
int main(int argc, char *argv[])
{
/*****
* boolean value indicates when to break main loop
* (and thus finish this configuration tool)
*****/
int request_finish = 0;
int current = 0; /***** menu related variables */
int menu_items = 7;
enum state status[] = {invalid, invalid, inactive, inactive, inactive, inactive, invalid};
WINDOW *mainscr; /***** ncurses related variables */
int i, j;
/* ***** detect available mixer devices */
mixer_devices = scanMixerDevices();
if (mixer_devices == NULL || mixer_devices->count == 0)
{
/* ***** no mixer devices available -> exit! */
fprintf(stderr, "No mixer devices available!\n");
fprintf(stderr, "Please purchase a sound card and install it!\n");
exit(-1);
}
else
{
if (mixer_devices->count == 1) /***** exactly one mixer device available */
{
setMixer(mixer_devices->name[0]); /***** set this mixer */
if (initMixer() == MIXER_OK) /***** if mixer is ok, keep it */
{
status[0] = ok;
status[2] = invalid;
}
else /***** otherwise, exit!*/
{
fprintf(stderr, "Couldn't init the only available mixer device: /dev/%s\n",
mixer_devices->name[0]);
exit(-1);
}
}
else /* ***** more than one device available! */
{
/* ***** use /dev/mixer as default if it exists */
for (i = 0; i < mixer_devices->count; i++)
{
if (strcmp(mixer_devices->name[i], "mixer") == 0)
{
setMixer("mixer");
if (initMixer() == MIXER_OK)
{
status[0] = ok;
status[2] = invalid;
}
else
noMixer();
break;
}
}
}
}
/* ***** detect available audio devices */
audio_devices = scanAudioDevices();
if (audio_devices == NULL || audio_devices->count == 0)
{
/* ***** no audio devices available! */
fprintf(stderr, "No audio device available that\n");
fprintf(stderr, "supports 16bit recording!\n");
fprintf(stderr, "Please purchase a sound card and install it!\n");
exit(-1);
}
else
{
if (audio_devices->count == 1) /***** exactly one audio device available */
{
setAudio(audio_devices->name[0]); /***** set this audio device */
if (initAudio() == AUDIO_OK) /***** if audio device is ok, keep it */
{
status[1] = ok;
}
else /***** otherwise, exit!*/
{
fprintf(stderr, "Couldn't init the only available audio device: /dev/%s\n",
audio_devices->name[0]);
exit(-1);
}
}
else /* ***** more than one device available! */
{
/* ***** use /dev/dspW as default if it exists */
for (i = 0; i < audio_devices->count; i++)
{
if (strcmp(audio_devices->name[i], "dspW") == 0)
{
setAudio("dspW");
if (initAudio() == AUDIO_OK)
status[1] = ok;
else
noAudio();
break;
}
}
}
}
/*****
* if mixer and audio device have been selected successfully,
* set menu cursor to next available menu item
*****/
if (status[0] == ok && status[1] == ok)
current = 2;
/***** ignore Ctrl-C */
signal(SIGINT, SIG_IGN);
/* ***** ncurses stuff */
initscr(); /* initialize the curses library */
if (color_term != -1) /***** define dialog color pairs if terminal supports colors */
{
start_color ();
if ((color_term = has_colors ()))
{
color_term = 1;
init_pair (1, COLOR_WHITE, COLOR_BLUE);
init_pair (2, COLOR_YELLOW, COLOR_BLUE);
init_pair (3, COLOR_BLUE, COLOR_YELLOW);
init_pair (4, COLOR_YELLOW, COLOR_CYAN);
}
}
else
color_term = 0;
keypad(stdscr, TRUE); /* enable keyboard mapping */
scrollok (stdscr, FALSE);
cbreak(); /* take input chars one at a time, no wait for \n */
noecho(); /* don't echo input */
refresh();
mainscr = popupWindow(COLS, LINES); /***** dialog window that contains the main menu */
leaveok (mainscr, FALSE);
while (!request_finish)
{
wattrset (mainscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */
/*****
* draw a box around the dialog window
* and empty it.
*****/
box(mainscr, 0, 0);
for (i = 1; i < COLS-1; i++)
for (j = 1; j < LINES-1; j++)
mvwaddch(mainscr, j, i, ' ');
/***** dialog header */
mvwaddstr(mainscr, 1, 2, "CVoiceControl");
mvwaddstr(mainscr, 1, COLS - strlen("(c) 2000 Daniel Kiecza") - 2, "(c) 2000 Daniel Kiecza");
mvwaddseparator(mainscr, 2, COLS);
mvwaddstr(mainscr, 3, (COLS / 2) - (strlen ("Recording Device Configuration Tool") / 2),
"Recording Device Configuration Tool");
mvwaddseparator(mainscr, 4, COLS);
/***** main menu */
mvwaddstr(mainscr, 5, 2, "Please Select:");
setHighlight(mainscr, status[0], current == 0);
mvwaddstr(mainscr, 7,5,"Select Mixer Device");
if (mixerOK() == MIXER_OK)
{
mvwaddstr(mainscr, 7,24," ("); waddstr(mainscr, getMixer()); waddstr(mainscr, ")");
}
else
mvwaddstr(mainscr, 7,24," (none selected!)");
setHighlight(mainscr, status[1], current == 1);
mvwaddstr(mainscr, 8,5,"Select Audio Device");
if (audioOK() == AUDIO_OK)
{
mvwaddstr(mainscr, 8,24," ("); waddstr(mainscr, getAudio()); waddstr(mainscr, ")");
}
else
mvwaddstr(mainscr, 8,24," (none selected!)");
setHighlight(mainscr, status[2], current == 2);
mvwaddstr(mainscr, 9,5,"Adjust Mixer Levels");
setHighlight(mainscr, status[3], current == 3);
mvwaddstr(mainscr, 10,5,"Calculate Recording Thresholds");
setHighlight(mainscr, status[4], current == 4);
mvwaddstr(mainscr, 11,5,"Estimate Characteristics of Recording Channel");
setHighlight(mainscr, status[5], current == 5);
mvwaddstr(mainscr, 12,5,"Write Configuration");
setHighlight(mainscr, status[6], current == 6);
mvwaddstr(mainscr, 13,5,"Exit");
wmove(mainscr, 5, 17); /***** set cursor to an appropriate location */
wrefresh(mainscr); /***** refresh the dialog */
/* process the command keystroke */
switch(getch())
{
case KEY_UP: /***** cursor up */
current = (current == 0 ? menu_items - 1 : current - 1);
while(status[current] == inactive)
current = (current == 0 ? menu_items - 1 : current - 1);
break;
case KEY_DOWN: /***** cursor down */
current = (current == menu_items-1 ? 0 : current + 1);
while(status[current] == inactive)
current = (current == menu_items-1 ? 0 : current + 1);
break;
case ENTER: /***** handle menu selections */
case BLANK:
switch (current)
{
case 0: /***** select mixer device */
status[0] = invalid;
status[2] = inactive;
status[3] = inactive;
status[4] = inactive;
status[5] = inactive;
noMixer();
if (selectMixer() == MIXER_OK)
{
status[0] = ok;
status[2] = invalid;
}
break;
case 1: /***** select audio device */
status[1] = invalid;
status[3] = inactive;
status[4] = inactive;
status[5] = inactive;
noAudio();
if (selectAudio() == AUDIO_OK)
status[1] = ok;
break;
case 2: /***** adjust mixer levels */
if (adjustMixerLevels())
{
status[2] = ok;
status[3] = invalid;
status[4] = invalid;
}
break;
case 3: /***** calculate recording thresholds */
if (calculateThresholds())
status[3] = ok;
else
status[3] = invalid;
break;
case 4: /***** estimate the characteristics of the recording channel */
if (estimateChannelMean())
status[4] = ok;
else
status[4] = invalid;
break;
case 5: /***** save configuration! */
if (saveConfiguration())
{
status[5] = ok;
status[6] = ok;
}
break;
case 6: /***** leave program */
if (status[6] == ok || (status[6] != ok && safeExit()))
{
wrefresh(mainscr); /***** refresh the dialog */
request_finish = 1;
delwin(mainscr); /***** delete ncurses dialog window */
}
break;
}
break;
}
/***** if the configuration is done, activate the menu item "Save Configuration" */
if (status[0] != ok || status[1] != ok ||
status[2] != ok || status[3] != ok ||
status[4] != ok)
status[5] = inactive;
else if (status[5] != ok)
status[5] = invalid;
}
endwin(); /* we're done */
/***** free memory used by the list of mixer and audio devices */
if (mixer_devices != NULL)
{
for (i = 0; i < mixer_devices->count; i++)
free(mixer_devices->name[i]);
free(mixer_devices->name);
free(mixer_devices);
}
if (audio_devices != NULL)
{
for (i = 0; i < audio_devices->count; i++)
free(audio_devices->name[i]);
free(audio_devices->name);
free(audio_devices);
}
exit(0);
}
int selectAudio()
{
int top = 0, current = 0; /***** selection menu related variables */
int max_view = 9;
int retval = 0; /***** return value */
int request_finish = 0; /***** leave current dialog, if request_finish is set to 1 */
int width = 45, height = 15, i, j; /***** ncurses related variables */
WINDOW *audioscr = popupWindow (width, height);
while (!request_finish)
{
wattrset (audioscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */
/*****
* draw a box around the dialog window
* and empty it.
*****/
werase (audioscr);
box (audioscr, 0, 0);
for (i = 1; i < width-1; i++)
for (j = 1; j < height-1; j++)
mvwaddch(audioscr, j, i, ' ');
/***** dialog header */
mvwaddstr(audioscr, 1, 2, "Select Audio Device:");
mvwaddseparator(audioscr, 2, width);
/***** selection area */
for (i = 0; i < MIN2(audio_devices->count, max_view); i++)
{
setHighlight(audioscr, ok, i == current);
mvwaddstr(audioscr, 4+i, 4, "/dev/");
waddstr(audioscr, audio_devices->name[top+i]);
}
wattroff(audioscr, A_REVERSE);
/*****
* show up/down arrow to the left, if more items are available
* than can be displayed
*****/
if (top > 0)
{
mvwaddch(audioscr,4, 2, ACS_UARROW);
mvwaddch(audioscr,4+1, 2, ACS_VLINE);
}
if (audio_devices->count > max_view && top+max_view <= audio_devices->count-1)
{
mvwaddch(audioscr,4+max_view-2, 2, ACS_VLINE);
mvwaddch(audioscr,4+max_view-1, 2, ACS_DARROW);
}
wmove(audioscr, 1, 23); /***** set cursor to an appropriate location */
wrefresh (audioscr); /***** refresh the dialog */
/* process the command keystroke */
switch(getch())
{
case KEY_UP: /***** cursor up */
if (current > 0)
current--;
else
top = (top > 0 ? top-1 : 0);
break;
case KEY_DOWN: /***** cursor down */
if (top+current < audio_devices->count-1)
{
if (current < max_view-1)
current++;
else
top++;
}
break;
case ESCAPE: /***** Hit Escape to leave dialog */
retval = AUDIO_ERR;
request_finish = 1;
break;
case ENTER: /***** make selection with Enter or Space bar */
case BLANK:
setAudio(audio_devices->name[top+current]); /***** set audio device to highlighted item */
retval = initAudio(); /***** retval is ok, if initAudio() returned ok */
if (retval == AUDIO_ERR)
noAudio();
request_finish = 1; /***** leave dialog */
break;
}
}
delwin(audioscr); /***** delete ncurses dialog window */
return(retval);
}
void NodeConnectorView::hoverEnterEvent(QGraphicsSceneHoverEvent* event)
{
Q_UNUSED(event);
setHighlight(true);
}
void WidgetLabel::leave() {
setHighlight(false);
}
void WidgetLabel::enter() {
setHighlight(true);
}
void NodeConnectorView::hoverLeaveEvent(QGraphicsSceneHoverEvent* event)
{
Q_UNUSED(event);
setHighlight(false);
}
void editModel()
{
int width = 65, height = 22, i, j; /***** ncurses related variables */
WINDOW *editscr = popupWindow(width, height);
int top = 0, current = 0; /***** menu selection related variables */
int max_view = 10;
int request_finish = 0; /***** request_finish = 1 breaks the main while loop */
while (!request_finish)
{
wattrset (editscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */
/*****
* draw a box around the dialog window
* and empty it.
*****/
werase (editscr);
box (editscr, 0, 0);
for (i = 1; i < width-1; i++)
for (j = 1; j < height-1; j++)
mvwaddch(editscr, j, i, ' ');
/***** dialog header */
mvwaddstr(editscr, 1, 2, "Edit Speaker Model");
mvwaddseparator(editscr, 2, width);
/***** display help at the bottom */
mvwaddseparator(editscr, height-4, width);
mvwaddstr(editscr, height-3, 2, "a = add item, d = delete item, Enter = edit item");
mvwaddstr(editscr, height-2, 2, "b = back to main menu");
/***** display information about current speaker model in a table */
mvwaddstr(editscr, 4, 2, "Number of items:");
mvwaddint(editscr, 4, 19, model->number_of_items);
mvwaddstr(editscr, 6, 4, "Label");
mvwaddch(editscr, 6,25, ACS_VLINE);
mvwaddstr(editscr, 6,27, "Command");
mvwaddch(editscr, 6,48, ACS_VLINE);
mvwaddstr(editscr, 6,50, "Samples");
/***** display table */
for (i = 0; i < 55; i++)
mvwaddch(editscr, 7, 3+i, ACS_HLINE);
mvwaddch(editscr, 7,25, ACS_PLUS);
mvwaddch(editscr, 7,48, ACS_PLUS);
for (i = 0; i < max_view; i++)
{
mvwaddch(editscr, 8+i, 25, ACS_VLINE);
mvwaddch(editscr, 8+i, 48, ACS_VLINE);
}
/***** fill table */
for (i = 0; i < MIN2(model->number_of_items, max_view); i++)
{
setHighlight(editscr, active, i == current);
mvwaddstr(editscr, 8+i, 3, " ");
mvwaddstr(editscr, 8+i, 26, " ");
mvwaddstr(editscr, 8+i, 49, " ");
mvwaddnstr(editscr, 8+i, 4, getModelItem(model, top+i)->label, 20);
mvwaddnstr(editscr, 8+i, 27, getModelItem(model, top+i)->command, 20);
mvwaddint(editscr, 8+i, 53, getModelItem(model, top+i)->number_of_samples);
}
wattroff(editscr, A_REVERSE);
/***** up/down arrows indicate that not all items can be displayed */
if (top > 0)
{
mvwaddch(editscr, 8, 2, ACS_UARROW);
mvwaddch(editscr, 8+1, 2, ACS_VLINE);
}
if (model->number_of_items > max_view && top+max_view <= model->number_of_items-1)
{
mvwaddch(editscr, 8+max_view-2, 2, ACS_VLINE);
mvwaddch(editscr, 8+max_view-1, 2, ACS_DARROW);
}
wmove(editscr, 1,21); /***** move cursor to an appropriate location */
wrefresh(editscr); /***** refresh dialog window */
/* process the command keystroke */
switch(getch())
{
case KEY_UP: /***** cursor up */
if (top+current > 0)
{
if (current > 0)
current--;
else
top--;
}
break;
case KEY_DOWN: /***** cursor down */
if (top+current < model->number_of_items-1)
{
if (current < max_view-1)
current++;
else
top++;
}
break;
case 'b':
/*****
* allow leaving of the menu only if a predefined minimum amount of
* sample utterances has been donated for each model item
*****/
j = MIN_NR_SAMPLES_PER_ITEM;
for (i = 0; i < model->number_of_items; i++)
if (getModelItem(model, i)->number_of_samples < j)
{
j = 0;
break;
}
if (j < MIN_NR_SAMPLES_PER_ITEM) /***** at least one model item doesn't meet requirements */
{
int width = 42, height = 10, i, j; /***** ncurses related variables */
WINDOW *warnscr = popupWindow (width, height);
char tmp_string[80];
wattrset (warnscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */
/*****
* draw a box around the dialog window
* and empty it.
*****/
werase (warnscr);
box (warnscr, 0, 0);
for (i = 1; i < width-1; i++)
for (j = 1; j < height-1; j++)
mvwaddch(warnscr, j, i, ' ');
/***** dialog header */
mvwaddstr(warnscr, 1, 2, "Warning!");
mvwaddseparator(warnscr, 2, width);
/***** dialog message */
sprintf(tmp_string, "We need at least %d sample utterances", MIN_NR_SAMPLES_PER_ITEM);
mvwaddstr(warnscr, 3, 2, tmp_string);
mvwaddstr(warnscr, 4, 2,"for each speaker model item!!!");
mvwaddstr(warnscr, 5, 2,"Please donate the minimum number of ");
mvwaddstr(warnscr, 6, 2,"samples before leaving this menu!");
mvwaddstrcntr(warnscr, 8, width, "Press any key to continue ...");
wmove(warnscr, 1, 11); /***** move cursor to an appropriate location */
wrefresh (warnscr); /***** refresh dialog window */
getch(); /***** wait for keyboard input */
delwin(warnscr); /***** delete ncurses dialog window */
}
else
request_finish = 1; /***** otherwise prepare to leave menu */
break;
case ENTER: /***** edit the currently selected model item */
if (model->number_of_items > 0)
editModelItem(getModelItem(model, top+current));
break;
case 'a': /***** append a new item to the speaker model */
appendEmptyModelItem(model, "New Item", "New Command");
modified = 1; /***** switch 'modified' to 1 */
/***** set cursor to show new item */
current = model->number_of_items-1 - top;
while (current > max_view-1)
{
current--;
top++;
}
break;
case 'd': /***** delete currently selected item from model */
deleteModelItem(model, top+current);
modified = 1; /***** switch 'modified' to 1 */
/***** set cursor to a valid value */
if (top+current == model->number_of_items)
{
if (top > 0)
top--;
else if (current > 0)
current--;
}
break;
}
}
}
void KDGanttViewTaskLink::initTaskLink()
{
horLineList = new QPtrList<KDCanvasLine>;
verLineList = new QPtrList<KDCanvasLine>;
horLineList2 = new QPtrList<KDCanvasLine>;
verLineList2 = new QPtrList<KDCanvasLine>;
horLineList3 = new QPtrList<KDCanvasLine>;
topList = new QPtrList<KDCanvasPolygon>;
topLeftList = new QPtrList<KDCanvasPolygon>;
topRightList = new QPtrList<KDCanvasPolygon>;
horLineList->setAutoDelete( true );
verLineList->setAutoDelete( true );
horLineList2->setAutoDelete( true );
verLineList2->setAutoDelete( true );
horLineList3->setAutoDelete( true );
topList->setAutoDelete( true );
topLeftList->setAutoDelete( true );
topRightList->setAutoDelete( true );
myTimeTable = fromList.getFirst()->myGanttView->myTimeTable;
KDCanvasLine* horLine,*verLine;
KDCanvasLine* horLine2,*verLine2;
KDCanvasLine* horLine3;
KDCanvasPolygon* top;
KDCanvasPolygon* topLeft;
KDCanvasPolygon* topRight;
unsigned int i, j;
for ( i = 0;i < fromList.count();++i) {
for ( j = 0;j < toList.count();++j) {
horLine = new KDCanvasLine(myTimeTable,this,Type_is_KDGanttTaskLink);
verLine = new KDCanvasLine(myTimeTable,this,Type_is_KDGanttTaskLink);
horLine2 = new KDCanvasLine(myTimeTable,this,Type_is_KDGanttTaskLink);
verLine2 = new KDCanvasLine(myTimeTable,this,Type_is_KDGanttTaskLink);
horLine3 = new KDCanvasLine(myTimeTable,this,Type_is_KDGanttTaskLink);
top = new KDCanvasPolygon(myTimeTable,this,Type_is_KDGanttTaskLink);
topLeft = new KDCanvasPolygon(myTimeTable,this,Type_is_KDGanttTaskLink);
topRight = new KDCanvasPolygon(myTimeTable,this,Type_is_KDGanttTaskLink);
QPointArray arr = QPointArray(3);
arr.setPoint(0,-4,-5);
arr.setPoint(1,4,-5);
arr.setPoint(2,0,0);
top->setPoints(arr);
arr.setPoint(0,5,-5); // need an extra y pixel, canvas bug?
arr.setPoint(1,5,5); // need an extra y pixel, canvas bug?
arr.setPoint(2,0,0);
topLeft->setPoints(arr);
arr.setPoint(0,-5,-4);
arr.setPoint(1,-5,4);
arr.setPoint(2,0,0);
topRight->setPoints(arr);
horLineList->append(horLine);
verLineList->append(verLine);
horLineList2->append(horLine2);
verLineList2->append(verLine2);
horLineList3->append(horLine3);
topList->append(top);
topLeftList->append(topLeft);
topRightList->append(topRight);
horLine->setZ(1);
verLine->setZ(1);
horLine2->setZ(1);
verLine2->setZ(1);
horLine3->setZ(1);
top->setZ(1);
topLeft->setZ(1);
topRight->setZ(1);
}
}
setTooltipText( "Tasklink" );
setWhatsThisText( "Tasklink" );
myTimeTable->myTaskLinkList.append(this);
setHighlight( false);
setHighlightColor(Qt::red );
setColor(Qt::black);
setVisible(true);
}
void editModelItem(ModelItem *model_item)
{
int width = 65, height = 22, i, j; /***** ncurses related variables */
WINDOW *itemscr = popupWindow (width, height);
int top = 0, current = 0; /***** menu selection related variables */
int max_view = 6;
int input_field_width = 40; /***** width of string input field */
int request_finish = 0; /***** request_finish = 1 breaks the main while loop */
while (!request_finish)
{
wattrset (itemscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */
/*****
* draw a box around the dialog window
* and empty it.
*****/
werase (itemscr);
box (itemscr, 0, 0);
for (i = 1; i < width-1; i++)
for (j = 1; j < height-1; j++)
mvwaddch(itemscr, j, i, ' ');
/***** dialog header */
mvwaddstr(itemscr, 1, 2, "Edit Speaker Model Item");
mvwaddseparator(itemscr, 2, width);
/***** display help at the bottom */
mvwaddseparator(itemscr, height-4, width);
mvwaddstr(itemscr, height-3, 2, "r = record sample, d = delete sample, enter = play sample");
mvwaddstr(itemscr, height-2, 2, "b = back to model menu, l = edit label, c = edit command");
/***** display information about current speaker item */
mvwaddstr(itemscr, 4, 2, "Label :");
mvwaddnstr(itemscr, 4, 12, model_item->label, input_field_width);
mvwaddstr(itemscr, 5, 2, "Command :");
mvwaddnstr(itemscr, 5, 12, model_item->command, input_field_width);
mvwaddstr(itemscr, 7, 2, "Number of samples:");
mvwaddint(itemscr, 7, 21, model_item->number_of_samples);
/***** show sample utterances in a list. */
mvwaddstr(itemscr, 9, 4, "ID"); /***** header */
for (i = 0; i < 28; i++)
mvwaddch(itemscr,10, 3+i, ACS_HLINE);
/***** list items */
for (i = 0; i < MIN2(model_item->number_of_samples, max_view); i++)
{
setHighlight(itemscr, active, i == current);
mvwaddstr(itemscr,11+i, 3, " ");
mvwaddstr(itemscr,11+i, 4, getModelItemSample(model_item, top+i)->id);
}
wattroff(itemscr, A_REVERSE);
/***** up/down arrows indicate that not all items can be displayed */
if (top > 0)
{
mvwaddch(itemscr,11, 2, ACS_UARROW);
mvwaddch(itemscr,11+1, 2, ACS_VLINE);
}
if (model_item->number_of_samples > max_view && top+max_view <= model_item->number_of_samples-1)
{
mvwaddch(itemscr,11+max_view-2, 2, ACS_VLINE);
mvwaddch(itemscr,11+max_view-1, 2, ACS_DARROW);
}
wmove(itemscr, 1,26); /***** move cursor to a convenient location */
wrefresh(itemscr); /***** refresh dialog window */
/* process the command keystroke */
switch(getch())
{
case KEY_UP: /***** cursor up */
if (top+current > 0)
{
if (current > 0)
current--;
else
top--;
}
break;
case KEY_DOWN: /***** cursor down */
if (top+current < model_item->number_of_samples-1)
{
if (current < max_view-1)
current++;
else
top++;
}
break;
case 'b': /***** leave menu */
request_finish = 1;
break;
case ENTER: /***** play selected utterance */
if (model_item->number_of_samples > 0)
{
int width = 42, height = 8, i, j; /* ncurses related variables */
WINDOW *playbackscr = popupWindow (width, height);
wattrset (playbackscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */
/*****
* draw a box around the dialog window
* and empty it.
*****/
werase (playbackscr);
box (playbackscr, 0, 0);
for (i = 1; i < width-1; i++)
for (j = 1; j < height-1; j++)
mvwaddch(playbackscr, j, i, ' ');
/***** dialog header */
mvwaddstr(playbackscr, 1, 2, "Playback");
mvwaddseparator(playbackscr, 2, width);
/***** play wave if present */
if (getModelItemSample(model_item, top+current)->has_wav)
{
/***** dialog message */
mvwaddstr(playbackscr, 3, 2,"Utterance is being played ... ");
/* mvwaddstrcntr(playbackscr, 6, width, "Press any key to cancel ..."); */
wmove(playbackscr, 1, 11); /***** move cursor to an appropriate location */
wrefresh (playbackscr); /***** refresh dialog window */
/***** if play fails or was cancelled ....*/
if (playSample(getModelItemSample(model_item, top+current)) != AUDIO_OK)
{
/***** display information */
mvwaddstr(playbackscr, 1, 2, "Warning! ");
mvwaddstr(playbackscr, 3, 2,"Either playback has been cancelled ");
mvwaddstr(playbackscr, 4, 2,"or wave couldn't be sent to your ");
mvwaddstr(playbackscr, 5, 2,"soundcard ! ");
mvwaddstrcntr(playbackscr, 6, width, "Press any key to continue ...");
wmove(playbackscr, 1, 11); /***** move cursor to an appropriate location */
wrefresh (playbackscr); /***** refresh dialog window */
getch(); /***** wait for keyboard input */
}
}
else /***** no wave data present! */
{
mvwaddstr(playbackscr, 3, 2,"Utterance can't be played! No wave ");
mvwaddstr(playbackscr, 4, 2,"data available! Note: KvoiceControl ");
mvwaddstr(playbackscr, 5, 2,"did NOT save the original wave data!");
mvwaddstrcntr(playbackscr, 6, width, "Press any key to cancel ...");
wmove(playbackscr, 1, 11); /***** move cursor to an appropriate location */
wrefresh (playbackscr); /***** refresh dialog window */
getch(); /***** wait for keyboard input */
}
delwin(playbackscr); /***** delete ncurses dialog window */
}
break;
case 'r': /***** record sample utterance */
{
int width = 42, height = 8, i, j; /***** ncurses related variables */
WINDOW *recordscr = popupWindow (width, height);
ModelItemSample *new_sample; /***** temporary pointer to new utterance */
wattrset (recordscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */
/*****
* draw a box around the dialog window
* and empty it.
*****/
werase (recordscr);
box (recordscr, 0, 0);
for (i = 1; i < width-1; i++)
for (j = 1; j < height-1; j++)
mvwaddch(recordscr, j, i, ' ');
/***** dialog header */
mvwaddstr(recordscr, 1, 2, "Recording");
mvwaddseparator(recordscr, 2, width);
/***** dialog message */
mvwaddstr(recordscr, 3, 2,"Utterance is recorded automatically!");
mvwaddstr(recordscr, 4, 2,"Please say what you want to say ...");
mvwaddstrcntr(recordscr, 6, width, "Press any key to cancel ...");
wmove(recordscr, 1, 12); /***** move cursor to a convenient location */
wrefresh (recordscr); /***** refresh dialog screen */
new_sample = recordSample(); /***** auto record a sample utterance */
if (new_sample != NULL) /***** if the recording was successful ... */
{
appendModelItemSample(model_item, new_sample); /***** add the sample to the model */
/***** set cursor to be over new sample utterance */
current = model_item->number_of_samples-1 - top;
while (current > max_view-1)
{
current--;
top++;
}
}
else /***** recording has failed or was cancelled */
{
/***** dialog message */
mvwaddstr(recordscr, 1, 2, "Cancel! ");
mvwaddstr(recordscr, 3, 2,"Nothing has been recorded! Either ");
mvwaddstr(recordscr, 4, 2,"you cancelled or no data could be ");
mvwaddstr(recordscr, 5, 2,"recorded ! ");
mvwaddstrcntr(recordscr, 6, width, "Press any key to continue ...");
wmove(recordscr, 1, 10); /***** move cursor to a convenient location */
wrefresh (recordscr); /***** refresh dialog screen */
getch(); /***** wait for keyboard input */
}
delwin(recordscr); /***** delete ncurses dialog window */
}
break;
case 'l': /***** edit label */
{
/*****
* use wstringInput to edit the label of the current utterance
* if the label has changed, switch 'modified' to 1
*****/
char tmp_string[1000];
strcpy(tmp_string, model_item->label);
free(model_item->label);
model_item->label = wstringInput(itemscr, 4, 12, 255, input_field_width, tmp_string);
if (strcmp(tmp_string, model_item->label) != 0)
modified = 1;
}
break;
case 'c': /***** edit command */
{
/*****
* use wstringInput to edit the commandd of the current utterance
* if the command has changed, switch 'modified' to 1
*****/
char tmp_string[1000];
strcpy(tmp_string, model_item->command);
free(model_item->command);
model_item->command = wstringInput(itemscr, 5, 12, 255, input_field_width, tmp_string);
if (strcmp(tmp_string, model_item->command) != 0)
modified = 1;
}
break;
case 'd':
/*****
* delete currently selected sample utterance from model item
* and switch 'modified' to 1
*****/
deleteModelItemSample(model_item, top+current);
modified = 1;
/***** set cursor to a valid value */
if (top+current == model_item->number_of_samples)
{
if (top > 0)
top--;
else if (current > 0)
current--;
}
break;
}
}
}
