C++ (Cpp) minofの例

コード例 #1

ファイル: rectangle.c プロジェクト: Soren-Nordstrom/Ion3

void rectangle_constrain(WRectangle *g, const WRectangle *bounds)
{
    const WRectangle tmpg=*g;
    
    g->x=minof(maxof(tmpg.x, bounds->x), tmpg.x+tmpg.w-1);
    g->y=minof(maxof(tmpg.y, bounds->y), tmpg.y+tmpg.h-1);
    g->w=maxof(1, minof(bounds->x+bounds->w, tmpg.x+tmpg.w)-g->x);
    g->h=maxof(1, minof(bounds->y+bounds->h, tmpg.y+tmpg.h)-g->y);
}

コード例 #2

ファイル: menu.c プロジェクト: Soren-Nordstrom/Ion3

static void menu_firstfit(WMenu *menu, bool submenu, const WRectangle *refg)
{
    WRectangle geom;
    
    calc_size(menu, &(geom.w), &(geom.h));
    
    if(!(menu->last_fp.mode&REGION_FIT_BOUNDS)){
        geom.x=menu->last_fp.g.x;
        geom.y=menu->last_fp.g.y;
    }else if(menu->pmenu_mode){
        geom.x=refg->x;
        geom.y=refg->y;
        
        if(!submenu){
            const WRectangle *maxg = 
                &REGION_GEOM(REGION_PARENT((WRegion*)menu));
            
            geom.x-=geom.w/2;
            geom.y+=POINTER_OFFSET;

            if(geom.y+MINIMUM_Y_VISIBILITY>maxg->y+maxg->h){
                geom.y=maxg->y+maxg->h-MINIMUM_Y_VISIBILITY;
                geom.x=refg->x+POINTER_OFFSET;
                if(geom.x+geom.w>maxg->x+maxg->w)
                    geom.x=refg->x-geom.w-POINTER_OFFSET;
            }else{
                if(geom.x<0)
                    geom.x=0;
                else if(geom.x+geom.w>maxg->x+maxg->w)
                    geom.x=maxg->x+maxg->w-geom.w;
            }
        }
    }else{
        const WRectangle *maxg=&(menu->last_fp.g);
        if(submenu){
            int l, r, t, b, xoff, yoff;
            
            get_placement_offs(menu, &xoff, &yoff);
            l=refg->x+xoff;
            r=refg->x+refg->w+xoff;
            t=refg->y-yoff;
            b=refg->y+refg->h-yoff;
            
            geom.x=maxof(l, r-geom.w);
            if(geom.x+geom.w>maxg->x+maxg->w)
                geom.x=maxg->x;

            geom.y=minof(b-geom.h, t);
            if(geom.y<maxg->y)
                geom.y=maxg->y;
        }else{
            geom.x=maxg->x;
            geom.y=maxg->y+maxg->h-geom.h;
        }
    }
    
    window_do_fitrep(&menu->win, NULL, &geom);
}

コード例 #3

ファイル: sizepolicy.c プロジェクト: Soren-Nordstrom/Ion3

static void gravity_stretch_policy(int szplcy, WRegion *reg,
                                   const WRectangle *rq_geom, WFitParams *fp, 
                                   bool ws, bool hs)
{
    WRectangle max_geom=fp->g;
    int w, h;

    fp->g=*rq_geom;
    
    w=(ws ? max_geom.w : minof(rq_geom->w, max_geom.w));
    h=(hs ? max_geom.h : minof(rq_geom->h, max_geom.h));
    
    if(reg!=NULL)
        region_size_hints_correct(reg,  &w, &h, FALSE);
    
    fp->g.w=w;
    fp->g.h=h;
    
    do_gravity(&max_geom, szplcy, &(fp->g));
}

コード例 #4

ファイル: prac0601.c プロジェクト: bobchin/study_c

