← Back to branch summary

~muktupavels/metacity/adwaita-icon-theme-lp-1414613

« back to all changes in this revision

Viewing changes to src/screen.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2005-12-13 23:03:47 UTC
  • mto: (2.2.1 sid) (1.4.2)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20051213230347-8dnaprp18n18dz1y
Tags: upstream-2.13.5
Import upstream version 2.13.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/screen.c
6
6
 * Some ICCCM manager selection code derived from fvwm2,
7
7
 * Copyright (C) 2001 Dominik Vogt, Matthias Clasen, and fvwm2 team
8
8
 * Copyright (C) 2003 Rob Adams
 
9
 * Copyright (C) 2004, 2005 Elijah Newren
9
10
 * 
10
11
 * This program is free software; you can redistribute it and/or
11
12
 * modify it under the terms of the GNU General Public License as
220
221
          while (i < n_infos)
221
222
            {
222
223
              screen->xinerama_infos[i].number = infos[i].screen_number;
223
 
              screen->xinerama_infos[i].x_origin = infos[i].x_org;
224
 
              screen->xinerama_infos[i].y_origin = infos[i].y_org;
225
 
              screen->xinerama_infos[i].width = infos[i].width;
226
 
              screen->xinerama_infos[i].height = infos[i].height;
 
224
              screen->xinerama_infos[i].rect.x = infos[i].x_org;
 
225
              screen->xinerama_infos[i].rect.y = infos[i].y_org;
 
226
              screen->xinerama_infos[i].rect.width = infos[i].width;
 
227
              screen->xinerama_infos[i].rect.height = infos[i].height;
227
228
 
228
229
              meta_topic (META_DEBUG_XINERAMA,
229
230
                          "Xinerama %d is %d,%d %d x %d\n",
230
231
                          screen->xinerama_infos[i].number,
231
 
                          screen->xinerama_infos[i].x_origin,
232
 
                          screen->xinerama_infos[i].y_origin,
233
 
                          screen->xinerama_infos[i].width,
234
 
                          screen->xinerama_infos[i].height);              
 
232
                          screen->xinerama_infos[i].rect.x,
 
233
                          screen->xinerama_infos[i].rect.y,
 
234
                          screen->xinerama_infos[i].rect.width,
 
235
                          screen->xinerama_infos[i].rect.height);
235
236
              
236
237
              ++i;
237
238
            }
281
282
          while (i < n_monitors)
282
283
            {
283
284
              screen->xinerama_infos[i].number = i;
284
 
              screen->xinerama_infos[i].x_origin = monitors[i].x;
285
 
              screen->xinerama_infos[i].y_origin = monitors[i].y;
286
 
              screen->xinerama_infos[i].width = monitors[i].width;
287
 
              screen->xinerama_infos[i].height = monitors[i].height;
 
285
              screen->xinerama_infos[i].rect.x = monitors[i].x;
 
286
              screen->xinerama_infos[i].rect.y = monitors[i].y;
 
287
              screen->xinerama_infos[i].rect.width = monitors[i].width;
 
288
              screen->xinerama_infos[i].rect.height = monitors[i].height;
288
289
 
289
290
              meta_topic (META_DEBUG_XINERAMA,
290
291
                          "Xinerama %d is %d,%d %d x %d\n",
291
292
                          screen->xinerama_infos[i].number,
292
 
                          screen->xinerama_infos[i].x_origin,
293
 
                          screen->xinerama_infos[i].y_origin,
294
 
                          screen->xinerama_infos[i].width,
295
 
                          screen->xinerama_infos[i].height);              
 
293
                          screen->xinerama_infos[i].rect.x,
 
294
                          screen->xinerama_infos[i].rect.y,
 
295
                          screen->xinerama_infos[i].rect.width,
 
296
                          screen->xinerama_infos[i].rect.height);              
296
297
              
297
298
              ++i;
298
299
            }
324
325
          screen->n_xinerama_infos = 2;
325
326
          
326
327
          screen->xinerama_infos[0].number = 0;
327
 
          screen->xinerama_infos[0].x_origin = 0;
328
 
          screen->xinerama_infos[0].y_origin = 0;
329
 
          screen->xinerama_infos[0].width = screen->width / 2;
330
 
          screen->xinerama_infos[0].height = screen->height;
 
328
          screen->xinerama_infos[0].rect = screen->rect;
 
