void UBDesktopAnnotationController::customCapture()
{
mIsFullyTransparent = true;
updateBackground();
mDesktopPalette->disappearForCapture();
UBCustomCaptureWindow customCaptureWindow(mDesktopPalette);
// need to show the window before execute it to avoid some glitch on windows.
#ifndef Q_WS_WIN // Working only without this call on win32 desktop mode
customCaptureWindow.show();
#endif
if (customCaptureWindow.execute(getScreenPixmap()) == QDialog::Accepted)
{
QPixmap selectedPixmap = customCaptureWindow.getSelectedPixmap();
emit imageCaptured(selectedPixmap, false);
}
mDesktopPalette->appear();
mIsFullyTransparent = false;
updateBackground();
}
MusicLrcContainerForWallpaper::MusicLrcContainerForWallpaper(QWidget *parent)
: MusicLrcContainer(parent)
{
QVBoxLayout *vBoxLayout = new QVBoxLayout(this);
vBoxLayout->setContentsMargins(0, 0, 0, 0);
vBoxLayout->setSpacing(0);
setLayout(vBoxLayout);
m_background = new MusicTransitionAnimationLabel(this);
m_background->setScaledContents(true);
vBoxLayout->addWidget(m_background);
QVBoxLayout *bBoxLayout = new QVBoxLayout(m_background);
bBoxLayout->setContentsMargins(0, 0, 0, 0);
bBoxLayout->setSpacing(0);
m_background->setLayout(bBoxLayout);
m_containerType = "WALLPAPER";
m_layoutWidget = new MusicVLayoutAnimationWidget(this);
m_layoutWidget->connectTo(this);
bBoxLayout->addWidget(m_layoutWidget);
m_animationFreshTime = 0;
m_wallThread = new MusicDesktopWallpaperThread(this);
connect(m_wallThread, SIGNAL(updateBackground(QPixmap)), SLOT(updateBackground(QPixmap)));
#ifdef Q_OS_WIN
m_wallThread->sendMessageToDesktop();
SetParent((HWND)winId(), m_wallThread->findDesktopIconWnd());
#endif
}
void UBDesktopAnnotationController::windowCapture()
{
mIsFullyTransparent = true;
updateBackground();
mDesktopPalette->disappearForCapture();
UBWindowCapture util(this);
if (util.execute() == QDialog::Accepted)
{
QPixmap windowPixmap = util.getCapturedWindow();
// on Mac OS X we can only know that user cancel the operatiion by checking is the image is null
// because the screencapture utility always return code 0 event if user cancel the application
if (!windowPixmap.isNull())
{
emit imageCaptured(windowPixmap, false);
}
}
mDesktopPalette->appear();
mIsFullyTransparent = false;
updateBackground();
}
Stack::Stack(QWidget* parent) :
QWidget(parent),
m_symbols_dialog(0),
m_printer(0),
m_current_document(0),
m_footer_margin(0),
m_header_margin(0),
m_footer_visible(0),
m_header_visible(0)
{
setMouseTracking(true);
m_contents = new QStackedWidget(this);
m_alerts = new AlertLayer(this);
m_scenes = new SceneList(this);
setScenesVisible(false);
m_menu = new QMenu(this);
m_menu_group = new QActionGroup(this);
m_menu_group->setExclusive(true);
connect(m_menu_group, SIGNAL(triggered(QAction*)), this, SLOT(actionTriggered(QAction*)));
m_find_dialog = new FindDialog(this);
connect(m_find_dialog, SIGNAL(findNextAvailable(bool)), this, SIGNAL(findNextAvailable(bool)));
connect(ActionManager::instance(), SIGNAL(insertText(QString)), this, SLOT(insertSymbol(QString)));
m_layout = new QGridLayout(this);
m_layout->setMargin(0);
m_layout->setSpacing(0);
m_layout->setRowMinimumHeight(1, 6);
m_layout->setRowMinimumHeight(4, 6);
m_layout->setRowStretch(2, 1);
m_layout->setColumnMinimumWidth(1, 6);
m_layout->setColumnMinimumWidth(4, 6);
m_layout->setColumnStretch(1, 1);
m_layout->setColumnStretch(2, 1);
m_layout->setColumnStretch(3, 1);
m_layout->addWidget(m_contents, 1, 0, 4, 6);
m_layout->addWidget(m_scenes, 1, 0, 4, 3);
m_layout->addWidget(m_alerts, 3, 3);
m_resize_timer = new QTimer(this);
m_resize_timer->setInterval(50);
m_resize_timer->setSingleShot(true);
connect(m_resize_timer, SIGNAL(timeout()), this, SLOT(updateBackground()));
m_theme_renderer = new ThemeRenderer(this);
connect(m_theme_renderer, SIGNAL(rendered(QImage,QRect,Theme)), this, SLOT(updateBackground(QImage,QRect)));
setHeaderVisible(Preferences::instance().alwaysShowHeader());
setFooterVisible(Preferences::instance().alwaysShowFooter());
// Always draw background
setAttribute(Qt::WA_OpaquePaintEvent);
setAutoFillBackground(false);
updateBackground();
}
Stack::Stack(QWidget* parent) :
QWidget(parent),
m_symbols_dialog(0),
m_current_document(0),
m_background_position(0),
m_margin(0),
m_footer_margin(0),
m_header_margin(0),
m_footer_visible(0),
m_header_visible(0)
{
setMouseTracking(true);
m_contents = new QStackedWidget(this);
m_alerts = new AlertLayer(this);
m_scenes = new SceneList(this);
setScenesVisible(false);
m_load_screen = new LoadScreen(this);
m_find_dialog = new FindDialog(this);
connect(m_find_dialog, SIGNAL(findNextAvailable(bool)), this, SIGNAL(findNextAvailable(bool)));
connect(ActionManager::instance(), SIGNAL(insertText(QString)), this, SLOT(insertSymbol(QString)));
m_layout = new QGridLayout(this);
m_layout->setMargin(0);
m_layout->setSpacing(0);
m_layout->setRowMinimumHeight(1, 6);
m_layout->setRowMinimumHeight(4, 6);
m_layout->setRowStretch(2, 1);
m_layout->setColumnMinimumWidth(1, 6);
m_layout->setColumnMinimumWidth(4, 6);
m_layout->setColumnStretch(1, 1);
m_layout->setColumnStretch(2, 1);
m_layout->setColumnStretch(3, 1);
m_layout->addWidget(m_contents, 1, 0, 4, 6);
m_layout->addWidget(m_scenes, 1, 0, 4, 3);
m_layout->addWidget(m_alerts, 3, 3);
m_layout->addWidget(m_load_screen, 0, 0, 6, 6);
m_resize_timer = new QTimer(this);
m_resize_timer->setInterval(50);
m_resize_timer->setSingleShot(true);
connect(m_resize_timer, SIGNAL(timeout()), this, SLOT(updateBackground()));
connect(&background_loader, SIGNAL(finished()), this, SLOT(updateBackground()));
}
void MediaSourceBase::sourceOffline()
{
qDebug() << "SOURCE" << id << "LEFT US";
leftMeterSlider->setValue(0);
rightMeterSlider->setValue(0);
volumeSlider->setValue(0);
opacitySlider->setValue(0);
volumeSlider->setEnabled(false);
opacitySlider->setEnabled(false);
monitorButton->setEnabled(false);
goButton->setEnabled(false);
audioData.clear();
name = "";
if (!pipeline.isNull())
{
pipeline->setState(QGst::StateNull);
pipeline.clear();
}
updateBackground();
}
ItemDocument::ItemDocument(const QString &caption, const char *name)
: Document(caption, name), m_queuedEvents(0), m_nextIdNum(1),
m_bIsLoading(false), m_currentState(0), m_savedState(0) {
m_zOrder.clear();
m_canvas = new Canvas(this, "canvas");
m_canvasTip = new CanvasTip(this, m_canvas);
m_cmManager = new CMManager(this);
updateBackground();
m_pUpdateItemViewScrollbarsTimer = new QTimer(this);
connect(m_pUpdateItemViewScrollbarsTimer, SIGNAL(timeout()), this, SLOT(updateItemViewScrollbars()));
m_pEventTimer = new QTimer(this);
connect(m_pEventTimer, SIGNAL(timeout()), this, SLOT(processItemDocumentEvents()));
connect(this, SIGNAL(selectionChanged()), this, SLOT(slotInitItemActions()));
connect(ComponentSelector::self(), SIGNAL(itemClicked(const QString&)), this, SLOT(slotUnsetRepeatedItemId()));
connect(FlowPartSelector::self(), SIGNAL(itemClicked(const QString&)), this, SLOT(slotUnsetRepeatedItemId()));
#ifdef MECHANICS
connect(MechanicsSelector::self(), SIGNAL(itemClicked(const QString&)), this, SLOT(slotUnsetRepeatedItemId()));
#endif
m_pAlignmentAction = new KActionMenu(i18n("Alignment"), "rightjust", this);
slotUpdateConfiguration();
}
RecOptDialog::RecOptDialog(ScheduledRecording* sr, MythMainWindow *parent, const char *name)
: MythDialog(parent, name), listMenu(this, "listMenu")
{
schedRec = sr;
program = sr->getProgramInfo();
theme = new XMLParse();
theme->SetWMult(wmult);
theme->SetHMult(hmult);
if (!theme->LoadTheme(xmldata, "recording_options"))
{
MythPopupBox::showOkPopup(gContext->GetMainWindow(), tr("Missing Element"),
tr("The theme you are using does not contain a 'recording_options' "
"element. Please contact the theme creator and ask if they could "
"please update it.<br><br>The next screen will be empty. "
"Press EXIT to return to the menu."));
return;
}
LoadWindow(xmldata);
listMenu.init(theme, "selector", "menu_list", listRect);
rootGroup = sr->getRootGroup();
rootGroup->setParentList(&listMenu);
listMenu.setCurGroup(rootGroup);
setNoErase();
allowEvents = true;
allowUpdates = true;
updateBackground();
}
void View::updateBackImage()
{
Q_D(View);
for (int y = 0; y < d->row; y++)
{
// Background
int start = d->column;
for (int x = 0; x < d->column; x++)
{
if (d->terminal->isDiryAt(y, x))
{
start = x;
while (x < d->column && d->terminal->isDiryAt(y, x))
x++;
updateBackground(y, start, x);
}
}
// Foreground
updateText(y);
for (int x = 0; x < d->column; x++)
d->terminal->setDirtyAt(y, x, false);
}
}
void Stack::resizeEvent(QResizeEvent* event)
{
updateMask();
m_resize_timer->start();
updateBackground();
QWidget::resizeEvent(event);
}
void Tracker :: update ()
{
if( ofGetFrameNum() == 2 ) // automatically set background after a delay.
{
updateBackground();
}
updateVideoGrabber();
updateVideoPlayer();
updateTracking();
int blobsFound;
blobsFound = updateContours();
if( blobsFound > 0 )
{
blobUtil.downSampleBlobs( contourFinder.blobs, blobs, 40 );
blobUtil.scaleBlobs( blobs, renderArea.width / (float)videoSmlRect.width, renderArea.height / (float)videoSmlRect.height );
// blobUtil.translateBlobs( peeps, renderArea.x, renderArea.y );
}
else
{
blobs.clear();
}
}
void Stack::updateBackground()
{
const int margin = m_layout->rowMinimumHeight(0);
const qreal pixelratio = devicePixelRatioF();
// Create temporary background
const QRectF foreground = m_theme.foregroundRect(size(), margin, pixelratio);
QImage image(size() * pixelratio, QImage::Format_ARGB32_Premultiplied);
image.setDevicePixelRatio(pixelratio);
image.fill(m_theme.loadColor().rgb());
{
QPainter painter(&image);
QColor color = m_theme.foregroundColor();
color.setAlpha(m_theme.foregroundOpacity() * 2.55f);
painter.setPen(Qt::NoPen);
painter.setBrush(color);
if (!m_theme.roundCornersEnabled()) {
painter.drawRect(foreground);
} else {
painter.setRenderHint(QPainter::Antialiasing);
painter.drawRoundedRect(foreground, m_theme.cornerRadius(), m_theme.cornerRadius());
}
}
updateBackground(image, foreground.toRect());
// Create proper background
if (!m_resize_timer->isActive()) {
m_theme_renderer->create(m_theme, size(), margin, pixelratio);
}
}
void UBDesktopAnnotationController::screenCapture()
{
mIsFullyTransparent = true;
updateBackground();
mDesktopPalette->disappearForCapture();
QPixmap originalPixmap = getScreenPixmap();
mDesktopPalette->appear();
emit imageCaptured(originalPixmap, false);
mIsFullyTransparent = false;
updateBackground();
}
void CGUIDialog::updateGraphics()
{
updateBackground();
for( auto &control : mControlList )
{
control->updateGraphics();
}
}
//--------------------------------------------------------------
void testApp::update(){
unsigned long long now = ofGetElapsedTimeMillis();
float dt = (now - timeElapsed)/1000.0f;
timeElapsed = now;
// update scene
updateBackground();
updateTripno(dt);
}
void TabOrderEditor::mousePressEvent(QMouseEvent *e)
{
e->accept();
if (!m_indicator_region.contains(e->pos())) {
if (QWidget *child = m_bg_widget->childAt(e->pos())) {
QDesignerFormEditorInterface *core = m_form_window->core();
if (core->widgetFactory()->isPassiveInteractor(child)) {
QMouseEvent event(QEvent::MouseButtonPress,
child->mapFromGlobal(e->globalPos()),
e->button(), e->buttons(), e->modifiers());
qApp->sendEvent(child, &event);
QMouseEvent event2(QEvent::MouseButtonRelease,
child->mapFromGlobal(e->globalPos()),
e->button(), e->buttons(), e->modifiers());
qApp->sendEvent(child, &event2);
updateBackground();
}
}
return;
}
if (e->button() != Qt::LeftButton)
return;
const int target_index = widgetIndexAt(e->pos());
if (target_index == -1)
return;
m_beginning = false;
if (e->modifiers() & Qt::ControlModifier) {
m_current_index = target_index + 1;
if (m_current_index >= m_tab_order_list.size())
m_current_index = 0;
update();
return;
}
if (m_current_index == -1)
return;
m_tab_order_list.swap(target_index, m_current_index);
++m_current_index;
if (m_current_index == m_tab_order_list.size())
m_current_index = 0;
TabOrderCommand *cmd = new TabOrderCommand(formWindow());
cmd->init(m_tab_order_list);
formWindow()->commandHistory()->push(cmd);
}
void TabOrderEditor::setBackground(QWidget *background)
{
if (background == m_bg_widget) {
return;
}
m_bg_widget = background;
updateBackground();
}
void MSTextRect::background(unsigned long pixel_)
{
if (background()!=pixel_)
{
unsigned long oldbg=_bg;
_bg=pixel_;
textMSGC().background(background());
updateBackground(oldbg);
}
}
void MSWidget::background(unsigned long pixel_)
{
if (pixel_!=background())
{
unsigned long old=background();
_bg=pixel_;
if (_window!=0) XSetWindowBackground(display(),_window,pixel_);
updateBackground(old);
}
}
void MediaSourceBase::opcatiyFaderChanged()
{
if (syncVolToOpacityCheckBox->isChecked())
{
setVolume(opacitySlider->value() / 1000.0);
volumeFaderChanged();
}
updateBackground();
emit opacityChanged(opacitySlider->value() / 1000.0);
}
void ItemDocument::print() {
static KPrinter *printer = new KPrinter;
if (! printer->setup(KTechlab::self()))
return;
// setup the printer. with Qt, you always "print" to a
// QPainter.. whether the output medium is a pixmap, a screen,
// or paper
QPainter p;
p.begin(printer);
// we let our view do the actual printing
QPaintDeviceMetrics metrics(printer);
// Round to 16 so that we cut in the middle of squares
int w = metrics.width();
w = (w & 0xFFFFFFF0) + ((w << 1) & 0x10);
int h = metrics.height();
h = (h & 0xFFFFFFF0) + ((h << 1) & 0x10);
p.setClipping(true);
p.setClipRect(0, 0, w, h, QPainter::CoordPainter);
// Send off the painter for drawing
m_canvas->setBackgroundPixmap(0);
QRect bounding = canvasBoundingRect();
unsigned int rows = (unsigned) std::ceil(double(bounding.height()) / double(h));
unsigned int cols = (unsigned) std::ceil(double(bounding.width()) / double(w));
int offset_x = bounding.x();
int offset_y = bounding.y();
for (unsigned row = 0; row < rows; ++row) {
for (unsigned col = 0; col < cols; ++col) {
if (row != 0 || col != 0)
printer->newPage();
QRect drawArea(offset_x + (col * w), offset_y + (row * h), w, h);
m_canvas->drawArea(drawArea, & p);
p.translate(-w, 0);
}
p.translate(w * cols, -h);
}
updateBackground();
// and send the result to the printer
p.end();
}
void Window::create()
{
if (isFullscreen() && !mVideoMode.isValid())
{
mVideoMode = sf::VideoMode::getFullscreenModes()[0];
}
sf::RenderWindow::create(mVideoMode,mTitle,mStyle);
setMouseCursor(mCursor);
updateBackground();
mVisible = true;
}
void Stack::setMargins(int footer, int header)
{
m_footer_margin = footer;
m_header_margin = header;
m_footer_visible = (m_footer_visible != 0) ? -m_footer_margin : 0;
m_header_visible = (m_header_visible != 0) ? m_header_margin : 0;
updateMargin();
updateBackground();
updateMask();
showHeader();
}
WeatherWallpaper::WeatherWallpaper(QObject * parent, const QVariantList & args )
: Plasma::Wallpaper(parent, args)
, m_configWidget(0)
, m_weatherLocation(0)
, m_advancedDialog(0)
, m_fileDialog(0)
, m_fadeValue(0)
, m_animation(0)
, m_model(0)
{
connect(this, SIGNAL(renderCompleted(QImage)), this, SLOT(updateBackground(QImage)));
}
void UBDesktopAnnotationController::stylusToolChanged(int tool)
{
Q_UNUSED(tool);
// UBStylusTool::Enum eTool = (UBStylusTool::Enum)tool;
// if(eTool != UBStylusTool::Selector && eTool != UBStylusTool::Text)
// {
// if(mKeyboardPalette->m_isVisible)
// UBApplication::mainWindow->actionVirtualKeyboard->activate(QAction::Trigger);
// }
updateBackground();
}
void KRootPixmap::slotDone(bool success)
{
if(!success)
{
kdWarning(270) << k_lineinfo << "loading of desktop background failed.\n";
return;
}
// We need to test active as the pixmap might become available
// after the widget has been destroyed.
if(m_bActive)
updateBackground(m_pPixmap);
}
void MediaSourceBase::sourceOnline()
{
qDebug() << "SOURCE" << id << "IS NOW ONLINE";
volumeSlider->setValue(0);
opacitySlider->setValue(0);
volumeSlider->setEnabled(true);
opacitySlider->setEnabled(true);
monitorButton->setEnabled(true);
goButton->setEnabled(true);
updateBackground();
}
void ShaderShadowMapEngine::handleEnter(
Light *light, LightTypeE eType, RenderAction *ract, SSMEngineData *data)
{
updateShadowTexChunk (data);
updateLightPassMaterial(data);
updateBackground (data);
UInt32 parentTravMask = ract->getTravMask();
ract->setTravMask(_sfShadowTravMask.getValue());
// call specific handler for light type
switch(eType)
{
case Point:
{
PointLight *pointL =
boost::polymorphic_downcast<PointLight *>(light);
handlePointLightEnter(pointL, ract, data);
}
break;
case Directional:
{
DirectionalLight *dirL =
boost::polymorphic_downcast<DirectionalLight *>(light);
handleDirectionalLightEnter(dirL, ract, data);
}
break;
case Spot:
{
SpotLight *spotL =
boost::polymorphic_downcast<SpotLight *>(light);
handleSpotLightEnter(spotL, ract, data);
}
break;
default:
{
FWARNING(("ShaderShadowMapEngine::handleEnter: Unknown "
"light type [%u]\n", eType));
}
break;
}
ract->setTravMask(parentTravMask);
}
void MiniMap::updateMiniMap( Game& game ){
Map &m = game.map;
if( imgMinimap.width() !=width() &&
imgMinimap.height()!=height() ) {
int w = width(), h = height();
imgMinimap = QImage( w, h, QImage::Format_RGB32 );
imgFog = QImage( w, h, QImage::Format_RGB32 );
step = 0;
updateBackground(m);
}
if( game.interactive().size() ){
int countStp = std::min((int)game.interactive().size(), 100);
for(int i=0; i<countStp; ++i){
if( step >= (size_t)game.interactive().size() ){
step = 0;
surface = QPixmap::fromImage( imgMinimap );
update();
updateBackground(m);
}
if( game.interactive().size() )
smallStep(game);
++step;
}
} else {
if( step%2==0 ){
surface = QPixmap::fromImage( imgMinimap );
updateBackground(m);
update();
}
++step;
}
}
void SetScene::onUpdate(){
getGL().setPGPNow(getGL().pGLSL_BASE);
getGL().startFrame();
//pRenderManager->clear();
//getGL().setPGPNow(getGL().pGLSL_BASE);
//getGL().PMatrix=PMatrix;
//getGL().useProgram();
//getGL().setMode(NORMAL);
isRunning=true;
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//pCamera->setCamera( 0, 0, -10,0, 0, 0, 0,1, 0);
//getGL().setLookAt( 0,230, 0, 0,0,0, 0,0,1);
for(int i=0; i<sceneNum;i++)
{
vButtonAll[i]->setActive(true);
if(gameMode==GAMEMOVE_LEVEL&&i>=gameLevelRecord)
vButtonAll[i]->setActive(false);
}
pCamera->setLook();
updateBackground();
switch(state)
{
case STATE_FIX:
updateFix();
break;
case STATE_GETIN:
updateGetIn();
break;
case STATE_GETOUT:
updateGetOut();
break;
case STATE_TRANSLATE:
break;
}
//pRenderManager->render();
//getGL().setFuncType(GLSL::FUNS_LIGHT_EASY);//FUNS_LIGHT_PHONG FUNS_LIGHT_EASY
//getGL().chooseMatrix(GLSL::MMATRIX);
//getGL().setIdentity();
//vSquare[0]->draw();
}
