~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

popupWidth += max<int>(0, client()->clientPaddingRight() - client()->clientInsetRight()) + max<int>(0, client()->clientPaddingLeft() - client()->clientInsetLeft());

372

373

// Leave room for the border

374

popupWidth += 2 * popupWindowBorderWidth;

375

popupHeight += 2 * popupWindowBorderWidth;

376

377

// The popup should be at least as wide as the control on the page

378

popupWidth = max(rScreenCoords.width() - client()->clientInsetLeft() - client()->clientInsetRight(), popupWidth);

379

380

// Always left-align items in the popup. This matches popup menus on the mac.

381

int popupX = rScreenCoords.x() + client()->clientInsetLeft();

382

383

IntRect popupRect(popupX, rScreenCoords.maxY(), popupWidth, popupHeight);

384

385

// Check that we don't go off the screen vertically

386

if (popupRect.maxY() > screen.height()) {

387

// The popup will go off the screen, so try placing it above the client

388

if (rScreenCoords.y() - popupRect.height() < 0) {

389

// The popup won't fit above, either, so place it whereever's bigger and resize it to fit

390

if ((rScreenCoords.y() + rScreenCoords.height() / 2) < (screen.height() / 2)) {

391

// Below is bigger

392

popupRect.setHeight(screen.height() - popupRect.y());

393

} else {

394

// Above is bigger

395

popupRect.setY(0);

396

popupRect.setHeight(rScreenCoords.y());

397

}

398

} else {

399

// The popup fits above, so reposition it

400

popupRect.setY(rScreenCoords.y() - popupRect.height());

401

}

402

}

403

404

// Check that we don't go off the screen horizontally

405

if (popupRect.x() + popupRect.width() > screen.width() + screen.x())

406

popupRect.setX(screen.x() + screen.width() - popupRect.width());

407

if (popupRect.x() < screen.x())

408

popupRect.setX(screen.x());

409

410

m_windowRect = popupRect;

411

return;

412

}

413

414

bool PopupMenuWin::setFocusedIndex(int i, bool hotTracking)

415

{

416

if (i < 0 || i >= client()->listSize() || i == focusedIndex())

417

return false;

418

419

if (!client()->itemIsEnabled(i))

420

return false;

421

422

invalidateItem(focusedIndex());

423

invalidateItem(i);

424

425

m_focusedIndex = i;

426

427

if (!hotTracking)

428

client()->setTextFromItem(i);

429

430

if (!scrollToRevealSelection())

431

::UpdateWindow(m_popup);

432

433

return true;

434

}

435

436

int PopupMenuWin::visibleItems() const

437

{

438

return clientRect().height() / m_itemHeight;

439

}

440

441

int PopupMenuWin::listIndexAtPoint(const IntPoint& point) const

442

{

443

return m_scrollOffset + point.y() / m_itemHeight;

444

}

445

446

int PopupMenuWin::focusedIndex() const

447

{

448

return m_focusedIndex;

449

}

450

451

void PopupMenuWin::focusFirst()

452

{

453

if (!client())

454

return;

455

456

int size = client()->listSize();

457

458

for (int i = 0; i < size; ++i)

459

if (client()->itemIsEnabled(i)) {

460

setFocusedIndex(i);

461

break;

462

}

463

}

464

465

void PopupMenuWin::focusLast()

466

{

467

if (!client())

468

return;

469

470

int size = client()->listSize();

471

472

for (int i = size - 1; i > 0; --i)

473

if (client()->itemIsEnabled(i)) {

474

setFocusedIndex(i);

475

break;

476

}

477

}

478

479

bool PopupMenuWin::down(unsigned lines)

480

{

481

if (!client())

482

return false;

483

484

int size = client()->listSize();

485

486

int lastSelectableIndex, selectedListIndex;

487

lastSelectableIndex = selectedListIndex = focusedIndex();

488

for (int i = selectedListIndex + 1; i >= 0 && i < size; ++i)

489

if (client()->itemIsEnabled(i)) {

490

lastSelectableIndex = i;

491

if (i >= selectedListIndex + (int)lines)

492

break;

493

}

494

495

return setFocusedIndex(lastSelectableIndex);

496

}

497

498

bool PopupMenuWin::up(unsigned lines)

499

