changelog.title->setSizeToContent();

         yCounter += changelog.title->getSize().y;

         /// yCounter += 10 * dpiScale;

         for(CBaseUIButton *change : changelog.changes) {

             change->setSizeToContent();

             change->setSizeY(change->getSize().y * 2.0f);

             yCounter += change->getSize().y /* + 13 * dpiScale*/;

         }

         // gap to previous version

     std::sort(m_channels.begin(), m_channels.end(), [](ChatChannel *a, ChatChannel *b) { return a->name < b->name; });

     // the screen resolution once. So I'll just compute absolute position manually.

     float button_container_height = button_height + 2;

     for(auto chan : m_channels) {

     const float size = Osu::getUIScale(324.0f);

     m_vSize = Vector2(size, size);

     m_cube->setSize(m_vSize);

     m_pauseButton->setSize(30 * dpiScale, 30 * dpiScale);

                              m_pauseButton->getSize().y + 10 * dpiScale);

     if(m_updateAvailableButton != NULL) {

     m_versionButton->onResized();  // HACKHACK: framework, setSizeToContent() does not update string metrics

     m_versionButton->setSizeToContent(8 * dpiScale, 8 * dpiScale);

     int numButtons = m_menuElements.size();

     int menuElementHeight = m_vSize.y / numButtons;

         curY += (i > 0 ? menuElementHeight + menuElementPadding : 0.0f);

         m_menuElements[i]->onResized();  // HACKHACK: framework, setSize() does not update string metrics

                                          menuElementExtraWidth * offsetPercent +

                                          menuElementExtraWidth * (1.0f - offsetPercent),

                                      curY);

     int experimentalOffsetY = 6 * dpiScale;

     for(int i = 0; i < m_experimentalMods.size(); i++) {

         CBaseUIElement *e = m_experimentalMods[i].element;

         e->setSizeY(e->getRelSize().y * dpiScale);

         // custom

     for(int i = 0; i < m_experimentalMods.size(); i++) {

         CBaseUIElement *e = m_experimentalMods[i].element;

         if(e->getSize().x > experimentalMaxWidth) experimentalMaxWidth = e->getSize().x;

     const int categoriesWidth = optionsWidth * categoriesOptionsPercent;

                           categoriesWidth);

     m_options->setSize(optionsWidth, osu->getScreenHeight() + 1);

     m_search->setSize(m_options->getSize());

     m_categories->setSize(categoriesWidth, osu->getScreenHeight() + 1);

     // reset

         if(m_elements[i].resetButton != NULL) {

             CBaseUIButton *resetButton = m_elements[i].resetButton;

             resetButton->setSize(Vector2(35, 50) * dpiScale);

         }

         for(int j = 0; j < m_elements[i].elements.size(); j++) {

             } else

                 e->setSizeX(elementWidth);

             yCounter += e->getSize().y;

         } else if(m_elements[i].elements.size() == 2 || isKeyBindButton) {

                 const float dividerMiddle = 5.0f / 8.0f;

                 const float dividerEnd = 2.0f / 8.0f;

                 e1->setSizeX(e1->getSize().y);

                 e2->setSizeX(elementWidth * dividerMiddle - spacing);

                 e3->setSizeX(elementWidth * dividerEnd - spacing);

             } else {

                 float dividerEnd = 1.0f / 2.0f;

                 float dividerBegin = 1.0f - dividerEnd;

                 e1->setSizeX(elementWidth * dividerBegin - spacing);

                 e2->setSizeX(elementWidth * dividerEnd - spacing);

             }

                 e2->setSizeX(buttonSize);

                 e3->setSizeX(buttonSize);

             } else {

                 const int labelSliderLabelOffset = 15 * dpiScale;

                     sliderSize = 100;

                 }

                 e2->setSizeX(sliderSize - 2 * elementTextStartOffset - labelSliderLabelOffset * 2);

             }

             yCounter += e2->getSize().y;

     for(int i = 0; i < m_categoryButtons.size(); i++) {

         OptionsMenuCategoryButton *category = m_categoryButtons[i];

         category->onResized();  // HACKHACK: framework, setSize*() does not update string metrics

         category->setSize(m_categories->getSize().x - 1, categoryHeight);

     }

     m_categories->getContainer()->update_pos();

         if(m_bVisible) {

             m_contextMenu->setPos(m_skinSelectLocalButton->getPos());

         } else {

             // Put it 50px from top, we'll move it later

             m_contextMenu->setPos(Vector2{0, 100});

     // build context menu

     m_contextMenu->setPos(m_resolutionSelectButton->getPos());

     m_contextMenu->begin();

     for(int i = 0; i < resolutions.size(); i++) {

         if(resolutions[i].x > nativeResolution.x || resolutions[i].y > nativeResolution.y) continue;

     // build context menu

     m_contextMenu->setPos(m_outputDeviceSelectButton->getPos());

     m_contextMenu->begin();

     for(auto device : outputDevices) {

         CBaseUIButton *button = m_contextMenu->addButton(device.name);

 void OptionsMenu::onNotelockSelect() {

     // build context menu

     m_contextMenu->setPos(m_notelockSelectButton->getPos());

     m_contextMenu->begin(m_notelockSelectButton->getSize().x);

     {

         for(int i = 0; i < m_notelockTypes.size(); i++) {

 void OptionsMenu::onHPDrainSelect() {

     // build context menu

     m_contextMenu->setPos(m_hpDrainSelectButton->getPos());

     m_contextMenu->begin(m_hpDrainSelectButton->getSize().x);

     {

         for(int i = 1; i < m_drainTypes.size(); i++) {

                              Osu::getImageScale(m_rankingTitle->getImage(), 75.0f) * uiScale);

     m_rankingTitle->setSize(m_rankingTitle->getImage()->getWidth() * m_rankingTitle->getScale().x,

                             m_rankingTitle->getImage()->getHeight() * m_rankingTitle->getScale().y);

     m_songInfo->setSize(osu->getScreenWidth(),

                         max(m_songInfo->getMinimumHeight(),

                         osu->getScreenSize().y - (50 * uiScale * 2.f + 20.f * uiScale));

     m_rankings->setSize(osu->getScreenSize().x + 2, osu->getScreenSize().y - m_songInfo->getSize().y + 3);

     update_pos();

     // NOTE: no uiScale for rankingPanel and rankingGrade, doesn't really work due to legacy layout expectations

     m_rankingIndex->setSize(m_rankings->getSize().x + 2, osu->getScreenHeight() * 0.07f * uiScale);

     m_rankingIndex->setBackgroundColor(0xff745e13);

     m_rankingBottom->setSize(m_rankings->getSize().x + 2, osu->getScreenHeight() * 0.2f);

     setGrade(m_grade);

     m_rankingGrade->setScale(rankingGradeImageScale, rankingGradeImageScale);

     m_rankingGrade->setSize(m_rankingGrade->getImage()->getWidth() * m_rankingGrade->getScale().x,

                             m_rankingGrade->getImage()->getHeight() * m_rankingGrade->getScale().y);

                                   m_rankingGrade->getImage()->getWidth() * m_rankingGrade->getScale().x / 2.0f,

                               -m_rankings->getRelPos().y +

                                   osu->getUIScale(osu->getSkin()->getVersion() > 1.0f ? 200 : 170) -

         m_view->getSize().x -

             getActualSize().x * 0.15f);  // WARNING: hardcoded to match 0.85f above for buttonWidthCompensation

 }

 Button *Button::setVisible(bool visible) {

 void Button::setTargetRelPosY(float targetRelPosY) {

     m_fTargetRelPosY = targetRelPosY;

 }

 Vector2 Button::getActualOffset() const {

     if(m_contextMenu != NULL) {

         m_contextMenu->setPos(pos);

         m_contextMenu->begin(0, true);

         {

             m_contextMenu->addButton("[...]      Rename Collection", 1);

     if(m_contextMenu != NULL) {

         m_contextMenu->setPos(pos);

         m_contextMenu->begin(0, true);

         {

             m_contextMenu->addButton("Use Mods", 1);  // for scores without mods this will just nomod

                           max(osu->getSkin()->getSongSelectTop()->getHeight() * m_fSongSelectTopScale *

                                   osu_songbrowser_topbar_left_percent.getFloat(),

                               m_songInfo->getMinimumHeight() + margin));

     m_songInfo->setSize(m_topbarLeft->getSize().x - margin,

                         max(m_topbarLeft->getSize().y * 0.75f, m_songInfo->getMinimumHeight() + margin));

     for(int i = 0; i < m_topbarLeftButtons.size(); i++) {

         m_topbarLeftButtons[i]->onResized();  // HACKHACK: framework bug (should update string metrics on setSize())

         m_topbarLeftButtons[i]->setSize(topbarLeftButtonWidth, topbarLeftButtonHeight);

             m_topbarLeft->getSize().x - (i + 1) * (topbarLeftButtonMargin + topbarLeftButtonWidth),

             m_topbarLeft->getSize().y - m_topbarLeftButtons[i]->getSize().y);

     }

     for(int i = 0; i < m_topbarLeftTabButtons.size(); i++) {

         m_topbarLeftTabButtons[i]->onResized();  // HACKHACK: framework bug (should update string metrics on setSize())

         m_topbarLeftTabButtons[i]->setSize(topbarLeftTabButtonWidth, topbarLeftTabButtonHeight);

                                              m_topbarLeft->getSize().y - m_topbarLeftTabButtons[i]->getSize().y);

     }

     for(int i = 0; i < m_topbarRightTabButtons.size(); i++) {

         m_topbarRightTabButtons[i]->onResized();  // HACKHACK: framework bug (should update string metrics on setSize())

         m_topbarRightTabButtons[i]->setSize(topbarRightTabButtonWidth, topbarRightTabButtonHeight);

             m_topbarRight->getSize().x -

                 (topbarRightTabButtonMargin + (m_topbarRightTabButtons.size() - i) * topbarRightTabButtonWidth),

             m_topbarRight->getSize().y - m_topbarRightTabButtons[i]->getSize().y);

     if(m_topbarRightTabButtons.size() > 0) {

         m_groupLabel->onResized();  // HACKHACK: framework bug (should update string metrics on setSizeToContent())

         m_groupLabel->setSizeToContent(3 * dpiScale);

                                 Vector2(-m_groupLabel->getSize().x, m_topbarRightTabButtons[0]->getSize().y / 2.0f -

                                                                         m_groupLabel->getSize().y / 2.0f));

     }

         0.0f, 200.0f * dpiScale);

     for(int i = 0; i < m_topbarRightSortButtons.size(); i++) {

         m_topbarRightSortButtons[i]->setSize(topbarRightSortButtonWidth, topbarRightSortButtonHeight);

             m_topbarRight->getSize().x -

                 (topbarRightSortButtonMargin + (m_topbarRightTabButtons.size() - i) * topbarRightSortButtonWidth),

             topbarRightSortButtonMargin);

     }

     for(int i = 0; i < m_topbarRightGroupButtons.size(); i++) {

         m_topbarRightGroupButtons[i]->setSize(topbarRightSortButtonWidth, topbarRightSortButtonHeight);

             m_topbarRight->getSize().x -

                 (topbarRightSortButtonMargin + (m_topbarRightTabButtons.size() - i) * topbarRightSortButtonWidth),

             topbarRightSortButtonMargin);

     if(m_topbarRightGroupButtons.size() > 0) {

         m_groupLabel->onResized();  // HACKHACK: framework bug (should update string metrics on setSizeToContent())

         m_groupLabel->setSizeToContent(3 * dpiScale);

             m_topbarRightGroupButtons[m_topbarRightGroupButtons.size() - 1]->getRelPos() +

             Vector2(-m_groupLabel->getSize().x,

                     m_topbarRightGroupButtons[m_topbarRightGroupButtons.size() - 1]->getSize().y / 2.0f -

     if(m_topbarRightSortButtons.size() > 0) {

         m_sortLabel->onResized();  // HACKHACK: framework bug (should update string metrics on setSizeToContent())

         m_sortLabel->setSizeToContent(3 * dpiScale);

             m_topbarRightSortButtons[m_topbarRightSortButtons.size() - 1]->getRelPos() +

             Vector2(-m_sortLabel->getSize().x,

                     m_topbarRightSortButtons[m_topbarRightSortButtons.size() - 1]->getSize().y / 2.0f -

         // new, hardcoded offsets instead of dynamically using the button skin image widths (except starting at 3rd

         // button)

             navBarXCounter + gap + (i > 0 ? Osu::getUIScale(57.6f) : 0) +

             (i > 1 ? max((i - 1) * Osu::getUIScale(48.0f), m_bottombarNavButtons[i - 1]->getSize().x) : 0));

         // old, overflows with some skins (e.g. kyu)

         // m_bottombarNavButtons[i-1]->getRelPos().x + m_bottombarNavButtons[i-1]->getSize().x : 0));

     }

     const int userButtonHeight = m_bottombar->getSize().y * 0.9f;

     m_userButton->setSize(userButtonHeight * 3.5f, userButtonHeight);

                                 m_bottombarNavButtons[m_bottombarNavButtons.size() - 1]->getRelPos().x +

                                     m_bottombarNavButtons[m_bottombarNavButtons.size() - 1]->getSize().x + 10),

                             m_bottombar->getSize().y - m_userButton->getSize().y - 1);

         m_localBestContainer->setPos(m_scoreBrowser->getPos().x,

                                      m_scoreBrowser->getPos().y + m_scoreBrowser->getSize().y);

         m_localBestContainer->setSize(m_scoreBrowser->getPos().x, local_best_size);

         m_localBestLabel->setSize(m_scoreBrowser->getSize().x, 40);

         if(m_localBestButton) {

             m_localBestButton->setSize(m_scoreBrowser->getSize().x, scoreHeight);

         }

     }

     for(size_t i = 0; i < elements.size(); i++) {

         CBaseUIElement *scoreButton = elements[i];

         scoreButton->setSize(m_scoreBrowser->getSize().x, scoreHeight);

     }

     m_scoreBrowserScoresStillLoadingElement->setSize(m_scoreBrowser->getSize().x * 0.9f, scoreHeight * 0.75f);

         m_scoreBrowser->getSize().x / 2 - m_scoreBrowserScoresStillLoadingElement->getSize().x / 2,

         (browserHeight / 2) * 0.65f - m_scoreBrowserScoresStillLoadingElement->getSize().y / 2);

     m_scoreBrowserNoRecordsYetElement->setSize(m_scoreBrowser->getSize().x * 0.9f, scoreHeight * 0.75f);

     if(elements[0] == m_scoreBrowserNoRecordsYetElement) {

             m_scoreBrowser->getSize().x / 2 - m_scoreBrowserScoresStillLoadingElement->getSize().x / 2,

             (browserHeight / 2) * 0.65f - m_scoreBrowserScoresStillLoadingElement->getSize().y / 2);

     } else {

             m_scoreBrowser->getSize().x / 2 - m_scoreBrowserScoresStillLoadingElement->getSize().x / 2, 45);

     }

     m_localBestContainer->update_pos();

 void SongBrowser::onSortScoresClicked(CBaseUIButton *button) {

     m_contextMenu->setPos(button->getPos());

     m_contextMenu->begin(button->getSize().x);

     {

         CBaseUIButton *button = m_contextMenu->addButton("Online Leaderboard");

 void SongBrowser::onGroupClicked(CBaseUIButton *button) {

     m_contextMenu->setPos(button->getPos());

     m_contextMenu->begin(button->getSize().x);

     {

         for(size_t i = 0; i < m_groupings.size(); i++) {

 void SongBrowser::onSortClicked(CBaseUIButton *button) {

     m_contextMenu->setPos(button->getPos());

     m_contextMenu->begin(button->getSize().x);

     {

         for(size_t i = 0; i < m_sortingMethods.size(); i++) {

     // manual hack for small resolutions

     if(m_contextMenu->getRelPos().x + m_contextMenu->getSize().x > m_topbarRight->getSize().x) {

         int newRelPosX = m_topbarRight->getSize().x - m_contextMenu->getSize().x - 1;

         m_contextMenu->setPosX(m_topbarRight->getPos().x + m_topbarRight->getSize().x - m_contextMenu->getSize().x - 1);

     }

 }

 void SongBrowser::onSelectionMode() {

     m_contextMenu->setPos(m_bottombarNavButtons[0]->getPos());

     m_contextMenu->begin(0, true);

     {

         UIContextMenuButton *standardButton = m_contextMenu->addButton("Standard", 0);

     m_contextMenu->setPos(m_contextMenu->getPos() -

                           Vector2((m_contextMenu->getSize().x - m_bottombarNavButtons[0]->getSize().x) / 2.0f,

                                   m_contextMenu->getSize().y));

                              Vector2((m_contextMenu->getSize().x - m_bottombarNavButtons[0]->getSize().x) / 2.0f,

                                      m_contextMenu->getSize().y));

     m_contextMenu->end(true, false);

 void SongButton::triggerContextMenu(Vector2 pos) {

     if(m_contextMenu != NULL) {

         m_contextMenu->setPos(pos);

         m_contextMenu->begin(0, true);

         {

             if(m_databaseBeatmap != NULL && m_databaseBeatmap->getDifficulties().size() < 1)

             if(m_vPos.y < 0) {

                 const float underflow = std::abs(m_vPos.y);

                 setPosY(m_vPos.y + underflow);

                 setSizeY(m_vSize.y - underflow);

 void UIContextMenu::onResized() { setSize(m_vSize); }

 void UIContextMenu::onMoved() {

     setPos(m_vPos);

 }

 void UIContextMenu::clampToBottomScreenEdge(UIContextMenu *menu) {

     if(menu->getRelPos().y + menu->getSize().y > osu->getScreenHeight()) {

         int newRelPosY = osu->getScreenHeight() - menu->getSize().y - 1;

         menu->setPosY(newRelPosY);

     }

 }

 void UIContextMenu::clampToRightScreenEdge(UIContextMenu *menu) {

     if(menu->getRelPos().x + menu->getSize().x > osu->getScreenWidth()) {

         const int newRelPosX = osu->getScreenWidth() - menu->getSize().x - 1;

         menu->setPosX(newRelPosX);

     }

 }

 CBaseUIContainer *CBaseUIContainer::addBaseUIElement(CBaseUIElement *element, float xPos, float yPos) {

     if(element == NULL) return this;

     element->setPos(m_vPos + element->getRelPos());

     m_vElements.push_back(element);

 CBaseUIContainer *CBaseUIContainer::addBaseUIElement(CBaseUIElement *element) {

     if(element == NULL) return this;

     element->setPos(m_vPos + element->getRelPos());

     m_vElements.push_back(element);

 CBaseUIContainer *CBaseUIContainer::addBaseUIElementBack(CBaseUIElement *element, float xPos, float yPos) {

     if(element == NULL) return this;

     element->setPos(m_vPos + element->getRelPos());

     m_vElements.insert(m_vElements.begin(), element);

 CBaseUIContainer *CBaseUIContainer::addBaseUIElementBack(CBaseUIElement *element) {

     if(element == NULL) return this;

     element->setPos(m_vPos + element->getRelPos());

     m_vElements.insert(m_vElements.begin(), element);

 CBaseUIContainer *CBaseUIContainer::insertBaseUIElement(CBaseUIElement *element, CBaseUIElement *index) {

     if(element == NULL || index == NULL) return this;

     element->setPos(m_vPos + element->getRelPos());

     for(size_t i = 0; i < m_vElements.size(); i++) {

         if(m_vElements[i] == index) {

 CBaseUIContainer *CBaseUIContainer::insertBaseUIElementBack(CBaseUIElement *element, CBaseUIElement *index) {

     if(element == NULL || index == NULL) return this;

     element->setPos(m_vPos + element->getRelPos());

     for(size_t i = 0; i < m_vElements.size(); i++) {

         if(m_vElements[i] == index) {

         return this;                                             \

     }                                                            \

                                                                  \

         if(m_vmPos.x != xPos || m_vmPos.y != yPos) {             \

             m_vmPos.x = xPos - m_vSize.x * m_vAnchor.x;          \

             m_vmPos.y = yPos - m_vSize.y * m_vAnchor.y;          \

         }                                                        \

         return this;                                             \

     }                                                            \

         if(m_vmPos.x != xPos) {                                  \

             m_vmPos.x = xPos - m_vSize.x * m_vAnchor.x;          \

             updateLayout();                                      \

         }                                                        \

         return this;                                             \

     }                                                            \

         if(m_vmPos.y != yPos) {                                  \

             m_vmPos.y = yPos - m_vSize.x * m_vAnchor.y;          \

             updateLayout();                                      \

         }                                                        \

         return this;                                             \

     }                                                            \

         if(m_vmPos != position) {                                \

             m_vmPos = position - m_vSize * m_vAnchor;            \

             updateLayout();                                      \

         return this;                                             \

     }                                                            \

                                                                  \

         if(m_vmPos.x != xPos || m_vmPos.y != yPos) {             \

             m_vmPos.x = xPos;                                    \

             m_vmPos.y = yPos;                                    \

         }                                                        \

         return this;                                             \

     }                                                            \

         if(m_vmPos.x != xPos) {                                  \

             m_vmPos.x = xPos;                                    \

             updateLayout();                                      \

         }                                                        \

         return this;                                             \

     }                                                            \

         if(m_vmPos.y != yPos) {                                  \

             m_vmPos.y = yPos;                                    \

             updateLayout();                                      \

         }                                                        \

         return this;                                             \

     }                                                            \

         if(m_vmPos != position) {                                \

             m_vmPos = position;                                  \

             updateLayout();                                      \

 }

 void CBaseUIWindow::updateTitleBarMetrics() {

         m_vSize.x - m_closeButton->getSize().x - (m_iTitleBarHeight - m_closeButton->getSize().x) / 2.0f,

         m_iTitleBarHeight / 2.0f - m_closeButton->getSize().y / 2.0f);

         m_vSize.x - m_minimizeButton->getSize().x * 2 - (m_iTitleBarHeight - m_minimizeButton->getSize().x) / 2.0f - 6,

         m_iTitleBarHeight / 2.0f - m_minimizeButton->getSize().y / 2.0f);

     /// m_newLog->setSize(m_vSize.x - 2*CONSOLE_BORDER, m_vSize.y - getTitleBarHeight() - 2*CONSOLE_BORDER -

     /// m_textbox->getSize().y - 1);

     m_textbox->setSize(m_vSize.x - 2 * CONSOLE_BORDER, m_textbox->getSize().y);

     m_log->scrollToY(m_log->getScrollPosY());

     // m_newLog->scrollY(m_newLog->getScrollPosY());

 }

 void VSControlBar::onResized() {

     m_volume->setSizeX(m_prev->getRelPos().x);

     m_info->setSizeX(m_repeat->getRelPos().x - (m_next->getRelPos().x + m_next->getSize().x) + 1);  // +1 fudge

     m_titleBar->setSizeX(m_vSize.x + 2);

     m_controlBar->setSizeX(m_vSize.x);

     m_musicBrowser->setSize(m_vSize.x,

                             m_vSize.y - m_controlBar->getSize().y - m_titleBar->getSize().y - getTitleBarHeight());