void QmlProfilerStateWidget::updateDisplay()
{
    // When datamodel is acquiring data
    if (!d->loadingDone && !d->emptyList && !d->appKilled) {
        setVisible(true);
        d->text->setText(tr("Loading data"));
        if (d->isRecording) {
            d->isRecording = false;
            d->estimatedProfilingTime = d->profilingTimer.elapsed();
            emit newTimeEstimation(d->estimatedProfilingTime);
        }
        d->progressBar->setValue(d->m_modelManager->progress() * 1000);
        d->progressBar->setVisible(true);
        resize(300,70);
        reposition();
        return;
    }

    // When application is being profiled
    if (d->isRecording) {
        setVisible(true);
        d->progressBar->setVisible(false);
        d->text->setText(tr("Profiling application"));
        resize(200,70);
        reposition();
        return;
    }

    // After profiling, there is an empty trace
    if (d->traceAvailable && d->loadingDone && d->emptyList) {
        setVisible(true);
        d->progressBar->setVisible(false);
        d->text->setText(tr("No QML events recorded"));
        resize(200,70);
        reposition();
        return;
    }

    // Application died before all data could be read
    if (!d->loadingDone && !d->emptyList && d->appKilled) {
        setVisible(true);
        d->text->setText(tr("Application stopped before loading all data"));
        if (d->isRecording) {
            d->isRecording = false;
            d->estimatedProfilingTime = d->profilingTimer.elapsed();
            emit newTimeEstimation(d->estimatedProfilingTime);
        }
        d->progressBar->setValue(d->m_modelManager->progress() * 1000);
        d->progressBar->setVisible(true);
        resize(300,70);
        reposition();
        return;
    }

    // There is a trace on view, hide this dialog
    d->progressBar->setVisible(false);
    setVisible(false);
}

static char *editinput(void)
{
    int c;

    Repeat = NO_ARG;
    old_point = rl_point = rl_mark = rl_end = 0;
    rl_line_buffer[0] = '\0';

    el_intr_pending = -1;
    while ((c = tty_get()) != EOF) {
        switch (tty_special(c)) {
	    case CSdone:
		return rl_line_buffer;

	    case CSeof:
		return NULL;

	    case CSsignal:
		return (char *)"";

	    case CSmove:
		reposition();
		break;

	    case CSdispatch:
		switch (emacs(c)) {
		    case CSdone:
			return rl_line_buffer;

		    case CSeof:
			return NULL;

		    case CSsignal:
			return (char *)"";

		    case CSmove:
			reposition();
			break;

		    case CSdispatch:
		    case CSstay:
			break;
		}
		break;

	    case CSstay:
		break;
        }
    }
    return NULL;
}

bool CPetInventoryGlyph::doAction(CGlyphAction *action) {
	CInventoryGlyphAction *invAction = static_cast<CInventoryGlyphAction *>(action);
	CPetInventoryGlyphs *owner = dynamic_cast<CPetInventoryGlyphs *>(_owner);
	if (!invAction)
		return false;

	switch (invAction->getMode()) {
	case ACTION_REMOVED:
		if (invAction->_item == _item) {
			_item = nullptr;
			_background = nullptr;
			_field34 = 0;
		}
		break;

	case ACTION_REMOVE:
		if (_item == invAction->_item && _owner) {
			int v = populateItem(_item, 0);
			_background = owner->getBackground(v);

			if (isHighlighted()) {
				Point glyphPos = _owner->getHighlightedGlyphPos();
				reposition(glyphPos);
				updateTooltip();
			}
		}
		break;

	default:
		break;
	}

	return true;
}

void HighlightItem::setPos(double x, double y)
{
    QRectF pr = parentRect();
    m_xn = (x - pr.left()) / (double)pr.width();
    m_yn = (y - pr.top()) / (double)pr.height();
    reposition();
}

void CPetInventoryGlyph::highlightCurrent(const Point &pt) {
	reposition(pt);
	if (_item) {
		CPETObjectSelectedMsg selectedMsg;
		selectedMsg.execute(_item);
	}
}

WaitingOverlay::WaitingOverlay(KJob *job, QWidget *baseWidget, QWidget *parent)
    : QWidget(parent ? parent : baseWidget->window())
    , mBaseWidget(baseWidget)
{
    Q_ASSERT(baseWidget);
    Q_ASSERT(parentWidget() != baseWidget);

    connect(baseWidget, &QObject::destroyed, this, &QObject::deleteLater);
    connect(job, &KJob::result, this, &QObject::deleteLater);
    mPreviousState = mBaseWidget->isEnabled();

    QBoxLayout *topLayout = new QVBoxLayout(this);
    topLayout->addStretch();
    QLabel *description = new QLabel(this);
    description->setText(i18n("<p style=\"color: white;\"><b>Waiting for operation</b><br/></p>"));
    description->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
    topLayout->addWidget(description);
    topLayout->addStretch();

    QPalette p = palette();
    p.setColor(backgroundRole(), QColor(0, 0, 0, 128));
    setPalette(p);
    setAutoFillBackground(true);

    mBaseWidget->installEventFilter(this);

    reposition();
}