{

500

if (!client())

501

return false;

502

503

int size = client()->listSize();

504

505

int lastSelectableIndex, selectedListIndex;

506

lastSelectableIndex = selectedListIndex = focusedIndex();

507

for (int i = selectedListIndex - 1; i >= 0 && i < size; --i)

508

if (client()->itemIsEnabled(i)) {

509

lastSelectableIndex = i;

510

if (i <= selectedListIndex - (int)lines)

511

break;

512

}

513

514

return setFocusedIndex(lastSelectableIndex);

515

}

516

517

void PopupMenuWin::invalidateItem(int index)

518

{

519

if (!m_popup)

520

return;

521

522

IntRect damageRect(clientRect());

523

damageRect.setY(m_itemHeight * (index - m_scrollOffset));

524

damageRect.setHeight(m_itemHeight);

525

if (m_scrollbar)

526

damageRect.setWidth(damageRect.width() - m_scrollbar->frameRect().width());

527

528

RECT r = damageRect;

529

::InvalidateRect(m_popup, &r, TRUE);

530

}

531

532

IntRect PopupMenuWin::clientRect() const

533

{

534

IntRect clientRect = m_windowRect;

535

clientRect.inflate(-popupWindowBorderWidth);

536

clientRect.setLocation(IntPoint(0, 0));

537

return clientRect;

538

}

539

540

void PopupMenuWin::incrementWheelDelta(int delta)

541

{

542

m_wheelDelta += delta;

543

}

544

545

void PopupMenuWin::reduceWheelDelta(int delta)

546

{

547

ASSERT(delta >= 0);

548

ASSERT(delta <= abs(m_wheelDelta));

549

550

if (m_wheelDelta > 0)

551

m_wheelDelta -= delta;

552

else if (m_wheelDelta < 0)

553

m_wheelDelta += delta;

554

else

555

return;

556

}

557

558

bool PopupMenuWin::scrollToRevealSelection()

559

{

560

if (!m_scrollbar)

561

return false;

562

563

int index = focusedIndex();

564

565

if (index < m_scrollOffset) {

566

ScrollableArea::scrollToOffsetWithoutAnimation(VerticalScrollbar, index);

567

return true;

568

}

569

570

if (index >= m_scrollOffset + visibleItems()) {

571

ScrollableArea::scrollToOffsetWithoutAnimation(VerticalScrollbar, index - visibleItems() + 1);

572

return true;

573

}

574

575

return false;

576

}

577

578

void PopupMenuWin::updateFromElement()

579

{

580

if (!m_popup)

581

return;

582

583

m_focusedIndex = client()->selectedIndex();

584

585

::InvalidateRect(m_popup, 0, TRUE);

586

if (!scrollToRevealSelection())

587

::UpdateWindow(m_popup);

588

}

589

590

const int separatorPadding = 4;

591

const int separatorHeight = 1;

592

void PopupMenuWin::paint(const IntRect& damageRect, HDC hdc)

593

