---

palm/HiRes.c

Go to the documentation of this file.

#include <PalmTypes.h>
#include <FeatureMgr.h>
#include <ErrorBase.h>
#include <ErrorMgr.h>
#include <SystemMgr.h>
/*
 * Pen Input Manager needs Palmos 5 SDK release 3
 * which includes support for Dynamic Input Areas (DIA)
 */
#include <PenInputMgr.h>
#include <NotifyMgr.h>
#include <SysEvtMgr.h>
#include <logging.h>
#include <simcity.h>

#define _HIRESSOURCE_
#include <resCompat.h>
#include <palmutils.h>

#if defined(HRSUPPORT)

Coord sWidth;
Coord sHeight;
static UInt32 hdfs = ~0UL;

#define SetBits(B,L) (((1U << ((L) - 1)) - 1U + (1U << ((L) - 1))) << (B))
#define pinMaxConstraintSize SetBits(0, (sizeof (Coord) * 8) - 1)

void
setScreenRes(void)
{
        switch(highDensityFeatureSet()) {
        case kDensityQuadruple:
                WriteLog("Quadruple Density\n");
        case kDensityTriple:
                WriteLog("Triple Density\n");
        case kDensityDouble:
                WriteLog("Double Density\n");
                SETWIDTH(BASEWIDTH * 2);
                SETHEIGHT(BASEHEIGHT * 2);
                break;
        case kDensityOneAndAHalf:
                WriteLog("One And A Half Density\n");
                SETWIDTH(BASEWIDTH * 1.5);
                SETHEIGHT(BASEHEIGHT * 1.5);
                break;
        case kDensityLow:
                WriteLog("Single Density\n");
                SETWIDTH(BASEWIDTH);
                SETHEIGHT(BASEHEIGHT);
        default:
                if (sonyHires()) {
                        WriteLog("Sony High Density\n");
                        SETWIDTH(BASEWIDTH * 2);
                        SETHEIGHT(BASEHEIGHT * 2);
                } else {
                        WriteLog("Fallthru - Single Density (%d)\n",
                            (int)highDensityFeatureSet());
                        SETWIDTH(BASEWIDTH);
                        SETHEIGHT(BASEHEIGHT);

                }
                break;
        }
}

UInt32
highDensityFeatureSet(void)
{
        UInt32 tval;

        if (hdfs != ~0UL)
                return (hdfs);

        hdfs = 0;

        if (0 != FtrGet(sysFtrCreator, sysFtrNumWinVersion, &tval))
                goto out;
        if (tval < 4)
                goto out;
        if (0 != WinScreenGetAttribute(winScreenDensity, &tval))
                goto out;
        hdfs = tval;
        if (hdfs == kDensityLow)
                hdfs = 0;
out:
        return (hdfs);
}

Boolean
isDoubleOrMoreResolution()
{
        if (hdfs >= kDensityDouble || sonyHires())
                return (1);
        return (0);
}

void
StartHiresDraw(void)
{
        if (hdfs) WinSetCoordinateSystem(hdfs);
        StartHiresFontDraw();
}

void
EndHiresDraw(void)
{
        EndHiresFontDraw();
        if (hdfs) WinSetCoordinateSystem(kCoordinatesStandard);
}

void
StartHiresFontDraw(void)
{
        if (hdfs) {
                if (IsScaleModes()) 
                        WinSetScalingMode(kBitmapScalingOff | kTextScalingOff |
                            kTextPaddingOff);
                else
                        BmpSetDensity(WinGetBitmap(WinGetDrawWindow()),
                            kDensityLow);
        }
}

void
EndHiresFontDraw(void)
{
        if (hdfs) {
                if (IsScaleModes())
                        WinSetScalingMode(0);
                else
                        BmpSetDensity(WinGetBitmap(WinGetDrawWindow()), hdfs);
        }
}

Boolean
canHires(void)
{
        return (highDensityFeatureSet() || sonyCanHires());
}

Boolean
isHires(void)
{
        return (highDensityFeatureSet() || sonyHires());
}

void
scaleEvent(EventPtr event)
{
        UInt32 mul;
        if (isHires()) {
                if (sonyHires())
                        mul = kDensityDouble;
                else
                        mul = hdfs ? hdfs : kDensityLow;
                event->screenX  = (Coord)((UInt32)event->screenX * mul /
                    kDensityLow);
                event->screenY = (Coord)((UInt32)event->screenY * mul /
                    kDensityLow);
        }
}

