Source/AIListWindowController.m

   1 /*
   2  * Adium is the legal property of its developers, whose names are listed in the copyright file included
   3  * with this source distribution.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU
   6  * General Public License as published by the Free Software Foundation; either version 2 of the License,
   7  * or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
  10  * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  11  * Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with this program; if not,
  14  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  15  */
  16
  17 #import "AIListWindowController.h"
  18
  19 #import "AISCLViewPlugin.h"
  20 #import <Adium/AIListOutlineView.h>
  21 #import <Adium/AIChatControllerProtocol.h>
  22 #import <Adium/AIAccountControllerProtocol.h>
  23 #import <Adium/AIInterfaceControllerProtocol.h>
  24 #import <Adium/AIPreferenceControllerProtocol.h>
  25 #import <Adium/AIDockControllerProtocol.h>
  26 #import <AIUtilities/AIWindowAdditions.h>
  27 #import <AIUtilities/AIFunctions.h>
  28 #import <AIUtilities/AIWindowControllerAdditions.h>
  29 #import <AIUtilities/AIApplicationAdditions.h>
  30 #import <AIListBookmark.h>
  31 #import <Adium/AIListContact.h>
  32 #import <Adium/AIListGroup.h>
  33 #import <Adium/AIListObject.h>
  34 #import <Adium/AIUserIcons.h>
  35 #import <AIUtilities/AIDockingWindow.h>
  36 #import <AIUtilities/AIEventAdditions.h>
  37
  38 #import <AIUtilities/AITigerCompatibility.h>
  39
  40 #define PREF_GROUP_CONTACT_LIST                                 @"Contact List"
  41
  42 #define SLIDE_ALLOWED_RECT_EDGE_MASK                    (AIMinXEdgeMask | AIMaxXEdgeMask)
  43 #define DOCK_HIDING_MOUSE_POLL_INTERVAL                 0.1
  44 #define WINDOW_ALIGNMENT_TOLERANCE                              2.0f
  45 #define MOUSE_EDGE_SLIDE_ON_DISTANCE                    1.1f
  46 #define WINDOW_SLIDING_MOUSE_DISTANCE_TOLERANCE 3.0f
  47
  48 #define SNAP_DISTANCE                                                   15.0
  49
  50 @interface AIListWindowController (PRIVATE)
  51 - (id)initWithContactList:(AIListObject<AIContainingObject> *)contactList;
  52 + (NSString *)nibName;
  53
  54 - (void)_configureAutoResizing;
  55 - (void)_configureToolbar;
  56 + (void)updateScreenSlideBoundaryRect:(id)sender;
  57 - (BOOL)shouldSlideWindowOffScreen_mousePositionStrategy;
  58 - (void)slideWindowIfNeeded:(id)sender;
  59 - (BOOL)shouldSlideWindowOnScreen_mousePositionStrategy;
  60 - (BOOL)shouldSlideWindowOnScreen_adiumActiveStrategy;
  61 - (BOOL)shouldSlideWindowOffScreen_adiumActiveStrategy;
  62 - (void)setSavedFrame:(NSRect)f;
  63 - (void)restoreSavedFrame;
  64
  65 - (void)delayWindowSlidingForInterval:(NSTimeInterval)inDelayTime;
  66 @end
  67
  68 @implementation AIListWindowController
  69
  70 + (void)initialize
  71 {
  72         if ([self isEqual:[AIListWindowController class]]) {
  73                 [[NSNotificationCenter defaultCenter] addObserver:self
  74                                                                                                  selector:@selector(updateScreenSlideBoundaryRect:)
  75                                                                                                          name:NSApplicationDidChangeScreenParametersNotification
  76                                                                                                    object:nil];
  77
  78                 [self updateScreenSlideBoundaryRect:nil];
  79         }
  80 }
  81
  82 //Return a new contact list window controller
  83 + (AIListWindowController *)listWindowController
  84 {
  85     return [[[self alloc] initWithContactList:nil] autorelease];
  86 }
  87
  88 + (AIListWindowController *)listWindowControllerForContactList:(AIListObject<AIContainingObject> *)contactList
  89 {
  90         return [[[self alloc] initWithContactList:contactList] autorelease];
  91 }
  92
  93 - (id)initWithContactList:(AIListObject<AIContainingObject> *)contactList
  94 {
  95         if ((self = [self initWithWindowNibName:[[self class] nibName]])) {
  96                 preventHiding = NO;
  97                 previousAlpha = 0;
  98                 [self setContactList:contactList];
  99         }
 100
 101         return self;
 102 }
 103
 104 - (AIListObject<AIContainingObject> *)contactList
 105 {
 106         return (contactListRoot ? contactListRoot : [contactListController contactList]);
 107 }
 108
 109 - (AIListController *) listController
 110 {
 111         return contactListController;
 112 }
 113
 114 - (AIListOutlineView *)contactListView
 115 {
 116         return contactListView;
 117 }
 118
 119 - (void)setContactList:(AIListObject<AIContainingObject> *)inContactList
 120 {
 121         if (inContactList != contactListRoot) {
 122                 [contactListRoot release];
 123                 contactListRoot = [inContactList retain];
 124         }
 125 }
 126
 127 //Our window nib name
 128 + (NSString *)nibName
 129 {
 130     return @"";
 131 }
 132
 133 - (Class)listControllerClass
 134 {
 135         return [AIListController class];
 136 }
 137
 138 - (void)dealloc
 139 {
 140         [[NSNotificationCenter defaultCenter] removeObserver:self];
 141
 142         [contactListController close];
 143         [windowLastScreen release];
 144
 145         [super dealloc];
 146 }
 147
 148 //
 149 - (NSString *)adiumFrameAutosaveName
 150 {
 151         AILogWithSignature(@"My autosave name is %@",[NSString stringWithFormat:@"Contact List:%@", [[self contactList] contentsBasedIdentifier]]);
 152         return [NSString stringWithFormat:@"Contact List:%@", [[self contactList] contentsBasedIdentifier]];
 153 }
 154
 155 //Setup the window after it has loaded
 156 - (void)windowDidLoad
 157 {
 158         contactListController = [[[self listControllerClass] alloc] initWithContactList:[self contactList]
 159                                                                                                                                           inOutlineView:contactListView
 160                                                                                                                                            inScrollView:scrollView_contactList
 161                                                                                                                                                    delegate:self];
 162
 163         //super's windowDidLoad will restore our location, which is based upon the contactListRoot
 164         [super windowDidLoad];
 165
 166     //Exclude this window from the window menu (since we add it manually)
 167     [[self window] setExcludedFromWindowsMenu:YES];
 168         [[self window] useOptimizedDrawing:YES];
 169
 170         minWindowSize = [[self window] minSize];
 171         [contactListController setMinWindowSize:minWindowSize];
 172
 173         [[self window] setTitle:AILocalizedString(@"Contacts","Contact List window title")];
 174
 175     //Watch for resolution and screen configuration changes
 176     [[NSNotificationCenter defaultCenter] addObserver:self
 177                                                                                          selector:@selector(screenParametersChanged:)
 178                                                                                                  name:NSApplicationDidChangeScreenParametersNotification
 179                                                                                            object:nil];
 180
 181         //Show the contact list initially even if it is at a screen edge and supposed to slide out of view
 182         [self delayWindowSlidingForInterval:5];
 183
 184         id<AIPreferenceController> preferenceController = [adium preferenceController];
 185     //Observe preference changes
 186         [preferenceController registerPreferenceObserver:self forGroup:PREF_GROUP_CONTACT_LIST];
 187         [preferenceController registerPreferenceObserver:self forGroup:PREF_GROUP_APPEARANCE];
 188
 189         //Preference code below assumes layout is done before theme.
 190         [preferenceController registerPreferenceObserver:self forGroup:PREF_GROUP_LIST_LAYOUT];
 191         [preferenceController registerPreferenceObserver:self forGroup:PREF_GROUP_LIST_THEME];
 192
 193         [[NSNotificationCenter defaultCenter] addObserver:self
 194                                                                                          selector:@selector(applicationDidUnhide:)
 195                                                                                                  name:NSApplicationDidUnhideNotification
 196                                                                                            object:nil];
 197
 198         //Save our frame immediately for sliding purposes
 199         [self setSavedFrame:[[self window] frame]];
 200 }
 201
 202 //Close the contact list window
 203 - (void)windowWillClose:(NSNotification *)notification
 204 {
 205         if ([self windowSlidOffScreenEdgeMask] != AINoEdges) {
 206                 //Hide the window while it's still off-screen
 207                 [[self window] setAlphaValue:0.0];
 208
 209                 //Then move it back on screen so that we'll save the proper position in -[AIWindowController windowWillClose:]
 210                 [self slideWindowOnScreenWithAnimation:NO];
 211         }
 212
 213         [super windowWillClose:notification];
 214
 215         //Invalidate the dock-like hiding timer
 216         [slideWindowIfNeededTimer invalidate]; [slideWindowIfNeededTimer release];
 217
 218     //Stop observing
 219         [[adium preferenceController] unregisterPreferenceObserver:self];
 220     [[NSNotificationCenter defaultCenter] removeObserver:self];
 221         [[[NSWorkspace sharedWorkspace] notificationCenter] removeObserver:self];
 222
 223     //Tell the interface to unload our window
 224     NSNotificationCenter *adiumNotificationCenter = [adium notificationCenter];
 225     [adiumNotificationCenter postNotificationName:Interface_ContactListDidResignMain object:self];
 226         [adiumNotificationCenter postNotificationName:Interface_ContactListDidClose object:self];
 227 }
 228
 229 int levelForAIWindowLevel(AIWindowLevel windowLevel)
 230 {
 231         int                             level;
 232
 233         switch (windowLevel) {
 234                 case AINormalWindowLevel: level = NSNormalWindowLevel; break;
 235                 case AIFloatingWindowLevel: level = NSFloatingWindowLevel; break;
 236                 case AIDesktopWindowLevel: level = kCGBackstopMenuLevel; break;
 237                 default: level = NSNormalWindowLevel; break;
 238         }
 239
 240         return level;
 241 }
 242
 243 - (void)setWindowLevel:(int)level
 244 {
 245         [[self window] setLevel:level];
 246         if (![NSApp isOnLeopardOrBetter]) {
 247                 [[self window] setIgnoresExpose:(level == kCGBackstopMenuLevel)]; //Ignore expose while on the desktop
 248         }
 249 }
 250
 251 //Preferences have changed
 252 - (void)preferencesChangedForGroup:(NSString *)group
 253                                                            key:(NSString *)key
 254                                                         object:(AIListObject *)object
 255                                         preferenceDict:(NSDictionary *)prefDict
 256                                                  firstTime:(BOOL)firstTime
 257 {
 258         BOOL shouldRevealWindowAndDelaySliding = NO;
 259
 260     if ([group isEqualToString:PREF_GROUP_CONTACT_LIST]) {
 261                 AIWindowLevel   windowLevel = [[prefDict objectForKey:KEY_CL_WINDOW_LEVEL] intValue];
 262
 263                 [self setWindowLevel:levelForAIWindowLevel(windowLevel)];
 264
 265                 listHasShadow = [[prefDict objectForKey:KEY_CL_WINDOW_HAS_SHADOW] boolValue];
 266                 [[self window] setHasShadow:listHasShadow];
 267
 268                 windowHidingStyle = [[prefDict objectForKey:KEY_CL_WINDOW_HIDING_STYLE] intValue];
 269                 slideOnlyInBackground = [[prefDict objectForKey:KEY_CL_SLIDE_ONLY_IN_BACKGROUND] boolValue];
 270
 271                 [[self window] setHidesOnDeactivate:(windowHidingStyle == AIContactListWindowHidingStyleBackground)];
 272
 273                 if ([[NSApplication sharedApplication] isOnLeopardOrBetter]) {
 274                         if (windowHidingStyle == AIContactListWindowHidingStyleSliding || [[prefDict objectForKey:KEY_CL_ALL_SPACES] boolValue])
 275                                 [[self window] setCollectionBehavior:NSWindowCollectionBehaviorCanJoinAllSpaces];
 276                         else
 277                                 [[self window] setCollectionBehavior:NSWindowCollectionBehaviorDefault];
 278                 }
 279
 280                 if (windowHidingStyle == AIContactListWindowHidingStyleSliding) {
 281                         if (!slideWindowIfNeededTimer) {
 282                                 slideWindowIfNeededTimer = [[NSTimer scheduledTimerWithTimeInterval:DOCK_HIDING_MOUSE_POLL_INTERVAL
 283                                                                                                                                                          target:self
 284                                                                                                                                                    selector:@selector(slideWindowIfNeeded:)
 285                                                                                                                                                    userInfo:nil
 286                                                                                                                                                         repeats:YES] retain];
 287                         }
 288
 289                 } else if (slideWindowIfNeededTimer) {
 290             [slideWindowIfNeededTimer invalidate];
 291                         [slideWindowIfNeededTimer release]; slideWindowIfNeededTimer = nil;
 292                 }
 293
 294                 [contactListController setShowTooltips:[[prefDict objectForKey:KEY_CL_SHOW_TOOLTIPS] boolValue]];
 295                 [contactListController setShowTooltipsInBackground:[[prefDict objectForKey:KEY_CL_SHOW_TOOLTIPS_IN_BACKGROUND] boolValue]];
 296     }
 297
 298         //Auto-Resizing
 299         if ([group isEqualToString:PREF_GROUP_APPEARANCE]) {
 300                 int                             windowStyle = [[prefDict objectForKey:KEY_LIST_LAYOUT_WINDOW_STYLE] intValue];
 301                 BOOL                    autoResizeVertically = [[prefDict objectForKey:KEY_LIST_LAYOUT_VERTICAL_AUTOSIZE] boolValue];
 302                 BOOL                    autoResizeHorizontally = [[prefDict objectForKey:KEY_LIST_LAYOUT_HORIZONTAL_AUTOSIZE] boolValue];
 303                 int                             forcedWindowWidth, maxWindowWidth;
 304
 305                 if (autoResizeHorizontally) {
 306                         //If autosizing, KEY_LIST_LAYOUT_HORIZONTAL_WIDTH determines the maximum width; no forced width.
 307                         maxWindowWidth = [[prefDict objectForKey:KEY_LIST_LAYOUT_HORIZONTAL_WIDTH] intValue];
 308                         forcedWindowWidth = -1;
 309                 } else {
 310                         if (windowStyle == AIContactListWindowStyleStandard/* || windowStyle == AIContactListWindowStyleBorderless*/) {
 311                                 //In the non-transparent non-autosizing modes, KEY_LIST_LAYOUT_HORIZONTAL_WIDTH has no meaning
 312                                 maxWindowWidth = 10000;
 313                                 forcedWindowWidth = -1;
 314                         } else {
 315                                 //In the transparent non-autosizing modes, KEY_LIST_LAYOUT_HORIZONTAL_WIDTH determines the width of the window
 316                                 forcedWindowWidth = [[prefDict objectForKey:KEY_LIST_LAYOUT_HORIZONTAL_WIDTH] intValue];
 317                                 maxWindowWidth = forcedWindowWidth;
 318                         }
 319                 }
 320
 321                 //Show the resize indicator if either or both of the autoresizing options is NO
 322                 [[self window] setShowsResizeIndicator:!(autoResizeVertically && autoResizeHorizontally)];
 323
 324                 /*
 325                  Reset the minimum and maximum sizes in case [self contactListDesiredSizeChanged]; doesn't cause a sizing change
 326                  (and therefore the min and max sizes aren't set there).
 327                  */
 328                 NSSize  thisMinimumSize = minWindowSize;
 329                 NSSize  thisMaximumSize = NSMakeSize(maxWindowWidth, 10000);
 330                 NSRect  currentFrame = [[self window] frame];
 331
 332                 if (forcedWindowWidth != -1) {
 333                         /*
 334                          If we have a forced width but we are doing no autoresizing, set our frame now so we don't have to be doing checks every time
 335                          contactListDesiredSizeChanged is called.
 336                          */
 337                         if (!(autoResizeVertically || autoResizeHorizontally)) {
 338                                 thisMinimumSize.width = forcedWindowWidth;
 339                                 [[self window] setFrame:NSMakeRect(currentFrame.origin.x,currentFrame.origin.y,forcedWindowWidth,currentFrame.size.height)
 340                                                                 display:YES
 341                                                                 animate:NO];
 342                         }
 343                 }
 344
 345                 //If vertically resizing, make the minimum and maximum heights the current height
 346                 if (autoResizeVertically) {
 347                         thisMinimumSize.height = currentFrame.size.height;
 348                         thisMaximumSize.height = currentFrame.size.height;
 349                 }
 350
 351                 //If horizontally resizing, make the minimum and maximum widths the current width
 352                 if (autoResizeHorizontally) {
 353                         thisMinimumSize.width = currentFrame.size.width;
 354                         thisMaximumSize.width = currentFrame.size.width;
 355                 }
 356
 357                 /* For a standard window, inform the contact list that, if asked, it wants to be 175 pixels or more.
 358                  * A maximum width less than this can make the list autosize smaller, but if it has its druthers it'll be a sane
 359                  * size.
 360                  */
 361                 [contactListView setMinimumDesiredWidth:((windowStyle == AIContactListWindowStyleStandard) ? 175 : 0)];
 362
 363                 [[self window] setMinSize:thisMinimumSize];
 364                 [[self window] setMaxSize:thisMaximumSize];
 365
 366                 [contactListController setAutoresizeHorizontally:autoResizeHorizontally];
 367                 [contactListController setAutoresizeVertically:autoResizeVertically];
 368                 [contactListController setForcedWindowWidth:forcedWindowWidth];
 369                 [contactListController setMaxWindowWidth:maxWindowWidth];
 370
 371                 [contactListController contactListDesiredSizeChanged];
 372
 373                 if (!firstTime) {
 374                         shouldRevealWindowAndDelaySliding = YES;
 375                 }
 376         }
 377
 378         //Window opacity
 379         if ([group isEqualToString:PREF_GROUP_APPEARANCE]) {
 380                 float opacity = [[prefDict objectForKey:KEY_LIST_LAYOUT_WINDOW_OPACITY] floatValue];
 381                 [contactListController setBackgroundOpacity:opacity];
 382
 383                 if (!firstTime) {
 384                         shouldRevealWindowAndDelaySliding = YES;
 385                 }
 386         }
 387
 388         //Layout and Theme ------------
 389         BOOL groupLayout = ([group isEqualToString:PREF_GROUP_LIST_LAYOUT]);
 390         BOOL groupTheme = ([group isEqualToString:PREF_GROUP_LIST_THEME]);
 391     if (groupLayout || (groupTheme && !firstTime)) { /* We don't want to execute this code twice when initializing */
 392                 NSDictionary    *layoutDict = [[adium preferenceController] preferencesForGroup:PREF_GROUP_LIST_LAYOUT];
 393                 NSDictionary    *themeDict = [[adium preferenceController] preferencesForGroup:PREF_GROUP_LIST_THEME];
 394
 395                 //Layout only
 396                 if (groupLayout) {
 397                         int iconSize = [[layoutDict objectForKey:KEY_LIST_LAYOUT_USER_ICON_SIZE] intValue];
 398                         [AIUserIcons setListUserIconSize:NSMakeSize(iconSize,iconSize)];
 399                 }
 400
 401                 //Theme only
 402                 if (groupTheme || firstTime) {
 403                         NSString                *imagePath = [themeDict objectForKey:KEY_LIST_THEME_BACKGROUND_IMAGE_PATH];
 404
 405                         //Background Image
 406                         if (imagePath && [imagePath length] && [[themeDict objectForKey:KEY_LIST_THEME_BACKGROUND_IMAGE_ENABLED] boolValue]) {
 407                                 [contactListView setBackgroundImage:[[[NSImage alloc] initWithContentsOfFile:imagePath] autorelease]];
 408                         } else {
 409                                 [contactListView setBackgroundImage:nil];
 410                         }
 411                 }
 412
 413                 //Both layout and theme
 414                 [contactListController updateLayoutFromPrefDict:layoutDict andThemeFromPrefDict:themeDict];
 415
 416                 if (!firstTime) {
 417                         shouldRevealWindowAndDelaySliding = YES;
 418                 }
 419         }
 420
 421         if (shouldRevealWindowAndDelaySliding) {
 422                 [self delayWindowSlidingForInterval:2];
 423                 [self slideWindowOnScreenWithAnimation:NO];
 424
 425         } else {
 426                 //Do a slide immediately if needed (to display as per our new preferneces)
 427                 [self slideWindowIfNeeded:nil];
 428
 429         }
 430 }
 431
 432 - (IBAction)performDefaultActionOnSelectedObject:(AIListObject *)selectedObject sender:(NSOutlineView *)sender
 433 {
 434     if ([selectedObject isKindOfClass:[AIListGroup class]]) {
 435         //Expand or collapse the group
 436         if ([sender isItemExpanded:selectedObject]) {
 437             [sender collapseItem:selectedObject];
 438         } else {
 439             [sender expandItem:selectedObject];
 440         }
 441
 442         } else if ([selectedObject isMemberOfClass:[AIListBookmark class]]) {
 443                 //Hide any tooltip the contactListController is currently showing
 444                 [contactListController hideTooltip];
 445
 446                 [(AIListBookmark *)selectedObject openChat];
 447
 448         } else if ([selectedObject isKindOfClass:[AIListContact class]]) {
 449                 //Hide any tooltip the contactListController is currently showing
 450                 [contactListController hideTooltip];
 451
 452                 //Open a new message with the contact
 453                 [[adium interfaceController] setActiveChat:[[adium chatController] openChatWithContact:(AIListContact *)selectedObject
 454                                                                                                                                                         onPreferredAccount:YES]];
 455     }
 456
 457
 458 }
 459
 460 - (BOOL) canCustomizeToolbar
 461 {
 462         return NO;
 463 }
 464
 465 //Interface Container --------------------------------------------------------------------------------------------------
 466 #pragma mark Interface Container
 467 //Close this container
 468 - (void)close:(id)sender
 469 {
 470     //In response to windowShouldClose, the interface controller releases us.  At that point, no one would be retaining
 471         //this instance of AIContactListWindowController, and we would be deallocated.  The call to [self window] will
 472         //crash if we are deallocated.  A dirty, but functional fix is to temporarily retain ourself here.
 473     [self retain];
 474
 475     if ([self windowShouldClose:nil]) {
 476         [[self window] close];
 477     }
 478
 479     [self release];
 480 }
 481
 482 - (void)makeActive:(id)sender
 483 {
 484         [[self window] makeKeyAndOrderFront:self];
 485 }
 486
 487
 488 //Contact list brought to front
 489 - (void)windowDidBecomeKey:(NSNotification *)notification
 490 {
 491     [[adium notificationCenter] postNotificationName:Interface_ContactListDidBecomeMain object:self];
 492 }
 493
 494 //Contact list sent back
 495 - (void)windowDidResignKey:(NSNotification *)notification
 496 {
 497     [[adium notificationCenter] postNotificationName:Interface_ContactListDidResignMain object:self];
 498 }
 499
 500 //
 501 - (void)showWindowInFrontIfAllowed:(BOOL)inFront
 502 {
 503         //Always show for three seconds at least if we're told to show
 504         [self delayWindowSlidingForInterval:3];
 505
 506         //Call super to actually do the showing
 507         [super showWindowInFrontIfAllowed:inFront];
 508
 509         NSWindow        *window = [self window];
 510
 511         if ([self windowSlidOffScreenEdgeMask] != AINoEdges) {
 512                 [self slideWindowOnScreenWithAnimation:NO];
 513         }
 514
 515         windowSlidOffScreenEdgeMask = AINoEdges;
 516
 517         currentScreen = [window screen];
 518         currentScreenFrame = [currentScreen frame];
 519
 520         if ([[NSScreen screens] count] &&
 521                 (currentScreen == [[NSScreen screens] objectAtIndex:0])) {
 522                 currentScreenFrame.size.height -= [NSMenuView menuBarHeight];
 523         }
 524
 525         //Ensure the window is displaying at the proper level and exposé setting
 526         AIWindowLevel   windowLevel = [[[adium preferenceController] preferenceForKey:KEY_CL_WINDOW_LEVEL
 527                                                                                                                                                         group:PREF_GROUP_CONTACT_LIST] intValue];
 528         [self setWindowLevel:levelForAIWindowLevel(windowLevel)];
 529 }
 530
 531 - (void)setSavedFrame:(NSRect)frame
 532 {
 533         oldFrame = frame;
 534         [[self window] saveFrameUsingName:@"SavedContactListFrame"];
 535 }
 536
 537 - (void)restoreSavedFrame
 538 {
 539         NSWindow *myWindow = [self window];
 540         [myWindow setFrameUsingName:@"SavedContactListFrame" force:YES];
 541         oldFrame = [myWindow frame];
 542 }
 543
 544 // Auto-resizing support ------------------------------------------------------------------------------------------------
 545 #pragma mark Auto-resizing support
 546
 547 - (void)screenParametersChanged:(NSNotification *)notification
 548 {
 549         NSWindow        *window = [self window];
 550
 551         NSScreen        *windowScreen = [window screen];
 552         if (!windowScreen) {
 553                 if ([[NSScreen screens] containsObject:windowLastScreen]) {
 554                         windowScreen = windowLastScreen;
 555                 } else {
 556                         [windowLastScreen release]; windowLastScreen = nil;
 557                         windowScreen = [NSScreen mainScreen];
 558                 }
 559         }
 560
 561         NSRect newScreenFrame = [windowScreen frame];
 562
 563         if ([[NSScreen screens] count] &&
 564                 (windowScreen == [[NSScreen screens] objectAtIndex:0])) {
 565                         newScreenFrame.size.height -= [NSMenuView menuBarHeight];
 566         }
 567
 568         NSRect listFrame = [window frame];
 569
 570         oldFrame.origin.x *= ((newScreenFrame.size.width - listFrame.size.width) / ((currentScreenFrame.size.width - listFrame.size.width) + 0.00001));
 571         oldFrame.origin.y *= ((newScreenFrame.size.height - listFrame.size.height) / ((currentScreenFrame.size.height - listFrame.size.height) + 0.00001));
 572
 573         [self delayWindowSlidingForInterval:2];
 574         [self slideWindowOnScreenWithAnimation:NO];
 575
 576         [contactListController contactListDesiredSizeChanged];
 577
 578         currentScreen = [window screen];
 579         currentScreenFrame = newScreenFrame;
 580         [self setSavedFrame:[window frame]];
 581 }
 582
 583 // Printing
 584 #pragma mark Printing
 585 - (void)adiumPrint:(id)sender
 586 {
 587         [contactListView print:sender];
 588 }
 589
 590 // Dock-like hiding -----------------------------------------------------------------------------------------------------
 591 #pragma mark Dock-like hiding
 592
 593 /* screenSlideBoundaryRect is the rect that the contact list slides in and out of for dock-like hiding
 594  * screenSlideBoundaryRect = (menubarScreen frame without menubar) union (union of frames of all other screens)
 595  */
 596 static NSRect screenSlideBoundaryRect = { {0.0f, 0.0f}, {0.0f, 0.0f} };
 597 + (void)updateScreenSlideBoundaryRect:(id)sender
 598 {
 599         NSArray *screens = [NSScreen screens];
 600         int numScreens = [screens count];
 601
 602         if (numScreens > 0) {
 603                 //The menubar screen is a special case - the menubar is not a part of the rect we're interested in
 604                 NSScreen *menubarScreen = [screens objectAtIndex:0];
 605                 screenSlideBoundaryRect = [menubarScreen frame];
 606                 screenSlideBoundaryRect.size.height = NSMaxY([menubarScreen visibleFrame]) - NSMinY([menubarScreen frame]);
 607                 for (int i = 1; i < numScreens; i++) {
 608                         screenSlideBoundaryRect = NSUnionRect(screenSlideBoundaryRect, [[screens objectAtIndex:i] frame]);
 609                 }
 610         }
 611 }
 612
 613 /*!
 614  * @brief Adium unhid
 615  *
 616  * If the contact list is open but not visible when we unhide, we should always display it; it should not, however, steal focus.
 617  */
 618 - (void)applicationDidUnhide:(NSNotification *)notification
 619 {
 620         if (![[self window] isVisible]) {
 621                 [self showWindowInFrontIfAllowed:NO];
 622         }
 623 }
 624
 625 - (BOOL)windowShouldHideOnDeactivate
 626 {
 627         return (windowHidingStyle == AIContactListWindowHidingStyleBackground);
 628 }
 629
 630 - (void)slideWindowIfNeeded:(id)sender
 631 {
 632         if ([self shouldSlideWindowOnScreen]) {
 633                 //If we're hiding the window (generally) but now sliding it on screen, make sure it's on top
 634                 if (windowHidingStyle == AIContactListWindowHidingStyleSliding) {
 635                         [self setWindowLevel:NSFloatingWindowLevel];
 636                         overrodeWindowLevel = YES;
 637                 }
 638
 639                 [self slideWindowOnScreen];
 640
 641         } else if ([self shouldSlideWindowOffScreen]) {
 642                 AIRectEdgeMask adjacentEdges = [self slidableEdgesAdjacentToWindow];
 643
 644         if (adjacentEdges & (AIMinXEdgeMask | AIMaxXEdgeMask)) {
 645             [self slideWindowOffScreenEdges:(adjacentEdges & (AIMinXEdgeMask | AIMaxXEdgeMask))];
 646                 } else {
 647             [self slideWindowOffScreenEdges:adjacentEdges];
 648                 }
 649
 650                 /* If we're hiding the window (generally) but now sliding it off screen, set it to kCGBackstopMenuLevel and don't
 651                  * let it participate in expose.
 652                  */
 653                 if (overrodeWindowLevel &&
 654                         windowHidingStyle == AIContactListWindowHidingStyleSliding) {
 655                         [self setWindowLevel:kCGBackstopMenuLevel];
 656                         overrodeWindowLevel = YES;
 657                 }
 658
 659         } else if (overrodeWindowLevel &&
 660                            ([self slidableEdgesAdjacentToWindow] == AINoEdges) &&
 661                            ([self windowSlidOffScreenEdgeMask] == AINoEdges)) {
 662                 /* If the window level was overridden at some point and now we:
 663                  *   1. Are on screen AND
 664                  *   2. No longer have any edges eligible for sliding
 665                  * we should restore our window level.
 666                  */
 667                 AIWindowLevel   windowLevel = [[[adium preferenceController] preferenceForKey:KEY_CL_WINDOW_LEVEL
 668                                                                                                                                                                 group:PREF_GROUP_CONTACT_LIST] intValue];
 669                 [self setWindowLevel:levelForAIWindowLevel(windowLevel)];
 670                 overrodeWindowLevel = NO;
 671         }
 672 }
 673
 674 - (BOOL)shouldSlideWindowOnScreen
 675 {
 676         BOOL shouldSlide = NO;
 677
 678         if (([self windowSlidOffScreenEdgeMask] != AINoEdges) &&
 679                 ![NSApp isHidden]) {
 680                 if (slideOnlyInBackground && [NSApp isActive]) {
 681                         //We only slide while in the background, and the app is not in the background. Slide on screen.
 682                         shouldSlide = YES;
 683
 684                 } else if (windowHidingStyle == AIContactListWindowHidingStyleSliding) {
 685                         //Slide on screen if the mouse position indicates we should
 686                         shouldSlide = [self shouldSlideWindowOnScreen_mousePositionStrategy];
 687                 } else {
 688                         //It's slid off-screen... and it's not supposed to be sliding at all.  Slide back on screen!
 689                         shouldSlide = YES;
 690                 }
 691         }
 692
 693         return shouldSlide;
 694 }
 695
 696 - (BOOL)shouldSlideWindowOffScreen
 697 {
 698         BOOL shouldSlide = NO;
 699
 700         if ((windowHidingStyle == AIContactListWindowHidingStyleSliding) &&
 701                 !preventHiding &&
 702                 ([self windowSlidOffScreenEdgeMask] == AINoEdges) &&
 703                 (!(slideOnlyInBackground && [NSApp isActive]))) {
 704                 shouldSlide = [self shouldSlideWindowOffScreen_mousePositionStrategy];
 705         }
 706
 707         return shouldSlide;
 708 }
 709
 710 // slide off screen if the window is aligned to a screen edge and the mouse is not in the strip of screen
 711 // you'd get by translating the window along the screen edge.  This is the dock's behavior.
 712 - (BOOL)shouldSlideWindowOffScreen_mousePositionStrategy
 713 {
 714         BOOL shouldSlideOffScreen = NO;
 715
 716         NSWindow *window = [self window];
 717         NSRect windowFrame = [window frame];
 718         NSPoint mouseLocation = [NSEvent mouseLocation];
 719
 720         AIRectEdgeMask slidableEdgesAdjacentToWindow = [self slidableEdgesAdjacentToWindow];
 721         NSRectEdge screenEdge;
 722         for (screenEdge = 0; screenEdge < 4; screenEdge++) {
 723                 if (slidableEdgesAdjacentToWindow & (1 << screenEdge)) {
 724                         float distanceMouseOutsideWindow = AISignedExteriorDistanceRect_edge_toPoint_(windowFrame, AIOppositeRectEdge_(screenEdge), mouseLocation);
 725                         if (distanceMouseOutsideWindow > WINDOW_SLIDING_MOUSE_DISTANCE_TOLERANCE)
 726                                 shouldSlideOffScreen = YES;
 727                 }
 728         }
 729
 730         /* Don't allow the window to slide off if the user is dragging
 731          * This method is hacky and does not completely work.  is there a way to detect if the mouse is down?
 732          */
 733         NSEventType currentEventType = [[NSApp currentEvent] type];
 734         if (currentEventType == NSLeftMouseDragged ||
 735                 currentEventType == NSRightMouseDragged ||
 736                 currentEventType == NSOtherMouseDragged ||
 737                 currentEventType == NSPeriodic) {
 738                 shouldSlideOffScreen = NO;
 739         }
 740
 741         return shouldSlideOffScreen;
 742 }
 743
 744 // note: may be inaccurate when mouse is up against an edge
 745 - (NSScreen *)screenForPoint:(NSPoint)point
 746 {
 747         NSScreen *pointScreen = nil;
 748
 749         NSEnumerator *screenEnumerator = [[NSScreen screens] objectEnumerator];
 750         NSScreen *screen;
 751         while ((screen = [screenEnumerator nextObject]) != nil) {
 752                 if (NSPointInRect(point, NSInsetRect([screen frame], -1, -1))) {
 753                         pointScreen = screen;
 754                         break;
 755                 }
 756         }
 757
 758         return pointScreen;
 759 }
 760
 761 - (NSRect)squareRectWithCenter:(NSPoint)point sideLength:(float)sideLength
 762 {
 763         return NSMakeRect(point.x - sideLength*0.5f, point.y - sideLength*0.5f, sideLength, sideLength);
 764 }
 765
 766 - (BOOL)pointIsInScreenCorner:(NSPoint)point
 767 {
 768         BOOL inCorner = NO;
 769         NSScreen *menubarScreen = [[NSScreen screens] objectAtIndex:0];
 770         float menubarHeight = NSMaxY([menubarScreen frame]) - NSMaxY([menubarScreen visibleFrame]); // breaks if the dock is at the top of the screen (i.e. if the user is insane)
 771
 772         NSRect screenFrame = [[self screenForPoint:point] frame];
 773         NSPoint lowerLeft  = screenFrame.origin;
 774         NSPoint upperRight = NSMakePoint(NSMaxX(screenFrame), NSMaxY(screenFrame));
 775         NSPoint lowerRight = NSMakePoint(upperRight.x, lowerLeft.y);
 776         NSPoint upperLeft  = NSMakePoint(lowerLeft.x, upperRight.y);
 777
 778         float sideLength = menubarHeight * 2.0f;
 779         inCorner = (NSPointInRect(point, [self squareRectWithCenter:lowerLeft sideLength:sideLength])
 780                                 || NSPointInRect(point, [self squareRectWithCenter:lowerRight sideLength:sideLength])
 781                                 || NSPointInRect(point, [self squareRectWithCenter:upperLeft sideLength:sideLength])
 782                                 || NSPointInRect(point, [self squareRectWithCenter:upperRight sideLength:sideLength]));
 783
 784         return inCorner;
 785 }
 786
 787 // YES if the mouse is against all edges of the screen where we previously slid the window and not in a corner.
 788 // This means that this method will never return YES of the cl is slid into a corner.
 789 - (BOOL)shouldSlideWindowOnScreen_mousePositionStrategy
 790 {
 791         BOOL mouseNearSlideOffEdges = ([self windowSlidOffScreenEdgeMask] != AINoEdges);
 792
 793         NSPoint mouseLocation = [NSEvent mouseLocation];
 794
 795         NSRectEdge screenEdge;
 796         for (screenEdge = 0; screenEdge < 4; screenEdge++) {
 797                 if (windowSlidOffScreenEdgeMask & (1 << screenEdge)) {
 798                         float mouseOutsideSlideBoundaryRectDistance = AISignedExteriorDistanceRect_edge_toPoint_(screenSlideBoundaryRect,
 799                                                                                                                                                                                                          screenEdge,
 800                                                                                                                                                                                                          mouseLocation);
 801                         if(mouseOutsideSlideBoundaryRectDistance < -MOUSE_EDGE_SLIDE_ON_DISTANCE) {
 802                                 mouseNearSlideOffEdges = NO;
 803                         }
 804                 }
 805         }
 806
 807         return mouseNearSlideOffEdges && ![self pointIsInScreenCorner:mouseLocation];
 808 }
 809
 810 #pragma mark Dock-like hiding
 811
 812 - (NSScreen *)windowLastScreen
 813 {
 814         return windowLastScreen;
 815 }
 816
 817 - (BOOL)animationShouldStart:(NSAnimation *)animation
 818 {
 819         //Whenever an animation starts, we should be using the normal shadow setting
 820         [[self window] setHasShadow:listHasShadow];
 821
 822         //Don't let docking interfere with the animation
 823         if ([[self window] respondsToSelector:@selector(setDockingEnabled:)])
 824                 [(id)[self window] setDockingEnabled:NO];
 825
 826         if (windowSlidOffScreenEdgeMask == AINoEdges) {
 827                 [[self window] setAlphaValue:previousAlpha];
 828         }
 829
 830         return YES;
 831 }
 832
 833 - (void)animationDidEnd:(NSAnimation*)animation
 834 {
 835         //Restore docking behavior
 836         if ([[self window] respondsToSelector:@selector(setDockingEnabled:)])
 837                 [(id)[self window] setDockingEnabled:YES];
 838
 839         if (windowSlidOffScreenEdgeMask == AINoEdges) {
 840                 /* When the window is offscreen, there are no constraints on its size, for example it will grow downwards as much as
 841                  * it needs to to accomodate new rows.  Now that it's onscreen, there are constraints.
 842                  */
 843                 [contactListController contactListDesiredSizeChanged];
 844
 845         } else {
 846                 //Offscreen windows should be told not to cast a shadow
 847                 [[self window] setHasShadow:NO];
 848
 849                 previousAlpha = [[self window] alphaValue];
 850                 [[self window] setAlphaValue:0.0];
 851         }
 852
 853         [windowAnimation release]; windowAnimation = nil;
 854 }
 855
 856 - (BOOL)keepListOnScreenWhenSliding
 857 {
 858         return NO;
 859 }
 860
 861 /*!
 862  * @brief Slide the window to a given point
 863  *
 864  * windowSlidOffScreenEdgeMask must already be set to the resulting offscreen mask (or 0 if the window is sliding on screen)
 865  *
 866  * A standard window (titlebar window) will crash if told to setFrame completely offscreen. Also, using our own movement we can more precisely
 867  * control the movement speed and acceleration.
 868  */
 869 - (void)slideWindowToPoint:(NSPoint)targetPoint
 870 {
 871         NSWindow                                *myWindow = [self window];
 872         NSScreen                                *windowScreen;
 873
 874         windowScreen = [myWindow screen];
 875         if (!windowScreen) windowScreen = [self windowLastScreen];
 876         if (!windowScreen) windowScreen = [NSScreen mainScreen];
 877
 878         NSRect  frame = [myWindow frame];
 879         float yOff = (targetPoint.y + NSHeight(frame)) - NSMaxY([windowScreen frame]);
 880         if (windowScreen == [[NSScreen screens] objectAtIndex:0]) yOff -= [NSMenuView menuBarHeight];
 881         if (yOff > 0) targetPoint.y -= yOff;
 882
 883         frame.origin = targetPoint;
 884
 885         if ((windowSlidOffScreenEdgeMask != AINoEdges) &&
 886                 [self keepListOnScreenWhenSliding]) {
 887                 switch (windowSlidOffScreenEdgeMask) {
 888                         case AIMinXEdgeMask:
 889                                 frame.origin.x += 1;
 890                                 break;
 891                         case AIMaxXEdgeMask:
 892                                 frame.origin.x -= 1;
 893                                 break;
 894                         case AIMaxYEdgeMask:
 895                                 frame.origin.y -= 1;
 896                                 break;
 897                         case AIMinYEdgeMask:
 898                                 frame.origin.y += 1;
 899                                 break;
 900                         case AINoEdges:
 901                                 //We'll never get here
 902                                 break;
 903                 }
 904         }
 905
 906         if (windowAnimation) {
 907                 [windowAnimation stopAnimation];
 908                 [windowAnimation release];
 909         }
 910
 911         windowAnimation = [[NSViewAnimation alloc] initWithViewAnimations:
 912                 [NSArray arrayWithObject:
 913                         [NSDictionary dictionaryWithObjectsAndKeys:
 914                                 myWindow, NSViewAnimationTargetKey,
 915                                 [NSValue valueWithRect:frame], NSViewAnimationEndFrameKey,
 916                                 nil]]];
 917         [windowAnimation setFrameRate:0.0];
 918         [windowAnimation setDuration:0.25];
 919         [windowAnimation setDelegate:self];
 920         [windowAnimation setAnimationBlockingMode:NSAnimationNonblocking];
 921         [windowAnimation startAnimation];
 922 }
 923
 924 - (void)moveWindowToPoint:(NSPoint)inOrigin
 925 {
 926         [[self window] setFrameOrigin:inOrigin];
 927
 928         if (windowSlidOffScreenEdgeMask == AINoEdges) {
 929                 /* When the window is offscreen, there are no constraints on its size, for example it will grow downwards as much as
 930                 * it needs to to accomodate new rows.  Now that it's onscreen, there are constraints.
 931                 */
 932                 [contactListController contactListDesiredSizeChanged];
 933                 [[self window] setAlphaValue:previousAlpha];
 934         }
 935 }
 936
 937 /*!
 938  * @brief Find the mask specifying what edges are potentially slidable for our window
 939  *
 940  * @result AIRectEdgeMask, which is 0 if no edges are slidable
 941  */
 942 - (AIRectEdgeMask)slidableEdgesAdjacentToWindow
 943 {
 944         AIRectEdgeMask slidableEdges = 0;
 945
 946         NSWindow *window = [self window];
 947         NSRect windowFrame = [window frame];
 948
 949         NSRectEdge edge;
 950         for (edge = 0; edge < 4; edge++) {
 951                 if ((SLIDE_ALLOWED_RECT_EDGE_MASK & (1 << edge)) &&
 952                         (AIRectIsAligned_edge_toRect_edge_tolerance_(windowFrame,
 953                                                                                                                  edge,
 954                                                                                                                  screenSlideBoundaryRect,
 955                                                                                                                  edge,
 956                                                                                                                  WINDOW_ALIGNMENT_TOLERANCE))) {
 957                         slidableEdges |= (1 << edge);
 958                 }
 959         }
 960
 961         return slidableEdges;
 962 }
 963
 964 - (void)slideWindowOffScreenEdges:(AIRectEdgeMask)rectEdgeMask
 965 {
 966         NSWindow        *window;
 967         NSRect          newWindowFrame;
 968         NSRectEdge      edge;
 969
 970         if (rectEdgeMask == AINoEdges)
 971                 return;
 972
 973         window = [self window];
 974         newWindowFrame = [window frame];
 975
 976         [self setSavedFrame:newWindowFrame];
 977
 978         [windowLastScreen release];
 979         windowLastScreen = [[window screen] retain];
 980
 981         for (edge = 0; edge < 4; edge++) {
 982                 if (rectEdgeMask & (1 << edge)) {
 983                         newWindowFrame = AIRectByAligningRect_edge_toRect_edge_(newWindowFrame,
 984                                                                                                                                         AIOppositeRectEdge_(edge),
 985                                                                                                                                         screenSlideBoundaryRect,
 986                                                                                                                                         edge);
 987                 }
 988         }
 989
 990         windowSlidOffScreenEdgeMask |= rectEdgeMask;
 991
 992         [self slideWindowToPoint:newWindowFrame.origin];
 993 }
 994
 995 - (void)slideWindowOnScreenWithAnimation:(BOOL)animate
 996 {
 997         if ([self windowSlidOffScreenEdgeMask] != AINoEdges) {
 998                 NSWindow        *window = [self window];
 999                 NSRect          windowFrame = [window frame];
1000
1001                 if (!NSEqualRects(windowFrame, oldFrame)) {
1002                         //Restore shadow and frame if we're appearing from having slid off-screen
1003                         [window setHasShadow:[[[adium preferenceController] preferenceForKey:KEY_CL_WINDOW_HAS_SHADOW
1004                                                                                                                                                    group:PREF_GROUP_CONTACT_LIST] boolValue]];
1005                         [window orderFront:nil];
1006
1007                         windowSlidOffScreenEdgeMask = AINoEdges;
1008
1009                         if (animate) {
1010                                 [self slideWindowToPoint:oldFrame.origin];
1011                         } else {
1012                                 [self moveWindowToPoint:oldFrame.origin];
1013                         }
1014
1015                         [windowLastScreen release];     windowLastScreen = nil;
1016                 }
1017         }
1018 }
1019
1020 - (void)slideWindowOnScreen
1021 {
1022         [self slideWindowOnScreenWithAnimation:YES];
1023 }
1024
1025 - (void)setPreventHiding:(BOOL)newPreventHiding {
1026         preventHiding = newPreventHiding;
1027 }
1028
1029 - (void)endWindowSlidingDelay
1030 {
1031         [self setPreventHiding:NO];
1032 }
1033
1034 - (void)delayWindowSlidingForInterval:(NSTimeInterval)inDelayTime
1035 {
1036         [self setPreventHiding:YES];
1037
1038         [NSObject cancelPreviousPerformRequestsWithTarget:self
1039                                                                                          selector:@selector(endWindowSlidingDelay)
1040                                                                                            object:nil];
1041         [self performSelector:@selector(endWindowSlidingDelay)
1042                            withObject:nil
1043                            afterDelay:inDelayTime];
1044 }
1045
1046 - (AIRectEdgeMask)windowSlidOffScreenEdgeMask
1047 {
1048         return windowSlidOffScreenEdgeMask;
1049 }
1050
1051 // Snap Groups Together------------------------------------------------------------------------------------------------
1052 #pragma mark Snap Groups Together
1053
1054 /*!
1055  * @brief If window did move and is not docked then snap it to other windows
1056  */
1057 - (void)windowDidMove:(NSNotification *)notification
1058 {
1059         BOOL suppressSnapping = [NSEvent shiftKey];
1060
1061         attachToBottom = nil;
1062
1063         if (windowSlidOffScreenEdgeMask == AINoEdges && !suppressSnapping)
1064                 [self snapToOtherWindows];
1065 }
1066
1067 /*!
1068  * @brief Captures mouse up event to check that if the window snapped underneath
1069  * another window they are merged together
1070  */
1071 - (void)mouseUp:(NSEvent *)event {
1072         if (attachToBottom) {
1073                 AIListGroup *from = (AIListGroup *)[self contactList];
1074                 AIListGroup *to = (AIListGroup *)[attachToBottom contactList];
1075
1076                 [from moveAllGroupsFrom:from to:to];
1077
1078                 [[adium notificationCenter] postNotificationName:DetachedContactListIsEmpty
1079                                                                                                   object:from
1080                                                                                                 userInfo:nil];
1081                 [[adium notificationCenter] postNotificationName:@"Contact_ListChanged"
1082                                                                                                   object:to
1083                                                                                                 userInfo:nil];
1084         }
1085 }
1086
1087 /*!
1088  * @brief Snaps window to windows next to it
1089  */
1090 - (void)snapToOtherWindows
1091 {
1092         NSWindow *myWindow = [self window];
1093         NSArray *windows = [[NSApplication sharedApplication] windows];
1094         NSEnumerator *enumerator = [windows objectEnumerator];
1095
1096         NSWindow *window;
1097
1098         NSRect currentFrame = [myWindow frame];
1099         NSPoint suggested = currentFrame.origin;
1100
1101         // Check to snap to each guide
1102         while ((window = [enumerator nextObject])) {
1103                 // No snapping to itself and it must be within a snapping distance to other windows
1104                 if ((window != myWindow) &&
1105                         [window delegate] && [window isVisible] &&
1106                         [[window delegate] conformsToProtocol:@protocol(AIInterfaceContainer)]) {
1107                         /* Note: [window delegate] may be invalid if the window is in the middle of closing.
1108                          * Checking if it's visible should hopefully cover that case.
1109                          */
1110                         suggested = [self snapTo:window with:currentFrame saveTo:suggested];
1111                 }
1112         }
1113
1114         [[self window] setFrameOrigin:suggested];
1115 }
1116
1117
1118 /*!
1119  * @brief Check that window is inside snappable region of other window
1120  */
1121 static BOOL isInRangeOfRect(NSRect sourceRect, NSRect targetRect)
1122 {
1123         return NSIntersectsRect(NSInsetRect(sourceRect, -SNAP_DISTANCE, -SNAP_DISTANCE), targetRect);
1124 }
1125
1126 /*!
1127  * @brief Check if points are close enough to be snapped together
1128  */
1129 static BOOL canSnap(float a, float b)
1130 {
1131         return (abs(a - b) <= SNAP_DISTANCE);
1132 }
1133
1134 - (NSPoint)snapTo:(NSWindow*)neighborWindow with:(NSRect)currentRect saveTo:(NSPoint)location{
1135         NSRect neighbor = [neighborWindow frame];
1136         NSPoint spacing = [self windowSpacing];
1137         unsigned overlap = 0;
1138         unsigned bottom = 0;
1139
1140         if (!NSEqualRects(neighbor,currentRect) && isInRangeOfRect(currentRect, neighbor)) {
1141                 // X Snapping
1142                 if (canSnap(NSMaxX(currentRect), NSMinX(neighbor))) {
1143                         location.x = NSMinX(neighbor) - NSWidth(currentRect) - spacing.x;
1144                 } else if (canSnap(NSMinX(currentRect), NSMaxX(neighbor))) {
1145                         location.x = NSMaxX(neighbor) + spacing.x;
1146                 } else if (canSnap(NSMinX(currentRect), NSMinX(neighbor))) {
1147                         location.x = NSMinX(neighbor);
1148                         overlap++;
1149                         bottom++;
1150                 }
1151
1152                 // Y Snapping
1153                 if (canSnap(NSMaxY(neighbor), NSMaxY(currentRect))) {
1154                         location.y = NSMaxY(neighbor) - NSHeight(currentRect);
1155                         overlap++;
1156                 } else if (canSnap(NSMinY(neighbor), NSMaxY(currentRect))) {
1157                         location.y = NSMinY(neighbor) - NSHeight(currentRect) - spacing.y;
1158                         bottom++;
1159                 } else if (canSnap(NSMaxY(neighbor), NSMinY(currentRect))) {
1160                         location.y = NSMaxY(neighbor) + spacing.y;
1161                 } else if (canSnap(NSMinY(neighbor), NSMinY(currentRect))) {
1162                         location.y = NSMinY(neighbor);
1163                         overlap++;
1164                 }
1165
1166         }
1167
1168         // If we snapped on top of neighbor
1169         if (overlap == 2)
1170                 return currentRect.origin;
1171
1172         // Save window that we could possible attach to
1173         if (bottom == 2)
1174                 attachToBottom = [neighborWindow delegate];
1175
1176         return location;
1177 }
1178
1179
1180 /*!
1181  * @brief Gets space that windows should be apart by based on current window style
1182  */
1183 - (NSPoint)windowSpacing {
1184         AIContactListWindowStyle style = [[[adium preferenceController] preferenceForKey:KEY_LIST_LAYOUT_WINDOW_STYLE
1185                                                                                                                   group:PREF_GROUP_APPEARANCE] intValue];
1186         int space = [[[adium preferenceController] preferenceForKey:@"Group Top Spacing"
1187                                                                                                                   group:@"List Layout"] intValue];
1188
1189         switch (style) {
1190                 case AIContactListWindowStyleStandard:
1191                 case AIContactListWindowStyleBorderless:
1192                         return NSMakePoint(0,0);
1193                 case AIContactListWindowStyleGroupBubbles:
1194                 case AIContactListWindowStyleContactBubbles:
1195                 case AIContactListWindowStyleContactBubbles_Fitted:
1196                         return NSMakePoint(space,space-WINDOW_ALIGNMENT_TOLERANCE);
1197         }
1198         return NSMakePoint(0,0);
1199 }
1200
1201 @end