{

594

if (!m_popup)

595

return;

596

597

if (!m_DC) {

598

m_DC = ::CreateCompatibleDC(HWndDC(m_popup));

599

if (!m_DC)

600

return;

601

}

602

603

if (m_bmp) {

604

bool keepBitmap = false;

605

BITMAP bitmap;

606

if (GetObject(m_bmp, sizeof(bitmap), &bitmap))

607

keepBitmap = bitmap.bmWidth == clientRect().width()

608

&& bitmap.bmHeight == clientRect().height();

609

if (!keepBitmap) {

610

DeleteObject(m_bmp);

611

m_bmp = 0;

612

}

613

}

614

if (!m_bmp) {

615

#if OS(WINCE)

616

BitmapInfo bitmapInfo = BitmapInfo::createBottomUp(clientRect().size(), BitmapInfo::BitCount16);

617

#else

618

BitmapInfo bitmapInfo = BitmapInfo::createBottomUp(clientRect().size());

619

#endif

620

void* pixels = 0;

621

m_bmp = ::CreateDIBSection(m_DC, &bitmapInfo, DIB_RGB_COLORS, &pixels, 0, 0);

622

if (!m_bmp)

623

return;

624

625

::SelectObject(m_DC, m_bmp);

626

}

627

628

GraphicsContext context(m_DC);

629

630

int itemCount = client()->listSize();

631

632

// listRect is the damageRect translated into the coordinates of the entire menu list (which is itemCount * m_itemHeight pixels tall)

633

IntRect listRect = damageRect;

634

listRect.move(IntSize(0, m_scrollOffset * m_itemHeight));

635

636

for (int y = listRect.y(); y < listRect.maxY(); y += m_itemHeight) {

637

int index = y / m_itemHeight;

638

639

Color optionBackgroundColor, optionTextColor;

640

PopupMenuStyle itemStyle = client()->itemStyle(index);

641

if (index == focusedIndex()) {

642

optionBackgroundColor = RenderTheme::defaultTheme()->activeListBoxSelectionBackgroundColor();

643

optionTextColor = RenderTheme::defaultTheme()->activeListBoxSelectionForegroundColor();

644

} else {

645

optionBackgroundColor = itemStyle.backgroundColor();

646

optionTextColor = itemStyle.foregroundColor();

647

}

648

649

// itemRect is in client coordinates

650

IntRect itemRect(0, (index - m_scrollOffset) * m_itemHeight, damageRect.width(), m_itemHeight);

651

652

// Draw the background for this menu item

653

if (itemStyle.isVisible())

654

context.fillRect(itemRect, optionBackgroundColor, ColorSpaceDeviceRGB);

655

656

if (client()->itemIsSeparator(index)) {

657

IntRect separatorRect(itemRect.x() + separatorPadding, itemRect.y() + (itemRect.height() - separatorHeight) / 2, itemRect.width() - 2 * separatorPadding, separatorHeight);

658

context.fillRect(separatorRect, optionTextColor, ColorSpaceDeviceRGB);

659

continue;

660

}

661

662

String itemText = client()->itemText(index);

663

664

TextDirection direction = (itemText.defaultWritingDirection() == WTF::Unicode::RightToLeft) ? RTL : LTR;

665

TextRun textRun(itemText, 0, 0, TextRun::AllowTrailingExpansion, direction);

666

667

context.setFillColor(optionTextColor, ColorSpaceDeviceRGB);

668

669

Font itemFont = client()->menuStyle().font();

670

if (client()->itemIsLabel(index)) {

671

FontDescription d = itemFont.fontDescription();

672

d.setWeight(d.bolderWeight());

673

itemFont = Font(d, itemFont.letterSpacing(), itemFont.wordSpacing());

674

itemFont.update(m_popupClient->fontSelector());

675

}

676

677

// Draw the item text

678

if (itemStyle.isVisible()) {

679

int textX = max<int>(0, client()->clientPaddingLeft() - client()->clientInsetLeft());

680

if (RenderTheme::defaultTheme()->popupOptionSupportsTextIndent() && itemStyle.textDirection() == LTR)

681

textX += minimumIntValueForLength(itemStyle.textIndent(), itemRect.width());

682

int textY = itemRect.y() + itemFont.fontMetrics().ascent() + (itemRect.height() - itemFont.fontMetrics().height()) / 2;

683

context.drawBidiText(itemFont, textRun, IntPoint(textX, textY));

684

}

685

}

686

687

if (m_scrollbar)

688

m_scrollbar->paint(&context, damageRect);

689

690

HWndDC hWndDC;

691

HDC localDC = hdc ? hdc : hWndDC.setHWnd(m_popup);

692

693

::BitBlt(localDC, damageRect.x(), damageRect.y(), damageRect.width(), damageRect.height(), m_DC, damageRect.x(), damageRect.y(), SRCCOPY);

694

}

695

696

int PopupMenuWin::scrollSize(ScrollbarOrientation orientation) const

697

{

698

return ((orientation == VerticalScrollbar) && m_scrollbar) ? (m_scrollbar->totalSize() - m_scrollbar->visibleSize()) : 0;

699

}

700

701

int PopupMenuWin::scrollPosition(Scrollbar*) const

702

{

703

return m_scrollOffset;

704

}

705

706

void PopupMenuWin::setScrollOffset(const IntPoint& offset)

707

{

708

scrollTo(offset.y());

709

}

710

711

void PopupMenuWin::scrollTo(int offset)

712

{

713

ASSERT(m_scrollbar);

714

715

if (!m_popup)

716

return;

717

718

if (m_scrollOffset == offset)

719

return;

720

721

int scrolledLines = m_scrollOffset - offset;

722

m_scrollOffset = offset;

723

724

UINT flags = SW_INVALIDATE;

725

726

#ifdef CAN_SET_SMOOTH_SCROLLING_DURATION

727

BOOL shouldSmoothScroll = FALSE;

728

::SystemParametersInfo(SPI_GETLISTBOXSMOOTHSCROLLING, 0, &shouldSmoothScroll, 0);

729

if (shouldSmoothScroll)

730

flags |= MAKEWORD(SW_SMOOTHSCROLL, smoothScrollAnimationDuration);

731

#endif

732

733

IntRect listRect = clientRect();

734

if (m_scrollbar)

735

listRect.setWidth(listRect.width() - m_scrollbar->frameRect().width());

736

RECT r = listRect;

737

::ScrollWindowEx(m_popup, 0, scrolledLines * m_itemHeight, &r, 0, 0, 0, flags);

738

if (m_scrollbar) {

739

r = m_scrollbar->frameRect();

740

::InvalidateRect(m_popup, &r, TRUE);

741

}

742

::UpdateWindow(m_popup);

743

}