329
          screen->xinerama_infos[0].rect.width = screen->rect.width / 2;
331
330
 
332
331
          screen->xinerama_infos[1].number = 1;
333
 
          screen->xinerama_infos[1].x_origin = screen->width / 2;
334
 
          screen->xinerama_infos[1].y_origin = 0;
335
 
          screen->xinerama_infos[1].width = screen->width / 2 + screen->width % 2;
336
 
          screen->xinerama_infos[1].height = screen->height;
 
332
          screen->xinerama_infos[1].rect = screen->rect;
 
333
          screen->xinerama_infos[1].rect.x = screen->rect.width / 2;
 
334
          screen->xinerama_infos[1].rect.width = screen->rect.width / 2;
337
335
        }
338
336
      else
339
337
        {
344
342
          screen->n_xinerama_infos = 1;
345
343
          
346
344
          screen->xinerama_infos[0].number = 0;
347
 
          screen->xinerama_infos[0].x_origin = 0;
348
 
          screen->xinerama_infos[0].y_origin = 0;
349
 
          screen->xinerama_infos[0].width = screen->width;
350
 
          screen->xinerama_infos[0].height = screen->height;
 
345
          screen->xinerama_infos[0].rect = screen->rect;
351
346
        }
352
347
    }
353
348
 
519
514
  screen->screen_name = get_screen_name (display, number);
520
515
  screen->xscreen = ScreenOfDisplay (xdisplay, number);
521
516
  screen->xroot = xroot;
522
 
  screen->width = WidthOfScreen (screen->xscreen);
523
 
  screen->height = HeightOfScreen (screen->xscreen);
 
517
  screen->rect.x = screen->rect.y = 0;
 
518
  screen->rect.width = WidthOfScreen (screen->xscreen);
 
519
  screen->rect.height = HeightOfScreen (screen->xscreen);
524
520
  screen->current_cursor = -1; /* invalid/unset */
525
521
  screen->default_xvisual = DefaultVisualOfScreen (screen->xscreen);
526
522
  screen->default_depth = DefaultDepthOfScreen (screen->xscreen);
1014
1010
  if (screen->closing > 0)
1015
1011
    return;
1016
1012
 
1017
 
  data[0] = screen->width;
1018
 
  data[1] = screen->height;
 
1013
  data[0] = screen->rect.width;
 
1014
  data[1] = screen->rect.height;
1019
1015
 
1020
1016
  meta_verbose ("Setting _NET_DESKTOP_GEOMETRY to %ld, %ld\n", data[0], data[1]);
1021
1017
 
1205
1201
      entries[i].title = window->title;
1206
1202
      entries[i].icon = window->icon;
1207
1203
      entries[i].blank = FALSE;
1208
 
      entries[i].minimized = !meta_window_showing_on_its_workspace (window);
 
1204
      entries[i].hidden = !meta_window_showing_on_its_workspace (window);
1209
1205
      entries[i].demands_attention = window->wm_state_demands_attention;
1210
1206
      
1211
1207
      if (!window->minimized || !meta_window_get_icon_geometry (window, &r))
1212
1208
        meta_window_get_outer_rect (window, &r);
1213
1209
      
1214
 
      entries[i].x = r.x;
1215
 
      entries[i].y = r.y;
1216
 
      entries[i].width = r.width;
1217
 
      entries[i].height = r.height;
 
1210
      entries[i].rect = r;
1218
1211
 
1219
1212
      /* Find inside of highlight rectangle to be used
1220
1213
       * when window is outlined for tabbing.
1228
1221
          int south = window->frame->rect.height - window->frame->child_y -
1229
1222
            window->rect.height;
1230
1223
          int east = window->frame->child_x;
1231
 
          entries[i].inner_x = east;
1232
 
          entries[i].inner_y = south;
1233
 
          entries[i].inner_width = window->rect.width;
1234
 
          entries[i].inner_height = window->frame->rect.height - south * 2;
 
1224
          entries[i].inner_rect.x = east;
 
1225
          entries[i].inner_rect.y = south;
 
1226
          entries[i].inner_rect.width = window->rect.width;
 
1227
          entries[i].inner_rect.height = window->frame->rect.height - south * 2;
1235
1228
        }
1236
1229
      else
1237
1230
        {
1238
1231
          /* Use an arbitrary border size */