void ThreadControlBlock::updateBoostedPriority(const uint8_t boostedPriority)
{
	decltype(boostedPriority_) newBoostedPriority {boostedPriority};

	for (const auto& mutexControlBlock : ownedProtocolMutexList_)
	{
		const auto mutexBoostedPriority = mutexControlBlock.getBoostedPriority();
		newBoostedPriority = std::max(newBoostedPriority, mutexBoostedPriority);
	}

	if (boostedPriority_ == newBoostedPriority)
		return;

	const auto oldEffectivePriority = getEffectivePriority();
	boostedPriority_ = newBoostedPriority;
	const auto newEffectivePriority = getEffectivePriority();

	if (oldEffectivePriority == newEffectivePriority || threadListNode.isLinked() == false)
		return;

	const auto loweringBefore = newEffectivePriority < oldEffectivePriority;

	reposition(loweringBefore);

	// this code is placed here, even though it could be moved to ThreadControlBlock::reposition(), simplifying
	// ThreadControlBlock::setPriority(). This way optimizer can remove recursive calls to this function, reducing
	// memory usage of threads.
	if (priorityInheritanceMutexControlBlock_ != nullptr)
		priorityInheritanceMutexControlBlock_->getOwner()->updateBoostedPriority();
}

ScriptTerminatorWidget::ScriptTerminatorWidget( const QString &message )
: PopupWidget( 0 )
{
    setFrameStyle( QFrame::StyledPanel | QFrame::Raised );

    setContentsMargins( 4, 4, 4, 4 );

    setMinimumWidth( 26 );
    setMinimumHeight( 26 );
    setSizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );

    QPalette p = QToolTip::palette();
    setPalette( p );

    QLabel *alabel = new QLabel( message, this );
    alabel->setWordWrap( true );
    alabel->setTextFormat( Qt::RichText );
    alabel->setTextInteractionFlags( Qt::TextBrowserInteraction );
    alabel->setSizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::Preferred );
    alabel->setPalette( p );

    KPushButton *button = new KPushButton( i18n( "Terminate" ), this );
    button->setPalette(p);;
    connect( button, SIGNAL(clicked()), SIGNAL(terminate()) );
    button = new KPushButton( KStandardGuiItem::close(), this );
    button->setPalette(p);
    connect( button, SIGNAL(clicked()), SLOT(hide()) );

    reposition();
}

void GraphGraphicsView::drawSpecifiedGraph(int vertices, int edges)
{
    clearNodes();
    clearArrows();
    adjMatrix.clear();
    adj.clear();

    for (int i = 0; i < vertices; ++i) {
        nodes.push_back(new NodeGraphicsItem(QString::number(i+1)));
        scene.addItem(nodes[i]);
        nodes[i]->setPos(qrand() % 500, qrand() % 500);
    }

    for (int i = 0; i < nodes.length(); ++i) {
        adjMatrix.push_back(QList<int>());
        adj.push_back(AdjacencyList());
        for (int j = 0; j < nodes.length(); ++j) {
            if (edges > 0 && i != j)
            {
                int val = qrand() % 11;
                adjMatrix[i].push_back(val);
                if (val > 0) {
                    adj[i].Insert(j,val);
                }
                edges--;
            }
        }
        //adj[i].printValues();
    }

    reposition();
}

void RazorPanelPrivate::screensChangeds()
{
    if (! canPlacedOn(mScreenNum, mPosition))
        mScreenNum = findAvailableScreen(mPosition);

    reposition();
}

