Пример #1
0
// repaint cells that have been changed from previous generation
void Pstable::repaint_changed()
{
    int rows = procview->procs.size();
    int cols = procview->cats.size();
    int left = leftCell(), right = lastColVisible();
    int top = topCell(), bottom = lastRowVisible();
    if(right >= cols) right = cols - 1;
    if(bottom >= rows) bottom = rows - 1;
    int far_right = right;
    if(leftmostchanged != -1 && right >= leftmostchanged)
	right = leftmostchanged - 1;
    for(int c = right + 1; c <= far_right; c++)
	updateHeading(c);
    for(int r = top; r <= bottom; r++) {
	for(int c = left; c <= right; c++) {
	    Category *cat = procview->cats[c];
	    Procinfo *p = procview->procs[r], *op = 0;
	    if(r >= procview->old_procs.size()
	       || (op = procview->old_procs[r], cat->compare(p, op) != 0)
	       || p->selected != op->selected) {
		updateCell(r, c);
	    }
	}
	// update all cells that have moved or changed width
	for(int c = right + 1; c <= far_right; c++)
	    updateCell(r, c);
    }
    if(leftmostchanged != -1)
	clearRight();
}
Пример #2
0
void TableBody::timerEvent(QTimerEvent *)
{
    // timer not proved !
    return;
    // printf("timer\n");
    if (!autoscrolling)
        return;
    ////killTimers();
    if (scrolldir == UP)
    {
        int top = topCell();
        setTopCell((top > 1) ? top - 1 : 0);
        dragSelectTo(topCell());
    }
    else
    {
        setTopCell(topCell() + 1);
        int bottom = lastRowVisible();
        dragSelectTo((bottom < numRows()) ? bottom : numRows() - 1);
    }
    startTimer(scroll_delay);
}
Пример #3
0
bool TableHead::isCellChanged(int row, int col)
{
    int xpos;
    int ypos;
    int w;
    int fold, dep;
    QString str;
    bool sorted = (htable->sortedCol() == col);

    w = htable->max_widths[col];
    xpos = htable->colXPos(col);

    {
        str = htable->title(col);
    }
    // int left = leftCell();
    // int top	 = topCell();
    CellAttribute *attr = tablecache.value(row - topCell(), col - leftCell());

    if (attr == NULL) // Uninitialed?
    {
        return true;
    }
    else
    {
        bool result = false;
        if (attr->text == str and attr->sorted == sorted and
            attr->size == tmp_size and attr->xpos == xpos
            //	and attr->w==w
            )
        {
            return false;
        }
        else
        {
            attr->text = str;
            attr->sorted = sorted;
            attr->xpos = xpos;
            //		attr->w=w;
            attr->size = tmp_size;
            //			if(head)	printf("head
            // true");
            return true;
        }
        // printf("return  %s x=%d\n",str.toAscii().data(),xpos);
    }
}
Пример #4
0
// repaint cells that have been changed due to configuration change
void Pstable::repaint_statically_changed(int update_col)
{
    int rows = procview->procs.size();
    int cols = procview->cats.size();
    int right = lastColVisible(), left = right + 1;
    int top = topCell(), bottom = lastRowVisible();
    if(leftmostchanged == -1 || leftmostchanged > update_col)
	leftmostchanged = update_col;
    if(leftmostchanged != -1)
	left = leftmostchanged;
    if(right >= cols) right = cols - 1;
    if(bottom >= rows) bottom = rows - 1;
    for(int c = left; c <= right; c++)
	updateHeading(c);
    for(int r = top; r <= bottom; r++) {
	for(int c = left; c <= right; c++)
	    updateCell(r, c);
    }
    if(leftmostchanged != -1)
	clearRight();
}
Пример #5
0
void KFinderWin::setBranchVisible( KFinderItem* startItem )
{
  KFinderItem* curItem;
  int i1 = -1, i2 = -1;
  int branchLevel = -1;
  bool bFound = false;
  QListIterator<KFinderItem> it( itemList );
  //for ( ; it.current(); ++it )
  for ( curItem = finder->first(); curItem != 0; curItem = finder->next() )
  {
    if( bFound ){
      i2++;
      if( curItem->getLevel() <= branchLevel )
        break;
    }
    else {
      i1++;
      if( curItem == startItem ) {
	branchLevel = curItem->getLevel();
	i2 = i1;
	bFound = true;
      }    
    }
  }
  
  int lastRow = lastRowVisible();
  if( (i2 - i1) > lastRow - topCell() - 2 )
    setTopCell( i1 ? (i1 - 1) : i1 );
  else if( i2 > lastRow ) {
         int newTopCell = topCell() + ( i2 - lastRow );
         if( findRow(minViewY() + cellHeight() - 1) != topCell())
           newTopCell++;
         setTopCell( newTopCell );
       }
       else if( i1 < topCell() ) {
         int newTopCell = topCell() - ( topCell() - i1 );
	 if( newTopCell )
           newTopCell--;
         setTopCell( newTopCell );
       }	 
}
Пример #6
0
//??
void TableBody::showRange(int from, int to)
{
    int h = viewHeight() / cellHeight();
    if (to >= topCell() + h)
        setTopCell(qMax(0, qMin(from, to - h + 1)));
}
Пример #7
0
// DRAFT CODE !!  BOTTLENECK !!!
// Description : draw a cell of table
// 		1. draw the background of a cell
// 		2. draw the text of a cell
//
// called by
// 		1.QtTableView::paintEvent()
void TableBody::paintCell(QPainter *p, int row, int col, bool use_cache)
{
    // *** sequence important !!!
    //	if(isCellChanged(row,col)==false)	{
    // if(use_cache==true)	return;
    //}

    CellAttribute *attr =
        tablecache.value(row - topCell(), col - leftCell()); // save cache
    //	isCellChanged(row,col);

    bool sort;
    int h = cellHeight();
    int w = htable->max_widths[col];
    attr->w = w; //

    QColor baseColor = palette().brush(QPalette::Base).color();
    sort = (col == htable->sorted_col);
    attr->sorted = sort;

    // gridline
    QColor lineColor, textColor;
    QColor altColor = palette().brush(QPalette::AlternateBase).color();
    lineColor.setRgb((baseColor.red() * 0.5 + altColor.red() * 0.5),
                     (baseColor.green() * 0.4 + altColor.green() * 0.6),
                     (baseColor.blue() * 0.4 + altColor.blue() * 0.6));

    //	QStyleOption opt;
    //	opt.rect=QRect(0,0,w,h-1);
    //	opt.state = QStyle::State_Active; //?
    // QStyle::SH_ItemView_PaintAlternatingRowColorsForEmptyArea
    //  const int gridHint =
    //  style()->styleHint(QStyle::SH_Table_GridLineColor,
    //  &opt, this);

    p->setPen(lineColor);
    p->drawLine(0, h - 1, w, h - 1);

    // background
    if (htable->isSelected(row))
    {
        p->fillRect(0, 0, w, h - 1, palette().brush(QPalette::Highlight));
        p->setPen(palette().brush(QPalette::HighlightedText).color()); // text
        attr->selected = true;
    }
    else
    {
        attr->selected = false;
        if (sort)
        {
            p->fillRect(0, 0, w, h - 1, lineColor.dark(101));
        }
        else
        {
            p->fillRect(0, 0, w, h - 1, baseColor);
        }
        // style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, p,
        // this);
        p->setPen(palette().brush(QPalette::Text).color()); // text
    }

    // tree gadget , treestep=height
    int gap = h / 4;
    int testFlag = 0;
    if (col == 0 and htable->treemode == true)
    {
        QStyleOption opt;
        int d = htable->rowDepth(row);
        attr->depth = d; //**
        int treestep = htable->treestep;
        if (true /*lines*/)
        {
            /// int dx = folding ? gadget_space : 6;
            for (int level = d, prow = row; level >= 0 and prow >= 0;
                 level--, prow = htable->parentRow(prow))
            {
                if (level == d)
                    continue;
                int x = gap + level * treestep;
                QRect branchR(x, 0, treestep, h);
                opt.rect = branchR;

                if (htable->lastChild(prow) == false)
                {
                    if (testFlag)
                    {
                        p->drawLine(x + treestep / 2, 0, x + treestep / 2, h);
                    }
                    else
                    {
                        opt.state = QStyle::State_Sibling; // | vertical
                                                           // line
                        style()->drawPrimitive(QStyle::PE_IndicatorBranch, &opt,
                                               p, this);
                    }
                }
            }

            QRect branchR(gap + d * treestep, 0, treestep, h);
            opt.rect = branchR;
            if (testFlag)
            {
                int x = gap + d * treestep + treestep / 2;

                p->drawLine(x, h / 2, x + treestep / 2, h / 2);
                if (!htable->lastChild(row))
                {
                    p->drawLine(x, 0, x, h);
                }
                else
                {
                    p->drawLine(x, 0, x, h / 2);
                }
            }
            else
            {
                opt.state = QStyle::State_Item; //?
                if (!htable->lastChild(row))
                    opt.state = opt.state | QStyle::State_Sibling; // |
            }
            attr->lastchild = htable->lastChild(row);
        }

        if (true /*folding*/)
        {
            HeadedTable::NodeState fs = htable->folded(row);
            attr->folded = fs; //**
            if (fs != HeadedTable::Leaf)
            {
                opt.state = opt.state | QStyle::State_Children;
                if (fs != HeadedTable::Closed)
                    opt.state = opt.state | QStyle::State_Open;
            }
            p->save(); // temp , save pencolor
            style()->drawPrimitive(QStyle::PE_IndicatorBranch, &opt, p, this);
            p->restore();
        }
        gap = htable->gadget_space + d * treestep + 1;
    }

    // virtual int Pstable::alignment(int col)
    if (htable->alignment_col[col] == Qt::AlignRight) // using cache
    {
        w -= gap;
        gap = 0;
    }
    // Qt::IncludeTrailingSpaces
    // p->drawText(gap, 0, w , h, Qt::TextIncludeTrailingSpace |
    // Qt::IncludeTrailingSpaces | Qt::AlignVCenter |
    // htable->alignment_col[col],htable->text(row,col));
    // p->drawText(gap, 0, w , h, Qt::TextIncludeTrailingSpace |
    // Qt::AlignVCenter
    // | htable->alignment_col[col],htable->text(row,col));
    p->drawText(gap, 0, w, h, Qt::AlignVCenter | htable->alignment_col[col],
                htable->text(row, col));

    htable->overpaintCell(p, row, col, gap);

    // cache write!
    // attr->xpos=tmp_x ;
    attr->text = htable->text(row, col);
    attr->xpos = htable->colXPos(col);
    attr->size = tmp_size;
}
Пример #8
0
// new, possible COMMON?
bool TableBody::isCellChanged(int row, int col)
{
    QString str;
    int xpos;
    int fold, dep;
    bool selected;
    bool sorted;
    int lc;
    int width;

    {
        str = htable->text(row, col);
        xpos = htable->colXPos(col);
        selected = htable->isSelected(row);
        sorted = (htable->sortedCol() == col);
        width = htable->max_widths[col];
    }

    // int left = leftCell(), top = topCell();
    CellAttribute *attr = tablecache.value(row - topCell(), col - leftCell());

    if (attr == NULL) // never NULL
    {
        return true;
    }
    else
    {
        bool result = false;
        if (attr->text == str and attr->selected == selected and
            attr->sorted == sorted and attr->xpos == xpos and attr->w == width
            // and attr->size==tmp_size
            and
            (attr->size.height() >= tmp_size.height())
            //	and (attr->size.width()>=tmp_size.width())
            )
        {
            result = false;
        }
        else
        {
            //	attr->text=str;
            //	attr->selected=selected;
            //	attr->sorted=sorted;
            //	attr->xpos=xpos;
            //	attr->size=tmp_size;
            //	attr->w=width;

            //	if (row==29 and col==0)
            //	printf("(%d %d) xpos=%d %d sorted=%d %d sel=%d
            //%d str=%s
            //%s\n",attr->size.height(),tmp_size.height(),
            //			attr->xpos,xpos,attr->sorted,sorted,attr->selected,selected
            //			,qPrintable(attr->text),qPrintable(str));
            //	printf("true (%d
            //%d)\n",row-topCell(),col-leftCell());
            return true;
        }

        if (col == 0)
        {
            dep = htable->rowDepth(row); // folding_level
            fold = htable->folded(row);
            lc = htable->lastChild(row);

            if (attr->depth == dep /* Uninitial*/
                and attr->folded == fold and attr->lastchild == lc)
            {
                // false
            }
            else
            {
                //	attr->depth=dep;
                //	attr->folded=fold;
                result = true;
                //	printf("true (%d
                //%d)\n",row-topCell(),col-leftCell());
            }
        }
        return result;
    }
}