744

745

void PopupMenuWin::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)

746

{

747

IntRect scrollRect = rect;

748

scrollRect.move(scrollbar->x(), scrollbar->y());

749

RECT r = scrollRect;

750

::InvalidateRect(m_popup, &r, false);

751

}

752

753

int PopupMenuWin::visibleHeight() const

754

{

755

return m_scrollbar ? m_scrollbar->visibleSize() : m_windowRect.height();

756

}

757

758

int PopupMenuWin::visibleWidth() const

759

{

760

return m_windowRect.width();

761

}

762

763

IntSize PopupMenuWin::contentsSize() const

764

{

765

return m_windowRect.size();

766

}

767

768

bool PopupMenuWin::scrollbarsCanBeActive() const

769

{

770

return m_showPopup;

771

}

772

773

IntRect PopupMenuWin::scrollableAreaBoundingBox() const

774

{

775

return m_windowRect;

776

}

777

778

void PopupMenuWin::registerClass()

779

{

780

static bool haveRegisteredWindowClass = false;

781

782

if (haveRegisteredWindowClass)

783

return;

784

785

#if OS(WINCE)

786

WNDCLASS wcex;

787

#else

788

WNDCLASSEX wcex;

789

wcex.cbSize = sizeof(WNDCLASSEX);

790

wcex.hIconSm = 0;

791

wcex.style = CS_DROPSHADOW;

792

#endif

793

794

wcex.lpfnWndProc = PopupMenuWndProc;

795

wcex.cbClsExtra = 0;

796

wcex.cbWndExtra = sizeof(PopupMenu*); // For the PopupMenu pointer

797

wcex.hInstance = WebCore::instanceHandle();

798

wcex.hIcon = 0;

799

wcex.hCursor = LoadCursor(0, IDC_ARROW);

800

wcex.hbrBackground = 0;

801

wcex.lpszMenuName = 0;

802

wcex.lpszClassName = kPopupWindowClassName;

803

804

haveRegisteredWindowClass = true;

805

806

#if OS(WINCE)

807

RegisterClass(&wcex);

808

#else

809

RegisterClassEx(&wcex);

810

#endif

811

}

812

813

814

LRESULT CALLBACK PopupMenuWin::PopupMenuWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

815

{

816

if (PopupMenuWin* popup = static_cast<PopupMenuWin*>(getWindowPointer(hWnd, 0)))

817

return popup->wndProc(hWnd, message, wParam, lParam);

818

819

if (message == WM_CREATE) {

820

LPCREATESTRUCT createStruct = reinterpret_cast<LPCREATESTRUCT>(lParam);

821

822

// Associate the PopupMenu with the window.

823

setWindowPointer(hWnd, 0, createStruct->lpCreateParams);

824

return 0;

825

}

826

827

return ::DefWindowProc(hWnd, message, wParam, lParam);

828

}

829

830

const int smoothScrollAnimationDuration = 5000;

831

832

LRESULT PopupMenuWin::wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

833

