winrt::ICommandBarElement TextCommandBarFlyout::GetButton()

in dev/CommandBarFlyout/TextCommandBarFlyout.cpp [931:1132]

• 183 lines of code
• 17 McCabe index (conditional complexity)

winrt::ICommandBarElement TextCommandBarFlyout::GetButton(TextControlButtons textControlButton)
{
    const auto foundButton = m_buttons.find(textControlButton);

    if (foundButton != m_buttons.end())
    {
        return foundButton->second;
    }
    else
    {
        switch (textControlButton)
        {
        case TextControlButtons::Cut:
            {
                winrt::AppBarButton button;
                const auto executeFunc = [this]() { ExecuteCutCommand(); };

                if (SharedHelpers::IsStandardUICommandAvailable())
                {
                    InitializeButtonWithUICommand(button, winrt::StandardUICommand(winrt::StandardUICommandKind::Cut), executeFunc);
                }
                else
                {
                    InitializeButtonWithProperties(
                        button,
                        SR_TextCommandLabelCut,
                        winrt::Symbol::Cut,
                        SR_TextCommandKeyboardAcceleratorKeyCut,
                        SR_TextCommandDescriptionCut,
                        executeFunc);
                }

                m_buttons[TextControlButtons::Cut] = button;
                return button;
            }
        case TextControlButtons::Copy:
            {
                winrt::AppBarButton button;
                const auto executeFunc = [this]() { ExecuteCopyCommand(); };

                if (SharedHelpers::IsStandardUICommandAvailable())
                {
                    InitializeButtonWithUICommand(button, winrt::StandardUICommand(winrt::StandardUICommandKind::Copy), executeFunc);
                }
                else
                {
                    InitializeButtonWithProperties(
                        button,
                        SR_TextCommandLabelCopy,
                        winrt::Symbol::Copy,
                        SR_TextCommandKeyboardAcceleratorKeyCopy,
                        SR_TextCommandDescriptionCopy,
                        executeFunc);
                }

                m_buttons[TextControlButtons::Copy] = button;
                return button;
            }
        case TextControlButtons::Paste:
            {
                winrt::AppBarButton button;
                const auto executeFunc = [this]() { ExecutePasteCommand(); };

                if (SharedHelpers::IsStandardUICommandAvailable())
                {
                    InitializeButtonWithUICommand(button, winrt::StandardUICommand(winrt::StandardUICommandKind::Paste), executeFunc);
                }
                else
                {
                    InitializeButtonWithProperties(
                        button,
                        SR_TextCommandLabelPaste,
                        winrt::Symbol::Paste,
                        SR_TextCommandKeyboardAcceleratorKeyPaste,
                        SR_TextCommandDescriptionPaste,
                        executeFunc);
                }

                m_buttons[TextControlButtons::Paste] = button;
                return button;
            }
        // Bold, Italic, and Underline don't have command library commands associated with them,
        // so we'll just unconditionally initialize them with properties.
        case TextControlButtons::Bold:
            {
                winrt::AppBarToggleButton button;
                InitializeButtonWithProperties(
                    button,
                    SR_TextCommandLabelBold,
                    winrt::Symbol::Bold,
                    SR_TextCommandKeyboardAcceleratorKeyBold,
                    SR_TextCommandDescriptionBold,
                    [this]() { ExecuteBoldCommand(); });

                m_buttons[TextControlButtons::Bold] = button;
                return button;
            }
        case TextControlButtons::Italic:
            {
                winrt::AppBarToggleButton button;
                InitializeButtonWithProperties(
                    button,
                    SR_TextCommandLabelItalic,
                    winrt::Symbol::Italic,
                    SR_TextCommandKeyboardAcceleratorKeyItalic,
                    SR_TextCommandDescriptionItalic,
                    [this]() { ExecuteItalicCommand(); });

                m_buttons[TextControlButtons::Italic] = button;
                return button;
            }
        case TextControlButtons::Underline:
            {
                winrt::AppBarToggleButton button;
                InitializeButtonWithProperties(
                    button,
                    SR_TextCommandLabelUnderline,
                    winrt::Symbol::Underline,
                    SR_TextCommandKeyboardAcceleratorKeyUnderline,
                    SR_TextCommandDescriptionUnderline,
                    [this]() { ExecuteUnderlineCommand(); });

                m_buttons[TextControlButtons::Underline] = button;
                return button;
            }
        case TextControlButtons::Undo:
            {
                winrt::AppBarButton button;
                const auto executeFunc = [this]() { ExecuteUndoCommand(); };

                if (SharedHelpers::IsStandardUICommandAvailable())
                {
                    InitializeButtonWithUICommand(button, winrt::StandardUICommand(winrt::StandardUICommandKind::Undo), executeFunc);
                }
                else
                {
                    InitializeButtonWithProperties(
                        button,
                        SR_TextCommandLabelUndo,
                        winrt::Symbol::Undo,
                        SR_TextCommandKeyboardAcceleratorKeyUndo,
                        SR_TextCommandDescriptionUndo,
                        executeFunc);
                }

                m_buttons[TextControlButtons::Undo] = button;
                return button;
            }
        case TextControlButtons::Redo:
            {
                winrt::AppBarButton button;
                const auto executeFunc = [this]() { ExecuteRedoCommand(); };

                if (SharedHelpers::IsStandardUICommandAvailable())
                {
                    InitializeButtonWithUICommand(button, winrt::StandardUICommand(winrt::StandardUICommandKind::Redo), executeFunc);
                }
                else
                {
                    InitializeButtonWithProperties(
                        button,
                        SR_TextCommandLabelRedo,
                        winrt::Symbol::Redo,
                        SR_TextCommandKeyboardAcceleratorKeyRedo,
                        SR_TextCommandDescriptionRedo,
                        executeFunc);
                }

                m_buttons[TextControlButtons::Redo] = button;
                return button;
            }
        case TextControlButtons::SelectAll:
            {
                winrt::AppBarButton button;
                const auto executeFunc = [this]() { ExecuteSelectAllCommand(); };

                if (SharedHelpers::IsStandardUICommandAvailable())
                {
                    auto command = winrt::StandardUICommand(winrt::StandardUICommandKind::SelectAll);
                    command.IconSource(nullptr);

                    InitializeButtonWithUICommand(button, command, executeFunc);
                }
                else
                {
                    InitializeButtonWithProperties(
                        button,
                        SR_TextCommandLabelSelectAll,
                        SR_TextCommandKeyboardAcceleratorKeySelectAll,
                        SR_TextCommandDescriptionSelectAll,
                        executeFunc);
                }

                m_buttons[TextControlButtons::SelectAll] = button;
                return button;
            }
        default:
            MUX_ASSERT(false);
            return nullptr;
        }
    }
}