1 /*
   2  * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #include "awt_Toolkit.h"
  27 #include "awt_TextArea.h"
  28 #include "awt_TextComponent.h"
  29 #include "awt_Canvas.h"
  30 #include "awt_Window.h"
  31 #include "awt_Frame.h"
  32 
  33 /* IMPORTANT! Read the README.JNI file for notes on JNI converted AWT code.
  34  */
  35 
  36 /***********************************************************************/
  37 // Struct for _ReplaceText() method
  38 struct ReplaceTextStruct {
  39   jobject textComponent;
  40   jstring text;
  41   int start, end;
  42 };
  43 
  44 /************************************************************************
  45  * AwtTextArea fields
  46  */
  47 
  48 jfieldID AwtTextArea::scrollbarVisibilityID;
  49 
  50 WNDPROC AwtTextArea::sm_pDefWindowProc = NULL;
  51 
  52 /************************************************************************
  53  * AwtTextArea methods
  54  */
  55 
  56 AwtTextArea::AwtTextArea() {
  57     m_bIgnoreEnChange = FALSE;
  58     m_bCanUndo        = FALSE;
  59     m_hEditCtrl       = NULL;
  60     m_lHDeltaAccum    = 0;
  61     m_lVDeltaAccum    = 0;
  62 }
  63 
  64 AwtTextArea::~AwtTextArea()
  65 {
  66 }
  67 
  68 void AwtTextArea::Dispose()
  69 {
  70     if (m_hEditCtrl != NULL) {
  71         VERIFY(::DestroyWindow(m_hEditCtrl));
  72         m_hEditCtrl = NULL;
  73     }
  74     AwtTextComponent::Dispose();
  75 }
  76 
  77 /* Create a new AwtTextArea object and window.   */
  78 AwtTextArea* AwtTextArea::Create(jobject peer, jobject parent)
  79 {
  80     return (AwtTextArea*) AwtTextComponent::Create(peer, parent, true);
  81 }
  82 
  83 void AwtTextArea::EditSetSel(CHARRANGE &cr) {
  84     // Fix for 5003402: added restoring/hiding selection to enable automatic scrolling
  85     SendMessage(EM_HIDESELECTION, FALSE, TRUE);
  86     SendMessage(EM_EXSETSEL, 0, reinterpret_cast<LPARAM>(&cr));
  87     SendMessage(EM_HIDESELECTION, TRUE, TRUE);
  88     // 6417581: force expected drawing
  89     if (IS_WINVISTA && cr.cpMin == cr.cpMax) {
  90         ::InvalidateRect(GetHWnd(), NULL, TRUE);
  91     }
  92 }
  93 
  94 void AwtTextArea::EditGetSel(CHARRANGE &cr) {
  95     SendMessage(EM_EXGETSEL, 0, reinterpret_cast<LPARAM>(&cr));
  96 }
  97 
  98 /* Count how many '\n's are there in jStr */
  99 size_t AwtTextArea::CountNewLines(JNIEnv *env, jstring jStr, size_t maxlen)
 100 {
 101     size_t nNewlines = 0;
 102 
 103     if (jStr == NULL) {
 104         return nNewlines;
 105     }
 106     /*
 107      * Fix for BugTraq Id 4260109.
 108      * Don't use TO_WSTRING since it allocates memory on the stack
 109      * causing stack overflow when the text is very long.
 110      */
 111     size_t length = env->GetStringLength(jStr) + 1;
 112     WCHAR *string = new WCHAR[length];
 113     env->GetStringRegion(jStr, 0, static_cast<jsize>(length - 1), reinterpret_cast<jchar*>(string));
 114     string[length-1] = '\0';
 115     for (size_t i = 0; i < maxlen && i < length - 1; i++) {
 116         if (string[i] == L'\n') {
 117             nNewlines++;
 118         }
 119     }
 120     delete[] string;
 121     return nNewlines;
 122 }
 123 
 124 BOOL AwtTextArea::InheritsNativeMouseWheelBehavior() {return true;}
 125 
 126 
 127 LRESULT
 128 AwtTextArea::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) {
 129 
 130     LRESULT retValue = 0;
 131     MsgRouting mr = mrDoDefault;
 132 
 133     switch (message) {
 134         case WM_PRINTCLIENT:
 135           {
 136             FORMATRANGE fr;
 137             HDC hPrinterDC = (HDC)wParam;
 138             int nHorizRes = ::GetDeviceCaps(hPrinterDC, HORZRES);
 139             int nVertRes = ::GetDeviceCaps(hPrinterDC, VERTRES);
 140             int nLogPixelsX = ::GetDeviceCaps(hPrinterDC, LOGPIXELSX);
 141             int nLogPixelsY = ::GetDeviceCaps(hPrinterDC, LOGPIXELSY);
 142 
 143             // Ensure the printer DC is in MM_TEXT mode.
 144             ::SetMapMode ( hPrinterDC, MM_TEXT );
 145 
 146             // Rendering to the same DC we are measuring.
 147             ::ZeroMemory(&fr, sizeof(fr));
 148             fr.hdc = fr.hdcTarget = hPrinterDC;
 149             // Set up the page.
 150             fr.rcPage.left     = fr.rcPage.top = 0;
 151             fr.rcPage.right    = (nHorizRes/nLogPixelsX) * 1440; // in twips
 152             fr.rcPage.bottom   = (nVertRes/nLogPixelsY) * 1440;
 153             fr.rc.left   = fr.rcPage.left;
 154             fr.rc.top    = fr.rcPage.top;
 155             fr.rc.right  = fr.rcPage.right;
 156             fr.rc.bottom = fr.rcPage.bottom;
 157 
 158             // start printing from the first visible line
 159             LRESULT nLine = SendMessage(EM_GETFIRSTVISIBLELINE, 0, 0);
 160             LONG startCh = static_cast<LONG>(SendMessage(EM_LINEINDEX,
 161                                                          (WPARAM)nLine, 0));
 162             fr.chrg.cpMin = startCh;
 163             fr.chrg.cpMax = -1;
 164 
 165             SendMessage(EM_FORMATRANGE, TRUE, (LPARAM)&fr);
 166           }
 167 
 168         break;
 169     case EM_SETCHARFORMAT:
 170     case WM_SETFONT:
 171         SetIgnoreEnChange(TRUE);
 172         break;
 173     }
 174 
 175     retValue = AwtComponent::WindowProc(message, wParam, lParam);
 176 
 177     switch (message) {
 178     case EM_SETCHARFORMAT:
 179     case WM_SETFONT:
 180         SetIgnoreEnChange(FALSE);
 181         break;
 182     }
 183 
 184     return retValue;
 185 }
 186 
 187 /*
 188  * This routine is a window procedure for the subclass of the standard edit control
 189  * used to generate context menu. RichEdit controls don't have built-in context menu.
 190  * To implement this functionality we have to create an invisible edit control and
 191  * forward WM_CONTEXTMENU messages from a RichEdit control to this helper edit control.
 192  * While the edit control context menu is active we intercept the message generated in
 193  * response to particular item selection and forward it back to the RichEdit control.
 194  * (See AwtTextArea::WmContextMenu for more details).
 195  */
 196 LRESULT
 197 AwtTextArea::EditProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
 198 
 199     static BOOL bContextMenuActive = FALSE;
 200 
 201     LRESULT retValue = 0;
 202     MsgRouting mr = mrDoDefault;
 203 
 204     DASSERT(::IsWindow(::GetParent(hWnd)));
 205 
 206     switch (message) {
 207     case WM_UNDO:
 208     case WM_CUT:
 209     case WM_COPY:
 210     case WM_PASTE:
 211     case WM_CLEAR:
 212     case EM_SETSEL:
 213         if (bContextMenuActive) {
 214             ::SendMessage(::GetParent(hWnd), message, wParam, lParam);
 215             mr = mrConsume;
 216         }
 217         break;
 218     case WM_CONTEXTMENU:
 219         bContextMenuActive = TRUE;
 220         break;
 221     }
 222 
 223     if (mr == mrDoDefault) {
 224         DASSERT(sm_pDefWindowProc != NULL);
 225         retValue = ::CallWindowProc(sm_pDefWindowProc,
 226                                     hWnd, message, wParam, lParam);
 227     }
 228 
 229     if (message == WM_CONTEXTMENU) {
 230         bContextMenuActive = FALSE;
 231     }
 232 
 233     return retValue;
 234 }
 235 
 236 MsgRouting
 237 AwtTextArea::WmContextMenu(HWND hCtrl, UINT xPos, UINT yPos) {
 238     /* Use the system provided edit control class to generate context menu. */
 239     if (m_hEditCtrl == NULL) {
 240         DWORD dwStyle = WS_CHILD;
 241         DWORD dwExStyle = 0;
 242         m_hEditCtrl = ::CreateWindowEx(dwExStyle,
 243                                         L"EDIT",
 244                                         L"TEXT",
 245                                         dwStyle,
 246                                         0, 0, 0, 0,
 247                                         GetHWnd(),
 248                                         reinterpret_cast<HMENU>(
 249                                          static_cast<INT_PTR>(
 250                                              CreateControlID())),
 251                                         AwtToolkit::GetInstance().GetModuleHandle(),
 252                                         NULL);
 253         DASSERT(m_hEditCtrl != NULL);
 254         if (sm_pDefWindowProc == NULL) {
 255             sm_pDefWindowProc = (WNDPROC)::GetWindowLongPtr(m_hEditCtrl,
 256                                                          GWLP_WNDPROC);
 257         }
 258         ::SetLastError(0);
 259         INT_PTR ret = ::SetWindowLongPtr(m_hEditCtrl, GWLP_WNDPROC,
 260                                    (INT_PTR)AwtTextArea::EditProc);
 261         DASSERT(ret != 0 || ::GetLastError() == 0);
 262     }
 263 
 264     /*
 265      * Tricks on the edit control to ensure that its context menu has
 266      * the correct set of enabled items according to the RichEdit state.
 267      */
 268     ::SetWindowText(m_hEditCtrl, TEXT("TEXT"));
 269 
 270     if (m_bCanUndo == TRUE && SendMessage(EM_CANUNDO)) {
 271         /* Enable 'Undo' item. */
 272         ::SendMessage(m_hEditCtrl, WM_CHAR, 'A', 0);
 273     }
 274 
 275     {
 276         /*
 277          * Initial selection for the edit control - (0,1).
 278          * This enables 'Cut', 'Copy' and 'Delete' and 'Select All'.
 279          */
 280         INT nStart = 0;
 281         INT nEnd = 1;
 282         if (SendMessage(EM_SELECTIONTYPE) == SEL_EMPTY) {
 283             /*
 284              * RichEdit selection is empty - clear selection of the edit control.
 285              * This disables 'Cut', 'Copy' and 'Delete'.
 286              */
 287             nStart = -1;
 288             nEnd = 0;
 289         } else {
 290 
 291             CHARRANGE cr;
 292             EditGetSel(cr);
 293             /* Check if all the text is selected. */
 294             if (cr.cpMin == 0) {
 295 
 296                 int len = ::GetWindowTextLength(GetHWnd());
 297                 if (cr.cpMin == 0 && cr.cpMax >= len) {
 298                     /*
 299                      * All the text is selected in RichEdit - select all the
 300                      * text in the edit control. This disables 'Select All'.
 301                      */
 302                     nStart = 0;
 303                     nEnd = -1;
 304                 }
 305             }
 306         }
 307         ::SendMessage(m_hEditCtrl, EM_SETSEL, (WPARAM)nStart, (LPARAM)nEnd);
 308     }
 309 
 310     /* Disable 'Paste' item if the RichEdit control is read-only. */
 311     ::SendMessage(m_hEditCtrl, EM_SETREADONLY,
 312                   GetStyle() & ES_READONLY ? TRUE : FALSE, 0);
 313 
 314     POINT p;
 315     p.x = xPos;
 316     p.y = yPos;
 317 
 318     /*
 319      * If the context menu is requested with SHIFT+F10 or VK_APPS key,
 320      * we position its top left corner to the center of the RichEdit
 321      * client rect.
 322      */
 323     if (p.x == -1 && p.y == -1) {
 324         RECT r;
 325         VERIFY(::GetClientRect(GetHWnd(), &r));
 326         p.x = (r.left + r.right) / 2;
 327         p.y = (r.top + r.bottom) / 2;
 328         VERIFY(::ClientToScreen(GetHWnd(), &p));
 329     }
 330 
 331     // The context menu steals focus from the proxy.
 332     // So, set the focus-restore flag up.
 333     SetRestoreFocus(TRUE);
 334     ::SendMessage(m_hEditCtrl, WM_CONTEXTMENU, (WPARAM)m_hEditCtrl, MAKELPARAM(p.x, p.y));
 335     SetRestoreFocus(FALSE);
 336 
 337     return mrConsume;
 338 }
 339 
 340 MsgRouting
 341 AwtTextArea::WmNcHitTest(UINT x, UINT y, LRESULT& retVal)
 342 {
 343     if (::IsWindow(AwtWindow::GetModalBlocker(AwtComponent::GetTopLevelParentForWindow(GetHWnd())))) {
 344         retVal = HTCLIENT;
 345         return mrConsume;
 346     }
 347     return AwtTextComponent::WmNcHitTest(x, y, retVal);
 348 }
 349 
 350 
 351 MsgRouting
 352 AwtTextArea::WmNotify(UINT notifyCode)
 353 {
 354     if (notifyCode == EN_CHANGE) {
 355         /*
 356          * Ignore notifications if the text hasn't been changed.
 357          * EN_CHANGE sent on character formatting changes as well.
 358          */
 359         if (m_bIgnoreEnChange == FALSE) {
 360             m_bCanUndo = TRUE;
 361             DoCallback("valueChanged", "()V");
 362         } else {
 363             m_bCanUndo = FALSE;
 364         }
 365     }
 366     return mrDoDefault;
 367 }
 368 
 369 MsgRouting
 370 AwtTextArea::HandleEvent(MSG *msg, BOOL synthetic)
 371 {
 372     MsgRouting returnVal;
 373     /*
 374      * RichEdit 1.0 control starts internal message loop if the
 375      * left mouse button is pressed while the cursor is not over
 376      * the current selection or the current selection is empty.
 377      * Because of this we don't receive WM_MOUSEMOVE messages
 378      * while the left mouse button is pressed. To work around
 379      * this behavior we process the relevant mouse messages
 380      * by ourselves.
 381      * By consuming WM_MOUSEMOVE messages we also don't give
 382      * the RichEdit control a chance to recognize a drag gesture
 383      * and initiate its own drag-n-drop operation.
 384      *
 385      * The workaround also allows us to implement synthetic focus mechanism.
 386      *
 387      */
 388     if (IsFocusingMouseMessage(msg)) {
 389         CHARRANGE cr;
 390 
 391         LONG lCurPos = EditGetCharFromPos(msg->pt);
 392 
 393         EditGetSel(cr);
 394         /*
 395          * NOTE: Plain EDIT control always clears selection on mouse
 396          * button press. We are clearing the current selection only if
 397          * the mouse pointer is not over the selected region.
 398          * In this case we sacrifice backward compatibility
 399          * to allow dnd of the current selection.
 400          */
 401         if (lCurPos < cr.cpMin || cr.cpMax <= lCurPos) {
 402             if (msg->message == WM_LBUTTONDBLCLK) {
 403                 SetStartSelectionPos(static_cast<LONG>(SendMessage(
 404                     EM_FINDWORDBREAK, WB_MOVEWORDLEFT, lCurPos)));
 405                 SetEndSelectionPos(static_cast<LONG>(SendMessage(
 406                     EM_FINDWORDBREAK, WB_MOVEWORDRIGHT, lCurPos)));
 407             } else {
 408                 SetStartSelectionPos(lCurPos);
 409                 SetEndSelectionPos(lCurPos);
 410             }
 411             cr.cpMin = GetStartSelectionPos();
 412             cr.cpMax = GetEndSelectionPos();
 413             EditSetSel(cr);
 414         }
 415 
 416         delete msg;
 417         return mrConsume;
 418     } else if (msg->message == WM_LBUTTONUP) {
 419 
 420         /*
 421          * If the left mouse button is pressed on the selected region
 422          * we don't clear the current selection. We clear it on button
 423          * release instead. This is to allow dnd of the current selection.
 424          */
 425         if (GetStartSelectionPos() == -1 && GetEndSelectionPos() == -1) {
 426             CHARRANGE cr;
 427 
 428             LONG lCurPos = EditGetCharFromPos(msg->pt);
 429 
 430             cr.cpMin = lCurPos;
 431             cr.cpMax = lCurPos;
 432             EditSetSel(cr);
 433         }
 434 
 435         /*
 436          * Cleanup the state variables when left mouse button is released.
 437          * These state variables are designed to reflect the selection state
 438          * while the left mouse button is pressed and be set to -1 otherwise.
 439          */
 440         SetStartSelectionPos(-1);
 441         SetEndSelectionPos(-1);
 442         SetLastSelectionPos(-1);
 443 
 444         delete msg;
 445         return mrConsume;
 446     } else if (msg->message == WM_MOUSEMOVE && (msg->wParam & MK_LBUTTON)) {
 447 
 448         /*
 449          * We consume WM_MOUSEMOVE while the left mouse button is pressed,
 450          * so we have to simulate autoscrolling when mouse is moved outside
 451          * of the client area.
 452          */
 453         POINT p;
 454         RECT r;
 455         BOOL bScrollLeft = FALSE;
 456         BOOL bScrollRight = FALSE;
 457         BOOL bScrollUp = FALSE;
 458         BOOL bScrollDown = FALSE;
 459 
 460         p.x = msg->pt.x;
 461         p.y = msg->pt.y;
 462         VERIFY(::GetClientRect(GetHWnd(), &r));
 463 
 464         if (p.x < 0) {
 465             bScrollLeft = TRUE;
 466             p.x = 0;
 467         } else if (p.x > r.right) {
 468             bScrollRight = TRUE;
 469             p.x = r.right - 1;
 470         }
 471         if (p.y < 0) {
 472             bScrollUp = TRUE;
 473             p.y = 0;
 474         } else if (p.y > r.bottom) {
 475             bScrollDown = TRUE;
 476             p.y = r.bottom - 1;
 477         }
 478 
 479         LONG lCurPos = EditGetCharFromPos(p);
 480 
 481         if (GetStartSelectionPos() != -1 &&
 482             GetEndSelectionPos() != -1 &&
 483             lCurPos != GetLastSelectionPos()) {
 484 
 485             CHARRANGE cr;
 486 
 487             SetLastSelectionPos(lCurPos);
 488 
 489             cr.cpMin = GetStartSelectionPos();
 490             cr.cpMax = GetLastSelectionPos();
 491 
 492             EditSetSel(cr);
 493         }
 494 
 495         if (bScrollLeft == TRUE || bScrollRight == TRUE) {
 496             SCROLLINFO si;
 497             memset(&si, 0, sizeof(si));
 498             si.cbSize = sizeof(si);
 499             si.fMask = SIF_PAGE | SIF_POS | SIF_RANGE;
 500 
 501             VERIFY(::GetScrollInfo(GetHWnd(), SB_HORZ, &si));
 502             if (bScrollLeft == TRUE) {
 503                 si.nPos = si.nPos - si.nPage / 2;
 504                 si.nPos = max(si.nMin, si.nPos);
 505             } else if (bScrollRight == TRUE) {
 506                 si.nPos = si.nPos + si.nPage / 2;
 507                 si.nPos = min(si.nPos, si.nMax);
 508             }
 509             /*
 510              * Okay to use 16-bit position since RichEdit control adjusts
 511              * its scrollbars so that their range is always 16-bit.
 512              */
 513             DASSERT(abs(si.nPos) < 0x8000);
 514             SendMessage(WM_HSCROLL,
 515                         MAKEWPARAM(SB_THUMBPOSITION, LOWORD(si.nPos)));
 516         }
 517         if (bScrollUp == TRUE) {
 518             SendMessage(EM_LINESCROLL, 0, -1);
 519         } else if (bScrollDown == TRUE) {
 520             SendMessage(EM_LINESCROLL, 0, 1);
 521         }
 522         delete msg;
 523         return mrConsume;
 524     } else if (msg->message == WM_RBUTTONUP ||
 525                (msg->message == WM_SYSKEYDOWN && msg->wParam == VK_F10 &&
 526                 HIBYTE(::GetKeyState(VK_SHIFT)))) {
 527         POINT p;
 528         if (msg->message == WM_RBUTTONUP) {
 529             VERIFY(::GetCursorPos(&p));
 530         } else {
 531             p.x = -1;
 532             p.y = -1;
 533         }
 534 
 535         if (!::PostMessage(GetHWnd(), WM_CONTEXTMENU, (WPARAM)GetHWnd(),
 536                            MAKELPARAM(p.x, p.y))) {
 537             JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 538             JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
 539             env->ExceptionDescribe();
 540             env->ExceptionClear();
 541         }
 542         delete msg;
 543         return mrConsume;
 544     } else if (msg->message == WM_MOUSEWHEEL) {
 545         // 4417236: If there is an old version of RichEd32.dll which
 546         // does not provide the mouse wheel scrolling we have to
 547         // interpret WM_MOUSEWHEEL as a sequence of scroll messages.
 548         // kdm@sparc.spb.su
 549         UINT platfScrollLines = 3;
 550         // Retrieve a number of scroll lines.
 551         ::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
 552                                &platfScrollLines, 0);
 553 
 554         if (platfScrollLines > 0) {
 555             HWND hWnd = GetHWnd();
 556             LONG styles = ::GetWindowLong(hWnd, GWL_STYLE);
 557 
 558             RECT rect;
 559             // rect.left and rect.top are zero.
 560             // rect.right and rect.bottom contain the width and height
 561             VERIFY(::GetClientRect(hWnd, &rect));
 562 
 563             // calculate a number of visible lines
 564             TEXTMETRIC tm;
 565             HDC hDC = ::GetDC(hWnd);
 566             DASSERT(hDC != NULL);
 567             VERIFY(::GetTextMetrics(hDC, &tm));
 568             VERIFY(::ReleaseDC(hWnd, hDC));
 569             LONG visibleLines = rect.bottom / tm.tmHeight + 1;
 570 
 571             LONG lineCount = static_cast<LONG>(::SendMessage(hWnd,
 572                 EM_GETLINECOUNT, 0, 0));
 573             BOOL sb_vert_disabled = (styles & WS_VSCROLL) == 0
 574               || (lineCount <= visibleLines);
 575 
 576             LONG *delta_accum = &m_lVDeltaAccum;
 577             UINT wm_msg = WM_VSCROLL;
 578             int sb_type = SB_VERT;
 579 
 580             if (sb_vert_disabled && (styles & WS_HSCROLL)) {
 581                 delta_accum = &m_lHDeltaAccum;
 582                 wm_msg = WM_HSCROLL;
 583                 sb_type = SB_HORZ;
 584             }
 585 
 586             int delta = (short) HIWORD(msg->wParam);
 587             *delta_accum += delta;
 588             if (abs(*delta_accum) >= WHEEL_DELTA) {
 589                 if (platfScrollLines == WHEEL_PAGESCROLL) {
 590                     // Synthesize a page down or a page up message.
 591                     ::SendMessage(hWnd, wm_msg,
 592                                   (delta > 0) ? SB_PAGEUP : SB_PAGEDOWN, 0);
 593                     *delta_accum = 0;
 594                 } else {
 595                     // We provide a friendly behavior of text scrolling.
 596                     // During of scrolling the text can be out of the client
 597                     // area's boundary. Here we try to prevent this behavior.
 598                     SCROLLINFO si;
 599                     ::ZeroMemory(&si, sizeof(si));
 600                     si.cbSize = sizeof(SCROLLINFO);
 601                     si.fMask = SIF_POS | SIF_RANGE | SIF_PAGE;
 602                     int actualScrollLines =
 603                         abs((int)(platfScrollLines * (*delta_accum / WHEEL_DELTA)));
 604                     for (int i = 0; i < actualScrollLines; i++) {
 605                         if (::GetScrollInfo(hWnd, sb_type, &si)) {
 606                             if ((wm_msg == WM_VSCROLL)
 607                                 && ((*delta_accum < 0
 608                                      && si.nPos >= (si.nMax - (int) si.nPage))
 609                                     || (*delta_accum > 0
 610                                         && si.nPos <= si.nMin))) {
 611                                 break;
 612                             }
 613                         }
 614                         // Here we don't send EM_LINESCROLL or EM_SCROLL
 615                         // messages to rich edit because it doesn't
 616                         // provide horizontal scrolling.
 617                         // So it's only possible to scroll by 1 line
 618                         // at a time to prevent scrolling when the
 619                         // scrollbar thumb reaches its boundary position.
 620                         ::SendMessage(hWnd, wm_msg,
 621                             (*delta_accum>0) ? SB_LINEUP : SB_LINEDOWN, 0);
 622                     }
 623                     *delta_accum %= WHEEL_DELTA;
 624                 }
 625             } else {
 626                 *delta_accum = 0;
 627             }
 628         }
 629         delete msg;
 630         return mrConsume;
 631         // 4417236: end of fix
 632     }
 633 
 634     /*
 635      * Store the 'synthetic' parameter so that the WM_PASTE security check
 636      * happens only for synthetic events.
 637      */
 638     m_synthetic = synthetic;
 639     returnVal = AwtComponent::HandleEvent(msg, synthetic);
 640     m_synthetic = FALSE;
 641 
 642     return returnVal;
 643 }
 644 
 645 
 646 /* Fix for 4776535, 4648702
 647  * If width is 0 or 1 Windows hides the horizontal scroll bar even
 648  * if the WS_HSCROLL style is set. It is a bug in Windows.
 649  * As a workaround we should set an initial width to 2.
 650  * kdm@sparc.spb.su
 651  */
 652 void AwtTextArea::Reshape(int x, int y, int w, int h)
 653 {
 654     if (w < 2) {
 655         w = 2;
 656     }
 657     AwtTextComponent::Reshape(x, y, w, h);
 658 }
 659 
 660 LONG AwtTextArea::getJavaSelPos(LONG orgPos)
 661 {
 662     long wlen;
 663     long pos = orgPos;
 664     long cur = 0;
 665     long retval = 0;
 666     LPTSTR wbuf;
 667 
 668     if ((wlen = GetTextLength()) == 0)
 669         return 0;
 670     wbuf = new TCHAR[wlen + 1];
 671     GetText(wbuf, wlen + 1);
 672     if (m_isLFonly == TRUE) {
 673         wlen = RemoveCR(wbuf);
 674     }
 675 
 676     while (cur < pos && cur < wlen) {
 677         if (wbuf[cur] == _T('\r') && wbuf[cur + 1] == _T('\n')) {
 678             pos++;
 679         }
 680         cur++;
 681         retval++;
 682     }
 683     delete[] wbuf;
 684     return retval;
 685 }
 686 
 687 LONG AwtTextArea::getWin32SelPos(LONG orgPos)
 688 {
 689     if (GetTextLength() == 0)
 690        return 0;
 691     return orgPos;
 692 }
 693 
 694 void AwtTextArea::SetSelRange(LONG start, LONG end)
 695 {
 696     CHARRANGE cr;
 697     cr.cpMin = getWin32SelPos(start);
 698     cr.cpMax = getWin32SelPos(end);
 699     EditSetSel(cr);
 700 }
 701 
 702 
 703 void AwtTextArea::_ReplaceText(void *param)
 704 {
 705     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 706 
 707     ReplaceTextStruct *rts = (ReplaceTextStruct *)param;
 708 
 709     jobject textComponent = rts->textComponent;
 710     jstring text = rts->text;
 711     jint start = rts->start;
 712     jint end = rts->end;
 713 
 714     AwtTextComponent *c = NULL;
 715 
 716     PDATA pData;
 717     JNI_CHECK_PEER_GOTO(textComponent, done);
 718     JNI_CHECK_NULL_GOTO(text, "null string", done);
 719 
 720     c = (AwtTextComponent *)pData;
 721     if (::IsWindow(c->GetHWnd()))
 722     {
 723       jsize length = env->GetStringLength(text) + 1;
 724       // Bugid 4141477 - Can't use TO_WSTRING here because it uses alloca
 725       // WCHAR* buffer = TO_WSTRING(text);
 726       TCHAR *buffer = new TCHAR[length];
 727       env->GetStringRegion(text, 0, length-1, reinterpret_cast<jchar*>(buffer));
 728       buffer[length-1] = '\0';
 729 
 730       c->CheckLineSeparator(buffer);
 731       c->RemoveCR(buffer);
 732       // Fix for 5003402: added restoring/hiding selection to enable automatic scrolling
 733       c->SendMessage(EM_HIDESELECTION, FALSE, TRUE);
 734       c->SendMessage(EM_SETSEL, start, end);
 735       c->SendMessage(EM_REPLACESEL, FALSE, (LPARAM)buffer);
 736       c->SendMessage(EM_HIDESELECTION, TRUE, TRUE);
 737 
 738       delete[] buffer;
 739     }
 740 
 741 done:
 742     env->DeleteGlobalRef(textComponent);
 743     env->DeleteGlobalRef(text);
 744 
 745     delete rts;
 746 }
 747 
 748 
 749 /************************************************************************
 750  * TextArea native methods
 751  */
 752 
 753 extern "C" {
 754 
 755 /*
 756  * Class:     java_awt_TextArea
 757  * Method:    initIDs
 758  * Signature: ()V
 759  */
 760 JNIEXPORT void JNICALL
 761 Java_java_awt_TextArea_initIDs(JNIEnv *env, jclass cls)
 762 {
 763     TRY;
 764 
 765     AwtTextArea::scrollbarVisibilityID =
 766         env->GetFieldID(cls, "scrollbarVisibility", "I");
 767 
 768     DASSERT(AwtTextArea::scrollbarVisibilityID != NULL);
 769 
 770     CATCH_BAD_ALLOC;
 771 }
 772 
 773 } /* extern "C" */
 774 
 775 
 776 /************************************************************************
 777  * WTextAreaPeer native methods
 778  */
 779 
 780 extern "C" {
 781 
 782 /*
 783  * Class:     sun_awt_windows_WTextAreaPeer
 784  * Method:    create
 785  * Signature: (Lsun/awt/windows/WComponentPeer;)V
 786  */
 787 JNIEXPORT void JNICALL
 788 Java_sun_awt_windows_WTextAreaPeer_create(JNIEnv *env, jobject self,
 789                                           jobject parent)
 790 {
 791     TRY;
 792 
 793     PDATA pData;
 794     JNI_CHECK_PEER_RETURN(parent);
 795     AwtToolkit::CreateComponent(self, parent,
 796                                 (AwtToolkit::ComponentFactory)
 797                                 AwtTextArea::Create);
 798     JNI_CHECK_PEER_CREATION_RETURN(self);
 799 
 800     CATCH_BAD_ALLOC;
 801 }
 802 
 803 /*
 804  * Class:     sun_awt_windows_WTextAreaPeer
 805  * Method:    replaceText
 806  * Signature: (Ljava/lang/String;II)V
 807  */
 808 JNIEXPORT void JNICALL
 809 Java_sun_awt_windows_WTextAreaPeer_replaceText(JNIEnv *env, jobject self,
 810                                                jstring text,
 811                                                jint start, jint end)
 812 {
 813     TRY;
 814 
 815     jobject selfGlobalRef = env->NewGlobalRef(self);
 816     jstring textGlobalRef = (jstring)env->NewGlobalRef(text);
 817 
 818     ReplaceTextStruct *rts = new ReplaceTextStruct;
 819     rts->textComponent = selfGlobalRef;
 820     rts->text = textGlobalRef;
 821     rts->start = start;
 822     rts->end = end;
 823 
 824     AwtToolkit::GetInstance().SyncCall(AwtTextArea::_ReplaceText, rts);
 825     // global refs and rts are deleted in _ReplaceText()
 826 
 827     CATCH_BAD_ALLOC;
 828 }
 829 
 830 /*
 831  * Class:     sun_awt_windows_WTextAreaPeer
 832  * Method:    insertText
 833  * Signature: (Ljava/lang/String;I)V
 834  */
 835 JNIEXPORT void JNICALL
 836 Java_sun_awt_windows_WTextAreaPeer_insertText(JNIEnv *env, jobject self,
 837                                               jstring text, jint pos)
 838 {
 839     Java_sun_awt_windows_WTextAreaPeer_replaceText(env, self, text, pos, pos);
 840 }
 841 
 842 } /* extern "C" */
 843 
 844 
--- EOF ---