framemgr.c

手写识别Chinput3.0.2源代码,可以在linux下开发手写板程序

        fm->iters =
        p = (FrameIter) Xmalloc (sizeof (FrameIterRec));
    }
    else
    {
        p->next = (FrameIter) Xmalloc (sizeof (FrameIterRec));
        p = p->next;
    }
    /*endif*/
    if (p)
    {
        p->iter = it;
        p->counting = False;
        p->counter = 0;
        p->end = end;
        p->next = NULL;
    }
    /*endif*/
    return (p);
}

static void _FrameMgrRemoveIter (FrameMgr fm, FrameIter it)
{
    FrameIter prev;
    FrameIter p;

    prev = NULL;
    p = fm->iters;
    while (p)
    {
        if (p == it)
        {
            if (prev)
                prev->next = p->next;
            else
                fm->iters = p->next;
            /*endif*/
            Xfree (p);
            break;
        }
        /*endif*/
        prev = p;
        p = p->next;
    }
    /*endwhile*/
}

static FrameIter _FrameIterCounterIncr (FrameIter fitr, int i)
{
    FrameIter p = fitr;

    while (p)
    {
        if (p->counting)
        {
            p->counter += i;
            if (p->counter >= p->end)
            {
                IterFixIteration (p->iter);
                return (p);
            }
            /*endif*/
        }
        /*endif*/
        p = p->next;
    }
    /*endwhile*/
    return (NULL);
}

static void _IterStartWatch (Iter it, void *client_data)
{
    FrameIter p = (FrameIter) client_data;
    p->counting = True;
}

static FmStatus FrameInstSetSize (FrameInst fi, int num)
{
    ExtraData d;
    ExtraDataRec dr;
    XimFrameType type;
    register int i;

    i = 0;
    while ((type = fi->template[i].type) != EOL)
    {
        switch (type)
        {
        case BARRAY:
            if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
            {
                dr.num = -1;
                d = ChainMgrSetData (&fi->cm, i, dr);
            }
            /*endif*/
            if (d->num == NO_VALUE)
            {
                d->num = num;
                return FmSuccess;
            }
            /*endif*/
            break;
        case ITER:
            if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
            {
                dr.iter = IterInit (&fi->template[i + 1], NO_VALUE);
                d = ChainMgrSetData (&fi->cm, i, dr);
            }
            /*endif*/
            if (IterSetSize (d->iter, num) == FmSuccess)
                return FmSuccess;
            /*endif*/
            break;
            
        case POINTER:
            if ((d = ChainMgrGetExtraData(&fi->cm, i)) == NULL)
            {
                dr.fi = FrameInstInit(fi->template[i + 1].data);
                d = ChainMgrSetData(&fi->cm, i, dr);
            }
            /*endif*/
            if (FrameInstSetSize(d->fi, num) == FmSuccess)
                return FmSuccess;
            /*endif*/
            break;
        }
        /*endswitch*/
        i = _FrameInstIncrement(fi->template, i);
    }
    /*endwhile*/
    return FmNoMoreData;
}

static int FrameInstGetSize (FrameInst fi)
{
    XimFrameType type;
    register int i;
    ExtraData d;
    ExtraDataRec dr;
    int ret_size;

    i = fi->cur_no;
    while ((type = fi->template[i].type) != EOL)
    {
        switch (type)
        {
        case BARRAY:
            if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
                return NO_VALUE;
            /*endif*/
            return d->num;

        case ITER:
            if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
            {
                dr.iter = IterInit (&fi->template[i + 1], NO_VALUE);
                d = ChainMgrSetData (&fi->cm, i, dr);
            }
            /*endif*/
            ret_size = IterGetSize(d->iter);
            if (ret_size != NO_VALID_FIELD)
                return ret_size;
            /*endif*/
            break;
            
        case POINTER:
            if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
            {
                dr.fi = FrameInstInit (fi->template[i + 1].data);
                d = ChainMgrSetData (&fi->cm, i, dr);
            }
            /*endif*/
            ret_size = FrameInstGetSize (d->fi);
            if (ret_size != NO_VALID_FIELD)
                return ret_size;
            /*endif*/
            break;
        }
        /*endswitch*/
        i = _FrameInstIncrement (fi->template, i);
    }
    /*endwhile*/
    return NO_VALID_FIELD;
}

