void HUD::update(int width, int height) { std::set<Resolution> availableRes; for (size_t i = 0; i < ARRAYSIZE(kResolution); i++) if (ResMan.hasResource(kResolution[i].gui, Aurora::kFileTypeGUI)) availableRes.insert(kResolution[i]); const int wWidth = width; const int wHeight = height; const Resolution *foundRes = 0; for (std::set<Resolution>::const_iterator it = availableRes.begin(); it != availableRes.end(); ++it) if (it->width == wWidth && it->height == wHeight) foundRes = &*it; bool scale = false; if (!foundRes) { for (std::set<Resolution>::const_iterator it = availableRes.begin(); it != availableRes.end(); ++it) { if ((it->width == 800) && (it->height == 600)) { foundRes = &*it; break; } } if (!foundRes) throw Common::Exception("No gui with 800x600 resolution found."); scale = true; } load(foundRes->gui); // Make all the widgets invisible and scale them if needed. for (size_t i = 0; i < ARRAYSIZE(kKnownWidgets); i++) { Widget *widget = getWidget(kKnownWidgets[i].name); if (!widget) continue; widget->setInvisible(!kKnownWidgets[i].visible); float x, y, z; if (scale) { switch (kKnownWidgets[i].position) { case kPositionUpperLeft: widget->getPosition(x, y, z); widget->setPosition(-wWidth/2 + (400 + x), wHeight/2 - (300 - y), z); break; case kPositionUpperRight: widget->getPosition(x, y, z); widget->setPosition(wWidth/2 - (400 - x), wHeight/2 - (300 - y), z); break; case kPositionUpperMid: widget->getPosition(x, y, z); widget->setPosition(x, wHeight/2 - (300 - y), z); break; case kPositionLowerLeft: widget->getPosition(x, y, z); widget->setPosition(-wWidth/2 + (400 + x), -wHeight/2 + (300 + y), z); break; case kPositionLowerRight: widget->getPosition(x, y, z); widget->setPosition(wWidth/2 - (400 - x), -wHeight/2 + (300 + y), z); break; case kPositionLowerMid: widget->getPosition(x, y, z); widget->setPosition(x, -wHeight/2 + (300 + y), z); break; default: break; } } } }
void GlassWindow::workingWindow(bool w) { Widget *working = titleBarContainer.findWidgetById("working"); working->setVisible(w); }
void engine_display::on_pushButton_released() { Widget *mainwindow = new Widget(); mainwindow->show(); this->close(); }
void Gui::mouseMove( int x, int y, MouseButtons mb ) { // cout << "Ui::Gui::mouseMove( )" << endl; if ( pChannelPopup != NULL ) { pChannelPopup->mouseMove( x, y, mb ); if ( pChannelPopup != NULL ) { if ( !pChannelPopup->passEvents() ) return; } } if ( pMouseChannelWidget != NULL ) { Widget* o = pMouseChannelWidget->mouseMove( x - pMouseChannelWidget->absoluteXPos(), y - pMouseChannelWidget->absoluteYPos(), mb ); if ( pLastMouseOver != o ) { if ( (pLastMouseOver == pMouseChannelWidget) || (o == pMouseChannelWidget) ) { if ( o == pMouseChannelWidget ) { pMouseChannelWidget->mouseIn( mb ); } else { pMouseChannelWidget->mouseOut( mb ); pMouseChannelWidget->onDestroy.disconnect( this ); } } else { pLastMouseOver->onDestroy.disconnect( this ); } pLastMouseOver = o; pLastMouseOver->onDestroy.connect( this, &Gui::objectDestroyed ); } } else { for( int i = 0; i < pPopups.count(); i++ ) { Popup* p = pPopups.get( i ); Rect r = p->getRect(); if ( r.pointInside( x, y ) ) { p->mouseMove( x, y, mb ); if ( !p->passEvents() ) return; } } Widget* o = fgFrame().mouseMove( x, y, mb ); if ( o != NULL ) { if ( o != pLastMouseOver ) { if ( pLastMouseOver != NULL ) { pLastMouseOver->onDestroy.disconnect( this ); pLastMouseOver->mouseOut( mb ); pLastMouseOver = NULL; } // if ( o != &frame ) o->mouseIn( mb ); pLastMouseOver = o; pLastMouseOver->onDestroy.connect( this, &Gui::objectDestroyed ); } //o->mouseMove( x, y, mb ); } else { pLastMouseOver->onDestroy.disconnect( this ); pLastMouseOver = NULL; } } if ( pMouseDragWidget != NULL ) { if ( ( Utils::max(x, pPressedX) - Utils::min(x, pPressedX) > 5 ) || ( Utils::max(y, pPressedY) - Utils::min(y, pPressedY) > 5 ) ) { DragObject* d = NULL; pMouseDragWidget->onDrag( pMouseDragWidget, x - pMouseDragWidget->absoluteXPos(), y - pMouseDragWidget->absoluteYPos(), &d ); if ( d != NULL ) { pMouseDragWidget->mouseReleased( x - pMouseDragWidget->absoluteXPos(), y - pMouseDragWidget->absoluteYPos(), mb ); d->popup( x - (d->width() / 2), y - (d->height() / 2), *this ); if ( mouseChannelWidget() != NULL ) unsetMouseChannelWidget( *mouseChannelWidget() ); d->mousePressed( x, y, mb ); } pMouseDragWidget->onDestroy.disconnect( this ); pMouseDragWidget = NULL; } } }
/** * @brief * Send and process a message directly */ void Gui::SendMessage(const GuiMessage &cMessage) { // Pass message to message filters for (uint32 i=0; i<m_lstMessageFilters.GetNumOfElements(); i++) { // Pass message to filter m_lstMessageFilters[i]->AddMessage(cMessage); } // Get widget Widget *pWidget = cMessage.GetWidget(); // Process message switch (cMessage.GetType()) { // Exit application case MessageOnExit: // Set flag to leave application m_bActive = false; // Skip passing message to widget return; // Timer fired case MessageOnTimer: { // Get timer Timer *pTimer = cMessage.GetTimer(); // Discard message, if the timer has already been destroyed if (pTimer && m_lstTimers.IsElement(pTimer)) { // Fire timer pTimer->Fire(); } // Skip passing message to widget return; } // Widget has been destroyed case MessageOnDestroy: // Remove from parent widget if (pWidget->GetParent()) { pWidget->GetParent()->RemoveChild(pWidget); } // Remove from list of top-level widgets if (m_lstTopLevelWidgets.IsElement(pWidget)) { m_lstTopLevelWidgets.Remove(pWidget); } // Add widget to list of destroyed widgets m_lstDestroyedWidgets.Add(pWidget); // Pass message on to widget break; // Mouse has entered a widget case MessageOnMouseEnter: // Set new mouse-over widget if (m_pMouseOverWidget != pWidget) { // Update mouse-over widget m_pMouseOverWidgetNew = pWidget; UpdateMouseOverWidget(); } break; // Mouse has left a widget case MessageOnMouseLeave: // Reset mouse-over widget if (m_pMouseOverWidget == pWidget) { // Update mouse-over widget m_pMouseOverWidgetNew = nullptr; UpdateMouseOverWidget(); } break; // Widget has got the focus case MessageOnGetFocus: // Set focus widget if (m_pFocusWidget != pWidget) { // Update focus widget m_pFocusWidgetNew = pWidget; UpdateFocusWidget(); } break; // Widget has lost the focus case MessageOnLooseFocus: // Set focus widget if (m_pFocusWidget == pWidget) { // Update focus widget m_pFocusWidgetNew = nullptr; UpdateFocusWidget(); } break; case MessageOnUnknown: case MessageOnInternalMessage: case MessageOnWakeup: case MessageOnThemeChanged: case MessageOnUpdateContent: case MessageOnUpdateChildWidget: case MessageOnAddChildWidget: case MessageOnRemoveChildWidget: case MessageOnClose: case MessageOnCreate: case MessageOnShow: case MessageOnHide: case MessageOnEnable: case MessageOnDisable: case MessageOnActivate: case MessageOnDrawBackground: case MessageOnDraw: case MessageOnMove: case MessageOnSize: case MessageOnWindowState: case MessageOnEnterFullscreen: case MessageOnLeaveFullscreen: case MessageOnPreferredSize: case MessageOnAdjustContent: case MessageOnMouseOver: case MessageOnMouseMove: case MessageOnMouseHover: case MessageOnMousePosUpdate: case MessageOnMouseButtonDown: case MessageOnMouseButtonUp: case MessageOnMouseButtonClick: case MessageOnMouseButtonDoubleClick: case MessageOnMouseWheel: case MessageOnKeyDown: case MessageOnKeyUp: case MessageOnHotkey: case MessageOnDrop: case MessageOnUserMessage: default: // Nothing to do in here break; } // Pass message to widget if (pWidget) { pWidget->OnMessage(cMessage); } }
void Window::attach(Widget& w) { begin(); // FTLK: begin attaching new Fl_Wigets to this window w.attach(*this); // let the Widget create its Fl_Wigits end(); // FTLK: stop attaching new Fl_Wigets to this window }
void EditorItem::paintCell(QPainter *p, const QColorGroup & cg, int column, int width, int align) { //int margin = static_cast<Editor*>(listView())->itemMargin(); if(!d->property) return; if(column == 0) { QFont font = listView()->font(); if(d->property->isModified()) font.setBold(true); p->setFont(font); p->setBrush(cg.highlight()); p->setPen(cg.highlightedText()); KListViewItem::paintCell(p, cg, column, width, align); p->fillRect(parent() ? 0 : 50, 0, width, height()-1, QBrush(isSelected() ? cg.highlight() : backgroundColor())); p->setPen(isSelected() ? cg.highlightedText() : cg.text()); int delta = -20+KPROPEDITOR_ITEM_MARGIN; if ((firstChild() && dynamic_cast<EditorGroupItem*>(parent()))) { delta = -KPROPEDITOR_ITEM_MARGIN-1; } if (dynamic_cast<EditorDummyItem*>(parent())) { delta = KPROPEDITOR_ITEM_MARGIN*2; } else if (parent() && dynamic_cast<EditorDummyItem*>(parent()->parent())) { if (dynamic_cast<EditorGroupItem*>(parent())) delta += KPROPEDITOR_ITEM_MARGIN*2; else delta += KPROPEDITOR_ITEM_MARGIN*5; } p->drawText( QRect(delta,2, width+listView()->columnWidth(1)-KPROPEDITOR_ITEM_MARGIN*2, height()), Qt::AlignLeft | Qt::AlignTop /*| Qt::SingleLine*/, text(0)); p->setPen( KPROPEDITOR_ITEM_BORDER_COLOR ); p->drawLine(width-1, 0, width-1, height()-1); p->drawLine(0, -1, width-1, -1); p->setPen( KPROPEDITOR_ITEM_BORDER_COLOR ); //! \todo custom color? if (dynamic_cast<EditorDummyItem*>(parent())) p->drawLine(0, 0, 0, height()-1 ); } else if(column == 1) { QColorGroup icg(cg); icg.setColor(QColorGroup::Background, backgroundColor()); p->setBackgroundColor(backgroundColor()); Widget *widget = d->editor->createWidgetForProperty(d->property, false /*don't change Widget::property() */); if(widget) { QRect r(0, 0, d->editor->header()->sectionSize(1), height() - (widget->hasBorders() ? 0 : 1)); p->setClipRect(r, QPainter::CoordPainter); p->setClipping(true); widget->drawViewer(p, icg, r, d->property->value()); p->setClipping(false); } } p->setPen( KPROPEDITOR_ITEM_BORDER_COLOR ); //! \todo custom color? p->drawLine(0, height()-1, width, height()-1 ); }
void GuiManager::runLoop() { Dialog * const activeDialog = getTopDialog(); bool didSaveState = false; if (activeDialog == 0) return; #ifdef ENABLE_EVENTRECORDER // Suspend recording while GUI is shown g_eventRec.suspendRecording(); #endif if (!_stateIsSaved) { saveState(); _theme->enable(); didSaveState = true; _useStdCursor = !_theme->ownCursor(); if (_useStdCursor) setupCursor(); // _theme->refresh(); _redrawStatus = kRedrawFull; redraw(); } _lastMousePosition.x = _lastMousePosition.y = -1; _lastMousePosition.time = 0; Common::EventManager *eventMan = _system->getEventManager(); uint32 lastRedraw = 0; const uint32 waitTime = 1000 / 45; bool tooltipCheck = false; while (!_dialogStack.empty() && activeDialog == getTopDialog() && !eventMan->shouldQuit()) { redraw(); // Don't "tickle" the dialog until the theme has had a chance // to re-allocate buffers in case of a scaler change. activeDialog->handleTickle(); if (_useStdCursor) animateCursor(); // _theme->updateScreen(); // _system->updateScreen(); if (lastRedraw + waitTime < _system->getMillis(true)) { _theme->updateScreen(); _system->updateScreen(); lastRedraw = _system->getMillis(true); } Common::Event event; while (eventMan->pollEvent(event)) { // We will need to check whether the screen changed while polling // for an event here. While we do send EVENT_SCREEN_CHANGED // whenever this happens we still cannot be sure that we get such // an event immediately. For example, we might have an mouse move // event queued before an screen changed event. In some rare cases // this would make the GUI redraw (with the code a few lines // below) when it is not yet updated for new overlay dimensions. // As a result ScummVM would crash because it tries to copy data // outside the actual overlay screen. if (event.type != Common::EVENT_SCREEN_CHANGED) { checkScreenChange(); } // The top dialog can change during the event loop. In that case, flush all the // dialog-related events since they were probably generated while the old dialog // was still visible, and therefore not intended for the new one. // // This hopefully fixes strange behavior/crashes with pop-up widgets. (Most easily // triggered in 3x mode or when running ScummVM under Valgrind.) if (activeDialog != getTopDialog() && event.type != Common::EVENT_SCREEN_CHANGED) continue; processEvent(event, activeDialog); if (event.type == Common::EVENT_MOUSEMOVE) { tooltipCheck = true; } if (lastRedraw + waitTime < _system->getMillis(true)) { _theme->updateScreen(); _system->updateScreen(); lastRedraw = _system->getMillis(true); } } if (tooltipCheck && _lastMousePosition.time + kTooltipDelay < _system->getMillis(true)) { Widget *wdg = activeDialog->findWidget(_lastMousePosition.x, _lastMousePosition.y); if (wdg && wdg->hasTooltip() && !(wdg->getFlags() & WIDGET_PRESSED)) { Tooltip *tooltip = new Tooltip(); tooltip->setup(activeDialog, wdg, _lastMousePosition.x, _lastMousePosition.y); tooltip->runModal(); delete tooltip; } } // Delay for a moment _system->delayMillis(10); } // WORKAROUND: When quitting we might not properly close the dialogs on // the dialog stack, thus we do this here to avoid any problems. // This is most noticable in bug #3481395 "LAUNCHER: Can't quit from unsupported game dialog". // It seems that Dialog::runModal never removes the dialog from the dialog // stack, thus if the dialog does not call Dialog::close to close itself // it will never be removed. Since we can have multiple run loops being // called we cannot rely on catching EVENT_QUIT in the event loop above, // since it would only catch it for the top run loop. if (eventMan->shouldQuit() && activeDialog == getTopDialog()) getTopDialog()->close(); if (didSaveState) { _theme->disable(); restoreState(); _useStdCursor = false; } #ifdef ENABLE_EVENTRECORDER // Resume recording once GUI is shown g_eventRec.resumeRecording(); #endif }
void OptionsCommand::onExecute(Context* context) { // Load the window widget base::UniquePtr<Window> window(app::load_widget<Window>("options.xml", "options")); Widget* check_smooth = app::find_widget<Widget>(window, "smooth"); Widget* check_autotimeline = app::find_widget<Widget>(window, "autotimeline"); Widget* move_click2 = app::find_widget<Widget>(window, "move_click2"); Widget* draw_click2 = app::find_widget<Widget>(window, "draw_click2"); Widget* cursor_color_box = app::find_widget<Widget>(window, "cursor_color_box"); Widget* grid_color_box = app::find_widget<Widget>(window, "grid_color_box"); Widget* pixel_grid_color_box = app::find_widget<Widget>(window, "pixel_grid_color_box"); m_checked_bg = app::find_widget<ComboBox>(window, "checked_bg_size"); m_checked_bg_zoom = app::find_widget<Widget>(window, "checked_bg_zoom"); Widget* checked_bg_color1_box = app::find_widget<Widget>(window, "checked_bg_color1_box"); Widget* checked_bg_color2_box = app::find_widget<Widget>(window, "checked_bg_color2_box"); Button* checked_bg_reset = app::find_widget<Button>(window, "checked_bg_reset"); Widget* undo_size_limit = app::find_widget<Widget>(window, "undo_size_limit"); Widget* undo_goto_modified = app::find_widget<Widget>(window, "undo_goto_modified"); Widget* button_ok = app::find_widget<Widget>(window, "button_ok"); // Cursor color ColorButton* cursor_color = new ColorButton(Editor::get_cursor_color(), IMAGE_RGB); cursor_color->setId("cursor_color"); cursor_color_box->addChild(cursor_color); // Get global settings for documents IDocumentSettings* docSettings = context->getSettings()->getDocumentSettings(NULL); // Grid color ColorButton* grid_color = new ColorButton(docSettings->getGridColor(), IMAGE_RGB); grid_color->setId("grid_color"); grid_color_box->addChild(grid_color); // Pixel grid color ColorButton* pixel_grid_color = new ColorButton(docSettings->getPixelGridColor(), IMAGE_RGB); pixel_grid_color->setId("pixel_grid_color"); pixel_grid_color_box->addChild(pixel_grid_color); // Others if (get_config_bool("Options", "MoveClick2", false)) move_click2->setSelected(true); if (get_config_bool("Options", "DrawClick2", false)) draw_click2->setSelected(true); if (get_config_bool("Options", "MoveSmooth", true)) check_smooth->setSelected(true); if (get_config_bool("Options", "AutoShowTimeline", true)) check_autotimeline->setSelected(true); // Checked background size m_checked_bg->addItem("16x16"); m_checked_bg->addItem("8x8"); m_checked_bg->addItem("4x4"); m_checked_bg->addItem("2x2"); m_checked_bg->setSelectedItemIndex((int)RenderEngine::getCheckedBgType()); // Zoom checked background if (RenderEngine::getCheckedBgZoom()) m_checked_bg_zoom->setSelected(true); // Checked background colors m_checked_bg_color1 = new ColorButton(RenderEngine::getCheckedBgColor1(), IMAGE_RGB); m_checked_bg_color2 = new ColorButton(RenderEngine::getCheckedBgColor2(), IMAGE_RGB); checked_bg_color1_box->addChild(m_checked_bg_color1); checked_bg_color2_box->addChild(m_checked_bg_color2); // Reset button checked_bg_reset->Click.connect(Bind<void>(&OptionsCommand::onResetCheckedBg, this)); // Undo limit undo_size_limit->setTextf("%d", get_config_int("Options", "UndoSizeLimit", 8)); // Goto modified frame/layer on undo/redo if (get_config_bool("Options", "UndoGotoModified", true)) undo_goto_modified->setSelected(true); // Show the window and wait the user to close it window->openWindowInForeground(); if (window->getKiller() == button_ok) { int undo_size_limit_value; Editor::set_cursor_color(cursor_color->getColor()); docSettings->setGridColor(grid_color->getColor()); docSettings->setPixelGridColor(pixel_grid_color->getColor()); set_config_bool("Options", "MoveSmooth", check_smooth->isSelected()); set_config_bool("Options", "AutoShowTimeline", check_autotimeline->isSelected()); set_config_bool("Options", "MoveClick2", move_click2->isSelected()); set_config_bool("Options", "DrawClick2", draw_click2->isSelected()); RenderEngine::setCheckedBgType((RenderEngine::CheckedBgType)m_checked_bg->getSelectedItemIndex()); RenderEngine::setCheckedBgZoom(m_checked_bg_zoom->isSelected()); RenderEngine::setCheckedBgColor1(m_checked_bg_color1->getColor()); RenderEngine::setCheckedBgColor2(m_checked_bg_color2->getColor()); undo_size_limit_value = undo_size_limit->getTextInt(); undo_size_limit_value = MID(1, undo_size_limit_value, 9999); set_config_int("Options", "UndoSizeLimit", undo_size_limit_value); set_config_bool("Options", "UndoGotoModified", undo_goto_modified->isSelected()); // Save configuration flush_config_file(); } }
void FileSystemActor::onLaunch() { assert(!filePath.isNull()); if (!_onLaunchHandler.empty()) _onLaunchHandler(this); // override for widgets Widget * w = widgetManager->getActiveWidgetForFile(getFullPath()); if (w && w->isWidgetOverrideActor(this)) { w->launchWidgetOverride(this); return; } // Do a quick pass to determine what needs to be created or not bool isWatchingHighlighted = cam->isWatchedActorHighlighted(this); bool zoomIntoImage = isFileSystemType(Image) && !isWatchingHighlighted && texMgr->isTextureState(thumbnailID, TextureLoaded); bool launchImage = (isFileSystemType(Image) && isWatchingHighlighted) && !texMgr->isTextureState(thumbnailID, TextureLoaded); bool createTemporaryActor = !zoomIntoImage && !launchImage; bool createRandomAnimPath = createTemporaryActor; Actor * obj = NULL; if (createTemporaryActor) { obj = new Actor(); Vec3 startPosition; // Set up the state of the Actor obj->pushActorType(Temporary); obj->setDims(getDims()); obj->setGravity(false); obj->setCollisions(false); obj->setAlphaAnim(getAlpha(), 0.2f, 40); obj->setGlobalPose(getGlobalPose()); obj->setObjectToMimic(this); } // Special case for launching a pileized actor Vec3 startPosition; if (isPileized()) { startPosition = pileizedPile->getGlobalPosition(); }else{ startPosition = getGlobalPosition(); } // create random animation path from the icon up to the camera eye if (createRandomAnimPath) { // Set an animation that moves the icon into the camera CreateRandomAnimPath(obj, startPosition, cam->getEye(), 40); // Delete the object after the random animation is over. animManager->removeAnimation(obj); animManager->addAnimation(AnimationEntry(obj, (FinishedCallBack) DeleteActorAfterAnim)); } // handle the launch override if there is one if (!getLaunchOverride().isEmpty()) { fsManager->launchFileAsync(getLaunchOverride()); return; } // Execute this Icon if (!isFileSystemType(Virtual)) { // If this is a folder, then try and browse to it if (scnManager->isShellExtension && isFileSystemType(Folder)) { // try and send a custom message to the proxy window to move to the child incrementNumTimesLaunched(); animManager->finishAnimation(this); SaveSceneToFile(); winOS->ShellExtBrowseToChild(filePath); return; } // This is an image, so zoom to it if we are not already watching it else if (zoomIntoImage && isFileSystemType(Image) && texMgr->isTextureState(thumbnailID, TextureLoaded)) { Key_EnableSlideShow(); this->putToSleep(); // record this zoom interaction statsManager->getStats().bt.interaction.actors.highlightedImage++; return; } // Execute it as normal // QString lnkTarget, lnkArgs, lnkWorkingDir; bool fileLaunched = false; /* if (isFileSystemType(Link)) { fsManager->getShortcutTarget(getFullPath(), &lnkTarget, &lnkArgs, &lnkWorkingDir); fileLaunched = fsManager->launchFileAsync(lnkTarget, lnkArgs, lnkWorkingDir); } else */ fileLaunched = fsManager->launchFileAsync(filePath); if (fileLaunched) { // otherwise, just increment this file launch count and execute it // it is decided that images do not auto-grow (was a design decision) if (!launchImage) { incrementNumTimesLaunched(); } // record this launch statsManager->getStats().bt.interaction.actors.launchedFile++; } } else { incrementNumTimesLaunched(); fsManager->launchFile(filePath); } }
void RaceSetupScreen::init() { Screen::init(); input_manager->setMasterPlayerOnly(true); RibbonWidget* w = getWidget<RibbonWidget>("difficulty"); assert( w != NULL ); race_manager->setMajorMode(RaceManager::MAJOR_MODE_SINGLE); if (UserConfigParams::m_difficulty == RaceManager::DIFFICULTY_BEST && PlayerManager::getCurrentPlayer()->isLocked("difficulty_best")) { w->setSelection(RaceManager::DIFFICULTY_HARD, PLAYER_ID_GAME_MASTER); } else { w->setSelection( UserConfigParams::m_difficulty, PLAYER_ID_GAME_MASTER ); } DynamicRibbonWidget* w2 = getWidget<DynamicRibbonWidget>("gamemode"); assert( w2 != NULL ); w2->clearItems(); // ---- Add game modes irr::core::stringw name1 = irr::core::stringw( RaceManager::getNameOf(RaceManager::MINOR_MODE_NORMAL_RACE)) + L"\n"; //FIXME: avoid duplicating descriptions from the help menu! name1 += _("All blows allowed, so catch weapons and make clever use of them!"); w2->addItem( name1, IDENT_STD, RaceManager::getIconOf(RaceManager::MINOR_MODE_NORMAL_RACE)); irr::core::stringw name2 = irr::core::stringw( RaceManager::getNameOf(RaceManager::MINOR_MODE_TIME_TRIAL)) + L"\n"; //FIXME: avoid duplicating descriptions from the help menu! name2 += _("Contains no powerups, so only your driving skills matter!"); w2->addItem( name2, IDENT_TTRIAL, RaceManager::getIconOf(RaceManager::MINOR_MODE_TIME_TRIAL)); if (PlayerManager::getCurrentPlayer()->isLocked(IDENT_FTL)) { w2->addItem( _("Locked : solve active challenges to gain access to more!"), "locked", RaceManager::getIconOf(RaceManager::MINOR_MODE_FOLLOW_LEADER), true); } else { irr::core::stringw name3 = irr::core::stringw( RaceManager::getNameOf(RaceManager::MINOR_MODE_FOLLOW_LEADER)) + L"\n"; //I18N: short definition for follow-the-leader game mode name3 += _("Keep up with the leader kart but don't overtake it!"); w2->addItem(name3, IDENT_FTL, RaceManager::getIconOf(RaceManager::MINOR_MODE_FOLLOW_LEADER), false); } irr::core::stringw name4 = irr::core::stringw(_("Battle")) + L"\n"; //FIXME: avoid duplicating descriptions from the help menu! name4 += _("Hit others with weapons until they lose all their lives."); w2->addItem( name4, IDENT_STRIKES, RaceManager::getIconOf(RaceManager::MINOR_MODE_FREE_FOR_ALL)); irr::core::stringw name5 = irr::core::stringw( RaceManager::getNameOf(RaceManager::MINOR_MODE_SOCCER)) + L"\n"; name5 += _("Push the ball into the opposite cage to score goals."); w2->addItem( name5, IDENT_SOCCER, RaceManager::getIconOf(RaceManager::MINOR_MODE_SOCCER)); #define ENABLE_EASTER_EGG_MODE #ifdef ENABLE_EASTER_EGG_MODE if(race_manager->getNumLocalPlayers() == 1) { irr::core::stringw name1 = irr::core::stringw( RaceManager::getNameOf(RaceManager::MINOR_MODE_EASTER_EGG)) + L"\n"; //FIXME: avoid duplicating descriptions from the help menu! name1 += _("Explore tracks to find all hidden eggs"); w2->addItem( name1, IDENT_EASTER, RaceManager::getIconOf(RaceManager::MINOR_MODE_EASTER_EGG)); } #endif irr::core::stringw name6 = irr::core::stringw( _("Ghost replay race")) + L"\n"; name6 += _("Race against ghost karts and try to beat them!"); w2->addItem( name6, IDENT_GHOST, "/gui/icons/mode_ghost.png"); w2->updateItemDisplay(); // restore saved game mode switch (UserConfigParams::m_game_mode) { case CONFIG_CODE_NORMAL : w2->setSelection(IDENT_STD, PLAYER_ID_GAME_MASTER, true); break; case CONFIG_CODE_TIMETRIAL : w2->setSelection(IDENT_TTRIAL, PLAYER_ID_GAME_MASTER, true); break; case CONFIG_CODE_FTL : w2->setSelection(IDENT_FTL, PLAYER_ID_GAME_MASTER, true); break; case CONFIG_CODE_3STRIKES : w2->setSelection(IDENT_STRIKES, PLAYER_ID_GAME_MASTER, true); break; case CONFIG_CODE_EASTER : w2->setSelection(IDENT_EASTER, PLAYER_ID_GAME_MASTER, true); break; case CONFIG_CODE_SOCCER : w2->setSelection(IDENT_SOCCER, PLAYER_ID_GAME_MASTER, true); break; case CONFIG_CODE_GHOST : w2->setSelection(IDENT_GHOST, PLAYER_ID_GAME_MASTER, true); break; } { RibbonWidget* w = getWidget<RibbonWidget>("difficulty"); assert(w != NULL); int index = w->findItemNamed("best"); Widget* hardestWidget = &w->getChildren()[index]; if (PlayerManager::getCurrentPlayer()->isLocked("difficulty_best")) { hardestWidget->setBadge(LOCKED_BADGE); hardestWidget->setActive(false); } else { hardestWidget->unsetBadge(LOCKED_BADGE); hardestWidget->setActive(true); } } } // init
void FileSystemActor::setFilePath(QString fullPath, bool skipTextureResolution /*=false*/) { if (_isAnimatedTexture) _animatedTextureSource.setPath(fullPath); // Save the Path (or Virtual Folder Name) filePath = fullPath; winOS->GetShortPathName(fullPath, shortPath); if (skipTextureResolution) return; // resolve the texture to load for this file if there is one QString ext = fsManager->getFileExtension(fullPath); QString texId; GLTextureDetail detail = FileIcon; GLTextureLoadPriority priority = NormalPriority; bool isVista = winOS->IsWindowsVersionGreaterThanOrEqualTo(WindowsVista); bool overrideSystemTextures = GLOBAL(settings).useThemeIconOverrides; int virtualIconId = winOS->GetIconTypeFromFileName(fullPath); if (virtualIconId > -1) { // mark this is a virtual icon pushFileSystemType(Virtual); pushFileSystemType(Folder); // check if we are overloading any virtual icons (only My Computer for now) if (overrideSystemTextures && (virtualIconId == MyComputer) && texMgr->hasTexture("override.virtual.mycomputer")) { texId = QT_NT("override.virtual.mycomputer"); detail = HiResImage; } else { // otherwise, we will just load the icon later texId = fullPath; // NOTE: we force load these icons here because we do not do so if the // texture id is set below loadThumbnailTexture(GLTextureObject(Load, texId, texId, FileIcon, priority, false)); } } else { // not a virtual icon, just a random icon then unsigned int fileAttributes = fsManager->getFileAttributes(fullPath); // delete this object if it doesn't exist (and it's not a photo frame or volume) if (!fileAttributes && !(isFileSystemType(PhotoFrame) || isFileSystemType(LogicalVolume))) { animManager->addAnimation(AnimationEntry(this, (FinishedCallBack) DeleteActorAfterAnim)); setAlpha(0.0f); return; } // make sure there's no lingering animations animManager->removeAnimation(this); setAlpha(1.0f); // XXX: check if we are using animated textures // _isAnimatedTexture = (fileExtension == ".gif"); // check if this is a shortcut // NOTE: if it is a valid shortcut, the file attributes and extension // now refer to the target and not the shortcut itself if (fileAttributes && ext == ".lnk") { // resolve the shortcut target fsManager->getShortcutTarget(fullPath, &lnkFullPath); if (fsManager->isValidFileName(lnkFullPath)) { pushFileSystemType(Link); popFileSystemType(DeadLink); fileAttributes = fsManager->getFileAttributes(lnkFullPath); ext = fsManager->getFileExtension(lnkFullPath); } else { pushFileSystemType(DeadLink); } } // check if it is a folder if (fileAttributes & Directory) { pushFileSystemType(Folder); // XXX: only override shortcuts, and not folders? /* if (!overrideSystemTextures || !enableFileTypeIconsForShortcuts) { texId = winOS->GetSystemIconInfo(getFullPath()); } else */ if (overrideSystemTextures) { texId = QT_NT("override.ext.folder"); detail = HiResImage; } } else { // normal file pushFileSystemType(File); hasExtension(true); //only files have extension, so the nameable extension hide only applies here // resolve some information about the file if (ext.size() > 0) { if (ext == ".exe") pushFileSystemType(Executable); else { // XXX: check if it's a document // pushFileSystemType(Document); if (overrideSystemTextures) { QString potentialOverrideTex = QString(QT_NT("override.ext")) + ext; if (texMgr->hasTexture(potentialOverrideTex)) { texId = potentialOverrideTex; detail = HiResImage; } } } // load the thumbnail if this is an image // NOTE: we append the period because if the extension is empty // the search is always true if (GLOBAL(supportedExtensions).contains(ext + ".")) { if (!isThumbnailized()) enableThumbnail(true, !winOS->IsFileInUse(fullPath)); pushFileSystemType(Image); pushFileSystemType(Thumbnail); hideText(true); } } } } // at this point, resolve the file icon texture id if there was no override if (texId.isEmpty()) { texId = winOS->GetSystemIconInfo(fullPath); // mark the texture for loading loadThumbnailTexture(GLTextureObject(Load, texId, texId, detail, priority,false)); } setTextureID(texId); // we also want to try and load thumbnails for normal files if they exist // (as long as it's not a widget file) Widget * w = widgetManager->getActiveWidgetForFile(fullPath); if (!isThumbnailized() && (detail == FileIcon) && !w) { FileSystemActorType typesToIgnore = FileSystemActorType(Executable | Virtual); // on vista, just queue the thumbnail for loading if (isVista && !isFileSystemType(typesToIgnore)) { QString ext = fsManager->getFileExtension(getTargetPath()); loadThumbnailTexture(GLTextureObject(Load|Reload, _alternateThumbnailId, getTargetPath(), SampledImage, IdlePriority)); } // on windows xp, check if the thumbs db has a record first else if (winOS->IsWindowsVersion(WindowsXP)) { if (texMgr->hasWinThumbnail(getTargetPath())) { loadThumbnailTexture(GLTextureObject(Load|Reload, _alternateThumbnailId, getTargetPath(), SampledImage, IdlePriority)); } } } // XXX: (disabled) set the initial dimensions and weight of this file based on it's size // setDimsFromFileSize(this); // set the text if(!isFileSystemType(PhotoFrame)) { if (w && w->isWidgetOverrideActor(this)) { setText(w->getWidgetOverrideLabel(this)); Vec3 actorDims = getDims(); float aspect = (actorDims.x / actorDims.y); Vec3 dims(GLOBAL(settings).xDist, GLOBAL(settings).zDist / aspect, GLOBAL(settings).yDist); float scale = w->getWidgetOverrideScale(this); if (scale > 0.0f) { dims *= scale; setSizeAnim(getDims(), dims, 25); } } else setText(getFileName(isFileSystemType(Link) || isFileSystemType(DeadLink))); } setRespectIconExtensionVisibility(!isFileSystemType(Folder)); // New name was set, invalidate text textManager->invalidate(); rndrManager->invalidateRenderer(); }
Widget* ResourceLayout::createWidget(const WidgetInfo& _widgetInfo, const std::string& _prefix, Widget* _parent, bool _template) { std::string widgetName = _widgetInfo.name; WidgetStyle style = _widgetInfo.style; std::string widgetLayer = _widgetInfo.layer; if (!widgetName.empty()) widgetName = _prefix + widgetName; if (_parent != nullptr && style != WidgetStyle::Popup) widgetLayer.clear(); IntCoord coord; if (_widgetInfo.positionType == WidgetInfo::Pixels) coord = _widgetInfo.intCoord; else if (_widgetInfo.positionType == WidgetInfo::Relative) { if (_parent == nullptr || style == WidgetStyle::Popup) coord = CoordConverter::convertFromRelative(_widgetInfo.floatCoord, RenderManager::getInstance().getViewSize()); else coord = CoordConverter::convertFromRelative(_widgetInfo.floatCoord, _parent->getClientCoord().size()); } Widget* wid; if (nullptr == _parent) wid = Gui::getInstance().createWidgetT(_widgetInfo.type, _widgetInfo.skin, coord, _widgetInfo.align, widgetLayer, widgetName); else if (_template) wid = _parent->_createSkinWidget(style, _widgetInfo.type, _widgetInfo.skin, coord, _widgetInfo.align, widgetLayer, widgetName); else wid = _parent->createWidgetT(style, _widgetInfo.type, _widgetInfo.skin, coord, _widgetInfo.align, widgetLayer, widgetName); for (VectorStringPairs::const_iterator iter = _widgetInfo.properties.begin(); iter != _widgetInfo.properties.end(); ++iter) { wid->setProperty(iter->first, iter->second); } for (MapString::const_iterator iter = _widgetInfo.userStrings.begin(); iter != _widgetInfo.userStrings.end(); ++iter) { wid->setUserString(iter->first, iter->second); if (!_template) LayoutManager::getInstance().eventAddUserString(wid, iter->first, iter->second); } for (VectorWidgetInfo::const_iterator iter = _widgetInfo.childWidgetsInfo.begin(); iter != _widgetInfo.childWidgetsInfo.end(); ++iter) { createWidget(*iter, _prefix, wid); } for (std::vector<ControllerInfo>::const_iterator iter = _widgetInfo.controllers.begin(); iter != _widgetInfo.controllers.end(); ++iter) { MyGUI::ControllerItem* item = MyGUI::ControllerManager::getInstance().createItem(iter->type); if (item) { for (MapString::const_iterator iterProp = iter->properties.begin(); iterProp != iter->properties.end(); ++iterProp) { item->setProperty(iterProp->first, iterProp->second); } MyGUI::ControllerManager::getInstance().addItem(wid, item); } else { MYGUI_LOG(Warning, "Controller '" << iter->type << "' not found"); } } return wid; }
static void doMenu() { Widget *w; int left, right, up, down, attack, xAxisMoved, yAxisMoved; left = FALSE; right = FALSE; up = FALSE; down = FALSE; attack = FALSE; if (menuInput.left == TRUE) { left = TRUE; } else if (menuInput.right == TRUE) { right = TRUE; } else if (menuInput.up == TRUE) { up = TRUE; } else if (menuInput.down == TRUE) { down = TRUE; } else if (menuInput.attack == TRUE) { attack = TRUE; } else if (input.left == TRUE) { left = TRUE; } else if (input.right == TRUE) { right = TRUE; } else if (input.up == TRUE) { up = TRUE; } else if (input.down == TRUE) { down = TRUE; } else if (input.attack == TRUE) { attack = TRUE; } if (down == TRUE) { menu.index++; if (menu.index == menu.widgetCount) { menu.index = 0; } playSound("sound/common/click"); } else if (up == TRUE) { menu.index--; if (menu.index < 0) { menu.index = menu.widgetCount - 1; } playSound("sound/common/click"); } else if (attack == TRUE) { w = menu.widgets[menu.index]; if (w->clickAction != NULL) { w->clickAction(); } playSound("sound/common/click"); } else if (left == TRUE) { w = menu.widgets[menu.index]; if (w->leftAction != NULL) { w->leftAction(); } playSound("sound/common/click"); } else if (right == TRUE) { w = menu.widgets[menu.index]; if (w->rightAction != NULL) { w->rightAction(); } playSound("sound/common/click"); } xAxisMoved = input.xAxisMoved; yAxisMoved = input.yAxisMoved; memset(&menuInput, 0, sizeof(Input)); memset(&input, 0, sizeof(Input)); input.xAxisMoved = xAxisMoved; input.yAxisMoved = yAxisMoved; }
void Window::dispose() { Widget *widget = this; while (widget->parent()) widget = widget->parent(); ((Screen *) widget)->disposeWindow(this); }
void onMouseWheel(const input::events::MouseWheel& ev){ if(focused) focused->onMouseWheel(ev); }
void Window::center() { Widget *widget = this; while (widget->parent()) widget = widget->parent(); ((Screen *) widget)->centerWindow(this); }
void onKey(const input::events::Key& ev) { if(focused) focused->onKey(ev); }
void Window::detach(Widget& b) { b.hide(); }
void onJoystick(const input::events::Joystick& ev) { if(focused) focused->onJoystick(ev); }
void Gui::render( ) { List<UpdateWidget*>& l = Widget::updatedWidgets(); if ( l.count() <= 0 ) return; int i = l.count() - 1; Widget* o = NULL; List<Widget*> tmpL; l.sort( &objectsListSortCallback ); while( i >= 0 ){ o = l.get( i )->o; Rect r = l.get( i )->r; if ( pFgFrame != NULL ) fgFrame().getWidgetsInRect( tmpL, r ); if ( pTopFrame != NULL ) topFrame().getWidgetsInRect( tmpL, r ); tmpL.sort( &objectListSortCallback ); int i2 = 0; bool skip = false; // int before = tmpL.count(); while ( (i2 < tmpL.count()) && ( o != NULL ) ) { Widget* o2 = tmpL.get( i2 ); Rect r2( o2->absoluteXPos(), o2->absoluteYPos(), o2->width(), o2->height() ); if ( o2->border() != NULL ) { if ( o2->border()->drawmode() != drawOpaque ) r2.applyBorder( o2->border() ); } if ( (r2.encloses( r )) && ( o2->drawmode() == drawOpaque ) && ( o2->visible() ) ) { if ( o2->zIndex() > o->zIndex() ) { skip = true; break; } else { while ( i2+1 < tmpL.count() ) { tmpL.remove( i2+1 ); } break; } } i2++; } if ( !skip ) { for( int i2 = tmpL.count() - 1; i2 >= 0; i2-- ){ Rect r2 = Rect( tmpL.get( i2 )->absoluteXPos(), tmpL.get( i2 )->absoluteYPos(), tmpL.get( i2 )->width(), tmpL.get( i2 )->height() ); r2.crop( r ); screen().pushClipRect( r2 ); screen().pushClipRect( tmpL.get( i2 )->getClipRect() ); screen().setRelativePoint( tmpL.get( i2 )->absoluteXPos(), tmpL.get( i2 )->absoluteYPos() ); tmpL.get( i2 )->renderBorder( screen() ); screen().setRelativePoint( tmpL.get( i2 )->absoluteXPos() + tmpL.get( i2 )->borderLeft(), tmpL.get( i2 )->absoluteYPos() + tmpL.get( i2 )->borderTop() ); Rect r3( r2.left - tmpL.get( i2 )->absoluteXPos() - tmpL.get( i2 )->borderLeft(), r2.top - tmpL.get( i2 )->absoluteYPos() - tmpL.get( i2 )->borderTop(), r2.width, r2.height ); tmpL.get( i2 )->render( screen(), r3 ); screen().popClipRect(); screen().popClipRect(); screen().setRelativePoint( 0, 0 ); } for( int i = 0; i < pPopups.count(); i++ ) { Popup* p = pPopups.get( i ); r.crop( p->getRect() ); if ( r.area() > 0 ) { Rect r = p->getRect(); r.crop( r ); p->render( r ); } } } else { } tmpL.clear(); i--; } Widget::clearUpdatedWidgets(); }
bool InputManager::injectMousePress(int _absx, int _absy, MouseButton _id) { Widget* old_key_focus = mWidgetKeyFocus; // если мы щелкнули не на гуй if (!isFocusMouse()) { resetKeyFocusWidget(); if (old_key_focus != mWidgetKeyFocus) eventChangeKeyFocus(mWidgetKeyFocus); return false; } // если активный элемент заблокирован //FIXME if (!mWidgetMouseFocus->getEnabled()) return true; if (MouseButton::Left == _id) { // захват окна mLeftMouseCapture = true; // запоминаем место нажатия if (mLayerMouseFocus != nullptr) { IntPoint point = mLayerMouseFocus->getPosition(_absx, _absy); mLastLeftPressed = point; } } if (MouseButton::Right == _id) { // захват окна mRightMouseCapture = true; // запоминаем место нажатия if (mLayerMouseFocus != nullptr) { IntPoint point = mLayerMouseFocus->getPosition(_absx, _absy); mLastRightPressed = point; } } // ищем вверх тот виджет который может принимать фокус Widget* item = mWidgetMouseFocus; while ((item != nullptr) && (!item->getNeedKeyFocus())) item = item->getParent(); // устанавливаем перед вызовом т.к. возможно внутри ктонить поменяет фокус под себя setKeyFocusWidget(item); if (mWidgetMouseFocus != nullptr) { mWidgetMouseFocus->_riseMouseButtonPressed(_absx, _absy, _id); // после пресса может сброситься if (mWidgetMouseFocus) { // поднимаем виджет, надо подумать что делать если поменялся фокус клавы LayerManager::getInstance().upLayerItem(mWidgetMouseFocus); // поднимаем пикинг Overlapped окон Widget* pick = mWidgetMouseFocus; do { // если оверлаппед, то поднимаем пикинг if (pick->getWidgetStyle() == WidgetStyle::Overlapped) { if (pick->getParent()) pick->getParent()->_forcePeek(pick); } pick = pick->getParent(); } while (pick); } } if (old_key_focus != mWidgetKeyFocus) eventChangeKeyFocus(mWidgetKeyFocus); return true; }
void Container::makeLayout(int x,int y,int w,int h) { debug_output("Container::makeLayout(x: %d, y: %d, w: %d, h: %d)\n",x,y,w,h); Widget::makeLayout(x,y,w,h); // if(border) this->x += border,this->y += border,width -= border*2,height -= border*2; if(child) { Widget *c = child; int i,n = 0,sz[children],min,max,sum,exp,nexp,sp = (children-1)*spacing; int x1 = 0,y1 = 0,w1 = 0,h1 = 0,w2 = width,h2 = height; if(type==WIDGET_VOID) x1 += this->x,y1 += this->y; else if(type==WIDGET_FRAME) x1 += MulDiv(dbu_x,7,4),y1 += MulDiv(dbu_y,11,8),w2 -= MulDiv(dbu_x,7+7,4),h1 -= MulDiv(dbu_y,11+7,8); if((style&HORIZONTAL)) { for(i=0,c=child,min=0,max=0,sum=0,exp=0,nexp=0; c; ++i,c=c->next) { sum += sz[i] = n = c->getMinimumWidth(); if(!min || min>n) min = n; if(max<n) max = n; if((c->style&EXPAND)) ++exp; else nexp += n; } debug_output("Container::makeLayout(min: %d, max: %d, exp: %d, nexp: %d)\n",min,max,exp,nexp); if((style&HOMOGENOUS)) { for(w1=(w2-sp)/children,c=child; c; x1+=w1+spacing,c=c->next) { if(!c->next) w1 = w2-x1; debug_output("Container::makeLayout(HOMOGENOUS x1: %d, w1: %d %s)\n",x1,w1,c->text? c->text : "-"); c->makeLayout(x1,y1,w1,h2); } } else { for(i=0,c=child; c; ++i,x1+=w1+spacing,c=c->next) { if((c->style&EXPAND)) { if(!c->next) w1 = w2-x1; else w1 = (w2-sp-nexp)/exp; } else w1 = sz[i]; debug_output("Container::makeLayout(x1: %d, w1: %d %s)\n",x1,w1,c->text? c->text : "-"); c->makeLayout(x1,y1,w1,h2); } } } else if((style&VERTICAL)) { for(i=0,c=child,min=0,max=0,sum=0,exp=0,nexp=0; c; ++i,c=c->next) { sum += sz[i] = n = c->getMinimumHeight(); if(!min || min>n) min = n; if(max<n) max = n; if((c->style&EXPAND)) ++exp; else nexp += n; } debug_output("Container::makeLayout(min: %d, max: %d, exp: %d, nexp: %d)\n",min,max,exp,nexp); if((style&HOMOGENOUS)) { for(h1=(h2-sp)/children,c=child; c; y1+=n+spacing,c=c->next) { if(!c->next) h1 = h2-y1; debug_output("Container::makeLayout(HOMOGENOUS y1: %d, h1: %d %s)\n",y1,h1,c->text? c->text : "-"); c->makeLayout(x1,y1,w2,h1); } } else { for(i=0,c=child; c; ++i,y1+=h1+spacing,c=c->next) { if((c->style&EXPAND)) { if(!c->next) h1 = h2-y1; else h1 = (h2-sp-nexp)/exp; } else h1 = sz[i]; debug_output("Container::makeLayout(y1: %d, h1: %d %s)\n",y1,h1,c->text? c->text : "-"); c->makeLayout(x1,y1,w2,h1); } } } else if((style&TABLE)) { } else { for(; c; c=c->next) c->makeLayout(x,y,w,h); } } }
bool InputManager::injectMouseMove(int _absx, int _absy, int _absz) { // запоминаем позицию mMousePosition.set(_absx, _absy); // вычисляем прирост по колеса int relz = _absz - mOldAbsZ; mOldAbsZ = _absz; // проверка на скролл if (relz != 0) { bool isFocus = isFocusMouse(); if (mWidgetMouseFocus != nullptr) mWidgetMouseFocus->_riseMouseWheel(relz); return isFocus; } if (mLeftMouseCapture || mRightMouseCapture) { if (mWidgetMouseFocus != nullptr) { if (mLayerMouseFocus != nullptr) { IntPoint point = mLayerMouseFocus->getPosition(_absx, _absy); if (mLeftMouseCapture) mWidgetMouseFocus->_riseMouseDrag(point.left, point.top, MouseButton::Left); if (mRightMouseCapture) mWidgetMouseFocus->_riseMouseDrag(point.left, point.top, MouseButton::Right); } } else { mLeftMouseCapture = false; mRightMouseCapture = false; } return true; } Widget* old_mouse_focus = mWidgetMouseFocus; // ищем активное окно Widget* item = LayerManager::getInstance().getWidgetFromPoint(_absx, _absy); // ничего не изменилось if (mWidgetMouseFocus == item) { bool isFocus = isFocusMouse(); if (mWidgetMouseFocus != nullptr) { if (mLayerMouseFocus != nullptr) { IntPoint point = mLayerMouseFocus->getPosition(_absx, _absy); mWidgetMouseFocus->_riseMouseMove(point.left, point.top); } } return isFocus; } if (item) { // поднимаемся до рута Widget* root = item; while (root->getParent()) root = root->getParent(); // проверяем на модальность if (!mVectorModalRootWidget.empty()) { if (root != mVectorModalRootWidget.back()) { item = nullptr; } } if (item != nullptr) { mLayerMouseFocus = root->getLayer(); } } //-------------------------------------------------------------------------------------// // новый вид рутового фокуса мыши Widget* save_widget = nullptr; // спускаемся по новому виджету и устанавливаем рутовый фокус Widget* root_focus = item; while (root_focus != nullptr) { if (root_focus->getRootMouseFocus()) { save_widget = root_focus; break; } root_focus->_setRootMouseFocus(true); root_focus->_riseMouseChangeRootFocus(true); root_focus = root_focus->getParent(); } // спускаемся по старому виджету и сбрасываем фокус root_focus = mWidgetMouseFocus; while (root_focus != nullptr) { if (root_focus == save_widget) break; root_focus->_setRootMouseFocus(false); root_focus->_riseMouseChangeRootFocus(false); root_focus = root_focus->getParent(); } //-------------------------------------------------------------------------------------// // смена фокуса, проверяем на доступность виджета if ((mWidgetMouseFocus != nullptr) && (mWidgetMouseFocus->getEnabled())) { mWidgetMouseFocus->_riseMouseLostFocus(item); } if ((item != nullptr) && (item->getEnabled())) { item->_riseMouseMove(_absx, _absy); item->_riseMouseSetFocus(mWidgetMouseFocus); } // запоминаем текущее окно mWidgetMouseFocus = item; if (old_mouse_focus != mWidgetMouseFocus) eventChangeMouseFocus(mWidgetMouseFocus); return isFocusMouse(); }
/** * @brief Updates the toolkit input for repeating keys. */ void toolkit_update (void) { unsigned int t; Window *wdw; Widget *wgt; char buf[2]; SDL_Event event; int ret; /* Clean up the dead if needed. */ if (!dialogue_isOpen()) { /* Hack, since dialogues use secondary loop. */ if (toolkit_delayCounter > 0) toolkit_delayCounter--; else toolkit_purgeDead(); } /* Killed all the windows. */ if (windows == NULL) { SDL_ShowCursor(SDL_DISABLE); toolkit_open = 0; /* disable toolkit */ if (paused) unpause_game(); } /* Must have a key pressed. */ if (input_key == 0) return; t = SDL_GetTicks(); /* Should be repeating. */ if (input_keyTime + INPUT_DELAY + input_keyCounter*INPUT_FREQ > t) return; /* Increment counter. */ input_keyCounter++; /* Check to see what it affects. */ if (windows != NULL) { /* Get the window. */ wdw = toolkit_getActiveWindow(); if (wdw == NULL) return; /* See if widget needs event. */ for (wgt=wdw->widgets; wgt!=NULL; wgt=wgt->next) { if (wgt_isFlag( wgt, WGT_FLAG_RAWINPUT )) { if (wgt->rawevent != NULL) { event.type = SDL_KEYDOWN; event.key.state = SDL_PRESSED; event.key.keysym.sym = input_key; event.key.keysym.mod = 0; ret = wgt->rawevent( wgt, &event ); if (ret != 0) return; } } } /* Handle the focused widget. */ wgt = toolkit_getFocus( wdw ); if ((wgt != NULL) && (wgt->keyevent != NULL)) { wgt->keyevent( wgt, input_key, 0 ); } if ((input_text != 0) && (wgt != NULL) && (wgt->textevent != NULL)) { buf[0] = input_text; buf[1] = '\0'; wgt->textevent( wgt, buf ); } } }
void Welcom::enterMain() { Widget* widget = new Widget(); this->close(); widget->show(); }
void flips(Widget& widget) { widget.flip(); }
int button_released(void* p, int v, real x, real y, char* e) { Widget *w = p; button_draw(w, 1); return w->f(); }
PassOwnPtr<WebCore::ContextMenu> ContextMenuClientImpl::customizeMenu(PassOwnPtr<WebCore::ContextMenu> defaultMenu) { // Displaying the context menu in this function is a big hack as we don't // have context, i.e. whether this is being invoked via a script or in // response to user input (Mouse event WM_RBUTTONDOWN, // Keyboard events KeyVK_APPS, Shift+F10). Check if this is being invoked // in response to the above input events before popping up the context menu. if (!m_webView->contextMenuAllowed()) return defaultMenu; HitTestResult r = m_webView->page()->contextMenuController()->hitTestResult(); Frame* selectedFrame = r.innerNodeFrame(); WebContextMenuData data; data.mousePosition = selectedFrame->view()->contentsToWindow(r.roundedPointInInnerNodeFrame()); // Compute edit flags. data.editFlags = WebContextMenuData::CanDoNone; if (m_webView->focusedWebCoreFrame()->editor()->canUndo()) data.editFlags |= WebContextMenuData::CanUndo; if (m_webView->focusedWebCoreFrame()->editor()->canRedo()) data.editFlags |= WebContextMenuData::CanRedo; if (m_webView->focusedWebCoreFrame()->editor()->canCut()) data.editFlags |= WebContextMenuData::CanCut; if (m_webView->focusedWebCoreFrame()->editor()->canCopy()) data.editFlags |= WebContextMenuData::CanCopy; if (m_webView->focusedWebCoreFrame()->editor()->canPaste()) data.editFlags |= WebContextMenuData::CanPaste; if (m_webView->focusedWebCoreFrame()->editor()->canDelete()) data.editFlags |= WebContextMenuData::CanDelete; // We can always select all... data.editFlags |= WebContextMenuData::CanSelectAll; data.editFlags |= WebContextMenuData::CanTranslate; // Links, Images, Media tags, and Image/Media-Links take preference over // all else. data.linkURL = r.absoluteLinkURL(); if (!r.absoluteImageURL().isEmpty()) { data.srcURL = r.absoluteImageURL(); data.mediaType = WebContextMenuData::MediaTypeImage; } else if (!r.absoluteMediaURL().isEmpty()) { data.srcURL = r.absoluteMediaURL(); // We know that if absoluteMediaURL() is not empty, then this // is a media element. HTMLMediaElement* mediaElement = toMediaElement(r.innerNonSharedNode()); if (mediaElement->hasTagName(HTMLNames::videoTag)) data.mediaType = WebContextMenuData::MediaTypeVideo; else if (mediaElement->hasTagName(HTMLNames::audioTag)) data.mediaType = WebContextMenuData::MediaTypeAudio; if (mediaElement->error()) data.mediaFlags |= WebContextMenuData::MediaInError; if (mediaElement->paused()) data.mediaFlags |= WebContextMenuData::MediaPaused; if (mediaElement->muted()) data.mediaFlags |= WebContextMenuData::MediaMuted; if (mediaElement->loop()) data.mediaFlags |= WebContextMenuData::MediaLoop; if (mediaElement->supportsSave()) data.mediaFlags |= WebContextMenuData::MediaCanSave; if (mediaElement->hasAudio()) data.mediaFlags |= WebContextMenuData::MediaHasAudio; if (mediaElement->hasVideo()) data.mediaFlags |= WebContextMenuData::MediaHasVideo; if (mediaElement->controls()) data.mediaFlags |= WebContextMenuData::MediaControls; } else if (r.innerNonSharedNode()->hasTagName(HTMLNames::objectTag) || r.innerNonSharedNode()->hasTagName(HTMLNames::embedTag)) { RenderObject* object = r.innerNonSharedNode()->renderer(); if (object && object->isWidget()) { Widget* widget = toRenderWidget(object)->widget(); if (widget && widget->isPluginContainer()) { data.mediaType = WebContextMenuData::MediaTypePlugin; WebPluginContainerImpl* plugin = static_cast<WebPluginContainerImpl*>(widget); WebString text = plugin->plugin()->selectionAsText(); if (!text.isEmpty()) { data.selectedText = text; data.editFlags |= WebContextMenuData::CanCopy; } data.editFlags &= ~WebContextMenuData::CanTranslate; data.linkURL = plugin->plugin()->linkAtPosition(data.mousePosition); if (plugin->plugin()->supportsPaginatedPrint()) data.mediaFlags |= WebContextMenuData::MediaCanPrint; HTMLPlugInImageElement* pluginElement = toHTMLPlugInImageElement(r.innerNonSharedNode()); data.srcURL = pluginElement->document()->completeURL(pluginElement->url()); data.mediaFlags |= WebContextMenuData::MediaCanSave; // Add context menu commands that are supported by the plugin. if (plugin->plugin()->canRotateView()) data.mediaFlags |= WebContextMenuData::MediaCanRotate; } } } data.isImageBlocked = (data.mediaType == WebContextMenuData::MediaTypeImage) && !r.image(); // If it's not a link, an image, a media element, or an image/media link, // show a selection menu or a more generic page menu. if (selectedFrame->document()->loader()) data.frameEncoding = selectedFrame->document()->encoding(); // Send the frame and page URLs in any case. data.pageURL = urlFromFrame(m_webView->mainFrameImpl()->frame()); if (selectedFrame != m_webView->mainFrameImpl()->frame()) { data.frameURL = urlFromFrame(selectedFrame); RefPtr<HistoryItem> historyItem = selectedFrame->loader()->history()->currentItem(); if (historyItem) data.frameHistoryItem = WebHistoryItem(historyItem); } if (r.isSelected()) { if (!r.innerNonSharedNode()->hasTagName(HTMLNames::inputTag) || !static_cast<HTMLInputElement*>(r.innerNonSharedNode())->isPasswordField()) data.selectedText = selectedFrame->editor()->selectedText().stripWhiteSpace(); } if (r.isContentEditable()) { data.isEditable = true; #if ENABLE(INPUT_SPEECH) if (r.innerNonSharedNode()->hasTagName(HTMLNames::inputTag)) { data.isSpeechInputEnabled = static_cast<HTMLInputElement*>(r.innerNonSharedNode())->isSpeechEnabled(); } #endif // When Chrome enables asynchronous spellchecking, its spellchecker adds spelling markers to misspelled // words and attaches suggestions to these markers in the background. Therefore, when a user right-clicks // a mouse on a word, Chrome just needs to find a spelling marker on the word instead of spellchecking it. if (selectedFrame->settings() && selectedFrame->settings()->asynchronousSpellCheckingEnabled()) { DocumentMarker marker; data.misspelledWord = selectMisspellingAsync(selectedFrame, marker); if (marker.description().length()) { Vector<String> suggestions; marker.description().split('\n', suggestions); data.dictionarySuggestions = suggestions; } else if (m_webView->spellCheckClient()) { int misspelledOffset, misspelledLength; m_webView->spellCheckClient()->spellCheck(data.misspelledWord, misspelledOffset, misspelledLength, &data.dictionarySuggestions); } } else { data.isSpellCheckingEnabled = m_webView->focusedWebCoreFrame()->editor()->isContinuousSpellCheckingEnabled(); // Spellchecking might be enabled for the field, but could be disabled on the node. if (m_webView->focusedWebCoreFrame()->editor()->isSpellCheckingEnabledInFocusedNode()) { data.misspelledWord = selectMisspelledWord(defaultMenu.get(), selectedFrame); if (m_webView->spellCheckClient()) { int misspelledOffset, misspelledLength; m_webView->spellCheckClient()->spellCheck( data.misspelledWord, misspelledOffset, misspelledLength, &data.dictionarySuggestions); if (!misspelledLength) data.misspelledWord.reset(); } } } HTMLFormElement* form = selectedFrame->selection()->currentForm(); if (form && r.innerNonSharedNode()->hasTagName(HTMLNames::inputTag)) { HTMLInputElement* selectedElement = static_cast<HTMLInputElement*>(r.innerNonSharedNode()); if (selectedElement) { WebSearchableFormData ws = WebSearchableFormData(WebFormElement(form), WebInputElement(selectedElement)); if (ws.url().isValid()) data.keywordURL = ws.url(); } } } #if OS(DARWIN) if (selectedFrame->editor()->selectionHasStyle(CSSPropertyDirection, "ltr") != FalseTriState) data.writingDirectionLeftToRight |= WebContextMenuData::CheckableMenuItemChecked; if (selectedFrame->editor()->selectionHasStyle(CSSPropertyDirection, "rtl") != FalseTriState) data.writingDirectionRightToLeft |= WebContextMenuData::CheckableMenuItemChecked; #endif // OS(DARWIN) // Now retrieve the security info. DocumentLoader* dl = selectedFrame->loader()->documentLoader(); WebDataSource* ds = WebDataSourceImpl::fromDocumentLoader(dl); if (ds) data.securityInfo = ds->response().securityInfo(); data.referrerPolicy = static_cast<WebReferrerPolicy>(selectedFrame->document()->referrerPolicy()); // Filter out custom menu elements and add them into the data. populateCustomMenuItems(defaultMenu.get(), &data); data.node = r.innerNonSharedNode(); WebFrame* selected_web_frame = WebFrameImpl::fromFrame(selectedFrame); if (m_webView->client()) m_webView->client()->showContextMenu(selected_web_frame, data); return defaultMenu; }
int main(int argc, char *argv[]) { QApplication app(argc, argv); QGraphicsScene *scene = new QGraphicsScene(); Widget *a = new Widget(Qt::blue, Qt::white, "a"); a->setPreferredSize(100, 100); Widget *b = new Widget(Qt::green, Qt::black, "b"); b->setPreferredSize(100, 100); Widget *c = new Widget(Qt::red, Qt::black, "c"); c->setPreferredSize(100, 100); QGraphicsAnchorLayout *layout = new QGraphicsAnchorLayout(); /* //! [adding a corner anchor in two steps] layout->addAnchor(a, Qt::AnchorTop, layout, Qt::AnchorTop); layout->addAnchor(a, Qt::AnchorLeft, layout, Qt::AnchorLeft); //! [adding a corner anchor in two steps] */ //! [adding a corner anchor] layout->addCornerAnchors(a, Qt::TopLeftCorner, layout, Qt::TopLeftCorner); //! [adding a corner anchor] //! [adding anchors] layout->addAnchor(b, Qt::AnchorLeft, a, Qt::AnchorRight); layout->addAnchor(b, Qt::AnchorTop, a, Qt::AnchorBottom); //! [adding anchors] // Place a third widget below the second. layout->addAnchor(b, Qt::AnchorBottom, c, Qt::AnchorTop); /* //! [adding anchors to match sizes in two steps] layout->addAnchor(b, Qt::AnchorLeft, c, Qt::AnchorLeft); layout->addAnchor(b, Qt::AnchorRight, c, Qt::AnchorRight); //! [adding anchors to match sizes in two steps] */ //! [adding anchors to match sizes] layout->addAnchors(b, c, Qt::Horizontal); //! [adding anchors to match sizes] // Anchor the bottom-right corner of the third widget to the bottom-right // corner of the layout. layout->addCornerAnchors(c, Qt::BottomRightCorner, layout, Qt::BottomRightCorner); QGraphicsWidget *w = new QGraphicsWidget(0, Qt::Window | Qt::CustomizeWindowHint | Qt::WindowTitleHint); w->setPos(20, 20); w->setMinimumSize(100, 100); w->setPreferredSize(320, 240); w->setLayout(layout); w->setWindowTitle(QApplication::translate("simpleanchorlayout", "QGraphicsAnchorLayout in use")); scene->addItem(w); QGraphicsView *view = new QGraphicsView(); view->setScene(scene); view->setWindowTitle(QApplication::translate("simpleanchorlayout", "Simple Anchor Layout")); view->resize(360, 320); view->show(); return app.exec(); }