void XXObjectRectangle::unionRect(XSWFCONTEXT&cnt,XXVARLIST&list)
{
	XXObjectRectangle*pRect=m_pRoot->m_pGlobal->CreateRectangle();
	if(pRect&&list.GetSize()>0&&list[0].IsObject())
	{
		XXObjectRectangle*pr=(XXObjectRectangle*)list[0].pObject;
		if(pr->IsObject(XXOBJ_RECTANGLE))
		{
		    double r=left+width;
			double b=top+height;
			double r1=pr->left+pr->width;
			double b1=pr->top+pr->height;
			double l=XMIN(left,pr->left);
			double t=XMIN(top,pr->top);
			r=XMAX(r,r1);
			b=XMAX(b,b1);
			pRect->left=l;
			pRect->top=t;
			pRect->width=r-l;
			pRect->height=b-t;
			//if(r>l&&b>t)
			//   pVar->iData32=XTRUE;
		}
	}
	cnt.pStack->Push((pRect));
}
 unsigned long ChannelStream::GetOutputTime()
 {
     if (!this->startedPlaying)
         return 0;
     
     return XMAX(Platform::GetMilliseconds() - this->playStart,0) + this->playOffset;
 }
int
dceslicecompose(DCEslice* s1, DCEslice* s2, DCEslice* result)
{
    int err = NC_NOERR;
    size_t lastx = 0;
    DCEslice sr; /* For back compatability so s1 and result can be same object */
#ifdef DEBUG1
slicedump("compose: s1",s1);
slicedump("compose: s2",s2);
#endif
    sr.node.sort = CES_SLICE;
    sr.stride    = s1->stride * s2->stride;
    sr.first     = MAP(s1,s2->first);
    if(sr.first > s1->last)
	return NC_EINVALCOORDS;
    lastx        = MAP(s1,s2->last);
    sr.last      = XMIN(s1->last,lastx);
    sr.length    = (sr.last + 1) - sr.first;
    sr.declsize = XMAX(s1->declsize,s2->declsize); /* use max declsize */
    /* fill in other fields */
    sr.count = (sr.length + (sr.stride - 1))/sr.stride;
    *result = sr;
#ifdef DEBUG1
slicedump("compose: result",result);
#endif
    return err;
}
/*  Config lcdc timimg when hdmi chooses a resolution
 *  params: mode[lcdc_timimg_parms_t] lcdc timimg to 
 *          set
 *  return: null
 */
