void LayersMgrWidget::onDelLayer(wxCommandEvent& event)
{
	int index = getEditLayerIndex();

	m_layersSizer->Detach(m_layers.size() - 1 - index);
	delete m_layers[index]->getLayer();
	delete m_layers[index];
	m_layers.erase(m_layers.begin() + index);

	if (index < m_layers.size())
		setEditable(m_layers[index]);
	else
		setEditable(m_layers.back());

	if (m_layers.empty())
		m_editedLayer = NULL;

	if (m_layers.size() == 1)
		m_btnDel->Enable(false);

	m_parent->Fit();

	wxWindow* root = m_parent;
	while (root->GetParent())
		root = root->GetParent();
	root->Refresh();
}
QStandardItemModel *ConversationData::makeContextModel(
    QMap<int, QStandardItem *> &items, bool editable) {

    auto ret = new QStandardItemModel();
    auto rootItem = new QStandardItem();
    rootItem->setText("Root context");
    rootItem->setEditable(false);
    rootItem->setDragEnabled(false);
    rootItem->setDropEnabled(editable);
    rootItem->setData(rootContext()->id(), IDData);
    ret->invisibleRootItem()->appendRow(rootItem);
    items[rootContext()->id()] = rootItem;

    for(auto con : m_contexts) {
        if(items.contains(con->id())) continue;
        auto item = new QStandardItem();

        item->setData(con->id(), IDData);
        item->setText(con->label());
        item->setEditable(editable);
        item->setDragEnabled(editable);
        item->setDropEnabled(editable);

        items[con->id()] = item;
    }
    for(auto con : m_contexts) {
        if(!con->parent()) continue;
        items[con->parent()->id()]->appendRow(items[con->id()]);
    }

    // TODO: sort the elements in the tree

    return ret;
}
Exemple #3
0
	void Plugin::Init (ICoreProxy_ptr proxy)
	{
		Proxy_ = proxy;

#ifdef HAVE_QJSON
		auto di = new QStandardItem ("Digitally Imported");
		di->setData (Media::RadioType::None, Media::RadioItemRole::ItemType);
		di->setEditable (false);
		di->setIcon (QIcon (":/hotstreams/resources/images/di.png"));
		Roots_ ["di"] = di;

		auto sky = new QStandardItem ("SkyFM");
		sky->setData (Media::RadioType::None, Media::RadioItemRole::ItemType);
		sky->setEditable (false);
		sky->setIcon (QIcon (":/hotstreams/resources/images/skyfm.png"));
		Roots_ ["sky"] = sky;
#endif

		auto somafm = new QStandardItem ("SomaFM");
		somafm->setData (Media::RadioType::None, Media::RadioItemRole::ItemType);
		somafm->setEditable (false);
		somafm->setIcon (QIcon (":/hotstreams/resources/images/somafm.png"));
		Roots_ ["somafm"] = somafm;

		auto stealkill = new QStandardItem ("42fm");
		stealkill->setData (Media::RadioType::None, Media::RadioItemRole::ItemType);
		stealkill->setEditable (false);
		stealkill->setIcon (QIcon (":/hotstreams/resources/images/radio.png"));
		Roots_ ["42fm"] = stealkill;
	}
 void DataManagerProperty::setProperty(ossimRefPtr<ossimProperty> property)
 {
    m_property = property.get();
    
    if(m_property.valid())
    {
       setEditable(!m_property->isReadOnly());
    }
    if(column() != 1)
    {
       setEditable(false);
    }
 }