int main(void)
{
  int na, nb;

  puts("二つの整数を入力してください。");
  printf("整数１："); scanf("%d", &na);
  printf("整数２："); scanf("%d", &nb);

  printf("小さい方の値は%dです。\n", minof(na, nb));

  return 0;
}

コード例 #5

ファイル: menu.c プロジェクト: Soren-Nordstrom/Ion3

static void menu_do_refit(WMenu *menu, WWindow *par, const WFitParams *oldfp)
{
    WRectangle geom;
    
    calc_size(menu, &(geom.w), &(geom.h));
    
    if(!(menu->last_fp.mode&REGION_FIT_BOUNDS)){
        geom.x=menu->last_fp.g.x;
        geom.y=menu->last_fp.g.y;
    }else if(menu->pmenu_mode){
        geom.x=REGION_GEOM(menu).x;
        geom.y=REGION_GEOM(menu).y;
    }else{
        const WRectangle *maxg=&(menu->last_fp.g);
        int xdiff=REGION_GEOM(menu).x-oldfp->g.x;
        int ydiff=(REGION_GEOM(menu).y+REGION_GEOM(menu).h
                   -(oldfp->g.y+oldfp->g.h));
        geom.x=maxof(0, minof(maxg->x+xdiff, maxg->x+maxg->w-geom.w));
        geom.y=maxof(0, minof(maxg->y+maxg->h+ydiff, maxg->y+maxg->h)-geom.h);
    }
    
    window_do_fitrep(&menu->win, par, &geom);
}

コード例 #6

ファイル: menu.c プロジェクト: Soren-Nordstrom/Ion3

static int scrolld_subs(WMenu *menu, int d)
{
    int diff=0;
    WRegion *p=REGION_PARENT_REG(menu);
    const WRectangle *pg;
    
    if(p==NULL)
        return 0;

    pg=&REGION_GEOM(p);
    
    while(menu!=NULL){
        diff=maxof(diff, calc_diff(&REGION_GEOM(menu), pg, d));
        menu=menu->submenu;
    }
    
    return minof(maxof(0, diff), scroll_amount);
}

コード例 #7

ファイル: sizepolicy.c プロジェクト: Soren-Nordstrom/Ion3

static int fit_y(int y, int h, const WRectangle *max_geom)
{
    int mh=maxof(max_geom->h, 1);
    h=minof(mh, h);
    return minof(maxof(y, max_geom->y), max_geom->y+mh-h);
}

コード例 #8

ファイル: sizepolicy.c プロジェクト: Soren-Nordstrom/Ion3

