ocaml/maccaml/lcontrols.c

/*
    WASTE Demo Project:
    Macintosh Controls with Long Values

    Copyright © 1993-1996 Marco Piovanelli
    All Rights Reserved

    C port by John C. Daub
*/

/***************************************************************************
   This file is not subject to the O'Caml licence.
   It is a slightly modified version of "LongControls.c" from
   the WASTE Demo source (version 1.2).
 ***************************************************************************/
/* $Id$ */

#ifndef __CONTROLS__
#include <Controls.h>
#endif

#ifndef __FIXMATH__
#include <FixMath.h>
#endif

#ifndef __TOOLUTILS__
#include <ToolUtils.h>
#endif

#include "main.h"                              /* The change */
#define BSL(A, B)    (((long) (A)) << (B))      /* is here    */


// long control auxiliary record used for keeping long settings
// a handle to this record is stored in the reference field of the control record

struct LCAuxRec
{
    long    value;    // long value
    long    min;    // long min
    long    max;    // long max
};
typedef struct LCAuxRec LCAuxRec, *LCAuxPtr, **LCAuxHandle;


OSErr LCAttach( ControlRef control )
{
    Handle        aux;
    LCAuxPtr    pAux;

    /*    allocate the auxiliary record that will hold long settings */

    if ( ( aux = NewHandleClear( sizeof( LCAuxRec ) ) ) == nil )
    {
        return    MemError( );
    }

    /*    store a handle to the auxiliary record in the contrlRfCon field */

    SetControlReference( control, (long) aux );

    /*    copy current control settings into the auxiliary record */

    pAux = * (LCAuxHandle) aux;
    pAux->value = GetControlValue( control );
    pAux->min = GetControlMinimum( control );
    pAux->max = GetControlMaximum( control );

    return noErr;
}

void LCDetach( ControlRef control )
{
    Handle aux;

    if ( ( aux = (Handle) GetControlReference( control ) ) != nil )
    {
        SetControlReference( control, 0L );
        DisposeHandle( aux );
    }
}

void LCSetValue( ControlRef control, long value )
{
    LCAuxPtr pAux;
    short controlMin, controlMax, newControlValue;

    pAux = * (LCAuxHandle) GetControlReference( control );

    /*    make sure value is in the range min...max */

    if ( value < pAux->min )
    {
        value = pAux->min;
    }
    if ( value > pAux->max )
    {
        value = pAux->max;
    }

    /*    save value in auxiliary record */

    pAux->value = value;

    /*    calculate new thumb position */

    controlMin = GetControlMinimum( control );
    controlMax = GetControlMaximum( control );
    newControlValue = controlMin + FixRound( FixMul ( FixDiv( value - pAux->min,
                pAux->max - pAux->min), BSL(controlMax - controlMin, 16 )));

    /*    do nothing if the thumb position hasn't changed */

    if ( newControlValue != GetControlValue(control) )
    {
        SetControlValue( control, newControlValue );
    }
}

void LCSetMin( ControlRef control, long min )
{
    LCAuxPtr pAux;

    pAux = * (LCAuxHandle) GetControlReference( control );

    /*    make sure min is less than or equal to max */

    if ( min > pAux->max )
    {
        min = pAux->max;
    }

    /*    save min in auxiliary record */

    pAux->min = min;

    /*    set control minimum to min or SHRT_MIN, whichever is greater */

    SetControlMinimum( control, ( min >= SHRT_MIN ) ? min : SHRT_MIN );

    /*    reset value */

    LCSetValue( control, pAux->value );
}

void LCSetMax( ControlRef control, long max )
{
    LCAuxPtr pAux;

    pAux = * (LCAuxHandle) GetControlReference( control );

    /*    make sure max is greater than or equal to min */

    if ( max < pAux->min )
    {
        max = pAux->min;
    }

    /*    save max in auxiliary record */

    pAux->max = max;

    /*    set control maximum to max or SHRT_MAX, whichever is less */

    SetControlMaximum( control, ( max <= SHRT_MAX ) ? max : SHRT_MAX );

    /*    reset value */

    LCSetValue( control, pAux->value );
}

/*    In each of these LCGetXXX() functions, there are 2 ways listed to do things.  They are
    both the same thing and perform the same stuff, just one is easier to read than the
    other (IMHO).  I asked Marco about it and he gave me the shorter code (what's commented
    in each function) and gave me this explanation:

        This version [the commented code] yields smaller and faster code
        (try disassembling both versions if you wish), but some people may
        find it somewhat harder to read.

    I agree with Marco that his code is better overall, but in the interest of readabilty
    (since this demo is a learning tool), I left my code in and put Marco's in commented
    out.  Pick whichever you'd like to use.
*/

long LCGetValue( ControlRef control )
{
    LCAuxPtr    pAux;

    pAux = *((LCAuxHandle)GetControlReference( control ));

    return pAux->value;

//    this is Marco's code.  Remember, this is a little harder to read, but overall
//    yields tighter code.

//    return (* (LCAuxHandle) GetControlReference(control)) -> value;

}

long LCGetMin( ControlRef control )
{
    LCAuxPtr    pAux;

    pAux = *((LCAuxHandle)GetControlReference( control ));

    return pAux->min;

//    this is Marco's code.  Remember, this is a little harder to read, but overall
//    yields tighter code.

//    return (* (LCAuxHandle)GetControlReference(control)) -> min;

}

long LCGetMax( ControlRef control )
{
    LCAuxPtr    pAux;

    pAux = *((LCAuxHandle)GetControlReference( control ));

    return pAux->max;

//    this is Marco's code.  Remember, this is a little harder to read, but overall
//    yields tighter code.

//    return (* (LCAuxHandle)GetControlReference(control)) -> max;

}

void LCSynch( ControlRef control )
{
    LCAuxPtr pAux;
    short controlMin, controlMax, controlValue;

    controlMin = GetControlMinimum( control );
    controlMax = GetControlMaximum( control );
    controlValue = GetControlValue( control );
    pAux = * (LCAuxHandle) GetControlReference( control );

    /*    calculate new long value */

    pAux->value = pAux->min + FixMul( FixRatio ( controlValue - controlMin,
                  controlMax - controlMin), pAux->max - pAux->min );
}