Changeset 4142

Show
Ignore:
Timestamp:
2006年08月17日 08時16分27秒 (2 years ago)
Author:
miyoshi
Message:

(Fx_create_frame): Normalize coding style.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/src/ChangeLog.Meadow

    r4141 r4142  
    112006-08-17  MIYOSHI Masanori  <miyoshi@meadowy.org> 
    22 
     3        * mw32fns.c (Fx_create_frame): Normalize coding style. 
     4 
     52006-08-17  MIYOSHI Masanori  <miyoshi@meadowy.org> 
     6 
    37        * mw32fns.c (mw32_WndProc<WM_ERASEBKGND>): Return 0 if there is no 
    4         update region. 
     8        update region.  Refer to ticket:335. 
    59 
    6102006-08-10  MIYOSHI Masanori  <miyoshi@meadowy.org> 

  • trunk/src/mw32fns.c

    r4141 r4142  
    18971897    return DefWindowProc (hwnd, msg, wParam, lParam); 
    18981898 
    1899   switch (msg) { 
    1900   case WM_ERASEBKGND: 
    1901     { 
    1902       RECT rect; 
    1903       int orefcount; 
    1904       HDC ohdc; 
    1905       int ret; 
    1906  
    1907       orefcount = f->output_data.mw32->hdc_nestlevel; 
    1908       ohdc = f->output_data.mw32->hdc; 
    1909  
    1910       f->output_data.mw32->hdc = (HDC) wParam; 
    1911       f->output_data.mw32->hdc_nestlevel = 1; 
    1912  
    1913       ret = GetUpdateRect (FRAME_MW32_WINDOW (f), &rect, FALSE); 
    1914       if (ret) 
    1915         mw32_clear_native_frame_area (f, rect.left, rect.top, 
    1916                                      rect.right, rect.bottom); 
    1917  
    1918       f->output_data.mw32->hdc = ohdc; 
    1919       f->output_data.mw32->hdc_nestlevel = orefcount; 
    1920  
    1921       return ret ? 1 : 0; 
    1922     } 
    1923  
    1924   case WM_PAINT: 
    1925     { 
     1899  switch (msg) 
     1900    { 
     1901    case WM_ERASEBKGND: 
     1902      { 
     1903       RECT rect; 
     1904       int orefcount; 
     1905       HDC ohdc; 
     1906        int ret; 
     1907 
     1908       orefcount = f->output_data.mw32->hdc_nestlevel; 
     1909        ohdc = f->output_data.mw32->hdc; 
     1910 
     1911       f->output_data.mw32->hdc = (HDC) wParam; 
     1912        f->output_data.mw32->hdc_nestlevel = 1; 
     1913 
     1914        ret = GetUpdateRect (FRAME_MW32_WINDOW (f), &rect, FALSE); 
     1915        if (ret) 
     1916          mw32_clear_native_frame_area (f, rect.left, rect.top, 
     1917                                        rect.right, rect.bottom); 
     1918 
     1919       f->output_data.mw32->hdc = ohdc; 
     1920        f->output_data.mw32->hdc_nestlevel = orefcount; 
     1921 
     1922        return ret ? 1 : 0; 
     1923      } 
     1924 
     1925    case WM_PAINT: 
    19261926      if (hwnd == tip_window) /* don't redraw tooltip */ 
    19271927        goto dflt; 
    …… 
    19711971          return 0; 
    19721972        } 
    1973     } 
    1974  
    1975     goto dflt; 
    1976  
    1977   case WM_SETFOCUS: 
    1978  
    1979     mw32_new_focus_frame (dpyinfo, f); 
    1980  
    1981     /* This code is for switching selected-frame.  In order to 
    1982        generate no events before Emacs is set up, check whether 
    1983        selected_frame is initial terminal frame.  This is because 
    1984        input_pending should be false at the startup to show startup 
    1985        message. */ 
    1986     if (SELECTED_FRAME () 
    1987         && (SELECTED_FRAME () != XFRAME (Vterminal_frame)) 
    1988         && (SELECTED_FRAME () != f)) 
    1989       PostMessage (hwnd, WM_EMACS_ACTIVATE, 
    1990                    (WPARAM) 0, (LPARAM) 0); 
    1991  
    1992     mw32_update_frame_alpha (f); 
    1993  
    1994     /* Synchronize caret state */ 
    1995     if (CARET_CURSOR_P (XWINDOW (f->selected_window)->phys_cursor_type) 
    1996         && MW32_FRAME_CARET_SHOWN (f)) 
    1997       { 
    1998         DestroyCaret (); 
    1999         MW32_FRAME_CARET_STATE (f) = NO_CARET; 
    2000         MW32_FRAME_CARET_BLOCKED (f) = FALSE; 
    2001         PostMessage (hwnd, WM_EMACS_SETCARET, (WPARAM)SHOWN_CARET, (LPARAM)0); 
    2002       } 
    2003     return 0; 
    2004  
    2005   case WM_KILLFOCUS: 
    2006  
    2007     if (MW32_FRAME_CARET_STATE (f) > NO_CARET) 
    2008       { 
    2009         DestroyCaret (); 
    2010         MW32_FRAME_CARET_STATE (f) = NO_CARET; 
    2011         MW32_FRAME_CARET_BLOCKED (f) = FALSE; 
    2012       } 
    2013  
    2014     if (f == FRAME_MW32_DISPLAY_INFO (f)->mw32_focus_frame) 
    2015       mw32_new_focus_frame (dpyinfo, NULL); 
    2016  
    2017     /* reset mouse face and help echo.  */ 
    2018     mw32_update_frame_alpha (f); 
    2019  
    2020     PostMessage (hwnd, WM_EMACS_CLEAR_MOUSE_FACE, 
    2021                  (WPARAM) 1, (LPARAM) 0); 
    2022  
    2023     return 0; 
    2024  
    2025   case WM_MOVING: 
    2026     f->output_data.mw32->frame_moving_or_sizing = 1; 
    2027     mw32_update_frame_alpha (f); 
    2028     return TRUE; 
    2029  
    2030   case WM_SIZING: 
    2031     f->output_data.mw32->frame_moving_or_sizing = 2; 
    2032     mw32_update_frame_alpha (f); 
    2033     return TRUE; 
    2034  
    2035   case WM_EXITSIZEMOVE: 
    2036     f->output_data.mw32->frame_moving_or_sizing = 0; 
    2037     mw32_update_frame_alpha (f); 
    2038  
    2039     return TRUE; 
    2040  
    2041   case WM_MOVE: 
    2042  
    2043     if (!f->async_iconified && f->async_visible) 
    2044       { 
    2045         RECT rect; 
    2046  
    2047         GetWindowRect (hwnd, &rect); 
    2048  
    2049         mw32_real_positions (f, &f->left_pos, &f->top_pos); 
    2050       } 
    2051  
    2052     break; 
    2053  
    2054   case WM_SIZE: 
    2055  
    2056     switch (wParam) 
    2057       { 
    2058       case SIZE_MINIMIZED: 
    2059         f->async_visible = 0; 
    2060         f->async_iconified = 1; 
    2061         break; 
    2062       case SIZE_MAXIMIZED: 
    2063         f->want_fullscreen |= FULLSCREEN_BOTH; 
    2064         /* fall through */ 
    2065       case SIZE_RESTORED: 
     1973 
     1974      goto dflt; 
     1975 
     1976    case WM_SETFOCUS: 
     1977 
     1978      mw32_new_focus_frame (dpyinfo, f); 
     1979 
     1980      /* This code is for switching selected-frame.  In order to 
     1981         generate no events before Emacs is set up, check whether 
     1982         selected_frame is initial terminal frame.  This is because 
     1983         input_pending should be false at the startup to show startup 
     1984         message. */ 
     1985      if (SELECTED_FRAME () 
     1986          && (SELECTED_FRAME () != XFRAME (Vterminal_frame)) 
     1987          && (SELECTED_FRAME () != f)) 
     1988        PostMessage (hwnd, WM_EMACS_ACTIVATE, (WPARAM) 0, (LPARAM) 0); 
     1989 
     1990      mw32_update_frame_alpha (f); 
     1991 
     1992      /* Synchronize caret state */ 
     1993      if (CARET_CURSOR_P (XWINDOW (f->selected_window)->phys_cursor_type) 
     1994          && MW32_FRAME_CARET_SHOWN (f)) 
     1995        { 
     1996          DestroyCaret (); 
     1997          MW32_FRAME_CARET_STATE (f) = NO_CARET; 
     1998          MW32_FRAME_CARET_BLOCKED (f) = FALSE; 
     1999          PostMessage (hwnd, WM_EMACS_SETCARET, 
     2000                       (WPARAM)SHOWN_CARET, (LPARAM)0); 
     2001        } 
     2002      return 0; 
     2003 
     2004    case WM_KILLFOCUS: 
     2005 
     2006      if (MW32_FRAME_CARET_STATE (f) > NO_CARET) 
     2007        { 
     2008          DestroyCaret (); 
     2009          MW32_FRAME_CARET_STATE (f) = NO_CARET; 
     2010          MW32_FRAME_CARET_BLOCKED (f) = FALSE; 
     2011        } 
     2012 
     2013      if (f == FRAME_MW32_DISPLAY_INFO (f)->mw32_focus_frame) 
     2014        mw32_new_focus_frame (dpyinfo, NULL); 
     2015 
     2016      /* reset mouse face and help echo.  */ 
     2017      mw32_update_frame_alpha (f); 
     2018 
     2019      PostMessage (hwnd, WM_EMACS_CLEAR_MOUSE_FACE, (WPARAM) 1, (LPARAM) 0); 
     2020 
     2021      return 0; 
     2022 
     2023    case WM_MOVING: 
     2024      f->output_data.mw32->frame_moving_or_sizing = 1; 
     2025      mw32_update_frame_alpha (f); 
     2026      return TRUE; 
     2027 
     2028    case WM_SIZING: 
     2029      f->output_data.mw32->frame_moving_or_sizing = 2; 
     2030      mw32_update_frame_alpha (f); 
     2031      return TRUE; 
     2032 
     2033    case WM_EXITSIZEMOVE: 
     2034      f->output_data.mw32->frame_moving_or_sizing = 0; 
     2035      mw32_update_frame_alpha (f); 
     2036 
     2037      return TRUE; 
     2038 
     2039    case WM_MOVE: 
     2040 
     2041      if (!f->async_iconified && f->async_visible) 
    20662042        { 
    20672043          RECT rect; 
    …… 
    20692045          GetWindowRect (hwnd, &rect); 
    20702046 
    2071           f->async_visible = IsWindowVisible (hwnd); 
    2072           f->async_iconified = IsIconic (hwnd); 
    20732047          mw32_real_positions (f, &f->left_pos, &f->top_pos); 
    2074           SET_FRAME_GARBAGED (f); 
    2075           mw32_update_frame_alpha (f); 
    20762048        } 
     2049 
     2050      break; 
     2051 
     2052    case WM_SIZE: 
     2053 
     2054      switch (wParam) 
     2055        { 
     2056        case SIZE_MINIMIZED: 
     2057          f->async_visible = 0; 
     2058          f->async_iconified = 1; 
     2059          break; 
     2060        case SIZE_MAXIMIZED: 
     2061          f->want_fullscreen |= FULLSCREEN_BOTH; 
     2062          /* fall through */ 
     2063        case SIZE_RESTORED: 
     2064          { 
     2065            RECT rect; 
     2066 
     2067            GetWindowRect (hwnd, &rect); 
     2068 
     2069            f->async_visible = IsWindowVisible (hwnd); 
     2070            f->async_iconified = IsIconic (hwnd); 
     2071            mw32_real_positions (f, &f->left_pos, &f->top_pos); 
     2072            SET_FRAME_GARBAGED (f); 
     2073            mw32_update_frame_alpha (f); 
     2074          } 
     2075        } 
     2076 
     2077      break; 
     2078 
     2079    case WM_SHOWWINDOW: 
     2080      if (!wParam) 
     2081        { 
     2082          f->async_visible = 0; 
     2083          f->async_iconified = 1; 
     2084        } 
     2085      goto dflt; 
     2086 
     2087    case WM_NCMOUSEMOVE: 
     2088      /* reset mouse face only.  */ 
     2089      PostMessage (hwnd, WM_EMACS_CLEAR_MOUSE_FACE, (WPARAM) 0, (LPARAM) 0); 
     2090      goto dflt; 
     2091 
     2092    case WM_WINDOWPOSCHANGED: 
     2093      if (!f->async_iconified && f->async_visible) 
     2094        { 
     2095          int call_defprocp = 1; 
     2096          RECT rect; 
     2097          LPWINDOWPOS lppos = (LPWINDOWPOS) lParam; 
     2098 
     2099          if (!(lppos->flags & SWP_NOMOVE)) 
     2100            { 
     2101              GetWindowRect (hwnd, &rect); 
     2102              /* position change */ 
     2103              mw32_real_positions (f, &f->left_pos, &f->top_pos); 
     2104              call_defprocp = 0; 
     2105            } 
     2106 
     2107          GetClientRect (hwnd, &rect); 
     2108          if (!(lppos->flags & SWP_NOSIZE) 
     2109              || lppos->flags & SWP_DRAWFRAME) 
     2110            { 
     2111              /* size change */ 
     2112              int width, height; 
     2113              int rows, cols; 
     2114              int wdiff = 0, hdiff = 0; 
     2115 
     2116              height = rect.bottom - rect.top; 
     2117              width = rect.right - rect.left; 
     2118 
     2119              if ((width < (2 * (FRAME_INTERNAL_BORDER_WIDTH (f) 
     2120                                 + FRAME_TOTAL_FRINGE_WIDTH (f)) 
     2121                            + f->scroll_bar_actual_width)) 
     2122                  || (height < (2 * FRAME_INTERNAL_BORDER_WIDTH (f)))) 
     2123                { 
     2124                  /* This case MUST not happen.  Because it means that the 
     2125                     window size is smaller than required size.  Normally, 
     2126                     this case is caused by iconification on Windows.  So 
     2127                     we MUST not regard it as a normal window size changing 
     2128                     message. (by himi)  Call DefWindowProc() to generate 
     2129                     WM_SIZE message. 
     2130                  */ 
     2131                  goto dflt; 
     2132                } 
     2133 
     2134              if (!(f->want_fullscreen & FULLSCREEN_WIDTH) 
     2135                  || !(f->want_fullscreen & FULLSCREEN_HEIGHT)) 
     2136                { 
     2137                  wdiff = ((width 
     2138                            - 2 * (FRAME_INTERNAL_BORDER_WIDTH (f) 
     2139                                   + FRAME_TOTAL_FRINGE_WIDTH (f)) 
     2140                            - f->scroll_bar_actual_width) 
     2141                           % FRAME_DEFAULT_FONT_WIDTH (f)); 
     2142                  hdiff = ((height 
     2143                            - 2 * FRAME_INTERNAL_BORDER_WIDTH (f)) 
     2144                           % FRAME_LINE_HEIGHT (f)); 
     2145                  if ((2 * wdiff) > FRAME_DEFAULT_FONT_WIDTH (f)) 
     2146                    wdiff -= FRAME_DEFAULT_FONT_WIDTH (f); 
     2147                  if ((2 * hdiff) > FRAME_LINE_HEIGHT (f)) 
     2148                    hdiff -= FRAME_LINE_HEIGHT (f); 
     2149 
     2150                  width -= wdiff; 
     2151                  height -= hdiff; 
     2152 
     2153                  { 
     2154                    /* 
     2155                      Rearrange the frame size, which should be 
     2156                      smaller than the display size. 
     2157                    */ 
     2158                    HDC hdc = GetDC (hwnd); 
     2159                    RECT nrect; 
     2160                    int work_area_w, work_area_h; 
     2161 
     2162                    nrect.left = nrect.top = 0; 
     2163                    nrect.right = width; 
     2164                    nrect.bottom = height; 
     2165                    AdjustWindowRectEx (&nrect, f->output_data.mw32->dwStyle, 
     2166                                        FRAME_EXTERNAL_MENU_BAR (f), 
     2167                                        f->output_data.mw32->dwStyleEx); 
     2168 
     2169                    get_working_area_size (hwnd, &work_area_w, &work_area_h); 
     2170                    if (nrect.bottom - nrect.top > work_area_h) 
     2171                      { 
     2172                        hdiff += FRAME_LINE_HEIGHT (f); 
     2173                        height -= FRAME_LINE_HEIGHT (f); 
     2174                      } 
     2175                    if (nrect.right - nrect.left > work_area_w) 
     2176                      { 
     2177                        wdiff += FRAME_DEFAULT_FONT_WIDTH (f); 
     2178                        width -= FRAME_DEFAULT_FONT_WIDTH (f); 
     2179                      } 
     2180                    ReleaseDC (hwnd, hdc); 
     2181                  } 
     2182                } 
     2183 
     2184              rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); 
     2185              cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); 
     2186 
     2187              if (cols != f->text_cols 
     2188                  || rows != f->text_lines 
     2189                  || width != FRAME_PIXEL_WIDTH (f) 
     2190                  || height != FRAME_PIXEL_HEIGHT (f)) 
     2191                { 
     2192                  change_frame_size (f, rows, cols, 0, 1, 0); 
     2193                  SET_FRAME_GARBAGED (f); 
     2194                  cancel_mouse_face (f); 
     2195                  FRAME_PIXEL_WIDTH (f) = width; 
     2196                  FRAME_PIXEL_HEIGHT (f) = height; 
     2197                  f->win_gravity = NorthWestGravity; 
     2198                } 
     2199 
     2200              /* To adjust window correctly, 
     2201                 we must check size of the window twice 
     2202                 (strictly speaking number of dimention), 
     2203                 thus, width and height. */ 
     2204              if ((f->output_data.mw32->frame_change_state < 2) 
     2205                  && (wdiff || hdiff)) 
     2206                { 
     2207                  f->output_data.mw32->frame_change_state++; 
     2208                  SetWindowPos (hwnd, NULL, 0, 0, lppos->cx - wdiff, 
     2209                                lppos->cy - hdiff, SWP_NOZORDER | SWP_NOMOVE); 
     2210                } 
     2211              else 
     2212                f->output_data.mw32->frame_change_state = 0; 
     2213 
     2214              call_defprocp = 0; 
     2215            } 
     2216          else 
     2217            f->output_data.mw32->frame_change_state = 0; 
     2218 
     2219          if (!call_defprocp) 
     2220            return 0; 
     2221        } 
     2222 
     2223      goto dflt; 
     2224 
     2225    case WM_ACTIVATE: 
     2226    case WM_ACTIVATEAPP: 
     2227      mw32_check_fullscreen (f); 
     2228 
     2229      goto dflt; 
     2230 
     2231    case WM_CLOSE: 
     2232      PostMessage (hwnd, WM_EMACS_DESTROY, wParam, lParam); 
     2233      return 0; 
     2234 
     2235    case WM_CREATE: 
     2236      return 0; 
     2237 
     2238    case WM_INITMENU: 
     2239      if (f->output_data.mw32->menubar_handle == (HMENU) wParam) 
     2240        mw32_menu_bar_store_activate_event (f); 
     2241      return 0; 
     2242 
     2243    case WM_MENUSELECT: 
     2244      /* Direct handling of help_echo in menus.  Should be safe now 
     2245         that we generate the help_echo by placing a help event in the 
     2246         keyboard buffer.  */ 
     2247      { 
     2248        HMENU menu = (HMENU) lParam; 
     2249        UINT menu_item = (UINT) LOWORD (wParam); 
     2250        UINT flags = (UINT) HIWORD (wParam); 
     2251 
     2252        mw32_menu_display_help (hwnd, menu, menu_item, flags); 
    20772253      } 
    2078  
    2079     break; 
    2080  
    2081   case WM_SHOWWINDOW: 
    2082     if (!wParam) 
    2083       { 
    2084         f->async_visible = 0; 
    2085         f->async_iconified = 1; 
    2086       } 
    2087     goto dflt; 
    2088  
    2089   case WM_NCMOUSEMOVE: 
    2090     /* reset mouse face only.  */ 
    2091     PostMessage (hwnd, WM_EMACS_CLEAR_MOUSE_FACE, 
    2092                  (WPARAM) 0, (LPARAM) 0); 
    2093     goto dflt; 
    2094  
    2095   case WM_WINDOWPOSCHANGED: 
    2096     if (!f->async_iconified && f->async_visible) 
    2097       { 
    2098         int call_defprocp = 1; 
    2099         RECT rect; 
    2100         LPWINDOWPOS lppos = (LPWINDOWPOS) lParam; 
    2101  
    2102         if (!(lppos->flags & SWP_NOMOVE)) 
    2103           { 
    2104             GetWindowRect (hwnd, &rect); 
    2105             /* position change */ 
    2106             mw32_real_positions (f, &f->left_pos, &f->top_pos); 
    2107             call_defprocp = 0; 
    2108           } 
    2109  
    2110         GetClientRect (hwnd, &rect); 
    2111         if (!(lppos->flags & SWP_NOSIZE) 
    2112             || lppos->flags & SWP_DRAWFRAME) 
    2113           { 
    2114             /* size change */ 
    2115             int width, height; 
    2116             int rows, cols; 
    2117             int wdiff = 0, hdiff = 0; 
    2118  
    2119             height = rect.bottom - rect.top; 
    2120             width = rect.right - rect.left; 
    2121  
    2122             if ((width < (2 * (FRAME_INTERNAL_BORDER_WIDTH (f) 
    2123                                + FRAME_TOTAL_FRINGE_WIDTH (f)) 
    2124                           + f->scroll_bar_actual_width)) 
    2125                 || (height < (2 * FRAME_INTERNAL_BORDER_WIDTH (f)))) 
    2126               { 
    2127                 /* This case MUST not happen.  Because it means that the 
    2128                    window size is smaller than required size.  Normally, 
    2129                    this case is caused by iconification on Windows.  So 
    2130                    we MUST not regard it as a normal window size changing 
    2131                    message. (by himi)  Call DefWindowProc() to generate 
    2132                    WM_SIZE message. 
    2133                 */ 
    2134                 goto dflt; 
    2135               } 
    2136  
    2137             if (!(f->want_fullscreen & FULLSCREEN_WIDTH) 
    2138                 || !(f->want_fullscreen & FULLSCREEN_HEIGHT)) 
    2139               { 
    2140                 wdiff = ((width 
    2141                           - 2 * (FRAME_INTERNAL_BORDER_WIDTH (f) 
    2142                                  + FRAME_TOTAL_FRINGE_WIDTH (f)) 
    2143                           - f->scroll_bar_actual_width) 
    2144                          % FRAME_DEFAULT_FONT_WIDTH (f)); 
    2145                 hdiff = ((height 
    2146                           - 2 * FRAME_INTERNAL_BORDER_WIDTH (f)) 
    2147                          % FRAME_LINE_HEIGHT (f)); 
    2148                 if ((2 * wdiff) > FRAME_DEFAULT_FONT_WIDTH (f)) 
    2149                   wdiff -= FRAME_DEFAULT_FONT_WIDTH (f); 
    2150                 if ((2 * hdiff) > FRAME_LINE_HEIGHT (f)) 
    2151                   hdiff -= FRAME_LINE_HEIGHT (f); 
    2152  
    2153                 width -= wdiff; 
    2154                 height -= hdiff; 
    2155  
     2254      return 0; 
     2255 
     2256    case WM_MEASUREITEM: 
     2257      if (f) 
     2258        { 
     2259          MEASUREITEMSTRUCT * pMis = (MEASUREITEMSTRUCT *) lParam; 
     2260 
     2261          if (pMis->CtlType == ODT_MENU) 
     2262            { 
     2263              /* Work out dimensions for popup menu titles. */ 
     2264              char * title = (char *) pMis->itemData; 
     2265              HDC hdc = GetDC (hwnd); 
     2266              HFONT menu_font = GetCurrentObject (hdc, OBJ_FONT); 
     2267              LOGFONT menu_logfont; 
     2268              HFONT old_font; 
     2269              SIZE size; 
     2270 
     2271              GetObject (menu_font, sizeof (menu_logfont), &menu_logfont); 
     2272              menu_logfont.lfWeight = FW_BOLD; 
     2273              menu_font = CreateFontIndirect (&menu_logfont); 
     2274              old_font = SelectObject (hdc, menu_font); 
     2275 
     2276              pMis->itemHeight = GetSystemMetrics (SM_CYMENUSIZE); 
     2277              if (title) 
    21562278                { 
    2157                   /* 
    2158                     Rearrange the frame size, which should be smaller than the 
    2159                     display size. 
    2160                   */ 
    2161                   HDC hdc = GetDC (hwnd); 
    2162                   RECT nrect; 
    2163                   int work_area_w, work_area_h; 
    2164  
    2165                   nrect.left = nrect.top = 0; 
    2166                   nrect.right = width; 
    2167                   nrect.bottom = height; 
    2168                   AdjustWindowRectEx (&nrect, f->output_data.mw32->dwStyle, 
    2169                                       FRAME_EXTERNAL_MENU_BAR (f), 
    2170                                       f->output_data.mw32->dwStyleEx); 
    2171  
    2172                   get_working_area_size (hwnd, &work_area_w, &work_area_h); 
    2173                   if (nrect.bottom - nrect.top > work_area_h) 
    2174                     { 
    2175                       hdiff += FRAME_LINE_HEIGHT (f); 
    2176                       height -= FRAME_LINE_HEIGHT (f); 
    2177                     } 
    2178                   if (nrect.right - nrect.left > work_area_w) 
    2179                     { 
    2180                       wdiff += FRAME_DEFAULT_FONT_WIDTH (f); 
    2181                       width -= FRAME_DEFAULT_FONT_WIDTH (f); 
    2182                     } 
    2183                   ReleaseDC (hwnd, hdc); 
     2279                  GetTextExtentPoint32 (hdc, title, strlen (title), &size); 
     2280                  pMis->itemWidth = size.cx; 
     2281                  if (pMis->itemHeight < size.cy) 
     2282                    pMis->itemHeight = size.cy; 
    21842283                } 
    2185               } 
    2186  
    2187             rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); 
    2188             cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); 
    2189  
    2190             if (cols != f->text_cols 
    2191                 || rows != f->text_lines 
    2192                 || width != FRAME_PIXEL_WIDTH (f) 
    2193                 || height != FRAME_PIXEL_HEIGHT (f)) 
    2194               { 
    2195                 change_frame_size (f, rows, cols, 0, 1, 0); 
    2196                 SET_FRAME_GARBAGED (f); 
    2197                 cancel_mouse_face (f); 
    2198                 FRAME_PIXEL_WIDTH (f) = width; 
    2199                 FRAME_PIXEL_HEIGHT (f) = height; 
    2200                 f->win_gravity = NorthWestGravity; 
    2201               } 
    2202  
    2203             /* To adjust window correctly, 
    2204                we must check size of the window twice 
    2205                (strictly speaking number of dimention), 
    2206                thus, width and height. */ 
    2207             if ((f->output_data.mw32->frame_change_state < 2) 
    2208                 && (wdiff || hdiff)) 
    2209               { 
    2210                 f->output_data.mw32->frame_change_state++; 
    2211                 SetWindowPos (hwnd, NULL, 0, 0, 
    2212                               lppos->cx - wdiff, 
    2213                               lppos->cy - hdiff, 
    2214                               SWP_NOZORDER | SWP_NOMOVE); 
    2215               } 
    2216             else 
    2217               f->output_data.mw32->frame_change_state = 0; 
    2218  
    2219             call_defprocp = 0; 
    2220           } 
    2221         else 
    2222           f->output_data.mw32->frame_change_state = 0; 
    2223  
    2224         if (!call_defprocp) 
    2225           return 0; 
    2226       } 
    2227  
    2228     goto dflt; 
    2229  
    2230   case WM_ACTIVATE: 
    2231   case WM_ACTIVATEAPP: 
    2232     mw32_check_fullscreen (f); 
    2233  
    2234     goto dflt; 
    2235  
    2236   case WM_CLOSE: 
    2237     PostMessage (hwnd, WM_EMACS_DESTROY, wParam, lParam); 
    2238     return 0; 
    2239  
    2240   case WM_CREATE: 
    2241     return 0; 
    2242  
    2243   case WM_INITMENU: 
    2244     { 
    2245       if (f->output_data.mw32->menubar_handle == (HMENU) wParam) 
    2246         mw32_menu_bar_store_activate_event (f); 
     2284              else 
     2285                pMis->itemWidth = 0; 
     2286 
     2287              SelectObject (hdc, old_font); 
     2288              DeleteObject (menu_font); 
     2289              ReleaseDC (hwnd, hdc); 
     2290              return TRUE; 
     2291            } 
     2292        } 
    22472293      return 0; 
    2248     } 
    2249  
    2250   case WM_MENUSELECT: 
    2251     /* Direct handling of help_echo in menus.  Should be safe now 
    2252        that we generate the help_echo by placing a help event in the 
    2253        keyboard buffer.  */ 
    2254     { 
    2255       HMENU menu = (HMENU) lParam; 
    2256       UINT menu_item = (UINT) LOWORD (wParam); 
    2257       UINT flags = (UINT) HIWORD (wParam); 
    2258  
    2259       mw32_menu_display_help (hwnd, menu, menu_item, flags); 
    2260     } 
    2261     return 0; 
    2262  
    2263   case WM_MEASUREITEM: 
    2264     if (f) 
    2265       { 
    2266         MEASUREITEMSTRUCT * pMis = (MEASUREITEMSTRUCT *) lParam; 
    2267  
    2268         if (pMis->CtlType == ODT_MENU) 
    2269           { 
    2270             /* Work out dimensions for popup menu titles. */ 
    2271             char * title = (char *) pMis->itemData; 
    2272             HDC hdc = GetDC (hwnd); 
    2273             HFONT menu_font = GetCurrentObject (hdc, OBJ_FONT); 
    2274             LOGFONT menu_logfont; 
    2275             HFONT old_font; 
    2276             SIZE size; 
    2277  
    2278             GetObject (menu_font, sizeof (menu_logfont), &menu_logfont); 
    2279             menu_logfont.lfWeight = FW_BOLD; 
    2280             menu_font = CreateFontIndirect (&menu_logfont); 
    2281             old_font = SelectObject (hdc, menu_font); 
    2282  
    2283             pMis->itemHeight = GetSystemMetrics (SM_CYMENUSIZE); 
    2284             if (title) 
    2285               { 
    2286                 GetTextExtentPoint32 (hdc, title, strlen (title), &size); 
    2287                 pMis->itemWidth = size.cx; 
    2288                 if (pMis->itemHeight < size.cy) 
    2289                   pMis->itemHeight = size.cy; 
    2290               } 
    2291             else 
    2292               pMis->itemWidth = 0; 
    2293  
    2294             SelectObject (hdc, old_font); 
    2295             DeleteObject (menu_font); 
    2296             ReleaseDC (hwnd, hdc); 
    2297             return TRUE; 
    2298           } 
    2299       } 
    2300     return 0; 
    2301  
    2302   case WM_DRAWITEM: 
    2303     if (f) 
    2304       { 
    2305         DRAWITEMSTRUCT * pDis = (DRAWITEMSTRUCT *) lParam; 
    2306  
    2307         if (pDis->CtlType == ODT_MENU) 
    2308           { 
    2309             /* Draw popup menu title. */ 
    2310             char * title = (char *) pDis->itemData; 
    2311             if (title) 
    2312               { 
    2313                 HDC hdc = pDis->hDC; 
    2314                 HFONT menu_font = GetCurrentObject (hdc, OBJ_FONT); 
    2315                 LOGFONT menu_logfont; 
    2316                 HFONT old_font; 
    2317  
    2318                 GetObject (menu_font, sizeof (menu_logfont), &menu_logfont); 
    2319                 menu_logfont.lfWeight = FW_BOLD; 
    2320                 menu_font = CreateFontIndirect (&menu_logfont); 
    2321                 old_font = SelectObject (hdc, menu_font); 
    2322  
    2323                 /* Always draw title as if not selected.  */ 
    2324                 ExtTextOut (hdc, 
    2325                             pDis->rcItem.left 
    2326                             + GetSystemMetrics (SM_CXMENUCHECK), 
    2327                             pDis->rcItem.top, 
    2328                             ETO_OPAQUE, &pDis->rcItem, 
    2329                             title, strlen (title), NULL); 
    2330  
    2331                 SelectObject (hdc, old_font); 
    2332                 DeleteObject (menu_font); 
    2333               } 
    2334             return TRUE; 
    2335           } 
    2336       } 
    2337     return 0; 
    2338  
    2339   case WM_ENTERMENULOOP: 
    2340     if (dpyinfo->mouse_cursor_stat < 0) 
    2341       { 
    2342         ShowCursor (TRUE); 
    2343         dpyinfo->mouse_cursor_stat = 0; 
    2344       } 
    2345     return 0; 
    2346      
    2347   case WM_EXITMENULOOP: 
    2348     { 
     2294 
     2295    case WM_DRAWITEM: 
     2296      if (f) 
     2297        { 
     2298          DRAWITEMSTRUCT * pDis = (DRAWITEMSTRUCT *) lParam; 
     2299 
     2300          if (pDis->CtlType == ODT_MENU) 
     2301            { 
     2302              /* Draw popup menu title. */ 
     2303              char * title = (char *) pDis->itemData; 
     2304              if (title) 
     2305                { 
     2306                  HDC hdc = pDis->hDC; 
     2307                  HFONT menu_font = GetCurrentObject (hdc, OBJ_FONT); 
     2308                  LOGFONT menu_logfont; 
     2309                  HFONT old_font; 
     2310 
     2311                  GetObject (menu_font, sizeof (menu_logfont), &menu_logfont); 
     2312                  menu_logfont.lfWeight = FW_BOLD; 
     2313                  menu_font = CreateFontIndirect (&menu_logfont); 
     2314                  old_font = SelectObject (hdc, menu_font); 
     2315 
     2316                  /* Always draw title as if not selected.  */ 
     2317                  ExtTextOut (hdc, 
     2318                              pDis->rcItem.left 
     2319                              + GetSystemMetrics (SM_CXMENUCHECK), 
     2320                              pDis->rcItem.top, 
     2321                              ETO_OPAQUE, &pDis->rcItem, 
     2322                              title, strlen (title), NULL); 
     2323 
     2324                  SelectObject (hdc, old_font); 
     2325                  DeleteObject (menu_font); 
     2326                } 
     2327              return TRUE; 
     2328            } 
     2329        } 
     2330      return 0; 
     2331 
     2332    case WM_ENTERMENULOOP: 
     2333      if (dpyinfo->mouse_cursor_stat < 0) 
     2334        { 
     2335          ShowCursor (TRUE); 
     2336          dpyinfo->mouse_cursor_stat = 0; 
     2337        } 
     2338      return 0; 
     2339 
     2340    case WM_EXITMENULOOP: 
    23492341      if (!wParam) /* not track popup menu */ 
    23502342        f->output_data.mw32->disable_reconstruct_menubar = 0; 
    23512343      lock_mouse_cursor_visible (FALSE); 
    23522344      return 0; 
    2353     } 
    2354  
    2355   case WM_VSCROLL: 
    2356     { 
     2345 
     2346    case WM_VSCROLL: 
    23572347      mw32_scroll_bar_store_event (wParam, lParam); 
    23582348      return 0; 
    2359     } 
    2360  
    2361   case WM_SYSCOMMAND: 
    2362     { 
     2349 
     2350    case WM_SYSCOMMAND: 
    23632351      switch (wParam & 0xFFF0) 
    23642352        { 
    …… 
    23722360        } 
    23732361      goto dflt; 
    2374     } 
    2375  
    2376   case WM_EMACS_FLASH_WINDOW: 
    2377     { 
     2362 
     2363    case WM_EMACS_FLASH_WINDOW: 
    23782364      if ((enum emacs_flash_window_type) wParam == INVERT_EDGES_OF_FRAME) 
    23792365        mw32m_flash_window (f); 
    …… 
    23852371        } 
    23862372      return 0; 
    2387     } 
    23882373#if defined(MEADOW) && defined(IME_CONTROL) 
    23892374#ifdef W32_VER4 
    2390   case WM_IME_NOTIFY: 
    2391     if (wParam == IMN_SETOPENSTATUS) 
    2392       { 
    2393         if (!IME_event_off_count) 
    2394           PostMessage (hwnd, WM_MULE_IME_STATUS, 0, 0); 
    2395         else 
    2396           IME_event_off_count--; 
    2397         SetEvent (fep_switch_event); 
    2398       } 
    2399     goto dflt; 
     2375    case WM_IME_NOTIFY: 
     2376      if (wParam == IMN_SETOPENSTATUS) 
     2377       { 
     2378          if (!IME_event_off_count) 
     2379            PostMessage (hwnd, WM_MULE_IME_STATUS, 0, 0); 
     2380          else 
     2381            IME_event_off_count--; 
     2382          SetEvent (fep_switch_event); 
     2383       } 
     2384      goto dflt; 
    24002385 
    24012386#ifdef IME_RECONVERSION 
    …… 
    24062391      goto dflt; 
    24072392#endif 
    2408   case WM_IME_STARTCOMPOSITION: 
    2409     { 
     2393    case WM_IME_STARTCOMPOSITION: 
    24102394      mw32_set_ime_conv_window (hwnd, XWINDOW (f->selected_window)); 
    24112395      f->output_data.mw32->ime_composition_state = 1; 
    24122396      POST_THREAD_INFORM_MESSAGE (main_thread_id, WM_EMACS_GET_IME_FONT_PROP, 
    24132397                                  (WPARAM) f, (LPARAM) 0); 
    2414     } 
    2415   goto dflt; 
    2416  
    2417   case WM_EMACS_MODIFY_IME_FONT_PROP: 
    2418     { 
     2398      goto dflt; 
     2399 
     2400    case WM_EMACS_MODIFY_IME_FONT_PROP: 
    24192401      /* set logfont for IME */ 
    24202402      /* f is not current selected frame because running thread here 
    …… 
    24282410          mw32_set_ime_font (FRAME_MW32_WINDOW (f), &lf); 
    24292411        } 
    2430     } 
    2431     goto dflt; 
    2432  
    2433   case WM_IME_COMPOSITION: 
    2434     { 
     2412      goto dflt; 
     2413 
     2414    case WM_IME_COMPOSITION: 
    24352415      if (lParam & GCS_RESULTSTR) 
    24362416        { 
    …… 
    24482428 
    24492429      goto dflt; 
    2450     } 
    2451  
    2452   case WM_IME_ENDCOMPOSITION: 
    2453     /* To erase garbage image of system caret set update_mode_lines */ 
    2454     /* I can not find smart solution for results of asynchronisity of 
    2455        IME events posted onto main thread. */ 
    2456     if (CARET_CURSOR_P (XWINDOW (f->selected_window)->phys_cursor_type)) 
    2457       update_mode_lines++; 
    2458  
    2459     f->output_data.mw32->ime_composition_state = 0; 
    2460  
    2461     goto dflt; 
     2430 
     2431    case WM_IME_ENDCOMPOSITION: 
     2432      /* To erase garbage image of system caret set update_mode_lines */ 
     2433      /* I can not find smart solution for results of asynchronisity of 
     2434         IME events posted onto main thread. */ 
     2435      if (CARET_CURSOR_P (XWINDOW (f->selected_window)->phys_cursor_type)) 
     2436        update_mode_lines++; 
     2437 
     2438      f->output_data.mw32->ime_composition_state = 0; 
     2439 
     2440      goto dflt; 
    24622441 
    24632442#else /* not W32_VER4 */ 
    24642443 
    2465   case WM_IME_REPORT: 
    2466     switch (wParam) 
     2444    case WM_IME_REPORT: 
     2445      switch (wParam) 
     2446        { 
     2447        case IR_STRING: 
     2448          { 
     2449            HANDLE himestr; 
     2450 
     2451            himestr = mw32_ime_string_handle ((HANDLE) lParam); 
     2452            if (!himestr) break; 
     2453 
     2454            PostMessage (NULL, WM_MULE_IME_REPORT, 
     2455                         (WPARAM) himestr, (LPARAM) f); 
     2456            return 1; 
     2457          } 
     2458        case IR_OPENCONVERT: 
     2459        case IR_CLOSECONVERT: 
     2460          if (!IME_event_off_count) 
     2461            PostMessage (hwnd, WM_MULE_IME_STATUS, 0, 0); 
     2462          else 
     2463            IME_event_off_count--; 
     2464          SetEvent (fep_switch_event); 
     2465          return 0; 
     2466        } 
     2467#endif /* not W32_VER4 */ 
     2468    case WM_MULE_IMM_SET_COMPOSITION_FONT: 
     2469      f->output_data.mw32->ime_logfont = *((LPLOGFONT) lParam); 
     2470      mw32_set_ime_font (hwnd, (LPLOGFONT) lParam); 
     2471      POST_THREAD_INFORM_MESSAGE (main_thread_id, 
     2472                                  WM_MULE_IMM_SET_COMPOSITION_FONT_REPLY, 
     2473                                  (WPARAM) 0, (LPARAM) 0); 
     2474      break; 
     2475    case WM_MULE_IMM_SET_CONVERSION_WINDOW: 
     2476      mw32_set_ime_conv_window (hwnd, (struct window *) wParam); 
     2477      break; 
     2478 
     2479    case WM_MULE_IMM_SET_COMPOSITION_STRING: 
     2480      mw32_ime_set_composition_string (hwnd, (char*) wParam); 
     2481      break; 
     2482 
     2483    case WM_MULE_IMM_GET_COMPOSITION_STRING: 
     2484      mw32_ime_get_composition_string (hwnd); 
     2485      break; 
     2486 
     2487#endif /* not MEADOW and IME_CONTROL */ 
     2488 
     2489      /* Emacs private message entries. */ 
     2490    case WM_EMACS_CREATE_FRAME: 
     2491      mw32m_create_frame_window ((struct frame*) wParam, (LPSTR) lParam); 
     2492      break; 
     2493 
     2494    case WM_EMACS_CREATE_TIP_FRAME: 
     2495      mw32m_create_tip_frame_window ((struct frame *) wParam); 
     2496      break; 
     2497 
     2498    case WM_EMACS_CREATE_SCROLLBAR: 
     2499      mw32m_create_scrollbar (hwnd, (LPRECT) wParam, (HINSTANCE) lParam); 
     2500      break; 
     2501 
     2502#ifdef IME_CONTROL 
     2503    case WM_MULE_IME_CREATE_AGENT: 
     2504      mw32m_ime_create_agent (); 
     2505      break; 
     2506    case WM_MULE_IME_DESTROY_AGENT: 
     2507      mw32m_ime_destroy_agent (hwnd); 
     2508      break; 
     2509#endif 
     2510    case WM_EMACS_DESTROY_FRAME: 
     2511      mw32m_destroy_frame (hwnd); 
     2512      break; 
     2513 
     2514    case WM_EMACS_POPUP_MENU: 
     2515      /* Use menubar_active to indicate that WM_INITMENU is from 
     2516         TrackPopupMenu below, and should be ignored.  */ 
     2517      f = mw32_window_to_frame (dpyinfo, hwnd); 
     2518      if (f) 
     2519        f->output_data.mw32->menubar_active = 1; 
     2520 
     2521      mw32m_track_popup_menu (hwnd, (HANDLE) wParam, (LPPOINT) lParam); 
     2522      dpyinfo->grabbed = 0; 
     2523      break; 
     2524 
     2525    case WM_EMACS_SETCARET: 
    24672526      { 
    2468       case IR_STRING: 
    2469