1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
// Copyright (c) 2009 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/cocoa/tab_contents_controller.h"
#import "chrome/app/chrome_dll_resource.h"
#import "chrome/browser/command_updater.h"
#import "chrome/browser/location_bar.h"
@interface TabContentsController(CommandUpdates)
- (void)enabledStateChangedForCommand:(NSInteger)command enabled:(BOOL)enabled;
@end
@interface TabContentsController(Private)
- (void)updateToolbarCommandStatus;
@end
// A C++ bridge class that handles listening for updates to commands and
// passing them back to the controller.
class TabContentsCommandObserver : public CommandUpdater::CommandObserver {
public:
TabContentsCommandObserver(TabContentsController* controller,
CommandUpdater* commands);
~TabContentsCommandObserver();
// Overridden from CommandUpdater::CommandObserver
void EnabledStateChangedForCommand(int command, bool enabled);
private:
TabContentsController* controller_; // weak, owns me
CommandUpdater* commands_; // weak
};
// TODO(pinkerton): implement these
class LocationBarBridge : public LocationBar {
public:
LocationBarBridge(TabContentsController* controller);
// Overridden from LocationBar
virtual void ShowFirstRunBubble() { NOTIMPLEMENTED(); }
virtual std::wstring GetInputString() const { NOTIMPLEMENTED(); return L""; }
virtual WindowOpenDisposition GetWindowOpenDisposition() const
{ NOTIMPLEMENTED(); return NEW_FOREGROUND_TAB; }
virtual PageTransition::Type GetPageTransition() const
{ NOTIMPLEMENTED(); return 0; }
virtual void AcceptInput() { NOTIMPLEMENTED(); }
virtual void FocusLocation() { NOTIMPLEMENTED(); }
virtual void FocusSearch() { NOTIMPLEMENTED(); }
virtual void SaveStateToContents(TabContents* contents) { NOTIMPLEMENTED(); }
private:
TabContentsController* controller_; // weak, owns me
};
@implementation TabContentsController
- (id)initWithNibName:(NSString*)name
bundle:(NSBundle*)bundle
contents:(TabContents*)contents
commands:(CommandUpdater*)commands {
if ((self = [super initWithNibName:name bundle:bundle])) {
commands_ = commands;
if (commands_)
observer_ = new TabContentsCommandObserver(self, commands);
locationBarBrige_ = new LocationBarBridge(self);
}
return self;
}
- (void)dealloc {
// make sure our contents have been removed from the window
[[self view] removeFromSuperview];
delete observer_;
delete locationBarBrige_;
[super dealloc];
}
- (void)awakeFromNib {
// Provide a starting point since we won't get notifications if the state
// doesn't change between tabs.
[self updateToolbarCommandStatus];
[locationBar_ setStringValue:@"http://dev.chromium.org"];
}
- (LocationBar*)locationBar {
return locationBarBrige_;
}
// Returns YES if the tab represented by this controller is the front-most.
- (BOOL)isCurrentTab {
// We're the current tab if we're in the view hierarchy, otherwise some other
// tab is.
return [[self view] superview] ? YES : NO;
}
// Called when the state for a command changes to |enabled|. Update the
// corresponding UI element.
- (void)enabledStateChangedForCommand:(NSInteger)command enabled:(BOOL)enabled {
// We don't need to update anything if we're not the frontmost tab.
// TODO(pinkerton): i'm worried that observer ordering could cause the
// notification to be sent before we've been put into the view, but we
// appear to be called in the right order so far.
if (![self isCurrentTab])
return;
NSButton* button = nil;
switch (command) {
case IDC_BACK:
button = backButton_;
break;
case IDC_FORWARD:
button = forwardButton_;
break;
case IDC_HOME:
// TODO(pinkerton): add home button
break;
case IDC_STAR:
button = starButton_;
break;
}
[button setEnabled:enabled];
}
- (IBAction)fullScreen:(id)sender {
if ([[self view] isInFullScreenMode]) {
[[self view] exitFullScreenModeWithOptions:nil];
} else {
[[self view] enterFullScreenMode:[NSScreen mainScreen] withOptions:nil];
}
}
// Set the enabled state of the buttons on the toolbar to match the state in
// the controller. We can't only rely on notifications to do this because the
// command model only assumes a single toolbar and won't send notifications if
// the state doesn't change.
- (void)updateToolbarCommandStatus {
[backButton_ setEnabled:commands_->IsCommandEnabled(IDC_BACK) ? YES : NO];
[forwardButton_
setEnabled:commands_->IsCommandEnabled(IDC_FORWARD) ? YES : NO];
[reloadStopButton_
setEnabled:commands_->IsCommandEnabled(IDC_RELOAD) ? YES : NO];
[starButton_ setEnabled:commands_->IsCommandEnabled(IDC_STAR) ? YES : NO];
}
- (void)willBecomeSelectedTab {
[self updateToolbarCommandStatus];
}
@end
//--------------------------------------------------------------------------
TabContentsCommandObserver::TabContentsCommandObserver(
TabContentsController* controller, CommandUpdater* commands)
: controller_(controller), commands_(commands) {
DCHECK(controller_ && commands);
// Register for notifications about state changes for the toolbar buttons
commands_->AddCommandObserver(IDC_BACK, this);
commands_->AddCommandObserver(IDC_FORWARD, this);
commands_->AddCommandObserver(IDC_RELOAD, this);
commands_->AddCommandObserver(IDC_HOME, this);
commands_->AddCommandObserver(IDC_STAR, this);
}
TabContentsCommandObserver::~TabContentsCommandObserver() {
// Unregister the notifications
commands_->RemoveCommandObserver(IDC_BACK, this);
commands_->RemoveCommandObserver(IDC_FORWARD, this);
commands_->RemoveCommandObserver(IDC_RELOAD, this);
commands_->RemoveCommandObserver(IDC_HOME, this);
commands_->RemoveCommandObserver(IDC_STAR, this);
}
void TabContentsCommandObserver::EnabledStateChangedForCommand(int command,
bool enabled) {
[controller_ enabledStateChangedForCommand:command
enabled:enabled ? YES : NO];
}
//--------------------------------------------------------------------------
LocationBarBridge::LocationBarBridge(TabContentsController* controller)
: controller_(controller) {
}
|
