static void setPaletteColor(const QVariantMap &object,
QPalette &palette,
QPalette::ColorRole role)
{
// QPalette::Active -> ENABLED_FOCUSED_WINDOW_FOCUSED_STATE_SET
palette.setColor(QPalette::Active,
role,
QRgb(object.value(QLatin1String("ENABLED_FOCUSED_WINDOW_FOCUSED_STATE_SET")).toInt()));
// QPalette::Inactive -> ENABLED_STATE_SET
palette.setColor(QPalette::Inactive,
role,
QRgb(object.value(QLatin1String("ENABLED_STATE_SET")).toInt()));
// QPalette::Disabled -> EMPTY_STATE_SET
palette.setColor(QPalette::Disabled,
role,
QRgb(object.value(QLatin1String("EMPTY_STATE_SET")).toInt()));
palette.setColor(QPalette::Current, role, palette.color(QPalette::Active, role));
if (role == QPalette::WindowText) {
// QPalette::BrightText -> PRESSED
// QPalette::Active -> PRESSED_ENABLED_FOCUSED_WINDOW_FOCUSED_STATE_SET
palette.setColor(QPalette::Active,
QPalette::BrightText,
QRgb(object.value(QLatin1String("PRESSED_ENABLED_FOCUSED_WINDOW_FOCUSED_STATE_SET")).toInt()));
// QPalette::Inactive -> PRESSED_ENABLED_STATE_SET
palette.setColor(QPalette::Inactive,
QPalette::BrightText,
QRgb(object.value(QLatin1String("PRESSED_ENABLED_STATE_SET")).toInt()));
// QPalette::Disabled -> PRESSED_STATE_SET
palette.setColor(QPalette::Disabled,
QPalette::BrightText,
QRgb(object.value(QLatin1String("PRESSED_STATE_SET")).toInt()));
palette.setColor(QPalette::Current, QPalette::BrightText, palette.color(QPalette::Active, QPalette::BrightText));
// QPalette::HighlightedText -> SELECTED
// QPalette::Active -> ENABLED_SELECTED_WINDOW_FOCUSED_STATE_SET
palette.setColor(QPalette::Active,
QPalette::HighlightedText,
QRgb(object.value(QLatin1String("ENABLED_SELECTED_WINDOW_FOCUSED_STATE_SET")).toInt()));
// QPalette::Inactive -> ENABLED_SELECTED_STATE_SET
palette.setColor(QPalette::Inactive,
QPalette::HighlightedText,
QRgb(object.value(QLatin1String("ENABLED_SELECTED_STATE_SET")).toInt()));
// QPalette::Disabled -> SELECTED_STATE_SET
palette.setColor(QPalette::Disabled,
QPalette::HighlightedText,
QRgb(object.value(QLatin1String("SELECTED_STATE_SET")).toInt()));
palette.setColor(QPalette::Current,
QPalette::HighlightedText,
palette.color(QPalette::Active, QPalette::HighlightedText));
// Same colors for Text
palette.setColor(QPalette::Active, QPalette::Text, palette.color(QPalette::Active, role));
palette.setColor(QPalette::Inactive, QPalette::Text, palette.color(QPalette::Inactive, role));
palette.setColor(QPalette::Disabled, QPalette::Text, palette.color(QPalette::Disabled, role));
palette.setColor(QPalette::Current, QPalette::Text, palette.color(QPalette::Current, role));
// And for ButtonText
palette.setColor(QPalette::Active, QPalette::ButtonText, palette.color(QPalette::Active, role));
palette.setColor(QPalette::Inactive, QPalette::ButtonText, palette.color(QPalette::Inactive, role));
palette.setColor(QPalette::Disabled, QPalette::ButtonText, palette.color(QPalette::Disabled, role));
palette.setColor(QPalette::Current, QPalette::ButtonText, palette.color(QPalette::Current, role));
}
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool Application::initConfiguration() {
if ( !Client::Application::initConfiguration() )
return false;
QPalette pal;
_scheme.colors.background = pal.color(QPalette::Window);
_scheme.fetch();
pal.setColor(QPalette::Window, _scheme.colors.background);
#if QT_VERSION >= 0x040300
// Keep original Qt settings for buttons. This can be achieved by
// using a custom StyleSheet:
// appname -stylesheet=mystyle.qss
// mystyle.qcc
// QPushButton { background-color: red }
//pal.setColor(QPalette::Button, _scheme.colors.background.lighter(110));
#endif
setPalette(pal);
try { _mapsDesc.location = configGetString("map.location").c_str(); }
catch (...) { _mapsDesc.location = "@DATADIR@/maps/world%s.png"; }
_mapsDesc.type = QString();
try { _mapsDesc.type = configGetString("map.type").c_str(); }
catch (...) {}
_mapsDesc.isMercatorProjected = false;
try {
string proj = configGetString("map.format");
if ( proj == "mercator" )
_mapsDesc.isMercatorProjected = true;
else if ( proj == "rectangular" )
_mapsDesc.isMercatorProjected = false;
else {
cerr << "Unknown map format: " << proj << endl;
return false;
}
}
catch (...) {}
_mapsDesc.cacheSize = 0;
try { _mapsDesc.cacheSize = configGetInt("map.cacheSize"); }
catch ( ... ) {}
_mapsDesc.location = Environment::Instance()->absolutePath(_mapsDesc.location.toStdString()).c_str();
_eventTimeAgo = 0.0;
bool setTimeAgo = false;
try {
_eventTimeAgo += double(configGetInt("events.timeAgo.days")*24*60*60);
setTimeAgo = true;
}
catch (...) {}
try {
_eventTimeAgo += double(configGetInt("events.timeAgo.hours")*60*60);
setTimeAgo = true;
}
catch (...) {}
try {
_eventTimeAgo += double(configGetInt("events.timeAgo.minutes")*60);
setTimeAgo = true;
}
catch (...) {}
try {
_eventTimeAgo += double(configGetInt("events.timeAgo.seconds"));
setTimeAgo = true;
}
catch (...) {}
try {
_nonInteractive = configGetBool("mode.interactive") == false;
}
catch (...) {}
try {
_startFullScreen = configGetBool("mode.fullscreen");
}
catch (...) {}
// Default is: display events from 1 day ago until 'now'
if ( !setTimeAgo )
_eventTimeAgo = double(24*60*60);
_commandTargetClient = "";
try {
_commandTargetClient = configGetString("commands.target");
}
catch (...) {}
setOrganizationName(agencyID().c_str());
setApplicationName(name().c_str());
return true;
}
void AbstractWheelWidget::paintEvent(QPaintEvent* event)
{
Q_UNUSED( event );
// -- first calculate size and position.
int w = width();
int h = height();
QPainter painter(this);
QPalette palette = QApplication::palette();
QPalette::ColorGroup colorGroup = isEnabled() ? QPalette::Active : QPalette::Disabled;
// linear gradient brush
QLinearGradient grad(0.5, 0, 0.5, 1.0);
grad.setColorAt(0, palette.color(colorGroup, QPalette::ButtonText));
grad.setColorAt(0.2, palette.color(colorGroup, QPalette::Button));
grad.setColorAt(0.8, palette.color(colorGroup, QPalette::Button));
grad.setColorAt(1.0, palette.color(colorGroup, QPalette::ButtonText));
grad.setCoordinateMode( QGradient::ObjectBoundingMode );
QBrush gBrush( grad );
// paint a border and background
painter.setPen(palette.color(colorGroup, QPalette::ButtonText));
painter.setBrush(gBrush);
// painter.setBrushOrigin( QPointF( 0.0, 0.0 ) );
painter.drawRect( 0, 0, w-1, h-1 );
// paint inner border
painter.setPen(palette.color(colorGroup, QPalette::Button));
painter.setBrush(Qt::NoBrush);
painter.drawRect( 1, 1, w-3, h-3 );
// paint the items
painter.setClipRect( QRect( 3, 3, w-6, h-6 ) );
painter.setPen(palette.color(colorGroup, QPalette::ButtonText));
int iH = itemHeight();
int iC = itemCount();
if (iC > 0) {
m_itemOffset = m_itemOffset % iH;
for (int i=-h/2/iH; i<=h/2/iH+1; i++) {
int itemNum = m_currentItem + i;
while (itemNum < 0)
itemNum += iC;
while (itemNum >= iC)
itemNum -= iC;
paintItem(&painter, itemNum, QRect(6, h/2 +i*iH - m_itemOffset - iH/2, w-6, iH ));
}
}
// draw a transparent bar over the center
QColor highlight = palette.color(colorGroup, QPalette::Highlight);
highlight.setAlpha(150);
QLinearGradient grad2(0.5, 0, 0.5, 1.0);
grad2.setColorAt(0, highlight);
grad2.setColorAt(1.0, highlight.lighter());
grad2.setCoordinateMode( QGradient::ObjectBoundingMode );
QBrush gBrush2( grad2 );
QLinearGradient grad3(0.5, 0, 0.5, 1.0);
grad3.setColorAt(0, highlight);
grad3.setColorAt(1.0, highlight.darker());
grad3.setCoordinateMode( QGradient::ObjectBoundingMode );
QBrush gBrush3( grad3 );
painter.fillRect( QRect( 0, h/2 - iH/2, w, iH/2 ), gBrush2 );
painter.fillRect( QRect( 0, h/2, w, iH/2 ), gBrush3 );
}
void UserViewDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const
{
UserViewItemBase *base = dynamic_cast<UserViewItemBase*>(m_uv->itemFromIndex(index));
if( NULL == base )
return;
painter->save();
painter->translate(option.rect.x(), option.rect.y());
QPainter *p = painter;
QPalette cg = option.palette;
int width = option.rect.width();
int height = option.rect.height();
QSize itemsize = option.rect.size();
int margin = 1;
switch( base->type() )
{
case GRP_ITEM:
{
GroupItem *item = static_cast<GroupItem*>(base);
QString text = index.data( Qt::DisplayRole ).toString();
QImage img = Image( ( option.state & QStyle::State_Open ) ? "expanded" : "collapsed");
if (!img.isNull())
p->drawImage(2 + margin, (height - img.height()) / 2, img);
int x = 24 + margin;
if (!( option.state & QStyle::State_Open ) && item->m_unread)
{
CommandDef *lcmdDefUnreadMessages = CorePlugin::instance()->messageTypes.find(item->m_unread);
if (lcmdDefUnreadMessages)
{
img = Image(lcmdDefUnreadMessages->icon);
if (!img.isNull())
{
if (m_uv->m_bUnreadBlink)
p->drawImage(x, (height - img.height()) / 2, img);
x += img.width() + 2;
}
}
}
if (!CorePlugin::instance()->value("UseSysColors").toBool())
p->setPen(CorePlugin::instance()->value("ColorGroup").toUInt());
QFont f(option.font);
if (CorePlugin::instance()->value("SmallGroupFont").toBool())
{
int size = f.pixelSize();
if (size > 0)
f.setPixelSize(size * 3 / 4);
else
{
size = f.pointSize();
f.setPointSize(size * 3 / 4);
}
}
f.setBold(true);
p->setFont(f);
x = drawText(p, x, itemsize, text);
if (CorePlugin::instance()->value("GroupSeparator").toBool())
drawSeparator(p, x, itemsize, m_uv->style());
break;
}
case USR_ITEM:
{
ContactItem *item = static_cast<ContactItem*>(base);
QFont f(option.font);
if (item->style() & CONTACT_ITALIC)
{
if (CorePlugin::instance()->value("VisibleStyle").toUInt() & STYLE_ITALIC)
f.setItalic(true);
if (CorePlugin::instance()->value("VisibleStyle").toUInt() & STYLE_UNDER)
f.setUnderline(true);
if (CorePlugin::instance()->value("VisibleStyle").toUInt() & STYLE_STRIKE)
f.setStrikeOut(true);
}
if (item->style() & CONTACT_UNDERLINE)
{
if (CorePlugin::instance()->value("AuthStyle").toUInt() & STYLE_ITALIC)
f.setItalic(true);
if (CorePlugin::instance()->value("AuthStyle").toUInt() & STYLE_UNDER)
f.setUnderline(true);
if (CorePlugin::instance()->value("AuthStyle").toUInt() & STYLE_STRIKE)
f.setStrikeOut(true);
}
if (item->style() & CONTACT_STRIKEOUT)
{
if (CorePlugin::instance()->value("InvisibleStyle").toUInt() & STYLE_ITALIC)
f.setItalic(true);
if (CorePlugin::instance()->value("InvisibleStyle").toUInt() & STYLE_UNDER)
f.setUnderline(true);
if (CorePlugin::instance()->value("InvisibleStyle").toUInt() & STYLE_STRIKE)
f.setStrikeOut(true);
}
int x = margin;
QIcon mainIcon = index.data( Qt::DecorationRole ).value<QIcon>();
if (!mainIcon.isNull())
{
QPixmap img = mainIcon.pixmap( 16 );
x += 2;
p->drawPixmap(x, ( height - img.height() ) / 2, img);
x += img.width() + 2;
}
if (x < 24)
x = 24;
if (!item->isSelected() || !m_uv->hasFocus() || !CorePlugin::instance()->value("UseDblClick").toBool())
{
if (!CorePlugin::instance()->value("UseSysColors").toBool())
{
switch (item->status())
{
case STATUS_ONLINE:
p->setPen(CorePlugin::instance()->value("ColorOnline").toUInt());
break;
case STATUS_FFC:
p->setPen(CorePlugin::instance()->value("ColorOnline").toUInt());
break;
case STATUS_AWAY:
p->setPen(CorePlugin::instance()->value("ColorAway").toUInt());
break;
case STATUS_NA:
p->setPen(CorePlugin::instance()->value("ColorNA").toUInt());
break;
case STATUS_DND:
p->setPen(CorePlugin::instance()->value("ColorDND").toUInt());
break;
default:
p->setPen(CorePlugin::instance()->value("ColorOffline").toUInt());
break;
}
}
if (item->status() != STATUS_ONLINE && item->status() != STATUS_FFC)
p->setPen(m_uv->palette().color(QPalette::Disabled,QPalette::Text));
}
if (item->m_bBlink)
f.setBold(true);
else
f.setBold(false);
p->setFont(f);
QString highlight;
QString text = index.data( Qt::DisplayRole ).toString();
int pos=0;
if(!m_uv->m_search.isEmpty())
{
pos=text.toUpper().indexOf(m_uv->m_search.toUpper());
//Search for substring in contact name
if (pos > -1)
highlight=text.mid(pos,m_uv->m_search.length());
}
int save_x = x;
//p->setPen(QColor(0, 0, 0));
x = drawText(p, x, itemsize, text);
if (pos > 0)
save_x = drawText(p, save_x, itemsize, text.left(pos)) - 4;
x += 2;
if (!highlight.isEmpty())
{
QPen oldPen = p->pen();
QColor oldBg = p->background().color();
p->setBackgroundMode(Qt::OpaqueMode);
if (item == m_uv->m_searchItem)
if (item == m_uv->currentItem() && CorePlugin::instance()->value("UseDblClick").toBool())
{
p->setBackground(cg.color(QPalette::HighlightedText));
p->setPen(cg.color(QPalette::Highlight));
}
else
{
p->setBackground(cg.color(QPalette::Highlight));
p->setPen(cg.color(QPalette::HighlightedText));
}
else
{
p->setBackground(oldPen.color());
p->setPen(oldBg);
}
drawText(p, save_x, itemsize, highlight);
p->setPen(oldPen);
p->setBackground(oldBg);
p->setBackgroundMode(Qt::TransparentMode);
}
unsigned xIcon = width;
QString icons = index.data( SIM::ExtraIconsRole ).toString();
while( !icons.isEmpty() )
{
QString icon = getToken(icons, ',');
QImage img = Image(icon);
if (!img.isNull())
{
xIcon -= img.width() + 2;
if (xIcon < (unsigned)x)
break;
p->drawImage(xIcon, (height - img.height()) / 2, img);
}
}
break;
}
case DIV_ITEM:
{
QString text = index.data( Qt::DisplayRole ).toString();
QFont f(option.font);
int size = f.pixelSize();
if (size <= 0)
{
size = f.pointSize();
f.setPointSize(size * 3 / 4);
}
else
f.setPixelSize(size * 3 / 4);
p->setFont(f);
int x = drawText(p, 24 + margin, itemsize, text);
drawSeparator(p, x, itemsize, m_uv->style());
break;
}
}
painter->restore();
}
/*!
Paints the border and title decoration for the top-level \a widget
using the \a painter provided and the decoration \a state. The value
of \a decorationRegion is a combination of the bitmask values of
enum DecorationRegion.
Note that Qt for Embedded Linux expects this function to return true if any of
the widget's decorations are repainted; otherwise it returns false.
*/
bool QDecorationDefault::paint(QPainter *painter,
const QWidget *widget,
int decorationRegion,
DecorationState state)
{
if (decorationRegion == None)
return false;
const QRect titleRect = QDecoration::region(widget, Title).boundingRect();
const QPalette pal = QApplication::palette();
int titleHeight = titleRect.height();
int titleWidth = titleRect.width();
QRegion oldClipRegion = painter->clipRegion();
Qt::WindowFlags flags = widget->windowFlags();
bool hasBorder = !widget->isMaximized();
bool hasTitle = flags & Qt::WindowTitleHint;
bool hasSysMenu = flags & Qt::WindowSystemMenuHint;
bool hasContextHelp = flags & Qt::WindowContextHelpButtonHint;
bool hasMinimize = flags & Qt::WindowMinimizeButtonHint;
bool hasMaximize = flags & Qt::WindowMaximizeButtonHint;
bool paintAll = (decorationRegion == int(All));
bool handled = false;
bool porterDuff = painter->paintEngine()->hasFeature(QPaintEngine::PorterDuff);
if ((paintAll || decorationRegion & Borders) && state == Normal && hasBorder) {
if (hasTitle) { // reduce flicker
QRect rect(widget->rect());
QRect r(rect.left(), rect.top() - titleHeight,
rect.width(), titleHeight);
painter->setClipRegion(oldClipRegion - r);
}
QRect br = QDecoration::region(widget).boundingRect();
if (porterDuff)
painter->setCompositionMode(QPainter::CompositionMode_Source);
qDrawWinPanel(painter, br.x(), br.y(), br.width(),
br.height(), pal, false,
&pal.brush(QPalette::Window));
if (porterDuff)
painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
handled |= true;
}
if ((paintAll || decorationRegion & Title && titleWidth > 0) && state == Normal && hasTitle) {
painter->setClipRegion(oldClipRegion);
QBrush titleBrush;
QPen titlePen;
if (widget == qApp->activeWindow()) {
titleBrush = pal.brush(QPalette::Highlight);
titlePen = pal.color(QPalette::HighlightedText);
} else {
titleBrush = pal.brush(QPalette::Window);
titlePen = pal.color(QPalette::Text);
}
if (porterDuff)
painter->setCompositionMode(QPainter::CompositionMode_Source);
qDrawShadePanel(painter,
titleRect.x(), titleRect.y(), titleRect.width(), titleRect.height(),
pal, true, 1, &titleBrush);
if (porterDuff)
painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
painter->setPen(titlePen);
painter->drawText(titleRect.x() + 4, titleRect.y(),
titleRect.width() - 8, titleRect.height(),
Qt::AlignVCenter, windowTitleFor(widget));
handled |= true;
}
if (state != Hover) {
painter->setClipRegion(oldClipRegion);
if ((paintAll || decorationRegion & Menu) && hasSysMenu) {
paintButton(painter, widget, Menu, state, pal);
handled |= true;
}
if ((paintAll || decorationRegion & Help) && hasContextHelp) {
paintButton(painter, widget, Help, state, pal);
handled |= true;
}
if ((paintAll || decorationRegion & Minimize) && hasMinimize) {
paintButton(painter, widget, Minimize, state, pal);
handled |= true;
}
if ((paintAll || decorationRegion & Maximize) && hasMaximize) {
paintButton(painter, widget,
((widget->windowState() & Qt::WindowMaximized)? Normalize : Maximize),
state, pal);
handled |= true;
}
if (paintAll || decorationRegion & Close) {
paintButton(painter, widget, Close, state, pal);
handled |= true;
}
}
return handled;
}
//___________________________________________________
QColor Button::buttonDetailColor( const QPalette& palette, bool active ) const
{ return palette.color( active ? QPalette::Active : QPalette::Disabled, QPalette::ButtonText ); }
QColor Legend::getBackgroundColor() const
{
QPalette legendPalette = palette();
return legendPalette.color(QPalette::Base);
}
void ELabel::display()
{
QPalette palette = this->palette();
if (val.type() == QVariant::Bool)
{
if (val.toBool())
{
if (palette.color(backgroundRole()) != m_trueColor || text() != m_trueString)
{
palette.setColor(backgroundRole(), m_trueColor);
setPalette(palette);
setText(m_trueString);
}
}
else
{
// qDebug() << "val.toBool() e` falso!";
if (palette.color(backgroundRole()) != m_falseColor || m_falseString != text())
{
palette.setColor(backgroundRole(), m_falseColor);
setPalette(palette);
setText(m_falseString);
}
}
}
//else if (val.type() == QVariant::UInt)
else if (val.canConvert(QVariant::UInt) && (v_colors.size()) && (!val.toString().contains("###")))
{
/* Look for the value `val' inside the v_values
* vector, to see if a string and a color were
* configured for that value.
*/
int index = v_values.indexOf(val.toUInt());
if (index != -1)
{
if(palette.color(backgroundRole()) != v_colors[index])
{
palette.setColor(backgroundRole(), v_colors[index]);
setPalette(palette);
}
setText(v_strings[index]);
}
else /* No string nor a colour for that value! */
{
if(palette.color(backgroundRole()) != QColor("white"))
{
palette.setColor(backgroundRole(), QColor("white") );
setPalette(palette);
}
setText(QString("No match for value %1!").arg(val.toUInt() ) );
}
// setPalette(pal);
}
else
{
QString s = val.toString();
if (s.contains("###"))
{
if(palette.color(backgroundRole()) != QColor("white"))
{
pal.setColor(backgroundRole(), Qt::white);
setPalette(pal);
}
}
setText(val.toString());
}
qDebug() << "text(): " << text() << "m_trueString: " << m_trueString << "m_falseString: " << m_falseString;
// QLabel::paintEvent(e);
}
ConfigDialog::ConfigDialog(QWidget* parent) : QDialog(parent)
{
setupUi(this);
_buttonBox->button(QDialogButtonBox::Apply)->setFocusPolicy(Qt::NoFocus);
_buttonBox->button(QDialogButtonBox::Ok)->setFocusPolicy(Qt::NoFocus);
_buttonBox->button(QDialogButtonBox::Cancel)->setFocusPolicy(Qt::NoFocus);
connect(_buttonBox->button(QDialogButtonBox::Apply), SIGNAL(clicked()),
this, SIGNAL(applied()));
connect(_buttonBox->button(QDialogButtonBox::Ok), SIGNAL(clicked()),
this, SLOT(ok()));
connect(_buttonBox->button(QDialogButtonBox::Cancel), SIGNAL(clicked()),
this, SLOT(hide()));
_comboBoxVo->setSizeAdjustPolicy(QComboBox::AdjustToContents);
_comboBoxVoClipping->setSizeAdjustPolicy(QComboBox::AdjustToContents);
_comboBoxAo->setSizeAdjustPolicy(QComboBox::AdjustToContents);
QString voToolTip = tr(
"使用するビデオドライバになります。\n"
"初期設定は「%1」になります。");
QString voNameDefault = ConfigData::VONAME_DEFAULT;
if( voNameDefault.isEmpty() )
voNameDefault = tr("指定無し");
_comboBoxVo->setToolTip(voToolTip.arg(voNameDefault));
QString voClippingToolTip = tr(
"クリッピング機能使用時に自動で切り替えるビデオドライバになります。\n"
"クリッピングが正常に機能するかは、選択するビデオドライバに依存します。\n"
"初期設定は「%1」になります。");
QString voNameForClippingDefault = ConfigData::VONAME_FOR_CLIPPING_DEFAULT;
if( voNameForClippingDefault.isEmpty() )
voNameForClippingDefault = tr("指定無し");
_comboBoxVoClipping->setToolTip(voClippingToolTip.arg(voNameForClippingDefault));
QString aoToolTip = tr(
"使用するオーディオドライバになります。\n"
"初期設定は「%1」になります。");
QString aoNameDefault = ConfigData::AONAME_DEFAULT;
if( aoNameDefault.isEmpty() )
aoNameDefault = tr("指定無し");
_comboBoxAo->setToolTip(aoToolTip.arg(aoNameDefault));
#ifdef Q_OS_LINUX
#ifdef QT_NO_DEBUG_OUTPUT
_checkBoxSoftVideoEq->setEnabled(false);
#else
connect(_checkBoxSoftVideoEq, SIGNAL(clicked(bool)),
this, SLOT(checkBoxSoftVideoEq_clicked(bool)));
#endif // QT_NO_DEBUG_OUTPUT
#else
_checkBoxSoftVideoEq->setEnabled(false);
#endif // Q_OS_LINUX
_groupBoxCacheSize->setFocusPolicy(Qt::NoFocus); // qtデザイナでは効果無し、ここで指定
connect(_groupBoxCacheSize, SIGNAL(toggled(bool)), // checkBoxを切り替えた時のspinBoxの選択状態を解除する
this, SLOT(groupBoxCacheSize_toggled(bool)));
_groupBoxScreenshotPath->setFocusPolicy(Qt::NoFocus);
_groupBoxMplayerPath->setFocusPolicy(Qt::NoFocus);
_groupBoxLimitLogLine->setFocusPolicy(Qt::NoFocus);
connect(_groupBoxLimitLogLine, SIGNAL(toggled(bool)),
this, SLOT(groupBoxLimitLogLine_toggled(bool)));
_groupBoxContactUrlPath->setFocusPolicy(Qt::NoFocus);
QPalette palette = _groupBoxCacheSize->palette();
QColor colorText = palette.color(QPalette::Text);
palette.setColor(QPalette::Active, QPalette::Text, palette.color(QPalette::WindowText));
palette.setColor(QPalette::Inactive, QPalette::Text, palette.color(QPalette::WindowText));
_groupBoxCacheSize->setPalette(palette);
_groupBoxScreenshotPath->setPalette(palette);
_groupBoxMplayerPath->setPalette(palette);
_groupBoxContactUrlPath->setPalette(palette);
palette.setColor(QPalette::Active, QPalette::Text, colorText);
palette.setColor(QPalette::Inactive, QPalette::Text, colorText);
_spinBoxCacheStream->setPalette(palette);
_lineEditScreenshotPath->setPalette(palette);
_lineEditMplayerPath->setPalette(palette);
_lineEditContactUrlPath->setPalette(palette);
_lineEditContactUrlArg->setPalette(palette);
connect(_buttonScreenshotPath, SIGNAL(clicked()), this, SLOT(setScreenshotPathFromDialog()));
connect(_buttonMplayerPath, SIGNAL(clicked()), this, SLOT(setMplayerPathFromDialog()));
connect(_buttonContactUrlPath, SIGNAL(clicked()), this, SLOT(setContactUrlPathFromDialog()));
connect(_buttonContactUrlArg, SIGNAL(clicked()), this, SLOT(buttonContactUrlArg_clicked()));
// コンタクトURLパス指定部のエディットボックスの幅設定
int w = _lineEditContactUrlArg->fontMetrics().width(ConfigData::CONTACTURL_ARG_DEFAULT) + 20;
_lineEditContactUrlArg->setMinimumWidth(w);
_lineEditContactUrlPath->setMinimumWidth(w);
// コンタクトURLパス選択ボタン、引数ボタンの幅設定
w = _buttonContactUrlPath->fontMetrics().width(_buttonContactUrlPath->text()) + 14;
if( w < 30 )
w = 30;
if( w < _buttonContactUrlPath->sizeHint().width() )
_buttonContactUrlPath->setMaximumWidth(w);
w = _buttonContactUrlArg->fontMetrics().width(_buttonContactUrlArg->text()) + 14;
if( w < 30 )
w = 30;
if( w < _buttonContactUrlArg->sizeHint().width() )
_buttonContactUrlArg->setMaximumWidth(w);
resize(10,10);
}
//! [paint start]
bool MyDecoration::paint(QPainter *painter, const QWidget *widget,
int decorationRegion, DecorationState state)
{
if (decorationRegion == None)
return false;
//! [paint start]
//! [paint different regions]
bool handled = false;
QPalette palette = QApplication::palette();
QHash<DecorationRegion, QPixmap> buttonPixmaps;
if (widget->windowState() == Qt::WindowMaximized)
buttonPixmaps = maximizedButtonPixmaps;
else
buttonPixmaps = normalButtonPixmaps;
if (decorationRegion & Title) {
QRect rect = QDecoration::region(widget, Title).boundingRect();
painter->fillRect(rect, palette.brush(QPalette::Base));
painter->save();
painter->setPen(QPen(palette.color(QPalette::Text)));
painter->drawText(rect, Qt::AlignCenter, widget->windowTitle());
painter->restore();
handled = true;
}
if (decorationRegion & Top) {
QRect rect = QDecoration::region(widget, Top).boundingRect();
painter->fillRect(rect, palette.brush(QPalette::Dark));
handled = true;
}
if (decorationRegion & Left) {
QRect rect = QDecoration::region(widget, Left).boundingRect();
painter->fillRect(rect, palette.brush(QPalette::Dark));
handled = true;
}
if (decorationRegion & Right) {
QRect rect = QDecoration::region(widget, Right).boundingRect();
painter->fillRect(rect, palette.brush(QPalette::Dark));
handled = true;
}
if (decorationRegion & Bottom) {
QRect rect = QDecoration::region(widget, Bottom).boundingRect();
painter->fillRect(rect, palette.brush(QPalette::Dark));
handled = true;
}
if (decorationRegion & TopLeft) {
QRect rect = QDecoration::region(widget, TopLeft).boundingRect();
painter->fillRect(rect, palette.brush(QPalette::Dark));
handled = true;
}
if (decorationRegion & TopRight) {
QRect rect = QDecoration::region(widget, TopRight).boundingRect();
painter->fillRect(rect, palette.brush(QPalette::Dark));
handled = true;
}
if (decorationRegion & BottomLeft) {
QRect rect = QDecoration::region(widget, BottomLeft).boundingRect();
painter->fillRect(rect, palette.brush(QPalette::Dark));
handled = true;
}
if (decorationRegion & BottomRight) {
QRect rect = QDecoration::region(widget, BottomRight).boundingRect();
painter->fillRect(rect, palette.brush(QPalette::Dark));
handled = true;
}
//! [paint different regions]
//! [paint buttons]
int margin = (titleHeight - 16) / 2;
Qt::WindowFlags flags = widget->windowFlags();
foreach (DecorationRegion testRegion, stateRegions) {
if (decorationRegion & testRegion && flags & buttonHintMap.key(testRegion)) {
QRect rect = QDecoration::region(
widget, testRegion).boundingRect();
painter->fillRect(rect, palette.brush(QPalette::Base));
QRect buttonRect = rect.adjusted(0, margin, -buttonMargin - margin,
-buttonMargin);
painter->drawPixmap(buttonRect.topLeft(), buttonPixmaps[testRegion]);
handled = true;
}
}
//! [paint buttons]
//! [paint end]
return handled;
}
void QScriptEdit::extraAreaPaintEvent(QPaintEvent *e)
{
QRect rect = e->rect();
QPalette pal = palette();
pal.setCurrentColorGroup(QPalette::Active);
QPainter painter(m_extraArea);
painter.fillRect(rect, Qt::lightGray);
const QFontMetrics fm(fontMetrics());
int markWidth = fm.lineSpacing();
int extraAreaWidth = m_extraArea->width();
QLinearGradient gradient(QPointF(extraAreaWidth - 10, 0), QPointF(extraAreaWidth, 0));
gradient.setColorAt(0, pal.color(QPalette::Background));
gradient.setColorAt(1, pal.color(QPalette::Base));
painter.fillRect(rect, gradient);
QLinearGradient gradient2(QPointF(0, 0), QPointF(markWidth, 0));
gradient2.setColorAt(0, pal.color(QPalette::Dark));
gradient2.setColorAt(1, pal.color(QPalette::Background));
painter.fillRect(rect.intersected(QRect(rect.x(), rect.y(), markWidth, rect.height())), gradient2);
painter.setPen(QPen(pal.color(QPalette::Background), 2));
if (isLeftToRight())
painter.drawLine(rect.x() + extraAreaWidth-1, rect.top(), rect.x() + extraAreaWidth-1, rect.bottom());
else
painter.drawLine(rect.x(), rect.top(), rect.x(), rect.bottom());
painter.setRenderHint(QPainter::Antialiasing);
#ifndef QT_NO_SYNTAXHIGHLIGHTER
QTextBlock block = firstVisibleBlock();
int blockNumber = block.blockNumber();
qreal top = blockBoundingGeometry(block).translated(contentOffset()).top();
qreal bottom = top + blockBoundingRect(block).height();
QString imagesPath = QString::fromLatin1(":/qt/scripttools/debugging/images");
QString imageExt;
// SVGs don't work on all platforms, even when QT_NO_SVG is not defined, so disable SVG usage for now.
// #ifndef QT_NO_SVG
#if 0
imageExt = QString::fromLatin1("svg");
#else
imageExt = QString::fromLatin1("png");
#endif
while (block.isValid() && top <= rect.bottom()) {
if (block.isVisible() && bottom >= rect.top()) {
int lineNumber = blockNumber + m_baseLineNumber;
if (m_breakpoints.contains(lineNumber)) {
int radius = fm.lineSpacing() - 1;
QRect r(rect.x(), (int)top, radius, radius);
QIcon icon(m_breakpoints[lineNumber].enabled
? QString::fromLatin1("%0/breakpoint.%1").arg(imagesPath).arg(imageExt)
: QString::fromLatin1("%0/d_breakpoint.%1").arg(imagesPath).arg(imageExt));
icon.paint(&painter, r, Qt::AlignCenter);
}
if (m_executionLineNumber == lineNumber) {
int radius = fm.lineSpacing() - 1;
QRect r(rect.x(), (int)top, radius, radius);
QIcon icon(QString::fromLatin1("%0/location.%1").arg(imagesPath).arg(imageExt));
icon.paint(&painter, r, Qt::AlignCenter);
}
if (!isExecutableLine(lineNumber))
painter.setPen(pal.color(QPalette::Mid));
else
painter.setPen(QColor(Qt::darkCyan));
QString number = QString::number(lineNumber);
painter.drawText(rect.x() + markWidth, (int)top, rect.x() + extraAreaWidth - markWidth - 4,
fm.height(), Qt::AlignRight, number);
}
block = block.next();
top = bottom;
bottom = top + blockBoundingRect(block).height();
++blockNumber;
}
#endif
}
QT_BEGIN_NAMESPACE
/*!
\headerfile <qdrawutil.h>
\title Drawing Utility Functions
\sa QPainter
*/
/*!
\fn void qDrawShadeLine(QPainter *painter, int x1, int y1, int x2, int y2,
const QPalette &palette, bool sunken,
int lineWidth, int midLineWidth)
\relates <qdrawutil.h>
Draws a horizontal (\a y1 == \a y2) or vertical (\a x1 == \a x2)
shaded line using the given \a painter. Note that nothing is
drawn if \a y1 != \a y2 and \a x1 != \a x2 (i.e. the line is
neither horizontal nor vertical).
The provided \a palette specifies the shading colors (\l
{QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
{QPalette::mid()}{middle} colors). The given \a lineWidth
specifies the line width for each of the lines; it is not the
total line width. The given \a midLineWidth specifies the width of
a middle line drawn in the QPalette::mid() color.
The line appears sunken if \a sunken is true, otherwise raised.
\warning This function does not look at QWidget::style() or
QApplication::style(). Use the drawing functions in QStyle to
make widgets that follow the current GUI style.
Alternatively you can use a QFrame widget and apply the
QFrame::setFrameStyle() function to display a shaded line:
\snippet code/src_gui_painting_qdrawutil.cpp 0
\sa qDrawShadeRect(), qDrawShadePanel(), QStyle
*/
void qDrawShadeLine(QPainter *p, int x1, int y1, int x2, int y2,
const QPalette &pal, bool sunken,
int lineWidth, int midLineWidth)
{
if (!(p && lineWidth >= 0 && midLineWidth >= 0)) {
qWarning("qDrawShadeLine: Invalid parameters");
return;
}
int tlw = lineWidth*2 + midLineWidth; // total line width
QPen oldPen = p->pen(); // save pen
if (sunken)
p->setPen(pal.color(QPalette::Dark));
else
p->setPen(pal.light().color());
QPolygon a;
int i;
if (y1 == y2) { // horizontal line
int y = y1 - tlw/2;
if (x1 > x2) { // swap x1 and x2
int t = x1;
x1 = x2;
x2 = t;
}
x2--;
for (i=0; i<lineWidth; i++) { // draw top shadow
a.setPoints(3, x1+i, y+tlw-1-i,
x1+i, y+i,
x2-i, y+i);
p->drawPolyline(a);
}
if (midLineWidth > 0) {
p->setPen(pal.mid().color());
for (i=0; i<midLineWidth; i++) // draw lines in the middle
p->drawLine(x1+lineWidth, y+lineWidth+i,
x2-lineWidth, y+lineWidth+i);
}
if (sunken)
p->setPen(pal.light().color());
else
p->setPen(pal.dark().color());
for (i=0; i<lineWidth; i++) { // draw bottom shadow
a.setPoints(3, x1+i, y+tlw-i-1,
x2-i, y+tlw-i-1,
x2-i, y+i+1);
p->drawPolyline(a);
}
}
else if (x1 == x2) { // vertical line
int x = x1 - tlw/2;
if (y1 > y2) { // swap y1 and y2
int t = y1;
y1 = y2;
y2 = t;
}
y2--;
for (i=0; i<lineWidth; i++) { // draw left shadow
a.setPoints(3, x+i, y2,
x+i, y1+i,
x+tlw-1, y1+i);
p->drawPolyline(a);
}
if (midLineWidth > 0) {
p->setPen(pal.mid().color());
for (i=0; i<midLineWidth; i++) // draw lines in the middle
p->drawLine(x+lineWidth+i, y1+lineWidth, x+lineWidth+i, y2);
}
if (sunken)
p->setPen(pal.light().color());
else
p->setPen(pal.dark().color());
for (i=0; i<lineWidth; i++) { // draw right shadow
a.setPoints(3, x+lineWidth, y2-i,
x+tlw-i-1, y2-i,
x+tlw-i-1, y1+lineWidth);
p->drawPolyline(a);
}
}
p->setPen(oldPen);
}
virtual void paintEvent(QPaintEvent *ev)
{
if (tickPosition() == QSlider::NoTicks)
return QSlider::paintEvent(ev);
QPainter p(this);
QStyleOptionSlider option;
initStyleOption(&option);
const int& ticks( option.tickPosition );
const int available(style()->proxy()->pixelMetric(QStyle::PM_SliderSpaceAvailable, &option, this));
int interval = option.tickInterval;
if( interval < 1 ) interval = option.pageStep;
if( interval < 1 ) return;
const QRect& r(option.rect);
const QPalette palette(option.palette);
const int fudge(style()->proxy()->pixelMetric(QStyle::PM_SliderLength, &option, this) / 2);
int current(option.minimum);
int nextLabel = current;
QFontMetrics fm(font());
int h = fm.height() + 3;
int w = fm.width(QString::number(option.maximum)) + 3;
if(available<w)
nextLabel = -1;
float i = available/(orientation() == Qt::Horizontal ? w : h);
float t = option.maximum/interval;
int valStep = t/ i + 1;
// Since there is no subrect for tickmarks do a translation here.
p.save();
p.translate(r.x(), r.y());
p.setPen(palette.color(QPalette::WindowText));
int extra = (option.tickPosition == QSlider::TicksBothSides ? 2 : 1);
int tickSize(option.orientation == Qt::Horizontal ? (r.height() - h*extra)/3:(r.width() - w*extra)/3);
while(current <= option.maximum)
{
const int position(QStyle::sliderPositionFromValue(option.minimum, option.maximum,
current, available, option.upsideDown) + fudge);
// calculate positions
if(option.orientation == Qt::Horizontal)
{
if (ticks & QSlider::TicksAbove) {
p.drawLine(position, h, position, tickSize + h);
if(current == nextLabel)
p.drawText(QRect(position - w/2, 0, w, h), Qt::AlignHCenter, QString::number(current));
}
if (ticks & QSlider::TicksBelow) {
p.drawLine( position, r.height() - h - tickSize, position, r.height() - h );
if(current == nextLabel)
p.drawText(QRect(position - w/2, r.height() - h + 3, w, h), Qt::AlignHCenter, QString::number(current));
}
} else {
if (ticks & QSlider::TicksAbove) {
p.drawLine(w, position, tickSize + w, position);
if(current == nextLabel)
p.drawText(QRect(0, position - h/2, w - 3, h), Qt::AlignRight | Qt::AlignVCenter, QString::number(current));
}
if (ticks & QSlider::TicksBelow) {
p.drawLine(r.width() - w - tickSize, position, r.width() - w, position );
if(current == nextLabel)
p.drawText(QRect(r.width() - w + 3, position - h/2, w, h), Qt::AlignVCenter, QString::number(current));
}
}
// go to next position
if (current == nextLabel)
nextLabel += interval*valStep;
current += interval;
}
p.restore();
option.subControls = QStyle::SC_SliderGroove | QStyle::SC_SliderHandle;
style()->proxy()->drawComplexControl(QStyle::CC_Slider, &option, &p, this);
}
void KviTalWizard::setCurrentPage(KviTalWizardPageData * pData)
{
m_p->pCurrentPage = pData;
bool bCancelEnabled = true;
bool bNextEnabled = false;
bool bBackEnabled = false;
bool bHelpEnabled = false;
bool bFinishEnabled = false;
QString szTitle;
QString szSteps;
bool bHaveNextPage = false;
bool bHavePrevPage = false;
if(pData)
{
bHavePrevPage = m_p->findPrevEnabledPage(pData->pWidget);
bHaveNextPage = m_p->findNextEnabledPage(pData->pWidget);
bNextEnabled = (pData->iEnableFlags & KviTalWizardPageData::EnableNext) && bHaveNextPage;
bBackEnabled = (pData->iEnableFlags & KviTalWizardPageData::EnableBack) && bHavePrevPage;
bCancelEnabled = (pData->iEnableFlags & KviTalWizardPageData::EnableCancel);
bFinishEnabled = (pData->iEnableFlags & KviTalWizardPageData::EnableFinish);
bHelpEnabled = (pData->iEnableFlags & KviTalWizardPageData::EnableHelp);
m_p->pWidgetStack->setCurrentWidget(pData->pWidget);
szTitle = "<b>";
szTitle += pData->szTitle;
szTitle += "</b>";
QPalette pal = m_p->pStepsLabel->palette();
QColor clrWin = pal.color(QPalette::Normal,QPalette::Window);
QColor clrTxt = pal.color(QPalette::Normal,QPalette::WindowText);
QColor clrMid = qRgb(
(clrWin.red() + clrTxt.red()) / 2,
(clrWin.green() + clrTxt.green()) / 2,
(clrWin.blue() + clrTxt.blue()) / 2
);
szSteps = "<nobr><font color=\"";
szSteps += clrMid.name();
szSteps += "\"><b>[";
szSteps += QString("Step %1 of %2").arg(pData->iVisibleIndex).arg(m_p->iEnabledPageCount);
szSteps += "]</b></font></nobr>";
}
m_p->pTitleLabel->setText(szTitle);
m_p->pStepsLabel->setText(szSteps);
m_p->pNextButton->setEnabled(bNextEnabled);
if(bHaveNextPage)
{
m_p->pNextButton->show();
m_p->pNextSpacer->show();
m_p->pNextButton->setDefault(true);
} else {
m_p->pNextButton->hide();
m_p->pNextSpacer->hide();
m_p->pNextButton->setDefault(false);
}
m_p->pBackButton->setEnabled(bBackEnabled);
if(bHavePrevPage)
m_p->pBackButton->show();
else
m_p->pBackButton->hide();
m_p->pHelpButton->setEnabled(bHelpEnabled);
if(bHelpEnabled)
m_p->pHelpButton->show();
else
m_p->pHelpButton->hide();
m_p->pCancelButton->setEnabled(bCancelEnabled);
m_p->pFinishButton->setEnabled(bFinishEnabled);
if(bFinishEnabled)
{
m_p->pFinishButton->show();
m_p->pFinishSpacer->show();
m_p->pFinishButton->setDefault(true);
} else {
m_p->pFinishButton->hide();
m_p->pFinishSpacer->hide();
m_p->pFinishButton->setDefault(false);
}
}
TextEditorSettings::TextEditorSettings(QObject *parent)
: QObject(parent)
{
QTC_ASSERT(!m_instance, return);
m_instance = this;
ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
// Note: default background colors are coming from FormatDescription::background()
// Add font preference page
FormatDescriptions formatDescriptions;
formatDescriptions.push_back(FormatDescription(QLatin1String(C_TEXT), tr("Text")));
// Special categories
const QPalette p = QApplication::palette();
formatDescriptions.push_back(FormatDescription(QLatin1String(C_LINK), tr("Link"), Qt::blue));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_SELECTION), tr("Selection"), p.color(QPalette::HighlightedText)));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_LINE_NUMBER), tr("Line Number")));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_SEARCH_RESULT), tr("Search Result")));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_SEARCH_SCOPE), tr("Search Scope")));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_PARENTHESES), tr("Parentheses")));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_CURRENT_LINE), tr("Current Line")));
// Standard categories
formatDescriptions.push_back(FormatDescription(QLatin1String(C_NUMBER), tr("Number"), Qt::darkBlue));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_STRING), tr("String"), Qt::darkGreen));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_TYPE), tr("Type"), Qt::darkMagenta));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_KEYWORD), tr("Keyword"), Qt::darkYellow));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_OPERATOR), tr("Operator")));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_PREPROCESSOR), tr("Preprocessor"), Qt::darkBlue));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_LABEL), tr("Label"), Qt::darkRed));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_COMMENT), tr("Comment"), Qt::darkGreen));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_DOXYGEN_COMMENT), tr("Doxygen Comment"), Qt::darkBlue));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_DOXYGEN_TAG), tr("Doxygen Tag"), Qt::blue));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_DISABLED_CODE), tr("Disabled Code"), Qt::gray));
// Diff categories
formatDescriptions.push_back(FormatDescription(QLatin1String(C_ADDED_LINE), tr("Added Line"), QColor(0, 170, 0)));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_REMOVED_LINE), tr("Removed Line"), Qt::red));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_DIFF_FILE), tr("Diff File"), Qt::darkBlue));
formatDescriptions.push_back(FormatDescription(QLatin1String(C_DIFF_LOCATION), tr("Diff Location"), Qt::blue));
m_fontSettingsPage = new FontSettingsPage(formatDescriptions,
QLatin1String("TextEditor"),
tr("Text Editor"),
this);
pm->addObject(m_fontSettingsPage);
// Add the GUI used to configure the tab, storage and interaction settings
TextEditor::BehaviorSettingsPageParameters behaviorSettingsPageParameters;
behaviorSettingsPageParameters.name = tr("Behavior");
behaviorSettingsPageParameters.category = QLatin1String("TextEditor");
behaviorSettingsPageParameters.trCategory = tr("Text Editor");
behaviorSettingsPageParameters.settingsPrefix = QLatin1String("text");
m_behaviorSettingsPage = new BehaviorSettingsPage(behaviorSettingsPageParameters, this);
pm->addObject(m_behaviorSettingsPage);
TextEditor::DisplaySettingsPageParameters displaySettingsPageParameters;
displaySettingsPageParameters.name = tr("Display");
displaySettingsPageParameters.category = QLatin1String("TextEditor");
displaySettingsPageParameters.trCategory = tr("Text Editor");
displaySettingsPageParameters.settingsPrefix = QLatin1String("text");
m_displaySettingsPage = new DisplaySettingsPage(displaySettingsPageParameters, this);
pm->addObject(m_displaySettingsPage);
connect(m_fontSettingsPage, SIGNAL(changed(TextEditor::FontSettings)),
this, SIGNAL(fontSettingsChanged(TextEditor::FontSettings)));
connect(m_behaviorSettingsPage, SIGNAL(tabSettingsChanged(TextEditor::TabSettings)),
this, SIGNAL(tabSettingsChanged(TextEditor::TabSettings)));
connect(m_behaviorSettingsPage, SIGNAL(storageSettingsChanged(TextEditor::StorageSettings)),
this, SIGNAL(storageSettingsChanged(TextEditor::StorageSettings)));
connect(m_displaySettingsPage, SIGNAL(displaySettingsChanged(TextEditor::DisplaySettings)),
this, SIGNAL(displaySettingsChanged(TextEditor::DisplaySettings)));
}
QWidget *MemcheckErrorDelegate::createDetailsWidget(const QModelIndex &errorIndex, QWidget *parent) const
{
QWidget *widget = new QWidget(parent);
QVBoxLayout *layout = new QVBoxLayout;
// code + white-space:pre so the padding (see below) works properly
// don't include frameName here as it should wrap if required and pre-line is not supported
// by Qt yet it seems
const QString displayTextTemplate = QString("<code style='white-space:pre'>%1:</code> %2");
QString relativeTo = relativeToPath();
const Error error = errorIndex.data(ErrorListModel::ErrorRole).value<Error>();
QLabel *errorLabel = new QLabel();
errorLabel->setWordWrap(true);
errorLabel->setContentsMargins(0, 0, 0, 0);
errorLabel->setMargin(0);
errorLabel->setIndent(0);
QPalette p = errorLabel->palette();
QColor lc = p.color(QPalette::Text);
QString linkStyle = QString("style=\"color:rgba(%1, %2, %3, %4);\"")
.arg(lc.red()).arg(lc.green()).arg(lc.blue()).arg(int(0.7 * 255));
p.setBrush(QPalette::Text, p.highlightedText());
errorLabel->setPalette(p);
errorLabel->setText(QString("%1 <span %4>%2</span>")
.arg(error.what(), errorLocation(errorIndex, error, true, linkStyle),
linkStyle));
connect(errorLabel, SIGNAL(linkActivated(QString)), SLOT(openLinkInEditor(QString)));
layout->addWidget(errorLabel);
const QVector<Stack> stacks = error.stacks();
for (int i = 0; i < stacks.count(); ++i) {
const Stack &stack = stacks.at(i);
// auxwhat for additional stacks
if (i > 0) {
QLabel *stackLabel = new QLabel(stack.auxWhat());
stackLabel->setWordWrap(true);
stackLabel->setContentsMargins(0, 0, 0, 0);
stackLabel->setMargin(0);
stackLabel->setIndent(0);
QPalette p = stackLabel->palette();
p.setBrush(QPalette::Text, p.highlightedText());
stackLabel->setPalette(p);
layout->addWidget(stackLabel);
}
int frameNr = 1;
foreach (const Frame &frame, stack.frames()) {
QString frameName = makeFrameName(frame, relativeTo);
QTC_ASSERT(!frameName.isEmpty(), qt_noop());
QLabel *frameLabel = new QLabel(widget);
frameLabel->setAutoFillBackground(true);
if (frameNr % 2 == 0) {
// alternating rows
QPalette p = frameLabel->palette();
p.setBrush(QPalette::Base, p.alternateBase());
frameLabel->setPalette(p);
}
frameLabel->setFont(QFont("monospace"));
connect(frameLabel, SIGNAL(linkActivated(QString)), SLOT(openLinkInEditor(QString)));
// pad frameNr to 2 chars since only 50 frames max are supported by valgrind
const QString displayText = displayTextTemplate
.arg(frameNr++, 2).arg(frameName);
frameLabel->setText(displayText);
frameLabel->setToolTip(Valgrind::XmlProtocol::toolTipForFrame(frame));
frameLabel->setWordWrap(true);
frameLabel->setContentsMargins(0, 0, 0, 0);
frameLabel->setMargin(0);
frameLabel->setIndent(10);
layout->addWidget(frameLabel);
}
}
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
widget->setLayout(layout);
return widget;
}
QwtCompass *CompassGrid::createCompass( int pos )
{
int c;
QPalette palette0;
for ( c = 0; c < QPalette::NColorRoles; c++ )
palette0.setColor( ( QPalette::ColorRole )c, QColor() );
palette0.setColor( QPalette::Base,
palette().color( backgroundRole() ).light( 120 ) );
palette0.setColor( QPalette::WindowText,
palette0.color( QPalette::Base ) );
QwtCompass *compass = new QwtCompass( this );
compass->setLineWidth( 4 );
compass->setFrameShadow(
pos <= 2 ? QwtCompass::Sunken : QwtCompass::Raised );
switch( pos )
{
case 0:
{
/*
A compass with a rose and no needle. Scale and rose are
rotating.
*/
compass->setMode( QwtCompass::RotateScale );
QwtSimpleCompassRose *rose = new QwtSimpleCompassRose( 16, 2 );
rose->setWidth( 0.15 );
compass->setRose( rose );
break;
}
case 1:
{
/*
A windrose, with a scale indicating the main directions only
*/
QMap<double, QString> map;
map.insert( 0.0, "N" );
map.insert( 90.0, "E" );
map.insert( 180.0, "S" );
map.insert( 270.0, "W" );
compass->setLabelMap( map );
QwtSimpleCompassRose *rose = new QwtSimpleCompassRose( 4, 1 );
compass->setRose( rose );
compass->setNeedle(
new QwtCompassWindArrow( QwtCompassWindArrow::Style2 ) );
compass->setValue( 60.0 );
break;
}
case 2:
{
/*
A compass with a rotating needle in darkBlue. Shows
a ticks for each degree.
*/
palette0.setColor( QPalette::Base, Qt::darkBlue );
palette0.setColor( QPalette::WindowText,
QColor( Qt::darkBlue ).dark( 120 ) );
palette0.setColor( QPalette::Text, Qt::white );
compass->setScaleComponents(
QwtAbstractScaleDraw::Ticks | QwtAbstractScaleDraw::Labels );
compass->setScaleTicks( 1, 1, 3 );
compass->setScale( 36, 5, 0 );
compass->setNeedle(
new QwtCompassMagnetNeedle( QwtCompassMagnetNeedle::ThinStyle ) );
compass->setValue( 220.0 );
break;
}
case 3:
{
/*
A compass without a frame, showing numbers as tick labels.
The origin is at 220.0
*/
palette0.setColor( QPalette::Base,
palette().color( backgroundRole() ) );
palette0.setColor( QPalette::WindowText, Qt::blue );
compass->setLineWidth( 0 );
compass->setScaleComponents( QwtAbstractScaleDraw::Backbone |
QwtAbstractScaleDraw::Ticks | QwtAbstractScaleDraw::Labels );
compass->setScaleTicks( 0, 0, 3 );
QMap<double, QString> map;
for ( double d = 0.0; d < 360.0; d += 60.0 )
{
QString label;
label.sprintf( "%.0f", d );
map.insert( d, label );
}
compass->setLabelMap( map );
compass->setScale( 36, 5, 0 );
compass->setNeedle( new QwtDialSimpleNeedle( QwtDialSimpleNeedle::Ray,
true, Qt::white ) );
compass->setOrigin( 220.0 );
compass->setValue( 20.0 );
break;
}
case 4:
{
/*
A compass showing another needle
*/
compass->setScaleComponents(
QwtAbstractScaleDraw::Ticks | QwtAbstractScaleDraw::Labels );
compass->setScaleTicks( 0, 0, 3 );
compass->setNeedle( new QwtCompassMagnetNeedle(
QwtCompassMagnetNeedle::TriangleStyle, Qt::white, Qt::red ) );
compass->setValue( 220.0 );
break;
}
case 5:
{
/*
A compass with a yellow on black ray
*/
palette0.setColor( QPalette::WindowText, Qt::black );
compass->setNeedle( new QwtDialSimpleNeedle( QwtDialSimpleNeedle::Ray,
false, Qt::yellow ) );
compass->setValue( 315.0 );
break;
}
}
QPalette newPalette = compass->palette();
for ( c = 0; c < QPalette::NColorRoles; c++ )
{
const QPalette::ColorRole colorRole = ( QPalette::ColorRole ) c;
if ( palette0.color( colorRole ).isValid() )
newPalette.setColor( colorRole, palette0.color( colorRole ) );
}
for ( int i = 0; i < QPalette::NColorGroups; i++ )
{
QPalette::ColorGroup colorGroup = ( QPalette::ColorGroup )i;
const QColor light =
newPalette.color( colorGroup, QPalette::Base ).light( 170 );
const QColor dark = newPalette.color( colorGroup, QPalette::Base ).dark( 170 );
const QColor mid = compass->frameShadow() == QwtDial::Raised
? newPalette.color( colorGroup, QPalette::Base ).dark( 110 )
: newPalette.color( colorGroup, QPalette::Base ).light( 110 );
newPalette.setColor( colorGroup, QPalette::Dark, dark );
newPalette.setColor( colorGroup, QPalette::Mid, mid );
newPalette.setColor( colorGroup, QPalette::Light, light );
}
compass->setPalette( newPalette );
return compass;
}
void QwtPainter::drawRoundedFrame( QPainter *painter,
const QRectF &rect, double xRadius, double yRadius,
const QPalette &palette, int lineWidth, int frameStyle )
{
painter->save();
painter->setRenderHint( QPainter::Antialiasing, true );
painter->setBrush( Qt::NoBrush );
double lw2 = lineWidth * 0.5;
QRectF r = rect.adjusted( lw2, lw2, -lw2, -lw2 );
QPainterPath path;
path.addRoundedRect( r, xRadius, yRadius );
enum Style
{
Plain,
Sunken,
Raised
};
Style style = Plain;
if ( (frameStyle & QFrame::Sunken) == QFrame::Sunken )
style = Sunken;
else if ( (frameStyle & QFrame::Raised) == QFrame::Raised )
style = Raised;
if ( style != Plain && path.elementCount() == 17 )
{
// move + 4 * ( cubicTo + lineTo )
QPainterPath pathList[8];
for ( int i = 0; i < 4; i++ )
{
const int j = i * 4 + 1;
pathList[ 2 * i ].moveTo(
path.elementAt(j - 1).x, path.elementAt( j - 1 ).y
);
pathList[ 2 * i ].cubicTo(
path.elementAt(j + 0).x, path.elementAt(j + 0).y,
path.elementAt(j + 1).x, path.elementAt(j + 1).y,
path.elementAt(j + 2).x, path.elementAt(j + 2).y );
pathList[ 2 * i + 1 ].moveTo(
path.elementAt(j + 2).x, path.elementAt(j + 2).y
);
pathList[ 2 * i + 1 ].lineTo(
path.elementAt(j + 3).x, path.elementAt(j + 3).y
);
}
QColor c1( palette.color( QPalette::Dark ) );
QColor c2( palette.color( QPalette::Light ) );
if ( style == Raised )
qSwap( c1, c2 );
for ( int i = 0; i < 4; i++ )
{
QRectF r = pathList[2 * i].controlPointRect();
QPen arcPen;
arcPen.setWidth( lineWidth );
QPen linePen;
linePen.setWidth( lineWidth );
switch( i )
{
case 0:
{
arcPen.setColor( c1 );
linePen.setColor( c1 );
break;
}
case 1:
{
QLinearGradient gradient;
gradient.setStart( r.topLeft() );
gradient.setFinalStop( r.bottomRight() );
gradient.setColorAt( 0.0, c1 );
gradient.setColorAt( 1.0, c2 );
arcPen.setBrush( gradient );
linePen.setColor( c2 );
break;
}
case 2:
{
arcPen.setColor( c2 );
linePen.setColor( c2 );
break;
}
case 3:
{
QLinearGradient gradient;
gradient.setStart( r.bottomRight() );
gradient.setFinalStop( r.topLeft() );
gradient.setColorAt( 0.0, c2 );
gradient.setColorAt( 1.0, c1 );
arcPen.setBrush( gradient );
linePen.setColor( c1 );
break;
}
}
painter->setPen( arcPen );
painter->drawPath( pathList[ 2 * i] );
painter->setPen( linePen );
painter->drawPath( pathList[ 2 * i + 1] );
}
}
else
{
QPen pen( palette.color( QPalette::WindowText ), lineWidth );
painter->setPen( pen );
painter->drawPath( path );
}
painter->restore();
}
int guiMain(const po::variables_map& options) {
{ // by default on Windows the selection is hard to see in the main window, because it's some gray;
QPalette pal (QApplication::palette());
pal.setColor(QPalette::Highlight, pal.color(QPalette::Active, QPalette::Highlight));
pal.setColor(QPalette::HighlightedText, pal.color(QPalette::Active, QPalette::HighlightedText));
QApplication::setPalette(pal);
}
getDefaultFont(); // !!! to initialize the static var
string strStartSession;
string strLastSession;
int nSessCnt;
bool bOpenLast;
string strTempSessTempl;
string strDirSessTempl;
//bool bIsTempSess (false);
string strTempSession (getSepTerminatedDir(convStr(QDir::tempPath())) + TEMP_SESS + SessionEditorDlgImpl::SESS_EXT);
string strFolderSess;
bool bHideFolderSess (true);
if (options.count(s_hiddenFolderSessOpt.m_szLongOpt) > 0)
{
strFolderSess = options[s_hiddenFolderSessOpt.m_szLongOpt].as<string>();
}
else if (options.count(s_loadedFolderSessOpt.m_szLongOpt) > 0)
{
strFolderSess = options[s_loadedFolderSessOpt.m_szLongOpt].as<string>();
bHideFolderSess = false;
}
SessEraser sessEraser;
strLastSession = getActiveSession(options, nSessCnt, bOpenLast, strTempSessTempl, strDirSessTempl);
if (options.count(s_tempSessOpt.m_szLongOpt) > 0)
{
SessEraser::eraseTempSess();
strStartSession = strTempSession;
if (strTempSessTempl.empty())
{
strTempSessTempl = strLastSession;
}
if (!strTempSessTempl.empty())
{
try
{
copyFile2(strTempSessTempl, strStartSession);
}
catch (...)
{ // nothing //ttt2 do more
}
}
string strProcDir (options[s_tempSessOpt.m_szLongOpt].as<string>());
strProcDir = getNonSepTerminatedDir(convStr(QDir(fromNativeSeparators(convStr(strProcDir))).absolutePath()));
setFolder(strStartSession, strProcDir);
bOpenLast = true;
}
else if (!strFolderSess.empty())
{
string strProcDir = getNonSepTerminatedDir(convStr(QDir(fromNativeSeparators(convStr(strFolderSess))).absolutePath())); //ttt2 test on root
if (!dirExists(strProcDir))
{
showMessage(0, QMessageBox::Critical, 0, 0, MainFormDlgImpl::tr("Error"), MainFormDlgImpl::tr("Folder \"%1\" doesn't exist. The program will exit ...").arg(convStr(strProcDir)), MainFormDlgImpl::tr("O&K"));
return 1;
}
string strDirName (convStr(QFileInfo(convStr(strProcDir)).fileName()));
if (strDirName.empty()) // it's a whole disk drive on Windows, e.g. D:\\ ;
{
strDirName += strProcDir[0];
strDirName += "-MP3Diags";
}
strStartSession = getSepTerminatedDir(strProcDir) + strDirName + SessionEditorDlgImpl::SESS_EXT;
if (bHideFolderSess)
{
sessEraser.m_strSessionToHide = strStartSession;
}
if (!fileExists(strStartSession))
{
if (strDirSessTempl.empty())
{
strDirSessTempl = strLastSession;
}
if (!strDirSessTempl.empty())
{
try
{
copyFile2(strDirSessTempl, strStartSession);
setFolder(strStartSession, strProcDir);
}
catch (...)
{ // nothing //ttt2 do more
}
}
}
ofstream out (strStartSession.c_str(), ios_base::app);
if (!out)
{
showMessage(0, QMessageBox::Critical, 0, 0, MainFormDlgImpl::tr("Error"), MainFormDlgImpl::tr("Cannot write to file \"%1\". The program will exit ...").arg(convStr(strStartSession)), MainFormDlgImpl::tr("O&K"));
return 1;
}
bOpenLast = true;
}
else if (0 == nSessCnt)
{ // first run; create a new session and run it
SessionEditorDlgImpl dlg (0, "", SessionEditorDlgImpl::FIRST_TIME, ""); // ttt0 detect system locale
dlg.setWindowIcon(QIcon(":/images/logo.svg"));
strStartSession = dlg.run();
if (strStartSession.empty())
{
return 0;
}
if ("*" == strStartSession)
{
strStartSession.clear();
}
else
{
vector<string> vstrSess;
//vstrSess.push_back(strStartSession);
GlobalSettings st;
st.saveSessions(vstrSess, strStartSession, dlg.shouldOpenLastSession(), "", "", dlg.getTranslation(), GlobalSettings::LOAD_EXTERNAL_CHANGES);
}
bOpenLast = true;
}
else
{
strStartSession = strLastSession;
}
bool bOpenSelDlg (strStartSession.empty() || !bOpenLast);
try
{
for (;;)
{
{
QFont fnt;
string strNewFont (convStr(fnt.family()));
int nNewSize (fnt.pointSize());
fixAppFont(fnt, strNewFont, nNewSize);
}
if (bOpenSelDlg)
{
SessionsDlgImpl dlg (0);
dlg.setWindowIcon(QIcon(":/images/logo.svg"));
strStartSession = dlg.run();
if (strStartSession.empty())
{
return 0;
}
}
bOpenSelDlg = true;
CB_ASSERT (!strStartSession.empty());
bool bDefaultForVisibleSessBtn (true);
//if (strStartSession != strTempSession)
{
vector<string> vstrSess;
bool bOpenLast;
string s, s1, s2, s3;
GlobalSettings st;
st.loadSessions(vstrSess, s, bOpenLast, s1, s2, s3);
st.saveSessions(vstrSess, strStartSession, bOpenLast, s1, s2, s3, GlobalSettings::LOAD_EXTERNAL_CHANGES);
bDefaultForVisibleSessBtn = (cSize(vstrSess) != 1 || !strFolderSess.empty() || vstrSess.end() != find(vstrSess.begin(), vstrSess.end(), strTempSession));
}
{ //ttt2 overkill - create a "CommonData" just to read the language setting
SessionSettings settings (strStartSession);
CommonData commonData(settings, 0, 0, 0, 0, 0, 0, 0, 0, 0, false);
settings.loadMiscConfigSettings(&commonData, SessionSettings::DONT_INIT_GUI);
TranslatorHandler::getGlobalTranslator().setTranslation(commonData.m_strTranslation); // !!! must be done here, before the MainFormDlgImpl constructor
}
MainFormDlgImpl mainDlg (strStartSession, bDefaultForVisibleSessBtn);
mainDlg.setWindowIcon(QIcon(":/images/logo.svg"));
if (bDefaultForVisibleSessBtn)
{
mainDlg.setWindowTitle(QString(getAppName()) + " - " + convStr(SessionEditorDlgImpl::getTitleName(strStartSession)));
}
else
{
mainDlg.setWindowTitle(QString(getAppName()));
}
if (MainFormDlgImpl::OPEN_SESS_DLG != mainDlg.run())
{
return 0;
}
}
}
catch (const exception& ex)
{
CB_ASSERT1 (false, ex.what());
}
catch (...) // ttt2 for now it doesn't catch many exceptions; it seems that nothing can be done if an exception leaves a slot / event handler, but maybe there are ways around
{
/*QMessageBox dlg (QMessageBox::Critical, "Error", "Caught generic exception. Exiting ...", QMessageBox::Close, 0, Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint | Qt::WindowStaysOnTopHint);
dlg.exec();
qDebug("out - err");*/
CB_ASSERT (false);
}
/*mainDlg.show();
return app.exec();*/
}
KNewStuff2Download::KNewStuff2Download()
: QWidget()
{
m_engine = NULL;
m_activefeed = NULL;
m_activeentry = NULL;
resize(800, 600);
setWindowTitle("KNewStuff2 Download Dialog Test");
QPushButton *installbutton = new QPushButton("Install");
connect(installbutton, SIGNAL(clicked()), SLOT(slotInstall()));
QPushButton *closebutton = new QPushButton("Close");
connect(closebutton, SIGNAL(clicked()), SLOT(close()));
m_providerlist = new QListWidget();
m_providerlist->setFixedWidth(200);
m_feeds = new QTabWidget();
#if 0
frame = new QFrame(this);
frame->setFrameStyle(QFrame::StyledPanel | QFrame::Plain);
QPalette palette = this->palette();
palette.setColor(backgroundRole(), palette.color(QPalette::Base));
frame->setPalette(palette);
frame->setLineWidth(1);
frame->setMidLineWidth(0);
recentButton = new KNSButton(frame);
recentButton->setIcon(QIcon::fromTheme("alarmclock"));
recentButton->setText("Most recent");
estimatedButton = new KNSButton(frame);
estimatedButton->setIcon(QIcon::fromTheme("favorites"));
estimatedButton->setText("Most estimated");
wantedButton = new KNSButton(frame);
wantedButton->setIcon(QIcon::fromTheme("kget"));
wantedButton->setText("Most wanted");
connect(recentButton, SIGNAL(toggled(bool)), this, SLOT(buttonToggled(bool)));
connect(estimatedButton, SIGNAL(toggled(bool)), this, SLOT(buttonToggled(bool)));
connect(wantedButton, SIGNAL(toggled(bool)), this, SLOT(buttonToggled(bool)));
frame->setMinimumHeight(40);
recentButton->setChecked(true);
#endif
QHBoxLayout *hbox = new QHBoxLayout();
hbox->addWidget(m_providerlist);
hbox->addWidget(m_feeds);
QVBoxLayout *vbox = new QVBoxLayout();
setLayout(vbox);
vbox->addLayout(hbox);
vbox->addWidget(installbutton);
vbox->addWidget(closebutton);
show();
}
SeekSlider::SeekSlider( Qt::Orientation q, QWidget *_parent, bool _static )
: QSlider( q, _parent ), b_classic( _static )
{
isSliding = false;
f_buffering = 1.0;
mHandleOpacity = 1.0;
chapters = NULL;
mHandleLength = -1;
// prepare some static colors
QPalette p = palette();
QColor background = p.color( QPalette::Active, QPalette::Background );
tickpointForeground = p.color( QPalette::Active, QPalette::WindowText );
tickpointForeground.setHsv( tickpointForeground.hue(),
( background.saturation() + tickpointForeground.saturation() ) / 2,
( background.value() + tickpointForeground.value() ) / 2 );
// set the background color and gradient
QColor backgroundBase( p.window().color() );
backgroundGradient.setColorAt( 0.0, backgroundBase.darker( 140 ) );
backgroundGradient.setColorAt( 1.0, backgroundBase );
// set the foreground color and gradient
QColor foregroundBase( 50, 156, 255 );
foregroundGradient.setColorAt( 0.0, foregroundBase );
foregroundGradient.setColorAt( 1.0, foregroundBase.darker( 140 ) );
// prepare the handle's gradient
handleGradient.setColorAt( 0.0, p.window().color().lighter( 120 ) );
handleGradient.setColorAt( 0.9, p.window().color().darker( 120 ) );
// prepare the handle's shadow gradient
QColor shadowBase = p.shadow().color();
if( shadowBase.lightness() > 100 )
shadowBase = QColor( 60, 60, 60 ); // Palette's shadow is too bright
shadowDark = shadowBase.darker( 150 );
shadowLight = shadowBase.lighter( 180 );
shadowLight.setAlpha( 50 );
/* Timer used to fire intermediate updatePos() when sliding */
seekLimitTimer = new QTimer( this );
seekLimitTimer->setSingleShot( true );
/* Tooltip bubble */
mTimeTooltip = new TimeTooltip( this );
mTimeTooltip->setMouseTracking( true );
/* Properties */
setRange( MINIMUM, MAXIMUM );
setSingleStep( 2 );
setPageStep( 10 );
setMouseTracking( true );
setTracking( true );
setFocusPolicy( Qt::NoFocus );
/* Use the new/classic style */
if( !b_classic )
setStyle( new SeekStyle );
/* Init to 0 */
setPosition( -1.0, 0, 0 );
secstotimestr( psz_length, 0 );
animHandle = new QPropertyAnimation( this, "handleOpacity", this );
animHandle->setDuration( FADEDURATION );
animHandle->setStartValue( 0.0 );
animHandle->setEndValue( 1.0 );
hideHandleTimer = new QTimer( this );
hideHandleTimer->setSingleShot( true );
hideHandleTimer->setInterval( FADEOUTDELAY );
CONNECT( this, sliderMoved( int ), this, startSeekTimer() );
CONNECT( seekLimitTimer, timeout(), this, updatePos() );
CONNECT( hideHandleTimer, timeout(), this, hideHandle() );
mTimeTooltip->installEventFilter( this );
}
void paintContact(QPainter* mp, const QStyleOptionViewItem& option, const QModelIndex& index) const
{
mp->save();
QStyleOptionViewItem o = option;
QPalette palette = o.palette;
MUCItem::Role r = index.data(GCUserModel::StatusRole).value<Status>().mucItem().role();
QRect rect = o.rect;
if(nickColoring_) {
if(r == MUCItem::Moderator)
palette.setColor(QPalette::Text, colorModerator_);
else if(r == MUCItem::Participant)
palette.setColor(QPalette::Text, colorParticipant_);
else if(r == MUCItem::Visitor)
palette.setColor(QPalette::Text, colorVisitor_);
else
palette.setColor(QPalette::Text, colorNoRole_);
}
mp->fillRect(rect, (o.state & QStyle::State_Selected) ? palette.color(QPalette::Highlight) : palette.color(QPalette::Base));
if(showAvatar_) {
QPixmap ava = index.data(GCUserModel::AvatarRole).value<QPixmap>();
if(ava.isNull()) {
ava = IconsetFactory::iconPixmap("psi/default_avatar");
}
ava = AvatarFactory::roundedAvatar(ava, avatarRadius_, avatarSize_);
QRect avaRect(rect);
avaRect.setWidth(ava.width());
avaRect.setHeight(ava.height());
if(!avatarAtLeft_) {
avaRect.moveTopRight(rect.topRight());
avaRect.translate(-1, 1);
rect.setRight(avaRect.left() - 1);
}
else {
avaRect.translate(1, 1);
rect.setLeft(avaRect.right() + 1);
}
mp->drawPixmap(avaRect, ava);
}
QPixmap status = showStatusIcons_? PsiIconset::instance()->status(index.data(GCUserModel::StatusRole).value<Status>()).pixmap() : QPixmap();
int h = rect.height();
int sh = status.isNull() ? 0 : status.height();
rect.setHeight(qMax(sh, fontHeight_));
rect.moveTop(rect.top() + (h - rect.height())/2);
if(!status.isNull()) {
QRect statusRect(rect);
statusRect.setWidth(status.width());
statusRect.setHeight(status.height());
statusRect.translate(1, 1);
mp->drawPixmap(statusRect, status);
rect.setLeft(statusRect.right() + 2);
}
else
rect.setLeft(rect.left() + 2);
mp->setPen(QPen((o.state & QStyle::State_Selected) ? palette.color(QPalette::HighlightedText) : palette.color(QPalette::Text)));
mp->setFont(o.font);
mp->setClipRect(rect);
QTextOption to;
to.setWrapMode(QTextOption::NoWrap);
mp->drawText(rect, index.data(Qt::DisplayRole).toString(), to);
QList<QPixmap> rightPixs;
if(showAffiliations_) {
QPixmap pix = index.data(GCUserModel::AffilationIconRole).value<QPixmap>();;
if(!pix.isNull())
rightPixs.push_back(pix);
}
if(showClients_) {
QPixmap clientPix = index.data(GCUserModel::ClientIconRole).value<QPixmap>();
if(!clientPix.isNull())
rightPixs.push_back(clientPix);
}
mp->restore();
if(rightPixs.isEmpty())
return;
int sumWidth = 0;
foreach (const QPixmap& pix, rightPixs) {
sumWidth += pix.width();
}
sumWidth += rightPixs.count();
QColor bgc = (option.state & QStyle::State_Selected) ? palette.color(QPalette::Highlight) : palette.color(QPalette::Base);
QColor tbgc = bgc;
tbgc.setAlpha(0);
QLinearGradient grad(rect.right() - sumWidth - 20, 0, rect.right() - sumWidth, 0);
grad.setColorAt(0, tbgc);
grad.setColorAt(1, bgc);
QBrush tbakBr(grad);
QRect gradRect(rect);
gradRect.setLeft(gradRect.right() - sumWidth - 20);
mp->fillRect(gradRect, tbakBr);
QRect iconRect(rect);
for (int i=0; i<rightPixs.size(); i++) {
const QPixmap pix = rightPixs[i];
iconRect.setRight(iconRect.right() - pix.width() -1);
mp->drawPixmap(iconRect.topRight(), pix);
}
}
void paintContact(QPainter* mp, const QStyleOptionViewItem& option, const QModelIndex& index, GCUserViewItem* item) const
{
mp->save();
QStyleOptionViewItem o = option;
QPalette palette = o.palette;
MUCItem::Role r = item->s.mucItem().role();
QRect rect = o.rect;
if(nickColoring_) {
if(r == MUCItem::Moderator)
palette.setColor(QPalette::Text, colorModerator_);
else if(r == MUCItem::Participant)
palette.setColor(QPalette::Text, colorParticipant_);
else if(r == MUCItem::Visitor)
palette.setColor(QPalette::Text, colorVisitor_);
else
palette.setColor(QPalette::Text, colorNoRole_);
}
mp->fillRect(rect, (o.state & QStyle::State_Selected) ? palette.color(QPalette::Highlight) : palette.color(QPalette::Base));
if(showAvatar_) {
QPixmap ava = item->avatar();
if(ava.isNull()) {
ava = IconsetFactory::iconPixmap("psi/default_avatar");
}
ava = AvatarFactory::roundedAvatar(ava, avatarRadius_, avatarSize_);
QRect avaRect(rect);
avaRect.setWidth(ava.width());
avaRect.setHeight(ava.height());
if(!avatarAtLeft_) {
avaRect.moveTopRight(rect.topRight());
avaRect.translate(-1, 1);
rect.setRight(avaRect.left() - 1);
}
else {
avaRect.translate(1, 1);
rect.setLeft(avaRect.right() + 1);
}
mp->drawPixmap(avaRect, ava);
}
QPixmap status = showStatusIcons_ ? item->icon() : QPixmap();
int h = rect.height();
int sh = status.isNull() ? 0 : status.height();
rect.setHeight(qMax(sh, fontHeight_));
rect.moveTop(rect.top() + (h - rect.height())/2);
if(!status.isNull()) {
QRect statusRect(rect);
statusRect.setWidth(status.width());
statusRect.setHeight(status.height());
statusRect.translate(1, 1);
mp->drawPixmap(statusRect, status);
rect.setLeft(statusRect.right() + 2);
}
else
rect.setLeft(rect.left() + 2);
mp->setPen(QPen((o.state & QStyle::State_Selected) ? palette.color(QPalette::HighlightedText) : palette.color(QPalette::Text)));
mp->setFont(o.font);
mp->setClipRect(rect);
QTextOption to;
to.setWrapMode(QTextOption::NoWrap);
mp->drawText(rect, index.data(Qt::DisplayRole).toString(), to);
QList<QPixmap> rightPixs;
if(showClients_) {
GCUserView *gcuv = (GCUserView*)item->treeWidget();
GCMainDlg* dlg = gcuv->mainDlg();
QPixmap clientPix;
if(dlg) {
UserListItem u;
const QString &nick = item->text(0);
Jid caps_jid(/*s.mucItem().jid().isEmpty() ? */ dlg->jid().withResource(nick) /* : s.mucItem().jid()*/);
QString client_name = dlg->account()->capsManager()->clientName(caps_jid);
QString client_version = (client_name.isEmpty() ? QString() : dlg->account()->capsManager()->clientVersion(caps_jid));
UserResource ur;
ur.setClient(client_name,client_version,"");
u.userResourceList().append(ur);
QStringList clients = u.clients();
if(!clients.isEmpty())
clientPix = IconsetFactory::iconPixmap("clients/" + clients.takeFirst());
}
if(!clientPix.isNull())
rightPixs.push_back(clientPix);
}
if(showAffiliations_) {
MUCItem::Affiliation a = item->s.mucItem().affiliation();
QPixmap pix;
if(a == MUCItem::Owner)
pix = IconsetFactory::iconPixmap("affiliation/owner");
else if(a == MUCItem::Admin)
pix = IconsetFactory::iconPixmap("affiliation/admin");
else if(a == MUCItem::Member)
pix = IconsetFactory::iconPixmap("affiliation/member");
else if(a == MUCItem::Outcast)
pix = IconsetFactory::iconPixmap("affiliation/outcast");
else
pix = IconsetFactory::iconPixmap("affiliation/noaffiliation");
if(!pix.isNull())
rightPixs.push_back(pix);
}
mp->restore();
if(rightPixs.isEmpty())
return;
int sumWidth = 0;
foreach (const QPixmap& pix, rightPixs) {
sumWidth += pix.width();
}
sumWidth += rightPixs.count();
QColor bgc = (option.state & QStyle::State_Selected) ? palette.color(QPalette::Highlight) : palette.color(QPalette::Base);
QColor tbgc = bgc;
tbgc.setAlpha(0);
QLinearGradient grad(rect.right() - sumWidth - 20, 0, rect.right() - sumWidth, 0);
grad.setColorAt(0, tbgc);
grad.setColorAt(1, bgc);
QBrush tbakBr(grad);
QRect gradRect(rect);
gradRect.setLeft(gradRect.right() - sumWidth - 20);
mp->fillRect(gradRect, tbakBr);
QRect iconRect(rect);
for (int i=0; i<rightPixs.size(); i++) {
const QPixmap pix = rightPixs[i];
iconRect.setRight(iconRect.right() - pix.width() -1);
mp->drawPixmap(iconRect.topRight(), pix);
}
}
const QColorGroup& colorGroup) const
#else
/*!
\brief Draw the scale
\param painter The painter
\param palette Palette, text color is used for the labels,
foreground color for ticks and backbone
*/
void QwtAbstractScaleDraw::draw(QPainter *painter,
const QPalette& palette) const
#endif
{
if ( hasComponent(QwtAbstractScaleDraw::Labels) )
{
painter->save();
#if QT_VERSION < 0x040000
painter->setPen(colorGroup.text()); // ignore pen style
#else
painter->setPen(palette.color(QPalette::Text)); // ignore pen style
#endif
const QwtValueList &majorTicks =
d_data->scldiv.ticks(QwtScaleDiv::MajorTick);
for (int i = 0; i < (int)majorTicks.count(); i++)
{
const double v = majorTicks[i];
if ( d_data->scldiv.contains(v) )
drawLabel(painter, majorTicks[i]);
}
painter->restore();
}
if ( hasComponent(QwtAbstractScaleDraw::Ticks) )
{
painter->save();
QPen pen = painter->pen();
#if QT_VERSION < 0x040000
pen.setColor(colorGroup.foreground());
#else
pen.setColor(palette.color(QPalette::Foreground));
#endif
painter->setPen(pen);
for ( int tickType = QwtScaleDiv::MinorTick;
tickType < QwtScaleDiv::NTickTypes; tickType++ )
{
const QwtValueList &ticks = d_data->scldiv.ticks(tickType);
for (int i = 0; i < (int)ticks.count(); i++)
{
const double v = ticks[i];
if ( d_data->scldiv.contains(v) )
drawTick(painter, v, d_data->tickLength[tickType]);
}
}
painter->restore();
}
if ( hasComponent(QwtAbstractScaleDraw::Backbone) )
{
painter->save();
QPen pen = painter->pen();
#if QT_VERSION < 0x040000
pen.setColor(colorGroup.foreground());
#else
pen.setColor(palette.color(QPalette::Foreground));
#endif
painter->setPen(pen);
drawBackbone(painter);
painter->restore();
}
}
void UIVMPreviewWindow::repaintBGImages()
{
/* Delete the old images: */
if (m_pbgImage)
{
delete m_pbgImage;
m_pbgImage = 0;
}
if (m_pGlossyImg)
{
delete m_pGlossyImg;
m_pGlossyImg = 0;
}
/* Check that there is enough room for our fancy stuff.
* If not we just draw nothing (the border and the blur radius). */
QRect cr = contentsRect();
if (cr.width() < 41 || cr.height() < 41)
return;
QPalette pal = palette();
m_wRect = cr.adjusted(10, 10, -10, -10);
m_vRect = m_wRect.adjusted(m_vMargin, m_vMargin, -m_vMargin, -m_vMargin).adjusted(-3, -3, 3, 3);
/* First draw the shadow. Its a rounded rectangle which get blurred: */
QImage imageW(cr.size(), QImage::Format_ARGB32);
QColor bg = pal.color(QPalette::Base);
bg.setAlpha(0); /* We want blur to transparent _and_ whatever the base color is. */
imageW.fill(bg.rgba());
QPainter pW(&imageW);
pW.setBrush(QColor(30, 30, 30)); /* Dark gray */
pW.setPen(Qt::NoPen);
pW.drawRoundedRect(QRect(QPoint(0, 0), cr.size()).adjusted(10, 10, -10, -10), m_vMargin, m_vMargin);
pW.end();
/* Blur the rectangle */
QImage imageO(cr.size(), QImage::Format_ARGB32);
blurImage(imageW, imageO, 10);
QPainter pO(&imageO);
/* Now paint the border with a gradient to get a look of a monitor: */
QRect rr = QRect(QPoint(0, 0), cr.size()).adjusted(10, 10, -10, -10);
QLinearGradient lg(0, rr.y(), 0, rr.height());
QColor base(200, 200, 200); /* light variant */
// QColor base(80, 80, 80); /* Dark variant */
lg.setColorAt(0, base);
lg.setColorAt(0.4, base.darker(300));
lg.setColorAt(0.5, base.darker(400));
lg.setColorAt(0.7, base.darker(300));
lg.setColorAt(1, base);
pO.setBrush(lg);
pO.setPen(QPen(base.darker(150), 1));
pO.drawRoundedRect(rr, m_vMargin, m_vMargin);
pO.end();
/* Make a copy of the new bg image: */
m_pbgImage = new QImage(imageO);
/* Now the glossy overlay has to be created.
* Start with defining a nice looking painter path. */
QRect gRect = QRect(QPoint(0, 0), m_vRect.size());
QPainterPath glossyPath(QPointF(gRect.x(), gRect.y()));
glossyPath.lineTo(gRect.x() + gRect.width(), gRect.y());
glossyPath.lineTo(gRect.x() + gRect.width(), gRect.y() + gRect.height() * 1.0/3.0);
glossyPath.cubicTo(gRect.x() + gRect.width() / 2.0, gRect.y() + gRect.height() * 1.0/3.0,
gRect.x() + gRect.width() / 2.0, gRect.y() + gRect.height() * 2.0/3.0,
gRect.x(), gRect.y() + gRect.height() * 2.0/3.0);
glossyPath.closeSubpath();
/* Paint the glossy path on a QImage: */
QImage image(m_vRect.size(), QImage::Format_ARGB32);
QColor bg1(Qt::white); /* We want blur to transparent _and_ white. */
bg1.setAlpha(0);
image.fill(bg1.rgba());
QPainter painter(&image);
painter.fillPath(glossyPath, QColor(255, 255, 255, 80));
painter.end();
/* Blur the image to get a much more smooth feeling */
QImage image1(m_vRect.size(), QImage::Format_ARGB32);
blurImage(image, image1, 7);
m_pGlossyImg = new QImage(image1);
/* Repaint: */
update();
}
wxColour wxSystemSettingsNative::GetColour(wxSystemColour index)
{
QPalette pal = qApp->palette();
QColor color;
switch (index)
{
case wxSYS_COLOUR_SCROLLBAR:
case wxSYS_COLOUR_BACKGROUND:
//case wxSYS_COLOUR_DESKTOP:
case wxSYS_COLOUR_INACTIVECAPTION:
case wxSYS_COLOUR_MENU:
case wxSYS_COLOUR_WINDOWFRAME:
case wxSYS_COLOUR_ACTIVEBORDER:
case wxSYS_COLOUR_INACTIVEBORDER:
color = pal.color(QPalette::Window);
break;
//case wxSYS_COLOUR_3DFACE:
case wxSYS_COLOUR_3DLIGHT:
color = pal.color(QPalette::Light);
break;
case wxSYS_COLOUR_BTNFACE:
color = pal.color(QPalette::Button);
break;
case wxSYS_COLOUR_WINDOW:
color = pal.color(QPalette::Base);
break;
case wxSYS_COLOUR_MENUBAR:
color = pal.window().color();
break;
case wxSYS_COLOUR_3DDKSHADOW:
color = pal.color(QPalette::Shadow);
break;
case wxSYS_COLOUR_BTNSHADOW:
color = pal.color(QPalette::Dark);
break;
case wxSYS_COLOUR_GRAYTEXT:
//case wxSYS_COLOUR_3DSHADOW:
color = pal.color(QPalette::Disabled, QPalette::Text);
break;
case wxSYS_COLOUR_BTNHIGHLIGHT:
//case wxSYS_COLOUR_BTNHILIGHT:
//case wxSYS_COLOUR_3DHIGHLIGHT:
//case wxSYS_COLOUR_3DHILIGHT:
color = pal.color(QPalette::Light);
break;
case wxSYS_COLOUR_HIGHLIGHT:
color = pal.highlight().color();
break;
case wxSYS_COLOUR_LISTBOX:
color = pal.base().color();
break;
case wxSYS_COLOUR_LISTBOXTEXT:
color = pal.color(QPalette::WindowText);
break;
case wxSYS_COLOUR_LISTBOXHIGHLIGHTTEXT:
// This is for the text in a list control (or tree) when the
// item is selected, but not focused
color = pal.color(QPalette::HighlightedText);
break;
case wxSYS_COLOUR_WINDOWTEXT:
color = pal.color(QPalette::Text);
break;
case wxSYS_COLOUR_MENUTEXT:
case wxSYS_COLOUR_CAPTIONTEXT:
case wxSYS_COLOUR_INACTIVECAPTIONTEXT:
case wxSYS_COLOUR_BTNTEXT:
color = pal.color(QPalette::ButtonText);
break;
case wxSYS_COLOUR_INFOBK:
color = pal.color(QPalette::ToolTipBase);
break;
case wxSYS_COLOUR_INFOTEXT:
color = pal.color(QPalette::ToolTipText);
break;
case wxSYS_COLOUR_HIGHLIGHTTEXT:
color = pal.color(QPalette::BrightText);
break;
case wxSYS_COLOUR_APPWORKSPACE:
color = QColor(Qt::white); // ?
break;
case wxSYS_COLOUR_ACTIVECAPTION:
case wxSYS_COLOUR_MENUHILIGHT:
color = pal.color(QPalette::Highlight);
break;
case wxSYS_COLOUR_HOTLIGHT:
case wxSYS_COLOUR_GRADIENTACTIVECAPTION:
case wxSYS_COLOUR_GRADIENTINACTIVECAPTION:
// TODO
color = QColor(Qt::black);
break;
case wxSYS_COLOUR_MAX:
default:
wxFAIL_MSG( wxT("unknown system colour index") );
color = QColor(Qt::white);
break;
}
return wxColor( color.red(), color.green(), color.blue(), color.alpha() );
}
aboutPokerthImpl::aboutPokerthImpl(QWidget *parent, ConfigFile *c)
: QDialog(parent), myConfig(c)
{
#ifdef __APPLE__
setWindowModality(Qt::ApplicationModal);
setWindowFlags(Qt::WindowSystemMenuHint | Qt::CustomizeWindowHint | Qt::Dialog);
#endif
setupUi(this);
myAppDataPath = QString::fromUtf8(myConfig->readConfigString("AppDataDir").c_str());
QPalette myPalette = textBrowser_licence->palette();
#ifdef GUI_800x480
#ifdef ANDROID
myPalette.setColor(QPalette::Base, QColor(255,255,255,255));
myPalette.setColor(QPalette::Text, QColor(0,0,0,255));
#else
myPalette.setColor(QPalette::Base, QColor(0,0,0,255));
myPalette.setColor(QPalette::Text, QColor(255,255,255,255));
#endif
#else
QColor myColor = myPalette.color(QPalette::Window);
myPalette.setColor(QPalette::Base, myColor);
#endif
textBrowser_licence->setPalette(myPalette);
textBrowser_2->setPalette(myPalette);
textBrowser_3->setPalette(myPalette);
textBrowser_4->setPalette(myPalette);
QFile gplFile(QDir::toNativeSeparators(myAppDataPath+"misc/agpl.html"));
QString gplString;
if(gplFile.exists()) {
if (gplFile.open( QIODevice::ReadOnly)) {
QTextStream stream( &gplFile );
gplString = stream.readAll();
textBrowser_licence->setHtml(gplString);
}
}
label_logo->setPixmap(QPixmap(":/gfx/logoChip3D.png"));
#ifdef GUI_800x480
label_pokerthVersion->setStyleSheet("QLabel { font-size: 30px; font-weight: bold;}");
#else
label_pokerthVersion->setStyleSheet("QLabel { font-size: 16px; font-weight: bold;}");
#endif
#ifdef ANDROID
int api = -2;
#ifndef ANDROID_TEST
JavaVM *currVM = (JavaVM *)QApplication::platformNativeInterface()->nativeResourceForWidget("JavaVM", 0);
JNIEnv* env;
if (currVM->AttachCurrentThread(&env, NULL)<0) {
qCritical()<<"AttachCurrentThread failed";
} else {
jclass jclassApplicationClass = env->FindClass("android/os/Build$VERSION");
if (jclassApplicationClass) {
api = env->GetStaticIntField(jclassApplicationClass, env->GetStaticFieldID(jclassApplicationClass,"SDK_INT", "I"));
}
currVM->DetachCurrentThread();
}
#endif
label_pokerthVersion->setText(QString(tr("PokerTH %1 for Android (API%2)").arg(POKERTH_BETA_RELEASE_STRING).arg(api)));
#else
label_pokerthVersion->setText(QString(tr("PokerTH %1").arg(POKERTH_BETA_RELEASE_STRING)));
#endif
this->setWindowTitle(QString(tr("About PokerTH %1").arg(POKERTH_BETA_RELEASE_STRING)));
//add text to lables and textbrowsers
QString thxToInfos;
thxToInfos.append(tr("- Wikimedia Commons: for different popular avatar picture resources")+"<br>");
thxToInfos.append(tr("- Benedikt, Erhard, Felix, Florian, Linus, Lothar, Steffi, Caro: for people avatar pictures")+"<br>");
thxToInfos.append(tr("- ZeiZei: for misc avatar pictures")+"<br>");
thxToInfos.append(tr("- kde-look.org: for different gpl licensed sounds")+"<br>");
thxToInfos.append(tr("- doc_dos: for self recorded chip sounds")+"<br>");
thxToInfos.append(tr("- thiger, dunkanx, BerndA, coldz, drull: for different patches")+"<br>");
thxToInfos.append(tr("- kraut: for internet-game-server hosting and administration")+"<br>");
thxToInfos.append(tr("- danuxi: for startwindow background gfx and danuxi1 table background")+"<br>");
thxToInfos.append(tr("- heyn: for moderating forum and organise bugtracker and feature requests")+"<br>");
thxToInfos.append(tr("- texas_outlaw: for new table sounds")+"<br>");
textBrowser_3->setHtml(thxToInfos);
QString infoText;
infoText.append(tr("- Poker engine for the popular Texas Hold'em Poker")+"\n");
infoText.append(tr("- Singleplayer games with up to 9 computer-opponents")+"\n");
infoText.append(tr("- Multiplayer network games")+"\n");
infoText.append(tr("- Internet online games")+"\n");
infoText.append(tr("- Changeable gui with online style gallery")+"\n");
infoText.append(tr("- Online ranking website with result tables")+"\n");
infoText.append("\n");
QString thisYear = QDate::currentDate().toString("yyyy");
infoText.append("(c)2006-"+thisYear+", Felix Hammer, Florian Thauer, Lothar May");
label_infotext->setText(infoText);
QString projectText;
projectText.append("<b>"+tr("Project page:")+"</b><br>");
projectText.append(" <a href='http://www.pokerth.net'>http://www.pokerth.net</a><br>");
projectText.append("<b>IRC:</b><br>");
projectText.append(" #pokerth (irc.freenode.net)<br>");
projectText.append("<b>"+tr("Authors:")+"</b><br>");
projectText.append(" Felix Hammer (<a href=mailto:[email protected]>[email protected]</a>)<br>");
projectText.append(" - "+tr("initial idea, basic architecture, gui implementation, gui graphics editing, linux package")+"<br>");
projectText.append(" Florian Thauer (<a href=mailto:[email protected]>[email protected]</a>)<br>");
projectText.append(" - "+tr("initial idea, basic architecture, engine development")+"<br>");
projectText.append(" Lothar May (<a href=mailto:[email protected]>[email protected]</a>)<br>");
projectText.append(" - "+tr("basic architecture, network development, windows package, MacOS package")+"<br>");
projectText.append(" Oskar Lindqvist (<a href=mailto:[email protected]>[email protected]</a>)<br>");
projectText.append(" - "+tr("initial gui graphics design")+"<br>");
textBrowser_2->setHtml(projectText);
}
nsresult
nsLookAndFeel::NativeGetColor(ColorID aID, nscolor &aColor)
{
nsresult res = NS_OK;
if (!qApp)
return NS_ERROR_FAILURE;
QPalette palette = qApp->palette();
switch (aID) {
case eColorID_WindowBackground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_WindowForeground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_WidgetBackground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_WidgetForeground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::WindowText));
break;
case eColorID_WidgetSelectBackground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_WidgetSelectForeground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::WindowText));
break;
case eColorID_Widget3DHighlight:
aColor = NS_RGB(0xa0,0xa0,0xa0);
break;
case eColorID_Widget3DShadow:
aColor = NS_RGB(0x40,0x40,0x40);
break;
case eColorID_TextBackground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_TextForeground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::WindowText));
break;
case eColorID_TextSelectBackground:
case eColorID_IMESelectedRawTextBackground:
case eColorID_IMESelectedConvertedTextBackground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Highlight));
break;
case eColorID_TextSelectForeground:
case eColorID_IMESelectedRawTextForeground:
case eColorID_IMESelectedConvertedTextForeground:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::HighlightedText));
break;
case eColorID_IMERawInputBackground:
case eColorID_IMEConvertedTextBackground:
aColor = NS_TRANSPARENT;
break;
case eColorID_IMERawInputForeground:
case eColorID_IMEConvertedTextForeground:
aColor = NS_SAME_AS_FOREGROUND_COLOR;
break;
case eColorID_IMERawInputUnderline:
case eColorID_IMEConvertedTextUnderline:
aColor = NS_SAME_AS_FOREGROUND_COLOR;
break;
case eColorID_IMESelectedRawTextUnderline:
case eColorID_IMESelectedConvertedTextUnderline:
aColor = NS_TRANSPARENT;
break;
case eColorID_SpellCheckerUnderline:
aColor = NS_RGB(0xff, 0, 0);
break;
case eColorID_activeborder:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_activecaption:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_appworkspace:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_background:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_captiontext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
break;
case eColorID_graytext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Disabled, QPalette::Text));
break;
case eColorID_highlight:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Highlight));
break;
case eColorID_highlighttext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::HighlightedText));
break;
case eColorID_inactiveborder:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Disabled, QPalette::Window));
break;
case eColorID_inactivecaption:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Disabled, QPalette::Window));
break;
case eColorID_inactivecaptiontext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Disabled, QPalette::Text));
break;
case eColorID_infobackground:
#if (QT_VERSION >= QT_VERSION_CHECK(4, 4, 0))
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::ToolTipBase));
#else
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Base));
#endif
break;
case eColorID_infotext:
#if (QT_VERSION >= QT_VERSION_CHECK(4, 4, 0))
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::ToolTipText));
#else
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
#endif
break;
case eColorID_menu:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_menutext:
case eColorID__moz_menubartext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
break;
case eColorID_scrollbar:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Mid));
break;
case eColorID_threedface:
case eColorID_buttonface:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Button));
break;
case eColorID_buttonhighlight:
case eColorID_threedhighlight:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Dark));
break;
case eColorID_buttontext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::ButtonText));
break;
case eColorID_buttonshadow:
case eColorID_threedshadow:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Dark));
break;
case eColorID_threeddarkshadow:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Shadow));
break;
case eColorID_threedlightshadow:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Light));
break;
case eColorID_window:
case eColorID_windowframe:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID_windowtext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
break;
// from the CSS3 working draft (not yet finalized)
// http://www.w3.org/tr/2000/wd-css3-userint-20000216.html#color
case eColorID__moz_buttondefault:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Button));
break;
case eColorID__moz_field:
case eColorID__moz_combobox:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Base));
break;
case eColorID__moz_fieldtext:
case eColorID__moz_comboboxtext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
break;
case eColorID__moz_dialog:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID__moz_dialogtext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::WindowText));
break;
case eColorID__moz_dragtargetzone:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Window));
break;
case eColorID__moz_buttonhovertext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::ButtonText));
break;
case eColorID__moz_menuhovertext:
case eColorID__moz_menubarhovertext:
aColor = QCOLOR_TO_NS_RGB(palette.color(QPalette::Normal, QPalette::Text));
break;
default:
aColor = 0;
res = NS_ERROR_FAILURE;
break;
}
return res;
}
TextEditorSettings::TextEditorSettings(QObject *parent)
: QObject(parent)
, m_d(new Internal::TextEditorSettingsPrivate)
{
QTC_ASSERT(!m_instance, return);
m_instance = this;
// Note: default background colors are coming from FormatDescription::background()
// Add font preference page
FormatDescriptions formatDescr;
formatDescr.append(FormatDescription(C_TEXT, tr("Text"), tr("Generic text.\nApplied to "
"text, if no other "
"rules matching.")));
// Special categories
const QPalette p = QApplication::palette();
formatDescr.append(FormatDescription(C_LINK, tr("Link"),
tr("Links that follow symbol under cursor."), Qt::blue));
formatDescr.append(FormatDescription(C_SELECTION, tr("Selection"), tr("Selected text."),
p.color(QPalette::HighlightedText)));
formatDescr.append(FormatDescription(C_LINE_NUMBER, tr("Line Number"),
tr("Line numbers located on the "
"left side of the editor.")));
formatDescr.append(FormatDescription(C_SEARCH_RESULT, tr("Search Result"),
tr("Highlighted search results inside the editor.")));
formatDescr.append(FormatDescription(C_SEARCH_SCOPE, tr("Search Scope"),
tr("Section where the pattern is searched in.")));
formatDescr.append(FormatDescription(C_PARENTHESES, tr("Parentheses"),
tr("Displayed when matching parentheses, square brackets "
"or curly brackets are found.")));
formatDescr.append(FormatDescription(C_CURRENT_LINE, tr("Current Line"),
tr("Line where the cursor is placed in.")));
FormatDescription currentLineNumber =
FormatDescription(C_CURRENT_LINE_NUMBER, tr("Current Line Number"),
tr("Line number located on the left side of the "
"editor where the cursor is placed in."), Qt::darkGray);
currentLineNumber.format().setBold(true);
formatDescr.append(currentLineNumber);
formatDescr.append(FormatDescription(C_OCCURRENCES, tr("Occurrences"),
tr("Occurrences of the symbol under the cursor.\n"
"(Only the background will be applied.)")));
formatDescr.append(FormatDescription(C_OCCURRENCES_UNUSED, tr("Unused Occurrence"),
tr("Occurrences of unused variables.")));
formatDescr.append(FormatDescription(C_OCCURRENCES_RENAME, tr("Renaming Occurrence"),
tr("Occurrences of a symbol that will be renamed.")));
// Standard categories
formatDescr.append(FormatDescription(C_NUMBER, tr("Number"), tr("Number literal."),
Qt::darkBlue));
formatDescr.append(FormatDescription(C_STRING, tr("String"),
tr("Character and string literals."), Qt::darkGreen));
formatDescr.append(FormatDescription(C_TYPE, tr("Type"), tr("Name of a type."),
Qt::darkMagenta));
formatDescr.append(FormatDescription(C_LOCAL, tr("Local"), tr("Local variables.")));
formatDescr.append(FormatDescription(C_FIELD, tr("Field"),
tr("Class' data members."), Qt::darkRed));
formatDescr.append(FormatDescription(C_ENUMERATION, tr("Enumeration"),
tr("Applied to Enumeration Items."), Qt::darkMagenta));
Format functionFormat;
formatDescr.append(FormatDescription(C_FUNCTION, tr("Function"), tr("Name of a function."),
functionFormat));
functionFormat.setItalic(true);
formatDescr.append(FormatDescription(C_VIRTUAL_METHOD, tr("Virtual Method"),
tr("Name of method declared as virtual."),
functionFormat));
formatDescr.append(FormatDescription(C_BINDING, tr("QML Binding"),
tr("QML item property, that allows a "
"binding to another property."),
Qt::darkRed));
Format qmlLocalNameFormat;
qmlLocalNameFormat.setItalic(true);
formatDescr.append(FormatDescription(C_QML_LOCAL_ID, tr("QML Local Id"),
tr("QML item id within a QML file."), qmlLocalNameFormat));
formatDescr.append(FormatDescription(C_QML_ROOT_OBJECT_PROPERTY,
tr("QML root Object Property"),
tr("QML property of a parent item."), qmlLocalNameFormat));
formatDescr.append(FormatDescription(C_QML_SCOPE_OBJECT_PROPERTY,
tr("QML scope Object Property"),
tr("Property of the same QML item."), qmlLocalNameFormat));
formatDescr.append(FormatDescription(C_QML_STATE_NAME, tr("QML State Name"),
tr("Name of a QML state."), qmlLocalNameFormat));
formatDescr.append(FormatDescription(C_QML_TYPE_ID, tr("QML Type Name"),
tr("Name of a QML type."), Qt::darkMagenta));
Format qmlExternalNameFormat = qmlLocalNameFormat;
qmlExternalNameFormat.setForeground(Qt::darkBlue);
formatDescr.append(FormatDescription(C_QML_EXTERNAL_ID, tr("QML External Id"),
tr("QML id defined in another QML file."),
qmlExternalNameFormat));
formatDescr.append(FormatDescription(C_QML_EXTERNAL_OBJECT_PROPERTY,
tr("QML External Object Property"),
tr("QML property defined in another QML file."),
qmlExternalNameFormat));
Format jsLocalFormat;
jsLocalFormat.setForeground(QColor(41, 133, 199)); // very light blue
jsLocalFormat.setItalic(true);
formatDescr.append(FormatDescription(C_JS_SCOPE_VAR, tr("JavaScript Scope Var"),
tr("Variables defined inside the JavaScript file."),
jsLocalFormat));
Format jsGlobalFormat;
jsGlobalFormat.setForeground(QColor(0, 85, 175)); // light blue
jsGlobalFormat.setItalic(true);
formatDescr.append(FormatDescription(C_JS_IMPORT_VAR, tr("JavaScript Import"),
tr("Name of a JavaScript import inside a QML file."),
jsGlobalFormat));
formatDescr.append(FormatDescription(C_JS_GLOBAL_VAR, tr("JavaScript Global Variable"),
tr("Variables defined outside the script."),
jsGlobalFormat));
formatDescr.append(FormatDescription(C_KEYWORD, tr("Keyword"),
tr("Reserved keywords of the programming language."),
Qt::darkYellow));
formatDescr.append(FormatDescription(C_OPERATOR, tr("Operator"),
tr("Operators. (for example operator++ operator-=)")));
formatDescr.append(FormatDescription(C_PREPROCESSOR, tr("Preprocessor"),
tr("Preprocessor directives."), Qt::darkBlue));
formatDescr.append(FormatDescription(C_LABEL, tr("Label"), tr("Labels for goto statements."),
Qt::darkRed));
formatDescr.append(FormatDescription(C_COMMENT, tr("Comment"),
tr("All style of comments except Doxygen comments."),
Qt::darkGreen));
formatDescr.append(FormatDescription(C_DOXYGEN_COMMENT, tr("Doxygen Comment"),
tr("Doxygen comments."), Qt::darkBlue));
formatDescr.append(FormatDescription(C_DOXYGEN_TAG, tr("Doxygen Tag"), tr("Doxygen tags"),
Qt::blue));
formatDescr.append(FormatDescription(C_VISUAL_WHITESPACE, tr("Visual Whitespace"),
tr("Whitespace\nWill not be applied to whitespace "
"in comments and strings."), Qt::lightGray));
formatDescr.append(FormatDescription(C_DISABLED_CODE, tr("Disabled Code"),
tr("Code disabled by preprocessor directives.")));
// Diff categories
formatDescr.append(FormatDescription(C_ADDED_LINE, tr("Added Line"),
tr("Applied to added lines in differences "
"(in diff editor)."), QColor(0, 170, 0)));
formatDescr.append(FormatDescription(C_REMOVED_LINE, tr("Removed Line"),
tr("Applied to removed lines "
"in differences (in diff editor)."), Qt::red));
formatDescr.append(FormatDescription(C_DIFF_FILE, tr("Diff File"),
tr("Compared files (in diff editor)."), Qt::darkBlue));
formatDescr.append(FormatDescription(C_DIFF_LOCATION, tr("Diff Location"),
tr("Location in the files where the difference is "
"(in diff editor)."), Qt::blue));
m_d->m_fontSettingsPage = new FontSettingsPage(formatDescr,
QLatin1String(Constants::TEXT_EDITOR_FONT_SETTINGS),
this);
ExtensionSystem::PluginManager::addObject(m_d->m_fontSettingsPage);
// Add the GUI used to configure the tab, storage and interaction settings
TextEditor::BehaviorSettingsPageParameters behaviorSettingsPageParameters;
behaviorSettingsPageParameters.id = QLatin1String(Constants::TEXT_EDITOR_BEHAVIOR_SETTINGS);
behaviorSettingsPageParameters.displayName = tr("Behavior");
behaviorSettingsPageParameters.settingsPrefix = QLatin1String("text");
m_d->m_behaviorSettingsPage = new BehaviorSettingsPage(behaviorSettingsPageParameters, this);
ExtensionSystem::PluginManager::addObject(m_d->m_behaviorSettingsPage);
TextEditor::DisplaySettingsPageParameters displaySettingsPageParameters;
displaySettingsPageParameters.id = QLatin1String(Constants::TEXT_EDITOR_DISPLAY_SETTINGS),
displaySettingsPageParameters.displayName = tr("Display");
displaySettingsPageParameters.settingsPrefix = QLatin1String("text");
m_d->m_displaySettingsPage = new DisplaySettingsPage(displaySettingsPageParameters, this);
ExtensionSystem::PluginManager::addObject(m_d->m_displaySettingsPage);
m_d->m_highlighterSettingsPage =
new HighlighterSettingsPage(QLatin1String(Constants::TEXT_EDITOR_HIGHLIGHTER_SETTINGS), this);
ExtensionSystem::PluginManager::addObject(m_d->m_highlighterSettingsPage);
m_d->m_snippetsSettingsPage =
new SnippetsSettingsPage(QLatin1String(Constants::TEXT_EDITOR_SNIPPETS_SETTINGS), this);
ExtensionSystem::PluginManager::addObject(m_d->m_snippetsSettingsPage);
connect(m_d->m_fontSettingsPage, SIGNAL(changed(TextEditor::FontSettings)),
this, SIGNAL(fontSettingsChanged(TextEditor::FontSettings)));
connect(m_d->m_behaviorSettingsPage, SIGNAL(typingSettingsChanged(TextEditor::TypingSettings)),
this, SIGNAL(typingSettingsChanged(TextEditor::TypingSettings)));
connect(m_d->m_behaviorSettingsPage, SIGNAL(storageSettingsChanged(TextEditor::StorageSettings)),
this, SIGNAL(storageSettingsChanged(TextEditor::StorageSettings)));
connect(m_d->m_behaviorSettingsPage, SIGNAL(behaviorSettingsChanged(TextEditor::BehaviorSettings)),
this, SIGNAL(behaviorSettingsChanged(TextEditor::BehaviorSettings)));
connect(m_d->m_displaySettingsPage, SIGNAL(displaySettingsChanged(TextEditor::DisplaySettings)),
this, SIGNAL(displaySettingsChanged(TextEditor::DisplaySettings)));
// TODO: Move these settings to TextEditor category
m_d->m_completionSettings.fromSettings(QLatin1String("CppTools/"), Core::ICore::settings());
}
void QgsGrassTools::runModule( QString name )
{
if ( name.length() == 0 ) return; // Section
#ifndef WIN32
QgsGrassShell* sh = 0;
#endif
QString path = QgsApplication::pkgDataPath() + "/grass/modules/" + name;
QgsDebugMsg( QString( "path = %1" ).arg( path ) );
QWidget *m;
if ( name == "shell" )
{
// Set history file
QString mapsetPath = QgsGrass::getDefaultGisdbase() + "/"
+ QgsGrass::getDefaultLocation() + "/"
+ QgsGrass::getDefaultMapset();
// bash
QString hist = "HISTFILE=" + mapsetPath + "/.bash_history";
char *histChar = new char[hist.length()+1];
strcpy( histChar, hist.toAscii().constData() );
putenv( histChar );
// csh/tcsh
#ifndef WIN32
hist = "histfile=" + mapsetPath + "/.history";
histChar = new char[hist.length()+1];
strcpy( histChar, hist.toAscii().constData() );
putenv( histChar );
#endif
#ifdef WIN32
if ( !QProcess::startDetached( getenv( "COMSPEC" ) ) )
{
QMessageBox::warning( 0, "Warning", tr( "Cannot start command shell (%1)" ).arg( getenv( "COMSPEC" ) ) );
}
return;
#else
#ifdef HAVE_OPENPTY
sh = new QgsGrassShell( this, mTabWidget );
m = dynamic_cast<QWidget *>( sh );
#else
QMessageBox::warning( 0, tr( "Warning" ), tr( "GRASS Shell is not compiled." ) );
#endif // HAVE_OPENPTY
#endif // ! WIN32
}
else
{
m = dynamic_cast<QWidget *>( new QgsGrassModule( this, name,
mIface, path, mTabWidget ) );
}
int height = mTabWidget->iconSize().height();
QPixmap pixmap = QgsGrassModule::pixmap( path, height );
// Icon size in QT4 does not seem to be variable
// -> put smaller icons in the middle
QPixmap pixmap2( mTabWidget->iconSize() );
QPalette pal;
pixmap2.fill( pal.color( QPalette::Window ) );
QPainter painter( &pixmap2 );
int x = ( int )(( mTabWidget->iconSize().width() - pixmap.width() ) / 2 );
painter.drawPixmap( x, 0, pixmap );
painter.end();
QIcon is;
is.addPixmap( pixmap2 );
mTabWidget->addTab( m, is, "" );
mTabWidget->setCurrentIndex( mTabWidget->count() - 1 );
// We must call resize to reset COLUMNS enviroment variable
// used by bash !!!
#ifndef WIN32
if ( sh ) sh->resizeTerminal();
#endif
}