fvwm/update.c

   1 /* -*-c-*- */
   2 /* This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /* ---------------------------- included header files ---------------------- */
  18
  19 #include "config.h"
  20 #include <stdio.h>
  21
  22 #include "libs/fvwmlib.h"
  23 #include "libs/charmap.h"
  24 #include "libs/wcontext.h"
  25 #include "libs/Grab.h"
  26 #include "fvwm.h"
  27 #include "externs.h"
  28 #include "execcontext.h"
  29 #include "cursor.h"
  30 #include "bindings.h"
  31 #include "misc.h"
  32 #include "screen.h"
  33 #include "update.h"
  34 #include "style.h"
  35 #include "builtins.h"
  36 #include "borders.h"
  37 #include "frame.h"
  38 #include "gnome.h"
  39 #include "ewmh.h"
  40 #include "icons.h"
  41 #include "geometry.h"
  42 #include "move_resize.h"
  43 #include "add_window.h"
  44 #include "module_interface.h"
  45 #include "focus.h"
  46 #include "stack.h"
  47 #include "icons.h"
  48
  49 /* ---------------------------- local definitions -------------------------- */
  50
  51 /* ---------------------------- local macros ------------------------------- */
  52
  53 /* ---------------------------- imports ------------------------------------ */
  54
  55 /* ---------------------------- included code files ------------------------ */
  56
  57 /* ---------------------------- local types -------------------------------- */
  58
  59 /* ---------------------------- forward declarations ----------------------- */
  60
  61 /* ---------------------------- local variables ---------------------------- */
  62
  63 /* ---------------------------- exported variables (globals) --------------- */
  64
  65 /* ---------------------------- local functions ---------------------------- */
  66
  67 /* ---------------------------- interface functions ------------------------ */
  68
  69 static void init_style(
  70         FvwmWindow *old_t, FvwmWindow *t, window_style *pstyle,
  71         short *pbuttons)
  72 {
  73         /* copy the window structure because we still need some old values. */
  74         memcpy(old_t, t, sizeof(FvwmWindow));
  75         /* determine level of decoration */
  76         setup_style_and_decor(t, pstyle, pbuttons);
  77         /* restore some old values */
  78         IS_STICKY_ACROSS_PAGES(t) = IS_STICKY_ACROSS_PAGES(old_t);
  79         IS_STICKY_ACROSS_DESKS(t) = IS_STICKY_ACROSS_DESKS(old_t);
  80         GET_USER_STATES(t) = GET_USER_STATES(old_t);
  81
  82         return;
  83 }
  84
  85 static void apply_window_updates(
  86         FvwmWindow *t, update_win *flags, window_style *pstyle,
  87         FvwmWindow *focus_w)
  88 {
  89         FvwmWindow old_t;
  90         short buttons;
  91         Bool is_style_initialised = False;
  92         rectangle frame_g;
  93         const exec_context_t *exc;
  94         exec_context_changes_t ecc;
  95
  96         frame_g.x = t->g.frame.x;
  97         frame_g.y = t->g.frame.y;
  98         frame_g.width = t->g.frame.width;
  99         frame_g.height = t->g.frame.height;
 100
 101         /* TA:  2010-07-28:  Conditionally update window states if they're
 102          * present -- i.e., we're preserving states set via Windowstyle.
 103          */
 104         CLEAR_USER_STATES(t, S_USER_STATES(SCM(*pstyle)));
 105         SET_USER_STATES(t, S_USER_STATES(SCF(*pstyle)));
 106
 107         if (flags->do_setup_focus_policy)
 108         {
 109                 setup_focus_policy(t);
 110                 if (t == focus_w &&
 111                     !fpol_query_allow_user_focus(&FW_FOCUS_POLICY(t)))
 112                 {
 113                         focus_w = NULL;
 114                         if (Scr.Hilite == t)
 115                         {
 116                                 Scr.Hilite = NULL;
 117                         }
 118                         flags->do_redraw_decoration = True;
 119                 }
 120         }
 121         if (flags->do_update_gnome_styles)
 122         {
 123                 if (!S_DO_IGNORE_GNOME_HINTS(SCF(*pstyle)))
 124                 {
 125                         GNOME_GetStyle(t, pstyle);
 126                 }
 127         }
 128         if (flags->do_update_window_grabs)
 129         {
 130                 focus_grab_buttons(t);
 131         }
 132         if (IS_TRANSIENT(t) && flags->do_redecorate_transient)
 133         {
 134                 flags->do_redecorate = True;
 135                 flags->do_update_window_font = True;
 136         }
 137
 138         /*
 139          * is_sticky
 140          * is_icon_sticky
 141          *
 142          * These are a bit complicated because they can move windows to a
 143          * different page or desk. */
 144         ecc.type = EXCT_NULL;
 145         ecc.w.fw = t;
 146         ecc.w.w = FW_W_FRAME(t);
 147         ecc.w.wcontext = C_FRAME;
 148         exc = exc_create_context(
 149                 &ecc, ECC_TYPE | ECC_FW | ECC_W | ECC_WCONTEXT);
 150         if (flags->do_update_stick_icon && IS_ICONIFIED(t) &&
 151             !(IS_STICKY_ACROSS_PAGES(t) || IS_STICKY_ACROSS_DESKS(t)))
 152         {
 153                 if (IS_ICON_STICKY_ACROSS_PAGES(pstyle) ||
 154                     IS_ICON_STICKY_ACROSS_DESKS(pstyle))
 155                 {
 156                         /* stick and unstick the window to force the icon on
 157                          * the current page */
 158                         handle_stick(
 159                                 NULL, exc, "",
 160                                 S_IS_STICKY_ACROSS_PAGES(SCF(*pstyle)),
 161                                 S_IS_STICKY_ACROSS_DESKS(SCF(*pstyle)), 1, 1);
 162                         handle_stick(NULL, exc, "", 0, 0, 1, 0);
 163                 }
 164                 flags->do_update_icon_title = True;
 165         }
 166         else if (flags->do_update_stick)
 167         {
 168                 handle_stick(
 169                         NULL, exc, "", S_IS_STICKY_ACROSS_PAGES(SCF(*pstyle)),
 170                         S_IS_STICKY_ACROSS_DESKS(SCF(*pstyle)), 0, 0);
 171         }
 172         exc_destroy_context(exc);
 173         if (FMiniIconsSupported && flags->do_update_mini_icon)
 174         {
 175                 if (!HAS_EWMH_MINI_ICON(t) || DO_EWMH_MINI_ICON_OVERRIDE(t))
 176                 {
 177                         change_mini_icon(t, pstyle);
 178                 }
 179                 else
 180                 {
 181                         if (EWMH_SetIconFromWMIcon(t, NULL, 0, True))
 182                         {
 183                                 SET_HAS_EWMH_MINI_ICON(t, True);
 184                         }
 185                         else
 186                         {
 187                                 /* "should" not happen */
 188                                 SET_HAS_EWMH_MINI_ICON(t, False);
 189                                 change_mini_icon(t, pstyle);
 190                         }
 191                 }
 192         }
 193         if (flags->do_update_visible_window_name)
 194         {
 195                 setup_visible_name(t, False);
 196                 BroadcastName(M_VISIBLE_NAME,FW_W(t),FW_W_FRAME(t),
 197                               (unsigned long)t,t->visible_name);
 198                 EWMH_SetVisibleName(t, False);
 199         }
 200
 201         if (flags->do_update_visible_icon_name)
 202         {
 203                 setup_visible_name(t, True);
 204                 BroadcastName(MX_VISIBLE_ICON_NAME,FW_W(t),FW_W_FRAME(t),
 205                               (unsigned long)t,t->visible_icon_name);
 206                 EWMH_SetVisibleName(t, True);
 207         }
 208
 209         if (flags->do_update_window_font || flags->do_update_window_font_height)
 210         {
 211                 if (!is_style_initialised)
 212                 {
 213                         init_style(&old_t, t, pstyle, &buttons);
 214                         is_style_initialised = True;
 215                 }
 216                 setup_window_font(t, pstyle, flags->do_update_window_font);
 217                 flags->do_redecorate = True;
 218         }
 219         if (flags->do_update_title_text_dir)
 220         {
 221                 flags->do_redecorate = True;
 222         }
 223         if (flags->do_redecorate || flags->do_update_title_dir)
 224         {
 225                 size_borders b_old;
 226                 size_borders b_new;
 227                 int dw = 0;
 228                 int dh = 0;
 229                 rectangle naked_g;
 230                 rectangle *new_g;
 231
 232                 if (flags->do_redecorate)
 233                 {
 234                         if (!is_style_initialised)
 235                         {
 236                                 init_style(&old_t, t, pstyle, &buttons);
 237                                 is_style_initialised = True;
 238                         }
 239
 240                         /* redecorate */
 241                         change_auxiliary_windows(t, buttons);
 242
 243                         /* calculate the new offsets */
 244                         /* naked_g: geometry without decor */
 245                         gravity_get_naked_geometry(
 246                                 old_t.hints.win_gravity, &old_t, &naked_g,
 247                                 &t->g.normal);
 248                         /* gravity without decor */
 249                         gravity_translate_to_northwest_geometry_no_bw(
 250                                 old_t.hints.win_gravity, &old_t, &naked_g,
 251                                 &naked_g);
 252                         /* set g.normal with the decor */
 253                         gravity_add_decoration(
 254                                 old_t.hints.win_gravity, t, &t->g.normal,
 255                                 &naked_g);
 256                 }
 257                 if (flags->do_update_title_dir)
 258                 {
 259                         /* new border sizes */
 260                         get_window_borders(t, &b_old);
 261                         SET_TITLE_DIR(t, S_TITLE_DIR(SCF(*pstyle)));
 262                         setup_title_geometry(t, pstyle);
 263                         get_window_borders(t, &b_new);
 264
 265                         /* resizing */
 266                         dw = b_new.total_size.width - b_old.total_size.width;
 267                         dh = b_new.total_size.height - b_old.total_size.height;
 268                         gravity_resize(
 269                                 t->hints.win_gravity, &t->g.normal, dw, dh);
 270                         gravity_constrain_size(
 271                                 t->hints.win_gravity, t, &t->g.normal, 0);
 272                 }
 273
 274                 if (IS_MAXIMIZED(t))
 275                 {
 276                         if (flags->do_redecorate)
 277                         {
 278                                 int off_x = old_t.g.normal.x - old_t.g.max.x;
 279                                 int off_y = old_t.g.normal.y - old_t.g.max.y;
 280                                 int new_off_x;
 281                                 int new_off_y;
 282
 283                                 /* maximized windows are always considered to
 284                                  * have NorthWestGravity */
 285                                 gravity_get_naked_geometry(
 286                                         NorthWestGravity, &old_t, &naked_g,
 287                                         &t->g.max);
 288                                 gravity_translate_to_northwest_geometry_no_bw(
 289                                         NorthWestGravity, &old_t, &naked_g,
 290                                         &naked_g);
 291                                 gravity_add_decoration(
 292                                         NorthWestGravity, t, &t->g.max,
 293                                         &naked_g);
 294                                 /* prevent random paging when unmaximizing
 295                                  * after e.g. the border width has changed */
 296                                 new_off_x = t->g.normal.x - t->g.max.x;
 297                                 new_off_y = t->g.normal.y - t->g.max.y;
 298                                 t->g.max_offset.x += new_off_x - off_x;
 299                                 t->g.max_offset.y += new_off_y - off_y;
 300                         }
 301                         if (flags->do_update_title_dir)
 302                         {
 303                                 frame_g = t->g.max;
 304                                 gravity_resize(
 305                                         t->hints.win_gravity, &t->g.max, dw,
 306                                         dh);
 307                                 gravity_constrain_size(
 308                                         t->hints.win_gravity, t, &t->g.max,
 309                                         CS_UPDATE_MAX_DEFECT);
 310                         }
 311                         new_g = &t->g.max;
 312                 }
 313                 else
 314                 {
 315                         new_g = &t->g.normal;
 316                 }
 317                 if (IS_SHADED(t))
 318                 {
 319                         get_unshaded_geometry(t, new_g);
 320                         if (USED_TITLE_DIR_FOR_SHADING(t))
 321                         {
 322                                 SET_SHADED_DIR(t, GET_TITLE_DIR(t));
 323                         }
 324                         get_shaded_geometry(t, &frame_g, new_g);
 325                 }
 326                 else
 327                 {
 328                         get_relative_geometry(&frame_g, new_g);
 329                 }
 330                 flags->do_setup_frame = True;
 331                 flags->do_redraw_decoration = True;
 332         }
 333         if (flags->do_update_rotated_title)
 334         {
 335                 if (t->title_text_rotation != ROTATION_0)
 336                 {
 337                         flags->do_setup_frame = True;
 338                         flags->do_redraw_decoration = True;
 339                 }
 340         }
 341         if (flags->do_resize_window)
 342         {
 343                 rectangle old_g;
 344
 345                 setup_frame_size_limits(t, pstyle);
 346                 old_g = frame_g;
 347                 frame_g = t->g.normal;
 348                 gravity_constrain_size(t->hints.win_gravity, t, &frame_g, 0);
 349                 t->g.normal = frame_g;
 350                 if (IS_MAXIMIZED(t))
 351                 {
 352                         frame_g = t->g.max;
 353                         gravity_constrain_size(
 354                                 t->hints.win_gravity, t, &frame_g,
 355                                 CS_UPDATE_MAX_DEFECT);
 356                         t->g.max = frame_g;
 357                 }
 358                 frame_g = old_g;
 359                 gravity_constrain_size(
 360                         t->hints.win_gravity, t, &frame_g, 0);
 361
 362                 flags->do_setup_frame = True;
 363                 flags->do_redraw_decoration = True;
 364         }
 365         if (flags->do_setup_frame)
 366         {
 367                 FvwmWindow *tmp;
 368
 369                 setup_title_geometry(t, pstyle);
 370                 /* frame_force_setup_window needs to know if the window is
 371                  * hilighted */
 372                 tmp = get_focus_window();
 373                 set_focus_window(focus_w);
 374                 frame_force_setup_window(
 375                         t, frame_g.x, frame_g.y, frame_g.width, frame_g.height,
 376                         True);
 377                 set_focus_window(tmp);
 378                 GNOME_SetWinArea(t);
 379                 EWMH_SetFrameStrut(t);
 380         }
 381         if (flags->do_update_window_color)
 382         {
 383                 if (t != focus_w)
 384                 {
 385                         flags->do_redraw_decoration = True;
 386                 }
 387                 update_window_color_style(t, pstyle);
 388                 if (t != Scr.Hilite)
 389                 {
 390                         flags->do_broadcast_focus = True;
 391                 }
 392         }
 393         if (flags->do_update_window_color_hi)
 394         {
 395                 if (t == focus_w)
 396                 {
 397                         flags->do_redraw_decoration = True;
 398                 }
 399                 update_window_color_hi_style(t, pstyle);
 400                 flags->do_broadcast_focus = True;
 401                 if (t == Scr.Hilite)
 402                 {
 403                         flags->do_broadcast_focus = True;
 404                 }
 405         }
 406         if (flags->do_update_icon_title_cs_hi)
 407         {
 408                 if (t == focus_w && IS_ICONIFIED(t))
 409                 {
 410                         flags->do_redraw_icon = True;
 411                 }
 412                 update_icon_title_cs_hi_style(t, pstyle);
 413         }
 414         if (flags->do_update_icon_title_cs)
 415         {
 416                 if (t != focus_w && IS_ICONIFIED(t))
 417                 {
 418                         flags->do_redraw_icon = True;
 419                 }
 420                 update_icon_title_cs_style(t, pstyle);
 421         }
 422         if (flags->do_update_icon_background_cs)
 423         {
 424                 int old_cs = t->icon_background_cs;
 425
 426                 update_icon_background_cs_style(t, pstyle);
 427                 if ((old_cs < 0 && t->icon_background_cs >= 0) ||
 428                     (old_cs >= 0 && t->icon_background_cs < 0))
 429                 {
 430                         flags->do_update_icon = True;
 431                 }
 432                 else
 433                 {
 434                         flags->do_redraw_icon = True;
 435                 }
 436         }
 437         if (flags->do_update_icon_size_limits)
 438         {
 439                 setup_icon_size_limits(t, pstyle);
 440                 flags->do_update_icon = True;
 441         }
 442         if (flags->do_update_icon_font)
 443         {
 444                 if (!is_style_initialised)
 445                 {
 446                         init_style(&old_t, t, pstyle, &buttons);
 447                         is_style_initialised = True;
 448                 }
 449                 setup_icon_font(t, pstyle, flags->do_update_icon_font);
 450                 flags->do_update_icon_title = True;
 451         }
 452         if (flags->do_update_icon_boxes)
 453         {
 454                 change_icon_boxes(t, pstyle);
 455         }
 456         if (flags->do_update_icon)
 457         {
 458                 setup_icon_background_parameters(t, pstyle);
 459                 setup_icon_title_parameters(t, pstyle);
 460                 change_icon(t, pstyle);
 461                 flags->do_update_icon_placement = True;
 462                 flags->do_update_icon_title = False;
 463                 flags->do_redraw_icon = False;
 464                 flags->do_update_ewmh_icon = True;
 465         }
 466         if (flags->do_redraw_icon)
 467         {
 468                 /* should not test if the window is iconified */
 469                 DrawIconWindow(t, True, True, False, True, NULL);;
 470                 flags->do_redraw_decoration = False;
 471                 flags->do_update_icon_title = False;
 472         }
 473         if (flags->do_update_icon_title)
 474         {
 475                 RedoIconName(t);
 476         }
 477         if (flags->do_update_icon_placement)
 478         {
 479                 if (IS_ICONIFIED(t))
 480                 {
 481                         initial_window_options_t win_opts;
 482
 483                         memset(&win_opts, 0, sizeof(win_opts));
 484                         SET_ICONIFIED(t, 0);
 485                         Iconify(t, &win_opts);
 486                         flags->do_redraw_decoration = False;
 487                 }
 488         }
 489         if (flags->do_redraw_decoration)
 490         {
 491                 FvwmWindow *tmp;
 492
 493                 /* frame_redraw_decorations needs to know if the window is
 494                  * hilighted */
 495                 tmp = get_focus_window();
 496                 set_focus_window(focus_w);
 497                 if (IS_ICONIFIED(t))
 498                 {
 499                         DrawIconWindow(t, True, True, False, False, NULL);
 500                 }
 501                 else
 502                 {
 503                         border_redraw_decorations(t);
 504                 }
 505                 set_focus_window(tmp);
 506         }
 507         if (flags->do_update_frame_attributes)
 508         {
 509                 setup_frame_attributes(t, pstyle);
 510         }
 511         if (flags->do_update_ewmh_state_hints)
 512         {
 513                 EWMH_SetWMState(t, False);
 514         }
 515         if (flags->do_update_modules_flags)
 516         {
 517                 BroadcastConfig(M_CONFIGURE_WINDOW,t);
 518         }
 519         if (flags->do_update_ewmh_mini_icon || flags->do_update_ewmh_icon)
 520         {
 521                 EWMH_DoUpdateWmIcon(
 522                         t, flags->do_update_ewmh_mini_icon,
 523                         flags->do_update_ewmh_icon);
 524         }
 525         if (flags->do_update_placement_penalty)
 526         {
 527                 setup_placement_penalty(t, pstyle);
 528         }
 529         if (flags->do_update_working_area)
 530         {
 531                 EWMH_UpdateWorkArea();
 532         }
 533         if (flags->do_update_ewmh_stacking_hints)
 534         {
 535                 if (DO_EWMH_USE_STACKING_HINTS(t))
 536                 {
 537                         if (t->ewmh_hint_layer > 0 &&
 538                             t->layer != t->ewmh_hint_layer)
 539                         {
 540                                 t->ewmh_normal_layer = t->layer;
 541                                 new_layer(t, t->ewmh_hint_layer);
 542                         }
 543                 }
 544                 else
 545                 {
 546                         if (t->ewmh_hint_layer > 0 && t->ewmh_normal_layer)
 547                         {
 548                                 if (t->ewmh_normal_layer)
 549                                 {
 550                                         new_layer(t, t->ewmh_normal_layer);
 551                                 }
 552                                 else
 553                                 {
 554                                         new_layer(t, Scr.DefaultLayer);
 555                                 }
 556                         }
 557                 }
 558         }
 559         if (flags->do_update_ewmh_allowed_actions)
 560         {
 561                 EWMH_SetAllowedActions(t);
 562         }
 563         if (flags->do_broadcast_focus)
 564         {
 565                 if (Scr.Hilite != NULL && t == Scr.Hilite)
 566                 {
 567                         BroadcastPacket(
 568                                 M_FOCUS_CHANGE, 5, (long)FW_W(Scr.Hilite),
 569                                 (long)FW_W_FRAME(Scr.Hilite), (long)0,
 570                                 (long)Scr.Hilite->hicolors.fore,
 571                                 (long)Scr.Hilite->hicolors.back);
 572                 }
 573         }
 574         if (flags->do_refresh)
 575         {
 576                 if (!IS_ICONIFIED(t))
 577                 {
 578                         refresh_window(FW_W_FRAME(t), False);
 579                 }
 580         }
 581         setup_numeric_vals(t, pstyle);
 582         if (flags->do_update_cr_motion_method)
 583         {
 584                 switch (SCR_MOTION_METHOD(&pstyle->flags))
 585                 {
 586                 case WS_CR_MOTION_METHOD_AUTO:
 587                         if (WAS_CR_MOTION_METHOD_DETECTED(t))
 588                         {
 589                                 /* method was already detected, keep it */
 590                                 break;
 591                         }
 592                         /* fall through */
 593                 case WS_CR_MOTION_METHOD_USE_GRAV:
 594                 case WS_CR_MOTION_METHOD_STATIC_GRAV:
 595                         SET_CR_MOTION_METHOD(
 596                                 t, SCR_MOTION_METHOD(&pstyle->flags));
 597                         SET_CR_MOTION_METHOD_DETECTED(t, 0);
 598                         break;
 599                 }
 600         }
 601
 602         if (flags->do_update_layer)
 603         {
 604                 int layer = get_layer(t);
 605
 606                 if (SUSE_LAYER(&pstyle->flags))
 607                 {
 608                         /* use layer from style */
 609                         layer = SGET_LAYER(*pstyle);
 610                 }
 611
 612                 /* Set the layer, and modify the stack ring. */
 613                 new_layer(t, layer);
 614         }
 615
 616         return;
 617 }
 618
 619 /* ---------------------------- builtin commands --------------------------- */
 620
 621 /* takes only care of destroying windows that have to go away. */
 622 void destroy_scheduled_windows(void)
 623 {
 624         flist *t;
 625         Bool do_need_ungrab = False;
 626
 627         if (Scr.flags.is_executing_complex_function ||
 628             Scr.flags.is_executing_menu_function ||
 629             !Scr.flags.is_window_scheduled_for_destroy)
 630         {
 631                 return;
 632         }
 633         /* Grab the server during the style update! */
 634         if (GrabEm(CRS_WAIT, GRAB_BUSY))
 635         {
 636                 do_need_ungrab = True;
 637         }
 638         MyXGrabServer(dpy);
 639         Scr.flags.is_window_scheduled_for_destroy = 0;
 640         /* need to destroy one or more windows before looking at the window
 641          * list */
 642         for (t = Scr.FWScheduledForDestroy; t != NULL; t = t->next)
 643         {
 644                 destroy_window(t->object);
 645         }
 646         Scr.FWScheduledForDestroy = flist_free_list(Scr.FWScheduledForDestroy);
 647         MyXUngrabServer(dpy);
 648         if (do_need_ungrab)
 649         {
 650                 UngrabEm(GRAB_BUSY);
 651         }
 652
 653         return;
 654 }
 655
 656 /* similar to the flush_window_updates() function, but does only the updates
 657  * for a single window whose decor has been changed. */
 658 void apply_decor_change(FvwmWindow *fw)
 659 {
 660         window_style style;
 661         update_win flags;
 662
 663         lookup_style(fw, &style);
 664         memset(&flags, 0, sizeof(flags));
 665         flags.do_redecorate = True;
 666         flags.do_update_window_font_height = True;
 667         apply_window_updates(fw, &flags, &style, get_focus_window());
 668
 669         return;
 670 }
 671
 672 /* Check and apply new style to each window if the style has changed. */
 673 void flush_window_updates(void)
 674 {
 675         FvwmWindow *t;
 676         window_style style;
 677         FvwmWindow *focus_fw;
 678         Bool do_need_ungrab = False;
 679         update_win flags;
 680
 681         /* Grab the server during the style update! */
 682         if (GrabEm(CRS_WAIT, GRAB_BUSY))
 683         {
 684                 do_need_ungrab = True;
 685         }
 686         MyXGrabServer(dpy);
 687
 688         /* This is necessary in case the focus policy changes. With
 689          * ClickToFocus some buttons have to be grabbed/ungrabbed. */
 690         focus_fw = get_focus_window();
 691         DeleteFocus(False);
 692
 693         /* Apply the new default font and colours first */
 694         if (Scr.flags.has_default_color_changed ||
 695             Scr.flags.has_default_font_changed)
 696         {
 697                 ApplyDefaultFontAndColors();
 698         }
 699
 700         /* update styles for all windows */
 701         for (t = Scr.FvwmRoot.next; t != NULL; t = t->next)
 702         {
 703                 memset(&flags, 0, sizeof(update_win));
 704                 check_window_style_change(t, &flags, &style);
 705                 if (Scr.flags.has_xinerama_state_changed)
 706                 {
 707                         flags.do_update_icon_boxes = True;
 708                         flags.do_update_icon_placement = True;
 709                 }
 710                 if (Scr.flags.has_nr_buttons_changed)
 711                 {
 712                         flags.do_redecorate = True;
 713                 }
 714                 /* TODO: this is not optimised for minimal redrawing yet*/
 715                 if (t->decor->flags.has_changed)
 716                 {
 717                         flags.do_redecorate = True;
 718                         flags.do_update_window_font_height = True;
 719                 }
 720                 if (Scr.flags.has_default_font_changed && !HAS_ICON_FONT(t))
 721                 {
 722                         flags.do_update_icon_font = True;
 723                 }
 724                 if (Scr.flags.has_default_font_changed && !HAS_WINDOW_FONT(t))
 725                 {
 726                         flags.do_update_window_font = True;
 727                 }
 728                 if (t->decor->flags.has_title_height_changed)
 729                 {
 730                         flags.do_update_window_font_height = True;
 731                 }
 732                 if (Scr.flags.has_mouse_binding_changed)
 733                 {
 734                         flags.do_update_window_grabs = True;
 735                 }
 736                 /* now apply the changes */
 737                 apply_window_updates(t, &flags, &style, focus_fw);
 738         }
 739
 740         /* restore the focus; also handles the case that the previously focused
 741          * window is now NeverFocus */
 742         if (focus_fw)
 743         {
 744                 SetFocusWindow(focus_fw, False, FOCUS_SET_FORCE);
 745                 if (Scr.flags.has_mouse_binding_changed)
 746                 {
 747                         focus_grab_buttons(focus_fw);
 748                 }
 749         }
 750         else
 751         {
 752                 DeleteFocus(True);
 753         }
 754
 755         /* finally clean up the change flags */
 756         reset_style_changes();
 757         reset_decor_changes();
 758         Scr.flags.do_need_window_update = 0;
 759         Scr.flags.has_default_font_changed = 0;
 760         Scr.flags.has_default_color_changed = 0;
 761         Scr.flags.has_mouse_binding_changed = 0;
 762         Scr.flags.has_nr_buttons_changed = 0;
 763         Scr.flags.has_xinerama_state_changed = 0;
 764
 765         MyXUngrabServer(dpy);
 766         if (do_need_ungrab)
 767         {
 768                 UngrabEm(GRAB_BUSY);
 769         }
 770
 771         return;
 772 }
 773
 774 void CMD_UpdateStyles(F_CMD_ARGS)
 775 {
 776         if (Scr.flags.do_need_window_update)
 777         {
 778                 flush_window_updates();
 779         }
 780
 781         return;
 782 }