static FmStatus FrameInstSetIterCount (FrameInst fi, int num)
{
    ExtraData d;
    ExtraDataRec dr;
    register int i;
    XimFrameType type;

    i = 0;
    while ((type = fi->template[i].type) != EOL)
    {
        switch (type)
        {
        case ITER:
            if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
            {
                dr.iter = IterInit (&fi->template[i + 1], num);
                (void)ChainMgrSetData (&fi->cm, i, dr);
                return FmSuccess;
            }
            /*endif*/
            if (IterSetIterCount (d->iter, num) == FmSuccess)
                return FmSuccess;
            /*endif*/
            break;
            
        case POINTER:
            if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
            {
                dr.fi = FrameInstInit (fi->template[i + 1].data);
                d = ChainMgrSetData (&fi->cm, i, dr);
            }
            /*endif*/
            if (FrameInstSetIterCount (d->fi, num) == FmSuccess)
                return FmSuccess;
            /*endif*/
            break;
        }
        /*endswitch*/
        i = _FrameInstIncrement (fi->template, i);
    }
    /*endwhile*/
    return FmNoMoreData;
}

static int FrameInstGetTotalSize (FrameInst fi)
{
    register int size;
    register int i;

    size = 0;
    i = 0;

    while (fi->template[i].type != EOL)
    {
        size += _FrameInstGetItemSize (fi, i);
        i = _FrameInstIncrement (fi->template, i);
    }
    /*endwhile*/
    return size;
}

static void FrameInstReset (FrameInst fi)
{
    ChainIterRec ci;
    int frame_no;
    ExtraDataRec d;

    ChainIterInit (&ci, &fi->cm);

    while (ChainIterGetNext (&ci, &frame_no, &d))
    {
        register XimFrameType type;
        type = fi->template[frame_no].type;
        if (type == ITER)
        {
            if (d.iter)
                IterReset (d.iter);
            /*endif*/
        }
        else if (type == POINTER)
        {
            if (d.fi)
                FrameInstReset (d.fi);
            /*endif*/
        }
        /*endif*/
    }
    /*endwhile*/
    ChainIterFree (&ci);

    fi->cur_no = 0;
}

static Iter IterInit (XimFrame frame, int count)
{
    Iter it;
    register XimFrameType type;

    it = (Iter) Xmalloc (sizeof (IterRec));
    it->template = frame;
    it->max_count = (count == NO_VALUE)  ?  0  :  count;
    it->allow_expansion = (count == NO_VALUE);
    it->cur_no = 0;
    it->start_watch_proc = NULL;
    it->client_data = NULL;
    it->start_counter = False;

    type = frame->type;
    if (type & COUNTER_MASK)
    {
        /* COUNTER_XXX cannot be an item of a ITER */
        Xfree (it);
        return NULL;
    }
    /*endif*/

    switch (type)
    {
    case BIT8:
    case BIT16:
    case BIT32:
    case BIT64:
        /* Do nothing */
        break;
        
    case BARRAY:
    case ITER:
    case POINTER:
        ChainMgrInit (&it->cm);
        break;
        
    default:
        Xfree (it);
        return NULL; /* This should never occur */
    }
    /*endswitch*/
    return it;
}

static void IterFree (Iter it)
{
    switch (it->template->type)
    {
    case BARRAY:
        ChainMgrFree (&it->cm);
        break;
    
    case ITER:
        {
            ChainIterRec ci;
            int count;
            ExtraDataRec d;

            ChainIterInit (&ci, &it->cm);
            while (ChainIterGetNext (&ci, &count, &d))
                IterFree (d.iter);
            /*endwhile*/
            ChainIterFree (&ci);
            ChainMgrFree (&it->cm);
        }
        break;
    
    case POINTER:
        {
            ChainIterRec ci;
            int count;
            ExtraDataRec dr;
    
            ChainIterInit (&ci, &it->cm);
            while (ChainIterGetNext (&ci, &count, &dr))
                FrameInstFree (dr.fi);
            /*endwhile*/
            ChainIterFree (&ci);
            ChainMgrFree (&it->cm);
        }
        break;
    }
    /*endswitch*/
    Xfree (it);
}

static Bool IterIsLoopEnd (Iter it, Bool *myself)
{
    Bool ret = False;
    *myself = False;

    if (!it->allow_expansion  &&  (it->cur_no == it->max_count))
    {
        *myself = True;
        return True;
    }
    /*endif*/
    
    if (it->template->type == POINTER)
    {
        ExtraData d = ChainMgrGetExtraData (&it->cm, it->cur_no);
        if (d)
        {
            if (FrameInstIsIterLoopEnd (d->fi))
            {
                ret = True;
            }
            else
            {
                if (FrameInstIsEnd (d->fi))
                {
                    it->cur_no++;
                    if (!it->allow_expansion  &&  it->cur_no == it->max_count)
                    {
                        *myself = True;
                        ret = True;
                    }
                    /*endif*/
                }
                /*endif*/
            }
            /*endif*/
        }
        /*endif*/
    }
    else if (it->template->type == ITER)
    {
        ExtraData d = ChainMgrGetExtraData (&it->cm, it->cur_no);
        if (d)
        {
            Bool yourself;
            
            if (IterIsLoopEnd (d->iter, &yourself))
                ret = True;
            /*endif*/
        }
        /*endif*/
    }
    /*endif*/

    return ret;
}