1239
1232
#define OUTLINE_WIDTH 5
1240
 
          entries[i].inner_x = OUTLINE_WIDTH;
1241
 
          entries[i].inner_y = OUTLINE_WIDTH;
1242
 
          entries[i].inner_width = window->rect.width - OUTLINE_WIDTH * 2;
1243
 
          entries[i].inner_height = window->rect.height - OUTLINE_WIDTH * 2;
 
1233
          entries[i].inner_rect.x = OUTLINE_WIDTH;
 
1234
          entries[i].inner_rect.y = OUTLINE_WIDTH;
 
1235
          entries[i].inner_rect.width = window->rect.width - OUTLINE_WIDTH * 2;
 
1236
          entries[i].inner_rect.height = window->rect.height - OUTLINE_WIDTH * 2;
1244
1237
        }
1245
1238
      
1246
1239
      ++i;
1309
1302
          entries[i].icon = NULL;
1310
1303
          entries[i].blank = TRUE;
1311
1304
        }
1312
 
      entries[i].minimized = FALSE;
 
1305
      entries[i].hidden = FALSE;
1313
1306
      entries[i].demands_attention = FALSE;
1314
1307
 
1315
1308
      ++i;
1375
1368
  best_xinerama = 0;
1376
1369
  xinerama_score = 0;
1377
1370
 
1378
 
  i = 0;
1379
 
  while (i < screen->n_xinerama_infos)
 
1371
  for (i = 0; i < screen->n_xinerama_infos; i++)
1380
1372
    {
1381
 
      MetaRectangle dest, screen_info;
1382
 
      
1383
 
      screen_info.x = screen->xinerama_infos[i].x_origin;
1384
 
      screen_info.y = screen->xinerama_infos[i].y_origin;
1385
 
      screen_info.width = screen->xinerama_infos[i].width;
1386
 
      screen_info.height = screen->xinerama_infos[i].height;
1387
 
      
1388
 
      if (meta_rectangle_intersect (&screen_info, rect, &dest))
 
1373
      MetaRectangle dest;
 
1374
      if (meta_rectangle_intersect (&screen->xinerama_infos[i].rect,
 
1375
                                    rect,
 
1376
                                    &dest))
1389
1377
        {
1390
 
          if (dest.width * dest.height > xinerama_score)
 
1378
          int cur = meta_rectangle_area (&dest);
 
1379
          if (cur > xinerama_score)
1391
1380
            {
1392
 
              xinerama_score = dest.width * dest.height;
 
1381
              xinerama_score = cur;
1393
1382
              best_xinerama = i;
1394
1383
            }
1395
1384
        }
1396
 
      
1397
 
      ++i;
1398
1385
    }
1399
1386
 
1400
1387
  return &screen->xinerama_infos[best_xinerama];
1424
1411
    {
1425
1412
      current = screen->xinerama_infos + i;
1426
1413
 
1427
 
      if (((direction == META_SCREEN_RIGHT) && 
1428
 
           (current->x_origin == input->x_origin + input->width) &&
1429
 
           (current->y_origin >= input->y_origin) &&
1430
 
           (current->y_origin <= input->y_origin+input->height)) ||
1431
 
          ((direction == META_SCREEN_LEFT) && 
1432
 
           (input->x_origin == current->x_origin + current->width) &&
1433
 
           (current->y_origin >= input->y_origin) &&
1434
 
           (current->y_origin <= input->y_origin + input->height)) ||
1435
 
          ((direction == META_SCREEN_UP) && 
1436
 
           (input->y_origin == current->y_origin + current->height) &&
1437
 
           (current->x_origin >= input->x_origin) &&
1438
 
           (current->x_origin <= input->x_origin + input->width)) ||
1439
 
          ((direction == META_SCREEN_DOWN) && 
1440
 
           (current->y_origin == input->y_origin + input->height) &&
1441
 
           (current->x_origin >= input->x_origin) &&
1442
 
           (current->x_origin <= input->x_origin + input->width)))
 
1414
      if ((direction == META_SCREEN_RIGHT && 
 
1415
           current->rect.x == input->rect.x + input->rect.width &&
 
1416
           meta_rectangle_vert_overlap(&current->rect, &input->rect)) ||
 
1417
          (direction == META_SCREEN_LEFT && 
 
1418
           input->rect.x == current->rect.x + current->rect.width &&
 
1419
           meta_rectangle_vert_overlap(&current->rect, &input->rect)) ||
 
1420
          (direction == META_SCREEN_UP && 
 
1421
           input->rect.y == current->rect.y + current->rect.height &&
 
1422
           meta_rectangle_horiz_overlap(&current->rect, &input->rect)) ||
 
1423
          (direction == META_SCREEN_DOWN && 
 
1424
           current->rect.y == input->rect.y + input->rect.height &&
 
1425
           meta_rectangle_horiz_overlap(&current->rect, &input->rect)))
1443
1426
        {
1444
1427
          return current;
1445
1428
        }
1543
1526
  g_queue_free (xinerama_queue);
1544
1527
}
1545
1528
 
