SetWaitCursor::~SetWaitCursor()
{
if (m_guiApp) {
RG_DEBUG << "SetWaitCursor::SetWaitCursor() : restoring normal cursor\n";
QWidget* viewport = 0;
QCursor currentCompositionViewCursor;
if ((m_guiApp->getView() &&
m_guiApp->getView()->getTrackEditor() &&
m_guiApp->getView()->getTrackEditor()->getCompositionView() &&
m_guiApp->getView()->getTrackEditor()->getCompositionView()->viewport())) {
viewport = m_guiApp->getView()->getTrackEditor()->getCompositionView()->viewport();
currentCompositionViewCursor = viewport->cursor();
}
m_guiApp->setCursor(m_saveCursor);
if (viewport) {
if (currentCompositionViewCursor.shape() == Qt::WaitCursor) {
viewport->setCursor(m_saveCompositionViewCursor);
} else {
viewport->setCursor(currentCompositionViewCursor); // because m_guiApp->setCursor() has replaced it
}
}
// otherwise, it's been modified elsewhere, so leave it as is
}
}
void MainDialog::onStateChanged(int state, short disconnectStatus)
{
QColor clr = BTN_RED;
if( state == CloseWaitState || state == ProgressState ) {
QCursor* ovrCur = QApplication::overrideCursor();
if( ovrCur == NULL || ovrCur->shape() != Qt::WaitCursor )
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
clr = BTN_YELLOW;
}
if( state == EstablishState ) {
QApplication::restoreOverrideCursor();
startButton_->setEnabled( false );
stopButton_->setEnabled( true );
clr = BTN_GREEN;
}
else {
QApplication::restoreOverrideCursor();
startButton_->setEnabled(true);
stopButton_->setEnabled(false);
}
QPalette pal;
pal.setColor(QPalette::Button, clr);
colorButton_->setPalette(pal);
}
void QDragManager::updateCursor()
{
#ifndef QT_NO_CURSOR
if (willDrop) {
if (qt_qws_dnd_deco)
qt_qws_dnd_deco->show();
if (currentActionForOverrideCursor != global_accepted_action) {
QApplication::changeOverrideCursor(QCursor(dragCursor(global_accepted_action), 0, 0));
currentActionForOverrideCursor = global_accepted_action;
}
} else {
QCursor *overrideCursor = QApplication::overrideCursor();
if (!overrideCursor || overrideCursor->shape() != Qt::ForbiddenCursor) {
QApplication::changeOverrideCursor(QCursor(Qt::ForbiddenCursor));
currentActionForOverrideCursor = Qt::IgnoreAction;
}
#ifndef EMSCRIPTEN
// Hiding the pixmap feels weird, and doesn't match the desktop behaving;
// so I've disabled it for Emscripten.
if (qt_qws_dnd_deco)
qt_qws_dnd_deco->hide();
#endif
}
#endif
}
void GenericCodeEditor::hideMouseCursor()
{
#ifdef Q_OS_MAC
return; // LATER: for some reason this crashes on osx. we should try to figure out why
#endif
QCursor * overrideCursor = QApplication::overrideCursor();
if (!overrideCursor || overrideCursor->shape() != Qt::BlankCursor)
QApplication::setOverrideCursor( Qt::BlankCursor );
}
int QtCursorDatabase::cursorToValue(const QCursor &cursor) const
{
#ifndef QT_NO_CURSOR
Qt::CursorShape shape = cursor.shape();
if (m_cursorShapeToValue.contains(shape))
return m_cursorShapeToValue[shape];
#endif
return -1;
}
CursorWidget(QCursor cursor, QColor color)
:m_cursor(cursor)
,m_color(color)
{
if (cursor.shape() == Qt::ArrowCursor)
unsetCursor();
else
setCursor(cursor);
}
void mousePressEvent(QMouseEvent *)
{
// Toggle cursor
QCursor newCursor = (cursor().shape() == m_cursor.shape()) ? QCursor() : m_cursor;
if (newCursor.shape() == Qt::ArrowCursor)
unsetCursor();
else
setCursor(newCursor);
}
bool LLWebView::event(QEvent* event)
{
if (window && event->type() == QEvent::CursorChange) {
QCursor cursor = this->cursor();
if (currentShape != cursor.shape()) {
currentShape = cursor.shape();
LLQtWebKit::ECursor llcursor;
switch(currentShape)
{
case Qt::ArrowCursor:
llcursor = LLQtWebKit::C_ARROW;
break;
case Qt::PointingHandCursor:
llcursor = LLQtWebKit::C_POINTINGHAND;
break;
case Qt::IBeamCursor:
llcursor = LLQtWebKit::C_IBEAM;
break;
case Qt::SplitVCursor:
llcursor = LLQtWebKit::C_SPLITV;
break;
case Qt::SplitHCursor:
llcursor = LLQtWebKit::C_SPLITH;
break;
default:
qWarning() << "Unhandled cursor shape:" << currentShape;
llcursor = LLQtWebKit::C_ARROW;
}
LLEmbeddedBrowserWindowEvent event(window->getWindowId());
event.setEventUri(window->getCurrentUri());
event.setIntValue((int)llcursor);
window->d->mEventEmitter.update(&LLEmbeddedBrowserWindowObserver::onCursorChanged, event);
}
return true;
}
return QGraphicsWebView::event(event);
}
QXcbCursorCacheKey::QXcbCursorCacheKey(const QCursor &c)
: shape(c.shape()), bitmapCacheKey(0), maskCacheKey(0)
{
if (shape == Qt::BitmapCursor) {
const qint64 pixmapCacheKey = c.pixmap().cacheKey();
if (pixmapCacheKey) {
bitmapCacheKey = pixmapCacheKey;
} else {
Q_ASSERT(c.bitmap());
Q_ASSERT(c.mask());
bitmapCacheKey = c.bitmap()->cacheKey();
maskCacheKey = c.mask()->cacheKey();
}
}
}
void Vruler::mouseMoveEvent(QMouseEvent *m)
{
if (Mpressed)
{
rulerGesture->mouseMoveEvent(m);
}
else
{
QCursor* cursor = qApp->overrideCursor();
Qt::CursorShape shape = cursor ? cursor->shape() : Qt::ArrowCursor;
if ((shape == Qt::SplitHCursor) || (shape == Qt::SplitVCursor))
{
qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
}
}
}
/*
* Makes the specified cursor appear above a specific native window group
* Called from QSymbianControl and QApplication::restoreOverrideCursor
*
* Window server is needed for this, so there is no equivalent when using
* the sprite workaround.
*/
void qt_symbian_setWindowGroupCursor(const QCursor &cursor, RWindowTreeNode &node)
{
Qt::HANDLE handle = cursor.handle();
if (handle) {
RWsPointerCursor *pcurs = reinterpret_cast<RWsPointerCursor *> (handle);
node.SetCustomPointerCursor(*pcurs);
} else
#ifdef Q_SYMBIAN_HAS_SYSTEM_CURSORS
{
TInt shape = qt_symbian_translate_cursor_shape(cursor.shape());
node.SetPointerCursor(shape);
}
#else
qWarning("qt_s60_setWindowGroupCursor - null handle");
#endif
}
// static
QCursor MapEditorTool::scaledToScreen(const QCursor& unscaled_cursor)
{
auto scale = Settings::getInstance().getSetting(Settings::General_PixelsPerInch).toReal() / 96.0;
if (unscaled_cursor.shape() == Qt::BitmapCursor
&& scale > 1.5)
{
// Need to scale our low res image for high DPI screen
const auto unscaled_pixmap = unscaled_cursor.pixmap();
const auto scaled_hotspot = QPointF{ unscaled_cursor.hotSpot() } * scale;
return QCursor{ unscaled_pixmap.scaledToWidth(unscaled_pixmap.width() * scale, Qt::SmoothTransformation),
qRound(scaled_hotspot.x()), qRound(scaled_hotspot.y()) };
}
else
{
return unscaled_cursor;
}
}
bool EditPickPointsPlugin::StartEdit(MeshModel &mm, GLArea *gla )
{
//qDebug() << "StartEdit Pick Points: " << mm.fileName.c_str() << " ..." << mm.cm.fn;
//if there are no faces then we cant do anything with this plugin
if(mm.cm.fn < 1)
{
if(NULL != pickPointsDialog)
{
pickPointsDialog->hide();
}
//show message
QMessageBox::warning(gla->window(), "Edit Pick Points",
"Sorry, this mesh has no faces on which picked points can sit.",
QMessageBox::Ok, QMessageBox::Ok);
return false;
}
//get the cursor
QCursor *cursor = QApplication::overrideCursor();
if(cursor) overrideCursorShape = cursor->shape();
else overrideCursorShape = Qt::ArrowCursor;
//set this so redraw can use it
glArea = gla;
//Create GUI window if we dont already have one
if(pickPointsDialog == 0)
{
pickPointsDialog = new PickPointsDialog(this, gla->window());
}
currentModel = &mm;
//set the current mesh
pickPointsDialog->setCurrentMeshModel(&mm, gla);
//show the dialog
pickPointsDialog->show();
return true;
}
void QDragManager::updateCursor()
{
#ifndef QT_NO_CURSOR
if (willDrop) {
if (qt_qws_dnd_deco)
qt_qws_dnd_deco->show();
if (currentActionForOverrideCursor != global_accepted_action) {
QApplication::changeOverrideCursor(QCursor(dragCursor(global_accepted_action), 0, 0));
currentActionForOverrideCursor = global_accepted_action;
}
} else {
QCursor *overrideCursor = QApplication::overrideCursor();
if (!overrideCursor || overrideCursor->shape() != Qt::ForbiddenCursor) {
QApplication::changeOverrideCursor(QCursor(Qt::ForbiddenCursor));
currentActionForOverrideCursor = Qt::IgnoreAction;
}
if (qt_qws_dnd_deco)
qt_qws_dnd_deco->hide();
}
#endif
}
void MainDialog::onStateChanged(quint8 state, const QString& reason)
{
QColor clr = BTN_RED;
if( state == EngineClosingState || state == ProgressState ) {
QCursor* ovrCur = QApplication::overrideCursor();
if( ovrCur == NULL || ovrCur->shape() != Qt::WaitCursor )
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
clr = BTN_YELLOW;
}
if( state == EstablishState || state == EstablishWarnState ) {
QApplication::restoreOverrideCursor();
startButton_->setEnabled( false );
stopButton_->setEnabled( true );
clr = BTN_GREEN;
}
else {
QApplication::restoreOverrideCursor();
startButton_->setEnabled(true);
stopButton_->setEnabled(false);
}
QPalette pal;
pal.setColor(QPalette::Button, clr);
colorButton_->setPalette(pal);
if( state == ProgressState )
statusBar_->connecting(netman_->model()->value(ServerParam));
else if( state == ReconnectingState )
statusBar_->reconnecting();
else if( state == EstablishState || state == EstablishWarnState )
statusBar_->established(reason);
else if( state == ForcedClosingState)
statusBar_->loggedOut(reason);
else if( state == ClosedFailureState || state == ClosedRemoteState ) {
statusBar_->disconnected(reason);
netman_->reconnect();
}
}
void QBasicDrag::updateCursor(Qt::DropAction action)
{
#ifndef QT_NO_CURSOR
Qt::CursorShape cursorShape = Qt::ForbiddenCursor;
if (canDrop()) {
switch (action) {
case Qt::CopyAction:
cursorShape = Qt::DragCopyCursor;
break;
case Qt::LinkAction:
cursorShape = Qt::DragLinkCursor;
break;
default:
cursorShape = Qt::DragMoveCursor;
break;
}
}
QCursor *cursor = QGuiApplication::overrideCursor();
QPixmap pixmap = m_drag->dragCursor(action);
if (!cursor) {
QGuiApplication::changeOverrideCursor((pixmap.isNull()) ? QCursor(cursorShape) : QCursor(pixmap));
} else {
if (!pixmap.isNull()) {
if ((cursor->pixmap().cacheKey() != pixmap.cacheKey())) {
QGuiApplication::changeOverrideCursor(QCursor(pixmap));
}
} else {
if (cursorShape != cursor->shape()) {
QGuiApplication::changeOverrideCursor(QCursor(cursorShape));
}
}
}
#endif
updateAction(action);
}
void Hruler::mouseMoveEvent(QMouseEvent *m)
{
if (currDoc->isLoading())
return;
if (textEditMode)
{
double ColWidth = (textWidth() - ColGap * (Cols - 1)) / Cols;
int ColEnd, ColStart;
double oldInd;
if (RulerCode == rc_leftFrameDist || RulerCode == rc_rightFrameDist)
{
ColStart = 0; //textPosToLocal(0);
ColEnd = width(); //textPosToLocal(textWidth());
}
else
{
ColStart = textPosToLocal((ColWidth+ColGap)*(ActCol-1));
ColEnd = textPosToLocal((ColWidth+ColGap)*(ActCol-1) + ColWidth);
}
if ((Mpressed) && (m->y() < height()) && (m->y() > 0) && (m->x() > ColStart - currDoc->guidesSettings.grabRad) && (m->x() < ColEnd + currDoc->guidesSettings.grabRad))
{
qApp->changeOverrideCursor(QCursor(Qt::SizeHorCursor));
double toplimit = textWidth() + RExtra - (ColGap * (Cols - 1))-1;
double toplimit2 = textWidth() + Extra - (ColGap * (Cols - 1))-1;
switch (RulerCode)
{
case rc_leftFrameDist:
Extra -= (MouseX - m->x()) / Scaling;
if (Extra < 0)
Extra = 0;
if (Extra > toplimit2)
Extra = toplimit2;
emit MarkerMoved(currItem->xPos(), textBase()-currItem->xPos());
repaint();
break;
case rc_rightFrameDist:
RExtra += (MouseX - m->x()) / Scaling;
if (RExtra < 0)
RExtra = 0;
if (RExtra > toplimit)
RExtra = toplimit;
emit MarkerMoved(RExtra, 0);
repaint();
break;
case rc_indentFirst:
First -= (MouseX - m->x()) / Scaling;
if (First+Indent < 0)
First = -Indent;
if (First+Indent > ColWidth)
First = ColWidth-Indent;
emit MarkerMoved(textBase(), First+Indent);
repaint();
break;
case rc_leftMargin:
oldInd = Indent+First;
Indent -= (MouseX - m->x()) / Scaling;
if (Indent < 0)
Indent = 0;
if (Indent > ColWidth-1)
Indent = ColWidth-1;
First = oldInd - Indent;
emit MarkerMoved(textBase(), Indent);
repaint();
break;
case rc_rightMargin:
RMargin -= (MouseX - m->x()) / Scaling;
if (RMargin < 0)
RMargin = 0;
if (RMargin > ColWidth-1)
RMargin = ColWidth-1;
emit MarkerMoved(textBase(), RMargin);
repaint();
break;
case rc_tab:
TabValues[ActTab].tabPosition -= (MouseX - m->x()) / Scaling;
if (TabValues[ActTab].tabPosition < 0)
TabValues[ActTab].tabPosition = 0;
if (TabValues[ActTab].tabPosition > ColWidth-1)
TabValues[ActTab].tabPosition = ColWidth-1;
emit MarkerMoved(textBase(), TabValues[ActTab].tabPosition);
UpdateTabList();
repaint();
break;
default:
break;
}
MouseX = m->x();
/* if (RulerCode != rc_none)
{
QPoint py = currView->viewport()->mapFromGlobal(m->globalPos());
QPainter p;
p.begin(currView->viewport());
p.setCompositionMode(QPainter::CompositionMode_Xor);
p.setPen(QPen(Qt::white, 1, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
QPoint out = currView->contentsToViewport(QPoint(0, qRound(currDoc->currentPage()->yOffset() * Scaling)));
p.drawLine(Markp, out.y(), Markp, out.y()+qRound(currDoc->currentPage()->height() * Scaling));
p.drawLine(py.x(), out.y(), py.x(), out.y()+qRound(currDoc->currentPage()->height() * Scaling));
p.end();
Markp = py.x();
}*/
return;
}
if ((!Mpressed) && (m->y() < height()) && (m->y() > 0) && (m->x() > ColStart - 2*currDoc->guidesSettings.grabRad) && (m->x() < ColEnd + 2*currDoc->guidesSettings.grabRad))
{
qApp->changeOverrideCursor(QCursor(loadIcon("tab.png"), 3));
switch(findRulerHandle(m->pos(), currDoc->guidesSettings.grabRad))
{
case rc_leftFrameDist:
qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
break;
case rc_rightFrameDist:
qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
break;
case rc_indentFirst:
qApp->changeOverrideCursor(QCursor(Qt::SizeHorCursor));
break;
case rc_leftMargin:
qApp->changeOverrideCursor(QCursor(Qt::SizeHorCursor));
break;
case rc_rightMargin:
qApp->changeOverrideCursor(QCursor(Qt::SizeHorCursor));
break;
case rc_tab:
qApp->changeOverrideCursor(QCursor(Qt::SizeHorCursor));
break;
}
Draw(m->x());
double marker = localToTextPos(m->x());
emit MarkerMoved(textBase(), marker);
return;
}
if ((Mpressed) && (RulerCode == rc_tab) && ((m->y() > height()) || (m->y() < 0)))
{
qApp->changeOverrideCursor(QCursor(loadIcon("DelPoint.png"), 1, 1));
return;
}
qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
}
else
{
if (Mpressed)
{
rulerGesture->mouseMoveEvent(m);
}
else
{
QCursor* cursor = qApp->overrideCursor();
Qt::CursorShape shape = cursor ? cursor->shape() : Qt::ArrowCursor;
if ((shape == Qt::SplitHCursor) || (shape == Qt::SplitVCursor))
{
qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
}
}
}
}
void process(const QObject * obj){
if(obj != NULL){
QListViewItem * buf = __current;
__current = new QListViewItem(__current,obj->className(),QString(obj->name()));
__current->setPixmap(0,__pixgeom);
QMetaObject* _m = obj->metaObject();
QListViewItem * att = NULL;
if(_m != NULL){
QString _superclass(_m->superClassName());
if(!_superclass.isEmpty()){
att = new QListViewItem(__current,"Inherit",_superclass);
att->setPixmap(0,__pixattptr);
QMetaObject* _meta = _m->superClass();
QListViewItem * att4 = NULL;
while((_meta = _meta->superClass())!= NULL){
att4 = new QListViewItem(att,att4,QString(_meta->className()));
att4->setPixmap(0,__pixatt);
}
}
att = new QListViewItem(__current,att,"Priority",(obj->highPriority()?"High":"Normal"));
att->setPixmap(0,__pixatt);
att = new QListViewItem(__current,att,"Widget",(obj->isWidgetType()?"True":"False"));
att->setPixmap(0,__pixatt);
QStrList _slots = _m->slotNames(true);
if(!_slots.isEmpty()){
att = new QListViewItem(__current,att,"Slots");
att->setPixmap(0,__pixtransf);
uint sl_size = _slots.count();
QListViewItem * att2 = NULL;
for(uint j = 0; j < sl_size; j++ ){
att2 = new QListViewItem(att,att2,_slots.at(j));
att2->setPixmap(0,__pixatt);
}
}
QStrList _signals = _m->signalNames(true);
if(!_signals.isEmpty()){
att = new QListViewItem(__current,att,"Signals");
att->setPixmap(0,__pixtransf);
uint si_size = _signals.count();
QListViewItem * att2 = NULL;
for(uint j = 0; j < si_size; j++ ){
att2 = new QListViewItem(att,att2,_signals.at(j));
att2->setPixmap(0,__pixatt);
}
}
int numCInfo = _m->numClassInfo(true);
if(numCInfo !=0){
att = new QListViewItem(__current,att,"ClassInfo","List<Info>["+QString::number(numCInfo)+']');
att->setPixmap(0,__pixtransf);
QListViewItem * att2 = NULL;
for(int j = 0; j < numCInfo; j++ ){
const QClassInfo * _inf = _m->classInfo(j);
if(_inf != NULL){
att2 = new QListViewItem(att,att2,QString(_inf->name),QString(_inf->value));
att2->setPixmap(0,__pixatt);
}
}
}
QStrList _props = _m->propertyNames(true);
if(!_props.isEmpty()){
att = new QListViewItem(__current,att,"Properties");
att->setPixmap(0,__pixtransf);
uint p_size = _props.count();
QListViewItem * att2 = NULL;
for(uint j = 0; j < p_size; j++ ){
att2 = new QListViewItem(att,att2,_props.at(j));
att2->setPixmap(0,__pixatt);
QVariant val;
QString propname(_props.at(j));
#if QT_VERSION >= 300
const QMetaProperty* prop = _m->property (j,true);
#else
const QMetaProperty* prop = _m->property (propname,true);
#endif
QString proptype;
if(prop){
proptype = prop->type();
att2->setText(2,proptype);
/*
QListViewItem * att3 = new QListViewItem(att2,"Writable",(prop->writable()?"True":"False"));
att3->setPixmap(0,__pixatt);
att3 = new QListViewItem(att2,att3,"Designable",(prop->designable()?"True":"False"));
att3->setPixmap(0,__pixatt);
*/
}
val = obj->property(propname);
if(!val.isValid())att2->setText(1,"Invalid");
else if(prop->isEnumType()){
att2->setText(1,prop->valueToKey(val.toInt()));
}
else if(prop->isSetType()){
QStrList st = prop->valueToKeys(val.toInt());
QString t = st.at(0);
for(uint i= 1; i < st.count(); i++)t+='/'+st.at(i);
att2->setText(1,t);
}
else if(val.type() == QVariant::String)att2->setText(1,'"'+val.toString()+'"');
else if(val.type() == QVariant::CString)att2->setText(1,'"'+val.toCString()+'"');
else if(val.type() == QVariant::Bool){
if(val.toBool())att2->setText(1,"True");
else att2->setText(1,"False");
}
else if(val.type() == QVariant::Int)att2->setText(1,QString::number(val.toInt()));
else if(val.type() == QVariant::UInt)att2->setText(1,QString::number(val.toUInt()));
else if(val.type() == QVariant::Double)att2->setText(1,QString::number(val.toDouble()));
else if(val.type() == QVariant::Rect){
const QRect r = val.toRect();
att2->setText(1,'[' + QString::number(r.left()) + ',' + QString::number(r.top())+
',' + QString::number(r.right()) + ',' + QString::number(r.bottom())+']');
}
else if(val.type() == QVariant::Region){
const QRegion reg = val.toRegion();
QRect r = reg.boundingRect();
att2->setText(1,'[' + QString::number(r.left()) + ',' + QString::number(r.top())+
',' + QString::number(r.right()) + ',' + QString::number(r.bottom())+"],");
}
else if(val.type() == QVariant::Size){
const QSize s = val.toSize();
att2->setText(1,'[' + QString::number(s.width()) + ',' + QString::number(s.height())+']');
}
else if(val.type() == QVariant::Point){
const QPoint p = val.toPoint();
att2->setText(1,'[' + QString::number(p.x()) + ',' + QString::number(p.y())+']');
}
else if(val.type() == QVariant::Color){
const QColor c = val.toColor();
att2->setText(1,'[' + QString::number(c.red()) + ',' +
QString::number(c.green()) + ',' +
QString::number(c.blue()) + ']');
}
else if(val.type() == QVariant::ColorGroup){
const QColorGroup cg = val.toColorGroup();
QColor c = cg.base();
att2->setText(1,'[' + QString::number(c.red()) + ',' +
QString::number(c.green()) + ',' +
QString::number(c.blue()) + "], ...");
}
else if(val.type() == QVariant::Font){
const QFont f = val.toFont();
QString text = '\'' + f.family() + "', " + QString::number(f.pointSize())
+ ", " + QString::number(f.weight());
if(f.italic())text+=", italic";
att2->setText(1,text);
}
else if(val.type() == QVariant::SizePolicy){
QSizePolicy sp = val.toSizePolicy();
QString text;
if(sp.horData() == QSizePolicy::Fixed)text+="Fixed";
else if(sp.horData() == QSizePolicy::Minimum )text+="Minimum";
else if(sp.horData() == QSizePolicy::Maximum )text+="Maximum";
else if(sp.horData() == QSizePolicy::Preferred )text+="Preferred";
else if(sp.horData() == QSizePolicy::MinimumExpanding )text+="MinimumExpanding";
else if(sp.horData() == QSizePolicy::Expanding )text+="Expanding";
text +='/';
if(sp.verData() == QSizePolicy::Fixed)text+="Fixed";
else if(sp.verData() == QSizePolicy::Minimum )text+="Minimum";
else if(sp.verData() == QSizePolicy::Maximum )text+="Maximum";
else if(sp.verData() == QSizePolicy::Preferred )text+="Preferred";
else if(sp.verData() == QSizePolicy::MinimumExpanding )text+="MinimumExpanding";
else if(sp.verData() == QSizePolicy::Expanding )text+="Expanding";
att2->setText(1,text);
}
else if(val.type() == QVariant::Pixmap){
QPixmap pix = val.toPixmap();
if(!pix.isNull())att2->setPixmap(1,pix);
}
else if(val.type() == QVariant::Cursor){
const QCursor cur = val.toCursor();
const QBitmap * pix = cur.bitmap();
if(pix && !pix->isNull())att2->setPixmap(1,*pix);
else att2->setText(1,QString::number(cur.shape()));
}
}
}
}
const QObjectList * roots = obj->children();
if(roots != NULL){
__current = new QListViewItem(__current,att,"children","ptr="+QString::number((unsigned long)roots),
"List<QObject>["+QString::number(roots->count())+"]");
__current->setPixmap(0,__pixappe);
QObjectList r(*roots);
uint size = r.count();
for(uint i = 0; i < size; i++ ){
QObject * _obj = r.at(i);
process(_obj);
}
}
__current = buf;
}
}
//*******************************************************************
// set_cursor
//*******************************************************************
void QBtShared::set_cursor( const QCursor& in_cursor )
{
if( !QApplication::overrideCursor() || ( QApplication::overrideCursor()->shape() != in_cursor.shape() ) ) {
QApplication::setOverrideCursor( in_cursor );
}
}
HCURSOR QWindowsCursor::createSystemCursor(const QCursor &c)
{
int hx = c.hotSpot().x();
int hy = c.hotSpot().y();
const Qt::CursorShape cshape = c.shape();
if (cshape == Qt::BitmapCursor) {
const QPixmap pixmap = c.pixmap();
if (!pixmap.isNull())
if (const HCURSOR hc = createPixmapCursor(pixmap, hx, hy))
return hc;
}
// Non-standard Windows cursors are created from bitmaps
static const uchar vsplit_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x80, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xe0, 0x03, 0x00,
0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xff, 0x7f, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x7f, 0x00,
0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x00,
0x00, 0xc0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
static const uchar vsplitm_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
0x00, 0xc0, 0x01, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xf0, 0x07, 0x00,
0x00, 0xf8, 0x0f, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xc0, 0x01, 0x00,
0x00, 0xc0, 0x01, 0x00, 0x80, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0x00,
0x80, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0x00,
0x80, 0xff, 0xff, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xc0, 0x01, 0x00,
0x00, 0xc0, 0x01, 0x00, 0x00, 0xf8, 0x0f, 0x00, 0x00, 0xf0, 0x07, 0x00,
0x00, 0xe0, 0x03, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
static const uchar hsplit_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00,
0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00,
0x00, 0x41, 0x82, 0x00, 0x80, 0x41, 0x82, 0x01, 0xc0, 0x7f, 0xfe, 0x03,
0x80, 0x41, 0x82, 0x01, 0x00, 0x41, 0x82, 0x00, 0x00, 0x40, 0x02, 0x00,
0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00,
0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
static const uchar hsplitm_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00,
0x00, 0xe0, 0x07, 0x00, 0x00, 0xe2, 0x47, 0x00, 0x00, 0xe3, 0xc7, 0x00,
0x80, 0xe3, 0xc7, 0x01, 0xc0, 0xff, 0xff, 0x03, 0xe0, 0xff, 0xff, 0x07,
0xc0, 0xff, 0xff, 0x03, 0x80, 0xe3, 0xc7, 0x01, 0x00, 0xe3, 0xc7, 0x00,
0x00, 0xe2, 0x47, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00,
0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
static const uchar openhand_bits[] = {
0x80,0x01,0x58,0x0e,0x64,0x12,0x64,0x52,0x48,0xb2,0x48,0x92,
0x16,0x90,0x19,0x80,0x11,0x40,0x02,0x40,0x04,0x40,0x04,0x20,
0x08,0x20,0x10,0x10,0x20,0x10,0x00,0x00};
static const uchar openhandm_bits[] = {
0x80,0x01,0xd8,0x0f,0xfc,0x1f,0xfc,0x5f,0xf8,0xff,0xf8,0xff,
0xf6,0xff,0xff,0xff,0xff,0x7f,0xfe,0x7f,0xfc,0x7f,0xfc,0x3f,
0xf8,0x3f,0xf0,0x1f,0xe0,0x1f,0x00,0x00};
static const uchar closedhand_bits[] = {
0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x0d,0x48,0x32,0x08,0x50,
0x10,0x40,0x18,0x40,0x04,0x40,0x04,0x20,0x08,0x20,0x10,0x10,
0x20,0x10,0x20,0x10,0x00,0x00,0x00,0x00};
static const uchar closedhandm_bits[] = {
0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x0d,0xf8,0x3f,0xf8,0x7f,
0xf0,0x7f,0xf8,0x7f,0xfc,0x7f,0xfc,0x3f,0xf8,0x3f,0xf0,0x1f,
0xe0,0x1f,0xe0,0x1f,0x00,0x00,0x00,0x00};
wchar_t *sh = 0;
switch (c.shape()) { // map to windows cursor
case Qt::ArrowCursor:
sh = IDC_ARROW;
break;
case Qt::UpArrowCursor:
sh = IDC_UPARROW;
break;
case Qt::CrossCursor:
sh = IDC_CROSS;
break;
case Qt::WaitCursor:
sh = IDC_WAIT;
break;
case Qt::IBeamCursor:
sh = IDC_IBEAM;
break;
case Qt::SizeVerCursor:
sh = IDC_SIZENS;
break;
case Qt::SizeHorCursor:
sh = IDC_SIZEWE;
break;
case Qt::SizeBDiagCursor:
sh = IDC_SIZENESW;
break;
case Qt::SizeFDiagCursor:
sh = IDC_SIZENWSE;
break;
case Qt::SizeAllCursor:
sh = IDC_SIZEALL;
break;
case Qt::ForbiddenCursor:
sh = IDC_NO;
break;
case Qt::WhatsThisCursor:
sh = IDC_HELP;
break;
case Qt::BusyCursor:
sh = IDC_APPSTARTING;
break;
case Qt::PointingHandCursor:
sh = IDC_HAND;
break;
case Qt::BlankCursor:
case Qt::SplitVCursor:
case Qt::SplitHCursor:
case Qt::OpenHandCursor:
case Qt::ClosedHandCursor:
case Qt::BitmapCursor: {
QImage bbits, mbits;
bool invb, invm;
if (cshape == Qt::BlankCursor) {
bbits = QImage(32, 32, QImage::Format_Mono);
bbits.fill(0); // ignore color table
mbits = bbits.copy();
hx = hy = 16;
invb = invm = false;
} else if (cshape == Qt::OpenHandCursor || cshape == Qt::ClosedHandCursor) {
bool open = cshape == Qt::OpenHandCursor;
QBitmap cb = QBitmap::fromData(QSize(16, 16), open ? openhand_bits : closedhand_bits);
QBitmap cm = QBitmap::fromData(QSize(16, 16), open ? openhandm_bits : closedhandm_bits);
bbits = cb.toImage().convertToFormat(QImage::Format_Mono);
mbits = cm.toImage().convertToFormat(QImage::Format_Mono);
hx = hy = 8;
invb = invm = false;
} else if (cshape == Qt::BitmapCursor) {
bbits = c.bitmap()->toImage().convertToFormat(QImage::Format_Mono);
mbits = c.mask()->toImage().convertToFormat(QImage::Format_Mono);
invb = bbits.colorCount() > 1 && qGray(bbits.color(0)) < qGray(bbits.color(1));
invm = mbits.colorCount() > 1 && qGray(mbits.color(0)) < qGray(mbits.color(1));
} else { // Qt::SplitVCursor, Qt::SplitHCursor
const QBitmap cb = QBitmap::fromData(QSize(32, 32), cshape == Qt::SplitVCursor ? vsplit_bits : hsplit_bits);
const QBitmap cm = QBitmap::fromData(QSize(32, 32), cshape == Qt::SplitVCursor ? vsplitm_bits : hsplitm_bits);
bbits = cb.toImage().convertToFormat(QImage::Format_Mono);
mbits = cm.toImage().convertToFormat(QImage::Format_Mono);
hx = hy = 16;
invb = invm = false;
}
const int n = qMax(1, bbits.width() / 8);
const int h = bbits.height();
#if !defined(Q_OS_WINCE)
QScopedArrayPointer<uchar> xBits(new uchar[h * n]);
QScopedArrayPointer<uchar> xMask(new uchar[h * n]);
int x = 0;
for (int i = 0; i < h; ++i) {
uchar *bits = bbits.scanLine(i);
uchar *mask = mbits.scanLine(i);
for (int j = 0; j < n; ++j) {
uchar b = bits[j];
uchar m = mask[j];
if (invb)
b ^= 0xff;
if (invm)
m ^= 0xff;
xBits[x] = ~m;
xMask[x] = b ^ m;
++x;
}
}
return CreateCursor(GetModuleHandle(0), hx, hy, bbits.width(), bbits.height(),
xBits.data(), xMask.data());
#elif defined(GWES_ICONCURS) // Q_WS_WINCE
// Windows CE only supports fixed cursor size.
int sysW = GetSystemMetrics(SM_CXCURSOR);
int sysH = GetSystemMetrics(SM_CYCURSOR);
int sysN = qMax(1, sysW / 8);
uchar* xBits = new uchar[sysH * sysN];
uchar* xMask = new uchar[sysH * sysN];
int x = 0;
for (int i = 0; i < sysH; ++i) {
if (i >= h) {
memset(&xBits[x] , 255, sysN);
memset(&xMask[x] , 0, sysN);
x += sysN;
} else {
int fillWidth = n > sysN ? sysN : n;
uchar *bits = bbits.scanLine(i);
uchar *mask = mbits.scanLine(i);
for (int j = 0; j < fillWidth; ++j) {
uchar b = bits[j];
uchar m = mask[j];
if (invb)
b ^= 0xFF;
if (invm)
m ^= 0xFF;
xBits[x] = ~m;
xMask[x] = b ^ m;
++x;
}
for (int j = fillWidth; j < sysN; ++j ) {
xBits[x] = 255;
xMask[x] = 0;
++x;
}
}
}
HCURSOR hcurs = CreateCursor(qWinAppInst(), hx, hy, sysW, sysH,
xBits, xMask);
delete [] xBits;
delete [] xMask;
return hcurs;
#else
Q_UNUSED(n);
Q_UNUSED(h);
return 0;
#endif
}
case Qt::DragCopyCursor:
case Qt::DragMoveCursor:
case Qt::DragLinkCursor: {
const QPixmap pixmap = QGuiApplicationPrivate::instance()->getPixmapCursor(cshape);
return createPixmapCursor(pixmap, hx, hy);
}
default:
qWarning("%s: Invalid cursor shape %d", __FUNCTION__, cshape);
return 0;
}
#ifdef Q_OS_WINCE
return LoadCursor(0, sh);
#else
return (HCURSOR)LoadImage(0, sh, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED);
#endif
}
QString VariantHandler::displayString(const QVariant &value)
{
switch (value.type()) {
#ifndef QT_NO_CURSOR
case QVariant::Cursor:
{
const QCursor cursor = value.value<QCursor>();
return Util::enumToString(QVariant::fromValue<int>(cursor.shape()), "Qt::CursorShape");
}
#endif
case QVariant::Icon:
{
const QIcon icon = value.value<QIcon>();
if (icon.isNull()) {
return QObject::tr("<no icon>");
}
QStringList l;
foreach (const QSize &size, icon.availableSizes()) {
l.push_back(displayString(size));
}
return l.join(QLatin1String(", "));
}
case QVariant::Line:
return
QString::fromUtf8("%1, %2 → %3, %4").
arg(value.toLine().x1()).arg(value.toLine().y1()).
arg(value.toLine().x2()).arg(value.toLine().y2());
case QVariant::LineF:
return
QString::fromUtf8("%1, %2 → %3, %4").
arg(value.toLineF().x1()).arg(value.toLineF().y1()).
arg(value.toLineF().x2()).arg(value.toLineF().y2());
case QVariant::Locale:
return value.value<QLocale>().name();
case QVariant::Point:
return
QString::fromLatin1("%1, %2").
arg(value.toPoint().x()).
arg(value.toPoint().y());
case QVariant::PointF:
return
QString::fromLatin1("%1, %2").
arg(value.toPointF().x()).
arg(value.toPointF().y());
case QVariant::Rect:
return
QString::fromLatin1("%1, %2 %3 x %4").
arg(value.toRect().x()).
arg(value.toRect().y()).
arg(value.toRect().width()).
arg(value.toRect().height());
case QVariant::RectF:
return
QString::fromLatin1("%1, %2 %3 x %4").
arg(value.toRectF().x()).
arg(value.toRectF().y()).
arg(value.toRectF().width()).
arg(value.toRectF().height());
case QVariant::Region:
{
const QRegion region = value.value<QRegion>();
if (region.isEmpty()) {
return QLatin1String("<empty>");
}
if (region.rectCount() == 1) {
return displayString(region.rects().first());
} else {
return QString::fromLatin1("<%1 rects>").arg(region.rectCount());
}
}
case QVariant::Palette:
{
const QPalette pal = value.value<QPalette>();
if (pal == qApp->palette()) {
return QLatin1String("<inherited>");
}
return QLatin1String("<custom>");
}
case QVariant::Size:
return
QString::fromLatin1("%1 x %2").
arg(value.toSize().width()).
arg(value.toSize().height());
case QVariant::SizeF:
return
QString::fromLatin1("%1 x %2").
arg(value.toSizeF().width()).
arg(value.toSizeF().height());
case QVariant::StringList:
return value.toStringList().join(", ");
case QVariant::Transform:
{
const QTransform t = value.value<QTransform>();
return
QString::fromLatin1("[%1 %2 %3, %4 %5 %6, %7 %8 %9]").
arg(t.m11()).arg(t.m12()).arg(t.m13()).
arg(t.m21()).arg(t.m22()).arg(t.m23()).
arg(t.m31()).arg(t.m32()).arg(t.m33());
}
default:
break;
}
// types with dynamic type ids
if (value.type() == (QVariant::Type)qMetaTypeId<QTextLength>()) {
const QTextLength l = value.value<QTextLength>();
QString typeStr;
switch (l.type()) {
case QTextLength::VariableLength:
typeStr = QObject::tr("variable");
break;
case QTextLength::FixedLength:
typeStr = QObject::tr("fixed");
break;
case QTextLength::PercentageLength:
typeStr = QObject::tr("percentage");
break;
}
return QString::fromLatin1("%1 (%2)").arg(l.rawValue()).arg(typeStr);
}
if (value.userType() == qMetaTypeId<QPainterPath>()) {
const QPainterPath path = value.value<QPainterPath>();
if (path.isEmpty()) {
return QObject::tr("<empty>");
}
return QObject::tr("<%1 elements>").arg(path.elementCount());
}
if (value.userType() == qMetaTypeId<QMargins>()) {
const QMargins margins = value.value<QMargins>();
return QObject::tr("left: %1, top: %2, right: %3, bottom: %4")
.arg(margins.left()).arg(margins.top())
.arg(margins.right()).arg(margins.bottom());
}
if (value.canConvert<QObject*>()) {
return Util::displayString(value.value<QObject*>());
}
if (value.userType() == qMetaTypeId<QMatrix4x4>()) {
return displayMatrix4x4(value.value<QMatrix4x4>());
}
if (value.userType() == qMetaTypeId<const QMatrix4x4*>()) {
return displayMatrix4x4(value.value<const QMatrix4x4*>());
}
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
if (value.userType() == qMetaTypeId<QSet<QByteArray> >()) {
const QSet<QByteArray> set = value.value<QSet<QByteArray> >();
QStringList l;
foreach (const QByteArray &b, set) {
l.push_back(QString::fromUtf8(b));
}
return l.join(", ");
}
void RulerGesture::movePoint(QMouseEvent* m, bool mouseRelease)
{
FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
const int page = m_doc->OnPage(mousePointDoc.x(), mousePointDoc.y());
QRect viewport(m_view->viewport()->mapToGlobal(QPoint(0,0)), QSize(m_view->visibleWidth(), m_view->visibleHeight()));
QPoint newMousePoint = m->globalPos() - (m_canvas->mapToParent(QPoint(0, 0)) + m_canvas->parentWidget()->mapToGlobal(QPoint(0, 0)));
switch (m_mode)
{
case ORIGIN:
m_canvas->repaint();
m_canvas->displayCorrectedXYHUD(m->globalPos(), mousePointDoc.x(), mousePointDoc.y());
break;
case HORIZONTAL:
if (!m_ScMW->doc->guidesSettings.guidesShown)
break;
m_canvas->update(0, m_xy.y()-2, m_canvas->width(), 4);
m_canvas->update(0, newMousePoint.y()-2, m_canvas->width(), 4);
if ((page >= 0) && (viewport.contains(m->globalPos())))
{
if (!m_haveGuide)
{
qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
if (mouseRelease)
{
m_doc->Pages->at(page)->guides.addHorizontal(mousePointDoc.y() - m_doc->Pages->at(page)->yOffset(), GuideManagerCore::Standard);
m_guide = mousePointDoc.y() - m_doc->Pages->at(page)->yOffset();
m_page = page;
m_haveGuide = true;
m_doc->changed();
}
}
else if (mouseRelease)
{
if (page == m_page)
m_doc->Pages->at(page)->guides.moveHorizontal( m_guide, mousePointDoc.y() - m_doc->Pages->at(page)->yOffset(), GuideManagerCore::Standard);
else
{
m_doc->Pages->at(m_page)->guides.deleteHorizontal( m_guide, GuideManagerCore::Standard);
m_doc->Pages->at(page)->guides.addHorizontal(mousePointDoc.y() - m_doc->Pages->at(page)->yOffset(), GuideManagerCore::Standard);
m_page = page;
}
if (m_doc->currentPage() != m_doc->Pages->at(m_page))
m_doc->setCurrentPage( m_doc->Pages->at(m_page) );
m_doc->changed();
}
else
{
QCursor* cursor = qApp->overrideCursor();
if (cursor && (cursor->shape() != Qt::SplitVCursor))
qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
}
m_currentGuide = mousePointDoc.y() - m_doc->Pages->at(page)->yOffset();
}
else
{
if (m_haveGuide)
{
qApp->changeOverrideCursor(QCursor(loadIcon("DelPoint.png")));
if (mouseRelease)
{
m_doc->Pages->at(m_page)->guides.deleteHorizontal( m_guide, GuideManagerCore::Standard);
m_haveGuide = false;
m_doc->changed();
}
}
}
m_canvas->displayCorrectedSingleHUD(m->globalPos(), mousePointDoc.y(), false);
break;
case VERTICAL:
if (!m_ScMW->doc->guidesSettings.guidesShown)
break;
m_canvas->update(m_xy.x()-2, 0, 4, m_canvas->height());
m_canvas->update(newMousePoint.x()-2, 0, 4, m_canvas->height());
if ((page >= 0) && viewport.contains(m->globalPos()))
{
if (!m_haveGuide)
{
qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
if (mouseRelease)
{
m_doc->Pages->at(page)->guides.addVertical(mousePointDoc.x() - m_doc->Pages->at(page)->xOffset(), GuideManagerCore::Standard);
m_guide = mousePointDoc.x() - m_doc->Pages->at(page)->xOffset();
m_page = page;
m_haveGuide = true;
m_doc->changed();
}
}
else if (mouseRelease)
{
if (page == m_page)
m_doc->Pages->at(page)->guides.moveVertical( m_guide, mousePointDoc.x() - m_doc->Pages->at(page)->xOffset(), GuideManagerCore::Standard);
else
{
m_doc->Pages->at(m_page)->guides.deleteVertical( m_guide, GuideManagerCore::Standard);
m_doc->Pages->at(page)->guides.addVertical(mousePointDoc.x() - m_doc->Pages->at(page)->xOffset(), GuideManagerCore::Standard);
m_page = page;
}
if (m_doc->currentPage() != m_doc->Pages->at(m_page))
m_doc->setCurrentPage( m_doc->Pages->at(m_page) );
m_doc->changed();
}
else
{
QCursor* cursor = qApp->overrideCursor();
if (cursor && (cursor->shape() != Qt::SplitHCursor))
qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
}
m_currentGuide = mousePointDoc.x() - m_doc->Pages->at(page)->xOffset();
}
else
{
if (m_haveGuide)
{
qApp->changeOverrideCursor(QCursor(loadIcon("DelPoint.png")));
if (mouseRelease)
{
m_doc->Pages->at(m_page)->guides.deleteVertical( m_guide, GuideManagerCore::Standard);
m_haveGuide = false;
m_doc->changed();
}
}
}
m_canvas->displayCorrectedSingleHUD(m->globalPos(), mousePointDoc.x(), true);
break;
}
m_xy = newMousePoint;
}
QString VariantHandler::displayString(const QVariant& value)
{
switch (value.type()) {
#ifndef QT_NO_CURSOR
case QVariant::Cursor:
{
const QCursor cursor = value.value<QCursor>();
return Util::enumToString(QVariant::fromValue<int>(cursor.shape()), "Qt::CursorShape");
}
#endif
case QVariant::Icon:
{
const QIcon icon = value.value<QIcon>();
if (icon.isNull()) {
return QObject::tr("<no icon>");
}
QStringList l;
foreach (const QSize &size, icon.availableSizes()) {
l.push_back(displayString(size));
}
return l.join(QLatin1String(", "));
}
case QVariant::Line:
return
QString::fromUtf8("%1 x %2 → %3 x %4").
arg(value.toLine().x1()).arg(value.toLine().y1()).
arg(value.toLine().x2()).arg(value.toLine().y2());
case QVariant::LineF:
return
QString::fromUtf8("%1 x %2 → %3 x %4").
arg(value.toLineF().x1()).arg(value.toLineF().y1()).
arg(value.toLineF().x2()).arg(value.toLineF().y2());
case QVariant::Locale:
return value.value<QLocale>().name();
case QVariant::Point:
return
QString::fromLatin1("%1x%2").
arg(value.toPoint().x()).
arg(value.toPoint().y());
case QVariant::PointF:
return
QString::fromLatin1("%1x%2").
arg(value.toPointF().x()).
arg(value.toPointF().y());
case QVariant::Rect:
return
QString::fromLatin1("%1x%2 %3x%4").
arg(value.toRect().x()).
arg(value.toRect().y()).
arg(value.toRect().width()).
arg(value.toRect().height());
case QVariant::RectF:
return
QString::fromLatin1("%1x%2 %3x%4").
arg(value.toRectF().x()).
arg(value.toRectF().y()).
arg(value.toRectF().width()).
arg(value.toRectF().height());
case QVariant::Region:
{
const QRegion region = value.value<QRegion>();
if (region.isEmpty()) {
return QLatin1String("<empty>");
}
if (region.rectCount() == 1) {
return displayString(region.rects().first());
} else {
return QString::fromLatin1("<%1 rects>").arg(region.rectCount());
}
}
case QVariant::Palette:
{
const QPalette pal = value.value<QPalette>();
if (pal == qApp->palette()) {
return QLatin1String("<inherited>");
}
return QLatin1String("<custom>");
}
case QVariant::Size:
return
QString::fromLatin1("%1x%2").
arg(value.toSize().width()).
arg(value.toSize().height());
case QVariant::SizeF:
return
QString::fromLatin1("%1x%2").
arg(value.toSizeF().width()).
arg(value.toSizeF().height());
case QVariant::StringList:
return value.toStringList().join(", ");
case QVariant::Transform:
{
const QTransform t = value.value<QTransform>();
return
QString::fromLatin1("[%1 %2 %3, %4 %5 %6, %7 %8 %9]").
arg(t.m11()).arg(t.m12()).arg(t.m13()).
arg(t.m21()).arg(t.m22()).arg(t.m23()).
arg(t.m31()).arg(t.m32()).arg(t.m33());
}
default:
break;
}
// types with dynamic type ids
if (value.type() == (QVariant::Type)qMetaTypeId<QTextLength>()) {
const QTextLength l = value.value<QTextLength>();
QString typeStr;
switch (l.type()) {
case QTextLength::VariableLength:
typeStr = QObject::tr("variable");
break;
case QTextLength::FixedLength:
typeStr = QObject::tr("fixed");
break;
case QTextLength::PercentageLength:
typeStr = QObject::tr("percentage");
break;
}
return QString::fromLatin1("%1 (%2)").arg(l.rawValue()).arg(typeStr);
}
if (value.userType() == qMetaTypeId<QPainterPath>()) {
const QPainterPath path = value.value<QPainterPath>();
if (path.isEmpty()) {
return QObject::tr("<empty>");
}
return QObject::tr("<%1 elements>").arg(path.elementCount());
}
if (value.userType() == qMetaTypeId<QMargins>()) {
const QMargins margins = value.value<QMargins>();
return QObject::tr("left: %1, top: %2, right: %3, bottom: %4")
.arg(margins.left()).arg(margins.top())
.arg(margins.right()).arg(margins.bottom());
}
if (value.canConvert<QObject*>()) {
return Util::displayString(value.value<QObject*>());
}
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
if (value.userType() == qMetaTypeId<QSet<QByteArray> >()) {
const QSet<QByteArray> set = value.value<QSet<QByteArray> >();
QStringList l;
foreach (const QByteArray &b, set)
l.push_back(QString::fromUtf8(b));
return l.join(", ");
}
if (value.userType() == qMetaTypeId<QSurfaceFormat>()) {
const QSurfaceFormat format = value.value<QSurfaceFormat>();
QString s;
switch (format.renderableType()) {
case QSurfaceFormat::DefaultRenderableType: s += "Default"; break;
case QSurfaceFormat::OpenGL: s += "OpenGL"; break;
case QSurfaceFormat::OpenGLES: s += "OpenGL ES"; break;
case QSurfaceFormat::OpenVG: s += "OpenVG"; break;
}
s += " (" + QString::number(format.majorVersion()) + "." + QString::number(format.minorVersion());
switch (format.profile()) {
case QSurfaceFormat::CoreProfile: s += " core"; break;
case QSurfaceFormat::CompatibilityProfile: s += " compat"; break;
case QSurfaceFormat::NoProfile: break;
}
s += ")";
s += " RGBA: " + QString::number(format.redBufferSize()) + "/" + QString::number(format.greenBufferSize())
+ "/" + QString::number(format.blueBufferSize()) + "/" + QString::number(format.alphaBufferSize());
s += " Depth: " + QString::number(format.depthBufferSize());
s += " Stencil: " + QString::number(format.stencilBufferSize());
s += " Buffer: ";
switch (format.swapBehavior()) {
case QSurfaceFormat::DefaultSwapBehavior: s += "default"; break;
case QSurfaceFormat::SingleBuffer: s += "single"; break;
case QSurfaceFormat::DoubleBuffer: s += "double"; break;
case QSurfaceFormat::TripleBuffer: s += "triple"; break;
default: s += "unknown";
}
return s;
}
if (value.userType() == qMetaTypeId<QSurface::SurfaceClass>()) {
const QSurface::SurfaceClass sc = value.value<QSurface::SurfaceClass>();
switch (sc) {
case QSurface::Window: return QObject::tr("Window");
#if QT_VERSION > QT_VERSION_CHECK(5, 1, 0)
case QSurface::Offscreen: return QObject::tr("Offscreen");
#endif
default: return QObject::tr("Unknown Surface Class");
}
}
if (value.userType() == qMetaTypeId<QSurface::SurfaceType>()) {
const QSurface::SurfaceType type = value.value<QSurface::SurfaceType>();
switch (type) {
case QSurface::RasterSurface: return QObject::tr("Raster");
case QSurface::OpenGLSurface: return QObject::tr("OpenGL");
default: return QObject::tr("Unknown Surface Type");
}
}
#endif
// enums
const QString enumStr = Util::enumToString(value);
if (!enumStr.isEmpty()) {
return enumStr;
}
// custom converters
const QHash<int, Converter<QString>*>::const_iterator it = s_variantHandlerRepository()->stringConverters.constFind(value.userType());
if (it != s_variantHandlerRepository()->stringConverters.constEnd()) {
return (*it.value())(value);
}
return value.toString();
}
static bool equal(const QCursor &v1, const QCursor &v2)
{ return v1.shape() == v2.shape(); }
WCursor transform(const QCursor& cursor)
{
return WCursor(static_cast<Ws::CursorShape>(cursor.shape()));
}