void sep0611_hdmi_lcdc_timing(struct lcdc_timing_params_t *mode)
{
    unsigned int plcr = 0;
	unsigned int pfcr = 0;
	unsigned int lcdcscr = 0;
	unsigned int lcdcbcr = 0;
	
	plcr = H_WIDTH(mode->lpw) | H_WAIT1((mode->lswc + 1)) | H_WAIT2((mode->lewc + 1));
	pfcr = V_WIDTH(mode->fpw) | V_WAIT1((mode->fswc + 1)) | V_WAIT2((mode->fewc + 1));
	
	lcdcscr = XMAX((mode->lpc + 1))|YMAX((mode->flc + 1));
	lcdcbcr = readl(LCDC_BCR_V);
	lcdcbcr &= ~0x3f;
	lcdcbcr |= PCD(mode->pcd);
	
	writel(0x0, LCDC_ECR_V);
	
	msleep(20);
	
	writel(lcdcbcr, LCDC_BCR_V);
	writel(plcr, LCDC_PLCR_V);
	writel(pfcr, LCDC_PFCR_V);
	writel(lcdcscr, LCDC_SCR_V);
	
	msleep(20);
	
	writel(0x1, LCDC_ECR_V);
	
	msleep(10);
}
void XXObjectRectangle::intersects(XSWFCONTEXT&cnt,XXVARLIST&list)
{
	XXVar pVar;//=XXVar::CreateBool(XFALSE);
	pVar.ToLogic();
	if(list.GetSize()>0&&list[0].IsObject())
	{
		XXObjectRectangle*pr=(XXObjectRectangle*)list[0].pObject;
		if(pr->IsObject(XXOBJ_RECTANGLE))
		{
		    double r=left+width;
			double b=top+height;
			double r1=pr->left+pr->width;
			double b1=pr->top+pr->height;
			double l=XMAX(left,pr->left);
			double t=XMAX(top,pr->top);
			r=XMIN(r,r1);
			b=XMIN(b,b1);
			if(r>l&&b>t)
			   pVar.iData32=XTRUE;
		}
	}
	cnt.pStack->Push(pVar);
}
Exemple #6
0
void XDomTR::RowSpan(DRAWCONTEXT*pDraw,CELLDATA*pData,XBOOL bAdd)
{
	XU16 i=0;
	while(i<pData->spans.GetSize())
	{
		pData->spans[i]--;
		
		if(pData->spans[i]<=0)
		{
			SetTabRow(pDraw,pData,0,pData->spans[i+3]);//,0,bAdd);
			pData->spans.RemoveAt(i,5);
		}
		else
		{
			pData->spans[i+3]=XMAX(pData->spans[i+3]-pData->rowws[pData->nRow],0);
			i+=5;
		}
	}
}
void
MAST::GCMMAOptimizationInterface::optimize() {
#if MAST_ENABLE_GCMMA == 1

    // make sure that all processes have the same problem setup
    _feval->sanitize_parallel();
    
    int
    N                  = _feval->n_vars(),
    M                  = _feval->n_eq() + _feval->n_ineq(),
    n_rel_change_iters = _feval->n_iters_relative_change();
    
    libmesh_assert_greater(N, 0);
    
    std::vector<Real>  XVAL(N, 0.), XOLD1(N, 0.), XOLD2(N, 0.),
    XMMA(N, 0.), XMIN(N, 0.), XMAX(N, 0.), XLOW(N, 0.), XUPP(N, 0.),
    ALFA(N, 0.), BETA(N, 0.), DF0DX(N, 0.),
    A(M, 0.), B(M, 0.), C(M, 0.), Y(M, 0.), RAA(M, 0.), ULAM(M, 0.),
    FVAL(M, 0.), FAPP(M, 0.), FNEW(M, 0.), FMAX(M, 0.),
    DFDX(M*N, 0.), P(M*N, 0.), Q(M*N, 0.), P0(N, 0.), Q0(N, 0.),
    UU(M, 0.), GRADF(M, 0.), DSRCH(M, 0.), HESSF(M*(M+1)/2, 0.),
    f0_iters(n_rel_change_iters);
    
    std::vector<int> IYFREE(M, 0);
    std::vector<bool> eval_grads(M, false);
    
    Real
    ALBEFA  = 0.1,
    GHINIT  = 0.5,
    GHDECR  = 0.7,
    GHINCR  = 1.2,
    F0VAL   = 0.,
    F0NEW   = 0.,
    F0APP   = 0.,
    RAA0    = 0.,
    Z       = 0.,
    GEPS    =_feval->tolerance();
    
    
    /*C********+*********+*********+*********+*********+*********+*********+
     C
     C  The meaning of some of the scalars and vectors in the program:
     C
     C     N  = Complex of variables x_j in the problem.
     C     M  = Complex of constraints in the problem (not including
     C          the simple upper and lower bounds on the variables).
     C ALBEFA = Relative spacing between asymptote and mode limit. Lower value
     C          will cause the move limit (alpha,beta) to move closer to asymptote
     C          values (l, u).
     C GHINIT = Initial asymptote setting. For the first two iterations the
     C          asymptotes (l, u) are defined based on offsets from the design
     C          point as this fraction of the design variable bounds, ie.
     C              l_j   =   x_j^k  - GHINIT * (x_j^max - x_j^min)
     C              u_j   =   x_j^k  + GHINIT * (x_j^max - x_j^min)
     C GHDECR = Fraction by which the asymptote is reduced for oscillating
     C          changes in design variables based on three consecutive iterations
     C GHINCR = Fraction by which the asymptote is increased for non-oscillating
     C          changes in design variables based on three consecutive iterations
     C INNMAX = Maximal number of inner iterations within each outer iter.
     C          A reasonable choice is INNMAX=10.
     C  ITER  = Current outer iteration number ( =1 the first iteration).
     C  GEPS  = Tolerance parameter for the constraints.
     C          (Used in the termination criteria for the subproblem.)
     C
     C   XVAL(j) = Current value of the variable x_j.
     C  XOLD1(j) = Value of the variable x_j one iteration ago.
     C  XOLD2(j) = Value of the variable x_j two iterations ago.
     C   XMMA(j) = Optimal value of x_j in the MMA subproblem.
     C   XMIN(j) = Original lower bound for the variable x_j.
     C   XMAX(j) = Original upper bound for the variable x_j.
     C   XLOW(j) = Value of the lower asymptot l_j.
     C   XUPP(j) = Value of the upper asymptot u_j.
     C   ALFA(j) = Lower bound for x_j in the MMA subproblem.
     C   BETA(j) = Upper bound for x_j in the MMA subproblem.
     C    F0VAL  = Value of the objective function f_0(x)
     C   FVAL(i) = Value of the i:th constraint function f_i(x).
     C  DF0DX(j) = Derivative of f_0(x) with respect to x_j.
     C   FMAX(i) = Right hand side of the i:th constraint.
     C   DFDX(k) = Derivative of f_i(x) with respect to x_j,
     C             where k = (j-1)*M + i.
     C      P(k) = Coefficient p_ij in the MMA subproblem, where
     C             k = (j-1)*M + i.
     C      Q(k) = Coefficient q_ij in the MMA subproblem, where
     C             k = (j-1)*M + i.
     C     P0(j) = Coefficient p_0j in the MMA subproblem.
     C     Q0(j) = Coefficient q_0j in the MMA subproblem.
     C      B(i) = Right hand side b_i in the MMA subproblem.
     C    F0APP  = Value of the approximating objective function
     C             at the optimal soultion of the MMA subproblem.
     C   FAPP(i) = Value of the approximating i:th constraint function
     C             at the optimal soultion of the MMA subproblem.
     C    RAA0   = Parameter raa_0 in the MMA subproblem.
     C    RAA(i) = Parameter raa_i in the MMA subproblem.
     C      Y(i) = Value of the "artificial" variable y_i.
     C      Z    = Value of the "minimax" variable z.
     C      A(i) = Coefficient a_i for the variable z.
     C      C(i) = Coefficient c_i for the variable y_i.
     C   ULAM(i) = Value of the dual variable lambda_i.
     C  GRADF(i) = Gradient component of the dual objective function.
     C  DSRCH(i) = Search direction component in the dual subproblem.
     C  HESSF(k) = Hessian matrix component of the dual function.
     C IYFREE(i) = 0 for dual variables which are fixed to zero in
     C               the current subspace of the dual subproblem,
     C           = 1 for dual variables which are "free" in
     C               the current subspace of the dual subproblem.
     C
     C********+*********+*********+*********+*********+*********+*********+*/
    
    
    /*
     *  The USER should now give values to the parameters
     *  M, N, GEPS, XVAL (starting point),
     *  XMIN, XMAX, FMAX, A and C.
     */
    // _initi(M,N,GEPS,XVAL,XMIN,XMAX,FMAX,A,C);
    // Assumed:  FMAX == A
    _feval->_init_dvar_wrapper(XVAL, XMIN, XMAX);
    // set the value of C[i] to be very large numbers
    Real max_x = 0.;
    for (unsigned int i=0; i<N; i++)
        if (max_x < fabs(XVAL[i]))
            max_x = fabs(XVAL[i]);
    std::fill(C.begin(), C.end(), std::max(1.e0*max_x, _constr_penalty));
    
    int INNMAX=_max_inner_iters, ITER=0, ITE=0, INNER=0, ICONSE=0;
    /*
     *  The outer iterative process starts.
     */
    bool terminate = false, inner_terminate=false;
    while (!terminate) {
        
        ITER=ITER+1;
        ITE=ITE+1;
        /*
         *  The USER should now calculate function values and gradients
         *  at XVAL. The result should be put in F0VAL,DF0DX,FVAL,DFDX.
         */
        std::fill(eval_grads.begin(), eval_grads.end(), true);
        _feval->_evaluate_wrapper(XVAL,
                                  F0VAL, true, DF0DX,
                                  FVAL, eval_grads, DFDX);
        if (ITER == 1)
            // output the very first iteration
            _feval->_output_wrapper(0, XVAL, F0VAL, FVAL, true);
        
        /*
         *  RAA0,RAA,XLOW,XUPP,ALFA and BETA are calculated.
         */
        raasta_(&M, &N, &RAA0, &RAA[0], &XMIN[0], &XMAX[0], &DF0DX[0], &DFDX[0]);
        asympg_(&ITER, &M, &N, &ALBEFA, &GHINIT, &GHDECR, &GHINCR,
                &XVAL[0], &XMIN[0], &XMAX[0], &XOLD1[0], &XOLD2[0],
                &XLOW[0], &XUPP[0], &ALFA[0], &BETA[0]);
        /*
         *  The inner iterative process starts.
         */
        
        // write the asymptote data for the inneriterations
        _output_iteration_data(ITER, XVAL, XMIN, XMAX, XLOW, XUPP, ALFA, BETA);

        INNER=0;
        inner_terminate = false;
        while (!inner_terminate) {
            
            /*
             *  The subproblem is generated and solved.
             */
            mmasug_(&ITER, &M, &N, &GEPS, &IYFREE[0], &XVAL[0], &XMMA[0],
                    &XMIN[0], &XMAX[0], &XLOW[0], &XUPP[0], &ALFA[0], &BETA[0],
                    &A[0], &B[0], &C[0], &Y[0], &Z, &RAA0, &RAA[0], &ULAM[0],
                    &F0VAL, &FVAL[0], &F0APP, &FAPP[0], &FMAX[0], &DF0DX[0], &DFDX[0],
                    &P[0], &Q[0], &P0[0], &Q0[0], &UU[0], &GRADF[0], &DSRCH[0], &HESSF[0]);
            /*
             *  The USER should now calculate function values at XMMA.
             *  The result should be put in F0NEW and FNEW.
             */
            std::fill(eval_grads.begin(), eval_grads.end(), false);
            _feval->_evaluate_wrapper(XMMA,
                                      F0NEW, false, DF0DX,
                                      FNEW, eval_grads, DFDX);
            
            if (INNER >= INNMAX) {
                libMesh::out
                << "** Max Inner Iter Reached: Terminating! Inner Iter = "
                << INNER << std::endl;
                inner_terminate = true;
            }
            else {
                /*
                 *  It is checked if the approximations were conservative.
                 */
                conser_( &M, &ICONSE, &GEPS, &F0NEW, &F0APP, &FNEW[0], &FAPP[0]);
                if (ICONSE == 1) {
                    libMesh::out
                    << "** Conservative Solution: Terminating! Inner Iter = "
                    << INNER << std::endl;
                    inner_terminate = true;
                }
                else {
                    /*
                     *  The approximations were not conservative, so RAA0 and RAA
                     *  are updated and one more inner iteration is started.
                     */
                    INNER=INNER+1;
                    raaupd_( &M, &N, &GEPS, &XMMA[0], &XVAL[0],
                            &XMIN[0], &XMAX[0], &XLOW[0], &XUPP[0],
                            &F0NEW, &FNEW[0], &F0APP, &FAPP[0], &RAA0, &RAA[0]);
                }
            }
        }
        
        /*
         *  The inner iterative process has terminated, which means
         *  that an outer iteration has been completed.
         *  The variables are updated so that XVAL stands for the new
         *  outer iteration point. The fuction values are also updated.
         */
        xupdat_( &N, &ITER, &XMMA[0], &XVAL[0], &XOLD1[0], &XOLD2[0]);
        fupdat_( &M, &F0NEW, &FNEW[0], &F0VAL, &FVAL[0]);
        /*
         *  The USER may now write the current solution.
         */
        _feval->_output_wrapper(ITER, XVAL, F0VAL, FVAL, true);
        f0_iters[(ITE-1)%n_rel_change_iters] = F0VAL;
        
        /*
         *  One more outer iteration is started as long as
         *  ITE is less than MAXITE:
         */
        if (ITE == _feval->max_iters()) {
            libMesh::out
            << "GCMMA: Reached maximum iterations, terminating! "
            << std::endl;
            terminate = true;
        }
        
        // relative change in objective
        bool rel_change_conv = true;
        Real f0_curr = f0_iters[n_rel_change_iters-1];
        
        for (unsigned int i=0; i<n_rel_change_iters-1; i++) {
            if (f0_curr > sqrt(GEPS))
                rel_change_conv = (rel_change_conv &&
                                   fabs(f0_iters[i]-f0_curr)/fabs(f0_curr) < GEPS);
            else
                rel_change_conv = (rel_change_conv &&
                                   fabs(f0_iters[i]-f0_curr) < GEPS);
        }
        if (rel_change_conv) {
            libMesh::out
            << "GCMMA: Converged relative change tolerance, terminating! "
            << std::endl;
            terminate = true;
        }
        
    }
    
#endif //MAST_ENABLE_GCMMA == 1
}
Exemple #8
0
void XDomTD::LayeroutCells(DRAWCONTEXT*pDraw,CELLDATA*pData,int span)
{
   CELLDATA data;  
   LAYEROUTDATA margin;
   SpanCol(pData); 
   data.Reset(pData->cur.x,pData->cur.y,XTRUE);
   PreLayerout(pDraw,&data,&margin);
   data.pData=XNULL;
   int cspan=//pDraw->DCOLSPAN;//
	        //span==0?XMAX(FindAttrib(XEAB::COLSPAN,1),1):span;
			span==0?pDraw->DCOLSPAN:span;
   int rspan=pDraw->DROWSPAN;//
             //XMAX(FindAttrib(XEAB::ROWSPAN,1),1);
	//for debug 
   
   XRect rw=pDraw->win;
   
   

  // if(pDraw->SETWIDTH==663)
//	   int a=0;

   XSize sz;
   if(pData->bFinal)
   {
	   
	   int w=pData->fixCols[pData->nCol];
	   for(int i=1;i<cspan;i++)
	   {
		   if(pData->nCol+i>=(int)pData->fixCols.GetSize()) break;
		   w+=pData->fixCols[pData->nCol+i];
	   }
	   InitMargin(pDraw,&data,&margin,m_nPosX,m_nPosY,w,m_nHeight);
	   XPoint pt=data.cur;
	   if(InitSize(pDraw,&data,w,XFALSE))
	   	 m_nFixHeight=data.max.cy-pt.y;
	   //XSize sz;
	   sz=XSize(m_nWidth,m_nHeight);
	   SetMargin(&margin,m_nWidth,m_nHeight,sz);
	   SaveData(&data);
	   //pDraw->win=rt;
	   //m_nFixHeight=m_nHeight;
   }
   else
   {
	   //data.Reset(pData->cur.x,pData->cur.y,XTRUE);
	   
	   int w=0;
	   //if(pData->nCol+cspan<(XINT)pData->setCols.GetSize())
		{
			//w=pData->setCols[pData->nCol];
			for(int i=0;i<cspan;i++)
			{
				if(pData->nCol+i>=(int)pData->setCols.GetSize()) break;
				w+=pData->setCols[pData->nCol+i];
			}
			//int w1=0;
			/*for(int i=0;i<cspan;i++)
			{
				if(pData->nCol+i>=(int)pData->cols[i]
			}*/
		}

	   InitMargin(pDraw,&data,&margin,m_nPosX,m_nPosY,w,m_nHeight);
	   XPoint pt=data.cur;

	   XU8 bFix=InitFixed(pDraw,&data,w);

	   sz=XSize(m_nWidth,m_nHeight);
	   SetMargin(&margin,m_nWidth,m_nHeight,sz);
	   //pDraw->win=rt;
	   //m_nHeight=XMAX(m_nHeight,pDraw->SETHEIGHT);//m_nHeight;//XMAX(m_nHeight,pDraw->SPACE);
	   //w=m_nWidth;
	   if(bFix)
	   {
		    m_nFixWidth=m_nWidth;
			m_nFixHeight=data.max.cy-pt.y;
	   }
	   if(span==0)
	   {
		   int nMin=m_nMin;
		   //if(bFix) m_nFixWidth=data.max.cx-
		   w=m_nFixWidth;
		   for(int i=0;i<cspan;i++)
		   {
			   XU16 id=pData->nCol+i;
			   
			   if(id>=pData->cols.GetSize())
			   {
				   pData->tabs.Add(bFix==1);
				   pData->cols.Add(nMin/(cspan-i));
				   pData->fixCols.Add(w/(cspan-i));
				   nMin-=nMin/(cspan-i);
				   w-=w/(cspan-i);
				   //break;
			   }
			   else if(i+1<cspan)
			   {
				   pData->tabs[id]|=bFix;
				   nMin=XMAX(nMin-pData->cols[id],0);
				   w=XMAX(w-pData->fixCols[id],0);
			   }
			   else
			   {
				   pData->tabs[id]|=bFix;
				   if(pData->cols[id]<nMin)
			   		   pData->cols[id]=nMin;
				   if(pData->fixCols[id]<w)
			   		   pData->fixCols[id]=w;
			   }
		   }
	   }
   }
   //m_rows.DataFrom(data.rowws);
   //m_cols.DataFrom(data.fixCols);
   //XSize size(m_nWidth,m_nHeight);	
   //SetMargin(&margin,m_nWidth,m_nHeight,size);
   /*	XString8 str=FindAttrib(XEAB::ID,"");
	if(str=="999")
		int a=0;*/
   if(pDraw->bCollapse)
   {
	   //m_nWidth-=2;
	   //m_nHeight-=2;
	   //sz.cx-=2;
	   sz.cy-=2;
   } //*///*/

   if(rspan<=1)
		SetTabRow(pDraw,pData,sz.cx,sz.cy);//m_nWidth,m_nHeight);//XSize(m_nWidth,m_nHeight),m_nMin,XTRUE);
   else
   {
	   	SetTabRow(pDraw,pData,sz.cx,pDraw->SPACE);//XSize(m_nWidth,pDraw->nRowSpace),m_nMin,XTRUE);
		pData->spans.Add(rspan);
		pData->spans.Add(pData->nCol);
		pData->spans.Add(m_nWidth);
		pData->spans.Add(m_nFixHeight);
		pData->spans.Add(cspan);
   }
   pDraw->win=rw;
   
   pData->nCol+=cspan;
   EndLayerout(pDraw,&data);
}
Exemple #9
0
XU32 XDomTable::Paint(DRAWCONTEXT *pDraw)
{
   	//XString8 str=FindAttrib(XEAB::ID,"");
	//if(str=="last")
	//	int a=0;


   if(m_nWidth<=0) return 0;
   if(m_nPosX>=pDraw->paint.right||
	  m_nPosX+m_nWidth<=pDraw->paint.left||
	  m_nPosY>=pDraw->paint.bottom||
	  m_nPosY+m_nHeight<=pDraw->paint.top) return 0;

  XU32 ss=PrePaint(pDraw);

  XRect rect(m_nPosX,m_nPosY,m_nPosX+m_nWidth,m_nPosY+m_nHeight);

  int bd=FindAttrib(XEAB::BORDER,0);
  XU8 nType=FindAttrib(XEAB::FRAME,XEnumFrame::BOX);
  XU8 bCollapse=pDraw->bCollapse;
  pDraw->bCollapse=FindAttrib(XEAB::BORDER_COLLAPSE,0);
  int nr=pDraw->SPACING;
  pDraw->SPACING=XMAX(FindAttrib(XEAB::CELLSPACING,1),0);
  XU8 d=pDraw->TABBORDER;
  pDraw->TABBORDER=bd;

  XRect ar=XRect(rect.left,rect.top,rect.right,rect.bottom);
  
  PaintBack(pDraw,ar,XTRUE);
  
  XU32 s=HandleChild(XDO_PAINT_TABLE,(XU32)pDraw,0);
  pDraw->bCollapse=bCollapse;
  pDraw->TABBORDER=d;
  if(nType==XEF::VOID_X) bd=0;

  if(bd>0)
  {
	  XGraphics*pg=pDraw->pDraw;
	  //pDraw->Save();
	  XColor cc(pDraw->DCBACK);
	  XColor dc(cc);
	  dc.Dark(60);
	  cc.Dark(30);
	  
	  int bx=m_nPosX,by=m_nPosY;
	  int ex=m_nPosX+m_nWidth-1,ey=m_nPosY+m_nHeight-1;
	  for(int i=0;i<bd;i++)
	  {
		pg->SetColor(cc);
		switch(nType)
		{
		case XEF::BOX:
		case XEF::ABOVE:
		case XEF::BORDER:
		case XEF::HSIDES:
			 pg->DrawLine(bx,by,ex,by);
			 break;
		}
		switch(nType)
		{
		case XEF::BORDER:
		case XEF::BOX:
		case XEF::VSIDES:
		case XEF::LHS:
			 pg->DrawLine(bx,by,bx,ey);
			 break;
		}
		pg->SetColor(dc);
		switch(nType)
		{
		case XEF::BORDER:
		case XEF::BOX:
		case XEF::VSIDES:
		case XEF::RHS:
			 pg->DrawLine(ex,by,ex,ey);
			 break;
		}
		switch(nType)
		{
		case XEF::BORDER:
		case XEF::BOX:
		case XEF::HSIDES:
		case XEF::BELOW:
			 pg->DrawLine(bx,ey,ex,ey);
			 break;
		}
		cc.Bright(3);
		dc.Bright(3);
		bx++;
		by++;
		ex--;
		ey--;
	  }

	  //cc.Dark(20);
	  /*pDraw->pDraw->DrawFrame(
		  XRect(m_nPosX,m_nPosY,m_nPosX+m_nWidth,m_nPosY+m_nHeight),
		  cc,bd,XTRUE);*/
//	  pDraw->Restore();
  }
  pDraw->SPACING=nr;
  PaintBorder(pDraw,ar);
  EndPaint(pDraw);
  //if(bSave) 
	//  pDraw->Restore();

  return s;
}
Exemple #10
0
XU32 XDomTD::LayeroutPre(DRAWCONTEXT*pDraw,CELLDATA*pData)
{
	XINT i;
	SpanCol(pData);
	//LAYEROUTDATA margin;
	//PreLayerout(pDraw,pData,margin);	
//	if(pDraw->SETWIDTH==-84)
//	   int a=0;
	int w=FindAttrib(XEAB::WIDTH,0);
	int cspan=XMAX(FindAttrib(XEAB::COLSPAN,1),1);
	int rspan=XMAX(FindAttrib(XEAB::ROWSPAN,1),1);
	/*if(w==0)
	{
		if(m_childs.GetSize()>0)
			pData->setCols.Add(0);
	} */
	//else
	if(w)
	{
		for(i=pData->setCols.GetSize();i<pData->nCol;i++)
			pData->setCols.Add(0);
		for(i=0;i<cspan;i++)
		{
		   XU16 id=pData->nCol+i;
		   if(id>=pData->setCols.GetSize())
		   {
			   pData->setCols.Add(w/(cspan-i));
			   w-=w/(cspan-i);
		   }
		   else if(i+1<cspan)
		   {
			   if(w>0)
			   {
				   if(pData->setCols[id]>=0)
					 w=XMAX(w-pData->setCols[id],0);
				   else w-=w/(cspan-i);
			   }
			   else
			   {
				   if(pData->setCols[id]<0)
					   w=XMIN(w-pData->setCols[id],0);
				   else w-=w/(cspan-i);
			   }
		   }
		   else
		   {
			   if(w>0)
			   {
					if(pData->setCols[id]<w)
					 pData->setCols[id]=w;
			   }
			   else if(pData->setCols[id]>w)
				   pData->setCols[id]=w;

		   }
		}
	}
//	else if(m_childs.GetSize()>0)

	pData->nCol+=cspan;
	if(rspan>1)
	{
		pData->spans.Add(rspan);
		pData->spans.Add(pData->nCol);
		pData->spans.Add(0);
		pData->spans.Add(0);
		pData->spans.Add(cspan);
   }
   //EndLayerout(pDraw,pData);
   return 0;
}
Exemple #11
0
void XDomTable::LayeroutTable(DRAWCONTEXT *pDraw, CELLDATA &data)
{
	XU32 i;
	int bd=FindAttrib(XEAB::BORDER,0);
	int cp=pDraw->SPACING;//XMAX(FindAttrib(XEAB::CELLSPACING,1),0);
	int wd=pDraw->SETWIDTH;//FindAttrib(XEAB::WIDTH,0);

	//if(wd==900)
	//	int a=0;
	//int wmm=wd;
	if(wd<0)
		wd=-pDraw->win.Width()*wd/100;

	//if(wd==660)
	 //  int a=0;

	XRect win=pDraw->win;
	int cs=pDraw->SPACING;//XMAX(FindAttrib(XEAB::CELLPADDING,1),0);//cellspacing



    XU8 nType=FindAttrib(XEAB::FRAME,XEnumFrame::BOX);
    //if(nType==XEF::VOID_X) bd=0;
	//XU8 nPad=pDraw->PADDING;
	//XU8 nSpa=pDraw->SPACING;
	//if(bd) cs++;
	{
		pDraw->SPACING=cp;
		if(bd) pDraw->SPACING+=2;
		pDraw->PADDING=cs;
	}
	if(wd>0) 
	{
		wd-=(bd<<1)+cp;
		pDraw->win.left+=bd;
		pDraw->win.right=pDraw->win.left+wd;
	}
	else	 
	{
		pDraw->win.left+=bd;
		pDraw->win.right-=bd+cp;
	}
	XPoint pt(pDraw->win.left,pDraw->win.top);
	//if(0)
	{
		
		HandleChild(XDO_LAYEROUT_TABPRE,(XU32)pDraw,(XU32)&data);
		XU32 nc=data.setCols.GetSize();
		data.Reset(pt.x,pt.y,XFALSE);

		if(nc>0) 
		{
			int pw=0,ww=pDraw->win.Width(),nsc=0,nfc=0;
			int tw=ww,ssw=0;
			for(i=0;i<nc;i++)
			{
				if(data.setCols[i]>0) 
				{
					nfc++;
					tw-=data.setCols[i];
					ssw+=data.setCols[i];
				}
				else if(data.setCols[i]<0)
					pw+=data.setCols[i];
				else nsc++;
			}
			//if((nsc+nfc)<=0&&pw>-100&&pw<0)
			//{
				
				//ww=ww*-100/pw;
			//}
			
			tw=tw*(100+pw)/100;
			if(pw!=0&&nsc>1) tw=tw/nsc;
			if(tw<=0) tw=ww/nc;
			if(nsc+nfc>0) pw=-100;
			//if(nsc<=0&&pw>-100)
			//	ww=ww*100/pw;

			for(i=0;i<nc;i++)
			{
				if(data.setCols[i]>0)
				{
					if(ssw>wd)
					{
						data.setCols[i]=data.setCols[i]*wd/ssw;
						//XVar var(XEAB::WIDTH,data.setCols[i]);

					}
					continue;
				}
				else if(data.setCols[i]<0)
				{
					data.setCols[i]=data.setCols[i]*ww/pw;
				}
				else
					data.setCols[i]=tw;
			}
		}
		//data.tabs.InsertAt(0,(XU8)0,data.fixCols.GetSize());
		
	}


	//else pDraw->win.right--;
	//XString8 str=FindAttrib(XEAB::ID,"");
	//if(str=="100")
	//	int a=0;
	//else if(m_nWidth>0) pDraw->win.right=pDraw->win.left+wd;

	HandleChild(XDO_LAYEROUT_TABS,(XU32)pDraw,(XU32)&data);
	MoreRowSpan(&data);
	data.max.cx=0;	
	//data.max.cy-=my;
	data.nMin=0;
	int nFixed=0;
	for(i=0;i<data.cols.GetSize();i++)
	{
		if(data.tabs[i])
			nFixed+=data.fixCols[i];
		else
			nFixed+=data.nMin;

		data.nMin+=data.cols[i];
		data.max.cx+=data.fixCols[i];
	}

	//if(data.max.cx==905)
	//	int a=0;

	int mx=pDraw->win.Width();
	int nMin=data.nMin;
	XBOOL bReset=XFALSE;
	if(data.max.cx<wd)
	{
		bReset=XTRUE;
		int nTotal=0,nLeft=wd,nLast=wd;
		for(i=0;i<data.tabs.GetSize();i++)
		{
			if(data.tabs[i]) //continue;
				 nLeft-=data.fixCols[i];
			else nTotal+=data.fixCols[i];
		}
		if(nTotal==0)
		{
			for(i=0;i<data.tabs.GetSize();i++)
			{
				if(i+1==data.fixCols.GetSize())
					data.fixCols[i]=nLast;
				else
				{
					if(data.max.cx<=0)
						data.fixCols[i]=wd/data.tabs.GetSize();
					else
						data.fixCols[i]=data.fixCols[i]*wd/data.max.cx;
					nLast-=data.fixCols[i];
				}
			}
		}
		else
		{
			for(i=0;i<data.tabs.GetSize();i++)
			{
				if(i+1==data.fixCols.GetSize())
					data.fixCols[i]=nLast;
				else
				{
					if(!data.tabs[i]) //continue;
						data.fixCols[i]=data.fixCols[i]*nLeft/nTotal;
					nLast-=data.fixCols[i];
				}
			}
		}
		//if(wmm>0)
		data.max.cx=wd;
		//else
		//	data.max.cx=
	}
	else if(data.max.cx>mx)//&&m_bNoChild)
	{
		/*if(nFixed<mx)
		{
			int nLeft=mx-nFixed;
			for(i=0;i<data.cols.GetSize();i++)
			{
				if(data.tabs[i]) continue;
				int dd=XMAX(data.fixCols[i]-data.cols[i],0);
				data.fixCols[i]=data.cols[i]+nLeft*dd/(data.max.cx-nFixed);
			}
			data.max.cx=mx;
		}
		else*/ if(data.nMin<mx)
		{
			int nLeft=mx-data.nMin;
			for(i=0;i<data.cols.GetSize();i++)
			{
				int dd=XMAX(data.fixCols[i]-data.cols[i],0);
				data.fixCols[i]=data.cols[i]+nLeft*dd/(data.max.cx-data.nMin);
			}
			data.max.cx=mx;
		}
		else
		{
			for(i=0;i<data.cols.GetSize();i++)
				data.fixCols[i]=data.cols[i];
			data.max.cx=data.nMin;
		}
		bReset=XTRUE;
	}
	//if(bReset)
	{
		int maxx=data.max.cx;
		data.Reset(pt.x,pt.y,XFALSE);
		//data.rowws.RemoveAll(XFALSE);
		//data.cols.RemoveAll(XFALSE);
		//data.fixCols.RemoveAll(XFALSE);
		
		data.bFinal=XTRUE;
		for(i=0;i<data.rowws.GetSize();i++)
			data.rowws[i]=0;
		HandleChild(XDO_LAYEROUT_TABS,(XU32)pDraw,(XU32)&data);
		MoreRowSpan(&data);
		data.max.cx=maxx;
		//data.max.cy-=my;
		data.nMin=nMin;
	}

	int ds=(bd<<1)+cp;
	//if(bd>0)
	{
		//bd--;
		data.max.cx+=ds;//bd<<1;
		//data.max.cy+=ds;//bd<<1;
		data.nMin+=ds;//bd<<1;
	}

	m_nHeight=ds;
	for(i=0;i<data.rowws.GetSize();i++)
		m_nHeight+=data.rowws[i];
	int sh=pDraw->SETHEIGHT;//FindAttrib(XEAB::HEIGHT,0);
	/*if(m_nHeight<sh)
	{
		for(i=0;i<data.rowws.GetSize();i++)
		{
			if(m_nHeight>0)
				data.rowws[i]=data.rowws[i]*sh/m_nHeight;
			else
				data.rowws[i]=sh/data.rowws.GetSize();
		}
	} &*/
	m_nHeight=XMAX(m_nHeight,sh);
//	pDraw->win=rt;
	m_nMin=data.nMin;
	m_nWidth=data.max.cx;
	//m_nHeight=data.max.cy;

	//pDraw->PADDING=nPad;
	//pDraw->SPACING=nSpa;
	pDraw->win=win;

}
Exemple #12
0
struct pollfd
channel_request_poll(struct channel* c)
{
    if (channel_wanted_readsz(c))
        return (struct pollfd){c->fdh->fd, POLLIN, 0};

    if (channel_wanted_writesz(c))
        return (struct pollfd){c->fdh->fd, POLLOUT, 0};

    return (struct pollfd){-1, 0, 0};
}

