framemgr.c

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

    type = it->template->type;
    switch (type)
    {
    case BARRAY:
        {
            ExtraData d;
            ExtraDataRec dr;

            for (i = 0;  i < it->max_count;  i++)
            {
                if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
                {
                    dr.num = NO_VALUE;
                    d = ChainMgrSetData (&it->cm, i, dr);
                }
                /*endif*/
                if (d->num == NO_VALUE)
                {
                    d->num = num;
                    return FmSuccess;
                }
                /*endif*/
            }
            /*endfor*/
            if (it->allow_expansion)
            {
                ExtraDataRec dr;
                
                dr.num = num;
                ChainMgrSetData (&it->cm, it->max_count, dr);
                it->max_count++;
    
                return FmSuccess;
            }
            /*endif*/
        }   
        return FmNoMoreData;

    case ITER:
        {
            ExtraData d;
            ExtraDataRec dr;

            for (i = 0;  i < it->max_count;  i++)
            {
                if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
                {
                    dr.iter = IterInit (it->template + 1, NO_VALUE);
                    d = ChainMgrSetData (&it->cm, i, dr);
                }
                /*endif*/
                if (IterSetSize (d->iter, num) == FmSuccess)
                    return FmSuccess;
                /*endif*/
            }
            /*endfor*/
            if (it->allow_expansion)
            {
                ExtraDataRec dr;

                dr.iter = IterInit (it->template + 1, NO_VALUE);
                ChainMgrSetData (&it->cm, it->max_count, dr);
                it->max_count++;

                if (IterSetSize(dr.iter, num) == FmSuccess)
                    return FmSuccess;
                /*endif*/
            }
            /*endif*/
        }
        return FmNoMoreData;

    case POINTER:
        {
            ExtraData d;
            ExtraDataRec dr;

            for (i = 0;  i < it->max_count;  i++)
            {
                if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
                {
                    dr.fi = FrameInstInit (it->template[1].data);
                    d = ChainMgrSetData (&it->cm, i, dr);
                }
                /*endif*/
                if (FrameInstSetSize (d->fi, num) == FmSuccess)
                    return FmSuccess;
                /*endif*/
            }
            /*endfor*/
            if (it->allow_expansion)
            {
                ExtraDataRec dr;

                dr.fi = FrameInstInit (it->template[1].data);
                ChainMgrSetData (&it->cm, it->max_count, dr);
                it->max_count++;

                if (FrameInstSetSize (dr.fi, num) == FmSuccess)
                    return FmSuccess;
                /*endif*/
            }
            /*endif*/
        }
        return FmNoMoreData;
    }
    /*endswitch*/
    return FmNoMoreData;
}

static int IterGetSize (Iter it)
{
    register int i;
    ExtraData d;
    ExtraDataRec dr;

    if (it->cur_no >= it->max_count)
        return NO_VALID_FIELD;
    /*endif*/
    
    switch (it->template->type)
    {
    case BARRAY:
        if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
            return NO_VALUE;
        /*endif*/
        return d->num;

    case ITER:
        for (i = it->cur_no; i < it->max_count; i++)
        {
            int ret_size;

            if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
            {
                dr.iter = IterInit (it->template + 1, NO_VALUE);
                d = ChainMgrSetData (&it->cm, i, dr);
            }
            /*endif*/
            ret_size = IterGetSize (d->iter);
            if (ret_size != NO_VALID_FIELD)
                return ret_size;
            /*endif*/
        }
        /*endfor*/
        return NO_VALID_FIELD;
    
    case POINTER:
        for (i = it->cur_no;  i < it->max_count;  i++)
        {
            int ret_size;
            
            if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
            {
                dr.fi = FrameInstInit (it->template[1].data);
                d = ChainMgrSetData (&it->cm, i, dr);
            }
            /*endif*/
            ret_size = FrameInstGetSize (d->fi);
            if (ret_size != NO_VALID_FIELD)
                return ret_size;
            /*endif*/
        }
        /*endfor*/
        return NO_VALID_FIELD;
    }
    /*endswitch*/
    return NO_VALID_FIELD;
}