static XimFrameType IterGetNextType (Iter it, XimFrameTypeInfo info)
{
    XimFrameType type = it->template->type;

    if (it->start_counter)
    {
        (*it->start_watch_proc) (it, it->client_data);
        it->start_counter = False;
    }
    /*endif*/
    if (it->cur_no >= it->max_count)
    {
        if (it->allow_expansion)
            it->max_count = it->cur_no + 1;
        else
            return EOL;
        /*endif*/
    }
    /*endif*/

    switch (type)
    {
    case BIT8:
    case BIT16:
    case BIT32:
    case BIT64:
        it->cur_no++;
        return type;

    case BARRAY:
        if (info)
        {
            ExtraData d;
    
            if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
                info->num = NO_VALUE;
            else
                info->num = d->num;
            /*endif*/
        }
        /*endif*/
        it->cur_no++;
        return BARRAY;

    case ITER:
        {
            XimFrameType ret_type;
            ExtraData d;
            ExtraDataRec dr;

            if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
            {
                dr.iter = IterInit (it->template + 1, NO_VALUE);
                d = ChainMgrSetData (&it->cm, it->cur_no, dr);
            }
            /*endif*/

            ret_type = IterGetNextType (d->iter, info);
            if (ret_type == EOL)
            {
                it->cur_no++;
                ret_type = IterGetNextType (it, info);
            }
            /*endif*/
	    return ret_type;
        }

    case POINTER:
        {
            XimFrameType ret_type;
            ExtraData d;
            ExtraDataRec dr;

            if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
            {
                dr.fi = FrameInstInit (it->template[1].data);
                d = ChainMgrSetData (&it->cm, it->cur_no, dr);
            }
            /*endif*/

            ret_type = FrameInstGetNextType (d->fi, info);
            if (ret_type == EOL)
            {
                it->cur_no++;
                ret_type = IterGetNextType (it, info);
            }
            /*endif*/
	    return ret_type;
        }
    }
    /*endswitch*/
    return (XimFrameType) NULL;  /* This should never occur */
}

static XimFrameType IterPeekNextType (Iter it, XimFrameTypeInfo info)
{
    XimFrameType type = it->template->type;

    if (!it->allow_expansion  &&  it->cur_no >= it->max_count)
        return (EOL);
    /*endif*/
    
    switch (type)
    {
    case BIT8:
    case BIT16:
    case BIT32:
    case BIT64:
        return type;

    case BARRAY:
        if (info)
        {
            ExtraData d;

            if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
                info->num = NO_VALUE;
            else
                info->num = d->num;
            /*endif*/
        }
        /*endif*/
        return BARRAY;
    
    case ITER:
        {
            XimFrameType ret_type;
            ExtraData d;
            ExtraDataRec dr;

            if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
            {
                dr.iter = IterInit (it->template + 1, NO_VALUE);
                d = ChainMgrSetData (&it->cm, it->cur_no, dr);
            }
            /*endif*/

            ret_type = IterPeekNextType (d->iter, info);
            if (ret_type == EOL)
                ret_type = IterPeekNextType (it, info);
            /*endif*/
            return ret_type;
        }
        
    case POINTER:
        {
            XimFrameType ret_type;
            ExtraData d;
            ExtraDataRec dr;

            if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
            {
                dr.fi = FrameInstInit (it->template[1].data);
                d = ChainMgrSetData (&it->cm, it->cur_no, dr);
            }
            /*endif*/

            ret_type = FrameInstPeekNextType (d->fi, info);
            if (ret_type == EOL)
                ret_type = IterPeekNextType (it, info);
            /*endif*/
            return (ret_type);
        }
    }
    /*endswitch*/
    /* Reaching here is a bug! */
    return (XimFrameType) NULL;
}

static FmStatus IterSetSize (Iter it, int num)
{
    XimFrameType type;
    register int i;

    if (!it->allow_expansion  &&  it->max_count == 0)
        return FmNoMoreData;
    /*endif*/