{

834

LRESULT lResult = 0;

835

836

switch (message) {

837

#if !OS(WINCE)

838

case WM_MOUSEACTIVATE:

839

return MA_NOACTIVATE;

840

#endif

841

case WM_SIZE: {

842

if (!scrollbar())

843

break;

844

845

IntSize size(LOWORD(lParam), HIWORD(lParam));

846

scrollbar()->setFrameRect(IntRect(size.width() - scrollbar()->width(), 0, scrollbar()->width(), size.height()));

847

848

int visibleItems = this->visibleItems();

849

scrollbar()->setEnabled(visibleItems < client()->listSize());

850

scrollbar()->setSteps(1, max(1, visibleItems - 1));

851

scrollbar()->setProportion(visibleItems, client()->listSize());

852

853

break;

854

}

855

case WM_SYSKEYDOWN:

856

case WM_KEYDOWN: {

857

if (!client())

858

break;

859

860

bool altKeyPressed = GetKeyState(VK_MENU) & HIGH_BIT_MASK_SHORT;

861

bool ctrlKeyPressed = GetKeyState(VK_CONTROL) & HIGH_BIT_MASK_SHORT;

862

863

lResult = 0;

864

switch (LOWORD(wParam)) {

865

case VK_F4: {

866

if (!altKeyPressed && !ctrlKeyPressed) {

867

int index = focusedIndex();

868

ASSERT(index >= 0);

869

client()->valueChanged(index);

870

hide();

871

}

872

break;

873

}

874

case VK_DOWN:

875

if (altKeyPressed) {

876

int index = focusedIndex();

877

ASSERT(index >= 0);

878

client()->valueChanged(index);

879

hide();

880

} else

881

down();

882

break;

883

case VK_RIGHT:

884

down();

885

break;

886

case VK_UP:

887

if (altKeyPressed) {

888

int index = focusedIndex();

889

ASSERT(index >= 0);

890

client()->valueChanged(index);

891

hide();

892

} else

893

up();

894

break;

895

case VK_LEFT:

896

up();

897

break;

898

case VK_HOME:

899

focusFirst();

900

break;

901

case VK_END:

902

focusLast();

903

break;

904

case VK_PRIOR:

905

if (focusedIndex() != scrollOffset()) {

906

// Set the selection to the first visible item

907

int firstVisibleItem = scrollOffset();

908

up(focusedIndex() - firstVisibleItem);

909

} else {

910

// The first visible item is selected, so move the selection back one page

911

up(visibleItems());

912

}

913

break;

914

case VK_NEXT: {

915

int lastVisibleItem = scrollOffset() + visibleItems() - 1;

916

if (focusedIndex() != lastVisibleItem) {

917

// Set the selection to the last visible item

918

down(lastVisibleItem - focusedIndex());

919

} else {

920

// The last visible item is selected, so move the selection forward one page

921

down(visibleItems());

922

}

923

break;

924

}

925

case VK_TAB:

926

::SendMessage(client()->hostWindow()->platformPageClient(), message, wParam, lParam);

927

hide();

928

break;

929

case VK_ESCAPE:

930

hide();

931

break;

932

default:

933

if (isASCIIPrintable(wParam))

934

// Send the keydown to the WebView so it can be used for type-to-select.

935

// Since we know that the virtual key is ASCII printable, it's OK to convert this to

936

// a WM_CHAR message. (We don't want to call TranslateMessage because that will post a

937

// WM_CHAR message that will be stolen and redirected to the popup HWND.

938

::PostMessage(m_popup, WM_HOST_WINDOW_CHAR, wParam, lParam);

939

else

940

lResult = 1;

941

break;

942

}

943

break;

944

}

945

case WM_CHAR: {

946

if (!client())

947

break;

948

949

lResult = 0;

950

int index;

951

switch (wParam) {

952

case 0x0D: // Enter/Return

953

hide();

954

index = focusedIndex();

955

ASSERT(index >= 0);

956

client()->valueChanged(index);

957

break;

958

case 0x1B: // Escape

959

hide();

960

break;

961

case 0x09: // TAB

962

case 0x08: // Backspace

963

case 0x0A: // Linefeed

964

default: // Character

965

lResult = 1;

966

break;

967

}

968

break;

969

}

970

case WM_MOUSEMOVE: {

971

IntPoint mousePoint(MAKEPOINTS(lParam));

972

if (scrollbar()) {

973

IntRect scrollBarRect = scrollbar()->frameRect();

974

if (scrollbarCapturingMouse() || scrollBarRect.contains(mousePoint)) {

975

// Put the point into coordinates relative to the scroll bar

976

mousePoint.move(-scrollBarRect.x(), -scrollBarRect.y());

977

PlatformMouseEvent event(hWnd, message, wParam, MAKELPARAM(mousePoint.x(), mousePoint.y()));

978

scrollbar()->mouseMoved(event);

979

break;

980

}

981

}

982

983

BOOL shouldHotTrack = FALSE;

984

#if !OS(WINCE)

985

::SystemParametersInfo(SPI_GETHOTTRACKING, 0, &shouldHotTrack, 0);

986

#endif

987

988

RECT bounds;

989

GetClientRect(popupHandle(), &bounds);

990

if (!::PtInRect(&bounds, mousePoint) && !(wParam & MK_LBUTTON) && client()) {

991

// When the mouse is not inside the popup menu and the left button isn't down, just

992

// repost the message to the web view.

993

994

// Translate the coordinate.

995

translatePoint(lParam, m_popup, client()->hostWindow()->platformPageClient());

996

997

::PostMessage(m_popup, WM_HOST_WINDOW_MOUSEMOVE, wParam, lParam);

998

break;

999

}

1000

1001

if ((shouldHotTrack || wParam & MK_LBUTTON) && ::PtInRect(&bounds, mousePoint))

1002

setFocusedIndex(listIndexAtPoint(mousePoint), true);

1003

1004

break;

1005

}

1006

case WM_LBUTTONDOWN: {

1007

IntPoint mousePoint(MAKEPOINTS(lParam));

1008

if (scrollbar()) {

1009

IntRect scrollBarRect = scrollbar()->frameRect();

1010

if (scrollBarRect.contains(mousePoint)) {

1011

// Put the point into coordinates relative to the scroll bar

1012

mousePoint.move(-scrollBarRect.x(), -scrollBarRect.y());

1013

PlatformMouseEvent event(hWnd, message, wParam, MAKELPARAM(mousePoint.x(), mousePoint.y()));

1014

scrollbar()->mouseDown(event);

1015

setScrollbarCapturingMouse(true);

1016

break;

1017

}

1018

}

1019

1020

// If the mouse is inside the window, update the focused index. Otherwise,

1021

// hide the popup.

1022

RECT bounds;

1023

GetClientRect(m_popup, &bounds);

1024

if (::PtInRect(&bounds, mousePoint))

1025

setFocusedIndex(listIndexAtPoint(mousePoint), true);

1026

else

1027

hide();

1028

break;

1029

}

1030

case WM_LBUTTONUP: {

1031

IntPoint mousePoint(MAKEPOINTS(lParam));

1032

if (scrollbar()) {

1033

IntRect scrollBarRect = scrollbar()->frameRect();

1034

if (scrollbarCapturingMouse() || scrollBarRect.contains(mousePoint)) {

1035

setScrollbarCapturingMouse(false);

1036

// Put the point into coordinates relative to the scroll bar

1037

mousePoint.move(-scrollBarRect.x(), -scrollBarRect.y());

1038

PlatformMouseEvent event(hWnd, message, wParam, MAKELPARAM(mousePoint.x(), mousePoint.y()));

1039

scrollbar()->mouseUp(event);

1040

// FIXME: This is a hack to work around Scrollbar not invalidating correctly when it doesn't have a parent widget

1041

RECT r = scrollBarRect;

1042

::InvalidateRect(popupHandle(), &r, TRUE);

1043

break;

1044

}

1045

}

1046

// Only hide the popup if the mouse is inside the popup window.

1047

RECT bounds;

1048

GetClientRect(popupHandle(), &bounds);

1049

if (client() && ::PtInRect(&bounds, mousePoint)) {

1050

hide();

1051

int index = focusedIndex();

1052

if (index >= 0)

1053

client()->valueChanged(index);

1054

}

1055

break;

1056

}

1057

1058

case WM_MOUSEWHEEL: {

1059

if (!scrollbar())

1060

break;

1061

1062

int i = 0;

1063

for (incrementWheelDelta(GET_WHEEL_DELTA_WPARAM(wParam)); abs(wheelDelta()) >= WHEEL_DELTA; reduceWheelDelta(WHEEL_DELTA)) {

1064

if (wheelDelta() > 0)

1065

++i;

1066

else

1067

--i;

1068

}

1069

1070

ScrollableArea::scroll(i > 0 ? ScrollUp : ScrollDown, ScrollByLine, abs(i));

1071

break;

1072

}

1073

1074

case WM_PAINT: {

1075

PAINTSTRUCT paintInfo;

1076

::BeginPaint(popupHandle(), &paintInfo);

1077

paint(paintInfo.rcPaint, paintInfo.hdc);

1078

::EndPaint(popupHandle(), &paintInfo);

1079

lResult = 0;

1080

break;

1081

}

1082

#if !OS(WINCE)

1083

case WM_PRINTCLIENT:

1084

paint(clientRect(), (HDC)wParam);

1085

break;

1086

#endif

1087

default:

1088

lResult = DefWindowProc(hWnd, message, wParam, lParam);

1089

}

1090

1091

return lResult;

1092

}

1093

1094

}

Older »