Coord
scaleCoord(Coord x)
{
        Int32 mul = sonyHires() ? kDensityDouble :
            ( hdfs ? hdfs : kDensityLow );
        return ((Coord)((Int32)x * mul / kDensityLow));
}

Coord
normalizeCoord(Coord x)
{
        Int32 mul = sonyHires() ? kDensityDouble : (hdfs ? hdfs : kDensityLow);
        return ((Coord)((Int32)x * kDensityLow / mul));
}

static Int16 has_silk = -1;

Int16
hasVirtualSilk(void)
{
        return (has_silk);
}

void
StartSilk(void)
{
        Err err;
        UInt32 version;

        if (has_silk != -1)
                return;

        WriteLog("StartSilk(");

        err = FtrGet(pinCreator, pinFtrAPIVersion, &version);
        if (!err && version) {
                if (pinAPIVersion1_0 == version)
                        has_silk = 1;
                else
                        has_silk = 2;
                WriteLog("%d)\n", has_silk);
                return;
        }

        if (SonySilk()) {
                has_silk = 1;
                WriteLog("%d)\n", has_silk);
                return;
        }

        has_silk = 0;
        WriteLog("%d)\n", has_silk);

        return;
}

void
EndSilk(void)
{
        WriteLog("Endsilk\n");
        has_silk = 0;
        SonyEndSilk();
}

void
SetSilkResizable(FormPtr form, UInt8 resizeable)
{
        if (SonySilk()) {
                SonySetSilkResizable(resizeable);
        } else if (hasVirtualSilk()) {
                UInt16 state;

                if (resizeable)
                        state = pinInputTriggerEnabled;
                else
                        state = pinInputTriggerDisabled;
                if (resizeable) {
                        RectangleType bnds;
                        Coord x, y;

                        FrmGetFormBounds(form, &bnds);
                        x = bnds.extent.x;
                        y = bnds.extent.y;
                        WinSetConstraintsSize(WinGetWindowHandle(form), y,
                            pinMaxConstraintSize, pinMaxConstraintSize, x, x,
                            pinMaxConstraintSize);
                        FrmSetDIAPolicyAttr(form, frmDIAPolicyCustom);
                        PINSetInputTriggerState(pinInputTriggerEnabled);
                        PINSetInputAreaState(pinInputAreaUser);
                } else {
                        PINSetInputTriggerState(state);
                }
        }
}

Boolean
collapseMove(FormPtr form, UInt8 stretchy, Int16 *roffsetX, Int16 *roffsetY)
{
        Coord           dispHeight, dispWidth;
        RectangleType   dwRect;
        Int16           offX, offY;
        WinHandle       frmH;

        if (!hasVirtualSilk()) {
                return (false);
        }

        WinGetDisplayExtent(&dispWidth, &dispHeight);
        WriteLog("extent = %d, %d\n", (int)dispWidth, (int)dispHeight);

        frmH = WinGetWindowHandle(form);
        WinGetBounds(frmH, &dwRect);
        offX = dispWidth - dwRect.extent.x - dwRect.topLeft.x;
        offY = dispHeight - dwRect.extent.y - dwRect.topLeft.y;

        WriteLog("offX = %d, offY = %d\n", (int)offX, (int)offY);

        if (stretchy && CM_MODAL) {
                offX -= 2;
                offY -= 2;
        }
        if (roffsetX != NULL) *roffsetX = offX;
        if (roffsetY != NULL) *roffsetY = offY;

        if (offX || offY) {
                if (stretchy && CM_MOVEX)
                        dwRect.topLeft.x += offX;
                else /* Stretch the X axis */
                        dwRect.extent.x += offX;
                if (stretchy && CM_MOVEY)
                        dwRect.topLeft.y += offY;
                else
                        dwRect.extent.y += offY;
                WinSetBounds(frmH, &dwRect);
                return (true);
        }
        return (false);
}

void
collapsePreRedraw(FormPtr form
#if !defined(SONY_CLIE)
    __attribute__((unused))
#endif
)
{
        SonyCollapsePreRedraw(form);
}

#endif /* HRSUPPORT */

---