void
channel_write(struct channel* c, const struct iovec* iov, unsigned nio)
{
    assert(c->dir == CHANNEL_TO_FD);

    if (c->fdh == NULL)
        return; // If the stream is closed, just discard

    bool try_direct = !c->always_buffer && ringbuf_size(c->rb) == 0;
    size_t directwrsz = 0;
    size_t totalsz;

    if (c->adb_encoding_hack)
        try_direct = false;

    // If writing directly, would make us overflow the write counter,
    // fall back to buffered IO.
    if (try_direct) {
        totalsz = iovec_sum(iov, nio);
        if (c->track_bytes_written &&
            UINT32_MAX - c->bytes_written < totalsz)
        {
            try_direct = false;
        }
    }

    if (try_direct) {
        // If writev fails, just fall back to buffering path
        directwrsz = XMAX(writev(c->fdh->fd, iov, nio), 0);
        if (c->track_bytes_written)
            c->bytes_written += directwrsz;
    }

    for (unsigned i = 0; i < nio; ++i) {
        size_t skip = XMIN(iov[i].iov_len, directwrsz);
        directwrsz -= skip;
        char* b = (char*)iov[i].iov_base + skip;
        size_t blen = iov[i].iov_len - skip;
        ringbuf_copy_in(c->rb, b, blen);
        ringbuf_note_added(c->rb, blen);
    }
}

