void SmileyCategoryListType::AddAccountAsCategory(PROTOACCOUNT *acc, const CMString &defaultFile)
{
if (Proto_IsAccountEnabled(acc) && acc->szProtoName && IsSmileyProto(acc->szModuleName)) {
CMString displayName(acc->tszAccountName ? acc->tszAccountName : _A2T(acc->szModuleName));
CMString PhysProtoName, paths;
DBVARIANT dbv;
if (db_get_ts(NULL, acc->szModuleName, "AM_BaseProto", &dbv) == 0) {
PhysProtoName = _T("AllProto");
PhysProtoName += dbv.ptszVal;
db_free(&dbv);
}
if (!PhysProtoName.IsEmpty())
paths = g_SmileyCategories.GetSmileyCategory(PhysProtoName) ? g_SmileyCategories.GetSmileyCategory(PhysProtoName)->GetFilename() : _T("");
if (paths.IsEmpty()) {
const char *packnam = acc->szProtoName;
if (mir_strcmp(packnam, "JABBER") == 0)
packnam = "JGMail";
else if (strstr(packnam, "SIP") != NULL)
packnam = "MSN";
char path[MAX_PATH];
mir_snprintf(path, "Smileys\\nova\\%s.msl", packnam);
paths = _A2T(path);
CMString patha;
pathToAbsolute(paths, patha);
if (_taccess(patha.c_str(), 0) != 0)
paths = defaultFile;
}
CMString tname(_A2T(acc->szModuleName));
AddCategory(tname, displayName, acc->bIsVirtual ? smcVirtualProto : smcProto, paths);
}
}
void BaseCheckoutWizard::runWizard(const QString &path, QWidget *parent, const QString & /*platform*/, const QVariantMap &extraValues)
{
Q_UNUSED(extraValues)
// Create dialog and launch
d->parameterPages = createParameterPages(path);
Internal::CheckoutWizardDialog dialog(d->parameterPages, parent);
d->dialog = &dialog;
connect(&dialog, SIGNAL(progressPageShown()), this, SLOT(slotProgressPageShown()));
dialog.setWindowTitle(displayName());
if (dialog.exec() != QDialog::Accepted)
return;
// Now try to find the project file and open
const QString checkoutPath = d->checkoutPath;
d->clear();
QString errorMessage;
const QString projectFile = openProject(checkoutPath, &errorMessage);
if (projectFile.isEmpty()) {
QMessageBox msgBox(QMessageBox::Warning, tr("Cannot Open Project"),
tr("Failed to open project in '%1'.").arg(QDir::toNativeSeparators(checkoutPath)));
msgBox.setDetailedText(errorMessage);
msgBox.exec();
}
}
void DeadCodeFinder::dumpResults()
{
for (int i = 0; i < m_fileSet->size(); ++i) {
auto file = m_fileSet->file(i);
// this only makes sense for libraries
if (file->header()->type() == ET_EXEC)
continue;
bool skip = false;
foreach (const auto &excludePrefix, m_excludePrefixes) {
if (file->fileName().startsWith(excludePrefix)) {
skip = true;
break;
}
}
if (skip)
continue;
std::cout << "Unreferenced exported symbols in " << qPrintable(file->displayName()) << ":" << std::endl;
dumpResultsForFile(file);
std::cout << std::endl;
}
}
bool CursorInfo::isValid(const Location &location) const
{
const Path p = location.path();
bool ret = false;
FILE *f = fopen(p.constData(), "r");
if (f && fseek(f, location.offset(), SEEK_SET) != -1) {
const String display = displayName();
// int paren = symbolName.indexOf('(');
// int bracket = symbolName.indexOf('<');
// int end = symbolName.size();
// if (paren != -1) {
// if (bracket != -1) {
// end = std::min(paren, bracket);
// } else {
// end = paren;
// }
// } else if (bracket != -1) {
// end = bracket;
// }
// int start = end;
// while (start > 0 && RTags::isSymbol(symbolName.at(start - 1)))
// --start;
char buf[1024];
const int length = display.size();
if (length && length < static_cast<int>(sizeof(buf)) - 1 && fread(buf, std::min<int>(length, sizeof(buf) - 1), 1, f)) {
buf[length] = '\0';
ret = display == buf;
if (!ret) {
error("Different:\n[%s]\n[%s]", buf, display.constData());
}
}
}
if (f)
fclose(f);
return ret;
}
analysis::SamplingAlgorithm SamplingAlgorithmRecord_Impl::samplingAlgorithm() const {
analysis::SamplingAlgorithmOptions opts(m_sampleType,
m_rngType,
options());
OptionalFileReference restartFile, outFile;
OptionalFileReferenceRecord ofr = restartFileReferenceRecord();
if (ofr) {
restartFile = ofr->fileReference();
}
ofr = outFileReferenceRecord();
if (ofr) {
outFile = ofr->fileReference();
}
boost::optional<runmanager::Job> job;
if (this->jobUUID()){
try {
job = this->projectDatabase().runManager().getJob(this->jobUUID().get());
}
catch (const std::exception& e) {
LOG(Error, "Job " << toString(this->jobUUID().get()) << " not found in RunManager. "
<< e.what());
}
}
return analysis::SamplingAlgorithm(handle(),
uuidLast(),
displayName(),
description(),
complete(),
failed(),
iter(),
opts,
restartFile,
outFile,
job);
}
QString QASActor::displayNameOrWebFinger() const {
if (displayName().isEmpty())
return webFinger();
return displayName();
}
void DirDef::writeDocumentation(OutputList &ol)
{
ol.pushGeneratorState();
QCString shortTitle=theTranslator->trDirReference(m_shortName);
QCString title=theTranslator->trDirReference(m_dispName);
startFile(ol,getOutputFileBase(),name(),title,HLI_None,TRUE);
// write navigation path
writeNavigationPath(ol);
ol.endQuickIndices();
ol.startContents();
startTitle(ol,getOutputFileBase());
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
ol.parseText(shortTitle);
ol.enableAll();
ol.disable(OutputGenerator::Html);
ol.parseText(title);
ol.popGeneratorState();
endTitle(ol,getOutputFileBase(),title);
if (!Config_getString("GENERATE_TAGFILE").isEmpty())
{
Doxygen::tagFile << " <compound kind=\"dir\">" << endl;
Doxygen::tagFile << " <name>" << convertToXML(displayName()) << "</name>" << endl;
Doxygen::tagFile << " <path>" << convertToXML(name()) << "</path>" << endl;
Doxygen::tagFile << " <filename>" << convertToXML(getOutputFileBase()) << Doxygen::htmlFileExtension << "</filename>" << endl;
}
//---------------------------------------- start flexible part -------------------------------
QListIterator<LayoutDocEntry> eli(
LayoutDocManager::instance().docEntries(LayoutDocManager::Directory));
LayoutDocEntry *lde;
for (eli.toFirst();(lde=eli.current());++eli)
{
switch (lde->kind())
{
case LayoutDocEntry::BriefDesc:
writeBriefDescription(ol);
break;
case LayoutDocEntry::DirGraph:
writeDirectoryGraph(ol);
break;
case LayoutDocEntry::MemberDeclStart:
startMemberDeclarations(ol);
break;
case LayoutDocEntry::DirSubDirs:
writeSubDirList(ol);
break;
case LayoutDocEntry::DirFiles:
writeFileList(ol);
break;
case LayoutDocEntry::MemberDeclEnd:
endMemberDeclarations(ol);
break;
case LayoutDocEntry::DetailedDesc:
{
LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
writeDetailedDescription(ol,ls->title);
}
break;
case LayoutDocEntry::ClassIncludes:
case LayoutDocEntry::ClassInheritanceGraph:
case LayoutDocEntry::ClassNestedClasses:
case LayoutDocEntry::ClassCollaborationGraph:
case LayoutDocEntry::ClassAllMembersLink:
case LayoutDocEntry::ClassUsedFiles:
case LayoutDocEntry::NamespaceNestedNamespaces:
case LayoutDocEntry::NamespaceClasses:
case LayoutDocEntry::FileClasses:
case LayoutDocEntry::FileNamespaces:
case LayoutDocEntry::FileIncludes:
case LayoutDocEntry::FileIncludeGraph:
case LayoutDocEntry::FileIncludedByGraph:
case LayoutDocEntry::FileSourceLink:
case LayoutDocEntry::GroupClasses:
case LayoutDocEntry::GroupNamespaces:
case LayoutDocEntry::GroupDirs:
case LayoutDocEntry::GroupNestedGroups:
case LayoutDocEntry::GroupFiles:
case LayoutDocEntry::GroupGraph:
case LayoutDocEntry::GroupPageDocs:
case LayoutDocEntry::AuthorSection:
case LayoutDocEntry::MemberGroups:
case LayoutDocEntry::MemberDecl:
case LayoutDocEntry::MemberDef:
case LayoutDocEntry::MemberDefStart:
case LayoutDocEntry::MemberDefEnd:
err("Internal inconsistency: member %d should not be part of "
"LayoutDocManager::Directory entry list\n",lde->kind());
break;
}
}
//---------------------------------------- end flexible part -------------------------------
if (!Config_getString("GENERATE_TAGFILE").isEmpty())
{
writeDocAnchorsToTagFile();
Doxygen::tagFile << " </compound>" << endl;
}
endFile(ol);
ol.popGeneratorState();
}
void AccountsListDelegate::updateItemWidgets(const QList<QWidget *> widgets, const QStyleOptionViewItem &option, const QPersistentModelIndex &index) const
{
// draws:
// AccountName
// Checkbox | Icon | | ConnectionIcon | ConnectionState
// errorMessage
if (!index.isValid()) {
return;
}
Q_ASSERT(widgets.size() == 6);
// Get the widgets
QCheckBox* checkbox = qobject_cast<QCheckBox*>(widgets.at(0));
ChangeIconButton* changeIconButton = qobject_cast<ChangeIconButton*>(widgets.at(1));
QLabel *statusTextLabel = qobject_cast<QLabel*>(widgets.at(2));
QLabel *statusIconLabel = qobject_cast<QLabel*>(widgets.at(3));
EditDisplayNameButton *displayNameButton = qobject_cast<EditDisplayNameButton*>(widgets.at(4));
QLabel *connectionErrorLabel = qobject_cast<QLabel*>(widgets.at(5));
Q_ASSERT(checkbox);
Q_ASSERT(changeIconButton);
Q_ASSERT(statusTextLabel);
Q_ASSERT(statusIconLabel);
Q_ASSERT(displayNameButton);
Q_ASSERT(connectionErrorLabel);
bool isSelected(itemView()->selectionModel()->isSelected(index) && itemView()->hasFocus());
bool isEnabled(index.data(KTp::AccountsListModel::EnabledRole).toBool());
KIcon accountIcon(index.data(Qt::DecorationRole).value<QIcon>());
KIcon statusIcon(index.data(KTp::AccountsListModel::ConnectionStateIconRole).value<QIcon>());
QString statusText(index.data(KTp::AccountsListModel::ConnectionStateDisplayRole).toString());
QString displayName(index.data(Qt::DisplayRole).toString());
QString connectionError(index.data(KTp::AccountsListModel::ConnectionErrorMessageDisplayRole).toString());
Tp::AccountPtr account(index.data(KTp::AccountsListModel::AccountRole).value<Tp::AccountPtr>());
if (!account->isEnabled()) {
connectionError = i18n("Click checkbox to enable");
}
QRect outerRect(0, 0, option.rect.width(), option.rect.height());
QRect contentRect = outerRect.adjusted(m_hpadding,m_vpadding,-m_hpadding,-m_vpadding); //add some padding
// checkbox
if (isEnabled) {
checkbox->setChecked(true);;
checkbox->setToolTip(i18n("Disable account"));
} else {
checkbox->setChecked(false);
checkbox->setToolTip(i18n("Enable account"));
}
int checkboxLeftMargin = contentRect.left();
int checkboxTopMargin = (outerRect.height() - checkbox->height()) / 2;
checkbox->move(checkboxLeftMargin, checkboxTopMargin);
// changeIconButton
changeIconButton->setIcon(accountIcon);
changeIconButton->setAccount(account);
// At the moment (KDE 4.8.1) decorationSize is not passed from KWidgetItemDelegate
// through the QStyleOptionViewItem, therefore we leave default size unless
// the user has a more recent version.
if (option.decorationSize.width() > -1) {
changeIconButton->setButtonIconSize(option.decorationSize.width());
}
int changeIconButtonLeftMargin = checkboxLeftMargin + checkbox->width();
int changeIconButtonTopMargin = (outerRect.height() - changeIconButton->height()) / 2;
changeIconButton->move(changeIconButtonLeftMargin, changeIconButtonTopMargin);
// statusTextLabel
QFont statusTextFont = option.font;
QPalette statusTextLabelPalette = option.palette;
if (isEnabled) {
statusTextLabel->setEnabled(true);
statusTextFont.setItalic(false);
} else {
statusTextLabel->setDisabled(true);
statusTextFont.setItalic(true);
}
if (isSelected) {
statusTextLabelPalette.setColor(QPalette::Text, statusTextLabelPalette.color(QPalette::Active, QPalette::HighlightedText));
}
statusTextLabel->setPalette(statusTextLabelPalette);
statusTextLabel->setFont(statusTextFont);
statusTextLabel->setText(statusText);
statusTextLabel->setFixedSize(statusTextLabel->fontMetrics().boundingRect(statusText).width(),
statusTextLabel->height());
int statusTextLabelLeftMargin = contentRect.right() - statusTextLabel->width();
int statusTextLabelTopMargin = (outerRect.height() - statusTextLabel->height()) / 2;
statusTextLabel->move(statusTextLabelLeftMargin, statusTextLabelTopMargin);
// statusIconLabel
statusIconLabel->setPixmap(statusIcon.pixmap(KIconLoader::SizeSmall));
statusIconLabel->setFixedSize(statusIconLabel->minimumSizeHint());
int statusIconLabelLeftMargin = contentRect.right() - statusTextLabel->width() - statusIconLabel->width() - 6;
int statusIconLabelTopMargin = (outerRect.height() - statusIconLabel->height()) / 2;
statusIconLabel->move(statusIconLabelLeftMargin, statusIconLabelTopMargin);
QRect innerRect = contentRect.adjusted(changeIconButton->geometry().right() - contentRect.left(),
0,
-statusTextLabel->width() - statusIconLabel->width() - 6,
0); // rect containing account name and error message
// displayNameButton
QFont displayNameButtonFont = option.font;
QPalette displayNameButtonPalette = option.palette;
if (isEnabled) {
displayNameButtonPalette.setColor(QPalette::WindowText, displayNameButtonPalette.color(QPalette::Active, QPalette::Text));
displayNameButtonFont.setBold(true);
} else {
displayNameButtonFont.setItalic(true);
// NOTE: Flat QPushButton use WindowText instead of ButtonText for button text color
displayNameButtonPalette.setColor(QPalette::WindowText, displayNameButtonPalette.color(QPalette::Disabled, QPalette::Text));
}
if (isSelected) {
// Account is selected
displayNameButtonPalette.setColor(QPalette::WindowText, displayNameButtonPalette.color(QPalette::Active, QPalette::HighlightedText));
}
displayNameButton->setFont(displayNameButtonFont);
displayNameButton->setPalette(displayNameButtonPalette);
QString displayNameButtonText = displayNameButton->fontMetrics().elidedText(displayName,
Qt::ElideRight,
innerRect.width() - (m_hpadding*2));
displayNameButton->setText(displayNameButtonText);
displayNameButton->setFixedSize(displayNameButton->fontMetrics().boundingRect(displayNameButtonText).width() + (m_hpadding*2),
displayNameButton->minimumSizeHint().height());
displayNameButton->setAccount(account);
int displayNameButtonLeftMargin = innerRect.left();
int displayNameButtonTopMargin = innerRect.top();
displayNameButton->move(displayNameButtonLeftMargin, displayNameButtonTopMargin);
// connectionErrorLabel
QFont connectionErrorLabelFont = option.font;
QPalette connectionErrorLabelPalette = option.palette;
if (isEnabled) {
connectionErrorLabelPalette.setColor(QPalette::WindowText, connectionErrorLabelPalette.color(QPalette::Active, QPalette::Text));
} else {
connectionErrorLabelFont.setItalic(true);
connectionErrorLabelPalette.setColor(QPalette::Text, connectionErrorLabelPalette.color(QPalette::Disabled, QPalette::Text));
}
if (isSelected) {
// Account is selected
connectionErrorLabelPalette.setColor(QPalette::Text, connectionErrorLabelPalette.color(QPalette::Active, QPalette::HighlightedText));
}
connectionErrorLabel->setFont(connectionErrorLabelFont);
connectionErrorLabel->setPalette(connectionErrorLabelPalette);
QString connectionErrorLabelText = connectionErrorLabel->fontMetrics().elidedText(connectionError,
Qt::ElideRight,
innerRect.width() - (m_hpadding*2));
connectionErrorLabel->setText(connectionErrorLabelText);
connectionErrorLabel->setFixedSize(connectionErrorLabel->fontMetrics().boundingRect(connectionErrorLabelText).width(),
displayNameButton->height());
int connectionErrorLabelLeftMargin = innerRect.left() + m_hpadding;
int connectionErrorLabelTopMargin = contentRect.bottom() - displayNameButton->height();
connectionErrorLabel->move(connectionErrorLabelLeftMargin, connectionErrorLabelTopMargin);
}
void TypeConstraint::verifyFail(const Func* func, TypedValue* tv,
int id, bool useStrictTypes) const {
VMRegAnchor _;
std::string name = displayName(func);
auto const givenType = describe_actual_type(tv, isHHType());
if (UNLIKELY(!useStrictTypes)) {
if (auto dt = underlyingDataType()) {
// In non-strict mode we may be able to coerce a type failure. For object
// typehints there is no possible coercion in the failure case, but HNI
// builtins currently only guard on kind not class so the following wil
// generate false positives for objects.
if (*dt != KindOfObject) {
// HNI conversions implicitly unbox references, this behavior is wrong,
// in particular it breaks the way type conversion works for PHP 7
// scalar type hints
if (tv->m_type == KindOfRef) {
auto inner = tv->m_data.pref->var()->asTypedValue();
if (tvCoerceParamInPlace(inner, *dt)) {
tvAsVariant(tv) = tvAsVariant(inner);
return;
}
} else {
if (tvCoerceParamInPlace(tv, *dt)) return;
}
}
}
} else if (UNLIKELY(!func->unit()->isHHFile() &&
!RuntimeOption::EnableHipHopSyntax)) {
// PHP 7 allows for a widening conversion from Int to Float. We still ban
// this in HH files.
if (auto dt = underlyingDataType()) {
if (*dt == KindOfDouble && tv->m_type == KindOfInt64 &&
tvCoerceParamToDoubleInPlace(tv)) {
return;
}
}
}
// Handle return type constraint failures
if (id == ReturnId) {
std::string msg;
if (func->isClosureBody()) {
msg =
folly::format(
"Value returned from {}closure must be of type {}, {} given",
func->isAsync() ? "async " : "",
name,
givenType
).str();
} else {
msg =
folly::format(
"Value returned from {}{} {}() must be of type {}, {} given",
func->isAsync() ? "async " : "",
func->preClass() ? "method" : "function",
func->fullName(),
name,
givenType
).str();
}
if (RuntimeOption::EvalCheckReturnTypeHints >= 2 && !isSoft()) {
raise_return_typehint_error(msg);
} else {
raise_warning_unsampled(msg);
}
return;
}
// Handle implicit collection->array conversion for array parameter type
// constraints
auto c = tvToCell(tv);
if (isArray() && !isSoft() && !func->mustBeRef(id) &&
c->m_type == KindOfObject && c->m_data.pobj->isCollection()) {
// To ease migration, the 'array' type constraint will implicitly cast
// collections to arrays, provided the type constraint is not soft and
// the parameter is not by reference. We raise a notice to let the user
// know that there was a type mismatch and that an implicit conversion
// was performed.
raise_notice(
folly::format(
"Argument {} to {}() must be of type {}, {} given; argument {} was "
"implicitly cast to array",
id + 1, func->fullName(), name, givenType, id + 1
).str()
);
tvCastToArrayInPlace(tv);
return;
}
// Handle parameter type constraint failures
if (isExtended() && isSoft()) {
// Soft extended type hints raise warnings instead of recoverable
// errors, to ease migration.
raise_warning_unsampled(
folly::format(
"Argument {} to {}() must be of type {}, {} given",
id + 1, func->fullName(), name, givenType
).str()
);
} else if (isExtended() && isNullable()) {
raise_typehint_error(
folly::format(
"Argument {} to {}() must be of type {}, {} given",
id + 1, func->fullName(), name, givenType
).str()
);
} else {
auto cls = Unit::lookupClass(m_typeName);
if (cls && isInterface(cls)) {
raise_typehint_error(
folly::format(
"Argument {} passed to {}() must implement interface {}, {} given",
id + 1, func->fullName(), name, givenType
).str()
);
} else {
raise_typehint_error(
folly::format(
"Argument {} passed to {}() must be an instance of {}, {} given",
id + 1, func->fullName(), name, givenType
).str()
);
}
}
}
QString BareMetalGdbCommandsDeployStepWidget::summaryText() const
{
return displayName();
}
void
openCtrl(struct display *d)
{
CtrlRec *cr;
const char *dname;
char *sockdir;
struct sockaddr_un sa;
if (!*fifoDir)
return;
if (d)
cr = &d->ctrl, dname = displayName(d);
else
cr = &ctrl, dname = 0;
if (cr->fd < 0) {
if (mkdir(fifoDir, 0755)) {
if (errno != EEXIST) {
logError("mkdir %\"s failed: %m; no control sockets will be available\n",
fifoDir);
return;
}
} else {
chmod(fifoDir, 0755); /* override umask */
}
sockdir = 0;
strApp(&sockdir, fifoDir, dname ? "/dmctl-" : "/dmctl",
dname, (char *)0);
if (sockdir) {
strApp(&cr->path, sockdir, "/socket", (char *)0);
if (cr->path) {
if (strlen(cr->path) >= sizeof(sa.sun_path)) {
logError("path %\"s too long; control socket will not be available\n",
cr->path);
#ifdef HONORS_SOCKET_PERMS
} else if (mkdir(sockdir, 0700) && errno != EEXIST) {
logError("mkdir %\"s failed: %m; control socket will not be available\n",
sockdir);
} else if (unlink(cr->path) && errno != ENOENT) {
logError("unlink %\"s failed: %m; control socket will not be available\n",
cr->path);
} else {
#else
} else if (unlink(sockdir) && errno != ENOENT) {
logError("unlink %\"s failed: %m; control socket will not be available\n",
sockdir);
} else if (!strApp(&cr->realdir, sockdir, "-XXXXXX", (char *)0)) {
} else if (!mkTempDir(cr->realdir)) {
logError("mkdir %\"s failed: %m; control socket will not be available\n",
cr->realdir);
free(cr->realdir);
cr->realdir = 0;
} else if (symlink(cr->realdir, sockdir)) {
logError("symlink %\"s => %\"s failed: %m; control socket will not be available\n",
sockdir, cr->realdir);
rmdir(cr->realdir);
free(cr->realdir);
cr->realdir = 0;
} else {
chown(sockdir, 0, d ? 0 : fifoGroup);
chmod(sockdir, 0750);
#endif
if ((cr->fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
logError("Cannot create control socket: %m\n");
} else {
sa.sun_family = AF_UNIX;
strcpy(sa.sun_path, cr->path);
if (!bind(cr->fd, (struct sockaddr *)&sa, sizeof(sa))) {
if (!listen(cr->fd, 5)) {
#ifdef HONORS_SOCKET_PERMS
chmod(cr->path, 0660);
if (!d)
chown(cr->path, -1, fifoGroup);
chmod(sockdir, 0755);
#else
chmod(cr->path, 0666);
#endif
registerCloseOnFork(cr->fd);
registerInput(cr->fd);
free(sockdir);
return;
}
unlink(cr->path);
logError("Cannot listen on control socket %\"s: %m\n",
cr->path);
} else {
logError("Cannot bind control socket %\"s: %m\n",
cr->path);
}
close(cr->fd);
cr->fd = -1;
}
#ifdef HONORS_SOCKET_PERMS
rmdir(sockdir);
#else
unlink(sockdir);
rmdir(cr->realdir);
free(cr->realdir);
cr->realdir = 0;
#endif
}
free(cr->path);
cr->path = 0;
}
free(sockdir);
}
}
void NamespaceDef::writeMemberDocumentation(OutputList &ol,MemberListType lt,const QCString &title)
{
MemberList * ml = getMemberList(lt);
if (ml) ml->writeDocumentation(ol,displayName(),this,title);
}
void sf2Instrument::openFile( const QString & _sf2File, bool updateTrackName )
{
emit fileLoading();
// Used for loading file
char * sf2Ascii = qstrdup( qPrintable( SampleBuffer::tryToMakeAbsolute( _sf2File ) ) );
QString relativePath = SampleBuffer::tryToMakeRelative( _sf2File );
// free reference to soundfont if one is selected
freeFont();
m_synthMutex.lock();
s_fontsMutex.lock();
// Increment Reference
if( s_fonts.contains( relativePath ) )
{
qDebug() << "Using existing reference to " << relativePath;
m_font = s_fonts[ relativePath ];
m_font->refCount++;
m_fontId = fluid_synth_add_sfont( m_synth, m_font->fluidFont );
}
// Add to map, if doesn't exist.
else
{
m_fontId = fluid_synth_sfload( m_synth, sf2Ascii, true );
if( fluid_synth_sfcount( m_synth ) > 0 )
{
// Grab this sf from the top of the stack and add to list
m_font = new sf2Font( fluid_synth_get_sfont( m_synth, 0 ) );
s_fonts.insert( relativePath, m_font );
}
else
{
collectErrorForUI( sf2Instrument::tr( "A soundfont %1 could not be loaded." ).arg( QFileInfo( _sf2File ).baseName() ) );
// TODO: Why is the filename missing when the file does not exist?
}
}
s_fontsMutex.unlock();
m_synthMutex.unlock();
if( m_fontId >= 0 )
{
// Don't reset patch/bank, so that it isn't cleared when
// someone resolves a missing file
//m_patchNum.setValue( 0 );
//m_bankNum.setValue( 0 );
m_filename = relativePath;
emit fileChanged();
}
delete[] sf2Ascii;
if( updateTrackName || instrumentTrack()->displayName() == displayName() )
{
instrumentTrack()->setName( QFileInfo( _sf2File ).baseName() );
}
}
void MaemoUploadAndInstallTarPackageStep::ctor()
{
finishInitialization(displayName(), new MaemoTarPackageInstaller(this));
}
void QgsVectorLayerProperties::apply()
{
labelingDialog->apply();
//
// Set up sql subset query if applicable
//
grpSubset->setEnabled( true );
if ( txtSubsetSQL->toPlainText() != layer->subsetString() )
{
// set the subset sql for the layer
layer->setSubsetString( txtSubsetSQL->toPlainText() );
mMetadataFilled = false;
}
// set up the scale based layer visibility stuff....
layer->toggleScaleBasedVisibility( chkUseScaleDependentRendering->isChecked() );
layer->setMinimumScale( 1.0 / cbMinimumScale->scale() );
layer->setMaximumScale( 1.0 / cbMaximumScale->scale() );
// provider-specific options
if ( layer->dataProvider() )
{
if ( layer->dataProvider()->capabilities() & QgsVectorDataProvider::SetEncoding )
{
layer->dataProvider()->setEncoding( cboProviderEncoding->currentText() );
}
}
// update the display field
if ( htmlRadio->isChecked() )
{
layer->setDisplayField( htmlMapTip->toPlainText() );
}
if ( fieldComboRadio->isChecked() )
{
layer->setDisplayField( displayFieldComboBox->currentText() );
}
layer->setEditForm( leEditForm->text() );
layer->setEditFormInit( leEditFormInit->text() );
actionDialog->apply();
labelDialog->apply();
layer->enableLabels( labelCheckBox->isChecked() );
layer->setLayerName( displayName() );
for ( int i = 0; i < tblAttributes->rowCount(); i++ )
{
int idx = tblAttributes->item( i, attrIdCol )->text().toInt();
QPushButton *pb = qobject_cast<QPushButton *>( tblAttributes->cellWidget( i, attrEditTypeCol ) );
if ( !pb )
continue;
QgsVectorLayer::EditType editType = editTypeFromButtonText( pb->text() );
layer->setEditType( idx, editType );
switch ( editType )
{
case QgsVectorLayer::ValueMap:
if ( mValueMaps.contains( idx ) )
{
QMap<QString, QVariant> &map = layer->valueMap( idx );
map.clear();
map = mValueMaps[idx];
}
break;
case QgsVectorLayer::EditRange:
case QgsVectorLayer::SliderRange:
case QgsVectorLayer::DialRange:
if ( mRanges.contains( idx ) )
{
layer->range( idx ) = mRanges[idx];
}
break;
case QgsVectorLayer::CheckBox:
if ( mCheckedStates.contains( idx ) )
{
layer->setCheckedState( idx, mCheckedStates[idx].first, mCheckedStates[idx].second );
}
break;
case QgsVectorLayer::ValueRelation:
if ( mValueRelationData.contains( idx ) )
{
layer->valueRelation( idx ) = mValueRelationData[idx];
}
break;
case QgsVectorLayer::LineEdit:
case QgsVectorLayer::UniqueValues:
case QgsVectorLayer::UniqueValuesEditable:
case QgsVectorLayer::Classification:
case QgsVectorLayer::FileName:
case QgsVectorLayer::Enumeration:
case QgsVectorLayer::Immutable:
case QgsVectorLayer::Hidden:
case QgsVectorLayer::TextEdit:
case QgsVectorLayer::Calendar:
case QgsVectorLayer::UuidGenerator:
break;
}
}
if ( layer->isUsingRendererV2() )
{
QgsRendererV2PropertiesDialog* dlg =
static_cast<QgsRendererV2PropertiesDialog*>( widgetStackRenderers->currentWidget() );
dlg->apply();
}
else
{
QgsSingleSymbolDialog *sdialog =
qobject_cast < QgsSingleSymbolDialog * >( widgetStackRenderers->currentWidget() );
QgsGraduatedSymbolDialog *gdialog =
qobject_cast < QgsGraduatedSymbolDialog * >( widgetStackRenderers->currentWidget() );
QgsContinuousColorDialog *cdialog =
qobject_cast < QgsContinuousColorDialog * >( widgetStackRenderers->currentWidget() );
QgsUniqueValueDialog* udialog =
qobject_cast< QgsUniqueValueDialog * >( widgetStackRenderers->currentWidget() );
if ( sdialog )
{
sdialog->apply();
}
else if ( gdialog )
{
gdialog->apply();
}
else if ( cdialog )
{
cdialog->apply();
}
else if ( udialog )
{
udialog->apply();
}
layer->setTransparency( static_cast < unsigned int >( 255 - sliderTransparency->value() ) );
}
//apply diagram settings
diagramPropertiesDialog->apply();
//apply overlay dialogs
for ( QList<QgsApplyDialog*>::iterator it = mOverlayDialogs.begin(); it != mOverlayDialogs.end(); ++it )
{
( *it )->apply();
}
//layer title and abstract
layer->setTitle( mLayerTitleLineEdit->text() );
layer->setAbstract( mLayerAbstractTextEdit->toPlainText() );
// update symbology
emit refreshLegend( layer->id(), false );
//no need to delete the old one, maplayer will do it if needed
layer->setCacheImage( 0 );
layer->triggerRepaint();
// notify the project we've made a change
QgsProject::instance()->dirty( true );
}
DatabaseDetails DatabaseBackendBase::details() const
{
// This code path is only used for database quota delegate calls, so file dates are irrelevant and left uninitialized.
return DatabaseDetails(stringIdentifier(), displayName(), estimatedSize(), 0, 0, 0);
}
DatabaseDetails DatabaseBackendBase::details() const
{
return DatabaseDetails(stringIdentifier(), displayName(), estimatedSize(), 0);
}
BareMetalGdbCommandsDeployStep::BareMetalGdbCommandsDeployStep(BuildStepList *bsl)
: BuildStep(bsl, stepId())
{
setDefaultDisplayName(displayName());
}
QString WinRtPackageDeploymentStepWidget::summaryText() const
{
return displayName();
}
QString QmakeBuildConfiguration::defaultShadowBuildDirectory() const
{
// todo displayName isn't ideal
return QmakeProject::shadowBuildDirectory(target()->project()->projectFilePath().toString(),
target()->kit(), displayName());
}
void AGOSEngine_Waxworks::boxController(uint x, uint y, uint mode) {
HitArea *best_ha;
HitArea *ha = _hitAreas;
uint count = ARRAYSIZE(_hitAreas);
uint16 priority = 0;
uint16 x_ = x;
uint16 y_ = y;
if (getGameType() == GType_FF || getGameType() == GType_PP) {
x_ += _scrollX;
y_ += _scrollY;
} else if (getGameType() == GType_SIMON2) {
if (getBitFlag(79) || y < 134) {
x_ += _scrollX * 8;
}
}
best_ha = NULL;
do {
if (ha->flags & kBFBoxInUse) {
if (!(ha->flags & kBFBoxDead)) {
if (x_ >= ha->x && y_ >= ha->y &&
x_ - ha->x < ha->width && y_ - ha->y < ha->height && priority <= ha->priority) {
priority = ha->priority;
best_ha = ha;
} else {
if (ha->flags & kBFBoxSelected) {
hitarea_leave(ha , true);
ha->flags &= ~kBFBoxSelected;
}
}
} else {
ha->flags &= ~kBFBoxSelected;
}
}
} while (ha++, --count);
_currentBoxNum = 0;
_currentBox = best_ha;
if (best_ha == NULL) {
clearName();
if (getGameType() == GType_WW && _mouseCursor >= 4) {
_mouseCursor = 0;
_needHitAreaRecalc++;
}
return;
}
_currentBoxNum = best_ha->id;
if (mode != 0) {
if (mode == 3) {
if (best_ha->flags & kBFDragBox) {
_lastClickRem = best_ha;
}
} else {
_lastHitArea = best_ha;
if (getGameType() == GType_PP) {
_variableArray[400] = x;
_variableArray[401] = y;
} else if (getGameType() == GType_SIMON1 || getGameType() == GType_SIMON2 ||
getGameType() == GType_FF) {
_variableArray[1] = x;
_variableArray[2] = y;
}
}
}
if ((getGameType() == GType_WW) && (_mouseCursor == 0 || _mouseCursor >= 4)) {
uint verb = best_ha->verb & 0x3FFF;
if (verb >= 239 && verb <= 242) {
uint cursor = verb - 235;
if (_mouseCursor != cursor) {
_mouseCursor = cursor;
_needHitAreaRecalc++;
}
}
}
if (getGameType() != GType_WW || !_nameLocked) {
if (best_ha->flags & kBFNoTouchName) {
clearName();
} else if (best_ha != _lastNameOn) {
displayName(best_ha);
}
}
if (best_ha->flags & kBFInvertTouch && !(best_ha->flags & kBFBoxSelected)) {
hitarea_leave(best_ha, false);
best_ha->flags |= kBFBoxSelected;
}
}
void LadspaEffect::pluginInstantiation()
{
m_maxSampleRate = maxSamplerate( displayName() );
ladspa2LMMS * manager = engine::getLADSPAManager();
// Calculate how many processing units are needed.
const ch_cnt_t lmms_chnls = engine::mixer()->audioDev()->channels();
int effect_channels = manager->getDescription( m_key )->inputChannels;
setProcessorCount( lmms_chnls / effect_channels );
// Categorize the ports, and create the buffers.
m_portCount = manager->getPortCount( m_key );
for( ch_cnt_t proc = 0; proc < processorCount(); proc++ )
{
multi_proc_t ports;
for( int port = 0; port < m_portCount; port++ )
{
port_desc_t * p = new PortDescription;
p->name = manager->getPortName( m_key, port );
p->proc = proc;
p->port_id = port;
p->control = NULL;
// Determine the port's category.
if( manager->isPortAudio( m_key, port ) )
{
// Nasty manual memory management--was having difficulty
// with some prepackaged plugins that were segfaulting
// during cleanup. It was easier to troubleshoot with the
// memory management all taking place in one file.
p->buffer =
new LADSPA_Data[engine::mixer()->framesPerPeriod()];
if( p->name.toUpper().contains( "IN" ) &&
manager->isPortInput( m_key, port ) )
{
p->rate = CHANNEL_IN;
}
else if( p->name.toUpper().contains( "OUT" ) &&
manager->isPortOutput( m_key, port ) )
{
p->rate = CHANNEL_OUT;
}
else if( manager->isPortInput( m_key, port ) )
{
p->rate = AUDIO_RATE_INPUT;
}
else
{
p->rate = AUDIO_RATE_OUTPUT;
}
}
else
{
p->buffer = new LADSPA_Data[1];
if( manager->isPortInput( m_key, port ) )
{
p->rate = CONTROL_RATE_INPUT;
}
else
{
p->rate = CONTROL_RATE_OUTPUT;
}
}
p->scale = 1.0f;
if( manager->isPortToggled( m_key, port ) )
{
p->data_type = TOGGLED;
}
else if( manager->isInteger( m_key, port ) )
{
p->data_type = INTEGER;
}
else if( p->name.toUpper().contains( "(SECONDS)" ) )
{
p->data_type = TIME;
p->scale = 1000.0f;
int loc = p->name.toUpper().indexOf(
"(SECONDS)" );
p->name.replace( loc, 9, "(ms)" );
}
else if( p->name.toUpper().contains( "(S)" ) )
{
p->data_type = TIME;
p->scale = 1000.0f;
int loc = p->name.toUpper().indexOf( "(S)" );
p->name.replace( loc, 3, "(ms)" );
}
else if( p->name.toUpper().contains( "(MS)" ) )
{
p->data_type = TIME;
int loc = p->name.toUpper().indexOf( "(MS)" );
p->name.replace( loc, 4, "(ms)" );
}
else
{
p->data_type = FLOATING;
}
// Get the range and default values.
p->max = manager->getUpperBound( m_key, port );
if( p->max == NOHINT )
{
p->max = p->name.toUpper() == "GAIN" ? 10.0f :
1.0f;
}
if( manager->areHintsSampleRateDependent(
m_key, port ) )
{
p->max *= m_maxSampleRate;
}
p->min = manager->getLowerBound( m_key, port );
if( p->min == NOHINT )
{
p->min = 0.0f;
}
if( manager->areHintsSampleRateDependent(
m_key, port ) )
{
p->min *= m_maxSampleRate;
}
p->def = manager->getDefaultSetting( m_key, port );
if( p->def == NOHINT )
{
if( p->data_type != TOGGLED )
{
p->def = ( p->min + p->max ) / 2.0f;
}
else
{
p->def = 1.0f;
}
}
else if( manager->areHintsSampleRateDependent( m_key, port ) )
{
p->def *= m_maxSampleRate;
}
p->max *= p->scale;
p->min *= p->scale;
p->def *= p->scale;
p->value = p->def;
p->suggests_logscale = manager->isLogarithmic( m_key, port );
ports.append( p );
// For convenience, keep a separate list of the ports that are used
// to control the processors.
if( p->rate == AUDIO_RATE_INPUT ||
p->rate == CONTROL_RATE_INPUT )
{
p->control_id = m_portControls.count();
m_portControls.append( p );
}
}
m_ports.append( ports );
}
// Instantiate the processing units.
m_descriptor = manager->getDescriptor( m_key );
if( m_descriptor == NULL )
{
QMessageBox::warning( 0, "Effect",
"Can't get LADSPA descriptor function: " + m_key.second,
QMessageBox::Ok, QMessageBox::NoButton );
setOkay( false );
return;
}
if( m_descriptor->run == NULL )
{
QMessageBox::warning( 0, "Effect",
"Plugin has no processor: " + m_key.second,
QMessageBox::Ok, QMessageBox::NoButton );
setDontRun( true );
}
for( ch_cnt_t proc = 0; proc < processorCount(); proc++ )
{
LADSPA_Handle effect = manager->instantiate( m_key,
m_maxSampleRate );
if( effect == NULL )
{
QMessageBox::warning( 0, "Effect",
"Can't get LADSPA instance: " + m_key.second,
QMessageBox::Ok, QMessageBox::NoButton );
setOkay( false );
return;
}
m_handles.append( effect );
}
// Connect the ports.
for( ch_cnt_t proc = 0; proc < processorCount(); proc++ )
{
for( int port = 0; port < m_portCount; port++ )
{
port_desc_t * pp = m_ports.at( proc ).at( port );
if( !manager->connectPort( m_key,
m_handles[proc],
port,
pp->buffer ) )
{
QMessageBox::warning( 0, "Effect",
"Failed to connect port: " + m_key.second,
QMessageBox::Ok, QMessageBox::NoButton );
setDontRun( true );
return;
}
}
}
// Activate the processing units.
for( ch_cnt_t proc = 0; proc < processorCount(); proc++ )
{
manager->activate( m_key, m_handles[proc] );
}
m_controls = new LadspaControls( this );
}
Account::~Account()
{
qDebug() << "Account" << displayName() << "deleted";
delete _credentials;
delete _am;
}
QString Qt4BuildConfiguration::defaultShadowBuildDirectory() const
{
// todo displayName isn't ideal
return Qt4Project::shadowBuildDirectory(target()->project()->document()->fileName(),
target()->kit(), displayName());
}
void NamespaceDef::writeDocumentation(OutputList &ol)
{
static bool generateTreeView = Config_getBool("GENERATE_TREEVIEW");
//static bool outputJava = Config_getBool("OPTIMIZE_OUTPUT_JAVA");
//static bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
QCString pageTitle = title();
startFile(ol,getOutputFileBase(),name(),pageTitle,HLI_NamespaceVisible,!generateTreeView);
if (!generateTreeView)
{
if (getOuterScope()!=Doxygen::globalScope)
{
writeNavigationPath(ol);
}
ol.endQuickIndices();
}
startTitle(ol,getOutputFileBase(),this);
ol.parseText(pageTitle);
addGroupListToTitle(ol,this);
addNamespaceAttributes(ol);
endTitle(ol,getOutputFileBase(),displayName());
ol.startContents();
if (Doxygen::searchIndex)
{
Doxygen::searchIndex->setCurrentDoc(this,anchor(),FALSE);
Doxygen::searchIndex->addWord(localName(),TRUE);
}
Doxygen::indexList->addIndexItem(this,0);
//---------------------------------------- start flexible part -------------------------------
SrcLangExt lang = getLanguage();
QListIterator<LayoutDocEntry> eli(
LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace));
LayoutDocEntry *lde;
for (eli.toFirst(); (lde=eli.current()); ++eli)
{
switch (lde->kind())
{
case LayoutDocEntry::BriefDesc:
writeBriefDescription(ol);
break;
case LayoutDocEntry::MemberDeclStart:
startMemberDeclarations(ol);
break;
case LayoutDocEntry::NamespaceClasses:
{
LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
writeClassDeclarations(ol,ls->title(lang));
}
break;
case LayoutDocEntry::NamespaceNestedNamespaces:
{
LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
writeNamespaceDeclarations(ol,ls->title(lang),false);
}
break;
case LayoutDocEntry::NamespaceNestedConstantGroups:
{
LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
writeNamespaceDeclarations(ol,ls->title(lang),true);
}
break;
case LayoutDocEntry::MemberGroups:
writeMemberGroups(ol);
break;
case LayoutDocEntry::MemberDecl:
{
LayoutDocEntryMemberDecl *lmd = (LayoutDocEntryMemberDecl*)lde;
writeMemberDeclarations(ol,lmd->type,lmd->title(lang));
}
break;
case LayoutDocEntry::MemberDeclEnd:
endMemberDeclarations(ol);
break;
case LayoutDocEntry::DetailedDesc:
{
LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
writeDetailedDescription(ol,ls->title(lang));
}
break;
case LayoutDocEntry::MemberDefStart:
startMemberDocumentation(ol);
break;
case LayoutDocEntry::NamespaceInlineClasses:
writeInlineClasses(ol);
break;
case LayoutDocEntry::MemberDef:
{
LayoutDocEntryMemberDef *lmd = (LayoutDocEntryMemberDef*)lde;
writeMemberDocumentation(ol,lmd->type,lmd->title(lang));
}
break;
case LayoutDocEntry::MemberDefEnd:
endMemberDocumentation(ol);
break;
case LayoutDocEntry::AuthorSection:
writeAuthorSection(ol);
break;
case LayoutDocEntry::ClassIncludes:
case LayoutDocEntry::ClassInheritanceGraph:
case LayoutDocEntry::ClassNestedClasses:
case LayoutDocEntry::ClassCollaborationGraph:
case LayoutDocEntry::ClassAllMembersLink:
case LayoutDocEntry::ClassUsedFiles:
case LayoutDocEntry::ClassInlineClasses:
case LayoutDocEntry::FileClasses:
case LayoutDocEntry::FileNamespaces:
case LayoutDocEntry::FileConstantGroups:
case LayoutDocEntry::FileIncludes:
case LayoutDocEntry::FileIncludeGraph:
case LayoutDocEntry::FileIncludedByGraph:
case LayoutDocEntry::FileSourceLink:
case LayoutDocEntry::FileInlineClasses:
case LayoutDocEntry::GroupClasses:
case LayoutDocEntry::GroupInlineClasses:
case LayoutDocEntry::GroupNamespaces:
case LayoutDocEntry::GroupDirs:
case LayoutDocEntry::GroupNestedGroups:
case LayoutDocEntry::GroupFiles:
case LayoutDocEntry::GroupGraph:
case LayoutDocEntry::GroupPageDocs:
case LayoutDocEntry::DirSubDirs:
case LayoutDocEntry::DirFiles:
case LayoutDocEntry::DirGraph:
err("Internal inconsistency: member %d should not be part of "
"LayoutDocManager::Namespace entry list\n",lde->kind());
break;
}
}
//---------------------------------------- end flexible part -------------------------------
ol.endContents();
endFileWithNavPath(this,ol);
if (Config_getBool("SEPARATE_MEMBER_PAGES"))
{
MemberList *allMemberList = getMemberList(MemberListType_allMembersList);
if (allMemberList) allMemberList->sort();
writeMemberPages(ol);
}
}
Console::Console()
{
m_consoleItemModel = new ConsoleItemModel(this);
m_consoleWidget = new QWidget;
m_consoleWidget->setWindowTitle(displayName());
m_consoleWidget->setEnabled(true);
QVBoxLayout *vbox = new QVBoxLayout(m_consoleWidget);
vbox->setMargin(0);
vbox->setSpacing(0);
m_consoleView = new ConsoleView(m_consoleItemModel, m_consoleWidget);
auto proxyModel = new ConsoleProxyModel(this);
proxyModel->setSourceModel(m_consoleItemModel);
connect(m_consoleItemModel,
&ConsoleItemModel::selectEditableRow,
proxyModel,
&ConsoleProxyModel::selectEditableRow);
//Scroll to bottom when rows matching current filter settings are inserted
//Not connecting rowsRemoved as the only way to remove rows is to clear the
//model which will automatically reset the view.
connect(m_consoleItemModel, &QAbstractItemModel::rowsInserted,
proxyModel, &ConsoleProxyModel::onRowsInserted);
m_consoleView->setModel(proxyModel);
connect(proxyModel, &ConsoleProxyModel::setCurrentIndex,
m_consoleView->selectionModel(), &QItemSelectionModel::setCurrentIndex);
connect(proxyModel, &ConsoleProxyModel::scrollToBottom,
m_consoleView, &ConsoleView::onScrollToBottom);
auto itemDelegate = new ConsoleItemDelegate(m_consoleItemModel, this);
connect(m_consoleView->selectionModel(), &QItemSelectionModel::currentChanged,
itemDelegate, &ConsoleItemDelegate::currentChanged);
m_consoleView->setItemDelegate(itemDelegate);
Aggregation::Aggregate *aggregate = new Aggregation::Aggregate();
aggregate->add(m_consoleView);
aggregate->add(new Core::ItemViewFind(m_consoleView));
vbox->addWidget(m_consoleView);
vbox->addWidget(new Core::FindToolBarPlaceHolder(m_consoleWidget));
m_showDebugButton = new QToolButton(m_consoleWidget);
m_showDebugButton->setAutoRaise(true);
m_showDebugButtonAction = new Utils::SavedAction(this);
m_showDebugButtonAction->setDefaultValue(true);
m_showDebugButtonAction->setSettingsKey(QLatin1String(CONSOLE), QLatin1String(SHOW_LOG));
m_showDebugButtonAction->setToolTip(tr("Show debug, log, and info messages."));
m_showDebugButtonAction->setCheckable(true);
m_showDebugButtonAction->setChecked(true);
m_showDebugButtonAction->setIcon(Utils::Icons::INFO_TOOLBAR.icon());
connect(m_showDebugButtonAction, &Utils::SavedAction::toggled,
proxyModel, &ConsoleProxyModel::setShowLogs);
m_showDebugButton->setDefaultAction(m_showDebugButtonAction);
m_showWarningButton = new QToolButton(m_consoleWidget);
m_showWarningButton->setAutoRaise(true);
m_showWarningButtonAction = new Utils::SavedAction(this);
m_showWarningButtonAction->setDefaultValue(true);
m_showWarningButtonAction->setSettingsKey(QLatin1String(CONSOLE), QLatin1String(SHOW_WARNING));
m_showWarningButtonAction->setToolTip(tr("Show warning messages."));
m_showWarningButtonAction->setCheckable(true);
m_showWarningButtonAction->setChecked(true);
m_showWarningButtonAction->setIcon(Utils::Icons::WARNING_TOOLBAR.icon());
connect(m_showWarningButtonAction, &Utils::SavedAction::toggled,
proxyModel, &ConsoleProxyModel::setShowWarnings);
m_showWarningButton->setDefaultAction(m_showWarningButtonAction);
m_showErrorButton = new QToolButton(m_consoleWidget);
m_showErrorButton->setAutoRaise(true);
m_showErrorButtonAction = new Utils::SavedAction(this);
m_showErrorButtonAction->setDefaultValue(true);
m_showErrorButtonAction->setSettingsKey(QLatin1String(CONSOLE), QLatin1String(SHOW_ERROR));
m_showErrorButtonAction->setToolTip(tr("Show error messages."));
m_showErrorButtonAction->setCheckable(true);
m_showErrorButtonAction->setChecked(true);
m_showErrorButtonAction->setIcon(Utils::Icons::CRITICAL_TOOLBAR.icon());
connect(m_showErrorButtonAction, &Utils::SavedAction::toggled,
proxyModel, &ConsoleProxyModel::setShowErrors);
m_showErrorButton->setDefaultAction(m_showErrorButtonAction);
m_spacer = new QWidget(m_consoleWidget);
m_spacer->setMinimumWidth(30);
m_statusLabel = new QLabel(m_consoleWidget);
readSettings();
connect(Core::ICore::instance(), &Core::ICore::saveSettingsRequested,
this, &Console::writeSettings);
}
String IndexerJob::addNamePermutations(const CXCursor &cursor, const Location &location)
{
CXCursorKind kind = clang_getCursorKind(cursor);
const CXCursorKind originalKind = kind;
char buf[1024];
int pos = sizeof(buf) - 1;
buf[pos] = '\0';
int cutoff = -1;
CXCursor c = cursor;
bool hasTemplates = false;
do {
CXStringScope displayName(clang_getCursorDisplayName(c));
const char *name = displayName.data();
if (!name)
break;
const int len = strlen(name);
if (!len)
break;
if (kind == CXCursor_ClassTemplate)
hasTemplates = true;
if (pos != sizeof(buf) - 1 && (pos -= 2) >= 0) {
memset(buf + pos, ':', 2);
}
pos -= len;
if (pos < 0) {
error("SymbolName too long. Giving up");
return String();
}
memcpy(buf + pos, name, len);
c = clang_getCursorSemanticParent(c);
kind = clang_getCursorKind(c);
if (cutoff == -1) {
switch (kind) {
case CXCursor_ClassDecl:
case CXCursor_ClassTemplate:
case CXCursor_StructDecl:
break;
case CXCursor_Namespace:
// namespaces can include all namespaces in their symbolname
if (originalKind == CXCursor_Namespace)
break;
default:
cutoff = pos;
break;
}
}
} while (RTags::needsQualifiers(kind));
String type;
switch (originalKind) {
case CXCursor_ClassDecl:
case CXCursor_StructDecl:
case CXCursor_ClassTemplate:
break;
default:
type = typeName(cursor);
break;
}
if (cutoff == -1)
cutoff = pos;
String ret;
for (int i=0; i<2; ++i) {
char *ch = buf + pos;
while (true) {
const String name(ch, sizeof(buf) - (ch - buf) - 1);
mData->symbolNames[name].insert(location);
if (!type.isEmpty()) {
mData->symbolNames[type + name].insert(location);
}
ch = strstr(ch + 1, "::");
if (ch) {
ch += 2;
} else {
break;
}
}
if (i == 0) {
ret.assign(buf + cutoff, sizeof(buf) - cutoff - 1);
if (!type.isEmpty())
ret.prepend(type);
}
if (!hasTemplates) {
break;
} else if (i == 0) {
char *start = strchr(buf + pos, '<');
assert(start);
char *end = strchr(start, '>');
const int templateSize = (end - start) + 1;
assert(end);
memmove(buf + pos + templateSize, buf + pos, start - (buf + pos));
pos += templateSize;
}
}
return ret;
}
const QPixmap&
LayoutIcon::findPixmap(const QString& code_, bool showFlag, const QString& displayName_)
{
QPixmap* pm = NULL;
if( code_ == ERROR_CODE ) {
pm = m_pixmapCache[ERROR_CODE];
if( pm == NULL ) {
pm = createErrorPixmap();
m_pixmapCache.insert(ERROR_CODE, pm);
}
return *pm;
}
QString displayName(displayName_);
if( displayName.isEmpty() ) {
displayName = KxkbConfig::getDefaultDisplayName(code_);
}
if( displayName.length() > 3 )
displayName = displayName.left(3);
const QString pixmapKey( showFlag ? code_ + "." + displayName : displayName );
pm = m_pixmapCache[pixmapKey];
if( pm )
return *pm;
QString flag;
if( showFlag ) {
QString countryCode = getCountryFromLayoutName( code_ );
flag = locate("locale", flagTemplate.arg(countryCode));
}
if( flag.isEmpty() ) {
pm = new QPixmap(FLAG_MAX_WIDTH, FLAG_MAX_HEIGHT);
pm->fill(Qt::gray);
}
else {
pm = new QPixmap(flag);
dimPixmap( *pm );
#if 0
if( pm->height() < FLAG_MAX_HEIGHT ) {
QPixmap* pix = new QPixmap(FLAG_MAX_WIDTH, FLAG_MAX_HEIGHT);
pix->fill( Qt::lightGray );
// pix->fill( QColor(qRgba(127,127,127,255)) );
// QBitmap mask;
// mask.fill(1);
// pix->setMask(mask);
int dy = (pix->height() - pm->height()) / 2;
copyBlt( pix, 0, dy, pm, 0, 0, -1, -1 );
// QPixmap* px = new QPixmap(21, 14);
// px->convertFromImage(img);*/
delete pm;
pm = pix;
}
#endif
}
QPainter p(pm);
p.setFont(m_labelFont);
p.setPen(Qt::black);
p.drawText(1, 1, pm->width(), pm->height()-2, Qt::AlignCenter, displayName);
p.setPen(Qt::white);
p.drawText(0, 0, pm->width(), pm->height()-2, Qt::AlignCenter, displayName);
m_pixmapCache.insert(pixmapKey, pm);
return *pm;
}
void BareMetalGdbCommandsDeployStep::ctor()
{
setDefaultDisplayName(displayName());
}
void QgsVectorLayerProperties::apply()
{
if ( labelingDialog )
labelingDialog->apply();
//
// Set up sql subset query if applicable
//
grpSubset->setEnabled( true );
if ( txtSubsetSQL->toPlainText() != layer->subsetString() )
{
// set the subset sql for the layer
layer->setSubsetString( txtSubsetSQL->toPlainText() );
mMetadataFilled = false;
}
// set up the scale based layer visibility stuff....
layer->toggleScaleBasedVisibility( chkUseScaleDependentRendering->isChecked() );
layer->setMinimumScale( 1.0 / cbMinimumScale->scale() );
layer->setMaximumScale( 1.0 / cbMaximumScale->scale() );
// provider-specific options
if ( layer->dataProvider() )
{
if ( layer->dataProvider()->capabilities() & QgsVectorDataProvider::SetEncoding )
{
layer->dataProvider()->setEncoding( cboProviderEncoding->currentText() );
layer->updateFieldMap();
}
}
// update the display field
if ( htmlRadio->isChecked() )
{
layer->setDisplayField( htmlMapTip->toPlainText() );
}
if ( fieldComboRadio->isChecked() )
{
layer->setDisplayField( displayFieldComboBox->currentText() );
}
actionDialog->apply();
if ( labelDialog )
labelDialog->apply();
layer->enableLabels( labelCheckBox->isChecked() );
layer->setLayerName( displayName() );
QSet<QString> excludeAttributesWMS, excludeAttributesWFS;
// Apply fields settings
mFieldsPropertiesDialog->apply();
if ( layer->isUsingRendererV2() )
{
QgsRendererV2PropertiesDialog* dlg =
static_cast<QgsRendererV2PropertiesDialog*>( widgetStackRenderers->currentWidget() );
dlg->apply();
}
else
{
QgsSingleSymbolDialog *sdialog =
qobject_cast < QgsSingleSymbolDialog * >( widgetStackRenderers->currentWidget() );
QgsGraduatedSymbolDialog *gdialog =
qobject_cast < QgsGraduatedSymbolDialog * >( widgetStackRenderers->currentWidget() );
QgsContinuousColorDialog *cdialog =
qobject_cast < QgsContinuousColorDialog * >( widgetStackRenderers->currentWidget() );
QgsUniqueValueDialog* udialog =
qobject_cast< QgsUniqueValueDialog * >( widgetStackRenderers->currentWidget() );
if ( sdialog )
{
sdialog->apply();
}
else if ( gdialog )
{
gdialog->apply();
}
else if ( cdialog )
{
cdialog->apply();
}
else if ( udialog )
{
udialog->apply();
}
layer->setTransparency( static_cast < unsigned int >( 255 - sliderTransparency->value() ) );
}
//apply diagram settings
diagramPropertiesDialog->apply();
//apply overlay dialogs
for ( QList<QgsApplyDialog*>::iterator it = mOverlayDialogs.begin(); it != mOverlayDialogs.end(); ++it )
{
( *it )->apply();
}
//layer title and abstract
layer->setTitle( mLayerTitleLineEdit->text() );
layer->setAbstract( mLayerAbstractTextEdit->toPlainText() );
// update symbology
emit refreshLegend( layer->id(), QgsLegendItem::DontChange );
//no need to delete the old one, maplayer will do it if needed
layer->setCacheImage( 0 );
layer->triggerRepaint();
// notify the project we've made a change
QgsProject::instance()->dirty( true );
}