static FmStatus IterSetIterCount (Iter it, int num)
{
    register int i;

    if (it->allow_expansion)
    {
        it->max_count = num;
        it->allow_expansion = False;
        return FmSuccess;
    }
    /*endif*/

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

    switch (it->template->type)
    {
    case ITER:
        for (i = 0;  i < it->max_count;  i++)
        {
            ExtraData d;
            ExtraDataRec dr;

            if ((d = ChainMgrGetExtraData(&it->cm, i)) == NULL)
            {
                dr.iter = IterInit(it->template + 1, num);
                (void)ChainMgrSetData(&it->cm, i, dr);
                return FmSuccess;
            }
            /*endif*/
            if (IterSetIterCount(d->iter, num) == FmSuccess)
                return FmSuccess;
            /*endif*/
        }
        /*endfor*/
        if (it->allow_expansion)
        {
            ExtraDataRec dr;

            dr.iter = IterInit (it->template + 1, num);
            ChainMgrSetData (&it->cm, it->max_count, dr);
            it->max_count++;

            return FmSuccess;
        }
        /*endif*/
        break;
    
    case POINTER:
        for (i = 0;  i < it->max_count;  i++)
        {
            ExtraData d;
            ExtraDataRec dr;
            
            if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
            {
                dr.fi = FrameInstInit (it->template[1].data);
                d = ChainMgrSetData (&it->cm, i, dr);
            }
            /*endif*/
            if (FrameInstSetIterCount (d->fi, num) == FmSuccess)
                return FmSuccess;
            /*endif*/
        }
        /*endfor*/
        if (it->allow_expansion)
        {
            ExtraDataRec dr;
            
            dr.fi = FrameInstInit (it->template[1].data);
            ChainMgrSetData (&it->cm, it->max_count, dr);
            it->max_count++;

            if (FrameInstSetIterCount (dr.fi, num) == FmSuccess)
                return FmSuccess;
            /*endif*/
        }
        /*endif*/
        break;
    }
    /*endswitch*/
    return FmNoMoreData;
}

static int IterGetTotalSize (Iter it)
{
    register int size, i;
    XimFrameType type;

    if (it->allow_expansion)
        return NO_VALUE;
    /*endif*/
    if (it->max_count == 0)
        return 0;
    /*endif*/

    size = 0;
    type = it->template->type;

    switch (type)
    {
    case BIT8:
        size = it->max_count;
        break;

    case BIT16:
        size = it->max_count*2;
        break;

    case BIT32:
        size = it->max_count*4;
        break;

    case BIT64:
        size = it->max_count*8;
        break;

    case BARRAY:
        for (i = 0;  i < it->max_count;  i++)
        {
            register int num;
            ExtraData d;
            
            if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
                return  NO_VALUE;
            /*endif*/
            if ((num = d->num) == NO_VALUE)
                return  NO_VALUE;
            /*endif*/
            size += num;
        }
        /*endfor*/
        break;
        
    case ITER:
        for (i = 0;  i < it->max_count;  i++)
        {
            register int num;
            ExtraData d;
            
            if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
                return  NO_VALUE;
            /*endif*/
            if ((num = IterGetTotalSize (d->iter)) == NO_VALUE)
                return  NO_VALUE;
            /*endif*/
            size += num;
        }
        /*endfor*/
        break;
        
    case POINTER:
        for (i = 0;  i < it->max_count;  i++)
        {
            register int num;
            ExtraData d;
            ExtraDataRec dr;
            
            if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
            {
                dr.fi = FrameInstInit (it->template[1].data);
                d = ChainMgrSetData (&it->cm, i, dr);
            }
            /*endif*/
            if ((num = FrameInstGetTotalSize (d->fi)) == NO_VALUE)
                return NO_VALUE;
            /*endif*/
            size += num;
        }
        /*endfor*/
        break;
    }
    /*endswitch*/
    return  size;
}

static void IterReset (Iter it)
{
    ChainIterRec ci;
    int count;
    ExtraDataRec d;

    switch (it->template->type)
    {
    case ITER:
        ChainIterInit (&ci, &it->cm);
        while (ChainIterGetNext (&ci, &count, &d))
            IterReset (d.iter);
        /*endwhile*/
        ChainIterFree (&ci);
        break;
  
    case POINTER:
        ChainIterInit (&ci, &it->cm);
        while (ChainIterGetNext (&ci, &count, &d))
            FrameInstReset (d.fi);
        /*endwhile*/
        ChainIterFree (&ci);
        break;
    }
    /*endswitch*/
    it->cur_no = 0;
}

static void IterSetStartWatch (Iter it,
                               IterStartWatchProc proc,
                               void *client_data)
{
    it->start_watch_proc = proc;
    it->client_data = client_data;
}