// Begin channel shutdown process.  Closure is not complete until
// channel_dead_p(c) returns true.
void
channel_close(struct channel* c)
{
    c->pending_close = true;
    if (c->fdh != NULL
        && ((c->dir == CHANNEL_TO_FD && ringbuf_size(c->rb) == 0)
            || c->dir == CHANNEL_FROM_FD))
    {
        fdh_destroy(c->fdh);
        c->fdh = NULL;
    }
}

static void
poll_channel_1(void* arg)
{
    struct channel* c = arg;
    size_t sz;

    if ((sz = channel_wanted_readsz(c)) > 0) {
        size_t nr_read;
        if (c->adb_encoding_hack)
            nr_read = channel_read_adb_hack(c, sz);
        else
            nr_read = channel_read_1(c, sz);

        assert(nr_read <= c->window);
        if (c->track_window)
            c->window -= nr_read;

        if (nr_read == 0)
            channel_close(c);
    }

    if ((sz = channel_wanted_writesz(c)) > 0) {
        size_t nr_written;
        if (c->adb_encoding_hack)
            nr_written = channel_write_adb_hack(c, sz);
        else
            nr_written = channel_write_1(c, sz);

        assert(nr_written <= UINT32_MAX - c->bytes_written);
        if (c->track_bytes_written)
            c->bytes_written += nr_written;

        if (c->pending_close && ringbuf_size(c->rb) == 0)
            channel_close(c);
    }
}