Exemple #5
0
void DepthComboBox::updateEditable(int index)
{
    if ( index == 0 ) {
        // Allow the combo box to be edited
        setEditable(true);
        // Select all of the text
        lineEdit()->selectAll();
        setCursor(Qt::IBeamCursor);
    } else {
        // Depth is the bedrock depth and is uneditable
        setEditable(false);
        unsetCursor();
    }
}
	void StreamListFetcherBase::handleParsed ()
	{
		auto watcher = dynamic_cast<QFutureWatcher<decltype (Parse ({}))>*> (sender ());
		watcher->deleteLater ();

		for (const auto& stream : watcher->result ())
		{
			auto name = stream.Name_;
			if (!stream.Genres_.isEmpty ())
				name += " (" + stream.Genres_.join ("; ") + ")";

			auto tooltip = "<span style=\"white-space: nowrap\">" + stream.Description_;
			if (!stream.DJ_.isEmpty ())
				tooltip += "<br /><em>DJ:</em> " + stream.DJ_;
			tooltip += "</span>";

			auto item = new QStandardItem (name);
			item->setToolTip (tooltip);
			item->setIcon (RadioIcon_);
			item->setData (stream.Name_, StreamItemRoles::PristineName);
			item->setData (Media::RadioType::Predefined, Media::RadioItemRole::ItemType);
			item->setData (stream.URL_, Media::RadioItemRole::RadioID);
			item->setData (stream.PlaylistFormat_, StreamItemRoles::PlaylistFormat);
			item->setEditable (false);
			Root_->appendRow (item);
		}

		deleteLater ();
	}
ActionComboBoxWidget::ActionComboBoxWidget(QWidget *parent) : ComboBoxWidget(parent),
    m_filterLineEdit(nullptr),
    m_wasPopupVisible(false)
{
    setEditable(true);

    lineEdit()->hide();

    getView()->viewport()->parentWidget()->installEventFilter(this);

    QStandardItemModel *model(new QStandardItemModel(this));
    const QVector<ActionsManager::ActionDefinition> definitions(ActionsManager::getActionDefinitions());

    for (int i = 0; i < definitions.count(); ++i)
    {
        QStandardItem *item(new QStandardItem(QCoreApplication::translate("actions", (definitions.at(i).description.isEmpty() ? definitions.at(i).text : definitions.at(i).description).toUtf8().constData())));
        item->setData(QColor(Qt::transparent), Qt::DecorationRole);
        item->setData(definitions.at(i).identifier, Qt::UserRole);
        item->setToolTip(ActionsManager::getActionName(definitions.at(i).identifier));
        item->setFlags(item->flags() | Qt::ItemNeverHasChildren);

        if (!definitions.at(i).icon.isNull())
        {
            item->setIcon(definitions.at(i).icon);
        }

        model->appendRow(item);
    }

    setModel(model);
    setCurrentIndex(-1);
}
ActionComboBoxWidget::ActionComboBoxWidget(QWidget *parent) : ComboBoxWidget(parent),
	m_filterLineEditWidget(nullptr),
	m_model(new QStandardItemModel(this)),
	m_wasPopupVisible(false)
{
	setEditable(true);

	lineEdit()->hide();

	getView()->viewport()->parentWidget()->installEventFilter(this);

	const QVector<ActionsManager::ActionDefinition> definitions(ActionsManager::getActionDefinitions());

	for (int i = 0; i < definitions.count(); ++i)
	{
		if (!definitions.at(i).flags.testFlag(ActionsManager::ActionDefinition::IsDeprecatedFlag) && !definitions.at(i).flags.testFlag(ActionsManager::ActionDefinition::RequiresParameters))
		{
			addDefinition(definitions.at(i));
		}
	}

	m_model->setSortRole(IdentifierRole);

	setModel(m_model);
	setCurrentIndex(-1);
}
Exemple #9
0
AlbumItem::AlbumItem()
    : QStandardItem()
    , m_iconSize( 40 )
    , m_showArtist( false )
{
    setEditable( false );
}
	void FotoBilderAccount::handleGotAlbums ()
	{
		QDomDocument document;
		const QByteArray& content = CreateDomDocumentFromReply (qobject_cast<QNetworkReply*> (sender ()),
				document);
		if (content.isEmpty ())
			return;

		if (IsErrorReply (content))
			return;

		if (auto rc = CollectionsModel_->rowCount ())
			CollectionsModel_->removeRows (0, rc);
		CollectionsModel_->setHorizontalHeaderLabels ({ tr ("Name") });

		AllPhotosItem_ = new QStandardItem (tr ("All photos"));
		AllPhotosItem_->setData (ItemType::AllPhotos, CollectionRole::Type);
		AllPhotosItem_->setEditable (false);
		CollectionsModel_->appendRow (AllPhotosItem_);

		//TODO enable due to upload issues
		const auto& albums = ParseGetGalsRequest (document);
		for (const auto& album : albums)
		{
			auto item = new QStandardItem (album.Title_);
			item->setData (ItemType::Collection, CollectionRole::Type);
			item->setEditable (false);
			item->setData (album.ID_, CollectionRole::ID);
			CollectionsModel_->appendRow (item);
			Id2AlbumItem_ [album.ID_] = item;
		}

		RequestPictures ();
	}