static ExtraData ChainMgrSetData (ChainMgr cm,
                                  int frame_no,
                                  ExtraDataRec data)
{
    Chain cur = (Chain) Xmalloc (sizeof (ChainRec));

    cur->frame_no = frame_no;
    cur->d = data;
    cur->next = NULL;

    if (cm->top == NULL)
    {
        cm->top = cm->tail = cur;
    }
    else
    {
        cm->tail->next = cur;
        cm->tail = cur;
    }
    /*endif*/
    return &cur->d;
}

static ExtraData ChainMgrGetExtraData (ChainMgr cm, int frame_no)
{
    Chain cur;

    cur = cm->top;

    while (cur)
    {
        if (cur->frame_no == frame_no)
            return &cur->d;
        /*endif*/
        cur = cur->next;
    }
    /*endwhile*/
    return NULL;
}

static Bool ChainIterGetNext (ChainIter ci, int *frame_no, ExtraData d)
{
    if (ci->cur == NULL)
        return False;
    /*endif*/
    
    *frame_no = ci->cur->frame_no;
    *d = ci->cur->d;

    ci->cur = ci->cur->next;

    return True;
}

static int _FrameInstIncrement (XimFrame frame, int count)
{
    XimFrameType type;

    type = frame[count].type;
    type &= ~COUNTER_MASK;

    switch (type)
    {
    case BIT8:
    case BIT16:
    case BIT32:
    case BIT64:
    case BARRAY:
    case PADDING:
        return count + 1;
        
    case POINTER:
        return count + 2;
        
    case ITER:
        return _FrameInstIncrement (frame, count + 1);
    }
    /*endswitch*/
    return - 1;    /* Error */
}

static int _FrameInstDecrement (XimFrame frame, int count)
{
    register int i;
    XimFrameType type;

    if (count == 0)
        return - 1;    /* cannot decrement */
    /*endif*/
    
    if (count == 1)
        return 0;     /* BOGUS - It should check the contents of data */
    /*endif*/
    
    type = frame[count - 2].type;
    type &= ~COUNTER_MASK;

    switch (type)
    {
    case BIT8:
    case BIT16:
    case BIT32:
    case BIT64:
    case BARRAY:
    case PADDING:
    case PTR_ITEM:
        return count - 1;

    case POINTER:
    case ITER:
        i = count - 3;
        while (i >= 0)
        {
            if (frame[i].type != ITER)
                return i + 1;
            /*endif*/
            i--;
        }
        /*endwhile*/
        return 0;
    }
    /*enswitch*/
    return - 1;    /* Error */
}

static int _FrameInstGetItemSize (FrameInst fi, int cur_no)
{
    XimFrameType type;

    type = fi->template[cur_no].type;
    type &= ~COUNTER_MASK;

    switch (type)
    {
    case BIT8:
        return 1;

    case BIT16:
        return 2;

    case BIT32:
        return 4;

    case BIT64:
        return 8;

    case BARRAY:
        {
            ExtraData d;

            if ((d = ChainMgrGetExtraData (&fi->cm, cur_no)) == NULL)
                return NO_VALUE;
            /*endif*/
            if (d->num == NO_VALUE)
                return NO_VALUE;
            /*endif*/
            return d->num;
        }

    case PADDING:
        {
            register int unit;
            register int number;
            register int size;
            register int i;

            unit = _UNIT ((int) fi->template[cur_no].data);
            number = _NUMBER ((int) fi->template[cur_no].data);

            i = cur_no;
            size = 0;
            while (number > 0)
            {
                i = _FrameInstDecrement (fi->template, i);
                size += _FrameInstGetItemSize (fi, i);
                number--;
            }
            /*endwhile*/
            size = (unit - (size%unit))%unit;
            return size;
        }

    case ITER:
        {
            ExtraData d;
            int sub_size;

            if ((d = ChainMgrGetExtraData (&fi->cm, cur_no)) == NULL)
                return NO_VALUE;
            /*endif*/
            sub_size = IterGetTotalSize (d->iter);
            if (sub_size == NO_VALUE)
                return NO_VALUE;
            /*endif*/
            return sub_size;
        }

    case POINTER:
        {
            ExtraData d;
            int sub_size;

            if ((d = ChainMgrGetExtraData (&fi->cm, cur_no)) == NULL)
                return NO_VALUE;
            /*endif*/
            sub_size = FrameInstGetTotalSize (d->fi);
            if (sub_size == NO_VALUE)
                return NO_VALUE;
            /*endif*/
            return sub_size;
        }
    }
    /*endswitch*/
    return NO_VALUE;
}