void vrpn_Qt::AddWidget(QWidget* widget) {
// Ignore widgets called vrpn_Qt_ignore
if (widget->objectName() == "vrpn_Qt_ignore") {
return;
}
// Check if widget is derived from abstract button
if (qobject_cast<QAbstractButton*>(widget)) {
QAbstractButton* button = qobject_cast<QAbstractButton*>(widget);
connect(button, SIGNAL(pressed()), this, SLOT(ButtonChanged()));
connect(button, SIGNAL(released()), this, SLOT(ButtonChanged()));
buttonWidgets.append(button);
buttons[num_buttons] = button->isChecked();
num_buttons++;
}
// Check if widget is derived from abstract slider
else if (qobject_cast<QAbstractSlider*>(widget)) {
QAbstractSlider* slider = qobject_cast<QAbstractSlider*>(widget);
connect(slider, SIGNAL(valueChanged(int)), this, SLOT(AnalogChanged()));
analogWidgets.append(slider);
channel[num_channel] = slider->value();
num_channel++;
}
// Check for double spin box
else if (qobject_cast<QDoubleSpinBox*>(widget)) {
virtual dyn_t getGuiValue(void){
QAbstractButton *button = dynamic_cast<QAbstractButton*>(_widget);
if (button!=NULL)
return DYN_create_bool(button->isChecked());
QAbstractSlider *slider = dynamic_cast<QAbstractSlider*>(_widget);
if (slider!=NULL)
return DYN_create_int(slider->value());
QLabel *label = dynamic_cast<QLabel*>(_widget);
if (label!=NULL)
return DYN_create_string(label->text());
QLineEdit *line_edit = dynamic_cast<QLineEdit*>(_widget);
if (line_edit!=NULL)
return DYN_create_string(line_edit->text());
QTextEdit *text_edit = dynamic_cast<QTextEdit*>(_widget);
if (text_edit!=NULL)
return DYN_create_string(text_edit->toPlainText());
QSpinBox *spinbox = dynamic_cast<QSpinBox*>(_widget);
if (spinbox!=NULL)
return DYN_create_int(spinbox->value());
QDoubleSpinBox *doublespinbox = dynamic_cast<QDoubleSpinBox*>(_widget);
if (doublespinbox!=NULL)
return DYN_create_float(doublespinbox->value());
handleError("Gui #%d does not have a getValue method", _gui_num);
return DYN_create_bool(false);
}
//---------------------------------------------------------------------------
void MainWindow::scrollSliderReleased()
{
QAbstractSlider *slider = (QAbstractSlider *) QObject::sender();
int ScrollPos = slider->sliderPosition();
bool reset_slider;
calc_scroll(QAbstractSlider::SliderMove + 100, ScrollPos, reset_slider);
slider->setSliderPosition(ScrollPos);
}
void StatsWatcher::registerSliderAction(int action)
{
QAbstractSlider *slider = qobject_cast<QAbstractSlider*>(sender());
if (!slider)
{
DEBUG_LOG("Aquest slot només s'hauria de connectar amb sliders. Retornem de la funció");
return;
}
QString statMessage;
switch (action)
{
case QAbstractSlider::SliderNoAction:
statMessage = "No Action";
break;
case QAbstractSlider::SliderSingleStepAdd:
statMessage = "+1 Pas";
break;
case QAbstractSlider::SliderSingleStepSub:
statMessage = "-1 Pas";
break;
case QAbstractSlider::SliderPageStepAdd:
statMessage = "+1 Page";
break;
case QAbstractSlider::SliderPageStepSub:
statMessage = "-1 Page";
break;
case QAbstractSlider::SliderToMinimum:
statMessage = "A mínim";
break;
case QAbstractSlider::SliderToMaximum:
statMessage = "A màxim";
break;
case QAbstractSlider::SliderMove:
// Només registrem quan s'ha fet un move amb rodeta
if (!slider->isSliderDown())
{
statMessage = "Desplaçar amb rodeta";
}
break;
// Cas especial. petit hack per connectar amb sliderReleased
case 10:
statMessage = "Desplaçar clickant";
break;
}
if (!statMessage.isEmpty())
{
log(QString("[%1] S'ha fet l'acció [%2] sobre l'slider [%3]").arg(m_context).arg(statMessage).arg(sender()->objectName()));
}
}
void SoundSettings::InitWindow()
{
boost::shared_ptr<UiServices::UiModule> ui_module = framework_->GetModuleManager()->GetModule<UiServices::UiModule>(Foundation::Module::MT_UiServices).lock();
// If this occurs, we're most probably operating in headless mode.
if (ui_module.get() == 0)
return;
QUiLoader loader;
QFile file("./data/ui/soundsettings.ui");
if (!file.exists())
{
OpenALAudioModule::LogError("Cannot find sound settings .ui file.");
return;
}
settings_widget_ = loader.load(&file);
if (!settings_widget_)
return;
ui_module->GetInworldSceneController()->AddSettingsWidget(settings_widget_, "Sound");
boost::shared_ptr<Foundation::SoundServiceInterface> soundsystem = framework_->GetServiceManager()->GetService<Foundation::SoundServiceInterface>(Foundation::Service::ST_Sound).lock();
if (!soundsystem.get())
return;
QAbstractSlider* slider = settings_widget_->findChild<QAbstractSlider*>("slider_master");
if (slider)
{
slider->setValue(soundsystem->GetMasterGain() * 100);
QObject::connect(slider, SIGNAL(valueChanged(int)), this, SLOT(MasterGainChanged(int)));
}
slider = settings_widget_->findChild<QAbstractSlider*>("slider_triggered");
if (slider)
{
slider->setValue(soundsystem->GetSoundMasterGain(Foundation::SoundServiceInterface::Triggered) * 100);
QObject::connect(slider, SIGNAL(valueChanged(int)), this, SLOT(TriggeredGainChanged(int)));
}
slider = settings_widget_->findChild<QAbstractSlider*>("slider_ambient");
if (slider)
{
slider->setValue(soundsystem->GetSoundMasterGain(Foundation::SoundServiceInterface::Ambient) * 100);
QObject::connect(slider, SIGNAL(valueChanged(int)), this, SLOT(AmbientGainChanged(int)));
}
slider = settings_widget_->findChild<QAbstractSlider*>("slider_voice");
if (slider)
{
slider->setValue(soundsystem->GetSoundMasterGain(Foundation::SoundServiceInterface::Voice) * 100);
QObject::connect(slider, SIGNAL(valueChanged(int)), this, SLOT(VoiceGainChanged(int)));
}
}
int AbstractSlider::triggerAction(lua_State * L) // ( SliderAction action )
{
QAbstractSlider* obj = ObjectHelper<QAbstractSlider>::check( L, 1);
QAbstractSlider::SliderAction f;
int fInt = Util::toInt( L, 2 );
if( (fInt >= 0 && fInt <= 7) )
{
f = (QAbstractSlider::SliderAction) fInt;
obj->triggerAction( f );
}
else
Lua::Util::error( L, "expecting a valid QAbstractSlider::SliderAction" );
return 0;
}
//---------------------------------------------------------------------------
void MainWindow::scrollAction(int action)
{
if ( action == QAbstractSlider::SliderNoAction )
return;
QAbstractSlider *slider = (QAbstractSlider *) QObject::sender();
int ScrollPos = slider->sliderPosition();
bool reset_slider;
int code = calc_scroll(action, ScrollPos, reset_slider);
if ( code != 0 )
{
if ( reset_slider )
slider->setSliderPosition(ScrollPos);
if ( slider == (QAbstractSlider *) canvas->verticalScrollBar() )
move_focus(0, code);
else
move_focus(code, 0);
canvas->viewport()->update();
}
}
bool ScrollPanner::eventFilter(QObject *obj, QEvent *event)
{
bool b = QObject::eventFilter(obj, event);
if (event->type() == QEvent::Resize)
{
QAbstractSlider *sl = dynamic_cast<QAbstractSlider*>(obj);
if (sl)
{
if (sl == m_sliderX)
{
setHorizontalViewSize(sl->pageStep());
} else
if (sl == m_sliderY)
{
setVerticalViewSize(sl->pageStep());
}
}
}
return b;
}
virtual void setGuiValue(dyn_t val){
{
QAbstractButton *button = dynamic_cast<QAbstractButton*>(_widget);
if (button!=NULL){
if(val.type==BOOL_TYPE)
button->setChecked(val.bool_number);
else
handleError("Button->setValue received %s, expected BOOL_TYPE", DYN_type_name(val.type));
return;
}
}
{
QAbstractSlider *slider = dynamic_cast<QAbstractSlider*>(_widget);
if (slider!=NULL){
if(val.type==INT_TYPE)
slider->setValue(val.bool_number);
else
handleError("Slider->setValue received %s, expected INT_TYPE", DYN_type_name(val.type));
return;
}
}
{
QLabel *label = dynamic_cast<QLabel*>(_widget);
if (label!=NULL){
if(val.type==STRING_TYPE)
label->setText(STRING_get_qstring(val.string));
else
handleError("Text->setValue received %s, expected STRING_TYPE", DYN_type_name(val.type));
return;
}
}
{
QLineEdit *line_edit = dynamic_cast<QLineEdit*>(_widget);
if (line_edit!=NULL){
if(val.type==STRING_TYPE)
line_edit->setText(STRING_get_qstring(val.string));
else
handleError("Line->setValue received %s, expected STRING_TYPE", DYN_type_name(val.type));
return;
}
}
{
QTextEdit *text_edit = dynamic_cast<QTextEdit*>(_widget);
if (text_edit!=NULL){
if(val.type==STRING_TYPE)
text_edit->setPlainText(STRING_get_chars(val.string));
else
handleError("Text->setValue received %s, expected STRING_TYPE", DYN_type_name(val.type));
return;
}
}
{
QSpinBox *spinbox = dynamic_cast<QSpinBox*>(_widget);
if (spinbox!=NULL){
if (val.type==INT_TYPE)
spinbox->setValue((int)val.int_number);
else
handleError("IntText->setValue received %s, expected INT_TYPE", DYN_type_name(val.type));
return;
}
}
{
QDoubleSpinBox *doublespinbox = dynamic_cast<QDoubleSpinBox*>(_widget);
if (doublespinbox!=NULL){
if (val.type==FLOAT_TYPE)
doublespinbox->setValue(val.float_number);
else
handleError("FloatText->setValue received %s, expected FLOAT_TYPE", DYN_type_name(val.type));
return;
}
}
handleError("Gui #%d does not have a setValue method", _gui_num);
}
bool MainWindow::eventFilter(QObject *obj, QEvent *event)
{
QClipboard * clipboard = QApplication::clipboard(); //added by AiO
if ( obj == canvas->viewport() )
{
// paint
if ( event->type() == QEvent::Paint )
{
set_drawing_rectangle(canvas->viewport()->size().width(), canvas->viewport()->size().height());
QPainter p(canvas->viewport());
p.setPen(Qt::black);
p.setBrush(Qt::green);
PaintStruct ps;
ps.p = &p;
ps.border = 2;
drawGraph(&ps);
}
// mouse
else if ( event->type() == QEvent::MouseMove )
{
QMouseEvent *mevent = (QMouseEvent *) event;
if ( qApp->overrideCursor() )
{
//cursor is overridden, we are panning
if ( mevent->x() != ox || mevent->y() != oy )
{
move_focus(ox - mevent->x(), oy - mevent->y());
ox = mevent->x();
oy = mevent->y();
canvas->viewport()->update();
//update();
}
}
}
else if ( event->type() == QEvent::MouseButtonPress )
{
QMouseEvent *mevent = (QMouseEvent *) event;
if ( mevent->button() == Qt::LeftButton )
{
Qt::KeyboardModifiers mods = mevent->modifiers();
if (mods & Qt::ShiftModifier) zoomIn();
else if (mods & Qt::ControlModifier) zoomOut();
if ( !sticky )
{
qApp->setOverrideCursor(*MOVING_CURSOR);
}
else
{
if ( qApp->overrideCursor() )
{
//cursor is already overridden, release it
qApp->restoreOverrideCursor();
canvas->setMouseTracking(false);
}
else
{
qApp->setOverrideCursor(*MOVING_CURSOR);
canvas->setMouseTracking(true);
}
}
ox = mevent->x();
oy = mevent->y();
}
else if(mevent->button() == Qt::RightButton ) //Added by AiO
{
//query the cordinates of the mouse for node
char curNodeTitle[1024];
char * curNode;
char *index; //used for search
QMessageBox msgBox;
curNode = node_xy_title(mevent->x(),mevent->y());
if(curNode == 0) return true;
strncpy(curNodeTitle, curNode, 1024-1);
curNodeTitle[1024-1] = 0;
//label ends with ':'
//test for color characters format sym num num TEXT sym :
// replace : -1 with 0 and use &curNodeTitle[3]
//test with popup
if(curNodeTitle[0] == 0x0c)
{
index = strchr(curNodeTitle, ':');
if(index == 0) goto nocolon; //test for no label but color
--index;
--index;
--index;
*index = 0;
msgBox.setText(&curNodeTitle[3]);
clipboard->setText(&curNodeTitle[3]);
}
else
{
nocolon:
msgBox.setText(curNodeTitle);
clipboard->setText(curNodeTitle);
}
msgBox.exec();
}
}
else if ( event->type() == QEvent::MouseButtonRelease )
{
if ( !sticky )
qApp->restoreOverrideCursor();
}
// wheel
else if ( event->type() == QEvent::Wheel )
{
QWheelEvent *wevent = (QWheelEvent *) event;
if ( (qApp->keyboardModifiers() & Qt::ControlModifier) != 0 )
{
wevent->accept();
int numDegrees = wevent->delta() / 8;
int numSteps = numDegrees / 15;
if ( numSteps < 0)
{
numSteps = -numSteps;
for ( int x = 0; x < numSteps; x++ )
zoomOut();
}
else
{
for ( int x = 0; x < numSteps; x++ )
zoomIn();
}
return true;
}
else
{
bool ret = QMainWindow::eventFilter(obj, event);
QAbstractSlider *slider = (QAbstractSlider *) (wevent->orientation() == Qt::Vertical?
canvas->verticalScrollBar() :
canvas->horizontalScrollBar());
int ScrollPos = slider->sliderPosition();
bool reset_slider;
calc_scroll(QAbstractSlider::SliderMove + 100, ScrollPos, reset_slider);
slider->setSliderPosition(ScrollPos);
return ret;
}
}
// keyboard
else if ( event->type() == QEvent::KeyPress )
{
QKeyEvent *kevent = (QKeyEvent *) event;
int key = kevent->key();
KeyDown(key, kevent->modifiers());
if ( key == 0 )
{
event->accept();
return true;
}
}
}
return QMainWindow::eventFilter(obj, event);
}
bool QgsAttributeEditor::setValue( QWidget *editor, QgsVectorLayer *vl, int idx, const QVariant &value )
{
if ( !editor )
return false;
QgsVectorLayer::EditType editType = vl->editType( idx );
const QgsField &field = vl->pendingFields()[idx];
QVariant::Type myFieldType = field.type();
QSettings settings;
QString nullValue = settings.value( "qgis/nullValue", "NULL" ).toString();
switch ( editType )
{
case QgsVectorLayer::Classification:
case QgsVectorLayer::UniqueValues:
case QgsVectorLayer::Enumeration:
case QgsVectorLayer::ValueMap:
case QgsVectorLayer::ValueRelation:
{
QVariant v = value;
QComboBox *cb = qobject_cast<QComboBox *>( editor );
if ( !cb )
return false;
if ( v.isNull() )
{
v = nullValue;
}
int idx = cb->findData( v );
if ( idx < 0 )
return false;
cb->setCurrentIndex( idx );
}
break;
case QgsVectorLayer::DialRange:
case QgsVectorLayer::SliderRange:
case QgsVectorLayer::EditRange:
{
if ( myFieldType == QVariant::Int )
{
if ( editType == QgsVectorLayer::EditRange )
{
QSpinBox *sb = qobject_cast<QSpinBox *>( editor );
if ( !sb )
return false;
sb->setValue( value.toInt() );
}
else
{
QAbstractSlider *sl = qobject_cast<QAbstractSlider *>( editor );
if ( !sl )
return false;
sl->setValue( value.toInt() );
}
break;
}
else if ( myFieldType == QVariant::Double )
{
QDoubleSpinBox *dsb = qobject_cast<QDoubleSpinBox *>( editor );
if ( !dsb )
return false;
dsb->setValue( value.toDouble() );
}
}
case QgsVectorLayer::CheckBox:
{
QCheckBox *cb = qobject_cast<QCheckBox *>( editor );
if ( cb )
{
QPair<QString, QString> states = vl->checkedState( idx );
cb->setChecked( value == states.first );
break;
}
}
// fall-through
case QgsVectorLayer::LineEdit:
case QgsVectorLayer::UniqueValuesEditable:
case QgsVectorLayer::Immutable:
case QgsVectorLayer::UuidGenerator:
default:
{
QLineEdit *le = qobject_cast<QLineEdit *>( editor );
QTextEdit *te = qobject_cast<QTextEdit *>( editor );
QPlainTextEdit *pte = qobject_cast<QPlainTextEdit *>( editor );
if ( !le && !te && !pte )
return false;
QString text;
if ( value.isNull() )
{
if ( myFieldType == QVariant::Int || myFieldType == QVariant::Double || myFieldType == QVariant::LongLong )
text = "";
else if ( editType == QgsVectorLayer::UuidGenerator )
text = QUuid::createUuid().toString();
else
text = nullValue;
}
else
{
text = value.toString();
}
if ( le )
le->setText( text );
if ( te )
te->setHtml( text );
if ( pte )
pte->setPlainText( text );
}
break;
case QgsVectorLayer::FileName:
case QgsVectorLayer::Calendar:
{
QLineEdit* le = qobject_cast<QLineEdit*>( editor );
if ( !le )
{
le = editor->findChild<QLineEdit *>();
}
if ( !le )
{
return false;
}
le->setText( value.toString() );
}
break;
}
return true;
}
bool QgsAttributeEditor::retrieveValue( QWidget *widget, QgsVectorLayer *vl, int idx, QVariant &value )
{
if ( !widget )
return false;
const QgsField &theField = vl->pendingFields()[idx];
QgsVectorLayer::EditType editType = vl->editType( idx );
bool modified = false;
QString text;
QSettings settings;
QString nullValue = settings.value( "qgis/nullValue", "NULL" ).toString();
QLineEdit *le = qobject_cast<QLineEdit *>( widget );
if ( le )
{
text = le->text();
modified = le->isModified();
if ( text == nullValue )
{
text = QString::null;
}
}
QTextEdit *te = qobject_cast<QTextEdit *>( widget );
if ( te )
{
text = te->toHtml();
modified = te->document()->isModified();
if ( text == nullValue )
{
text = QString::null;
}
}
QPlainTextEdit *pte = qobject_cast<QPlainTextEdit *>( widget );
if ( pte )
{
text = pte->toPlainText();
modified = pte->document()->isModified();
if ( text == nullValue )
{
text = QString::null;
}
}
QComboBox *cb = qobject_cast<QComboBox *>( widget );
if ( cb )
{
if ( editType == QgsVectorLayer::UniqueValues ||
editType == QgsVectorLayer::ValueMap ||
editType == QgsVectorLayer::Classification ||
editType == QgsVectorLayer::ValueRelation )
{
text = cb->itemData( cb->currentIndex() ).toString();
if ( text == nullValue )
{
text = QString::null;
}
}
else
{
text = cb->currentText();
}
modified = true;
}
QListWidget *lw = qobject_cast<QListWidget *>( widget );
if ( lw )
{
if ( editType == QgsVectorLayer::ValueRelation )
{
text = '{';
for ( int i = 0, n = 0; i < lw->count(); i++ )
{
if ( lw->item( i )->checkState() == Qt::Checked )
{
if ( n > 0 )
{
text.append( ',' );
}
text.append( lw->item( i )->data( Qt::UserRole ).toString() );
n++;
}
}
text.append( '}' );
}
else
{
text = QString::null;
}
modified = true;
}
QSpinBox *sb = qobject_cast<QSpinBox *>( widget );
if ( sb )
{
text = QString::number( sb->value() );
}
QAbstractSlider *slider = qobject_cast<QAbstractSlider *>( widget );
if ( slider )
{
text = QString::number( slider->value() );
}
QDoubleSpinBox *dsb = qobject_cast<QDoubleSpinBox *>( widget );
if ( dsb )
{
text = QString::number( dsb->value() );
}
QCheckBox *ckb = qobject_cast<QCheckBox *>( widget );
if ( ckb )
{
QPair<QString, QString> states = vl->checkedState( idx );
text = ckb->isChecked() ? states.first : states.second;
}
QCalendarWidget *cw = qobject_cast<QCalendarWidget *>( widget );
if ( cw )
{
text = cw->selectedDate().toString();
}
le = widget->findChild<QLineEdit *>();
if ( le )
{
text = le->text();
}
switch ( theField.type() )
{
case QVariant::Int:
{
bool ok;
int myIntValue = text.toInt( &ok );
if ( ok && !text.isEmpty() )
{
value = QVariant( myIntValue );
modified = true;
}
else if ( modified )
{
value = QVariant();
}
}
break;
case QVariant::LongLong:
{
bool ok;
qlonglong myLongValue = text.toLong( &ok );
if ( ok && !text.isEmpty() )
{
value = QVariant( myLongValue );
modified = true;
}
else if ( modified )
{
value = QVariant();
}
}
case QVariant::Double:
{
bool ok;
double myDblValue = text.toDouble( &ok );
if ( ok && !text.isEmpty() )
{
value = QVariant( myDblValue );
modified = true;
}
else if ( modified )
{
value = QVariant();
}
}
break;
case QVariant::Date:
{
QDate myDateValue = QDate::fromString( text, Qt::ISODate );
if ( myDateValue.isValid() && !text.isEmpty() )
{
value = myDateValue;
modified = true;
}
else if ( modified )
{
value = QVariant();
}
}
break;
default: //string
modified = true;
value = QVariant( text );
break;
}
return modified;
}
QWidget *QgsAttributeEditor::createAttributeEditor( QWidget *parent, QWidget *editor, QgsVectorLayer *vl, int idx, const QVariant &value, QMap<int, QWidget*> &proxyWidgets )
{
if ( !vl )
return 0;
QWidget *myWidget = 0;
QgsVectorLayer::EditType editType = vl->editType( idx );
const QgsField &field = vl->pendingFields()[idx];
QVariant::Type myFieldType = field.type();
bool synchronized = false;
switch ( editType )
{
case QgsVectorLayer::UniqueValues:
{
QList<QVariant> values;
vl->dataProvider()->uniqueValues( idx, values );
QComboBox *cb = comboBox( editor, parent );
if ( cb )
{
cb->setEditable( false );
for ( QList<QVariant>::iterator it = values.begin(); it != values.end(); it++ )
cb->addItem( it->toString(), it->toString() );
myWidget = cb;
}
}
break;
case QgsVectorLayer::Enumeration:
{
QStringList enumValues;
vl->dataProvider()->enumValues( idx, enumValues );
QComboBox *cb = comboBox( editor, parent );
if ( cb )
{
QStringList::const_iterator s_it = enumValues.constBegin();
for ( ; s_it != enumValues.constEnd(); ++s_it )
{
cb->addItem( *s_it, *s_it );
}
myWidget = cb;
}
}
break;
case QgsVectorLayer::ValueMap:
{
const QMap<QString, QVariant> &map = vl->valueMap( idx );
QComboBox *cb = comboBox( editor, parent );
if ( cb )
{
for ( QMap<QString, QVariant>::const_iterator it = map.begin(); it != map.end(); it++ )
{
cb->addItem( it.key(), it.value() );
}
myWidget = cb;
}
}
break;
case QgsVectorLayer::ValueRelation:
{
const QgsVectorLayer::ValueRelationData &data = vl->valueRelation( idx );
QgsVectorLayer *layer = qobject_cast<QgsVectorLayer*>( QgsMapLayerRegistry::instance()->mapLayer( data.mLayer ) );
QMap< QString, QString > map;
int fi = -1;
if ( layer )
{
int ki = layer->fieldNameIndex( data.mOrderByValue ? data.mValue : data.mKey );
int vi = layer->fieldNameIndex( data.mOrderByValue ? data.mKey : data.mValue );
if ( !data.mFilterAttributeColumn.isNull() )
fi = layer->fieldNameIndex( data.mFilterAttributeColumn );
if ( ki >= 0 && vi >= 0 )
{
QgsAttributeList attributes;
attributes << ki;
attributes << vi;
if ( fi >= 0 )
attributes << fi;
layer->select( attributes, QgsRectangle(), false );
QgsFeature f;
while ( layer->nextFeature( f ) )
{
if ( fi >= 0 && f.attributeMap()[ fi ].toString() != data.mFilterAttributeValue )
continue;
map.insert( f.attributeMap()[ ki ].toString(), f.attributeMap()[ vi ].toString() );
}
}
}
if ( !data.mAllowMulti )
{
QComboBox *cb = comboBox( editor, parent );
if ( cb )
{
if ( data.mAllowNull )
{
QSettings settings;
cb->addItem( tr( "(no selection)" ), settings.value( "qgis/nullValue", "NULL" ).toString() );
}
for ( QMap< QString, QString >::const_iterator it = map.begin(); it != map.end(); it++ )
{
if ( data.mOrderByValue )
cb->addItem( it.key(), it.value() );
else
cb->addItem( it.value(), it.key() );
}
myWidget = cb;
}
}
else
{
QListWidget *lw = listWidget( editor, parent );
if ( lw )
{
QStringList checkList = value.toString().remove( QChar( '{' ) ).remove( QChar( '}' ) ).split( "," );
for ( QMap< QString, QString >::const_iterator it = map.begin(); it != map.end(); it++ )
{
QListWidgetItem *item;
if ( data.mOrderByValue )
{
item = new QListWidgetItem( it.key() );
item->setData( Qt::UserRole, it.value() );
item->setCheckState( checkList.contains( it.value() ) ? Qt::Checked : Qt::Unchecked );
}
else
{
item = new QListWidgetItem( it.value() );
item->setData( Qt::UserRole, it.key() );
item->setCheckState( checkList.contains( it.key() ) ? Qt::Checked : Qt::Unchecked );
}
lw->addItem( item );
}
myWidget = lw;
}
}
}
break;
case QgsVectorLayer::Classification:
{
QMap<QString, QString> classes;
const QgsUniqueValueRenderer *uvr = dynamic_cast<const QgsUniqueValueRenderer *>( vl->renderer() );
if ( uvr )
{
const QList<QgsSymbol *> symbols = uvr->symbols();
for ( int i = 0; i < symbols.size(); i++ )
{
QString label = symbols[i]->label();
QString name = symbols[i]->lowerValue();
if ( label == "" )
label = name;
classes.insert( name, label );
}
}
const QgsCategorizedSymbolRendererV2 *csr = dynamic_cast<const QgsCategorizedSymbolRendererV2 *>( vl->rendererV2() );
if ( csr )
{
const QgsCategoryList &categories = (( QgsCategorizedSymbolRendererV2 * )csr )->categories(); // FIXME: QgsCategorizedSymbolRendererV2::categories() should be const
for ( int i = 0; i < categories.size(); i++ )
{
QString label = categories[i].label();
QString value = categories[i].value().toString();
if ( label.isEmpty() )
label = value;
classes.insert( value, label );
}
}
QComboBox *cb = comboBox( editor, parent );
if ( cb )
{
for ( QMap<QString, QString>::const_iterator it = classes.begin(); it != classes.end(); it++ )
{
cb->addItem( it.value(), it.key() );
}
myWidget = cb;
}
}
break;
case QgsVectorLayer::DialRange:
case QgsVectorLayer::SliderRange:
case QgsVectorLayer::EditRange:
{
if ( myFieldType == QVariant::Int )
{
int min = vl->range( idx ).mMin.toInt();
int max = vl->range( idx ).mMax.toInt();
int step = vl->range( idx ).mStep.toInt();
if ( editType == QgsVectorLayer::EditRange )
{
QSpinBox *sb = 0;
if ( editor )
sb = qobject_cast<QSpinBox *>( editor );
else
sb = new QSpinBox( parent );
if ( sb )
{
sb->setRange( min, max );
sb->setSingleStep( step );
myWidget = sb;
}
}
else
{
QAbstractSlider *sl = 0;
if ( editor )
{
sl = qobject_cast<QAbstractSlider*>( editor );
}
else if ( editType == QgsVectorLayer::DialRange )
{
sl = new QDial( parent );
}
else
{
sl = new QSlider( Qt::Horizontal, parent );
}
if ( sl )
{
sl->setRange( min, max );
sl->setSingleStep( step );
myWidget = sl;
}
}
break;
}
else if ( myFieldType == QVariant::Double )
{
QDoubleSpinBox *dsb = 0;
if ( editor )
dsb = qobject_cast<QDoubleSpinBox*>( editor );
else
dsb = new QDoubleSpinBox( parent );
if ( dsb )
{
double min = vl->range( idx ).mMin.toDouble();
double max = vl->range( idx ).mMax.toDouble();
double step = vl->range( idx ).mStep.toDouble();
dsb->setRange( min, max );
dsb->setSingleStep( step );
myWidget = dsb;
}
break;
}
}
case QgsVectorLayer::CheckBox:
{
QCheckBox *cb = 0;
if ( editor )
cb = qobject_cast<QCheckBox*>( editor );
else
cb = new QCheckBox( parent );
if ( cb )
{
myWidget = cb;
break;
}
}
// fall-through
case QgsVectorLayer::LineEdit:
case QgsVectorLayer::TextEdit:
case QgsVectorLayer::UuidGenerator:
case QgsVectorLayer::UniqueValuesEditable:
case QgsVectorLayer::Immutable:
{
QLineEdit *le = 0;
QTextEdit *te = 0;
QPlainTextEdit *pte = 0;
QComboBox * cb = 0;
if ( editor )
{
le = qobject_cast<QLineEdit *>( editor );
te = qobject_cast<QTextEdit *>( editor );
pte = qobject_cast<QPlainTextEdit *>( editor );
cb = qobject_cast<QComboBox *>( editor );
}
else if ( editType == QgsVectorLayer::TextEdit )
{
pte = new QPlainTextEdit( parent );
}
else
{
le = new QLineEdit( parent );
}
if ( le )
{
if ( editType == QgsVectorLayer::UniqueValuesEditable )
{
QList<QVariant> values;
vl->dataProvider()->uniqueValues( idx, values );
QStringList svalues;
for ( QList<QVariant>::const_iterator it = values.begin(); it != values.end(); it++ )
svalues << it->toString();
QCompleter *c = new QCompleter( svalues );
c->setCompletionMode( QCompleter::PopupCompletion );
le->setCompleter( c );
}
if ( editType == QgsVectorLayer::UuidGenerator )
{
le->setReadOnly( true );
}
le->setValidator( new QgsFieldValidator( le, field ) );
myWidget = le;
}
if ( te )
{
te->setAcceptRichText( true );
myWidget = te;
}
if ( pte )
{
myWidget = pte;
}
if ( cb )
{
myWidget = cb;
}
if ( myWidget )
{
myWidget->setDisabled( editType == QgsVectorLayer::Immutable );
QgsStringRelay* relay = NULL;
QMap<int, QWidget*>::const_iterator it = proxyWidgets.find( idx );
if ( it != proxyWidgets.end() )
{
QObject* obj = qvariant_cast<QObject*>( (*it)->property( "QgisAttrEditProxy" ) );
relay = qobject_cast<QgsStringRelay*>( obj );
}
else
{
relay = new QgsStringRelay( myWidget );
}
if ( cb && cb->isEditable() )
{
synchronized = connect( relay, SIGNAL( textChanged( QString ) ), myWidget, SLOT( setEditText( QString ) ) );
synchronized &= connect( myWidget, SIGNAL( editTextChanged( QString ) ), relay, SLOT( changeText( QString ) ) );
}
else
{
synchronized = connect( relay, SIGNAL( textChanged( QString ) ), myWidget, SLOT( setText( QString ) ) );
synchronized &= connect( myWidget, SIGNAL( textChanged( QString ) ), relay, SLOT( changeText( QString ) ) );
}
if ( !cb || cb->isEditable() )
{
myWidget->setProperty( "QgisAttrEditProxy", QVariant( QMetaType::QObjectStar, &relay ) );
}
}
}
break;
case QgsVectorLayer::Hidden:
myWidget = 0;
break;
case QgsVectorLayer::FileName:
case QgsVectorLayer::Calendar:
{
QPushButton *pb = 0;
QLineEdit *le = qobject_cast<QLineEdit *>( editor );
if ( le )
{
if ( le )
myWidget = le;
if ( editor->parent() )
{
pb = editor->parent()->findChild<QPushButton *>();
}
}
else
{
le = new QLineEdit();
pb = new QPushButton( tr( "..." ) );
QHBoxLayout *hbl = new QHBoxLayout();
hbl->addWidget( le );
hbl->addWidget( pb );
myWidget = new QWidget( parent );
myWidget->setBackgroundRole( QPalette::Window );
myWidget->setAutoFillBackground( true );
myWidget->setLayout( hbl );
}
if ( pb )
{
if ( editType == QgsVectorLayer::FileName )
connect( pb, SIGNAL( clicked() ), new QgsAttributeEditor( pb ), SLOT( selectFileName() ) );
if ( editType == QgsVectorLayer::Calendar )
connect( pb, SIGNAL( clicked() ), new QgsAttributeEditor( pb ), SLOT( selectDate() ) );
}
}
break;
}
QMap<int, QWidget*>::const_iterator it = proxyWidgets.find( idx );
if ( it != proxyWidgets.end() )
{
if ( !synchronized )
{
myWidget->setEnabled( false );
}
}
else
{
proxyWidgets.insert( idx, myWidget );
}
setValue( myWidget, vl, idx, value );
return myWidget;
}
QWidget *QgsAttributeEditor::createAttributeEditor( QWidget *parent, QWidget *editor, QgsVectorLayer *vl, int idx, const QVariant &value )
{
if ( !vl )
return NULL;
QWidget *myWidget = NULL;
QgsVectorLayer::EditType editType = vl->editType( idx );
const QgsField &field = vl->pendingFields()[idx];
QVariant::Type myFieldType = field.type();
switch ( editType )
{
case QgsVectorLayer::UniqueValues:
{
QList<QVariant> values;
vl->dataProvider()->uniqueValues( idx, values );
QComboBox *cb = comboBox( editor, parent );
if ( cb )
{
cb->setEditable( false );
for ( QList<QVariant>::iterator it = values.begin(); it != values.end(); it++ )
cb->addItem( it->toString(), it->toString() );
myWidget = cb;
}
}
break;
case QgsVectorLayer::Enumeration:
{
QStringList enumValues;
vl->dataProvider()->enumValues( idx, enumValues );
QComboBox *cb = comboBox( editor, parent );
if ( cb )
{
QStringList::const_iterator s_it = enumValues.constBegin();
for ( ; s_it != enumValues.constEnd(); ++s_it )
{
cb->addItem( *s_it, *s_it );
}
myWidget = cb;
}
}
break;
case QgsVectorLayer::ValueMap:
{
const QMap<QString, QVariant> &map = vl->valueMap( idx );
QComboBox *cb = comboBox( editor, parent );
if ( cb )
{
for ( QMap<QString, QVariant>::const_iterator it = map.begin(); it != map.end(); it++ )
{
cb->addItem( it.key(), it.value() );
}
myWidget = cb;
}
}
break;
case QgsVectorLayer::ValueRelation:
{
QSettings settings;
QString nullValue = settings.value( "qgis/nullValue", "NULL" ).toString();
const QgsVectorLayer::ValueRelationData &data = vl->valueRelation( idx );
QgsVectorLayer *layer = qobject_cast<QgsVectorLayer*>( QgsMapLayerRegistry::instance()->mapLayer( data.mLayer ) );
QMap< QString, QString > map;
if ( layer )
{
int ki = layer->fieldNameIndex( data.mOrderByValue ? data.mValue : data.mKey );
int vi = layer->fieldNameIndex( data.mOrderByValue ? data.mKey : data.mValue );
if ( data.mAllowNull )
map.insert( nullValue, tr( "(no selection)" ) );
if ( ki >= 0 && vi >= 0 )
{
layer->select( QgsAttributeList() << ki << vi, QgsRectangle(), false );
QgsFeature f;
while ( layer->nextFeature( f ) )
{
map.insert( f.attributeMap()[ ki ].toString(), f.attributeMap()[ vi ].toString() );
}
}
}
QComboBox *cb = comboBox( editor, parent );
if ( cb )
{
for ( QMap< QString, QString >::const_iterator it = map.begin(); it != map.end(); it++ )
{
if ( data.mOrderByValue )
cb->addItem( it.key(), it.value() );
else
cb->addItem( it.value(), it.key() );
}
myWidget = cb;
}
}
break;
case QgsVectorLayer::Classification:
{
QMap<QString, QString> classes;
const QgsUniqueValueRenderer *uvr = dynamic_cast<const QgsUniqueValueRenderer *>( vl->renderer() );
if ( uvr )
{
const QList<QgsSymbol *> symbols = uvr->symbols();
for ( int i = 0; i < symbols.size(); i++ )
{
QString label = symbols[i]->label();
QString name = symbols[i]->lowerValue();
if ( label == "" )
label = name;
classes.insert( name, label );
}
}
const QgsCategorizedSymbolRendererV2 *csr = dynamic_cast<const QgsCategorizedSymbolRendererV2 *>( vl->rendererV2() );
if ( csr )
{
const QgsCategoryList &categories = (( QgsCategorizedSymbolRendererV2 * )csr )->categories(); // FIXME: QgsCategorizedSymbolRendererV2::categories() should be const
for ( int i = 0; i < categories.size(); i++ )
{
QString label = categories[i].label();
QString value = categories[i].value().toString();
if ( label.isEmpty() )
label = value;
classes.insert( value, label );
}
}
QComboBox *cb = comboBox( editor, parent );
if ( cb )
{
for ( QMap<QString, QString>::const_iterator it = classes.begin(); it != classes.end(); it++ )
{
cb->addItem( it.value(), it.key() );
}
myWidget = cb;
}
}
break;
case QgsVectorLayer::DialRange:
case QgsVectorLayer::SliderRange:
case QgsVectorLayer::EditRange:
{
if ( myFieldType == QVariant::Int )
{
int min = vl->range( idx ).mMin.toInt();
int max = vl->range( idx ).mMax.toInt();
int step = vl->range( idx ).mStep.toInt();
if ( editType == QgsVectorLayer::EditRange )
{
QSpinBox *sb = NULL;
if ( editor )
sb = qobject_cast<QSpinBox *>( editor );
else
sb = new QSpinBox( parent );
if ( sb )
{
sb->setRange( min, max );
sb->setSingleStep( step );
myWidget = sb;
}
}
else
{
QAbstractSlider *sl = NULL;
if ( editor )
{
sl = qobject_cast<QAbstractSlider*>( editor );
}
else if ( editType == QgsVectorLayer::DialRange )
{
sl = new QDial( parent );
}
else
{
sl = new QSlider( Qt::Horizontal, parent );
}
if ( sl )
{
sl->setRange( min, max );
sl->setSingleStep( step );
myWidget = sl;
}
}
break;
}
else if ( myFieldType == QVariant::Double )
{
QDoubleSpinBox *dsb = NULL;
if ( editor )
dsb = qobject_cast<QDoubleSpinBox*>( editor );
else
dsb = new QDoubleSpinBox( parent );
if ( dsb )
{
double min = vl->range( idx ).mMin.toDouble();
double max = vl->range( idx ).mMax.toDouble();
double step = vl->range( idx ).mStep.toDouble();
dsb->setRange( min, max );
dsb->setSingleStep( step );
myWidget = dsb;
}
break;
}
}
case QgsVectorLayer::CheckBox:
{
QCheckBox *cb = NULL;
if ( editor )
cb = qobject_cast<QCheckBox*>( editor );
else
cb = new QCheckBox( parent );
if ( cb )
{
myWidget = cb;
break;
}
}
// fall-through
case QgsVectorLayer::LineEdit:
case QgsVectorLayer::TextEdit:
case QgsVectorLayer::UniqueValuesEditable:
case QgsVectorLayer::Immutable:
{
QLineEdit *le = NULL;
QTextEdit *te = NULL;
QPlainTextEdit *pte = NULL;
if ( editor )
{
le = qobject_cast<QLineEdit *>( editor );
te = qobject_cast<QTextEdit *>( editor );
pte = qobject_cast<QPlainTextEdit *>( editor );
}
else if ( editType == QgsVectorLayer::TextEdit )
{
pte = new QPlainTextEdit( parent );
}
else
{
le = new QLineEdit( parent );
}
if ( le )
{
if ( editType == QgsVectorLayer::UniqueValuesEditable )
{
QList<QVariant> values;
vl->dataProvider()->uniqueValues( idx, values );
QStringList svalues;
for ( QList<QVariant>::const_iterator it = values.begin(); it != values.end(); it++ )
svalues << it->toString();
QCompleter *c = new QCompleter( svalues );
c->setCompletionMode( QCompleter::PopupCompletion );
le->setCompleter( c );
}
le->setValidator( new QgsFieldValidator( le, field ) );
myWidget = le;
}
if ( te )
{
te->setAcceptRichText( true );
myWidget = te;
}
if ( pte )
{
myWidget = pte;
}
if ( myWidget )
{
myWidget->setDisabled( editType == QgsVectorLayer::Immutable );
}
}
break;
case QgsVectorLayer::Hidden:
myWidget = NULL;
break;
case QgsVectorLayer::FileName:
case QgsVectorLayer::Calendar:
{
QPushButton *pb = NULL;
QLineEdit *le = qobject_cast<QLineEdit *>( editor );
if ( le )
{
if ( le )
myWidget = le;
if ( editor->parent() )
{
pb = editor->parent()->findChild<QPushButton *>();
}
}
else
{
le = new QLineEdit();
pb = new QPushButton( tr( "..." ) );
QHBoxLayout *hbl = new QHBoxLayout();
hbl->addWidget( le );
hbl->addWidget( pb );
myWidget = new QWidget( parent );
myWidget->setBackgroundRole( QPalette::Window );
myWidget->setAutoFillBackground( true );
myWidget->setLayout( hbl );
}
if ( pb )
{
if ( editType == QgsVectorLayer::FileName )
connect( pb, SIGNAL( clicked() ), new QgsAttributeEditor( pb ), SLOT( selectFileName() ) );
if ( editType == QgsVectorLayer::Calendar )
connect( pb, SIGNAL( clicked() ), new QgsAttributeEditor( pb ), SLOT( selectDate() ) );
}
}
break;
}
setValue( myWidget, vl, idx, value );
return myWidget;
}
int AbstractSlider::setRange(lua_State * L) // ( int min, int max )
{
QAbstractSlider* obj = ObjectHelper<QAbstractSlider>::check( L, 1);
obj->setRange( Util::toInt( L, 2), Util::toInt( L, 3) );
return 0;
}
