Changeset 4112

Show
Ignore:
Timestamp:
2006年07月17日 16時05分41秒 (2 years ago)
Author:
yamazaki
Message:

Change the treatment of main_thread_hdc.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/src/ChangeLog.Meadow

    r4111 r4112  
     12006-07-17  YAMAZAKI Katsuhiro <yamazaki-k@mwe.biglobe.ne.jp> 
     2 
     3        * mw32fns.c (Fx_create_frame): Move the position in which 
     4        GET_FRAME_HDC is called after mw32window, because the window handle 
     5        is obtained in there. 
     6        (mw32_WndProc<WM_PAINT>): Changes from EnterCriticalSection and 
     7        LeaveCriticalSection to MW32_BLOCK_FRAME_HDC and 
     8        MW32_BLOCK_FRAME_HDC. 
     9 
     10        * mw32term.h (GET_FRAME_HDC_LEVEL_LIMIT): Moved to `mw32term.c'. 
     11        (MW32_BLOCK_FRAME_HDC): New Macro. 
     12        (MW32_UNBLOCK_FRAME_HDC): Ditto. 
     13        (GET_FRAME_HDC): Changes from the macro to the function call.  
     14        (RELEASE_FRAME_HDC): Ditto. 
     15        (CLEANUP_FRAME_HDC): Ditto. 
     16 
     17        * mw32term.c (GET_FRAME_HDC_LEVEL_LIMIT): Moved from `mw32term.h'. 
     18        (MAIN_THREAD_FRAME_HDC_STACK): New define. 
     19        (main_thread_hdc_frame): New variable. 
     20        (old_main_thread_hdc_stack): Ditto. 
     21        (old_main_thread_hdc): Ditto. 
     22        (old_main_thread_hdc_nestlevel): Ditto. 
     23        (old_main_thread_hdc_hwnd): Ditto. 
     24        (old_main_thread_hdc_frame): Ditto. 
     25        (mw32_init_frame_hdc): New function. 
     26        (mw32_get_frame_hdc): Ditto. 
     27        (mw32_release_frame_hdc): Ditto. 
     28        (mw32_cleanup_frame_hdc): Ditto. 
     29        (MW32_update_begin): Changes from EnterCriticalSection and 
     30        LeaveCriticalSection to MW32_BLOCK_FRAME_HDC and 
     31        MW32_BLOCK_FRAME_HDC. 
     32        (mw32_clear_mouse_face): Ditto. 
     33        (mw32_initialize): Call mw32_init_frame_hdc. 
     34 
    1352006-07-16  MIYOSHI Masanori  <miyoshi@meadowy.org> 
    236 
  • trunk/src/mw32fns.c

    r4102 r4112  
    19411941            return 0; 
    19421942 
    1943           EnterCriticalSection (&(f->output_data.mw32->hdc_critsec)); 
     1943          MW32_BLOCK_FRAME_HDC (f); 
    19441944          if (main_thread_hdc == INVALID_HANDLE_VALUE) 
    19451945            { 
     
    19631963              Sleep (2); 
    19641964            } 
    1965           LeaveCriticalSection (&(f->output_data.mw32->hdc_critsec)); 
     1965          MW32_UNBLOCK_FRAME_HDC (f); 
    19661966 
    19671967          return 0; 
     
    30573057    } 
    30583058 
    3059   GET_FRAME_HDC (f); 
    3060  
    30613059  /* Extract the window parameters from the supplied values 
    30623060     that are needed to determine window geometry.  */ 
     
    31823180  /* Create the X widget or window.  */ 
    31833181  mw32_window (f, minibuffer_only); 
     3182 
     3183  GET_FRAME_HDC (f); 
    31843184 
    31853185  /* Now consider the frame official.  */ 
  • trunk/src/mw32term.c

    r4111 r4112  
    195195HWND mw32_frame_window; 
    196196 
    197 /* Window's DC that is used by main thread. */ 
    198 HDC main_thread_hdc = INVALID_HANDLE_VALUE; 
    199  
    200 /* Nesting level of main_thread_hdc. */ 
    201 int main_thread_hdc_nestlevel = 0; 
    202  
    203 /* hwnd for main_thread_hdc to use on release. */ 
    204 HWND main_thread_hdc_hwnd = INVALID_HANDLE_VALUE; 
    205197  
    206198/* The scroll bar in which the last X motion event occurred. 
     
    352344#endif /* 0 */ 
    353345 
     346  
     347/*********************************************************************** 
     348                          FRAME HDC handling 
     349 ***********************************************************************/ 
     350/* main_thread_hdc_nestlevel never exceeds this limit under normal usage. */ 
     351#define GET_FRAME_HDC_LEVEL_LIMIT 10 
     352 
     353/* main_thread_hdc stack never exceeds this limit under normal usage. */ 
     354#define MAIN_THREAD_FRAME_HDC_STACK 10 
     355 
     356/* Window's DC that is used by main thread. */ 
     357HDC main_thread_hdc = INVALID_HANDLE_VALUE; 
     358 
     359/* Nesting level of main_thread_hdc. */ 
     360int main_thread_hdc_nestlevel = 0; 
     361 
     362/* hwnd for main_thread_hdc to use on release. */ 
     363HWND main_thread_hdc_hwnd = INVALID_HANDLE_VALUE; 
     364 
     365/* frame when main_thread_hdc is operated. */ 
     366FRAME_PTR main_thread_hdc_frame = NULL; 
     367 
     368/* Stack level of main_thread_hdc. */ 
     369int old_main_thread_hdc_stack; 
     370 
     371/* Stack of main_thread_hdc. */ 
     372HDC old_main_thread_hdc[MAIN_THREAD_FRAME_HDC_STACK]; 
     373 
     374/* Stack of main_thread_hdc_nestlevel. */ 
     375int old_main_thread_hdc_nestlevel[MAIN_THREAD_FRAME_HDC_STACK]; 
     376 
     377/* Stack of main_thread_hdc_hwnd. */ 
     378HWND old_main_thread_hdc_hwnd[MAIN_THREAD_FRAME_HDC_STACK]; 
     379 
     380/* Stack of main_thread_hdc_frame. */ 
     381FRAME_PTR old_main_thread_hdc_frame[MAIN_THREAD_FRAME_HDC_STACK]; 
     382 
     383void 
     384mw32_init_frame_hdc () 
     385{ 
     386  int i; 
     387 
     388  for (i = 0; i < MAIN_THREAD_FRAME_HDC_STACK; i++) 
     389    { 
     390      old_main_thread_hdc[i] = INVALID_HANDLE_VALUE;; 
     391      old_main_thread_hdc_nestlevel[i] = 0; 
     392      old_main_thread_hdc_hwnd[i] = INVALID_HANDLE_VALUE; 
     393      old_main_thread_hdc_frame[i] = NULL; 
     394    } 
     395  old_main_thread_hdc_stack = 0; 
     396} 
     397 
     398/* Check whether the same frame is a nest. */ 
     399#define MW32_HDC_NEST_CHECK 0 
     400 
     401HDC 
     402mw32_get_frame_hdc (f) 
     403     FRAME_PTR f; 
     404{ 
     405  HDC ret_hdc = INVALID_HANDLE_VALUE; 
     406#if MW32_HDC_NEST_CHECK 
     407  int i; 
     408#endif 
     409 
     410  if (FRAME_WINDOW_P (f)) 
     411    { 
     412      if (MW32_MAIN_THREAD_P()) 
     413        { 
     414          if (main_thread_hdc != INVALID_HANDLE_VALUE) 
     415            { 
     416              if (main_thread_hdc_hwnd != FRAME_MW32_WINDOW (f)) 
     417                { 
     418                  if (old_main_thread_hdc_stack < MAIN_THREAD_FRAME_HDC_STACK) 
     419                    { 
     420                      old_main_thread_hdc_hwnd[old_main_thread_hdc_stack] 
     421                        = main_thread_hdc_hwnd; 
     422                      main_thread_hdc_hwnd = INVALID_HANDLE_VALUE; 
     423                      old_main_thread_hdc_nestlevel[old_main_thread_hdc_stack] 
     424                        = main_thread_hdc_nestlevel; 
     425                      main_thread_hdc_nestlevel = 0; 
     426 
     427                      MW32_BLOCK_FRAME_HDC (main_thread_hdc_frame); 
     428                      old_main_thread_hdc[old_main_thread_hdc_stack] 
     429                        = main_thread_hdc; 
     430                      main_thread_hdc = INVALID_HANDLE_VALUE; 
     431                      MW32_UNBLOCK_FRAME_HDC (main_thread_hdc_frame); 
     432 
     433                      old_main_thread_hdc_frame[old_main_thread_hdc_stack] 
     434                        = main_thread_hdc_frame; 
     435                      main_thread_hdc_frame = NULL; 
     436                      old_main_thread_hdc_stack++; 
     437 
     438                      update_begin_hook (f); 
     439                      main_thread_hdc_frame = f; 
     440                      ret_hdc = main_thread_hdc; 
     441 
     442#if MW32_HDC_NEST_CHECK 
     443                      /* Check whether the same frame is a nest. */ 
     444                      for (i = 0; i < old_main_thread_hdc_stack; i++) 
     445                        { 
     446                          if (f == old_main_thread_hdc_frame[i]) 
     447                            { 
     448                              abort (); 
     449                            } 
     450                        } 
     451#endif 
     452                    } 
     453                  else 
     454                    { 
     455                      abort (); 
     456                    } 
     457                } 
     458              else 
     459                { 
     460                  if (main_thread_hdc_nestlevel++ > GET_FRAME_HDC_LEVEL_LIMIT) 
     461                    { 
     462                      abort (); 
     463                    } 
     464                  else 
     465                    { 
     466                      ret_hdc = main_thread_hdc; 
     467                    } 
     468                } 
     469            } 
     470          else 
     471            { 
     472              update_begin_hook (f); 
     473              main_thread_hdc_frame = f; 
     474              ret_hdc = main_thread_hdc; 
     475            } 
     476        } 
     477      else 
     478        { 
     479          if ((f)->output_data.mw32->hdc != INVALID_HANDLE_VALUE) 
     480            { 
     481              if ((f)->output_data.mw32->hdc_nestlevel++ 
     482                  > GET_FRAME_HDC_LEVEL_LIMIT) 
     483                { 
     484                  abort (); 
     485                } 
     486              else 
     487                { 
     488                  ret_hdc = (f)->output_data.mw32->hdc; 
     489                } 
     490            } 
     491          else 
     492            { 
     493              update_begin_hook (f); 
     494              ret_hdc = (f)->output_data.mw32->hdc; 
     495            } 
     496        } 
     497    } 
     498  return ret_hdc; 
     499} 
     500 
     501int 
     502mw32_release_frame_hdc (f) 
     503     FRAME_PTR f; 
     504{ 
     505  if (FRAME_WINDOW_P (f)) 
     506    { 
     507      int *pcount; 
     508      HDC *phdc; 
     509      if (MW32_MAIN_THREAD_P ()) 
     510        { 
     511          phdc = &main_thread_hdc; 
     512          pcount = &main_thread_hdc_nestlevel; 
     513        } 
     514      else 
     515        { 
     516          phdc = &((f)->output_data.mw32->hdc); 
     517          pcount = &((f)->output_data.mw32->hdc_nestlevel); 
     518        } 
     519 
     520      if (*phdc == INVALID_HANDLE_VALUE) 
     521        abort (); 
     522 
     523      if (*pcount > 1) 
     524        (*pcount)--; 
     525      else 
     526        { 
     527          update_end_hook (f); 
     528          if (MW32_MAIN_THREAD_P ()) 
     529            { 
     530              if (old_main_thread_hdc_stack) 
     531                { 
     532                  old_main_thread_hdc_stack--; 
     533                  main_thread_hdc_frame 
     534                    = old_main_thread_hdc_frame[old_main_thread_hdc_stack]; 
     535                  old_main_thread_hdc_frame[old_main_thread_hdc_stack] 
     536                    = NULL; 
     537 
     538                  MW32_BLOCK_FRAME_HDC (main_thread_hdc_frame); 
     539                  main_thread_hdc 
     540                    = old_main_thread_hdc[old_main_thread_hdc_stack]; 
     541                  old_main_thread_hdc[old_main_thread_hdc_stack] 
     542                    = INVALID_HANDLE_VALUE; 
     543                  MW32_UNBLOCK_FRAME_HDC (main_thread_hdc_frame); 
     544 
     545                  main_thread_hdc_nestlevel 
     546                    = old_main_thread_hdc_nestlevel[old_main_thread_hdc_stack]; 
     547                  old_main_thread_hdc_nestlevel[old_main_thread_hdc_stack] 
     548                    = 0; 
     549                  main_thread_hdc_hwnd 
     550                    = old_main_thread_hdc_hwnd[old_main_thread_hdc_stack]; 
     551                  old_main_thread_hdc_hwnd[old_main_thread_hdc_stack] 
     552                    = INVALID_HANDLE_VALUE; 
     553                } 
     554              else 
     555                { 
     556                  main_thread_hdc_frame = NULL; 
     557                } 
     558            } 
     559        } 
     560    } 
     561} 
     562 
     563int 
     564mw32_cleanup_frame_hdc (f) 
     565     FRAME_PTR f; 
     566{ 
     567  if (FRAME_WINDOW_P (f)) 
     568    { 
     569      if (MW32_MAIN_THREAD_P ()) 
     570        { 
     571          if (main_thread_hdc != INVALID_HANDLE_VALUE) 
     572            { 
     573              main_thread_hdc_nestlevel = 1; 
     574              update_end_hook (f); 
     575              if (old_main_thread_hdc_stack) 
     576                { 
     577                  old_main_thread_hdc_stack--; 
     578                  main_thread_hdc_frame 
     579                    = old_main_thread_hdc_frame[old_main_thread_hdc_stack]; 
     580                  old_main_thread_hdc_frame[old_main_thread_hdc_stack] = NULL; 
     581 
     582                  MW32_BLOCK_FRAME_HDC (main_thread_hdc_frame); 
     583                  main_thread_hdc 
     584                    = old_main_thread_hdc[old_main_thread_hdc_stack]; 
     585                  old_main_thread_hdc[old_main_thread_hdc_stack] 
     586                    = INVALID_HANDLE_VALUE; 
     587                  MW32_UNBLOCK_FRAME_HDC (main_thread_hdc_frame); 
     588 
     589                  main_thread_hdc_nestlevel 
     590                    = old_main_thread_hdc_nestlevel[old_main_thread_hdc_stack]; 
     591                  old_main_thread_hdc_nestlevel[old_main_thread_hdc_stack] = 0; 
     592                  main_thread_hdc_hwnd 
     593                    = old_main_thread_hdc_hwnd[old_main_thread_hdc_stack]; 
     594                  old_main_thread_hdc_hwnd[old_main_thread_hdc_stack] 
     595                    = INVALID_HANDLE_VALUE; 
     596                } 
     597              else 
     598                { 
     599                  main_thread_hdc_frame = NULL; 
     600                } 
     601            } 
     602        } 
     603      else 
     604        { 
     605          if ((f)->output_data.mw32->hdc != INVALID_HANDLE_VALUE) 
     606            { 
     607              (f)->output_data.mw32->hdc_nestlevel = 1; 
     608              update_end_hook (f); 
     609            } 
     610        } 
     611    } 
     612} 
    354613 
    355614  
     
    567826 
    568827          main_thread_hdc_hwnd = FRAME_MW32_WINDOW (f); 
    569           EnterCriticalSection (&(f->output_data.mw32->hdc_critsec)); 
     828          MW32_BLOCK_FRAME_HDC (f); 
    570829          main_thread_hdc = GetDC (main_thread_hdc_hwnd); 
    571           LeaveCriticalSection (&(f->output_data.mw32->hdc_critsec)); 
     830          MW32_UNBLOCK_FRAME_HDC (f); 
    572831 
    573832          main_thread_hdc_nestlevel = 1; 
     
    42874546  struct mw32_display_info  *dpyinfo = FRAME_MW32_DISPLAY_INFO (f); 
    42884547 
    4289   EnterCriticalSection (&(f->output_data.mw32->hdc_critsec)); 
     4548  MW32_BLOCK_FRAME_HDC (f); 
    42904549  if (main_thread_hdc == INVALID_HANDLE_VALUE) 
    42914550    { 
     
    42994558  /* Pending process will be donw in mw32_message_loop */ 
    43004559 
    4301   LeaveCriticalSection (&(f->output_data.mw32->hdc_critsec)); 
     4560  MW32_UNBLOCK_FRAME_HDC (f); 
    43024561} 
    43034562 
     
    63526611  main_thread_id = GetCurrentThreadId (); 
    63536612 
     6613  mw32_init_frame_hdc (); 
     6614 
    63546615  /* Create message thread.  */ 
    63556616  /* Caution!!!!! inherited thread can't make Lisp Object directly 
  • trunk/src/mw32term.h

    r4093 r4112  
    531531#define FRAME_OUTER_WINDOW(f) (FRAME_MW32_WINDOW (f)) 
    532532 
    533 /* hdc_refcount never exceeds this limit under normal usage */ 
    534 #define GET_FRAME_HDC_LEVEL_LIMIT 256 
    535 #define GET_FRAME_HDC(f)                                                \ 
    536  (! FRAME_WINDOW_P (f)? INVALID_HANDLE_VALUE:                           \ 
    537   (MW32_MAIN_THREAD_P()                                                 \ 
    538    ?(main_thread_hdc != INVALID_HANDLE_VALUE                            \ 
    539      ?((main_thread_hdc_nestlevel++ > GET_FRAME_HDC_LEVEL_LIMIT)        \ 
    540        ?(abort(), INVALID_HANDLE_VALUE)                                 \ 
    541        :main_thread_hdc)                                                \ 
    542      :(update_begin_hook (f), main_thread_hdc))                         \ 
    543    :(((f)->output_data.mw32->hdc != INVALID_HANDLE_VALUE)               \ 
    544      ?(((f)->output_data.mw32->hdc_nestlevel++                          \ 
    545         > GET_FRAME_HDC_LEVEL_LIMIT)                                    \ 
    546        ?(abort(), INVALID_HANDLE_VALUE)                                 \ 
    547        :(f)->output_data.mw32->hdc)                                     \ 
    548      :(update_begin_hook (f), (f)->output_data.mw32->hdc)))) 
    549  
    550  
    551 #define RELEASE_FRAME_HDC(f)                                            \ 
    552  if (FRAME_WINDOW_P (f))                                                \ 
    553   {                                                                     \ 
    554     int *pcount;                                                        \ 
    555     HDC *phdc;                                                          \ 
    556     if (MW32_MAIN_THREAD_P ())                                          \ 
    557       {                                                                 \ 
    558         phdc = &main_thread_hdc;                                        \ 
    559         pcount = &main_thread_hdc_nestlevel;                            \ 
    560       }                                                                 \ 
    561     else                                                                \ 
    562       {                                                                 \ 
    563         phdc = &((f)->output_data.mw32->hdc);                           \ 
    564         pcount = &((f)->output_data.mw32->hdc_nestlevel);               \ 
    565       }                                                                 \ 
    566     if (*phdc == INVALID_HANDLE_VALUE)                                  \ 
    567       abort ();                                                         \ 
    568     else                                                                \ 
    569       {                                                                 \ 
    570         if (*pcount > 1)                                                \ 
    571           (*pcount)--;                                                  \ 
    572         else                                                            \ 
    573           update_end_hook (f);                                          \ 
    574       }                                                                 \ 
    575   } 
    576  
    577 /* GET/RELEASE_FRAME_HDC is sometimes used asymmetrical becaulse of 
    578    signalling. This macro does force release of hdc. */ 
    579 #define CLEANUP_FRAME_HDC(f)                                            \ 
    580  if (FRAME_WINDOW_P (f))                                                \ 
    581   {                                                                     \ 
    582     if (MW32_MAIN_THREAD_P ())                                          \ 
    583       {                                                                 \ 
    584         if (main_thread_hdc != INVALID_HANDLE_VALUE)                    \ 
    585           {                                                             \ 
    586             main_thread_hdc_nestlevel = 1;                              \ 
    587             update_end_hook (f);                                        \ 
    588           }                                                             \ 
    589       }                                                                 \ 
    590     else                                                                \ 
    591       {                                                                 \ 
    592         if ((f)->output_data.mw32->hdc != INVALID_HANDLE_VALUE)         \ 
    593           {                                                             \ 
    594             (f)->output_data.mw32->hdc_nestlevel = 1;                   \ 
    595             update_end_hook (f);                                        \ 
    596           }                                                             \ 
    597       }                                                                 \ 
    598   } 
    599  
     533/* FRAME HDC handling */ 
     534#if 0 
     535#define MW32_BLOCK_FRAME_HDC(f) \ 
     536  EnterCriticalSection (&((f)->output_data.mw32->hdc_critsec)) 
     537#define MW32_UNBLOCK_FRAME_HDC(f) \ 
     538  LeaveCriticalSection (&((f)->output_data.mw32->hdc_critsec)) 
     539#else 
     540#define MW32_BLOCK_FRAME_HDC(f) EnterCriticalSection (&critsec_message) 
     541#define MW32_UNBLOCK_FRAME_HDC(f) LeaveCriticalSection (&critsec_message) 
     542#endif 
     543 
     544extern HDC mw32_get_frame_hdc P_ ((FRAME_PTR f)); 
     545extern int mw32_release_frame_hdc P_ ((FRAME_PTR f)); 
     546extern int mw32_cleanup_frame_hdc P_ ((FRAME_PTR f)); 
     547#define GET_FRAME_HDC(f) mw32_get_frame_hdc (f) 
     548#define RELEASE_FRAME_HDC(f) mw32_release_frame_hdc (f) 
     549#define CLEANUP_FRAME_HDC(f) mw32_cleanup_frame_hdc (f) 
    600550 
    601551#define MW32_BLOCK_CARET(f)                             \ 
     
    11391089/* for mw32fns module interfaces. */ 
    11401090extern void mw32_setup_default_hdc P_ ((HDC hdc)); 
    1141 extern HDC mw32_get_frame_hdc P_ ((struct frame *f)); 
    11421091extern void mw32_destroy_frame_hdc P_ ((struct frame *f)); 
    11431092/* extern void mw32_lower_frame P_ ((struct frame *f)); */