EXPORT_C void CHuiCanvasGc::Clip(const TRect& aClipRect)
{
if (!iGc)
{
return;
}
switch (iClipMode)
{
case EHuiCanvasClipModeNormal:
case EHuiCanvasClipModeDelayed:
{
if (iClippingRegion.Count())
{
CancelClipping();
}
if (!aClipRect.IsEmpty())
{
iTempRegion.Clear();
iTempRegion.AddRect(aClipRect);
ClipRegion(iTempRegion);
}
break;
}
case EHuiCanvasClipModeNone:
default:
{
// Do nothing
break;
}
}
}
void TestRRegion::TestAddRect()
{
RRegion rgn;
TInt index,i;
if (!rect[0].IsEmpty())
{
for(index=0;index<4;index++)
{
for(i=0;i<=index;i++)
rgn.AddRect(rect[index]);
test(rgn.Count()==(index+1));
}
test(rgn.BoundingRect()==bounds);
if (!xrect.IsEmpty())
{
rgn.AddRect(xrect);
TInt count = rgn.Count();
test( (count > 4) && (count <= 9) );
}
}
rgn.AddRect(bounds);
test(rgn.Count()==1);
rgn.Close();
}
CHuiCanvasGc::TClipRectVisibility CHuiCanvasGc::IsClipped(const TRect& aRect, const TRegion& aClippingRegion) const
{
TClipRectVisibility isClipped = EFullyOutside;
if (!aClippingRegion.Count())
{
return EFullyInside;
}
if (!aRect.IsEmpty() && aClippingRegion.Count())
{
#if 0
TBool test = EFalse;
if (test)
{
for (TInt i=0; i<aClippingRegion.Count(); i++)
{
#ifdef _DEBUG
RDebug::Print(_L("aClippingRegion Rect: %d %d %d %d"),
aClippingRegion[i].iTl.iX,
aClippingRegion[i].iTl.iY,
aClippingRegion[i].iBr.iX,
aClippingRegion[i].iBr.iY);
#endif
}
}
#endif
if (aClippingRegion.Intersects(aRect))
{
iTempRegion.Clear();
iTempRegion2.Clear();
iTempRegion.AddRect(aRect);
iTempRegion2.Intersection(aClippingRegion, iTempRegion);
iTempRegion2.Tidy();
// Assume it is only partially inside region -> Clipped
isClipped = EPartialOverlap;
if (iTempRegion2.Count() == 1)
{
if (iTempRegion2[0] == aRect)
{
// Fully inside region -> Not clipped
isClipped = EFullyInside;
}
}
}
else
{
// No overlap -> aRect is completely outside region -> Clipped
isClipped = EFullyOutside;
}
}
return isClipped;
}
void TestRRegion::CheckRectRegion(const TRegion& region,const TRect& rect)
// Check the region matches the rectangle
{
const TRect* rlist;
if (rect.IsEmpty())
test(region.Count()==0);
else
{
test(region.Count()==1);
rlist=region.RectangleList();
test(rlist[0]==rect);
test(region[0]==rect);
}
}
void TScrollBar::DrawThumb(TDrawContext& context)
{
TRect thumbArea;
GetThumbArea(thumbArea);
TRect thumb;
GetThumb(thumb);
if (context.GetDepth() < 8)
{
context.SetStipple(TGraphicsUtils::GetGrayStipple());
context.SetForeColor(kBlackColor);
context.SetBackColor(kWhiteColor);
}
else
context.SetForeColor(kMediumGrayColor);
if (thumb.IsEmpty())
{
context.PaintRect(thumbArea);
}
else
{
if (IsVertical())
{
TRect r(thumbArea.left, thumbArea.top, thumbArea.right, thumb.top);
context.PaintRect(r);
r.Set(thumb.left, thumb.bottom, thumbArea.right, thumbArea.bottom);
context.PaintRect(r);
}
else
{
TRect r(thumbArea.left, thumbArea.top, thumb.left, thumbArea.bottom);
context.PaintRect(r);
r.Set(thumb.right, thumbArea.top, thumbArea.right, thumbArea.bottom);
context.PaintRect(r);
}
TGraphicsUtils::Draw3DBorderAndInset(context, thumb);
context.SetForeColor(kLightGrayColor);
context.PaintRect(thumb);
}
}
/**
* Prepares the sprite in the set of type aSpriteType to be displayed at
* aSpritePos with size aSpriteSize. The sprite will be resized as necessary under the
* restriction of aSpriteResizeMode.
*/
EXPORT_C void CSpriteSet::PrepareSpriteForDisplayL(TInt aSpriteType, const TPoint& aSpritePos, const TSize& aSpriteSize, TSpriteResizeMode aSpriteResizeMode)
{
__ASSERT_DEBUG((aSpriteType >= 0) && (aSpriteType < iSourceMembers.Count()),Panic(EEgulPanicInvalidSpriteIndex));
__ASSERT_DEBUG((aSpriteSize.iWidth >= 0) && (aSpriteSize.iHeight >= 0),Panic(EEgulPanicNegativeSpriteSize));
iSpritePosition = aSpritePos;
iMainFbsBitGc->SetOrigin(TPoint(0,0));
TSize spriteSize(aSpriteSize);
const TSize sourceSize(iSourceMembers[aSpriteType]->Bitmap()->SizeInPixels());
AdjustSpriteSizeAccordingToResizeMode(spriteSize, sourceSize, aSpriteResizeMode);
User::LeaveIfError(iMainBmpDevice->Resize(spriteSize));
User::LeaveIfError(iMaskBmpDevice->Resize(spriteSize));
iMainFbsBitGc->Resized();
iMaskFbsBitGc->Resized();
iMaskFbsBitGc->SetBrushColor(KRgbBlack);
iMaskFbsBitGc->Clear();
const TRect translatedClipRect(iClippingRect.iTl - aSpritePos, iClippingRect.Size());
if(!translatedClipRect.IsEmpty())
iMaskFbsBitGc->SetClippingRect(translatedClipRect);
TInternalSpriteResizeMode resizeMode = EHSameVSame;
ComputeInternalResizeMode(resizeMode,aSpriteResizeMode,sourceSize,spriteSize);
RenderSprite(aSpriteType,resizeMode,sourceSize,spriteSize);
iMaskFbsBitGc->CancelClippingRect();
iMainFbsBitGc->SetOrigin(-aSpritePos);
}
void TFuncSpecView::Paint(TDC& dc, bool erase, TRect& rect)
{
TSwitchMinApp* theApp = TYPESAFE_DOWNCAST(GetApplication(), TSwitchMinApp);
if (theApp) {
// Only paint if we're printing and we have something to paint, otherwise do nothing.
//
if (theApp->Printing && theApp->Printer && !rect.IsEmpty()) {
// Use pageSize to get the size of the window to render into. For a Window it's the client area,
// for a printer it's the printer DC dimensions and for print preview it's the layout window.
//
TSize pageSize(rect.right - rect.left, rect.bottom - rect.top);
TPrintDialog::TData& printerData = theApp->Printer->GetSetup();
// Get area we can draw in
TRect drawingArea(swdoc->PaintHeader(dc, rect, "", 0, 0, false), rect.BottomRight());
TEXTMETRIC tm;
dc.SelectObject(TFont("Arial", -12));
if (!dc.GetTextMetrics(tm)) {
dc.SelectObject(TFont("Arial", -12));
dc.GetTextMetrics(tm);
}
int fHeight=tm.tmHeight+tm.tmExternalLeading;
unsigned long inputs=swdoc->GetSystem()->GetInputs();
XPosVector xpos;
uint divider;
char* data;
Print_CreateWidths(xpos, divider, dc);
if (xpos.back().x < rect.Size().cx) { // put space in structure to stretch across page
uint spacing=(rect.Size().cx - xpos.back().x)/(xpos.size()+1);
uint space_inc=spacing;
for(XPosVector::size_type i=0; i<xpos.size(); i++) {
if (i==inputs) { // after inputs section, increase divider
divider += space_inc;
space_inc += spacing;
}
xpos[i].x += space_inc;
space_inc += spacing;
}
}
data=new char[xpos.size()];
unsigned long PagesDown=1+pow(2,inputs)/( (drawingArea.Size().cy/fHeight) - 2); // 2 lines for header and horz divider
unsigned long PagesAcross=1+xpos.back().x/drawingArea.Size().cx;
unsigned long Pages=1+PagesDown*PagesAcross;
// Compute the number of pages to print.
//
printerData.MinPage = 1;
printerData.MaxPage = Pages;
int fromPage = printerData.FromPage == -1 ? 1 : printerData.FromPage;
int toPage = printerData.ToPage == -1 ? 1 : printerData.ToPage;
int currentPage = fromPage;
TPoint p;
dc.SelectObject(TPen(TColor::Black));
while (currentPage <= toPage) {
swdoc->PaintHeader(dc, rect, "Specification", currentPage, Pages, true);
if (currentPage==1) Print_Summary(dc, drawingArea);
else {
// Calculate origin of line by page number
// x
int col=((currentPage-2) ) % PagesAcross;
p.x=drawingArea.left - col * drawingArea.Size().cx;
// y
int row=floor((currentPage-2)/PagesAcross);
p.y=drawingArea.top/* - row * drawingArea.Size().cy*/;
// Calculate starting and ending input states
CELL_TYPE state, stateEnd;
state=(row*(drawingArea.Size().cy-fHeight))/fHeight;
stateEnd=state+(drawingArea.Size().cy-fHeight)/fHeight;
if (stateEnd >= (pow(2,inputs)-1) ) stateEnd=pow(2,inputs)-1;
//
// Draw header and lines
// Vertical
if ( ((p.x+divider) > drawingArea.left) && ((p.x+divider)<drawingArea.right) ) {
dc.MoveTo(p.x+divider, p.y);
dc.LineTo(p.x+divider, p.y+((stateEnd-state)+3)*fHeight);
}
// Labels
for(XPosVector::size_type i=0; i<xpos.size(); i++)
dc.TextOut(TPoint(xpos[i].x, p.y), xpos[i].s.c_str());
p.y += fHeight;
// Horizontal
dc.MoveTo(drawingArea.left, p.y + fHeight/2);
dc.LineTo(p.x+xpos.back().x, p.y + fHeight/2);
p.y += fHeight;
//
// Draw each line
while(state <= stateEnd) {
Print_GenerateLine(data, state);
Print_Line(dc, p, xpos, data);
p.y += fHeight;
state++;
}
}
currentPage++;
}
delete[] data;
}
else {
// INSERT>> Normal painting code goes here.
wTabs->InvalidateRect(rect, erase);
}
}
}
//
// Paint routine for Window, Printer, and PrintPreview for a TEdit/TListBox client.
//
void poundsMDIChild::Paint (TDC& dc, BOOL, TRect& rect)
{
poundsApp *theApp = TYPESAFE_DOWNCAST(GetApplication(), poundsApp);
if (theApp) {
// Only paint if we're printing and we have something to paint, otherwise do nothing.
if (theApp->Printing && theApp->Printer && !rect.IsEmpty()) {
// Use pageSize to get the size of the window to render into. For a Window it's the client area,
// for a printer it's the printer DC dimensions and for print preview it's the layout window.
TSize pageSize(rect.right - rect.left, rect.bottom - rect.top);
HFONT hFont = (HFONT)GetClientWindow()->GetWindowFont();
TFont font("Arial", -12);
if (hFont == 0)
dc.SelectObject(font);
else
dc.SelectObject(TFont(hFont));
TEXTMETRIC tm;
int fHeight = (dc.GetTextMetrics(tm) == TRUE) ? tm.tmHeight + tm.tmExternalLeading : 10;
// How many lines of this font can we fit on a page.
int linesPerPage = MulDiv(pageSize.cy, 1, fHeight);
if (linesPerPage) {
TPrintDialog::TData &printerData = theApp->Printer->GetSetup();
int maxPg = 1;
// Get the client class window (this is the contents we're going to print).
TEdit *clientEditWindow /* = 0*/;
TListBox *clientListWindow = 0;
TWindow *clientUnknownWindow = 0;
clientEditWindow = TYPESAFE_DOWNCAST(GetClientWindow(), TEdit);
if (clientEditWindow)
maxPg = ((clientEditWindow->GetNumLines() / linesPerPage) + 1.0);
else {
clientListWindow = TYPESAFE_DOWNCAST(GetClientWindow(), TListBox);
if (clientListWindow)
maxPg = ((clientListWindow->GetCount() / linesPerPage) + 1.0);
else
clientUnknownWindow = TYPESAFE_DOWNCAST(GetClientWindow(), TWindow);
}
// Compute the number of pages to print.
printerData.MinPage = 1;
printerData.MaxPage = maxPg;
// Do the text stuff:
int fromPage = printerData.FromPage == -1 ? 1 : printerData.FromPage;
int toPage = printerData.ToPage == -1 ? 1 : printerData.ToPage;
char buffer[255];
int currentPage = fromPage;
while (currentPage <= toPage) {
int startLine = (currentPage - 1) * linesPerPage;
int lineIdx = 0;
while (lineIdx < linesPerPage) {
// If the string is no longer valid then there's nothing more to display.
if (clientEditWindow) {
if (!clientEditWindow->GetLine(buffer, sizeof(buffer), startLine + lineIdx))
break;
}
else if (clientListWindow) {
if (clientListWindow->GetString(buffer, startLine + lineIdx) < 0)
break;
}
else if (clientUnknownWindow) {
clientUnknownWindow->Paint(dc, FALSE, rect);
break;
}
dc.TabbedTextOut(TPoint(0, lineIdx * fHeight), buffer, lstrlen(buffer), 0, NULL, 0);
lineIdx++;
}
currentPage++;
}
}
}
}
}
// -------------------------------------------------------------------------
void ctkTreeComboBox::resizePopup()
{
// copied from QComboBox.cpp
Q_D(ctkTreeComboBox);
QStyle * const style = this->style();
QWidget* container = qobject_cast<QWidget*>(this->view()->parent());
QStyleOptionComboBox opt;
this->initStyleOption(&opt);
QRect listRect(style->subControlRect(QStyle::CC_ComboBox, &opt,
QStyle::SC_ComboBoxListBoxPopup, this));
QRect screen = QApplication::desktop()->availableGeometry(
QApplication::desktop()->screenNumber(this));
QPoint below = this->mapToGlobal(listRect.bottomLeft());
int belowHeight = screen.bottom() - below.y();
QPoint above = this->mapToGlobal(listRect.topLeft());
int aboveHeight = above.y() - screen.y();
bool boundToScreen = !this->window()->testAttribute(Qt::WA_DontShowOnScreen);
const bool usePopup = style->styleHint(QStyle::SH_ComboBox_Popup, &opt, this);
{
int listHeight = 0;
int count = 0;
QStack<QModelIndex> toCheck;
toCheck.push(this->view()->rootIndex());
#ifndef QT_NO_TREEVIEW
QTreeView *treeView = qobject_cast<QTreeView*>(this->view());
if (treeView && treeView->header() && !treeView->header()->isHidden())
listHeight += treeView->header()->height();
#endif
while (!toCheck.isEmpty())
{
QModelIndex parent = toCheck.pop();
for (int i = 0; i < this->model()->rowCount(parent); ++i)
{
QModelIndex idx = this->model()->index(i, this->modelColumn(), parent);
if (!idx.isValid())
{
continue;
}
listHeight += this->view()->visualRect(idx).height(); /* + container->spacing() */;
#ifndef QT_NO_TREEVIEW
if (this->model()->hasChildren(idx) && treeView && treeView->isExpanded(idx))
{
toCheck.push(idx);
}
#endif
++count;
if (!usePopup && count > this->maxVisibleItems())
{
toCheck.clear();
break;
}
}
}
listRect.setHeight(listHeight);
}
{
// add the spacing for the grid on the top and the bottom;
int heightMargin = 0;//2*container->spacing();
// add the frame of the container
int marginTop, marginBottom;
container->getContentsMargins(0, &marginTop, 0, &marginBottom);
heightMargin += marginTop + marginBottom;
//add the frame of the view
this->view()->getContentsMargins(0, &marginTop, 0, &marginBottom);
//marginTop += static_cast<QAbstractScrollAreaPrivate *>(QObjectPrivate::get(this->view()))->top;
//marginBottom += static_cast<QAbstractScrollAreaPrivate *>(QObjectPrivate::get(this->view()))->bottom;
heightMargin += marginTop + marginBottom;
listRect.setHeight(listRect.height() + heightMargin);
}
// Add space for margin at top and bottom if the style wants it.
if (usePopup)
{
listRect.setHeight(listRect.height() + style->pixelMetric(QStyle::PM_MenuVMargin, &opt, this) * 2);
}
// Make sure the popup is wide enough to display its contents.
if (usePopup)
{
const int diff = d->computeWidthHint() - this->width();
if (diff > 0)
{
listRect.setWidth(listRect.width() + diff);
}
}
//we need to activate the layout to make sure the min/maximum size are set when the widget was not yet show
container->layout()->activate();
//takes account of the minimum/maximum size of the container
listRect.setSize( listRect.size().expandedTo(container->minimumSize())
.boundedTo(container->maximumSize()));
// make sure the widget fits on screen
if (boundToScreen)
{
if (listRect.width() > screen.width() )
{
listRect.setWidth(screen.width());
}
if (this->mapToGlobal(listRect.bottomRight()).x() > screen.right())
{
below.setX(screen.x() + screen.width() - listRect.width());
above.setX(screen.x() + screen.width() - listRect.width());
}
if (this->mapToGlobal(listRect.topLeft()).x() < screen.x() )
{
below.setX(screen.x());
above.setX(screen.x());
}
}
if (usePopup)
{
// Position horizontally.
listRect.moveLeft(above.x());
#ifndef Q_WS_S60
// Position vertically so the curently selected item lines up
// with the combo box.
const QRect currentItemRect = this->view()->visualRect(this->view()->currentIndex());
const int offset = listRect.top() - currentItemRect.top();
listRect.moveTop(above.y() + offset - listRect.top());
#endif
// Clamp the listRect height and vertical position so we don't expand outside the
// available screen geometry.This may override the vertical position, but it is more
// important to show as much as possible of the popup.
const int height = !boundToScreen ? listRect.height() : qMin(listRect.height(), screen.height());
#ifdef Q_WS_S60
//popup needs to be stretched with screen minimum dimension
listRect.setHeight(qMin(screen.height(), screen.width()));
#else
listRect.setHeight(height);
#endif
if (boundToScreen)
{
if (listRect.top() < screen.top())
{
listRect.moveTop(screen.top());
}
if (listRect.bottom() > screen.bottom())
{
listRect.moveBottom(screen.bottom());
}
}
#ifdef Q_WS_S60
if (screen.width() < screen.height())
{
// in portait, menu should be positioned above softkeys
listRect.moveBottom(screen.bottom());
}
else
{
TRect staConTopRect = TRect();
AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EStaconTop, staConTopRect);
listRect.setWidth(listRect.height());
//by default popup is centered on screen in landscape
listRect.moveCenter(screen.center());
if (staConTopRect.IsEmpty())
{
// landscape without stacon, menu should be at the right
(opt.direction == Qt::LeftToRight) ? listRect.setRight(screen.right()) :
listRect.setLeft(screen.left());
}
}
#endif
}
else if (!boundToScreen || listRect.height() <= belowHeight)
{
listRect.moveTopLeft(below);
}
else if (listRect.height() <= aboveHeight)
{
listRect.moveBottomLeft(above);
}
else if (belowHeight >= aboveHeight)
{
listRect.setHeight(belowHeight);
listRect.moveTopLeft(below);
}
else
{
listRect.setHeight(aboveHeight);
listRect.moveBottomLeft(above);
}
#if QT_VERSION < QT_VERSION_CHECK(5,0,0) && !defined QT_NO_IM
if (QInputContext *qic = this->inputContext())
{
qic->reset();
}
#endif
QScrollBar *sb = this->view()->horizontalScrollBar();
Qt::ScrollBarPolicy policy = this->view()->horizontalScrollBarPolicy();
bool needHorizontalScrollBar =
(policy == Qt::ScrollBarAsNeeded || policy == Qt::ScrollBarAlwaysOn)
&& sb->minimum() < sb->maximum();
if (needHorizontalScrollBar)
{
listRect.adjust(0, 0, 0, sb->height());
}
container->setGeometry(listRect);
}