windows-server-2003/printscan/ui/uicommon/vwiaset.h

/*******************************************************************************
 *
 *  (C) COPYRIGHT MICROSOFT CORPORATION, 1998
 *
 *  TITLE:       VWIASET.H
 *
 *  VERSION:     1.0
 *
 *  AUTHOR:      ShaunIv
 *
 *  DATE:        1/10/2000
 *
 *  DESCRIPTION: Encapsulate the differences between LIST and RANGE properties
 *
 *******************************************************************************/

#ifndef __VWIASET_H_INCLUDED
#define __VWIASET_H_INCLUDED

#include <windows.h>
#include "pshelper.h"

class CValidWiaSettings
{
private:
    //
    // Indices into array for range values
    //
    enum
    {
        MinValue = 0,
        MaxValue = 1,
        StepValue = 2
    };

private:
    CSimpleDynamicArray<LONG> m_ValueList;
    LONG                      m_nInitialValue;
    LONG                      m_nType;

public:
    CValidWiaSettings(void)
      : m_nType(0),
        m_nInitialValue(0)
    {
    }
    CValidWiaSettings( IUnknown *pUnknown, const PropStorageHelpers::CPropertyId &propertyName )
      : m_nType(0),
        m_nInitialValue(0)
    {
        Read( pUnknown, propertyName );
    }
    CValidWiaSettings( const CValidWiaSettings &other )
      : m_nType(0),
        m_nInitialValue(0)
    {
        Assign(other);
    }
    CValidWiaSettings &operator=( const CValidWiaSettings &other )
    {
        if (&other != this)
        {
            Assign(other);
        }
        return *this;
    }
    CValidWiaSettings &Assign( const CValidWiaSettings &other )
    {
        Destroy();
        m_nType = other.Type();
        m_ValueList = other.ValueList();
        m_nInitialValue = other.InitialValue();
        if (!IsValid())
        {
            Destroy();
        }
        return *this;
    }
    LONG Type(void) const
    {
        return m_nType;
    }
    LONG InitialValue(void) const
    {
        return m_nInitialValue;
    }
    const CSimpleDynamicArray<LONG> &ValueList(void) const
    {
        return m_ValueList;
    }
    CSimpleDynamicArray<LONG> &ValueList(void)
    {
        return m_ValueList;
    }
    void Destroy(void)
    {
        m_nType = 0;
        m_nInitialValue = 0;
        m_ValueList.Destroy();
    }
    bool IsValid(void) const
    {
        if (IsList())
        {
            return (m_ValueList.Size() != 0);
        }
        else if (IsRange())
        {
            return (m_ValueList.Size() == 3);
        }
        else return false;
    }
    bool Read( IUnknown *pUnknown, const PropStorageHelpers::CPropertyId &propertyName )
    {
        bool bSuccess = false;
        Destroy();
        m_nType = 0;

        //
        // If we can't read this value, we're done
        //
        if (!PropStorageHelpers::GetProperty( pUnknown, propertyName, m_nInitialValue ))
        {
            return false;
        }

        ULONG nAccessFlags;
        if (PropStorageHelpers::GetPropertyAccessFlags( pUnknown, propertyName, nAccessFlags ))
        {
            if (nAccessFlags & WIA_PROP_LIST)
            {
                if (PropStorageHelpers::GetPropertyList( pUnknown, propertyName, m_ValueList ))
                {
                    m_nType = WIA_PROP_LIST;
                    bSuccess = (m_ValueList.Size() != 0);
                }
            }
            else if (nAccessFlags & WIA_PROP_RANGE)
            {
                PropStorageHelpers::CPropertyRange PropertyRange;
                if (PropStorageHelpers::GetPropertyRange( pUnknown, propertyName, PropertyRange ))
                {
                    m_nType = WIA_PROP_RANGE;
                    m_ValueList.Append( PropertyRange.nMin );
                    m_ValueList.Append( PropertyRange.nMax );
                    m_ValueList.Append( PropertyRange.nStep );
                    bSuccess = (m_ValueList.Size() == 3);
                }
            }
        }
        if (!bSuccess)
        {
            Destroy();
        }
        return bSuccess;
    }
    bool FindClosestValueByRoundingDown( LONG &nValue ) const
    {
        //
        // Make sure we have a valid item
        //
        if (!IsValid())
        {
            return false;
        }

        if (IsRange())
        {
            //
            // Make sure we are in the legal range
            //
            nValue = WiaUiUtil::Min( WiaUiUtil::Max( m_ValueList[MinValue], nValue ), m_ValueList[MaxValue] );

            //
            // Divide the difference between nValue and min by nStep, then multiply by nStep to
            // get rid of the remainder to round down to the nearest value
            //
            nValue = m_ValueList[MinValue] + (((nValue - m_ValueList[MinValue]) / m_ValueList[StepValue]) * m_ValueList[StepValue]);
            return true;
        }
        else if (IsList() && m_ValueList.Size())
        {
            //
            // Assume the list is sorted, so we can take the first item and assume it is the minimum value
            //
            LONG nResult = m_ValueList[0];
            for (int i=0;i<m_ValueList.Size();i++)
            {
                if (m_ValueList[i] > nValue)
                {
                    break;
                }
                nResult = m_ValueList[i];
            }
            nValue = nResult;
            return true;
        }
        return false;
    }
    bool FindClosestValue( LONG &nValue ) const
    {
        LONG nFloor=nValue;
        if (FindClosestValueByRoundingDown(nFloor))
        {
            LONG nCeiling=nFloor;
            if (Increment(nCeiling))
            {
                if (nValue - nFloor < nCeiling - nValue)
                {
                    nValue = nFloor;
                    return true;
                }
                else
                {
                    nValue = nCeiling;
                    return true;
                }
            }
        }
        return false;
    }
    bool IsLegalValue( LONG nValue ) const
    {
        LONG nTestValue = nValue;
        if (FindClosestValueByRoundingDown(nTestValue))
        {
            return (nTestValue == nValue);
        }
        return false;
    }
    int FindIndexOfItem( LONG nCurrentValue ) const
    {
        if (IsRange())
        {
            //
            // Make sure we are in the legal range
            //
            nCurrentValue = WiaUiUtil::Min( WiaUiUtil::Max( m_ValueList[MinValue], nCurrentValue ), m_ValueList[MaxValue] );

            return (nCurrentValue - m_ValueList[MinValue]) / m_ValueList[StepValue];
        }
        else if (IsList() && m_ValueList.Size())
        {
            //
            // Assume the list is sorted, so we can take the first item and assume it is the minimum value
            //
            for (int i=0;i<m_ValueList.Size();i++)
            {
                if (m_ValueList[i] == nCurrentValue)
                {
                    return i;
                }
            }
        }
        //
        // returns -1 to indicate failure
        //
        return -1;
    }
    bool Increment( LONG &nCurrentValue ) const
    {
        //
        // Round us off.  This will also take care of validation.
        //
        if (!FindClosestValueByRoundingDown( nCurrentValue ))
        {
            return false;
        }

        if (IsRange())
        {
            //
            // Let FindClosestValueByRoundingDown take care of making sure that we don't exceed the maximum
            //
            nCurrentValue += m_ValueList[StepValue];
            return FindClosestValueByRoundingDown( nCurrentValue );
        }
        else if (IsList() && m_ValueList.Size())
        {
            int nIndex = FindIndexOfItem( nCurrentValue );

            //
            // Make sure we are in the list
            //
            if (nIndex < 0)
            {
                return false;
            }

            //
            // Get the next value
            //
            nIndex++;

            //
            // Make sure we aren't off the end of the list
            //
            if (nIndex >= m_ValueList.Size())
            {
                nIndex = m_ValueList.Size() - 1;
            }

            //
            // Return it
            //
            nCurrentValue = m_ValueList[nIndex];

            //
            // Everything is OK
            //
            return true;
        }
        return false;
    }
    bool Decrement( LONG &nCurrentValue ) const
    {
        //
        // Round us off.  This will also take care of validation.
        //
        if (!FindClosestValueByRoundingDown( nCurrentValue ))
        {
            return false;
        }

        if (IsRange())
        {
            //
            // Let FindClosestValueByRoundingDown take care of making sure that we don't go under the minimum
            //
            nCurrentValue -= m_ValueList[StepValue];
            return FindClosestValueByRoundingDown( nCurrentValue );
        }
        else if (IsList() && m_ValueList.Size())
        {
            int nIndex = FindIndexOfItem( nCurrentValue );

            //
            // Make sure we are in the list
            //
            if (nIndex < 0)
            {
                return false;
            }

            //
            // Get the previous value
            //
            nIndex--;

            //
            // Make sure we aren't before the beginning of the list
            //
            if (nIndex < 0)
            {
                nIndex = 0;
            }

            //
            // Return it
            //
            nCurrentValue = m_ValueList[nIndex];

            //
            // Everything is OK
            //
            return true;
        }
        return false;
    }
    LONG GetItemCount(void) const
    {
        if (IsList())
        {
            return m_ValueList.Size();
        }
        else if (IsRange())
        {
            //
            // Calculate the number of steps between the minimum and maximum
            //
            return ((m_ValueList[MaxValue] - m_ValueList[MinValue]) / m_ValueList[StepValue]) + 1;
        }
        return 0;
    }
    bool GetItemAtIndex( int nIndex, LONG &nItem ) const
    {
        if (!IsValid())
        {
            return false;
        }
        if (IsList() && nIndex >= 0 && nIndex < m_ValueList.Size())
        {
            nItem = m_ValueList[nIndex];
            return true;
        }
        else if (IsRange() && nIndex < GetItemCount())
        {
            //
            // Return the minimum + nIndex * stepvalue
            //
            nItem = m_ValueList[MinValue] + (m_ValueList[StepValue] * nIndex);
            return true;
        }
        return false;
    }
    bool FindIntersection( const CValidWiaSettings &Set1, const CValidWiaSettings &Set2 )
    {
        //
        // We are modifying ourselves, so clear all of our data
        //
        Destroy();

        //
        // If either set is invalid, no intersection
        //
        if (!Set1.IsValid() || !Set2.IsValid())
        {
            return false;
        }

        //
        // If either a or b is a set (or both), just add all of the items
        // that are legal in both to ourself and set the type to a LIST
        //
        if (Set1.IsList())
        {
            m_nType = WIA_PROP_LIST;
            for (int i=0;i<Set1.GetItemCount();i++)
            {
                LONG nItem;
                if (Set1.GetItemAtIndex(i,nItem))
                {
                    if (Set2.IsLegalValue(nItem))
                    {
                        m_ValueList.Append(nItem);
                    }
                }
            }

            //
            // Figure out where to get the initial value from
            //
            if (IsLegalValue(Set1.InitialValue()))
            {
                m_nInitialValue = Set1.InitialValue();
            }
            else if (IsLegalValue(Set2.InitialValue()))
            {
                m_nInitialValue = Set2.InitialValue();
            }
            else
            {
                if (!FindClosestValueByRoundingDown( m_nInitialValue ))
                {
                    //
                    // As a last resort, use the first value
                    //
                    GetItemAtIndex(0,m_nInitialValue);
                }
            }

            return (m_ValueList.Size() != 0);
        }
        else if (Set2.IsList())
        {
            m_nType = WIA_PROP_LIST;
            for (int i=0;i<Set2.GetItemCount();i++)
            {
                LONG nItem;
                if (Set2.GetItemAtIndex(i,nItem))
                {
                    if (Set1.IsLegalValue(nItem))
                    {
                        m_ValueList.Append(nItem);
                    }
                }
            }

            //
            // Figure out where to get the initial value from
            //
            if (IsLegalValue(Set2.InitialValue()))
            {
                m_nInitialValue = Set2.InitialValue();
            }
            else if (IsLegalValue(Set1.InitialValue()))
            {
                m_nInitialValue = Set1.InitialValue();
            }
            else
            {
                if (!FindClosestValueByRoundingDown( m_nInitialValue ))
                {
                    //
                    // As a last resort, use the first value
                    //
                    GetItemAtIndex(0,m_nInitialValue);
                }
            }

            return (m_ValueList.Size() != 0);
        }
        //
        // Both are ranges.
        // BUGBUG: I may have to actually figure out how to do this in a more sophisticated
        // way.  Basically, I am taking the minimum of the two maximums and the maximum of the
        // two minimums if and only if the at least one of the minimums is in the set of the
        // other items and they have the same step value
        //
        else if (Set1.IsLegalValue(Set2.Min()) || Set2.IsLegalValue(Set1.Min()) && Set1.Step() == Set2.Step())
        {
            m_nType = WIA_PROP_RANGE;

            //
            //  Minimum, Maximum, Step
            //
            m_ValueList.Append(WiaUiUtil::Max(Set1.Min(),Set2.Min()));
            m_ValueList.Append(WiaUiUtil::Min(Set1.Max(),Set2.Max()));
            m_ValueList.Append(Set1.Step());

            //
            // Figure out where to get the initial value from
            //
            if (IsLegalValue(Set2.InitialValue()))
            {
                m_nInitialValue = Set2.InitialValue();
            }
            else if (IsLegalValue(Set1.InitialValue()))
            {
                m_nInitialValue = Set1.InitialValue();
            }
            else
            {
                if (!FindClosestValueByRoundingDown( m_nInitialValue ))
                {
                    //
                    // As a last resort, use the first value
                    //
                    GetItemAtIndex(0,m_nInitialValue);
                }
            }

            return (m_ValueList.Size() == 3);
        }
        return true;
    }
    LONG Min(void) const
    {
        if (!IsValid())
        {
            return 0;
        }
        if (IsList())
        {
            return (m_ValueList[0]);
        }
        else if (IsRange())
        {
            return (m_ValueList[MinValue]);
        }
        return 0;
    }
    LONG Max(void) const
    {
        if (!IsValid())
        {
            return 0;
        }
        if (IsList())
        {
            return (m_ValueList[m_ValueList.Size()-1]);
        }
        else if (IsRange())
        {
            return (m_ValueList[MaxValue]);
        }
        return 0;
    }
    LONG Step(void) const
    {
        if (IsRange())
        {
            return (m_ValueList[StepValue]);
        }
        return 0;
    }
    bool IsRange(void) const
    {
        return (m_nType == WIA_PROP_RANGE);
    }
    bool IsList(void) const
    {
        return (m_nType == WIA_PROP_LIST);
    }
    
    static bool SetNumericPropertyOnBoundary( IUnknown *pUnknown, const PropStorageHelpers::CPropertyId &propertyName, LONG nValue )
    {
        CValidWiaSettings ValidWiaSettings;
        if (!ValidWiaSettings.Read( pUnknown, propertyName ))
        {
            return false;
        }
        if (!ValidWiaSettings.FindClosestValueByRoundingDown(nValue))
        {
            return false;
        }
        if (!PropStorageHelpers::SetProperty( pUnknown, propertyName, nValue ))
        {
            return false;
        }
        return true;
    }
    
    
};

#endif //__VWIASET_H_INCLUDED