QtVCardPhotoAndNameFields::QtVCardPhotoAndNameFields(QWidget* parent) :
    QWidget(parent),
    ui(new Ui::QtVCardPhotoAndNameFields) {
    ui->setupUi(this);
    ui->lineEditPREFIX->hide();
    ui->lineEditMIDDLE->hide();
    ui->lineEditSUFFIX->hide();
    ui->lineEditFN->hide();
    ui->lineEditNICKNAME->hide();
    ui->labelFN->hide();
    ui->labelNICKNAME->hide();
    ui->labelFULLNAME->hide();

#if QT_VERSION >= 0x040700
    ui->lineEditFN->setPlaceholderText(tr("Formatted Name"));
    ui->lineEditNICKNAME->setPlaceholderText(tr("Nickname"));
    ui->lineEditPREFIX->setPlaceholderText(tr("Prefix"));
    ui->lineEditGIVEN->setPlaceholderText(tr("Given Name"));
    ui->lineEditMIDDLE->setPlaceholderText(tr("Middle Name"));
    ui->lineEditFAMILY->setPlaceholderText(tr("Last Name"));
    ui->lineEditSUFFIX->setPlaceholderText(tr("Suffix"));
#endif

    setEditable(false);
}
CaptureFilterCombo::CaptureFilterCombo(QWidget *parent, bool plain) :
    QComboBox(parent),
    cf_edit_(NULL)
{
    cf_edit_ = new CaptureFilterEdit(this, plain);

    setEditable(true);
    // Enabling autocompletion here gives us two simultaneous completions:
    // Inline (highlighted text) for entire filters, handled here and popup
    // completion for fields handled by CaptureFilterEdit.
    setAutoCompletion(false);
    setLineEdit(cf_edit_);
    setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
    setInsertPolicy(QComboBox::NoInsert);
    setAccessibleName(tr("Capture filter selector"));
    setStyleSheet(
            "QComboBox {"
#ifdef Q_OS_MAC
            "  border: 1px solid gray;"
#else
            "  border: 1px solid palette(shadow);"
#endif
            "  border-radius: 3px;"
            "  padding: 0px 0px 0px 0px;"
            "  margin-left: 0px;"
            "  min-width: 20em;"
            " }"

            "QComboBox::drop-down {"
            "  subcontrol-origin: padding;"
            "  subcontrol-position: top right;"
            "  width: 16px;"
            "  border-left-width: 0px;"
            " }"

            "QComboBox::down-arrow {"
            "  image: url(:/icons/toolbar/14x14/x-filter-dropdown.png);"
            " }"

            "QComboBox::down-arrow:on { /* shift the arrow when popup is open */"
            "  top: 1px;"
            "  left: 1px;"
            "}"
            );

    connect(this, SIGNAL(interfacesChanged()), cf_edit_, SLOT(checkFilter()));
    connect(cf_edit_, SIGNAL(pushFilterSyntaxStatus(const QString&)),
            this, SIGNAL(pushFilterSyntaxStatus(const QString&)));
    connect(cf_edit_, SIGNAL(popFilterSyntaxStatus()),
            this, SIGNAL(popFilterSyntaxStatus()));
    connect(cf_edit_, SIGNAL(captureFilterSyntaxChanged(bool)),
            this, SIGNAL(captureFilterSyntaxChanged(bool)));
    connect(cf_edit_, SIGNAL(startCapture()), this, SIGNAL(startCapture()));
    connect(cf_edit_, SIGNAL(startCapture()), this, SLOT(saveAndRebuildFilterList()));
    connect(wsApp, SIGNAL(appInitialized()), this, SLOT(rebuildFilterList()));
    connect(wsApp, SIGNAL(preferencesChanged()), this, SLOT(rebuildFilterList()));

    rebuildFilterList();
    clearEditText();
}
Exemple #13
0
FlagsComboBox::FlagsComboBox(QWidget *parent):
    QComboBox(parent)
{
    setModel(new QStandardItemModel(this));
    setEditable(false);
    setItemDelegate(new QStyledItemDelegate(this));

    auto item = new QStandardItem;
    item->setFlags(Qt::ItemIsEnabled);
    standardItemModel()->appendRow(item);

    connect(view(), &QListView::pressed, this, [this](const QModelIndex &index)
    {
        auto item = standardItemModel()->itemFromIndex(index);

        if(!(item->flags() & Qt::ItemIsUserCheckable))
            return;

        if(item->checkState() == Qt::Checked)
            item->setCheckState(Qt::Unchecked);
        else
            item->setCheckState(Qt::Checked);
    });

    connect(standardItemModel(), &QStandardItemModel::dataChanged, this, [this]()
    {
        updateText();

        emit flagsChanged(flags());
    });
}
Exemple #14
0
QtVCardWidget::QtVCardWidget(QWidget* parent) :
    QWidget(parent),
    ui(new ::Ui::QtVCardWidget) {
    ui->setupUi(this);

    ui->cardFields->setColumnStretch(0,0);
    ui->cardFields->setColumnStretch(1,0);
    ui->cardFields->setColumnStretch(2,2);
    ui->cardFields->setColumnStretch(3,1);
    ui->cardFields->setColumnStretch(4,2);
    menu = new QMenu(this);

    toolButton = new QToolButton(this);
    toolButton->setText(tr("Add Field"));
    toolButton->setArrowType(Qt::NoArrow);
    toolButton->setAutoRaise(false);
    toolButton->setPopupMode(QToolButton::InstantPopup);
    toolButton->hide();
    toolButton->setMenu(menu);

    addFieldType(menu, std::make_shared<QtVCardInternetEMailField::FieldInfo>());
    addFieldType(menu, std::make_shared<QtVCardTelephoneField::FieldInfo>());
    addFieldType(menu, std::make_shared<QtVCardAddressField::FieldInfo>());
    addFieldType(menu, std::make_shared<QtVCardAddressLabelField::FieldInfo>());
    addFieldType(menu, std::make_shared<QtVCardBirthdayField::FieldInfo>());
    addFieldType(menu, std::make_shared<QtVCardJIDField::FieldInfo>());
    addFieldType(menu, std::make_shared<QtVCardDescriptionField::FieldInfo>());
    addFieldType(menu, std::make_shared<QtVCardRoleField::FieldInfo>());
    addFieldType(menu, std::make_shared<QtVCardTitleField::FieldInfo>());
    addFieldType(menu, std::make_shared<QtVCardOrganizationField::FieldInfo>());
    addFieldType(menu, std::make_shared<QtVCardURLField::FieldInfo>());

    setEditable(false);
    setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
}
AutocompletingComboBox::AutocompletingComboBox(QWidget* parent) : QComboBox(parent) {
	setEditable(true);
	setInsertPolicy(QComboBox::NoInsert);
	completer()->setCompletionMode(QCompleter::PopupCompletion);

	connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(resetColor()));
}
Exemple #16
0
QString ComboBox::handleDCOP(int function, const QStringList& args)
{
  switch (function) {
    case DCOP::text:
      return currentText();
    case DCOP::setText:
      setWidgetText(args[0]);
      break;
    case DCOP::selection:
      return currentText();
    case DCOP::currentItem:
      return QString::number(currentItem());
    case DCOP::setCurrentItem:
      setCurrentItem(args[0].toUInt());
      break;
    case DCOP::item:
    {
      int i = args[0].toInt();
      if (i >= 0 && i < count()) 
        return text(i);
      break;
    }
    case DCOP::removeItem:
      removeItem(args[0].toInt());
      break;
    case DCOP::insertItem:
      insertItem(args[0], args[1].toInt());
      break;
    case DCOP::insertItems:
      insertStringList(QStringList::split("\n", args[0]), args[1].toInt());
      break;
    case DCOP::addUniqueItem:
      for (int i=0; i<count(); i++)
        if (text(i) == args[0])
          return QString();
      insertItem(args[0]);
      break;
    case DCOP::clear:
      clear();
      break;
    case DCOP::count:
      return QString::number(count());
    case DCOP::setSelection:
    {
      for (int i = 0; i < count(); i++)
        if (text(i) == args[0])
        {
          setCurrentItem(i);
          break;
        }
      break;
    }
    case DCOP::setEditable:
      setEditable(args[0] != "false" && args[0] != "0");
      break;
    default:
      return KommanderWidget::handleDCOP(function, args);
  }
  return QString();
}
Exemple #17
0
//-----------------------------------------------------------------------------
// Function: ReferenceSelector::ReferenceSelector()
//-----------------------------------------------------------------------------
ReferenceSelector::ReferenceSelector(QWidget *parent):
QComboBox(parent)
{
	setEditable(false);

	connect(this, SIGNAL(currentIndexChanged(int)),	this, SLOT(onIndexChange(int)), Qt::UniqueConnection);
}
Exemple #18
0
int QwtCounter::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: buttonReleased((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 1: valueChanged((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 2: btnReleased(); break;
        case 3: btnClicked(); break;
        case 4: textChanged(); break;
        }
        _id -= 5;
    }
#ifndef QT_NO_PROPERTIES
      else if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< int*>(_v) = numButtons(); break;
        case 1: *reinterpret_cast< double*>(_v) = step(); break;
        case 2: *reinterpret_cast< double*>(_v) = minVal(); break;
        case 3: *reinterpret_cast< double*>(_v) = maxVal(); break;
        case 4: *reinterpret_cast< int*>(_v) = stepButton1(); break;
        case 5: *reinterpret_cast< int*>(_v) = stepButton2(); break;
        case 6: *reinterpret_cast< int*>(_v) = stepButton3(); break;
        case 7: *reinterpret_cast< double*>(_v) = value(); break;
        case 8: *reinterpret_cast< bool*>(_v) = editable(); break;
        }
        _id -= 9;
    } else if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: setNumButtons(*reinterpret_cast< int*>(_v)); break;
        case 1: setStep(*reinterpret_cast< double*>(_v)); break;
        case 2: setMinValue(*reinterpret_cast< double*>(_v)); break;
        case 3: setMaxValue(*reinterpret_cast< double*>(_v)); break;
        case 4: setStepButton1(*reinterpret_cast< int*>(_v)); break;
        case 5: setStepButton2(*reinterpret_cast< int*>(_v)); break;
        case 6: setStepButton3(*reinterpret_cast< int*>(_v)); break;
        case 7: setValue(*reinterpret_cast< double*>(_v)); break;
        case 8: setEditable(*reinterpret_cast< bool*>(_v)); break;
        }
        _id -= 9;
    } else if (_c == QMetaObject::ResetProperty) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 9;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