1546
 
gboolean
1547
 
meta_screen_rect_intersects_xinerama (MetaScreen    *screen,
1548
 
                                      MetaRectangle *rect,
1549
 
                                      int            which_xinerama)
1550
 
{
1551
 
  MetaRectangle dest, screen_rect;
1552
 
  
1553
 
  screen_rect.x = screen->xinerama_infos[which_xinerama].x_origin;
1554
 
  screen_rect.y = screen->xinerama_infos[which_xinerama].y_origin;
1555
 
  screen_rect.width = screen->xinerama_infos[which_xinerama].width;
1556
 
  screen_rect.height = screen->xinerama_infos[which_xinerama].height;
1557
 
  
1558
 
  if (meta_rectangle_intersect (&screen_rect, rect, &dest))
1559
 
    return TRUE;
1560
 
 
1561
 
  return FALSE;
1562
 
}
1563
 
 
1564
1529
const MetaXineramaScreenInfo*
1565
1530
meta_screen_get_current_xinerama (MetaScreen *screen)
1566
1531
{
1573
1538
  if (screen->display->xinerama_cache_invalidated)
1574
1539
    {
1575
1540
      Window root_return, child_return;
1576
 
      int root_x_return, root_y_return;
1577
1541
      int win_x_return, win_y_return;
1578
1542
      unsigned int mask_return;
1579
1543
      int i;
 
1544
      MetaRectangle pointer_position;
1580
1545
      
1581
1546
      screen->display->xinerama_cache_invalidated = FALSE;
1582
1547
      
 
1548
      pointer_position.width = pointer_position.height = 1;
1583
1549
      XQueryPointer (screen->display->xdisplay,
1584
1550
                     screen->xroot,
1585
1551
                     &root_return,
1586
1552
                     &child_return,
1587
 
                     &root_x_return,
1588
 
                     &root_y_return,
 
1553
                     &pointer_position.x,
 
1554
                     &pointer_position.y,
1589
1555
                     &win_x_return,
1590
1556
                     &win_y_return,
1591
1557
                     &mask_return);
1592
1558
 
1593
1559
      screen->last_xinerama_index = 0;
1594
 
      i = 0;
1595
 
      while (i < screen->n_xinerama_infos)
 
1560
      for (i = 0; i < screen->n_xinerama_infos; i++)
1596
1561
        {
1597
 
          if ((root_x_return >= screen->xinerama_infos[i].x_origin &&
1598
 
               root_x_return < (screen->xinerama_infos[i].x_origin + 
1599
 
                                screen->xinerama_infos[i].width) &&
1600
 
               root_y_return >= screen->xinerama_infos[i].y_origin &&
1601
 
               root_y_return < (screen->xinerama_infos[i].y_origin + 
1602
 
                                screen->xinerama_infos[i].height)))
1603
 
          {
1604
 
            screen->last_xinerama_index = i;
1605
 
            break;
1606
 
          }
1607
 
          
1608
 
          ++i;
 
1562
          if (meta_rectangle_contains_rect (&screen->xinerama_infos[i].rect,
 
1563
                                            &pointer_position))
 
1564
            {
 
1565
              screen->last_xinerama_index = i;
 
1566
              break;
 
1567
            }
1609
1568
        }
1610
1569
      
1611
1570
      meta_topic (META_DEBUG_XINERAMA,
2200
2159
                    int         width,
2201
2160
                    int         height)
2202
2161
{  
2203
 
  screen->width = width;
2204
 
  screen->height = height;
 
2162
  screen->rect.width = width;
 
2163
  screen->rect.height = height;
2205
2164
 
2206
2165
  reload_xinerama_infos (screen);
2207
2166
  set_desktop_geometry_hint (screen);