bool
channel_dead_p(struct channel* c)
{
    return (c->fdh == NULL &&
            ringbuf_size(c->rb) == 0 &&
            c->sent_eof == true);
}

void
channel_poll(struct channel* c)
{
    struct errinfo ei = { .want_msg = false };
    if (catch_error(poll_channel_1, c, &ei) && ei.err != EINTR) {
        if (c->dir == CHANNEL_TO_FD) {
            // Error writing to fd, so purge buffered bytes we'll
            // never write.  By purging, we also make the stream
            // appear writable (because now there's space available),
            // but any writes will actually go into a black hole.
            // This way, if somebody's blocked on being able to write
            // to this stream, he'll get unblocked.  This behavior is
            // important when c is TO_PEER and lets us complete an
            // orderly shutdown, flushing any data we've buffered,
            // without adding special logic all over the place to
            // account for this situation.
            ringbuf_note_removed(c->rb, ringbuf_size(c->rb));
        }

        channel_close(c);
        c->err = ei.err;
    }
}
/******************************** the module driver ************************************************************/
static int sep0611_overlay_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	unsigned int intArg,data;
	overlay_config_t config;
	lcdc_timming timming_tmp;
	switch(cmd)
	{
#if 0
		case OVERLAY_FORBID:
			if(copy_from_user(&intArg, (int *)arg, sizeof(int)))
				return -EFAULT;
			overlay_forbid = intArg;
			return 0;
#endif
#if USE_PICTURE
		case 111://GET_IMG
			//if(copy_from_user(&config, (overlay_config_t *)arg, sizeof(overlay_config_t)))
			//	return -EFAULT;
			return sep0611_overlay_get_img();
#endif
		case OVERLAY_PRINT_REGS:
			dprintk("print regs:\n");
			for(intArg=0; intArg<=0xCC;intArg+=4)
			{
				printk("reg[0x%x] = (0x%x)\n", (unsigned int)io + intArg, readl(io + intArg));
			}
			break;
		case OVERLAY_GET_STARTBUF:
			dprintk("overlay_kernel ioctl get startbuffer!\n");
			if(copy_to_user((unsigned int *)arg, &over1_addr_phy, sizeof(unsigned int)))
			{
				dprintk("error while copy!\n");
				return -EFAULT;
			}else{
			//	dprintk("success get startbuf: 0x%x",over1_addr_phy);
			}
			break;
		case OVERLAY_AUTORP_CTL:
			if(copy_from_user(&intArg, (int *)arg, sizeof(int)))
				return -EFAULT;
			if(intArg == 1){
				writel(0, io + SEP0611_ACSR);
				data = readl(io + SEP0611_LCDCBCR);
				data &=~(0x3<<13);
				data |=(0x2<<13);
				writel(data, io + SEP0611_LCDCBCR);
				mdelay(10);
				writel(1, io + SEP0611_ACSR);
				dprintk("ctl enable auto repair\n");
			}else{
				data = readl(io + SEP0611_LCDCBCR);
				data &=~(0x3<<13);
				writel(data, io + SEP0611_LCDCBCR);
				dprintk("ctl disable auto repair\n");
			}
			break;
		case OVERLAY_SHOW_CURSOR:
			return sep0611_overlay_drawcursor();
		case OVERLAY_SETPOS_CURSOR:
			if(copy_from_user(&intArg, (int *)arg, sizeof(int)))
				return -EFAULT;
			return sep0611_overlay_setpos_cursor(intArg);

		case OVERLAY_LAYERS_CTL://enable or disable layers
			if(copy_from_user(&intArg, (int *)arg, sizeof(int)))
				return -EFAULT;
			sep0611_overlay_layers_ctl(intArg);
			break;
		case 114://set lcdc timming
			if(copy_from_user(&timming_tmp, (lcdc_timming *)arg, sizeof(lcdc_timming)))
				return -EFAULT;
			sep0611_overlay_settimming(timming_tmp);
			break;
		case 115://set lcdc base layer size and format
			if(copy_from_user(&config, (overlay_config_t *)arg, sizeof(overlay_config_t)))
				return -EFAULT;
			intArg = 0;
			dprintk("set base size:(%d,%d)\n", config.width, config.height);
			intArg = XMAX(config.width)|YMAX(config.height);
			writel(intArg, io + SEP0611_BBPCR);
			writel(config.width, io + SEP0611_BASE_RAW_IMAGE_WIDTH); 
			switch(config.format)
			{
				case V4L2_PIX_FMT_RGB565:
					dprintk("use rgb565\n");
					data = readl(io + SEP0611_LCDCBCR);
					data &=~(0x3<<27);
					writel(data, io + SEP0611_LCDCBCR);
					break;
				case V4L2_PIX_FMT_RGB24:
					dprintk("use rgb888\n");
					data = readl(io + SEP0611_LCDCBCR);
					data &= ~(0x3<<27);
					data |= (0x2<<27);
					writel(data, io + SEP0611_LCDCBCR);
					break;
				default:
					dprintk("not support!\n");
					break;
			}
			break;
		case OVERLAY_GET_POSITION:
			return sep0611_overlay_get_pos((overlay_config_t*)arg);

		case OVERLAY_GET_SCREEN_INFO:
			return sep0611_overlay_get_screenInfo((overlay_config_t*)arg);

		case OVERLAY_SET_POSITION:
			if(copy_from_user(&config, (overlay_config_t *)arg, sizeof(overlay_config_t)))
				return -EFAULT;
			return sep0611_overlay_set_pos(config);

		case OVERLAY_QUEUE_BUFFER:
			if(copy_from_user(&intArg, (overlay_config_t *)arg, sizeof(unsigned int)))
				return -EFAULT;
			return sep0611_overlay_q_buffer((unsigned int)intArg);

		case OVERLAY_SET_CONFIGURE:
			if(copy_from_user(&config, (overlay_config_t *)arg, sizeof(overlay_config_t)))
				return -EFAULT;
			sep0611_overlay_set_configure(config);
			//sep0611_overlay_q_buffer(over1_addr_phy);
			break;

		case OVERLAY_SET_DISABLE:
			return sep0611_overlay_disable();

		case OVERLAY_SET_ENABLE:
			return sep0611_overlay_enable();

		case OVERLAY_COMMON_ENABLE:
			sep0611_common_enable();
			return 0;
		case OVERLAY_COMMON_DISABLE:
			sep0611_common_disable();
			return 0;
		case OVERLAY_SWITCHTO_VIDEO:
			sep0611_switchto_mode(0);
			break;
		case OVERLAY_SWITCHTO_HDMI:
			sep0611_switchto_mode(1);
			break;
		case OVERLAY_SWITCHTO_LCD:
			sep0611_switchto_mode(2);
			break;
		default:
			dprintk(" Unsupported IOCTL(%d)!!!\n", cmd);      
			break;			
	}
	return 0;
}
static int sep0611_overlay_settimming(lcdc_timming timming)
{
	unsigned int data;
	dprintk("go to %s\n", __func__);

	//disable LCDC
	writel(WIN_DISABLE, io + SEP0611_LCDCECR);

#if 1
	if(timming.width == 9999)//switch PLL source
	{	
		data = readl(io_pmu + 0x2c);
		dprintk("pmu_0x2c = 0x%x\n", data);
		data = readl(io_pmu + 0x34);
		dprintk("pmu_0x34 = 0x%x\n", data);

		data = readl(io_pmu + 0x2c);
		data &= ~(0x3<<4);
		if(timming.height == 9999) ;//use MPLL
		else {data |= 0x1<<4; /*data|=0x1;*/}		//use APLL
		writel(data, io_pmu + 0x2c);//to use APLL 800MHz

		data = readl(io_pmu + 0x34);
		data &= ~(0x1<<3);
		data |= 0x1<<3;
		writel(data , io_pmu + 0x34);

		for(;;)
		{
			data = readl(io_pmu + 0x34);
			data &= 0x1<<3;
			dprintk("data = %d\n",data);
			if(data ==0) break;
			msleep(100);
		}
		dprintk("after write the regs\n");
		data = readl(io_pmu + 0x2c);
		dprintk("pmu_0x2c = 0x%x\n", data);
		data = readl(io_pmu + 0x34);
		dprintk("pmu_0x34 = 0x%x\n", data);
		dprintk("pmu config OK\n");
		writel(WIN_ENABLE, io + SEP0611_LCDCECR);
		return 0;
	}

#endif
	dprintk("lcd.t=%d, %d, %d, %d, %d, %d, %d, %d, %d\n",timming.width,timming.height,timming.pcd,timming.h_width,timming.h_wait1,timming.h_wait2,timming.v_width,timming.v_wait1,timming.v_wait2);

	msleep(10);
	//size
	data = 0;
	data |= XMAX(timming.width)|YMAX(timming.height);
	writel(data, io + SEP0611_LCDCSCR);

	// PCD
	data = readl(io + SEP0611_LCDCBCR);
	data &=~(0x1F);
	data |=timming.pcd;
	writel(data, io + SEP0611_LCDCBCR);

	// H timming
	data = 0;
	data = H_WIDTH(timming.h_width) | H_WAIT1(timming.h_wait1) | H_WAIT2(timming.h_wait2);
	writel(data, io + SEP0611_PLCR);

	// V timming
	data = 0;
	data = V_WIDTH(timming.v_width) | V_WAIT1(timming.v_wait1) | V_WAIT2(timming.v_wait2);
	writel(data, io + SEP0611_PFCR);

	msleep(10);
	//enable LCDC
	writel(WIN_ENABLE, io + SEP0611_LCDCECR);
	return 0;
}