UtilFunc.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: Utility functions (hence the u in uLib)
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// This file had grown so large it's now split it into smaller units.

// > IoUtil.cpp     - I/O related functions.
// > UserUtil.cpp   - User32 related functions.
// > GdiUtil.cpp    - GDI32 related functions.
// > KernelUtil.cpp - Kernel32 related functions.
// > SecUtil.cpp    - Security related functions. Se also UmLsa.cpp
// > ShellUtil.cpp  - Shell32 related functions.

#include <uLib/Common.h>
#include <uLib/UtilFunc.h>
#include <uLib/Debug.h>
#include <uLib/StrFunc.h>

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// These will return some basic struct types on the fly.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

POINT MkPoint( LONG x, LONG y ) {
    POINT p = { x,y };
    return p;
    }

POINTS MkPointS( SHORT x, SHORT y ) {
    POINTS p = { x,y };
    return p;
    }

SIZE MkSize( LONG cx, LONG cy ) {
    SIZE s = { cx,cy };
    return s;
    }

SIZES MkSizeS( SHORT cx, SHORT cy ) {
    SIZES s = { cx,cy };
    return s;
    }

RECT MkRect( LONG L, LONG T, LONG R, LONG B ) {
    RECT r = { L,T,R,B };
    return r;
    }

RECTS MkRectS( SHORT L, SHORT T, SHORT R, SHORT B ) {
    RECTS r = { L,T,R,B };
    return r;
    }

// Point conversion for mouse hit test;
// E.g: POINT pt = Point( LITERAL( POINTS, lParam ));
// See also POINTSTOPOINT() and POINTTOPOINTS()

POINT MkPoint( const POINTS& p ) { // extern "C++"
    POINT pt = { p.x, p.y };
    return pt;
    }
POINTS MkPointS( const POINT& p ) { // extern "C++"
    POINTS pt = { (short)p.x, (short)p.y };
    return pt;
    }

// Point equality comparators

bool operator == ( POINT P1, POINT P2 ) { // extern "C++"
    return LITERAL( UINT64,P1 ) == LITERAL( UINT64,P2 );
    }
bool operator != ( POINT P1, POINT P2 ) { // extern "C++"
    return LITERAL( UINT64,P1 ) != LITERAL( UINT64,P2 );
    }
bool operator == ( POINTS P1, POINTS P2 ) { // extern "C++"
    return LITERAL( DWORD,P1 ) == LITERAL( DWORD,P2 );
    }
bool operator != ( POINTS P1, POINTS P2 ) { // extern "C++"
    return LITERAL( DWORD,P1 ) != LITERAL( DWORD,P2 );
    }

// Some rectangle conversions

LPRECT AbsToDimRect( LPRECT r ) {
    r->right -= r->left; // _out  r.right = width
    r->bottom -= r->top; // _out  r.bottom = height
    return r;
    }

LPRECT DimToAbsRect( LPRECT r ) {
    r->right += r->left; // _out  r.right = x2
    r->bottom += r->top; // _out  r.bottom = y2
    return r;
    }

LPRECT AbsToRelRect( LPRECT R ) {
    OffsetRect( R, -(R->left), -(R->top) );
    return R;
    }

LPRECT NegateRect( LPRECT R ) // Change sign of all rect fields
{
    R->top    = -R->top;
    R->bottom = -R->bottom;
    R->left   = -R->left;
    R->right  = -R->right;
    return R;
}

// Fit one rect inside another with preserved aspect ratio.

void FitRect( PRECT pRc, PRECT pBounds, OUT PRECT pOut )
{
    SIZE ext, bounds, fit;
    ext.cx = RECT_WIDTH( *pRc );
    ext.cy = RECT_HEIGHT( *pRc );
    bounds.cx = RECT_WIDTH( *pBounds );
    bounds.cy = RECT_HEIGHT( *pBounds );
        
    if ((ext.cx != bounds.cx) || (ext.cy != bounds.cy)) // pRc must be scaled
    {
        // [REF] https://stackoverflow.com/questions/1373035/how-do-i-scale-one-rectangle-to-the-maximum-size-possible-within-another-rectang
        float scalex = float(bounds.cx) / ext.cx;
        float scaley = float(bounds.cy) / ext.cy;
        // Scale by same factor to preserve aspect ratio.
        float scale = min_<float>( scalex, scaley );
        fit.cx = long( scale * ext.cx );
        fit.cy = long( scale * ext.cy );
    }
    else fit = ext;

    long x = pBounds->left + ((bounds.cx - fit.cx) / 2);
    long y = pBounds->top + ((bounds.cy - fit.cy) / 2);
    SetRect( pOut, x, y, x + fit.cx, y + fit.cy );
}

// Some special legacy rect operations.

void DiffRect( PRECT Borders, LPCRECT Outer, LPCRECT Inner )
{
    Borders->top    = Inner->top - Outer->top;
    Borders->bottom = Inner->bottom - Outer->bottom;
    Borders->left   = Inner->left - Outer->left;
    Borders->right  = Inner->right - Outer->right;

}

void AbsDiffRect( PRECT Borders, LPCRECT Outer, LPCRECT Inner ) // Without sign.
{
    Borders->top    = abs( Inner->top - Outer->top );
    Borders->bottom = abs( Inner->bottom - Outer->bottom );
    Borders->left   = abs( Inner->left - Outer->left );
    Borders->right  = abs( Inner->right - Outer->right );
}

void InflateBorders( PRECT Target, LPCRECT Borders )
{
    // Refer to DiffRect() to comprehend.
    Target->top    -= Borders->top;
    Target->bottom -= Borders->bottom;
    Target->left   -= Borders->left;
    Target->right  -= Borders->right;
}

void AbsInflateBorders( PRECT Target, LPCRECT Borders )
{
    Target->top    -= Borders->top;
    Target->bottom += Borders->bottom;
    Target->left   -= Borders->left;
    Target->right  += Borders->right;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// EngUnits convert a value to a multiple of 10^3 (engineering units).
// Probably belongs in a math module, but uLib don't have one.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

long double EngUnits( long double Value, int* pExpo )
// Note: MSVC does /not/ support long double, they're trucated to measly double.
// If you need long double in MSVC, buy Love's excellent xMath library.
{
    long double val = Value;
    int expo = 0;
    bool neg = (val < 0);
    if (neg) val = -val;

    if (val > 1.0)
    {
        while( val > 1000.0 ) {
            expo += 3;
            val *= 0.001;
        }
    }
    else if (val < 1.0)
    {
        while( val < 1.0 ) {
            expo -= 3;
            val *= 1000.0;
        }
    }
    if (neg) val = -val;

    if (pExpo) *pExpo = expo;
    return val;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// EOF