Exemple #19
0
MOTableView::MOTableView(QWidget* parent):QTableView(parent)
{

    //_view->installEventFilter(this);
    installEventFilter(this);
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
    horizontalHeader()->setSectionResizeMode(QHeaderView::Interactive);
#else
    horizontalHeader()->setResizeMode(QHeaderView::Interactive);
#endif
    verticalHeader()->hide();

    //editable ?
    setEditable(true);

    // context menu
    _actionCopy = new QAction("Copy", this);
    connect(_actionCopy,SIGNAL(triggered()),this, SLOT(onCopyAsked()));
    _actionCopy->setShortcut(QKeySequence::Copy);
    _actionCopy->setShortcutContext(Qt::WidgetShortcut);
    this->addAction(_actionCopy);
    _actionPaste = new QAction("Paste", this);
    connect(_actionPaste,SIGNAL(triggered()),this, SLOT(onPasteAsked()));
    _actionPaste->setShortcut(QKeySequence::Paste);
    _actionPaste->setShortcutContext(Qt::WidgetShortcut);
    this->addAction(_actionPaste);

    this->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(this,SIGNAL(customContextMenuRequested(const QPoint &)),
            this,SLOT(contextualMenu(const QPoint &)));


}
SearchWidget::SearchWidget(Window *window, QWidget *parent) : QComboBox(parent),
	m_window(NULL),
	m_completer(new QCompleter(this)),
	m_suggester(NULL),
	m_lastValidIndex(0),
	m_isIgnoringActivation(false),
	m_isPopupUpdated(false),
	m_shouldSelectAllOnRelease(false),
	m_wasPopupVisible(false)
{
	m_completer->setCaseSensitivity(Qt::CaseInsensitive);
	m_completer->setCompletionMode(QCompleter::PopupCompletion);
	m_completer->setCompletionRole(Qt::DisplayRole);

	setEditable(true);
	setMinimumWidth(100);
	setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
	setItemDelegate(new SearchDelegate(this));
	setModel(SearchesManager::getSearchEnginesModel());
	setInsertPolicy(QComboBox::NoInsert);
	optionChanged(QLatin1String("Search/SearchEnginesSuggestions"), SettingsManager::getValue(QLatin1String("Search/SearchEnginesSuggestions")));

	lineEdit()->setCompleter(m_completer);
	lineEdit()->setDragEnabled(true);
	lineEdit()->setStyleSheet(QLatin1String("QLineEdit {background:transparent;}"));
	lineEdit()->installEventFilter(this);

	ToolBarWidget *toolBar = qobject_cast<ToolBarWidget*>(parent);

	if (toolBar && toolBar->getIdentifier() != ToolBarsManager::NavigationBar)
	{
		connect(toolBar, SIGNAL(windowChanged(Window*)), this, SLOT(setWindow(Window*)));
	}
void QtPropertyItem::ApplyDataFlags()
{
	if(NULL != itemData)
	{
		int dataFlags = itemData->GetFlags();

		if(dataFlags & QtPropertyData::FLAG_IS_CHECKABLE)
		{
			setCheckable(true);
			if(itemData->GetValue().toBool())
			{
				setCheckState(Qt::Checked);
			}
		}

		if(dataFlags & QtPropertyData::FLAG_IS_DISABLED)
		{
			setEnabled(false);
		}

		if(dataFlags & QtPropertyData::FLAG_IS_NOT_EDITABLE)
		{
			setEditable(false);
		}
	}
}
KoZoomAction::KoZoomAction( KoZoomMode::Modes zoomModes, const QString& text, QObject *parent)
    : QSelectAction(text, parent)
    ,d(new Private)
{
    d->zoomModes = zoomModes;
    d->slider = 0;
    d->input = 0;
    d->specialButtons = 0;
    setIcon(koIcon("zoom-original"));
    setEditable( true );
    setMaxComboViewCount( 15 );

    d->sliderLookup[0] = KoZoomMode::minimumZoom();
    d->sliderLookup[32] = KoZoomMode::maximumZoom();

    int steps = 32;
    int halfSteps = steps / 2;
    qreal zoomStep = pow(1.0 / KoZoomMode::minimumZoom(), 1.0/halfSteps);
    for(int i = 1; i < steps; ++i) {
        d->sliderLookup[i] = pow(zoomStep, i - halfSteps);
    }

    d->effectiveZoom = 1.0;
    regenerateItems(d->effectiveZoom, true);

    connect( this, SIGNAL( triggered( const QString& ) ), SLOT( triggered( const QString& ) ) );
}
Exemple #23
0
EncodingComboBox::EncodingComboBox(QWidget *parent)
: QComboBox(parent) {
	enc = QStringList() << "UTF-8" << "Unicode"
			<< tr("Western European Languages") + " (CP1252)"
			<< tr("Western European Languages With Euro") + " (ISO-8859-15)"
			<< tr("Slavic/Central European Languages") + " (ISO-8859-2)"
			<< tr("Slavic/Central European Windows") + " (CP1250)"
			<< tr("Esperanto, Galician, Maltese, Turkish") + " (ISO-8859-3)"
			<< tr("Old Baltic Charset") + " (ISO-8859-4)"
			<< tr("Cyrillic") + " (ISO-8859-5)"
			<< tr("Cyrillic Windows") + " (CP1251)"
			<< tr("Arabic") + " (ISO-8859-6)"
			<< tr("Modern Greek") + " (ISO-8859-7)"
			<< tr("Turkish") + " (ISO-8859-9)"
			<< tr("Baltic") + " (ISO-8859-13)"
			<< tr("Celtic") + " (ISO-8859-14)"
			<< tr("Hebrew Charset") + " (ISO-8859-8)"
			<< tr("Russian") + " (KOI8-R)"
			<< tr("Ukrainian, Belarusian") + " (KOI8-U/RU)"
			<< tr("Simplified Chinese Charset") + " (CP936)"
			<< tr("Traditional Chinese Charset") + " (BIG5)"
			<< tr("Japanese Charset") + " (SHIFT-JIS)"
			<< tr("Korean Charset") + " (CP949)"
			<< tr("Thai Charset") + " (CP874)";
	addItems(enc);
	setEditable(true);
}
Exemple #24
0
AddressWidget::AddressWidget(Window *window, QWidget *parent) : ComboBoxWidget(parent),
	m_window(nullptr),
	m_lineEdit(new LineEditWidget(this)),
	m_completionModel(new AddressCompletionModel(this)),
	m_completionView(nullptr),
	m_visibleView(nullptr),
	m_bookmarkLabel(nullptr),
	m_feedsLabel(nullptr),
	m_loadPluginsLabel(nullptr),
	m_urlIconLabel(nullptr),
	m_completionModes(NoCompletionMode),
	m_hints(WindowsManager::DefaultOpen),
	m_removeModelTimer(0),
	m_isHistoryDropdownEnabled(SettingsManager::getValue(SettingsManager::AddressField_EnableHistoryDropdownOption).toBool()),
	m_isNavigatingCompletion(false),
	m_isUsingSimpleMode(false),
	m_wasPopupVisible(false)
{
	ToolBarWidget *toolBar(qobject_cast<ToolBarWidget*>(parent));

	if (!toolBar)
	{
		m_isUsingSimpleMode = true;
	}

	setEditable(true);
	setLineEdit(m_lineEdit);
	setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
	setMinimumWidth(100);
	setItemDelegate(new AddressDelegate(AddressDelegate::HistoryMode, this));
	setInsertPolicy(QComboBox::NoInsert);
	setMouseTracking(true);
	setWindow(window);
	optionChanged(SettingsManager::AddressField_CompletionModeOption, SettingsManager::getValue(SettingsManager::AddressField_CompletionModeOption));
	optionChanged(SettingsManager::AddressField_DropActionOption, SettingsManager::getValue(SettingsManager::AddressField_DropActionOption));
	optionChanged(SettingsManager::AddressField_SelectAllOnFocusOption, SettingsManager::getValue(SettingsManager::AddressField_SelectAllOnFocusOption));

	m_lineEdit->setStyleSheet(QLatin1String("QLineEdit {background:transparent;}"));
	m_lineEdit->installEventFilter(this);

	view()->installEventFilter(this);
	view()->viewport()->setAttribute(Qt::WA_Hover);
	view()->viewport()->setMouseTracking(true);
	view()->viewport()->installEventFilter(this);

	if (toolBar)
	{
		optionChanged(SettingsManager::AddressField_ShowBookmarkIconOption, SettingsManager::getValue(SettingsManager::AddressField_ShowBookmarkIconOption));
		optionChanged(SettingsManager::AddressField_ShowFeedsIconOption, SettingsManager::getValue(SettingsManager::AddressField_ShowFeedsIconOption));
		optionChanged(SettingsManager::AddressField_ShowUrlIconOption, SettingsManager::getValue(SettingsManager::AddressField_ShowUrlIconOption));

		m_lineEdit->setPlaceholderText(tr("Enter address or search…"));

		connect(SettingsManager::getInstance(), SIGNAL(valueChanged(int,QVariant)), this, SLOT(optionChanged(int,QVariant)));

		if (toolBar->getIdentifier() != ToolBarsManager::NavigationBar)
		{
			connect(toolBar, SIGNAL(windowChanged(Window*)), this, SLOT(setWindow(Window*)));
		}
	}
ActionComboBoxWidget::ActionComboBoxWidget(QWidget *parent) : QComboBox(parent),
	m_view(new ItemViewWidget(this)),
	m_filterLineEdit(NULL),
	m_wasPopupVisible(false)
{
	setEditable(true);
	setView(m_view);
	setItemDelegate(new ItemDelegate(this));

	m_view->setHeaderHidden(true);

	lineEdit()->hide();

	view()->viewport()->parentWidget()->installEventFilter(this);

	QStandardItemModel *model = new QStandardItemModel(this);
	const QVector<ActionDefinition> definitions = ActionsManager::getActionDefinitions();

	for (int i = 0; i < definitions.count(); ++i)
	{
		QStandardItem *item = new QStandardItem(definitions.at(i).icon, QCoreApplication::translate("actions", (definitions.at(i).description.isEmpty() ? definitions.at(i).text : definitions.at(i).description).toUtf8().constData()));
		item->setData(definitions.at(i).identifier, Qt::UserRole);
		item->setToolTip(ActionsManager::getActionName(definitions.at(i).identifier));
		item->setFlags(item->flags() | Qt::ItemNeverHasChildren);

		model->appendRow(item);
	}

	setModel(model);
	setCurrentIndex(-1);
}
Exemple #26
0
DrivesCombo::DrivesCombo(QWidget* parent, const char* name)
 : KComboBox(parent, name)
{
  setEditable(true);

  QFile file("/etc/fstab");
  if (file.open(IO_ReadOnly))
  {
    QTextStream stream(&file);
    QString line;
    QStringList drives;

    while (!stream.eof())
    {
      line = stream.readLine();
      if (line.contains("cdfss"))
      {
        kdDebug() << "DrivesCombo: found disc drive: " << line.section(' ', 0, 0) << endl;
	drives.append(line.section(' ', 0, 0));
      }
    }
    insertStringList(drives);
  }
  file.close();
}
void LayersMgrWidget::onLayerDown(wxCommandEvent& event)
{
	int index = getEditLayerIndex();

	LayerWidget* layer = m_layers[index];
	m_layers[index] = m_layers[index - 1];
	m_layers[index - 1] = layer;

	m_layersSizer->Remove(m_layers.size() - 1 - index);
	m_layersSizer->Insert(m_layers.size() - 1 - (index - 1), layer);

	if (index - 1 == 0)
	{
		m_btnDown->Enable(false);
		m_btnUp->Enable(true);

		// debug fix
		setEditable(layer);
	}
	else
	{
		m_btnDown->Enable(true);
		m_btnUp->Enable(true);
	}

	Layout();
	Refresh();
}
Exemple #28
0
YaLabel::YaLabel(QWidget* parent)
	: M11EditableLabel(parent)
	, effectiveWidth_(-1)
	, isEventNotifierLabel_(false)
{
	setOpenExternalLinks(false);
	setEditable(false);
}
Exemple #29
0
ArrowChooser::ArrowChooser(QWidget* pa, bool direction)  : QComboBox(pa)
{
	setEditable(false);
	clear();
	setIconSize(QSize(22, 22));
	addItem(CommonStrings::tr_None);
	arrowDirection = direction;
}
		CtrlrTextPropLabel (CtrlrTextPropertyComponent& owner_, const int maxChars_, const bool isMultiline_)
			: Label (String::empty, String::empty),
				owner (owner_), maxChars (maxChars_), isMultiline (isMultiline_)
		{
	        setEditable (true, true, false);
			setColour (backgroundColourId, Colours::white);
			setColour (outlineColourId, findColour (ComboBox::outlineColourId));
		}