void sizepolicy(WSizePolicy *szplcy, WRegion *reg,
                const WRectangle *rq_geom, int rq_flags,
                WFitParams *fp)
{
    uint extra=fp->mode&REGION_FIT_ROTATE;
    
    WRectangle tmp;
    if(rq_geom!=NULL)
        tmp=*rq_geom;
    else if(reg!=NULL)
        tmp=REGION_GEOM(reg);
    else
        tmp=fp->g;
    
    if((*szplcy)&SIZEPOLICY_SHRUNK){
        if(reg!=NULL){
            tmp.w=region_min_w(reg);
            tmp.h=region_min_h(reg);
        }else{
            tmp.w=1;
            tmp.h=1;
        }
        rq_flags&=~(REGION_RQGEOM_WEAK_W|REGION_RQGEOM_WEAK_H);
    }

    fp->mode=REGION_FIT_EXACT|extra;
    
    switch((*szplcy)&SIZEPOLICY_MASK){
    case SIZEPOLICY_GRAVITY:
        gravity_stretch_policy(*szplcy, reg, &tmp, fp, FALSE, FALSE);
        break;
        
    case SIZEPOLICY_STRETCH_LEFT:
        gravity_stretch_policy(org(*szplcy, SIZEPOLICY_HORIZ_LEFT|SIZEPOLICY_VERT_CENTER), 
                               reg, &tmp, fp, FALSE, TRUE);
        break;
        
    case SIZEPOLICY_STRETCH_RIGHT:
        gravity_stretch_policy(org(*szplcy, SIZEPOLICY_HORIZ_RIGHT|SIZEPOLICY_VERT_CENTER), 
                               reg, &tmp, fp, FALSE, TRUE);
        break;
        
    case SIZEPOLICY_STRETCH_TOP:
        gravity_stretch_policy(org(*szplcy, SIZEPOLICY_VERT_TOP|SIZEPOLICY_HORIZ_CENTER), 
                               reg, &tmp, fp, TRUE, FALSE);
        break;
        
    case SIZEPOLICY_STRETCH_BOTTOM:
        gravity_stretch_policy(org(*szplcy, SIZEPOLICY_VERT_BOTTOM|SIZEPOLICY_HORIZ_CENTER), 
                               reg, &tmp, fp, TRUE, FALSE);
        break;
        
    case SIZEPOLICY_FULL_EXACT:
        gravity_stretch_policy(org(*szplcy, SIZEPOLICY_VERT_CENTER|SIZEPOLICY_HORIZ_CENTER), 
                               reg, &tmp, fp, TRUE, TRUE);
        break;
        
    case SIZEPOLICY_FREE:
        if(reg!=NULL)
            region_size_hints_correct(reg, &tmp.w, &tmp.h, FALSE);
        rectangle_constrain(&tmp, &(fp->g));
        fp->g=tmp;
        break;
        
    case SIZEPOLICY_VISIBILITY_CONSTRAINED:
        if(reg!=NULL)
            region_size_hints_correct(reg, &tmp.w, &tmp.h, FALSE);
        { 
            /* Constraint such that at least min(size, CF_VISIBILITY_CONSTRAINT) 
             * much is visible at each border.
             */
            int dx=maxof(0, tmp.w-CF_VISIBILITY_CONSTRAINT);
            int dy=maxof(0, tmp.h-CF_VISIBILITY_CONSTRAINT);
            tmp.x=maxof(fp->g.x-dx, minof(tmp.x, fp->g.x+fp->g.w+dx-tmp.w));
            tmp.y=maxof(fp->g.y-dy, minof(tmp.y, fp->g.y+fp->g.h+dy-tmp.h));
        }
        fp->g=tmp;
        break;
        
    case SIZEPOLICY_UNCONSTRAINED:
        if(reg!=NULL)
            region_size_hints_correct(reg, &tmp.w, &tmp.h, TRUE);
        fp->g=tmp;
        break;

    case SIZEPOLICY_FREE_GLUE:
        sizepolicy_free_snap(szplcy, reg, &tmp, rq_flags, fp);
        break;
        
    case SIZEPOLICY_FULL_BOUNDS:
    default:
        fp->mode=REGION_FIT_BOUNDS|extra;
        break;
    }
}

コード例 #9

ファイル: sizepolicy.c プロジェクト: Soren-Nordstrom/Ion3

static int fit_x(int x, int w, const WRectangle *max_geom)
{
    int mw=maxof(max_geom->w, 1);
    w=minof(mw, w);
    return minof(maxof(x, max_geom->x), max_geom->x+mw-w);
}

コード例 #10

ファイル: sizepolicy.c プロジェクト: Soren-Nordstrom/Ion3