Node* MapManager::loadZoneByNumber(const int zoneNumber)
{
	//일단 반복문 없이 생짜로 때려박는다.
	NodeTileMap* centerZone = _mapsForNodesWithIndex[zoneNumber-1];
	_nineZones[DIRECTION_N] = centerZone;
	_nineZones[DIRECTION_1] = centerZone->nearNodesMap[DIRECTION_1];
	_nineZones[DIRECTION_2] = centerZone->nearNodesMap[DIRECTION_2];
	_nineZones[DIRECTION_3] = centerZone->nearNodesMap[DIRECTION_3];
	_nineZones[DIRECTION_4] = centerZone->nearNodesMap[DIRECTION_4];
	_nineZones[DIRECTION_6] = centerZone->nearNodesMap[DIRECTION_6];
	_nineZones[DIRECTION_7] = centerZone->nearNodesMap[DIRECTION_7];
	_nineZones[DIRECTION_8] = centerZone->nearNodesMap[DIRECTION_8];
	_nineZones[DIRECTION_9] = centerZone->nearNodesMap[DIRECTION_9];
	
	for (int i = (int)DIRECTION_1; i <= (int)DIRECTION_9; ++i)
	{
		_nineZones[(DirectionKind)i]->_tiledMap = TMXTiledMap::create(_nineZones[(DirectionKind)i]->_mapFileName);
		_handle->addChild(_nineZones[(DirectionKind)i]->_tiledMap);
	}

	for (int i = DIRECTION_1; i <= DIRECTION_9; ++i)
	{
		_nineZones[(DirectionKind)i]->_tiledMap->setAnchorPoint(ccp(0.5, 0.5));
	}
	_nineZones[DIRECTION_N]->_tiledMap->setPosition(ccp(0,0));
	reposition();

	_handle->setPosition(ccp(0,0/*SCREEN_PIXEL_WIDTH/2,SCREEN_PIXEL_HEIGHT/2*/));

	return _handle;
}

    void EGLWindow::setFullscreen(bool fullscreen, uint width, uint height)
    {
        short frequency = 0;

        if (mClosed || !mIsTopLevel)
        {
            return;
        }

        if (fullscreen == mIsFullScreen && width == mWidth && height == mHeight)
        {
            return;
        }
		if (fullscreen)
        {
            mGLSupport->switchMode(width, height, frequency);
        }
        else
        {
            mGLSupport->switchMode();
        }

        if (mIsFullScreen != fullscreen)
        {
            switchFullScreen(fullscreen);
        }

        if (!mIsFullScreen)
        {
            resize(width, height);
            reposition(mLeft, mTop);
        }
    }

PDFViewerWindow::PDFViewerWindow(unsigned int monitor, PagePart myPart, bool showInformationLine, const RuntimeConfiguration& r, bool enabled): 
  QWidget(),
  m_enabled(enabled),
  m_monitor(monitor),
  minimumPageNumber(0),
  maximumPageNumber(65535),
  myPart(myPart)
{
  if ( ! enabled )
    return;
  setupUi(this);
  if ( !showInformationLine || ! r.showPresenterArea()) {
    /* If the information line is disabled because we're the primary screen,
     * or the user explicitly said so, disable it completely.
     */
    hideInformationLine();
  }
  else {
    /* Enable the information line, but control visibility of the components as requested by the user.
     */
    this->showInformationLine();
    this->wallClock->setVisible(r.showWallClock());
    this->thumbnailArea->setVisible(r.showThumbnails());
    this->slideClock->setVisible(r.showSlideClock());
    this->presentationClock->setVisible(r.showPresentationClock());
  }
  reposition();
}

void Camera::moveBackward()
{
	adjustBob(false);
	Vector3 newPos = getPosition() - getSubjectRelative();
	setPosition(newPos.x, getPosition().y, newPos.z);
	reposition();
}

ErrorOverlay::ErrorOverlay(QWidget *baseWidget, const QString &details, QWidget *parent) :
    QWidget(parent ? parent : baseWidget->window()),
    m_BaseWidget(baseWidget)
{
    // Build the UI
    QVBoxLayout *layout = new QVBoxLayout;
    layout->setSpacing(10);

    QLabel *pixmap = new QLabel();
    pixmap->setPixmap(KIcon("dialog-error").pixmap(64));

    QLabel *message = new QLabel(i18n("Power Management configuration module could not be loaded.\n%1", details));

    pixmap->setAlignment(Qt::AlignHCenter);
    message->setAlignment(Qt::AlignHCenter);

    layout->addStretch();
    layout->addWidget(pixmap);
    layout->addWidget(message);
    layout->addStretch();

    setLayout(layout);

    // Draw the transparent overlay background
    QPalette p = palette();
    p.setColor(backgroundRole(), QColor(0, 0, 0, 128));
    p.setColor(foregroundRole(), Qt::white);
    setPalette(p);
    setAutoFillBackground(true);

    m_BaseWidget->installEventFilter(this);

    reposition();
}

bool CallConfirmWidget::eventFilter(QObject*, QEvent* event)
{
    if (event->type() == QEvent::Resize)
        reposition();

    return false;
}

void PDFViewerWindow::setMonitor(const unsigned int monitor)
{
  if ( m_monitor != monitor )
  {
    m_monitor = monitor;
    reposition();
  }
}

SymbolTable_i& SymbolTable_i::operator ++()
{
   if (eof())
      return *this;
   _pos++;
   reposition();
   return *this;
}

void Camera::strafeRight(GLfloat step)
{
	Vector3 pos = getPosition();
	pos.x -= cosf(Utils::degreesToRadians(-m_yaw));
	pos.z -= sinf(Utils::degreesToRadians(-m_yaw));
	setPosition(pos);
	reposition();
}

bool KWindowPositioner::eventFilter(QObject *, QEvent *e)
{
    if(e->type() == QEvent::Move)
    {
        reposition();
    }

    return false;
}