calculator/src/CalcViewModel/Common/NavCategory.h

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

/* The NavCategory group of classes and enumerations is intended to serve
 * as a single location for storing metadata about a navigation mode.
 *
 * These .h and .cpp files:
 *     - Define the ViewMode enumeration which is used for setting the mode of the app.
 *     - Define a list of metadata associated with each ViewMode.
 *     - Define the order of groups and items in the navigation menu.
 *     - Provide a static helper function for creating the navigation menu options.
 *     - Provide static helper functions for querying information about a given ViewMode.
 */

#pragma once

#include "Utils.h"
#include "MyVirtualKey.h"

namespace CalculatorApp
{
    namespace Common
    {
        // Don't change the order of these enums
        // and definitely don't use int arithmetic
        // to change modes.
        public enum class ViewMode
        {
            None = -1,
            Standard = 0,
            Scientific = 1,
            Programmer = 2,
            Date = 3,
            Volume = 4,
            Length = 5,
            Weight = 6,
            Temperature = 7,
            Energy = 8,
            Area = 9,
            Speed = 10,
            Time = 11,
            Power = 12,
            Data = 13,
            Pressure = 14,
            Angle = 15,
            Currency = 16
        };

        public enum class CategoryGroupType
        {
            None = -1,
            Calculator = 0,
            Converter = 1
        };

        private struct NavCategoryInitializer
        {
            constexpr NavCategoryInitializer(
                ViewMode mode,
                int id,
                wchar_t const * name,
                wchar_t const * nameKey,
                wchar_t const * glyph,
                CategoryGroupType group,
                MyVirtualKey vKey,
                bool categorySupportsNegative)
                :
                viewMode(mode),
                serializationId(id),
                friendlyName(name),
                nameResourceKey(nameKey),
                glyph(glyph),
                groupType(group),
                virtualKey(vKey),
                supportsNegative(categorySupportsNegative)
            {}

            const ViewMode viewMode;
            const int serializationId;
            const wchar_t * const friendlyName;
            const wchar_t * const nameResourceKey;
            const wchar_t * const glyph;
            const CategoryGroupType groupType;
            const MyVirtualKey virtualKey;
            const bool supportsNegative;
        };

        private struct NavCategoryGroupInitializer
        {
            constexpr NavCategoryGroupInitializer(CategoryGroupType t, wchar_t const * h, wchar_t const * n, wchar_t const * a) :
                type(t), headerResourceKey(h), modeResourceKey(n), automationResourceKey(a)
            {}

            const CategoryGroupType type;
            const wchar_t *headerResourceKey;
            const wchar_t *modeResourceKey;
            const wchar_t *automationResourceKey;
        };

        [Windows::UI::Xaml::Data::Bindable]
        public ref class NavCategory sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
        {
        public:
            OBSERVABLE_OBJECT();

            property Platform::String^ Name
            {
                Platform::String^ get() { return m_name; }
            }

            property Platform::String^ AutomationName
            {
                Platform::String^ get() { return m_automationName; }
            }

            property Platform::String^ Glyph
            {
                Platform::String^ get() { return m_glyph; }
            }

            property int Position
            {
                int get() { return m_position; }
            }

            property ViewMode Mode
            {
                ViewMode get()
                {
                    return m_viewMode;
                }
            }

            property Platform::String^ AutomationId
            {
                Platform::String^ get()
                {
                    return m_viewMode.ToString();
                }
            }

            property Platform::String^ AccessKey
            {
                Platform::String^ get() 
                {
                    return m_accessKey;
                }
            }


            property bool SupportsNegative
            {
                bool get()
                {
                    return m_supportsNegative;
                }
            }

            // For saving/restoring last mode used.
            static int Serialize(ViewMode mode);
            static ViewMode Deserialize(Platform::Object^ obj);
            static ViewMode GetViewModeForFriendlyName(Platform::String^ name);

            static bool IsValidViewMode(ViewMode mode);
            static bool IsCalculatorViewMode(ViewMode mode);
            static bool IsDateCalculatorViewMode(ViewMode mode);
            static bool IsConverterViewMode(ViewMode mode);

            static Platform::String^ GetFriendlyName(ViewMode mode);
            static Platform::String^ GetNameResourceKey(ViewMode mode);
            static CategoryGroupType GetGroupType(ViewMode mode);

            // GetIndex is 0-based, GetPosition is 1-based
            static int GetIndex(ViewMode mode);
            static int GetFlatIndex(ViewMode mode);
            static int GetIndexInGroup(ViewMode mode, CategoryGroupType type);
            static int GetPosition(ViewMode mode);

            static ViewMode GetViewModeForVirtualKey(MyVirtualKey virtualKey);

        internal:
            NavCategory(Platform::String^ name, Platform::String^ automationName, Platform::String^ glyph, Platform::String^ accessKey, Platform::String^ mode, ViewMode viewMode, bool supportsNegative) :
                m_name(name),
                m_automationName(automationName),
                m_glyph(glyph),
                m_accessKey(accessKey),
                m_mode(mode),
                m_viewMode(viewMode),
                m_supportsNegative(supportsNegative)
            {
                m_position = NavCategory::GetPosition(m_viewMode);
            }

            static std::vector<MyVirtualKey> GetCategoryAcceleratorKeys();

        private:
            static bool IsModeInCategoryGroup(ViewMode mode, CategoryGroupType groupType);

            ViewMode m_viewMode;
            Platform::String^ m_name;
            Platform::String^ m_automationName;
            Platform::String^ m_glyph;
            Platform::String^ m_accessKey;
            Platform::String^ m_mode;
            int m_position;
            bool m_supportsNegative;
        };

        [Windows::UI::Xaml::Data::Bindable]
        public ref class NavCategoryGroup sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
        {

        public:
            OBSERVABLE_OBJECT();
            OBSERVABLE_PROPERTY_R(Platform::String^, Name);
            OBSERVABLE_PROPERTY_R(Platform::String^, AutomationName);
            OBSERVABLE_PROPERTY_R(CategoryGroupType, GroupType);
            OBSERVABLE_PROPERTY_R(Windows::Foundation::Collections::IObservableVector<NavCategory^>^, Categories);

            static Windows::Foundation::Collections::IObservableVector<NavCategoryGroup^>^ CreateMenuOptions();

            static Platform::String^ GetHeaderResourceKey(CategoryGroupType type);
            
        internal:
            static NavCategoryGroup^ CreateCalculatorCategory();
            static NavCategoryGroup^ CreateConverterCategory();
    
        private:
            NavCategoryGroup(const NavCategoryGroupInitializer& groupInitializer);

            static std::vector<NavCategoryInitializer> GetInitializerCategoryGroup(CategoryGroupType groupType);
        };
    }
}