static void sizepolicy_free_snap(WSizePolicy *szplcy, WRegion *reg,
                                 WRectangle *rq_geom, int rq_flags,
                                 WFitParams *fp)
{
    WRectangle max_geom=fp->g;
    bool fullw=((rq_flags&REGION_RQGEOM_WEAK_W) &&
                (*szplcy&SIZEPOLICY_HORIZ_MASK)==SIZEPOLICY_HORIZ_CENTER);
    bool fullh=((rq_flags&REGION_RQGEOM_WEAK_H) &&
                (*szplcy&SIZEPOLICY_VERT_MASK)==SIZEPOLICY_VERT_CENTER);

    int w=(fullw ? max_geom.w : minof(rq_geom->w, max_geom.w));
    int h=(fullh ? max_geom.h : minof(rq_geom->h, max_geom.h));
    int x_=0, y_=0;

    
    if(!(rq_flags&REGION_RQGEOM_WEAK_X) 
       && rq_flags&REGION_RQGEOM_WEAK_W){
        x_=fit_x(rq_geom->x, 1, &max_geom);
        if(((*szplcy)&SIZEPOLICY_HORIZ_MASK)==SIZEPOLICY_HORIZ_RIGHT)
            w=max_geom.x+max_geom.w-x_;
        else
            w=minof(w, max_geom.x+max_geom.w-x_);
    }
    
    if(!(rq_flags&REGION_RQGEOM_WEAK_Y)
       && rq_flags&REGION_RQGEOM_WEAK_H){
        y_=fit_x(rq_geom->y, 1, &max_geom);
        if(((*szplcy)&SIZEPOLICY_VERT_MASK)==SIZEPOLICY_VERT_BOTTOM)
            h=max_geom.y+max_geom.h-y_;
        else
            h=minof(h, max_geom.y+max_geom.h-y_);
    }
       
    if(reg!=NULL)
        region_size_hints_correct(reg, &w, &h, FALSE);
    
    fp->g.w=w;
    fp->g.h=h;
    
    if(!(rq_flags&REGION_RQGEOM_WEAK_X) 
       && rq_flags&REGION_RQGEOM_WEAK_W){
        fp->g.x=x_;
    }else if(rq_flags&REGION_RQGEOM_WEAK_X){
        switch((*szplcy)&SIZEPOLICY_HORIZ_MASK){
        case SIZEPOLICY_HORIZ_CENTER:
            fp->g.x=max_geom.x+(max_geom.w-w)/2;
            break;
 
        case SIZEPOLICY_HORIZ_LEFT:
            fp->g.x=max_geom.x;
            break;
            
        case SIZEPOLICY_HORIZ_RIGHT:
            fp->g.x=max_geom.x+max_geom.w-w;
            break;
            
        default:
            fp->g.x=fit_x(rq_geom->x, w, &max_geom);
            break;
        }
    }else{
        fp->g.x=fit_x(rq_geom->x, w, &max_geom);
    }
    
    if(!(rq_flags&REGION_RQGEOM_WEAK_Y)
       && rq_flags&REGION_RQGEOM_WEAK_H){
        fp->g.y=y_;
    }else if(rq_flags&REGION_RQGEOM_WEAK_Y){
        switch((*szplcy)&SIZEPOLICY_VERT_MASK){
        case SIZEPOLICY_VERT_CENTER:
            fp->g.y=max_geom.y+(max_geom.h-h)/2;
            break;
            
        case SIZEPOLICY_VERT_TOP:
            fp->g.y=max_geom.y;
            break;
            
        case SIZEPOLICY_VERT_BOTTOM:
            fp->g.y=max_geom.y+max_geom.h-h;
            break;
            
        default:
            fp->g.y=fit_y(rq_geom->y, h, &max_geom);
            break;
        }
    }else{
        fp->g.y=fit_y(rq_geom->y, h, &max_geom);
    }
    
    (*szplcy)&=~(SIZEPOLICY_VERT_MASK|SIZEPOLICY_HORIZ_MASK);
    
    *szplcy|=( (fullw || fp->g.x<=max_geom.x ? SIZEPOLICY_HORIZ_LEFT : 0)
              |(fullw || fp->g.x+fp->g.w>=max_geom.x+max_geom.w ? SIZEPOLICY_HORIZ_RIGHT : 0)
              |(fullh || fp->g.y<=max_geom.y ? SIZEPOLICY_VERT_TOP : 0)
              |(fullh || fp->g.y+fp->g.h>=max_geom.y+max_geom.h ? SIZEPOLICY_VERT_BOTTOM : 0));
}